var PERSEUS_PREFIX = "assets/perseus/";
/******/ (function(modules) { // webpackBootstrap
/******/ 	// install a JSONP callback for chunk loading
/******/ 	var parentJsonpFunction = window["webpackJsonp"];
/******/ 	window["webpackJsonp"] = function webpackJsonpCallback(chunkIds, moreModules) {
/******/ 		// add "moreModules" to the modules object,
/******/ 		// then flag all "chunkIds" as loaded and fire callback
/******/ 		var moduleId, chunkId, i = 0, callbacks = [];
/******/ 		for(;i < chunkIds.length; i++) {
/******/ 			chunkId = chunkIds[i];
/******/ 			if(installedChunks[chunkId])
/******/ 				callbacks.push.apply(callbacks, installedChunks[chunkId]);
/******/ 			installedChunks[chunkId] = 0;
/******/ 		}
/******/ 		for(moduleId in moreModules) {
/******/ 			modules[moduleId] = moreModules[moduleId];
/******/ 		}
/******/ 		if(parentJsonpFunction) parentJsonpFunction(chunkIds, moreModules);
/******/ 		while(callbacks.length)
/******/ 			callbacks.shift().call(null, __webpack_require__);
/******/
/******/ 	};
/******/
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// object to store loaded and loading chunks
/******/ 	// "0" means "already loaded"
/******/ 	// Array means "loading", array contains callbacks
/******/ 	var installedChunks = {
/******/ 		2:0
/******/ 	};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;
/******/
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/ 	// This file contains only the entry chunk.
/******/ 	// The chunk loading function for additional chunks
/******/ 	__webpack_require__.e = function requireEnsure(chunkId, callback) {
/******/ 		// "0" is the signal for "already loaded"
/******/ 		if(installedChunks[chunkId] === 0)
/******/ 			return callback.call(null, __webpack_require__);
/******/
/******/ 		// an array means "currently loading".
/******/ 		if(installedChunks[chunkId] !== undefined) {
/******/ 			installedChunks[chunkId].push(callback);
/******/ 		} else {
/******/ 			// start chunk loading
/******/ 			installedChunks[chunkId] = [callback];
/******/ 			var head = document.getElementsByTagName('head')[0];
/******/ 			var script = document.createElement('script');
/******/ 			script.type = 'text/javascript';
/******/ 			script.charset = 'utf-8';
/******/ 			script.async = true;
/******/ 			script.src = PERSEUS_PREFIX + __webpack_require__.p + "" + chunkId + "." + ({"1":"extra-widgets"}[chunkId]||chunkId) + ".js";
/******/ 			head.appendChild(script);
/******/ 		}
/******/ 	};
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "build/";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Loads the Perseus preview frame
	 *
	 * This is loaded inside the iframe, where it sets up the PreviewFrame component
	 * that handles all communication between the iframe and its parent.
	 * NOTE(amy): The KA CMS preview relies on frame-exercise.jsx in webapp's
	 * perseus-preview-package (which largely duplicates this logic)
	 */
	
	__webpack_require__(1);
	
	// We only apply the stub implementation of window.Khan when it is not detected.
	// When the stub implementation is not used, mathJaxLoaded is defined on
	// window.Khan so we wait for mathJaxLoaded to complete before initializing
	// Perseus
	if (!window.Khan) {
	    window.Khan = {
	        Util: KhanUtil,
	        error: function error() {},
	        query: { debug: "" },
	        imageBase: "/images/"
	    };
	}
	
	var Perseus = window.Perseus = __webpack_require__(9);
	var ReactDOM = window.ReactDOM = React.__internalReactDOM;
	
	var PreviewFrame = __webpack_require__(10);
	var constants = __webpack_require__(11);
	
	// const afterMathJaxLoad = () => {
	//     Perseus.init({skipMathJax: false, loadExtraWidgets: true})
	//         .then(function() {
	//             const isMobile =
	//                 window.frameElement.getAttribute("data-mobile") === "true";
	
	//             const styles = {};
	//             if (
	//                 window.frameElement.getAttribute("data-lint-gutter") === "true"
	//             ) {
	//                 // When we're being used in "edit mode", we need to draw our own
	//                 // border and allocate space on the right to display lint
	//                 // indicators in. IframeContentRenderer tells us to do this by
	//                 // setting the data-lint-gutter attribute. If that attribute is
	//                 // not set we don't need to allocate extra space or draw a
	//                 // border. The DeviceFramer has already done it for us.
	//                 styles.marginRight = constants.lintGutterWidth;
	//                 styles.borderWidth = constants.perseusFrameBorderWidth;
	//                 styles.borderColor = "black";
	//                 styles.borderStyle = "solid";
	//             }
	
	//             ReactDOM.render(
	//                 <div id="measured" style={styles}>
	//                     <PreviewFrame isMobile={isMobile} />
	//                 </div>,
	//                 document.getElementById("content-container")
	//             );
	//         })
	//         .then(
	//             function() {},
	//             function(err) {
	//                 console.error(err); // @Nolint
	//             }
	//         );
	// };
	
	// if (window.Khan.mathJaxLoaded) {
	//     window.Khan.mathJaxLoaded.then(afterMathJaxLoad);
	// } else {
	//     afterMathJaxLoad();
	// }

/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Sets up the basic environment for running Perseus in.
	 */
	
	window.icu = {
	    getDecimalFormatSymbols: function getDecimalFormatSymbols() {
	        return {
	            decimal_separator: ".",
	            grouping_separator: ",",
	            minus: "-"
	        };
	    }
	};
	
	window.KhanUtil = {
	    debugLog: function debugLog() {},
	    localeToFixed: function localeToFixed(num, precision) {
	        return num.toFixed(precision);
	    }
	};
	
	window.Exercises = {
	    localMode: true,
	
	    useKatex: true,
	    khanExercisesUrlBase: "../",
	
	    getCurrentFramework: function getCurrentFramework() {
	        return "khan-exercises";
	    },
	    PerseusBridge: {
	        cleanupProblem: function cleanupProblem() {
	            return false;
	        }
	    }
	};

/***/ },
/* 2 */,
/* 3 */,
/* 4 */,
/* 5 */,
/* 6 */,
/* 7 */,
/* 8 */,
/* 9 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Main entry point
	 */
	var version = __webpack_require__(50);
	
	var Widgets = __webpack_require__(31);
	var basicWidgets = __webpack_require__(32);
	// const basicWidgets = require("./all-widgets.js");
	Widgets.registerMany(basicWidgets);
	
	module.exports = {
	    apiVersion: version.apiVersion,
	    itemDataVersion: version.itemDataVersion,
	    init: __webpack_require__(33),
	    ArticleRenderer: __webpack_require__(34),
	    ItemRenderer: __webpack_require__(13),
	    ServerItemRenderer: __webpack_require__(35),
	    HintsRenderer: __webpack_require__(36),
	    Renderer: __webpack_require__(37),
	    MultiItems: __webpack_require__(30)
	};

/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/**
	  * Demonstrates the rendered result of a Perseus question within an iframe.
	  *
	  * This mounts an ItemRenderer, HintRenderer, or ArticleRenderer(s)
	  * (depending on the content given) and applies mobile styling if necessary.
	  * NOTE(amy): The KA CMS preview relies on preview-frame.jsx in webapp's
	  * perseus-preview-package (which largely duplicates this logic)
	  */
	
	var React = __webpack_require__(43);
	
	var ItemRenderer = __webpack_require__(13);
	var HintRenderer = __webpack_require__(38);
	var ArticleRenderer = __webpack_require__(34);
	var TouchEmulator = __webpack_require__(42);
	
	var PreviewFrame = React.createClass({
	    displayName: "PreviewFrame",
	
	    propTypes: {
	        isMobile: React.PropTypes.bool.isRequired
	    },
	
	    getInitialState: function getInitialState() {
	        return {};
	    },
	
	    componentDidMount: function componentDidMount() {
	        var _this = this;
	
	        window.addEventListener("message", function (event) {
	            var data = window.parent.iframeDataStore[event.data];
	
	            if (data) {
	                _this.setState(data);
	            }
	        });
	
	        window.parent.postMessage(window.frameElement.getAttribute("data-id"), "*");
	
	        this._updateParentWithHeight();
	
	        if (window.MutationObserver) {
	            // To know when to update the parent with the new iframe content
	            // height, we listen to DOM mutations inside the iframe and
	            // update the parent with the latest height every time a
	            // mutation is detected.
	            this._observer = new MutationObserver(function () {
	                _this._updateParentWithHeight();
	            });
	
	            this._observer.observe(document.getElementById("measured"), {
	                childList: true,
	                subtree: true,
	                attributes: true
	            });
	        }
	
	        // In addition to mutation observers, we also periodically check the
	        // height to capture the result of animations.
	        setInterval(function () {
	            _this._updateParentWithHeight();
	        }, 500);
	
	        if (this.props.isMobile) {
	            TouchEmulator();
	        }
	
	        // article-all means that we are rendering a full preview of an article
	        if (this.state.type === "article-all") {
	            document.body.style.overflow = "scroll";
	        } else {
	            document.body.style.overflow = "hidden";
	        }
	    },
	
	    componentDidUpdate: function componentDidUpdate() {
	        if (this.state.type === "article-all") {
	            document.body.style.overflow = "scroll";
	        } else {
	            document.body.style.overflow = "hidden";
	        }
	    },
	    componentWillUnmount: function componentWillUnmount() {
	        if (this._observer) {
	            this._observer.disconnect();
	        }
	    },
	
	
	    _updateParentWithHeight: function _updateParentWithHeight() {
	        var lowest = 0;
	        ["#content-container", ".preview-measure"].forEach(function (selector) {
	            Array.from(document.querySelectorAll(selector)).forEach(function (element) {
	                lowest = Math.max(lowest, element.getBoundingClientRect().bottom);
	            });
	        });
	
	        var bottomMargin = 30;
	
	        window.parent.postMessage({
	            id: window.frameElement.getAttribute("data-id"),
	            height: lowest + bottomMargin
	        }, "*");
	    },
	
	    render: function render() {
	        var _this2 = this;
	
	        if (this.state.data) {
	            var makeUpdatedData = function makeUpdatedData(data) {
	                return _extends({}, data, {
	                    workAreaSelector: "#workarea",
	                    hintsAreaSelector: "#hintsarea",
	                    apiOptions: _extends({}, data.apiOptions, {
	                        isMobile: _this2.props.isMobile
	                    })
	                });
	            };
	
	            var isExercise = this.state.type === "question" || this.state.type === "hint";
	
	            var perseusClass = "framework-perseus fonts-loaded " + (isExercise ? "bibliotron-exercise " : "bibliotron-article ") + (this.props.isMobile ? "perseus-mobile" : "");
	
	            var linterContext = this.state.data.linterContext;
	
	            if (this.state.type === "question") {
	                return React.createElement(
	                    "div",
	                    {
	                        className: perseusClass,
	                        style: this.props.isMobile ? {} : { margin: "30px 0" },
	                        ref: "container"
	                    },
	                    React.createElement(ItemRenderer, _extends({}, makeUpdatedData(this.state.data), {
	                        linterContext: linterContext
	                    })),
	                    React.createElement("div", { id: "workarea", style: { marginLeft: 0 } }),
	                    React.createElement("div", { id: "hintsarea" })
	                );
	            } else if (this.state.type === "hint") {
	                return React.createElement(
	                    "div",
	                    {
	                        className: perseusClass,
	                        style: this.props.isMobile ? {} : { margin: "30px 0" },
	                        ref: "container"
	                    },
	                    React.createElement(HintRenderer, _extends({}, makeUpdatedData(this.state.data), {
	                        linterContext: linterContext
	                    }))
	                );
	            } else if (this.state.type === "article") {
	                return React.createElement(
	                    "div",
	                    {
	                        className: perseusClass,
	                        style: this.props.isMobile ? {} : { margin: "30px 0" }
	                    },
	                    React.createElement(ArticleRenderer, _extends({}, makeUpdatedData(this.state.data), {
	                        linterContext: linterContext
	                    }))
	                );
	            } else if (this.state.type === "article-all") {
	                return React.createElement(
	                    "div",
	                    {
	                        className: perseusClass,
	                        style: this.props.isMobile ? {} : { margin: "30px 0" }
	                    },
	                    this.state.data.map(function (data, i) {
	                        return React.createElement(ArticleRenderer, _extends({
	                            key: i
	                        }, makeUpdatedData(data), {
	                            linterContext: linterContext
	                        }));
	                    })
	                );
	            } else {
	                return React.createElement("div", null);
	            }
	        } else {
	            return React.createElement("div", null);
	        }
	    }
	});
	
	module.exports = PreviewFrame;

/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

	var devices = {
	    PHONE: "phone",
	    TABLET: "tablet",
	    DESKTOP: "desktop"
	};
	
	module.exports = {
	    devices: devices,
	    // How many pixels do we reserve on the right-hand side of a preview
	    // for displaying lint indicators? This space needs to be reserved
	    // in DeviceFramer, but it is actually allocated in PerseusFrame
	    lintGutterWidth: 36,
	    // How wide a border does PerseusFrame draw? We need to allocate enough
	    // space for it in DeviceFramer.
	    perseusFrameBorderWidth: 1
	};

/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable brace-style */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	/**
	 * [Most of] the Perseus client API.
	 *
	 * If making a change to this file, or otherwise to the perseus
	 * API, you should increment:
	 *  * the perseus api major version if it is a breaking change
	 *  * the perseus api minor version if it is an additive-only change
	 *  * nothing if it is purely a bug fix.
	 *
	 * Callbacks passed to Renderer/ItemRenderer:
	 *  * onInputError:
	 *    Called when there is an error grading a widget
	 *  * onFocusChange: (newFocusPath, oldFocusPath, keypadDOMNode)
	 *    Called when the user focus changes. The first two parameters are `path`
	 *    arrays uniquely identifying the respect inputs. The third parameter,
	 *    `keypadDOMNode`, is the DOM node of the custom keypad, or `null` if the
	 *    keypad is disabled, which can be used by clients to accommodate for the
	 *    appearance of the keypad on the screen.
	 *    When focus changes to or from nothing being selected, `path` will be null.
	 *  * interactionCallback: Called when the user interacts with a widget.
	 *  * answerableCallback: Called with the current `answerability` of the
	 *    problem, e.g. whether all required fields have input.
	 *  * getAnotherHint: If provided, a button is rendered at the bottom of the
	 *    hints (only when at least one hint has been shown, and not all hints
	 *    have been shown) allowing the user to take another hint. This function
	 *    is then called when the user clicks the button.
	 *
	 * Stable CSS ClassNames:
	 * These are css class names that will continue to preserve their
	 * semantic meaning across the same perseus api major version.
	 */
	var React = __webpack_require__(43);
	
	var StubTagEditor = __webpack_require__(55);
	
	module.exports = {
	    Options: {
	        propTypes: React.PropTypes.shape({
	            isArticle: React.PropTypes.bool.isRequired,
	
	            satStyling: React.PropTypes.bool.isRequired,
	            onInputError: React.PropTypes.func.isRequired,
	            onFocusChange: React.PropTypes.func.isRequired,
	            staticRender: React.PropTypes.bool.isRequired,
	            GroupMetadataEditor: React.PropTypes.func.isRequired,
	            showAlignmentOptions: React.PropTypes.bool.isRequired,
	            readOnly: React.PropTypes.bool.isRequired,
	
	            answerableCallback: React.PropTypes.func,
	            getAnotherHint: React.PropTypes.func,
	            interactionCallback: React.PropTypes.func,
	
	            // A function that takes in the relative problem number (starts at
	            // 0 and is incremented for each group widget), and the ID of the
	            // group widget, then returns a react component that will be added
	            // immediately above the renderer in the group widget. If the
	            // function returns null, no annotation will be added.
	            groupAnnotator: React.PropTypes.func.isRequired,
	
	            // If imagePlaceholder or widgetPlaceholder are set, perseus will
	            // render the placeholder instead of the image or widget node.
	            imagePlaceholder: React.PropTypes.node,
	            widgetPlaceholder: React.PropTypes.node,
	
	            // Base React elements that can be used in place of the standard DOM
	            // DOM elements. For example, when provided, <Link /> will be used
	            // in place of <a />. This allows clients to provide pre-styled
	            // components or components with custom behavior.
	            baseElements: React.PropTypes.shape({
	                // The <Link /> component provided here must adhere to the same
	                // interface as React's base <a /> component.
	                Link: React.PropTypes.func
	            }),
	
	            // Function that takes dimensions and returns a React component
	            // to display while an image is loading
	            imagePreloader: React.PropTypes.func,
	
	            // Function that takes an object argument. The object should
	            // include type and id, both strings, at least and can optionally
	            // include a boolean "correct" value. This is used for keeping
	            // track of widget interactions.
	            trackInteraction: React.PropTypes.func,
	
	            // A boolean that indicates whether or not a custom keypad is
	            // being used.  For mobile web this will be the ProvidedKeypad
	            // component.  In this situation we use the MathInput component
	            // from the math-input repo instead of the existing perseus math
	            // input components.
	            // TODO(charlie): Make this mutually exclusive with `staticRender`.
	            // Internally, we defer to `customKeypad` over `staticRender`, but
	            // they should really be represented as an enum or some other data
	            // structure that forbids them both being enabled at once.
	            customKeypad: React.PropTypes.bool,
	
	            // Indicates whether or not to use mobile styling.
	            isMobile: React.PropTypes.bool,
	
	            // A function, called with a bool indicating whether use of the
	            // drawing area (scratchpad) should be allowed/disallowed.
	            // Previously handled by `Khan.scratchpad.enable/disable`
	            setDrawingAreaAvailable: React.PropTypes.func,
	
	            // Whether to use the Draft.js editor or the legacy textarea
	            useDraftEditor: React.PropTypes.bool,
	
	            // Styling options that control the visual behavior of Perseus
	            // items.
	            // TODO(mdr): If we adopt this pattern, we'll need to think about
	            //     how to make individual `styling` options be optional, and
	            //     how to set their default values without overwriting provided
	            //     values. For now, though, you must either specify all fields
	            //     of `styling`, or omit the `styling` option entirely.
	            styling: React.PropTypes.shape({
	                // Which version of radio widget styles to use in non-SAT
	                // contexts.
	                //
	                // "legacy" was the version of the widget display after XOM but
	                // before we started adding MCR styles. It doesn't have support
	                // for rationales. It has since been removed.
	                //
	                // "intermediate" is a design which adds several new additions
	                // to the "legacy" styles such as:
	                //  1. Using the XOM "desktop" styles (with a visible check icon
	                //     and lines in between choices) on mobile devices.
	                //  2. Designs for rationales
	                //  3. Using the single-select styles for multi-select styles
	                //
	                // "final" is a design which will build off of the
	                // "intermediate" designs and adds some improved designs as well
	                // as:
	                //  1. a/b/c/d/etc. letters inside of the prompt check box
	                //  2. New iconography and styles to indicate choice correctness
	                //
	                // The "legacy" and "intermediate" designs will be A/B tested
	                // against each other to ensure that its changes don't cause
	                // problems due to the new designs. Once the "intermediate"
	                // designs are finished, they will be A/B tested against the
	                // "final" designs.
	                //
	                // If no flag is provided, "legacy" styles will be shown.
	                //
	                // TODO(emily): Remove this by Aug 1, 2017, at which point all
	                //   callsites should have been switched to using the "final"
	                //   designs.
	                radioStyleVersion: React.PropTypes.oneOf(["intermediate", "final"])
	            }),
	
	            // The color used for the hint progress indicator (eg. 1 / 3)
	            hintProgressColor: React.PropTypes.string
	        }).isRequired,
	
	        defaults: {
	            isArticle: false,
	            isMobile: false,
	            satStyling: false,
	            onInputError: function onInputError() {},
	            onFocusChange: function onFocusChange() {},
	            staticRender: false,
	            GroupMetadataEditor: StubTagEditor,
	            showAlignmentOptions: false,
	            readOnly: false,
	            groupAnnotator: function groupAnnotator() {
	                return null;
	            },
	            baseElements: {
	                Link: function Link(props) {
	                    return React.createElement("a", props);
	                }
	            },
	            setDrawingAreaAvailable: function setDrawingAreaAvailable() {},
	            useDraftEditor: false,
	            styling: {
	                radioStyleVersion: "final"
	            }
	        }
	    },
	    ClassNames: {
	        RENDERER: "perseus-renderer",
	        TWO_COLUMN_RENDERER: "perseus-renderer-two-columns",
	        RESPONSIVE_RENDERER: "perseus-renderer-responsive",
	        INPUT: "perseus-input",
	        FOCUSED: "perseus-focused",
	        RADIO: {
	            OPTION: "perseus-radio-option",
	            SELECTED: "perseus-radio-selected",
	            OPTION_CONTENT: "perseus-radio-option-content"
	        },
	        INTERACTIVE: "perseus-interactive",
	        CORRECT: "perseus-correct",
	        INCORRECT: "perseus-incorrect",
	        UNANSWERED: "perseus-unanswered",
	        MOBILE: "perseus-mobile"
	    }
	};

/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable no-var, prefer-spread */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var _ = __webpack_require__(56);
	
	var ApiOptions = __webpack_require__(12).Options;
	var HintsRenderer = __webpack_require__(36);
	var Renderer = __webpack_require__(37);
	var ProvideKeypad = __webpack_require__(65);
	var Util = __webpack_require__(17);
	
	var _require = __webpack_require__(80),
	    mapObject = _require.mapObject;
	
	var Gorgon = __webpack_require__(41);
	
	var _require2 = __webpack_require__(52),
	    linterContextProps = _require2.linterContextProps,
	    linterContextDefault = _require2.linterContextDefault;
	
	var RP = React.PropTypes;
	
	var ItemRenderer = React.createClass({
	    displayName: "ItemRenderer",
	
	    propTypes: _extends({}, ProvideKeypad.propTypes, {
	        // defaults are set in `this.update()` so as to adhere to
	        // `ApiOptions.PropTypes`, though the API options that are passed in
	        // can be in any degree of completeness
	        apiOptions: RP.shape({
	            interactionCallback: RP.func,
	            onFocusChange: RP.func,
	            setDrawingAreaAvailable: RP.func
	        }),
	        // Whether this component should control hiding/showing peripheral
	        // item-related components (for list, see item.answerArea below).
	        // TODO(alex): Generalize this to an 'expectsToBeInTemplate' prop
	        controlPeripherals: RP.bool,
	        hintsAreaSelector: RP.string,
	        initialHintsVisible: RP.number,
	        item: RP.shape({
	            answerArea: RP.shape({
	                calculator: RP.bool,
	                chi2Table: RP.bool,
	                periodicTable: RP.bool,
	                tTable: RP.bool,
	                zTable: RP.bool
	            }),
	            hints: RP.arrayOf(RP.object),
	            question: RP.object
	        }).isRequired,
	
	        onShowCalculator: RP.func,
	        onShowChi2Table: RP.func,
	        onShowPeriodicTable: RP.func,
	        onShowTTable: RP.func,
	        onShowZTable: RP.func,
	
	        problemNum: RP.number,
	        reviewMode: React.PropTypes.bool,
	        savedState: RP.any,
	        workAreaSelector: RP.string,
	        linterContext: linterContextProps,
	        legacyPerseusLint: React.PropTypes.arrayOf(React.PropTypes.string)
	    }),
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            apiOptions: {}, // defaults are set in `this.update()`
	            controlPeripherals: true,
	            hintsAreaSelector: "#hintsarea",
	            initialHintsVisible: 0,
	            workAreaSelector: "#workarea",
	            reviewMode: false,
	            linterContext: linterContextDefault
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return _extends({}, ProvideKeypad.getInitialState(), {
	            hintsVisible: this.props.initialHintsVisible,
	            questionCompleted: false,
	            questionHighlightedWidgets: []
	        });
	    },
	
	    componentDidMount: function componentDidMount() {
	        ProvideKeypad.componentDidMount.call(this);
	        if (this.props.controlPeripherals && this.props.apiOptions.setDrawingAreaAvailable) {
	            this.props.apiOptions.setDrawingAreaAvailable(true);
	        }
	        this._currentFocus = null;
	        this.update();
	    },
	
	    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        this.setState({
	            questionHighlightedWidgets: []
	        });
	    },
	
	    componentDidUpdate: function componentDidUpdate() {
	        this.update();
	    },
	
	    componentWillUnmount: function componentWillUnmount() {
	        ProvideKeypad.componentWillUnmount.call(this);
	        ReactDOM.unmountComponentAtNode(document.querySelector(this.props.workAreaSelector));
	        ReactDOM.unmountComponentAtNode(document.querySelector(this.props.hintsAreaSelector));
	
	        if (this.props.controlPeripherals) {
	            var answerArea = this.props.item.answerArea || {};
	            if (answerArea.calculator) {
	                $("#calculator").hide();
	            }
	            if (answerArea.periodicTable) {
	                $(".periodic-table-info-box").hide();
	            }
	            if (answerArea.zTable) {
	                $(".z-table-info-box").hide();
	            }
	            if (answerArea.tTable) {
	                $(".t-table-info-box").hide();
	            }
	            if (answerArea.chi2Table) {
	                $(".chi2-table-info-box").hide();
	            }
	        }
	    },
	
	    keypadElement: function keypadElement() {
	        return ProvideKeypad.keypadElement.call(this);
	    },
	
	
	    update: function update() {
	        var apiOptions = _extends({}, ApiOptions.defaults, this.props.apiOptions, {
	            onFocusChange: this._handleFocusChange
	        });
	
	        // Since the item renderer works by rendering things into three divs
	        // that have completely different places in the DOM, we have to do this
	        // strangeness instead of relying on React's normal render() method.
	        // TODO(alpert): Figure out how to clean this up somehow
	        this.questionRenderer = ReactDOM.render(React.createElement(Renderer, _extends({
	            keypadElement: this.keypadElement(),
	            problemNum: this.props.problemNum,
	            onInteractWithWidget: this.handleInteractWithWidget,
	            highlightedWidgets: this.state.questionHighlightedWidgets,
	            apiOptions: apiOptions,
	            questionCompleted: this.state.questionCompleted,
	            reviewMode: this.props.reviewMode,
	            savedState: this.props.savedState,
	            linterContext: Gorgon.pushContextStack(this.props.linterContext, "question")
	        }, this.props.item.question, {
	            legacyPerseusLint: this.props.legacyPerseusLint
	        })), document.querySelector(this.props.workAreaSelector));
	
	        this.hintsRenderer = ReactDOM.render(React.createElement(HintsRenderer, {
	            hints: this.props.item.hints,
	            hintsVisible: this.state.hintsVisible,
	            apiOptions: apiOptions,
	            linterContext: Gorgon.pushContextStack(this.props.linterContext, "hints")
	        }), document.querySelector(this.props.hintsAreaSelector));
	
	        var answerArea = this.props.item.answerArea || {};
	        if (this.props.controlPeripherals) {
	            $("#calculator").toggle(answerArea.calculator || false);
	            $(".periodic-table-info-box").toggle(answerArea.periodicTable || false);
	            $(".z-table-info-box").toggle(answerArea.zTable || false);
	            $(".t-table-info-box").toggle(answerArea.tTable || false);
	            $(".chi2-table-info-box").toggle(answerArea.chi2Table || false);
	        } else {
	            if (answerArea.calculator) {
	                this.props.onShowCalculator && this.props.onShowCalculator();
	            }
	            if (answerArea.periodicTable) {
	                this.props.onShowPeriodicTable && this.props.onShowPeriodicTable();
	            }
	            if (answerArea.zTable) {
	                this.props.onShowZTable && this.props.onShowZTable();
	            }
	            if (answerArea.tTable) {
	                this.props.onShowTTable && this.props.onShowTTable();
	            }
	            if (answerArea.chi2Table) {
	                this.props.onShowChi2Table && this.props.onShowChi2Table();
	            }
	        }
	
	        if (apiOptions.answerableCallback) {
	            var isAnswerable = this.questionRenderer.emptyWidgets().length === 0;
	            apiOptions.answerableCallback(isAnswerable);
	        }
	    },
	
	    _handleFocusChange: function _handleFocusChange(newFocus, oldFocus) {
	        if (newFocus != null) {
	            this._setCurrentFocus(newFocus);
	        } else {
	            this._onRendererBlur(oldFocus);
	        }
	    },
	
	    // Sets the current focus path and element and send an onChangeFocus event
	    // back to our parent.
	    _setCurrentFocus: function _setCurrentFocus(newFocus) {
	        var _this = this;
	
	        var keypadElement = this.keypadElement();
	
	        // By the time this happens, newFocus cannot be a prefix of
	        // prevFocused, since we must have either been called from
	        // an onFocusChange within a renderer, which is only called when
	        // this is not a prefix, or between the question and answer areas,
	        // which can never prefix each other.
	        var prevFocus = this._currentFocus;
	        this._currentFocus = newFocus;
	
	        // Determine whether the newly focused path represents an input.
	        var inputPaths = this.getInputPaths();
	        var didFocusInput = this._currentFocus && inputPaths.some(function (inputPath) {
	            return Util.inputPathsEqual(inputPath, _this._currentFocus);
	        });
	
	        if (this.props.apiOptions.onFocusChange != null) {
	            this.props.apiOptions.onFocusChange(this._currentFocus, prevFocus, didFocusInput && keypadElement && ReactDOM.findDOMNode(keypadElement));
	        }
	
	        if (keypadElement) {
	            if (didFocusInput) {
	                keypadElement.activate();
	            } else {
	                keypadElement.dismiss();
	            }
	        }
	    },
	
	    _onRendererBlur: function _onRendererBlur(blurPath) {
	        var _this2 = this;
	
	        var blurringFocusPath = this._currentFocus;
	
	        // Failsafe: abort if ID is different, because focus probably happened
	        // before blur.
	        if (!Util.inputPathsEqual(blurPath, blurringFocusPath)) {
	            return;
	        }
	
	        // Wait until after any new focus events fire this tick before
	        // declaring that nothing is focused, since if there were a focus change
	        // across Renderers (e.g., from the HintsRenderer to the
	        // QuestionRenderer), we could receive the blur before the focus.
	        setTimeout(function () {
	            if (Util.inputPathsEqual(_this2._currentFocus, blurringFocusPath)) {
	                _this2._setCurrentFocus(null);
	            }
	        });
	    },
	
	    /**
	     * Accepts a question area widgetId, or an answer area widgetId of
	     * the form "answer-input-number 1", or the string "answer-area"
	     * for the whole answer area (if the answer area is a single widget).
	     */
	    _setWidgetProps: function _setWidgetProps(widgetId, newProps, callback) {
	        this.questionRenderer._setWidgetProps(widgetId, newProps, callback);
	    },
	
	    _handleAPICall: function _handleAPICall(functionName, path) {
	        // Get arguments to pass to function, including `path`.
	        var functionArgs = _.rest(arguments);
	
	        // TODO(charlie): Extend this API to support inputs in the
	        // HintsRenderer as well.
	        var caller = this.questionRenderer;
	
	        return caller[functionName].apply(caller, functionArgs);
	    },
	
	    setInputValue: function setInputValue(path, newValue, focus) {
	        return this._handleAPICall("setInputValue", path, newValue, focus);
	    },
	
	    focusPath: function focusPath(path) {
	        return this._handleAPICall("focusPath", path);
	    },
	
	    blurPath: function blurPath(path) {
	        return this._handleAPICall("blurPath", path);
	    },
	
	    getDOMNodeForPath: function getDOMNodeForPath(path) {
	        return this._handleAPICall("getDOMNodeForPath", path);
	    },
	
	    getGrammarTypeForPath: function getGrammarTypeForPath(path) {
	        return this._handleAPICall("getGrammarTypeForPath", path);
	    },
	
	    getInputPaths: function getInputPaths() {
	        var questionAreaInputPaths = this.questionRenderer.getInputPaths();
	        return questionAreaInputPaths;
	    },
	
	    handleInteractWithWidget: function handleInteractWithWidget(widgetId) {
	        var withRemoved = _.difference(this.state.questionHighlightedWidgets, [widgetId]);
	        this.setState({
	            questionCompleted: false,
	            questionHighlightedWidgets: withRemoved
	        });
	
	        if (this.props.apiOptions.interactionCallback) {
	            this.props.apiOptions.interactionCallback();
	        }
	    },
	
	    focus: function focus() {
	        return this.questionRenderer.focus();
	    },
	
	    blur: function blur() {
	        if (this._currentFocus) {
	            this.blurPath(this._currentFocus);
	        }
	    },
	
	    showHint: function showHint() {
	        if (this.state.hintsVisible < this.getNumHints()) {
	            this.setState({
	                hintsVisible: this.state.hintsVisible + 1
	            });
	        }
	    },
	
	    getNumHints: function getNumHints() {
	        return this.props.item.hints.length;
	    },
	
	    /**
	     * Grades the item.
	     *
	     * Returns a KE-style score of {
	     *     empty: bool,
	     *     correct: bool,
	     *     message: string|null,
	     *     guess: Array
	     * }
	     */
	    scoreInput: function scoreInput() {
	        var guessAndScore = this.questionRenderer.guessAndScore();
	        var guess = guessAndScore[0];
	        var score = guessAndScore[1];
	
	        // Continue to include an empty guess for the now defunct answer area.
	        // TODO(alex): Check whether we rely on the format here for
	        //             analyzing ProblemLogs. If not, remove this layer.
	        var maxCompatGuess = [guess, []];
	
	        var keScore = Util.keScoreFromPerseusScore(score, maxCompatGuess, this.questionRenderer.getSerializedState());
	
	        var emptyQuestionAreaWidgets = this.questionRenderer.emptyWidgets();
	
	        this.setState({
	            questionCompleted: keScore.correct,
	            questionHighlightedWidgets: emptyQuestionAreaWidgets
	        });
	
	        return keScore;
	    },
	
	    /**
	     * Returns an array of all widget IDs in the order they occur in
	     * the question content.
	     */
	    getWidgetIds: function getWidgetIds() {
	        return this.questionRenderer.getWidgetIds();
	    },
	
	    /**
	     * Returns an object mapping from widget ID to KE-style score.
	     * The keys of this object are the values of the array returned
	     * from `getWidgetIds`.
	     */
	    scoreWidgets: function scoreWidgets() {
	        var qScore = this.questionRenderer.scoreWidgets();
	        var qGuess = this.questionRenderer.getUserInputForWidgets();
	        var state = this.questionRenderer.getSerializedState();
	        return mapObject(qScore, function (score, id) {
	            return Util.keScoreFromPerseusScore(score, qGuess[id], state);
	        });
	    },
	
	    /**
	     * Get a representation of the current state of the item.
	     */
	    getSerializedState: function getSerializedState() {
	        return {
	            question: this.questionRenderer.getSerializedState(),
	            hints: this.hintsRenderer.getSerializedState()
	        };
	    },
	
	    restoreSerializedState: function restoreSerializedState(state, callback) {
	        // We need to wait for both the question renderer and the hints
	        // renderer to finish restoring their states.
	        var numCallbacks = 2;
	        var fireCallback = function fireCallback() {
	            --numCallbacks;
	            if (callback && numCallbacks === 0) {
	                callback();
	            }
	        };
	
	        this.questionRenderer.restoreSerializedState(state.question, fireCallback);
	        this.hintsRenderer.restoreSerializedState(state.hints, fireCallback);
	    },
	
	    showRationalesForCurrentlySelectedChoices: function showRationalesForCurrentlySelectedChoices() {
	        this.questionRenderer.showRationalesForCurrentlySelectedChoices();
	    },
	    deselectIncorrectSelectedChoices: function deselectIncorrectSelectedChoices() {
	        this.questionRenderer.deselectIncorrectSelectedChoices();
	    },
	
	
	    render: function render() {
	        return React.createElement("div", null);
	    }
	});
	
	module.exports = ItemRenderer;

/***/ },
/* 14 */,
/* 15 */,
/* 16 */,
/* 17 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable brace-style, comma-dangle, indent, max-len, no-var, one-var, prefer-spread */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var _ = __webpack_require__(56);
	var KhanAnswerTypes = __webpack_require__(82);
	
	var nestedMap = function nestedMap(children, func, context) {
	    if (_.isArray(children)) {
	        return _.map(children, function (child) {
	            return nestedMap(child, func);
	        });
	    } else {
	        return func.call(context, children);
	    }
	};
	
	var Util = {
	    /**
	     * Used to compare equality of two input paths, which are represented as
	     * arrays of strings.
	     */
	    inputPathsEqual: function inputPathsEqual(a, b) {
	        if (a == null || b == null) {
	            return a == null === (b == null);
	        }
	
	        return a.length === b.length && a.every(function (item, index) {
	            return b[index] === item;
	        });
	    },
	
	
	    nestedMap: nestedMap,
	
	    rWidgetParts: /^\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]$/,
	    rWidgetRule: /^\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]/,
	    rTypeFromWidgetId: /^([a-z-]+) ([0-9]+)$/,
	    snowman: "\u2603",
	
	    noScore: {
	        type: "points",
	        earned: 0,
	        total: 0,
	        message: null
	    },
	
	    seededRNG: function seededRNG(seed) {
	        var randomSeed = seed;
	
	        return function () {
	            // Robert Jenkins' 32 bit integer hash function.
	            var seed = randomSeed;
	            seed = seed + 0x7ed55d16 + (seed << 12) & 0xffffffff;
	            seed = (seed ^ 0xc761c23c ^ seed >>> 19) & 0xffffffff;
	            seed = seed + 0x165667b1 + (seed << 5) & 0xffffffff;
	            seed = (seed + 0xd3a2646c ^ seed << 9) & 0xffffffff;
	            seed = seed + 0xfd7046c5 + (seed << 3) & 0xffffffff;
	            seed = (seed ^ 0xb55a4f09 ^ seed >>> 16) & 0xffffffff;
	            return (randomSeed = seed & 0xfffffff) / 0x10000000;
	        };
	    },
	
	    // Shuffle an array using a given random seed or function.
	    // If `ensurePermuted` is true, the input and ouput are guaranteed to be
	    // distinct permutations.
	    shuffle: function shuffle(array, randomSeed, ensurePermuted) {
	        // Always return a copy of the input array
	        var shuffled = _.clone(array);
	
	        // Handle edge cases (input array is empty or uniform)
	        if (!shuffled.length || _.all(shuffled, function (value) {
	            return _.isEqual(value, shuffled[0]);
	        })) {
	            return shuffled;
	        }
	
	        var random;
	        if (_.isFunction(randomSeed)) {
	            random = randomSeed;
	        } else {
	            random = Util.seededRNG(randomSeed);
	        }
	
	        do {
	            // Fischer-Yates shuffle
	            for (var top = shuffled.length; top > 0; top--) {
	                var newEnd = Math.floor(random() * top),
	                    temp = shuffled[newEnd];
	
	                shuffled[newEnd] = shuffled[top - 1];
	                shuffled[top - 1] = temp;
	            }
	        } while (ensurePermuted && _.isEqual(array, shuffled));
	
	        return shuffled;
	    },
	
	    // In IE8, split doesn't work right. Implement it ourselves.
	    split: "x".split(/(.)/g).length ? function (str, r) {
	        return str.split(r);
	    } : function (str, r) {
	        // Based on Steven Levithan's MIT-licensed split, available at
	        // http://blog.stevenlevithan.com/archives/cross-browser-split
	        var output = [];
	        var lastIndex = r.lastIndex = 0;
	        var match;
	
	        while (match = r.exec(str)) {
	            output.push(str.slice(lastIndex, match.index));
	            output.push.apply(output, match.slice(1));
	            lastIndex = match.index + match[0].length;
	        }
	
	        output.push(str.slice(lastIndex));
	        return output;
	    },
	
	    /**
	     * Given two score objects for two different widgets, combine them so that
	     * if one is wrong, the total score is wrong, etc.
	     */
	    combineScores: function combineScores(scoreA, scoreB) {
	        var message;
	
	        if (scoreA.type === "points" && scoreB.type === "points") {
	            if (scoreA.message && scoreB.message && scoreA.message !== scoreB.message) {
	                // TODO(alpert): Figure out how to combine messages usefully
	                message = null;
	            } else {
	                message = scoreA.message || scoreB.message;
	            }
	
	            return {
	                type: "points",
	                earned: scoreA.earned + scoreB.earned,
	                total: scoreA.total + scoreB.total,
	                message: message
	            };
	        } else if (scoreA.type === "points" && scoreB.type === "invalid") {
	            return scoreB;
	        } else if (scoreA.type === "invalid" && scoreB.type === "points") {
	            return scoreA;
	        } else if (scoreA.type === "invalid" && scoreB.type === "invalid") {
	            if (scoreA.message && scoreB.message && scoreA.message !== scoreB.message) {
	                // TODO(alpert): Figure out how to combine messages usefully
	                message = null;
	            } else {
	                message = scoreA.message || scoreB.message;
	            }
	
	            return {
	                type: "invalid",
	                message: message
	            };
	        }
	    },
	
	    keScoreFromPerseusScore: function keScoreFromPerseusScore(score, guess, state) {
	        if (score.type === "points") {
	            return {
	                empty: false,
	                correct: score.earned >= score.total,
	                message: score.message,
	                guess: guess,
	                state: state
	            };
	        } else if (score.type === "invalid") {
	            return {
	                empty: true,
	                correct: false,
	                message: score.message,
	                guess: guess,
	                state: state
	            };
	        } else {
	            throw new Error("Invalid score type: " + score.type);
	        }
	    },
	
	    /**
	     * Return the first valid interpretation of 'text' as a number, in the form
	     * {value: 2.3, exact: true}.
	     */
	    firstNumericalParse: function firstNumericalParse(text) {
	        // TODO(alpert): This is sort of hacky...
	        var first;
	        var val = KhanAnswerTypes.predicate.createValidatorFunctional(function (ans) {
	            first = ans;
	            return true; /* break */
	        }, {
	            simplify: "optional",
	            inexact: true,
	            forms: "integer, proper, improper, pi, log, mixed, decimal"
	        });
	
	        val(text);
	        return first;
	    },
	
	    stringArrayOfSize: function stringArrayOfSize(size) {
	        return _(size).times(function () {
	            return "";
	        });
	    },
	
	    /**
	     * For a graph's x or y dimension, given the tick step,
	     * the ranges extent (e.g. [-10, 10]), the pixel dimension constraint,
	     * and the grid step, return a bunch of configurations for that dimension.
	     *
	     * Example:
	     *      gridDimensionConfig(10, [-50, 50], 400, 5)
	     *
	     * Returns: {
	     *      scale: 4,
	     *      snap: 2.5,
	     *      tickStep: 2,
	     *      unityLabel: true
	     * };
	     */
	    gridDimensionConfig: function gridDimensionConfig(absTickStep, extent, dimensionConstraint, gridStep) {
	        var scale = Util.scaleFromExtent(extent, dimensionConstraint);
	        var stepPx = absTickStep * scale;
	        var unityLabel = stepPx > 30;
	        return {
	            scale: scale,
	            tickStep: absTickStep / gridStep,
	            unityLabel: unityLabel
	        };
	    },
	
	    /**
	     * Given the range, step, and boxSize, calculate the reasonable gridStep.
	     * Used for when one was not given explicitly.
	     *
	     * Example:
	     *      getGridStep([[-10, 10], [-10, 10]], [1, 1], 340)
	     *
	     * Returns: [1, 1]
	     */
	    getGridStep: function getGridStep(range, step, boxSize) {
	        return _(2).times(function (i) {
	            var scale = Util.scaleFromExtent(range[i], boxSize);
	            var gridStep = Util.gridStepFromTickStep(step[i], scale);
	            return gridStep;
	        });
	    },
	
	    snapStepFromGridStep: function snapStepFromGridStep(gridStep) {
	        return _.map(gridStep, function (step) {
	            return step / 2;
	        });
	    },
	
	    /**
	     * Given the range and a dimension, come up with the appropriate
	     * scale.
	     * Example:
	     *      scaleFromExtent([-25, 25], 500) // returns 10
	     */
	    scaleFromExtent: function scaleFromExtent(extent, dimensionConstraint) {
	        var span = extent[1] - extent[0];
	        var scale = dimensionConstraint / span;
	        return scale;
	    },
	
	    /**
	     * Return a reasonable tick step given extent and dimension.
	     * (extent is [begin, end] of the domain.)
	     * Example:
	     *      tickStepFromExtent([-10, 10], 300) // returns 2
	     */
	    tickStepFromExtent: function tickStepFromExtent(extent, dimensionConstraint) {
	        var span = extent[1] - extent[0];
	
	        var tickFactor;
	        // If single number digits
	        if (15 < span && span <= 20) {
	            tickFactor = 23;
	
	            // triple digit or decimal
	        } else if (span > 100 || span < 5) {
	            tickFactor = 10;
	
	            // double digit
	        } else {
	            tickFactor = 16;
	        }
	        var constraintFactor = dimensionConstraint / 500;
	        var desiredNumTicks = tickFactor * constraintFactor;
	        return Util.tickStepFromNumTicks(span, desiredNumTicks);
	    },
	
	    /**
	     * Given the tickStep and the graph's scale, find a
	     * grid step.
	     * Example:
	     *      gridStepFromTickStep(200, 0.2) // returns 100
	     */
	    gridStepFromTickStep: function gridStepFromTickStep(tickStep, scale) {
	        var tickWidth = tickStep * scale;
	        var x = tickStep;
	        var y = Math.pow(10, Math.floor(Math.log(x) / Math.LN10));
	        var leadingDigit = Math.floor(x / y);
	        if (tickWidth < 25) {
	            return tickStep;
	        }
	        if (tickWidth < 50) {
	            if (leadingDigit === 5) {
	                return tickStep;
	            } else {
	                return tickStep / 2;
	            }
	        }
	        if (leadingDigit === 1) {
	            return tickStep / 2;
	        }
	        if (leadingDigit === 2) {
	            return tickStep / 4;
	        }
	        if (leadingDigit === 5) {
	            return tickStep / 5;
	        }
	    },
	
	    /**
	     * Find a good tick step for the desired number of ticks in the range
	     * Modified from d3.scale.linear: d3_scale_linearTickRange.
	     * Thanks, mbostock!
	     * Example:
	     *      tickStepFromNumTicks(50, 6) // returns 10
	     */
	    tickStepFromNumTicks: function tickStepFromNumTicks(span, numTicks) {
	        var step = Math.pow(10, Math.floor(Math.log(span / numTicks) / Math.LN10));
	        var err = numTicks / span * step;
	
	        // Filter ticks to get closer to the desired count.
	        if (err <= 0.15) {
	            step *= 10;
	        } else if (err <= 0.35) {
	            step *= 5;
	        } else if (err <= 0.75) {
	            step *= 2;
	        }
	
	        // Round start and stop values to step interval.
	        return step;
	    },
	
	    /**
	     * Constrain tick steps intended for desktop size graphs
	     * to something more suitable for mobile size graphs.
	     * Specifically, we aim for 10 or fewer ticks per graph axis.
	     */
	    constrainedTickStepsFromTickSteps: function constrainedTickStepsFromTickSteps(tickSteps, ranges) {
	        var steps = [];
	
	        for (var i = 0; i < 2; i++) {
	            var span = ranges[i][1] - ranges[i][0];
	            var numTicks = span / tickSteps[i];
	            if (numTicks <= 10) {
	                // Will displays fine on mobile
	                steps[i] = tickSteps[i];
	            } else if (numTicks <= 20) {
	                // Will be crowded on mobile, so hide every other tick
	                steps[i] = tickSteps[i] * 2;
	            } else {
	                // Fallback in case we somehow have more than 20 ticks
	                // Note: This shouldn't happen due to GraphSettings.validStep
	                steps[i] = Util.tickStepFromNumTicks(span, 10);
	            }
	        }
	
	        return steps;
	    },
	
	    /**
	     * Transparently update deprecated props so that the code to deal
	     * with them only lives in one place: (Widget).deprecatedProps
	     *
	     * For example, if a boolean `foo` was deprecated in favor of a
	     * number 'bar':
	     *      deprecatedProps: {
	     *          foo: function(props) {
	     *              return {bar: props.foo ? 1 : 0};
	     *          }
	     *      }
	     */
	    DeprecationMixin: {
	        // This lifecycle stage is only called before first render
	        componentWillMount: function componentWillMount() {
	            var newProps = {};
	
	            _.each(this.deprecatedProps, function (func, prop) {
	                if (_.has(this.props, prop)) {
	                    _.extend(newProps, func(this.props));
	                }
	            }, this);
	
	            if (!_.isEmpty(newProps)) {
	                // Set new props directly so that widget renders correctly
	                // when it first mounts, even though these will be overwritten
	                // almost immediately afterwards...
	                _.extend(this.props, newProps);
	
	                // ...when we propagate the new props upwards and they come
	                // back down again.
	                setTimeout(this.props.onChange, 0, newProps);
	            }
	        }
	    },
	
	    /**
	     * Approximate equality on numbers and primitives.
	     */
	    eq: function eq(x, y) {
	        if (_.isNumber(x) && _.isNumber(y)) {
	            return Math.abs(x - y) < 1e-9;
	        } else {
	            return x === y;
	        }
	    },
	
	    /**
	     * Deep approximate equality on primitives, numbers, arrays, and objects.
	     */
	    deepEq: function deepEq(x, y) {
	        if (_.isArray(x) && _.isArray(y)) {
	            if (x.length !== y.length) {
	                return false;
	            }
	            for (var i = 0; i < x.length; i++) {
	                if (!Util.deepEq(x[i], y[i])) {
	                    return false;
	                }
	            }
	            return true;
	        } else if (_.isArray(x) || _.isArray(y)) {
	            return false;
	        } else if (_.isFunction(x) && _.isFunction(y)) {
	            return Util.eq(x, y);
	        } else if (_.isFunction(x) || _.isFunction(y)) {
	            return false;
	        } else if (_.isObject(x) && _.isObject(y)) {
	            return x === y || _.all(x, function (v, k) {
	                return Util.deepEq(y[k], v);
	            }) && _.all(y, function (v, k) {
	                return Util.deepEq(x[k], v);
	            });
	        } else if (_.isObject(x) || _.isObject(y)) {
	            return false;
	        } else {
	            return Util.eq(x, y);
	        }
	    },
	
	    /**
	     * Query String Parser
	     *
	     * Original from:
	     * http://stackoverflow.com/questions/901115/get-querystring-values-in-javascript/2880929#2880929
	     */
	    parseQueryString: function parseQueryString(query) {
	        query = query || window.location.search.substring(1);
	        var urlParams = {},
	            e,
	            a = /\+/g,
	            // Regex for replacing addition symbol with a space
	        r = /([^&=]+)=?([^&]*)/g,
	            d = function d(s) {
	            return decodeURIComponent(s.replace(a, " "));
	        };
	
	        while (e = r.exec(query)) {
	            urlParams[d(e[1])] = d(e[2]);
	        }
	
	        return urlParams;
	    },
	
	    /**
	     * Query string adder
	     * Works for URLs without #.
	     * Original from:
	     * http://stackoverflow.com/questions/5999118/add-or-update-query-string-parameter
	     */
	    updateQueryString: function updateQueryString(uri, key, value) {
	        value = encodeURIComponent(value);
	        var re = new RegExp("([?&])" + key + "=.*?(&|$)", "i");
	        var separator = uri.indexOf("?") !== -1 ? "&" : "?";
	        if (uri.match(re)) {
	            return uri.replace(re, "$1" + key + "=" + value + "$2");
	        } else {
	            return uri + separator + key + "=" + value;
	        }
	    },
	
	    /**
	     * A more strict encodeURIComponent that escapes `()'!`s
	     * Especially useful for creating URLs that are embeddable in markdown
	     *
	     * Adapted from
	     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent
	     * This function and the above original available under the
	     * CC-BY-SA 2.5 license.
	     */
	    strongEncodeURIComponent: function strongEncodeURIComponent(str) {
	        return encodeURIComponent(str)
	        // Note that although RFC3986 reserves "!", RFC5987 does not,
	        // so we do not need to escape it
	        .replace(/['()!]/g, window.escape) // i.e., %27 %28 %29
	        .replace(/\*/g, "%2A");
	    },
	
	    // There are certain widgets where we don't want to provide the "answered"
	    // highlight indicator.
	    // The issue with just using the `graded` flag on questions is that showing
	    // that a certain widget is ungraded can sometimes reveal the answer to a
	    // question ("is this transformation possible? if so, do it")
	    // This is kind of a hack to get around this.
	    widgetShouldHighlight: function widgetShouldHighlight(widget) {
	        if (!widget) {
	            return false;
	        }
	        var HIGHLIGHT_BAR_BLACKLIST = ["measurer", "protractor"];
	        return !_.contains(HIGHLIGHT_BAR_BLACKLIST, widget.type);
	    },
	
	    /**
	     * If a widget says that it is empty once it is graded.
	     * Trying to encapsulate references to the score format.
	     */
	    scoreIsEmpty: function scoreIsEmpty(score) {
	        // HACK(benkomalo): ugh. this isn't great; the Perseus score objects
	        // overload the type "invalid" for what should probably be three
	        // distinct cases:
	        //  - truly empty or not fully filled out
	        //  - invalid or malformed inputs
	        //  - "almost correct" like inputs where the widget wants to give
	        //  feedback (e.g. a fraction needs to be reduced, or `pi` should
	        //  be used instead of 3.14)
	        //
	        //  Unfortunately the coercion happens all over the place, as these
	        //  Perseus style score objects are created *everywhere* (basically
	        //  in every widget), so it's hard to change now. We assume that
	        //  anything with a "message" is not truly empty, and one of the
	        //  latter two cases for now.
	        return score.type === "invalid" && (!score.message || score.message.length === 0);
	    },
	
	    /**
	     * Extracts the location of a touch or mouse event, allowing you to pass
	     * in a "mouseup", "mousedown", or "mousemove" event and receive the
	     * correct coordinates. Shouldn't be used with "vmouse" events.
	     *
	     * The Util.touchHandlers are used to track the current state of the touch
	     * event, such as whether or not the user is currently pressed down (either
	     * through touch or mouse) on the screen.
	     */
	
	    touchHandlers: {
	        pointerDown: false,
	        currentTouchIdentifier: null
	    },
	
	    resetTouchHandlers: function resetTouchHandlers() {
	        _.extend(Util.touchHandlers, {
	            pointerDown: false,
	            currentTouchIdentifier: null
	        });
	    },
	
	    extractPointerLocation: function extractPointerLocation(event) {
	        var touchOrEvent;
	
	        if (Util.touchHandlers.pointerDown) {
	            // Look for the touch matching the one we're tracking; ignore others
	            if (Util.touchHandlers.currentTouchIdentifier != null) {
	                var len = event.changedTouches ? event.changedTouches.length : 0;
	                for (var i = 0; i < len; i++) {
	                    if (event.changedTouches[i].identifier === Util.touchHandlers.currentTouchIdentifier) {
	                        touchOrEvent = event.changedTouches[i];
	                    }
	                }
	            } else {
	                touchOrEvent = event;
	            }
	
	            var isEndish = event.type === "touchend" || event.type === "touchcancel";
	            if (touchOrEvent && isEndish) {
	                Util.touchHandlers.pointerDown = false;
	                Util.touchHandlers.currentTouchIdentifier = null;
	            }
	        } else {
	            // touchstart or mousedown
	            Util.touchHandlers.pointerDown = true;
	            if (event.changedTouches) {
	                touchOrEvent = event.changedTouches[0];
	                Util.touchHandlers.currentTouchIdentifier = touchOrEvent.identifier;
	            } else {
	                touchOrEvent = event;
	            }
	        }
	
	        if (touchOrEvent) {
	            return {
	                left: touchOrEvent.pageX,
	                top: touchOrEvent.pageY
	            };
	        }
	    },
	
	    /**
	     * Pass this function as the touchstart for an element to
	     * avoid sending the touch to the mobile scratchpad
	     */
	    captureScratchpadTouchStart: function captureScratchpadTouchStart(e) {
	        e.stopPropagation();
	    },
	
	    getImageSize: function getImageSize(url, callback) {
	        var img = new Image();
	        img.onload = function () {
	            // IE 11 seems to have problems calculating the heights of svgs
	            // if they're not in the DOM. To solve this, we add the element to
	            // the dom, wait for a rerender, and use `.clientWidth` and
	            // `.clientHeight`. I think we could also solve the problem by
	            // adding the image to the document before setting the src, but then
	            // the experience would be worse for other browsers.
	            if (img.width === 0 && img.height === 0) {
	                document.body.appendChild(img);
	                _.defer(function () {
	                    callback(img.clientWidth, img.clientHeight);
	                    document.body.removeChild(img);
	                });
	            } else {
	                callback(img.width, img.height);
	            }
	        };
	
	        // Require here to prevent recursive imports
	        var SvgImage = __webpack_require__(67);
	        img.src = SvgImage.getRealImageUrl(url);
	    },
	
	    textarea: {
	        /**
	         * Gets the word right before where the textarea cursor is
	         *
	         * @param {Element} textarea - The textarea DOM element
	         * @return {JSON} - An object with the word and its starting and ending positions in the textarea
	         */
	        getWordBeforeCursor: function getWordBeforeCursor(textarea) {
	            var text = textarea.value;
	
	            var endPos = textarea.selectionStart - 1;
	            var startPos = Math.max(text.lastIndexOf("\n", endPos), text.lastIndexOf(" ", endPos)) + 1;
	
	            return {
	                string: text.substring(startPos, endPos + 1),
	                pos: {
	                    start: startPos,
	                    end: endPos
	                }
	            };
	        },
	
	        /**
	         * Moves the textarea cursor at the specified position
	         *
	         * @param {Element} textarea - The textarea DOM element
	         * @param {int} pos - The position where the cursor will be moved
	         */
	        moveCursor: function moveCursor(textarea, pos) {
	            textarea.selectionStart = pos;
	            textarea.selectionEnd = pos;
	        }
	    }
	};
	
	Util.random = Util.seededRNG(new Date().getTime() & 0xffffffff);
	
	module.exports = Util;

/***/ },
/* 18 */,
/* 19 */,
/* 20 */,
/* 21 */,
/* 22 */,
/* 23 */,
/* 24 */,
/* 25 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable max-lines, no-console, no-var, react/prop-types, react/sort-comp */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	/* globals katex */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var ReactCreateFragment = __webpack_require__(168);
	var $ = __webpack_require__(169);
	var _ = __webpack_require__(56);
	
	var ApiOptions = __webpack_require__(12).Options;
	var DragTarget = __webpack_require__(88);
	
	var _require = __webpack_require__(47),
	    iconChevronDown = _require.iconChevronDown,
	    iconChevronRight = _require.iconChevronRight,
	    iconTrash = _require.iconTrash;
	
	var InlineIcon = __webpack_require__(48);
	var KatexErrorView = __webpack_require__(89);
	var PerseusMarkdown = __webpack_require__(49);
	var PropCheckBox = __webpack_require__(90);
	var Util = __webpack_require__(17);
	var Widgets = __webpack_require__(31);
	var preprocessTex = __webpack_require__(91);
	
	var PerseusEditor = __webpack_require__(92);
	
	var WIDGET_PROP_BLACKLIST = __webpack_require__(93);
	
	// like [[snowman input-number 1]]
	var widgetPlaceholder = "[[\u2603 {id}]]";
	var widgetRegExp = "(\\[\\[\u2603 {id}\\]\\])";
	var rWidgetSplit = new RegExp(widgetRegExp.replace("{id}", "[a-z-]+ [0-9]+"), "g");
	
	var shortcutRegexp = /^\[\[([a-z\-]+)$/; // like [[nu, [[int, etc
	
	var ENDS_WITH_A_PARAGRAPH = /(?:\n{2,}|^\n*)$/;
	var TRAILING_NEWLINES = /(\n*)$/;
	var LEADING_NEWLINES = /^(\n*)/;
	
	var commafyInteger = function commafyInteger(n) {
	    var str = n.toString();
	    if (str.length >= 5) {
	        str = str.replace(/(\d)(?=(\d{3})+$)/g, "$1{,}");
	    }
	    return str;
	};
	var makeEndWithAParagraphIfNecessary = function makeEndWithAParagraphIfNecessary(content) {
	    if (!ENDS_WITH_A_PARAGRAPH.test(content)) {
	        var newlines = TRAILING_NEWLINES.exec(content)[1];
	        return content + "\n\n".slice(0, 2 - newlines.length);
	    } else {
	        return content;
	    }
	};
	var makeStartWithAParagraphAlways = function makeStartWithAParagraphAlways(content) {
	    var newlines = LEADING_NEWLINES.exec(content)[1];
	    return "\n\n".slice(0, 2 - newlines.length) + content;
	};
	
	var WidgetSelect = React.createClass({
	    displayName: "WidgetSelect",
	
	    shouldComponentUpdate: function shouldComponentUpdate() {
	        return false;
	    },
	
	    handleChange: function handleChange(e) {
	        var widgetType = e.target.value;
	        if (widgetType === "") {
	            // TODO(alpert): Not sure if change will trigger here
	            // but might as well be safe
	            return;
	        }
	        if (this.props.onChange) {
	            this.props.onChange(widgetType);
	        }
	    },
	
	    render: function render() {
	        var widgets = Widgets.getPublicWidgets();
	        var orderedWidgetNames = _.sortBy(_.keys(widgets), function (name) {
	            return widgets[name].displayName;
	        });
	        var addWidgetString = "Add a widget\u2026";
	        return React.createElement(
	            "select",
	            { value: "", onChange: this.handleChange },
	            React.createElement(
	                "option",
	                { value: "" },
	                addWidgetString
	            ),
	            React.createElement(
	                "option",
	                { disabled: true },
	                "--"
	            ),
	            _.map(orderedWidgetNames, function (name) {
	                return React.createElement(
	                    "option",
	                    { key: name, value: name },
	                    widgets[name].displayName
	                );
	            })
	        );
	    }
	});
	
	// This component handles upgading widget editor props via prop
	// upgrade transforms. Widget editors will always be rendered
	// with all available transforms applied, but the results of those
	// transforms will not be propogated upwards until serialization.
	var WidgetEditor = React.createClass({
	    displayName: "WidgetEditor",
	
	    propTypes: {
	        // Unserialized props
	        id: React.PropTypes.string.isRequired,
	        onChange: React.PropTypes.func.isRequired,
	        onRemove: React.PropTypes.func.isRequired,
	        apiOptions: ApiOptions.propTypes,
	
	        // Serialized props
	        type: React.PropTypes.string.isRequired,
	        alignment: React.PropTypes.string,
	        static: React.PropTypes.bool,
	        graded: React.PropTypes.bool,
	        options: React.PropTypes.any,
	        version: React.PropTypes.shape({
	            major: React.PropTypes.number.isRequired,
	            minor: React.PropTypes.number.isRequired
	        })
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            showWidget: false
	        };
	    },
	
	    componentWillMount: function componentWillMount() {
	        this._upgradeWidgetInfo(this.props);
	    },
	
	    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        this._upgradeWidgetInfo(nextProps);
	    },
	
	    _upgradeWidgetInfo: function _upgradeWidgetInfo(props) {
	        // We can't call serialize here because this.refs.widget
	        // doesn't exist before this component is mounted.
	        var filteredProps = _.omit(props, WIDGET_PROP_BLACKLIST);
	        var info = Widgets.upgradeWidgetInfoToLatestVersion(filteredProps);
	        this.setState({
	            widgetInfo: info
	        });
	    },
	
	    _toggleWidget: function _toggleWidget(e) {
	        e.preventDefault();
	        this.setState({ showWidget: !this.state.showWidget });
	    },
	
	    _handleWidgetChange: function _handleWidgetChange(newProps, cb, silent) {
	        var newWidgetInfo = _.clone(this.state.widgetInfo);
	        newWidgetInfo.options = _.extend(this.refs.widget.serialize(), newProps);
	        this.props.onChange(newWidgetInfo, cb, silent);
	    },
	
	    _toggleStatic: function _toggleStatic(e) {
	        e.preventDefault();
	        var newWidgetInfo = _.extend({}, this.state.widgetInfo, {
	            static: !this.state.widgetInfo.static
	        });
	        this.props.onChange(newWidgetInfo);
	    },
	
	    _handleAlignmentChange: function _handleAlignmentChange(e) {
	        var newAlignment = e.target.value;
	        var newWidgetInfo = _.clone(this.state.widgetInfo);
	        newWidgetInfo.alignment = newAlignment;
	        this.props.onChange(newWidgetInfo);
	    },
	
	    render: function render() {
	        var _this = this;
	
	        var widgetInfo = this.state.widgetInfo;
	
	        var Ed = Widgets.getEditor(widgetInfo.type);
	        var supportedAlignments;
	        if (this.props.apiOptions.showAlignmentOptions) {
	            supportedAlignments = Widgets.getSupportedAlignments(widgetInfo.type);
	        } else {
	            supportedAlignments = ["default"];
	        }
	
	        var supportsStaticMode = Widgets.supportsStaticMode(widgetInfo.type);
	
	        var isUngradedEnabled = widgetInfo.type === "transformer";
	        var gradedPropBox = React.createElement(PropCheckBox, {
	            label: "Graded:",
	            graded: widgetInfo.graded,
	            onChange: this.props.onChange
	        });
	
	        return React.createElement(
	            "div",
	            { className: "perseus-widget-editor" },
	            React.createElement(
	                "div",
	                {
	                    className: "perseus-widget-editor-title " + (this.state.showWidget ? "open" : "closed")
	                },
	                React.createElement(
	                    "a",
	                    {
	                        className: "perseus-widget-editor-title-id",
	                        href: "#",
	                        onClick: this._toggleWidget
	                    },
	                    this.props.id,
	                    this.state.showWidget ? React.createElement(InlineIcon, iconChevronDown) : React.createElement(InlineIcon, iconChevronRight)
	                ),
	                supportsStaticMode && React.createElement("input", {
	                    type: "button",
	                    onClick: this._toggleStatic,
	                    className: "simple-button--small",
	                    value: widgetInfo.static ? "Unset as static" : "Set as static"
	                }),
	                supportedAlignments.length > 1 && React.createElement(
	                    "select",
	                    {
	                        className: "alignment",
	                        value: widgetInfo.alignment,
	                        onChange: this._handleAlignmentChange
	                    },
	                    supportedAlignments.map(function (alignment) {
	                        return React.createElement(
	                            "option",
	                            { key: alignment },
	                            alignment
	                        );
	                    })
	                ),
	                React.createElement(
	                    "a",
	                    {
	                        href: "#",
	                        className: "remove-widget " + "simple-button simple-button--small orange",
	                        onClick: function onClick(e) {
	                            e.preventDefault();
	                            _this.props.onRemove();
	                        }
	                    },
	                    React.createElement(InlineIcon, iconTrash)
	                )
	            ),
	            React.createElement(
	                "div",
	                {
	                    className: "perseus-widget-editor-content " + (this.state.showWidget ? "enter" : "leave")
	                },
	                isUngradedEnabled && gradedPropBox,
	                React.createElement(Ed, _extends({
	                    ref: "widget",
	                    onChange: this._handleWidgetChange,
	                    "static": widgetInfo.static,
	                    apiOptions: this.props.apiOptions
	                }, widgetInfo.options))
	            )
	        );
	    },
	
	    getSaveWarnings: function getSaveWarnings() {
	        var issuesFunc = this.refs.widget.getSaveWarnings;
	        return issuesFunc ? issuesFunc() : [];
	    },
	
	    serialize: function serialize() {
	        // TODO(alex): Make this properly handle the case where we load json
	        // with a more recent widget version than this instance of Perseus
	        // knows how to handle.
	        var widgetInfo = this.state.widgetInfo;
	        return {
	            type: widgetInfo.type,
	            alignment: widgetInfo.alignment,
	            static: widgetInfo.static,
	            graded: widgetInfo.graded,
	            options: this.refs.widget.serialize(),
	            version: widgetInfo.version
	        };
	    }
	});
	
	// This is more general than the actual markdown image parsing regex,
	// which is fine for correctness since it should only mean we could
	// store extra image dimensions, unless the question is insanely
	// formatted.
	// A simplified regex here should hopefully be easier to keep in
	// sync if the markdown parsing changes, though if it becomes
	// easy to hook into the actual markdown regex without copy-pasting
	// it, we should do that.
	var IMAGE_REGEX = /!\[[^\]]*\]\(([^\s\)]+)[^\)]*\)/g;
	
	/**
	 * Find all the matches to a /g regex.
	 *
	 * Returns an array of the regex matches. Infinite loops if `regex` does not
	 * have a /g modifier.
	 *
	 * Note: Returns an array of the capture objects, whereas String::match
	 * ignores captures. If you don't need captures, use String::match
	 */
	var allMatches = function allMatches(regex, str) {
	    var result = [];
	    while (true) {
	        // eslint-disable-line no-constant-condition
	        var match = regex.exec(str);
	        if (!match) {
	            break;
	        }
	        result.push(match);
	    }
	    return result;
	};
	
	/**
	 * Return an array of URLs of all the images in the given renderer
	 * markdown.
	 */
	var imageUrlsFromContent = function imageUrlsFromContent(content) {
	    return _.map(allMatches(IMAGE_REGEX, content), function (capture) {
	        return capture[1];
	    });
	};
	
	/**
	 * NOTE: This Editor class contains a ton of legacy logic which is not used,
	 *        as a rewrite using Draft.js was implemented in perseus-editor.jsx.
	 *        This code remains as a backup in case bugs in the rewrite block
	 *        content creators.
	 *        If you are going to make Editor changes, you likely want to navigate
	 *        to perseus-editor.jsx
	 * TODO: Clear out all the textarea code and replace with Draft.js once we are
	 *       comfortable that it is working well consistently
	 */
	var Editor = React.createClass({
	    displayName: "Editor",
	
	    propTypes: {
	        apiOptions: ApiOptions.propTypes,
	        imageUploader: React.PropTypes.func,
	        onChange: React.PropTypes.func
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            content: "",
	            placeholder: "",
	            widgets: {},
	            images: {},
	            disabled: false,
	            widgetEnabled: true,
	            immutableWidgets: false,
	            showWordCount: false,
	            warnNoPrompt: false,
	            warnNoWidgets: false
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            showKatexErrors: false
	        };
	    },
	
	    getWidgetEditor: function getWidgetEditor(id, type) {
	        if (!Widgets.getEditor(type)) {
	            return;
	        }
	        return React.createElement(WidgetEditor, _extends({
	            ref: id,
	            id: id,
	            type: type,
	            onChange: this._handleWidgetEditorChange.bind(this, id),
	            onRemove: this._handleWidgetEditorRemove.bind(this, id),
	            apiOptions: this.props.apiOptions
	        }, this.props.widgets[id]));
	    },
	
	    _handleWidgetEditorChange: function _handleWidgetEditorChange(id, newProps, cb, silent) {
	        var widgets = _.clone(this.props.widgets);
	        widgets[id] = _.extend({}, widgets[id], newProps);
	        if (this.props.apiOptions.useDraftEditor) {
	            this.refs.textarea.updateWidget(id, newProps);
	        }
	        this.props.onChange({ widgets: widgets }, cb, silent);
	    },
	
	    _handleWidgetEditorRemove: function _handleWidgetEditorRemove(id) {
	        var textarea = this.refs.textarea;
	        if (this.props.apiOptions.useDraftEditor) {
	            textarea.removeWidget(id);
	        } else {
	            var re = new RegExp(widgetRegExp.replace("{id}", id), "gm");
	            this.props.onChange({ content: textarea.value.replace(re, "") });
	        }
	    },
	
	    /**
	     * Calculate the size of all the images in props.content, and send
	     * those sizes to this.props.images using props.onChange.
	     */
	    _sizeImages: function _sizeImages(props) {
	        var imageUrls = imageUrlsFromContent(props.content);
	
	        // Discard any images in our dimension table that no
	        // longer exist in content.
	        var images = _.pick(props.images, imageUrls);
	
	        // Only calculate sizes for images that were not present previously.
	        // Most content edits shouldn't have new images.
	        // This could get weird in the case of multiple images with the same
	        // URL, if you've changed the backing image size, but given graphie
	        // hashes it's probably an edge case.
	        var newImageUrls = _.filter(imageUrls, function (url) {
	            return !images[url];
	        });
	
	        // TODO(jack): Q promises would make this nicer and only
	        // fire once.
	        _.each(newImageUrls, function (url) {
	            Util.getImageSize(url, function (width, height) {
	                // We keep modifying the same image object rather than a new
	                // copy from this.props because all changes here are additive.
	                // Maintaining old changes isn't strictly necessary if
	                // props.onChange calls are not batched, but would be if they
	                // were, so this is nice from that anti-race-condition
	                // perspective as well.
	                images[url] = {
	                    width: width,
	                    height: height
	                };
	                props.onChange({
	                    images: _.clone(images)
	                }, null, // callback
	                true // silent
	                );
	            });
	        });
	    },
	    componentDidMount: function componentDidMount() {
	        // This can't be in componentWillMount because that's happening during
	        // the middle of our parent's render, so we can't call
	        // this.props.onChange during that, since it calls our parent's
	        // setState
	        this._sizeImages(this.props);
	
	        if (!this.props.apiOptions.useDraftEditor) {
	            $(ReactDOM.findDOMNode(this.refs.textarea)).on("copy cut", this._maybeCopyWidgets).on("paste", this._maybePasteWidgets);
	        }
	    },
	
	    componentDidUpdate: function componentDidUpdate(prevProps) {
	        // TODO(alpert): Maybe fix React so this isn't necessary
	        var textarea = ReactDOM.findDOMNode(this.refs.textarea);
	        textarea.value = this.props.content;
	
	        // This can't be in componentWillReceiveProps because that's happening
	        // during the middle of our parent's render.
	        if (this.props.content !== prevProps.content) {
	            this._sizeImages(this.props);
	        }
	    },
	
	    handleDrop: function handleDrop(e) {
	        var _this2 = this;
	
	        if (this.props.apiOptions.useDraftEditor) {
	            return;
	        }
	        var content = this.props.content;
	        var dataTransfer = e.nativeEvent.dataTransfer;
	
	        // files will hold something if the drag was from the desktop or a file
	        // located on the user's computer.
	        var files = dataTransfer.files;
	
	        // ... but we only get a url if the drag originated in another window
	        if (files.length === 0) {
	            var imageUrl = dataTransfer.getData("URL");
	
	            if (imageUrl) {
	                // TODO(joel) - relocate when the image upload dialog lands
	                var newContent = content + "\n\n![](" + imageUrl + ")";
	                this.props.onChange({ content: newContent });
	            }
	
	            return;
	        }
	
	        /* For each file we make sure it's an image, then create a sentinel -
	         * snowman + identifier to insert into the current text. The sentinel
	         * only lives there temporarily until we get a response back from the
	         * server that the image is now hosted on AWS, at which time we replace
	         * the temporary sentinel with the permanent url for the image.
	         *
	         * There is an abuse of tap in the middle of the pipeline to make sure
	         * everything is sequenced in the correct order. We want to modify the
	         * content (given any number of images) at the same time, i.e. only
	         * once, so we do that step with the tap. After the content has been
	         * changed we send off the request for each image.
	         *
	         * Note that the snowman doesn't do anything special in this case -
	         * it's effectively just part of a broken link. Perseus could be
	         * extended to recognize this sentinel and highlight it like for
	         * widgets.
	         */
	        _(files).chain().map(function (file) {
	            if (!file.type.match("image.*")) {
	                return null;
	            }
	
	            var sentinel = "\u2603 " + _.uniqueId("image_");
	            // TODO(joel) - figure out how to temporarily include the image
	            // before the server returns.
	            content += "\n\n![](" + sentinel + ")";
	
	            return { file: file, sentinel: sentinel };
	        }).reject(_.isNull).tap(function () {
	            _this2.props.onChange({ content: content });
	        }).each(function (fileAndSentinel) {
	            _this2.props.imageUploader(fileAndSentinel.file, function (url) {
	                _this2.props.onChange({
	                    content: _this2.props.content.replace(fileAndSentinel.sentinel, url)
	                });
	            });
	        });
	    },
	
	    handleChange: function handleChange() {
	        var textarea = ReactDOM.findDOMNode(this.refs.textarea);
	        this.props.onChange({ content: textarea.value });
	    },
	
	    _handleKeyDown: function _handleKeyDown(e) {
	        // Tab-completion of widgets. For example, to insert an image:
	        // type `[[im`, then tab.
	        if (e.key === "Tab") {
	            var textarea = ReactDOM.findDOMNode(this.refs.textarea);
	
	            var word = Util.textarea.getWordBeforeCursor(textarea);
	            var matches = word.string.toLowerCase().match(shortcutRegexp);
	
	            if (matches != null) {
	                var text = matches[1];
	                var widgets = Widgets.getAllWidgetTypes();
	                var matchingWidgets = _.filter(widgets, function (name) {
	                    return name.substring(0, text.length) === text;
	                });
	
	                if (matchingWidgets.length === 1) {
	                    var widgetType = matchingWidgets[0];
	
	                    this._addWidgetToContent(this.props.content, [word.pos.start, word.pos.end + 1], widgetType);
	                }
	
	                e.preventDefault();
	            }
	        }
	    },
	
	    _maybeCopyWidgets: function _maybeCopyWidgets(e) {
	        // If there are widgets being cut/copied, put the widget JSON in
	        // localStorage.perseusLastCopiedWidgets to allow copy-pasting of
	        // widgets between Editors. Also store the text to be pasted in
	        // localStorage.perseusLastCopiedText since we want to know if the user
	        // is actually pasting something originally from Perseus later.
	        var textarea = e.target;
	        var selectedText = textarea.value.substring(textarea.selectionStart, textarea.selectionEnd);
	
	        var widgetNames = _.map(selectedText.match(rWidgetSplit), function (syntax) {
	            return Util.rWidgetParts.exec(syntax)[1];
	        });
	
	        var widgetData = _.pick(this.serialize().widgets, widgetNames);
	
	        localStorage.perseusLastCopiedText = selectedText;
	        localStorage.perseusLastCopiedWidgets = JSON.stringify(widgetData);
	
	        console.log("Widgets copied: " + localStorage.perseusLastCopiedWidgets);
	    },
	
	    _maybePasteWidgets: function _maybePasteWidgets(e) {
	        // Use the data from localStorage to paste any widgets we copied
	        // before. Avoid name conflicts by renumbering pasted widgets so that
	        // their numbers are always higher than the highest numbered widget of
	        // their type.
	        // TODO(sam): Fix widget numbering in the widget editor titles
	
	        var widgetJSON = localStorage.perseusLastCopiedWidgets;
	        var lastCopiedText = localStorage.perseusLastCopiedText;
	        var textToBePasted = e.originalEvent.clipboardData.getData("text");
	
	        // Only intercept if we have widget data to paste and the user is
	        // pasting something originally from Perseus.
	        // TODO(sam/aria/alex): Make it so that you can paste arbitrary text
	        // (e.g. from a text editor) instead of exactly what was copied, and
	        // let the widgetJSON match up with it. This would let you copy text
	        // into a buffer, perform complex operations on it, then paste it back.
	        if (widgetJSON && lastCopiedText === textToBePasted) {
	            e.preventDefault();
	
	            var widgetData = JSON.parse(widgetJSON);
	            var safeWidgetMapping = this._safeWidgetNameMapping(widgetData);
	
	            // Use safe widget name map to construct the new widget data
	            // TODO(aria/alex): Don't use `rWidgetSplit` or other piecemeal
	            // regexes directly; abstract this out so that we don't have to
	            // worry about potential edge cases.
	            var safeWidgetData = {};
	            for (var _iterator = Object.entries(widgetData), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
	                var _ref;
	
	                if (_isArray) {
	                    if (_i >= _iterator.length) break;
	                    _ref = _iterator[_i++];
	                } else {
	                    _i = _iterator.next();
	                    if (_i.done) break;
	                    _ref = _i.value;
	                }
	
	                var _ref2 = _ref,
	                    key = _ref2[0],
	                    data = _ref2[1];
	
	                safeWidgetData[safeWidgetMapping[key]] = data;
	            }
	            var newWidgets = _.extend(safeWidgetData, this.props.widgets);
	
	            // Use safe widget name map to construct new text
	            var safeText = lastCopiedText.replace(rWidgetSplit, function (syntax) {
	                var match = Util.rWidgetParts.exec(syntax);
	                var completeWidget = match[0];
	                var widget = match[1];
	                return completeWidget.replace(widget, safeWidgetMapping[widget]);
	            });
	
	            // Add pasted text to previous content, replacing selected text to
	            // replicate normal paste behavior.
	            var textarea = e.target;
	            var selectionStart = textarea.selectionStart;
	            var newContent = this.props.content.substr(0, selectionStart) + safeText + this.props.content.substr(textarea.selectionEnd);
	
	            this.props.onChange({ content: newContent, widgets: newWidgets }, function () {
	                var expectedCursorPosition = selectionStart + safeText.length;
	                Util.textarea.moveCursor(textarea, expectedCursorPosition);
	            });
	        }
	    },
	
	    _safeWidgetNameMapping: function _safeWidgetNameMapping(widgetData) {
	        // Helper function for _maybePasteWidgets.
	        // For each widget about to be pasted, construct a mapping from
	        // old widget name to a new widget name that doesn't have conflicts
	        // with widgets already in the editor.
	        // eg. If there is an "image 2" already present in the editor and we're
	        // about to paste in two new images, return
	        // { "image 1": "image 3", "image 2": "image 4" }
	
	        // List of widgets about to be pasted as [[name, number], ...]
	        var widgets = _.keys(widgetData).map(function (name) {
	            return name.split(" ");
	        });
	        var widgetTypes = _.uniq(widgets.map(function (widget) {
	            return widget[0];
	        }));
	
	        // List of existing widgets as [[name, number], ...]
	        var existingWidgets = _.keys(this.props.widgets).map(function (name) {
	            return name.split(" ");
	        });
	
	        // Mapping of widget type to a safe (non-conflicting) number
	        // eg. { "image": 2, "dropdown": 1 }
	        var safeWidgetNums = {};
	        _.each(widgetTypes, function (type) {
	            safeWidgetNums[type] = _.chain(existingWidgets).filter(function (existingWidget) {
	                return existingWidget[0] === type;
	            }).map(function (existingWidget) {
	                return +existingWidget[1] + 1;
	            }).max().value();
	            // If there are no existing widgets _.max returns -Infinity
	            safeWidgetNums[type] = Math.max(safeWidgetNums[type], 1);
	        });
	
	        // Construct mapping, incrementing the vals in safeWidgetNums as we go
	        var safeWidgetMapping = {};
	        _.each(widgets, function (widget) {
	            var widgetName = widget.join(" ");
	            var widgetType = widget[0];
	
	            safeWidgetMapping[widgetName] = widgetType + " " + safeWidgetNums[widgetType];
	            safeWidgetNums[widgetType]++;
	        });
	
	        return safeWidgetMapping;
	    },
	
	    _addWidgetToContent: function _addWidgetToContent(oldContent, cursorRange, widgetType) {
	        var textarea = ReactDOM.findDOMNode(this.refs.textarea);
	
	        // Note: we have to use _.map here instead of Array::map
	        // because the results of a .match might be null if no
	        // widgets were found.
	        var allWidgetIds = _.map(oldContent.match(rWidgetSplit), function (syntax) {
	            var match = Util.rWidgetParts.exec(syntax);
	            var type = match[2];
	            var num = +match[3];
	            return [type, num];
	        });
	
	        var widgetNum = _.reduce(allWidgetIds, function (currentNum, otherId) {
	            var otherType = otherId[0],
	                otherNum = otherId[1];
	
	            if (otherType === widgetType) {
	                return Math.max(otherNum + 1, currentNum);
	            } else {
	                return currentNum;
	            }
	        }, 1);
	
	        var id = widgetType + " " + widgetNum;
	        var widgetContent = widgetPlaceholder.replace("{id}", id);
	
	        // Add newlines before block-display widgets like graphs
	        var isBlock = Widgets.getDefaultAlignment(widgetType) === "block";
	
	        var prelude = oldContent.slice(0, cursorRange[0]);
	        var postlude = oldContent.slice(cursorRange[1]);
	
	        var newPrelude = isBlock ? makeEndWithAParagraphIfNecessary(prelude) : prelude;
	        var newPostlude = isBlock ? makeStartWithAParagraphAlways(postlude) : postlude;
	
	        var newContent = newPrelude + widgetContent + newPostlude;
	
	        var newWidgets = _.clone(this.props.widgets);
	        newWidgets[id] = {
	            options: Widgets.getEditor(widgetType).defaultProps,
	            type: widgetType,
	            // Track widget version on creation, so that a widget editor
	            // without a valid version prop can only possibly refer to a
	            // pre-versioning creation time.
	            version: Widgets.getVersion(widgetType)
	        };
	
	        this.props.onChange({
	            content: newContent,
	            widgets: newWidgets
	        }, function () {
	            Util.textarea.moveCursor(textarea,
	            // We want to put the cursor after the widget
	            // and after any added newlines
	            newContent.length - postlude.length);
	        });
	    },
	
	    _addWidget: function _addWidget(widgetType) {
	        var textarea = this.refs.textarea;
	
	        if (this.props.apiOptions.useDraftEditor) {
	            textarea.addWidget(widgetType);
	        } else {
	            this._addWidgetToContent(this.props.content, [textarea.selectionStart, textarea.selectionEnd], widgetType);
	            textarea.focus();
	        }
	    },
	
	    // NOTE: These templates are all duplicated verbatim in perseus-editor.jsx
	    //        so any changes should also be done there, until this code is all
	    //        deleted in favor of perseus-editor.jsx
	    addTemplate: function addTemplate(e) {
	        var templateType = e.target.value;
	        if (templateType === "") {
	            return;
	        }
	        e.target.value = "";
	
	        if (this.props.apiOptions.useDraftEditor) {
	            this.refs.textarea.addTemplate(templateType);
	            return;
	        }
	
	        var oldContent = this.props.content;
	
	        // Force templates to have a blank line before them,
	        // as they are usually used as block elements
	        // (especially important for tables)
	        oldContent = oldContent.replace(/\n*$/, "\n\n");
	
	        var template;
	        if (templateType === "table") {
	            template = "header 1 | header 2 | header 3\n" + "- | - | -\n" + "data 1 | data 2 | data 3\n" + "data 4 | data 5 | data 6\n" + "data 7 | data 8 | data 9";
	        } else if (templateType === "titledTable") {
	            template = "|| **Table title** ||\n" + "header 1 | header 2 | header 3\n" + "- | - | -\n" + "data 1 | data 2 | data 3\n" + "data 4 | data 5 | data 6\n" + "data 7 | data 8 | data 9";
	        } else if (templateType === "alignment") {
	            template = "$\\begin{align} x+5 &= 30 \\\\\n" + "x+5-5 &= 30-5 \\\\\n" + "x &= 25 \\end{align}$";
	        } else if (templateType === "piecewise") {
	            template = "$f(x) = \\begin{cases}\n" + "7 & \\text{if }x=1 \\\\\n" + "f(x-1)+5 & \\text{if }x > 1\n" + "\\end{cases}$";
	        } else if (templateType === "allWidgets") {
	            template = Widgets.getAllWidgetTypes().map(function (type) {
	                return "[[" + Util.snowman + " " + type + " 1]]";
	            }).join("\n\n");
	        } else {
	            throw new Error("Invalid template type: " + templateType);
	        }
	
	        var newContent = oldContent + template;
	
	        this.props.onChange({ content: newContent }, this.focusAndMoveToEnd);
	    },
	
	    getSaveWarnings: function getSaveWarnings() {
	        var _this3 = this;
	
	        var widgetIds = _.intersection(this.widgetIds, _.keys(this.refs));
	        var warnings = _(widgetIds).chain().map(function (id) {
	            var issuesFunc = _this3.refs[id].getSaveWarnings;
	            var issues = issuesFunc ? issuesFunc() : [];
	            return _.map(issues, function (issue) {
	                return id + ": " + issue;
	            });
	        }).flatten(true).value();
	
	        return warnings;
	    },
	
	    focus: function focus() {
	        ReactDOM.findDOMNode(this.refs.textarea).focus();
	    },
	
	    focusAndMoveToEnd: function focusAndMoveToEnd() {
	        this.focus();
	        var textarea = ReactDOM.findDOMNode(this.refs.textarea);
	        textarea.selectionStart = textarea.value.length;
	        textarea.selectionEnd = textarea.value.length;
	    },
	
	    render: function render() {
	        var pieces;
	        var widgets;
	        var underlayPieces;
	        var widgetsDropDown;
	        var templatesDropDown;
	        var widgetsAndTemplates;
	        var wordCountDisplay;
	        var katexErrorList = [];
	
	        if (this.props.showWordCount) {
	            var numChars = PerseusMarkdown.characterCount(this.props.content);
	            var numWords = Math.floor(numChars / 6);
	            wordCountDisplay = React.createElement(
	                "span",
	                {
	                    className: "perseus-editor-word-count",
	                    title: "~" + commafyInteger(numWords) + " words (" + commafyInteger(numChars) + " characters)"
	                },
	                commafyInteger(numWords)
	            );
	        }
	
	        if (this.props.widgetEnabled) {
	            pieces = Util.split(this.props.content, rWidgetSplit);
	            widgets = {};
	            underlayPieces = [];
	
	            for (var i = 0; i < pieces.length; i++) {
	                if (i % 2 === 0) {
	                    // Normal text
	                    underlayPieces.push(pieces[i]);
	
	                    var ast = PerseusMarkdown.parse(pieces[i]);
	
	                    PerseusMarkdown.traverseContent(ast, function (node) {
	                        if (node.type === "math" || node.type === "blockMath") {
	                            var content = preprocessTex(node.content);
	                            try {
	                                katex.renderToString(content);
	                            } catch (e) {
	                                katexErrorList.push({
	                                    math: content,
	                                    message: e.message
	                                });
	                            }
	                        }
	                    });
	                } else {
	                    // Widget reference
	                    var match = Util.rWidgetParts.exec(pieces[i]);
	                    var id = match[1];
	                    var type = match[2];
	
	                    var selected = false;
	                    // TODO(alpert):
	                    // var selected = focused && selStart === selEnd &&
	                    //         offset <= selStart &&
	                    //         selStart < offset + text.length;
	                    // if (selected) {
	                    //     selectedWidget = id;
	                    // }
	
	                    var duplicate = id in widgets;
	
	                    widgets[id] = this.getWidgetEditor(id, type);
	                    var classes = (duplicate || !widgets[id] ? "error " : "") + (selected ? "selected " : "");
	                    var key = duplicate ? i : id;
	                    underlayPieces.push(React.createElement(
	                        "b",
	                        { className: classes, key: key },
	                        pieces[i]
	                    ));
	                }
	            }
	
	            // TODO(alpert): Move this to the content-change event handler
	            // _.each(_.keys(this.props.widgets), function(id) {
	            //     if (!(id in widgets)) {
	            //         // It's strange if these preloaded options stick around
	            //         // since it's inconsistent with how things work if you
	            //         // don't have the serialize/deserialize step in the
	            //         // middle
	            //         // TODO(alpert): Save options in a consistent manner so
	            //         // that you can undo the deletion of a widget
	            //         delete this.props.widgets[id];
	            //     }
	            // }, this);
	
	            this.widgetIds = _.keys(widgets);
	            widgetsDropDown = React.createElement(WidgetSelect, { ref: "widgetSelect", onChange: this._addWidget });
	
	            var insertTemplateString = "Insert template\u2026";
	            templatesDropDown = React.createElement(
	                "select",
	                { onChange: this.addTemplate },
	                React.createElement(
	                    "option",
	                    { value: "" },
	                    insertTemplateString
	                ),
	                React.createElement(
	                    "option",
	                    { disabled: true },
	                    "--"
	                ),
	                React.createElement(
	                    "option",
	                    { value: "table" },
	                    "Table"
	                ),
	                React.createElement(
	                    "option",
	                    { value: "titledTable" },
	                    "Titled table"
	                ),
	                React.createElement(
	                    "option",
	                    { value: "alignment" },
	                    "Aligned equations"
	                ),
	                React.createElement(
	                    "option",
	                    { value: "piecewise" },
	                    "Piecewise function"
	                ),
	                React.createElement(
	                    "option",
	                    { disabled: true },
	                    "--"
	                ),
	                React.createElement(
	                    "option",
	                    { value: "allWidgets" },
	                    "All widgets (for testing)"
	                )
	            );
	
	            if (!this.props.immutableWidgets) {
	                widgetsAndTemplates = React.createElement(
	                    "div",
	                    { className: "perseus-editor-widgets" },
	                    React.createElement(
	                        "div",
	                        { className: "perseus-editor-widgets-selectors" },
	                        widgetsDropDown,
	                        templatesDropDown,
	                        wordCountDisplay
	                    ),
	                    ReactCreateFragment(widgets)
	                );
	                // Prevent word count from being displayed elsewhere
	                wordCountDisplay = null;
	            }
	        } else {
	            underlayPieces = [this.props.content];
	        }
	
	        // Without this, the underlay isn't the proper size when the text ends
	        // with a newline.
	        underlayPieces.push(React.createElement("br", { key: "end" }));
	
	        var completeTextarea = [React.createElement(
	            "div",
	            {
	                className: "perseus-textarea-underlay",
	                ref: "underlay",
	                key: "underlay"
	            },
	            underlayPieces
	        ), React.createElement("textarea", {
	            ref: "textarea",
	            key: "textarea",
	            onChange: this.handleChange,
	            onKeyDown: this._handleKeyDown,
	            placeholder: this.props.placeholder,
	            disabled: this.props.disabled,
	            value: this.props.content
	        })];
	
	        if (this.props.apiOptions.useDraftEditor) {
	            completeTextarea = React.createElement(PerseusEditor, {
	                ref: "textarea",
	                onChange: this.props.onChange,
	                content: this.props.content,
	                placeholder: this.props.placeholder,
	                initialWidgets: this.props.widgets,
	                imageUploader: this.props.imageUploader,
	                widgetEnabled: this.props.widgetEnabled
	            });
	        }
	        var textareaWrapper;
	        if (this.props.imageUploader) {
	            textareaWrapper = React.createElement(
	                DragTarget,
	                {
	                    onDrop: this.handleDrop,
	                    className: "perseus-textarea-pair"
	                },
	                completeTextarea
	            );
	        } else {
	            textareaWrapper = React.createElement(
	                "div",
	                { className: "perseus-textarea-pair" },
	                completeTextarea
	            );
	        }
	
	        var contentWithoutWidgets = this.props.content.replace(/\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]/g, "");
	        var noPrompt = contentWithoutWidgets.trim().length === 0;
	        var noWidgets = !/\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]/g.test(this.props.content);
	
	        var warningStyle = {
	            borderTop: "none",
	            padding: 4,
	            backgroundColor: "pink"
	        };
	
	        return React.createElement(
	            "div",
	            {
	                className: "perseus-single-editor " + (this.props.className || "")
	            },
	            textareaWrapper,
	            katexErrorList.length > 0 && React.createElement(KatexErrorView, { errorList: katexErrorList }),
	            this.props.warnNoPrompt && noPrompt && React.createElement(
	                "div",
	                { style: warningStyle },
	                "Graded Groups should contain a prompt"
	            ),
	            this.props.warnNoWidgets && noWidgets && React.createElement(
	                "div",
	                { style: warningStyle },
	                "Graded Groups should contain at least one widget"
	            ),
	            wordCountDisplay,
	            widgetsAndTemplates
	        );
	    },
	
	    serialize: function serialize(options) {
	        var _this4 = this;
	
	        // need to serialize the widgets since the state might not be
	        // completely represented in props. ahem //transformer// (and
	        // interactive-graph and plotter).
	        var widgets = {};
	        var widgetIds = _.intersection(this.widgetIds, _.keys(this.refs));
	        _.each(widgetIds, function (id) {
	            widgets[id] = _this4.refs[id].serialize();
	        });
	
	        // Preserve the data associated with deleted widgets in their last
	        // modified form. This is only intended to be useful in the context of
	        // immediate cut and paste operations if Editor.serialize() is called
	        // in between the two (which ideally should not be happening).
	        // TODO(alex): Remove this once all widget.serialize() methods
	        //             have been fixed to only return props,
	        //             and the above no longer applies.
	        if (options && options.keepDeletedWidgets) {
	            _.chain(this.props.widgets).keys().reject(function (id) {
	                return _.contains(widgetIds, id);
	            }).each(function (id) {
	                widgets[id] = _this4.props.widgets[id];
	            });
	        }
	
	        return {
	            replace: this.props.replace,
	            content: this.props.content,
	            images: this.props.images,
	            widgets: widgets
	        };
	    }
	});
	
	module.exports = Editor;

/***/ },
/* 26 */,
/* 27 */,
/* 28 */,
/* 29 */
/***/ function(module, exports, __webpack_require__) {

	/*
	    We are currently in a situation where Crowdin adds extra backslashes
	    to some strings, but not all. However, we can trust that an individual
	    string is in its entirety either escaped or not. This will allow us to use
	    a heuristic to determine with a high probability whether a string is
	    escaped or not, and thus whether to unescape it or not in
	    our `before_dom_insert()` JIPT hook.
	
	    TODO(aasmund): Delete this file when we have converted all our strings
	    to the new, unescaped Crowdin format. Calls to `maybeUnescape()` should
	    be deleted (unescaping will never be needed anymore).
	
	    The heuristic is as follows:
	    - For each LaTeX-like token (one or more backslashes followed by a special
	      character or by at least one letter) in the string:
	      - If the token cannot be unescaped (e.g. \e ), return the original string.
	        Otherwise, we now have two candidate tokens: the original tokens
	        and the escaped tokens.
	      - For both the original and the unescaped token, compute a number that
	        indicates *how* LaTeX-like the token is:
	        - 6 if there's an odd number of backslashes followed by a valid LaTeX
	          macro name (all backslashes but the last form a sequence of LaTeX
	          newlines, and the last one starts the LaTeX macro)
	        - 4 if there's one backslash followed by a dollar sign
	          (this is likely intended to actually display a dollar sign)
	        - 3 if there's an even number of backslashes (this is a sequence of
	          LaTeX newlines, and the letters that follow are LaTeX math variables)
	        - 2 if there are no backslashes (this is valid, but not LaTeX)
	        - 1 if there's an odd number of backslashes (but more than one)
	          followed by a dollar sign (our strings don't currently contain this)
	        - 0 otherwise (if there's an odd number of backslashes followed by
	          something that isn't a valid LaTeX macro name)
	    - If exactly one of the candidate strings contains one or more tokens
	      that scored 0, return the other string. Otherwise, return the string
	      with the highest sum of token scores, choosing the unescaped string
	      if there's a tie.
	
	    This algorithm was implemented in Python and run against all of our current
	    Crowdin strings (about 440,000), both in original form and escaped form.
	    It *always* makes the correct guess for the original strings, and makes
	    the wrong guess only for 30 of the escaped strings.
	 */
	
	// This regex captures sequences that might represent LaTeX or escape sequences
	var MAYBE_LATEX_REGEX = /\\+([ !#$%*,.:;\[\]\^_{|}]|[a-zA-Z]*)/g;
	
	// These are the LaTeX macros that are currently in use in our strings.
	// They were collected by applying the above regex to all of our
	// Crowdin strings, and manually removing most invalid macro names. Macro name
	// validity was tested by pasting the macros into the Perseus editor.
	// Invalid macros would typically be the result of the regex finding a sequence
	// of LaTeX newlines followed by regular text, e.g. "\\\\xy = z". However,
	// there are some actual misspellings around, so we've kept those.
	// Note that \$ is handled separately.
	var LATEX_MACROS_LIST = [" ", "!", "#", "%", "*", ",", ".", ":", ";", "[", "]", "^", "_", "{", "|", "}", "alpha", "angle", "approx", "arccos", "arcsin", "arctan", "arrow", "bar", "barwedge", "begin", "beta", "bf", "big", "Big", "bigg", "Bigg", "bigl", "Bigl", "bigr", "Bigr", "bigstar", "bigtriangledown", "bigtriangleup", "binom", "blacklozenge", "blue", "blueA", "blueB", "blueC", "blueD", "blueE", "boldsymbol", "Box", "boxdot", "boxed", "bullet", "cancel", "cap", "cdot", "cdots", "checkmark", "chi", "circ", "circledcirc", "clubsuit", "colon", "color", "cong", "cos", "cot", "csc", "cup", "curvearrowright", "dagger", "dbinom", "ddots", "delta", "Delta", "det", "dfrac", "diamond", "diamondsuit", "displaystyle", "div", "dot", "dots", "downarrow", "Downarrow", "ell", "end", "enspace", "epsilon", "equiv", "eta", "fbox", "flat", "footnotesize", "frac", "frown", "gamma", "Gamma", "gcf", "ge", "geq", "gg", "goldB", "goldC", "goldD", "goldE", "gray", "grayD", "grayE", "grayF", "green", "greenB", "greenC", "greenD", "greenE", "gt", "hat", "hbox", "heartsuit", "hline", "hphantom", "huge", "Huge", "iff", "iiint", "iint", "implies", "in", "infty", "int", "intercal", "it", "kaBlue", "kappa", "kern", "lambda", "langle", "large", "Large", "LARGE", "lcm", "ldots", "le", "left", "leftarrow", "leftrightarrow", "Leftrightarrow", "leftrightharpoons", "leftroot", "leq", "lfloor", "lg", "lim", "limits", "llap", "ln", "log", "longrightarrow", "Longrightarrow", "lozenge", "lt", "lvert", "maroonB", "maroonC", "maroonD", "maroonE", "mathbb", "mathbf", "mathcal", "mathop", "mathrm", "mathsf", "max", "mbox", "mid", "mp", "mu", "nabla", "ne", "nearrow", "neq", "ngeq", "ngtr", "nleq", "nless", "normalsize", "not", "nu", "nx", "odot", "oint", "omega", "Omega", "operatorname", "oplus", "orange", "oslash", "otimes", "overbrace", "overleftarrow", "overleftrightarrow", "overline", "overrightarrow", "overset", "parallel", "partial", "perp", "phantom", "phi", "Phi", "pi", "pink", "pm", "prime", "propto", "psi", "Psi", "purple", "purpleA", "purpleC", "purpleD", "purpleE", "qquad", "quad", "raise", "rangle", "red", "redA", "redB", "redC", "redD", "redE", "rfloor", "rho", "right", "rightarrow", "Rightarrow", "rightleftharpoons", "rvert", "scriptsize", "scriptstyle", "searrow", "sec", "setminus", "sharp", "sigma", "Sigma", "sim", "simeq", "sin", "small", "space", "sqrt", "square", "stackrel", "star", "substack", "sum", "swarrow", "tan", "tan", "tau", "tealA", "tealB", "tealC", "tealD", "tealE", "text", "textbf", "textit", "textrm", "tfrac", "therefore", "theta", "Theta", "tilde", "times", "tiny", "to", "triangle", "triangleleft", "triangleright", "underbrace", "underline", "underset", "uparrow", "uproot", "varphi", "vdots", "vec", "veebar", "vert", "vphantom", "widehat", "xi", "xrightarrow",
	
	// These aren't valid LaTeX macros, but they are misspellings
	// that also occur in our strings.
	"Begin", "End", "inte", "lamba", "textb"];
	
	var LATEX_MACROS = LATEX_MACROS_LIST.reduce(function (result, macro) {
	    result[macro] = null;
	    return result;
	}, {});
	
	// These escape sequences are the only ones that are in use. Note that newline,
	// carriage return, tab, and backslash are the only characters we use that have
	// standard escape sequences (we do not use vertical tab, form feed, etc.).
	// We also expect that Unicode characters are never represented
	// by their \u escape sequence.
	var ESCAPE_SEQUENCES = {
	    n: "\n",
	    r: "\r",
	    t: "\t",
	    "\\": "\\"
	};
	
	// Returns a number representing how "LaTeX-like" a token is.
	// Will only be run on tokens that match `MAYBE_LATEX_REGEX`, or the result of
	// unescaping such a token. See the comment at the top of the file for details.
	var getLatexLevel = function getLatexLevel(text) {
	    var backslashCount = 0;
	    while (backslashCount < text.length && text[backslashCount] === "\\") {
	        backslashCount++;
	    }
	    if (backslashCount === 0) {
	        return 2; // Valid, but doesn't contain any LaTeX syntax
	    } else if (backslashCount % 2 === 0) {
	        return 3; // Sequence of LaTeX newlines followed by other chars
	    } else {
	        // An odd number of backslashes would be a sequence of LaTeX newlines
	        // followed by a LaTeX macro
	        var maybeMacro = text.substring(backslashCount);
	        if (maybeMacro === "$") {
	            // Valid, but all our strings that use escaped dollars only have
	            // one backslash, so this is likely wrong if there are more
	            return backslashCount === 1 ? 4 : 1;
	        } else {
	            return LATEX_MACROS.hasOwnProperty(maybeMacro) ? 6 : 0;
	        }
	    }
	};
	
	var tryUnescape = function tryUnescape(text) {
	    var i = 0;
	    var result = "";
	    while (i < text.length) {
	        var c = text[i];
	        if (c === "\\") {
	            i += 1;
	            if (i === text.length) {
	                return null; // Odd number of backslashes - not unescapable
	            }
	            var e = text[i];
	            if (ESCAPE_SEQUENCES.hasOwnProperty(e)) {
	                result += ESCAPE_SEQUENCES[e];
	            } else {
	                return null; // Invalid escape sequence
	            }
	        } else {
	            result += c;
	        }
	        i += 1;
	    }
	    return result;
	};
	
	var shouldUnescape = function shouldUnescape(text) {
	    // - If there are no backslashes in the text, (un)escaping will have
	    //   no effect, so we can't tell whether this string has been escaped
	    //   by Crowdin. However, in order to help Manticore detect situations
	    //   where the translation is escaped and the source string isn't,
	    //   we will declare such strings not to be escaped.
	    // - For each token that might be LaTeX:
	    //   - Try to unescape it. If that fails, we can say for certain
	    //     that `text` is not escaped.
	    //   - Compute the LaTeX level (see the comment at the top of the file)
	    //     for the original and the unescaped token, and sum these values over
	    //     all the tokens. Also, keep track of whether any of the original
	    //     or escaped tokens contain invalid LaTeX.
	    // - If there existed invalid LaTeX only in the original tokens, we need to
	    //   unescape; if there existed invalid LaTeX only in the escaped tokens,
	    //   we need to keep the original.
	    // - Otherwise, select the version with the highest LaTeX level, preferring
	    //   the unescaped version if there's a tie (because most of our strings
	    //   are currently in the "old Crowdin style", meaning that they
	    //   are escaped).
	    if (text.indexOf("\\") < 0) {
	        return false;
	    }
	    var levelSumOriginal = 0;
	    var levelSumUnescaped = 0;
	    var anyInvalidLatexInOriginal = false;
	    var anyInvalidLatexInUnescaped = false;
	    var match = void 0;
	    MAYBE_LATEX_REGEX.lastIndex = 0;
	    while ((match = MAYBE_LATEX_REGEX.exec(text)) !== null) {
	        var original = match[0];
	        var unescaped = tryUnescape(original);
	        if (unescaped === null) {
	            return false;
	        }
	        var originalLevel = getLatexLevel(original);
	        if (originalLevel === 0) {
	            anyInvalidLatexInOriginal = true;
	        }
	        var unescapedLevel = getLatexLevel(unescaped);
	        if (unescapedLevel === 0) {
	            anyInvalidLatexInUnescaped = true;
	        }
	        levelSumOriginal += originalLevel;
	        levelSumUnescaped += unescapedLevel;
	    }
	    if (anyInvalidLatexInOriginal !== anyInvalidLatexInUnescaped) {
	        return anyInvalidLatexInOriginal;
	    }
	    return levelSumUnescaped >= levelSumOriginal;
	};
	
	// Unescape the given string if it seems to be escaped.
	var maybeUnescape = function maybeUnescape(text) {
	    if (shouldUnescape(text)) {
	        return tryUnescape(text);
	    } else {
	        return text;
	    }
	};
	
	// Unescape both of the given strings if the first one seems to be escaped.
	// This is necessary because some Crowdin string pairs have a mismatch in
	// their escaping: the source is new-style (not escaped), while the translation
	// is old-style (escaped). Such strings will give an error in the translation
	// download job, so we must ensure that they also give an error in the frontend.
	// We do this by retaining the mismatch in their escaping, instead of giving
	// them individual unescaping treatments.
	var maybeUnescapeAccordingToSource = function maybeUnescapeAccordingToSource(source, translation) {
	    if (shouldUnescape(source)) {
	        // Note: We have not yet seen a situation where the source string is
	        // escaped and the translation is unescaped, so we choose not to care
	        // about that here. If it does happen, the second element in the
	        // returned array might be null.
	        return [tryUnescape(source), tryUnescape(translation)];
	    } else {
	        return [source, translation];
	    }
	};
	
	module.exports = {
	    maybeUnescape: maybeUnescape,
	    maybeUnescapeAccordingToSource: maybeUnescapeAccordingToSource,
	    shouldUnescape: shouldUnescape
	};

/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {

	
	/**
	 * This library provides support for Perseus multi-items: structured Perseus
	 * content that content creators can easily create, and that applications can
	 * easily render into different parts of the layout.
	 *
	 * For more details about application and motivation, see:
	 * https://sites.google.com/a/khanacademy.org/forge/for-developers/perseus-items-and-multi-items
	 *
	 * This file primarily exposes the `MultiRenderer` component, which performs
	 * multi-rendering. To multi-render a question, pass in the content of the item
	 * to the `MultiRenderer` component as a props. Then, pass in a function which
	 * takes an object of renderers (in the same structure as the content), and
	 * return a render tree. The `MultiRenderer` component will allow you to
	 * combine scores, serialized state, etc. without having to manually call on
	 * each of the functions. It also handles inter-widgets requests between the
	 * different renderers.
	 * For more details, see `multi-items/multi-renderer.jsx`.
	 *
	 * Example:
	 *
	 *   item = {_multi: {
	 *       left: <content data>,
	 *       right: [<content data>, <content data>],
	 *   }}
	 *   shape = shapes.shape({
	 *       left: shapes.content,
	 *       right: shapes.arrayOf(shapes.content),
	 *   })
	 *
	 *   <MultiRenderer item={item} shape={shape}>
	 *       {({renderers}) =>
	 *           <div>
	 *               <div id="left">{renderers.left}</div>
	 *               <ul id="right">
	 *                   {renderers.right.map(r => <li>{r}</li>)}
	 *               </ul>
	 *           </div>
	 *       }
	 *   </MultiRenderer>
	 *
	 * This file also exposes `shapes`, which helps you construct a runtime type
	 * declaration for your particular class of multi-item. This can then be used
	 * to create a MultirendererEditor for your multi-item shape, and to validate
	 * that a multi-item conforms to the shape via `buildPropTypeForShape`.
	 * For more details, see `multi-items/shapes.js`.
	 *
	 * This file also exposes some utility functions for working with generic
	 * multi-items, like `findContentNodesInItem`, `findHintNodesInItem`,
	 * `inferItemShape`, and `buildEmptyItemForShape`.
	 * For more details, see `multi-items/items.js`.
	 */
	var _require = __webpack_require__(61),
	    buildEmptyItemForShape = _require.buildEmptyItemForShape,
	    findContentNodesInItem = _require.findContentNodesInItem,
	    findHintNodesInItem = _require.findHintNodesInItem,
	    inferItemShape = _require.inferItemShape;
	
	var MultiRenderer = __webpack_require__(62);
	
	var _require2 = __webpack_require__(63),
	    buildPropTypeForShape = _require2.buildPropTypeForShape;
	
	var shapes = __webpack_require__(64);
	
	module.exports = {
	    // Tools for rendering your multi-items
	    MultiRenderer: MultiRenderer,
	
	    // Tools for declaring your multi-item shapes
	    shapes: shapes,
	    buildPropTypeForShape: buildPropTypeForShape,
	
	    // Tools for generically manipulating multi-items
	    buildEmptyItemForShape: buildEmptyItemForShape,
	    findContentNodesInItem: findContentNodesInItem,
	    findHintNodesInItem: findHintNodesInItem,
	    inferItemShape: inferItemShape
	};

/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable no-console, no-var, space-before-function-paren */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var _ = __webpack_require__(56);
	
	var DEFAULT_ALIGNMENT = "block";
	var DEFAULT_SUPPORTED_ALIGNMENTS = ["default"];
	var DEFAULT_STATIC = false;
	var DEFAULT_TRACKING = "";
	var DEFAULT_LINTABLE = false;
	
	var widgets = {};
	var editors = {};
	
	var Widgets = {
	    // Widgets must be registered to avoid circular dependencies with the
	    // core Editor and Renderer components.
	    register: function register(name, widget, editor) {
	        widgets[name] = widget;
	        editors[name] = editor;
	    },
	
	    registerMany: function registerMany(widgets) {
	        var _this = this;
	
	        widgets.forEach(function (_ref) {
	            var widget = _ref[0],
	                editor = _ref[1];
	
	            widget && _this.register(widget.name, widget, editor);
	        });
	
	        this.validateAlignments();
	    },
	
	    getWidget: function getWidget(name) {
	        // TODO(alex): Consider referring to these as renderers to avoid
	        // overloading "widget"
	        if (!_.has(widgets, name)) {
	            return null;
	        }
	
	        // Allow widgets to specify a widget directly or via a function
	        if (widgets[name].getWidget) {
	            return widgets[name].getWidget();
	        } else {
	            return widgets[name].widget;
	        }
	    },
	
	    getEditor: function getEditor(name) {
	        return _.has(editors, name) ? editors[name] : null;
	    },
	
	    getTransform: function getTransform(name) {
	        return _.has(widgets, name) ? widgets[name].transform || _.identity : null;
	    },
	
	    getVersion: function getVersion(name) {
	        var widgetInfo = widgets[name];
	        if (widgetInfo) {
	            return widgets[name].version || { major: 0, minor: 0 };
	        } else {
	            return null;
	        }
	    },
	
	    getVersionVector: function getVersionVector() {
	        var version = {};
	        _.each(_.keys(widgets), function (name) {
	            version[name] = Widgets.getVersion(name);
	        });
	        return version;
	    },
	
	    getPublicWidgets: function getPublicWidgets() {
	        // TODO(alex): Update underscore.js so that _.pick can take a function.
	        return _.pick(widgets, _.reject(_.keys(widgets), function (name) {
	            return widgets[name].hidden;
	        }));
	    },
	
	    isAccessible: function isAccessible(widgetInfo) {
	        var accessible = widgets[widgetInfo.type].accessible;
	        if (typeof accessible === "function") {
	            return accessible(widgetInfo.options);
	        } else {
	            return !!accessible;
	        }
	    },
	
	    getAllWidgetTypes: function getAllWidgetTypes() {
	        return _.keys(widgets);
	    },
	
	    upgradeWidgetInfoToLatestVersion: function upgradeWidgetInfoToLatestVersion(oldWidgetInfo) {
	        var type = oldWidgetInfo.type;
	        if (!_.isString(type)) {
	            throw new Error("widget type must be a string, but was: " + type);
	        }
	        var widgetExports = widgets[type];
	
	        if (widgetExports == null) {
	            // If we have a widget that isn't registered, we can't upgrade it
	            // TODO(aria): Figure out what the best thing to do here would be
	            return oldWidgetInfo;
	        }
	
	        // Unversioned widgets (pre-July 2014) are all implicitly 0.0
	        var initialVersion = oldWidgetInfo.version || { major: 0, minor: 0 };
	        var latestVersion = widgetExports.version || { major: 0, minor: 0 };
	
	        // If the widget version is later than what we understand (major
	        // version is higher than latest, or major versions are equal and minor
	        // version is higher than latest), don't perform any upgrades.
	        if (initialVersion.major > latestVersion.major || initialVersion.major === latestVersion.major && initialVersion.minor > latestVersion.minor) {
	            return oldWidgetInfo;
	        }
	
	        // We do a clone here so that it's safe to mutate the input parameter
	        // in propUpgrades functions (which I will probably accidentally do at
	        // some point, and we would like to not break when that happens).
	        var newEditorProps = _.clone(oldWidgetInfo.options) || {};
	
	        var upgradePropsMap = widgetExports.propUpgrades || {};
	
	        // Empty props usually mean a newly created widget by the editor,
	        // and are always considerered up-to-date.
	        // Mostly, we'd rather not run upgrade functions on props that are
	        // not complete.
	        if (_.keys(newEditorProps).length !== 0) {
	            // We loop through all the versions after the current version of
	            // the loaded widget, up to and including the latest version of the
	            // loaded widget, and run the upgrade function to bring our loaded
	            // widget's props up to that version.
	            // There is a little subtlety here in that we call
	            // upgradePropsMap[1] to upgrade *to* version 1,
	            // (not from version 1).
	            for (var nextVersion = initialVersion.major + 1; nextVersion <= latestVersion.major; nextVersion++) {
	                if (upgradePropsMap[nextVersion]) {
	                    newEditorProps = upgradePropsMap[nextVersion](newEditorProps);
	                } else if (typeof console !== "undefined" && console.warn) {
	                    // This is a warning because it is unlikely to be hit in
	                    // local testing, and a warning is slightly less scary in
	                    // prod than a `throw new Error`
	                    console.warn("No upgrade found for widget `" + type + "` from " + "major version `" + (nextVersion - 1) + "` to " + "major version `" + nextVersion + "` found. This " + "is necessary to render this `" + type + "` correctly.");
	                    // But try to keep going anyways (yolo!)
	                    // (Throwing an error here would just break the page
	                    // silently anyways, so that doesn't seem much better
	                    // than a halfhearted attempt to continue, however
	                    // shallow...)
	                }
	            }
	        }
	
	        // Minor version upgrades (eg. new optional props) don't have
	        // transform functions. Instead, we fill in the new props with their
	        // defaults.
	        var defaultProps = editors[type].defaultProps;
	        newEditorProps = _.extend({}, defaultProps, newEditorProps);
	
	        var alignment = oldWidgetInfo.alignment;
	
	        // Widgets that support multiple alignments will "lock in" the
	        // alignment to the alignment that would be listed first in the
	        // select box. If the widget only supports one alignment, the
	        // alignment value will likely just end up as "default".
	        if (alignment == null || alignment === "default") {
	            alignment = Widgets.getSupportedAlignments(type)[0];
	        }
	
	        var widgetStatic = oldWidgetInfo.static;
	
	        if (widgetStatic == null) {
	            widgetStatic = DEFAULT_STATIC;
	        }
	
	        return _.extend({}, oldWidgetInfo, {
	            // maintain other info, like type
	            // After upgrading we guarantee that the version is up-to-date
	            version: latestVersion,
	            // Default graded to true (so null/undefined becomes true):
	            graded: oldWidgetInfo.graded != null ? oldWidgetInfo.graded : true,
	            alignment: alignment,
	            static: widgetStatic,
	            options: newEditorProps
	        });
	    },
	
	    getRendererPropsForWidgetInfo: function getRendererPropsForWidgetInfo(widgetInfo, problemNum) {
	        var type = widgetInfo.type;
	        var widgetExports = widgets[type];
	        if (widgetExports == null) {
	            // The widget is not a registered widget
	            // It shouldn't matter what we return here, but for consistency
	            // we return the untransformed options, as if the widget did
	            // not have a transform defined.
	            return widgetInfo.options;
	        }
	        var transform;
	        if (widgetInfo.static) {
	            // There aren't a lot of real places where we'll have to default to
	            // _.identity, but it's theoretically possile if someone changes
	            // the JSON manually / we have to back out static support for a
	            // widget.
	            transform = this.getStaticTransform(type) || _.identity;
	        } else {
	            transform = widgetExports.transform || _.identity;
	        }
	        // widgetInfo.options are the widgetEditor's props:
	        return transform(widgetInfo.options, problemNum);
	    },
	
	    traverseChildWidgets: function traverseChildWidgets(widgetInfo, traverseRenderer) {
	        if (!traverseRenderer) {
	            throw new Error("traverseRenderer must be provided, but was not");
	        }
	
	        if (!widgetInfo || !widgetInfo.type || !widgets[widgetInfo.type]) {
	            return widgetInfo;
	        }
	
	        var widgetExports = widgets[widgetInfo.type];
	        var props = widgetInfo.options;
	
	        if (widgetExports.traverseChildWidgets && props) {
	            var newProps = widgetExports.traverseChildWidgets(props, traverseRenderer);
	            return _.extend({}, widgetInfo, { options: newProps });
	        } else {
	            return widgetInfo;
	        }
	    },
	
	    /**
	     * Handling for the optional alignments for widgets
	     * See widget-container.jsx for details on how alignments are implemented.
	     */
	
	    /**
	     * Returns the list of supported alignments for the given (string) widget
	     * type. This is used primarily at editing time to display the choices
	     * for the user.
	     *
	     * Supported alignments are given as an array of strings in the exports of
	     * a widget's module.
	     */
	    getSupportedAlignments: function getSupportedAlignments(type) {
	        var widgetInfo = widgets[type];
	        return widgetInfo && widgetInfo.supportedAlignments || DEFAULT_SUPPORTED_ALIGNMENTS;
	    },
	
	    /**
	     * For the given (string) widget type, determine the default alignment for
	     * the widget. This is used at rendering time to go from "default" alignment
	     * to the actual alignment displayed on the screen.
	     *
	     * The default alignment is given either as a string (called
	     * `defaultAlignment`) or a function (called `getDefaultAlignment`) on
	     * the exports of a widget's module.
	     */
	    getDefaultAlignment: function getDefaultAlignment(type) {
	        var widgetInfo = widgets[type];
	        var alignment;
	        if (!widgetInfo) {
	            return DEFAULT_ALIGNMENT;
	        }
	
	        if (widgetInfo.getDefaultAlignment) {
	            alignment = widgetInfo.getDefaultAlignment();
	        } else {
	            alignment = widgetInfo.defaultAlignment;
	        }
	        return alignment || DEFAULT_ALIGNMENT;
	    },
	
	    validAlignments: ["block", "inline-block", "inline", "float-left", "float-right", "full-width"],
	
	    /**
	     * Used at startup to fail fast if an alignment given by a widget is
	     * invalid.
	     */
	    // TODO(alex): Change this to run as a testcase (vs. being run at runtime)
	    validateAlignments: function validateAlignments() {
	        _.each(widgets, function (widgetInfo) {
	            if (widgetInfo.defaultAlignment && !_.contains(Widgets.validAlignments, widgetInfo.defaultAlignment)) {
	                throw new Error("Widget '" + widgetInfo.displayName + "' has an invalid defaultAlignment value: " + widgetInfo.defaultAlignment);
	            }
	
	            if (widgetInfo.supportedAlignments) {
	                var unknownAlignments = _.difference(widgetInfo.supportedAlignments, Widgets.validAlignments);
	
	                if (unknownAlignments.length) {
	                    throw new Error("Widget '" + widgetInfo.displayName + "' has an invalid value for supportedAlignments: " + unknownAlignments.join(" "));
	                }
	            }
	        });
	    },
	
	    /**
	     * Handling for static mode for widgets that support it.
	     */
	
	    /**
	     * Returns true iff the widget supports static mode.
	     * A widget implicitly supports static mode if it exports a
	     * staticTransform function.
	     */
	    supportsStaticMode: function supportsStaticMode(type) {
	        var widgetInfo = widgets[type];
	        return widgetInfo && widgetInfo.staticTransform != null;
	    },
	
	    /**
	     * Return the staticTransform function used to convert the editorProps to
	     * the rendered widget state.
	     */
	    getStaticTransform: function getStaticTransform(type) {
	        var widgetInfo = widgets[type];
	        return widgetInfo && widgetInfo.staticTransform;
	    },
	
	    /**
	     * Returns the tracking option for the widget. The default is "",
	     * which means simply to track interactions once. The other available
	     * option is "all" which means to track all interactions.
	     */
	    getTracking: function getTracking(type) {
	        var widgetInfo = widgets[type];
	        return widgetInfo && widgetInfo.tracking || DEFAULT_TRACKING;
	    },
	
	    /**
	     * Returns true if this widget can include lintable markdown text
	     * and supports a highlightLint prop, or false otherwise.
	     */
	    isLintable: function isLintable(type) {
	        var widgetInfo = widgets[type];
	        return widgetInfo && widgetInfo.isLintable || DEFAULT_LINTABLE;
	    }
	};
	
	module.exports = Widgets;

/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {

	/* globals true */
	
	// As new widgets get added here, please also make sure they get added in
	// webapp perseus/traversal.py so they can be properly translated.
	module.exports = [[__webpack_require__(68), true && __webpack_require__(75)], [__webpack_require__(69), true && __webpack_require__(70)], [__webpack_require__(71), true && __webpack_require__(72)], [__webpack_require__(73), true && __webpack_require__(74)]];

/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * This should be called by all clients, specifying whether extra widgets are
	 * needed via `loadExtraWidgets`. It is idempotent, so it's not a problem to
	 * call it multiple times.
	 *
	 * skipMathJax:
	 *   if false/undefined, MathJax will be configured, and the
	 *   promise will wait for MathJax to load (if it hasn't already).
	 * loadExtraWidgets:
	 *   if true, `extra-widgets` will be required. The client must have already
	 *   loaded the file, either by using the full perseus bundle
	 *   `/build/perseus.js`, or by loading `/build/perseus-extras.js` prior to
	 *   calling `Perseus.init()`.
	 */
	
	var init = function init(options) {
	    // Pass skipMathJax: true if MathJax is already loaded and configured.
	    var skipMathJax = options.skipMathJax;
	
	    var widgetsDeferred = $.Deferred();
	
	    // HACK(charlie): To maintain backwards compatibility, only exclude the
	    // extra widgets if the parameter is explicitly falsey (rather than merely
	    // undefined). We should probably bump the Perseus major version number
	    // (since this is a breaking change in the API) but this is a more
	    // lightweight fix that will get exercises working in our mobile apps
	    // immediately.
	    if (options.loadExtraWidgets === undefined || options.loadExtraWidgets) {
	        var Widgets = __webpack_require__(31);
	        __webpack_require__.e/*nsure*/(1, function (require) {
	            var extraWidgets = __webpack_require__(51);
	            Widgets.registerMany(extraWidgets);
	            widgetsDeferred.resolve();
	        }, 0);
	    } else {
	        widgetsDeferred.resolve();
	    }
	
	    var mathJaxDeferred = $.Deferred();
	
	    if (skipMathJax) {
	        mathJaxDeferred.resolve();
	    } else {
	        MathJax.Hub.Config({
	            messageStyle: "none",
	            skipStartupTypeset: "none",
	            "HTML-CSS": {
	                availableFonts: ["TeX"],
	                imageFont: null,
	                scale: 100,
	                showMathMenu: false
	            }
	        });
	
	        MathJax.Hub.Configured();
	        MathJax.Hub.Queue(mathJaxDeferred.resolve);
	    }
	
	    return widgetsDeferred.then(function () {
	        return mathJaxDeferred;
	    });
	};
	
	module.exports = init;

/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	/**
	 * An article renderer. Articles are long-form pieces of content,
	 * composed of multiple (Renderer) sections concatenated together.
	 */
	
	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var classNames = __webpack_require__(86);
	
	var Util = __webpack_require__(17);
	var ApiOptions = __webpack_require__(12).Options;
	var ApiClassNames = __webpack_require__(12).ClassNames;
	var Renderer = __webpack_require__(37);
	var ProvideKeypad = __webpack_require__(65);
	
	var Gorgon = __webpack_require__(41);
	
	var _require = __webpack_require__(52),
	    linterContextProps = _require.linterContextProps,
	    linterContextDefault = _require.linterContextDefault;
	
	var rendererProps = React.PropTypes.shape({
	    content: React.PropTypes.string,
	    widgets: React.PropTypes.object,
	    images: React.PropTypes.object
	});
	
	var ArticleRenderer = React.createClass({
	    displayName: "ArticleRenderer",
	
	    propTypes: _extends({}, ProvideKeypad.propTypes, {
	        apiOptions: React.PropTypes.shape({
	            onFocusChange: React.PropTypes.func,
	            isMobile: React.PropTypes.bool
	        }),
	        json: React.PropTypes.oneOfType([rendererProps, React.PropTypes.arrayOf(rendererProps)]).isRequired,
	
	        // Whether to use the new Bibliotron styles for articles
	        useNewStyles: React.PropTypes.bool,
	        linterContext: linterContextProps,
	        legacyPerseusLint: React.PropTypes.arrayOf(React.PropTypes.string)
	    }),
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            apiOptions: {},
	            useNewStyles: false,
	            linterContext: linterContextDefault
	        };
	    },
	    getInitialState: function getInitialState() {
	        return ProvideKeypad.getInitialState();
	    },
	    componentDidMount: function componentDidMount() {
	        ProvideKeypad.componentDidMount.call(this);
	        this._currentFocus = null;
	    },
	    shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {
	        return nextProps !== this.props || nextState !== this.state;
	    },
	    componentWillUnmount: function componentWillUnmount() {
	        ProvideKeypad.componentWillUnmount.call(this);
	    },
	    keypadElement: function keypadElement() {
	        return ProvideKeypad.keypadElement.call(this);
	    },
	    _handleFocusChange: function _handleFocusChange(newFocusPath, oldFocusPath) {
	        // TODO(charlie): DRY this up--some of this logic is repeated in
	        // ItemRenderer.
	        if (newFocusPath) {
	            this._setCurrentFocus(newFocusPath);
	        } else {
	            this._onRendererBlur(oldFocusPath);
	        }
	    },
	    _setCurrentFocus: function _setCurrentFocus(newFocusPath) {
	        var keypadElement = this.keypadElement();
	
	        var prevFocusPath = this._currentFocus;
	        this._currentFocus = newFocusPath;
	
	        // Use the section prefix to extract the relevant Renderer's input
	        // paths, so as to check whether the focused path represents an
	        // input.
	        var didFocusInput = false;
	        if (this._currentFocus) {
	            var _currentFocus = this._currentFocus,
	                sectionRef = _currentFocus[0],
	                focusPath = _currentFocus.slice(1);
	
	            var inputPaths = this.refs[sectionRef].getInputPaths();
	            didFocusInput = inputPaths.some(function (inputPath) {
	                return Util.inputPathsEqual(inputPath, focusPath);
	            });
	        }
	
	        if (this.props.apiOptions.onFocusChange != null) {
	            this.props.apiOptions.onFocusChange(this._currentFocus, prevFocusPath, didFocusInput && keypadElement && ReactDOM.findDOMNode(keypadElement));
	        }
	
	        if (keypadElement) {
	            if (didFocusInput) {
	                keypadElement.activate();
	            } else {
	                keypadElement.dismiss();
	            }
	        }
	    },
	    _onRendererBlur: function _onRendererBlur(blurPath) {
	        var _this = this;
	
	        var blurringFocusPath = this._currentFocus;
	
	        // Failsafe: abort if ID is different, because focus probably happened
	        // before blur.
	        if (!Util.inputPathsEqual(blurPath, blurringFocusPath)) {
	            return;
	        }
	
	        // Wait until after any new focus events fire this tick before declaring
	        // that nothing is focused, since if there were a focus change across
	        // sections, we could receive the blur before the focus.
	        setTimeout(function () {
	            if (Util.inputPathsEqual(_this._currentFocus, blurringFocusPath)) {
	                _this._setCurrentFocus(null);
	            }
	        });
	    },
	    blur: function blur() {
	        if (this._currentFocus) {
	            var _currentFocus2 = this._currentFocus,
	                sectionRef = _currentFocus2[0],
	                inputPath = _currentFocus2.slice(1);
	
	            this.refs[sectionRef].blurPath(inputPath);
	        }
	    },
	    _sections: function _sections() {
	        return Array.isArray(this.props.json) ? this.props.json : [this.props.json];
	    },
	    render: function render() {
	        var _classNames,
	            _this2 = this;
	
	        var apiOptions = _extends({}, ApiOptions.defaults, this.props.apiOptions, {
	            isArticle: true
	        });
	
	        var classes = classNames((_classNames = {
	            "framework-perseus": true,
	            "perseus-article": true,
	            "bibliotron-article": this.props.useNewStyles
	        }, _classNames[ApiClassNames.MOBILE] = apiOptions.isMobile, _classNames));
	
	        // TODO(alex): Add mobile api functions and pass them down here
	        var sections = this._sections().map(function (section, i) {
	            var refForSection = "section-" + i;
	            return React.createElement(
	                "div",
	                { key: i, className: "clearfix" },
	                React.createElement(Renderer, _extends({}, section, {
	                    ref: refForSection,
	                    key: i,
	                    key_: i,
	                    keypadElement: _this2.keypadElement(),
	                    apiOptions: _extends({}, apiOptions, {
	                        onFocusChange: function onFocusChange(newFocusPath, oldFocusPath) {
	                            // Prefix the paths with the relevant section,
	                            // so as to allow us to distinguish between
	                            // equivalently-named inputs across Renderers.
	                            _this2._handleFocusChange(newFocusPath && [refForSection].concat(newFocusPath), oldFocusPath && [refForSection].concat(oldFocusPath));
	                        }
	                    }),
	                    linterContext: Gorgon.pushContextStack(_this2.props.linterContext, "article"),
	                    legacyPerseusLint: _this2.props.legacyPerseusLint
	                }))
	            );
	        });
	
	        return React.createElement(
	            "div",
	            { className: classes },
	            sections
	        );
	    }
	});
	
	module.exports = ArticleRenderer;

/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/**
	 * A copy of the ItemRenderer which renders its question renderer and hints
	 * renderer normally instead of ReactDOM.render()ing them into elements in the
	 * DOM.
	 *
	 * This allows this component to be used in server-rendering of a perseus
	 * exercise.
	 */
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var _ = __webpack_require__(56);
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var ApiOptions = __webpack_require__(12).Options;
	var HintsRenderer = __webpack_require__(36);
	var ProvideKeypad = __webpack_require__(65);
	var Renderer = __webpack_require__(37);
	var Util = __webpack_require__(17);
	
	var _require2 = __webpack_require__(80),
	    mapObject = _require2.mapObject;
	
	var RP = React.PropTypes;
	
	var ItemRenderer = React.createClass({
	    displayName: "ItemRenderer",
	
	    propTypes: _extends({}, ProvideKeypad.propTypes, {
	        apiOptions: RP.any,
	        hintsVisible: RP.number,
	        item: RP.shape({
	            answerArea: RP.shape({
	                calculator: RP.bool,
	                chi2Table: RP.bool,
	                periodicTable: RP.bool,
	                tTable: RP.bool,
	                zTable: RP.bool
	            }),
	            hints: RP.arrayOf(RP.object),
	            question: RP.object
	        }).isRequired,
	        problemNum: RP.number,
	        reviewMode: RP.bool
	    }),
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            apiOptions: {} // a deep default is done in `this.update()`
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return _extends({}, ProvideKeypad.getInitialState(), {
	            questionCompleted: false,
	            questionHighlightedWidgets: []
	        });
	    },
	
	    componentDidMount: function componentDidMount() {
	        ProvideKeypad.componentDidMount.call(this);
	        this._currentFocus = null;
	    },
	
	    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        this.setState({
	            questionHighlightedWidgets: []
	        });
	    },
	
	    componentDidUpdate: function componentDidUpdate() {
	        if (this.props.apiOptions.answerableCallback) {
	            var isAnswerable = this.questionRenderer.emptyWidgets().length === 0;
	            this.props.apiOptions.answerableCallback(isAnswerable);
	        }
	    },
	
	    componentWillUnmount: function componentWillUnmount() {
	        ProvideKeypad.componentWillUnmount.call(this);
	    },
	    keypadElement: function keypadElement() {
	        return ProvideKeypad.keypadElement.call(this);
	    },
	
	
	    _handleFocusChange: function _handleFocusChange(newFocus, oldFocus) {
	        if (newFocus != null) {
	            this._setCurrentFocus(newFocus);
	        } else {
	            this._onRendererBlur(oldFocus);
	        }
	    },
	
	    // Sets the current focus path and element and
	    // send an onChangeFocus event back to our parent.
	    _setCurrentFocus: function _setCurrentFocus(newFocus) {
	        var _this = this;
	
	        var keypadElement = this.keypadElement();
	
	        // By the time this happens, newFocus cannot be a prefix of
	        // prevFocused, since we must have either been called from
	        // an onFocusChange within a renderer, which is only called when
	        // this is not a prefix, or between the question and answer areas,
	        // which can never prefix each other.
	        var prevFocus = this._currentFocus;
	        this._currentFocus = newFocus;
	
	        // Determine whether the newly focused path represents an input.
	        var inputPaths = this.getInputPaths();
	        var didFocusInput = this._currentFocus && inputPaths.some(function (inputPath) {
	            return Util.inputPathsEqual(inputPath, _this._currentFocus);
	        });
	
	        if (this.props.apiOptions.onFocusChange != null) {
	            this.props.apiOptions.onFocusChange(this._currentFocus, prevFocus, didFocusInput && keypadElement && ReactDOM.findDOMNode(keypadElement));
	        }
	
	        if (keypadElement) {
	            if (didFocusInput) {
	                keypadElement.activate();
	            } else {
	                keypadElement.dismiss();
	            }
	        }
	    },
	
	    _onRendererBlur: function _onRendererBlur(blurPath) {
	        var _this2 = this;
	
	        var blurringFocusPath = this._currentFocus;
	
	        // Failsafe: abort if ID is different, because focus probably happened
	        // before blur
	        if (!_.isEqual(blurPath, blurringFocusPath)) {
	            return;
	        }
	
	        // Wait until after any new focus events fire this tick before
	        // declaring that nothing is focused.
	        // If a different widget was focused, we'll see an onBlur event
	        // now, but then an onFocus event on a different element before
	        // this callback is executed
	        _.defer(function () {
	            if (_.isEqual(_this2._currentFocus, blurringFocusPath)) {
	                _this2._setCurrentFocus(null);
	            }
	        });
	    },
	
	    /**
	     * Accepts a question area widgetId, or an answer area widgetId of
	     * the form "answer-input-number 1", or the string "answer-area"
	     * for the whole answer area (if the answer area is a single widget).
	     */
	    _setWidgetProps: function _setWidgetProps(widgetId, newProps, callback) {
	        this.questionRenderer._setWidgetProps(widgetId, newProps, callback);
	    },
	
	    _handleAPICall: function _handleAPICall(functionName, path) {
	        // Get arguments to pass to function, including `path`
	        var functionArgs = _.rest(arguments);
	        var caller = this.questionRenderer;
	
	        return caller[functionName].apply(caller, functionArgs);
	    },
	
	    setInputValue: function setInputValue(path, newValue, focus) {
	        return this._handleAPICall("setInputValue", path, newValue, focus);
	    },
	
	    focusPath: function focusPath(path) {
	        return this._handleAPICall("focusPath", path);
	    },
	
	    blurPath: function blurPath(path) {
	        return this._handleAPICall("blurPath", path);
	    },
	
	    getDOMNodeForPath: function getDOMNodeForPath(path) {
	        return this._handleAPICall("getDOMNodeForPath", path);
	    },
	
	    getGrammarTypeForPath: function getGrammarTypeForPath(path) {
	        return this._handleAPICall("getGrammarTypeForPath", path);
	    },
	
	    getInputPaths: function getInputPaths() {
	        var questionAreaInputPaths = this.questionRenderer.getInputPaths();
	        return questionAreaInputPaths;
	    },
	
	    handleInteractWithWidget: function handleInteractWithWidget(widgetId) {
	        var withRemoved = _.difference(this.state.questionHighlightedWidgets, [widgetId]);
	        this.setState({
	            questionCompleted: false,
	            questionHighlightedWidgets: withRemoved
	        });
	
	        if (this.props.apiOptions.interactionCallback) {
	            this.props.apiOptions.interactionCallback();
	        }
	    },
	
	    focus: function focus() {
	        return this.questionRenderer.focus();
	    },
	
	    blur: function blur() {
	        if (this._currentFocus) {
	            this.blurPath(this._currentFocus);
	        }
	    },
	
	    getNumHints: function getNumHints() {
	        return this.props.item.hints.length;
	    },
	
	    /**
	     * Grades the item.
	     *
	     * Returns a KE-style score of {
	     *     empty: bool,
	     *     correct: bool,
	     *     message: string|null,
	     *     guess: Array
	     * }
	     */
	    scoreInput: function scoreInput() {
	        var guessAndScore = this.questionRenderer.guessAndScore();
	        var guess = guessAndScore[0];
	        var score = guessAndScore[1];
	
	        // Continue to include an empty guess for the now defunct answer area.
	        // TODO(alex): Check whether we rely on the format here for
	        //             analyzing ProblemLogs. If not, remove this layer.
	        var maxCompatGuess = [guess, []];
	
	        var keScore = Util.keScoreFromPerseusScore(score, maxCompatGuess, this.questionRenderer.getSerializedState());
	
	        var emptyQuestionAreaWidgets = this.questionRenderer.emptyWidgets();
	
	        this.setState({
	            questionCompleted: keScore.correct,
	            questionHighlightedWidgets: emptyQuestionAreaWidgets
	        });
	
	        return keScore;
	    },
	
	    /**
	     * Returns an array of all widget IDs in the order they occur in
	     * the question content.
	     */
	    getWidgetIds: function getWidgetIds() {
	        return this.questionRenderer.getWidgetIds();
	    },
	
	    /**
	     * Returns an object mapping from widget ID to KE-style score.
	     * The keys of this object are the values of the array returned
	     * from `getWidgetIds`.
	     */
	    scoreWidgets: function scoreWidgets() {
	        var qScore = this.questionRenderer.scoreWidgets();
	        var qGuess = this.questionRenderer.getUserInputForWidgets();
	        var state = this.questionRenderer.getSerializedState();
	        return mapObject(qScore, function (score, id) {
	            return Util.keScoreFromPerseusScore(score, qGuess[id], state);
	        });
	    },
	
	    /**
	     * Get a representation of the current state of the item.
	     */
	    getSerializedState: function getSerializedState() {
	        return {
	            question: this.questionRenderer.getSerializedState(),
	            hints: this.hintsRenderer.getSerializedState()
	        };
	    },
	
	    restoreSerializedState: function restoreSerializedState(state, callback) {
	        // We need to wait for both the question renderer and the hints
	        // renderer to finish restoring their states.
	        var numCallbacks = 2;
	        var fireCallback = function fireCallback() {
	            --numCallbacks;
	            if (callback && numCallbacks === 0) {
	                callback();
	            }
	        };
	
	        this.questionRenderer.restoreSerializedState(state.question, fireCallback);
	        this.hintsRenderer.restoreSerializedState(state.hints, fireCallback);
	    },
	
	    showRationalesForCurrentlySelectedChoices: function showRationalesForCurrentlySelectedChoices() {
	        this.questionRenderer.showRationalesForCurrentlySelectedChoices();
	    },
	    deselectIncorrectSelectedChoices: function deselectIncorrectSelectedChoices() {
	        this.questionRenderer.deselectIncorrectSelectedChoices();
	    },
	
	
	    render: function render() {
	        var _this3 = this;
	
	        var apiOptions = _extends({}, ApiOptions.defaults, this.props.apiOptions, {
	            onFocusChange: this._handleFocusChange
	        });
	
	        var questionRenderer = React.createElement(Renderer, _extends({
	            keypadElement: this.keypadElement(),
	            problemNum: this.props.problemNum,
	            onInteractWithWidget: this.handleInteractWithWidget,
	            highlightedWidgets: this.state.questionHighlightedWidgets,
	            apiOptions: apiOptions,
	            questionCompleted: this.state.questionCompleted,
	            reviewMode: this.props.reviewMode,
	            ref: function ref(elem) {
	                return _this3.questionRenderer = elem;
	            }
	        }, this.props.item.question));
	
	        var hintsRenderer = React.createElement(HintsRenderer, {
	            hints: this.props.item.hints,
	            hintsVisible: this.props.hintsVisible,
	            apiOptions: apiOptions,
	            ref: function ref(elem) {
	                return _this3.hintsRenderer = elem;
	            }
	        });
	
	        return React.createElement(
	            "div",
	            null,
	            React.createElement(
	                "div",
	                null,
	                questionRenderer
	            ),
	            React.createElement(
	                "div",
	                {
	                    className:
	                    // Avoid adding any horizontal padding when applying the
	                    // mobile hint styles, which are flush to the left.
	                    // NOTE(charlie): We may still want to apply this
	                    // padding for desktop exercises.
	                    !apiOptions.isMobile && css(styles.hintsContainer)
	                },
	                hintsRenderer
	            )
	        );
	    }
	});
	
	var styles = StyleSheet.create({
	    hintsContainer: {
	        marginLeft: 50
	    }
	});
	
	module.exports = ItemRenderer;

/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {

	var _mobileHintStylesHint, _mobileHintStylesGetA, _mobileHintStylesPlus;
	
	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var classnames = __webpack_require__(86);
	var _ = __webpack_require__(56);
	var i18n = window.i18n;
	
	var HintRenderer = __webpack_require__(38);
	var SvgImage = __webpack_require__(67);
	var ApiOptionsProps = __webpack_require__(66);
	
	var mediaQueries = __webpack_require__(76);
	var sharedStyles = __webpack_require__(78);
	
	var _require2 = __webpack_require__(77),
	    baseUnitPx = _require2.baseUnitPx,
	    hintBorderWidth = _require2.hintBorderWidth,
	    kaGreen = _require2.kaGreen,
	    gray85 = _require2.gray85,
	    gray17 = _require2.gray17;
	
	var Gorgon = __webpack_require__(41);
	
	var _require3 = __webpack_require__(52),
	    linterContextProps = _require3.linterContextProps,
	    linterContextDefault = _require3.linterContextDefault;
	
	var HintsRenderer = React.createClass({
	    displayName: "HintsRenderer",
	
	    propTypes: _extends({}, ApiOptionsProps.propTypes, {
	        className: React.PropTypes.string,
	        hints: React.PropTypes.arrayOf(React.PropTypes.any),
	        hintsVisible: React.PropTypes.number,
	        findExternalWidgets: React.PropTypes.func,
	        linterContext: linterContextProps
	    }),
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            linterContext: linterContextDefault
	        };
	    },
	
	    componentDidMount: function componentDidMount() {
	        this._cacheHintImages();
	    },
	
	    componentDidUpdate: function componentDidUpdate(prevProps, prevState) {
	        if (!_.isEqual(prevProps.hints, this.props.hints) || prevProps.hintsVisible !== this.props.hintsVisible) {
	            this._cacheHintImages();
	        }
	
	        // When a new hint is displayed we immediately focus it
	        if (prevProps.hintsVisible < this.props.hintsVisible) {
	            var pos = this.props.hintsVisible - 1;
	            ReactDOM.findDOMNode(this.refs["hintRenderer" + pos]).focus();
	        }
	    },
	
	    _hintsVisible: function _hintsVisible() {
	        if (this.props.hintsVisible == null || this.props.hintsVisible === -1) {
	            return this.props.hints.length;
	        } else {
	            return this.props.hintsVisible;
	        }
	    },
	
	    _cacheImagesInHint: function _cacheImagesInHint(hint) {
	        _.each(hint.images, function (data, src) {
	            var image = new Image();
	            image.src = SvgImage.getRealImageUrl(src);
	        });
	    },
	
	    _cacheHintImages: function _cacheHintImages() {
	        // Only cache images in the first hint at the start. When hints are
	        // taken, cache images in the rest of the hints
	        if (this._hintsVisible() > 0) {
	            _.each(this.props.hints, this._cacheImagesInHint);
	        } else if (this.props.hints.length > 0) {
	            this._cacheImagesInHint(this.props.hints[0]);
	        }
	    },
	
	    getApiOptions: function getApiOptions() {
	        return ApiOptionsProps.getApiOptions.call(this);
	    },
	
	
	    getSerializedState: function getSerializedState() {
	        var _this = this;
	
	        return _.times(this._hintsVisible(), function (i) {
	            return _this.refs["hintRenderer" + i].getSerializedState();
	        });
	    },
	
	    restoreSerializedState: function restoreSerializedState(state, callback) {
	        var _this2 = this;
	
	        // We need to wait until all the renderers are finished restoring their
	        // state before we fire our callback.
	        var numCallbacks = 1;
	        var fireCallback = function fireCallback() {
	            --numCallbacks;
	            if (callback && numCallbacks === 0) {
	                callback();
	            }
	        };
	
	        _.each(state, function (hintState, i) {
	            var hintRenderer = _this2.refs["hintRenderer" + i];
	            // This is not ideal in that it doesn't restore state
	            // if the hint isn't visible, but we can't exactly restore
	            // the state to an unmounted renderer, so...
	            // If you want to restore state to hints, make sure to
	            // have the appropriate number of hints visible already.
	            if (hintRenderer) {
	                ++numCallbacks;
	                hintRenderer.restoreSerializedState(hintState, fireCallback);
	            }
	        });
	
	        // This makes sure that the callback is fired if there aren't any
	        // mounted renderers.
	        fireCallback();
	    },
	
	    render: function render() {
	        var _this3 = this;
	
	        var apiOptions = this.getApiOptions();
	        var hintsVisible = this._hintsVisible();
	        var hints = [];
	        this.props.hints.slice(0, hintsVisible).forEach(function (hint, i) {
	            var lastHint = i === _this3.props.hints.length - 1 && !/\*\*/.test(hint.content);
	            var lastRendered = i === hintsVisible - 1;
	
	            var renderer = React.createElement(HintRenderer, {
	                lastHint: lastHint,
	                lastRendered: lastRendered,
	                hint: hint,
	                pos: i,
	                totalHints: _this3.props.hints.length,
	                ref: "hintRenderer" + i,
	                key: "hintRenderer" + i,
	                apiOptions: apiOptions,
	                findExternalWidgets: _this3.props.findExternalWidgets,
	                linterContext: Gorgon.pushContextStack(_this3.props.linterContext, "hints[" + i + "]")
	            });
	
	            if (hint.replace && hints.length > 0) {
	                hints[hints.length - 1] = renderer;
	            } else {
	                hints.push(renderer);
	            }
	        });
	
	        var showGetAnotherHint = apiOptions.getAnotherHint && hintsVisible > 0 && hintsVisible < this.props.hints.length;
	        var hintRatioCopy = "(" + hintsVisible + "/" + this.props.hints.length + ")";
	
	        var classNames = classnames(this.props.className, apiOptions.isMobile && hintsVisible > 0 && css(styles.mobileHintStylesHintsRenderer));
	
	        return React.createElement(
	            "div",
	            { className: classNames },
	            apiOptions.isMobile && hintsVisible > 0 && React.createElement(
	                "div",
	                {
	                    className: css(styles.mobileHintStylesHintTitle, sharedStyles.responsiveLabel)
	                },
	                i18n._("Hints")
	            ),
	            hints,
	            showGetAnotherHint && React.createElement(
	                "button",
	                {
	                    rel: "button",
	                    className: css(styles.linkButton, styles.getAnotherHintButton, apiOptions.isMobile && styles.mobileHintStylesGetAnotherHintButton),
	                    onClick: function onClick(evt) {
	                        evt.preventDefault();
	                        evt.stopPropagation();
	                        apiOptions.getAnotherHint();
	                    }
	                },
	                React.createElement(
	                    "span",
	                    {
	                        className: css(styles.plusText, apiOptions.isMobile && styles.mobileHintStylesPlusText)
	                    },
	                    "+"
	                ),
	                React.createElement(
	                    "span",
	                    { className: css(styles.getAnotherHintText) },
	                    i18n._("Get another hint"),
	                    " ",
	                    hintRatioCopy
	                )
	            )
	        );
	    }
	});
	
	var hintIndentation = baseUnitPx + hintBorderWidth;
	
	var styles = StyleSheet.create({
	    rendererMargins: {
	        marginTop: baseUnitPx
	    },
	
	    linkButton: {
	        cursor: "pointer",
	        border: "none",
	        backgroundColor: "transparent",
	        fontSize: "100%",
	        fontFamily: "inherit",
	        fontWeight: "bold",
	        color: kaGreen,
	        padding: 0,
	        position: "relative"
	    },
	
	    plusText: {
	        fontSize: 20,
	        position: "absolute",
	        top: -3,
	        left: 0
	    },
	    getAnotherHintText: {
	        marginLeft: 16
	    },
	
	    mobileHintStylesHintsRenderer: {
	        marginTop: 4 * baseUnitPx,
	        border: "solid " + gray85,
	        borderWidth: "1px 0 0 0",
	
	        position: "relative",
	        ":before": {
	            content: '""',
	            display: "table",
	            clear: "both"
	        },
	        ":after": {
	            content: '""',
	            display: "table",
	            clear: "both"
	        }
	    },
	
	    mobileHintStylesHintTitle: (_mobileHintStylesHint = {
	        fontFamily: "inherit",
	        fontStyle: "normal",
	        fontWeight: "bold",
	        color: gray17,
	
	        paddingTop: baseUnitPx,
	        paddingBottom: 1.5 * baseUnitPx
	
	    }, _mobileHintStylesHint[mediaQueries.lgOrSmaller] = {
	        paddingLeft: 0
	    }, _mobileHintStylesHint[mediaQueries.smOrSmaller] = {
	        // On phones, ensure that the button is aligned with the hint body
	        // content, which is inset at the standard `baseUnitPx`, plus an
	        // additional `hintBorderWidth`.
	        paddingLeft: hintIndentation
	    }, _mobileHintStylesHint),
	
	    getAnotherHintButton: {
	        marginTop: 1.5 * baseUnitPx
	    },
	
	    mobileHintStylesGetAnotherHintButton: (_mobileHintStylesGetA = {}, _mobileHintStylesGetA[mediaQueries.lgOrSmaller] = {
	        paddingLeft: 0
	    }, _mobileHintStylesGetA[mediaQueries.smOrSmaller] = {
	        // As with the title, on phones, ensure that the button is aligned
	        // with the hint body content.
	        paddingLeft: hintIndentation
	    }, _mobileHintStylesGetA),
	
	    mobileHintStylesPlusText: (_mobileHintStylesPlus = {}, _mobileHintStylesPlus[mediaQueries.lgOrSmaller] = {
	        left: 0
	    }, _mobileHintStylesPlus[mediaQueries.smOrSmaller] = {
	        left: hintIndentation
	    }, _mobileHintStylesPlus)
	});
	
	module.exports = HintsRenderer;

/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var _notGorgon = __webpack_require__(201);
	
	var _notGorgon2 = _interopRequireDefault(_notGorgon);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	/* eslint-disable max-lines, no-var */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	/* globals KA */
	var $ = __webpack_require__(169);
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var _ = __webpack_require__(56);
	var classNames = __webpack_require__(86);
	
	var JiptParagraphs = __webpack_require__(202);
	
	var _require = __webpack_require__(29),
	    maybeUnescape = _require.maybeUnescape;
	
	var PerseusMarkdown = __webpack_require__(49);
	var QuestionParagraph = __webpack_require__(203);
	var SvgImage = __webpack_require__(67);
	var TeX = __webpack_require__(178);
	var WidgetContainer = __webpack_require__(204);
	var Widgets = __webpack_require__(31);
	
	var Util = __webpack_require__(17);
	var ApiOptionsProps = __webpack_require__(66);
	var ApiClassNames = __webpack_require__(12).ClassNames;
	var Zoomable = __webpack_require__(205);
	var Deferred = __webpack_require__(206);
	var preprocessTex = __webpack_require__(91);
	
	var Gorgon = __webpack_require__(41); // The linter engine
	
	var _require2 = __webpack_require__(52),
	    linterContextProps = _require2.linterContextProps,
	    linterContextDefault = _require2.linterContextDefault;
	
	// The i18n linter
	
	var keypadElementPropType = __webpack_require__(257).propTypes.keypadElementPropType;
	
	var _require3 = __webpack_require__(80),
	    mapObject = _require3.mapObject,
	    mapObjectFromArray = _require3.mapObjectFromArray;
	
	var rContainsNonWhitespace = /\S/;
	var rImageURL = /(web\+graphie|https):\/\/[^\s]*/;
	
	var noopOnRender = function noopOnRender() {};
	
	if (typeof KA !== "undefined" && KA.language === "en-pt") {
	    // When using crowdin's jipt (Just in place translation), we need to keep a
	    // registry of crowdinId's to component so that we can update the
	    // component's state as the translator enters their translation.
	    window.PerseusTranslationComponents = [];
	
	    if (!KA.jipt_dom_insert_checks) {
	        KA.jipt_dom_insert_checks = [];
	    }
	
	    // We add a function that will get called whenever jipt says the dom needs
	    // to be updated
	    KA.jipt_dom_insert_checks.push(function (text, node, attribute) {
	        var $node = $(node);
	        var index = $node.data("perseus-component-index");
	        var paragraphIndex = $node.data("perseus-paragraph-index");
	        // We only update if we had added an index onto the node's data.
	        if (node && typeof index !== "undefined") {
	            var component = window.PerseusTranslationComponents[index];
	
	            if (!component) {
	                // The component has disappeared, so we tell jipt not to try
	                // and insert anything
	                return false;
	            }
	            // Jipt sometimes sends down the escaped translation, so we need to
	            // unescape \\t to \t among other characters here
	            text = maybeUnescape(text);
	
	            component.replaceJiptContent(text, paragraphIndex);
	
	            // Return false to tell jipt not to insert anything into the DOM
	            // itself, otherwise it will mess up what React expects there to be
	            return false;
	        }
	        // The string updated wasn't part of perseus, so we tell jipt to just
	        // insert the translation as-is.
	        return text;
	    });
	}
	
	var SHOULD_CLEAR_WIDGETS_PROP_LIST = ["content", "problemNum", "widgets"];
	
	// Check if one focus path / id path is a prefix of another
	// The focus path null will never be a prefix of any non-null
	// path, since it represents no focus.
	// Otherwise, prefix is calculated by whether every array
	// element in the prefix is present in the same position in the
	// wholeArray path.
	var isIdPathPrefix = function isIdPathPrefix(prefixArray, wholeArray) {
	    if (prefixArray === null || wholeArray === null) {
	        return prefixArray === wholeArray;
	    }
	    return _.every(prefixArray, function (elem, i) {
	        return _.isEqual(elem, wholeArray[i]);
	    });
	};
	
	/**
	 * Wrapper for the trackInteraction apiOption.
	 *
	 * @param trackApi Original API
	 * @param widgetType String name of the widget type
	 * @param widgetID String ID of the widget instance
	 * @param setting string setting for tracking (either "" for track once or
	 *          "all")
	 */
	var InteractionTracker = function InteractionTracker(trackApi, widgetType, widgetID, setting) {
	    if (!trackApi) {
	        this.track = this._noop;
	    } else {
	        this._tracked = false;
	        this.trackApi = trackApi;
	        this.widgetType = widgetType;
	        this.widgetID = widgetID;
	        this.setting = setting;
	        this.track = this._track.bind(this);
	    }
	};
	
	/**
	 * Function that actually calls the API to mark the interaction. This is
	 * private. The public version is just `.track` and is bound to this object
	 * for easy use in other context.
	 *
	 * @param extraData Any extra data to track about the event.
	 * @private
	 */
	InteractionTracker.prototype._track = function (extraData) {
	    if (this._tracked && !this.setting) {
	        return;
	    }
	    this._tracked = true;
	    this.trackApi(_extends({
	        type: this.widgetType,
	        id: this.widgetID
	    }, extraData));
	};
	
	/**
	 * This alternate version of `.track` does nothing as an optimization.
	 *
	 * @private
	 */
	InteractionTracker.prototype._noop = function () {};
	
	var Renderer = React.createClass({
	    displayName: "Renderer",
	
	    propTypes: _extends({}, ApiOptionsProps.propTypes, {
	        alwaysUpdate: React.PropTypes.bool,
	        findExternalWidgets: React.PropTypes.func,
	        highlightedWidgets: React.PropTypes.arrayOf(React.PropTypes.any),
	        ignoreMissingWidgets: React.PropTypes.bool,
	        images: React.PropTypes.any,
	        keypadElement: keypadElementPropType,
	        onInteractWithWidget: React.PropTypes.func,
	        onRender: React.PropTypes.func,
	        problemNum: React.PropTypes.number,
	        questionCompleted: React.PropTypes.bool,
	        reviewMode: React.PropTypes.bool,
	
	        serializedState: React.PropTypes.any,
	        // Callback which is called when serialized state changes with the new
	        // serialized state.
	        onSerializedStateUpdated: React.PropTypes.func,
	
	        // If linterContext.highlightLint is true, then content will be passed
	        // to the linter and any warnings will be highlighted in the rendered
	        // output.
	        linterContext: linterContextProps,
	
	        legacyPerseusLint: React.PropTypes.arrayOf(React.PropTypes.string)
	    }),
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            content: "",
	            widgets: {},
	            images: {},
	            // TODO(aria): Remove this now that it is true everywhere
	            // (here and in perseus-i18n)
	            ignoreMissingWidgets: true,
	            highlightedWidgets: [],
	            // onRender may be called multiple times per render, for example
	            // if there are multiple images or TeX pieces within `content`.
	            // It is a good idea to debounce any functions passed here.
	            questionCompleted: false,
	            onRender: noopOnRender,
	            onInteractWithWidget: function onInteractWithWidget() {},
	            findExternalWidgets: function findExternalWidgets() {
	                return [];
	            },
	            alwaysUpdate: false,
	            reviewMode: false,
	            serializedState: null,
	            onSerializedStateUpdated: function onSerializedStateUpdated() {},
	            linterContext: linterContextDefault
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return _.extend({
	            jiptContent: null,
	            // The i18n linter.
	            // TODO(joshuan): If this becomes an ES6 class, move to a
	            // member variable.
	            notGorgon: new _notGorgon2.default(),
	            // NotGorgon is async and currently does not contain a location.
	            // This is a list of error strings NotGorgon detected on its last
	            // run.
	            notGorgonLintErrors: []
	        }, this._getInitialWidgetState());
	    },
	
	    componentDidMount: function componentDidMount() {
	        this.handleRender({});
	        this._currentFocus = null;
	
	        this._rootNode = ReactDOM.findDOMNode(this);
	        this._isMounted = true;
	
	        // TODO(emily): actually make the serializedState prop work like a
	        // controlled prop, instead of manually calling .restoreSerializedState
	        // at the right times.
	        if (this.props.serializedState) {
	            this.restoreSerializedState(this.props.serializedState);
	        }
	
	        if (this.props.linterContext.highlightLint) {
	            // Get i18n lint errors asynchronously. If there are lint errors,
	            // this component will be rerendered.
	            this.state.notGorgon.runLinter(this.props.content, this.handleNotGorgonLintErrors);
	        }
	    },
	
	    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        if (!_.isEqual(_.pick(this.props, SHOULD_CLEAR_WIDGETS_PROP_LIST), _.pick(nextProps, SHOULD_CLEAR_WIDGETS_PROP_LIST))) {
	            this.setState(this._getInitialWidgetState(nextProps));
	        }
	    },
	
	    shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {
	        if (this.props.alwaysUpdate) {
	            // TOTAL hacks so that findWidgets doesn't break
	            // when one widget updates without the other.
	            // See passage-refs inside radios, which was why
	            // this was introduced.
	            // I'm sorry!
	            // TODO(aria): cry
	            return true;
	        }
	        var stateChanged = !_.isEqual(this.state, nextState);
	        var propsChanged = !_.isEqual(this.props, nextProps);
	        return propsChanged || stateChanged;
	    },
	
	    componentWillUpdate: function componentWillUpdate(nextProps, nextState) {
	        var oldJipt = this.shouldRenderJiptPlaceholder(this.props, this.state);
	        var newJipt = this.shouldRenderJiptPlaceholder(nextProps, nextState);
	        var oldContent = this.getContent(this.props, this.state);
	        var newContent = this.getContent(nextProps, nextState);
	        var oldHighlightedWidgets = this.props.highlightedWidgets;
	        var newHighlightedWidgets = nextProps.highlightedWidgets;
	
	        // TODO(jared): This seems to be a perfect overlap with
	        // "shouldComponentUpdate" -- can we just remove this
	        // componentWillUpdate and the reuseMarkdown attr?
	        this.reuseMarkdown = !oldJipt && !newJipt && oldContent === newContent && _.isEqual(this.state.notGorgonLintErrors, nextState.notGorgonLintErrors),
	        // If we are running the linter then we need to know when
	        // widgets have changed because we need for force the linter to
	        // run when that happens. Note: don't do identity comparison here:
	        // it can cause frequent re-renders that break MathJax somehow
	        (!this.props.linterContext.highlightLint || _.isEqual(this.props.widgets, nextProps.widgets)) &&
	        // If the linter is turned on or off, we have to rerender
	        this.props.linterContext.highlightLint === nextProps.linterContext.highlightLint &&
	        // yes, this is identity array comparison, but these are passed
	        // in from state in the item-renderer, so they should be
	        // identity equal unless something changed, and it's expensive
	        // to loop through them to look for differences.
	        // Technically, we could reuse the markdown when this changes,
	        // but to do that we'd have to do more expensive checking of
	        // whether a widget should be highlighted in the common case
	        // where this array hasn't changed, so we just redo the whole
	        // render if this changed
	        oldHighlightedWidgets === newHighlightedWidgets;
	    },
	
	    componentDidUpdate: function componentDidUpdate(prevProps, prevState) {
	        var _this = this;
	
	        this.handleRender(prevProps);
	        // We even do this if we did reuse the markdown because
	        // we might need to update the widget props on this render,
	        // even though we have the same widgets.
	        // WidgetContainers don't update their widgets' props when
	        // they are re-rendered, so even if they've been
	        // re-rendered we need to call these methods on them.
	        _.each(this.widgetIds, function (id) {
	            var container = _this.refs["container:" + id];
	            container.replaceWidgetProps(_this.getWidgetProps(id));
	        });
	
	        if (this.props.serializedState && !_.isEqual(this.props.serializedState, this.getSerializedState())) {
	            this.restoreSerializedState(this.props.serializedState);
	        }
	
	        if (this.props.linterContext.highlightLint) {
	            // Get i18n lint errors asynchronously. If lint errors have changed
	            // since the last run, this component will be rerendered.
	            this.state.notGorgon.runLinter(this.props.content, this.handleNotGorgonLintErrors);
	        }
	    },
	
	    componentWillUnmount: function componentWillUnmount() {
	        // Clean out the list of widgetIds when unmounting, as this list is
	        // meant to be consistent with the refs controlled by the renderer, and
	        // refs are also cleared out during unmounting.
	        // (This may not be totally necessary, but mobile clients have been
	        // seeing JS errors due to an inconsistency between the list of
	        // widgetIds and the child refs of the renderer.
	        // See: https://phabricator.khanacademy.org/D32420.)
	        this.widgetIds = [];
	
	        if (this.translationIndex != null) {
	            window.PerseusTranslationComponents[this.translationIndex] = null;
	        }
	
	        this.state.notGorgon.destroy();
	
	        this._isMounted = false;
	    },
	
	    getApiOptions: function getApiOptions() {
	        return ApiOptionsProps.getApiOptions.call(this);
	    },
	
	
	    _getInitialWidgetState: function _getInitialWidgetState(props) {
	        props = props || this.props;
	        var allWidgetInfo = this._getAllWidgetsInfo(props);
	        return {
	            widgetInfo: allWidgetInfo,
	            widgetProps: this._getAllWidgetsStartProps(allWidgetInfo, props)
	        };
	    },
	
	    _getAllWidgetsInfo: function _getAllWidgetsInfo(props) {
	        props = props || this.props;
	        return mapObject(props.widgets, function (widgetInfo, widgetId) {
	            if (!widgetInfo.type || !widgetInfo.alignment) {
	                var newValues = {};
	
	                if (!widgetInfo.type) {
	                    newValues.type = widgetId.split(" ")[0];
	                }
	                if (!widgetInfo.alignment) {
	                    newValues.alignment = "default";
	                }
	
	                widgetInfo = _.extend({}, widgetInfo, newValues);
	            }
	            return Widgets.upgradeWidgetInfoToLatestVersion(widgetInfo);
	        });
	    },
	
	    _getAllWidgetsStartProps: function _getAllWidgetsStartProps(allWidgetInfo, props) {
	        return mapObject(allWidgetInfo, function (editorProps) {
	            return Widgets.getRendererPropsForWidgetInfo(editorProps, props.problemNum);
	        });
	    },
	
	    _getDefaultWidgetInfo: function _getDefaultWidgetInfo(widgetId) {
	        var widgetIdParts = Util.rTypeFromWidgetId.exec(widgetId);
	        if (widgetIdParts == null) {
	            return {};
	        }
	        return {
	            type: widgetIdParts[1],
	            graded: true,
	            options: {}
	        };
	    },
	
	    _getWidgetInfo: function _getWidgetInfo(widgetId) {
	        return this.state.widgetInfo[widgetId] || this._getDefaultWidgetInfo(widgetId);
	    },
	
	    renderWidget: function renderWidget(impliedType, id, state) {
	        var widgetInfo = this.state.widgetInfo[id];
	
	        if (widgetInfo && widgetInfo.alignment === "full-width") {
	            state.foundFullWidth = true;
	        }
	
	        if (widgetInfo || this.props.ignoreMissingWidgets) {
	            var type = widgetInfo && widgetInfo.type || impliedType;
	            var shouldHighlight = _.contains(this.props.highlightedWidgets, id);
	
	            // By this point we should have no duplicates, which are
	            // filtered out in this.render(), so we shouldn't have to
	            // worry about using this widget key and ref:
	            return React.createElement(WidgetContainer, {
	                ref: "container:" + id,
	                key: "container:" + id,
	                type: type,
	                initialProps: this.getWidgetProps(id),
	                shouldHighlight: shouldHighlight,
	                linterContext: Gorgon.pushContextStack(this.props.linterContext, "widget")
	            });
	        } else {
	            return null;
	        }
	    },
	
	    getWidgetProps: function getWidgetProps(id) {
	        var _this2 = this;
	
	        var apiOptions = this.getApiOptions();
	        var widgetProps = this.state.widgetProps[id] || {};
	
	        // The widget needs access to its "rubric" at all times when in review
	        // mode (which is really just part of its widget info).
	        var reviewModeRubric = null;
	        var widgetInfo = this.state.widgetInfo[id];
	        if (this.props.reviewMode && widgetInfo) {
	            reviewModeRubric = widgetInfo.options;
	        }
	
	        if (!this._interactionTrackers) {
	            this._interactionTrackers = {};
	        }
	
	        var interactionTracker = this._interactionTrackers[id];
	        if (!interactionTracker) {
	            interactionTracker = this._interactionTrackers[id] = new InteractionTracker(apiOptions.trackInteraction, widgetInfo && widgetInfo.type, id, Widgets.getTracking(widgetInfo && widgetInfo.type));
	        }
	
	        return _extends({}, widgetProps, {
	            ref: id,
	            widgetId: id,
	            alignment: widgetInfo && widgetInfo.alignment,
	            static: widgetInfo && widgetInfo.static,
	            problemNum: this.props.problemNum,
	            apiOptions: this.getApiOptions(this.props),
	            keypadElement: this.props.keypadElement,
	            questionCompleted: this.props.questionCompleted,
	            onFocus: _.partial(this._onWidgetFocus, id),
	            onBlur: _.partial(this._onWidgetBlur, id),
	            findWidgets: this.findWidgets,
	            reviewModeRubric: reviewModeRubric,
	            onChange: function onChange(newProps, cb) {
	                var silent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
	
	                _this2._setWidgetProps(id, newProps, cb, silent);
	            },
	            trackInteraction: interactionTracker.track
	        });
	    },
	
	    /**
	    * Serializes the questions state so it can be recovered.
	    *
	    * The return value of this function can be sent to the
	    * `restoreSerializedState` method to restore this state.
	    *
	    * If an instance of widgetProps is passed in, it generates the serialized
	    * state from that instead of the current widget props.
	    */
	    getSerializedState: function getSerializedState(widgetProps) {
	        var _this3 = this;
	
	        return mapObject(widgetProps || this.state.widgetProps, function (props, widgetId) {
	            var widget = _this3.getWidgetInstance(widgetId);
	            if (widget && widget.getSerializedState) {
	                return widget.getSerializedState();
	            } else {
	                return props;
	            }
	        });
	    },
	
	    restoreSerializedState: function restoreSerializedState(serializedState, callback) {
	        var _this4 = this;
	
	        // Do some basic validation on the serialized state (just make sure the
	        // widget IDs are what we expect).
	        var serializedWidgetIds = _.keys(serializedState);
	        var widgetPropIds = _.keys(this.state.widgetProps);
	
	        // If the two lists of IDs match (ignoring order)
	        if (serializedWidgetIds.length !== widgetPropIds.length || _.intersection(serializedWidgetIds, widgetPropIds).length !== serializedWidgetIds.length) {
	            // eslint-disable-next-line no-console
	            console.error("Refusing to restore bad serialized state:", serializedState, "Current props:", this.state.widgetProps);
	            return;
	        }
	
	        // We want to wait until any children widgets who have a
	        // restoreSerializedState function also call their own callbacks before
	        // we declare that the operation is finished.
	        var numCallbacks = 1;
	        var fireCallback = function fireCallback() {
	            --numCallbacks;
	            if (callback && numCallbacks === 0) {
	                callback();
	            }
	        };
	
	        this.setState({
	            widgetProps: mapObject(serializedState, function (props, widgetId) {
	                var widget = _this4.getWidgetInstance(widgetId);
	                if (widget && widget.restoreSerializedState) {
	                    // Note that we probably can't call
	                    // `this.change()/this.props.onChange()` in this
	                    // function, so we take the return value and use
	                    // that as props if necessary so that
	                    // `restoreSerializedState` in a widget can
	                    // change the props as well as state.
	                    // If a widget has no props to change, it can
	                    // safely return null.
	                    ++numCallbacks;
	                    var restoreResult = widget.restoreSerializedState(props, fireCallback);
	                    return _.extend({}, _this4.state.widgetProps[widgetId], restoreResult);
	                } else {
	                    return props;
	                }
	            })
	        }, fireCallback);
	    },
	
	    /**
	     * Tell each of the radio widgets to show rationales for each of the
	     * currently selected choices inside of them. If the widget is correct, it
	     * shows rationales for all of the choices. This also disables interaction
	     * with the choices that we show rationales for.
	     */
	    showRationalesForCurrentlySelectedChoices: function showRationalesForCurrentlySelectedChoices() {
	        var _this5 = this;
	
	        Object.keys(this.props.widgets).forEach(function (widgetId) {
	            var widget = _this5.getWidgetInstance(widgetId);
	            if (widget && widget.showRationalesForCurrentlySelectedChoices) {
	                widget.showRationalesForCurrentlySelectedChoices(_this5._getWidgetInfo(widgetId).options);
	            }
	        });
	    },
	
	
	    /**
	     * Tells each of the radio widgets to deselect any of the incorrect choices
	     * that are currently selected (leaving correct choices still selected).
	     */
	    deselectIncorrectSelectedChoices: function deselectIncorrectSelectedChoices() {
	        var _this6 = this;
	
	        // TODO(emily): this has the exact same structure as
	        // showRationalesForCurrentlySelectedChoices above. Maybe DRY this up.
	        Object.keys(this.props.widgets).forEach(function (widgetId) {
	            var widget = _this6.getWidgetInstance(widgetId);
	            if (widget && widget.deselectIncorrectSelectedChoices) {
	                widget.deselectIncorrectSelectedChoices();
	            }
	        });
	    },
	
	
	    /**
	     * Allows inter-widget communication.
	     *
	     * This function yields this Renderer's own internal widgets, and it's used
	     * in two places.
	     *
	     * First, we expose our own internal widgets to each other by giving them
	     * a `findWidgets` function that, in turn, calls this function.
	     *
	     * Second, we expose our own internal widgets to this Renderer's parent,
	     * by allowing it to call this function directly. That way, it can hook us
	     * up to other Renderers on the page, by writing a `findExternalWidgets`
	     * prop that calls each other Renderer's `findInternalWidgets` function.
	     *
	     * Takes a `filterCriterion` on which widgets to return.
	     * `filterCriterion` can be one of:
	     *  * A string widget id
	     *  * A string widget type
	     *  * a function from (id, widgetInfo, widgetComponent) to true or false
	     *
	     * Returns an array of the matching widget components.
	     *
	     * If you need to do logic with more than the components, it is possible
	     * to do such logic inside the filter, rather than on the result array.
	     *
	     * See the passage-ref widget for an example.
	     *
	     * "Remember: abilities are not inherently good or evil, it's how you use
	     * them." ~ Kyle Katarn
	     * Please use this one with caution.
	     */
	    findInternalWidgets: function findInternalWidgets(filterCriterion) {
	        var _this7 = this;
	
	        var filterFunc;
	        // Convenience filters:
	        // "interactive-graph 3" will give you [[interactive-graph 3]]
	        // "interactive-graph" will give you all interactive-graphs
	        if (typeof filterCriterion === "string") {
	            if (filterCriterion.indexOf(" ") !== -1) {
	                var widgetId = filterCriterion;
	                filterFunc = function filterFunc(id, widgetInfo) {
	                    return id === widgetId;
	                };
	            } else {
	                var widgetType = filterCriterion;
	                filterFunc = function filterFunc(id, widgetInfo) {
	                    return widgetInfo.type === widgetType;
	                };
	            }
	        } else {
	            filterFunc = filterCriterion;
	        }
	
	        var results = this.widgetIds.filter(function (id) {
	            var widgetInfo = _this7._getWidgetInfo(id);
	            var widget = _this7.getWidgetInstance(id);
	            return filterFunc(id, widgetInfo, widget);
	        }).map(this.getWidgetInstance);
	
	        return results;
	    },
	
	    /**
	     * Allows inter-widget communication.
	     *
	     * Includes both widgets internal to this Renderer, and external widgets
	     * exposed by the `findExternalWidgets` prop.
	     *
	     * See `findInteralWidgets` for more information.
	     */
	    findWidgets: function findWidgets(filterCriterion) {
	        return [].concat(this.findInternalWidgets(filterCriterion), this.props.findExternalWidgets(filterCriterion));
	    },
	
	    getWidgetInstance: function getWidgetInstance(id) {
	        var ref = this.refs["container:" + id];
	        if (!ref) {
	            return null;
	        }
	        return ref.getWidget();
	    },
	
	    _onWidgetFocus: function _onWidgetFocus(id, focusPath) {
	        if (focusPath === undefined) {
	            focusPath = [];
	        } else {
	            if (!_.isArray(focusPath)) {
	                throw new Error("widget props.onFocus focusPath must be an Array, " + "but was" + JSON.stringify(focusPath));
	            }
	        }
	        this._setCurrentFocus([id].concat(focusPath));
	    },
	
	    _onWidgetBlur: function _onWidgetBlur(id, blurPath) {
	        var _this8 = this;
	
	        var blurringFocusPath = this._currentFocus;
	
	        // Failsafe: abort if ID is different, because focus probably happened
	        // before blur
	        var fullPath = [id].concat(blurPath);
	        if (!_.isEqual(fullPath, blurringFocusPath)) {
	            return;
	        }
	
	        // Wait until after any new focus events fire this tick before
	        // declaring that nothing is focused.
	        // If a different widget was focused, we'll see an onBlur event
	        // now, but then an onFocus event on a different element before
	        // this callback is executed
	        _.defer(function () {
	            if (_.isEqual(_this8._currentFocus, blurringFocusPath)) {
	                _this8._setCurrentFocus(null);
	            }
	        });
	    },
	
	    getContent: function getContent(props, state) {
	        return state.jiptContent || props.content;
	    },
	
	    shouldRenderJiptPlaceholder: function shouldRenderJiptPlaceholder(props, state) {
	        // TODO(aria): Pass this in via webapp as an apiOption
	        return typeof KA !== "undefined" && KA.language === "en-pt" && state.jiptContent == null && props.content.indexOf("crwdns") !== -1;
	    },
	
	    replaceJiptContent: function replaceJiptContent(content, paragraphIndex) {
	        if (paragraphIndex == null) {
	            // we're not translating paragraph-wise; replace the whole content
	            // (we could also theoretically check for apiOptions.isArticle
	            // here, which is what causes paragraphIndex to not be null)
	            this.setState({
	                jiptContent: content
	            });
	        } else {
	            // This is the same regex we use in perseus/translate.py to find
	            // code blocks. We use it to count entire code blocks as
	            // paragraphs.
	            var codeFenceRegex = /^\s*(`{3,}|~{3,})\s*(\S+)?\s*\n([\s\S]+?)\s*\1\s*$/; // eslint-disable-line max-len
	
	            if (codeFenceRegex.test(content)) {
	                // If a paragraph is a code block, we're going to treat it as a
	                // single paragraph even if it has double-newlines in it, so
	                // skip the next two checks.
	            } else if (/\S\n\s*\n\S/.test(content)) {
	                // Our "render the exact same QuestionParagraphs each time"
	                // strategy will fail if we allow translating a paragraph
	                // to more than one paragraph. This hack renders as a single
	                // paragraph and lets the translator know to not use \n\n,
	                // hopefully. We can't wait for linting because we can't
	                // safely render the node.
	                // TODO(aria): Check for the max number of backticks or tildes
	                // in the content, and just render a red code block of the
	                // content here instead?
	                content = "$\\large{\\red{\\text{Please translate each " + "paragraph to a single paragraph.}}}$";
	            } else if (/^\s*$/.test(content)) {
	                // We similarly can't have an all-whitespace paragraph, or
	                // we will parse it as the closing of the previous paragraph
	                content = "$\\large{\\red{\\text{Translated paragraph is " + "currently empty}}}$";
	            }
	            // Split the paragraphs; we have to use getContent() in case
	            // nothing has been translated yet (in which case we just have
	            // this.props.content)
	            var allContent = this.getContent(this.props, this.state);
	            var paragraphs = JiptParagraphs.parseToArray(allContent);
	            paragraphs[paragraphIndex] = content;
	            this.setState({
	                jiptContent: JiptParagraphs.joinFromArray(paragraphs)
	            });
	        }
	    },
	
	    // wrap top-level elements in a QuestionParagraph, mostly
	    // for appropriate spacing and other css
	    outputMarkdown: function outputMarkdown(ast, state) {
	        if (_.isArray(ast)) {
	            // This is duplicated from simple-markdown
	            // TODO(aria): Don't duplicate this logic
	            var oldKey = state.key;
	            var result = [];
	
	            // map nestedOutput over the ast, except group any text
	            // nodes together into a single string output.
	            // NOTE(aria): These are never strings--always QuestionParagraphs
	            // TODO(aria): We probably don't need this string logic here.
	            var lastWasString = false;
	            for (var i = 0; i < ast.length; i++) {
	                state.key = i;
	                state.paragraphIndex = i;
	                var nodeOut = this.outputMarkdown(ast[i], state);
	                var isString = typeof nodeOut === "string";
	                if (isString && lastWasString) {
	                    result[result.length - 1] += nodeOut;
	                } else {
	                    result.push(nodeOut);
	                }
	                lastWasString = isString;
	            }
	
	            state.key = oldKey;
	            return result;
	        } else {
	            // !!! WARNING: Mutative hacks! mutates `this._foundTextNodes`:
	            // because I wrote a bad interface to simple-markdown.js' `output`
	            this._foundTextNodes = false;
	            state.foundFullWidth = false;
	            var output = this.outputNested(ast, state);
	
	            // In Jipt-land, we need to render the exact same outer
	            // QuestionParagraph nodes always. This means the number of
	            // paragraphs needs to stay the same, and we can't modify
	            // the classnames on the QuestionParagraphs or we'll destroy
	            // the crowdin classnames. So we just only use the
	            // 'paragraph' classname from the QuestionParagraph.
	            // If this becomes a problem it would be easy to fix by wrapping
	            // the nodes in an extra layer (hopefully only for jipt) that
	            // handles the jipt classnames, and let this layer handle the
	            // dynamic classnames.
	            // We can't render the classes the first time and leave them
	            // the same because we don't know at the time of the first
	            // render whether they are full-bleed or centered, since they
	            // only contain crowdin IDs like `crwdns:972384209:0...`
	            var className;
	            if (this.translationIndex != null) {
	                className = null;
	            } else {
	                className = classNames({
	                    "perseus-paragraph-centered": !this._foundTextNodes,
	                    // There is only one node being rendered,
	                    // and it's a full-width widget.
	                    "perseus-paragraph-full-width": state.foundFullWidth && ast.content.length === 1
	                });
	            }
	
	            return React.createElement(
	                QuestionParagraph,
	                {
	                    key: state.key,
	                    className: className,
	                    translationIndex: this.translationIndex,
	                    paragraphIndex: state.paragraphIndex
	                },
	                output
	            );
	        }
	    },
	
	    // output non-top-level nodes or arrays
	    outputNested: function outputNested(ast, state) {
	        if (_.isArray(ast)) {
	            // This is duplicated from simple-markdown
	            // TODO(aria): Don't duplicate this logic
	            var oldKey = state.key;
	            var result = [];
	
	            // map nestedOutput over the ast, except group any text
	            // nodes together into a single string output.
	            var lastWasString = false;
	            for (var i = 0; i < ast.length; i++) {
	                state.key = i;
	                var nodeOut = this.outputNested(ast[i], state);
	                var isString = typeof nodeOut === "string";
	                if (isString && lastWasString) {
	                    result[result.length - 1] += nodeOut;
	                } else {
	                    result.push(nodeOut);
	                }
	                lastWasString = isString;
	            }
	
	            state.key = oldKey;
	            return result;
	        } else {
	            return this.outputNode(ast, this.outputNested, state);
	        }
	    },
	
	    // output individual AST nodes [not arrays]
	    outputNode: function outputNode(node, nestedOutput, state) {
	        var _this9 = this;
	
	        var apiOptions = this.getApiOptions();
	        var imagePlaceholder = apiOptions.imagePlaceholder;
	
	        if (node.type === "widget") {
	            var widgetPlaceholder = apiOptions.widgetPlaceholder;
	
	            if (widgetPlaceholder) {
	                return widgetPlaceholder;
	            }
	            // Widgets can contain text nodes, so we don't center them with
	            // markdown magic here.
	            // Instead, we center them with css magic in articles.less
	            // /cry(aria)
	            this._foundTextNodes = true;
	
	            if (_.contains(this.widgetIds, node.id)) {
	                // We don't want to render a duplicate widget key/ref,
	                // as this causes problems with react (for obvious
	                // reasons). Instead we just notify the
	                // hopefully-content-creator that they need to change the
	                // widget id.
	                return React.createElement(
	                    "span",
	                    { key: state.key, className: "renderer-widget-error" },
	                    "Widget [[",
	                    "\u2603",
	                    " ",
	                    node.id,
	                    "]] already exists."
	                );
	            } else {
	                this.widgetIds.push(node.id);
	                return this.renderWidget(node.widgetType, node.id, state);
	            }
	        } else if (node.type === "blockMath") {
	            // We render math here instead of in perseus-markdown.jsx
	            // because we need to pass it our onRender callback.
	            var deferred = new Deferred();
	
	            var onRender = function onRender(node) {
	                _this9.props.onRender && _this9.props.onRender(node);
	
	                if (apiOptions.isMobile) {
	                    // `onRender` only returns a node on the initial render.
	                    if (node) {
	                        var katex = node.querySelector(".katex");
	
	                        // Though MathJax's visible elements should have been
	                        // inserted into the DOM by now (and, thus, we should be
	                        // able to query for .MathJax instead), we're not seeing
	                        // that guarantee play out in practice. So we look for
	                        // either .MathJax or the script tag that is inserted
	                        // on initial render.
	                        // TODO(charlie): This works, but feels very brittle.
	                        // Figure out how we can call `onRender` only after the
	                        // elements have been inserted into the DOM.
	                        var mathjax = node.querySelector('script[type="math/tex"]') || node.querySelector(".MathJax");
	
	                        if (katex) {
	                            deferred.resolve();
	                        } else if (mathjax) {
	                            deferred.resolve();
	                        } else {
	                            throw new Error("No math present in Renderer");
	                        }
	                    }
	                }
	            };
	
	            var content = React.createElement(
	                TeX,
	                { onRender: onRender, onResourceLoaded: onRender },
	                preprocessTex(node.content)
	            );
	
	            var innerStyle = {
	                // HACK(benkomalo): we only want horizontal scrolling, but
	                // overflowX: 'auto' causes a vertical scrolling scrollbar
	                // as well, despite the parent and child elements having
	                // the exact same height. Force it to not scroll by
	                // applying overflowY: 'hidden'
	                overflowX: "auto",
	                overflowY: "hidden",
	
	                // HACK(kevinb): overflowY: 'hidden' inadvertently clips the
	                // top and bottom of some fractions.  We add padding to the
	                // top and bottom to avoid the clipping and then correct for
	                // the padding by adding equal but opposite margins.
	                paddingTop: 10,
	                paddingBottom: 10,
	                marginTop: -10,
	                marginBottom: -10
	            };
	
	            if (apiOptions.isMobile) {
	                // The style for the body of articles and exercises on mobile is
	                // to have a 16px margin.  When a user taps to zoom math we'd
	                // like the math to extend all the way to the edge of the page/
	                // To achieve this affect we nest the Zoomable component in two
	                // nested divs. The outer div has a negative margin to
	                // counteract the margin on main perseus container.  The inner
	                // div adds the margin back as padding so that when the math is
	                // scaled out it's inset from the edge of the page.  When the
	                // TeX component is full size it will extend to the edge of the
	                // page if it's larger than the page.
	                //
	                // TODO(kevinb) automatically determine the margin size
	                var margin = 16;
	                var outerStyle = {
	                    marginLeft: -margin,
	                    marginRight: -margin
	                };
	                var horizontalPadding = {
	                    paddingLeft: margin,
	                    paddingRight: margin
	                };
	
	                var computeMathBounds = function computeMathBounds(parentNode, parentBounds) {
	                    var textElement = parentNode.querySelector(".katex-html") || parentNode.querySelector(".MathJax");
	                    var textBounds = {
	                        width: textElement.offsetWidth,
	                        height: textElement.offsetHeight
	                    };
	
	                    // HACK(benkomalo): when measuring math content, note that
	                    // sometimes it actually peeks outside of the
	                    // container in some cases. Just be conservative and use
	                    // the maximum value of the text and the parent. :(
	                    return {
	                        width: Math.max(parentBounds.width, textBounds.width),
	                        height: Math.max(parentBounds.height, textBounds.height)
	                    };
	                };
	
	                return React.createElement(
	                    "div",
	                    {
	                        key: state.key,
	                        className: "perseus-block-math",
	                        style: outerStyle
	                    },
	                    React.createElement(
	                        "div",
	                        {
	                            className: "perseus-block-math-inner",
	                            style: _extends({}, innerStyle, horizontalPadding)
	                        },
	                        React.createElement(
	                            Zoomable,
	                            {
	                                readyToMeasureDeferred: deferred,
	                                computeChildBounds: computeMathBounds
	                            },
	                            content
	                        )
	                    )
	                );
	            } else {
	                return React.createElement(
	                    "div",
	                    { key: state.key, className: "perseus-block-math" },
	                    React.createElement(
	                        "div",
	                        {
	                            className: "perseus-block-math-inner",
	                            style: innerStyle
	                        },
	                        content
	                    )
	                );
	            }
	        } else if (node.type === "math") {
	            // Replace uses of \begin{align}...\end{align} which KaTeX doesn't
	            // support (yet) with \begin{aligned}...\end{aligned} which renders
	            // the same is supported by KaTeX.  It does the same for align*.
	            // TODO(kevinb) update content to use aligned instead of align.
	            var tex = node.content.replace(/\{align[*]?\}/g, "{aligned}");
	
	            // We render math here instead of in perseus-markdown.jsx
	            // because we need to pass it our onRender callback.
	            return React.createElement(
	                "span",
	                {
	                    key: state.key,
	                    style: {
	                        // If math is directly next to text, don't let it
	                        // wrap to the next line
	                        whiteSpace: "nowrap"
	                    }
	                },
	                React.createElement("span", null),
	                React.createElement(
	                    TeX,
	                    {
	                        onRender: this.props.onRender,
	                        onResourceLoaded: this.props.onRender
	                    },
	                    tex
	                ),
	                React.createElement("span", null)
	            );
	        } else if (node.type === "image") {
	            if (imagePlaceholder) {
	                return imagePlaceholder;
	            }
	
	            // We need to add width and height to images from our
	            // props.images mapping.
	
	            // We do a _.has check here to avoid weird things like
	            // 'toString' or '__proto__' as a url.
	            var extraAttrs = _.has(this.props.images, node.target) ? this.props.images[node.target] : null;
	
	            // The width of a table column is determined by the widest table
	            // cell within that column, but responsive images constrain
	            // themselves to the width of their parent containers. Thus,
	            // responsive images don't do very well within tables. To avoid
	            // haphazard sizing, simply make images within tables unresponsive.
	            // TODO(alex): Make tables themselves responsive.
	            var responsive = !state.inTable;
	
	            return React.createElement(SvgImage, _extends({
	                key: state.key,
	                src: PerseusMarkdown.sanitizeUrl(node.target),
	                alt: node.alt,
	                title: node.title,
	                responsive: responsive,
	                onUpdate: this.props.onRender,
	                zoomToFullSizeOnMobile: apiOptions.isMobile && apiOptions.isArticle
	            }, extraAttrs));
	        } else if (node.type === "columns") {
	            // Note that we have two columns. This is so we can put
	            // a className on the outer renderer content for SAT.
	            // TODO(aria): See if there is a better way we can do
	            // things like this
	            this._isTwoColumn = true;
	            // but then render normally:
	            return PerseusMarkdown.ruleOutput(node, nestedOutput, state);
	        } else if (node.type === "text") {
	            if (rContainsNonWhitespace.test(node.content)) {
	                this._foundTextNodes = true;
	            }
	
	            // Used by the translator portal to replace image URLs with
	            // placeholders, see preprocessWidgets in manticore-utils.js
	            // for more details.
	            if (imagePlaceholder && rImageURL.test(node.content)) {
	                return imagePlaceholder;
	            } else {
	                return node.content;
	            }
	        } else if (node.type === "table" || node.type === "titledTable") {
	            state.inTable = true;
	            var output = PerseusMarkdown.ruleOutput(node, nestedOutput, state);
	            state.inTable = false;
	
	            if (!apiOptions.isMobile) {
	                return output;
	            }
	
	            var _margin = 16;
	            var _outerStyle = {
	                marginLeft: -_margin,
	                marginRight: -_margin
	            };
	            var _innerStyle = {
	                paddingLeft: 0,
	                paddingRight: 0
	            };
	
	            var wrappedOutput = React.createElement(
	                "div",
	                { style: _extends({}, _innerStyle, { overflowX: "auto" }) },
	                React.createElement(
	                    Zoomable,
	                    { animateHeight: true },
	                    output
	                )
	            );
	
	            // TODO(benkomalo): how should we deal with tappable items inside
	            // of tables?
	            return React.createElement(
	                "div",
	                { style: _outerStyle },
	                wrappedOutput
	            );
	        } else {
	            // If it's a "normal" or "simple" markdown node, just
	            // output it using its output rule.
	            return PerseusMarkdown.ruleOutput(node, nestedOutput, state);
	        }
	    },
	
	    handleRender: function handleRender(prevProps) {
	        var onRender = this.props.onRender;
	        var oldOnRender = prevProps.onRender;
	
	        // In the common case of no callback specified, avoid this work.
	        if (onRender !== noopOnRender || oldOnRender !== noopOnRender) {
	            var $images = $(ReactDOM.findDOMNode(this)).find("img");
	
	            // Fire callback on image load...
	            if (oldOnRender !== noopOnRender) {
	                $images.off("load", oldOnRender);
	            }
	
	            if (onRender !== noopOnRender) {
	                $images.on("load", onRender);
	            }
	        }
	
	        // ...as well as right now (non-image, non-TeX or image from cache)
	        onRender();
	    },
	
	    // Sets the current focus path
	    // If the new focus path is not a prefix of the old focus path,
	    // we send an onChangeFocus event back to our parent.
	    _setCurrentFocus: function _setCurrentFocus(path) {
	        var apiOptions = this.getApiOptions();
	
	        // We don't do this when the new path is a prefix because
	        // that prefix is already focused (we're just in a more specific
	        // area of it). This makes it safe to call _setCurrentFocus
	        // whenever a widget is interacted with--we won't wipe out
	        // our focus state if we are already focused on a subpart
	        // of that widget (i.e. a transformation NumberInput inside
	        // of a transformer widget).
	        if (!isIdPathPrefix(path, this._currentFocus)) {
	            var prevFocus = this._currentFocus;
	
	            if (prevFocus) {
	                this.blurPath(prevFocus);
	            }
	
	            this._currentFocus = path;
	            if (apiOptions.onFocusChange != null) {
	                apiOptions.onFocusChange(this._currentFocus, prevFocus);
	            }
	        }
	    },
	
	    focus: function focus() {
	        var id;
	        var focusResult;
	        for (var i = 0; i < this.widgetIds.length; i++) {
	            var widgetId = this.widgetIds[i];
	            var widget = this.getWidgetInstance(widgetId);
	            var widgetFocusResult = widget && widget.focus && widget.focus();
	            if (widgetFocusResult) {
	                id = widgetId;
	                focusResult = widgetFocusResult;
	                break;
	            }
	        }
	
	        if (id) {
	            // reconstruct a {path, element} focus object
	            var path;
	            if (_.isObject(focusResult)) {
	                // The result of focus was a {path, id} object itself
	                path = [id].concat(focusResult.path || []);
	            } else {
	                // The result of focus was true or the like; just
	                // construct a root focus object
	                path = [id];
	            }
	
	            this._setCurrentFocus(path);
	            return true;
	        }
	    },
	
	    getDOMNodeForPath: function getDOMNodeForPath(path) {
	        var widgetId = _.first(path);
	        var interWidgetPath = _.rest(path);
	
	        // Widget handles parsing of the interWidgetPath. If the path is empty
	        // beyond the widgetID, as a special case we just return the widget's
	        // DOM node.
	        var widget = this.getWidgetInstance(widgetId);
	        var getNode = widget.getDOMNodeForPath;
	        if (getNode) {
	            return getNode(interWidgetPath);
	        } else if (interWidgetPath.length === 0) {
	            return ReactDOM.findDOMNode(widget);
	        }
	    },
	
	    getGrammarTypeForPath: function getGrammarTypeForPath(path) {
	        var widgetId = _.first(path);
	        var interWidgetPath = _.rest(path);
	
	        var widget = this.getWidgetInstance(widgetId);
	        return widget.getGrammarTypeForPath(interWidgetPath);
	    },
	
	    getInputPaths: function getInputPaths() {
	        var _this10 = this;
	
	        var inputPaths = [];
	        _.each(this.widgetIds, function (widgetId) {
	            var widget = _this10.getWidgetInstance(widgetId);
	            if (widget.getInputPaths) {
	                // Grab all input paths and add widgetID to the front
	                var widgetInputPaths = widget.getInputPaths();
	                // Prefix paths with their widgetID and add to collective
	                // list of paths.
	                _.each(widgetInputPaths, function (inputPath) {
	                    var relativeInputPath = [widgetId].concat(inputPath);
	                    inputPaths.push(relativeInputPath);
	                });
	            }
	        });
	
	        return inputPaths;
	    },
	
	    focusPath: function focusPath(path) {
	        // No need to focus if it's already focused
	        if (_.isEqual(this._currentFocus, path)) {
	            return;
	        } else if (this._currentFocus) {
	            // Unfocus old path, if exists
	            this.blurPath(this._currentFocus);
	        }
	
	        var widgetId = _.first(path);
	        var interWidgetPath = _.rest(path);
	
	        // Widget handles parsing of the interWidgetPath
	        var focusWidget = this.getWidgetInstance(widgetId).focusInputPath;
	        focusWidget && focusWidget(interWidgetPath);
	    },
	
	    blurPath: function blurPath(path) {
	        // No need to blur if it's not focused
	        if (!_.isEqual(this._currentFocus, path)) {
	            return;
	        }
	
	        var widgetId = _.first(path);
	        var interWidgetPath = _.rest(path);
	        var widget = this.getWidgetInstance(widgetId);
	        // We might be in the editor and blurring a widget that no
	        // longer exists, so only blur if we actually found the widget
	        if (widget) {
	            var blurWidget = this.getWidgetInstance(widgetId).blurInputPath;
	            // Widget handles parsing of the interWidgetPath
	            blurWidget && blurWidget(interWidgetPath);
	        }
	    },
	
	    blur: function blur() {
	        if (this._currentFocus) {
	            this.blurPath(this._currentFocus);
	        }
	    },
	
	    serialize: function serialize() {
	        var state = {};
	        _.each(this.state.widgetInfo, function (info, id) {
	            var widget = this.getWidgetInstance(id);
	            var s = widget.serialize();
	            if (!_.isEmpty(s)) {
	                state[id] = s;
	            }
	        }, this);
	        return state;
	    },
	
	    emptyWidgets: function emptyWidgets() {
	        var _this11 = this;
	
	        return _.filter(this.widgetIds, function (id) {
	            var widgetInfo = _this11._getWidgetInfo(id);
	            var score = _this11.getWidgetInstance(id).simpleValidate(widgetInfo.options, null);
	            return Util.scoreIsEmpty(score);
	        });
	    },
	
	    _setWidgetProps: function _setWidgetProps(id, newProps, cb,
	    // Widgets can call `onChange` with `silent` set to `true` to prevent
	    silent) {
	        var _this12 = this;
	
	        this.setState(function (prevState) {
	            var _extends2;
	
	            var widgetProps = _extends({}, prevState.widgetProps, (_extends2 = {}, _extends2[id] = _extends({}, prevState.widgetProps[id], newProps), _extends2));
	
	            if (!silent) {
	                _this12.props.onSerializedStateUpdated(_this12.getSerializedState(widgetProps));
	            }
	
	            return {
	                widgetProps: widgetProps
	            };
	        }, function () {
	            var cbResult = cb && cb();
	            if (!silent) {
	                _this12.props.onInteractWithWidget(id);
	            }
	            if (cbResult !== false) {
	                // TODO(jack): For some reason, some widgets don't always
	                // end up in refs here, which is repro-able if you make an
	                // [[ orderer 1 ]] and copy-paste this, then change it to
	                // be an [[ orderer 2 ]]. The resulting Renderer ends up
	                // with an "orderer 2" ref but not an "orderer 1" ref.
	                // @_@??
	                // TODO(jack): Figure out why this is happening and fix it
	                // As far as I can tell, this is only an issue in the
	                // editor-page, so doing this shouldn't break clients
	                // hopefully
	                _this12._setCurrentFocus([id]);
	            }
	        });
	    },
	
	    setInputValue: function setInputValue(path, newValue, focus) {
	        var widgetId = _.first(path);
	        var interWidgetPath = _.rest(path);
	        var widget = this.getWidgetInstance(widgetId);
	
	        // Widget handles parsing of the interWidgetPath.
	        widget.setInputValue(interWidgetPath, newValue, focus);
	    },
	
	    /**
	     * Returns an array of the widget `.getUserInput()` results
	     */
	    getUserInput: function getUserInput() {
	        var _this13 = this;
	
	        return _.map(this.widgetIds, function (id) {
	            return _this13.getWidgetInstance(id).getUserInput();
	        });
	    },
	
	    /**
	     * Returns an array of all widget IDs in the order they occur in
	     * the content.
	     */
	    getWidgetIds: function getWidgetIds() {
	        return this.widgetIds;
	    },
	
	    /**
	     * WARNING: This is an experimental/temporary API and should not be relied
	     *     upon in production code. This function may change its behavior or
	     *     disappear without notice.
	     *
	     * Returns a treelike structure containing all widget IDs (this will
	     * descend into group widgets as well).
	     *
	     * An example of what the structure looks like:
	     *
	     * [
	     *    {id: "radio 1", children: []},
	     *    {
	     *        id: "group 1",
	     *        children: [
	     *            {id: "radio 1", children: []}
	     *            {id: "radio 2", children: []}
	     *        ]
	     *    }
	     * ]
	     *
	     * Widgets will be listed in the order that they appear in their renderer.
	     *
	     * Note: If a group hasn't been rendered yet, though, then its children
	     * ids will not be returned.
	     * TODO(marcia): We should figure out a way to either return the widget ids
	     * without needing to render all-the-things, or we should probably have a
	     * better pattern for requesting widget ids so we are more likely to get
	     * one true answer.
	     */
	    getAllWidgetIds: function getAllWidgetIds() {
	        var _this14 = this;
	
	        // Recursively builds our result
	        return _.map(this.getWidgetIds(), function (id) {
	            var groupPrefix = "group";
	            if (id.substring(0, groupPrefix.length) === groupPrefix && _this14.getWidgetInstance(id)) {
	                return {
	                    id: id,
	                    children: _this14.getWidgetInstance(id).getRenderer().getAllWidgetIds()
	                };
	            }
	
	            // This is our base case
	            return { id: id, children: [] };
	        });
	    },
	
	    /**
	     * Returns the result of `.getUserInput()` for each widget, in
	     * a map from widgetId to userInput.
	     */
	    getUserInputForWidgets: function getUserInputForWidgets() {
	        var _this15 = this;
	
	        return mapObjectFromArray(this.widgetIds, function (id) {
	            return _this15.getWidgetInstance(id).getUserInput();
	        });
	    },
	
	    /**
	     * Returns an object mapping from widget ID to perseus-style score.
	     * The keys of this object are the values of the array returned
	     * from `getWidgetIds`.
	     */
	    scoreWidgets: function scoreWidgets() {
	        var _this16 = this;
	
	        var widgetProps = this.state.widgetInfo;
	        var onInputError = this.getApiOptions().onInputError || function () {};
	
	        var gradedWidgetIds = _.filter(this.widgetIds, function (id) {
	            var props = widgetProps[id];
	            // props.graded is unset or true
	            return props.graded == null || props.graded;
	        });
	
	        var widgetScores = {};
	        _.each(gradedWidgetIds, function (id) {
	            var props = widgetProps[id];
	            var widget = _this16.getWidgetInstance(id);
	            if (!widget) {
	                // This can occur if the widget has not yet been rendered
	                return;
	            }
	            widgetScores[id] = widget.simpleValidate(props.options, onInputError);
	        });
	
	        return widgetScores;
	    },
	
	    /**
	     * Grades the content.
	     *
	     * Returns a perseus-style score of {
	     *     type: "invalid"|"points",
	     *     message: string,
	     *     earned: undefined|number,
	     *     total: undefined|number
	     * }
	     */
	    score: function score() {
	        return _.reduce(this.scoreWidgets(), Util.combineScores, Util.noScore);
	    },
	
	    guessAndScore: function guessAndScore() {
	        var totalGuess = this.getUserInput();
	        var totalScore = this.score();
	
	        return [totalGuess, totalScore];
	    },
	
	    examples: function examples() {
	        var widgets = this.widgetIds;
	        var examples = _.compact(_.map(widgets, function (widget) {
	            return widget.examples ? widget.examples() : null;
	        }));
	
	        // no widgets with examples
	        if (!examples.length) {
	            return null;
	        }
	
	        var allEqual = _.all(examples, function (example) {
	            return _.isEqual(examples[0], example);
	        });
	
	        // some widgets have different examples
	        // TODO(alex): handle this better
	        if (!allEqual) {
	            return null;
	        }
	
	        return examples[0];
	    },
	
	    // NotGorgon callback
	    handleNotGorgonLintErrors: function handleNotGorgonLintErrors(lintErrors) {
	        if (!this._isMounted) {
	            return;
	        }
	
	        this.setState({
	            notGorgonLintErrors: lintErrors
	        });
	    },
	
	    render: function render() {
	        var _classNames;
	
	        var apiOptions = this.getApiOptions();
	
	        if (this.reuseMarkdown) {
	            return this.lastRenderedMarkdown;
	        }
	
	        var content = this.getContent(this.props, this.state);
	        // `this.widgetIds` is appended to in `this.outputMarkdown`:
	        this.widgetIds = [];
	
	        if (this.shouldRenderJiptPlaceholder(this.props, this.state)) {
	            // Crowdin's JIPT (Just in place translation) uses a fake language
	            // with language tag "en-pt" where the value of the translations
	            // look like: {crwdns2657085:0}{crwdne2657085:0} where it keeps the
	            // {crowdinId:ngettext variant}. We detect whether the current
	            // content matches this, so we can take over rendering of
	            // the perseus content as the translators interact with jipt.
	            // We search for only part of the tag that crowdin uses to guard
	            // against them changing the format on us. The full tag it looks
	            // for can be found in https://cdn.crowdin.net/jipt/jipt.js
	            // globalPhrase var.
	
	            // If we haven't already added this component to the registry do so
	            // now. showHints() may cause this component to be rerendered
	            // before jipt has a chance to replace its contents, so this check
	            // will keep us from adding the component to the registry a second
	            // time.
	            if (!this.translationIndex) {
	                this.translationIndex = window.PerseusTranslationComponents.push(this) - 1;
	            }
	
	            // For articles, we add jipt data to individual paragraphs. For
	            // exercises, we add it to the renderer and let translators
	            // translate the entire thing. For the article equivalent of
	            // this if block, search this file for where we render a
	            // QuestionParagraph, and see the `isJipt:` parameter sent to
	            // PerseusMarkdown.parse()
	            if (!apiOptions.isArticle) {
	                // We now need to output this tag, as jipt looks for it to be
	                // able to replace it with a translation that it runs an ajax
	                // call to get.  We add a data attribute with the index to the
	                // Persues.TranslationComponent registry so that when jipt
	                // calls its before_dom_insert we can lookup this component by
	                // this attribute and render the text with markdown.
	                return React.createElement(
	                    "div",
	                    { "data-perseus-component-index": this.translationIndex },
	                    content
	                );
	            }
	        }
	
	        // Hacks:
	        // We use mutable state here to figure out whether the output
	        // had two columns.
	        // It is updated to true by `this.outputMarkdown` if a
	        // column break is found
	        // TODO(aria): We now have a state variable threaded through
	        // simple-markdown output. We should mutate it instead of
	        // state on this component to do this in a less hacky way.
	        this._isTwoColumn = false;
	
	        // Parse the string of markdown to a parse tree
	        var parsedMarkdown = PerseusMarkdown.parse(content, {
	            // Recognize crowdin IDs while translating articles
	            // (This should never be hit by exercises, though if you
	            // decide you want to add a check that this is an article,
	            // go for it.)
	            isJipt: this.translationIndex != null
	        });
	
	        // Optionally apply the linter to the parse tree
	        if (this.props.linterContext.highlightLint) {
	            // If highlightLint is true and lint is detected, this call
	            // will modify the parse tree by adding lint nodes that will
	            // serve to highlight the lint when rendered
	            var context = _extends({
	                content: this.props.content,
	                widgets: this.props.widgets
	            }, this.props.linterContext);
	
	            Gorgon.runLinter(parsedMarkdown, context, true);
	
	            // Apply the lint errors from the last NotGorgon run.
	            // TODO(joshuan): Support overlapping dots.
	            this.state.notGorgon.applyLintErrors(parsedMarkdown, [].concat(this.state.notGorgonLintErrors, this.props.legacyPerseusLint || []));
	        }
	
	        // Render the linted markdown parse tree with React components
	        var markdownContents = this.outputMarkdown(parsedMarkdown, {
	            baseElements: apiOptions.baseElements
	        });
	
	        var className = classNames((_classNames = {}, _classNames[ApiClassNames.RENDERER] = true, _classNames[ApiClassNames.RESPONSIVE_RENDERER] = true, _classNames[ApiClassNames.TWO_COLUMN_RENDERER] = this._isTwoColumn, _classNames));
	
	        this.lastRenderedMarkdown = React.createElement(
	            "div",
	            { className: className },
	            markdownContents
	        );
	        return this.lastRenderedMarkdown;
	    }
	});
	
	module.exports = Renderer;

/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {

	var _newHint;
	
	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var classnames = __webpack_require__(86);
	var i18n = window.i18n;
	
	var Renderer = __webpack_require__(37);
	
	var ApiOptions = __webpack_require__(12).Options;
	
	var mediaQueries = __webpack_require__(76);
	
	var _require2 = __webpack_require__(77),
	    baseUnitPx = _require2.baseUnitPx,
	    hintBorderWidth = _require2.hintBorderWidth,
	    kaGreen = _require2.kaGreen,
	    gray97 = _require2.gray97;
	
	var Gorgon = __webpack_require__(41);
	
	var _require3 = __webpack_require__(52),
	    linterContextProps = _require3.linterContextProps,
	    linterContextDefault = _require3.linterContextDefault;
	
	/* Renders just a hint preview */
	
	
	var HintRenderer = React.createClass({
	    displayName: "HintRenderer",
	
	    propTypes: {
	        apiOptions: ApiOptions.propTypes,
	        className: React.PropTypes.string,
	        hint: React.PropTypes.any,
	        lastHint: React.PropTypes.bool,
	        lastRendered: React.PropTypes.bool,
	        pos: React.PropTypes.number,
	        totalHints: React.PropTypes.number,
	        findExternalWidgets: React.PropTypes.func,
	        linterContext: linterContextProps
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            linterContext: linterContextDefault
	        };
	    },
	
	
	    getSerializedState: function getSerializedState() {
	        return this.refs.renderer.getSerializedState();
	    },
	
	    restoreSerializedState: function restoreSerializedState(state, callback) {
	        this.refs.renderer.restoreSerializedState(state, callback);
	    },
	
	    render: function render() {
	        var _props = this.props,
	            apiOptions = _props.apiOptions,
	            className = _props.className,
	            hint = _props.hint,
	            lastHint = _props.lastHint,
	            lastRendered = _props.lastRendered,
	            pos = _props.pos,
	            totalHints = _props.totalHints;
	        var isMobile = apiOptions.isMobile;
	
	
	        var classNames = classnames(!isMobile && "perseus-hint-renderer", isMobile && css(styles.newHint), isMobile && lastRendered && css(styles.lastRenderedNewHint), lastHint && "last-hint", lastRendered && "last-rendered", className);
	
	        // TODO(charlie): Allowing `staticRender` here would require that we
	        // extend `HintsRenderer` and `HintRenderer` to implement the full
	        // "input' API, so that clients could access the static inputs. Allowing
	        // `customKeypad` would require that we extend `ItemRenderer` to support
	        // nested inputs in the `HintsRenderer`. For now, we disable these
	        // options. Instead, clients will get standard <input/> elements, which
	        // aren't nice to use on mobile, but are at least usable.
	        var rendererApiOptions = _extends({}, apiOptions, {
	            customKeypad: false,
	            staticRender: false
	        });
	
	        return React.createElement(
	            "div",
	            { className: classNames, tabIndex: "-1" },
	            !apiOptions.isMobile && React.createElement(
	                "span",
	                { className: "perseus-sr-only" },
	                i18n._("Hint #%(pos)s", { pos: pos + 1 })
	            ),
	            !apiOptions.isMobile && !apiOptions.satStyling && totalHints && pos != null && React.createElement(
	                "span",
	                {
	                    className: "perseus-hint-label",
	                    style: {
	                        display: "block",
	                        color: apiOptions.hintProgressColor
	                    }
	                },
	                pos + 1 + " / " + totalHints
	            ),
	            React.createElement(Renderer, {
	                ref: "renderer",
	                widgets: hint.widgets,
	                content: hint.content || "",
	                images: hint.images,
	                apiOptions: rendererApiOptions,
	                findExternalWidgets: this.props.findExternalWidgets,
	                linterContext: Gorgon.pushContextStack(this.props.linterContext, "hint")
	            })
	        );
	    }
	});
	
	var styles = StyleSheet.create({
	    newHint: (_newHint = {
	        marginBottom: 1.5 * baseUnitPx,
	
	        borderLeftColor: gray97,
	        borderLeftStyle: "solid",
	        borderLeftWidth: hintBorderWidth
	
	    }, _newHint[mediaQueries.lgOrSmaller] = {
	        paddingLeft: baseUnitPx
	    }, _newHint[mediaQueries.smOrSmaller] = {
	        paddingLeft: 0
	    }, _newHint[":focus"] = {
	        outline: "none"
	    }, _newHint),
	
	    lastRenderedNewHint: {
	        marginBottom: 0,
	        borderLeftColor: kaGreen
	    }
	});
	
	module.exports = HintRenderer;

/***/ },
/* 39 */,
/* 40 */,
/* 41 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var _perseusMarkdown = __webpack_require__(49);
	
	var _perseusMarkdown2 = _interopRequireDefault(_perseusMarkdown);
	
	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _treeTransformer = __webpack_require__(85);
	
	var _treeTransformer2 = _interopRequireDefault(_treeTransformer);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	var allLintRules = __webpack_require__(87).filter(function (r) {
	    return r.severity < _rule2.default.Severity.BULK_WARNING;
	});
	
	//
	// Run the Gorgon linter over the specified markdown parse tree,
	// with the specified context object, and
	// return a (possibly empty) array of lint warning objects.  If the
	// highlight argument is true, this function also modifies the parse
	// tree to add "lint" nodes that can be visually rendered,
	// highlighting the problems for the user. The optional rules argument
	// is an array of Rule objects specifying which lint rules should be
	// applied to this parse tree. When omitted, a default set of rules is used.
	//
	// The context object may have additional properties that some lint
	// rules require:
	//
	//   context.content is the source content string that was parsed to create
	//   the parse tree.
	//
	//   context.widgets is the widgets object associated
	//   with the content string
	//
	// TODO: to make this even more general, allow the first argument to be
	// a string and run the parser over it in that case? (but ignore highlight
	// in that case). This would allow the one function to be used for both
	// online linting and batch linting.
	//
	function runLinter(tree, context, highlight, rules) {
	    rules = rules || allLintRules;
	    var warnings = [];
	    var tt = new _treeTransformer2.default(tree);
	
	    // The markdown parser often outputs adjacent text nodes. We
	    // coalesce them before linting for efficiency and accuracy.
	    tt.traverse(function (node, state, content) {
	        if (_treeTransformer2.default.isTextNode(node)) {
	            var next = state.nextSibling();
	            while (_treeTransformer2.default.isTextNode(next)) {
	                node.content += next.content;
	                state.removeNextSibling();
	                next = state.nextSibling();
	            }
	        }
	    });
	
	    // HTML tables are complicated, and the CSS we use in
	    // ../components/lint.jsx to display lint does not work to
	    // correctly position the lint indicators in the margin when the
	    // lint is inside a table. So as a workaround we keep track of all
	    // the lint that appears within a table and move it up to the
	    // table element itself.
	    //
	    // It is not ideal to have to do this here,
	    // but it is cleaner here than fixing up the lint during rendering
	    // in perseus-markdown.jsx. If our lint display was simpler and
	    // did not require indicators in the margin, this wouldn't be a
	    // problem. Or, if we modified the lint display stuff so that
	    // indicator positioning and tooltip display were both handled
	    // with JavaScript (instead of pure CSS), then we could avoid this
	    // issue too. But using JavaScript has its own downsides: there is
	    // risk that the linter JavaScript would interfere with
	    // widget-related Javascript.
	    var tableWarnings = [];
	    var insideTable = false;
	
	    // Traverse through the nodes of the parse tree. At each node, loop
	    // through the array of lint rules and check whether there is a
	    // lint violation at that node.
	    tt.traverse(function (node, state, content) {
	        var nodeWarnings = [];
	
	        // If our rule is only designed to be tested against a particular
	        // content type and we're not in that content type, we don't need to
	        // consider that rule.
	        var applicableRules = rules.filter(function (r) {
	            return r.applies(context);
	        });
	
	        // Generate a stack so we can identify our position in the tree in
	        // lint rules
	        var stack = [].concat(context.stack);
	        stack.push(node.type);
	
	        var nodeContext = _extends({}, context, {
	            stack: stack.join('.')
	        });
	
	        applicableRules.forEach(function (rule) {
	            var warning = rule.check(node, state, content, nodeContext);
	            if (warning) {
	                // The start and end locations are relative to this
	                // particular node, and so are not generally very useful.
	                // TODO: When the markdown parser saves the node
	                // locations in the source string then we can add
	                // these numbers to that one and get and absolute
	                // character range that will be useful
	                if (warning.start || warning.end) {
	                    warning.target = content.substring(warning.start, warning.end);
	                }
	
	                // Add the warning to the list of all lint we've found
	                warnings.push(warning);
	
	                // If we're going to be highlighting lint, then we also
	                // need to keep track of warnings specific to this node.
	                if (highlight) {
	                    nodeWarnings.push(warning);
	                }
	            }
	        });
	
	        // If we're not highlighting lint in the tree, then we're done
	        // traversing this node.
	        if (!highlight) {
	            return;
	        }
	
	        // If the node we are currently at is a table, and there was lint
	        // inside the table, then we want to add that lint here
	        if (node.type === "table") {
	            if (tableWarnings.length) {
	                nodeWarnings.push.apply(nodeWarnings, tableWarnings);
	            }
	
	            // We're not in a table anymore, and don't have to remember
	            // the warnings for the table
	            insideTable = false;
	            tableWarnings = [];
	        } else if (!insideTable) {
	            // Otherwise, if we are not already inside a table, check
	            // to see if we've entered one. Because this is a post-order
	            // traversal we'll see the table contents before the table itself.
	            // Note that once we're inside the table, we don't have to
	            // do this check each time... We can just wait until we ascend
	            // up to the table, then we'll know we're out of it.
	            insideTable = state.ancestors().some(function (n) {
	                return n.type === "table";
	            });
	        }
	
	        // If we are inside a table and there were any warnings on
	        // this node, then we need to save the warnings for display
	        // on the table itself
	        if (insideTable && nodeWarnings.length) {
	            var _tableWarnings;
	
	            (_tableWarnings = tableWarnings).push.apply(_tableWarnings, nodeWarnings);
	        }
	
	        // If there were any warnings on this node, and if we're highlighting
	        // lint, then reparent the node so we can highlight it. Note that
	        // a single node can have multiple warnings. If this happends we
	        // concatenate the warnings and newline separate them. (The lint.jsx
	        // component that displays the warnings may want to convert the
	        // newlines into <br> tags.) We also provide a lint rule name
	        // so that lint.jsx can link to a document that provides more details
	        // on that particular lint rule. If there is more than one warning
	        // we only link to the first rule, however.
	        //
	        // Note that even if we're inside a table, we still reparent the
	        // linty node so that it can be highlighted. We just make a note
	        // of whether this lint is inside a table or not.
	        if (nodeWarnings.length) {
	            nodeWarnings.sort(function (a, b) {
	                return a.severity - b.severity;
	            });
	
	            if (node.type !== "text" || nodeWarnings.length > 1) {
	                // If the linty node is not a text node, or if there is more
	                // than one warning on a text node, then reparent the entire
	                // node under a new lint node and put the warnings there.
	                state.replace({
	                    type: "lint",
	                    content: node,
	                    message: nodeWarnings.map(function (w) {
	                        return w.message;
	                    }).join("\n\n"),
	                    ruleName: nodeWarnings[0].rule,
	                    insideTable: insideTable,
	                    severity: nodeWarnings[0].severity
	                });
	            } else {
	                //
	                // Otherwise, it is a single warning on a text node, and we
	                // only want to highlight the actual linty part of that string
	                // of text. So we want to replace the text node with (in the
	                // general case) three nodes:
	                //
	                // 1) A new text node that holds the non-linty prefix
	                //
	                // 2) A lint node that is the parent of a new text node
	                // that holds the linty part
	                //
	                // 3) A new text node that holds the non-linty suffix
	                //
	                // If the lint begins and/or ends at the boundaries of the
	                // original text node, then nodes 1 and/or 3 won't exist, of
	                // course.
	                //
	                // Note that we could generalize this to work with multple
	                // warnings on a text node as long as the warnings are
	                // non-overlapping. Hopefully, though, multiple warnings in a
	                // single text node will be rare in practice. Also, we don't
	                // have a good way to display multiple lint indicators on a
	                // single line, so keeping them combined in that case might
	                // be the best thing, anyway.
	                //
	                var _content = node.content; // Text nodes have content
	                var warning = nodeWarnings[0]; // There is only one warning.
	                // These are the lint boundaries within the content
	                var start = warning.start || 0;
	                var end = warning.end || _content.length;
	                var prefix = _content.substring(0, start);
	                var lint = _content.substring(start, end);
	                var suffix = _content.substring(end);
	                var replacements = []; // What we'll replace the node with
	
	                // The prefix text node, if there is one
	                if (prefix) {
	                    replacements.push({
	                        type: "text",
	                        content: prefix
	                    });
	                }
	
	                // The lint node wrapped around the linty text
	                replacements.push({
	                    type: "lint",
	                    content: {
	                        type: "text",
	                        content: lint
	                    },
	                    message: warning.message,
	                    ruleName: warning.rule,
	                    insideTable: insideTable,
	                    severity: warning.severity
	                });
	
	                // The suffix node, if there is one
	                if (suffix) {
	                    replacements.push({
	                        type: "text",
	                        content: suffix
	                    });
	                }
	
	                // Now replace the lint text node with the one to three
	                // nodes in the replacement array
	                state.replace.apply(state, replacements);
	            }
	        }
	    });
	
	    return warnings;
	}
	
	function pushContextStack(context, name) {
	    var stack = context.stack || [];
	    return _extends({}, context, {
	        stack: stack.concat(name)
	    });
	}
	
	//
	// TODO(davidflanagan):
	// Revisit these exports once we've got gorgon integrated into Perseus.
	// Do we really need to export all of these things, or can we export a
	// smaller set of functionality to enable both bulk linting by tools/gorgon.js
	// and online linting?
	//
	// TODO(davidflanagan): switch from require to import
	//
	module.exports = {
	    runLinter: runLinter,
	    parse: _perseusMarkdown2.default.parse,
	    pushContextStack: pushContextStack,
	    rules: allLintRules
	};

/***/ },
/* 42 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;// From: hammerjs.github.io/touch-emulator/
	(function(window, document, exportName, undefined) {
	    "use strict";
	
	    var isMultiTouch = false;
	    var multiTouchStartPos;
	    var eventTarget;
	    var touchElements = {};
	
	    // polyfills
	    if(!document.createTouch) {
	        document.createTouch = function(view, target, identifier, pageX, pageY, screenX, screenY, clientX, clientY) {
	            // auto set
	            if(clientX == undefined || clientY == undefined) {
	                clientX = pageX - window.pageXOffset;
	                clientY = pageY - window.pageYOffset;
	            }
	
	            return new Touch(target, identifier, {
	                pageX: pageX,
	                pageY: pageY,
	                screenX: screenX,
	                screenY: screenY,
	                clientX: clientX,
	                clientY: clientY
	            });
	        };
	    }
	
	    if(!document.createTouchList) {
	        document.createTouchList = function() {
	            var touchList = new TouchList();
	            for (var i = 0; i < arguments.length; i++) {
	                touchList[i] = arguments[i];
	            }
	            touchList.length = arguments.length;
	            return touchList;
	        };
	    }
	
	    /**
	     * create an touch point
	     * @constructor
	     * @param target
	     * @param identifier
	     * @param pos
	     * @param deltaX
	     * @param deltaY
	     * @returns {Object} touchPoint
	     */
	    function Touch(target, identifier, pos, deltaX, deltaY) {
	        deltaX = deltaX || 0;
	        deltaY = deltaY || 0;
	
	        this.identifier = identifier;
	        this.target = target;
	        this.clientX = pos.clientX + deltaX;
	        this.clientY = pos.clientY + deltaY;
	        this.screenX = pos.screenX + deltaX;
	        this.screenY = pos.screenY + deltaY;
	        this.pageX = pos.pageX + deltaX;
	        this.pageY = pos.pageY + deltaY;
	    }
	
	    /**
	     * create empty touchlist with the methods
	     * @constructor
	     * @returns touchList
	     */
	    function TouchList() {
	        var touchList = [];
	
	        touchList.item = function(index) {
	            return this[index] || null;
	        };
	
	        // specified by Mozilla
	        touchList.identifiedTouch = function(id) {
	            return this[id + 1] || null;
	        };
	
	        return touchList;
	    }
	
	
	    /**
	     * Simple trick to fake touch event support
	     * this is enough for most libraries like Modernizr and Hammer
	     */
	    function fakeTouchSupport() {
	        var objs = [window, document.documentElement];
	        var props = ['ontouchstart', 'ontouchmove', 'ontouchcancel', 'ontouchend'];
	
	        for(var o=0; o<objs.length; o++) {
	            for(var p=0; p<props.length; p++) {
	                if(objs[o] && objs[o][props[p]] == undefined) {
	                    objs[o][props[p]] = null;
	                }
	            }
	        }
	    }
	
	    /**
	     * we don't have to emulate on a touch device
	     * @returns {boolean}
	     */
	    function hasTouchSupport() {
	        return ("ontouchstart" in window) || // touch events
	               (window.Modernizr && window.Modernizr.touch) || // modernizr
	               (navigator.msMaxTouchPoints || navigator.maxTouchPoints) > 2; // pointer events
	    }
	
	    /**
	     * disable mouseevents on the page
	     * @param ev
	     */
	    function preventMouseEvents(ev) {
	        ev.preventDefault();
	        ev.stopPropagation();
	    }
	
	    /**
	     * only trigger touches when the left mousebutton has been pressed
	     * @param touchType
	     * @returns {Function}
	     */
	    function onMouse(touchType) {
	        return function(ev) {
	            // prevent mouse events
	            preventMouseEvents(ev);
	
	            if (ev.which !== 1) {
	                return;
	            }
	
	            // The EventTarget on which the touch point started when it was first placed on the surface,
	            // even if the touch point has since moved outside the interactive area of that element.
	            // also, when the target doesnt exist anymore, we update it
	            if (ev.type == 'mousedown' || !eventTarget || (eventTarget && !eventTarget.dispatchEvent)) {
	                eventTarget = ev.target;
	            }
	
	            // shiftKey has been lost, so trigger a touchend
	            if (isMultiTouch && !ev.shiftKey) {
	                triggerTouch('touchend', ev);
	                isMultiTouch = false;
	            }
	
	            triggerTouch(touchType, ev);
	
	            // we're entering the multi-touch mode!
	            if (!isMultiTouch && ev.shiftKey) {
	                isMultiTouch = true;
	                multiTouchStartPos = {
	                    pageX: ev.pageX,
	                    pageY: ev.pageY,
	                    clientX: ev.clientX,
	                    clientY: ev.clientY,
	                    screenX: ev.screenX,
	                    screenY: ev.screenY
	                };
	                triggerTouch('touchstart', ev);
	            }
	
	            // reset
	            if (ev.type == 'mouseup') {
	                multiTouchStartPos = null;
	                isMultiTouch = false;
	                eventTarget = null;
	            }
	        }
	    }
	
	    /**
	     * trigger a touch event
	     * @param eventName
	     * @param mouseEv
	     */
	    function triggerTouch(eventName, mouseEv) {
	        var touchEvent = document.createEvent('Event');
	        touchEvent.initEvent(eventName, true, true);
	
	        touchEvent.altKey = mouseEv.altKey;
	        touchEvent.ctrlKey = mouseEv.ctrlKey;
	        touchEvent.metaKey = mouseEv.metaKey;
	        touchEvent.shiftKey = mouseEv.shiftKey;
	        touchEvent.which = 0;
	
	        touchEvent.touches = getActiveTouches(mouseEv, eventName);
	        touchEvent.targetTouches = getActiveTouches(mouseEv, eventName);
	        touchEvent.changedTouches = getChangedTouches(mouseEv, eventName);
	
	        eventTarget.dispatchEvent(touchEvent);
	    }
	
	    /**
	     * create a touchList based on the mouse event
	     * @param mouseEv
	     * @returns {TouchList}
	     */
	    function createTouchList(mouseEv) {
	        var touchList = new TouchList();
	
	        if (isMultiTouch) {
	            var f = TouchEmulator.multiTouchOffset;
	            var deltaX = multiTouchStartPos.pageX - mouseEv.pageX;
	            var deltaY = multiTouchStartPos.pageY - mouseEv.pageY;
	
	            touchList.push(new Touch(eventTarget, 1, multiTouchStartPos, (deltaX*-1) - f, (deltaY*-1) + f));
	            touchList.push(new Touch(eventTarget, 2, multiTouchStartPos, deltaX+f, deltaY-f));
	        } else {
	            touchList.push(new Touch(eventTarget, 1, mouseEv, 0, 0));
	        }
	
	        return touchList;
	    }
	
	    /**
	     * receive all active touches
	     * @param mouseEv
	     * @returns {TouchList}
	     */
	    function getActiveTouches(mouseEv, eventName) {
	        // empty list
	        if (mouseEv.type == 'mouseup') {
	            return new TouchList();
	        }
	
	        var touchList = createTouchList(mouseEv);
	        if(isMultiTouch && mouseEv.type != 'mouseup' && eventName == 'touchend') {
	            touchList.splice(1, 1);
	        }
	        return touchList;
	    }
	
	    /**
	     * receive a filtered set of touches with only the changed pointers
	     * @param mouseEv
	     * @param eventName
	     * @returns {TouchList}
	     */
	    function getChangedTouches(mouseEv, eventName) {
	        var touchList = createTouchList(mouseEv);
	
	        // we only want to return the added/removed item on multitouch
	        // which is the second pointer, so remove the first pointer from the touchList
	        //
	        // but when the mouseEv.type is mouseup, we want to send all touches because then
	        // no new input will be possible
	        if(isMultiTouch && mouseEv.type != 'mouseup' &&
	            (eventName == 'touchstart' || eventName == 'touchend')) {
	            touchList.splice(0, 1);
	        }
	
	        return touchList;
	    }
	
	    /**
	     * show the touchpoints on the screen
	     */
	    function showTouches(ev) {
	        var touch, i, el, styles;
	
	        // first all visible touches
	        for(i = 0; i < ev.touches.length; i++) {
	            touch = ev.touches[i];
	            el = touchElements[touch.identifier];
	            if(!el) {
	                el = touchElements[touch.identifier] = document.createElement("div");
	                document.body.appendChild(el);
	            }
	
	            styles = TouchEmulator.template(touch);
	            for(var prop in styles) {
	                el.style[prop] = styles[prop];
	            }
	        }
	
	        // remove all ended touches
	        if(ev.type == 'touchend' || ev.type == 'touchcancel') {
	            for(i = 0; i < ev.changedTouches.length; i++) {
	                touch = ev.changedTouches[i];
	                el = touchElements[touch.identifier];
	                if(el) {
	                    el.parentNode.removeChild(el);
	                    delete touchElements[touch.identifier];
	                }
	            }
	        }
	    }
	
	    /**
	     * TouchEmulator initializer
	     */
	    function TouchEmulator() {
	        if (hasTouchSupport()) {
	            return;
	        }
	
	        fakeTouchSupport();
	
	        window.addEventListener("mousedown", onMouse('touchstart'), true);
	        window.addEventListener("mousemove", onMouse('touchmove'), true);
	        window.addEventListener("mouseup", onMouse('touchend'), true);
	
	        window.addEventListener("mouseenter", preventMouseEvents, true);
	        window.addEventListener("mouseleave", preventMouseEvents, true);
	        window.addEventListener("mouseout", preventMouseEvents, true);
	        window.addEventListener("mouseover", preventMouseEvents, true);
	
	        // it uses itself!
	        window.addEventListener("touchstart", showTouches, false);
	        window.addEventListener("touchmove", showTouches, false);
	        window.addEventListener("touchend", showTouches, false);
	        window.addEventListener("touchcancel", showTouches, false);
	    }
	
	    // start distance when entering the multitouch mode
	    TouchEmulator.multiTouchOffset = 75;
	
	    /**
	     * css template for the touch rendering
	     * @param touch
	     * @returns object
	     */
	    TouchEmulator.template = function(touch) {
	        var size = 30;
	        var transform = 'translate('+ (touch.clientX-(size/2)) +'px, '+ (touch.clientY-(size/2)) +'px)';
	        return {
	            position: 'fixed',
	            left: 0,
	            top: 0,
	            background: '#fff',
	            border: 'solid 1px #999',
	            opacity: .6,
	            borderRadius: '100%',
	            height: size + 'px',
	            width: size + 'px',
	            padding: 0,
	            margin: 0,
	            display: 'block',
	            overflow: 'hidden',
	            pointerEvents: 'none',
	            webkitUserSelect: 'none',
	            mozUserSelect: 'none',
	            userSelect: 'none',
	            webkitTransform: transform,
	            mozTransform: transform,
	            transform: transform,
	        }
	    };
	
	    // export
	    if (true) {
	        !(__WEBPACK_AMD_DEFINE_RESULT__ = function() {
	            return TouchEmulator;
	        }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	    } else if (typeof module != "undefined" && module.exports) {
	        module.exports = TouchEmulator;
	    } else {
	        window[exportName] = TouchEmulator;
	    }
	})(window, document, "TouchEmulator");


/***/ },
/* 43 */
/***/ function(module, exports, __webpack_require__) {

	/* This note applies to jquery, react, and underscore.
	 *
	 * We're faking a node module for this package by just exporting the global.
	 * There are a few complications which led us to this solution as a temporary
	 * fix.
	 *
	 * - Browserify can slow down a lot when you include the other packages (and
	 *   their dependency graphs). We were also battling general browserify
	 *   slowness at this time - browserify 3.4.0 is "good" but later versions
	 *   (3.53 if I remember correctly) are terribly slow (on the order of 20x
	 *   slower).
	 *
	 * - I'm not clear on the details of packaging this so we don't duplicate
	 *   dependencies anywhere. For instance when packaging perseus for webapp we
	 *   need to be careful not to include packages like underscore from our
	 *   dependencies or from the packages we depend on. (note: this is a very good
	 *   opportunity to either explain how existing tools solve the problem or
	 *   create a new tool to solve it)
	 *
	 * - Joel (and Jack)
	 */
	module.exports = window.React;


/***/ },
/* 44 */
/***/ function(module, exports, __webpack_require__) {

	// This funky setup is dictated by how we build React in webapp currently. See
	// the khan/react-build repo.
	module.exports = window.React.__internalReactDOM;


/***/ },
/* 45 */,
/* 46 */,
/* 47 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Icon paths to be used with `inline-icon.jsx`.
	 *
	 * These paths are taken directly from webapp's `icon-paths.js`. Unlike the
	 * webapp equivalent, these can be directly required within Perseus files since
	 * this is all bundled together anyway.
	 */
	
	/* eslint-disable max-len */
	module.exports = {
	    iconCheck: {
	        path: "M8.70710678,12.2928932 C8.31658249,11.9023689 7.68341751,11.9023689 7.29289322,12.2928932 C6.90236893,12.6834175 6.90236893,13.3165825 7.29289322,13.7071068 L9.82842712,16.2426407 C10.2207367,16.6349502 10.8574274,16.6328935 11.2471942,16.2380576 L16.7116603,10.7025237 C17.0996535,10.3094846 17.0955629,9.67633279 16.7025237,9.28833966 C16.3094846,8.90034653 15.6763328,8.90443714 15.2883397,9.29747629 L10.5309507,14.1167372 L8.70710678,12.2928932 Z",
	        width: 24,
	        height: 24
	    },
	    iconChevronDown: {
	        path: "M99.669 13.048q0 3.36-2.352 5.712l-41.664 41.664q-2.408 2.408-5.88 2.408t-5.712-2.408l-41.664-41.664q-2.408-2.24-2.408-5.712t2.408-5.88l4.76-4.816q2.52-2.352 5.88-2.352t5.656 2.352l31.136 31.136 31.08-31.136q2.352-2.352 5.712-2.352t5.88 2.352l4.816 4.816q2.352 2.52 2.352 5.88z",
	        width: 100,
	        height: 63.034
	    },
	    iconChevronRight: {
	        path: "M62.808 49.728q0 3.36-2.352 5.88l-41.72 41.664q-2.352 2.408-5.768 2.408t-5.768-2.408l-4.872-4.76q-2.352-2.52-2.352-5.88t2.352-5.712l31.08-31.136-31.08-31.024q-2.352-2.52-2.352-5.88t2.352-5.712l4.872-4.76q2.296-2.408 5.768-2.408t5.768 2.408l41.72 41.664q2.352 2.296 2.352 5.656z",
	        width: 63.034,
	        height: 100
	    },
	    iconCircle: {
	        path: "M100.035 50.046q.057 13.623-6.669 25.137t-18.24 18.183-25.08 6.669-25.137-6.726q-11.514-6.726-18.183-18.183-6.726-11.571-6.726-25.137t6.726-25.08 18.24-18.24 25.08-6.669q13.566 0 25.08 6.726 11.514 6.669 18.24 18.183t6.669 25.137z",
	        width: 100,
	        height: 100
	    },
	    iconCircleArrowDown: {
	        path: "M50.046 83.676q1.767 0 2.907-1.14l29.526-29.526q1.197-1.197 1.197-2.907t-1.197-2.964l-5.928-5.928q-1.197-1.14-2.964-1.14t-2.907 1.14l-12.312 12.312l0-32.661q0-1.71-1.254-2.964t-2.907-1.254l-8.322 0q-1.71 0-2.964 1.254t-1.254 2.964l0 32.661l-12.312-12.312q-1.197-1.254-2.907-1.254t-2.907 1.254l-5.928 5.928q-1.197 1.197-1.197 2.964t1.197 2.907l29.469 29.526q1.197 1.14 2.964 1.14zm49.989-33.63q.057 13.623-6.669 25.137t-18.24 18.183-25.08 6.669-25.137-6.726q-11.514-6.726-18.183-18.183-6.726-11.571-6.726-25.137t6.726-25.08 18.24-18.24 25.08-6.669q13.566 0 25.08 6.726 11.514 6.669 18.24 18.183t6.669 25.137z",
	        width: 100,
	        height: 100
	    },
	    iconCircleArrowUp: {
	        path: "M54.207 83.391q1.653 0 2.907-1.254t1.254-2.907l0-32.718l12.312 12.312q1.254 1.254 2.964 1.254t2.907-1.254l5.928-5.928q1.197-1.197 1.14-2.964 0-1.767-1.14-2.907l-29.526-29.526q-1.197-1.14-2.907-1.14t-2.964 1.14l-29.469 29.526q-1.197 1.254-1.197 2.964t1.197 2.907l5.928 5.928q1.197 1.197 2.907 1.197t2.907-1.197l12.312-12.312l0 32.718q0 1.653 1.254 2.907t2.964 1.254l8.322 0zm45.828-33.345q.057 13.623-6.669 25.137t-18.24 18.183-25.08 6.669-25.137-6.726q-11.514-6.726-18.183-18.183-6.726-11.571-6.726-25.137t6.726-25.08 18.24-18.24 25.08-6.669q13.566 0 25.08 6.726 11.514 6.669 18.24 18.183t6.669 25.137z",
	        width: 100,
	        height: 100
	    },
	    iconCircleThin: {
	        path: "M50.046 8.322q-8.493 0-16.188 3.306-15.561 6.669-22.173 22.23-3.363 7.695-3.363 16.188t3.306 16.188 8.949 13.281q5.586 5.586 13.281 8.892t16.188 3.306 16.188-3.306 13.281-8.892 8.892-13.281 3.306-16.188-3.306-16.188-8.892-13.281-13.281-8.949q-7.695-3.306-16.188-3.306zm0 91.713q-13.623 0-25.137-6.726t-18.183-18.183q-6.726-11.571-6.726-25.137t6.726-25.08 18.24-18.24 25.08-6.669q13.566 0 25.08 6.726 11.514 6.669 18.24 18.183t6.726 25.137-6.726 25.137-18.24 18.126q-11.514 6.726-25.08 6.726z",
	        width: 100,
	        height: 99.944
	    },
	    iconDesktop: {
	        path: "M94.208 52.119l0-43.746q0-.69-.506-1.15t-1.196-.506l-84.088 0q-.69 0-1.196.506t-.506 1.15l0 43.746q0 .69.506 1.196t1.196.506l84.088 0q.69 0 1.196-.506t.506-1.196zm6.716-43.746l0 57.224q0 3.45-2.484 5.934t-5.934 2.484l-28.566 0q0 3.128 2.53 7.774.828 1.61.828 2.622t-1.012 2.07q-1.012 1.012-2.346.966l-26.91 0q-1.38 0-2.392-1.012t-1.012-2.024q0-1.058 1.656-4.14t1.748-6.256l-28.612 0q-3.45 0-5.934-2.484t-2.484-5.934l0-57.224q0-3.45 2.484-5.934t5.934-2.438l84.088 0q3.45 0 5.98 2.438 2.438 2.484 2.438 5.934z",
	        width: 100,
	        height: 86.648
	    },
	    iconDropdownArrow: {
	        path: "M9 9.8c0 .5.7 1.7 1.5 2.8 1.5 1.9 1.5 1.9 3 0C15.7 9.7 15.4 9 12 9c-1.6 0-3 .4-3 .8z",
	        width: 24,
	        height: 24
	    },
	    iconExclamationSign: {
	        path: "M58.368 81.225l0-12.369q0-.912-.57-1.539t-1.425-.627l-12.54 0q-.855-.057-1.482.627t-.684 1.539l0 12.369q-.057.855.627 1.482t1.539.684l12.54 0q.855 0 1.425-.627t.57-1.539zm1.026-62.871q0-1.596-2.223-1.71l-14.307 0q-2.109 0-2.223 1.71l1.14 40.47q0 .627.627 1.14t1.539.456l12.084 0q.912-.057 1.539-.513t.684-1.083zm-9.348-18.354q13.566 0 25.08 6.726 11.514 6.669 18.24 18.183t6.726 25.137-6.726 25.137-18.24 18.183-25.08 6.669-25.137-6.726q-11.514-6.726-18.183-18.183-6.726-11.571-6.726-25.137t6.726-25.08 18.24-18.24 25.08-6.669z",
	        width: 100,
	        height: 99.944
	    },
	    // Grabbed from https://github.com/encharm/Font-Awesome-SVG-PNG
	    iconGear: {
	        path: "M1152 896q0-106-75-181t-181-75-181 75-75 181 75 181 181 75 181-75 75-181zm512-109v222q0 12-8 23t-20 13l-185 28q-19 54-39 91 35 50 107 138 10 12 10 25t-9 23q-27 37-99 108t-94 71q-12 0-26-9l-138-108q-44 23-91 38-16 136-29 186-7 28-36 28h-222q-14 0-24.5-8.5t-11.5-21.5l-28-184q-49-16-90-37l-141 107q-10 9-25 9-14 0-25-11-126-114-165-168-7-10-7-23 0-12 8-23 15-21 51-66.5t54-70.5q-27-50-41-99l-183-27q-13-2-21-12.5t-8-23.5v-222q0-12 8-23t19-13l186-28q14-46 39-92-40-57-107-138-10-12-10-24 0-10 9-23 26-36 98.5-107.5t94.5-71.5q13 0 26 10l138 107q44-23 91-38 16-136 29-186 7-28 36-28h222q14 0 24.5 8.5t11.5 21.5l28 184q49 16 90 37l142-107q9-9 24-9 13 0 25 10 129 119 165 170 7 8 7 22 0 12-8 23-15 21-51 66.5t-54 70.5q26 50 41 98l183 28q13 2 21 12.5t8 23.5z",
	        width: 1792,
	        height: 1792
	    },
	    iconMobilePhone: {
	        path: "M36.04 89.557q0-2.584-1.836-4.42t-4.42-1.836-4.352 1.836q-1.836 1.836-1.836 4.42t1.836 4.352 4.42 1.836q2.652-.068 4.42-1.836t1.768-4.352zm16.184-12.444l0-54.74q0-1.088-.748-1.768t-1.768-.68l-39.78 0q-1.088 0-1.768.748t-.68 1.7l0 54.74q0 1.02.748 1.768t1.7.68l39.78 0q1.02-.068 1.768-.748t.748-1.7zm-14.892-65.892q0-1.224-1.292-1.292l-12.444 0q-1.224.068-1.224 1.292t1.224 1.224l12.444 0q1.292 0 1.292-1.224zm22.372-1.292l0 79.628q0 3.944-2.992 6.936t-7.004 2.992l-39.78 0q-4.012 0-7.004-2.924-2.924-2.924-2.924-7.004l0-79.628q0-4.012 2.924-6.936t7.004-2.992l39.78 0q4.012-.068 7.004 2.924t2.992 7.004z",
	        width: 60.013,
	        height: 100
	    },
	    iconOk: {
	        path: "M37.964 76.048q-2.576 0-4.368-1.792l-31.864-31.864q-1.792-1.792-1.792-4.368t1.792-4.368l8.736-8.68q1.792-1.792 4.368-1.792t4.312 1.792l18.816 18.872 42-42.056q1.792-1.792 4.368-1.792t4.312 1.792l8.736 8.736q1.792 1.792 1.792 4.368t-1.792 4.312l-55.048 55.048q-1.792 1.792-4.368 1.792z",
	        width: 100,
	        height: 76.637
	    },
	    iconPlus: {
	        path: "M99.758 43.09l0 13.578q0 2.852-1.984 4.836t-4.836 1.984l-29.45 0l0 29.45q0 2.852-1.984 4.836t-4.836 1.984l-13.578 0q-2.852 0-4.836-1.984t-1.984-4.836l0-29.45l-29.45 0q-2.852 0-4.836-1.984t-1.984-4.836l0-13.578q0-2.852 1.984-4.836t4.836-1.984l29.45 0l0-29.45q0-2.852 1.984-4.836t4.836-1.984l13.578 0q2.852 0 4.836 1.984t1.984 4.836l0 29.45l29.45 0q2.852 0 4.836 1.984t1.984 4.836z",
	        width: 100,
	        height: 100
	    },
	    iconRemove: {
	        path: "M100.464 80.808q0 3.404-2.368 5.772l-11.47 11.544q-2.368 2.368-5.772 2.368t-5.698-2.368l-24.864-24.864-24.864 24.864q-2.368 2.368-5.772 2.368t-5.772-2.368l-11.47-11.544q-2.368-2.368-2.368-5.772t2.368-5.698l24.864-24.864-24.864-24.864q-2.368-2.368-2.368-5.772t2.368-5.772l11.47-11.47q2.368-2.368 5.772-2.368t5.772 2.368l24.864 24.864 24.864-24.864q2.294-2.368 5.698-2.368t5.772 2.368l11.47 11.47q2.368 2.368 2.368 5.772t-2.368 5.772l-24.864 24.864 24.864 24.864q2.368 2.294 2.368 5.698z",
	        width: 100,
	        height: 100
	    },
	    iconStar: {
	        path: "M15.1052249,9.55978547 L22.0028147,9.55978545 C23.6568673,9.55978545 23.9349557,10.3753626 22.6181351,11.3858845 L16.9943688,15.7015366 L19.2518801,22.8294455 C19.7526645,24.4106317 19.0984455,24.8825885 17.769353,23.8673293 L12.0490577,19.4977438 L6.5116497,23.8422153 C5.20921411,24.8640642 4.53299569,24.4067544 5.00266927,22.8160582 L7.10332364,15.7015366 L1.42794544,11.3634306 C0.110226041,10.3562014 0.383967283,9.54239221 2.0409646,9.54574013 L8.9924676,9.55978547 L11.1485117,2.72669438 C11.6458693,1.15043244 12.4548928,1.15900049 12.9494787,2.72669438 L15.1052249,9.55978547 Z",
	        width: 24,
	        height: 24
	    },
	    iconTryAgain: {
	        path: "M3.74890556,17.9799506 C2.19251241,16.1970909 1.10103636,13.4971457 1.13090903,11.1491783 C1.17160478,7.95052637 4.01704076,0.865059407 11.7028044,0.865059407 C19.388568,0.865059407 22.3026521,7.35203035 22.3026521,11.5879453 C22.3026521,15.8238603 19.386629,20.5574509 13.6832464,21.7131548 L13.6757539,17.3722171 C17.0812986,16.2190517 18.331158,14.1944123 18.3311578,11.5879451 C18.3311574,8.16554692 15.6664205,5.03476549 11.7028048,5.20494205 C7.73918903,5.37511861 5.59244567,8.66930079 5.59244567,11.1491783 C5.59244567,12.9090077 6.11128139,14.1753512 6.93640437,15.3053215 L8.14052356,14.2949456 C8.98559348,13.5858477 9.6994861,13.9070448 9.73489556,15.0076413 L9.91284941,20.5388014 C9.94832683,21.6415103 9.09967118,22.3514475 8.02194403,22.1254594 L2.60571602,20.9897332 C1.5259204,20.7633114 1.34338662,19.9984207 2.18070755,19.295825 L3.74890556,17.9799506 Z",
	        width: 23,
	        height: 23
	    },
	    iconTablet: {
	        path: "M45.322 90.706q0-1.86-1.302-3.224-1.364-1.364-3.224-1.364t-3.224 1.364-1.302 3.224q0 1.86 1.364 3.224 1.302 1.364 3.162 1.302 1.86.062 3.224-1.302t1.302-3.224zm27.218-11.346l0-68.014q0-.93-.682-1.612t-1.55-.682l-58.962 0q-.93 0-1.612.682t-.682 1.612l0 68.014q0 .93.682 1.612t1.612.62l58.962 0q.992-.062 1.612-.682t.62-1.55zm9.114-68.014l0 77.066q0 4.65-3.348 7.998t-7.998 3.348l-58.962 0q-4.65 0-7.998-3.348t-3.348-7.998l0-77.066q0-4.65 3.348-7.998t7.998-3.348l58.962 0q4.65 0 7.998 3.348t3.348 7.998z",
	        width: 81.852,
	        height: 100
	    },
	    iconTrash: {
	        path: "M31.293 37.506q2.052 0 2.052 2.109l0 37.506q0 1.995-2.052 2.109l-4.218 0q-.912-.057-1.482-.627t-.57-1.482l0-37.506q0-2.109 2.052-2.109l4.218 0zm18.753 2.109l0 37.506q0 .912-.57 1.482t-1.539.627l-4.161 0q-1.995 0-2.109-2.109l0-37.506q.057-.912.627-1.482t1.482-.627l4.161 0q.969.057 1.539.627t.57 1.482zm14.592-2.109q2.052 0 2.052 2.109l0 37.506q0 1.995-2.052 2.109l-4.161 0q-.969-.057-1.539-.627t-.57-1.482l0-37.506q0-2.109 2.109-2.109l4.161 0zm10.431 49.248l0-61.731l-58.368 0l0 61.731q.057 2.679.969 3.819t1.083 1.14l54.207 0q.171 0 1.14-1.083t.969-3.876zm-43.776-70.11l29.184 0l-3.135-7.581q-.456-.57-1.14-.741l-20.634 0q-.627.114-1.083.741zm-31.293 2.109q0-1.995 2.109-2.109l20.121 0l4.56-10.83q.969-2.394 3.477-4.104 2.565-1.71 5.187-1.71l20.805 0q2.622 0 5.187 1.71t3.477 4.104l4.56 10.83l20.178 0q.912.057 1.482.627t.57 1.482l0 4.161q0 1.995-2.052 2.109l-6.27 0l0 61.731q0 5.415-3.078 9.348t-7.353 3.933l-54.207 0q-4.275 0-7.353-3.819t-3.078-9.177l0-62.016l-6.213 0q-.969 0-1.539-.57t-.57-1.539l0-4.161z",
	        width: 91.681,
	        height: 100
	    },
	    iconUndo: {
	        path: "M10,6.6C10,7.2,9.8,8,9.3,9.1c0,0,0,0.1-0.1,0.1S9.2,9.3,9.2,9.4c0,0,0,0.1-0.1,0.1C9,9.6,9,9.6,8.9,9.6 c-0.1,0-0.1,0-0.1-0.1c0,0,0-0.1,0-0.1c0,0,0-0.1,0-0.1s0-0.1,0-0.1c0-0.3,0-0.5,0-0.7c0-0.4,0-0.7-0.1-1C8.6,7.1,8.5,6.9,8.4,6.7S8.2,6.3,8,6.1C7.8,5.9,7.6,5.8,7.4,5.7S6.9,5.5,6.7,5.5S6.1,5.4,5.8,5.4c-0.3,0-0.6,0-1,0H3.6v1.4c0,0.1,0,0.2-0.1,0.3C3.4,7.1,3.3,7.1,3.2,7.1C3.1,7.1,3,7.1,3,7L0.1,4.1C0,4.1,0,4,0,3.9s0-0.2,0.1-0.3L3,0.8C3,0.7,3.1,0.7,3.2,0.7c0.1,0,0.2,0,0.3,0.1C3.5,0.9,3.6,0.9,3.6,1v1.4h1.2c2.6,0,4.3,0.7,4.9,2.2C9.9,5.2,10,5.8,10,6.6z",
	        width: 10,
	        height: 10
	    },
	    iconMinus: {
	        path: "M8,13 L16,13 C16.5522847,13 17,12.5522847 17,12 C17,11.4477153 16.5522847,11 16,11 L8,11 C7.44771525,11 7,11.4477153 7,12 C7,12.5522847 7.44771525,13 8,13 Z",
	        width: 24,
	        height: 24
	    }
	};

/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable react/forbid-prop-types */
	
	/**
	 * A stripped version of Icon.jsx from webapp. Takes an SVG icon and renders it
	 * inline like Font Awesome did.
	 *
	 * If you are looking for an icon that we've used before you should look in
	 * webapp's `icon-paths.js` which is a reference file for all the SVG paths
	 * that we've used. You'll need to copy the object from that file into
	 * whichever file you're using the icon and explicitly pass it in to the
	 * <InlineIcon/> React component.
	 *
	 * We assume that the viewBox is cropped and aligned to (0, 0), but icons can
	 * be defined differently. At some point we might want to add these attributes
	 * to `icon-paths.js`, but for now this is a fairly safe assumption.
	 *
	 * Sample usage:
	 *
	 *   const editIcon = {
	 *      path: "M41.209 53.753l5.39 0l0 5.39l3.136 0l6.468-6.517-8.477-8.526-6.517 6.517l0 3.136zm33.173-34.937q-.882-.882-1.862.049l-19.6 19.6q-.931.98-.049 1.862t1.862-.049l19.6-19.6q.931-.98.049-1.862zm-38.563 45.668l0-16.121l37.632-37.632 16.17 16.121-37.632 37.632l-16.17 0zm43.022-12.397l0 10.633q-.049 6.713-4.753 11.417t-11.368 4.704l-46.599 0q-6.713 0-11.417-4.753t-4.704-11.368l0-46.599q0-6.664 4.753-11.417t11.368-4.704l46.599 0q3.528 0 6.566 1.372.833.392.98 1.323t-.49 1.617l-2.744 2.744q-.784.784-1.96.441t-2.352-.343l-46.599 0q-3.675 0-6.321 2.646t-2.646 6.321l0 46.599q0 3.675 2.646 6.321t6.321 2.646l46.599 0q3.675 0 6.321-2.646t2.646-6.321l0-7.056q0-.735.49-1.225l3.577-3.577q.833-.833 1.96-.392t1.127 1.617zm7.203-51.646q2.254 0 3.773 1.568l8.526 8.526q1.568 1.568 1.568 3.822t-1.568 3.773l-5.145 5.145-16.121-16.121 5.145-5.145q1.568-1.568 3.822-1.568z", // @Nolint
	 *      width: 100,
	 *      height: 78.912,
	 *   };
	 *   <InlineIcon {...editIcon} />
	 *
	 */
	var React = __webpack_require__(43);
	
	var InlineIcon = function InlineIcon(_ref) {
	    var path = _ref.path,
	        width = _ref.width,
	        height = _ref.height,
	        _ref$style = _ref.style,
	        style = _ref$style === undefined ? {} : _ref$style,
	        title = _ref.title;
	    return React.createElement(
	        "svg",
	        {
	            role: "img",
	            "aria-hidden": !title,
	            style: _extends({ verticalAlign: "middle" }, style),
	            width: width / height + "em",
	            height: "1em",
	            viewBox: "0 0 " + width + " " + height
	        },
	        !!title && React.createElement(
	            "title",
	            null,
	            title
	        ),
	        React.createElement("path", { d: path, fill: "currentColor" })
	    );
	};
	
	InlineIcon.propTypes = {
	    // An SVG path to render.
	    path: React.PropTypes.string.isRequired,
	
	    // The path's viewBox dimensions.
	    // We set the viewport height to 1em and scale the width accordingly.
	    height: React.PropTypes.number.isRequired,
	    width: React.PropTypes.number.isRequired,
	
	    style: React.PropTypes.object,
	
	    // A11y description for this icon. If absent, icon is marked
	    // aria-hidden=true
	    title: React.PropTypes.string
	};
	/* eslint-enable react/jsx-sort-prop-types */
	
	module.exports = InlineIcon;

/***/ },
/* 49 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable no-var, object-curly-spacing */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	/* globals KA */
	var _ = __webpack_require__(56);
	
	var SimpleMarkdown = __webpack_require__(260);
	var TeX = __webpack_require__(178);
	var Util = __webpack_require__(17);
	var Lint = __webpack_require__(179);
	
	/**
	 * This match function matches math in `$`s, such as:
	 *
	 * $y = x + 1$
	 *
	 * It functions roughly like the following regex:
	 * /\$([^\$]*)\$/
	 *
	 * Unfortunately, math may have other `$`s inside it, as
	 * long as they are inside `{` braces `}`, mostly for
	 * `\text{ $math$ }`.
	 *
	 * To parse this, we can't use a regex, since we
	 * should support arbitrary nesting (even though
	 * MathJax actually only supports two levels of nesting
	 * here, which we *could* parse with a regex).
	 *
	 * Non-regex matchers like this are now a first-class
	 * concept in simple-markdown. Yay!
	 *
	 * This can also match block-math, which is math alone in a paragraph.
	 */
	var mathMatcher = function mathMatcher(source, state, isBlock) {
	    var length = source.length;
	    var index = 0;
	
	    // When looking for blocks, skip over leading spaces
	    if (isBlock) {
	        if (state.inline) {
	            return null;
	        }
	        while (index < length && source[index] === " ") {
	            index++;
	        }
	    }
	
	    // Our source must start with a "$"
	    if (!(index < length && source[index] === "$")) {
	        return null;
	    }
	
	    index++;
	    var startIndex = index;
	    var braceLevel = 0;
	
	    // Loop through the source, looking for a closing '$'
	    // closing '$'s only count if they are not escaped with
	    // a `\`, and we are not in nested `{}` braces.
	    while (index < length) {
	        var character = source[index];
	
	        if (character === "\\") {
	            // Consume both the `\` and the escaped char as a single
	            // token.
	            // This is so that the second `$` in `$\\$` closes
	            // the math expression, since the first `\` is escaping
	            // the second `\`, but the second `\` is not escaping
	            // the second `$`.
	            // This also handles the case of escaping `$`s or
	            // braces `\{`
	            index++;
	        } else if (braceLevel <= 0 && character === "$") {
	            var endIndex = index + 1;
	            if (isBlock) {
	                // Look for two trailing newlines after the closing `$`
	                var match = /^(?: *\n){2,}/.exec(source.slice(endIndex));
	                endIndex = match ? endIndex + match[0].length : null;
	            }
	
	            // Return an array that looks like the results of a
	            // regex's .exec function:
	            // capture[0] is the whole string
	            // capture[1] is the first "paren" match, which is the
	            //   content of the math here, as if we wrote the regex
	            //   /\$([^\$]*)\$/
	            if (endIndex) {
	                return [source.substring(0, endIndex), source.substring(startIndex, index)];
	            }
	            return null;
	        } else if (character === "{") {
	            braceLevel++;
	        } else if (character === "}") {
	            braceLevel--;
	        } else if (character === "\n" && source[index - 1] === "\n") {
	            // This is a weird case we supported in the old
	            // math implementation--double newlines break
	            // math. I'm preserving it for now because content
	            // creators might have questions with single '$'s
	            // in paragraphs...
	            return null;
	        }
	
	        index++;
	    }
	
	    // we didn't find a closing `$`
	    return null;
	};
	var mathMatch = function mathMatch(source, state) {
	    return mathMatcher(source, state, false);
	};
	var blockMathMatch = function blockMathMatch(source, state) {
	    return mathMatcher(source, state, true);
	};
	
	var TITLED_TABLE_REGEX = new RegExp("^\\|\\| +(.*) +\\|\\| *\\n" + "(" +
	// The simple-markdown nptable regex, without
	// the leading `^`
	SimpleMarkdown.defaultRules.nptable.match.regex.source.substring(1) + ")");
	
	var crowdinJiptMatcher = SimpleMarkdown.blockRegex(/^(crwdns.*)\n\s*\n/);
	
	var rules = _.extend({}, SimpleMarkdown.defaultRules, {
	    // NOTE: basically ignored by JIPT. wraps everything at the outer layer
	    columns: {
	        order: -2,
	        match: SimpleMarkdown.blockRegex(/^([\s\S]*\n\n)={5,}\n\n([\s\S]*)/),
	        parse: function parse(capture, _parse, state) {
	            return {
	                col1: _parse(capture[1], state),
	                col2: _parse(capture[2], state)
	            };
	        },
	        react: function react(node, output, state) {
	            return React.createElement(
	                "div",
	                { className: "perseus-two-columns", key: state.key },
	                React.createElement(
	                    "div",
	                    { className: "perseus-column" },
	                    React.createElement(
	                        "div",
	                        { className: "perseus-column-content" },
	                        output(node.col1, state)
	                    )
	                ),
	                React.createElement(
	                    "div",
	                    { className: "perseus-column" },
	                    React.createElement("div", { className: "sat-header-grafting-area" }),
	                    React.createElement(
	                        "div",
	                        { className: "perseus-column-content" },
	                        React.createElement("div", { className: "sat-skill-subscore-grafting-area" }),
	                        output(node.col2, state),
	                        React.createElement("div", { className: "sat-grafting-area" })
	                    )
	                )
	            );
	        }
	    },
	    // Match paragraphs consisting solely of crowdin IDs
	    // (they look roughly like crwdns9238932:0), which means that
	    // crowdin is going to take the DOM node that ID is rendered into
	    // and count it as the top-level translation node. They mutate this
	    // node, so we need to make sure it is an outer node, not an inner
	    // span. So here we parse this separately and just output the
	    // raw string, which becomes the body of the <QuestionParagraph>
	    // created by the Renderer.
	    // This currently (2015-09-01) affects only articles, since
	    // for exercises the renderer just renders the crowdin id to the
	    // renderer div.
	    crowdinId: {
	        order: -1,
	        match: function match(source, state, prevCapture) {
	            // Only match on the just-in-place translation site
	            if (state.isJipt) {
	                return crowdinJiptMatcher(source, state, prevCapture);
	            } else {
	                return null;
	            }
	        },
	        parse: function parse(capture, _parse2, state) {
	            return { id: capture[1] };
	        },
	        react: function react(node, output, state) {
	            return node.id;
	        }
	    },
	    // This is pretty much horrible, but we have a regex here to capture an
	    // entire table + a title. capture[1] is the title. capture[2] of the
	    // regex is a copy of the simple-markdown nptable regex. Then we turn
	    // our capture[2] into tableCapture[0], and any further captures in
	    // our table regex into tableCapture[1..], and we pass tableCapture to
	    // our nptable regex
	    titledTable: {
	        // process immediately before nptables
	        order: SimpleMarkdown.defaultRules.nptable.order - 0.5,
	        match: SimpleMarkdown.blockRegex(TITLED_TABLE_REGEX),
	        parse: function parse(capture, _parse3, state) {
	            var title = SimpleMarkdown.parseInline(_parse3, capture[1], state);
	
	            // Remove our [0] and [1] captures, and pass the rest to
	            // the nptable parser
	            var tableCapture = _.rest(capture, 2);
	            var table = SimpleMarkdown.defaultRules.nptable.parse(tableCapture, _parse3, state);
	            return {
	                title: title,
	                table: table
	            };
	        },
	        react: function react(node, output, state) {
	            var contents = void 0;
	            if (!node.table) {
	                contents = "//invalid table//";
	            } else {
	                var tableOutput = SimpleMarkdown.defaultRules.table.react(node.table, output, state);
	
	                var caption = React.createElement(
	                    "caption",
	                    { key: "caption", className: "perseus-table-title" },
	                    output(node.title, state)
	                );
	
	                // Splice the caption into the table's children with the
	                // caption as the first child.
	                contents = React.cloneElement(tableOutput, null, [caption].concat(tableOutput.props.children));
	            }
	
	            // Note: if the DOM structure changes, edit the Zoomable wrapper
	            // in src/renderer.jsx.
	            return React.createElement(
	                "div",
	                { className: "perseus-titled-table", key: state.key },
	                contents
	            );
	        }
	    },
	    widget: {
	        order: SimpleMarkdown.defaultRules.link.order - 0.75,
	        match: SimpleMarkdown.inlineRegex(Util.rWidgetRule),
	        parse: function parse(capture, _parse4, state) {
	            return {
	                id: capture[1],
	                widgetType: capture[2]
	            };
	        },
	        react: function react(node, output, state) {
	            // The actual output is handled in the renderer, where
	            // we know the current widget props/state. This is
	            // just a stub for testing.
	            return React.createElement(
	                "em",
	                { key: state.key },
	                "[Widget: ",
	                node.id,
	                "]"
	            );
	        }
	    },
	    blockMath: {
	        order: SimpleMarkdown.defaultRules.codeBlock.order + 0.5,
	        match: blockMathMatch,
	        parse: function parse(capture, _parse5, state) {
	            return {
	                content: capture[1]
	            };
	        },
	        react: function react(node, output, state) {
	            // The actual output is handled in the renderer, because
	            // it needs to pass in an `onRender` callback prop. This
	            // is just a stub for testing.
	            return React.createElement(
	                TeX,
	                { key: state.key },
	                node.content
	            );
	        }
	    },
	    math: {
	        order: SimpleMarkdown.defaultRules.link.order - 0.25,
	        match: mathMatch,
	        parse: function parse(capture, _parse6, state) {
	            return {
	                content: capture[1]
	            };
	        },
	        react: function react(node, output, state) {
	            // The actual output is handled in the renderer, because
	            // it needs to pass in an `onRender` callback prop. This
	            // is just a stub for testing.
	            return React.createElement(
	                TeX,
	                { key: state.key },
	                node.content
	            );
	        }
	    },
	    unescapedDollar: {
	        order: SimpleMarkdown.defaultRules.link.order - 0.24,
	        match: SimpleMarkdown.inlineRegex(/^(?!\\)\$/),
	        parse: function parse(capture, _parse7, state) {
	            return {};
	        },
	        react: function react(node, output, state) {
	            // Unescaped dollar signs render correctly, but result in
	            // untranslatable text after the i18n python linter flags it
	            return "$";
	        }
	    },
	    fence: _.extend({}, SimpleMarkdown.defaultRules.fence, {
	        parse: function parse(capture, _parse8, state) {
	            var node = SimpleMarkdown.defaultRules.fence.parse(capture, _parse8, state);
	
	            // support screenreader-only text with ```alt
	            if (node.lang === "alt") {
	                return {
	                    type: "codeBlock",
	                    lang: "alt",
	                    // default codeBlock parsing doesn't parse the contents.
	                    // We need to parse the contents for things like table
	                    // support :).
	                    // The \n\n is because the inside of the codeblock might
	                    // not end in double newlines for block rules, because
	                    // ordinarily we don't parse this :).
	                    content: _parse8(node.content + "\n\n", state)
	                };
	            } else {
	                return node;
	            }
	        }
	    }),
	    // Extend the SimpleMarkdown link parser to make the link
	    // zero-rating-friendly if necessary. No changes will be made for
	    // non-zero-rated requests, but zero-rated requests will be re-pointed at
	    // either the zero-rated version of khanacademy.org or the external link
	    // warning interstitial. We also replace the default <a /> tag with a custom
	    // element, if necessary.
	    link: _.extend({}, SimpleMarkdown.defaultRules.link, {
	        react: function react(node, output, state) {
	            var link = SimpleMarkdown.defaultRules.link.react(node, output, state);
	
	            var href = link.props.href;
	
	            // TODO(charlie): Move this logic out of Perseus and into webapp via
	            // the <Link /> component that is now injected as a dependency.
	            if (typeof KA !== "undefined" && KA.isZeroRated) {
	                if (href.match(/https?:\/\/[^\/]*khanacademy.org/)) {
	                    href = href.replace("khanacademy.org", "zero.khanacademy.org");
	                } else {
	                    href = "/zero/external-link?url=" + encodeURIComponent(href);
	                }
	            }
	
	            var newProps = _extends({}, link.props, { href: href });
	
	            if (state.baseElements && state.baseElements.Link) {
	                return state.baseElements.Link(newProps);
	            } else {
	                return React.cloneElement(link, newProps);
	            }
	        }
	    }),
	    codeBlock: _.extend({}, SimpleMarkdown.defaultRules.codeBlock, {
	        react: function react(node, output, state) {
	            // ideally this should be a different rule, with only an
	            // output function, but right now that breaks the parser.
	            if (node.lang === "alt") {
	                return React.createElement(
	                    "div",
	                    {
	                        key: state.key,
	                        className: "perseus-markdown-alt perseus-sr-only"
	                    },
	                    output(node.content, state)
	                );
	            } else {
	                return SimpleMarkdown.defaultRules.codeBlock.react(node, output, state);
	            }
	        }
	    }),
	    list: _.extend({}, SimpleMarkdown.defaultRules.list, {
	        match: function match(source, state, prevCapture) {
	            // Since lists can contain double newlines and we have special
	            // handling of double newlines while parsing jipt content, just
	            // disable the list parser.
	            if (state.isJipt) {
	                return null;
	            } else {
	                return SimpleMarkdown.defaultRules.list.match(source, state, prevCapture);
	            }
	        }
	    }),
	    // The lint rule never actually matches anything.
	    // We check for lint after parsing, and, if we find any, we
	    // transform the tree to add lint nodes. This rule is here
	    // just for the react() function
	    lint: {
	        order: 1000,
	        match: function match(s) {
	            return null;
	        },
	        parse: function parse(capture, _parse9, state) {
	            return {};
	        },
	        react: function react(node, output, state) {
	            return React.createElement(
	                Lint,
	                {
	                    message: node.message,
	                    ruleName: node.ruleName,
	                    inline: isInline(node.content),
	                    insideTable: node.insideTable,
	                    severity: node.severity
	                },
	                output(node.content, state)
	            );
	        }
	    }
	});
	
	// Return true if the specified parse tree node represents inline content
	// and false otherwise. We need this so that lint nodes can figure out whether
	// they should behave as an inline wrapper or a block wrapper
	function isInline(node) {
	    return !!(node && node.type && inlineNodeTypes.hasOwnProperty(node.type));
	}
	var inlineNodeTypes = {
	    text: true,
	    math: true,
	    unescapedDollar: true,
	    link: true,
	    img: true,
	    strong: true,
	    u: true,
	    em: true,
	    del: true,
	    code: true
	};
	
	var builtParser = SimpleMarkdown.parserFor(rules);
	var parse = function parse(source, state) {
	    var paragraphedSource = source + "\n\n";
	
	    return builtParser(paragraphedSource, _.extend({ inline: false }, state));
	};
	var inlineParser = function inlineParser(source, state) {
	    return builtParser(source, _.extend({ inline: true }, state));
	};
	
	/**
	 * Traverse all of the nodes in the Perseus Markdown AST. The callback is
	 * called for each node in the AST.
	 */
	var traverseContent = function traverseContent(ast, cb) {
	    if (_.isArray(ast)) {
	        _.each(ast, function (node) {
	            return traverseContent(node, cb);
	        });
	    } else if (_.isObject(ast)) {
	        cb(ast);
	        if (ast.type === "table") {
	            traverseContent(ast.header, cb);
	            traverseContent(ast.cells, cb);
	        } else if (ast.type === "list") {
	            traverseContent(ast.items, cb);
	        } else if (ast.type === "titledTable") {
	            traverseContent(ast.table, cb);
	        } else if (ast.type === "columns") {
	            traverseContent(ast.col1, cb);
	            traverseContent(ast.col2, cb);
	        } else if (_.isArray(ast.content)) {
	            traverseContent(ast.content, cb);
	        }
	    }
	};
	
	/**
	 * Pull out text content from a Perseus Markdown AST.
	 * Returns an array of strings.
	 */
	var getContent = function getContent(ast) {
	    // Simplify logic by dealing with a single AST node at a time
	    if (_.isArray(ast)) {
	        return _.flatten(_.map(ast, getContent));
	    }
	
	    // Base case: This is where we actually extract text content
	    if (ast.content && _.isString(ast.content)) {
	        // Collapse whitespace within content unless it is code
	        if (ast.type.toLowerCase().indexOf("code") !== -1) {
	            // In case this is the sole child of a paragraph,
	            // prevent whitespace from being trimmed later
	            return ["", ast.content, ""];
	        } else {
	            return [ast.content.replace(/\s+/g, " ")];
	        }
	    }
	
	    // Recurse through child AST nodes
	    // Assumptions made:
	    // 1) Child AST nodes are either direct properties or inside
	    //    arbitrarily nested lists that are direct properties.
	    // 2) Only AST nodes have a 'type' property.
	    var children = _.chain(ast).values().flatten().filter(function (object) {
	        return object != null && _.has(object, "type");
	    }).value();
	
	    if (!children.length) {
	        return [];
	    } else {
	        var nestedContent = getContent(children);
	        if (ast.type === "paragraph" && nestedContent.length) {
	            // Trim whitespace before or after a paragraph
	            nestedContent[0] = nestedContent[0].replace(/^\s+/, "");
	            var last = nestedContent.length - 1;
	            nestedContent[last] = nestedContent[last].replace(/\s+$/, "");
	        }
	        return nestedContent;
	    }
	};
	
	/**
	 * Count the number of characters in Perseus Markdown source.
	 * Markdown markup and widget references are ignored.
	 */
	var characterCount = function characterCount(source) {
	    var ast = parse(source);
	    var content = getContent(ast).join("");
	    return content.length;
	};
	
	module.exports = {
	    characterCount: characterCount,
	    traverseContent: traverseContent,
	    parse: parse,
	    parseInline: inlineParser,
	    reactFor: SimpleMarkdown.reactFor,
	    ruleOutput: SimpleMarkdown.ruleOutput(rules, "react"),
	    basicOutput: SimpleMarkdown.reactFor(SimpleMarkdown.ruleOutput(rules, "react")),
	    sanitizeUrl: SimpleMarkdown.sanitizeUrl
	};

/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = {"apiVersion":{"major":10,"minor":2},"itemDataVersion":{"major":0,"minor":1}}

/***/ },
/* 51 */,
/* 52 */
/***/ function(module, exports, __webpack_require__) {

	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	// Define the shape of the linter context object that is passed through the
	// tree with additional information about what we are checking.
	
	var React = __webpack_require__(43);
	
	var linterContextProps = exports.linterContextProps = React.PropTypes.shape({
	    contentType: React.PropTypes.string,
	    highlightLint: React.PropTypes.bool,
	    paths: React.PropTypes.arrayOf(React.PropTypes.string),
	    stack: React.PropTypes.arrayOf(React.PropTypes.string)
	});
	
	var linterContextDefault = exports.linterContextDefault = {
	    contentType: '',
	    highlightLint: false,
	    paths: [],
	    stack: []
	};

/***/ },
/* 53 */,
/* 54 */,
/* 55 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Stub Tag Editor.
	 *
	 * This is stupidly used by Perseus Zero because I didn't implement
	 * the <TagEditor> for Perseus Zero (since everyone wants me to
	 * delete it anyways).
	 *
	 * This is a small wrapper for a TextListEditor that allows us to
	 * edit raw Tag ID strings in perseus zero (please don't use this).
	 *
	 * It also gives a nicer interface for the group metadata editor
	 * in local demo mode.
	 */
	var React = __webpack_require__(43);
	
	var TextListEditor = __webpack_require__(164);
	var EMPTY_ARRAY = [];
	
	var StubTagEditor = React.createClass({
	    displayName: "StubTagEditor",
	
	    propTypes: {
	        value: React.PropTypes.arrayOf(React.PropTypes.string),
	        onChange: React.PropTypes.func.isRequired,
	        showTitle: React.PropTypes.bool.isRequired
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            value: EMPTY_ARRAY,
	            showTitle: true
	        };
	    },
	
	    render: function render() {
	        return React.createElement(
	            "div",
	            null,
	            this.props.showTitle && React.createElement(
	                "div",
	                { style: { fontSize: 14 } },
	                "Tags:"
	            ),
	            React.createElement(TextListEditor, {
	                options: this.props.value || EMPTY_ARRAY,
	                layout: "vertical",
	                onChange: this.props.onChange
	            })
	        );
	    }
	});
	
	module.exports = StubTagEditor;

/***/ },
/* 56 */
/***/ function(module, exports, __webpack_require__) {

	/* This note applies to jquery, react, and underscore.
	 *
	 * We're faking a node module for this package by just exporting the global.
	 * There are a few complications which led us to this solution as a temporary
	 * fix.
	 *
	 * - Browserify can slow down a lot when you include the other packages (and
	 *   their dependency graphs). We were also battling general browserify
	 *   slowness at this time - browserify 3.4.0 is "good" but later versions
	 *   (3.53 if I remember correctly) are terribly slow (on the order of 20x
	 *   slower).
	 *
	 * - I'm not clear on the details of packaging this so we don't duplicate
	 *   dependencies anywhere. For instance when packaging perseus for webapp we
	 *   need to be careful not to include packages like underscore from our
	 *   dependencies or from the packages we depend on. (note: this is a very good
	 *   opportunity to either explain how existing tools solve the problem or
	 *   create a new tool to solve it)
	 *
	 * - Joel (and Jack)
	 */
	module.exports = window._;


/***/ },
/* 57 */,
/* 58 */,
/* 59 */,
/* 60 */,
/* 61 */
/***/ function(module, exports, __webpack_require__) {

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	var babelPluginFlowReactPropTypes_proptype_ItemObjectNode = __webpack_require__(170).babelPluginFlowReactPropTypes_proptype_ItemObjectNode || __webpack_require__(43).PropTypes.any;
	/**
	 * Utility functions for constructing and manipulating multi-items.
	 *
	 * These functions apply *specifically* to Items and ItemTrees - things that
	 * actually semantically *are* multi-items. For more general functions for
	 * traversing and manipulating *anything* shaped like a multi-item (like a
	 * renderer tree or a score tree or, well, a multi-item), see trees.js.
	 */
	
	
	var babelPluginFlowReactPropTypes_proptype_ItemArrayNode = __webpack_require__(170).babelPluginFlowReactPropTypes_proptype_ItemArrayNode || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_TagsNode = __webpack_require__(170).babelPluginFlowReactPropTypes_proptype_TagsNode || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_HintNode = __webpack_require__(170).babelPluginFlowReactPropTypes_proptype_HintNode || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_ContentNode = __webpack_require__(170).babelPluginFlowReactPropTypes_proptype_ContentNode || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_ItemTree = __webpack_require__(170).babelPluginFlowReactPropTypes_proptype_ItemTree || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_Item = __webpack_require__(170).babelPluginFlowReactPropTypes_proptype_Item || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_Shape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_Shape || __webpack_require__(43).PropTypes.any;
	
	var _require = __webpack_require__(172),
	    buildMapper = _require.buildMapper;
	
	var shapes = __webpack_require__(64);
	
	/**
	 * Return a semantically empty ItemTree that conforms to the given shape.
	 *
	 * - An empty content node has an empty content string and no widgets/images.
	 * - An empty hint node has an empty content string and no widgets/images.
	 * - An empty array node has no elements.
	 * - An empty object node has a semantically empty node for each of its keys.
	 *   (That is, we recursively call buildEmptyItemTreeForShape for each key.)
	 */
	function buildEmptyItemTreeForShape(shape) {
	    if (shape.type === "content") {
	        return {
	            "__type": "content",
	            "content": "",
	            "images": {},
	            "widgets": {}
	        };
	    } else if (shape.type === "hint") {
	        return {
	            "__type": "hint",
	            "replace": false,
	            "content": "",
	            "images": {},
	            "widgets": {}
	        };
	    } else if (shape.type === "tags") {
	        return [];
	    } else if (shape.type === "array") {
	        return [];
	    } else if (shape.type === "object") {
	        var valueShapes = shape.shape;
	        var object = {};
	        Object.keys(valueShapes).forEach(function (key) {
	            object[key] = buildEmptyItemTreeForShape(valueShapes[key]);
	        });
	        return object;
	    } else {
	        throw new Error("unexpected shape type " + shape.type);
	    }
	}
	
	/**
	 * Return a semantically empty Item that conforms to the given shape.
	 *
	 * - An empty content node has an empty content string and no widgets/images.
	 * - An empty hint node has an empty content string and no widgets/images.
	 * - An empty array node has no elements.
	 * - An empty object node has a semantically empty node for each of its keys.
	 *   (That is, we recursively call buildEmptyItemTreeForShape for each key.)
	 */
	function buildEmptyItemForShape(shape) {
	    return treeToItem(buildEmptyItemTreeForShape(shape));
	}
	
	/**
	 * Given an Item and its Shape, yield all of its content nodes to the callback.
	 */
	function findContentNodesInItem(item, shape, callback) {
	    var itemTree = itemToTree(item);
	    buildMapper().setContentMapper(callback).mapTree(itemTree, shape);
	}
	
	/**
	 * Given an Item and its Shape, yield all of its hint nodes to the callback.
	 */
	function findHintNodesInItem(item, shape, callback) {
	    var itemTree = itemToTree(item);
	    buildMapper().setHintMapper(callback).mapTree(itemTree, shape);
	}
	
	/**
	 * Given an ItemTree, return a Shape that it conforms to.
	 *
	 * The Shape might not be complete or correct Shape that this Item was designed
	 * for. If you have access to the intended Shape, use that instead.
	 */
	function inferItemShape(item) {
	    var itemTree = itemToTree(item);
	    return inferItemTreeShape(itemTree);
	}
	
	function inferItemTreeShape(node) {
	    if (Array.isArray(node)) {
	        if (node.length) {
	            if (typeof node[0] === "string") {
	                // There's no ItemTree that can manifest as a string.
	                // So, an array of strings must be a TagsNode, not ArrayNode.
	                return shapes.tags;
	            } else {
	                // Otherwise, assume that this is a valid ArrayNode, and
	                // therefore the shape of the first element applies to all
	                // elements in the array.
	                return shapes.arrayOf(inferItemTreeShape(node[0]));
	            }
	        } else {
	            // The array is empty, so we arbitrarily guess that it's a content
	            // array. As discussed in the docstring, this might be incorrect,
	            // and you shouldn't depend on it.
	            return shapes.arrayOf(shapes.content);
	        }
	    } else if (
	    // TODO(mdr): Remove #LegacyContentNode support.
	    (typeof node === "undefined" ? "undefined" : _typeof(node)) === "object" && (node.__type === "content" || node.__type === "item")) {
	        return shapes.content;
	    } else if ((typeof node === "undefined" ? "undefined" : _typeof(node)) === "object" && node.__type === "hint") {
	        return shapes.hint;
	    } else if ((typeof node === "undefined" ? "undefined" : _typeof(node)) === "object") {
	        var valueShapes = {};
	        Object.keys(node).forEach(function (key) {
	            // $FlowFixMe: Not sure why this property deref is an error.
	            valueShapes[key] = inferItemTreeShape(node[key]);
	        });
	        return shapes.shape(valueShapes);
	    } else {
	        throw new Error("unexpected multi-item node " + JSON.stringify(node));
	    }
	}
	
	/**
	 * Convert the given ItemTree to an Item, by wrapping it in the `_multi` key.
	 */
	function itemToTree(item) {
	    return item._multi;
	}
	
	/**
	 * Convert the given Item to an ItemTree, by unwrapping the `_multi` key.
	 */
	function treeToItem(node) {
	    return { _multi: node };
	}
	
	module.exports = {
	    buildEmptyItemTreeForShape: buildEmptyItemTreeForShape,
	    buildEmptyItemForShape: buildEmptyItemForShape,
	    findContentNodesInItem: findContentNodesInItem,
	    findHintNodesInItem: findHintNodesInItem,
	    inferItemShape: inferItemShape,
	    itemToTree: itemToTree,
	    treeToItem: treeToItem
	};

/***/ },
/* 62 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var babelPluginFlowReactPropTypes_proptype_TagsNode = __webpack_require__(170).babelPluginFlowReactPropTypes_proptype_TagsNode || __webpack_require__(43).PropTypes.any;
	/**
	 * Main entry point to the MultiRenderer render portion.
	 *
	 * This file exposes the `MultiRenderer` component which performs
	 * multi-rendering. To multi-render a question, pass in the content of the item
	 * to the `MultiRenderer` component as a props. Then, pass in a function which
	 * takes an object of renderers (in the same structure as the content), and
	 * return a render tree. The `MultiRenderer` component will allow you to
	 * combine scores, serialized state, etc. without having to manually call on
	 * each of the functions. It also handles inter-widgets requests between the
	 * different renderers.
	 *
	 * Example:
	 *
	 *   item = {_multi: {
	 *       left: <content data>,
	 *       right: [<content data>, <content data>],
	 *   }}
	 *   shape = shapes.shape({
	 *       left: shapes.content,
	 *       right: shapes.arrayOf(shapes.content),
	 *   })
	 *
	 *   <MultiRenderer item={item} shape={shape}>
	 *       {({renderers}) =>
	 *           <div>
	 *               <div id="left">{renderers.left}</div>
	 *               <ul id="right">
	 *                   {renderers.right.map(r => <li>{r}</li>)}
	 *               </ul>
	 *           </div>
	 *       }
	 *   </MultiRenderer>
	 */
	
	
	var babelPluginFlowReactPropTypes_proptype_HintNode = __webpack_require__(170).babelPluginFlowReactPropTypes_proptype_HintNode || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_ContentNode = __webpack_require__(170).babelPluginFlowReactPropTypes_proptype_ContentNode || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_Item = __webpack_require__(170).babelPluginFlowReactPropTypes_proptype_Item || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_ArrayShape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_ArrayShape || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_Shape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_Shape || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_Tree = __webpack_require__(188).babelPluginFlowReactPropTypes_proptype_Tree || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_Path = __webpack_require__(172).babelPluginFlowReactPropTypes_proptype_Path || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_HintMapper = __webpack_require__(172).babelPluginFlowReactPropTypes_proptype_HintMapper || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_ContentMapper = __webpack_require__(172).babelPluginFlowReactPropTypes_proptype_ContentMapper || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_TreeMapper = __webpack_require__(172).babelPluginFlowReactPropTypes_proptype_TreeMapper || __webpack_require__(43).PropTypes.any;
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var lens = __webpack_require__(180);
	var React = __webpack_require__(43);
	
	var _require2 = __webpack_require__(61),
	    itemToTree = _require2.itemToTree;
	
	var HintsRenderer = __webpack_require__(36);
	var Renderer = __webpack_require__(37);
	
	var _require3 = __webpack_require__(172),
	    buildMapper = _require3.buildMapper;
	
	var Util = __webpack_require__(17); // TODO(mdr)
	// TODO(mdr)
	// TODO(mdr)
	// TODO(mdr)
	// TODO(mdr)
	// TODO(mdr)
	
	var MultiRenderer = function (_React$Component) {
	    _inherits(MultiRenderer, _React$Component);
	
	    /* eslint-disable react/sort-comp */
	    // TODO(mdr): Update the linter to allow property type declarations here.
	    function MultiRenderer(props) {
	        _classCallCheck(this, MultiRenderer);
	
	        var _this = _possibleConstructorReturn(this, _React$Component.call(this, props));
	
	        _this._handleSerializedStateUpdated = function (path, newState) {
	            var onSerializedStateUpdated = _this.props.onSerializedStateUpdated;
	
	
	            if (onSerializedStateUpdated) {
	                var oldState = _this._getSerializedState(_this.props.serializedState);
	                onSerializedStateUpdated(lens(oldState).set(path, newState).freeze());
	            }
	        };
	
	        _this.rendererDataTreeMapper = buildMapper().setContentMapper(function (c, _, p) {
	            return _this._makeContentRendererData(c, p);
	        }).setHintMapper(function (h) {
	            return _this._makeHintRendererData(h);
	        }).setTagsMapper(function (t) {
	            return null;
	        });
	
	        _this.getRenderersMapper = buildMapper().setContentMapper(function (c) {
	            return c.makeRenderer();
	        }).setHintMapper(function (h) {
	            return h.makeRenderer();
	        }).setArrayMapper(_this._annotateRendererArray.bind(_this));
	
	        // Keep state in sync with props.
	        _this.state = _this._tryMakeRendererState(_this.props);
	        return _this;
	    }
	    /* eslint-enable react/sort-comp */
	
	    MultiRenderer.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	        // Keep state in sync with props.
	        if (nextProps.item !== this.props.item) {
	            this.setState(this._tryMakeRendererState(nextProps));
	        }
	    };
	
	    /**
	     * Attempt to build a State that includes a renderer tree corresponding to
	     * the item provided in props. On error, return a state with `renderError`
	     * set instead.
	     */
	
	
	    MultiRenderer.prototype._tryMakeRendererState = function _tryMakeRendererState(props) {
	        try {
	            return {
	                rendererDataTree: this._makeRendererDataTree(props.item, props.shape),
	                renderError: null
	            };
	        } catch (e) {
	            // NOTE(mdr): It's appropriate to log an error traceback in a
	            //     caught error condition, and console.error is supported in
	            //     all target browsers. Just do it, linter.
	            // eslint-disable-next-line no-console
	            console.error(e);
	            return {
	                rendererDataTree: null,
	                renderError: e
	            };
	        }
	    };
	
	    /**
	     * Props that aren't directly used by the MultiRenderer are delegated to
	     * the underlying Renderers.
	     */
	    MultiRenderer.prototype._getRendererProps = function _getRendererProps() {
	        /* eslint-disable no-unused-vars */
	        // eslint is complaining that `item` and `children` are unused. I'm
	        // explicitly pulling them out of `this.props` so I don't pass them to
	        // `<Renderer>`. I'm not sure how else to do this.
	        var _props = this.props,
	            item = _props.item,
	            children = _props.children,
	            shape = _props.shape,
	            otherProps = _objectWithoutProperties(_props, ["item", "children", "shape"]);
	        /* eslint-enable no-unused-vars */
	
	        return otherProps;
	    };
	
	    /**
	     * Construct a Renderer and a ref placeholder for the given ContentNode.
	     */
	
	
	    MultiRenderer.prototype._makeContentRendererData = function _makeContentRendererData(content, path) {
	        var _this2 = this;
	
	        // NOTE(emily): The `findExternalWidgets` function here is computed
	        //     inline and thus changes each time we run this function. If it
	        //     were to change every render, it would cause the Renderer to
	        //     re-render a lot more than is necessary. Don't re-compute this
	        //     element unless it is necessary!
	        // HACK(mdr): Flow can't prove that this is a ContentRendererData,
	        //     because of how we awkwardly construct it in order to obtain a
	        var data = { ref: null, makeRenderer: null };
	
	        var refFunc = function refFunc(e) {
	            return data.ref = e;
	        };
	        var findExternalWidgets = function findExternalWidgets(criterion) {
	            return _this2._findWidgets(data, criterion);
	        };
	        var handleSerializedState = function handleSerializedState(state) {
	            return _this2._handleSerializedStateUpdated(path, state);
	        };
	
	        data.makeRenderer = function () {
	            return React.createElement(Renderer, _extends({}, _this2._getRendererProps(), content, {
	                ref: refFunc,
	                findExternalWidgets: findExternalWidgets,
	                serializedState: _this2.props.serializedState ? lens(_this2.props.serializedState).get(path) : null,
	                onSerializedStateUpdated: handleSerializedState
	            }));
	        };
	        return data;
	    };
	
	    /**
	     * Construct a Renderer for the given HintNode, and keep track of the hint
	     * itself for future use, too.
	     */
	
	
	    MultiRenderer.prototype._makeHintRendererData = function _makeHintRendererData(hint) {
	        var _this3 = this;
	
	        // TODO(mdr): Once HintsRenderer supports inter-widget communication,
	        //     give it a ref. Until then, leave the ref null forever, to avoid
	        //     confusing the findWidgets functions.
	        //
	        // NOTE(davidflanagan): As a partial step toward inter-widget
	        // communication we're going to pass a findExternalWidgets function
	        // (using a dummy data object). This allows passage-ref widgets in
	        // hints to use findWidget() to find the passage widgets they reference.
	        // Note that this is one-way only, however. It does not allow
	        // widgets in the question to find widgets in the hints, for example.
	        var findExternalWidgets = function findExternalWidgets(criterion) {
	            return _this3._findWidgets({}, criterion);
	        };
	
	        return {
	            hint: hint,
	            findExternalWidgets: findExternalWidgets, // _annotateRendererArray() needs this
	            ref: null,
	            makeRenderer: function makeRenderer() {
	                return React.createElement(HintsRenderer, _extends({}, _this3._getRendererProps(), {
	                    findExternalWidgets: findExternalWidgets,
	                    hints: [hint]
	                }));
	            }
	        };
	    };
	
	    /**
	     * Construct a tree of interconnected RendererDatas, corresponding to the
	     * given item. Called in `_tryMakeRendererState`, in order to store this
	     * tree in the component state.
	     */
	
	
	    MultiRenderer.prototype._makeRendererDataTree = function _makeRendererDataTree(item, shape) {
	        var itemTree = itemToTree(item);
	        return this.rendererDataTreeMapper.mapTree(itemTree, shape);
	    };
	
	    /**
	     * Return all widgets that meet the given criterion, from all Renderers
	     * except the Renderer that triggered this call.
	     *
	     * This function is provided to each Renderer's `findExternalWidgets` prop,
	     * which enables widgets in different Renderers to discover each other and
	     * communicate.
	     */
	
	
	    MultiRenderer.prototype._findWidgets = function _findWidgets(callingData, filterCriterion) {
	        var results = [];
	
	        this._mapRenderers(function (data) {
	            if (callingData !== data && data.ref) {
	                results.push.apply(results, data.ref.findInternalWidgets(filterCriterion));
	            }
	        });
	
	        return results;
	    };
	
	    /**
	     * Copy the renderer tree, apply the given transformation to the leaf nodes
	     * and the optional given transformation to the array nodes, and return the
	     * result.
	     *
	     * Used to provide structured data to the call site (the Renderer tree on
	     * `render`, the Score tree on `getScores`, etc.), and to traverse the
	     * renderer tree even when we disregard the output (like in
	     * `_findWidgets`).
	     */
	
	
	    MultiRenderer.prototype._mapRenderers = function _mapRenderers(leafMapper) {
	        var rendererDataTree = this.state.rendererDataTree;
	
	
	        if (!rendererDataTree) {
	            return null;
	        }
	
	        var mapper = buildMapper().setContentMapper(leafMapper).setHintMapper(leafMapper);
	        return mapper.mapTree(rendererDataTree, this.props.shape);
	    };
	
	    MultiRenderer.prototype._scoreFromRef = function _scoreFromRef(ref) {
	        if (!ref) {
	            return null;
	        }
	
	        var _ref$guessAndScore = ref.guessAndScore(),
	            guess = _ref$guessAndScore[0],
	            score = _ref$guessAndScore[1];
	
	        var state = void 0;
	        if (ref.getSerializedState) {
	            state = ref.getSerializedState();
	        }
	        return Util.keScoreFromPerseusScore(score, guess, state);
	    };
	
	    /**
	     * Return a tree in the shape of the multi-item, with scores at each of
	     * the content nodes and `null` at the other leaf nodes.
	     */
	
	
	    MultiRenderer.prototype.getScores = function getScores() {
	        var _this4 = this;
	
	        return this._mapRenderers(function (data) {
	            return _this4._scoreFromRef(data.ref);
	        });
	    };
	
	    /**
	     * Return a single composite score for all rendered content nodes.
	     * The `guess` is a tree in the shape of the multi-item, with an individual
	     * guess at each content node and `null` at the other leaf nodes.
	     */
	
	
	    MultiRenderer.prototype.score = function score() {
	        var scores = [];
	        var state = [];
	        var guess = this._mapRenderers(function (data) {
	            if (!data.ref) {
	                return null;
	            }
	
	            if (data.ref.getSerializedState) {
	                state.push(data.ref.getSerializedState());
	            }
	
	            scores.push(data.ref.score());
	            return data.ref.getUserInput();
	        });
	
	        var combinedScore = scores.reduce(Util.combineScores);
	
	        return Util.keScoreFromPerseusScore(combinedScore, guess, state);
	    };
	
	    /**
	     * Return a tree in the shape of the multi-item, with serialized state at
	     * each of the content nodes and `null` at the other leaf nodes.
	     *
	     * If the lastSerializedState argument is supplied, this function will fill
	     * in the state of not-currently-rendered content and hint nodes with the
	     * values from the previous serialized state. If no lastSerializedState is
	     * supplied, `null` will be returned for not-currently-rendered content and
	     * hint nodes.
	     */
	
	
	    MultiRenderer.prototype._getSerializedState = function _getSerializedState(lastSerializedState) {
	        return this._mapRenderers(function (data, _, path) {
	            if (data.ref) {
	                return data.ref.getSerializedState();
	            } else if (lastSerializedState) {
	                return lens(lastSerializedState).get(path);
	            } else {
	                return null;
	            }
	        });
	    };
	
	    /**
	     * Given a tree in the shape of the multi-item, with serialized state at
	     * each of the content nodes, restore each state to the corresponding
	     * renderer if currently mounted.
	     */
	
	
	    MultiRenderer.prototype.restoreSerializedState = function restoreSerializedState(serializedState, callback) {
	        // We want to call our async callback only once all of the childrens'
	        // callbacks have run. We add one to this counter before we call out to
	        // each renderer and decrement it when it runs our callback.
	        var numCallbacks = 0;
	        var countCallback = function countCallback() {
	            numCallbacks--;
	            if (callback && numCallbacks === 0) {
	                callback();
	            }
	        };
	
	        this._mapRenderers(function (data, _, path) {
	            if (!data.ref) {
	                return;
	            }
	
	            var state = lens(serializedState).get(path);
	            if (!state) {
	                return;
	            }
	
	            numCallbacks++;
	            data.ref.restoreSerializedState(state, countCallback);
	        });
	    };
	
	    /**
	     * Given an array of renderers, if it happens to be an array of *hint*
	     * renderers, then attach a `firstN` method to the array, which allows the
	     * layout to render the hints together in one HintsRenderer.
	     */
	
	
	    MultiRenderer.prototype._annotateRendererArray = function _annotateRendererArray(renderers, rendererDatas, shape) {
	        var _this5 = this;
	
	        if (shape.elementShape.type === "hint") {
	            // The shape says that these are HintRendererDatas, even though
	            var hintRendererDatas = rendererDatas;
	
	            renderers = [].concat(renderers);
	            renderers.firstN = function (n) {
	                return React.createElement(HintsRenderer, _extends({}, _this5._getRendererProps(), {
	                    findExternalWidgets: hintRendererDatas[0] ? hintRendererDatas[0].findExternalWidgets : undefined,
	                    hints: hintRendererDatas.map(function (d) {
	                        return d.hint;
	                    }),
	                    hintsVisible: n
	                }));
	            };
	        }
	        return renderers;
	    };
	
	    /**
	     * Return a tree in the shape of the multi-item, with a Renderer at each
	     * content node and a HintRenderer at each hint node.
	     *
	     * This is generated by running each of the `makeRenderer` functions at the
	     * leaf nodes.
	     */
	
	
	    MultiRenderer.prototype._getRenderers = function _getRenderers() {
	        return this.getRenderersMapper.mapTree(this.state.rendererDataTree, this.props.shape);
	    };
	
	    MultiRenderer.prototype.render = function render() {
	        if (this.state.renderError) {
	            return React.createElement(
	                "div",
	                { className: css(styles.error) },
	                "Error rendering: ",
	                String(this.state.renderError)
	            );
	        }
	
	        // Pass the renderer tree to the `children` function, which will
	        // determine the actual content of this component.
	        return this.props.children({
	            renderers: this._getRenderers()
	        });
	    };
	
	    return MultiRenderer;
	}(React.Component);
	
	MultiRenderer.propTypes = {
	    item: babelPluginFlowReactPropTypes_proptype_Item,
	    shape: babelPluginFlowReactPropTypes_proptype_Shape,
	    children: __webpack_require__(43).PropTypes.func.isRequired,
	    serializedState: babelPluginFlowReactPropTypes_proptype_Tree,
	    onSerializedStateUpdated: __webpack_require__(43).PropTypes.func
	};
	
	
	var styles = StyleSheet.create({
	    error: {
	        color: "red"
	    }
	});
	
	module.exports = MultiRenderer;

/***/ },
/* 63 */
/***/ function(module, exports, __webpack_require__) {

	
	/**
	 * Utility functions to build React PropTypes for multi-items and shapes.
	 *
	 * If you're writing new components, though, consider using the Item and Shape
	 * Flow types instead.
	 */
	var React = __webpack_require__(43);
	
	/**
	 * A recursive PropType that accepts Shape objects, and rejects other objects.
	 *
	 * Usage: `propTypes: {shape: shapePropType}`.
	 */
	var babelPluginFlowReactPropTypes_proptype_Shape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_Shape || __webpack_require__(43).PropTypes.any;
	
	function shapePropType() {
	    var itemShape = React.PropTypes.oneOfType([React.PropTypes.shape({
	        type: React.PropTypes.oneOf(["content"]).isRequired
	    }).isRequired, React.PropTypes.shape({
	        type: React.PropTypes.oneOf(["hint"]).isRequired
	    }).isRequired, React.PropTypes.shape({
	        type: React.PropTypes.oneOf(["tags"]).isRequired
	    }).isRequired, React.PropTypes.shape({
	        type: React.PropTypes.oneOf(["object"]).isRequired,
	        shape: React.PropTypes.objectOf(shapePropType)
	    }).isRequired, React.PropTypes.shape({
	        type: React.PropTypes.oneOf(["array"]).isRequired,
	        elementShape: shapePropType
	    }).isRequired]);
	
	    return itemShape.apply(undefined, arguments);
	}
	
	/**
	 * Return a PropType that accepts Items of the given shape, and rejects other
	 * objects.
	 *
	 * Usage: `propTypes: {item: buildPropTypeForShape(myShape)}`
	 */
	function buildPropTypeForShape(shape) {
	    return React.PropTypes.oneOfType([React.PropTypes.shape({
	        _multi: buildTreePropTypeForShape(shape)
	    }), React.PropTypes.oneOf([null, undefined])]);
	}
	
	/**
	 * Return a PropType that accepts ItemTrees of the given shape, and rejects
	 * other objects.
	 */
	function buildTreePropTypeForShape(shape) {
	    if (shape.type === "content") {
	        return React.PropTypes.shape({
	            // TODO(mdr): Remove #LegacyContentNode support.
	            __type: React.PropTypes.oneOf(["content", "item"]).isRequired,
	            content: React.PropTypes.string,
	            images: React.PropTypes.objectOf(React.PropTypes.any),
	            widgets: React.PropTypes.objectOf(React.PropTypes.any)
	        });
	    } else if (shape.type === "hint") {
	        return React.PropTypes.shape({
	            __type: React.PropTypes.oneOf(["hint"]).isRequired,
	            content: React.PropTypes.string,
	            images: React.PropTypes.objectOf(React.PropTypes.any),
	            widgets: React.PropTypes.objectOf(React.PropTypes.any),
	            replace: React.PropTypes.bool
	        });
	    } else if (shape.type === "tags") {
	        return React.PropTypes.arrayOf(React.PropTypes.string.isRequired);
	    } else if (shape.type === "array") {
	        var elementPropType = buildTreePropTypeForShape(shape.elementShape);
	        return React.PropTypes.arrayOf(elementPropType.isRequired);
	    } else if (shape.type === "object") {
	        var valueShapes = shape.shape;
	        var propTypeShape = {};
	        Object.keys(valueShapes).forEach(function (key) {
	            propTypeShape[key] = buildTreePropTypeForShape(valueShapes[key]).isRequired;
	        });
	        return React.PropTypes.shape(propTypeShape);
	    } else {
	        throw new Error("unexpected shape type " + shape.type);
	    }
	}
	
	module.exports = {
	    shapePropType: shapePropType,
	    buildPropTypeForShape: buildPropTypeForShape
	};

/***/ },
/* 64 */
/***/ function(module, exports, __webpack_require__) {

	
	
	/**
	 * These tools allow you to construct arbirtary shapes, by combining simple
	 * leaf shapes like `content` and `hint` into composite shapes like
	 * `arrayOf(shape({question: content, hints: arrayOf(hint)}))`.
	 */
	var babelPluginFlowReactPropTypes_proptype_ObjectShape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_ObjectShape || __webpack_require__(43).PropTypes.any;
	/**
	 * Utility functions for constructing and inferring multi-item shapes.
	 *
	 * A shape is an object that serves as a runtime type declaration: it specifies
	 * a tree structure for a particular class of multi-item. See shape-types.js
	 * for further discussion.
	 *
	 * This module allows you to construct arbitrary Shape trees, by combining
	 * leaf node shapes like `content` and `hint` into composite shapes like
	 * `arrayOf(shape({foo: content, bar: hint}))`.
	 */
	
	
	var babelPluginFlowReactPropTypes_proptype_ArrayShape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_ArrayShape || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_TagsShape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_TagsShape || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_HintShape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_HintShape || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_ContentShape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_ContentShape || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_Shape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_Shape || __webpack_require__(43).PropTypes.any;
	
	var contentShape = {
	    type: "content"
	};
	var hintShape = {
	    type: "hint"
	};
	var tagsShape = {
	    type: "tags"
	};
	var buildArrayShape = function buildArrayShape(elementShape) {
	    return {
	        type: "array",
	        elementShape: elementShape
	    };
	};
	var buildObjectShape = function buildObjectShape(shape) {
	    return {
	        type: "object",
	        shape: shape
	    };
	};
	var hintsShape = buildArrayShape(hintShape);
	
	module.exports = {
	    content: contentShape,
	    hint: hintShape,
	    hints: hintsShape,
	    tags: tagsShape,
	    arrayOf: buildArrayShape,
	    shape: buildObjectShape
	};

/***/ },
/* 65 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable object-curly-spacing */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	/**
	 * A mixin that renders a custom software keypad in additional to the base
	 * component. The base component will receive blur events when the keypad is
	 * dismissed and can access the keypad element itself so as to manage its
	 * activation and dismissal.
	 *
	 * TODO(charlie): This would make a nicer higher-order component, except that
	 * we need to expose methods on the base component (i.e., `ItemRenderer`). When
	 * `ItemRenderer` and friends are written as ES6 Classes, we can have them
	 * extend a `ProvideKeypad` component instead of using this mixin.
	 */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var Keypad = __webpack_require__(257).components.Keypad;
	
	var ProvideKeypad = {
	    propTypes: {
	        apiOptions: React.PropTypes.shape({
	            customKeypad: React.PropTypes.bool
	        }),
	        // An Aphrodite style object, to be applied to the keypad container.
	        // Note that, given our awkward structure of injecting the keypad, this
	        // style won't be applied or updated dynamically. Rather, it will only
	        // be applied in `componentDidMount`.
	        keypadStyle: React.PropTypes.any
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            keypadElement: null
	        };
	    },
	    componentDidMount: function componentDidMount() {
	        var _this = this;
	
	        if (this.props.apiOptions && this.props.apiOptions.customKeypad) {
	            // TODO(charlie): Render this and the wrapped component in the same
	            // React tree. We may also want to add this keypad asynchronously or
	            // on-demand in the future.
	            this._keypadContainer = document.createElement('div');
	            document.body.appendChild(this._keypadContainer);
	
	            ReactDOM.render(React.createElement(Keypad, {
	                onElementMounted: function onElementMounted(element) {
	                    _this.setState({
	                        keypadElement: element
	                    });
	                },
	                onDismiss: function onDismiss() {
	                    _this.blur && _this.blur();
	                },
	                style: this.props.keypadStyle
	            }), this._keypadContainer);
	        }
	    },
	    componentWillUnmount: function componentWillUnmount() {
	        if (this._keypadContainer) {
	            ReactDOM.unmountComponentAtNode(this._keypadContainer);
	            if (this._keypadContainer.parentNode) {
	                // Note ChildNode.remove() isn't available in older Android
	                // webviews.
	                this._keypadContainer.parentNode.removeChild(this._keypadContainer);
	            }
	            this._keypadContainer = null;
	        }
	    },
	    keypadElement: function keypadElement() {
	        return this.state.keypadElement;
	    }
	};
	
	module.exports = ProvideKeypad;

/***/ },
/* 66 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/**
	 * A mixin that accepts the `apiOptions` prop, and populates any missing values
	 * with defaults.
	 */
	var React = __webpack_require__(43);
	
	var ApiOptions = __webpack_require__(12).Options;
	
	var ApiOptionsProps = {
	    propTypes: {
	        // TODO(mdr): Should this actually be objectOf(any)?
	        apiOptions: React.PropTypes.any
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return { apiOptions: {} };
	    },
	    getApiOptions: function getApiOptions() {
	        return _extends({}, ApiOptions.defaults, this.props.apiOptions);
	    }
	};
	
	module.exports = ApiOptionsProps;

/***/ },
/* 67 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* globals KA */
	var classNames = __webpack_require__(86);
	var React = __webpack_require__(43);
	var $ = __webpack_require__(169);
	var _ = __webpack_require__(56);
	
	var FixedToResponsive = __webpack_require__(189);
	var Graphie = __webpack_require__(190);
	var ImageLoader = __webpack_require__(191);
	
	var _require = __webpack_require__(29),
	    maybeUnescape = _require.maybeUnescape;
	
	var Util = __webpack_require__(17);
	var Zoom = __webpack_require__(192);
	
	// Minimum image width to make an image appear as zoomable.
	var ZOOMABLE_THRESHOLD = 700;
	
	// The global cache of label data. Its format is:
	// {
	//   hash (e.g. "c21435944d2cf0c8f39d9059cb35836aa701d04a"): {
	//     loaded: a boolean of whether the data has been loaded or not
	//     dataCallbacks: a list of callbacks to call with the data when the data
	//                    is loaded
	//     data: the other data for this hash
	//   },
	//   ...
	// }
	var labelDataCache = {};
	
	// Write our own JSONP handler because all the other ones don't do things we
	// need.
	var doJSONP = function doJSONP(url, options) {
	    options = _extends({
	        callbackName: "callback",
	        success: $.noop,
	        error: $.noop
	    }, options);
	
	    // Create the script
	    var script = document.createElement("script");
	    script.setAttribute("async", "");
	    script.setAttribute("src", url);
	
	    // A cleanup function to run when we're done.
	    function cleanup() {
	        document.head.removeChild(script);
	        delete window[options.callbackName];
	    }
	
	    // Add the global callback.
	    window[options.callbackName] = function () {
	        cleanup();
	        options.success.apply(null, arguments);
	    };
	
	    // Add the error handler.
	    script.addEventListener("error", function () {
	        cleanup();
	        options.error.apply(null, arguments);
	    });
	
	    // Insert the script to start the download.
	    document.head.appendChild(script);
	};
	
	var svgLabelsRegex = /^web\+graphie\:/;
	var hashRegex = /\/([^/]+)$/;
	
	function isLabeledSVG(url) {
	    return svgLabelsRegex.test(url);
	}
	
	function isImageProbablyPhotograph(imageUrl) {
	    // TODO(david): Do an inventory to refine this heuristic. For example, what
	    //     % of .png images are illustrations?
	    return (/\.(jpg|jpeg)$/i.test(imageUrl)
	    );
	}
	
	// For each svg+labels, there are two urls we need to download from. This gets
	// the base url without the suffix, and `getSvgUrl` and `getDataUrl` apply
	// appropriate suffixes to get the image and other data
	function getBaseUrl(url) {
	    // Force HTTPS connection unless we're on HTTP, so that IE works.
	    var protocol = window.location.protocol === "http:" ? "http:" : "https:";
	
	    return url.replace(svgLabelsRegex, protocol);
	}
	
	function getSvgUrl(url) {
	    return getBaseUrl(url) + ".svg";
	}
	
	function getDataUrl(url) {
	    return getBaseUrl(url) + "-data.json";
	}
	
	function shouldUseLocalizedData() {
	    // TODO(emily): Remove this depenency on `KA` and pass it down with
	    // Perseus' initialization. (Also used in renderer.jsx)
	    return typeof KA !== "undefined" && KA.language !== "en";
	}
	
	function shouldRenderJipt() {
	    return typeof KA !== "undefined" && KA.language === "en-pt";
	}
	
	var jiptLabels = [];
	if (shouldRenderJipt()) {
	    if (!KA.jipt_dom_insert_checks) {
	        KA.jipt_dom_insert_checks = [];
	    }
	
	    KA.jipt_dom_insert_checks.push(function (text, node, attribute) {
	        var index = $(node).data("jipt-label-index");
	        if (node && typeof index !== "undefined") {
	            var _jiptLabels$index = jiptLabels[index],
	                label = _jiptLabels$index.label,
	                useMath = _jiptLabels$index.useMath;
	
	
	            label.text("");
	
	            text = maybeUnescape(text);
	
	            if (useMath) {
	                var mathRegex = /^\$(.*)\$$/;
	                var match = text.match(mathRegex);
	                var mathText = match ? match[1] : "\\color{red}{\\text{Invalid Math}}";
	                label.processMath(mathText, true);
	            } else {
	                label.processText(text);
	            }
	
	            return false;
	        }
	        return text;
	    });
	}
	
	// A regex to split at the last / of a URL, separating the base part from the
	// hash. This is used to create the localized label data URLs.
	var splitHashRegex = /\/(?=[^/]+$)/;
	
	function getLocalizedDataUrl(url) {
	    if (typeof KA !== "undefined") {
	        // Parse out the hash and base so that we can insert the locale
	        var _getBaseUrl$split = getBaseUrl(url).split(splitHashRegex),
	            base = _getBaseUrl$split[0],
	            hash = _getBaseUrl$split[1];
	
	        return base + "/" + KA.language + "/" + hash + "-data.json";
	    } else {
	        return getDataUrl(url);
	    }
	}
	
	// Get the hash from the url, which is just the filename
	function getUrlHash(url) {
	    var match = url.match(hashRegex);
	
	    return match && match[1];
	}
	
	function defaultPreloader() {
	    return React.DOM.span({
	        style: {
	            background: "url(" + PERSEUS_PREFIX + "stylesheets/www.khanacademy.org/images/spinner.gif) no-repeat",
	            backgroundPosition: "center",
	            width: "100%",
	            height: "100%",
	            position: "absolute",
	            minWidth: "20px"
	        }
	    });
	}
	
	var SvgImage = React.createClass({
	    displayName: "SvgImage",
	
	    propTypes: {
	        allowFullBleed: React.PropTypes.bool,
	        alt: React.PropTypes.string,
	        constrainHeight: React.PropTypes.bool,
	
	        extraGraphie: React.PropTypes.shape({
	            box: React.PropTypes.array.isRequired,
	            range: React.PropTypes.array.isRequired,
	            labels: React.PropTypes.array.isRequired
	        }),
	
	        height: React.PropTypes.number,
	
	        // When the DOM updates to replace the preloader with the image, or
	        // vice-versa, we trigger this callback.
	        onUpdate: React.PropTypes.func,
	
	        preloader: React.PropTypes.func,
	
	        // By default, this component attempts to be responsive whenever
	        // possible (specifically, when width and height are passed in).
	        // You can expliclty force unresponsive behavior by *either*
	        // not passing in width/height *or* setting this prop to false.
	        // The difference is that forcing via this prop will result in
	        // explicit width and height styles being set on the rendered
	        // component.
	        responsive: React.PropTypes.bool,
	
	        scale: React.PropTypes.number,
	        src: React.PropTypes.string.isRequired,
	        title: React.PropTypes.string,
	        trackInteraction: React.PropTypes.func,
	        width: React.PropTypes.number,
	
	        // Whether clicking this image will allow it to be fully zoomed in to
	        // its original size on click, and allow the user to scroll in that
	        // state. This also does some hacky viewport meta tag changing to
	        // ensure this works on mobile devices, so I (david@) don't recommend
	        // enabling this on desktop yet.
	        zoomToFullSizeOnMobile: React.PropTypes.bool
	    },
	
	    statics: {
	        // Sometimes other components want to download the actual image e.g. to
	        // determine its size. Here, we transform an .svg-labels url into the
	        // correct image url, and leave normal image urls alone
	        getRealImageUrl: function getRealImageUrl(url) {
	            if (isLabeledSVG(url)) {
	                return getSvgUrl(url);
	            } else {
	                return url;
	            }
	        }
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            constrainHeight: false,
	            onUpdate: function onUpdate() {},
	            responsive: true,
	            src: "",
	            scale: 1,
	            zoomToFullSizeOnMobile: false
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            imageLoaded: false,
	            imageDimensions: null,
	            dataLoaded: false,
	            labelDataIsLocalized: false,
	            labels: [],
	            range: [[0, 0], [0, 0]]
	        };
	    },
	
	    componentDidMount: function componentDidMount() {
	        if (isLabeledSVG(this.props.src)) {
	            this.loadResources();
	        }
	    },
	
	    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        if (this.props.src !== nextProps.src) {
	            this.setState({
	                imageLoaded: false,
	                dataLoaded: false
	            });
	        }
	    },
	
	    shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {
	        // If the props changed, we definitely need to update
	        if (!_.isEqual(this.props, nextProps)) {
	            return true;
	        }
	
	        if (!isLabeledSVG(nextProps.src)) {
	            return false;
	        }
	
	        var wasLoaded = this.isLoadedInState(this.state);
	        var nextLoaded = this.isLoadedInState(nextState);
	
	        return wasLoaded !== nextLoaded;
	    },
	
	    componentDidUpdate: function componentDidUpdate() {
	        if (isLabeledSVG(this.props.src) && !this.isLoadedInState(this.state)) {
	            this.loadResources();
	        }
	    },
	
	    // Check if all of the resources are loaded in a given state
	    isLoadedInState: function isLoadedInState(state) {
	        return state.imageLoaded && state.dataLoaded;
	    },
	
	    loadResources: function loadResources() {
	        var _this = this;
	
	        var hash = getUrlHash(this.props.src);
	
	        // We can't make multiple jsonp calls to the same file because their
	        // callbacks will collide with each other. Instead, we cache the data
	        // and only make the jsonp calls once.
	        if (labelDataCache[hash]) {
	            if (labelDataCache[hash].loaded) {
	                var _labelDataCache$hash = labelDataCache[hash],
	                    data = _labelDataCache$hash.data,
	                    localized = _labelDataCache$hash.localized;
	
	                this.onDataLoaded(data, localized);
	            } else {
	                labelDataCache[hash].dataCallbacks.push(this.onDataLoaded);
	            }
	        } else {
	            var cacheData = {
	                loaded: false,
	                dataCallbacks: [this.onDataLoaded],
	                data: null,
	                localized: shouldUseLocalizedData()
	            };
	
	            labelDataCache[hash] = cacheData;
	
	            var retrieveData = function retrieveData(url, errorCallback) {
	                doJSONP(url, {
	                    callbackName: "svgData" + hash,
	                    success: function success(data) {
	                        cacheData.data = data;
	                        cacheData.loaded = true;
	
	                        _.each(cacheData.dataCallbacks, function (callback) {
	                            callback(cacheData.data, cacheData.localized);
	                        });
	                    },
	                    error: errorCallback
	                });
	            };
	
	            if (shouldUseLocalizedData()) {
	                retrieveData(getLocalizedDataUrl(this.props.src), function (x, status, error) {
	                    cacheData.localized = false;
	
	                    // If there is isn't any localized data, fall back to
	                    // the original, unlocalized data
	                    retrieveData(getDataUrl(_this.props.src), function (x, status, error) {
	                        // eslint-disable-next-line no-console
	                        console.error("Data load failed:", getDataUrl(_this.props.src), error);
	                    });
	                });
	            } else {
	                retrieveData(getDataUrl(this.props.src), function (x, status, error) {
	                    // eslint-disable-next-line no-console
	                    console.error("Data load failed:", getDataUrl(_this.props.src), error);
	                });
	            }
	        }
	    },
	
	    onDataLoaded: function onDataLoaded(data, localized) {
	        if (this.isMounted() && data.labels && data.range) {
	            this.setState({
	                dataLoaded: true,
	                labelDataIsLocalized: localized,
	                labels: data.labels,
	                range: data.range
	            });
	        }
	    },
	
	    sizeProvided: function sizeProvided() {
	        return this.props.width != null && this.props.height != null;
	    },
	
	    onImageLoad: function onImageLoad() {
	        var _this2 = this;
	
	        // Only need to do this if rendering a Graphie
	        if (this.sizeProvided()) {
	            // If width and height are provided, we don't need to calculate the
	            // size ourselves
	            this.setState({
	                imageLoaded: true
	            });
	        } else {
	            Util.getImageSize(this.props.src, function (width, height) {
	                if (_this2.isMounted()) {
	                    _this2.setState({
	                        imageLoaded: true,
	                        imageDimensions: [width, height]
	                    });
	                }
	            });
	        }
	    },
	
	    setupGraphie: function setupGraphie(graphie, options) {
	        var _this3 = this;
	
	        _.map(options.labels, function (labelData) {
	            if (shouldRenderJipt() && _this3.state.labelDataIsLocalized) {
	                // If we're using JIPT translation and we got proper JIPT tags,
	                // render the labels as plain text (so JIPT can find them) and
	                // add some extra properties to the element so we can properly
	                // re-render the label once it is replaced with translated
	                // text.
	                var elem = graphie.label(labelData.coordinates, labelData.content, labelData.alignment, false);
	
	                $(elem).data("jipt-label-index", jiptLabels.length);
	                jiptLabels.push({
	                    label: elem,
	                    useMath: labelData.typesetAsMath
	                });
	            } else if (labelData.coordinates) {
	                // Create labels from the data
	                // TODO(charlie): Some erroneous labels are being sent down
	                // without coordinates. They don't seem to have any content, so
	                // it seems fine to just ignore them (rather than error), but
	                // we should figure out why this is happening.
	                var label = graphie.label(labelData.coordinates, labelData.content, labelData.alignment, labelData.typesetAsMath, { "font-size": 100 * _this3.props.scale + "%" });
	
	                // Convert absolute positioning css from pixels to percentages
	                // TODO(alex): Dynamically resize font-size as well. This
	                // almost certainly means listening to throttled window.resize
	                // events.
	                var labelStyle = label[0].style;
	                var labelTop = _this3._tryGetPixels(labelStyle.top);
	                var labelLeft = _this3._tryGetPixels(labelStyle.left);
	                if (labelTop === null || labelLeft === null) {
	                    // Graphie labels are supposed to have an explicit position,
	                    // but to be on the safe side, let's fall back to using
	                    // jQuery's position(). The reason we're not always using
	                    // this is that in the presence of CSS transforms, it will
	                    // give the rendered position, which may be scaled and
	                    // not equal to the explicitly specified one.
	                    var labelPosition = label.position();
	                    labelTop = labelPosition.top;
	                    labelLeft = labelPosition.left;
	                }
	                var svgHeight = _this3.props.height * _this3.props.scale;
	                var svgWidth = _this3.props.width * _this3.props.scale;
	                label.css({
	                    top: labelTop / svgHeight * 100 + "%",
	                    left: labelLeft / svgWidth * 100 + "%"
	                });
	
	                // Add back the styles to each of the labels
	                _.each(labelData.style, function (styleValue, styleName) {
	                    label.css(styleName, styleValue);
	                });
	            }
	        });
	    },
	
	    // Try to parse a CSS value as pixels. Returns null if the parameter string
	    // does not contain a number followed by "px".
	    _tryGetPixels: function _tryGetPixels(value) {
	        value = value || "";
	        // While this doesn't check that there are no other alphabetical
	        // characters prior to "px", that should be taken care of by the DOM,
	        // which won't accept invalid units.
	        if (!value.endsWith("px")) {
	            return null;
	        }
	        // parseFloat() ignores trailing non-numerical characters.
	        return parseFloat(value) || null;
	    },
	
	    _handleZoomClick: function _handleZoomClick(e) {
	        var $image = $(e.target);
	
	        // It's possible that the image is already displayed at its
	        // full size, but we don't really know that until we get a chance
	        // to measure it (just now, after the user clicks). We only zoom
	        // if there's more image to be shown.
	        //
	        // TODO(kevindangoor) If the window is narrow and the image is
	        // already displayed as wide as possible, we may want to do
	        // nothing in that case as well. Figuring this out correctly
	        // likely required accounting for the image alignment and margins.
	        if ($image.width() < this.props.width || this.props.zoomToFullSizeOnMobile) {
	            Zoom.ZoomService.handleZoomClick(e, this.props.zoomToFullSizeOnMobile);
	        }
	        this.props.trackInteraction && this.props.trackInteraction();
	    },
	
	    render: function render() {
	        var imageSrc = this.props.src;
	
	        // Props to send to all images
	        var imageProps = {
	            alt: this.props.alt,
	            title: this.props.title
	        };
	
	        var width = this.props.width && this.props.width * this.props.scale;
	        var height = this.props.height && this.props.height * this.props.scale;
	        var dimensions = {
	            width: width,
	            height: height
	        };
	
	        // To make an image responsive, we need to know what its width and
	        // height are in advance (before inserting it into the DOM) so that we
	        // can ensure it doesn't grow past those limits. We don't always have
	        // this information, especially in places where <Renderer /> is used
	        // to render inline Markdown images within a widget. See Radio, Sorter,
	        // Matcher, etc.
	        // TODO(alex): Make all of those image rendering locations aware of
	        // width+height so that they too can render responsively.
	        var responsive = this.props.responsive && !!(width && height);
	
	        // An additional <Graphie /> may be inserted after the image/graphie
	        // pair. Only used by the image widget, for its legacy labels support.
	        // Note that since the image widget always provides width and height
	        // data, extraGraphie can be ignored for unresponsive images.
	        // TODO(alex): Convert all existing uses of that to web+graphie. This
	        // is tricky because web+graphie doesn't support labels on non-graphie
	        // images.
	        var extraGraphie = void 0;
	        if (this.props.extraGraphie && this.props.extraGraphie.labels.length) {
	            extraGraphie = React.createElement(Graphie, {
	                box: this.props.extraGraphie.box,
	                range: this.props.extraGraphie.range,
	                options: { labels: this.props.extraGraphie.labels },
	                responsive: true,
	                addMouseLayer: false,
	                setup: this.setupGraphie
	            });
	        }
	
	        // If preloader is undefined, we use the default. If it's
	        // null, there will be no preloader in use.
	        var preloaderBaseFunc = this.props.preloader === undefined ? defaultPreloader : this.props.preloader;
	
	        var preloader = preloaderBaseFunc ? function () {
	            return preloaderBaseFunc(dimensions);
	        } : null;
	
	        // Just use a normal image if a normal image is provided
	        if (!isLabeledSVG(imageSrc)) {
	            if (responsive) {
	                var wrapperClasses = classNames({
	                    zoomable: width > ZOOMABLE_THRESHOLD,
	                    "svg-image": true
	                });
	
	                imageProps.onClick = this._handleZoomClick;
	
	                return React.createElement(
	                    FixedToResponsive,
	                    {
	                        className: wrapperClasses,
	                        width: width,
	                        height: height,
	                        constrainHeight: this.props.constrainHeight,
	                        allowFullBleed: this.props.allowFullBleed && isImageProbablyPhotograph(imageSrc)
	                    },
	                    React.createElement(ImageLoader, {
	                        src: imageSrc,
	                        imgProps: imageProps,
	                        preloader: preloader,
	                        onUpdate: this.props.onUpdate
	                    }),
	                    extraGraphie
	                );
	            } else {
	                imageProps.style = dimensions;
	                return React.createElement(ImageLoader, {
	                    src: imageSrc,
	                    preloader: preloader,
	                    imgProps: imageProps,
	                    onUpdate: this.props.onUpdate
	                });
	            }
	        }
	
	        var imageUrl = getSvgUrl(imageSrc);
	
	        var graphie = void 0;
	        // Since we only want to do the graphie setup once, we only render the
	        // graphie once everything is loaded
	        if (this.isLoadedInState(this.state)) {
	            // Use the provided width and height to size the graphie if
	            // possible, otherwise use our own calculated size
	            var box = void 0;
	            if (this.sizeProvided()) {
	                box = [width, height];
	            } else {
	                box = [this.state.imageDimensions[0] * this.props.scale, this.state.imageDimensions[1] * this.props.scale];
	            }
	
	            var scale = [40 * this.props.scale, 40 * this.props.scale];
	
	            graphie = React.createElement(Graphie, {
	                ref: "graphie",
	                box: box,
	                scale: scale,
	                range: this.state.range,
	                options: _.pick(this.state, "labels"),
	                responsive: responsive,
	                addMouseLayer: false,
	                setup: this.setupGraphie
	            });
	        }
	
	        if (responsive) {
	            return React.createElement(
	                FixedToResponsive,
	                {
	                    className: "svg-image",
	                    width: width,
	                    height: height,
	                    constrainHeight: this.props.constrainHeight
	                },
	                React.createElement(ImageLoader, {
	                    src: imageUrl,
	                    onLoad: this.onImageLoad,
	                    onUpdate: this.props.onUpdate,
	                    preloader: preloader,
	                    imgProps: imageProps
	                }),
	                graphie,
	                extraGraphie
	            );
	        } else {
	            imageProps.style = dimensions;
	            return React.createElement(
	                "div",
	                { className: "unresponsive-svg-image", style: dimensions },
	                React.createElement(ImageLoader, {
	                    src: imageUrl,
	                    onLoad: this.onImageLoad,
	                    onUpdate: this.props.onUpdate,
	                    preloader: preloader,
	                    imgProps: imageProps
	                }),
	                graphie
	            );
	        }
	    }
	});
	
	module.exports = SvgImage;

/***/ },
/* 68 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable no-var, object-curly-spacing */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var _2 = __webpack_require__(56);
	
	var shuffle = __webpack_require__(17).shuffle;
	
	var Radio = __webpack_require__(173);
	
	var _choiceTransform = function _choiceTransform(editorProps, problemNum) {
	    var _maybeRandomize = function _maybeRandomize(array) {
	        return editorProps.randomize ? shuffle(array, problemNum) : array;
	    };
	
	    var _addNoneOfAbove = function _addNoneOfAbove(choices) {
	        var noneOfTheAbove = null;
	
	        var newChoices = _2.reject(choices, function (choice, index) {
	            if (choice.isNoneOfTheAbove) {
	                noneOfTheAbove = choice;
	                return true;
	            }
	        });
	
	        // Place the "None of the above" options last
	        if (noneOfTheAbove) {
	            newChoices.push(noneOfTheAbove);
	        }
	
	        return newChoices;
	    };
	
	    // Add meta-information to choices
	    var choices = editorProps.choices.slice();
	    choices = _2.map(choices, function (choice, i) {
	        return _2.extend({}, choice, {
	            originalIndex: i,
	            correct: Boolean(choice.correct)
	        });
	    });
	
	    // Randomize and add 'None of the above'
	    return _addNoneOfAbove(_maybeRandomize(choices));
	};
	
	var transform = function transform(editorProps, problemNum) {
	    var choices = _choiceTransform(editorProps, problemNum);
	
	    var numCorrect = _2.reduce(editorProps.choices, function (memo, choice) {
	        return choice.correct ? memo + 1 : memo;
	    }, 0);
	
	    var hasNoneOfTheAbove = editorProps.hasNoneOfTheAbove,
	        multipleSelect = editorProps.multipleSelect,
	        countChoices = editorProps.countChoices,
	        correctAnswer = editorProps.correctAnswer,
	        deselectEnabled = editorProps.deselectEnabled;
	
	
	    return {
	        numCorrect: numCorrect,
	        hasNoneOfTheAbove: hasNoneOfTheAbove,
	        multipleSelect: multipleSelect,
	        countChoices: countChoices,
	        correctAnswer: correctAnswer,
	        deselectEnabled: deselectEnabled,
	        choices: choices,
	        selectedChoices: _2.pluck(choices, "correct")
	    };
	};
	
	var propUpgrades = {
	    1: function _(v0props) {
	        var choices;
	        var hasNoneOfTheAbove;
	
	        if (!v0props.noneOfTheAbove) {
	            choices = v0props.choices;
	            hasNoneOfTheAbove = false;
	        } else {
	            choices = _2.clone(v0props.choices);
	            var noneOfTheAboveIndex = _2.random(0, v0props.choices.length - 1);
	            var noneChoice = _2.extend({}, v0props.choices[noneOfTheAboveIndex], {
	                isNoneOfTheAbove: true
	            });
	            choices.splice(noneOfTheAboveIndex, 1);
	            choices.push(noneChoice);
	            hasNoneOfTheAbove = true;
	        }
	
	        return _2.extend(_2.omit(v0props, "noneOfTheAbove"), {
	            choices: choices,
	            hasNoneOfTheAbove: hasNoneOfTheAbove
	        });
	    }
	};
	
	module.exports = {
	    name: "radio",
	    displayName: "Multiple choice",
	    accessible: true,
	    widget: Radio,
	    transform: transform,
	    staticTransform: transform,
	    version: { major: 1, minor: 0 },
	    propUpgrades: propUpgrades,
	    isLintable: true
	};

/***/ },
/* 69 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable brace-style, comma-dangle, no-undef, no-var, object-curly-spacing, react/forbid-prop-types, react/prop-types, react/sort-comp */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var classNames = __webpack_require__(86);
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	var InputWithExamples = __webpack_require__(181);
	var SimpleKeypadInput = __webpack_require__(182);
	var ParseTex = __webpack_require__(183).parseTex;
	var PossibleAnswers = __webpack_require__(184);
	var KhanAnswerTypes = __webpack_require__(82);
	
	var keypadElementPropType = __webpack_require__(257).propTypes.keypadElementPropType;
	
	var _require = __webpack_require__(52),
	    linterContextProps = _require.linterContextProps,
	    linterContextDefault = _require.linterContextDefault;
	
	var ApiClassNames = __webpack_require__(12).ClassNames;
	var ApiOptions = __webpack_require__(12).Options;
	
	var answerTypes = {
	    number: {
	        name: "Numbers",
	        forms: "integer, decimal, proper, improper, mixed"
	    },
	    decimal: {
	        name: "Decimals",
	        forms: "decimal"
	    },
	    integer: {
	        name: "Integers",
	        forms: "integer"
	    },
	    rational: {
	        name: "Fractions and mixed numbers",
	        forms: "integer, proper, improper, mixed"
	    },
	    improper: {
	        name: "Improper numbers (no mixed)",
	        forms: "integer, proper, improper"
	    },
	    mixed: {
	        name: "Mixed numbers (no improper)",
	        forms: "integer, proper, mixed"
	    },
	    percent: {
	        name: "Numbers or percents",
	        forms: "integer, decimal, proper, improper, mixed, percent"
	    },
	    pi: {
	        name: "Numbers with pi",
	        forms: "pi"
	    }
	};
	
	var formExamples = {
	    integer: function integer(options) {
	        return i18n._("an integer, like $6$");
	    },
	    proper: function proper(options) {
	        if (options.simplify === "optional") {
	            return i18n._("a *proper* fraction, like $1/2$ or $6/10$");
	        } else {
	            return i18n._("a *simplified proper* fraction, like $3/5$");
	        }
	    },
	    improper: function improper(options) {
	        if (options.simplify === "optional") {
	            return i18n._("an *improper* fraction, like $10/7$ or $14/8$");
	        } else {
	            return i18n._("a *simplified improper* fraction, like $7/4$");
	        }
	    },
	    mixed: function mixed(options) {
	        return i18n._("a mixed number, like $1\\ 3/4$");
	    },
	    decimal: function decimal(options) {
	        return i18n._("an *exact* decimal, like $0.75$");
	    },
	    percent: function percent(options) {
	        return i18n._("a percent, like $12.34\\%$");
	    },
	    pi: function pi(options) {
	        return i18n._("a multiple of pi, like $12\\ \\text{pi}$ or " + "$2/3\\ \\text{pi}$");
	    }
	};
	
	var InputNumber = React.createClass({
	    displayName: "InputNumber",
	
	    propTypes: {
	        answerType: React.PropTypes.oneOf(Object.keys(answerTypes)),
	        currentValue: React.PropTypes.string,
	        keypadElement: keypadElementPropType,
	        reviewModeRubric: React.PropTypes.object,
	        widgetId: React.PropTypes.string.isRequired,
	        linterContext: linterContextProps
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            currentValue: "",
	            size: "normal",
	            answerType: "number",
	            apiOptions: ApiOptions.defaults,
	            linterContext: linterContextDefault
	        };
	    },
	
	    shouldShowExamples: function shouldShowExamples() {
	        return this.props.answerType !== "number" && !this.props.apiOptions.staticRender;
	    },
	
	    render: function render() {
	        if (this.props.apiOptions.customKeypad) {
	            // TODO(charlie): Support "Review Mode".
	            return React.createElement(SimpleKeypadInput, {
	                ref: "input",
	                value: this.props.currentValue,
	                keypadElement: this.props.keypadElement,
	                onChange: this.handleChange,
	                onFocus: this._handleFocus,
	                onBlur: this._handleBlur
	            });
	        } else {
	            // HACK(johnsullivan): Create a function with shared logic between
	            // this and NumericInput.
	            var rubric = this.props.reviewModeRubric;
	            var correct = null;
	            var answerBlurb = null;
	            if (this.props.apiOptions.satStyling && rubric) {
	                var score = this.simpleValidate(rubric);
	                correct = score.type === "points" && score.earned === score.total;
	
	                if (!correct) {
	                    // TODO(johnsullivan): Make this a little more
	                    // human-friendly.
	                    var answerString = String(rubric.value);
	                    if (rubric.inexact && rubric.maxError) {
	                        answerString += " \xB1 " + rubric.maxError;
	                    }
	                    var answerStrings = [answerString];
	                    answerBlurb = React.createElement(PossibleAnswers, { answers: answerStrings });
	                }
	            }
	
	            var classes = {};
	            classes["perseus-input-size-" + this.props.size] = true;
	            classes[ApiClassNames.CORRECT] = rubric && correct && this.props.currentValue;
	            classes[ApiClassNames.INCORRECT] = rubric && !correct && this.props.currentValue;
	            classes[ApiClassNames.UNANSWERED] = rubric && !this.props.currentValue;
	
	            var input = React.createElement(InputWithExamples, {
	                ref: "input",
	                value: this.props.currentValue,
	                onChange: this.handleChange,
	                className: classNames(classes),
	                type: this._getInputType(),
	                examples: this.examples(),
	                shouldShowExamples: this.shouldShowExamples(),
	                onFocus: this._handleFocus,
	                onBlur: this._handleBlur,
	                id: this.props.widgetId,
	                disabled: this.props.apiOptions.readOnly,
	                linterContext: this.props.linterContext
	            });
	
	            if (answerBlurb) {
	                return React.createElement(
	                    "span",
	                    { className: "perseus-input-with-answer-blurb" },
	                    input,
	                    answerBlurb
	                );
	            } else {
	                return input;
	            }
	        }
	    },
	
	    handleChange: function handleChange(newValue, cb) {
	        this.props.onChange({ currentValue: newValue }, cb);
	    },
	
	    _getInputType: function _getInputType() {
	        if (this.props.apiOptions.staticRender) {
	            return "tex";
	        } else {
	            return "text";
	        }
	    },
	
	    _handleFocus: function _handleFocus() {
	        this.props.onFocus([]);
	        // HACK(kevinb): We want to dismiss the feedback popover that webapp
	        // displays as soon as a user clicks in in the input field so we call
	        // interactionCallback directly.
	        var interactionCallback = this.props.apiOptions.interactionCallback;
	
	        if (interactionCallback) {
	            interactionCallback();
	        }
	    },
	
	    _handleBlur: function _handleBlur() {
	        this.props.onBlur([]);
	    },
	
	    focus: function focus() {
	        this.refs.input.focus();
	        return true;
	    },
	
	    focusInputPath: function focusInputPath(inputPath) {
	        this.refs.input.focus();
	    },
	
	    blurInputPath: function blurInputPath(inputPath) {
	        this.refs.input.blur();
	    },
	
	    getInputPaths: function getInputPaths() {
	        // The widget itself is an input, so we return a single empty list to
	        // indicate this.
	        return [[]];
	    },
	
	    getGrammarTypeForPath: function getGrammarTypeForPath(path) {
	        return "number";
	    },
	
	    setInputValue: function setInputValue(path, newValue, cb) {
	        this.props.onChange({
	            currentValue: newValue
	        }, cb);
	    },
	
	    getUserInput: function getUserInput() {
	        return {
	            currentValue: this.props.currentValue
	        };
	    },
	
	    simpleValidate: function simpleValidate(rubric, onInputError) {
	        onInputError = onInputError || function () {};
	        return InputNumber.validate(this.getUserInput(), rubric, onInputError);
	    },
	
	    examples: function examples() {
	        var type = this.props.answerType;
	        var forms = answerTypes[type].forms.split(/\s*,\s*/);
	
	        var examples = _.map(forms, function (form) {
	            return formExamples[form](this.props);
	        }, this);
	
	        return [i18n._("**Your answer should be** ")].concat(examples);
	    }
	});
	
	_.extend(InputNumber, {
	    validate: function validate(state, rubric, onInputError) {
	        if (rubric.answerType == null) {
	            rubric.answerType = "number";
	        }
	        var val = KhanAnswerTypes.number.createValidatorFunctional(rubric.value, {
	            simplify: rubric.simplify,
	            inexact: rubric.inexact || undefined,
	            maxError: rubric.maxError,
	            forms: answerTypes[rubric.answerType].forms
	        });
	
	        // We may have received TeX; try to parse it before grading.
	        // If `currentValue` is not TeX, this should be a no-op.
	        var currentValue = ParseTex(state.currentValue);
	
	        var result = val(currentValue);
	
	        // TODO(eater): Seems silly to translate result to this invalid/points
	        // thing and immediately translate it back in ItemRenderer.scoreInput()
	        if (result.empty) {
	            var apiResult = onInputError(null, // reserved for some widget identifier
	            state.currentValue, result.message);
	            return {
	                type: "invalid",
	                message: apiResult === false ? null : result.message
	            };
	        } else {
	            return {
	                type: "points",
	                earned: result.correct ? 1 : 0,
	                total: 1,
	                message: result.message
	            };
	        }
	    }
	});
	
	var propTransform = function propTransform(editorProps) {
	    var simplify = editorProps.simplify,
	        size = editorProps.size,
	        answerType = editorProps.answerType;
	
	    return {
	        simplify: simplify,
	        size: size,
	        answerType: answerType
	    };
	};
	
	module.exports = {
	    name: "input-number",
	    displayName: "Number text box (old)",
	    defaultAlignment: "inline-block",
	    hidden: true,
	    widget: InputNumber,
	    transform: propTransform,
	    isLintable: true
	};

/***/ },
/* 70 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable comma-dangle, no-var, react/jsx-closing-bracket-location, react/jsx-indent-props, react/prop-types, react/sort-comp */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var _ = __webpack_require__(56);
	
	var Util = __webpack_require__(17);
	
	var BlurInput = __webpack_require__(185);
	var InfoTip = __webpack_require__(176);
	
	var answerTypes = {
	    number: {
	        name: "Numbers",
	        forms: "integer, decimal, proper, improper, mixed"
	    },
	    decimal: {
	        name: "Decimals",
	        forms: "decimal"
	    },
	    integer: {
	        name: "Integers",
	        forms: "integer"
	    },
	    rational: {
	        name: "Fractions and mixed numbers",
	        forms: "integer, proper, improper, mixed"
	    },
	    improper: {
	        name: "Improper numbers (no mixed)",
	        forms: "integer, proper, improper"
	    },
	    mixed: {
	        name: "Mixed numbers (no improper)",
	        forms: "integer, proper, mixed"
	    },
	    percent: {
	        name: "Numbers or percents",
	        forms: "integer, decimal, proper, improper, mixed, percent"
	    },
	    pi: {
	        name: "Numbers with pi",
	        forms: "pi"
	    }
	};
	
	var InputNumberEditor = React.createClass({
	    displayName: "InputNumberEditor",
	
	    propTypes: {
	        value: React.PropTypes.number,
	        simplify: React.PropTypes.oneOf(["required", "optional", "enforced"]),
	        size: React.PropTypes.oneOf(["normal", "small"]),
	        inexact: React.PropTypes.bool,
	        maxError: React.PropTypes.number,
	        answerType: React.PropTypes.string
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            value: 0,
	            simplify: "required",
	            size: "normal",
	            inexact: false,
	            maxError: 0.1,
	            answerType: "number"
	        };
	    },
	
	    handleAnswerChange: function handleAnswerChange(str) {
	        var value = Util.firstNumericalParse(str) || 0;
	        this.props.onChange({ value: value });
	    },
	
	    render: function render() {
	        var _this = this;
	
	        var answerTypeOptions = _.map(answerTypes, function (v, k) {
	            return React.createElement(
	                "option",
	                { value: k, key: k },
	                v.name
	            );
	        }, this);
	
	        return React.createElement(
	            "div",
	            null,
	            React.createElement(
	                "div",
	                null,
	                React.createElement(
	                    "label",
	                    null,
	                    "Correct answer:",
	                    " ",
	                    React.createElement(BlurInput, {
	                        value: "" + this.props.value,
	                        onChange: this.handleAnswerChange,
	                        ref: "input"
	                    })
	                )
	            ),
	            React.createElement(
	                "div",
	                null,
	                React.createElement(
	                    "label",
	                    null,
	                    "Unsimplified answers",
	                    " ",
	                    React.createElement(
	                        "select",
	                        {
	                            value: this.props.simplify,
	                            onChange: function onChange(e) {
	                                _this.props.onChange({
	                                    simplify: e.target.value
	                                });
	                            }
	                        },
	                        React.createElement(
	                            "option",
	                            { value: "required" },
	                            "will not be graded"
	                        ),
	                        React.createElement(
	                            "option",
	                            { value: "optional" },
	                            "will be accepted"
	                        ),
	                        React.createElement(
	                            "option",
	                            { value: "enforced" },
	                            "will be marked wrong"
	                        )
	                    )
	                ),
	                React.createElement(
	                    InfoTip,
	                    null,
	                    React.createElement(
	                        "p",
	                        null,
	                        "Normally select \"will not be graded\". This will give the user a message saying the answer is correct but not simplified. The user will then have to simplify it and re-enter, but will not be penalized. (5th grade and anything after)"
	                    ),
	                    React.createElement(
	                        "p",
	                        null,
	                        "Select \"will be accepted\" only if the user is not expected to know how to simplify fractions yet. (Anything prior to 5th grade)"
	                    ),
	                    React.createElement(
	                        "p",
	                        null,
	                        "Select \"will be marked wrong\" only if we are specifically assessing the ability to simplify."
	                    )
	                )
	            ),
	            React.createElement(
	                "div",
	                null,
	                React.createElement(
	                    "label",
	                    null,
	                    React.createElement("input", {
	                        type: "checkbox",
	                        checked: this.props.inexact,
	                        onChange: function onChange(e) {
	                            _this.props.onChange({
	                                inexact: e.target.checked
	                            });
	                        }
	                    }),
	                    " ",
	                    "Allow inexact answers"
	                ),
	                React.createElement(
	                    "label",
	                    null,
	                    React.createElement("input", { /* TODO(emily): don't use a hidden checkbox
	                                                   for alignment */
	                        type: "checkbox",
	                        style: { visibility: "hidden" }
	                    }),
	                    "Max error:",
	                    " ",
	                    React.createElement("input", {
	                        type: "text",
	                        disabled: !this.props.inexact,
	                        defaultValue: this.props.maxError,
	                        onBlur: function onBlur(e) {
	                            var ans = "" + (Util.firstNumericalParse(e.target.value) || 0);
	                            e.target.value = ans;
	                            _this.props.onChange({ maxError: ans });
	                        }
	                    })
	                )
	            ),
	            React.createElement(
	                "div",
	                null,
	                "Answer type:",
	                " ",
	                React.createElement(
	                    "select",
	                    {
	                        value: this.props.answerType,
	                        onChange: function onChange(e) {
	                            _this.props.onChange({ answerType: e.target.value });
	                        }
	                    },
	                    answerTypeOptions
	                ),
	                React.createElement(
	                    InfoTip,
	                    null,
	                    React.createElement(
	                        "p",
	                        null,
	                        "Use the default \"Numbers\" unless the answer must be in a specific form (e.g., question is about converting decimals to fractions)."
	                    )
	                )
	            ),
	            React.createElement(
	                "div",
	                null,
	                React.createElement(
	                    "label",
	                    null,
	                    "Width",
	                    " ",
	                    React.createElement(
	                        "select",
	                        {
	                            value: this.props.size,
	                            onChange: function onChange(e) {
	                                _this.props.onChange({ size: e.target.value });
	                            }
	                        },
	                        React.createElement(
	                            "option",
	                            { value: "normal" },
	                            "Normal (80px)"
	                        ),
	                        React.createElement(
	                            "option",
	                            { value: "small" },
	                            "Small (40px)"
	                        )
	                    )
	                ),
	                React.createElement(
	                    InfoTip,
	                    null,
	                    React.createElement(
	                        "p",
	                        null,
	                        "Use size \"Normal\" for all text boxes, unless there are multiple text boxes in one line and the answer area is too narrow to fit them."
	                    )
	                )
	            )
	        );
	    },
	
	    focus: function focus() {
	        ReactDOM.findDOMNode(this.refs.input).focus();
	        return true;
	    },
	
	    serialize: function serialize() {
	        return _.pick(this.props, "value", "simplify", "size", "inexact", "maxError", "answerType");
	    }
	});
	
	module.exports = InputNumberEditor;

/***/ },
/* 71 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable brace-style, comma-dangle, indent, no-undef, no-var, object-curly-spacing, react/forbid-prop-types, react/prop-types, react/sort-comp */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var classNames = __webpack_require__(86);
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var styleConstants = __webpack_require__(77);
	
	var InputWithExamples = __webpack_require__(181);
	var SimpleKeypadInput = __webpack_require__(182);
	var ParseTex = __webpack_require__(183).parseTex;
	var PossibleAnswers = __webpack_require__(184);
	
	var ApiClassNames = __webpack_require__(12).ClassNames;
	var ApiOptions = __webpack_require__(12).Options;
	var KhanAnswerTypes = __webpack_require__(82);
	var KhanMath = __webpack_require__(208);
	
	var keypadElementPropType = __webpack_require__(257).propTypes.keypadElementPropType;
	
	var _require2 = __webpack_require__(52),
	    linterContextProps = _require2.linterContextProps,
	    linterContextDefault = _require2.linterContextDefault;
	
	var _require3 = __webpack_require__(47),
	    iconDropdownArrow = _require3.iconDropdownArrow;
	
	var InlineIcon = __webpack_require__(48);
	
	var answerFormButtons = [{ title: "Integers", value: "integer", content: "6" }, { title: "Decimals", value: "decimal", content: "0.75" }, { title: "Proper fractions", value: "proper", content: "\u2157" }, {
	    title: "Improper fractions",
	    value: "improper",
	    content: "\u2077\u2044\u2084"
	}, { title: "Mixed numbers", value: "mixed", content: "1\xBE" }, { title: "Numbers with \u03C0", value: "pi", content: "\u03C0" }];
	
	var formExamples = {
	    integer: function integer() {
	        return i18n._("an integer, like $6$");
	    },
	    proper: function proper(form) {
	        return form.simplify === "optional" ? i18n._("a *proper* fraction, like $1/2$ or $6/10$") : i18n._("a *simplified proper* fraction, like $3/5$");
	    },
	    improper: function improper(form) {
	        return form.simplify === "optional" ? i18n._("an *improper* fraction, like $10/7$ or $14/8$") : i18n._("a *simplified improper* fraction, like $7/4$");
	    },
	    mixed: function mixed() {
	        return i18n._("a mixed number, like $1\\ 3/4$");
	    },
	    decimal: function decimal() {
	        return i18n._("an *exact* decimal, like $0.75$");
	    },
	    pi: function pi() {
	        return i18n._("a multiple of pi, like $12\\ \\text{pi}$ or " + "$2/3\\ \\text{pi}$");
	    }
	};
	
	var NumericInput = React.createClass({
	    displayName: "NumericInput",
	
	    propTypes: {
	        currentValue: React.PropTypes.string,
	        currentMultipleValues: React.PropTypes.arrayOf(React.PropTypes.string),
	        size: React.PropTypes.oneOf(["normal", "small"]),
	        apiOptions: ApiOptions.propTypes,
	        coefficient: React.PropTypes.bool,
	        answerForms: React.PropTypes.arrayOf(React.PropTypes.shape({
	            name: React.PropTypes.string.isRequired,
	            simplify: React.PropTypes.oneOf(["required", "optional"]).isRequired
	        })),
	        keypadElement: keypadElementPropType,
	        labelText: React.PropTypes.string,
	        reviewModeRubric: React.PropTypes.object,
	        trackInteraction: React.PropTypes.func.isRequired,
	        widgetId: React.PropTypes.string.isRequired,
	        linterContext: linterContextProps,
	        multipleNumberInput: React.PropTypes.bool
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            currentValue: "",
	            // currentMultipleValues has an empty string, because if finite
	            // solutions is chosen, there must be at least 1 answer
	            currentMultipleValues: [""],
	            size: "normal",
	            apiOptions: ApiOptions.defaults,
	            coefficient: false,
	            answerForms: [],
	            labelText: "",
	            linterContext: linterContextDefault,
	            multipleNumberInput: false
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            // dropdown option: either no-solutions or finite-solutions
	            numSolutions: "no-solutions",
	            // keeps track of the other set of values when switching
	            // between 0 and finite solutions
	            previousValues: [""]
	        };
	    },
	
	    getAnswerBlurb: function getAnswerBlurb(rubric) {
	        var correct;
	        var answerBlurb;
	        if (this.props.apiOptions.satStyling && rubric) {
	            var score = this.simpleValidate(rubric);
	            correct = score.type === "points" && score.earned === score.total;
	
	            if (!correct) {
	                var correctAnswers = _.filter(rubric.answers, function (answer) {
	                    return answer.status === "correct";
	                });
	                var answerStrings = _.map(correctAnswers, function (answer) {
	                    // Figure out how this answer is supposed to be
	                    // displayed
	                    var format = "decimal";
	                    if (answer.answerForms && answer.answerForms[0]) {
	                        // NOTE(johnsullivan): This isn't exactly ideal, but
	                        // it does behave well for all the currently known
	                        // problems. See D14742 for some discussion on
	                        // alternate strategies.
	                        format = answer.answerForms[0];
	                    }
	
	                    var answerString = KhanMath.toNumericString(answer.value, format);
	                    if (answer.maxError) {
	                        answerString += " \xB1 " + KhanMath.toNumericString(answer.maxError, format);
	                    }
	                    return answerString;
	                });
	                answerBlurb = React.createElement(PossibleAnswers, { answers: answerStrings });
	            }
	        }
	        return [answerBlurb, correct];
	    },
	
	    getClasses: function getClasses(correct, rubric) {
	        var classes = {};
	        classes["perseus-input-size-" + this.props.size] = true;
	        classes[ApiClassNames.CORRECT] = rubric && correct && this.props.currentValue;
	        classes[ApiClassNames.INCORRECT] = rubric && !correct && this.props.currentValue;
	        classes[ApiClassNames.UNANSWERED] = rubric && !this.props.currentValue;
	        return classes;
	    },
	
	    render: function render() {
	        var _this = this;
	
	        var rubric = this.props.reviewModeRubric;
	        var answers = this.getAnswerBlurb(rubric);
	        var answerBlurb = answers[0];
	        var correct = answers[1];
	        var classes = this.getClasses(correct, rubric);
	
	        var labelText = this.props.labelText;
	        if (labelText == null || labelText === "") {
	            labelText = i18n._("Your answer:");
	        }
	
	        var selectClasses = classNames({
	            "perseus-widget-dropdown": true
	        });
	
	        var dropdown = React.createElement(
	            "div",
	            null,
	            React.createElement(
	                "select",
	                {
	                    onChange: this.handleNumSolutionsChange,
	                    className: selectClasses + " " + css(styles.dropdown) + " " + ApiClassNames.INTERACTIVE,
	                    value: this.state.numSolutions
	                },
	                React.createElement(
	                    "option",
	                    { value: "no-solutions" },
	                    i18n._("0 solutions")
	                ),
	                React.createElement(
	                    "option",
	                    { value: "finite-solutions" },
	                    i18n._("Finite solutions")
	                )
	            ),
	            React.createElement(InlineIcon, _extends({}, iconDropdownArrow, {
	                style: {
	                    marginLeft: -24,
	                    height: 24,
	                    width: 24
	                }
	            }))
	        );
	
	        var input;
	        if (this.props.multipleNumberInput) {
	            if (this.state.numSolutions === "no-solutions") {
	                return dropdown;
	            } else {
	                var addInput = React.createElement(
	                    "div",
	                    {
	                        className: css(styles.addInputButton),
	                        onClick: this._addInput
	                    },
	                    "+"
	                );
	
	                input = React.createElement(
	                    "div",
	                    null,
	                    this.props.currentMultipleValues.map(function (item, i) {
	                        return React.createElement(
	                            "div",
	                            {
	                                key: i,
	                                className: css(styles.numberInputContainer)
	                            },
	                            i > 0 && React.createElement(
	                                "div",
	                                {
	                                    className: css(styles.removeInputButton),
	                                    onClick: function onClick(evt) {
	                                        return _this._removeInput(i, evt);
	                                    },
	                                    "aria-label": "Remove this answer"
	                                },
	                                "-"
	                            ),
	                            _this.props.apiOptions.customKeypad ? React.createElement(SimpleKeypadInput, {
	                                ref: "input",
	                                value: _this.props.currentMultipleValues[i],
	                                keypadElement: _this.props.keypadElement,
	                                onChange: function onChange(e) {
	                                    return _this.handleMultipleInputChange(i, e);
	                                },
	                                onFocus: _this._handleFocus,
	                                onBlur: _this._handleBlur
	                            }) : React.createElement(InputWithExamples, {
	                                ref: "input",
	                                value: _this.props.currentMultipleValues[i],
	                                onChange: function onChange(e) {
	                                    return _this.handleMultipleInputChange(i, e);
	                                },
	                                className: classNames(classes, css(styles.numberInput)),
	                                labelText: labelText,
	                                type: _this._getInputType(),
	                                examples: _this.examples(),
	                                shouldShowExamples: _this.shouldShowExamples(),
	                                onFocus: _this._handleFocus,
	                                onBlur: _this._handleBlur,
	                                id: _this.props.widgetId,
	                                disabled: _this.props.apiOptions.readOnly,
	                                highlightLint: _this.props.highlightLint
	                            })
	                        );
	                    }),
	                    addInput,
	                    "Add answer"
	                );
	            }
	        } else {
	            if (this.props.apiOptions.customKeypad) {
	                // TODO(charlie): Support "Review Mode".
	                return React.createElement(SimpleKeypadInput, {
	                    ref: "input",
	                    value: this.props.currentValue,
	                    keypadElement: this.props.keypadElement,
	                    onChange: this.handleChange,
	                    onFocus: this._handleFocus,
	                    onBlur: this._handleBlur
	                });
	            } else {
	                input = React.createElement(InputWithExamples, {
	                    ref: "input",
	                    value: this.props.currentValue,
	                    onChange: this.handleChange,
	                    className: classNames(classes),
	                    labelText: labelText,
	                    type: this._getInputType(),
	                    examples: this.examples(),
	                    shouldShowExamples: this.shouldShowExamples(),
	                    onFocus: this._handleFocus,
	                    onBlur: this._handleBlur,
	                    id: this.props.widgetId,
	                    disabled: this.props.apiOptions.readOnly,
	                    highlightLint: this.props.highlightLint
	                });
	            }
	        }
	
	        if (answerBlurb) {
	            return React.createElement(
	                "span",
	                { className: "perseus-input-with-answer-blurb" },
	                this.props.multipleNumberInput && dropdown,
	                input,
	                answerBlurb
	            );
	        } else if (this.props.apiOptions.satStyling) {
	            // NOTE(amy): the input widgets themselves already have
	            // a default aria label of "Your Answer", so we hide this
	            // redundant label from screen-readers.
	            return React.createElement(
	                "label",
	                {
	                    className: "perseus-input-with-label",
	                    "aria-hidden": "true"
	                },
	                React.createElement(
	                    "span",
	                    { className: "perseus-input-label" },
	                    i18n.i18nDoNotTranslate("Answer:")
	                ),
	                this.props.multipleNumberInput && dropdown,
	                input
	            );
	        } else {
	            return React.createElement(
	                "div",
	                null,
	                this.props.multipleNumberInput && dropdown,
	                input
	            );
	        }
	    },
	
	    handleChange: function handleChange(newValue, cb) {
	        this.props.onChange({ currentValue: newValue }, cb);
	        this.props.trackInteraction();
	    },
	
	    handleMultipleInputChange: function handleMultipleInputChange(index, newValue) {
	        var newValues = this.props.currentMultipleValues.slice();
	        newValues[index] = newValue;
	        this.props.onChange({
	            currentMultipleValues: newValues
	        });
	        this.props.trackInteraction();
	    },
	
	    handleNumSolutionsChange: function handleNumSolutionsChange(event) {
	        var newValue = event.target.value;
	        this.setState({ numSolutions: newValue });
	
	        // Saves the values the user entered when switching between no
	        // solutions and finite solutions, however, we also correctly update
	        // the answer that is to be graded
	        if (newValue === "no-solutions") {
	            this.setState({
	                previousValues: this.props.currentMultipleValues
	            });
	            this.props.onChange({
	                currentMultipleValues: []
	            });
	        } else {
	            this.props.onChange({
	                currentMultipleValues: this.state.previousValues
	            });
	            this.setState({
	                previousValues: []
	            });
	        }
	    },
	
	    _getInputType: function _getInputType() {
	        if (this.props.apiOptions.staticRender) {
	            return "tex";
	        } else {
	            return "text";
	        }
	    },
	
	    _handleFocus: function _handleFocus() {
	        this.props.onFocus([]);
	        // HACK(kevinb): We want to dismiss the feedback popover that webapp
	        // displays as soon as a user clicks in in the input field so we call
	        // interactionCallback directly.
	        var interactionCallback = this.props.apiOptions.interactionCallback;
	
	        if (interactionCallback) {
	            interactionCallback();
	        }
	    },
	
	    _handleBlur: function _handleBlur() {
	        this.props.onBlur([]);
	    },
	
	    _addInput: function _addInput() {
	        // Add a new blank value to the list of current values
	        this.props.onChange({
	            currentMultipleValues: this.props.currentMultipleValues.concat([""])
	        });
	    },
	
	    _removeInput: function _removeInput(i, event) {
	        var length = this.props.currentMultipleValues.length;
	        var newValues = this.props.currentMultipleValues.slice(0, i).concat(this.props.currentMultipleValues.slice(i + 1, length));
	        this.props.onChange({
	            currentMultipleValues: newValues
	        });
	    },
	
	    focus: function focus() {
	        this.refs.input.focus();
	        return true;
	    },
	
	    focusInputPath: function focusInputPath(inputPath) {
	        this.refs.input.focus();
	    },
	
	    blurInputPath: function blurInputPath(inputPath) {
	        this.refs.input.blur();
	    },
	
	    getInputPaths: function getInputPaths() {
	        // The widget itself is an input, so we return a single empty list to
	        // indicate this.
	        return [[]];
	    },
	
	    getGrammarTypeForPath: function getGrammarTypeForPath(inputPath) {
	        return "number";
	    },
	
	    setInputValue: function setInputValue(path, newValue, cb) {
	        this.props.onChange({
	            currentValue: newValue
	        }, cb);
	    },
	
	    getUserInput: function getUserInput() {
	        var multiple = this.props.multipleNumberInput;
	        return {
	            multInput: multiple,
	            currentValue: multiple ? this.props.currentMultipleValues : this.props.currentValue
	        };
	    },
	
	    simpleValidate: function simpleValidate(rubric) {
	        return NumericInput.validate(this.getUserInput(), rubric);
	    },
	
	    shouldShowExamples: function shouldShowExamples() {
	        var noFormsAccepted = this.props.answerForms.length === 0;
	        // To check if all answer forms are accepted, we must first
	        // find the *names* of all accepted forms, and see if they are
	        // all present, ignoring duplicates
	        var answerFormNames = _.uniq(this.props.answerForms.map(function (form) {
	            return form.name;
	        }));
	        var allFormsAccepted = answerFormNames.length >= _.size(formExamples);
	        return !noFormsAccepted && !allFormsAccepted;
	    },
	
	    examples: function examples() {
	        // if the set of specified forms are empty, allow all forms
	        var forms = this.props.answerForms.length !== 0 ? this.props.answerForms : _.map(_.keys(formExamples), function (name) {
	            return {
	                name: name,
	                simplify: "required"
	            };
	        });
	
	        var examples = _.map(forms, function (form) {
	            return formExamples[form.name](form);
	        });
	        // Ensure no duplicate tooltip text from simplified and unsimplified
	        // versions of the same format
	        examples = _.uniq(examples);
	
	        return [i18n._("**Your answer should be** ")].concat(examples);
	    }
	});
	
	_.extend(NumericInput, {
	    validate: function validate(state, rubric) {
	        var allAnswerForms = _.pluck(answerFormButtons, "value");
	
	        var createValidator = function createValidator(answer) {
	            return KhanAnswerTypes.number.createValidatorFunctional(answer.value, {
	                message: answer.message,
	                simplify: answer.status === "correct" ? answer.simplify : "optional",
	                inexact: true, // TODO(merlob) backfill / delete
	                maxError: answer.maxError,
	                forms: answer.strict && answer.answerForms && answer.answerForms.length !== 0 ? answer.answerForms : allAnswerForms
	            });
	        };
	
	        // We may have received TeX; try to parse it before grading.
	        // If `currentValue` is not TeX, this should be a no-op.
	        var currentValue = ParseTex(state.currentValue);
	        var correctAnswers = _.where(rubric.answers, { status: "correct" });
	
	        if (state.multInput) {
	            // sort the answers and the solutions so they can be compared
	            var sortedInputs = currentValue.split(",").sort();
	            correctAnswers.sort(function (a, b) {
	                return a.value > b.value ? 1 : -1;
	            });
	
	            // If the number of correct answers and user answers do not match
	            // return early that the answer is wrong
	            if (sortedInputs.length !== correctAnswers.length) {
	                return {
	                    type: "points",
	                    earned: 0,
	                    total: 1,
	                    message: "Incorrect number of answers"
	                };
	            }
	
	            // Look through all correct answers and make sure there is
	            // the correct user answer for each
	            var correct = true;
	            var message;
	            correctAnswers.forEach(function (answer, i) {
	                var localValue = sortedInputs[i];
	                if (rubric.coefficient) {
	                    if (!localValue) {
	                        localValue = 1;
	                    } else if (localValue === "-") {
	                        localValue = -1;
	                    }
	                }
	                var validate = createValidator(answer);
	                var status = validate(localValue);
	                correct = correct && status.correct;
	                if (status.message) {
	                    message = status.message;
	                }
	            });
	
	            return {
	                type: "points",
	                earned: correct ? 1 : 0,
	                total: 1,
	                message: message
	            };
	        } else {
	            // Look through all correct answers for one that matches either
	            // precisely or approximately and return the appropriate message:
	            // - if precise, return the message that the answer came with
	            // - if it needs to be simplified, etc., show that message
	            var result = _.find(_.map(correctAnswers, function (answer) {
	                // The coefficient is an attribute of the widget
	                var localValue = currentValue;
	                if (rubric.coefficient) {
	                    if (!localValue) {
	                        localValue = 1;
	                    } else if (localValue === "-") {
	                        localValue = -1;
	                    }
	                }
	                var validate = createValidator(answer);
	                return validate(localValue);
	            }), function (match) {
	                return match.correct || match.empty;
	            });
	
	            if (!result) {
	                // Otherwise, if the guess is not correct
	                var otherAnswers = [].concat(_.where(rubric.answers, { status: "ungraded" }), _.where(rubric.answers, { status: "wrong" }));
	
	                // Look through all other answers and if one matches either
	                // precisely or approximately return the answer's message
	                var match = _.find(otherAnswers, function (answer) {
	                    var validate = createValidator(answer);
	                    return validate(currentValue).correct;
	                });
	                result = {
	                    empty: match ? match.status === "ungraded" : false,
	                    correct: match ? match.status === "correct" : false,
	                    message: match ? match.message : null,
	                    guess: currentValue
	                };
	            }
	
	            // TODO(eater): Seems silly to translate result to this
	            // invalid/points thing and immediately translate it
	            // back in ItemRenderer.scoreInput()
	            if (result.empty) {
	                return {
	                    type: "invalid",
	                    message: result.message
	                };
	            } else {
	                return {
	                    type: "points",
	                    earned: result.correct ? 1 : 0,
	                    total: 1,
	                    message: result.message
	                };
	            }
	        }
	    }
	});
	
	// TODO(thomas): Currently we receive a list of lists of acceptable answer types
	// and union them down into a single set. It's worth considering whether it
	// wouldn't make more sense to have a single set of acceptable answer types for
	// a given *problem* rather than for each possible [correct/wrong] *answer*.
	// When should two answers to a problem take different answer types?
	// See D27790 for more discussion.
	var unionAnswerForms = function unionAnswerForms(answerFormsList) {
	    // Takes a list of lists of answer forms, and returns a list of the forms
	    // in each of these lists in the same order that they're listed in the
	    // `formExamples` forms from above.
	
	    // uniqueBy takes a list of elements and a function which compares whether
	    // two elements are equal, and returns a list of unique elements. This is
	    // just a helper function here, but works generally.
	    var uniqueBy = function uniqueBy(list, iteratee) {
	        return _.reduce(list, function (uniqueList, element) {
	            // For each element, decide whether it's already in the list of
	            // unique items.
	            var inList = _.find(uniqueList, iteratee.bind(null, element));
	            if (inList) {
	                return uniqueList;
	            } else {
	                return uniqueList.concat([element]);
	            }
	        }, []);
	    };
	
	    // Pull out all of the forms from the different lists.
	    var allForms = _.flatten(answerFormsList);
	    // Pull out the unique forms using uniqueBy.
	    var uniqueForms = uniqueBy(allForms, _.isEqual);
	    // Sort them by the order they appear in the `formExamples` list.
	    return _.sortBy(uniqueForms, function (form) {
	        return _.keys(formExamples).indexOf(form.name);
	    });
	};
	
	var propsTransform = function propsTransform(editorProps) {
	    var rendererProps = _.extend(_.omit(editorProps, "answers"), {
	        answerForms: unionAnswerForms(
	        // Pull out the name of each form and whether that form has
	        // required simplification.
	        _.map(editorProps.answers, function (answer) {
	            return _.map(answer.answerForms, function (form) {
	                return {
	                    simplify: answer.simplify,
	                    name: form
	                };
	            });
	        }))
	    });
	
	    return rendererProps;
	};
	
	var styles = StyleSheet.create({
	    addInputButton: {
	        cursor: "pointer",
	        display: "inline-block",
	        border: "2px solid " + styleConstants.kaGreen,
	        backgroundColor: styleConstants.kaGreen,
	        color: styleConstants.white,
	        fontSize: 20,
	        borderRadius: 15,
	        width: 18,
	        height: 18,
	        marginBottom: 7,
	        marginRight: 8,
	        marginTop: 3,
	        textAlign: "center",
	        paddingTop: 1
	    },
	
	    removeInputButton: {
	        cursor: "pointer",
	        display: "inline-block",
	        border: "2px solid " + styleConstants.red,
	        backgroundColor: styleConstants.red,
	        color: styleConstants.white,
	        fontSize: 20,
	        borderRadius: 15,
	        width: 18,
	        height: 18,
	        marginBottom: 7,
	        marginRight: 8,
	        marginTop: 4,
	        textAlign: "center"
	    },
	
	    dropdown: {
	        width: 250,
	        marginBottom: 10,
	        appearance: 'none',
	        backgroundColor: 'transparent',
	        border: "1px solid " + styleConstants.gray76,
	        borderRadius: 4,
	        boxShadow: 'none',
	        fontFamily: styleConstants.baseFontFamily,
	        padding: "9px 25px 9px 9px",
	
	        ':focus': {
	            outline: 'none',
	            border: "2px solid " + styleConstants.kaGreen,
	            padding: "8px 25px 8px 8px"
	        },
	
	        ':focus + svg': {
	            color: "" + styleConstants.kaGreen
	        },
	
	        ':disabled': {
	            color: styleConstants.gray68
	        },
	
	        ':disabled + svg': {
	            color: styleConstants.gray68
	        }
	    },
	
	    numberInput: {
	        float: "right",
	        width: 170,
	        marginBottom: 10,
	        border: "1px solid " + styleConstants.gray76,
	        borderRadius: 4,
	        padding: "9px 25px 9px 9px",
	
	        ':focus': {
	            outline: 'none',
	            border: "2px solid " + styleConstants.kaGreen,
	            padding: "8px 25px 8px 8px"
	        }
	    },
	
	    numberInputContainer: {
	        display: "flex"
	    }
	});
	
	module.exports = {
	    name: "numeric-input",
	    displayName: "Number text box",
	    defaultAlignment: "inline-block",
	    accessible: true,
	    widget: NumericInput,
	    transform: propsTransform,
	    isLintable: true
	};

/***/ },
/* 72 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable comma-dangle, no-redeclare, no-var, react/jsx-closing-bracket-location, react/jsx-indent-props, react/sort-comp, space-infix-ops */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	var Changeable = __webpack_require__(187);
	var EditorJsonify = __webpack_require__(197);
	
	var ButtonGroup = __webpack_require__(83);
	var Editor = __webpack_require__(25);
	
	var _require = __webpack_require__(47),
	    iconGear = _require.iconGear,
	    iconTrash = _require.iconTrash;
	
	var InfoTip = __webpack_require__(176);
	var InlineIcon = __webpack_require__(48);
	var MultiButtonGroup = __webpack_require__(198);
	var NumberInput = __webpack_require__(199);
	var PropCheckBox = __webpack_require__(90);
	var TextInput = __webpack_require__(200);
	
	var firstNumericalParse = __webpack_require__(17).firstNumericalParse;
	
	var answerFormButtons = [{ title: "Integers", value: "integer", content: "6" }, { title: "Decimals", value: "decimal", content: "0.75" }, { title: "Proper fractions", value: "proper", content: "\u2157" }, {
	    title: "Improper fractions",
	    value: "improper",
	    content: "\u2077\u2044\u2084"
	}, { title: "Mixed numbers", value: "mixed", content: "1\xBE" }, { title: "Numbers with \u03C0", value: "pi", content: "\u03C0" }];
	
	var initAnswer = function initAnswer(status) {
	    return {
	        value: null,
	        status: status,
	        message: "",
	        simplify: "required",
	        answerForms: [],
	        strict: false,
	        maxError: null
	    };
	};
	
	var NumericInputEditor = React.createClass({
	    displayName: "NumericInputEditor",
	
	    propTypes: _extends({}, Changeable.propTypes),
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            answers: [initAnswer("correct")],
	            size: "normal",
	            coefficient: false,
	            labelText: "",
	            multipleNumberInput: false
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            lastStatus: "wrong",
	            showOptions: _.map(this.props.answers, function () {
	                return false;
	            })
	        };
	    },
	
	    render: function render() {
	        var _this = this;
	
	        var answers = this.props.answers;
	
	        var unsimplifiedAnswers = function unsimplifiedAnswers(i) {
	            return React.createElement(
	                "div",
	                { className: "perseus-widget-row" },
	                React.createElement(
	                    "label",
	                    null,
	                    "Unsimplified answers are"
	                ),
	                React.createElement(ButtonGroup, {
	                    value: answers[i]["simplify"],
	                    allowEmpty: false,
	                    buttons: [{ value: "required", content: "ungraded" }, { value: "optional", content: "accepted" }, { value: "enforced", content: "wrong" }],
	                    onChange: _this.updateAnswer(i, "simplify")
	                }),
	                React.createElement(
	                    InfoTip,
	                    null,
	                    React.createElement(
	                        "p",
	                        null,
	                        "Normally select \"ungraded\". This will give the user a message saying the answer is correct but not simplified. The user will then have to simplify it and re-enter, but will not be penalized. (5th grade and after)"
	                    ),
	                    React.createElement(
	                        "p",
	                        null,
	                        "Select \"accepted\" only if the user is not expected to know how to simplify fractions yet. (Anything prior to 5th grade)"
	                    ),
	                    React.createElement(
	                        "p",
	                        null,
	                        "Select \"wrong\" ",
	                        React.createElement(
	                            "em",
	                            null,
	                            "only"
	                        ),
	                        " if we are specifically assessing the ability to simplify."
	                    )
	                )
	            );
	        };
	
	        var suggestedAnswerTypes = function suggestedAnswerTypes(i) {
	            return React.createElement(
	                "div",
	                null,
	                React.createElement(
	                    "div",
	                    { className: "perseus-widget-row" },
	                    React.createElement(
	                        "label",
	                        null,
	                        "Choose the suggested answer formats"
	                    ),
	                    React.createElement(MultiButtonGroup, {
	                        buttons: answerFormButtons,
	                        values: answers[i]["answerForms"],
	                        onChange: _this.updateAnswer(i, "answerForms")
	                    }),
	                    React.createElement(
	                        InfoTip,
	                        null,
	                        React.createElement(
	                            "p",
	                            null,
	                            "Formats will be autoselected for you based on the given answer; to show no suggested formats and accept all types, simply have a decimal/integer be the answer. Values with \u03C0 will have format \"pi\", and values that are fractions will have some subset (mixed will be \"mixed\" and \"proper\"; improper/proper will both be \"improper\" and \"proper\"). If you would like to specify that it is only a proper fraction (or only a mixed/improper fraction), deselect the other format. Except for specific cases, you should not need to change the autoselected formats."
	                        ),
	                        React.createElement(
	                            "p",
	                            null,
	                            "To restrict the answer to ",
	                            React.createElement(
	                                "em",
	                                null,
	                                "only"
	                            ),
	                            " an improper fraction (i.e. 7/4), select the improper fraction and toggle \"strict\" to true. This ",
	                            React.createElement(
	                                "b",
	                                null,
	                                "will not"
	                            ),
	                            " ",
	                            " accept 1.75 as an answer.",
	                            " "
	                        ),
	                        React.createElement(
	                            "p",
	                            null,
	                            "Unless you are testing that specific skill, please do not restrict the answer format."
	                        )
	                    )
	                ),
	                React.createElement(
	                    "div",
	                    { className: "perseus-widget-row" },
	                    React.createElement(PropCheckBox, {
	                        label: "Strictly match only these formats",
	                        strict: answers[i]["strict"],
	                        onChange: _this.updateAnswer.bind(_this, i)
	                    })
	                )
	            );
	        };
	
	        var maxError = function maxError(i) {
	            return React.createElement(
	                "div",
	                { className: "perseus-widget-row" },
	                React.createElement(
	                    "label",
	                    null,
	                    "Max error",
	                    " ",
	                    React.createElement(NumberInput, {
	                        className: "max-error",
	                        value: answers[i]["maxError"],
	                        onChange: _this.updateAnswer(i, "maxError"),
	                        placeholder: "0"
	                    })
	                )
	            );
	        };
	
	        var inputSize = React.createElement(
	            "div",
	            { className: "perseus-widget-row" },
	            React.createElement(
	                "label",
	                null,
	                "Width:  "
	            ),
	            React.createElement(ButtonGroup, {
	                value: this.props.size,
	                allowEmpty: false,
	                buttons: [{ value: "normal", content: "Normal (80px)" }, { value: "small", content: "Small (40px)" }],
	                onChange: this.change("size")
	            }),
	            React.createElement(
	                InfoTip,
	                null,
	                React.createElement(
	                    "p",
	                    null,
	                    "Use size \"Normal\" for all text boxes, unless there are multiple text boxes in one line and the answer area is too narrow to fit them."
	                )
	            )
	        );
	
	        var labelText = React.createElement(
	            "div",
	            { className: "perseus-widget-row" },
	            React.createElement(
	                "label",
	                null,
	                "Label text:",
	                " ",
	                React.createElement(TextInput, {
	                    value: this.props.labelText,
	                    onChange: this.change("labelText")
	                })
	            ),
	            React.createElement(
	                InfoTip,
	                null,
	                React.createElement(
	                    "p",
	                    null,
	                    "Text to describe this input. This will be shown to users using screenreaders."
	                )
	            )
	        );
	
	        var coefficientCheck = React.createElement(
	            "div",
	            null,
	            React.createElement(
	                "div",
	                { className: "perseus-widget-row" },
	                React.createElement(PropCheckBox, {
	                    label: "Coefficient",
	                    coefficient: this.props.coefficient,
	                    onChange: this.props.onChange
	                }),
	                React.createElement(
	                    InfoTip,
	                    null,
	                    React.createElement(
	                        "p",
	                        null,
	                        "A coefficient style number allows the student to use - for -1 and an empty string to mean 1."
	                    )
	                )
	            )
	        );
	
	        var addAnswerButton = React.createElement(
	            "div",
	            null,
	            React.createElement(
	                "a",
	                {
	                    href: "javascript:void(0)",
	                    className: "simple-button orange",
	                    onClick: function onClick() {
	                        return _this.addAnswer();
	                    },
	                    onKeyDown: function onKeyDown(e) {
	                        return _this.onSpace(e, _this.addAnswer);
	                    }
	                },
	                React.createElement(
	                    "span",
	                    null,
	                    "Add new answer"
	                )
	            )
	        );
	
	        var instructions = {
	            wrong: "(address the mistake/misconception)",
	            ungraded: "(explain in detail to avoid confusion)",
	            correct: "(reinforce the user's understanding)"
	        };
	
	        var generateInputAnswerEditors = function generateInputAnswerEditors() {
	            return answers.map(function (answer, i) {
	                var editor = React.createElement(Editor, {
	                    apiOptions: _this.props.apiOptions,
	                    content: answer.message || "",
	                    placeholder: "Why is this answer " + answer.status + "?\t" + instructions[answer.status],
	                    widgetEnabled: false,
	                    onChange: function onChange(newProps) {
	                        if ("content" in newProps) {
	                            _this.updateAnswer(i, {
	                                message: newProps.content
	                            });
	                        }
	                    }
	                });
	                return React.createElement(
	                    "div",
	                    { className: "perseus-widget-row", key: i },
	                    React.createElement(
	                        "div",
	                        {
	                            className: "input-answer-editor-value-container" + (answer.maxError ? " with-max-error" : "")
	                        },
	                        React.createElement(NumberInput, {
	                            value: answer.value,
	                            className: "numeric-input-value",
	                            placeholder: "answer",
	                            format: _.last(answer.answerForms),
	                            onFormatChange: function onFormatChange(newValue, format) {
	                                // NOTE(charlie): The mobile web expression
	                                // editor relies on this automatic answer
	                                // form resolution for determining when to
	                                // show the Pi symbol. If we get rid of it,
	                                // we should also disable Pi for
	                                // NumericInput and require problems that
	                                // use Pi to build on Expression.
	                                // Alternatively, we could store answers
	                                // as plaintext and parse them to determine
	                                // whether or not to reveal Pi on the
	                                // keypad (right now, answers are stored as
	                                // resolved values, like '0.125' rather
	                                // than '1/8').
	                                var forms;
	                                if (format === "pi") {
	                                    forms = ["pi"];
	                                } else if (format === "mixed") {
	                                    forms = ["proper", "mixed"];
	                                } else if (format === "proper" || format === "improper") {
	                                    forms = ["proper", "improper"];
	                                }
	                                _this.updateAnswer(i, {
	                                    value: firstNumericalParse(newValue),
	                                    answerForms: forms
	                                });
	                            },
	                            onChange: function onChange(newValue) {
	                                _this.updateAnswer(i, {
	                                    value: firstNumericalParse(newValue)
	                                });
	                            }
	                        }),
	                        answer.strict && React.createElement(
	                            "div",
	                            {
	                                className: "is-strict-indicator",
	                                title: "strictly equivalent to"
	                            },
	                            "\u2261"
	                        ),
	                        answer.simplify !== "required" && answer.status === "correct" && React.createElement(
	                            "div",
	                            {
	                                className: "simplify-indicator " + answer.simplify,
	                                title: "accepts unsimplified answers"
	                            },
	                            "\u2030"
	                        ),
	                        answer.maxError ? React.createElement(
	                            "div",
	                            { className: "max-error-container" },
	                            React.createElement(
	                                "div",
	                                { className: "max-error-plusmn" },
	                                "\xB1"
	                            ),
	                            React.createElement(NumberInput, {
	                                placeholder: 0,
	                                value: answers[i]["maxError"],
	                                format: _.last(answer.answerForms),
	                                onChange: _this.updateAnswer(i, "maxError")
	                            })
	                        ) : null,
	                        React.createElement("div", { className: "value-divider" }),
	                        React.createElement(
	                            "a",
	                            {
	                                href: "javascript:void(0)",
	                                className: "answer-status " + answer.status,
	                                onClick: function onClick() {
	                                    return _this.onStatusChange(i);
	                                },
	                                onKeyDown: function onKeyDown(e) {
	                                    return _this.onSpace(e, _this.onStatusChange, i);
	                                }
	                            },
	                            answer.status
	                        ),
	                        React.createElement(
	                            "a",
	                            {
	                                href: "javascript:void(0)",
	                                className: "answer-trash",
	                                onClick: function onClick() {
	                                    return _this.onTrashAnswer(i);
	                                },
	                                onKeyDown: function onKeyDown(e) {
	                                    return _this.onSpace(e, _this.onTrashAnswer, i);
	                                }
	                            },
	                            React.createElement(InlineIcon, iconTrash)
	                        ),
	                        React.createElement(
	                            "a",
	                            {
	                                href: "javascript:void(0)",
	                                className: "options-toggle",
	                                onClick: function onClick() {
	                                    return _this.onToggleOptions(i);
	                                },
	                                onKeyDown: function onKeyDown(e) {
	                                    return _this.onSpace(e, _this.onToggleOptions, i);
	                                }
	                            },
	                            React.createElement(InlineIcon, iconGear)
	                        )
	                    ),
	                    React.createElement(
	                        "div",
	                        { className: "input-answer-editor-message" },
	                        editor
	                    ),
	                    _this.state.showOptions[i] && React.createElement(
	                        "div",
	                        { className: "options-container" },
	                        maxError(i),
	                        answer.status === "correct" && unsimplifiedAnswers(i),
	                        suggestedAnswerTypes(i)
	                    )
	                );
	            });
	        };
	
	        return React.createElement(
	            "div",
	            { className: "perseus-input-number-editor" },
	            React.createElement(
	                "div",
	                { ref: function ref(e) {
	                        return _this.multInputOption = e;
	                    } },
	                React.createElement(
	                    "select",
	                    { onChange: this.onMultipleInputChange },
	                    React.createElement(
	                        "option",
	                        { value: "simple-numeric-input" },
	                        "Ask for one correct solution"
	                    ),
	                    React.createElement(
	                        "option",
	                        { value: "multiple-numeric-input" },
	                        "Ask for all correct solutions"
	                    )
	                )
	            ),
	            React.createElement(
	                "div",
	                { className: "ui-title" },
	                "User input"
	            ),
	            React.createElement(
	                "div",
	                { className: "msg-title" },
	                "Message shown to user on attempt"
	            ),
	            generateInputAnswerEditors(),
	            addAnswerButton,
	            inputSize,
	            coefficientCheck,
	            labelText
	        );
	    },
	
	    change: function change() {
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return Changeable.change.apply(this, args);
	    },
	
	
	    onToggleOptions: function onToggleOptions(choiceIndex) {
	        var showOptions = this.state.showOptions.slice();
	        showOptions[choiceIndex] = !showOptions[choiceIndex];
	        this.setState({ showOptions: showOptions });
	    },
	
	    onTrashAnswer: function onTrashAnswer(choiceIndex) {
	        if (choiceIndex >= 0 && choiceIndex < this.props.answers.length) {
	            var answers = this.props.answers.slice(0);
	            answers.splice(choiceIndex, 1);
	            this.props.onChange({ answers: answers });
	        }
	    },
	
	    onSpace: function onSpace(e, callback) {
	        if (e.key === " ") {
	            e.preventDefault(); // prevent page shifting
	            var args = _.toArray(arguments).slice(2);
	            callback.apply(this, args);
	        }
	    },
	
	    onStatusChange: function onStatusChange(choiceIndex) {
	        var statuses = ["wrong", "ungraded", "correct"];
	        var answers = this.props.answers;
	        var i = _.indexOf(statuses, answers[choiceIndex].status);
	        var newStatus = statuses[(i + 1) % statuses.length];
	
	        this.updateAnswer(choiceIndex, {
	            status: newStatus,
	            simplify: newStatus === "correct" ? "required" : "accepted"
	        });
	    },
	
	    onMultipleInputChange: function onMultipleInputChange(event) {
	        var newOption = event.target.value;
	        if (newOption === "multiple-numeric-input") {
	            this.props.onChange({ multipleNumberInput: true });
	        } else {
	            this.props.onChange({ multipleNumberInput: false });
	        }
	    },
	
	    updateAnswer: function updateAnswer(choiceIndex, update) {
	        var _this2 = this;
	
	        if (!_.isObject(update)) {
	            return _.partial(function (choiceIndex, key, value) {
	                var update = {};
	                update[key] = value;
	                _this2.updateAnswer(choiceIndex, update);
	            }, choiceIndex, update);
	        }
	
	        var answers = _.clone(this.props.answers);
	
	        // Don't bother to make a new answer box unless we are editing the last
	        // one.
	        // TODO(oliver): This might not be necessary anymore.
	        if (choiceIndex === answers.length) {
	            var lastAnswer = initAnswer(this.state.lastStatus);
	            var answers = answers.concat(lastAnswer);
	        }
	
	        answers[choiceIndex] = _.extend({}, answers[choiceIndex], update);
	        this.props.onChange({ answers: answers });
	    },
	
	    addAnswer: function addAnswer() {
	        var lastAnswer = initAnswer(this.state.lastStatus);
	        var answers = this.props.answers.concat(lastAnswer);
	        this.props.onChange({ answers: answers });
	    },
	
	    getSaveWarnings: function getSaveWarnings() {
	        // Filter out all the empty answers
	        var warnings = [];
	        // TODO(emily): This doesn't actually work, because the value is either
	        // null or undefined when undefined, probably.
	        if (_.contains(_.pluck(this.props.answers, "value"), "")) {
	            warnings.push("One or more answers is empty");
	        }
	        this.props.answers.forEach(function (answer, i) {
	            var formatError = answer.strict && (!answer.answerForms || answer.answerForms.length === 0);
	            if (formatError) {
	                warnings.push("Answer " + (i + 1) + " is set to string format " + "matching, but no format was selected");
	            }
	        });
	        return warnings;
	    },
	
	    serialize: function serialize() {
	        return EditorJsonify.serialize.call(this);
	    }
	});
	
	module.exports = NumericInputEditor;

/***/ },
/* 73 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable comma-dangle, indent, no-redeclare, no-undef, no-unused-vars, no-var, object-curly-spacing, react/jsx-closing-bracket-location, react/jsx-indent-props, react/sort-comp */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var classNames = __webpack_require__(86);
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var Tooltip = __webpack_require__(193);
	var _ = __webpack_require__(56);
	
	var ApiOptions = __webpack_require__(12).Options;
	var Changeable = __webpack_require__(187);
	var ApiOptions = __webpack_require__(12).Options;
	var ApiClassNames = __webpack_require__(12).ClassNames;
	var KhanAnswerTypes = __webpack_require__(82);
	
	var InlineIcon = __webpack_require__(48);
	var InputWithExamples = __webpack_require__(181);
	var MathInput = __webpack_require__(194);
	var TexButtons = __webpack_require__(195);
	
	var KeypadInput = __webpack_require__(257).components.KeypadInput;
	
	var _require$propTypes = __webpack_require__(257).propTypes,
	    keypadConfigurationPropType = _require$propTypes.keypadConfigurationPropType,
	    keypadElementPropType = _require$propTypes.keypadElementPropType;
	
	var KeypadTypes = __webpack_require__(257).consts.KeypadTypes;
	
	var _require = __webpack_require__(52),
	    linterContextProps = _require.linterContextProps,
	    linterContextDefault = _require.linterContextDefault;
	
	var _require2 = __webpack_require__(47),
	    iconExclamationSign = _require2.iconExclamationSign;
	
	var lens = __webpack_require__(180);
	
	var ERROR_MESSAGE = i18n._("Sorry, I don't understand that!");
	
	// TODON'T(emily): Don't delete these.
	var NO_ANSWERS_WARNING = ["An expression without an answer", "is no expression to me.", "Who can learn from an input", "like the one that I see?", "Put something in there", "won't you please?", "A few digits will do -", "might I suggest some threes?"].join("\n");
	var NO_CORRECT_ANSWERS_WARNING = "This question is probably going to be too " + "hard because the expression has no correct answer.";
	var SIMPLIFY_WARNING = function SIMPLIFY_WARNING(str) {
	    return "\"" + str + "\" is required to be simplified but is not considered " + "simplified by our fancy computer algebra system. This will be " + "graded as incorrect.";
	};
	var PARSE_WARNING = function PARSE_WARNING(str) {
	    return "\"" + str + "\" <- you sure that's math?";
	};
	var NOT_SPECIFIED_WARNING = function NOT_SPECIFIED_WARNING(ix) {
	    return "mind filling in answer " + ix + "? (the blank one)";
	};
	
	var insertBraces = function insertBraces(value) {
	    // HACK(alex): Make sure that all LaTeX super/subscripts are wrapped
	    // in curly braces to avoid the mismatch between KAS and LaTeX sup/sub
	    // parsing.
	    //
	    // What exactly is this mismatch? Due to its heritage of parsing plain
	    // text math from <OldExpression />, KAS parses "x^12" as x^(12).
	    // This is both generally what the user expects to happen, and is
	    // consistent with other computer algebra systems. It is NOT
	    // consistent with LaTeX however, where x^12 is equivalent to x^{1}2.
	    //
	    // Since the only LaTeX we parse comes from MathQuill, this wouldn't
	    // be a problem if MathQuill just always gave us the latter version
	    // (with explicit braces). However, instead it always gives the former.
	    // This behavior is baked in pretty deep; my naive attempts at changing
	    // it triggered all sorts of confusing errors. So instead we just make
	    // sure to add in any missing braces before grading MathQuill input.
	    //
	    // TODO(alex): Properly hack MathQuill to always use explicit braces.
	    return value.replace(/([_^])([^{])/g, "$1{$2}");
	};
	
	// The new, MathQuill input expression widget
	var Expression = React.createClass({
	    displayName: "Expression",
	
	    propTypes: _extends({}, Changeable.propTypes, {
	        apiOptions: ApiOptions.propTypes,
	        buttonSets: TexButtons.buttonSetsType,
	        buttonsVisible: React.PropTypes.oneOf(["always", "never", "focused"]),
	        functions: React.PropTypes.arrayOf(React.PropTypes.string),
	        keypadConfiguration: keypadConfigurationPropType,
	        keypadElement: keypadElementPropType,
	        times: React.PropTypes.bool,
	        trackInteraction: React.PropTypes.func.isRequired,
	        value: React.PropTypes.string,
	        widgetId: React.PropTypes.string.isRequired,
	        linterContext: linterContextProps
	    }),
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            value: "",
	            times: false,
	            functions: [],
	            buttonSets: ["basic", "trig", "prealgebra", "logarithms"],
	            onFocus: function onFocus() {},
	            onBlur: function onBlur() {},
	            apiOptions: ApiOptions.defaults,
	            linterContext: linterContextDefault
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            showErrorTooltip: false,
	            showErrorText: false
	        };
	    },
	
	    change: function change() {
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return Changeable.change.apply(this, args);
	    },
	
	
	    parse: function parse(value, props) {
	        // TODO(jack): Disable icu for content creators here, or
	        // make it so that solution answers with ','s or '.'s work
	        var options = _.pick(props || this.props, "functions");
	        if (window.icu && window.icu.getDecimalFormatSymbols) {
	            _.extend(options, window.icu.getDecimalFormatSymbols());
	        }
	        return KAS.parse(insertBraces(value), options);
	    },
	
	    render: function render() {
	        var _this = this;
	
	        if (this.props.apiOptions.customKeypad) {
	            return React.createElement(KeypadInput, {
	                ref: "input",
	                value: this.props.value,
	                keypadElement: this.props.keypadElement,
	                onChange: this.changeAndTrack,
	                onFocus: function onFocus() {
	                    _this.props.keypadElement.configure(_this.props.keypadConfiguration, function () {
	                        if (_this.isMounted()) {
	                            _this._handleFocus();
	                        }
	                    });
	                },
	                onBlur: this._handleBlur
	            });
	        } else if (this.props.apiOptions.staticRender) {
	            // To make things slightly easier, we just use an InputWithExamples
	            // component to handle the static rendering, which is the same
	            // component used by InputNumber and NumericInput
	            return React.createElement(InputWithExamples, {
	                ref: "input",
	                value: this.props.value,
	                type: "tex",
	                examples: [],
	                shouldShowExamples: false,
	                onChange: this.changeAndTrack,
	                onFocus: this._handleFocus,
	                onBlur: this._handleBlur,
	                id: this.props.widgetId,
	                linterContext: this.props.linterContext
	            });
	        } else {
	            // TODO(alex): Style this tooltip to be more consistent with other
	            // tooltips on the site; align to left middle (once possible)
	            var errorTooltip = React.createElement(
	                "span",
	                { className: "error-tooltip" },
	                React.createElement(
	                    Tooltip,
	                    {
	                        className: "error-text-container",
	                        horizontalPosition: "right",
	                        horizontalAlign: "left",
	                        verticalPosition: "top",
	                        arrowSize: 10,
	                        borderColor: "#fcc335",
	                        show: this.state.showErrorText
	                    },
	                    React.createElement(
	                        "span",
	                        {
	                            className: "error-icon",
	                            onMouseEnter: function onMouseEnter() {
	                                _this.setState({ showErrorText: true });
	                            },
	                            onMouseLeave: function onMouseLeave() {
	                                _this.setState({ showErrorText: false });
	                            },
	                            onClick: function onClick() {
	                                // TODO(alex): Better error feedback for mobile
	                                _this.setState({
	                                    showErrorText: !_this.state.showErrorText
	                                });
	                            }
	                        },
	                        React.createElement(InlineIcon, iconExclamationSign)
	                    ),
	                    React.createElement(
	                        "div",
	                        { className: "error-text" },
	                        ERROR_MESSAGE
	                    )
	                )
	            );
	
	            var className = classNames({
	                "perseus-widget-expression": true,
	                "show-error-tooltip": this.state.showErrorTooltip
	            });
	
	            return React.createElement(
	                "span",
	                { className: className },
	                React.createElement(MathInput, {
	                    ref: "input",
	                    className: ApiClassNames.INTERACTIVE,
	                    value: this.props.value,
	                    onChange: this.changeAndTrack,
	                    convertDotToTimes: this.props.times,
	                    buttonsVisible: this.props.buttonsVisible || "focused",
	                    buttonSets: this.props.buttonSets,
	                    onFocus: this._handleFocus,
	                    onBlur: this._handleBlur
	                }),
	                this.state.showErrorTooltip && errorTooltip
	            );
	        }
	    },
	
	    changeAndTrack: function changeAndTrack(e, cb) {
	        this.change("value", e, cb);
	        this.props.trackInteraction();
	    },
	
	    _handleFocus: function _handleFocus() {
	        this.props.onFocus([]);
	    },
	
	    _handleBlur: function _handleBlur() {
	        this.props.onBlur([]);
	    },
	
	    errorTimeout: null,
	
	    // Whenever the input value changes, attempt to parse it.
	    //
	    // Clear any errors if this parse succeeds, show an error within a second
	    // if it fails.
	    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        var _this2 = this;
	
	        if (!_.isEqual(this.props.value, nextProps.value) || !_.isEqual(this.props.functions, nextProps.functions)) {
	            clearTimeout(this.errorTimeout);
	
	            if (this.parse(nextProps.value, nextProps).parsed) {
	                this.setState({ showErrorTooltip: false });
	            } else {
	                // Store timeout ID so that we can clear it above
	                this.errorTimeout = setTimeout(function () {
	                    var apiResult = _this2.props.apiOptions.onInputError(null, // reserved for some widget identifier
	                    _this2.props.value, ERROR_MESSAGE);
	                    if (apiResult !== false) {
	                        _this2.setState({ showErrorTooltip: true });
	                    }
	                }, 2000);
	            }
	        }
	    },
	
	    componentWillUnmount: function componentWillUnmount() {
	        clearTimeout(this.errorTimeout);
	    },
	
	    focus: function focus() {
	        if (this.props.apiOptions.customKeypad) {
	            this.refs.input.focus();
	        } else {
	            // The buttons are often on top of text you're trying to read, so
	            // don't focus the editor automatically.
	        }
	
	        return true;
	    },
	
	    focusInputPath: function focusInputPath(inputPath) {
	        this.refs.input.focus();
	    },
	
	    blurInputPath: function blurInputPath(inputPath) {
	        this.refs.input.blur();
	    },
	
	    // HACK(joel)
	    insert: function insert(text) {
	        if (!this.props.apiOptions.staticRender) {
	            this.refs.input.insert(text);
	        }
	    },
	
	    getInputPaths: function getInputPaths() {
	        // The widget itself is an input, so we return a single empty list to
	        // indicate this.
	        return [[]];
	    },
	
	    getGrammarTypeForPath: function getGrammarTypeForPath(inputPath) {
	        return "expression";
	    },
	
	    setInputValue: function setInputValue(path, newValue, cb) {
	        this.props.onChange({
	            value: newValue
	        }, cb);
	    },
	
	    getAcceptableFormatsForInputPath: function getAcceptableFormatsForInputPath() {
	        // TODO(charlie): What format does the mobile team want this in?
	        return null;
	    },
	
	    getUserInput: function getUserInput() {
	        return insertBraces(this.props.value);
	    },
	
	    simpleValidate: function simpleValidate(rubric, onInputError) {
	        onInputError = onInputError || function () {};
	        return Expression.validate(this.getUserInput(), rubric, onInputError);
	    }
	});
	
	/* Content creators input a list of answers which are matched from top to
	 * bottom. The intent is that they can include spcific solutions which should
	 * be graded as correct or incorrect (or ungraded!) first, then get more
	 * general.
	 *
	 * We iterate through each answer, trying to match it with the user's input
	 * using the following angorithm:
	 * - Try to parse the user's input. If it doesn't parse then return "not
	 *   graded".
	 * - For each answer:
	 *   ~ Try to validate the user's input against the answer. The answer is
	 *     expected to parse.
	 *   ~ If the user's input validates (the validator judges it "correct"), we've
	 *     matched and can stop considering answers.
	 * - If there were no matches or the matching answer is considered "ungraded",
	 *   show the user an error. TODO(joel) - what error?
	 * - Otherwise, pass through the resulting points and message.
	 */
	_.extend(Expression, {
	    validate: function validate(state, rubric, onInputError) {
	        var options = _.clone(rubric);
	        if (window.icu && window.icu.getDecimalFormatSymbols) {
	            _.extend(options, window.icu.getDecimalFormatSymbols());
	        }
	
	        var createValidator = function createValidator(answer) {
	            return KhanAnswerTypes.expression.createValidatorFunctional(
	            // We don't give options to KAS.parse here because that is
	            // parsing the solution answer, not the student answer, and we
	            // don't want a solution to work if the student is using a
	            // different language but not in english.
	            KAS.parse(answer.value, rubric).expr, _({}).extend(options, {
	                simplify: answer.simplify,
	                form: answer.form
	            }));
	        };
	
	        // find the first result to match the user's input
	        var result;
	        var matchingAnswer;
	        var allEmpty = true;
	        var foundMatch = !!_(rubric.answerForms).find(function (answer) {
	            var validate = createValidator(answer);
	
	            // save these because they'll be needed if this answer matches
	            result = validate(state);
	            matchingAnswer = answer;
	            allEmpty = allEmpty && result.empty;
	
	            // short-circuit as soon as an answer matches
	            return result.correct;
	        });
	
	        var message = "" || result && result.message;
	
	        // now check to see whether it's considered correct, incorrect, or
	        // ungraded
	        if (!foundMatch) {
	            if (allEmpty) {
	                // If everything graded as empty, it's invalid.
	                return {
	                    type: "invalid",
	                    message: null
	                };
	            } else {
	                // We fell through all the possibilities and we're not empty,
	                // so the answer is considered incorrect.
	                return {
	                    type: "points",
	                    earned: 0,
	                    total: 1
	                };
	            }
	
	            // we matched an ungraded answer - return "invalid"
	        } else if (matchingAnswer.considered === "ungraded") {
	            var apiResult = onInputError(null, // reserved for some widget identifier
	            state, message);
	            return {
	                type: "invalid",
	                message: apiResult === false ? null : message
	            };
	
	            // The user's input matched one of the answers - is it correct or
	            // incorrect?
	        } else {
	            // TODO(eater): Seems silly to translate result to this
	            // invalid/points thing and immediately translate it back in
	            // ItemRenderer.scoreInput()
	            return {
	                type: "points",
	                earned: matchingAnswer.considered === "correct" ? 1 : 0,
	                total: 1,
	                message: message
	            };
	        }
	    }
	});
	
	/**
	 * Determine the keypad configuration parameters for the input, based on the
	 * provided properties.
	 *
	 * There are two configuration parameters to be passed to the keypad:
	 *   (1) The keypad type. For the Expression widget, we always use the
	 *       Expression keypad.
	 *   (2) The extra keys; namely, any variables or constants (like Pi) that need
	 *       to be included as keys on the keypad. These are scraped from the answer
	 *       forms.
	 */
	var keypadConfigurationForProps = function keypadConfigurationForProps(props) {
	    // Always use the Expression keypad, regardless of the button sets that have
	    // been enabled.
	    var keypadType = KeypadTypes.EXPRESSION;
	
	    // Extract any and all variables and constants from the answer forms.
	    var uniqueExtraVariables = {};
	    var uniqueExtraConstants = {};
	    for (var _iterator = props.answerForms, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
	        var _ref;
	
	        if (_isArray) {
	            if (_i >= _iterator.length) break;
	            _ref = _iterator[_i++];
	        } else {
	            _i = _iterator.next();
	            if (_i.done) break;
	            _ref = _i.value;
	        }
	
	        var answerForm = _ref;
	
	        var maybeExpr = KAS.parse(answerForm.value, props);
	        if (maybeExpr.parsed) {
	            (function () {
	                var expr = maybeExpr.expr;
	
	                // The keypad expects Greek letters to be capitalized (e.g., it
	                // requires `PI` instead of `pi`). Right now, it only supports Pi
	                // and Theta, so we special-case.
	                var isGreek = function isGreek(symbol) {
	                    return symbol === "pi" || symbol === "theta";
	                };
	                var toKey = function toKey(symbol) {
	                    return isGreek(symbol) ? symbol.toUpperCase() : symbol;
	                };
	
	                for (var _iterator2 = expr.getVars(), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
	                    var _ref2;
	
	                    if (_isArray2) {
	                        if (_i2 >= _iterator2.length) break;
	                        _ref2 = _iterator2[_i2++];
	                    } else {
	                        _i2 = _iterator2.next();
	                        if (_i2.done) break;
	                        _ref2 = _i2.value;
	                    }
	
	                    var variable = _ref2;
	
	                    uniqueExtraVariables[toKey(variable)] = true;
	                }
	                for (var _iterator3 = expr.getConsts(), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
	                    var _ref3;
	
	                    if (_isArray3) {
	                        if (_i3 >= _iterator3.length) break;
	                        _ref3 = _iterator3[_i3++];
	                    } else {
	                        _i3 = _iterator3.next();
	                        if (_i3.done) break;
	                        _ref3 = _i3.value;
	                    }
	
	                    var constant = _ref3;
	
	                    uniqueExtraConstants[toKey(constant)] = true;
	                }
	            })();
	        }
	    }
	
	    // TODO(charlie): Alert the keypad as to which of these symbols should be
	    // treated as functions.
	    var extraVariables = Object.keys(uniqueExtraVariables);
	    extraVariables.sort();
	
	    var extraConstants = Object.keys(uniqueExtraConstants);
	    extraConstants.sort();
	
	    var extraKeys = [].concat(extraVariables, extraConstants);
	    if (!extraKeys.length) {
	        // If there are no extra symbols available, we include Pi anyway, so
	        // that the "extra symbols" button doesn't appear empty.
	        extraKeys.push("PI");
	    }
	
	    return { keypadType: keypadType, extraKeys: extraKeys };
	};
	
	/*
	 * v0 props follow this schema:
	 *
	 *     times: bool
	 *     buttonSets: [string]
	 *     functions: [string]
	 *     buttonsVisible: "always" | "focused" | "never"
	 *
	 *     value: string
	 *     form: bool
	 *     simplify: bool
	 *
	 * v1 props follow this schema:
	 *
	 *     times: bool
	 *     buttonSets: [string]
	 *     functions: [string]
	 *     buttonsVisible: "always" | "focused" | "never"
	 *
	 *     answerForms: [{
	 *         considered: "correct" | "ungraded" | "incorrect"
	 *         form: bool
	 *         simplify: bool
	 *         value: string
	 *     }]
	 */
	
	var propUpgrades = {
	    1: function _(v0props) {
	        return {
	            times: v0props.times,
	            buttonSets: v0props.buttonSets,
	            functions: v0props.functions,
	            buttonsVisible: v0props.buttonsVisible,
	
	            answerForms: [{
	                considered: "correct",
	                form: v0props.form,
	                simplify: v0props.simplify,
	                value: v0props.value,
	                key: 0
	            }]
	        };
	    }
	};
	
	module.exports = {
	    name: "expression",
	    displayName: "Expression / Equation",
	    defaultAlignment: "inline-block",
	    widget: Expression,
	    transform: function transform(editorProps) {
	        var times = editorProps.times,
	            functions = editorProps.functions,
	            buttonSets = editorProps.buttonSets,
	            buttonsVisible = editorProps.buttonsVisible;
	
	        return {
	            keypadConfiguration: keypadConfigurationForProps(editorProps),
	            times: times,
	            functions: functions,
	            buttonSets: buttonSets,
	            buttonsVisible: buttonsVisible
	        };
	    },
	    version: { major: 1, minor: 0 },
	    propUpgrades: propUpgrades,
	
	    // For use by the editor
	    Expression: Expression,
	    isLintable: true
	};

/***/ },
/* 74 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable comma-dangle, indent, no-var, object-curly-spacing, one-var, react/forbid-prop-types, react/jsx-closing-bracket-location, react/jsx-indent-props, react/sort-comp, space-infix-ops */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	var lens = __webpack_require__(180);
	
	var Changeable = __webpack_require__(187);
	
	var InfoTip = __webpack_require__(176);
	var PropCheckBox = __webpack_require__(90);
	var SortableArea = __webpack_require__(196);
	var TeX = __webpack_require__(178); // OldExpression only
	var TexButtons = __webpack_require__(195);
	
	var Expression = __webpack_require__(73).Expression;
	
	// An answer can be considered correct, wrong, or ungraded.
	var CONSIDERED = ["correct", "wrong", "ungraded"];
	
	var answerFormType = React.PropTypes.shape({
	    considered: React.PropTypes.oneOf(CONSIDERED).isRequired,
	    value: React.PropTypes.string.isRequired,
	    form: React.PropTypes.bool.isRequired,
	    simplify: React.PropTypes.bool.isRequired
	});
	
	// Pick a key that isn't currently used by an answer in answerForms
	var _makeNewKey = function _makeNewKey(answerForms) {
	    // first note all the currently used keys in an array, used like a map :3
	    // note that this automatically updates the array's length property to
	    // be one past the largest key.
	    var usedKeys = [];
	    answerForms.forEach(function (ans) {
	        usedKeys[ans.key] = true;
	    });
	
	    // then scan through the array to find the first unused (undefined) key
	    for (var i = 0; i < usedKeys.length; i++) {
	        if (!usedKeys[i]) {
	            return i;
	        }
	    }
	
	    // if we didn't find a key, make one bigger than all the other keys,
	    // since that's how the length property is defined to work on arrays
	    return usedKeys.length;
	};
	
	var ExpressionEditor = React.createClass({
	    displayName: "ExpressionEditor",
	
	    propTypes: _extends({}, Changeable.propTypes, {
	        answerForms: React.PropTypes.arrayOf(answerFormType),
	        times: React.PropTypes.bool,
	        buttonSets: TexButtons.buttonSetsType,
	        functions: React.PropTypes.arrayOf(React.PropTypes.string)
	    }),
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            answerForms: [],
	            times: false,
	            buttonSets: ["basic"],
	            functions: ["f", "g", "h"]
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        // Is the format of `value` TeX or plain text?
	        // TODO(alex): Remove after backfilling everything to TeX
	        // TODO(joel) - sucks if you edit some expression without
	        // backslashes or curly braces, then come back to the question and
	        // it's surprisingly not TeX anymore.
	
	        var isTex;
	        // default to TeX if new;
	        if (this.props.answerForms.length === 0) {
	            isTex = true;
	        } else {
	            isTex = _(this.props.answerForms).any(function (form) {
	                var value = form.value;
	                // only TeX has backslashes and curly braces
	
	                return _.indexOf(value, "\\") !== -1 || _.indexOf(value, "{") !== -1;
	            });
	        }
	
	        return { isTex: isTex };
	    },
	
	    change: function change() {
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return Changeable.change.apply(this, args);
	    },
	
	
	    render: function render() {
	        var _this = this;
	
	        var answerOptions = this.props.answerForms.map(function (obj, ix) {
	            var expressionProps = {
	                // note we're using
	                // *this.props*.{times,functions,buttonSets} since each
	                // answer area has the same settings for those
	                times: _this.props.times,
	                functions: _this.props.functions,
	                buttonSets: _this.props.buttonSets,
	
	                buttonsVisible: "focused",
	                form: obj.form,
	                simplify: obj.simplify,
	                value: obj.value,
	
	                onChange: function onChange(props) {
	                    return _this.updateForm(ix, props);
	                },
	                trackInteraction: function trackInteraction() {},
	
	                widgetId: _this.props.widgetId + "-" + ix
	            };
	
	            return lens(obj).merge([], {
	                draggable: true,
	                onChange: function onChange(props) {
	                    return _this.updateForm(ix, props);
	                },
	                onDelete: function onDelete() {
	                    return _this.handleRemoveForm(ix);
	                },
	                expressionProps: expressionProps
	            }).freeze();
	        }).map(function (obj) {
	            return React.createElement(AnswerOption, obj);
	        });
	
	        var sortable = React.createElement(SortableArea, {
	            components: answerOptions,
	            onReorder: this.handleReorder,
	            className: "answer-options-list"
	        });
	
	        // checkboxes to choose which sets of input buttons are shown
	        var buttonSetChoices = _(TexButtons.buttonSets).map(function (set, name) {
	            // The first one gets special cased to always be checked, disabled,
	            // and float left.
	            var isFirst = name === "basic";
	            var checked = _.contains(_this.props.buttonSets, name) || isFirst;
	            var className = isFirst ? "button-set-label-float" : "button-set-label";
	            return React.createElement(
	                "label",
	                { className: className, key: name },
	                React.createElement("input", {
	                    type: "checkbox",
	                    checked: checked,
	                    disabled: isFirst,
	                    onChange: function onChange() {
	                        return _this.handleButtonSet(name);
	                    }
	                }),
	                name
	            );
	        });
	
	        buttonSetChoices.splice(1, 1, React.createElement(
	            "label",
	            { key: "show-div" },
	            React.createElement("input", { type: "checkbox", onChange: this.handleToggleDiv }),
	            React.createElement(
	                "span",
	                { className: "show-div-button" },
	                "show ",
	                React.createElement(
	                    TeX,
	                    null,
	                    "\\div"
	                ),
	                " button"
	            )
	        ));
	
	        return React.createElement(
	            "div",
	            { className: "perseus-widget-expression-editor" },
	            React.createElement(
	                "h3",
	                { className: "expression-editor-h3" },
	                "Global Options"
	            ),
	            React.createElement(
	                "div",
	                null,
	                React.createElement(PropCheckBox, {
	                    times: this.props.times,
	                    onChange: this.props.onChange,
	                    labelAlignment: "right",
	                    label: "Use \xD7 for rendering multiplication instead of a center dot."
	                }),
	                React.createElement(
	                    InfoTip,
	                    null,
	                    React.createElement(
	                        "p",
	                        null,
	                        "For pre-algebra problems this option displays multiplication as \\times instead of \\cdot in both the rendered output and the acceptable formats examples."
	                    )
	                )
	            ),
	            React.createElement(
	                "div",
	                null,
	                React.createElement(
	                    "label",
	                    null,
	                    "Function variables: ",
	                    React.createElement("input", {
	                        type: "text",
	                        defaultValue: this.props.functions.join(" "),
	                        onChange: this.handleFunctions
	                    })
	                ),
	                React.createElement(
	                    InfoTip,
	                    null,
	                    React.createElement(
	                        "p",
	                        null,
	                        "Single-letter variables listed here will be interpreted as functions. This let us know that f(x) means \"f of x\" and not \"f times x\"."
	                    )
	                )
	            ),
	            React.createElement(
	                "div",
	                null,
	                React.createElement(
	                    "div",
	                    null,
	                    "Button sets:"
	                ),
	                buttonSetChoices
	            ),
	            this.state.isTex && React.createElement(TexButtons, {
	                className: "math-input-buttons",
	                sets: this.props.buttonSets,
	                convertDotToTimes: this.props.times,
	                onInsert: this.handleTexInsert
	            }),
	            React.createElement(
	                "h3",
	                { className: "expression-editor-h3" },
	                "Answers"
	            ),
	            React.createElement(
	                "p",
	                { style: { margin: "4px 0" } },
	                "student responses area matched against these from top to bottom"
	            ),
	            sortable,
	            React.createElement(
	                "div",
	                null,
	                React.createElement(
	                    "button",
	                    {
	                        className: "simple-button orange",
	                        style: { fontSize: 13 },
	                        onClick: this.newAnswer,
	                        type: "button"
	                    },
	                    "Add new answer"
	                )
	            )
	        );
	    },
	
	    serialize: function serialize() {
	        var formSerializables = ["value", "form", "simplify", "considered",
	        // it's a little weird to serialize the react key, but saves some
	        // effort reconstructing them when this item is loaded later.
	        "key"];
	        var serializables = ["answerForms", "buttonSets", "functions", "times"];
	
	        var answerForms = this.props.answerForms.map(function (form) {
	            return _(form).pick(formSerializables);
	        });
	
	        return lens(this.props).set(["answerForms"], answerForms).mod([], function (props) {
	            return _(props).pick(serializables);
	        }).freeze();
	    },
	
	    getSaveWarnings: function getSaveWarnings() {
	        var _this2 = this;
	
	        var issues = [];
	
	        if (this.props.answerForms.length === 0) {
	            issues.push("No answers specified");
	        } else {
	            var hasCorrect = !!_(this.props.answerForms).find(function (form) {
	                return form.considered === "correct";
	            });
	            if (!hasCorrect) {
	                issues.push("No correct answer specified");
	            }
	
	            _(this.props.answerForms).each(function (form, ix) {
	                if (_this2.props.value === "") {
	                    issues.push("Answer " + (ix + 1) + " is empty");
	                } else {
	                    // note we're not using icu for content creators
	                    var expression = KAS.parse(form.value);
	                    if (!expression.parsed) {
	                        issues.push("Couldn't parse " + form.value);
	                    } else if (form.simplify && !expression.expr.isSimplified()) {
	                        issues.push(form.value + " isn't simplified, but is required\" +\n                            \" to be");
	                    }
	                }
	            });
	
	            // TODO(joel) - warn about:
	            //   - unreachable answers (how??)
	            //   - specific answers following unspecific answers
	            //   - incorrect answers as the final form
	        }
	
	        return issues;
	    },
	
	    _newEmptyAnswerForm: function _newEmptyAnswerForm() {
	        return {
	            considered: "correct",
	            form: false,
	
	            // note: the key means "n-th form created" - not "form in
	            // position n" and will stay the same for the life of this form
	            key: _makeNewKey(this.props.answerForms),
	
	            simplify: false,
	            value: ""
	        };
	    },
	
	    newAnswer: function newAnswer() {
	        var answerForms = this.props.answerForms.slice();
	        answerForms.push(this._newEmptyAnswerForm());
	        this.change({ answerForms: answerForms });
	    },
	
	    handleRemoveForm: function handleRemoveForm(i) {
	        var answerForms = this.props.answerForms.slice();
	        answerForms.splice(i, 1);
	        this.change({ answerForms: answerForms });
	    },
	
	    // called when the options (including the expression itself) to an answer
	    // form change
	    updateForm: function updateForm(i, props) {
	        var answerForms = lens(this.props.answerForms).merge([i], props).freeze();
	
	        this.change({ answerForms: answerForms });
	    },
	
	    handleReorder: function handleReorder(components) {
	        var answerForms = _(components).map(function (component) {
	            var form = _(component.props).pick("considered", "form", "simplify", "value");
	            form.key = component.key;
	            return form;
	        });
	
	        this.change({ answerForms: answerForms });
	    },
	
	    // called when the selected buttonset changes
	    handleButtonSet: function handleButtonSet(changingName) {
	        var _this3 = this;
	
	        var buttonSetNames = _(TexButtons.buttonSets).keys();
	
	        // Filter to preserve order - using .union and .difference would always
	        // move the last added button set to the end.
	        var buttonSets = _(buttonSetNames).filter(function (set) {
	            return _(_this3.props.buttonSets).contains(set) !== (set === changingName);
	        });
	
	        this.props.onChange({ buttonSets: buttonSets });
	    },
	
	    handleToggleDiv: function handleToggleDiv() {
	        // We always want buttonSets to contain exactly one of "basic" and
	        // "basic+div". Toggle between the two of them.
	        // If someone can think of a more elegant formulation of this (there
	        // must be one!) feel free to change it.
	        var keep, remove;
	        if (_(this.props.buttonSets).contains("basic+div")) {
	            keep = "basic";
	            remove = "basic+div";
	        } else {
	            keep = "basic+div";
	            remove = "basic";
	        }
	
	        var buttonSets = _(this.props.buttonSets).reject(function (set) {
	            return set === remove;
	        }).concat(keep);
	
	        this.change("buttonSets", buttonSets);
	    },
	
	    // called when the correct answer changes
	    handleTexInsert: function handleTexInsert(str) {
	        this.refs.expression.insert(str);
	    },
	
	    // called when the function variables change
	    handleFunctions: function handleFunctions(e) {
	        var newProps = {};
	        newProps.functions = _.compact(e.target.value.split(/[ ,]+/));
	        this.props.onChange(newProps);
	    }
	});
	
	// Find the next element in arr after val, wrapping around to the first.
	var findNextIn = function findNextIn(arr, val) {
	    var ix = _(arr).indexOf(val);
	    ix = (ix + 1) % arr.length;
	    return arr[ix];
	};
	
	var AnswerOption = React.createClass({
	    displayName: "AnswerOption",
	
	    propTypes: _extends({}, Changeable.propTypes, {
	        considered: React.PropTypes.oneOf(CONSIDERED).isRequired,
	        expressionProps: React.PropTypes.object.isRequired,
	
	        // Must the answer have the same form as this answer.
	        form: React.PropTypes.bool.isRequired,
	
	        // Must the answer be simplified.
	        simplify: React.PropTypes.bool.isRequired,
	
	        onChange: React.PropTypes.func.isRequired,
	        onDelete: React.PropTypes.func.isRequired
	    }),
	
	    getInitialState: function getInitialState() {
	        return { deleteFocused: false };
	    },
	
	    handleDeleteBlur: function handleDeleteBlur() {
	        this.setState({ deleteFocused: false });
	    },
	
	    change: function change() {
	        for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
	            args[_key2] = arguments[_key2];
	        }
	
	        return Changeable.change.apply(this, args);
	    },
	
	
	    render: function render() {
	        var removeButton = null;
	        if (this.state.deleteFocused) {
	            removeButton = React.createElement(
	                "button",
	                {
	                    type: "button",
	                    className: "simple-button orange",
	                    onClick: this.handleImSure,
	                    onBlur: this.handleDeleteBlur
	                },
	                "I'm sure!"
	            );
	        } else {
	            removeButton = React.createElement(
	                "button",
	                {
	                    type: "button",
	                    className: "simple-button orange",
	                    onClick: this.handleDelete
	                },
	                "Delete"
	            );
	        }
	
	        return React.createElement(
	            "div",
	            { className: "expression-answer-option" },
	            React.createElement("div", { className: "answer-handle" }),
	            React.createElement(
	                "div",
	                { className: "answer-body" },
	                React.createElement(
	                    "div",
	                    { className: "answer-considered" },
	                    React.createElement(
	                        "div",
	                        {
	                            onClick: this.toggleConsidered,
	                            className: "answer-status " + this.props.considered
	                        },
	                        this.props.considered
	                    ),
	                    React.createElement(
	                        "div",
	                        { className: "answer-expression" },
	                        React.createElement(Expression, this.props.expressionProps)
	                    )
	                ),
	                React.createElement(
	                    "div",
	                    { className: "answer-option" },
	                    React.createElement(PropCheckBox, {
	                        form: this.props.form,
	                        onChange: this.props.onChange,
	                        labelAlignment: "right",
	                        label: "Answer expression must have the same form."
	                    }),
	                    React.createElement(
	                        InfoTip,
	                        null,
	                        React.createElement(
	                            "p",
	                            null,
	                            "The student's answer must be in the same form. Commutativity and excess negative signs are ignored."
	                        )
	                    )
	                ),
	                React.createElement(
	                    "div",
	                    { className: "answer-option" },
	                    React.createElement(PropCheckBox, {
	                        simplify: this.props.simplify,
	                        onChange: this.props.onChange,
	                        labelAlignment: "right",
	                        label: "Answer expression must be fully expanded and simplified."
	                    }),
	                    React.createElement(
	                        InfoTip,
	                        null,
	                        React.createElement(
	                            "p",
	                            null,
	                            "The student's answer must be fully expanded and simplified. Answering this equation (x^2+2x+1) with this factored equation (x+1)^2 will render this response \"Your answer is not fully expanded and simplified.\""
	                        )
	                    )
	                ),
	                React.createElement(
	                    "div",
	                    { className: "remove-container" },
	                    removeButton
	                )
	            )
	        );
	    },
	
	    handleImSure: function handleImSure() {
	        this.props.onDelete();
	    },
	
	    handleDelete: function handleDelete() {
	        this.setState({ deleteFocused: true });
	    },
	
	    toggleConsidered: function toggleConsidered() {
	        var newVal = findNextIn(CONSIDERED, this.props.considered);
	        this.change({ considered: newVal });
	    }
	});
	
	module.exports = ExpressionEditor;

/***/ },
/* 75 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable comma-dangle, indent, no-undef, no-var, object-curly-spacing, react/forbid-prop-types, react/jsx-closing-bracket-location, react/jsx-indent-props, react/sort-comp */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	var ApiOptions = __webpack_require__(12).Options;
	var BaseRadio = __webpack_require__(186);
	var Changeable = __webpack_require__(187);
	var Editor = __webpack_require__(25);
	
	var _require = __webpack_require__(47),
	    iconPlus = _require.iconPlus,
	    iconTrash = _require.iconTrash;
	
	var InlineIcon = __webpack_require__(48);
	var PropCheckBox = __webpack_require__(90);
	
	var ChoiceEditor = React.createClass({
	    displayName: "ChoiceEditor",
	
	    propTypes: {
	        apiOptions: ApiOptions.propTypes,
	
	        choice: React.PropTypes.object,
	        showDelete: React.PropTypes.bool,
	        onClueChange: React.PropTypes.func,
	        onContentChange: React.PropTypes.func,
	        onDelete: React.PropTypes.func
	    },
	
	    render: function render() {
	        var checkedClass = this.props.choice.correct ? "correct" : "incorrect";
	        var placeholder = "Type a choice here...";
	
	        if (this.props.choice.isNoneOfTheAbove) {
	            placeholder = this.props.choice.correct ? "Type the answer to reveal to the user..." : "None of the above";
	        }
	
	        var editor = React.createElement(Editor, {
	            ref: "content-editor",
	            apiOptions: this.props.apiOptions,
	            content: this.props.choice.content || "",
	            widgetEnabled: false,
	            placeholder: placeholder,
	            disabled: this.props.choice.isNoneOfTheAbove && !this.props.choice.correct,
	            onChange: this.props.onContentChange
	        });
	
	        var clueEditor = React.createElement(Editor, {
	            ref: "clue-editor",
	            apiOptions: this.props.apiOptions,
	            content: this.props.choice.clue || "",
	            widgetEnabled: false,
	            placeholder: i18n._("Why is this choice " + checkedClass + "?"),
	            onChange: this.props.onClueChange
	        });
	
	        var deleteLink = React.createElement(
	            "a",
	            {
	                className: "simple-button orange delete-choice",
	                href: "#",
	                onClick: this.props.onDelete,
	                title: "Remove this choice"
	            },
	            React.createElement(InlineIcon, iconTrash)
	        );
	
	        return React.createElement(
	            "div",
	            { className: "choice-clue-editors" },
	            React.createElement(
	                "div",
	                { className: "choice-editor " + checkedClass },
	                editor
	            ),
	            React.createElement(
	                "div",
	                { className: "clue-editor" },
	                clueEditor
	            ),
	            this.props.showDelete && deleteLink
	        );
	    }
	});
	
	var RadioEditor = React.createClass({
	    displayName: "RadioEditor",
	
	    propTypes: _extends({}, Changeable.propTypes, {
	        apiOptions: ApiOptions.propTypes,
	        choices: React.PropTypes.arrayOf(React.PropTypes.shape({
	            content: React.PropTypes.string,
	            clue: React.PropTypes.string,
	            correct: React.PropTypes.bool
	        })),
	        displayCount: React.PropTypes.number,
	        randomize: React.PropTypes.bool,
	        hasNoneOfTheAbove: React.PropTypes.bool,
	        multipleSelect: React.PropTypes.bool,
	        countChoices: React.PropTypes.bool,
	
	        // TODO(kevinb): DEPRECATED: This is be used to force deselectEnabled
	        // behavior on mobile but not on desktop.  When enabled, the user can
	        // deselect a radio input by tapping on it again.
	        deselectEnabled: React.PropTypes.bool,
	
	        static: React.PropTypes.bool
	    }),
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            choices: [{}, {}],
	            displayCount: null,
	            randomize: false,
	            hasNoneOfTheAbove: false,
	            multipleSelect: false,
	            countChoices: false,
	            deselectEnabled: false
	        };
	    },
	
	    render: function render() {
	        var numCorrect = _.reduce(this.props.choices, function (memo, choice) {
	            return choice.correct ? memo + 1 : memo;
	        }, 0);
	        return React.createElement(
	            "div",
	            null,
	            React.createElement(
	                "div",
	                { className: "perseus-widget-row" },
	                React.createElement(
	                    "a",
	                    {
	                        href: "https://docs.google.com/document/d/1frZf7yrWVWb1n4tVjqlzqVUiv1pn4cZXbxgP62-JDBY/edit#heading=h.8ng1isya19nu",
	                        target: "_blank"
	                    },
	                    "Multiple choice style guide"
	                ),
	                React.createElement("br", null),
	                React.createElement(
	                    "div",
	                    { className: "perseus-widget-left-col" },
	                    React.createElement(PropCheckBox, {
	                        label: "Multiple selections",
	                        labelAlignment: "right",
	                        multipleSelect: this.props.multipleSelect,
	                        onChange: this.onMultipleSelectChange
	                    })
	                ),
	                React.createElement(
	                    "div",
	                    { className: "perseus-widget-right-col" },
	                    React.createElement(PropCheckBox, {
	                        label: "Randomize order",
	                        labelAlignment: "right",
	                        randomize: this.props.randomize,
	                        onChange: this.props.onChange
	                    })
	                ),
	                this.props.multipleSelect && React.createElement(
	                    "div",
	                    { className: "perseus-widget-left-col" },
	                    React.createElement(PropCheckBox, {
	                        label: "Specify number correct",
	                        labelAlignment: "right",
	                        countChoices: this.props.countChoices,
	                        onChange: this.onCountChoicesChange
	                    })
	                )
	            ),
	            React.createElement(BaseRadio, {
	                ref: "baseRadio",
	                multipleSelect: this.props.multipleSelect,
	                countChoices: this.props.countChoices,
	                numCorrect: numCorrect,
	                editMode: true,
	                labelWrap: false,
	                apiOptions: this.props.apiOptions,
	                choices: this.props.choices.map(function (choice, i) {
	                    var _this = this;
	
	                    return {
	                        content: React.createElement(ChoiceEditor, {
	                            ref: "choice-editor" + i,
	                            apiOptions: this.props.apiOptions,
	                            choice: choice,
	                            onContentChange: function onContentChange(newProps) {
	                                if ("content" in newProps) {
	                                    _this.onContentChange(i, newProps.content);
	                                }
	                            },
	                            onClueChange: function onClueChange(newProps) {
	                                if ("content" in newProps) {
	                                    _this.onClueChange(i, newProps.content);
	                                }
	                            },
	                            onDelete: this.onDelete.bind(this, i),
	                            showDelete: this.props.choices.length >= 2
	                        }),
	                        isNoneOfTheAbove: choice.isNoneOfTheAbove,
	                        checked: choice.correct
	                    };
	                }, this),
	                onChange: this.onChange
	            }),
	            React.createElement(
	                "div",
	                { className: "add-choice-container" },
	                React.createElement(
	                    "a",
	                    {
	                        className: "simple-button orange",
	                        href: "#",
	                        onClick: this.addChoice.bind(this, false)
	                    },
	                    React.createElement(InlineIcon, iconPlus),
	                    " Add a choice",
	                    " "
	                ),
	                !this.props.hasNoneOfTheAbove && React.createElement(
	                    "a",
	                    {
	                        className: "simple-button",
	                        href: "#",
	                        onClick: this.addChoice.bind(this, true)
	                    },
	                    React.createElement(InlineIcon, iconPlus),
	                    " None of the above",
	                    " "
	                )
	            )
	        );
	    },
	
	    change: function change() {
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return Changeable.change.apply(this, args);
	    },
	
	
	    onMultipleSelectChange: function onMultipleSelectChange(allowMultiple) {
	        allowMultiple = allowMultiple.multipleSelect;
	
	        var numCorrect = _.reduce(this.props.choices, function (memo, choice) {
	            return choice.correct ? memo + 1 : memo;
	        }, 0);
	
	        if (!allowMultiple && numCorrect > 1) {
	            var choices = _.map(this.props.choices, function (choice) {
	                return _.defaults({
	                    correct: false
	                }, choice);
	            });
	            this.props.onChange({
	                multipleSelect: allowMultiple,
	                choices: choices
	            });
	        } else {
	            this.props.onChange({
	                multipleSelect: allowMultiple
	            });
	        }
	    },
	
	    onCountChoicesChange: function onCountChoicesChange(count) {
	        count = count.countChoices;
	        this.props.onChange({ countChoices: count });
	    },
	
	    onChange: function onChange(_ref) {
	        var checked = _ref.checked;
	
	        var choices = _.map(this.props.choices, function (choice, i) {
	            return _.extend({}, choice, {
	                correct: checked[i],
	                content: choice.isNoneOfTheAbove && !checked[i] ? "" : choice.content
	            });
	        });
	
	        this.props.onChange({ choices: choices });
	    },
	
	    onContentChange: function onContentChange(choiceIndex, newContent) {
	        var choices = this.props.choices.slice();
	        choices[choiceIndex] = _.extend({}, choices[choiceIndex], {
	            content: newContent
	        });
	        this.props.onChange({ choices: choices });
	    },
	
	    onClueChange: function onClueChange(choiceIndex, newClue) {
	        var choices = this.props.choices.slice();
	        choices[choiceIndex] = _.extend({}, choices[choiceIndex], {
	            clue: newClue
	        });
	        if (newClue === "") {
	            delete choices[choiceIndex].clue;
	        }
	        this.props.onChange({ choices: choices });
	    },
	
	    onDelete: function onDelete(choiceIndex, e) {
	        e.preventDefault();
	
	        var choices = this.props.choices.slice();
	        var deleted = choices[choiceIndex];
	
	        choices.splice(choiceIndex, 1);
	
	        this.props.onChange({
	            choices: choices,
	            hasNoneOfTheAbove: this.props.hasNoneOfTheAbove && !deleted.isNoneOfTheAbove
	        });
	    },
	
	    addChoice: function addChoice(noneOfTheAbove, e) {
	        var _this2 = this;
	
	        e.preventDefault();
	
	        var choices = this.props.choices.slice();
	        var newChoice = { isNoneOfTheAbove: noneOfTheAbove };
	        var addIndex = choices.length - (this.props.hasNoneOfTheAbove ? 1 : 0);
	
	        choices.splice(addIndex, 0, newChoice);
	
	        this.props.onChange({
	            choices: choices,
	            hasNoneOfTheAbove: noneOfTheAbove || this.props.hasNoneOfTheAbove
	        }, function () {
	            _this2.refs["choice-editor" + addIndex].refs["content-editor"].focus();
	        });
	    },
	
	    setDisplayCount: function setDisplayCount(num) {
	        this.props.onChange({ displayCount: num });
	    },
	
	    focus: function focus() {
	        this.refs["choice-editor0"].refs["content-editor"].focus();
	        return true;
	    },
	
	    getSaveWarnings: function getSaveWarnings() {
	        if (!_.some(_.pluck(this.props.choices, "correct"))) {
	            return ["No choice is marked as correct."];
	        }
	        return [];
	    },
	
	    serialize: function serialize() {
	        return _.pick(this.props, "choices", "randomize", "multipleSelect", "countChoices", "displayCount", "hasNoneOfTheAbove", "deselectEnabled");
	    }
	});
	
	module.exports = RadioEditor;

/***/ },
/* 76 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A default set of media queries to use for different screen sizes. Based on
	 * the breakpoints from purecss.
	 *
	 * Use like:
	 *   StyleSheet.create({
	 *       blah: {
	 *           [mediaQueries.xs]: {
	 *
	 *           },
	 *       },
	 *   });
	 */
	
	var _require = __webpack_require__(77),
	    pureXsMax = _require.pureXsMax,
	    pureSmMin = _require.pureSmMin,
	    pureSmMax = _require.pureSmMax,
	    pureMdMin = _require.pureMdMin,
	    pureMdMax = _require.pureMdMax,
	    pureLgMin = _require.pureLgMin,
	    pureLgMax = _require.pureLgMax,
	    pureXlMin = _require.pureXlMin;
	
	module.exports = {
	    xs: "@media screen and (max-width: " + pureXsMax + ")",
	    sm: "@media screen and (min-width: " + pureSmMin + ") and " + ("(max-width: " + pureSmMax + ")"),
	    md: "@media screen and (min-width: " + pureMdMin + ") and " + ("(max-width: " + pureMdMax + ")"),
	    lg: "@media screen and (min-width: " + pureLgMin + ") and " + ("(max-width: " + pureLgMax + ")"),
	    xl: "@media screen and (min-width: " + pureXlMin + ")",
	
	    smOrSmaller: "@media screen and (max-width: " + pureSmMax + ")",
	    mdOrSmaller: "@media screen and (max-width: " + pureMdMax + ")",
	    lgOrSmaller: "@media screen and (max-width: " + pureLgMax + ")",
	
	    smOrLarger: "@media screen and (min-width: " + pureSmMin + ")",
	    mdOrLarger: "@media screen and (min-width: " + pureMdMin + ")",
	    lgOrLarger: "@media screen and (min-width: " + pureLgMin + ")"
	};

/***/ },
/* 77 */
/***/ function(module, exports, __webpack_require__) {

	// Generated by running:
	// `node less-to-js.js 'stylesheets/exercise-content-package/variables.less'`
	module.exports = {
	    // @baseFontFamily:        "Proxima Nova", sans-serif;
	    baseFontFamily: "'Proxima Nova',sans-serif",
	    // @boldFontFamily:        "Proxima Nova Semibold", sans-serif;
	    boldFontFamily: "'Proxima Nova Semibold',sans-serif",
	    // @green:                 #76a005;
	    green: "#76A005",
	    // @kaGreen:               #71b307;
	    kaGreen: "#71B307",
	    // @blue:                  #1c758a;
	    blue: "#1C758A",
	    // @gray:                  #aaa;
	    gray: "#AAAAAA",
	    // @red:                   #ffbaba;
	    red: "#FFBABA",
	    // @questionWidth:         480px;
	    questionWidth: "480px",
	    // @grayLight:             #aaa;
	    grayLight: "#AAAAAA",
	    // @grayLighter:           #ddd;
	    grayLighter: "#DDDDDD",
	    // @learnstormBlue:        #4898fc;
	    learnstormBlue: "#4898FC",
	
	    white: '#FFFFFF',
	    gray98: '#FAFAFA',
	    gray97: '#F6F7F7',
	    gray95: '#F0F1F2',
	    gray90: '#E3E5E6',
	    gray85: '#D6D8DA',
	    gray76: '#BABEC2',
	    gray68: '#888D93',
	    gray41: '#626569',
	    gray25: '#3B3e40',
	    gray17: '#21242c',
	    black: '#000000',
	
	    warning1: '#F86700',
	    warning3: '#C75300',
	
	    // @pure-sm-min: 568px;
	    pureSmMin: "568px",
	    // @pure-md-min: 768px;
	    pureMdMin: "768px",
	    // @pure-lg-min: 1024px;
	    pureLgMin: "1024px",
	    // @pure-xl-min: 1280px;
	    pureXlMin: "1280px",
	    // @pure-xs-max: (@pure-sm-min - 1);
	    pureXsMax: "567px",
	    // @pure-sm-max: (@pure-md-min - 1);
	    pureSmMax: "767px",
	    // @pure-md-max: (@pure-lg-min - 1);
	    pureMdMax: "1023px",
	    // @pure-lg-max: (@pure-xl-min - 1);
	    pureLgMax: "1279px",
	    // @tableBackgroundAccent: #f9f9f9; // for striping
	    tableBackgroundAccent: "#F9F9F9",
	    gtpBlue: "#4c00ff",
	    gtpIncorrectColor: "#babec2",
	    gtpCorrectColor: "#ffbe26",
	    // @satBlue:               #0084ce;
	    satBlue: "#0084CE",
	    // @satSelectedBackgroundColor: #e4f3f9;
	    satSelectedBackgroundColor: "#E4F3F9",
	    // @satActiveBackgroundColor: #d0edf4;
	    satActiveBackgroundColor: "#D0EDF4",
	    // @satCorrectColor:       #009900;
	    satCorrectColor: "#009900",
	    // @satCorrectBorderColor: #00cc00;
	    satCorrectBorderColor: "#00CC00",
	    // @satCorrectBackgroundColor: #e4f7e4;
	    satCorrectBackgroundColor: "#E4F7E4",
	    // @satIncorrectColor:     #990000;
	    satIncorrectColor: "#990000",
	    // @satIncorrectBorderColor: #cc5252;
	    satIncorrectBorderColor: "#CC5252",
	    // @satIncorrectBackgroundColor: #f2ebeb;
	    satIncorrectBackgroundColor: "#F2EBEB",
	    // @zIndexScratchPad: 1;
	    zIndexScratchPad: "1",
	    // @zIndexAboveScratchpad: @zIndexScratchPad + 1;
	    zIndexAboveScratchpad: "2",
	    // @zIndexInteractiveComponent: @zIndexAboveScratchpad + 1;
	    zIndexInteractiveComponent: "3",
	    // @zIndexCurrentlyDragging: @zIndexInteractiveComponent + 1;
	    zIndexCurrentlyDragging: "4",
	    // @zIndexCalculator: @zIndexCurrentlyDragging + 1;
	    zIndexCalculator: "5",
	    // @phoneMargin: 16px;
	    phoneMargin: 16,
	
	    negativePhoneMargin: -16,
	    hintBorderWidth: 4,
	
	    // The 'base unit' -- our new typography and layout styles are defined in
	    // terms of multiples of the 'base unit'.
	    baseUnitPx: 16,
	
	    interactiveSizes: {
	        defaultBoxSize: 400,
	        defaultBoxSizeSmall: 288
	    },
	
	    circleSize: 24,
	    radioMarginWidth: 2,
	
	    warningColor: "#f86700",
	    warningColorHover: "#df5c00",
	    warningColorActive: "#c75300",
	
	    publishBlockingErrorColor: "#be2612"
	};
	
	module.exports.radioBorderColor = module.exports.gray76;
	module.exports.checkedColor = module.exports.kaGreen;

/***/ },
/* 78 */
/***/ function(module, exports, __webpack_require__) {

	var _responsiveLabel;
	
	/* eslint-disable object-curly-spacing */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet;
	
	var mediaQueries = __webpack_require__(76);
	
	var _require2 = __webpack_require__(77),
	    zIndexAboveScratchpad = _require2.zIndexAboveScratchpad,
	    zIndexInteractiveComponent = _require2.zIndexInteractiveComponent,
	    radioBorderColor = _require2.radioBorderColor,
	    checkedColor = _require2.checkedColor,
	    circleSize = _require2.circleSize,
	    radioMarginWidth = _require2.radioMarginWidth;
	
	module.exports = StyleSheet.create({
	    perseusInteractive: {
	        zIndex: zIndexInteractiveComponent,
	        position: "relative"
	    },
	
	    aboveScratchpad: {
	        position: "relative",
	        zIndex: zIndexAboveScratchpad
	    },
	
	    blankBackground: {
	        // TODO(emily): Use KhanUtil._BACKGROUND?
	        backgroundColor: "#FDFDFD"
	    },
	
	    perseusSrOnly: {
	        border: 0,
	        clip: "rect(0,0,0,0)",
	        height: 1,
	        margin: -1,
	        overflow: "hidden",
	        padding: 0,
	        position: "absolute",
	        width: 1
	    },
	
	    responsiveLabel: (_responsiveLabel = {}, _responsiveLabel[mediaQueries.smOrSmaller] = {
	        fontSize: 14,
	        lineHeight: 1.3
	    }, _responsiveLabel[mediaQueries.md] = {
	        fontSize: 17,
	        lineHeight: 1.4
	    }, _responsiveLabel[mediaQueries.lgOrLarger] = {
	        fontSize: 20,
	        lineHeight: 1.4
	    }, _responsiveLabel),
	
	    responsiveInput: {
	        display: "inline-block",
	        WebkitAppearance: "none",
	        appearance: "none",
	
	        "::-ms-check": {
	            display: "none"
	        },
	
	        backgroundColor: "#fff",
	        border: "2px solid #fff",
	        boxShadow: "0 0px 0px 1px " + radioBorderColor,
	        outline: "none",
	
	        boxSizing: "border-box",
	        flexShrink: 0,
	        marginBottom: 1,
	        marginLeft: 1,
	        marginRight: 1,
	        marginTop: 1,
	
	        height: circleSize - 2,
	        width: circleSize - 2
	    },
	
	    responsiveRadioInput: {
	        borderRadius: "50%",
	
	        ":checked": {
	            backgroundColor: checkedColor,
	            border: "none",
	            borderRadius: "50%",
	            boxShadow: "inset 0px 0px 0px 2px white, " + ("0 0px 0px 2px " + checkedColor),
	
	            marginTop: radioMarginWidth,
	            marginBottom: radioMarginWidth,
	            marginLeft: radioMarginWidth,
	            marginRight: radioMarginWidth,
	
	            height: circleSize - 2 * radioMarginWidth,
	            width: circleSize - 2 * radioMarginWidth
	        }
	    },
	
	    responsiveRadioInputActive: {
	        backgroundColor: "#fff",
	        border: "2px solid #fff",
	        borderRadius: "50%",
	        boxShadow: "0 0px 0px 2px " + checkedColor,
	
	        marginTop: radioMarginWidth,
	        marginBottom: radioMarginWidth,
	        marginLeft: radioMarginWidth,
	        marginRight: radioMarginWidth,
	
	        height: circleSize - 2 * radioMarginWidth,
	        width: circleSize - 2 * radioMarginWidth,
	
	        ":checked": {
	            backgroundColor: "#fff"
	        }
	    },
	
	    disableTextSelection: {
	        userSelect: 'none'
	    }
	});

/***/ },
/* 79 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	    value: true
	});
	
	var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();
	
	var _util = __webpack_require__(174);
	
	var _inject = __webpack_require__(175);
	
	var StyleSheet = {
	    create: function create(sheetDefinition) {
	        return (0, _util.mapObj)(sheetDefinition, function (_ref) {
	            var _ref2 = _slicedToArray(_ref, 2);
	
	            var key = _ref2[0];
	            var val = _ref2[1];
	
	            return [key, {
	                // TODO(emily): Make a 'production' mode which doesn't prepend
	                // the class name here, to make the generated CSS smaller.
	                _name: key + '_' + (0, _util.hashObject)(val),
	                _definition: val
	            }];
	        });
	    },
	
	    rehydrate: function rehydrate() {
	        var renderedClassNames = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
	
	        (0, _inject.addRenderedClassNames)(renderedClassNames);
	    }
	};
	
	var StyleSheetServer = {
	    renderStatic: function renderStatic(renderFunc) {
	        (0, _inject.reset)();
	        (0, _inject.startBuffering)();
	        var html = renderFunc();
	        var cssContent = (0, _inject.flushToString)();
	
	        return {
	            html: html,
	            css: {
	                content: cssContent,
	                renderedClassNames: (0, _inject.getRenderedClassNames)()
	            }
	        };
	    }
	};
	
	var css = function css() {
	    for (var _len = arguments.length, styleDefinitions = Array(_len), _key = 0; _key < _len; _key++) {
	        styleDefinitions[_key] = arguments[_key];
	    }
	
	    // Filter out falsy values from the input, to allow for
	    // `css(a, test && c)`
	    var validDefinitions = styleDefinitions.filter(function (def) {
	        return def;
	    });
	
	    // Break if there aren't any valid styles.
	    if (validDefinitions.length === 0) {
	        return "";
	    }
	
	    var className = validDefinitions.map(function (s) {
	        return s._name;
	    }).join("-o_O-");
	    (0, _inject.injectStyleOnce)(className, '.' + className, validDefinitions.map(function (d) {
	        return d._definition;
	    }));
	
	    return className;
	};
	
	exports['default'] = {
	    StyleSheet: StyleSheet,
	    StyleSheetServer: StyleSheetServer,
	    css: css
	};
	module.exports = exports['default'];

/***/ },
/* 80 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A work-in-progress of _ methods for objects.
	 * That is, they take an object as a parameter,
	 * and return an object instead of an array.
	 *
	 * TODO(aria): Move this out of interactive2
	 */
	
	var _ = __webpack_require__(56);
	
	/**
	 * Does a pluck on keys inside objects in an object
	 *
	 * Ex:
	 * tools = {
	 *     translation: {
	 *         enabled: true
	 *     },
	 *     rotation: {
	 *         enabled: false
	 *     }
	 * };
	 * pluckObject(tools, "enabled") returns {
	 *     translation: true
	 *     rotation: false
	 * }
	 */
	var pluck = function pluck(table, subKey) {
	    return _.object(_.map(table, function (value, key) {
	        return [key, value[subKey]];
	    }));
	};
	
	/**
	 * Maps an object to an object
	 *
	 * > mapObject({a: '1', b: '2'}, (value, key) => {
	 *       return value + 1;
	 *   });
	 * {a: 2, b: 3}
	 */
	var mapObject = function mapObject(obj, lambda) {
	    var result = {};
	    _.each(_.keys(obj), function (key) {
	        result[key] = lambda(obj[key], key);
	    });
	    return result;
	};
	
	/**
	 * Maps an array to an object
	 *
	 * > mapObjectFromArray(['a', 'b'], function(elem) {
	 *       return elem + elem;
	 *   });
	 * {a: 'aa', b: 'bb'}
	 */
	var mapObjectFromArray = function mapObjectFromArray(arr, lambda) {
	    var result = {};
	    _.each(arr, function (elem) {
	        result[elem] = lambda(elem);
	    });
	    return result;
	};
	
	module.exports = {
	    pluck: pluck,
	    mapObject: mapObject,
	    mapObjectFromArray: mapObjectFromArray
	};

/***/ },
/* 81 */,
/* 82 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable object-curly-spacing */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	/* global i18n:false */
	
	var $ = __webpack_require__(169);
	var _ = __webpack_require__(56);
	
	var KhanMath = __webpack_require__(208);
	
	var MAXERROR_EPSILON = Math.pow(2, -42);
	
	/*
	 * Answer types
	 *
	 * Utility for creating answerable questions displayed in exercises
	 *
	 * Different answer types produce different kinds of input displays, and do
	 * different kinds of checking on the solutions.
	 *
	 * Each of the objects contain two functions, setup and createValidator.
	 *
	 * The setup function takes a solutionarea and solution, and performs setup
	 * within the solutionarea, and then returns an object which contains:
	 *
	 * answer: a function which, when called, will retrieve the current answer from
	 *         the solutionarea, which can then be validated using the validator
	 *         function
	 * validator: a function returned from the createValidator function (defined
	 *            below)
	 * solution: the correct answer to the problem
	 * showGuess: a function which, when given a guess, shows the guess within the
	 *            provided solutionarea
	 * showGuessCustom: a function which displays parts of a guess that are not
	 *                  within the solutionarea; currently only used for custom
	 *                  answers
	 *
	 * The createValidator function only takes a solution, and it returns a
	 * function which can be used to validate an answer.
	 *
	 * The resulting validator function returns:
	 * - true: if the answer is fully correct
	 * - false: if the answer is incorrect
	 * - "" (the empty string): if no answer has been provided (e.g. the answer box
	 *   is left unfilled)
	 * - a string: if there is some slight error
	 *
	 * In most cases, setup and createValidator don't really need the solution DOM
	 * element so we have setupFunctional and createValidatorFunctional for them
	 * which take only $solution.text() and $solution.data(). This makes it easier
	 * to reuse specific answer types.
	 *
	 * TODO(alpert): Think of a less-absurd name for createValidatorFunctional.
	 *
	 */
	
	var KhanAnswerTypes = {
	    /*
	     * predicate answer type
	     *
	     * performs simple predicate-based checking of a numeric solution, with
	     * different kinds of number formats
	     *
	     * Uses the data-forms option on the solution to choose which number formats
	     * are acceptable. Available data-forms:
	     *
	     * - integer:  3
	     * - proper:   3/5
	     * - improper: 5/3
	     * - pi:       3 pi
	     * - log:      log(5)
	     * - percent:  15%
	     * - mixed:    1 1/3
	     * - decimal:  1.7
	     *
	     * The solution should be a predicate of the form:
	     *
	     * function(guess, maxError) {
	     *     return abs(guess - 3) < maxError;
	     * }
	     *
	     */
	    predicate: {
	        defaultForms: "integer, proper, improper, mixed, decimal",
	        createValidatorFunctional: function createValidatorFunctional(predicate, options) {
	            // Extract the options from the given solution object
	            options = _.extend({
	                simplify: "required",
	                ratio: false,
	                forms: KhanAnswerTypes.predicate.defaultForms
	            }, options);
	            var acceptableForms = void 0;
	            // this is maintaining backwards compatibility
	            // TODO(merlob) fix all places that depend on this, then delete
	            if (!_.isArray(options.forms)) {
	                acceptableForms = options.forms.split(/\s*,\s*/);
	            } else {
	                acceptableForms = options.forms;
	            }
	
	            // TODO(jack): remove options.inexact in favor of options.maxError
	            if (options.inexact === undefined) {
	                // If we aren't allowing inexact, ensure that we don't have a
	                // large maxError as well.
	                options.maxError = 0;
	            }
	            // Allow a small tolerance on maxError, to avoid numerical
	            // representation issues (2.3 should be correct for a solution of
	            // 2.45 with maxError=0.15).
	            options.maxError = +options.maxError + MAXERROR_EPSILON;
	
	            // If percent is an acceptable form, make sure it's the last one
	            // in the list so we don't prematurely complain about not having
	            // a percent sign when the user entered the correct answer in a
	            // different form (such as a decimal or fraction)
	            if (_.contains(acceptableForms, "percent")) {
	                acceptableForms = _.without(acceptableForms, "percent");
	                acceptableForms.push("percent");
	            }
	
	            // Take text looking like a fraction, and turn it into a number
	            var fractionTransformer = function fractionTransformer(text) {
	                text = text
	                // Replace unicode minus sign with hyphen
	                .replace(/\u2212/, "-")
	                // Remove space after +, -
	                .replace(/([+-])\s+/g, "$1")
	                // Remove leading/trailing whitespace
	                .replace(/(^\s*)|(\s*$)/gi, "");
	
	                // Extract numerator and denominator
	                var match = text.match(/^([+-]?\d+)\s*\/\s*([+-]?\d+)$/);
	                var parsedInt = parseInt(text, 10);
	                if (match) {
	                    var num = parseFloat(match[1]);
	                    var denom = parseFloat(match[2]);
	                    var simplified = denom > 0 && (options.ratio || match[2] !== "1") && KhanMath.getGCD(num, denom) === 1;
	                    return [{
	                        value: num / denom,
	                        exact: simplified
	                    }];
	                } else if (!isNaN(parsedInt) && "" + parsedInt === text) {
	                    return [{
	                        value: parsedInt,
	                        exact: true
	                    }];
	                }
	
	                return [];
	            };
	
	            /*
	             * Different forms of numbers
	             *
	             * Each function returns a list of objects of the form:
	             *
	             * {
	             *    value: numerical value,
	             *    exact: true/false
	             * }
	             */
	            var forms = {
	                // integer, which is encompassed by decimal
	                integer: function integer(text) {
	                    // Compare the decimal form to the decimal form rounded to
	                    // an integer. Only accept if the user actually entered an
	                    // integer.
	                    var decimal = forms.decimal(text);
	                    var rounded = forms.decimal(text, 1);
	                    if (decimal[0].value != null && decimal[0].value === rounded[0].value || decimal[1].value != null && decimal[1].value === rounded[1].value) {
	                        return decimal;
	                    }
	                    return [];
	                },
	
	                // A proper fraction
	                proper: function proper(text) {
	                    return $.map(fractionTransformer(text), function (o) {
	                        // All fractions that are less than 1
	                        if (Math.abs(o.value) < 1) {
	                            return [o];
	                        } else {
	                            return [];
	                        }
	                    });
	                },
	
	                // an improper fraction
	                improper: function improper(text) {
	                    return $.map(fractionTransformer(text), function (o) {
	                        // All fractions that are greater than 1
	                        if (Math.abs(o.value) >= 1) {
	                            return [o];
	                        } else {
	                            return [];
	                        }
	                    });
	                },
	
	                // pi-like numbers
	                pi: function pi(text) {
	                    var match = void 0;
	                    var possibilities = [];
	
	                    // Replace unicode minus sign with hyphen
	                    text = text.replace(/\u2212/, "-");
	
	                    // - pi
	                    // (Note: we also support \pi (for TeX), p, tau (and \tau,
	                    // and t), pau.)
	                    if (match = text.match(/^([+-]?)\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i)) {
	                        possibilities = [{
	                            value: parseFloat(match[1] + "1"),
	                            exact: true
	                        }];
	
	                        // 5 / 6 pi
	                    } else if (match = text.match(/^([+-]?\s*\d+\s*(?:\/\s*[+-]?\s*\d+)?)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i // eslint-disable-line max-len
	                    )) {
	                        possibilities = fractionTransformer(match[1]);
	
	                        // 4 5 / 6 pi
	                    } else if (match = text.match(/^([+-]?)\s*(\d+)\s*([+-]?\d+)\s*\/\s*([+-]?\d+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i // eslint-disable-line max-len
	                    )) {
	                        var sign = parseFloat(match[1] + "1");
	                        var integ = parseFloat(match[2]);
	                        var num = parseFloat(match[3]);
	                        var denom = parseFloat(match[4]);
	                        var simplified = num < denom && KhanMath.getGCD(num, denom) === 1;
	
	                        possibilities = [{
	                            value: sign * (integ + num / denom),
	                            exact: simplified
	                        }];
	
	                        // 5 pi / 6
	                    } else if (match = text.match(/^([+-]?\s*\d+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)\s*(?:\/\s*([+-]?\s*\d+))?$/i // eslint-disable-line max-len
	                    )) {
	                        possibilities = fractionTransformer(match[1] + "/" + match[3]);
	
	                        // - pi / 4
	                    } else if (match = text.match(/^([+-]?)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)\s*(?:\/\s*([+-]?\d+))?$/i // eslint-disable-line max-len
	                    )) {
	                        possibilities = fractionTransformer(match[1] + "1/" + match[3]);
	
	                        // 0
	                    } else if (text === "0") {
	                        possibilities = [{ value: 0, exact: true }];
	
	                        // 0.5 pi (fallback)
	                    } else if (match = text.match(/^(.+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i // eslint-disable-line max-len
	                    )) {
	                        possibilities = forms.decimal(match[1]);
	                    } else {
	                        possibilities = _.reduce(KhanAnswerTypes.predicate.defaultForms.split(/\s*,\s*/), function (memo, form) {
	                            return memo.concat(forms[form](text));
	                        }, []);
	
	                        // If the answer is a floating point number that's
	                        // near a multiple of pi, mark is as being possibly
	                        // an approximation of pi.  We actually check if
	                        // it's a plausible approximation of pi/12, since
	                        // sometimes the correct answer is like pi/3 or pi/4.
	                        // We also say it's a pi-approximation if it involves
	                        // x/7 (since 22/7 is an approximation of pi.)
	                        // Never mark an integer as being an approximation
	                        // of pi.
	                        var approximatesPi = false;
	                        var number = parseFloat(text);
	                        if (!isNaN(number) && number !== parseInt(text)) {
	                            var piMult = Math.PI / 12;
	                            var roundedNumber = piMult * Math.round(number / piMult);
	                            if (Math.abs(number - roundedNumber) < 0.01) {
	                                approximatesPi = true;
	                            }
	                        } else if (text.match(/\/\s*7/)) {
	                            approximatesPi = true;
	                        }
	                        if (approximatesPi) {
	                            _.each(possibilities, function (possibility) {
	                                possibility.piApprox = true;
	                            });
	                        }
	                        return possibilities;
	                    }
	
	                    var multiplier = Math.PI;
	                    if (text.match(/\\?tau|t|\u03c4/)) {
	                        multiplier = Math.PI * 2;
	                    }
	
	                    // We're taking an early stand along side xkcd in the
	                    // inevitable ti vs. pau debate... http://xkcd.com/1292
	                    if (text.match(/pau/)) {
	                        multiplier = Math.PI * 1.5;
	                    }
	
	                    $.each(possibilities, function (ix, possibility) {
	                        possibility.value *= multiplier;
	                    });
	                    return possibilities;
	                },
	
	                // Converts '' to 1 and '-' to -1 so you can write "[___] x"
	                // and accept sane things
	                coefficient: function coefficient(text) {
	                    var possibilities = [];
	
	                    // Replace unicode minus sign with hyphen
	                    text = text.replace(/\u2212/, "-");
	
	                    if (text === "") {
	                        possibilities = [{ value: 1, exact: true }];
	                    } else if (text === "-") {
	                        possibilities = [{ value: -1, exact: true }];
	                    }
	                    return possibilities;
	                },
	
	                // simple log(c) form
	                log: function log(text) {
	                    var match = void 0;
	                    var possibilities = [];
	
	                    // Replace unicode minus sign with hyphen
	                    text = text.replace(/\u2212/, "-");
	                    text = text.replace(/[ \(\)]/g, "");
	
	                    if (match = text.match(/^log\s*(\S+)\s*$/i)) {
	                        possibilities = forms.decimal(match[1]);
	                    } else if (text === "0") {
	                        possibilities = [{ value: 0, exact: true }];
	                    }
	                    return possibilities;
	                },
	
	                // Numbers with percent signs
	                percent: function percent(text) {
	                    text = $.trim(text);
	                    // store whether or not there is a percent sign
	                    var hasPercentSign = false;
	
	                    if (text.indexOf("%") === text.length - 1) {
	                        text = $.trim(text.substring(0, text.length - 1));
	                        hasPercentSign = true;
	                    }
	
	                    var transformed = forms.decimal(text);
	                    $.each(transformed, function (ix, t) {
	                        t.exact = hasPercentSign;
	                        t.value = t.value / 100;
	                    });
	                    return transformed;
	                },
	
	                // Mixed numbers, like 1 3/4
	                mixed: function mixed(text) {
	                    var match = text
	                    // Replace unicode minus sign with hyphen
	                    .replace(/\u2212/, "-")
	                    // Remove space after +, -
	                    .replace(/([+-])\s+/g, "$1")
	                    // Extract integer, numerator and denominator
	                    .match(/^([+-]?)(\d+)\s+(\d+)\s*\/\s*(\d+)$/);
	
	                    if (match) {
	                        var sign = parseFloat(match[1] + "1");
	                        var integ = parseFloat(match[2]);
	                        var num = parseFloat(match[3]);
	                        var denom = parseFloat(match[4]);
	                        var simplified = num < denom && KhanMath.getGCD(num, denom) === 1;
	
	                        return [{
	                            value: sign * (integ + num / denom),
	                            exact: simplified
	                        }];
	                    }
	
	                    return [];
	                },
	
	                // Decimal numbers -- compare entered text rounded to
	                // 'precision' Reciprical of the precision against the correct
	                // answer. We round to 1/1e10 by default, which is healthily
	                // less than machine epsilon but should be more than any real
	                // decimal answer would use. (The 'integer' answer type uses
	                // precision == 1.)
	                decimal: function decimal(text, precision) {
	                    if (precision == null) {
	                        precision = 1e10;
	                    }
	
	                    var normal = function normal(text) {
	                        text = $.trim(text);
	
	                        var match = text
	                        // Replace unicode minus sign with hyphen
	                        .replace(/\u2212/, "-")
	                        // Remove space after +, -
	                        .replace(/([+-])\s+/g, "$1")
	                        // Extract integer, numerator and denominator. If
	                        // commas or spaces are used, they must be in the
	                        // "correct" places
	                        .match(/^([+-]?(?:\d{1,3}(?:[, ]?\d{3})*\.?|\d{0,3}(?:[, ]?\d{3})*\.(?:\d{3}[, ]?)*\d{1,3}))$/ // eslint-disable-line max-len
	                        );
	
	                        // You can't start a number with `0,`, to prevent us
	                        // interpeting '0.342' as correct for '342'
	                        var badLeadingZero = text.match(/^0[0,]*,/);
	
	                        if (match && !badLeadingZero) {
	                            var x = parseFloat(match[1].replace(/[, ]/g, ""));
	
	                            if (options.inexact === undefined) {
	                                x = Math.round(x * precision) / precision;
	                            }
	
	                            return x;
	                        }
	                    };
	
	                    var commas = function commas(text) {
	                        text = text.replace(/([\.,])/g, function (_, c) {
	                            return c === "." ? "," : ".";
	                        });
	                        return normal(text);
	                    };
	
	                    return [{ value: normal(text), exact: true }, { value: commas(text), exact: true }];
	                }
	            };
	
	            // validator function
	            return function (guess) {
	                // The fallback variable is used in place of the answer, if no
	                // answer is provided (i.e. the field is left blank)
	                var fallback = options.fallback != null ? "" + options.fallback : "";
	
	                guess = $.trim(guess) || fallback;
	                var score = {
	                    empty: guess === "",
	                    correct: false,
	                    message: null,
	                    guess: guess
	                };
	
	                // iterate over all the acceptable forms, and if one of the
	                // answers is correct, return true
	                $.each(acceptableForms, function (i, form) {
	                    var transformed = forms[form](guess);
	
	                    for (var j = 0, l = transformed.length; j < l; j++) {
	                        var val = transformed[j].value;
	                        var exact = transformed[j].exact;
	                        var piApprox = transformed[j].piApprox;
	                        // If a string was returned, and it exactly matches,
	                        // return true
	                        if (predicate(val, options.maxError)) {
	                            // If the exact correct number was returned,
	                            // return true
	                            if (exact || options.simplify === "optional") {
	                                score.correct = true;
	                                score.message = options.message || null;
	                                // If the answer is correct, don't say it's
	                                // empty. This happens, for example, with the
	                                // coefficient type where guess === "" but is
	                                // interpreted as "1" which is correct.
	                                score.empty = false;
	                            } else if (form === "percent") {
	                                // Otherwise, an error was returned
	                                score.empty = true;
	                                score.message = i18n._("Your answer is almost correct, " + "but it is missing a " + "<code>\\%</code> at the end.");
	                            } else {
	                                if (options.simplify !== "enforced") {
	                                    score.empty = true;
	                                }
	                                score.message = i18n._("Your answer is almost correct, " + "but it needs to be simplified.");
	                            }
	
	                            return false;
	                        } else if (piApprox && predicate(val, Math.abs(val * 0.001))) {
	                            score.empty = true;
	                            score.message = i18n._("Your answer is close, but you may " + "have approximated pi. Enter your " + "answer as a multiple of pi, like " + "<code>12\\ \\text{pi}</code> or " + "<code>2/3\\ \\text{pi}</code>");
	                        }
	                    }
	                });
	
	                if (score.correct === false) {
	                    var interpretedGuess = false;
	                    _.each(forms, function (form) {
	                        var anyAreNaN = _.any(form(guess), function (t) {
	                            return t.value != null && !_.isNaN(t.value);
	                        });
	
	                        if (anyAreNaN) {
	                            interpretedGuess = true;
	                        }
	                    });
	                    if (!interpretedGuess) {
	                        score.empty = true;
	                        score.message = i18n._("We could not understand your " + "answer. Please check your answer for extra " + "text or symbols.");
	                        return score;
	                    }
	                }
	
	                return score;
	            };
	        }
	    },
	
	    /*
	     * number answer type
	     *
	     * wraps the predicate answer type to performs simple number-based checking
	     * of a solution
	     */
	    number: {
	        convertToPredicate: function convertToPredicate(correct, options) {
	            // TODO(alpert): Don't think this $.trim is necessary
	            var correctFloat = parseFloat($.trim(correct));
	
	            return [function (guess, maxError) {
	                return Math.abs(guess - correctFloat) < maxError;
	            }, $.extend({}, options, { type: "predicate" })];
	        },
	        createValidatorFunctional: function createValidatorFunctional(correct, options) {
	            var _KhanAnswerTypes$pred;
	
	            return (_KhanAnswerTypes$pred = KhanAnswerTypes.predicate).createValidatorFunctional.apply(_KhanAnswerTypes$pred, KhanAnswerTypes.number.convertToPredicate(correct, options));
	        }
	    },
	
	    /*
	     * The expression answer type parses a given expression or equation
	     * and semantically compares it to the solution. In addition, instant
	     * feedback is provided by rendering the last answer that fully parsed.
	     *
	     * Parsing options:
	     * functions (e.g. data-functions="f g h")
	     *     A space or comma separated list of single-letter variables that
	     *     should be interpreted as functions. Case sensitive. "e" and "i"
	     *     are reserved.
	     *
	     *     no functions specified: f(x+y) == fx + fy
	     *     with "f" as a function: f(x+y) != fx + fy
	     *
	     * Comparison options:
	     * same-form (e.g. data-same-form)
	     *     If present, the answer must match the solution's structure in
	     *     addition to evaluating the same. Commutativity and excess negation
	     *     are ignored, but all other changes will trigger a rejection. Useful
	     *     for requiring a particular form of an equation, or if the answer
	     *     must be factored.
	     *
	     *     example question:    Factor x^2 + x - 2
	     *     example solution:    (x-1)(x+2)
	     *     accepted answers:    (x-1)(x+2), (x+2)(x-1), ---(-x-2)(-1+x), etc.
	     *     rejected answers:    x^2+x-2, x*x+x-2, x(x+1)-2, (x-1)(x+2)^1, etc.
	     *     rejection message:   Your answer is not in the correct form
	     *
	     * simplify (e.g. data-simplify)
	     *     If present, the answer must be fully expanded and simplified. Use
	     *     carefully - simplification is hard and there may be bugs, or you
	     *     might not agree on the definition of "simplified" used. You will
	     *     get an error if the provided solution is not itself fully expanded
	     *     and simplified.
	     *
	     *     example question:    Simplify ((n*x^5)^5) / (n^(-2)*x^2)^-3
	     *     example solution:    x^31 / n
	     *     accepted answers:    x^31 / n, x^31 / n^1, x^31 * n^(-1), etc.
	     *     rejected answers:    (x^25 * n^5) / (x^(-6) * n^6), etc.
	     *     rejection message:   Your answer is not fully expanded and simplified
	     *
	     * Rendering options:
	     * times (e.g. data-times)
	     *     If present, explicit multiplication (such as between numbers) will
	     *     be rendered with a cross/x symbol (TeX: \times) instead of the usual
	     *     center dot (TeX: \cdot).
	     *
	     *     normal rendering:    2 * 3^x -> 2 \cdot 3^{x}
	     *     but with "times":    2 * 3^x -> 2 \times 3^{x}
	     */
	    expression: {
	        parseSolution: function parseSolution(solutionString, options) {
	            var solution = KAS.parse(solutionString, options);
	            if (!solution.parsed) {
	                throw new Error("The provided solution (" + solutionString + ") didn't parse.");
	            } else if (options.simplified && !solution.expr.isSimplified()) {
	                throw new Error("The provided solution (" + solutionString + ") isn't fully expanded and simplified.");
	            } else {
	                solution = solution.expr;
	            }
	            return solution;
	        },
	
	        createValidatorFunctional: function createValidatorFunctional(solution, options) {
	            return function (guess) {
	                var score = {
	                    empty: false,
	                    correct: false,
	                    message: null,
	                    guess: guess
	                };
	                // Don't bother parsing an empty input
	                if (!guess) {
	                    score.empty = true;
	                    return score;
	                }
	
	                var answer = KAS.parse(guess, options);
	
	                // An unsuccessful parse doesn't count as wrong
	                if (!answer.parsed) {
	                    score.empty = true;
	                    return score;
	                }
	
	                // Solution will need to be parsed again if we're creating
	                // this from a multiple question type
	                if (typeof solution === "string") {
	                    solution = KhanAnswerTypes.expression.parseSolution(solution, options);
	                }
	
	                var result = KAS.compare(answer.expr, solution, options);
	
	                if (result.equal) {
	                    // Correct answer
	                    score.correct = true;
	                } else if (result.message) {
	                    // Nearly correct answer
	                    score.message = result.message;
	                } else {
	                    // Replace x with * and see if it would have been correct
	                    var answerX = KAS.parse(guess.replace(/[xX]/g, "*"), options);
	                    if (answerX.parsed) {
	                        var resultX = KAS.compare(answerX.expr, solution, options);
	                        if (resultX.equal) {
	                            score.empty = true;
	                            score.message = "I'm a computer. I only " + "understand multiplication if you use an " + "asterisk (*) as the multiplication sign.";
	                        } else if (resultX.message) {
	                            score.message = resultX.message + " Also, " + "I'm a computer. I only " + "understand multiplication if you use an " + "asterisk (*) as the multiplication sign.";
	                        }
	                    }
	                }
	                return score;
	            };
	        }
	    }
	};
	
	module.exports = KhanAnswerTypes;

/***/ },
/* 83 */
/***/ function(module, exports, __webpack_require__) {

	/* ButtonGroup is an aesthetically pleasing group of buttons.
	 *
	 * The class requires these properties:
	 *   buttons - an array of objects with keys:
	 *     "value": this is the value returned when the button is selected
	 *     "content": this is the JSX shown within the button, typically a string
	 *         that gets rendered as the button's display text
	 *     "title": this is the title-text shown on hover
	 *   onChange - a function that is provided with the updated value
	 *     (which it then is responsible for updating)
	 *
	 * The class has these optional properties:
	 *   value - the initial value of the button selected, defaults to null.
	 *   allowEmpty - if false, exactly one button _must_ be selected; otherwise
	 *     it defaults to true and _at most_ one button (0 or 1) may be selected.
	 *
	 * Requires stylesheets/perseus-admin-package/editor.less to look nice.
	 */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var styles = __webpack_require__(177);
	var css = __webpack_require__(79).css;
	
	var ButtonGroup = React.createClass({
	    displayName: 'ButtonGroup',
	
	    propTypes: {
	        value: React.PropTypes.any,
	        buttons: React.PropTypes.arrayOf(React.PropTypes.shape({
	            value: React.PropTypes.any.isRequired,
	            content: React.PropTypes.node,
	            title: React.PropTypes.string
	        })).isRequired,
	        onChange: React.PropTypes.func.isRequired,
	        allowEmpty: React.PropTypes.bool
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            value: null,
	            allowEmpty: true
	        };
	    },
	
	    focus: function focus() {
	        ReactDOM.findDOMNode(this).focus();
	        return true;
	    },
	
	    toggleSelect: function toggleSelect(newValue) {
	        var value = this.props.value;
	
	        if (this.props.allowEmpty) {
	            // Select the new button or unselect if it's already selected
	            this.props.onChange(value !== newValue ? newValue : null);
	        } else {
	            this.props.onChange(newValue);
	        }
	    },
	
	    render: function render() {
	        var _this = this;
	
	        var value = this.props.value;
	        var buttons = this.props.buttons.map(function (button, i) {
	            return React.createElement(
	                'button',
	                { title: button.title,
	                    type: 'button',
	                    id: "" + i,
	                    ref: "button" + i,
	                    key: "" + i,
	                    className: css(styles.button.buttonStyle, button.value === value && styles.button.selectedStyle),
	                    onClick: _this.toggleSelect.bind(_this, button.value)
	                },
	                button.content || "" + button.value
	            );
	        });
	
	        var outerStyle = {
	            display: 'inline-block'
	        };
	        return React.createElement(
	            'div',
	            { style: outerStyle },
	            buttons
	        );
	    }
	});
	
	module.exports = ButtonGroup;

/***/ },
/* 84 */
/***/ function(module, exports, __webpack_require__) {

	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _selector = __webpack_require__(207);
	
	var _selector2 = _interopRequireDefault(_selector);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } /**
	                                                                                                                                                           * The Rule class represents a Gorgon lint rule. A Rule instance has a check()
	                                                                                                                                                           * method that takes the same (node, state, content) arguments that a
	                                                                                                                                                           * TreeTransformer traversal callback function does. Call the check() method
	                                                                                                                                                           * during a tree traversal to determine whether the current node of the tree
	                                                                                                                                                           * violates the rule. If there is no violation, then check() returns
	                                                                                                                                                           * null. Otherwise, it returns an object that includes the name of the rule,
	                                                                                                                                                           * an error message, and the start and end positions within the node's content
	                                                                                                                                                           * string of the lint.
	                                                                                                                                                           *
	                                                                                                                                                           * A Gorgon lint rule consists of a name, a severity, a selector, a pattern
	                                                                                                                                                           * (RegExp) and two functions. The check() method uses the selector, pattern,
	                                                                                                                                                           * and functions as follows:
	                                                                                                                                                           *
	                                                                                                                                                           * - First, when determining which rules to apply to a particular piece of
	                                                                                                                                                           *   content, each rule can specify an optional function provided in the fifth
	                                                                                                                                                           *   parameter to evaluate whether or not we should be applying this rule.
	                                                                                                                                                           *   If the function returns false, we don't use the rule on this content.
	                                                                                                                                                           *
	                                                                                                                                                           * - Next, check() tests whether the node currently being traversed matches
	                                                                                                                                                           *   the selector. If it does not, then the rule does not apply at this node
	                                                                                                                                                           *   and there is no lint and check() returns null.
	                                                                                                                                                           *
	                                                                                                                                                           * - If the selector matched, then check() tests the text content of the node
	                                                                                                                                                           *   (and its children) against the pattern. If the pattern does not match,
	                                                                                                                                                           *   then there is no lint, and check() returns null.
	                                                                                                                                                           *
	                                                                                                                                                           * - If both the selector and pattern match, then check() calls the function
	                                                                                                                                                           *   passing the TraversalState object, the content string for the node, the
	                                                                                                                                                           *   array of nodes returned by the selector match, and the array of strings
	                                                                                                                                                           *   returned by the pattern match. This function can use these arguments to
	                                                                                                                                                           *   implement any kind of lint detection logic it wants. If it determines
	                                                                                                                                                           *   that there is no lint, then it should return null. Otherwise, it should
	                                                                                                                                                           *   return an error message as a string, or an object with `message`, `start`
	                                                                                                                                                           *   and `end` properties. The start and end properties are numbers that mark
	                                                                                                                                                           *   the beginning and end of the problematic content. Note that these numbers
	                                                                                                                                                           *   are relative to the content string passed to the traversal callback, not
	                                                                                                                                                           *   to the entire string that was used to generate the parse tree in the
	                                                                                                                                                           *   first place. TODO(davidflanagan): modify the simple-markdown library to
	                                                                                                                                                           *   have an option to add the text offset of each node to the parse
	                                                                                                                                                           *   tree. This will allows us to pinpoint lint errors within a long string
	                                                                                                                                                           *   of markdown text.
	                                                                                                                                                           *
	                                                                                                                                                           * - If the function returns null, then check() returns null. Otherwise,
	                                                                                                                                                           *   check() returns an object with `rule`, `message`, `start` and `end`
	                                                                                                                                                           *   properties. The value of the `rule` property is the name of the rule,
	                                                                                                                                                           *   which is useful for error reporting purposes.
	                                                                                                                                                           *
	                                                                                                                                                           * The name, severity, selector, pattern and function arguments to the Rule()
	                                                                                                                                                           * constructor are optional, but you may not omit both the selector and the
	                                                                                                                                                           * pattern. If you do not specify a selector, a default selector that matches
	                                                                                                                                                           * any node of type "text" will be used. If you do not specify a pattern, then
	                                                                                                                                                           * any node that matches the selector will be assumed to match the pattern as
	                                                                                                                                                           * well. If you don't pass a function as the fourth argument to the Rule()
	                                                                                                                                                           * constructor, then you must pass an error message string instead. If you do
	                                                                                                                                                           * this, you'll get a default function that unconditionally returns an object
	                                                                                                                                                           * that includes the error message and the start and end indexes of the
	                                                                                                                                                           * portion of the content string that matched the pattern. If you don't pass a
	                                                                                                                                                           * function in the fifth parameter, the rule will be applied in any context.
	                                                                                                                                                           *
	                                                                                                                                                           * One of the design goals of this Rule class is to allow simple lint rules to
	                                                                                                                                                           * be described in JSON files without any JavaScript code. So in addition to
	                                                                                                                                                           * the Rule() constructor, the class also defines a Rule.makeRule() factory
	                                                                                                                                                           * method. This method takes a single object as its argument and expects the
	                                                                                                                                                           * object to have four string properties. The `name` property is passed as the
	                                                                                                                                                           * first argument to the Rule() construtctor.  The optional `selector`
	                                                                                                                                                           * property, if specified, is passed to Selector.parse() and the resulting
	                                                                                                                                                           * Selector object is used as the second argument to Rule().  The optional
	                                                                                                                                                           * `pattern` property is converted to a RegExp before being passed as the
	                                                                                                                                                           * third argument to Rule(). (See Rule.makePattern() for details on the string
	                                                                                                                                                           * to RegExp conversion). Finally, the `message` property specifies an error
	                                                                                                                                                           * message that is passed as the final argument to Rule(). You can also use a
	                                                                                                                                                           * real RegExp as the value of the `pattern` property or define a custom lint
	                                                                                                                                                           * function on the `lint` property instead of setting the `message`
	                                                                                                                                                           * property. Doing either of these things means that your rule description can
	                                                                                                                                                           * no longer be saved in a JSON file, however.
	                                                                                                                                                           *
	                                                                                                                                                           * For example, here are two lint rules defined with Rule.makeRule():
	                                                                                                                                                           *
	                                                                                                                                                           *    let nestedLists = Rule.makeRule({
	                                                                                                                                                           *        name: "nested-lists",
	                                                                                                                                                           *        selector: "list list",
	                                                                                                                                                           *        message: `Nested lists:
	                                                                                                                                                           *    nested lists are hard to read on mobile devices;
	                                                                                                                                                           *    do not use additional indentation.`,
	                                                                                                                                                           *    });
	                                                                                                                                                           *
	                                                                                                                                                           *    let longParagraph = Rule.makeRule({
	                                                                                                                                                           *        name: "long-paragraph",
	                                                                                                                                                           *        selector: "paragraph",
	                                                                                                                                                           *        pattern: /^.{501,}/,
	                                                                                                                                                           *        lint: function(state, content, nodes, match) {
	                                                                                                                                                           *            return `Paragraph too long:
	                                                                                                                                                           *    This paragraph is ${content.length} characters long.
	                                                                                                                                                           *    Shorten it to 500 characters or fewer.`;
	                                                                                                                                                           *        },
	                                                                                                                                                           *    });
	                                                                                                                                                           *
	                                                                                                                                                           * Certain advanced lint rules need additional information about the content
	                                                                                                                                                           * being linted in order to detect lint. For example, a rule to check for
	                                                                                                                                                           * whitespace at the start and end of the URL for an image can't use the
	                                                                                                                                                           * information in the node or content arguments because the markdown parser
	                                                                                                                                                           * strips leading and trailing whitespace when parsing. (Nevertheless, these
	                                                                                                                                                           * spaces have been a practical problem for our content translation process so
	                                                                                                                                                           * in order to check for them, a lint rule needs access to the original
	                                                                                                                                                           * unparsed source text. Similarly, there are various lint rules that check
	                                                                                                                                                           * widget usage. For example, it is easy to write a lint rule to ensure that
	                                                                                                                                                           * images have alt text for images encoded in markdown. But when images are
	                                                                                                                                                           * added to our content via an image widget we also want to be able to check
	                                                                                                                                                           * for alt text. In order to do this, the lint rule needs to be able to look
	                                                                                                                                                           * widgets up by name in the widgets object associated with the parse tree.
	                                                                                                                                                           *
	                                                                                                                                                           * In order to support advanced linting rules like these, the check() method
	                                                                                                                                                           * takes a context object as its optional fourth argument, and passes this
	                                                                                                                                                           * object on to the lint function of each rule. Rules that require extra
	                                                                                                                                                           * context should not assume that they will always get it, and should verify
	                                                                                                                                                           * that the necessary context has been supplied before using it. Currently the
	                                                                                                                                                           * "content" property of the context object is the unparsed source text if
	                                                                                                                                                           * available, and the "widgets" property of the context object is the widget
	                                                                                                                                                           * object associated with that content string in the JSON object that defines
	                                                                                                                                                           * the Perseus article or exercise that is being linted.
	                                                                                                                                                           */
	
	// This represents the type returned by String.match(). It is an
	// array of strings, but also has index:number and input:string properties.
	// Flow doesn't handle it well, so we punt and just use any.
	var babelPluginFlowReactPropTypes_proptype_TreeNode = __webpack_require__(85).babelPluginFlowReactPropTypes_proptype_TreeNode || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_TraversalState = __webpack_require__(85).babelPluginFlowReactPropTypes_proptype_TraversalState || __webpack_require__(43).PropTypes.any;
	
	// This is the return type of the check() method of a Rule object
	
	
	// This is the return type of the lint detection function passed as the 4th
	// argument to the Rule() constructor. It can return null or a string or an
	// object containing a string and two numbers.
	// prettier-ignore
	// (prettier formats this in a way that ka-lint does not like)
	
	
	// This is the type of the lint detection function that the Rule() constructor
	// expects as its fourth argument. It is passed the TraversalState object and
	// content string that were passed to check(), and is also passed the array of
	// nodes returned by the selector match and the array of strings returned by
	// the pattern match. It should return null if no lint is detected or an
	// error message or an object contining an error message.
	
	
	// An optional check to verify whether or not a particular rule should
	// be checked by context. For example, some rules only apply in exercises,
	// and should never be applied to articles. Defaults to true, so if we
	// omit the applies function in a rule, it'll be tested everywhere.
	
	
	/**
	 * A Rule object describes a Gorgon lint rule. See the comment at the top of
	 * this file for detailed description.
	 */
	var Rule = function () {
	
	    // The comment at the top of this file has detailed docs for
	    // this constructor and its arguments
	    // Checks to see if we should apply a rule or not
	    // A regular expression if one was specified
	    // The severity of the rule
	    function Rule(name, severity, selector, pattern, lint, applies) {
	        _classCallCheck(this, Rule);
	
	        if (!selector && !pattern) {
	            throw new Error("Lint rules must have a selector or pattern");
	        }
	
	        this.name = name || "unnamed rule";
	        this.severity = severity || Rule.Severity.BULK_WARNING;
	        this.selector = selector || Rule.DEFAULT_SELECTOR;
	        this.pattern = pattern || null;
	
	        // If we're called with an error message instead of a function then
	        // use a default function that will return the message.
	        if (typeof lint === "function") {
	            this.lint = lint;
	            this.message = null;
	        } else {
	            this.lint = this._defaultLintFunction;
	            this.message = lint;
	        }
	
	        this.applies = applies || function () {
	            return true;
	        };
	    }
	
	    // A factory method for use with rules described in JSON files
	    // See the documentation at the start of this file for details.
	    // The error message for use with the default function
	    // The lint-testing function or a default
	    // The specified selector or the DEFAULT_SELECTOR
	    // The name of the rule
	
	
	    Rule.makeRule = function makeRule(options) {
	        return new Rule(options.name, options.severity, options.selector ? _selector2.default.parse(options.selector) : null, Rule.makePattern(options.pattern), options.lint || options.message, options.applies);
	    };
	
	    // Check the node n to see if it violates this lint rule.  A return value
	    // of false means there is no lint.  A returned object indicates a lint
	    // error. See the documentation at the top of this file for details.
	
	
	    Rule.prototype.check = function check(node, traversalState, content, context) {
	        // First, see if we match the selector.
	        // If no selector was passed to the constructor, we use a
	        // default selector that matches text nodes.
	        var selectorMatch = this.selector.match(traversalState);
	
	        // If the selector did not match, then we're done
	        if (!selectorMatch) {
	            return null;
	        }
	
	        // If the selector matched, then see if the pattern matches
	        var patternMatch = void 0;
	        if (this.pattern) {
	            patternMatch = content.match(this.pattern);
	        } else {
	            // If there is no pattern, then just match all of the content.
	            // Use a fake RegExp match object to represent this default match.
	            patternMatch = Rule.FakePatternMatch(content, content, 0);
	        }
	
	        // If there was a pattern and it didn't match, then we're done
	        if (!patternMatch) {
	            return null;
	        }
	
	        try {
	            // If we get here, then the selector and pattern have matched
	            // so now we call the lint function to see if there is lint.
	            var error = this.lint(traversalState, content, selectorMatch, patternMatch, context);
	
	            if (!error) {
	                return null; // No lint; we're done
	            } else if (typeof error === "string") {
	                // If the lint function returned a string we assume it
	                // applies to the entire content of the node and return it.
	                return {
	                    rule: this.name,
	                    severity: this.severity,
	                    message: error,
	                    start: 0,
	                    end: content.length
	                };
	            } else {
	                // If the lint function returned an object, then we just
	                // add the rule name to the message, start and end.
	                return {
	                    rule: this.name,
	                    severity: this.severity,
	                    message: error.message,
	                    start: error.start,
	                    end: error.end
	                };
	            }
	        } catch (e) {
	            // If the lint function threw an exception we handle that as
	            // a special type of lint. We want the user to see the lint
	            // warning in this case (even though it is out of their control)
	            // so that the bug gets reported. Otherwise we'd never know that
	            // a rule was failing.
	            return {
	                rule: "lint-rule-failure",
	                message: "Exception in rule " + this.name + ": " + e.message + "\nStack trace:\n" + e.stack,
	                start: 0,
	                end: content.length
	            };
	        }
	    };
	
	    // This internal method is the default lint function that we use when a
	    // rule is defined without a function. This is useful for rules where the
	    // selector and/or pattern match are enough to indicate lint. This
	    // function unconditionally returns the error message that was passed in
	    // place of a function, but also adds start and end properties that
	    // specify which particular portion of the node content matched the
	    // pattern.
	
	
	    Rule.prototype._defaultLintFunction = function _defaultLintFunction(state, content, selectorMatch, patternMatch) {
	        return {
	            message: this.message || "",
	            start: patternMatch.index,
	            end: patternMatch.index + patternMatch[0].length
	        };
	    };
	
	    // The makeRule() factory function uses this static method to turn its
	    // argument into a RegExp. If the argument is already a RegExp, we just
	    // return it. Otherwise, we compile it into a RegExp and return that.
	    // The reason this is necessary is that Rule.makeRule() is designed for
	    // use with data from JSON files and JSON files can't include RegExp
	    // literals. Strings passed to this function do not need to be delimited
	    // with / characters unless you want to include flags for the RegExp.
	    //
	    // Examples:
	    //
	    //   input ""        ==> output null
	    //   input /foo/     ==> output /foo/
	    //   input "foo"     ==> output /foo/
	    //   input "/foo/i"  ==> output /foo/i
	    //
	
	
	    Rule.makePattern = function makePattern(pattern) {
	        if (!pattern) {
	            return null;
	        } else if (pattern instanceof RegExp) {
	            return pattern;
	        } else if (pattern[0] === "/") {
	            var lastSlash = pattern.lastIndexOf("/");
	            var expression = pattern.substring(1, lastSlash);
	            var flags = pattern.substring(lastSlash + 1);
	            return new RegExp(expression, flags);
	        } else {
	            return new RegExp(pattern);
	        }
	    };
	
	    // This static method returns an string array with index and input
	    // properties added, in order to simulate the return value of the
	    // String.match() method. We use it when a Rule has no pattern and we
	    // want to simulate a match on the entire content string.
	
	
	    Rule.FakePatternMatch = function FakePatternMatch(input, match, index) {
	        var result = [match];
	        result.index = index;
	        result.input = input;
	        return result;
	    };
	
	    return Rule;
	}();
	
	Rule.Severity = {
	    ERROR: 1,
	    WARNING: 2,
	    GUIDELINE: 3,
	    BULK_WARNING: 4
	};
	exports.default = Rule;
	
	
	Rule.DEFAULT_SELECTOR = _selector2.default.parse("text");

/***/ },
/* 85 */
/***/ function(module, exports, __webpack_require__) {

	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	// TraversalCallback is the type of the callback function passed to the
	// traverse() method. It is invoked with node, state, and content arguments
	// and is expected to return nothing.
	Object.defineProperty(module.exports, "babelPluginFlowReactPropTypes_proptype_TreeNode", __webpack_require__(43).PropTypes.shape({
	    type: __webpack_require__(43).PropTypes.string.isRequired
	})); /**
	      * TreeTransformer is a class for traversing and transforming trees.  Create a
	      * TreeTransformer by passing the root node of the tree to the
	      * constructor. Then traverse that tree by calling the traverse() method. The
	      * argument to traverse() is a callback function that will be called once for
	      * each node in the tree. This is a post-order depth-first traversal: the
	      * callback is not called on the a way down, but on the way back up. That is,
	      * the children of a node are traversed before the node itself is.
	      *
	      * The traversal callback function is passed three arguments, the node being
	      * traversed, a TraversalState object, and the concatentated text content of
	      * the node and all of its descendants. The TraversalState object is the most
	      * most interesting argument: it has methods for querying the ancestors and
	      * siblings of the node, and for deleting or replacing the node. These
	      * transformation methods are why this class is a tree transformer and not
	      * just a tree traverser.
	      *
	      * A typical tree traversal looks like this:
	      *
	      *   new TreeTransformer(root).traverse((node, state, content) => {
	      *       let parent = state.parent();
	      *       let previous = state.previousSibling();
	      *       // etc.
	      *   });
	      *
	      * The traverse() method descends through nodes and arrays of nodes and calls
	      * the traverse callback on each node on the way back up to the root of the
	      * tree. (Note that it only calls the callback on the nodes themselves, not
	      * any arrays that contain nodes.) A node is loosely defined as any object
	      * with a string-valued `type` property. Objects that do not have a type
	      * property are assumed to not be part of the tree and are not traversed. When
	      * traversing an array, all elements of the array are examined, and any that
	      * are nodes or arrays are recursively traversed. When traversing a node, all
	      * properties of the object are examined and any node or array values are
	      * recursively traversed.  In typical parse trees, the children of a node are
	      * in a `children` or `content` array, but this class is designed to handle
	      * more general trees.  The Perseus markdown parser, for example, produces
	      * nodes of type "table" that have children in the `header` and `cells`
	      * properties.
	      *
	      * CAUTION: the traverse() method does not make any attempt to detect
	      * cycles. If you call it on a cyclic graph instead of a tree, it will cause
	      * infinite recursion (or, more likely, a stack overflow).
	      *
	      * TODO(davidflanagan): it probably wouldn't be hard to detect cycles: when
	      * pushing a new node onto the containers stack we could just check that it
	      * isn't already there.
	      *
	      * If a node has a text-valued `content` property, it is taken to be the
	      * plain-text content of the node. The traverse() method concatenates these
	      * content strings and passes them to the traversal callback for each
	      * node. This means that the callback has access the full text content of its
	      * node and all of the nodes descendants.
	      *
	      * See the TraversalState class for more information on what information and
	      * methods are available to the traversal callback.
	      **/
	
	// TreeNode is the type of a node in a parse tree. The only real requirement is
	// that every node has a string-valued `type` property
	
	// This is the TreeTransformer class described in detail at the
	// top of this file.
	var TreeTransformer = function () {
	
	    // To create a tree transformer, just pass the root node of the tree
	    function TreeTransformer(root) {
	        _classCallCheck(this, TreeTransformer);
	
	        this.root = root;
	    }
	
	    // A utility function for determing whether an arbitrary value is a node
	
	
	    TreeTransformer.isNode = function isNode(n) {
	        return n && (typeof n === "undefined" ? "undefined" : _typeof(n)) === "object" && typeof n.type === "string";
	    };
	
	    // Determines whether a value is a node with type "text" and has
	    // a text-valued `content` property.
	
	
	    TreeTransformer.isTextNode = function isTextNode(n) {
	        return TreeTransformer.isNode(n) && n.type === "text" && typeof n.content === "string";
	    };
	
	    // This is the main entry point for the traverse() method. See the comment
	    // at the top of this file for a detailed description. Note that this
	    // method just creates a new TraversalState object to use for this
	    // traversal and then invokes the internal _traverse() method to begin the
	    // recursion.
	
	
	    TreeTransformer.prototype.traverse = function traverse(f) {
	        this._traverse(this.root, new TraversalState(this.root), f);
	    };
	
	    // Do a post-order traversal of node and its descendants, invoking the
	    // callback function f() once for each node and returning the concatenated
	    // text content of the node and its descendants. f() is passed three
	    // arguments: the current node, a TraversalState object representing the
	    // current state of the traversal, and a string that holds the
	    // concatenated text of the node and its descendants.
	    //
	    // This private method holds all the traversal logic and implementation
	    // details. Note that this method uses the TraversalState object to store
	    // information about the structure of the tree.
	
	
	    TreeTransformer.prototype._traverse = function _traverse(n, state, f) {
	        var _this = this;
	
	        var content = "";
	        if (TreeTransformer.isNode(n)) {
	            // If we were called on a node object, then we handle it
	            // this way.
	            var _node = n; // safe cast; we just tested
	
	            // Put the node on the stack before recursing on its children
	            state._containers.push(_node);
	            state._ancestors.push(_node);
	
	            // Record the node's text content if it has any.
	            // Usually this is for nodes with a type property of "text",
	            // but other nodes types like "math" may also have content.
	            if (typeof _node.content === "string") {
	                content = _node.content;
	            }
	
	            // Recurse on the node. If there was content above, then there
	            // probably won't be any children to recurse on, but we check
	            // anyway.
	            //
	            // If we wanted to make the traversal completely specific to the
	            // actual Perseus parse trees that we'll be dealing with we could
	            // put a switch statement here to dispatch on the node type
	            // property with specific recursion steps for each known type of
	            // node.
	            var keys = Object.keys(_node);
	            keys.forEach(function (key) {
	                // Never recurse on the type property
	                if (key === "type") {
	                    return;
	                }
	                // Ignore properties that are null or primitive and only
	                // recurse on objects and arrays. Note that we don't do a
	                // isNode() check here. That is done in the recursive call to
	                // _traverse(). Note that the recursive call on each child
	                // returns the text content of the child and we add that
	                // content to the content for this node. Also note that we
	                // push the name of the property we're recursing over onto a
	                // TraversalState stack.
	                var value = _node[key];
	                if (value && (typeof value === "undefined" ? "undefined" : _typeof(value)) === "object") {
	                    state._indexes.push(key);
	                    content += _this._traverse(value, state, f);
	                    state._indexes.pop();
	                }
	            });
	
	            // Restore the stacks after recursing on the children
	            state._currentNode = state._ancestors.pop();
	            state._containers.pop();
	
	            // And finally call the traversal callback for this node.  Note
	            // that this is post-order traversal. We call the callback on the
	            // way back up the tree, not on the way down.  That way we already
	            // know all the content contained within the node.
	            f(_node, state, content);
	        } else if (Array.isArray(n)) {
	            // If we were called on an array instead of a node, then
	            var nodes = n;
	
	            // Push the array onto the stack. This will allow the
	            // TraversalState object to locate siblings of this node.
	            state._containers.push(nodes);
	
	            // Now loop through this array and recurse on each element in it.
	            // Before recursing on an element, we push its array index on a
	            // TraversalState stack so that the TraversalState sibling methods
	            // can work. Note that TraversalState methods can alter the length
	            // of the array, and change the index of the current node, so we
	            // are careful here to test the array length on each iteration and
	            // to reset the index when we pop the stack. Also note that we
	            // concatentate the text content of the children.
	            var index = 0;
	            while (index < nodes.length) {
	                state._indexes.push(index);
	                content += this._traverse(nodes[index], state, f);
	                // Casting to convince Flow that this is a number
	                index = state._indexes.pop() + 1;
	            }
	
	            // Pop the array off the stack. Note, however, that we do not call
	            // the traversal callback on the array. That function is only
	            // called for nodes, not arrays of nodes.
	            state._containers.pop();
	        }
	
	        // The _traverse() method always returns the text content of
	        // this node and its children. This is the one piece of state that
	        // is not tracked in the TraversalState object.
	        return content;
	    };
	
	    return TreeTransformer;
	}();
	
	// An instance of this class is passed to the callback function for
	// each node traversed. The class itself is not exported, but its
	// methods define the API available to the traversal callback.
	
	/**
	 * This class represents the state of a tree traversal. An instance is created
	 * by the traverse() method of the TreeTransformer class to maintain the state
	 * for that traversal, and the instance is passed to the traversal callback
	 * function for each node that is traversed. This class is not intended to be
	 * instantiated directly, but is exported so that its type can be used for
	 * Flow annotaions.
	 **/
	
	
	exports.default = TreeTransformer;
	
	var TraversalState = exports.TraversalState = function () {
	
	    // The constructor just stores the root node and creates empty stacks.
	
	
	    // These are internal state properties. Use the accessor methods defined
	    // below instead of using these properties directly. Note that the
	    // _containers and _indexes stacks can have two different types of
	    // elements, depending on whether we just recursed on an array or on a
	    // node. This is hard for Flow to deal with, so you'll see a number of
	    // Flow casts through the any type when working with these two properties.
	    function TraversalState(root) {
	        _classCallCheck(this, TraversalState);
	
	        this.root = root;
	
	        // When the callback is called, this property will hold the
	        // node that is currently being traversed.
	        this._currentNode = null;
	
	        // This is a stack of the objects and arrays that we've
	        // traversed through before reaching the currentNode.
	        // It is different than the ancestors array.
	        this._containers = new Stack();
	
	        // This stack has the same number of elements as the _containers
	        // stack. The last element of this._indexes[] is the index of
	        // the current node in the object or array that is the last element
	        // of this._containers[]. If the last element of this._containers[] is
	        // an array, then the last element of this stack will be a number.
	        // Otherwise if the last container is an object, then the last index
	        // will be a string property name.
	        this._indexes = new Stack();
	
	        // This is a stack of the ancestor nodes of the current one.
	        // It is different than the containers[] stack because it only
	        // includes nodes, not arrays.
	        this._ancestors = new Stack();
	    }
	
	    /**
	     * Return the current node in the traversal. Any time the traversal
	     * callback is called, this method will return the name value as the
	     * first argument to the callback.
	     */
	
	    // The root node of the tree being traversed
	
	
	    TraversalState.prototype.currentNode = function currentNode() {
	        return this._currentNode || this.root;
	    };
	
	    /**
	     * Return the parent of the current node, if there is one, or null.
	     */
	
	
	    TraversalState.prototype.parent = function parent() {
	        return this._ancestors.top();
	    };
	
	    /**
	     * Return an array of ancestor nodes. The first element of this array is
	     * the same as this.parent() and the last element is the root node. If we
	     * are currently at the root node, the the returned array will be empty.
	     * This method makes a copy of the internal state, so modifications to the
	     * returned array have no effect on the traversal.
	     */
	
	
	    TraversalState.prototype.ancestors = function ancestors() {
	        return this._ancestors.values();
	    };
	
	    /**
	     * Return the next sibling of this node, if it has one, or null otherwise.
	     */
	
	
	    TraversalState.prototype.nextSibling = function nextSibling() {
	        var siblings = this._containers.top();
	
	        // If we're at the root of the tree or if the parent is an
	        // object instead of an array, then there are no siblings.
	        if (!siblings || !Array.isArray(siblings)) {
	            return null;
	        }
	
	        // The top index is a number because the top container is an array
	        var index = this._indexes.top();
	        if (siblings.length > index + 1) {
	            return siblings[index + 1];
	        } else {
	            return null; // There is no next sibling
	        }
	    };
	
	    /**
	     * Return the previous sibling of this node, if it has one, or null
	     * otherwise.
	     */
	
	
	    TraversalState.prototype.previousSibling = function previousSibling() {
	        var siblings = this._containers.top();
	
	        // If we're at the root of the tree or if the parent is an
	        // object instead of an array, then there are no siblings.
	        if (!siblings || !Array.isArray(siblings)) {
	            return null;
	        }
	
	        // The top index is a number because the top container is an array
	        var index = this._indexes.top();
	        if (index > 0) {
	            return siblings[index - 1];
	        } else {
	            return null; // There is no previous sibling
	        }
	    };
	
	    /**
	     * Remove the next sibling node (if there is one) from the tree.  Returns
	     * the removed sibling or null. This method makes it easy to traverse a
	     * tree and concatenate adjacent text nodes into a single node.
	     */
	
	
	    TraversalState.prototype.removeNextSibling = function removeNextSibling() {
	        var siblings = this._containers.top();
	        if (siblings && Array.isArray(siblings)) {
	            // top index is a number because top container is an array
	            var index = this._indexes.top();
	            if (siblings.length > index + 1) {
	                return siblings.splice(index + 1, 1)[0];
	            }
	        }
	        return null;
	    };
	
	    /**
	     * Replace the current node in the tree with the specified nodes.  If no
	     * nodes are passed, this is a node deletion. If one node (or array) is
	     * passed, this is a 1-for-1 replacement. If more than one node is passed
	     * then this is a combination of deletion and insertion.  The new node or
	     * nodes will not be traversed, so this method can safely be used to
	     * reparent the current node node beneath a new parent.
	     *
	     * This method throws an error if you attempt to replace the root node of
	     * the tree.
	     */
	
	
	    TraversalState.prototype.replace = function replace() {
	        var parent = this._containers.top();
	        if (!parent) {
	            throw new Error("Can't replace the root of the tree");
	        }
	
	        // The top of the container stack is either an array or an object
	        // and the top of the indexes stack is a corresponding array index
	        // or object property. This is hard for Flow, so we have to do some
	        // unsafe casting and be careful when we use which cast version
	        var parentIsArray = Array.isArray(parent);
	        var array = parent;
	        var index = this._indexes.top();
	        var object = parent;
	        var property = this._indexes.top();
	
	        for (var _len = arguments.length, replacements = Array(_len), _key = 0; _key < _len; _key++) {
	            replacements[_key] = arguments[_key];
	        }
	
	        if (parentIsArray) {
	            // For an array parent we just splice the new nodes in
	            array.splice.apply(array, [index, 1].concat(replacements));
	            // Adjust the index to account for the changed array length.
	            // We don't want to traverse any of the newly inserted nodes.
	            this._indexes.pop();
	            this._indexes.push(index + replacements.length - 1);
	        } else {
	            // For an object parent we care how many new nodes there are
	            if (replacements.length === 0) {
	                // Deletion
	                delete object[property];
	            } else if (replacements.length === 1) {
	                // Replacement
	                object[property] = replacements[0];
	            } else {
	                // Replace one node with an array of nodes
	                object[property] = replacements;
	            }
	        }
	    };
	
	    /**
	     * Returns true if the current node has a previous sibling and false
	     * otherwise. If this method returns false, then previousSibling() will
	     * return null, and goToPreviousSibling() will throw an error.
	     */
	
	
	    TraversalState.prototype.hasPreviousSibling = function hasPreviousSibling() {
	        return Array.isArray(this._containers.top()) && this._indexes.top() > 0;
	    };
	
	    /**
	     * Modify this traversal state object to have the state it would have had
	     * when visiting the previous sibling. Note that you may want to use
	     * clone() to make a copy before modifying the state object like this.
	     * This mutator method is not typically used during ordinary tree
	     * traversals, but is used by the Selector class for matching multi-node
	     * selectors.
	     */
	
	
	    TraversalState.prototype.goToPreviousSibling = function goToPreviousSibling() {
	        if (!this.hasPreviousSibling()) {
	            throw new Error("goToPreviousSibling(): node has no previous sibling");
	        }
	
	        this._currentNode = this.previousSibling();
	        // Since we know that we have a previous sibling, we know that
	        // the value on top of the stack is a number, but we have to do
	        // this unsafe cast because Flow doesn't know that.
	        var index = this._indexes.pop();
	        this._indexes.push(index - 1);
	    };
	
	    /**
	     * Returns true if the current node has an ancestor and false otherwise.
	     * If this method returns false, then the parent() method will return
	     * null and goToParent() will throw an error
	     */
	
	
	    TraversalState.prototype.hasParent = function hasParent() {
	        return this._ancestors.size() !== 0;
	    };
	
	    /**
	     * Modify this object to look like it will look when we (later) visit the
	     * parent node of this node. You should not modify the instance passed to
	     * the tree traversal callback. Instead, make a copy with the clone()
	     * method and modify that.  This mutator method is not typically used
	     * during ordinary tree traversals, but is used by the Selector class for
	     * matching multi-node selectors that involve parent and ancestor
	     * selectors.
	     */
	
	
	    TraversalState.prototype.goToParent = function goToParent() {
	        if (!this.hasParent()) {
	            throw new Error("goToParent(): node has no ancestor");
	        }
	
	        this._currentNode = this._ancestors.pop();
	
	        // We need to pop the containers and indexes stacks at least once
	        // and more as needed until we restore the invariant that
	        // this._containers.top()[this.indexes.top()] === this._currentNode
	        //
	        while (this._containers.size() &&
	        // This is safe, but easier to just disable flow than do casts
	        // $FlowFixMe
	        this._containers.top()[this._indexes.top()] !== this._currentNode) {
	            this._containers.pop();
	            this._indexes.pop();
	        }
	    };
	
	    /**
	     * Return a new TraversalState object that is a copy of this one.
	     * This method is useful in conjunction with the mutating methods
	     * goToParent() and goToPreviousSibling().
	     */
	
	
	    TraversalState.prototype.clone = function clone() {
	        var clone = new TraversalState(this.root);
	        clone._currentNode = this._currentNode;
	        clone._containers = this._containers.clone();
	        clone._indexes = this._indexes.clone();
	        clone._ancestors = this._ancestors.clone();
	        return clone;
	    };
	
	    /**
	     * Returns true if this TraversalState object is equal to that
	     * TraversalState object, or false otherwise. This method exists
	     * primarily for use by our unit tests.
	     */
	
	
	    TraversalState.prototype.equals = function equals(that) {
	        return this.root === that.root && this._currentNode === that._currentNode && this._containers.equals(that._containers) && this._indexes.equals(that._indexes) && this._ancestors.equals(that._ancestors);
	    };
	
	    return TraversalState;
	}();
	
	/**
	 * This class is an internal utility that just treats an array as a stack
	 * and gives us a top() method so we don't have to write expressions like
	 * `ancestors[ancestors.length-1]`. The values() method automatically
	 * copies the internal array so we don't have to worry about client code
	 * modifying our internal stacks. The use of this Stack abstraction makes
	 * the TraversalState class simpler in a number of places.
	 */
	
	
	var Stack = function () {
	    function Stack(array) {
	        _classCallCheck(this, Stack);
	
	        this.stack = array ? array.slice(0) : [];
	    }
	
	    /** Push a value onto the stack. */
	
	
	    Stack.prototype.push = function push(v) {
	        this.stack.push(v);
	    };
	
	    /** Pop a value off of the stack. */
	
	
	    Stack.prototype.pop = function pop() {
	        return this.stack.pop();
	    };
	
	    /** Return the top value of the stack without popping it. */
	
	
	    Stack.prototype.top = function top() {
	        return this.stack[this.stack.length - 1];
	    };
	
	    /** Return a copy of the stack as an array */
	
	
	    Stack.prototype.values = function values() {
	        return this.stack.slice(0);
	    };
	
	    /** Return the number of elements in the stack */
	
	
	    Stack.prototype.size = function size() {
	        return this.stack.length;
	    };
	
	    /** Return a string representation of the stack */
	
	
	    Stack.prototype.toString = function toString() {
	        return this.stack.toString();
	    };
	
	    /** Return a shallow copy of the stack */
	
	
	    Stack.prototype.clone = function clone() {
	        return new Stack(this.stack);
	    };
	
	    /**
	     * Compare this stack to another and return true if the contents of
	     * the two arrays are the same.
	     */
	
	
	    Stack.prototype.equals = function equals(that) {
	        if (!that || !that.stack || that.stack.length !== this.stack.length) {
	            return false;
	        }
	        for (var i = 0; i < this.stack.length; i++) {
	            if (this.stack[i] !== that.stack[i]) {
	                return false;
	            }
	        }
	        return true;
	    };
	
	    return Stack;
	}();

/***/ },
/* 86 */
/***/ function(module, exports, __webpack_require__) {

	function classNames() {
		var args = arguments;
		var classes = [];
	
		for (var i = 0; i < args.length; i++) {
			var arg = args[i];
			if (!arg) {
				continue;
			}
	
			if ('string' === typeof arg || 'number' === typeof arg) {
				classes.push(arg);
			} else if ('object' === typeof arg) {
				for (var key in arg) {
					if (!arg.hasOwnProperty(key) || !arg[key]) {
						continue;
					}
					classes.push(key);
				}
			}
		}
		return classes.join(' ');
	}
	
	// safely export classNames in case the script is included directly on a page
	if (typeof module !== 'undefined' && module.exports) {
		module.exports = classNames;
	}


/***/ },
/* 87 */
/***/ function(module, exports, __webpack_require__) {

	// TODO(davidflanagan):
	// This should probably be converted to use import and to export
	// and object that maps rule names to rules. Also, maybe this should
	// be an auto-generated file with a script that updates it any time
	// we add a new rule?
	module.exports = [__webpack_require__(209), __webpack_require__(210), __webpack_require__(211), __webpack_require__(212), __webpack_require__(213), __webpack_require__(214), __webpack_require__(215), __webpack_require__(216), __webpack_require__(217), __webpack_require__(218), __webpack_require__(219), __webpack_require__(220), __webpack_require__(221), __webpack_require__(222), __webpack_require__(223), __webpack_require__(224), __webpack_require__(225), __webpack_require__(226), __webpack_require__(227), __webpack_require__(228), __webpack_require__(229), __webpack_require__(230), __webpack_require__(231), __webpack_require__(232), __webpack_require__(233), __webpack_require__(234), __webpack_require__(235), __webpack_require__(236), __webpack_require__(237), __webpack_require__(238), __webpack_require__(239)];

/***/ },
/* 88 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* This component makes its children a drag target. Example:
	 *
	 *     <DragTarget onDrop={this.handleDrop}>Drag to me</DragTarget>
	 *
	 *     ...
	 *
	 *     handleDrop: function(e) {
	 *         this.addImages(e.nativeEvent.dataTransfer.files);
	 *     }
	 *
	 * Now "Drag to me" will be a drag target - when something is dragged over it,
	 * the element will become partially transparent as a visual indicator that
	 * it's a target.
	 */
	// TODO(joel) - indicate before the hover is over the target that it's possible
	// to drag into the target. This would (I think) require a high level handler -
	// like on Perseus itself, waiting for onDragEnter, then passing down the
	// event. Sounds like a pain. Possible workaround - create a div covering the
	// entire page...
	//
	// Other extensions:
	// * custom styles for global drag and dragOver
	// * only respond to certain types of drags (only images for instance)!
	
	var React = __webpack_require__(43);
	
	var DragTarget = React.createClass({
	    displayName: "DragTarget",
	
	    propTypes: {
	        // All props not listed here are forwarded to the root element without
	        // modification.
	        onDrop: React.PropTypes.func.isRequired,
	        component: React.PropTypes.any, // component type
	        shouldDragHighlight: React.PropTypes.func,
	        style: React.PropTypes.any
	    },
	    getDefaultProps: function getDefaultProps() {
	        return {
	            component: "div",
	            shouldDragHighlight: function shouldDragHighlight() {
	                return true;
	            }
	        };
	    },
	    getInitialState: function getInitialState() {
	        return { dragHover: false };
	    },
	    handleDrop: function handleDrop(e) {
	        e.stopPropagation();
	        e.preventDefault();
	        this.setState({ dragHover: false });
	        this.props.onDrop(e);
	    },
	    handleDragEnd: function handleDragEnd() {
	        this.setState({ dragHover: false });
	    },
	    handleDragOver: function handleDragOver(e) {
	        e.preventDefault();
	    },
	    handleDragLeave: function handleDragLeave() {
	        this.setState({ dragHover: false });
	    },
	    handleDragEnter: function handleDragEnter(e) {
	        this.setState({ dragHover: this.props.shouldDragHighlight(e) });
	    },
	    render: function render() {
	        var opacity = this.state.dragHover ? { "opacity": 0.3 } : {};
	        var Component = this.props.component;
	
	        var forwardProps = Object.assign({}, this.props);
	        delete forwardProps.component;
	        delete forwardProps.shouldDragHighlight;
	
	        return React.createElement(Component, _extends({}, forwardProps, {
	            style: Object.assign({}, this.props.style, opacity),
	            onDrop: this.handleDrop,
	            onDragEnd: this.handleDragEnd,
	            onDragOver: this.handleDragOver,
	            onDragEnter: this.handleDragEnter,
	            onDragLeave: this.handleDragLeave
	        }));
	    }
	});
	
	module.exports = DragTarget;

/***/ },
/* 89 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Displays a collapsable list of KaTeX rendering errors.
	 */
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(79),
	    css = _require.css,
	    StyleSheet = _require.StyleSheet;
	
	var KatexErrorView = React.createClass({
	    displayName: "KatexErrorView",
	
	    propTypes: {
	        errorList: React.PropTypes.arrayOf(React.PropTypes.shape({
	            math: React.PropTypes.string.isRequired,
	            message: React.PropTypes.string.isRequired
	        })).isRequired
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            showErrors: false
	        };
	    },
	    handleToggleKatexErrors: function handleToggleKatexErrors(e) {
	        this.setState({ showErrors: !this.state.showErrors });
	    },
	    render: function render() {
	        var errorList = this.props.errorList;
	        var showErrors = this.state.showErrors;
	
	        // TODO(riley) replace with SVG icons
	
	        var disclosureClass = showErrors ? "icon-chevron-down" : "icon-chevron-right";
	
	        return React.createElement(
	            "div",
	            { className: css(styles.errorContainer) },
	            React.createElement(
	                "div",
	                {
	                    className: css(styles.title),
	                    onClick: this.handleToggleKatexErrors
	                },
	                React.createElement("i", { className: disclosureClass, style: { fontSize: 14 } }),
	                "\xA0 KaTeX Errors (",
	                errorList.length,
	                ")"
	            ),
	            showErrors && React.createElement(
	                "div",
	                { className: css(styles.errorExplanation) },
	                "These errors will cause your LaTeX to load really slowly for the student. Please fix them if you can. If you can\u2019t because KaTeX doesn\u2019t support the feature you need, please message Cam."
	            ),
	            showErrors && errorList.map(function (e, index) {
	                return React.createElement(
	                    "div",
	                    { className: css(styles.error), key: index },
	                    React.createElement(
	                        "div",
	                        { style: { color: "red" } },
	                        e.math
	                    ),
	                    React.createElement(
	                        "div",
	                        null,
	                        e.message
	                    )
	                );
	            })
	        );
	    }
	});
	
	var styles = StyleSheet.create({
	    title: {
	        backgroundColor: "#eee",
	        fontSize: "1.25em",
	        padding: "4px 10px"
	    },
	    errorContainer: {
	        border: "1px solid #ddd",
	        borderTop: "none"
	    },
	    errorExplanation: {
	        padding: "4px 10px",
	        backgroundColor: "pink"
	    },
	    error: {
	        padding: "4px 10px"
	    }
	});
	
	module.exports = KatexErrorView;

/***/ },
/* 90 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable react/prop-types, react/sort-comp */
	
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	/* A checkbox that syncs its value to props using the
	 * renderer's onChange method, and gets the prop name
	 * dynamically from its props list
	 */
	var PropCheckBox = React.createClass({
	    displayName: "PropCheckBox",
	
	    propTypes: {
	        labelAlignment: React.PropTypes.oneOf(["left", "right"])
	    },
	
	    DEFAULT_PROPS: {
	        label: null,
	        onChange: null,
	        labelAlignment: "left"
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return this.DEFAULT_PROPS;
	    },
	
	    propName: function propName() {
	        var propName = _.find(_.keys(this.props), function (localPropName) {
	            return !_.has(this.DEFAULT_PROPS, localPropName);
	        }, this);
	
	        if (!propName) {
	            throw new Error("Attempted to create a PropCheckBox with no prop!");
	        }
	
	        return propName;
	    },
	
	    _labelAlignLeft: function _labelAlignLeft() {
	        return this.props.labelAlignment === "left";
	    },
	
	    render: function render() {
	        var propName = this.propName();
	        return React.createElement(
	            "label",
	            null,
	            this._labelAlignLeft() && this.props.label,
	            React.createElement("input", {
	                type: "checkbox",
	                checked: this.props[propName],
	                onChange: this.toggle
	            }),
	            !this._labelAlignLeft() && this.props.label
	        );
	    },
	
	    toggle: function toggle() {
	        var propName = this.propName();
	        var changes = {};
	        changes[propName] = !this.props[propName];
	        this.props.onChange(changes);
	    }
	});
	
	module.exports = PropCheckBox;

/***/ },
/* 91 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Preprocess TeX code to convert things that KaTeX doesn't know how to handle
	 * to things is does.
	 */
	
	module.exports = function (texCode) {
	    return texCode
	    // Replace uses of \begin{align}...\end{align} which KaTeX doesn't
	    // support (yet) with \begin{aligned}...\end{aligned} which renders
	    // the same is supported by KaTeX.  It does the same for align*.
	    // TODO(kevinb) update content to use aligned instead of align.
	    .replace(/\{align[*]?\}/g, "{aligned}")
	    // Replace non-breaking spaces with regular spaces.
	    .replace(/[\u00a0]/g, " ");
	};

/***/ },
/* 92 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/*
	This is essentially a more advanced `textarea`, using Draft.js
	https://facebook.github.io/draft-js/
	
	The important Draft.js concepts needed to understand this file are:
	    - Everything is immutable, and inputs all result in a new `editorState`
	      object being passed to `handleChange`.  All changes must be done by
	      constructing new objects.  This means simply editing text involves
	      creating a new ContentState, which is used to create a new EditorState
	    - `EditorState` contains a `ContentState` property which contains the data
	      relevant to the text content
	    - `ContentState` is organized into individual "Blocks", which helps with
	      performance as updates only affect a single block
	    - Specific text in blocks can be denoted as "Entities", which can store
	      data relevant to its text.  This is what allows backspacing a widget
	      to result in its deletion in Perseus
	    - Special styling is done using Decorators, which allow substituting text
	      content with a custom react element
	    - Modifier is a collection of helpful utilities for modification purposes
	
	TODO(samiskin): Make tasks such as "addWidget" and "updateWidget" not functions
	                that you call on the PerseusEditor component (Can do once this
	                fully replacess the old editor).
	*/
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(298),
	    CharacterMetadata = _require.CharacterMetadata,
	    Entity = _require.Entity,
	    Editor = _require.Editor,
	    EditorState = _require.EditorState,
	    CompositeDecorator = _require.CompositeDecorator,
	    ContentState = _require.ContentState,
	    Modifier = _require.Modifier,
	    genKey = _require.genKey,
	    getDefaultKeyBinding = _require.getDefaultKeyBinding,
	    KeyBindingUtil = _require.KeyBindingUtil;
	
	var Widgets = __webpack_require__(31);
	var DraftUtils = __webpack_require__(269);
	
	// This controls the minimum time between when updates for the parent
	// component are generated.  The best time for this number sort of depends
	// on the user's typing speed though, as if the time between each letter being
	// typed is longer than the throttle, they would notice a freeze when the update
	// is being calculated.
	// TODO(samiskin): Figure out whats the best value for this number
	// 100 is best for my typing speed, but may not work as well for slower typists
	var UPDATE_PARENT_THROTTLE = 100;
	
	var widgetPlaceholder = "[[\u2603 {id}]]";
	var widgetRegExp = /\[\[\u2603 [a-z-]+ [0-9]+\]\]/g;
	var widgetPartsRegExp = /^\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]$/;
	var widgetRegexForId = function widgetRegexForId(id) {
	    return new RegExp("(\\[\\[\u2603 " + id + "\\]\\])", "gm");
	};
	var partialWidgetRegex = /\[\[([a-z-]+)$/; // Used for autocompletion
	
	var imageRegExp = /!\[[^\]]*?\]\([^\)].*?\)/g;
	
	// Note: Nested decorators currently do not work, therefore this will not
	//       work when nesting bold/italics/underline.  Hopefully this is
	//       fixed in future versions of Draft.js
	var boldRegExp = /\*\*([\s\S]+?)\*\*(?!\*)/g;
	var italicsRegExp = /\**(?:^|[^*])((\*|_)(\w+(\s\w+)*)\2)/g; // copied from https://github.com/ayberkt/RFMarkdownTextView/blob/387312e602f03b87f3ef82dc82c62df455d6fd30/RFMarkdownTextView/RFMarkdownSyntaxStorage.m
	var boldItalicsRegExp = /(\*\*\*\w+(\s\w+)*\*\*\*)/g;
	var underlineRegExp = /__([\s\S]+?)__(?!_)/g;
	var headerRegExp = /^ *(#{1,6})([^\n]+)$/g;
	
	/*
	    Styled ranges in Draft.js are done using a `CompositeDecorator`,
	    where a `strategy` is given to denote what ranges of text to style,
	    and a `component` is given to denote how that range should be rendered
	*/
	var entityStrategy = function entityStrategy(contentBlock, callback, type) {
	    return contentBlock.findEntityRanges(function (char) {
	        return char.getEntity() && Entity.get(char.getEntity()).type === type;
	    }, callback);
	};
	
	var styledBlock = function styledBlock(props, style) {
	    return React.createElement(
	        "span",
	        _extends({}, props, { style: style }),
	        props.children
	    );
	};
	styledBlock.propTypes = { children: React.PropTypes.any };
	
	var highlightedBlock = function highlightedBlock(props, backgroundColor) {
	    return styledBlock(props, { backgroundColor: backgroundColor });
	};
	
	var entityColorDecorator = function entityColorDecorator(type, color) {
	    return {
	        strategy: function strategy() {
	            for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	                args[_key] = arguments[_key];
	            }
	
	            return entityStrategy.apply(undefined, args.concat([type]));
	        },
	        component: function component(props) {
	            return highlightedBlock(props, color);
	        }
	    };
	};
	
	var regexColorDecorator = function regexColorDecorator(regex, color) {
	    return {
	        strategy: function strategy() {
	            for (var _len2 = arguments.length, args = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
	                args[_key2] = arguments[_key2];
	            }
	
	            return DraftUtils.regexStrategy.apply(DraftUtils, args.concat([regex]));
	        },
	        component: function component(props) {
	            return highlightedBlock(props, color);
	        }
	    };
	};
	
	var boldDecorator = {
	    strategy: function strategy() {
	        for (var _len3 = arguments.length, args = Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
	            args[_key3] = arguments[_key3];
	        }
	
	        return DraftUtils.regexStrategy.apply(DraftUtils, args.concat([boldRegExp]));
	    },
	    component: function component(props) {
	        return styledBlock(props, { fontWeight: "bold" });
	    }
	};
	
	// The italics regex has a group that ensures that the *___* block
	// does not include the * used to create a list.  Since this results
	// in match.index also including the first non-capturing group, we must
	// use custom logic for this strategy
	var italicsStrategy = function italicsStrategy() {
	    for (var _len4 = arguments.length, args = Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
	        args[_key4] = arguments[_key4];
	    }
	
	    return DraftUtils.regexStrategy.apply(DraftUtils, args.concat([italicsRegExp, function (matchArr) {
	        var start = matchArr.index + matchArr[0].length - matchArr[1].length;
	        var end = start + matchArr[1].length;
	        return { start: start, end: end };
	    }]));
	};
	var italicsDecorator = {
	    strategy: italicsStrategy,
	    component: function component(props) {
	        return styledBlock(props, { fontStyle: "italic" });
	    }
	};
	
	var underlineDecorator = {
	    strategy: function strategy() {
	        for (var _len5 = arguments.length, args = Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
	            args[_key5] = arguments[_key5];
	        }
	
	        return DraftUtils.regexStrategy.apply(DraftUtils, args.concat([underlineRegExp]));
	    },
	    component: function component(props) {
	        return styledBlock(props, { textDecoration: "underline" });
	    }
	};
	
	var boldItalicsDecorator = {
	    strategy: function strategy() {
	        for (var _len6 = arguments.length, args = Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
	            args[_key6] = arguments[_key6];
	        }
	
	        return DraftUtils.regexStrategy.apply(DraftUtils, args.concat([boldItalicsRegExp]));
	    },
	    component: function component(props) {
	        return styledBlock(props, {
	            fontWeight: "bold",
	            fontStyle: "italic"
	        });
	    }
	};
	
	// TODO: Make the headers also able to scale with the rest of the text
	// when changing the fontSize percentage
	var headerComponent = function headerComponent(props) {
	    var text = props.decoratedText;
	    var headerSize = text.split(headerRegExp)[1].length;
	    var style = { marginBottom: 0 };
	    return React.createElement("h" + headerSize, { style: style }, props.children);
	};
	headerComponent.propTypes = {
	    decoratedText: React.PropTypes.string,
	    children: React.PropTypes.any
	};
	
	var headerDecorator = {
	    strategy: function strategy() {
	        for (var _len7 = arguments.length, args = Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
	            args[_key7] = arguments[_key7];
	        }
	
	        return DraftUtils.regexStrategy.apply(DraftUtils, args.concat([headerRegExp]));
	    },
	    component: headerComponent
	};
	
	var decorator = new CompositeDecorator([entityColorDecorator("WIDGET", "#DFD"), entityColorDecorator("TEMP_IMAGE", "#fdffdd"), regexColorDecorator(imageRegExp, "#dffdfa"), boldItalicsDecorator, boldDecorator, underlineDecorator, italicsDecorator, headerDecorator]);
	
	// Key bindings are handled by mapping events to strings
	var keyBindings = function keyBindings(e) {
	    var isCommandPressed = KeyBindingUtil.hasCommandModifier(e);
	    if (isCommandPressed && e.keyCode === 66) {
	        // 66 = b
	        return "perseus-bold";
	    } else if (isCommandPressed && e.keyCode === 73) {
	        // 73 = i
	        return "perseus-italics";
	    } else if (isCommandPressed && e.keyCode === 85) {
	        // 85 = u
	        return "perseus-underline";
	    } else if (isCommandPressed && e.keyCode === 219) {
	        // 219 = [
	        return "perseus-decrease-font-size";
	    } else if (isCommandPressed && e.keyCode === 221) {
	        // 221 = ]
	        return "perseus-increase-font-size";
	    } else if (isCommandPressed && e.keyCode === 220) {
	        // 220 = ]
	        return "perseus-reset-font-size";
	    } else {
	        return getDefaultKeyBinding(e);
	    }
	};
	
	/*
	    This is the main Draft.js editor.  It keeps track of its internal Draft.js
	    state, however what it exposes through its `onChange` is a simple string
	    as well as a list of the currently active widgets.
	*/
	var PerseusEditor = React.createClass({
	    displayName: "PerseusEditor",
	
	    propTypes: {
	        onChange: React.PropTypes.func,
	        content: React.PropTypes.string,
	        initialWidgets: React.PropTypes.any,
	        placeholder: React.PropTypes.string,
	        imageUploader: React.PropTypes.func,
	        widgetEnabled: React.PropTypes.bool
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            onChange: function onChange() {},
	            content: "",
	            initialWidgets: {},
	            widgetEnabled: true,
	            placeholder: "Type here"
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        var _props = this.props,
	            content = _props.content,
	            initialWidgets = _props.initialWidgets,
	            widgetEnabled = _props.widgetEnabled;
	
	        var contentState = ContentState.createFromText(content);
	        var editorState = EditorState.createWithContent(contentState, decorator);
	
	        if (widgetEnabled) {
	            editorState = this._insertWidgetsAsEntities(editorState, initialWidgets);
	        }
	
	        return {
	            editorState: editorState,
	            widgets: initialWidgets,
	            fontSizePercentage: 100
	        };
	    },
	
	
	    // The editor can have its content changed completely by changing the
	    // content prop, however if the data this component sent to its parent
	    // using `this.props.onChange()` is being fed back in, ignore it
	    componentDidUpdate: function componentDidUpdate(prevProps) {
	        if (this.props.content !== this.lastContentUpdate) {
	            this.lastContentUpdate = this.props.content;
	            this.setState(this.getInitialState()); //eslint-disable-line
	        }
	    },
	
	
	    // By turning widgets into Entities, we allow for widgets to be considered
	    // "IMMUTABLE", that is, backspacing a widget will delete the entire text
	    // rather than just a "]" character.  It also enables us to detect which
	    // widget id has been deleted, as metadata can be attached to entities
	    // TODO(samiskin): Turn this task of `applyEntities(pattern, createEntity)`
	    // into a DraftUtils function
	    _insertWidgetsAsEntities: function _insertWidgetsAsEntities(editorState, widgets) {
	        var content = editorState.getCurrentContent();
	
	        Object.keys(widgets).forEach(function (id) {
	            var selection = DraftUtils.findPattern(content, widgetRegexForId(id)); //eslint-disable-line max-len
	            if (selection) {
	                // Sometimes the widgets don't actually exist
	                var entity = Entity.create("WIDGET", "IMMUTABLE", { id: id });
	                content = Modifier.applyEntity(content, selection, entity);
	            }
	        });
	
	        // EditorState.set is used rather than push, because no state should
	        // be added to the undo stack.
	        var withEntity = EditorState.set(editorState, {
	            currentContent: content
	        });
	
	        return withEntity;
	    },
	    _getDraftData: function _getDraftData() {
	        var editorState = this.state.editorState;
	        var contentState = editorState.getCurrentContent();
	        var selection = editorState.getSelection();
	        return { editorState: editorState, contentState: contentState, selection: selection };
	    },
	    _getNextWidgetId: function _getNextWidgetId(type) {
	        var currWidgets = this.state.widgets;
	        return Object.keys(currWidgets).filter(function (id) {
	            return currWidgets[id].type === type;
	        }).map(function (id) {
	            return +id.split(" ")[1];
	        }) //ids are (([a-z-]+) ([0-9]+))
	        .reduce(function (maxId, currId) {
	            return Math.max(maxId, currId);
	        }, 0);
	    },
	    _createInitialWidget: function _createInitialWidget(widgetType) {
	        // Since widgets are given IDs, adding a new widget must ensure that a
	        // unique id is generated for it.
	        var widgetNum = this._getNextWidgetId(widgetType);
	        var id = widgetType + " " + (widgetNum + 1);
	        var widget = {
	            options: Widgets.getEditor(widgetType).defaultProps,
	            type: widgetType,
	            // Track widget version on creation, so that a widget editor
	            // without a valid version prop can only possibly refer to a
	            // pre-versioning creation time.
	            version: Widgets.getVersion(widgetType)
	        };
	        return [id, widget];
	    },
	    addWidget: function addWidget(type) {
	        var _this = this;
	
	        this.focus(function () {
	            return _this._handleChange(_this._insertNewWidget(type));
	        });
	    },
	    _insertNewWidget: function _insertNewWidget(type, draftDataParams) {
	        var _extends2;
	
	        var draftData = _extends({}, this._getDraftData(), draftDataParams);
	
	        var _createInitialWidget2 = this._createInitialWidget(type),
	            id = _createInitialWidget2[0],
	            widget = _createInitialWidget2[1];
	
	        var newWidgets = _extends({}, this.state.widgets, (_extends2 = {}, _extends2[id] = widget, _extends2));
	        var newDraftData = this._insertWidgetText(draftData, id);
	
	        return {
	            editorState: newDraftData.editorState,
	            widgets: newWidgets
	        };
	    },
	    _insertWidgetText: function _insertWidgetText(draftData, id) {
	        // Text for the widget is inserted, and an entity is assigned
	        var text = widgetPlaceholder.replace("{id}", id);
	        var entity = Entity.create("WIDGET", "IMMUTABLE", { id: id });
	
	        return DraftUtils.replaceSelection(draftData, text, entity);
	    },
	    updateWidget: function updateWidget(id, newProps) {
	        var _extends3;
	
	        this.setState({ widgets: _extends({}, this.state.widgets, (_extends3 = {}, _extends3[id] = newProps, _extends3)) });
	    },
	
	
	    // This function only removes the widget from the content, and then
	    // handleChange handles removing widgets from the state, as widgets
	    // can also be deleted by editor actions such as backspace and delete
	    removeWidget: function removeWidget(id) {
	        var _this2 = this;
	
	        this.focus(function () {
	            var _getDraftData2 = _this2._getDraftData(),
	                editorState = _getDraftData2.editorState,
	                contentState = _getDraftData2.contentState;
	
	            var selection = DraftUtils.findPattern(contentState, widgetRegexForId(id)); //eslint-disable-line max-len
	            var newDraftData = DraftUtils.deleteSelection({
	                editorState: editorState,
	                selection: selection
	            });
	
	            _this2._handleChange({ editorState: newDraftData.editorState });
	        });
	    },
	    addTemplate: function addTemplate(templateType) {
	        var _this3 = this;
	
	        this.focus(function () {
	            _this3._addTemplate(templateType);
	        });
	    },
	    _addTemplate: function _addTemplate(templateType) {
	        var _this4 = this;
	
	        var _getDraftData3 = this._getDraftData(),
	            editorState = _getDraftData3.editorState,
	            contentState = _getDraftData3.contentState,
	            selection = _getDraftData3.selection;
	
	        var widgets = _extends({}, this.state.widgets);
	
	        // Templates shouldn't interrupt a line if the cursor is not at the end
	        var currBlock = contentState.getBlockForKey(selection.getEndKey());
	        selection = DraftUtils.selectEnd(currBlock);
	
	        // Insert a new line at the beginning if there is content there, that
	        // way the template appears on a newline in the rendered markdown
	        if (currBlock.getText().length > 0) {
	            contentState = Modifier.splitBlock(contentState, selection);
	            selection = contentState.getSelectionAfter();
	        }
	
	        if (templateType === "allWidgets") {
	            var allTypes = Widgets.getAllWidgetTypes().sort();
	
	            // Insert a newline at the beginning
	            contentState = Modifier.splitBlock(contentState, selection);
	            contentState = allTypes.reduce(function (content, type) {
	                var _createInitialWidget3 = _this4._createInitialWidget(type),
	                    id = _createInitialWidget3[0],
	                    widget = _createInitialWidget3[1];
	
	                widgets[id] = widget;
	                content = _this4._insertWidgetText({
	                    contentState: content,
	                    selection: content.getSelectionAfter()
	                }, id).contentState;
	                return Modifier.splitBlock(
	                // Put each widget on a new line
	                content, content.getSelectionAfter());
	            }, contentState);
	
	            editorState = EditorState.push(editorState, contentState, "insert-fragment");
	        } else {
	            var template = "";
	            if (templateType === "table") {
	                template = "header 1 | header 2 | header 3\n" + "- | - | -\n" + "data 1 | data 2 | data 3\n" + "data 4 | data 5 | data 6\n" + "data 7 | data 8 | data 9";
	            } else if (templateType === "titledTable") {
	                template = "|| **Table title** ||\n" + "header 1 | header 2 | header 3\n" + "- | - | -\n" + "data 1 | data 2 | data 3\n" + "data 4 | data 5 | data 6\n" + "data 7 | data 8 | data 9";
	            } else if (templateType === "alignment") {
	                template = "$\\begin{align} x+5 &= 30 \\\\\n" + "x+5-5 &= 30-5 \\\\\n" + "x &= 25 \\end{align}$";
	            } else if (templateType === "piecewise") {
	                template = "$f(x) = \\begin{cases}\n" + "7 & \\text{if }x=1 \\\\\n" + "f(x-1)+5 & \\text{if }x > 1\n" + "\\end{cases}$";
	            }
	
	            editorState = DraftUtils.insertText({ editorState: editorState, contentState: contentState, selection: selection }, "\n" + template + "\n").editorState;
	        }
	        this._handleChange({ editorState: editorState, widgets: widgets });
	    },
	    _handleCopy: function _handleCopy() {
	        var _this5 = this;
	
	        var _getDraftData4 = this._getDraftData(),
	            contentState = _getDraftData4.contentState,
	            selection = _getDraftData4.selection;
	
	        var entities = DraftUtils.getEntities(contentState, selection);
	
	        var copiedWidgets = entities.reduce(function (map, entity) {
	            var id = entity.getData().id;
	            map[id] = _this5.state.widgets[id];
	            return map;
	        }, {});
	
	        localStorage.perseusLastCopiedWidgets = JSON.stringify(copiedWidgets);
	        return false;
	    },
	
	
	    // Widgets cannot have ID conflicts, therefore this function exists
	    // to return a mapping of { new id -> safe id }
	    _createSafeWidgetMapping: function _createSafeWidgetMapping(newWidgets, currentWidgets) {
	        // Create a mapping of { type -> largest id of that type }
	        var maxIds = Object.keys(currentWidgets).reduce(function (idMap, widget) {
	            var _widget$split = widget.split(" "),
	                type = _widget$split[0],
	                id = _widget$split[1];
	
	            idMap[type] = idMap[type] ? Math.max(idMap[type], +id) : +id;
	            return idMap;
	        }, {});
	
	        var safeWidgetMapping = Object.keys(newWidgets).reduce(function (safeMap, widget) {
	            var type = widget.split(" ")[0];
	            maxIds[type] = maxIds[type] ? maxIds[type] + 1 : 1;
	            safeMap[widget] = type + " " + maxIds[type];
	            return safeMap;
	        }, {});
	
	        return safeWidgetMapping;
	    },
	
	
	    // Pasting text from another Perseus editor instance should also copy over
	    // the widgets.  To do this properly, we must parse the text, replace the
	    // widget ids with non-conflicting ones, store them, and also assign them
	    // proper entities.  Sadly Draft.js only supports `handlePastedText` which
	    // happens prior to the new content state being generated (which is needed
	    // to add entities to).  We therefore must reimplement the default Paste
	    // functionality, in order to add our custom steps afterwards
	    _handlePaste: function _handlePaste(pastedText, html, selection) {
	        // If no widgets are in localstorage, just use default behavior
	        var sourceWidgetsJSON = localStorage.perseusLastCopiedWidgets;
	        if (!sourceWidgetsJSON) {
	            return false;
	        }
	
	        var sourceWidgets = JSON.parse(sourceWidgetsJSON);
	        var widgets = _extends({}, this.state.widgets);
	        var safeWidgetMapping = this._createSafeWidgetMapping(sourceWidgets, widgets); //eslint-disable-line max-len
	        var charData = CharacterMetadata.create();
	
	        // insertText takes a sanitizer function which gets ran on every
	        // line.  It is used here in order to fix the new widgets to not
	        // have conflicting IDs, as well as fill in the widget data
	        var sanitizeText = function sanitizeText(textLine) {
	            var sanitized = textLine.replace(new RegExp("\r", "g"), ""); //eslint-disable-line no-control-regex
	            var characterList = Array(sanitized.length).fill(charData);
	            var safeText = sanitized.replace(widgetRegExp, function (syntax, offset) {
	                //eslint-disable-line max-len
	                var match = widgetPartsRegExp.exec(syntax);
	                var fullText = match[0]; // The entire [[ widgetName id ]]
	                var widgetId = match[1]; // Just the "widgetName id" part
	                var newId = safeWidgetMapping[widgetId];
	                var newText = widgetPlaceholder.replace("{id}", newId);
	
	                // Create an entity for the new widget, and assign it to the
	                // characters that match up to the new widget text (splice)
	                var entity = Entity.create("WIDGET", "IMMUTABLE", {
	                    id: newId
	                }); //eslint-disable-line max-len
	                var entityChar = CharacterMetadata.applyEntity(charData, entity); //eslint-disable-line max-len
	                var entityChars = Array(newText.length).fill(entityChar);
	                characterList.splice.apply(characterList, [offset, fullText.length].concat(entityChars));
	
	                widgets[newId] = sourceWidgets[widgetId];
	                return fullText.replace(widgetId, newId);
	            });
	            return { text: safeText, characterList: characterList };
	        };
	
	        var data = this._getDraftData();
	        data.selection = selection || data.selection;
	
	        var _DraftUtils$insertTex = DraftUtils.insertText(data, pastedText, sanitizeText),
	            editorState = _DraftUtils$insertTex.editorState;
	
	        this._handleChange({ editorState: editorState, widgets: widgets });
	        return true; // True means draft doesn't run its default behavior
	    },
	    _handleDrop: function _handleDrop(selection, dataTransfer) {
	        // All insertions are done to the end of the current block
	        var contentState = this.state.editorState.getCurrentContent();
	        var endKey = selection.getEndKey();
	        var endBlock = contentState.getBlockForKey(endKey);
	        var endSelection = DraftUtils.selectEnd(endBlock);
	
	        var imageUrl = dataTransfer.getLink();
	        if (imageUrl) {
	            // Adds new lines and collapses the selection
	            var _DraftUtils$insertTex2 = DraftUtils.insertText(_extends({}, this._getDraftData(), { selection: endSelection }), "\n![](" + imageUrl + ")"),
	                editorState = _DraftUtils$insertTex2.editorState;
	
	            this._handleChange({ editorState: editorState });
	        } else {
	            var text = dataTransfer.getText();
	            return this._handlePaste(text, null, endSelection);
	        }
	
	        return true; // Disable default draft drop handler
	    },
	    _handleDroppedFiles: function _handleDroppedFiles(selection, files) {
	        var _this6 = this;
	
	        var images = files.filter(function (file) {
	            return file.type.match("image.*");
	        });
	        var contentState = this.state.editorState.getCurrentContent();
	        images.forEach(function (image) {
	            // Insert placeholder text to show that the image is being uploaded
	            var text = "![](" + image.name + "...)";
	            var id = genKey();
	            var entity = Entity.create("TEMP_IMAGE", "IMMUTABLE", { id: id });
	
	            var charData = CharacterMetadata.create().merge({ entity: entity });
	            var characterList = Array(text.length).fill(charData);
	            var sanitizer = function sanitizer(textLine) {
	                return textLine === text ? { text: text, characterList: characterList } : null;
	            };
	
	            var blockKey = selection.getEndKey();
	            var contentBlock = contentState.getBlockForKey(blockKey);
	            var endOfBlockSelection = DraftUtils.selectEnd(contentBlock);
	            contentState = DraftUtils.insertText({ contentState: contentState, selection: endOfBlockSelection }, "\n" + text + "\n", sanitizer).contentState;
	
	            // Begin uploading the image, and update the link once complete
	            _this6.props.imageUploader(image, function (url) {
	                var currEditor = _this6.state.editorState;
	                var currContent = currEditor.getCurrentContent();
	                var placeholderLocation = DraftUtils.findEntity(currContent, function (c) {
	                    return c.getData().id === id;
	                });
	                var newDraftData = DraftUtils.replaceSelection({
	                    editorState: currEditor,
	                    contentState: currContent,
	                    selection: placeholderLocation
	                }, "![](" + url + ")");
	                _this6._handleChange({ editorState: newDraftData.editorState });
	            });
	        });
	        var editorState = EditorState.push(this.state.editorState, contentState, "insert-fragment");
	        this._handleChange({ editorState: editorState });
	        return true; // Disable default draft drop handler
	    },
	
	
	    // This implements tab completion for widgets.  When the user
	    // has typed [[d, then presses tab, we should replace [[d
	    // with the full [[ {emoji} dropdown 1 ]] text
	    _handleTab: function _handleTab(e) {
	        var _getDraftData5 = this._getDraftData(),
	            contentState = _getDraftData5.contentState,
	            selection = _getDraftData5.selection;
	
	        // isCollapsed means that there is no active selection, its just
	        // a blinking cursor.  For the SelectionState object, this
	        // essentially means that anchorOffset === focusOffset
	
	
	        if (!selection.isCollapsed() || !this.props.widgetEnabled) {
	            return;
	        }
	        e.preventDefault();
	
	        var currBlock = contentState.getBlockForKey(selection.getEndKey());
	        var text = currBlock.getText().substring(0, selection.getEndOffset());
	        var match = text.match(partialWidgetRegex);
	        if (match) {
	            var partialName = match[1];
	            var allWidgets = Widgets.getAllWidgetTypes();
	            var matchingWidgets = allWidgets.filter(function (widget) {
	                return widget.substring(0, partialName.length) === partialName;
	            });
	
	            // If only one match is available, complete it
	            if (matchingWidgets.length === 1) {
	                var widgetType = matchingWidgets[0];
	                var replacementArea = selection.merge({
	                    anchorOffset: match.index
	                });
	
	                this._handleChange(this._insertNewWidget(widgetType, {
	                    selection: replacementArea
	                }));
	            }
	        }
	        return true; // Say that we've handled the event, no other work needed
	    },
	    _getDecorationForStyle: function _getDecorationForStyle(style) {
	        switch (style) {
	            case "perseus-bold":
	                return "**";
	            case "perseus-italics":
	                return "*";
	            case "perseus-underline":
	                return "__";
	            default:
	                return null;
	        }
	    },
	    _handleKeyCommand: function _handleKeyCommand(command) {
	        // Check if the font size should be changed
	        var fontSizePercentage = this.state.fontSizePercentage;
	
	        if (command === "perseus-increase-font-size") {
	            this.setState({ fontSizePercentage: fontSizePercentage + 10 });
	            return true;
	        } else if (command === "perseus-decrease-font-size") {
	            this.setState({ fontSizePercentage: fontSizePercentage - 10 });
	            return true;
	        } else if (command === "perseus-reset-font-size") {
	            this.setState({ fontSizePercentage: 100 });
	            return true;
	        }
	
	        // Check whether a style such as bold/italics/underline should be added
	        var decoration = this._getDecorationForStyle(command);
	        if (decoration !== null) {
	            var data = this._getDraftData();
	
	            var _DraftUtils$toggleDec = DraftUtils.toggleDecoration(data, decoration),
	                editorState = _DraftUtils$toggleDec.editorState;
	
	            this._handleChange({ editorState: editorState });
	            return true;
	        }
	
	        return false;
	    },
	
	
	    lastContentUpdate: "",
	    _updateParent: function _updateParent(content, widgets) {
	        // The parent component should know of only the active widgets,
	        // however the widgets are not deleted from this.state because a
	        // user undoing a widget deletion should also recover the
	        // widget's metadata
	        var currEntities = DraftUtils.getEntities(content);
	        var visibleWidgets = currEntities.reduce(function (map, entity) {
	            var id = entity.getData().id;
	            map[id] = widgets[id];
	            return map;
	        }, {});
	
	        this.lastContentUpdate = content.getPlainText("\n");
	
	        // Provide the parent component with the current text
	        // representation, as well as the current active widgets
	        this.props.onChange({
	            content: this.lastContentUpdate,
	            widgets: visibleWidgets
	        });
	    },
	
	
	    pastContentState: null,
	    lastIdleCallback: null,
	    _handleChange: function _handleChange(newState) {
	        var _this7 = this;
	
	        var state = _extends({}, this.state, newState);
	        var widgets = state.widgets;
	        var editorState = state.editorState;
	
	        // The cursor should not exist within an entity
	        editorState = DraftUtils.snapSelectionOutsideEntities({ editorState: editorState }, this.state.editorState.getSelection()).editorState;
	
	        var newContent = editorState.getCurrentContent();
	
	        // editorState contains more than just the content, such as the current
	        // cursor position.  This means `handleChange` gets called for more than
	        // just content changes, so certain calculations aren't always needed.
	        if (newContent !== this.pastContentState) {
	            // This ensures that unless the content stops changing for a certain
	            // short duration, no processing will be done to update the parent.
	            // This allows the editing to remain performant for large files,
	            // as basic tasks only occur on individual ContentBlocks, while
	            // updating the parent involves iterating through them all
	            clearTimeout(this.lastIdleCallback);
	            this.lastIdleCallback = setTimeout(function () {
	                return _this7._updateParent(newContent, widgets);
	            }, UPDATE_PARENT_THROTTLE);
	        }
	
	        this.pastContentState = newContent;
	        this.setState({ editorState: editorState, widgets: widgets });
	    },
	
	
	    // HACK: There are currently serious Draft.js bugs related to mutating the
	    //       editorState when it is not in focus, then pressing undo.  This
	    //       workaround uses a callback parameter to run code after the
	    //       editorState has been updated to be in focus, that way functions
	    //       such as addWidget will not bring up serious issues when undone
	    focus: function focus(callback) {
	        this.editor.focus();
	        var editorState = this.state.editorState;
	        editorState = EditorState.set(editorState, {
	            selection: editorState.getSelection().set("hasFocus", true),
	            forceSelection: true
	        });
	        this.setState({ editorState: editorState }, callback);
	    },
	    render: function render() {
	        var _this8 = this;
	
	        return React.createElement(
	            "div",
	            {
	                onCopy: this._handleCopy,
	                onCut: this._handleCopy,
	                onDragStart: this._handleCopy,
	                style: {
	                    fontSize: this.state.fontSizePercentage + "%"
	                }
	            },
	            React.createElement(Editor, {
	                ref: function ref(e) {
	                    return _this8.editor = e;
	                },
	                editorState: this.state.editorState,
	                onChange: function onChange(editorState) {
	                    return _this8._handleChange({ editorState: editorState });
	                },
	                spellCheck: true,
	                stripPastedStyles: true,
	                placeholder: this.props.placeholder,
	                handlePastedText: this._handlePaste,
	                handleDroppedFiles: this._handleDroppedFiles,
	                handleDrop: this._handleDrop,
	                keyBindingFn: keyBindings,
	                handleKeyCommand: this._handleKeyCommand,
	                onTab: this._handleTab
	            })
	        );
	    }
	});
	
	module.exports = PerseusEditor;

/***/ },
/* 93 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * These are things that widgets should exclude when serializing themselves.
	 *
	 * The use of this list needs to die. Basically, there are codepaths that
	 * blindly serialize the "props" of a widget so that it can pass around its
	 * info. Unfortunately, props aren't guaranteed to be serializable, and
	 * automatically serializing schemaless list of attributes causes issues (e.g.
	 * circular JSON structures sometimes).
	 *
	 * This blacklists things that we know don't need to be serialized.
	 */
	module.exports = [
	// standard props "added" by react
	// (technically the renderer still adds them)
	"key", "ref",
	// added by src/renderer.jsx
	"containerSizeClass", "widgetId", "onChange", "problemNum", "apiOptions", "questionCompleted", "findWidgets",
	// added by src/editor.jsx, for widgets removing themselves
	// this is soooo not the right place for this, but alas.
	"onRemove",
	// also added by src/editor.jsx
	"id",
	// Callbacks and items for interaction handling
	"onBlur", "onFocus", "trackInteraction", "keypadElement"];

/***/ },
/* 94 */,
/* 95 */,
/* 96 */,
/* 97 */,
/* 98 */,
/* 99 */,
/* 100 */,
/* 101 */,
/* 102 */,
/* 103 */,
/* 104 */,
/* 105 */,
/* 106 */,
/* 107 */,
/* 108 */,
/* 109 */,
/* 110 */,
/* 111 */,
/* 112 */,
/* 113 */,
/* 114 */,
/* 115 */,
/* 116 */,
/* 117 */,
/* 118 */,
/* 119 */,
/* 120 */,
/* 121 */,
/* 122 */,
/* 123 */,
/* 124 */,
/* 125 */,
/* 126 */,
/* 127 */,
/* 128 */,
/* 129 */,
/* 130 */,
/* 131 */,
/* 132 */,
/* 133 */,
/* 134 */,
/* 135 */,
/* 136 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable comma-dangle, no-var, react/sort-comp */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	/* globals $_ */
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	var Changeable = __webpack_require__(187);
	var PerseusMarkdown = __webpack_require__(49);
	var WidgetJsonifyDeprecated = __webpack_require__(242);
	
	var EN_DASH = "\u2013";
	
	var PassageRef = React.createClass({
	    displayName: "PassageRef",
	
	    propTypes: _extends({}, Changeable.propTypes, {
	        passageNumber: React.PropTypes.number,
	        referenceNumber: React.PropTypes.number,
	        summaryText: React.PropTypes.string
	    }),
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            passageNumber: 1,
	            referenceNumber: 1,
	            summaryText: ""
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            lineRange: null,
	            content: null
	        };
	    },
	
	    shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {
	        return !_.isEqual(this.props, nextProps) || !_.isEqual(this.state, nextState);
	    },
	
	    getUserInput: function getUserInput() {
	        return WidgetJsonifyDeprecated.getUserInput.call(this);
	    },
	
	    render: function render() {
	        var lineRange = this.state.lineRange;
	        var lineRangeOutput;
	        if (!lineRange) {
	            lineRangeOutput = $_({ lineRange: "?" + EN_DASH + "?" }, "lines %(lineRange)s");
	        } else if (lineRange[0] === lineRange[1]) {
	            lineRangeOutput = $_({ lineNumber: lineRange[0] }, "line %(lineNumber)s");
	        } else {
	            lineRangeOutput = $_({
	                lineRange: lineRange[0] + EN_DASH + lineRange[1]
	            }, "lines %(lineRange)s");
	        }
	
	        var summaryOutput;
	        if (this.props.summaryText) {
	            var summaryTree = PerseusMarkdown.parseInline(this.props.summaryText);
	            summaryOutput = React.createElement(
	                "span",
	                { "aria-hidden": true },
	                " ",
	                "(\u201C",
	                PerseusMarkdown.basicOutput(summaryTree),
	                "\u201D)"
	            );
	        } else {
	            summaryOutput = null;
	        }
	
	        return React.createElement(
	            "span",
	            null,
	            lineRangeOutput,
	            summaryOutput,
	            lineRange && React.createElement(
	                "div",
	                { className: "perseus-sr-only" },
	                this.state.content
	            )
	        );
	    },
	
	    change: function change() {
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return Changeable.change.apply(this, args);
	    },
	
	
	    componentDidMount: function componentDidMount() {
	        this._deferredUpdateRange();
	
	        this._throttledUpdateRange = _.throttle(this._deferredUpdateRange, 500);
	        window.addEventListener("resize", this._throttledUpdateRange);
	    },
	
	    componentDidUpdate: function componentDidUpdate() {
	        this._deferredUpdateRange();
	    },
	
	    componentWillUnmount: function componentWillUnmount() {
	        window.removeEventListener("resize", this._throttledUpdateRange);
	    },
	
	    _deferredUpdateRange: function _deferredUpdateRange() {
	        _.defer(this._updateRange);
	    },
	
	    _updateRange: function _updateRange() {
	        var passage = this.props.findWidgets("passage " + this.props.passageNumber)[0];
	
	        var refInfo = null;
	        if (passage) {
	            refInfo = passage.getReference(this.props.referenceNumber);
	        }
	
	        if (this.isMounted()) {
	            if (refInfo) {
	                this.setState({
	                    lineRange: [refInfo.startLine, refInfo.endLine],
	                    content: refInfo.content
	                });
	            } else {
	                this.setState({
	                    lineRange: null,
	                    content: null
	                });
	            }
	        }
	    },
	
	    simpleValidate: function simpleValidate(rubric) {
	        return PassageRef.validate(this.getUserInput(), rubric);
	    }
	});
	
	_.extend(PassageRef, {
	    validate: function validate(state, rubric) {
	        return {
	            type: "points",
	            earned: 0,
	            total: 0,
	            message: null
	        };
	    }
	});
	
	module.exports = {
	    name: "passage-ref",
	    displayName: "PassageRef (SAT only)",
	    defaultAlignment: "inline",
	    widget: PassageRef,
	    transform: function transform(editorProps) {
	        return _.pick(editorProps, "passageNumber", "referenceNumber", "summaryText");
	    },
	    version: { major: 0, minor: 1 }
	};

/***/ },
/* 137 */,
/* 138 */,
/* 139 */,
/* 140 */,
/* 141 */,
/* 142 */,
/* 143 */,
/* 144 */,
/* 145 */,
/* 146 */,
/* 147 */,
/* 148 */,
/* 149 */,
/* 150 */,
/* 151 */,
/* 152 */,
/* 153 */,
/* 154 */,
/* 155 */,
/* 156 */,
/* 157 */,
/* 158 */,
/* 159 */,
/* 160 */,
/* 161 */,
/* 162 */,
/* 163 */,
/* 164 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable react/forbid-prop-types, react/sort-comp */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var _ = __webpack_require__(56);
	
	var textWidthCache = {};
	function getTextWidth(text) {
	    if (!textWidthCache[text]) {
	        // Hacky way to guess the width of an input box
	        var $test = $("<span>").text(text).appendTo("body");
	        textWidthCache[text] = $test.width() + 5;
	        $test.remove();
	    }
	    return textWidthCache[text];
	}
	
	var TextListEditor = React.createClass({
	    displayName: "TextListEditor",
	
	    propTypes: {
	        options: React.PropTypes.array,
	        layout: React.PropTypes.string,
	        onChange: React.PropTypes.func.isRequired
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            options: [],
	            layout: "horizontal"
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            items: this.props.options.concat("")
	        };
	    },
	
	    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        this.setState({
	            items: nextProps.options.concat("")
	        });
	    },
	
	    render: function render() {
	        var className = ["perseus-text-list-editor", "perseus-clearfix", "layout-" + this.props.layout].join(" ");
	
	        var inputs = _.map(this.state.items, function (item, i) {
	            return React.createElement(
	                "li",
	                { key: i },
	                React.createElement("input", {
	                    ref: "input_" + i,
	                    type: "text",
	                    value: item,
	                    onChange: this.onChange.bind(this, i),
	                    onKeyDown: this.onKeyDown.bind(this, i),
	                    style: { width: getTextWidth(item) }
	                })
	            );
	        }, this);
	
	        return React.createElement(
	            "ul",
	            { className: className },
	            inputs
	        );
	    },
	
	    onChange: function onChange(index, event) {
	        var items = _.clone(this.state.items);
	        items[index] = event.target.value;
	
	        if (index === items.length - 1) {
	            items = items.concat("");
	        }
	
	        this.setState({ items: items });
	        this.props.onChange(_.compact(items));
	    },
	
	    onKeyDown: function onKeyDown(index, event) {
	        var which = event.nativeEvent.keyCode;
	
	        // Backspace deletes an empty input...
	        if (which === 8 /* backspace */ && this.state.items[index] === "") {
	            event.preventDefault();
	
	            var items = _.clone(this.state.items);
	            var focusIndex = index === 0 ? 0 : index - 1;
	
	            if (index === items.length - 1 && (index === 0 || items[focusIndex] !== "")) {
	                // ...except for the last one, iff it is the only empty
	                // input at the end.
	                ReactDOM.findDOMNode(this.refs["input_" + focusIndex]).focus();
	            } else {
	                items.splice(index, 1);
	                this.setState({ items: items }, function () {
	                    ReactDOM.findDOMNode(this.refs["input_" + focusIndex]).focus();
	                });
	            }
	
	            // Deleting the last character in the second-to-last input
	            // removes it
	        } else if (which === 8 /* backspace */ && this.state.items[index].length === 1 && index === this.state.items.length - 2) {
	            event.preventDefault();
	
	            var _items = _.clone(this.state.items);
	            _items.splice(index, 1);
	            this.setState({ items: _items });
	            this.props.onChange(_.compact(_items));
	
	            // Enter adds an option below the current one...
	        } else if (which === 13 /* enter */) {
	                event.preventDefault();
	
	                var _items2 = _.clone(this.state.items);
	                var _focusIndex = index + 1;
	
	                if (index === _items2.length - 2) {
	                    // ...unless the empty input is just below.
	                    ReactDOM.findDOMNode(this.refs["input_" + _focusIndex]).focus();
	                } else {
	                    _items2.splice(_focusIndex, 0, "");
	                    this.setState({ items: _items2 }, function () {
	                        ReactDOM.findDOMNode(this.refs["input_" + _focusIndex]).focus();
	                    });
	                }
	            }
	    }
	});
	
	module.exports = TextListEditor;

/***/ },
/* 165 */,
/* 166 */,
/* 167 */,
/* 168 */
/***/ function(module, exports, __webpack_require__) {

	/* NOTE: This mimics what we do in webapp and links to our custom version of
	React -- this was not added with npm */
	module.exports = __webpack_require__(43).__internalAddons.createFragment;


/***/ },
/* 169 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = window.$


/***/ },
/* 170 */
/***/ function(module, exports, __webpack_require__) {

	var babelPluginFlowReactPropTypes_proptype_ObjectNode = __webpack_require__(188).babelPluginFlowReactPropTypes_proptype_ObjectNode || __webpack_require__(43).PropTypes.any;
	/**
	 * Type definitions for multi-item types, including:
	 *
	 * - Item: A multi-item tree wrapped in a `_multi` key, to help us recognize it
	 *         as a multi-item in other contexts and avoid misinterpreting its
	 *         other properties.
	 * - ItemTree: A multi-item without the `_multi` key. Conforms to the Tree
	 *             interface, so it's compatible with our tree traversal functions.
	 * - And the various types of nodes that compose a tree.
	 */
	
	
	var babelPluginFlowReactPropTypes_proptype_ArrayNode = __webpack_require__(188).babelPluginFlowReactPropTypes_proptype_ArrayNode || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_Tree = __webpack_require__(188).babelPluginFlowReactPropTypes_proptype_Tree || __webpack_require__(43).PropTypes.any;
	
	Object.defineProperty(module.exports, "babelPluginFlowReactPropTypes_proptype_ContentNode", __webpack_require__(43).PropTypes.shape({
	    __type: __webpack_require__(43).PropTypes.oneOf(["content", "item"]).isRequired,
	    content: __webpack_require__(43).PropTypes.string,
	    images: __webpack_require__(43).PropTypes.shape({}),
	    widgets: __webpack_require__(43).PropTypes.shape({})
	}));
	Object.defineProperty(module.exports, "babelPluginFlowReactPropTypes_proptype_HintNode", __webpack_require__(43).PropTypes.shape({
	    __type: __webpack_require__(43).PropTypes.oneOf(["hint"]).isRequired,
	    content: __webpack_require__(43).PropTypes.string,
	    images: __webpack_require__(43).PropTypes.shape({}),
	    widgets: __webpack_require__(43).PropTypes.shape({}),
	    replace: __webpack_require__(43).PropTypes.bool
	}));
	Object.defineProperty(module.exports, "babelPluginFlowReactPropTypes_proptype_Item", __webpack_require__(43).PropTypes.shape({
	    _multi: __webpack_require__(43).PropTypes.any.isRequired
	}));

/***/ },
/* 171 */
/***/ function(module, exports, __webpack_require__) {

	Object.defineProperty(module.exports, "babelPluginFlowReactPropTypes_proptype_ContentShape", __webpack_require__(43).PropTypes.shape({
	    type: __webpack_require__(43).PropTypes.oneOf(["content"]).isRequired
	}));
	/**
	 * Type definitions for multi-item shapes.
	 *
	 * A shape is an object that serves as a runtime type declaration: it specifies
	 * a tree structure for a particular class of multi-item.
	 *
	 * We use shapes instead static compile-time typing because the CMS needs to
	 * understand the shape of our content library's multi-items at runtime, and
	 * it's not always possible to infer the full shape from an example multi-item.
	 *
	 * Shapes also enable us to traverse a multi-item-shaped tree with confidence,
	 * even when we can't infer the shape from the tree alone.
	 *
	 * We *could* go all-in on a more general library to make certain Flow types
	 * runtime-inspectable, in order to DRY some things up, but that's probably a
	 * big ol' infrastructural magic mess, and the narrower scope of Shapes makes
	 * it easier to be confident that we've covered all cases rather than having to
	 * deal with all possible Javascript types.
	 */
	
	Object.defineProperty(module.exports, "babelPluginFlowReactPropTypes_proptype_HintShape", __webpack_require__(43).PropTypes.shape({
	    type: __webpack_require__(43).PropTypes.oneOf(["hint"]).isRequired
	}));
	Object.defineProperty(module.exports, "babelPluginFlowReactPropTypes_proptype_TagsShape", __webpack_require__(43).PropTypes.shape({
	    type: __webpack_require__(43).PropTypes.oneOf(["tags"]).isRequired
	}));
	Object.defineProperty(module.exports, "babelPluginFlowReactPropTypes_proptype_ArrayShape", __webpack_require__(43).PropTypes.shape({
	    type: __webpack_require__(43).PropTypes.oneOf(["array"]).isRequired,
	    elementShape: __webpack_require__(43).PropTypes.any.isRequired
	}));
	Object.defineProperty(module.exports, "babelPluginFlowReactPropTypes_proptype_ObjectShape", __webpack_require__(43).PropTypes.shape({
	    type: __webpack_require__(43).PropTypes.oneOf(["object"]).isRequired,
	    shape: __webpack_require__(43).PropTypes.shape({}).isRequired
	}));

/***/ },
/* 172 */
/***/ function(module, exports, __webpack_require__) {

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	var babelPluginFlowReactPropTypes_proptype_ArrayShape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_ArrayShape || __webpack_require__(43).PropTypes.any;
	/**
	 * Utility functions for manipulating multi-item-shaped trees.
	 *
	 * Multi-items are trees! But we also often have other trees that are shaped
	 * like multi-items - for example, if we map a multi-item tree into a tree of
	 * renderer info and state, and then map that again into a tree of just the
	 * renderer nodes, like we do in MultiRenderer. See tree-types.js for further
	 * discussion.
	 *
	 * These functions enable us to manipulate generic multi-item-shaped trees,
	 * regardless of what type of data they contain at their leaves. You can use
	 * the mapper functions to transform a tree into another tree of the same
	 * shape, or to discover all the nodes of a particular type.
	 *
	 * We expose two simple mapper functions (mapContentNodes and mapHintNodes),
	 * and also a more complex interface for creating a mapping over all of a
	 * tree's node types simultaneously:
	 *
	 * `buildMapper()` returns a TreeMapper object that allows you to build your
	 * mapper object one node type at a time. Then, you can execute your mapping by
	 * calling the `mapTree` method.
	 *
	 * For example:
	 *     const renderers = buildMapper()
	 *         .setContentMapper(this.renderContentNode)
	 *         .setHintMapper(this.renderHintNode)
	 *         .setTagsMapper(this.renderTagsNode)
	 *         .setArrayMapper(this.hideSkippedQuestions)
	 *         .mapTree(tree, shape);
	 *
	 * This will copy the given tree, apply the given transformations to the
	 * content, hint, and array nodes respectively, and return the resulting tree.
	 *
	 * For node types whose mappers aren't specified, we default to the identity
	 * function. (This builder interface enables us to implement that default
	 * behavior in a provably type-safe way, while not requiring the call site to
	 * be aware of all the node types. Hooray!)
	 *
	 * The call to `setArrayMapper` must come last, because the array mapper's
	 * argument types depend on the other mappers' types. See ArrayMapper for more
	 * details.
	 *
	 * WARNING: These functions trust that the provided tree conforms to the
	 * provided shape. If not, behavior is undefined and may not respect the type
	 * signatures specified here.
	 */
	
	
	var babelPluginFlowReactPropTypes_proptype_TagsShape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_TagsShape || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_HintShape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_HintShape || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_ContentShape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_ContentShape || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_Shape = __webpack_require__(171).babelPluginFlowReactPropTypes_proptype_Shape || __webpack_require__(43).PropTypes.any;
	
	/**
	 * The sequence of edges that lead to a particular node in a Tree.
	 * Elements can be `string` to correspond to an ObjectNode key, or `number` to
	 * correspond to an ArrayNode index.
	 */
	var babelPluginFlowReactPropTypes_proptype_ObjectNode = __webpack_require__(188).babelPluginFlowReactPropTypes_proptype_ObjectNode || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_ArrayNode = __webpack_require__(188).babelPluginFlowReactPropTypes_proptype_ArrayNode || __webpack_require__(43).PropTypes.any;
	
	var babelPluginFlowReactPropTypes_proptype_Tree = __webpack_require__(188).babelPluginFlowReactPropTypes_proptype_Tree || __webpack_require__(43).PropTypes.any;
	
	/**
	 * These are function interfaces for mapping over various types of tree nodes.
	 *
	 * ArrayMapper is a bit more complicated than the leaf node mappers. It's
	 * executed in the context of a `mapTree` call, after we've finished mapping
	 * its child nodes, so the function has access to both the resulting array
	 * (with mapped elements) and the original array (with the original untouched
	 * elements).
	 *
	 * The ArrayMapper then has the opportunity to apply a final transformation to
	 * the resulting array, like filtering certain elements or (in the hacky
	 * MultiRenderer case) attaching a `renderHints` method to arrays of hint
	 * renderers :)
	 *
	 * This is why `TreeMapper#setArrayMapper` must be called last: ArrayMapper's
	 * types depend on the ContentMapper and HintMapper's types. And, since you can
	 * only specify one mapper at a time in this builder interface (which is
	 * necessary to provide default mappers in a type-safe way), you need your
	 * dependencies to already be in place by the time you call `setArrayMapper`.
	 * Otherwise, we'd have to set the ArrayMapper and *hope* that you *eventually*
	 * provide a compatible ContentMapper and HintMapper, which is difficult to
	 * prove at compile time.
	 *
	 * There's no ObjectMapper here, but not for any particular reason. We just
	 * don't have a use case for it yet, so we haven't built it yet.
	 */
	
	
	/**
	 * A TreeMapper is a collection of node mappers, which, together, compose the
	 * behavior for mapping over an entire tree.
	 *
	 * This serves as the interface for the two TreeMapper classes, including both
	 * the internal mapper properties that we care about, and the `mapTree`
	 * function that the call site will use.
	 */
	
	
	/**
	 * This is a TreeMapper that only has mappers specified for its leaf nodes; its
	 * array mapper is the identity function.
	 *
	 * This is the TreeMapper initially returned by `buildMapper`. It allows you to
	 * change the types of your ContentMapper and HintMapper, which is safe because
	 * none of the other mappers that depend on those types (aka ArrayMapper) have
	 * been specified yet. (Or, more specifically, the ArrayMapper is currently
	 * `identity`, which can trivially vary with the ContentMapper and HintMapper's
	 * types.)
	 *
	 * Once you call `setArrayMapper`, however, we move to the other class:
	 * TreeMapperForLeavesAndCollections.
	 */
	var TreeMapperJustForLeaves = function () {
	    function TreeMapperJustForLeaves(content, hint, tags) {
	        _classCallCheck(this, TreeMapperJustForLeaves);
	
	        this.content = content;
	        this.hint = hint;
	        this.tags = tags;
	        this.array = identity;
	    }
	
	    TreeMapperJustForLeaves.prototype.setContentMapper = function setContentMapper(newContentMapper) {
	        return new TreeMapperJustForLeaves(newContentMapper, this.hint, this.tags);
	    };
	
	    TreeMapperJustForLeaves.prototype.setHintMapper = function setHintMapper(newHintMapper) {
	        return new TreeMapperJustForLeaves(this.content, newHintMapper, this.tags);
	    };
	
	    TreeMapperJustForLeaves.prototype.setTagsMapper = function setTagsMapper(newTagsMapper) {
	        return new TreeMapperJustForLeaves(this.content, this.hint, newTagsMapper);
	    };
	
	    TreeMapperJustForLeaves.prototype.setArrayMapper = function setArrayMapper(newArrayMapper) {
	        return new TreeMapperForLeavesAndCollections(this.content, this.hint, this.tags, newArrayMapper);
	    };
	
	    TreeMapperJustForLeaves.prototype.mapTree = function mapTree(tree, shape) {
	        return _mapTree(tree, shape, [], this);
	    };
	
	    return TreeMapperJustForLeaves;
	}();
	
	/**
	 * This is a TreeMapper that already has an ArrayMapper specified, so its
	 * ContentMapper and HintMapper are now locked in.
	 */
	
	
	var TreeMapperForLeavesAndCollections = function () {
	    function TreeMapperForLeavesAndCollections(content, hint, tags, array) {
	        _classCallCheck(this, TreeMapperForLeavesAndCollections);
	
	        this.content = content;
	        this.hint = hint;
	        this.tags = tags;
	        this.array = array;
	    }
	
	    TreeMapperForLeavesAndCollections.prototype.setArrayMapper = function setArrayMapper(newArrayMapper) {
	        return new TreeMapperForLeavesAndCollections(this.content, this.hint, this.tags, newArrayMapper);
	    };
	
	    TreeMapperForLeavesAndCollections.prototype.mapTree = function mapTree(tree, shape) {
	        return _mapTree(tree, shape, [], this);
	    };
	
	    return TreeMapperForLeavesAndCollections;
	}();
	
	function identity(x) {
	    return x;
	}
	
	/**
	 * Return a new TreeMapper that will perform a no-op transformation on an input
	 * tree. To make it useful, chain any combination of `setContentMapper`,
	 * `setHintMapper`, `setTagMapper`, and `setArrayMapper` to specify
	 * transformations for the individual node types.
	 */
	function buildMapper() {
	    return new TreeMapperJustForLeaves(identity, identity, identity);
	}
	
	/**
	 * Copy the given tree, apply the corresponding transformation specified in the
	 * TreeMapper to each node, and return the resulting tree.
	 */
	function _mapTree(tree, shape, path, mappers) {
	    // We trust the shape of the multi-item to match the shape provided at
	    // runtime. Therefore, in each shape branch, we cast the node to `any` and
	    // reinterpret it as the expected node type.
	    if (shape.type === "content") {
	        var _content = tree;
	        return mappers.content(_content, shape, path);
	    } else if (shape.type === "hint") {
	        var _hint = tree;
	        return mappers.hint(_hint, shape, path);
	    } else if (shape.type === "tags") {
	        var _tags = tree;
	        return mappers.tags(_tags, shape, path);
	    } else if (shape.type === "array") {
	        var _array = tree;
	
	        if (!Array.isArray(_array)) {
	            throw new Error("Invalid object of type \"" + (typeof _array === "undefined" ? "undefined" : _typeof(_array)) + "\" found at path " + (["<root>"].concat(path).join(".") + ". Expected array."));
	        }
	
	        var elementShape = shape.elementShape;
	        var mappedElements = _array.map(function (inner, i) {
	            return _mapTree(inner, elementShape, path.concat(i), mappers);
	        });
	        return mappers.array(mappedElements, _array, shape, path);
	    } else if (shape.type === "object") {
	        var object = tree;
	
	        if (object && (typeof object === "undefined" ? "undefined" : _typeof(object)) !== "object") {
	            throw new Error("Invalid object of type \"" + (typeof object === "undefined" ? "undefined" : _typeof(object)) + "\" found at " + ("path " + ["<root>"].concat(path).join(".") + ". Expected ") + "\"object\" type.");
	        }
	
	        var valueShapes = shape.shape;
	        if (!valueShapes) {
	            throw new Error("Unexpected shape " + JSON.stringify(shape) + " at path " + (["<root>"].concat(path).join(".") + "."));
	        }
	        var newObject = {};
	        Object.keys(valueShapes).forEach(function (key) {
	            if (!(key in object)) {
	                throw new Error("Key \"" + key + "\" is missing from shape at path " + (["<root>"].concat(path).join(".") + "."));
	            }
	
	            newObject[key] = _mapTree(object[key], valueShapes[key], path.concat(key), mappers);
	        });
	        return newObject;
	    } else {
	        throw new Error("unexpected shape type " + shape.type);
	    }
	}
	
	module.exports = {
	    buildMapper: buildMapper
	};

/***/ },
/* 173 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* global i18n */
	
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	var Renderer = __webpack_require__(37);
	var PassageRef = __webpack_require__(136);
	var Util = __webpack_require__(17);
	
	var BaseRadio = __webpack_require__(186);
	
	var _require = __webpack_require__(52),
	    linterContextProps = _require.linterContextProps,
	    linterContextDefault = _require.linterContextDefault;
	
	var Radio = React.createClass({
	    displayName: "Radio",
	
	    propTypes: {
	        apiOptions: BaseRadio.propTypes.apiOptions,
	        choices: React.PropTypes.arrayOf(React.PropTypes.shape({
	            content: React.PropTypes.string.isRequired,
	            // Clues are called "rationales" in most other places but are
	            // left as "clue"s here to preserve legacy widget data.
	            clue: React.PropTypes.string,
	            correct: React.PropTypes.bool,
	            isNoneOfTheAbove: React.PropTypes.bool,
	            originalIndex: React.PropTypes.number.isRequired
	        }).isRequired).isRequired,
	
	        deselectEnabled: React.PropTypes.bool,
	        displayCount: React.PropTypes.any,
	        findWidgets: React.PropTypes.func,
	        multipleSelect: React.PropTypes.bool,
	        countChoices: React.PropTypes.bool,
	        numCorrect: React.PropTypes.number,
	        onChange: React.PropTypes.func.isRequired,
	
	        questionCompleted: React.PropTypes.bool,
	        reviewModeRubric: BaseRadio.propTypes.reviewModeRubric,
	        trackInteraction: React.PropTypes.func.isRequired,
	        // values is the legacy choiceState data format
	        values: React.PropTypes.arrayOf(React.PropTypes.bool),
	        choiceStates: React.PropTypes.arrayOf(React.PropTypes.shape({
	            // Indicates whether this choice is selected. (Inside
	            // BaseRadio, this is called `checked`.)
	            selected: React.PropTypes.bool,
	
	            // Indicates whether the user has "crossed out" this choice,
	            // meaning that they don't think it's correct. This value does
	            // not affect scoring or other behavior; it's just a note for
	            // the user's reference.
	            crossedOut: React.PropTypes.bool,
	
	            highlighted: React.PropTypes.bool,
	            rationaleShown: React.PropTypes.bool,
	            correctnessShown: React.PropTypes.bool,
	            readOnly: React.PropTypes.bool
	        }).isRequired),
	        linterContext: linterContextProps,
	        static: React.PropTypes.bool
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            choices: [{}],
	            displayCount: null,
	            multipleSelect: false,
	            countChoices: false,
	            deselectEnabled: false,
	            linterContext: linterContextDefault
	        };
	    },
	
	    _renderRenderer: function _renderRenderer(content) {
	        content = content || "";
	
	        var nextPassageRefId = 1;
	        var widgets = {};
	
	        var modContent = content.replace(/\{\{passage-ref (\d+) (\d+)(?: "([^"]*)")?\}\}/g, function (match, passageNum, refNum, summaryText) {
	            var widgetId = "passage-ref " + nextPassageRefId;
	            nextPassageRefId++;
	
	            widgets[widgetId] = {
	                type: "passage-ref",
	                graded: false,
	                options: {
	                    passageNumber: parseInt(passageNum),
	                    referenceNumber: parseInt(refNum),
	                    summaryText: summaryText
	                },
	                version: PassageRef.version
	            };
	
	            return "[[" + Util.snowman + " " + widgetId + "]]";
	        });
	
	        // alwaysUpdate={true} so that passage-refs findWidgets
	        // get called when the outer passage updates the renderer
	        // TODO(aria): This is really hacky
	        // We pass in a key here so that we avoid a semi-spurious
	        // react warning when the ChoiceNoneAbove renders a
	        // different renderer in the same place. Note this destroys
	        // state, but since all we're doing is outputting
	        // "None of the above", that is okay.
	        // TODO(mdr): Widgets inside this Renderer are not discoverable through
	        //     the parent Renderer's `findWidgets` function.
	        return React.createElement(Renderer, {
	            key: "choiceContentRenderer",
	            content: modContent,
	            widgets: widgets,
	            findExternalWidgets: this.props.findWidgets,
	            alwaysUpdate: true,
	            linterContext: this.props.linterContext
	        });
	    },
	
	    focus: function focus(i) {
	        return this.refs.baseRadio.focus(i);
	    },
	
	    // When `BaseRadio`'s `onChange` handler is called, indicating a change in
	    // our choices' state, we need to call our `onChange` handler in order to
	    // persist those changes in the item's Perseus state.
	    //
	    // So, given the new values for each choice, construct the new
	    // `choiceStates` objects, and pass them to `this.props.onChange`.
	    //
	    // `newValueLists` is an object with two keys: `checked` and `crossedOut`.
	    // Each contains an array of boolean values, specifying the new checked and
	    // crossed-out value of each choice.
	    //
	    // NOTE(mdr): This method expects to be auto-bound. If this component is
	    //     converted to an ES6 class, take care to auto-bind this method!
	    updateChoices: function updateChoices(newValueLists) {
	        var _props = this.props,
	            choiceStates = _props.choiceStates,
	            choices = _props.choices;
	
	        // Construct the baseline `choiceStates` objects. If this is the user's
	        // first interaction with the widget, we'll need to initialize them to
	        // new objects with all fields set to the default values. Otherwise, we
	        // should clone the old `choiceStates` objects, in preparation to
	        // mutate them.
	
	        var newChoiceStates = void 0;
	        if (choiceStates) {
	            newChoiceStates = choiceStates.map(function (state) {
	                return _extends({}, state);
	            });
	        } else {
	            newChoiceStates = choices.map(function () {
	                return {
	                    selected: false,
	                    crossedOut: false,
	                    highlighted: false,
	                    rationaleShown: false,
	                    correctnessShown: false,
	                    readOnly: false
	                };
	            });
	        }
	
	        // Mutate the new `choiceState` objects, according to the new `checked`
	        // and `crossedOut` values provided in `newValueLists`.
	        newChoiceStates.forEach(function (choiceState, i) {
	            choiceState.selected = newValueLists.checked[i];
	            choiceState.crossedOut = newValueLists.crossedOut[i];
	        });
	
	        this.props.onChange({ choiceStates: newChoiceStates });
	        this.props.trackInteraction();
	    },
	
	    getUserInput: function getUserInput() {
	        // Return checked inputs in the form {choicesSelected: [bool]}. (Dear
	        // future timeline implementers: this used to be {value: i} before
	        // multiple select was added)
	        if (this.props.choiceStates) {
	            var noneOfTheAboveIndex = null;
	            var noneOfTheAboveSelected = false;
	
	            var choiceStates = this.props.choiceStates;
	            var choicesSelected = choiceStates.map(function () {
	                return false;
	            });
	            var countChoices = this.props.countChoices;
	            var numCorrect = this.props.numCorrect;
	
	            for (var i = 0; i < choicesSelected.length; i++) {
	                var index = this.props.choices[i].originalIndex;
	                choicesSelected[index] = choiceStates[i].selected;
	
	                if (this.props.choices[i].isNoneOfTheAbove) {
	                    noneOfTheAboveIndex = index;
	
	                    if (choicesSelected[i]) {
	                        noneOfTheAboveSelected = true;
	                    }
	                }
	            }
	
	            return {
	                countChoices: countChoices,
	                choicesSelected: choicesSelected,
	                numCorrect: numCorrect,
	                noneOfTheAboveIndex: noneOfTheAboveIndex,
	                noneOfTheAboveSelected: noneOfTheAboveSelected
	            };
	            // Support legacy choiceState implementation
	        } else if (this.props.values) {
	            var _noneOfTheAboveIndex = null;
	            var _noneOfTheAboveSelected = false;
	
	            var values = this.props.values.slice();
	            var _countChoices = this.props.countChoices;
	            var _numCorrect = this.props.numCorrect;
	
	            for (var _i = 0; _i < this.props.values.length; _i++) {
	                var _index = this.props.choices[_i].originalIndex;
	                values[_index] = this.props.values[_i];
	
	                if (this.props.choices[_i].isNoneOfTheAbove) {
	                    _noneOfTheAboveIndex = _index;
	                    if (values[_i]) {
	                        _noneOfTheAboveSelected = true;
	                    }
	                }
	            }
	            return {
	                choicesSelected: values,
	                noneOfTheAboveIndex: _noneOfTheAboveIndex,
	                noneOfTheAboveSelected: _noneOfTheAboveSelected,
	                countChoices: _countChoices,
	                numCorrect: _numCorrect
	            };
	        } else {
	            // Nothing checked
	            return {
	                choicesSelected: _.map(this.props.choices, function () {
	                    return false;
	                })
	            };
	        }
	    },
	
	    simpleValidate: function simpleValidate(rubric) {
	        return Radio.validate(this.getUserInput(), rubric);
	    },
	
	    enforceOrdering: function enforceOrdering(choices) {
	        var content = _.pluck(choices, "content");
	        if (_.isEqual(content, [i18n._("False"), i18n._("True")]) || _.isEqual(content, [i18n._("No"), i18n._("Yes")])) {
	            return [choices[1]].concat([choices[0]]);
	        }
	        return choices;
	    },
	
	    /**
	     * Turn on rationale display for the currently selected choices. Note that
	     * this leaves rationales on for choices that are already showing
	     * rationales.
	     */
	    showRationalesForCurrentlySelectedChoices: function showRationalesForCurrentlySelectedChoices(rubric) {
	        if (this.props.choiceStates) {
	            var score = this.simpleValidate(rubric);
	            var widgetCorrect = score.type === "points" && score.total === score.earned;
	
	            var newStates = this.props.choiceStates.map(function (state) {
	                return _extends({}, state, {
	                    highlighted: state.selected,
	                    // If the choice is selected, show the rationale now
	                    rationaleShown: state.selected ||
	                    // If the choice already had a rationale, keep it shown
	                    state.rationaleShown ||
	                    // If the widget is correctly answered, show the rationale
	                    // for all the choices
	                    widgetCorrect,
	                    // We use the same behavior for the readOnly flag as for
	                    // rationaleShown, but we keep it separate in case other
	                    // behaviors want to disable choices without showing rationales.
	                    readOnly: state.selected || state.readOnly || widgetCorrect,
	                    correctnessShown: state.selected || state.correctnessShown
	                });
	            });
	
	            this.props.onChange({
	                choiceStates: newStates
	            }, null, // cb
	            true // silent
	            );
	        }
	    },
	
	
	    /**
	     * Deselects any currently-selected choices that are not correct choices.
	     */
	    deselectIncorrectSelectedChoices: function deselectIncorrectSelectedChoices() {
	        var _this = this;
	
	        if (this.props.choiceStates) {
	            var newStates = this.props.choiceStates.map(function (state, i) {
	                return _extends({}, state, {
	                    selected: state.selected && !!_this.props.choices[i].correct,
	                    highlighted: false
	                });
	            });
	
	            this.props.onChange({
	                choiceStates: newStates
	            }, null, // cb
	            false // silent
	            );
	        }
	    },
	
	
	    render: function render() {
	        var _this2 = this;
	
	        var choices = this.props.choices;
	        var choiceStates = void 0;
	        if (this.props.static) {
	            choiceStates = _.map(choices, function (val) {
	                return {
	                    selected: val.correct,
	                    crossedOut: val.crossedOut,
	                    readOnly: true,
	                    highlighted: false,
	                    rationaleShown: true,
	                    correctnessShown: true
	                };
	            });
	        } else if (this.props.choiceStates) {
	            choiceStates = this.props.choiceStates;
	        } else if (this.props.values) {
	            // Support legacy choiceStates implementation
	            choiceStates = _.map(this.props.values, function (val) {
	                return {
	                    selected: val,
	                    crossedOut: false,
	                    readOnly: false,
	                    highlighted: false,
	                    rationaleShown: false,
	                    correctnessShown: false
	                };
	            });
	        } else {
	            choiceStates = _.map(choices, function () {
	                return {
	                    selected: false,
	                    crossedOut: false,
	                    readOnly: false,
	                    highlighted: false,
	                    rationaleShown: false,
	                    correctnessShown: false
	                };
	            });
	        }
	
	        choices = _.map(choices, function (choice, i) {
	            var content = choice.isNoneOfTheAbove && !choice.content ? // we use i18n._ instead of $_ here because the content
	            // sent to a renderer needs to be a string, not a react
	            // node (/renderable/fragment).
	            i18n._("None of the above") : choice.content;
	
	            var _choiceStates$i = choiceStates[i],
	                selected = _choiceStates$i.selected,
	                crossedOut = _choiceStates$i.crossedOut,
	                rationaleShown = _choiceStates$i.rationaleShown,
	                correctnessShown = _choiceStates$i.correctnessShown,
	                readOnly = _choiceStates$i.readOnly,
	                highlighted = _choiceStates$i.highlighted;
	
	
	            var reviewChoice = _this2.props.reviewModeRubric && _this2.props.reviewModeRubric.choices[i];
	
	            return {
	                content: _this2._renderRenderer(content),
	                checked: selected,
	                // Current versions of the radio widget always pass in the
	                // "correct" value through the choices. Old serialized state
	                // for radio widgets doesn't have this though, so we have to
	                // pull the correctness out of the review mode rubric. This
	                // only works because all of the places we use
	                // `restoreSerializedState()` also turn on reviewMode, but is
	                // fine for now.
	                // TODO(emily): Come up with a more comprehensive way to solve
	                // this sort of "serialized state breaks when internal
	                // structure changes" problem.
	                correct: typeof choice.correct === "undefined" ? !!reviewChoice && reviewChoice.correct : choice.correct,
	                disabled: readOnly,
	                hasRationale: !!choice.clue,
	                rationale: _this2._renderRenderer(choice.clue),
	                showRationale: rationaleShown,
	                showCorrectness: correctnessShown,
	                isNoneOfTheAbove: choice.isNoneOfTheAbove,
	                revealNoneOfTheAbove: _this2.props.questionCompleted && selected,
	                crossedOut: crossedOut,
	                highlighted: highlighted
	            };
	        });
	        choices = this.enforceOrdering(choices);
	
	        return React.createElement(BaseRadio, {
	            ref: "baseRadio",
	            labelWrap: true,
	            multipleSelect: this.props.multipleSelect,
	            countChoices: this.props.countChoices,
	            numCorrect: this.props.numCorrect,
	            choices: choices,
	            onChange: this.updateChoices,
	            reviewModeRubric: this.props.reviewModeRubric,
	            deselectEnabled: this.props.deselectEnabled,
	            apiOptions: this.props.apiOptions
	        });
	    }
	});
	
	_.extend(Radio, {
	    validate: function validate(state, rubric) {
	        var numSelected = _.reduce(state.choicesSelected, function (sum, selected) {
	            return sum + (selected ? 1 : 0);
	        }, 0);
	
	        if (numSelected === 0) {
	            return {
	                type: "invalid",
	                message: null
	            };
	        } else if (state.countChoices && numSelected !== state.numCorrect) {
	            return {
	                type: "invalid",
	                message: i18n._("Please choose the correct number of answers.")
	            };
	            // If NOTA and some other answer are checked, ...
	        } else if (state.noneOfTheAboveSelected && numSelected > 1) {
	            return {
	                type: "invalid",
	                message: i18n._("'None of the above' may not be selected " + "when other answers are selected.")
	            };
	        } else {
	            /* jshint -W018 */
	            var correct = _.all(state.choicesSelected, function (selected, i) {
	                var isCorrect = void 0;
	                if (state.noneOfTheAboveIndex === i) {
	                    isCorrect = _.all(rubric.choices, function (choice, j) {
	                        return i === j || !choice.correct;
	                    });
	                } else {
	                    isCorrect = !!rubric.choices[i].correct;
	                }
	                return isCorrect === selected;
	            });
	            /* jshint +W018 */
	
	            return {
	                type: "points",
	                earned: correct ? 1 : 0,
	                total: 1,
	                message: null
	            };
	        }
	    }
	});
	
	module.exports = Radio;

/***/ },
/* 174 */
/***/ function(module, exports, __webpack_require__) {

	// {K1: V1, K2: V2, ...} -> [[K1, V1], [K2, V2]]
	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	    value: true
	});
	
	var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();
	
	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var objectToPairs = function objectToPairs(obj) {
	    return Object.keys(obj).map(function (key) {
	        return [key, obj[key]];
	    });
	};
	
	exports.objectToPairs = objectToPairs;
	// [[K1, V1], [K2, V2]] -> {K1: V1, K2: V2, ...}
	var pairsToObject = function pairsToObject(pairs) {
	    var result = {};
	    pairs.forEach(function (_ref) {
	        var _ref2 = _slicedToArray(_ref, 2);
	
	        var key = _ref2[0];
	        var val = _ref2[1];
	
	        result[key] = val;
	    });
	    return result;
	};
	
	var mapObj = function mapObj(obj, fn) {
	    return pairsToObject(objectToPairs(obj).map(fn));
	};
	
	exports.mapObj = mapObj;
	// Flattens an array one level
	// [[A], [B, C, [D]]] -> [A, B, C, [D]]
	var flatten = function flatten(list) {
	    return list.reduce(function (memo, x) {
	        return memo.concat(x);
	    }, []);
	};
	
	exports.flatten = flatten;
	var UPPERCASE_RE = /([A-Z])/g;
	var MS_RE = /^ms-/;
	
	var kebabify = function kebabify(string) {
	    return string.replace(UPPERCASE_RE, '-$1').toLowerCase();
	};
	var kebabifyStyleName = function kebabifyStyleName(string) {
	    return kebabify(string).replace(MS_RE, '-ms-');
	};
	
	exports.kebabifyStyleName = kebabifyStyleName;
	var recursiveMerge = function recursiveMerge(a, b) {
	    // TODO(jlfwong): Handle malformed input where a and b are not the same
	    // type.
	
	    if (typeof a !== 'object') {
	        return b;
	    }
	
	    var ret = _extends({}, a);
	
	    Object.keys(b).forEach(function (key) {
	        if (ret.hasOwnProperty(key)) {
	            ret[key] = recursiveMerge(a[key], b[key]);
	        } else {
	            ret[key] = b[key];
	        }
	    });
	
	    return ret;
	};
	
	exports.recursiveMerge = recursiveMerge;
	/**
	 * CSS properties which accept numbers but are not in units of "px".
	 * Taken from React's CSSProperty.js
	 */
	var isUnitlessNumber = {
	    animationIterationCount: true,
	    borderImageOutset: true,
	    borderImageSlice: true,
	    borderImageWidth: true,
	    boxFlex: true,
	    boxFlexGroup: true,
	    boxOrdinalGroup: true,
	    columnCount: true,
	    flex: true,
	    flexGrow: true,
	    flexPositive: true,
	    flexShrink: true,
	    flexNegative: true,
	    flexOrder: true,
	    gridRow: true,
	    gridColumn: true,
	    fontWeight: true,
	    lineClamp: true,
	    lineHeight: true,
	    opacity: true,
	    order: true,
	    orphans: true,
	    tabSize: true,
	    widows: true,
	    zIndex: true,
	    zoom: true,
	
	    // SVG-related properties
	    fillOpacity: true,
	    floodOpacity: true,
	    stopOpacity: true,
	    strokeDasharray: true,
	    strokeDashoffset: true,
	    strokeMiterlimit: true,
	    strokeOpacity: true,
	    strokeWidth: true
	};
	
	/**
	 * Taken from React's CSSProperty.js
	 *
	 * @param {string} prefix vendor-specific prefix, eg: Webkit
	 * @param {string} key style name, eg: transitionDuration
	 * @return {string} style name prefixed with `prefix`, properly camelCased, eg:
	 * WebkitTransitionDuration
	 */
	function prefixKey(prefix, key) {
	    return prefix + key.charAt(0).toUpperCase() + key.substring(1);
	}
	
	/**
	 * Support style names that may come passed in prefixed by adding permutations
	 * of vendor prefixes.
	 * Taken from React's CSSProperty.js
	 */
	var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
	
	// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
	// infinite loop, because it iterates over the newly added props too.
	// Taken from React's CSSProperty.js
	Object.keys(isUnitlessNumber).forEach(function (prop) {
	    prefixes.forEach(function (prefix) {
	        isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
	    });
	});
	
	var stringifyValue = function stringifyValue(key, prop) {
	    if (typeof prop === "number") {
	        if (isUnitlessNumber[key]) {
	            return "" + prop;
	        } else {
	            return prop + "px";
	        }
	    } else {
	        return prop;
	    }
	};
	
	exports.stringifyValue = stringifyValue;
	/**
	 * JS Implementation of MurmurHash2
	 *
	 * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
	 * @see http://github.com/garycourt/murmurhash-js
	 * @author <a href="mailto:aappleby@gmail.com">Austin Appleby</a>
	 * @see http://sites.google.com/site/murmurhash/
	 *
	 * @param {string} str ASCII only
	 * @return {string} Base 36 encoded hash result
	 */
	function murmurhash2_32_gc(str) {
	    var l = str.length;
	    var h = l;
	    var i = 0;
	    var k = undefined;
	
	    while (l >= 4) {
	        k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
	
	        k = (k & 0xffff) * 0x5bd1e995 + (((k >>> 16) * 0x5bd1e995 & 0xffff) << 16);
	        k ^= k >>> 24;
	        k = (k & 0xffff) * 0x5bd1e995 + (((k >>> 16) * 0x5bd1e995 & 0xffff) << 16);
	
	        h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16) ^ k;
	
	        l -= 4;
	        ++i;
	    }
	
	    switch (l) {
	        case 3:
	            h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
	        case 2:
	            h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
	        case 1:
	            h ^= str.charCodeAt(i) & 0xff;
	            h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16);
	    }
	
	    h ^= h >>> 13;
	    h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16);
	    h ^= h >>> 15;
	
	    return (h >>> 0).toString(36);
	}
	
	// Hash a javascript object using JSON.stringify. This is very fast, about 3
	// microseconds on my computer for a sample object:
	// http://jsperf.com/test-hashfnv32a-hash/5
	//
	// Note that this uses JSON.stringify to stringify the objects so in order for
	// this to produce consistent hashes browsers need to have a consistent
	// ordering of objects. Ben Alpert says that Facebook depends on this, so we
	// can probably depend on this too.
	var hashObject = function hashObject(object) {
	    return murmurhash2_32_gc(JSON.stringify(object));
	};
	
	exports.hashObject = hashObject;
	var IMPORTANT_RE = /^([^:]+:.*?)( !important)?;$/;
	
	// Given a single style rule string like "a: b;", adds !important to generate
	// "a: b !important;".
	var importantify = function importantify(string) {
	    return string.replace(IMPORTANT_RE, function (_, base, important) {
	        return base + " !important;";
	    });
	};
	exports.importantify = importantify;

/***/ },
/* 175 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	    value: true
	});
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _asap = __webpack_require__(297);
	
	var _asap2 = _interopRequireDefault(_asap);
	
	var _generate = __webpack_require__(258);
	
	var _util = __webpack_require__(174);
	
	// The current <style> tag we are inserting into, or null if we haven't
	// inserted anything yet. We could find this each time using
	// `document.querySelector("style[data-aphrodite"])`, but holding onto it is
	// faster.
	var styleTag = null;
	
	// Inject a string of styles into a <style> tag in the head of the document. This
	// will automatically create a style tag and then continue to use it for
	// multiple injections. It will also use a style tag with the `data-aphrodite`
	// tag on it if that exists in the DOM. This could be used for e.g. reusing the
	// same style tag that server-side rendering inserts.
	var injectStyleTag = function injectStyleTag(cssContents) {
	    if (styleTag == null) {
	        // Try to find a style tag with the `data-aphrodite` attribute first.
	        styleTag = document.querySelector("style[data-aphrodite]");
	
	        // If that doesn't work, generate a new style tag.
	        if (styleTag == null) {
	            // Taken from
	            // http://stackoverflow.com/questions/524696/how-to-create-a-style-tag-with-javascript
	            var head = document.head || document.getElementsByTagName('head')[0];
	            styleTag = document.createElement('style');
	
	            styleTag.type = 'text/css';
	            styleTag.setAttribute("data-aphrodite", "");
	            head.appendChild(styleTag);
	        }
	    }
	
	    if (styleTag.styleSheet) {
	        styleTag.styleSheet.cssText += cssContents;
	    } else {
	        styleTag.appendChild(document.createTextNode(cssContents));
	    }
	};
	
	// Custom handlers for stringifying CSS values that have side effects
	// (such as fontFamily, which can cause @font-face rules to be injected)
	var stringHandlers = {
	    // With fontFamily we look for objects that are passed in and interpret
	    // them as @font-face rules that we need to inject. The value of fontFamily
	    // can either be a string (as normal), an object (a single font face), or
	    // an array of objects and strings.
	    fontFamily: function fontFamily(val) {
	        if (Array.isArray(val)) {
	            return val.map(fontFamily).join(",");
	        } else if (typeof val === "object") {
	            injectStyleOnce(val.fontFamily, "@font-face", [val], false);
	            return '"' + val.fontFamily + '"';
	        } else {
	            return val;
	        }
	    },
	
	    // With animationName we look for an object that contains keyframes and
	    // inject them as an `@keyframes` block, returning a uniquely generated
	    // name. The keyframes object should look like
	    //  animationName: {
	    //    from: {
	    //      left: 0,
	    //      top: 0,
	    //    },
	    //    '50%': {
	    //      left: 15,
	    //      top: 5,
	    //    },
	    //    to: {
	    //      left: 20,
	    //      top: 20,
	    //    }
	    //  }
	    // TODO(emily): `stringHandlers` doesn't let us rename the key, so I have
	    // to use `animationName` here. Improve that so we can call this
	    // `animation` instead of `animationName`.
	    animationName: function animationName(val) {
	        if (typeof val !== "object") {
	            return val;
	        }
	
	        // Generate a unique name based on the hash of the object. We can't
	        // just use the hash because the name can't start with a number.
	        // TODO(emily): this probably makes debugging hard, allow a custom
	        // name?
	        var name = 'keyframe_' + (0, _util.hashObject)(val);
	
	        // Since keyframes need 3 layers of nesting, we use `generateCSS` to
	        // build the inner layers and wrap it in `@keyframes` ourselves.
	        var finalVal = '@keyframes ' + name + '{';
	        Object.keys(val).forEach(function (key) {
	            finalVal += (0, _generate.generateCSS)(key, [val[key]], stringHandlers, false);
	        });
	        finalVal += '}';
	
	        injectGeneratedCSSOnce(name, finalVal);
	
	        return name;
	    }
	};
	
	// This is a map from Aphrodite's generated class names to `true` (acting as a
	// set of class names)
	var alreadyInjected = {};
	
	// This is the buffer of styles which have not yet been flushed.
	var injectionBuffer = "";
	
	// A flag to tell if we are already buffering styles. This could happen either
	// because we scheduled a flush call already, so newly added styles will
	// already be flushed, or because we are statically buffering on the server.
	var isBuffering = false;
	
	var injectGeneratedCSSOnce = function injectGeneratedCSSOnce(key, generatedCSS) {
	    if (!alreadyInjected[key]) {
	        if (!isBuffering) {
	            // We should never be automatically buffering on the server (or any
	            // place without a document), so guard against that.
	            if (typeof document === "undefined") {
	                throw new Error("Cannot automatically buffer without a document");
	            }
	
	            // If we're not already buffering, schedule a call to flush the
	            // current styles.
	            isBuffering = true;
	            (0, _asap2['default'])(flushToStyleTag);
	        }
	
	        injectionBuffer += generatedCSS;
	        alreadyInjected[key] = true;
	    }
	};
	
	var injectStyleOnce = function injectStyleOnce(key, selector, definitions, useImportant) {
	    if (!alreadyInjected[key]) {
	        var generated = (0, _generate.generateCSS)(selector, definitions, stringHandlers, useImportant);
	
	        injectGeneratedCSSOnce(key, generated);
	    }
	};
	
	exports.injectStyleOnce = injectStyleOnce;
	var reset = function reset() {
	    injectionBuffer = "";
	    alreadyInjected = {};
	    isBuffering = false;
	    styleTag = null;
	};
	
	exports.reset = reset;
	var startBuffering = function startBuffering() {
	    if (isBuffering) {
	        throw new Error("Cannot buffer while already buffering");
	    }
	    isBuffering = true;
	};
	
	exports.startBuffering = startBuffering;
	var flushToString = function flushToString() {
	    isBuffering = false;
	    var ret = injectionBuffer;
	    injectionBuffer = "";
	    return ret;
	};
	
	exports.flushToString = flushToString;
	var flushToStyleTag = function flushToStyleTag() {
	    var cssContent = flushToString();
	    if (cssContent.length > 0) {
	        injectStyleTag(cssContent);
	    }
	};
	
	exports.flushToStyleTag = flushToStyleTag;
	var getRenderedClassNames = function getRenderedClassNames() {
	    return Object.keys(alreadyInjected);
	};
	
	exports.getRenderedClassNames = getRenderedClassNames;
	var addRenderedClassNames = function addRenderedClassNames(classNames) {
	    classNames.forEach(function (className) {
	        alreadyInjected[className] = true;
	    });
	};
	exports.addRenderedClassNames = addRenderedClassNames;

/***/ },
/* 176 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A wrapper around react-components/info-tip.jsx that can be rendered on the
	 * server without causing a checksum mismatch on the client.
	 * (RCSS generates classnames with a randomSuffix, which ensures that any
	 * two sets of generated classnames will not match.)
	 */
	
	var React = __webpack_require__(43);
	
	var ReactComponentsInfoTip = __webpack_require__(259);
	
	var InfoTip = React.createClass({
	    displayName: "InfoTip",
	
	    getInitialState: function getInitialState() {
	        return {
	            didMount: false
	        };
	    },
	
	    componentDidMount: function componentDidMount() {
	        /* eslint-disable react/no-did-mount-set-state */
	        this.setState({ didMount: true });
	        /* eslint-enable react/no-did-mount-set-state */
	    },
	
	    render: function render() {
	        if (this.state.didMount) {
	            return React.createElement(ReactComponentsInfoTip, this.props);
	        } else {
	            return React.createElement("div", null);
	        }
	    }
	});
	
	module.exports = InfoTip;

/***/ },
/* 177 */
/***/ function(module, exports, __webpack_require__) {

	var StyleSheet = __webpack_require__(79).StyleSheet;
	
	var button = StyleSheet.create({
	    buttonStyle: {
	        backgroundColor: 'white',
	        border: '1px solid #ccc',
	        borderLeft: '0',
	        cursor: 'pointer',
	        margin: '0',
	        padding: '5px 10px',
	        position: 'relative', // for hover
	
	        ':first-child': {
	            borderLeft: '1px solid #ccc',
	            borderTopLeftRadius: '3px',
	            borderBottomLeftRadius: '3px'
	        },
	
	        ':last-child': {
	            borderRight: '1px solid #ccc',
	            borderTopRightRadius: '3px',
	            borderBottomRightRadius: '3px'
	        },
	
	        ':hover': {
	            backgroundColor: '#ccc'
	        },
	
	        ':focus': {
	            zIndex: '2'
	        }
	    },
	
	    selectedStyle: {
	        backgroundColor: '#ddd'
	    }
	});
	
	module.exports = {
	    button: button
	};

/***/ },
/* 178 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	/**
	 * For math rendered using KaTex and/or MathJax. Use me like <TeX>2x + 3</TeX>.
	 */
	/* global katex, MathJax, Khan */
	// TODO(joel) - require MathJax / katex so they don't have to be global
	
	var PureRenderMixin = __webpack_require__(270);
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var katexA11y = __webpack_require__(261);
	
	var pendingScripts = [];
	var pendingCallbacks = [];
	var needsProcess = false;
	
	var process = function process(script, callback) {
	    pendingScripts.push(script);
	    pendingCallbacks.push(callback);
	    if (!needsProcess) {
	        needsProcess = true;
	        setTimeout(doProcess, 0);
	    }
	};
	
	var loadMathJax = function loadMathJax(callback) {
	    if (typeof MathJax !== "undefined") {
	        callback();
	    } else if (typeof Khan !== "undefined" && Khan.mathJaxLoaded) {
	        Khan.mathJaxLoaded.then(callback);
	    } else {
	        throw new Error("MathJax wasn't loaded before it was needed by <TeX/>");
	    }
	};
	
	var doProcess = function doProcess() {
	    loadMathJax(function () {
	        MathJax.Hub.Queue(function () {
	            var oldElementScripts = MathJax.Hub.elementScripts;
	            MathJax.Hub.elementScripts = function (element) {
	                return pendingScripts;
	            };
	
	            try {
	                return MathJax.Hub.Process(null, function () {
	                    // Trigger all of the pending callbacks before clearing them
	                    // out.
	                    for (var _iterator = pendingCallbacks, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
	                        var _ref;
	
	                        if (_isArray) {
	                            if (_i >= _iterator.length) break;
	                            _ref = _iterator[_i++];
	                        } else {
	                            _i = _iterator.next();
	                            if (_i.done) break;
	                            _ref = _i.value;
	                        }
	
	                        var callback = _ref;
	
	                        callback();
	                    }
	
	                    pendingScripts = [];
	                    pendingCallbacks = [];
	                    needsProcess = false;
	                });
	            } catch (e) {
	                // IE8 requires `catch` in order to use `finally`
	                throw e;
	            } finally {
	                MathJax.Hub.elementScripts = oldElementScripts;
	            }
	        });
	    });
	};
	
	// Make content only visible to screen readers.
	// Both collegeboard.org and Bootstrap 3 use this exact implementation.
	var srOnly = {
	    border: 0,
	    clip: "rect(0,0,0,0)",
	    height: "1px",
	    margin: "-1px",
	    overflow: "hidden",
	    padding: 0,
	    position: "absolute",
	    width: "1px"
	};
	
	var TeX = React.createClass({
	    displayName: 'TeX',
	
	    propTypes: {
	        children: React.PropTypes.node,
	        onClick: React.PropTypes.func,
	        onRender: React.PropTypes.func,
	        style: React.PropTypes.any
	    },
	
	    mixins: [PureRenderMixin],
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            // Called after math is rendered or re-rendered
	            onRender: function onRender() {},
	            onClick: null
	        };
	    },
	
	    componentDidMount: function componentDidMount() {
	        var _this = this;
	
	        this._root = ReactDOM.findDOMNode(this);
	
	        if (this.refs.katex.childElementCount > 0) {
	            // If we already rendered katex in the render function, we don't
	            // need to render anything here.
	            this.props.onRender(this._root);
	            return;
	        }
	
	        var text = this.props.children;
	
	        this.setScriptText(text);
	        process(this.script, function () {
	            return _this.props.onRender(_this._root);
	        });
	    },
	
	    componentDidUpdate: function componentDidUpdate(prevProps, prevState) {
	        var _this2 = this;
	
	        // If we already rendered katex in the render function, we don't
	        // need to render anything here.
	        if (this.refs.katex.childElementCount > 0) {
	            if (this.script) {
	                // If we successfully rendered KaTeX, check if there's
	                // lingering MathJax from the last render, and if so remove it.
	                loadMathJax(function () {
	                    var jax = MathJax.Hub.getJaxFor(_this2.script);
	                    if (jax) {
	                        jax.Remove();
	                    }
	                });
	            }
	
	            this.props.onRender();
	            return;
	        }
	
	        var newText = this.props.children;
	
	        if (this.script) {
	            loadMathJax(function () {
	                MathJax.Hub.Queue(function () {
	                    var jax = MathJax.Hub.getJaxFor(_this2.script);
	                    if (jax) {
	                        return jax.Text(newText, _this2.props.onRender);
	                    } else {
	                        _this2.setScriptText(newText);
	                        process(_this2.script, _this2.props.onRender);
	                    }
	                });
	            });
	        } else {
	            this.setScriptText(newText);
	            process(this.script, this.props.onRender);
	        }
	    },
	
	    componentWillUnmount: function componentWillUnmount() {
	        var _this3 = this;
	
	        if (this.script) {
	            loadMathJax(function () {
	                var jax = MathJax.Hub.getJaxFor(_this3.script);
	                if (jax) {
	                    jax.Remove();
	                }
	            });
	        }
	    },
	
	    setScriptText: function setScriptText(text) {
	        if (!this.script) {
	            this.script = document.createElement("script");
	            this.script.type = "math/tex";
	            ReactDOM.findDOMNode(this.refs.mathjax).appendChild(this.script);
	        }
	        if ("text" in this.script) {
	            // IE8, etc
	            this.script.text = text;
	        } else {
	            this.script.textContent = text;
	        }
	    },
	
	    render: function render() {
	        var katexHtml = null;
	        try {
	            katexHtml = {
	                __html: katex.renderToString(this.props.children)
	            };
	        } catch (e) {
	            /* jshint -W103 */
	            if (e.__proto__ !== katex.ParseError.prototype) {
	                /* jshint +W103 */
	                throw e;
	            }
	        }
	
	        var katexA11yHtml = null;
	        if (katexHtml) {
	            try {
	                katexA11yHtml = {
	                    __html: katexA11y.renderString(this.props.children)
	                };
	            } catch (e) {
	                // Nothing
	            }
	        }
	
	        return React.createElement(
	            'span',
	            {
	                style: this.props.style,
	                onClick: this.props.onClick
	            },
	            React.createElement('span', { ref: 'mathjax' }),
	            React.createElement('span', {
	                ref: 'katex',
	                dangerouslySetInnerHTML: katexHtml,
	                'aria-hidden': !!katexHtml && !!katexA11yHtml
	            }),
	            React.createElement('span', {
	                dangerouslySetInnerHTML: katexA11yHtml,
	                style: srOnly
	            })
	        );
	    }
	});
	
	module.exports = TeX;

/***/ },
/* 179 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * This component renders "lint" nodes in a markdown parse tree. Lint nodes
	 * are inserted into the tree by the Gorgon linter (see src/gorgon/gorgon.js).
	 *
	 * This component serves multiple purposes
	 *
	 * 1) It renders a small circle in the right margin to indicate that there
	 * is lint on (or near) that line.
	 *
	 * 2) The area around the circle is hoverable: when the mouse moves over it
	 * the linty content is highlighted and a tooltip is displayed that explains
	 * what the problem is.
	 *
	 * 3) The hoverable area is also an HTML <a> tag. Clicking on it opens
	 * a new tab and links to additional details about the specific lint rule.
	 *
	 * The CSS required to position the circles in the right margin is tricky
	 * and it does not always work perfectly. When lint occurs on a block element
	 * that has a right margin (like anything blockquoted) the circle will appear
	 * to the left of where it belongs.  And if there is more
	 **/
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var constants = __webpack_require__(77);
	var InlineIcon = __webpack_require__(48);
	
	var exclamationIcon = {
	    path: "M6 11a1 1 0 1 1 0-2 1 1 0 0 1 0 2zm0-9a1 1 0 0 1 1 1v4a1 1 0 1 1-2 0V3a1 1 0 0 1 1-1z", // eslint-disable-line max-len
	    height: 12,
	    width: 12
	};
	
	var Lint = React.createClass({
	    displayName: "Lint",
	
	    propTypes: {
	        // The children are the linty content we're highlighting
	        children: React.PropTypes.node,
	        // Inline lint is highlighted differently than block lint.
	        inline: React.PropTypes.bool,
	        // This is the text that appears in the tooltip
	        message: React.PropTypes.string.isRequired,
	        // This is used as the fragment id (hash) in the URL of the link
	        ruleName: React.PropTypes.string.isRequired,
	        // Lint warnings inside tables are handled specially
	        insideTable: React.PropTypes.bool.isRequired,
	        // How important this lint message is for the editor. Severity goes
	        // from 1 (indicating an error) to 4 (offline reporting only)
	        severity: React.PropTypes.number
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            tooltipAbove: true
	        };
	    },
	
	    componentDidMount: function componentDidMount() {
	        this._positionTimeout = window.setTimeout(this.getPosition);
	    },
	
	    componentWillUnmount: function componentWillUnmount() {
	        window.clearTimeout(this._positionTimeout);
	    },
	
	    // We can't call setState in componentDidMount without risking a render
	    // thrash, and we can't call getBoundingClientRect in render, so we
	    // borrow a timeout approach from learnstorm-dashboard.jsx and set our
	    // state once the component has mounted and we can get what we need.
	    getPosition: function getPosition() {
	        var rect = ReactDOM.findDOMNode(this).getBoundingClientRect();
	        // TODO(scottgrant): This is a magic number! We don't know the size
	        // of the tooltip at this point, so we're arbitrarily choosing a
	        // point at which to flip the tooltip's position.
	        this.setState({ tooltipAbove: rect.top > 100 });
	    },
	
	    // Render the <a> element that holds the indicator icon and the tooltip
	    // We pass different styles for the inline and block cases
	    renderLink: function renderLink(style) {
	        var tooltipAbove = this.state.tooltipAbove;
	
	        var severityStyle = void 0;
	        var warningText = void 0;
	        var warningTextStyle = void 0;
	        if (this.props.severity === 1) {
	            severityStyle = styles.indicatorError;
	            warningText = "Error";
	            warningTextStyle = styles.publishBlockingError;
	        } else if (this.props.severity === 2) {
	            severityStyle = styles.indicatorWarning;
	            warningText = "Warning";
	            warningTextStyle = styles.warning;
	        } else {
	            severityStyle = styles.indicatorGuideline;
	            warningText = "Recommendation";
	            warningTextStyle = styles.warning;
	        }
	
	        return React.createElement(
	            "a",
	            {
	                href: "https://khanacademy.org/r/linter-rules#" + this.props.ruleName,
	                target: "lint-help-window",
	                className: css(style)
	            },
	            React.createElement(
	                "span",
	                { className: css(styles.indicator, severityStyle) },
	                this.props.severity === 1 && React.createElement(InlineIcon, exclamationIcon)
	            ),
	            React.createElement(
	                "div",
	                {
	                    className: css(styles.tooltip, tooltipAbove && styles.tooltipAbove)
	                },
	                this.props.message.split("\n\n").map(function (m, i) {
	                    return React.createElement(
	                        "p",
	                        { key: i, className: css(styles.tooltipParagraph) },
	                        React.createElement(
	                            "span",
	                            { className: css(warningTextStyle) },
	                            warningText,
	                            ":",
	                            " "
	                        ),
	                        m
	                    );
	                }),
	                React.createElement("div", {
	                    className: css(styles.tail, tooltipAbove && styles.tailAbove)
	                })
	            )
	        );
	    },
	
	    // The main render method surrounds linty content with a block or
	    // inline container and the link element that displays the indicator
	    // and holds the tooltip.
	    render: function render() {
	        if (this.props.insideTable) {
	            // If we're inside a table, then linty nodes just get
	            // a simple wrapper that allows them to be highlighted
	            if (this.props.inline) {
	                return React.createElement(
	                    "span",
	                    { "data-lint-inside-table": "true" },
	                    this.props.children
	                );
	            } else {
	                return React.createElement(
	                    "div",
	                    { "data-lint-inside-table": "true" },
	                    this.props.children
	                );
	            }
	        } else {
	            if (this.props.inline) {
	                return React.createElement(
	                    "span",
	                    { className: css(styles.lintContainer) },
	                    this.renderLink(styles.inlineHoverTarget),
	                    React.createElement(
	                        "span",
	                        null,
	                        this.props.children
	                    )
	                );
	            } else {
	                return React.createElement(
	                    "div",
	                    { className: css(styles.lintContainer) },
	                    this.renderLink(styles.hoverTarget),
	                    React.createElement(
	                        "div",
	                        null,
	                        this.props.children
	                    )
	                );
	            }
	        }
	    }
	});
	
	var styles = StyleSheet.create({
	    // This is the class of the outermost element.
	    // We use relative positioning so that the lint indicator can be
	    // positioned absolutely relative to the position of the linty container.
	    lintContainer: {
	        position: "relative"
	    },
	
	    // This is the main class for block lint. It is applied to the link element
	    // that is also the hover target.
	    hoverTarget: {
	        // Absolute positioning relative to the lintContainer element
	        position: "absolute",
	        // Top of the hover target is aligned with the top of the linty block
	        top: 0,
	
	        // We want the hover target in the right margin. It is 24px wide, but
	        // we have to offset it another 16px because of margins in the
	        // Perseus content. I'm not sure where the 16px margin is set
	        // so if that changes, this number will also have to be changed.
	        // This is the part of the CSS that doesn't work right when
	        // applied to things like blockquotes that have different right
	        // margins.
	        right: -40,
	
	        // The hover target is a 24x24 block element.
	        display: "block",
	        width: 24,
	        height: 24,
	
	        // The indicator is in a span inside the hover target.
	        // This style changes its color on hover
	        ":hover > span": {
	            backgroundColor: constants.warningColorHover
	        },
	
	        // The tooltip is in a div element inside the hover target.
	        // This style displays it on hover
	        ":hover div": {
	            display: "block"
	        },
	
	        // The linty content is in a <div> sibling that follows the
	        // hover target. This style highlights it on hover. We do an outline
	        // rather than a border so we don't affect the layout. We could also
	        // set the background color, but we don't because we can't reliably
	        // set the text color of this block element. We could use
	        // filter: invert(100%) if we want more visual change on hover here.
	        ":hover ~ div": {
	            outline: "1px solid " + constants.warningColor
	        },
	
	        // If the div sibling is a table, then we may be displaying
	        // lint warnings about errors inside that table. In that case
	        // we want to highlight any linty descendants of the table
	        ":hover ~ div div[data-lint-inside-table]": {
	            outline: "1px solid " + constants.warningColor
	        },
	
	        ":hover ~ div span[data-lint-inside-table]": {
	            backgroundColor: constants.warningColor,
	            color: constants.white
	        }
	    },
	
	    // This is how we position the hover target for inline lint.
	    inlineHoverTarget: {
	        // For inline lint we position the hover target with a float:right
	        // We can't use absolute positioning as we do in the block case
	        // because the horizontal position is not predictable in the
	        // inline case.
	        float: "right",
	
	        // We still have to make the hover target relative so that the
	        // tooltip can be positioned relative to it.
	        position: "relative",
	
	        // See the comment above about the extra 16px of offset needed here.
	        marginRight: -40,
	
	        // The hover target is a 24x24 block. Same as the block case
	        display: "block",
	        width: 24,
	        height: 24,
	
	        // The indicator is in a span inside the hover target.
	        // This style changes its color on hover.
	        // This is the same as the block case.
	        ":hover > span": {
	            backgroundColor: constants.warningColorHover
	        },
	
	        // The tooltip is in a div element inside the hover target.
	        // This style displays it on hover. This is the same as the block case.
	        ":hover div": {
	            display: "block"
	        },
	
	        // The linty content is in a <span> sibling that follows the
	        // hover target. This style highlights it on hover. In this case
	        // we can just set the foreground and background color to really
	        // draw attention to the linty content.
	        ":hover ~ span": {
	            backgroundColor: constants.warningColor,
	            color: constants.white
	        }
	    },
	
	    // This is the class for the lint indicator in the margin.
	    indicator: {
	        alignItems: 'center',
	        borderRadius: 4,
	        color: 'white',
	        display: 'flex',
	        fontSize: 12,
	        height: 8,
	        justifyContent: 'center',
	        margin: 8,
	        width: 8
	    },
	    indicatorError: {
	        backgroundColor: '#be2612',
	        borderRadius: 8,
	        height: 16,
	        width: 16
	    },
	    indicatorWarning: {
	        backgroundColor: '#f86700'
	    },
	    indicatorGuideline: {
	        backgroundColor: '#ffbe26'
	    },
	
	    // These are the styles for the tooltip
	    tooltip: {
	        // Absolute positioning relative to the lint indicator circle.
	        position: "absolute",
	        right: -12,
	
	        // The tooltip is hidden by default; only displayed on hover
	        display: "none",
	
	        // When it is displayed, it goes on top!
	        zIndex: "1000",
	
	        // These styles control what the tooltip looks like
	        color: constants.white,
	        backgroundColor: constants.gray17,
	        opacity: "0.9",
	        fontFamily: constants.baseFontFamily,
	        fontSize: "12px",
	        lineHeight: "15px",
	        width: "320px",
	        borderRadius: "4px"
	    },
	    // If we're going to render the tooltip above the warning circle, we use
	    // the previous rules in tooltip, but change the position slightly.
	    tooltipAbove: {
	        bottom: 32
	    },
	
	    // We give the tooltip a little triangular "tail" that points down at
	    // the lint indicator circle. This is inside the tooltip and positioned
	    // relative to it. It also shares the opacity of the tooltip. We're using
	    // the standard CSS trick for drawing triangles with a thick border.
	    tail: {
	        position: "absolute",
	        top: -12,
	        right: 16,
	        width: 0,
	        height: 0,
	
	        // This is the CSS triangle trick
	        borderLeft: "8px solid transparent",
	        borderRight: "8px solid transparent",
	        borderBottom: "12px solid " + constants.gray17
	    },
	    tailAbove: {
	        bottom: -12,
	        borderBottom: "none",
	        borderTop: "12px solid " + constants.gray17,
	        top: "auto"
	    },
	
	    // Each warning in the tooltip is its own <p>. They are 12 pixels from
	    // the edges of the tooltip and 12 pixels from each other.
	    tooltipParagraph: {
	        margin: 12
	    },
	
	    // The text "Warning" inside the tooltip is highlighted like this
	    warning: {
	        color: constants.warningColor,
	        fontFamily: constants.boldFontFamily
	    },
	
	    // The text "Publish-blocking error" instide the tooltip is highlighted
	    // like this
	    publishBlockingError: {
	        color: constants.publishBlockingErrorColor
	    }
	
	});
	
	module.exports = Lint;

/***/ },
/* 180 */
/***/ function(module, exports, __webpack_require__) {

	/* TODO batch *all* mutations
	 * idea: freeze / thaw implementations for all types
	 * lens constructor thaws, freeze delegates to type's freeze
	 */
	
	var util = __webpack_require__(262);
	    var clone = util.clone;
	    var isObject = util.isObject;
	    var merge = util.merge;
	
	var arr = __webpack_require__(263);
	var obj = __webpack_require__(264);
	var str = __webpack_require__(265);
	
	// equivalents, without requiring it
	// find the implementation to use for a given object
	var dispatch = function(x) {
	    if (Array.isArray(x)) {
	        return arr;
	    } else if (isObject(x)) {
	        return obj;
	    } else if (typeof x === "string") {
	        return str;
	    }
	};
	
	// This is underscore with a different name
	var lens = function(obj) {
	    if (obj instanceof lens) {
	        return obj;
	    }
	
	    if (!(this instanceof lens)) {
	        return new lens(obj);
	    }
	
	    var ops = dispatch(obj);
	    this._wrapped = ops.thaw ? ops.thaw(obj) : obj;
	};
	
	lens.prototype.freeze = function() {
	    var obj = this._wrapped;
	    var ops = dispatch(obj);
	
	    return ops.freeze ? ops.freeze(obj) : obj;
	};
	
	lens.prototype.zoom = function(lensArr) {
	    if (this._zoomStack === undefined) {
	        this._zoomStack = [];
	    }
	
	    this._zoomStack.push({
	        zoom: lensArr,
	        wrapped: this._wrapped
	    });
	    this._wrapped = lens(this._wrapped).get(lensArr);
	
	    return this;
	};
	
	lens.prototype.deZoom = function() {
	    var frame = this._zoomStack.pop();
	    this._wrapped = lens(frame.wrapped)
	        .set(frame.zoom, this._wrapped)
	        .freeze();
	
	    return this;
	};
	
	lens.prototype.get = function(lensArr) {
	    var obj = this._wrapped;
	
	    for (var i = 0; i < lensArr.length; i++) {
	        obj = dispatch(obj).get(obj, lensArr[i]);
	    }
	
	    return obj;
	};
	
	lens.prototype.mod = function(lensArr, f) {
	    var obj = this._wrapped;
	    var newObj = clone(obj);
	    var ops = dispatch(obj);
	
	    if (lensArr.length === 0) {
	        this._wrapped = f(this._wrapped);
	    } else if (lensArr.length === 1) {
	        this._wrapped = ops.mod(newObj, lensArr[0], f);
	    } else {
	        var monocle = lensArr[0];
	        var shortLens = lensArr.slice(1);
	
	        // newObj = ops.mod(obj[monocle], shortLens, f);
	
	        newObj[monocle] = lens(obj[monocle])
	            .mod(shortLens, f)
	            .freeze();
	        this._wrapped = newObj;
	    }
	
	    return this;
	};
	
	// TODO - move to individual files
	lens.prototype.merge = function(lensArr, props) {
	    this._wrapped = lens(this._wrapped).mod(lensArr, function(oldProps) {
	        return merge(oldProps, props);
	    }).freeze();
	
	    return this;
	};
	
	// Lens must have length >= 1 or there would be nothing to return
	lens.prototype.del = function(lensArr) {
	    var obj = this._wrapped;
	    var ops = dispatch(obj);
	
	    if (lensArr.length === 1) {
	        this._wrapped = ops.del(obj, lensArr[0]);
	    } else {
	        var monocle = lensArr[0];
	        var shortLens = lensArr.slice(1);
	        var newObj = clone(obj);
	
	        newObj[monocle] = lens(obj[monocle])
	            .del(shortLens)
	            .freeze();
	
	        this._wrapped = newObj;
	    }
	
	    return this;
	};
	
	lens.prototype.set = function(lensArr, set) {
	    return this.mod(lensArr, function() { return set; });
	};
	
	module.exports = lens;


/***/ },
/* 181 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable react/sort-comp */
	
	var React = __webpack_require__(43);
	var Tooltip = __webpack_require__(193);
	var _ = __webpack_require__(56);
	
	var ApiClassNames = __webpack_require__(12).ClassNames;
	var MathInput = __webpack_require__(194);
	var Renderer = __webpack_require__(37);
	var TextInput = __webpack_require__(200);
	var MathOutput = __webpack_require__(255);
	
	var Gorgon = __webpack_require__(41);
	
	var _require = __webpack_require__(52),
	    linterContextProps = _require.linterContextProps,
	    linterContextDefault = _require.linterContextDefault;
	
	var captureScratchpadTouchStart = __webpack_require__(17).captureScratchpadTouchStart;
	
	var MATH = "math";
	var TEXT = "text";
	var TEX = "tex";
	
	var InputWithExamples = React.createClass({
	    displayName: "InputWithExamples",
	
	    propTypes: {
	        type: React.PropTypes.oneOf([MATH, TEXT, TEX]),
	        value: React.PropTypes.string,
	        onChange: React.PropTypes.func.isRequired,
	        className: React.PropTypes.string,
	        examples: React.PropTypes.arrayOf(React.PropTypes.string).isRequired,
	        shouldShowExamples: React.PropTypes.bool,
	        convertDotToTimes: React.PropTypes.bool,
	        buttonSet: React.PropTypes.string,
	        buttonsVisible: React.PropTypes.oneOf(["always", "never", "focused"]),
	        labelText: React.PropTypes.string,
	        onFocus: React.PropTypes.func,
	        onBlur: React.PropTypes.func,
	        disabled: React.PropTypes.bool,
	
	        // A unique string identifying this InputWithExamples
	        id: React.PropTypes.string.isRequired,
	        linterContext: linterContextProps
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            type: TEXT,
	            shouldShowExamples: true,
	            onFocus: function onFocus() {},
	            onBlur: function onBlur() {},
	            disabled: false,
	            linterContext: linterContextDefault
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            focused: false,
	            showExamples: false
	        };
	    },
	
	    _getUniqueId: function _getUniqueId() {
	        return "input-with-examples-" + btoa(this.props.id).replace(/=/g, "");
	    },
	
	    _getInputClassName: function _getInputClassName() {
	        // <MathOutput> is a special component that manages its own class and
	        // state, as it's a <span> that wants to act like an <input>.
	        if (this.props.type === TEX) {
	            return this.props.className;
	        }
	
	        // Otherwise, we need to add these INPUT and FOCUSED tags here.
	        var className = ApiClassNames.INPUT + " " + ApiClassNames.INTERACTIVE;
	        if (this.state.focused) {
	            className += " " + ApiClassNames.FOCUSED;
	        }
	        if (this.props.className) {
	            className += " " + this.props.className;
	        }
	        return className;
	    },
	
	    _getPropsForInputType: function _getPropsForInputType() {
	        // Minimal set of props, used by each input type
	        var inputProps = {
	            "aria-describedby": this._getUniqueId(),
	            ref: "input",
	            className: this._getInputClassName(),
	            labelText: this.props.labelText,
	            value: this.props.value,
	            onFocus: this._handleFocus,
	            onBlur: this._handleBlur,
	            disabled: this.props.disabled
	        };
	
	        if (this.props.type === TEX) {
	            return inputProps;
	        }
	
	        // Add useful props required for MATH and TEXT modes
	        _.extend(inputProps, {
	            onChange: this.props.onChange,
	            onTouchStart: captureScratchpadTouchStart
	        });
	
	        // And add final props that are MATH- and TEXT-specific
	        if (this.props.type === MATH) {
	            return _.extend({
	                buttonSet: this.props.buttonSet,
	                buttonsVisible: this.props.buttonsVisible,
	                convertDotToTimes: this.props.convertDotToTimes
	            }, inputProps);
	        } else if (this.props.type === TEXT) {
	            return _.extend({
	                autoCapitalize: "off",
	                autoComplete: "off",
	                autoCorrect: "off",
	                spellCheck: "false"
	            }, inputProps);
	        }
	    },
	
	    _getComponentForInputType: function _getComponentForInputType() {
	        switch (this.props.type) {
	            case TEX:
	                return MathOutput;
	
	            case MATH:
	                return MathInput;
	
	            case TEXT:
	                return TextInput;
	
	            default:
	                return null;
	        }
	    },
	
	    _renderInput: function _renderInput() {
	        var inputProps = this._getPropsForInputType();
	        var InputComponent = this._getComponentForInputType();
	        return React.createElement(InputComponent, inputProps);
	    },
	
	    render: function render() {
	        var input = this._renderInput();
	
	        // Static rendering, which doesn't include the 'tooltip' logic that the
	        // other types require, and is hence handled separately.
	        if (this.props.type === TEX) {
	            return input;
	        }
	
	        // Else, we need to be able to show examples
	        var examplesContent = _.map(this.props.examples, function (example) {
	            return "- " + example;
	        }).join("\n");
	
	        var showExamples = this.props.shouldShowExamples && this.state.showExamples;
	
	        return React.createElement(
	            Tooltip,
	            {
	                ref: "tooltip",
	                className: "perseus-formats-tooltip preview-measure",
	                horizontalPosition: "left",
	                horizontalAlign: "left",
	                verticalPosition: "bottom",
	                arrowSize: 10,
	                borderColor: "#ccc",
	                show: showExamples
	            },
	            input,
	            React.createElement(
	                "div",
	                { id: this._getUniqueId() },
	                React.createElement(Renderer, {
	                    content: examplesContent,
	                    linterContext: Gorgon.pushContextStack(this.props.linterContext, 'input-with-examples')
	                })
	            )
	        );
	    },
	
	    _handleFocus: function _handleFocus() {
	        this.props.onFocus();
	        this.setState({
	            focused: true,
	            showExamples: true
	        });
	    },
	
	    show: function show() {
	        this.setState({ showExamples: true });
	    },
	
	    hide: function hide() {
	        this.setState({ showExamples: false });
	    },
	
	    _handleBlur: function _handleBlur() {
	        this.props.onBlur();
	        this.setState({
	            focused: false,
	            showExamples: false
	        });
	    },
	
	    focus: function focus() {
	        this.refs.input.focus();
	    },
	
	    blur: function blur() {
	        this.refs.input.blur();
	    },
	
	    handleChange: function handleChange(e) {
	        this.props.onChange(e.target.value);
	    }
	});
	
	module.exports = InputWithExamples;

/***/ },
/* 182 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
	
	/**
	 * A version of the `math-input` subrepo's KeypadInput component that adheres to
	 * the same API as Perseus's  MathOuput and NumberInput, allowing it to be
	 * dropped in as a replacement for those components without any modifications.
	 *
	 * TODO(charlie): Once the keypad API has stabilized, move this into the
	 * `math-input` subrepo and use it everywhere as a simpler, keypad-coupled
	 * interface to `math-input`'s MathInput component.
	 */
	
	var React = __webpack_require__(43);
	
	var KeypadInput = __webpack_require__(257).components.KeypadInput;
	
	var KeypadTypes = __webpack_require__(257).consts.KeypadTypes;
	
	var keypadElementPropType = __webpack_require__(257).propTypes.keypadElementPropType;
	
	var SimpleKeypadInput = React.createClass({
	    displayName: "SimpleKeypadInput",
	
	    propTypes: {
	        keypadElement: keypadElementPropType,
	        onFocus: React.PropTypes.func,
	        value: React.PropTypes.oneOfType([React.PropTypes.string, React.PropTypes.number])
	    },
	
	    focus: function focus() {
	        this.refs.input.focus();
	    },
	    blur: function blur() {
	        this.refs.input.blur();
	    },
	
	
	    getValue: function getValue() {
	        return this.props.value;
	    },
	
	    render: function render() {
	        var _this = this;
	
	        // Intercept the `onFocus` prop, as we need to configure the keypad
	        // before continuing with the default focus logic for Perseus inputs.
	        // Intercept the `value` prop so as to map `null` to the empty string,
	        // as the `KeypadInput` does not support `null` values.
	        var _props = this.props,
	            keypadElement = _props.keypadElement,
	            _onFocus = _props.onFocus,
	            value = _props.value,
	            rest = _objectWithoutProperties(_props, ["keypadElement", "onFocus", "value"]);
	
	        return React.createElement(KeypadInput, _extends({
	            ref: "input",
	            keypadElement: keypadElement,
	            onFocus: function onFocus() {
	                if (keypadElement) {
	                    keypadElement.configure({
	                        keypadType: KeypadTypes.FRACTION
	                    }, function () {
	                        if (_this.isMounted()) {
	                            _onFocus && _onFocus();
	                        }
	                    });
	                } else {
	                    _onFocus && _onFocus();
	                }
	            },
	            value: value == null ? "" : "" + value
	        }, rest));
	    }
	});
	
	module.exports = SimpleKeypadInput;

/***/ },
/* 183 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable comma-dangle, no-var */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	/*
	 * In this file, an `expression` is some portion of valid TeX enclosed in
	 * curly brackets.
	 */
	
	/*
	  * Find the index at which an expression ends, i.e., has an unmatched
	  * closing curly bracket. This method assumes that we start with a non-open
	  * bracket character and end when we've seen more left than right brackets
	  * (rather than assuming that we start with a bracket character and wait for
	  * bracket equality).
	  */
	function findEndpoint(tex, currentIndex) {
	    var bracketDepth = 0;
	
	    for (var i = currentIndex, len = tex.length; i < len; i++) {
	        var c = tex[i];
	
	        if (c === "{") {
	            bracketDepth++;
	        } else if (c === "}") {
	            bracketDepth--;
	        }
	
	        if (bracketDepth < 0) {
	            return i;
	        }
	    }
	    // If we never see unbalanced curly brackets, default to the
	    // entire string
	    return tex.length;
	}
	
	/*
	 * Parses an individual set of curly brackets into TeX.
	 */
	function parseNextExpression(tex, currentIndex, handler) {
	    // Find the first '{' and grab subsequent TeX
	    // Ex) tex: '{3}{7}', and we want the '3'
	    var openBracketIndex = tex.indexOf("{", currentIndex);
	    var nextExpIndex = openBracketIndex + 1;
	
	    // Truncate to only contain remaining TeX
	    var endpoint = findEndpoint(tex, nextExpIndex);
	    var expressionTeX = tex.substring(nextExpIndex, endpoint);
	    var parsedExp = walkTex(expressionTeX, handler);
	
	    return {
	        endpoint: endpoint,
	        expression: parsedExp
	    };
	}
	
	function getNextFracIndex(tex, currentIndex) {
	    var dfrac = "\\dfrac";
	    var frac = "\\frac";
	
	    var nextFrac = tex.indexOf(frac, currentIndex);
	    var nextDFrac = tex.indexOf(dfrac, currentIndex);
	
	    if (nextFrac > -1 && nextDFrac > -1) {
	        return Math.min(nextFrac, nextDFrac);
	    } else if (nextFrac > -1) {
	        return nextFrac;
	    } else if (nextDFrac > -1) {
	        return nextDFrac;
	    } else {
	        return -1;
	    }
	}
	
	function walkTex(tex, handler) {
	    // Ex) tex: '2 \dfrac {3}{7}'
	    var parsedString = "";
	    var currentIndex = 0;
	    var nextFrac = getNextFracIndex(tex, currentIndex);
	
	    // For each \dfrac, find the two expressions (wrapped in {}) and recur
	    while (nextFrac > -1) {
	        // Gather first fragment, preceding \dfrac
	        // Ex) parsedString: '2 '
	        parsedString += tex.substring(currentIndex, nextFrac);
	
	        // Remove everything preceding \dfrac, which has been parsed
	        currentIndex = nextFrac;
	
	        // Parse first expression and move index past it
	        // Ex) firstParsedExpression.expression: '3'
	        var firstParsedExpression = parseNextExpression(tex, currentIndex, handler);
	        currentIndex = firstParsedExpression.endpoint + 1;
	
	        // Parse second expression
	        // Ex) secondParsedExpression.expression: '7'
	        var secondParsedExpression = parseNextExpression(tex, currentIndex, handler);
	        currentIndex = secondParsedExpression.endpoint + 1;
	
	        // Add expressions to running total of parsed expressions
	        if (parsedString.length) {
	            parsedString += " ";
	        }
	
	        // Apply a custom handler based on the parsed subexpressions
	        parsedString += handler(firstParsedExpression.expression, secondParsedExpression.expression);
	
	        // Find next DFrac, relative to currentIndex
	        nextFrac = getNextFracIndex(tex, currentIndex);
	    }
	
	    // Add remaining TeX, which is \dfrac-free
	    parsedString += tex.slice(currentIndex);
	
	    return parsedString;
	}
	
	/*
	 * Modify a TeX expression, returning another TeX expression. The resulting
	 * expression will have its innermost fractions stubbed out with \fracs
	 * (as opposed to \dfracs). All other content will remain untouched.
	 */
	function modifyTex(tex) {
	    function isNestedFraction(tex) {
	        return tex.indexOf("\\frac") > -1 || tex.indexOf("\\dfrac") > -1;
	    }
	    var handler = function handler(exp1, exp2) {
	        var prefix;
	        if (isNestedFraction(exp1) || isNestedFraction(exp2)) {
	            prefix = "\\dfrac";
	        } else {
	            prefix = "\\frac";
	        }
	        return prefix + " {" + exp1 + "}{" + exp2 + "}";
	    };
	    return walkTex(tex, handler);
	}
	
	/*
	 * Parse a TeX expression into something interpretable by input-number.
	 * The process is concerned with: (1) parsing fractions, i.e., \dfracs; and
	 * (2) removing backslash-escaping from certain characters (right now, only
	 * percent signs).
	 *
	 * The basic algorithm for handling \dfracs splits on \dfracs and then recurs
	 * on the subsequent "expressions", i.e., the {} pairs that follow \dfrac. The
	 * recursion is to allow for nested \dfrac elements.
	 *
	 * Backslash-escapes are removed with a simple search-and-replace.
	 */
	function parseTex(tex) {
	    var handler = function handler(exp1, exp2) {
	        return exp1 + "/" + exp2;
	    };
	    var texWithoutFracs = walkTex(tex, handler);
	    return texWithoutFracs.replace("\\%", "%");
	}
	
	module.exports = {
	    parseTex: parseTex,
	    modifyTex: modifyTex
	};

/***/ },
/* 184 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * In review mode (currently only visible in the sat-mission), NumericInput and
	 * InputNumber use this component to display the set of correct answers.
	 */
	
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	var PossibleAnswers = React.createClass({
	    displayName: "PossibleAnswers",
	
	    propTypes: {
	        answers: React.PropTypes.arrayOf(React.PropTypes.string)
	    },
	    render: function render() {
	        // It's redundant to show duplicate answers.
	        // So, remove duplicates from the given list of answer strings.
	        var answers = _.uniq(this.props.answers);
	
	        var answerComponents = _.map(answers, function (answer) {
	            // Plus, now that our answers are distinct, we can safely use the
	            // answer string as a key.
	            return React.createElement(
	                "dd",
	                { key: answer },
	                answer
	            );
	        });
	        return React.createElement(
	            "dl",
	            { className: "perseus-possible-answers" },
	            React.createElement(
	                "dt",
	                null,
	                "Correct Answer"
	            ),
	            answerComponents
	        );
	    }
	});
	
	module.exports = PossibleAnswers;

/***/ },
/* 185 */
/***/ function(module, exports, __webpack_require__) {

	var React = __webpack_require__(43);
	
	/* You know when you want to propagate input to a parent...
	 * but then that parent does something with the input...
	 * then changing the props of the input...
	 * on every keystroke...
	 * so if some input is invalid or incomplete...
	 * the input gets reset or otherwise effed...
	 *
	 * This is the solution.
	 *
	 * Enough melodrama. Its an input that only sends changes
	 * to its parent on blur.
	 */
	var BlurInput = React.createClass({
	    displayName: "BlurInput",
	
	    propTypes: {
	        className: React.PropTypes.string,
	        style: React.PropTypes.any,
	        value: React.PropTypes.string.isRequired,
	        onChange: React.PropTypes.func.isRequired
	    },
	    getInitialState: function getInitialState() {
	        return { value: this.props.value };
	    },
	    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        this.setState({ value: nextProps.value });
	    },
	    handleChange: function handleChange(e) {
	        this.setState({ value: e.target.value });
	    },
	    handleBlur: function handleBlur(e) {
	        this.props.onChange(e.target.value);
	    },
	    render: function render() {
	        return React.createElement("input", {
	            className: this.props.className,
	            style: this.props.style,
	            type: "text",
	            value: this.state.value,
	            onChange: this.handleChange,
	            onBlur: this.handleBlur
	        });
	    }
	});
	
	module.exports = BlurInput;

/***/ },
/* 186 */
/***/ function(module, exports, __webpack_require__) {

	var _instructionsMobile, _responsiveRadioConta;
	
	/* eslint-disable object-curly-spacing */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	/* global i18n */
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var classNames = __webpack_require__(86);
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var _ = __webpack_require__(56);
	
	var ApiClassNames = __webpack_require__(12).ClassNames;
	var Renderer = __webpack_require__(37);
	var sharedStyles = __webpack_require__(78);
	var styleConstants = __webpack_require__(77);
	var mediaQueries = __webpack_require__(76);
	
	var captureScratchpadTouchStart = __webpack_require__(17).captureScratchpadTouchStart;
	
	var Choice = __webpack_require__(278);
	
	var ChoiceNoneAbove = React.createClass({
	    displayName: "ChoiceNoneAbove",
	
	    propTypes: {
	        className: React.PropTypes.string,
	        content: React.PropTypes.node,
	        showContent: React.PropTypes.bool
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            showContent: true
	        };
	    },
	
	    render: function render() {
	        var choiceProps = _.extend({}, this.props, {
	            className: classNames(this.props.className, "none-of-above"),
	            content: this.props.showContent ? this.props.content : // We use a Renderer here because that is how
	            // `this.props.content` is wrapped otherwise.
	            // We pass in a key here so that we avoid a semi-spurious
	            // react warning when we render this in the same place
	            // as the previous choice content renderer.
	            // Note this destroys state, but since all we're doing
	            // is outputting "None of the above", that is okay.
	            React.createElement(Renderer, {
	                key: "noneOfTheAboveRenderer",
	                content: i18n._("None of the above")
	            })
	        });
	
	        return React.createElement(Choice, choiceProps);
	    }
	});
	
	var ChoicesType = React.PropTypes.arrayOf(React.PropTypes.shape({
	    // Indicates whether this choice is checked.
	    checked: React.PropTypes.bool,
	
	    // Indicates whether the user has "crossed out" this choice, meaning
	    // that they don't think it's correct. This value does not affect
	    // scoring or other behavior; it's just a note for the user's
	    // reference.
	    crossedOut: React.PropTypes.bool,
	
	    content: React.PropTypes.node,
	    rationale: React.PropTypes.node,
	    hasRationale: React.PropTypes.bool,
	    showRationale: React.PropTypes.bool,
	    showCorrectness: React.PropTypes.bool,
	    correct: React.PropTypes.bool,
	    originalIndex: React.PropTypes.number,
	    isNoneOfTheAbove: React.PropTypes.bool
	}));
	
	var radioBorderColor = styleConstants.radioBorderColor;
	
	var BaseRadio = React.createClass({
	    displayName: "BaseRadio",
	
	    propTypes: {
	        apiOptions: React.PropTypes.shape({
	            readOnly: React.PropTypes.bool,
	            satStyling: React.PropTypes.bool,
	            isMobile: React.PropTypes.bool,
	            styling: React.PropTypes.shape({
	                radioStyleVersion: React.PropTypes.oneOf(["intermediate", "final"])
	            })
	        }),
	        choices: ChoicesType,
	        deselectEnabled: React.PropTypes.bool,
	        editMode: React.PropTypes.bool,
	        labelWrap: React.PropTypes.bool,
	        countChoices: React.PropTypes.bool,
	        numCorrect: React.PropTypes.number,
	        multipleSelect: React.PropTypes.bool,
	        reviewModeRubric: React.PropTypes.shape({
	            choices: ChoicesType
	        }),
	
	        // A callback indicating that this choice has changed. Its argument is
	        // an object with two keys: `checked` and `crossedOut`. Each contains
	        // an array of boolean values, specifying the new checked and
	        // crossed-out value of each choice.
	        onChange: React.PropTypes.func
	    },
	
	    statics: {
	        styles: StyleSheet.create({
	            instructions: {
	                display: "block",
	                color: styleConstants.gray17,
	                fontSize: 14,
	                lineHeight: 1.25,
	                fontStyle: "normal",
	                fontWeight: "bold",
	                marginBottom: 16
	            },
	
	            instructionsMobile: (_instructionsMobile = {
	                fontSize: 18
	            }, _instructionsMobile[mediaQueries.smOrSmaller] = {
	                fontSize: 16
	            }, _instructionsMobile[mediaQueries.xl] = {
	                fontSize: 20
	            }, _instructionsMobile),
	
	            radio: {
	                // Avoid centering
	                width: "100%"
	            },
	
	            responsiveRadioContainer: (_responsiveRadioConta = {
	                borderBottom: "1px solid " + radioBorderColor,
	                borderTop: "1px solid " + radioBorderColor,
	                width: "auto"
	            }, _responsiveRadioConta[mediaQueries.smOrSmaller] = {
	                marginLeft: styleConstants.negativePhoneMargin,
	                marginRight: styleConstants.negativePhoneMargin
	            }, _responsiveRadioConta),
	
	            radioContainerFirstHighlighted: {
	                borderTop: "1px solid rgba(0, 0, 0, 0)"
	            },
	
	            radioContainerLastHighlighted: {
	                borderBottom: "1px solid rgba(0, 0, 0, 0)"
	            },
	
	            satRadio: {
	                background: "none",
	                marginLeft: 0,
	                userSelect: "none"
	            },
	
	            satRadioOption: {
	                margin: 0,
	                padding: 0,
	                borderBottom: "1px solid #ccc",
	                ":first-child": {
	                    borderTop: "1px solid #ccc"
	                }
	            },
	
	            satRadioOptionCorrect: {
	                borderBottomColor: styleConstants.satCorrectBorderColor,
	                ":first-child": {
	                    borderTopColor: styleConstants.satCorrectBorderColor
	                }
	            },
	
	            satRadioOptionIncorrect: {
	                borderBottomColor: styleConstants.satIncorrectBorderColor,
	                ":first-child": {
	                    borderTopColor: styleConstants.satIncorrectBorderColor
	                }
	            },
	
	            satRadioOptionNextCorrect: {
	                borderBottomColor: styleConstants.satCorrectBorderColor
	            },
	
	            satRadioOptionNextIncorrect: {
	                borderBottomColor: styleConstants.satIncorrectBorderColor
	            },
	
	            satReviewRadioOption: {
	                pointerEvents: "none"
	            },
	
	            item: {
	                marginLeft: 20
	            },
	
	            inlineItem: {
	                display: "inline-block",
	                paddingLeft: 20,
	                verticalAlign: "middle"
	                // See http://stackoverflow.com/q/8120466 for explanation of
	                // why vertical align property is needed
	            },
	
	            responsiveItem: {
	                marginLeft: 0,
	                padding: 0,
	
	                ":not(:last-child)": {
	                    borderBottom: "1px solid " + radioBorderColor
	                }
	            },
	
	            selectedItem: {
	                background: "white"
	            },
	
	            aboveBackdrop: {
	                position: "relative",
	                // HACK(emily): We want selected choices to show up above our
	                // exercise backdrop, but below the exercise footer and
	                // "feedback popover" that shows up. This z-index is carefully
	                // coordinated between here and webapp. :(
	                zIndex: 1062
	            },
	
	            aboveBackdropMobile: {
	                boxShadow: "0 0 4px 0 rgba(0, 0, 0, 0.2)," + "0 0 2px 0 rgba(0, 0, 0, 0.1)",
	
	                ":not(:last-child)": {
	                    borderBottom: "1px solid rgba(0, 0, 0, 0)"
	                }
	            },
	
	            nextHighlighted: {
	                ":not(:last-child)": {
	                    borderBottom: "1px solid rgba(0, 0, 0, 0)"
	                }
	            },
	
	            responsiveContainer: {
	                overflow: "auto",
	                marginLeft: styleConstants.negativePhoneMargin,
	                marginRight: styleConstants.negativePhoneMargin,
	                paddingLeft: styleConstants.phoneMargin
	                // paddingRight is handled by responsiveFieldset
	            },
	
	            responsiveFieldset: {
	                paddingRight: styleConstants.phoneMargin
	            }
	        })
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            editMode: false
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            // TODO(mdr): This keeps the ID stable across re-renders on the
	            //     same machine, but, at time of writing, the server's state
	            //     isn't rehydrated to the client during SSR, so the server and
	            //     client will generate different IDs and cause a mismatch
	            //     during SSR :(
	            radioGroupName: _.uniqueId("perseus_radio_")
	        };
	    },
	
	    // When a particular choice's `onChange` handler is called, indicating a
	    // change in a single choice's values, we need to call our `onChange`
	    // handler in order to notify our parent. However, our API with our parent
	    // is that we always provide *all* values for *all* choices, even if just
	    // one choice's values changed. (This is because sometimes an interaction
	    // with one choice can affect many choices, like how checking a new answer
	    // will usually cause the old answer to become unchecked.)
	    //
	    // So, given the new values for a particular choice, compute the new values
	    // for all choices, and pass them to `this.props.onChange`.
	    //
	    // `newValues` is an object with two keys: `checked` and `crossedOut`. Each
	    // contains a boolean value specifying the new checked and crossed-out
	    // value of this choice.
	    updateChoice: function updateChoice(choiceIndex, newValues) {
	        // Get the baseline `checked` values. If we're checking a new answer
	        // and multiple-select is not on, we should clear all choices to be
	        // unchecked. Otherwise, we should copy the old checked values.
	        var newCheckedList = void 0;
	        if (newValues.checked && !this.props.multipleSelect) {
	            newCheckedList = this.props.choices.map(function (_) {
	                return false;
	            });
	        } else {
	            newCheckedList = this.props.choices.map(function (c) {
	                return c.checked;
	            });
	        }
	
	        // Get the baseline `crossedOut` values.
	        var newCrossedOutList = this.props.choices.map(function (c) {
	            return c.crossedOut;
	        });
	
	        // Update this choice's `checked` and `crossedOut` values.
	        newCheckedList[choiceIndex] = newValues.checked;
	        newCrossedOutList[choiceIndex] = newValues.crossedOut;
	
	        this.props.onChange({
	            checked: newCheckedList,
	            crossedOut: newCrossedOutList
	        });
	    },
	
	    focus: function focus(i) {
	        ReactDOM.findDOMNode(this.refs["radio" + (i || 0)]).focus();
	        return true;
	    },
	
	    getInstructionsText: function getInstructionsText() {
	        if (this.props.multipleSelect) {
	            if (this.props.countChoices) {
	                return i18n._("Choose %(numCorrect)s answers:", {
	                    numCorrect: this.props.numCorrect
	                });
	            } else {
	                return i18n._("Choose all answers that apply:");
	            }
	        } else {
	            return i18n._("Choose 1 answer:");
	        }
	    },
	
	    deselectEnabled: function deselectEnabled() {
	        // We want to force enable deselect on mobile.
	        return this.props.apiOptions.isMobile || this.props.deselectEnabled;
	    },
	
	    render: function render() {
	        var inputType = this.props.multipleSelect ? "checkbox" : "radio";
	        var rubric = this.props.reviewModeRubric;
	        var reviewMode = !!rubric;
	
	        var styles = BaseRadio.styles;
	        var sat = this.props.apiOptions.satStyling;
	
	        var isMobile = this.props.apiOptions.isMobile;
	
	        var choices = this.props.choices;
	        var firstChoiceHighlighted = choices[0].highlighted;
	        var lastChoiceHighlighted = choices[choices.length - 1].highlighted;
	
	        var className = classNames("perseus-widget-radio", !this.props.editMode && "perseus-rendered-radio", css(styles.radio,
	        // SAT doesn't use the "responsive styling" as it conflicts
	        // with their custom theming.
	        !sat && styles.responsiveRadioContainer, !sat && firstChoiceHighlighted && isMobile && styles.radioContainerFirstHighlighted, !sat && lastChoiceHighlighted && isMobile && styles.radioContainerLastHighlighted, sat && styles.satRadio));
	
	        var instructionsClassName = classNames("instructions", css(styles.instructions, isMobile && styles.instructionsMobile));
	        var instructions = this.getInstructionsText();
	        var shouldShowInstructions = !sat;
	
	        var responsiveClassName = css(styles.responsiveFieldset);
	        var fieldset = React.createElement(
	            "fieldset",
	            {
	                className: "perseus-widget-radio-fieldset " + responsiveClassName // eslint-disable-line max-len
	            },
	            React.createElement(
	                "legend",
	                { className: "perseus-sr-only" },
	                instructions
	            ),
	            shouldShowInstructions && React.createElement(
	                "div",
	                { className: instructionsClassName },
	                instructions
	            ),
	            React.createElement(
	                "ul",
	                { className: className },
	                this.props.choices.map(function (choice, i) {
	                    var _this = this;
	
	                    var Element = Choice;
	                    var elementProps = {
	                        ref: "radio" + i,
	                        apiOptions: this.props.apiOptions,
	                        checked: choice.checked,
	                        crossedOut: choice.crossedOut,
	                        reviewMode: reviewMode,
	                        correct: choice.correct,
	                        rationale: choice.rationale,
	                        content: choice.content,
	                        disabled: this.props.apiOptions.readOnly || choice.disabled,
	                        editMode: this.props.editMode,
	                        groupName: this.state.radioGroupName,
	                        isLastChoice: i === this.props.choices.length - 1,
	                        showCorrectness: reviewMode || !!choice.showCorrectness,
	                        showRationale: choice.hasRationale && (reviewMode || choice.showRationale),
	                        type: inputType,
	                        pos: i,
	                        deselectEnabled: this.deselectEnabled(),
	                        onChange: function onChange(newValues) {
	                            _this.updateChoice(i, newValues);
	                        }
	                    };
	
	                    if (choice.isNoneOfTheAbove) {
	                        Element = ChoiceNoneAbove;
	                        _.extend(elementProps, {
	                            showContent: choice.revealNoneOfTheAbove
	                        });
	                    }
	
	                    var nextChoice = this.props.choices[i + 1];
	                    var nextChoiceHighlighted = !!nextChoice && nextChoice.highlighted;
	
	                    var aphroditeClassName = function aphroditeClassName(checked) {
	                        // Whether or not to show correctness borders
	                        // for this choice and the next choice.
	                        var satShowCorrectness = sat && reviewMode && checked;
	                        var satShowCorrectnessNext = sat && reviewMode && nextChoice && nextChoice.checked;
	
	                        return css(sharedStyles.aboveScratchpad, styles.item, !sat && styles.responsiveItem, !sat && checked && styles.selectedItem, !sat && checked && choice.highlighted && styles.aboveBackdrop, !sat && checked && choice.highlighted && _this.props.apiOptions.isMobile && styles.aboveBackdropMobile, !sat && nextChoiceHighlighted && _this.props.apiOptions.isMobile && styles.nextHighlighted, sat && styles.satRadioOption, satShowCorrectness && !choice.correct && styles.satRadioOptionIncorrect, satShowCorrectness && choice.correct && styles.satRadioOptionCorrect, satShowCorrectnessNext && !nextChoice.correct && styles.satRadioOptionNextIncorrect, satShowCorrectnessNext && nextChoice.correct && styles.satRadioOptionNextCorrect, sat && rubric && styles.satReviewRadioOption);
	                    };
	
	                    // HACK(abdulrahman): Preloads the selection-state
	                    // css because of a bug that causes iOS to lag
	                    // when selecting the button for the first time.
	                    aphroditeClassName(true);
	
	                    var className = classNames(aphroditeClassName(choice.checked),
	                    // TODO(aria): Make test case for these API
	                    // classNames
	                    ApiClassNames.RADIO.OPTION, choice.checked && ApiClassNames.RADIO.SELECTED, reviewMode && rubric.choices[i].correct && ApiClassNames.CORRECT, reviewMode && !rubric.choices[i].correct && ApiClassNames.INCORRECT);
	
	                    // In edit mode, the Choice renders a Div in order to
	                    // allow for the contentEditable area to be selected
	                    // (label forces any clicks inside to select the input
	                    // element) We have to add some extra behavior to make
	                    // sure that we can still check the choice.
	                    var listElem = null;
	                    var clickHandler = null;
	                    if (this.props.editMode) {
	                        clickHandler = function clickHandler(e) {
	                            // Traverse the parent nodes of the clicked
	                            // element.
	                            var elem = e.target;
	                            while (elem && elem !== listElem) {
	                                // If the clicked element is inside of the
	                                // radio icon, then we want to trigger the
	                                // check by flipping the choice of the icon.
	                                if (elem.getAttribute("data-is-radio-icon")) {
	                                    _this.updateChoice(i, { checked: !choice.checked });
	                                    return;
	                                }
	                                elem = elem.parentNode;
	                            }
	                        };
	                    }
	
	                    // TODO(mattdr): Index isn't a *good* choice of key
	                    // here; is there a better one? Can we use choice
	                    // content somehow? Would changing our choice of key
	                    // somehow break something happening inside a choice's
	                    // child Renderers, by changing when we mount/unmount?
	                    return React.createElement(
	                        "li",
	                        {
	                            key: i,
	                            ref: function ref(e) {
	                                return listElem = e;
	                            },
	                            className: className,
	                            onClick: clickHandler,
	                            onTouchStart: !this.props.labelWrap ? null : captureScratchpadTouchStart
	                        },
	                        React.createElement(Element, elementProps)
	                    );
	                }, this)
	            )
	        );
	
	        // Allow for horizontal scrolling if content is too wide, which may be
	        // an issue especially on phones.
	        // This is disabled in SAT, since it conflicts with their theming.
	        return React.createElement(
	            "div",
	            { className: css(!sat && styles.responsiveContainer) },
	            fieldset
	        );
	    }
	});
	
	module.exports = BaseRadio;

/***/ },
/* 187 */
/***/ function(module, exports, __webpack_require__) {

	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	/**
	 * Changeable
	 *
	 * Adds a this.change() function to a component
	 *
	 * This.change takes prop changes as parameters, and calls
	 * this.props.onChange with the modified props.
	 */
	
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	var WIDGET_PROP_BLACKLIST = __webpack_require__(93);
	
	var USAGE = "Usage:\n" + "  this.change({propName: 5}, callback);\n" + "  this.change(\"propName\", 5, callback);\n" + "  this.change(\"propName\")";
	
	/**
	 * Primary helper function for this.change()
	 *
	 * Takes the parameters in a consistent style, once this.change() has
	 * figured out which way it was called.
	 */
	var _changeMultiple = function _changeMultiple(component, newProps, callback) {
	    // Omit "default" props:
	    // ref and key come from react, and don't actually represent
	    //   the conceptual state of our component
	    // onChange comes from our parent to allow this modification,
	    //   and doesn't conceptually represent the state of our component
	    var currProps = _.omit(component.props, WIDGET_PROP_BLACKLIST);
	    var nextProps = _.extend(currProps, newProps);
	    component.props.onChange(nextProps, callback);
	};
	
	/**
	 * Helper function for changing a single prop
	 */
	var _changeSingle = function _changeSingle(component, propName, value, callback) {
	    if (value === undefined) {
	        // If called with a single prop name, return a lambda to change
	        // a single prop on the current object
	        return _.partial(_changeSingle, component, propName);
	    } else {
	        // If called with two values, change a single prop of the
	        // current object
	        var newProps = {};
	        newProps[propName] = value;
	        _changeMultiple(component, newProps, callback);
	    }
	};
	
	/**
	 * this.change()
	 *
	 * Can be called as follows:
	 * this.change(newProps, callback);
	 *
	 * this.change(propName, propValue, callback);
	 *
	 * this.change(propName) -> returns a lambda that takes a prop value to
	 * set and a callback to call after having set that value.
	 */
	var change = exports.change = function change(newPropsOrSinglePropName, propValue, callback) {
	
	    if (_.isObject(newPropsOrSinglePropName) && callback === undefined) {
	        // Called with an object of multiple props to change
	        callback = propValue;
	        return _changeMultiple(this, newPropsOrSinglePropName, // object newProps
	        callback);
	    } else if (_.isString(newPropsOrSinglePropName)) {
	        // Called with a string propName of a single prop to change
	        return _changeSingle(this, newPropsOrSinglePropName, // string propName
	        propValue, callback);
	    } else {
	        throw new Error("Invalid types sent to this.change(): " + _.toArray(arguments).join() + "\n" + USAGE);
	    }
	};
	
	var propTypes = exports.propTypes = {
	    onChange: React.PropTypes.func.isRequired
	};
	
	Object.defineProperty(module.exports, "babelPluginFlowReactPropTypes_proptype_ChangeableProps", __webpack_require__(43).PropTypes.shape({
	    onChange: __webpack_require__(43).PropTypes.func.isRequired
	}));

/***/ },
/* 188 */
/***/ function(module, exports, __webpack_require__) {

	
	/**
	 * Type definitions for generic trees that are shaped like multi-items.
	 *
	 * Multi-items are trees! But we also often have other trees that are shaped
	 * like multi-items - for example, if we map a multi-item tree into a tree of
	 * renderer info and state, and then map that again into a tree of just the
	 * renderer nodes, like we do in MultiRenderer.
	 *
	 * Therefore, we provide the type Tree<C, H>, which represents a tree that's
	 * shaped like a multi-item, but the data that lives at each type of leaf could
	 * be anything.
	 *
	 * So, in a Tree<C, H>, content leaf nodes have type C, and hint leaf nodes
	 * have type H. An ItemTree is a Tree<ContentNode, HintNode>.
	 *
	 * That is, we still preserve the distinction between node types, and thereby
	 * enforce the Tree's adherence to some multi-item Shape, but we're flexible
	 * about exactly what type of data the tree contains at its leaves.
	 *
	 * This enables us to write generic tree-traversal and tree-mapping functions,
	 * as you'll see in trees.js.
	 */
	Object.defineProperty(module.exports, "babelPluginFlowReactPropTypes_proptype_ObjectNode", __webpack_require__(43).PropTypes.shape({}));

/***/ },
/* 189 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable react/prop-types */
	
	/**
	 * A wrapper for a component that would otherwise have a fixed width and
	 * height, that magically makes it reponsive while preserving its aspect ratio.
	 * Specifically, the component will shrink dynamically when it needs to but
	 * won't ever grow past its original dimensions.
	 *
	 * Can wrap multiple components with the same dimensions at the same time;
	 * these will be overlaid on top of each other.
	 *
	 * Usage:
	 * <FixedToResponsive width={400} height={400}>
	 *     <img src="bottom-layer.png" />
	 *     <img src="top-layer.png" />
	 * </FixedToResponsive>
	 */
	var classNames = __webpack_require__(86);
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(77),
	    negativePhoneMargin = _require.negativePhoneMargin;
	
	var MIN_VIEWPORT_HEIGHT = 480;
	
	var FixedToResponsive = React.createClass({
	    displayName: "FixedToResponsive",
	
	    propTypes: {
	        width: React.PropTypes.number.isRequired,
	        height: React.PropTypes.number.isRequired,
	        className: React.PropTypes.string,
	        constrainHeight: React.PropTypes.bool,
	        allowFullBleed: React.PropTypes.bool
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            className: "",
	            constrainHeight: false,
	            allowFullBleed: false
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            viewportHeight: null,
	            viewportWidth: null
	        };
	    },
	
	    componentDidMount: function componentDidMount() {
	        // Cache viewport sizes instead of computing on each render.
	        // We setState() in componentDidMount(), even though it's a React
	        // anti-pattern, because we do actually want to trigger a re-render
	        // after the initial render (because initial render may be
	        // server-side).
	        // TODO(david): Don't do this for each image. Do this once per page.
	        if (window.innerHeight < MIN_VIEWPORT_HEIGHT) {
	            // There is a weird issue when this gets rendered in an Android
	            // webview where window.innerHeight might be initially very small,
	            // like 46, but seems to be good after ~400ms.
	            setTimeout(this._cacheViewportSize, 800);
	        } else {
	            this._cacheViewportSize();
	        }
	    },
	
	    _cacheViewportSize: function _cacheViewportSize() {
	        if (this.isMounted()) {
	            this.setState({
	                viewportHeight: Math.max(MIN_VIEWPORT_HEIGHT, window.innerHeight),
	                viewportWidth: window.innerWidth
	            });
	        }
	    },
	
	    render: function render() {
	        // The ideal behavior for responsified, fixed size child components is
	        // that they shrink when they need to (while preserving aspect ratio)
	        // but never grow larger than their original dimensions. We accomplish
	        // this by absolutely positioning the children and telling them to fill
	        // up all of a space that has the correct aspect ratio.
	        var aspectRatio = this.props.width / this.props.height;
	
	        // This works because padding percentages are interpreted in terms of
	        // the width of the containing block, so:
	        //     (fixed height / fixed width) * display width = display height
	        // Based on http://refills.bourbon.io/components/#video && medium.com
	        var spacer = React.createElement("div", {
	            style: {
	                paddingBottom: (1 / aspectRatio).toFixed(4) * 100 + "%"
	            }
	        });
	
	        var _props = this.props,
	            width = _props.width,
	            height = _props.height;
	
	        // Constrain height to be at most 2/3 viewport height, maintaining
	        // aspect ratio.
	
	        if (this.props.constrainHeight && this.state.viewportHeight) {
	            var maxHeight = 2 / 3 * this.state.viewportHeight;
	            if (this.props.height >= maxHeight) {
	                height = maxHeight;
	                width = maxHeight * aspectRatio;
	            }
	        }
	
	        // Prevent child components from growing (aka "the Peter Pan effect")
	        var style = {
	            maxWidth: width,
	            maxHeight: height
	        };
	
	        var className = classNames("fixed-to-responsive", this.props.className);
	
	        var container = React.createElement(
	            "div",
	            { className: className, style: style },
	            spacer,
	            this.props.children
	        );
	
	        var shouldFullBleed = this.props.allowFullBleed && this.state.viewportWidth && width >= this.state.viewportWidth;
	
	        if (shouldFullBleed) {
	            return React.createElement(
	                "div",
	                {
	                    style: {
	                        marginLeft: negativePhoneMargin,
	                        marginRight: negativePhoneMargin
	                    }
	                },
	                container
	            );
	        } else {
	            return container;
	        }
	    }
	});
	
	module.exports = FixedToResponsive;

/***/ },
/* 190 */
/***/ function(module, exports, __webpack_require__) {

	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var _ = __webpack_require__(56);
	
	var GraphieClasses = __webpack_require__(276);
	var Movables = __webpack_require__(277);
	
	var GraphieMovable = GraphieClasses.GraphieMovable;
	
	var deepEq = __webpack_require__(17).deepEq;
	var nestedMap = __webpack_require__(17).nestedMap;
	var assert = __webpack_require__(256).assert;
	
	var GraphUtils = __webpack_require__(244);
	var createGraphie = GraphUtils.createGraphie;
	
	var Graphie = React.createClass({
	    displayName: "Graphie",
	
	    propTypes: {
	        addMouseLayer: React.PropTypes.bool,
	        box: React.PropTypes.arrayOf(React.PropTypes.number).isRequired,
	        children: React.PropTypes.node,
	        isMobile: React.PropTypes.bool,
	        onClick: React.PropTypes.func,
	        onMouseDown: React.PropTypes.func,
	        onMouseMove: React.PropTypes.func,
	        onMouseUp: React.PropTypes.func,
	        options: React.PropTypes.shape({
	            snapStep: React.PropTypes.arrayOf(React.PropTypes.number)
	        }),
	        range: React.PropTypes.arrayOf(React.PropTypes.arrayOf(React.PropTypes.number)),
	        responsive: React.PropTypes.bool,
	        setDrawingAreaAvailable: React.PropTypes.func,
	        setup: React.PropTypes.func.isRequired
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            range: [[-10, 10], [-10, 10]],
	            options: {},
	            responsive: false,
	            addMouseLayer: true
	        };
	    },
	
	    componentDidMount: function componentDidMount() {
	        this._setupGraphie();
	        this._updateMovables();
	    },
	
	    shouldComponentUpdate: function shouldComponentUpdate(nextProps) {
	        return !deepEq(this.props, nextProps);
	    },
	
	    componentDidUpdate: function componentDidUpdate(prevProps) {
	        // If someone changes the setup function passed in, we should
	        // technically setup graphie again. But that's definitely an
	        // anti-pattern, since it is most-likely caused by passing in an
	        // anonymous function rather than a "real" change, and re-rendering
	        // in that case would cause us to constantly re-setup graphie, which
	        // would have horrible performance implications. In order to avoid
	        // those, we just warn here.
	        if (this.props.setup !== prevProps.setup && window.console && window.console.warn) {
	            window.console.warn("<Graphie> was given a new setup function. " + "This is a bad idea; please refactor your code to give " + "the same setup function reference to <Graphie> on " + "every render.");
	        }
	        if (!deepEq(this.props.options, prevProps.options) || !deepEq(this.props.box, prevProps.box) || !deepEq(this.props.range, prevProps.range)) {
	            this._setupGraphie();
	        }
	        this._updateMovables();
	    },
	
	    /**
	     * Allow parents of the <Graphie> component to grab a reference to the
	     * underlying graphie object using
	     * `this.refs.graphieComponent.getGraphie()`
	     *
	     * This shouldn't be necessary for 90% of cases, but the power is there.
	     * Use it for good and not evil.
	     */
	    getGraphie: function getGraphie() {
	        return this._graphie;
	    },
	
	    // bounds-checked range
	    _range: function _range() {
	        return _.map(this.props.range, function (dimRange) {
	            if (dimRange[0] >= dimRange[1]) {
	                return [-10, 10];
	            } else {
	                return dimRange;
	            }
	        });
	    },
	
	    _box: function _box() {
	        return _.map(this.props.box, function (pixelDim) {
	            // 340 = default size in the editor. exact value
	            // is arbitrary; this is just a safety check.
	            return pixelDim > 0 ? pixelDim : 340;
	        });
	    },
	
	    _scale: function _scale() {
	        var box = this._box();
	        var range = this._range();
	        return _.map(box, function (pixelDim, i) {
	            var unitDim = range[i][1] - range[i][0];
	            return pixelDim / unitDim;
	        });
	    },
	
	    _setupGraphie: function _setupGraphie() {
	        this._removeMovables();
	
	        var graphieDiv = ReactDOM.findDOMNode(this.refs.graphieDiv);
	        $(graphieDiv).empty();
	        var graphie = this._graphie = createGraphie(graphieDiv);
	
	        // This has to be called before addMouseLayer. You can re-init
	        // with graphInit later if you prefer
	        graphie.init({
	            range: this._range(),
	            scale: this._scale(),
	            isMobile: this.props.isMobile
	        });
	        // Only add the mouselayer if we actually want one.
	        if (this.props.addMouseLayer) {
	            graphie.addMouseLayer({
	                onClick: this.props.onClick,
	                onMouseDown: this.props.onMouseDown,
	                onMouseUp: this.props.onMouseUp,
	                onMouseMove: this.props.onMouseMove,
	                setDrawingAreaAvailable: this.props.setDrawingAreaAvailable
	            });
	        }
	
	        graphie.snap = this.props.options.snapStep || [1, 1];
	
	        if (this.props.responsive) {
	            // Overwrite fixed styles set in init()
	            // TODO(alex): Either make this component always responsive by
	            // itself, or always wrap it in other components so that it is.
	            $(graphieDiv).css({ width: "100%", height: "100%" });
	            graphie.raphael.setSize("100%", "100%");
	        }
	
	        this.props.setup(graphie, _.extend({
	            range: this._range(),
	            scale: this._scale()
	        }, this.props.options));
	    },
	
	    _removeMovables: function _removeMovables() {
	        // _.invoke works even when this._movables is undefined
	        _.invoke(this._movables, "remove");
	        this._movables = {};
	    },
	
	    _renderMovables: function _renderMovables(children, options) {
	        var _this = this;
	
	        // Each leaf of `children` is a movable descriptor created by a call to
	        // some `GraphieMovable`, such as `MovablePoint`.
	        //
	        // This function takes these descriptors and renders them into
	        // on-screen movables, or updates on-screen movables for
	        // descriptors when possible.
	        //
	        // If there is no movable with that key already, this descriptor is
	        // stored in this._movables and promoted to an on-screen movable by
	        // calling `child.add(graphie)`.
	        //
	        // If a movable of the same type with the same key exists already,
	        // we take `child.props` and give them to the already-existing
	        // on-screen movable, and call `movable.modify()`
	
	        var graphie = options.graphie;
	        var oldMovables = options.oldMovables;
	        var newMovables = options.newMovables; /* output parameter */
	
	        var renderChildren = function renderChildren(elem) {
	            _.each(elem.movableProps, function (prop) {
	                // Render the children, and save the results of that
	                // render to the appropriate props
	                elem.props[prop] = _this._renderMovables(elem.props[prop], options);
	            });
	        };
	
	        // Add/modify movables
	
	        // We want to keep track of whether we have added a new svg element,
	        // because if we have, then we need to call .toFront() on any svg
	        // elements occurring afterwards. If this happens, we set
	        // `areMovablesOutOfOrder` to true:
	        var areMovablesOutOfOrder = false;
	        return nestedMap(children, function (childDescriptor) {
	            if (!childDescriptor) {
	                // Still increment the key to avoid cascading key changes
	                // on hiding/unhiding children, i.e. by using
	                // {someBoolean && <MovablePoint />}
	                options.nextKey++;
	                // preserve the null/undefined in the resulting array
	                return childDescriptor;
	            }
	
	            // Instantiate the descriptor to turn it into a real Movable
	            var child = new childDescriptor.type(childDescriptor.props);
	            assert(child instanceof GraphieMovable, "All children of a Graphie component must be Graphie " + "movables");
	
	            // Give each child a key
	            var keyProp = childDescriptor.key;
	            var key = keyProp == null ? "_no_id_" + options.nextKey : keyProp;
	            options.nextKey++;
	            var ref = childDescriptor.ref;
	
	            // We render our children first. This allows us to replace any
	            // `movableProps` on our child with the on-screen movables
	            // corresponding with those descriptors.
	            renderChildren(child);
	
	            var prevMovable = oldMovables[key];
	            if (!prevMovable) {
	                // We're creating a new child
	                child.add(graphie);
	                areMovablesOutOfOrder = true;
	
	                newMovables[key] = child;
	            } else if (child.constructor === prevMovable.constructor) {
	                // We're updating an old child
	                prevMovable.props = child.props;
	                var modifyResult = prevMovable.modify(graphie);
	                if (modifyResult === "reordered") {
	                    areMovablesOutOfOrder = true;
	                }
	
	                newMovables[key] = prevMovable;
	            } else {
	                // We're destroying an old child and replacing it
	                // with a new child of a different type
	
	                // This generally is a bad idea, so warn about it if this
	                // is being caused by implicit keys
	                if (keyProp == null) {
	                    /* eslint-disable no-console */
	                    if (typeof console !== "undefined" && console.warn) {
	                        console.warn("Replacing a <Graphie> child with a " + "child of a different type. Please add keys " + "to your <Graphie> children");
	                    }
	                    /* eslint-enable no-console */
	                }
	
	                prevMovable.remove();
	                child.add(graphie);
	                areMovablesOutOfOrder = true;
	
	                newMovables[key] = child;
	            }
	
	            if (areMovablesOutOfOrder) {
	                newMovables[key].toFront();
	            }
	
	            if (ref) {
	                _this.movables[ref] = newMovables[key];
	            }
	
	            return newMovables[key];
	        });
	    },
	
	    // Sort of like react diffing, but for movables
	    _updateMovables: function _updateMovables() {
	        var graphie = this._graphie;
	
	        var oldMovables = this._movables;
	        var newMovables = {};
	        this._movables = newMovables;
	        this.movables = {};
	
	        this._renderMovables(this.props.children, {
	            nextKey: 1,
	            graphie: graphie,
	            oldMovables: oldMovables,
	            newMovables: newMovables
	        });
	
	        // Remove any movables that no longer exist in the child array
	        _.each(oldMovables, function (oldMovable, key) {
	            if (!newMovables[key]) {
	                oldMovable.remove();
	            }
	        });
	    },
	
	    render: function render() {
	        return React.createElement(
	            "div",
	            { className: "graphie-container" },
	            React.createElement("div", { className: "graphie", ref: "graphieDiv" })
	        );
	    }
	});
	
	// Attach Graphie.createClass and Graphie.createSimpleClass
	_.extend(Graphie, GraphieClasses);
	// Attach the Movable react components for easy reference
	_.extend(Graphie, Movables);
	
	module.exports = Graphie;

/***/ },
/* 191 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Component to display an image (or other React components) while the desired
	 * image is loading.
	 *
	 * Derived from
	 * https://github.com/hzdg/react-imageloader/blob/master/src/index.js
	 * to better suit our environment/build tools. Additionally, this one does
	 * not introduce a wrapper element, which makes styling easier.
	 */
	
	var React = __webpack_require__(43);
	
	var PropTypes = React.PropTypes;
	
	
	var Status = {
	    PENDING: "pending",
	    LOADING: "loading",
	    LOADED: "loaded",
	    FAILED: "failed"
	};
	
	var ImageLoader = React.createClass({
	    displayName: "ImageLoader",
	
	    propTypes: {
	        children: React.PropTypes.oneOfType([React.PropTypes.arrayOf(React.PropTypes.node), React.PropTypes.node]),
	        imgProps: PropTypes.any,
	        onError: PropTypes.func,
	        onLoad: PropTypes.func,
	
	        // When the DOM updates to replace the preloader with the image, or
	        // vice-versa, we trigger this callback.
	        onUpdate: PropTypes.func,
	
	        preloader: PropTypes.func,
	        src: PropTypes.string
	    },
	
	    getInitialState: function getInitialState(props) {
	        return { status: this.props.src ? Status.LOADING : Status.PENDING };
	    },
	
	    componentDidMount: function componentDidMount() {
	        if (this.state.status === Status.LOADING) {
	            this.createLoader();
	        }
	    },
	
	    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        if (this.props.src !== nextProps.src) {
	            this.setState({
	                status: nextProps.src ? Status.LOADING : Status.PENDING
	            });
	        }
	    },
	
	    componentDidUpdate: function componentDidUpdate(prevProps, prevState) {
	        if (this.state.status === Status.LOADING && !this.img) {
	            this.createLoader();
	        }
	
	        if (prevState.status !== this.state.status) {
	            this.props.onUpdate();
	        }
	    },
	
	    componentWillUnmount: function componentWillUnmount() {
	        this.destroyLoader();
	    },
	
	    createLoader: function createLoader() {
	        this.destroyLoader(); // We can only have one loader at a time.
	
	        this.img = new Image();
	        this.img.onload = this.handleLoad;
	        this.img.onerror = this.handleError;
	        this.img.src = this.props.src;
	    },
	
	    destroyLoader: function destroyLoader() {
	        if (this.img) {
	            this.img.onload = null;
	            this.img.onerror = null;
	            this.img = null;
	        }
	    },
	
	    handleLoad: function handleLoad(event) {
	        this.destroyLoader();
	        this.setState({ status: Status.LOADED });
	
	        if (this.props.onLoad) {
	            this.props.onLoad(event);
	        }
	    },
	
	    handleError: function handleError(error) {
	        this.destroyLoader();
	        this.setState({ status: Status.FAILED });
	
	        if (this.props.onError) {
	            this.props.onError(error);
	        }
	    },
	
	    renderImg: function renderImg() {
	        var _props = this.props,
	            src = _props.src,
	            imgProps = _props.imgProps;
	
	        var props = { src: src };
	
	        for (var k in imgProps) {
	            if (imgProps.hasOwnProperty(k)) {
	                props[k] = imgProps[k];
	            }
	        }
	
	        return React.createElement("img", props);
	    },
	
	    render: function render() {
	        switch (this.state.status) {
	            case Status.LOADED:
	                return this.renderImg();
	
	            case Status.FAILED:
	                if (this.props.children) {
	                    return this.props.children;
	                }
	                break;
	            default:
	                if (this.props.preloader) {
	                    return this.props.preloader();
	                }
	        }
	        return null;
	    }
	});
	
	module.exports = ImageLoader;

/***/ },
/* 192 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable comma-dangle, max-len, no-var */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	// Derived from the MIT-licensed:
	// https://github.com/fat/zoom.js/blob/fd4f3e43153da7596da0bade198e99f98b47791e/js/zoom.js
	
	// NOTE(kevindangoor)
	// This version zooms a new, absolutely positioned image element rather than
	// scaling the original image element within a new container. The problem that
	// I ran into was that we had a grandparent node with a z-index
	// which caused the zoomed image to end up behind the overlay. We sidestep all
	// of that by simplifying to just use a new image element.
	
	/*global $*/
	/*jshint browser:true, node:true */
	
	"use strict";
	
	/* ========================================================================
	 * Bootstrap: transition.js v3.3.4
	 * http://getbootstrap.com/javascript/#transitions
	 * ========================================================================
	 * Copyright 2011-2015 Twitter, Inc.
	 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
	 * ======================================================================== */
	
	// CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)
	// ============================================================
	
	function transitionEnd() {
	    var el = document.createElement("bootstrap");
	
	    var transEndEventNames = {
	        WebkitTransition: "webkitTransitionEnd",
	        MozTransition: "transitionend",
	        OTransition: "oTransitionEnd otransitionend",
	        transition: "transitionend"
	    };
	
	    for (var name in transEndEventNames) {
	        if (el.style[name] !== undefined) {
	            return {
	                end: transEndEventNames[name]
	            };
	        }
	    }
	
	    return false; // explicit for ie8 (  ._.)
	}
	
	// http://blog.alexmaccaw.com/css-transitions
	$.fn.emulateTransitionEnd = function (duration) {
	    var called = false;
	    var $el = this;
	    $(this).one("bsTransitionEnd", function () {
	        called = true;
	    });
	    var callback = function callback() {
	        if (!called) {
	            $($el).trigger($.support.transition.end);
	        }
	    };
	
	    setTimeout(callback, duration);
	    return this;
	};
	
	$(function () {
	    $.support.transition = transitionEnd();
	
	    if (!$.support.transition) {
	        return;
	    }
	
	    $.event.special.bsTransitionEnd = {
	        bindType: $.support.transition.end,
	        delegateType: $.support.transition.end,
	        handle: function handle(e) {
	            if ($(e.target).is(this)) {
	                return e.handleObj.handler.apply(this, arguments);
	            }
	        }
	    };
	});
	
	/**
	 * Changes the viewport meta tag to the given contentString. Invokes callback
	 * after viewport meta tag changes have taken effect.
	 *
	 * TODO(david): Return a promise instead of invoking a callback.
	 */
	function changeViewportTag(contentString, callback) {
	    var scrollX = window.scrollX;
	    var scrollY = window.scrollY;
	
	    var viewport = document.querySelector("meta[name=viewport]");
	    if (viewport) {
	        viewport.setAttribute("content", contentString);
	    } else {
	        $("head").append("<meta name=\"viewport\" content=\"" + contentString + "\">");
	    }
	
	    // Hacky way to get the page to take the changes
	    // From http://stackoverflow.com/a/36894653
	    document.body.style.opacity = 0.9999;
	
	    // ... and undo the temporary change.
	    setTimeout(function () {
	        document.body.style.opacity = 1;
	
	        // ... which involves restoring the scroll position, which may have
	        // changed.
	        window.scrollTo(scrollX, scrollY);
	
	        // Invoke callback on the next tick to wait for scroll position to have
	        // finished resetting.
	        callback && setTimeout(callback, 0);
	    }, 0);
	}
	
	/**
	 * The zoom service
	 */
	function ZoomService() {}
	
	ZoomService.prototype._initialize = function (enableMobilePinch) {
	    // Check to see if the service is already initialized
	    if (this._$document) {
	        return;
	    }
	    this._activeZoom = this._initialScrollPosition = this._initialTouchPosition = this._touchMoveListener = null;
	
	    this._$document = $(document);
	    this._$window = $(window);
	    this._$body = $(document.body);
	
	    this._boundClick = $.proxy(this._clickHandler, this);
	
	    this._enableMobilePinch = enableMobilePinch;
	};
	
	ZoomService.prototype.handleZoomClick = function (e, enableMobilePinch) {
	    var _this = this;
	
	    this._initialize(enableMobilePinch);
	    var target = e.target;
	
	    if (!target || target.tagName !== "IMG") {
	        return;
	    }
	
	    if (this._$body.hasClass("zoom-overlay-open")) {
	        return;
	    }
	
	    if (e.metaKey || e.ctrlKey) {
	        return window.open(e.target.src, "_blank");
	    }
	
	    if (!enableMobilePinch && target.width >= window.innerWidth - Zoom.getOffset()) {
	        return;
	    }
	
	    this._activeZoomClose(true);
	
	    // Enable page zooming in (i.e. make sure there's no maximum-scale). Also,
	    // disable page zoom out on mobile devices, because the container that the
	    // image is placed in becomes bigger than the viewport if the page can be
	    // zoomed out. We explored other fixes like fixing the overlay and page
	    // size to be the viewport, but thought that might be even worse of a hack.
	    // See for more info:
	    // http://dbushell.com/2013/09/10/css-fixed-positioning-and-mobile-zoom/
	    if (enableMobilePinch) {
	        // Disable zoom out by setting minimum scale of 1 on the viewport tag.
	        changeViewportTag("width=device-width, initial-scale=1, minimum-scale=1", function () {
	            return _this._zoom(target);
	        });
	    } else {
	        this._zoom(target);
	    }
	
	    if (!enableMobilePinch) {
	        // todo(fat): probably worth throttling this
	        this._$window.on("scroll.zoom", $.proxy(this._scrollHandler, this));
	
	        this._$document.on("keyup.zoom", $.proxy(this._keyHandler, this));
	        this._$document.on("touchstart.zoom", $.proxy(this._touchStart, this));
	    }
	
	    // we use a capturing phase here to prevent unintended js events
	    // sadly no useCapture in jquery api (http://bugs.jquery.com/ticket/14953)
	    document.addEventListener("click", this._boundClick, true);
	
	    e.stopPropagation();
	};
	
	ZoomService.prototype._zoom = function (target) {
	    this._activeZoom = new Zoom(target, this._enableMobilePinch);
	    this._activeZoom.zoomImage();
	};
	
	ZoomService.prototype._activeZoomClose = function (forceDispose) {
	    var _this2 = this;
	
	    if (!this._activeZoom) {
	        return;
	    }
	
	    if (forceDispose) {
	        this._activeZoom.dispose();
	        this._disposeActiveZoom();
	    } else {
	        // Reset any underlying page zoom in case the user had pinched to zoom.
	        changeViewportTag("width=device-width, initial-scale=1, minimum-scale=1,\n            maximum-scale=1", function () {
	            if (_this2._activeZoom) {
	                _this2._activeZoom.close();
	                _this2._disposeActiveZoom();
	            }
	        });
	    }
	};
	
	ZoomService.prototype._disposeActiveZoom = function () {
	    this._$window.off(".zoom");
	    this._$document.off(".zoom");
	
	    document.removeEventListener("click", this._boundClick, true);
	
	    this._activeZoom = null;
	};
	
	ZoomService.prototype._scrollHandler = function (e) {
	    if (this._initialScrollPosition === null) {
	        this._initialScrollPosition = window.scrollY;
	    }
	    var deltaY = this._initialScrollPosition - window.scrollY;
	    if (Math.abs(deltaY) >= 40) {
	        this._activeZoomClose();
	    }
	};
	
	ZoomService.prototype._keyHandler = function (e) {
	    if (e.keyCode === 27) {
	        this._activeZoomClose();
	    }
	};
	
	ZoomService.prototype._clickHandler = function (e) {
	    e.stopPropagation();
	    e.preventDefault();
	    this._activeZoomClose();
	};
	
	ZoomService.prototype._touchStart = function (e) {
	    // Our jQuery doesn't include `touches` in its event
	    // TODO(kevindangoor) Remove `originalEvent` once jQuery is updated
	    this._initialTouchPosition = e.originalEvent.touches[0].pageY;
	    $(e.target).on("touchmove.zoom", $.proxy(this._touchMove, this));
	};
	
	ZoomService.prototype._touchMove = function (e) {
	    // Our jQuery doesn't include `touches` in its event
	    // TODO(kevindangoor) Remove `originalEvent` once jQuery is updated
	    if (Math.abs(e.originalEvent.touches[0].pageY - this._initialTouchPosition) > 10) {
	        this._activeZoomClose();
	        $(e.target).off("touchmove.zoom");
	    }
	};
	
	/**
	 * The zoom object
	 */
	function Zoom(img, enableMobilePinch) {
	    this._fullHeight = this._fullWidth = this._overlay = null;
	
	    this._targetImage = img;
	    this._enableMobilePinch = enableMobilePinch;
	
	    this._$body = $(document.body);
	}
	
	/** Margin around the image when in the "zoomed"/lightbox state. */
	Zoom._OFFSET = 80;
	Zoom._MAX_WIDTH = 2560;
	Zoom._MAX_HEIGHT = 4096;
	
	Zoom.getOffset = function (zoomToFitOnMobile) {
	    return zoomToFitOnMobile ? 0 : Zoom._OFFSET;
	};
	
	Zoom.prototype.getOffset = function () {
	    return Zoom.getOffset(this._enableMobilePinch);
	};
	
	Zoom.prototype.zoomImage = function () {
	    var img = document.createElement("img");
	    var $zoomedImage = $(img);
	
	    img.onload = function () {
	        // Load the image without specifying height and width so that we can find
	        // the true height and width.
	        this._fullHeight = Number(img.height);
	        this._fullWidth = Number(img.width);
	
	        // Set up our image to mirror the current image on the document.
	        var imageOffset = this._imageOffset = $(this._targetImage).offset();
	
	        // Position the image using viewport-fixed coordinates so that it is
	        // exactly over the image on the document.
	        //
	        // Said another way ... get the coordinates of the image relative to
	        // the viewport, and use those to position our new image (which is
	        // absolutely positioned within a full-bleed fixed-position container).
	        var left = this._left = imageOffset.left - $(window).scrollLeft();
	        var top = this._top = imageOffset.top - $(window).scrollTop();
	
	        $zoomedImage.css({
	            left: left,
	            top: top,
	            width: this._targetImage.width,
	            height: this._targetImage.height
	        });
	
	        this._zoomOriginal();
	    }.bind(this);
	
	    img.src = this._targetImage.src;
	
	    this.$zoomedImage = $zoomedImage;
	};
	
	Zoom.prototype._zoomOriginal = function () {
	    this.$zoomedImage.addClass("zoom-img").attr("data-action", "zoom-out");
	    $(this._targetImage).css("visibility", "hidden");
	
	    this._backdrop = document.createElement("div");
	    this._backdrop.className = "zoom-backdrop";
	    document.body.appendChild(this._backdrop);
	
	    this._overlay = document.createElement("div");
	    this._overlay.className = "zoom-overlay";
	
	    document.body.appendChild(this._overlay);
	    this._overlay.appendChild(this.$zoomedImage[0]);
	
	    this._calculateZoom();
	    this._triggerAnimation();
	};
	
	Zoom.prototype._calculateZoom = function () {
	    var originalFullImageWidth = this._fullWidth;
	    var originalFullImageHeight = this._fullHeight;
	    var viewportHeight = window.innerHeight - this.getOffset();
	    var viewportWidth = window.innerWidth - this.getOffset();
	
	    var maxScaleFactor = originalFullImageWidth / this._targetImage.width;
	
	    // Zoom to fit the viewport.
	    var imageAspectRatio = originalFullImageWidth / originalFullImageHeight;
	    var viewportAspectRatio = viewportWidth / viewportHeight;
	
	    if (originalFullImageWidth < viewportWidth && originalFullImageHeight < viewportHeight) {
	        this._imgScaleFactor = maxScaleFactor;
	    } else if (imageAspectRatio < viewportAspectRatio) {
	        this._imgScaleFactor = viewportHeight / originalFullImageHeight * maxScaleFactor;
	    } else {
	        this._imgScaleFactor = viewportWidth / originalFullImageWidth * maxScaleFactor;
	    }
	};
	
	Zoom.prototype._triggerAnimation = function () {
	    var viewportY = $(window).scrollTop() + window.innerHeight / 2;
	    var viewportX = $(window).scrollLeft() + window.innerWidth / 2;
	
	    var scaleFactor = this._imgScaleFactor;
	
	    var imageCenterY = this._imageOffset.top + this._targetImage.height / 2;
	    var imageCenterX = this._imageOffset.left + this._targetImage.width / 2;
	
	    this._translateY = (viewportY - imageCenterY) / scaleFactor;
	    this._translateX = (viewportX - imageCenterX) / scaleFactor;
	
	    // NOTE: This is re-used below.
	    this._zoomedInTransformString = "\n        scale(" + scaleFactor + ")\n        translate3d(" + this._translateX + "px, " + this._translateY + "px, 0)\n    ";
	
	    this.$zoomedImage.css({
	        transform: this._zoomedInTransformString
	    }).addClass("zoom-transition").one($.support.transition.end, $.proxy(this._onZoomInFinish, this)).emulateTransitionEnd(300);
	
	    this._$body.addClass("zoom-overlay-open");
	};
	
	Zoom.prototype._onZoomInFinish = function () {
	    // Remove the transform on the image, but make it look exactly the same as
	    // the image with the transform -- full-size and centered in the viewport
	    // -- using margins + left/top + scroll
	    //
	    // We need to remove the transform for scrolling to work -- the browser
	    // would still calculate the element position/sizing by its pre-transform
	    // dimensions.
	
	    var height = this._targetImage.height * this._imgScaleFactor;
	    var width = this._targetImage.width * this._imgScaleFactor;
	    var left = 0;
	    var top = 0;
	    var marginLeft = 0;
	    var marginTop = 0;
	    var scrollLeft = 0;
	    var scrollTop = 0;
	
	    // Horizontally center the image within the viewport, either by positioning
	    // with CSS or scrolling the viewport.
	    if (width < window.innerWidth) {
	        left = "50%";
	        marginLeft = -width / 2;
	    } else {
	        scrollLeft = (width - window.innerWidth) / 2;
	    }
	
	    // ... and similarly, vertically center the image within the viewport.
	    if (height < window.innerHeight) {
	        top = "50%";
	        marginTop = -height / 2;
	    } else {
	        scrollTop = (height - window.innerHeight) / 2;
	    }
	
	    this.$zoomedImage.css({
	        height: height,
	        left: left,
	        marginLeft: marginLeft,
	        marginTop: marginTop,
	        top: top,
	        transform: "",
	        width: width
	    }).removeClass("zoom-transition");
	
	    $(this._overlay).scrollLeft(scrollLeft).scrollTop(scrollTop);
	};
	
	Zoom.prototype.close = function () {
	    var _this3 = this;
	
	    this._$body.removeClass("zoom-overlay-open").addClass("zoom-overlay-transitioning");
	
	    // Upon closing the image, zoom it back out. Do this by first re-applying the
	    // zoomed-in transform and resetting the CSS top/left + margins to what it
	    // was right after zooming in -- basically undoing what we did in
	    // _onZoomInFinish.
	    // TODO(david): Adjust this translation of the transform to take into
	    //     account the current scroll position of the image (if the user
	    //     scrolled the image after it was zoomed).
	    this.$zoomedImage.css({
	        height: this._targetImage.height,
	        left: this._left,
	        marginLeft: 0,
	        marginTop: 0,
	        top: this._top,
	        transform: this._zoomedInTransformString,
	        width: this._targetImage.width
	    }).removeClass("zoom-transition");
	
	    $(this._overlay).scrollLeft(0).scrollTop(0);
	
	    // ... now that the image and its container have been set up to be in the
	    // same state as right at the end of the zoom-in animation, reset the
	    // transform to scale(1) to achieve the zoom-out-into-image-on-document
	    // animation.
	    setTimeout(function () {
	        _this3.$zoomedImage.css({
	            transform: "scale(1)"
	        }).addClass("zoom-transition").one($.support.transition.end, $.proxy(_this3.dispose, _this3)).emulateTransitionEnd(300);
	    }, 10);
	};
	
	Zoom.prototype.dispose = function () {
	    if (this.$zoomedImage && this.$zoomedImage[0].parentNode) {
	        this.$zoomedImage.remove();
	        this.$zoomedImage = null;
	
	        this._overlay.parentNode.removeChild(this._overlay);
	        this._backdrop.parentNode.removeChild(this._backdrop);
	
	        this._$body.removeClass("zoom-overlay-transitioning");
	    }
	    $(this._targetImage).css("visibility", "visible");
	};
	
	exports.ZoomService = new ZoomService();

/***/ },
/* 193 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A generic tooltip library for React.js
	 *
	 * This should eventually end up in react-components
	 *
	 * Interface: ({a, b} means one of a or b)
	 * const Tooltip = require("./tooltip.jsx");
	 * <Tooltip
	 *     className="class-for-tooltip-contents"
	 *     horizontalPosition="left" // one of "left", "right"
	 *     horizontalAlign="left" // one of "left", "right"
	 *     verticalPosition="bottom" // one of "top", "bottom"
	 *     arrowSize={10} // arrow size in pixels
	 *     borderColor="#ccc" // color of the border for the tooltip
	 *     show={true} // whether the tooltip should currently be visible
	 *     targetContainerStyle={targetContainerStyle}
	 * >
	 *     <TargetElementOfTheTooltip />
	 *     <TooltipContents1 />
	 *     <TooltipContents2 />
	 * </Tooltip>
	 *
	 * To show/hide the tooltip, the parent component should call the
	 * .show() and .hide() methods of the tooltip when appropriate.
	 * (These are usually set up as handlers of events on the target element.)
	 *
	 * Notes:
	 *     className should not specify a border; that is handled by borderColor
	 *     so that the arrow and tooltip match
	 */
	
	//          __,,--``\\
	//  _,,-''``         \\     ,
	// '----------_.------'-.___|\__
	//    _.--''``    `)__   )__   @\__
	//   (  .. ''---/___,,E/__,E'------`
	//    `-''`''
	// Here be dragons.
	
	// TODO(joel/aria) fix z-index issues https://s3.amazonaws.com/uploads.hipchat.com/6574/29028/yOApjwmgiMhEZYJ/Screen%20Shot%202014-05-30%20at%203.34.18%20PM.png
	// z-index: 3 on perseus-formats-tooltip seemed to work
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var zIndex = 10;
	
	var Triangle = React.createClass({
	    displayName: "Triangle",
	
	    propTypes: {
	        color: React.PropTypes.string.isRequired,
	        left: React.PropTypes.number.isRequired,
	        "top": React.PropTypes.number.isRequired,
	        width: React.PropTypes.number.isRequired,
	        height: React.PropTypes.number.isRequired,
	        horizontalDirection: React.PropTypes.oneOf(["left", "right"]).isRequired,
	        verticalDirection: React.PropTypes.oneOf(["top", "bottom"]).isRequired
	    },
	
	    render: function render() {
	        var borderLeft = void 0;
	        var borderRight = void 0;
	        var borderTop = void 0;
	        var borderBottom = void 0;
	
	        var hBorder = this.props.width + "px solid transparent";
	        if (this.props.horizontalDirection === "right") {
	            borderLeft = hBorder;
	        } else {
	            borderRight = hBorder;
	        }
	
	        var vBorder = this.props.height + "px solid " + this.props.color;
	        if (this.props.verticalDirection === "top") {
	            borderTop = vBorder;
	        } else {
	            borderBottom = vBorder;
	        }
	
	        return React.createElement("div", {
	            style: {
	                display: "block",
	                height: 0,
	                width: 0,
	                position: "absolute",
	                left: this.props.left,
	                "top": this.props["top"],
	                borderLeft: borderLeft,
	                borderRight: borderRight,
	                borderTop: borderTop,
	                borderBottom: borderBottom
	            }
	        });
	    }
	});
	
	var TooltipArrow = React.createClass({
	    displayName: "TooltipArrow",
	
	    propTypes: {
	        position: React.PropTypes.string,
	        visibility: React.PropTypes.string,
	        left: React.PropTypes.number,
	        "top": React.PropTypes.number,
	        color: React.PropTypes.string.isRequired, // a css color
	        border: React.PropTypes.string.isRequired, // a css color
	        width: React.PropTypes.number.isRequired,
	        height: React.PropTypes.number.isRequired,
	        horizontalDirection: React.PropTypes.oneOf(["left", "right"]).isRequired,
	        verticalDirection: React.PropTypes.oneOf(["top", "bottom"]).isRequired
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            position: "relative",
	            visibility: "visible",
	            left: 0,
	            "top": 0
	        };
	    },
	
	    // TODO(aria): Think about adding a box-shadow to the triangle here
	    // See http://css-tricks.com/triangle-with-shadow/
	    render: function render() {
	        //const isRight = (this.props.horizontalDirection === "right");
	        var isTop = this.props.verticalDirection === "top";
	
	        var frontTopOffset = isTop ? 0 : 1;
	        var borderTopOffset = isTop ? 0 : -1;
	
	        return React.createElement(
	            "div",
	            { style: {
	                    display: "block",
	                    position: this.props.position,
	                    visibility: this.props.visibility,
	                    left: this.props.left,
	                    "top": this.props["top"],
	                    width: this.props.width + 2,
	                    height: this.props.height + 1,
	                    marginTop: -1,
	                    marginBottom: -2,
	                    zIndex: zIndex
	                }
	            },
	            React.createElement(Triangle, {
	                horizontalDirection: this.props.horizontalDirection,
	                verticalDirection: this.props.verticalDirection,
	                color: this.props.border,
	                left: 0,
	                top: borderTopOffset,
	                width: this.props.width + 2 // one extra for the diagonal
	                , height: this.props.height + 2
	            }),
	            React.createElement(Triangle, {
	                horizontalDirection: this.props.horizontalDirection,
	                verticalDirection: this.props.verticalDirection,
	                color: this.props.color,
	                left: 1,
	                top: frontTopOffset,
	                width: this.props.width,
	                height: this.props.height
	            })
	        );
	    }
	});
	
	var VERTICAL_CORNERS = {
	    "top": {
	        "top": "-100%"
	    },
	    bottom: {
	        "top": 0
	    }
	};
	
	var HORIZONTAL_CORNERS = {
	    left: {
	        targetLeft: 0
	    },
	
	    right: {
	        targetLeft: "100%"
	    }
	};
	
	var HORIZONTAL_ALIGNMNENTS = {
	    left: {
	        tooltipLeft: 0,
	        arrowLeft: function arrowLeft(arrowSize) {
	            return 0;
	        }
	    },
	    right: {
	        tooltipLeft: "-100%",
	        arrowLeft: function arrowLeft(arrowSize) {
	            return -arrowSize - 2;
	        }
	    }
	};
	
	var Tooltip = React.createClass({
	    displayName: "Tooltip",
	
	    propTypes: {
	        show: React.PropTypes.bool.isRequired,
	        className: React.PropTypes.string,
	        arrowSize: React.PropTypes.number,
	        borderColor: React.PropTypes.string,
	        verticalPosition: React.PropTypes.oneOf(Object.keys(VERTICAL_CORNERS)),
	        horizontalPosition: React.PropTypes.oneOf(Object.keys(HORIZONTAL_CORNERS)),
	        horizontalAlign: React.PropTypes.oneOf(Object.keys(HORIZONTAL_ALIGNMNENTS)),
	        children: React.PropTypes.arrayOf(React.PropTypes.element).isRequired,
	        targetContainerStyle: React.PropTypes.any // style object
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            className: "",
	            arrowSize: 10,
	            borderColor: "#ccc",
	            verticalPosition: "bottom",
	            horizontalPosition: "left",
	            horizontalAlign: "left",
	            targetContainerStyle: {}
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            height: null // used for offsetting "top" positioned tooltips
	        };
	    },
	
	    componentDidMount: function componentDidMount() {
	        this._updateHeight();
	    },
	
	    componentWillReceiveProps: function componentWillReceiveProps() {
	        // If the contents have changed, reset our measure of the height
	        this.setState({ height: null });
	    },
	
	    componentDidUpdate: function componentDidUpdate() {
	        this._updateHeight();
	    },
	
	    _renderToolTipDiv: function _renderToolTipDiv(isTooltipAbove) {
	        var settings = Object.assign({}, HORIZONTAL_CORNERS[this.props.horizontalPosition], HORIZONTAL_ALIGNMNENTS[this.props.horizontalAlign], VERTICAL_CORNERS[this.props.verticalPosition]);
	
	        var arrowAbove = void 0;
	        var arrowBelow = void 0;
	
	        if (isTooltipAbove) {
	            // We put an absolutely positioned arrow in the correct place
	            arrowAbove = React.createElement(TooltipArrow, {
	                verticalDirection: "top",
	                horizontalDirection: this.props.horizontalAlign,
	                position: "absolute",
	                color: "white",
	                border: this.props.borderColor,
	                left: settings.arrowLeft(this.props.arrowSize),
	                top: -this.props.arrowSize + 2,
	                width: this.props.arrowSize,
	                height: this.props.arrowSize,
	                zIndex: zIndex
	            });
	
	            // And we use a visibility: hidden arrow below to shift up the
	            // content by the correct amount
	            arrowBelow = React.createElement(TooltipArrow, {
	                verticalDirection: "top",
	                horizontalDirection: this.props.horizontalAlign,
	                visibility: "hidden",
	                color: "white",
	                border: this.props.borderColor,
	                left: settings.arrowLeft(this.props.arrowSize),
	                top: -1,
	                width: this.props.arrowSize,
	                height: this.props.arrowSize,
	                zIndex: zIndex
	            });
	        } else {
	            arrowAbove = React.createElement(TooltipArrow, {
	                verticalDirection: "bottom",
	                horizontalDirection: this.props.horizontalAlign,
	                color: "white",
	                border: this.props.borderColor,
	                left: settings.arrowLeft(this.props.arrowSize),
	                top: -1,
	                width: this.props.arrowSize,
	                height: this.props.arrowSize,
	                zIndex: zIndex
	            });
	
	            arrowBelow = null;
	        }
	
	        /* A positioned div below the input to be the parent for our
	            tooltip */
	        return React.createElement(
	            "div",
	            { style: {
	                    position: "relative",
	                    height: 0,
	                    display: this.props.show ? "block" : "none"
	                }
	            },
	            React.createElement(
	                "div",
	                { ref: "tooltipContainer", className: "tooltipContainer", style: {
	                        position: "absolute",
	                        // height must start out undefined, not null, so that
	                        // we can measure the actual height with jquery.
	                        // This is used to position the tooltip with top: -100%
	                        // when in verticalPosition: "top" mode
	                        height: this.state.height || undefined,
	                        left: settings.targetLeft
	                    }
	                },
	                arrowAbove,
	                React.createElement(
	                    "div",
	                    { className: this.props.className,
	                        ref: "tooltipContent",
	                        style: {
	                            position: "relative",
	                            top: settings["top"],
	                            left: settings.tooltipLeft,
	                            border: "1px solid " + this.props.borderColor,
	                            WebkitBoxShadow: "0 1px 3px " + this.props.borderColor,
	                            MozBoxShadow: "0 1px 3px " + this.props.borderColor,
	                            boxShadow: "0 1px 3px " + this.props.borderColor,
	                            zIndex: zIndex - 1
	                        }
	                    },
	                    this.props.children.slice(1)
	                ),
	                arrowBelow
	            )
	        );
	    },
	
	    _updateHeight: function _updateHeight() {
	        var height = ReactDOM.findDOMNode(this.refs.tooltipContainer).offsetHeight;
	        if (height !== this.state.height) {
	            this.setState({ height: height });
	        }
	    },
	
	    render: function render() {
	        var isTooltipAbove = this.props.verticalPosition === "top";
	
	        /* We wrap the entire output in a span so that it displays inline */
	        return React.createElement(
	            "span",
	            null,
	            isTooltipAbove && this._renderToolTipDiv(isTooltipAbove),
	            React.createElement(
	                "div",
	                { style: this.props.targetContainerStyle },
	                this.props.children[0]
	            ),
	            !isTooltipAbove && this._renderToolTipDiv()
	        );
	    }
	});
	
	// Sorry.  // Apology-Oriented-Programming
	module.exports = Tooltip;

/***/ },
/* 194 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable react/prop-types, react/sort-comp */
	
	var classNames = __webpack_require__(86);
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var _ = __webpack_require__(56);
	
	var TexButtons = __webpack_require__(195);
	
	// TODO(alex): Package MathQuill
	var MathQuill = window.MathQuill;
	var PT = React.PropTypes;
	
	// A WYSIWYG math input that calls `onChange(LaTeX-string)`
	var MathInput = React.createClass({
	    displayName: "MathInput",
	
	    propTypes: {
	        value: PT.string,
	        onChange: PT.func.isRequired,
	        convertDotToTimes: PT.bool,
	        buttonsVisible: PT.oneOf(["always", "never", "focused"]),
	        buttonSets: TexButtons.buttonSetsType.isRequired,
	        labelText: React.PropTypes.string,
	        onFocus: PT.func,
	        onBlur: PT.func
	    },
	
	    render: function render() {
	        var className = classNames({
	            "perseus-math-input": true,
	
	            // mathquill usually adds these itself but react removes them when
	            // updating the component.
	            "mq-editable-field": true,
	            "mq-math-mode": true
	        });
	
	        if (this.props.className) {
	            className = className + " " + this.props.className;
	        }
	
	        var buttons = null;
	        if (this._shouldShowButtons()) {
	            buttons = React.createElement(TexButtons, {
	                sets: this.props.buttonSets,
	                className: "math-input-buttons absolute",
	                convertDotToTimes: this.props.convertDotToTimes,
	                onInsert: this.insert
	            });
	        }
	
	        return React.createElement(
	            "div",
	            { style: { display: "inline-block" } },
	            React.createElement(
	                "div",
	                { style: { display: "inline-block" } },
	                React.createElement("span", {
	                    className: className,
	                    ref: "mathinput",
	                    "aria-label": this.props.labelText,
	                    onFocus: this.handleFocus,
	                    onBlur: this.handleBlur
	                })
	            ),
	            React.createElement(
	                "div",
	                { style: { position: "relative" } },
	                buttons
	            )
	        );
	    },
	
	    // handlers:
	    // keep track of two related bits of state:
	    // * this.state.focused - whether the buttons are currently shown
	    // * this.mouseDown - whether a mouse click is active that started in the
	    //   buttons div
	
	    handleFocus: function handleFocus() {
	        this.setState({ focused: true });
	        // TODO(joel) fix properly - we should probably allow onFocus handlers
	        // to this property, but we need to work correctly with them.
	        // if (this.props.onFocus) {
	        //     this.props.onFocus();
	        // }
	    },
	
	    handleMouseDown: function handleMouseDown(event) {
	        var focused = ReactDOM.findDOMNode(this).contains(event.target);
	        this.mouseDown = focused;
	        if (!focused) {
	            this.setState({ focused: false });
	        }
	    },
	
	    handleMouseUp: function handleMouseUp() {
	        // this mouse click started in the buttons div so we should focus the
	        // input
	        if (this.mouseDown) {
	            this.focus();
	        }
	        this.mouseDown = false;
	    },
	
	    handleBlur: function handleBlur() {
	        if (!this.mouseDown) {
	            this.setState({ focused: false });
	        }
	    },
	
	    _shouldShowButtons: function _shouldShowButtons() {
	        if (this.props.buttonsVisible === "always") {
	            return true;
	        } else if (this.props.buttonsVisible === "never") {
	            return false;
	        } else {
	            return this.state.focused;
	        }
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            value: "",
	            convertDotToTimes: false,
	            buttonsVisible: "focused"
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return { focused: false };
	    },
	
	    insert: function insert(value) {
	        var input = this.mathField();
	        if (_(value).isFunction()) {
	            value(input);
	        } else if (value[0] === "\\") {
	            input.cmd(value).focus();
	        } else {
	            input.write(value).focus();
	        }
	        input.focus();
	    },
	
	    mathField: function mathField(options) {
	        // The MathQuill API is now "versioned" through its own "InterVer"
	        // system.
	        // See: https://github.com/mathquill/mathquill/pull/459
	        var MQ = MathQuill.getInterface(2);
	
	        // MathQuill.MathField takes a DOM node, MathQuill-ifies it if it's
	        // seeing that node for the first time, then returns the associated
	        // MathQuill object for that node. It is stable - will always return
	        // the same object when called on the same DOM node.
	        return MQ.MathField(ReactDOM.findDOMNode(this.refs.mathinput), options);
	    },
	
	    componentWillUnmount: function componentWillUnmount() {
	        window.removeEventListener("mousedown", this.handleMouseDown);
	        window.removeEventListener("mouseup", this.handleMouseUp);
	    },
	
	    componentDidMount: function componentDidMount() {
	        var _this = this;
	
	        window.addEventListener("mousedown", this.handleMouseDown);
	        window.addEventListener("mouseup", this.handleMouseUp);
	
	        var initialized = false;
	
	        // Initialize MathQuill.MathField instance
	        this.mathField({
	            // LaTeX commands that, when typed, are immediately replaced by the
	            // appropriate symbol. This does not include ln, log, or any of the
	            // trig functions; those are always interpreted as commands.
	            autoCommands: "pi theta phi sqrt nthroot",
	
	            // Pop the cursor out of super/subscripts on arithmetic operators
	            // or (in)equalities.
	            charsThatBreakOutOfSupSub: "+-*/=<>≠≤≥",
	
	            // Prevent excessive super/subscripts or fractions from being
	            // created without operands, e.g. when somebody holds down a key
	            supSubsRequireOperand: true,
	
	            // The name of this option is somewhat misleading, as tabbing in
	            // MathQuill breaks you out of a nested context (fraction/script)
	            // if you're in one, but moves focus to the next input if you're
	            // not. Spaces (with this option enabled) are just ignored in the
	            // latter case.
	            //
	            // TODO(alex): In order to allow inputting mixed numbers, we will
	            // have to accept spaces in certain cases. The desired behavior is
	            // still to escape nested contexts if currently in one, but to
	            // insert a space if not (we don't expect mixed numbers in nested
	            // contexts). We should also limit to one consecutive space.
	            spaceBehavesLikeTab: true,
	
	            handlers: {
	                edited: function edited(mathField) {
	                    // This handler is guaranteed to be called on change, but
	                    // unlike React it sometimes generates false positives.
	                    // One of these is on initialization (with an empty string
	                    // value), so we have to guard against that below.
	                    var value = mathField.latex();
	
	                    // Provide a MathQuill-compatible way to generate the
	                    // not-equals sign without pasting unicode or typing TeX
	                    value = value.replace(/<>/g, "\\ne");
	
	                    // Use the specified symbol to represent multiplication
	                    // TODO(alex): Add an option to disallow variables, in
	                    // which case 'x' should get converted to '\\times'
	                    if (_this.props.convertDotToTimes) {
	                        value = value.replace(/\\cdot/g, "\\times");
	
	                        // Preserve cursor position in the common case:
	                        // typing '*' to insert a multiplication sign.
	                        // We do this by modifying internal MathQuill state
	                        // directly, instead of waiting for `.latex()` to be
	                        // called in `componentDidUpdate()`.
	                        var left = mathField.__controller.cursor[MathQuill.L];
	                        if (left && left.ctrlSeq === "\\cdot ") {
	                            mathField.__controller.backspace();
	                            mathField.cmd("\\times");
	                        }
	                    } else {
	                        value = value.replace(/\\times/g, "\\cdot");
	                    }
	
	                    if (initialized && _this.props.value !== value) {
	                        _this.props.onChange(value);
	                    }
	                },
	                enter: function enter() {
	                    // This handler is called when the user presses the enter
	                    // key. Since this isn't an actual <input> element, we have
	                    // to manually trigger the usually automatic form submit.
	                    $(ReactDOM.findDOMNode(_this.refs.mathinput)).submit();
	                },
	                upOutOf: function upOutOf(mathField) {
	                    // This handler is called when the user presses the up
	                    // arrow key, but there is nowhere in the expression to go
	                    // up to (no numerator or exponent). For ease of use,
	                    // interpret this as an attempt to create an exponent.
	                    mathField.typedText("^");
	                }
	            }
	        });
	
	        // Ideally, we would be able to pass an initial value directly into
	        // the constructor above
	        this.mathField().latex(this.props.value);
	
	        initialized = true;
	    },
	
	    componentDidUpdate: function componentDidUpdate() {
	        if (!_.isEqual(this.mathField().latex(), this.props.value)) {
	            this.mathField().latex(this.props.value);
	        }
	    },
	
	    focus: function focus() {
	        this.mathField().focus();
	        this.setState({ focused: true });
	    },
	
	    blur: function blur() {
	        this.mathField().blur();
	        this.setState({ focused: false });
	    }
	});
	
	module.exports = MathInput;

/***/ },
/* 195 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable react/prop-types, react/sort-comp */
	
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	var TeX = __webpack_require__(178);
	
	var prettyBig = { fontSize: "150%" };
	var slightlyBig = { fontSize: "120%" };
	var symbStyle = { fontSize: "130%" };
	
	// These are functions because we want to generate a new component for each use
	// on the page rather than reusing an instance (which will cause an error).
	// Also, it's useful for things which might look different depending on the
	// props.
	
	var basic = [function () {
	    return [React.createElement(
	        "span",
	        { key: "plus", style: slightlyBig },
	        "+"
	    ), "+"];
	}, function () {
	    return [React.createElement(
	        "span",
	        { key: "minus", style: prettyBig },
	        "-"
	    ), "-"];
	},
	
	// TODO(joel) - display as \cdot when appropriate
	function (props) {
	    if (props.convertDotToTimes) {
	        return [React.createElement(
	            TeX,
	            { key: "times", style: prettyBig },
	            "\\times"
	        ), "\\times"];
	    } else {
	        return [React.createElement(
	            TeX,
	            { key: "times", style: prettyBig },
	            "\\cdot"
	        ), "\\cdot"];
	    }
	}, function () {
	    return [React.createElement(
	        TeX,
	        { key: "frac", style: prettyBig },
	        "\\frac{□}{□}"
	    ),
	
	    // If there's something in the input that can become part of a
	    // fraction, typing "/" puts it in the numerator. If not, typing
	    // "/" does nothing. In that case, enter a \frac.
	    function (input) {
	        var contents = input.latex();
	        input.typedText("/");
	        if (input.latex() === contents) {
	            input.cmd("\\frac");
	        }
	    }];
	}];
	
	var buttonSets = {
	    basic: basic,
	
	    "basic+div": basic.concat([function () {
	        return [React.createElement(
	            TeX,
	            { key: "div" },
	            "\\div"
	        ), "\\div"];
	    }]),
	
	    trig: [function () {
	        return [React.createElement(
	            TeX,
	            { key: "sin" },
	            "\\sin"
	        ), "\\sin"];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "cos" },
	            "\\cos"
	        ), "\\cos"];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "tan" },
	            "\\tan"
	        ), "\\tan"];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "theta", style: symbStyle },
	            "\\theta"
	        ), "\\theta"];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "pi", style: symbStyle },
	            "\\phi"
	        ), "\\phi"];
	    }],
	
	    prealgebra: [function () {
	        return [React.createElement(
	            TeX,
	            { key: "sqrt" },
	            "\\sqrt{x}"
	        ), "\\sqrt"];
	    },
	    // TODO(joel) - how does desmos do this?
	    function () {
	        return [React.createElement(
	            TeX,
	            { key: "nthroot" },
	            "\\sqrt[3]{x}"
	        ), function (input) {
	            input.typedText("nthroot3");
	            input.keystroke("Right");
	        }];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "pow", style: slightlyBig },
	            "\u25A1^a"
	        ), function (input) {
	            var contents = input.latex();
	            input.typedText("^");
	
	            // If the input hasn't changed (for example, if we're
	            // attempting to add an exponent on an empty input or an empty
	            // denominator), insert our own "a^b"
	            if (input.latex() === contents) {
	                input.typedText("a^b");
	            }
	        }];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "pi", style: slightlyBig },
	            "\\pi"
	        ), "\\pi"];
	    }],
	
	    logarithms: [function () {
	        return [React.createElement(
	            TeX,
	            { key: "log" },
	            "\\log"
	        ), "\\log"];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "ln" },
	            "\\ln"
	        ), "\\ln"];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "log_b" },
	            "\\log_b"
	        ), function (input) {
	            input.typedText("log_");
	            input.keystroke("Right");
	            input.typedText("(");
	            input.keystroke("Left");
	            input.keystroke("Left");
	        }];
	    }],
	
	    "basic relations": [function () {
	        return [React.createElement(
	            TeX,
	            { key: "eq" },
	            "="
	        ), "="];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "lt" },
	            "\\lt"
	        ), "\\lt"];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "gt" },
	            "\\gt"
	        ), "\\gt"];
	    }],
	
	    "advanced relations": [function () {
	        return [React.createElement(
	            TeX,
	            { key: "neq" },
	            "\\neq"
	        ), "\\neq"];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "leq" },
	            "\\leq"
	        ), "\\leq"];
	    }, function () {
	        return [React.createElement(
	            TeX,
	            { key: "geq" },
	            "\\geq"
	        ), "\\geq"];
	    }]
	};
	
	var buttonSetsType = React.PropTypes.arrayOf(React.PropTypes.oneOf(_(buttonSets).keys()));
	
	var TexButtons = React.createClass({
	    displayName: "TexButtons",
	
	    propTypes: {
	        sets: buttonSetsType.isRequired,
	        onInsert: React.PropTypes.func.isRequired
	    },
	
	    render: function render() {
	        var _this = this;
	
	        // Always show buttonSets in the same order. Note: Technically it's ok
	        // for _.keys() to return the keys in an arbitrary order, but in
	        // practice, they will be ordered as listed above.
	        var sortedButtonSets = _.sortBy(this.props.sets, function (setName) {
	            return _.keys(buttonSets).indexOf(setName);
	        });
	
	        var buttons = _(sortedButtonSets).map(function (setName) {
	            return buttonSets[setName];
	        });
	
	        var buttonRows = _(buttons).map(function (row) {
	            return row.map(function (symbGen) {
	                // create a (component, thing we should send to mathquill) pair
	                var symbol = symbGen(_this.props);
	                return React.createElement(
	                    "button",
	                    {
	                        onClick: function onClick() {
	                            return _this.props.onInsert(symbol[1]);
	                        },
	                        className: "tex-button",
	                        key: symbol[0].key,
	                        tabIndex: -1,
	                        type: "button"
	                    },
	                    symbol[0]
	                );
	            });
	        });
	
	        var buttonPopup = _(buttonRows).map(function (row, i) {
	            return React.createElement(
	                "div",
	                {
	                    className: "clearfix tex-button-row",
	                    key: _this.props.sets[i]
	                },
	                row
	            );
	        });
	
	        return React.createElement(
	            "div",
	            { className: this.props.className + " preview-measure" },
	            buttonPopup
	        );
	    },
	
	    statics: {
	        buttonSets: buttonSets,
	        buttonSetsType: buttonSetsType
	    }
	});
	
	module.exports = TexButtons;

/***/ },
/* 196 */
/***/ function(module, exports, __webpack_require__) {

	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var PT = React.PropTypes;
	
	// Takes an array of components to sort
	var SortableArea = React.createClass({
	    displayName: 'SortableArea',
	
	    propTypes: {
	        className: PT.string,
	        components: PT.arrayOf(PT.node).isRequired,
	        onReorder: PT.func.isRequired,
	        style: PT.any,
	        verify: PT.func
	    },
	    getDefaultProps: function getDefaultProps() {
	        return { verify: function verify() {
	                return true;
	            } };
	    },
	    getInitialState: function getInitialState() {
	        return {
	            // index of the component being dragged
	            dragging: null,
	            components: this.props.components
	        };
	    },
	    // Firefox refuses to drag an element unless you set data on it. Hackily
	    // add data each time an item is dragged.
	    componentDidMount: function componentDidMount() {
	        this._setDragEvents();
	    },
	    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        this.setState({ components: nextProps.components });
	    },
	    componentDidUpdate: function componentDidUpdate() {
	        this._setDragEvents();
	    },
	    // Alternatively send each handler to each component individually,
	    // partially applied
	    onDragStart: function onDragStart(startIndex) {
	        this.setState({ dragging: startIndex });
	    },
	    onDrop: function onDrop() {
	        // tell the parent component
	        this.setState({ dragging: null });
	        this.props.onReorder(this.state.components);
	    },
	    onDragEnter: function onDragEnter(enterIndex) {
	        // When a label is first dragged it triggers a dragEnter with itself,
	        // which we don't care about.
	        if (this.state.dragging === enterIndex) {
	            return;
	        }
	
	        var newComponents = this.state.components.slice();
	
	        // splice the tab out of its old position
	        var removed = newComponents.splice(this.state.dragging, 1);
	        // ... and into its new position
	        newComponents.splice(enterIndex, 0, removed[0]);
	
	        var verified = this.props.verify(newComponents);
	        if (verified) {
	            this.setState({
	                dragging: enterIndex,
	                components: newComponents
	            });
	        }
	        return verified;
	    },
	    _listenEvent: function _listenEvent(e) {
	        e.dataTransfer.setData('hackhackhack', 'because browsers!');
	    },
	    _cancelEvent: function _cancelEvent(e) {
	        // prevent the browser from redirecting to 'because browsers!'
	        e.preventDefault();
	    },
	    _setDragEvents: function _setDragEvents() {
	        this._dragItems = this._dragItems || [];
	        var items = ReactDOM.findDOMNode(this).querySelectorAll('[draggable=true]');
	
	        var oldItems = [];
	        var newItems = [];
	
	        for (var i = 0; i < this._dragItems.length; i++) {
	            var item = this._dragItems[i];
	            if (items.indexOf(item) < 0) {
	                oldItems.push(item);
	            }
	        }
	
	        for (var _i = 0; _i < items.length; _i++) {
	            var _item = items[_i];
	            if (this._dragItems.indexOf(_item) < 0) {
	                newItems.push(_item);
	            }
	        }
	
	        for (var _i2 = 0; _i2 < newItems.length; _i2++) {
	            var dragItem = newItems[_i2];
	            dragItem.addEventListener('dragstart', this._listenEvent);
	            dragItem.addEventListener('drop', this._cancelEvent);
	        }
	
	        for (var _i3 = 0; _i3 < oldItems.length; _i3++) {
	            var _dragItem = oldItems[_i3];
	            _dragItem.removeEventListener('dragstart', this._listenEvent);
	            _dragItem.removeEventListener('drop', this._cancelEvent);
	        }
	    },
	    render: function render() {
	        var _this = this;
	
	        var sortables = this.state.components.map(function (component, index) {
	            return React.createElement(SortableItem, {
	                index: index,
	                component: component,
	                area: _this,
	                key: component.key,
	                draggable: component.props.draggable,
	                dragging: index === _this.state.dragging
	            });
	        });
	        return React.createElement(
	            'ol',
	            { className: this.props.className, style: this.props.style },
	            sortables
	        );
	    }
	});
	
	// An individual sortable item
	var SortableItem = React.createClass({
	    displayName: 'SortableItem',
	
	    propTypes: {
	        area: PT.shape({
	            onDragEnter: PT.func.isRequired,
	            onDragStart: PT.func.isRequired,
	            onDrop: PT.func.isRequired
	        }),
	        component: PT.node.isRequired,
	        dragging: PT.bool.isRequired,
	        draggable: PT.bool.isRequired,
	        index: PT.number.isRequired
	    },
	    handleDragStart: function handleDragStart(e) {
	        e.nativeEvent.dataTransfer.effectAllowed = "move";
	        this.props.area.onDragStart(this.props.index);
	    },
	    handleDrop: function handleDrop() {
	        this.props.area.onDrop(this.props.index);
	    },
	    handleDragEnter: function handleDragEnter(e) {
	        var verified = this.props.area.onDragEnter(this.props.index);
	        // Ideally this would change the cursor based on whether this is a
	        // valid place to drop.
	        e.nativeEvent.dataTransfer.effectAllowed = verified ? "move" : "none";
	    },
	    handleDragOver: function handleDragOver(e) {
	        // allow a drop by preventing default handling
	        e.preventDefault();
	    },
	    render: function render() {
	        var dragState = "sortable-disabled";
	        if (this.props.dragging) {
	            dragState = "sortable-dragging";
	        } else if (this.props.draggable) {
	            dragState = "sortable-enabled";
	        }
	
	        return React.createElement(
	            'li',
	            { draggable: this.props.draggable,
	                className: dragState,
	                onDragStart: this.handleDragStart,
	                onDrop: this.handleDrop,
	                onDragEnter: this.handleDragEnter,
	                onDragOver: this.handleDragOver
	            },
	            this.props.component
	        );
	    }
	});
	
	module.exports = SortableArea;

/***/ },
/* 197 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable comma-dangle, no-var */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var _ = __webpack_require__(56);
	
	var WIDGET_PROP_BLACKLIST = __webpack_require__(93);
	
	var EditorJsonify = {
	    serialize: function serialize() {
	        // Omit props that get passed to all widgets
	        return _.omit(this.props, WIDGET_PROP_BLACKLIST);
	    }
	};
	
	module.exports = EditorJsonify;

/***/ },
/* 198 */
/***/ function(module, exports, __webpack_require__) {

	/* MultiButtonGroup is an aesthetically pleasing group of buttons,
	 * which allows multiple buttons to be selected at the same time.
	 *
	 * The class requires these properties:
	 *   buttons - an array of objects with keys:
	 *     "value": this is the value returned when the button is selected
	 *     "content": this is the JSX shown within the button, typically a string
	 *         that gets rendered as the button's display text
	 *     "title": this is the title-text shown on hover
	 *   onChange - a function that is provided with an array of the updated
	 *     values (which it then is responsible for updating)
	 *
	 * The class has these optional properties:
	 *   values - an array of the initial values of the buttons selected.
	 *
	 * Requires stylesheets/perseus-admin-package/editor.less to look nice.
	 */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var styles = __webpack_require__(177);
	var css = __webpack_require__(79).css;
	
	var MultiButtonGroup = React.createClass({
	    displayName: 'MultiButtonGroup',
	
	    propTypes: {
	        values: React.PropTypes.arrayOf(React.PropTypes.any),
	        buttons: React.PropTypes.arrayOf(React.PropTypes.shape({
	            value: React.PropTypes.any.isRequired,
	            content: React.PropTypes.node,
	            title: React.PropTypes.string
	        })).isRequired,
	        onChange: React.PropTypes.func.isRequired,
	        allowEmpty: React.PropTypes.bool
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            values: [],
	            allowEmpty: true
	        };
	    },
	
	    focus: function focus() {
	        ReactDOM.findDOMNode(this).focus();
	        return true;
	    },
	
	    toggleSelect: function toggleSelect(newValue) {
	        var values = (this.props.values || []).slice(0);
	        var allowEmpty = this.props.allowEmpty;
	
	        if (values.indexOf(newValue) >= 0 && (values.length > 1 || allowEmpty)) {
	            // If the value is already selected, unselect it
	            values.splice(values.indexOf(newValue), 1);
	        } else {
	            // Otherwise merge with other values and return
	            if (values.indexOf(newValue) < 0) {
	                values.push(newValue);
	            }
	        }
	
	        this.props.onChange(values);
	    },
	
	    render: function render() {
	        var _this = this;
	
	        var values = this.props.values || [];
	        var buttons = this.props.buttons.map(function (button, i) {
	            var selected = values.indexOf(button.value) >= 0;
	            return React.createElement(
	                'button',
	                { title: button.title,
	                    type: 'button',
	                    id: "" + i,
	                    key: "" + i,
	                    ref: "button" + i,
	                    className: css(styles.button.buttonStyle, selected && styles.button.selectedStyle),
	                    onClick: _this.toggleSelect.bind(_this, button.value)
	                },
	                button.content || "" + button.value
	            );
	        });
	
	        var outerStyle = {
	            display: 'inline-block'
	        };
	        return React.createElement(
	            'div',
	            { style: outerStyle },
	            buttons
	        );
	    }
	});
	
	module.exports = MultiButtonGroup;

/***/ },
/* 199 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable react/prop-types, react/sort-comp */
	
	var classNames = __webpack_require__(86);
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var _ = __webpack_require__(56);
	
	var firstNumericalParse = __webpack_require__(17).firstNumericalParse;
	var captureScratchpadTouchStart = __webpack_require__(17).captureScratchpadTouchStart;
	var knumber = __webpack_require__(275).number;
	var KhanMath = __webpack_require__(208);
	
	var toNumericString = KhanMath.toNumericString;
	var getNumericFormat = KhanMath.getNumericFormat;
	
	/* An input box that accepts only numeric strings
	 *
	 * Calls onChange(value, format) for valid numbers.
	 * Reverts to the current value onBlur or on [ENTER],
	 *   but maintains the format (i.e. 3/2, 1 1/2, 150%)
	 * Accepts empty input and sends it to onChange as null
	 *   if no numeric placeholder is set.
	 * If given a checkValidity function, will turn
	 *   the background/outline red when invalid
	 * If useArrowKeys is set to true, up/down arrows will
	 *   increment/decrement integers
	 * Optionally takes a size ("mini", "small", "normal")
	 */
	var NumberInput = React.createClass({
	    displayName: "NumberInput",
	
	    propTypes: {
	        value: React.PropTypes.number,
	        format: React.PropTypes.string,
	        placeholder: React.PropTypes.oneOfType([React.PropTypes.string, React.PropTypes.number]),
	        onChange: React.PropTypes.func.isRequired,
	        onFormatChange: React.PropTypes.func,
	        checkValidity: React.PropTypes.func,
	        size: React.PropTypes.string,
	        label: React.PropTypes.oneOf(["put your labels outside your inputs!"])
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            value: null,
	            placeholder: null,
	            format: null,
	            onFormatChange: function onFormatChange() {
	                return null;
	            },
	            checkValidity: function checkValidity() {
	                return true;
	            },
	            useArrowKeys: false
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            format: this.props.format
	        };
	    },
	
	    render: function render() {
	        var classes = classNames({
	            "number-input": true,
	            "invalid-input": !this._checkValidity(this.props.value),
	            mini: this.props.size === "mini",
	            small: this.props.size === "small",
	            normal: this.props.size === "normal"
	        });
	        if (this.props.className != null) {
	            classes = classes + " " + this.props.className;
	        }
	
	        return React.createElement("input", _extends({}, this.props, {
	            className: classes,
	            type: "text",
	            ref: "input",
	            onChange: this._handleChange,
	            onFocus: this._handleFocus,
	            onBlur: this._handleBlur,
	            onKeyPress: this._handleBlur,
	            onKeyDown: this._onKeyDown,
	            onTouchStart: captureScratchpadTouchStart,
	            defaultValue: toNumericString(this.props.value, this.state.format),
	            value: undefined
	        }));
	    },
	
	    componentDidUpdate: function componentDidUpdate(prevProps) {
	        if (!knumber.equal(this.getValue(), this.props.value)) {
	            this._setValue(this.props.value, this.state.format);
	        }
	    },
	
	    /* Return the current "value" of this input
	     * If empty, it returns the placeholder (if it is a number) or null
	     */
	    getValue: function getValue() {
	        return this.parseInputValue(ReactDOM.findDOMNode(this.refs.input).value);
	    },
	
	    /* Return the current string value of this input */
	    getStringValue: function getStringValue() {
	        return ReactDOM.findDOMNode(this.refs.input).value.toString();
	    },
	
	    parseInputValue: function parseInputValue(value) {
	        if (value === "") {
	            var placeholder = this.props.placeholder;
	            return _.isFinite(placeholder) ? +placeholder : null;
	        } else {
	            var result = firstNumericalParse(value);
	            return _.isFinite(result) ? result : this.props.value;
	        }
	    },
	
	    /* Set text input focus to this input */
	    focus: function focus() {
	        ReactDOM.findDOMNode(this.refs.input).focus();
	        this._handleFocus();
	    },
	
	    blur: function blur() {
	        ReactDOM.findDOMNode(this.refs.input).blur();
	        this._handleBlur();
	    },
	
	    setSelectionRange: function setSelectionRange(selectionStart, selectionEnd) {
	        ReactDOM.findDOMNode(this).setSelectionRange(selectionStart, selectionEnd);
	    },
	
	    getSelectionStart: function getSelectionStart() {
	        return ReactDOM.findDOMNode(this).selectionStart;
	    },
	
	    getSelectionEnd: function getSelectionEnd() {
	        return ReactDOM.findDOMNode(this).selectionEnd;
	    },
	
	    _checkValidity: function _checkValidity(value) {
	        if (value == null) {
	            return true;
	        }
	
	        var val = firstNumericalParse(value);
	        var checkValidity = this.props.checkValidity;
	
	        return _.isFinite(val) && checkValidity(val);
	    },
	
	    _handleChange: function _handleChange(e) {
	        var text = e.target.value;
	        var value = this.parseInputValue(text);
	        var format = getNumericFormat(text);
	
	        this.props.onChange(value);
	        if (format) {
	            this.props.onFormatChange(value, format);
	            this.setState({ format: format });
	        }
	    },
	
	    _handleFocus: function _handleFocus() {
	        if (this.props.onFocus) {
	            this.props.onFocus();
	        }
	    },
	
	    _handleBlur: function _handleBlur(e) {
	        // Only continue on blur or "enter"
	        if (e && e.type === "keypress" && e.keyCode !== 13) {
	            return;
	        }
	
	        this._setValue(this.props.value, this.state.format);
	        if (this.props.onBlur) {
	            this.props.onBlur();
	        }
	    },
	
	    _onKeyDown: function _onKeyDown(e) {
	        if (this.props.onKeyDown) {
	            this.props.onKeyDown(e);
	        }
	
	        if (!this.props.useArrowKeys || !_.contains(["ArrowUp", "ArrowDown"], e.key)) {
	            return;
	        }
	
	        var val = this.getValue();
	        if (val !== Math.floor(val)) {
	            return; // bail if not an integer
	        }
	
	        if (e.key === "ArrowUp") {
	            val = val + 1;
	        } else if (e.key === "ArrowDown") {
	            val = val - 1;
	        }
	
	        if (this._checkValidity(val)) {
	            this.props.onChange(val);
	        }
	    },
	
	    _setValue: function _setValue(val, format) {
	        $(ReactDOM.findDOMNode(this.refs.input)).val(toNumericString(val, format));
	    }
	});
	
	module.exports = NumberInput;

/***/ },
/* 200 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
	
	/* eslint-disable react/sort-comp */
	
	var React = __webpack_require__(43);
	
	var ReactDOM = __webpack_require__(44);
	
	var TextInput = React.createClass({
	    displayName: "TextInput",
	
	    propTypes: {
	        value: React.PropTypes.string,
	        onChange: React.PropTypes.func.isRequired,
	        className: React.PropTypes.string,
	        labelText: React.PropTypes.string,
	        onFocus: React.PropTypes.func,
	        onBlur: React.PropTypes.func,
	        disabled: React.PropTypes.bool
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            value: "",
	            disabled: false
	        };
	    },
	
	    render: function render() {
	        var _this = this;
	
	        var _props = this.props,
	            labelText = _props.labelText,
	            props = _objectWithoutProperties(_props, ["labelText"]);
	
	        return React.createElement("input", _extends({}, props, {
	            type: "text",
	            "aria-label": labelText,
	            onChange: function onChange(e) {
	                return _this.props.onChange(e.target.value);
	            }
	        }));
	    },
	
	    focus: function focus() {
	        ReactDOM.findDOMNode(this).focus();
	    },
	
	    blur: function blur() {
	        ReactDOM.findDOMNode(this).blur();
	    },
	
	    getValue: function getValue() {
	        return ReactDOM.findDOMNode(this).value;
	    },
	
	    getStringValue: function getStringValue() {
	        return ReactDOM.findDOMNode(this).value.toString();
	    },
	
	    setSelectionRange: function setSelectionRange(selectionStart, selectionEnd) {
	        ReactDOM.findDOMNode(this).setSelectionRange(selectionStart, selectionEnd);
	    },
	
	    getSelectionStart: function getSelectionStart() {
	        return ReactDOM.findDOMNode(this).selectionStart;
	    },
	
	    getSelectionEnd: function getSelectionEnd() {
	        return ReactDOM.findDOMNode(this).selectionEnd;
	    }
	});
	
	module.exports = TextInput;

/***/ },
/* 201 */
/***/ function(module, exports, __webpack_require__) {

	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _underscore = __webpack_require__(56);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * NotGorgon asynchronously calls Khan Academy's poentry linter.
	 *
	 * The poentry linter checks for issues that prevent content from being
	 * translated. This linter is KA-specific and so NotGorgon does not do anything
	 * in non-KA environments.
	 *
	 * NotGorgon is named as such because it is not Gorgon, Perseus' built-in
	 * linter.
	 */
	
	// msec to wait before we actually call the linter after receiving the
	// last call. The timer is reset if the lint is called during the wait.
	
	
	// A LintCB is called once the linter has been run.
	var DEBOUNCE_TIMEOUT = 1000;
	
	var NotGorgon = function () {
	  function NotGorgon() {
	    var _this = this;
	
	    _classCallCheck(this, NotGorgon);
	
	    this.previousContent = null;
	    this.runLinter = (0, _underscore.debounce)(function (perseusStr, onLintErrorsGenerated) {
	      // $FlowFixMe -- TODO(joshuan): use an api flag instead?
	      if (typeof KA === "undefined") {
	        return;
	      }
	
	      if (perseusStr === _this.previousContent) {
	        return;
	      }
	
	      _this.previousContent = perseusStr;
	
	      if (perseusStr === "") {
	        onLintErrorsGenerated([]);
	        return;
	      }
	
	      fetch("/api/internal/translate/lint_poentry?preview=1&lang=en", {
	        headers: { "Content-Type": "application/json" },
	        body: JSON.stringify({
	          // The poentry linter verifies that the translation from
	          // the original text to the translated text is sane. We
	          // want to ensure that the translation from English to
	          // English is sane, so msgid === mstr.
	          msgid: perseusStr, // msgid is the original text
	          msgstr: perseusStr, // msgstr is the translated text
	          format: "perseus_text",
	          filename: ""
	        }),
	        method: "POST"
	      }).then(function (response) {
	        if (response.status >= 400) {
	          return {
	            status: "error",
	            message: "Could not run i18n linter."
	          };
	        }
	        return response.json();
	      }, function (rejection) {
	        return {
	          status: "error",
	          message: "Could not run i18n linter."
	        };
	      }).then(function (json) {
	        if (json.status === "error") {
	          onLintErrorsGenerated(["Some part of this text makes it untranslatable. " + "The specific message from the i18n linter was: " + json.message.replace(/\n/g, " ")]);
	        } else {
	          onLintErrorsGenerated([]);
	        }
	      });
	    }, DEBOUNCE_TIMEOUT);
	  }
	  // To avoid linting when nothing has changed.
	
	
	  /**
	   * Runs the poentry linter on the given perseus string asynchronously.
	   *
	   * It doesn't do anything unless we're in a KA environment.
	   *
	   * onLintErrorsGenerated is called even if there are no errors. It is not
	   * called if perseusStr is unchanged from the last call.
	   *
	   * Linting is relatively expensive -- so we debounce linting each instance
	   * for some amount of time.
	   */
	
	
	  /**
	   * Applies an array of errors generated by linters without position
	   * information (NotGorgon and the legacy getSaveWarnings()) to the top
	   * of a Perseus tree.
	   */
	  NotGorgon.prototype.applyLintErrors = function applyLintErrors(parsedMarkdown, notGorgonLintErrors) {
	    // These lint errors do not have position data associated with
	    // them, so we just plop them at the top.
	    if (notGorgonLintErrors.length) {
	      var errorText = notGorgonLintErrors.join("\n\n");
	      parsedMarkdown.unshift({
	        content: {
	          type: "text",
	          content: ""
	        },
	        insideTable: false,
	        message: errorText,
	        ruleName: "legacy-error",
	        severity: _rule2.default.Severity.ERROR,
	        type: "lint"
	      });
	    }
	  };
	
	  NotGorgon.prototype.destroy = function destroy() {
	    this.runLinter = null;
	    this.previousContent = null;
	  };
	
	  return NotGorgon;
	}();
	
	exports.default = NotGorgon;

/***/ },
/* 202 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Paragraph parsing/splitting for article jipt i18n
	 */
	
	var SimpleMarkdown = __webpack_require__(260);
	
	var arrayRules = {
	    fence: {
	        match: SimpleMarkdown.defaultRules.fence.match,
	        order: 1,
	        parse: function parse(capture, state, _parse) {
	            return capture[3];
	        }
	    },
	    paragraph: {
	        match: SimpleMarkdown.defaultRules.paragraph.match,
	        order: 2,
	        parse: function parse(capture, state, _parse2) {
	            return capture[1];
	        }
	    }
	};
	
	var builtArrayParser = SimpleMarkdown.parserFor(arrayRules);
	
	// This should just return an array of strings! magick!
	var parseToArray = function parseToArray(source) {
	    // Remove any leading newlines to avoid splitting weirdness
	    // (simple-markdown has the `newline` rule for this, and i have
	    // no idea how this will handle leading newlines without that rule),
	    // and add \n\n to let it parse at a block/paragraph level
	    var paragraphedSource = source.replace(/^\n\s*\n/, "") + "\n\n";
	    return builtArrayParser(paragraphedSource, { inline: false });
	};
	
	var joinFromArray = function joinFromArray(paragraphs) {
	    return paragraphs.join("\n\n");
	};
	
	module.exports = {
	    parseToArray: parseToArray,
	    joinFromArray: joinFromArray
	};

/***/ },
/* 203 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable comma-dangle, no-var, react/jsx-closing-bracket-location, react/jsx-indent-props, react/prop-types */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var React = __webpack_require__(43);
	
	var QuestionParagraph = React.createClass({
	    displayName: "QuestionParagraph",
	
	    render: function render() {
	        var className = this.props.className ? "paragraph " + this.props.className : "paragraph";
	        // For perseus-article just-in-place-translation (jipt), we need
	        // to attach some metadata to top-level QuestionParagraphs:
	        return React.createElement(
	            "div",
	            {
	                className: className,
	                "data-perseus-component-index": this.props.translationIndex,
	                "data-perseus-paragraph-index": this.props.paragraphIndex
	            },
	            this.props.children
	        );
	    }
	});
	
	module.exports = QuestionParagraph;

/***/ },
/* 204 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable comma-dangle, react/forbid-prop-types, react/jsx-closing-bracket-location, react/jsx-indent-props, react/sort-comp */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var classNames = __webpack_require__(86);
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var _require = __webpack_require__(77),
	    zIndexInteractiveComponent = _require.zIndexInteractiveComponent;
	
	var Widgets = __webpack_require__(31);
	
	var _require2 = __webpack_require__(241),
	    containerSizeClass = _require2.containerSizeClass,
	    getClassFromWidth = _require2.getClassFromWidth;
	
	var _require3 = __webpack_require__(52),
	    linterContextProps = _require3.linterContextProps,
	    linterContextDefault = _require3.linterContextDefault;
	
	var WidgetContainer = React.createClass({
	    displayName: "WidgetContainer",
	
	    propTypes: {
	        shouldHighlight: React.PropTypes.bool.isRequired,
	        type: React.PropTypes.string,
	        initialProps: React.PropTypes.object.isRequired,
	        linterContext: linterContextProps
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            linterContext: linterContextDefault
	        };
	    },
	
	
	    getInitialState: function getInitialState() {
	        return {
	            // TODO(benkomalo): before we're mounted, we don't know how big
	            // we're going to be, so just default to MEDIUM for now. :/ In the
	            // future we can sniff with user-agents or something to get a
	            // better approximation, to avoid flickers
	            sizeClass: containerSizeClass.MEDIUM,
	            widgetProps: this.props.initialProps
	        };
	    },
	
	    componentDidMount: function componentDidMount() {
	        // Only relay size class changes for mobile right now.  We may want to
	        // this for desktop as well at some point in the future.
	        if (this.state.widgetProps.apiOptions.isMobile) {
	            var containerWidth = ReactDOM.findDOMNode(this).offsetWidth;
	
	            // NOTE(benkomalo): in the common case, this won't change anything.
	            // Unfortunately, it will cause a flash and re-layout on mobile,
	            // but until we have better SSR or a more drastic way change to our
	            // APIs that hints at the available size, we do have to measure DOM
	            // unfortunately.
	            /* eslint-disable react/no-did-mount-set-state */
	            this.setState({
	                sizeClass: getClassFromWidth(containerWidth)
	            });
	            /* eslint-enable react/no-did-mount-set-state */
	        }
	    },
	
	
	    render: function render() {
	        var className = classNames({
	            "perseus-widget-container": true,
	            "widget-highlight": this.props.shouldHighlight,
	            "widget-nohighlight": !this.props.shouldHighlight
	        });
	
	        var type = this.props.type;
	        var WidgetType = Widgets.getWidget(type);
	        if (WidgetType == null) {
	            // Just give up on invalid widget types
	            return React.createElement("div", { className: className });
	        }
	
	        var alignment = this.state.widgetProps.alignment;
	        if (alignment === "default") {
	            alignment = Widgets.getDefaultAlignment(type);
	        }
	
	        className += " widget-" + alignment;
	
	        var apiOptions = this.state.widgetProps.apiOptions;
	
	        // Hack to prevent interaction with static widgets: we overlay a big
	        // div on top of the widget and overflow: hidden the container.
	        // Ideally widgets themselves should know how to prevent interaction.
	        var isStatic = this.state.widgetProps.static || apiOptions.readOnly;
	        var staticContainerStyles = {
	            position: "relative",
	            overflow: "visible"
	        };
	        var staticOverlayStyles = {
	            width: "100%",
	            height: "100%",
	            position: "absolute",
	            top: 0,
	            left: 0,
	            zIndex: zIndexInteractiveComponent
	        };
	
	        // Some widgets may include strings of markdown that we may
	        // want to run the linter on. So if the widget is lintable,
	        // and we've been asked to highlight lint, pass that property
	        // on to the widget, and if the content is not lintable, make sure
	        // to default to false.
	        var linterContext = this.props.linterContext;
	
	        if (!Widgets.isLintable(type)) {
	            linterContext.highlightLint = false;
	        }
	
	        // Note: if you add more props here, please consider whether or not
	        // it should be auto-serialized (e.g. used in scoreInput()). See
	        // widget-jsonify-deprecated.jsx and widget-prop-blacklist.jsx
	
	        // We default to an empty object for style instead of null
	        // because of a strange bug where the static styles aren't applied
	        // after toggling static mode.
	        return React.createElement(
	            "div",
	            {
	                className: className,
	                style: isStatic ? staticContainerStyles : {}
	            },
	            React.createElement(WidgetType, _extends({}, this.state.widgetProps, {
	                linterContext: linterContext,
	                containerSizeClass: this.state.sizeClass,
	                ref: "widget"
	            })),
	            isStatic && React.createElement("div", { style: staticOverlayStyles })
	        );
	    },
	
	    componentWillReceiveProps: function componentWillReceiveProps(nextProps) {
	        if (this.props.type !== nextProps.type) {
	            throw new Error("WidgetContainer can't change widget type; set a different " + "key instead to recreate the container.");
	        }
	    },
	
	    shouldComponentUpdate: function shouldComponentUpdate(nextProps, nextState) {
	        return this.props.shouldHighlight !== nextProps.shouldHighlight || this.props.type !== nextProps.type || this.state.widgetProps !== nextState.widgetProps || this.state.sizeClass !== nextState.sizeClass;
	    },
	
	    getWidget: function getWidget() {
	        return this.refs.widget;
	    },
	
	    replaceWidgetProps: function replaceWidgetProps(newWidgetProps) {
	        this.setState({ widgetProps: newWidgetProps });
	    }
	});
	
	module.exports = WidgetContainer;

/***/ },
/* 205 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/**
	 * Zooms child to fit with tap-to-zoom behavior.
	 */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var Deferred = __webpack_require__(206);
	
	var Zoomable = React.createClass({
	    displayName: "Zoomable",
	
	    propTypes: {
	        animateHeight: React.PropTypes.bool,
	        children: React.PropTypes.element.isRequired,
	
	        /**
	         * Optional function that allows customizations in zooming.
	         *
	         * Defaults to just using the bounding client rect of the first DOM
	         * element of this component.
	         *
	         * @return {Object} bounds object with `width` and `height` properties
	         */
	        computeChildBounds: React.PropTypes.func,
	
	        // If this prop is specified, we wait until the deferred is resolved
	        // before measuring the child element.  This is necessary in cases
	        // where the child size depends on whether or not resources, such as
	        // fonts, have been loaded.
	        readyToMeasureDeferred: React.PropTypes.shape({
	            then: React.PropTypes.func.isRequired,
	            reject: React.PropTypes.func.isRequired
	        }).isRequired
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        var deferred = new Deferred();
	        deferred.resolve();
	
	        return {
	            animateHeight: false,
	            readyToMeasureDeferred: deferred,
	            computeChildBounds: function computeChildBounds(parentNode) {
	                var firstChild = parentNode.firstElementChild;
	
	                return {
	                    // The +1 is a fudge factor to make sure any border on the
	                    // content isn't clipped by the the container it's in.
	                    width: firstChild.offsetWidth + 1,
	                    height: firstChild.offsetHeight + 1
	                };
	            }
	        };
	    },
	    getInitialState: function getInitialState() {
	        return {
	            visible: false,
	            marginBottomPx: 0,
	            zoomed: true
	        };
	    },
	    componentDidMount: function componentDidMount() {
	        var _this = this;
	
	        this._node = ReactDOM.findDOMNode(this);
	        this.props.readyToMeasureDeferred.then(function () {
	            if (_this.isMounted()) {
	                _this.scaleChildToFit(false);
	
	                if (window.MutationObserver) {
	                    _this._observer = new MutationObserver(function (mutations) {
	                        if (_this.isMounted()) {
	                            for (var _iterator = mutations, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
	                                var _ref;
	
	                                if (_isArray) {
	                                    if (_i >= _iterator.length) break;
	                                    _ref = _iterator[_i++];
	                                } else {
	                                    _i = _iterator.next();
	                                    if (_i.done) break;
	                                    _ref = _i.value;
	                                }
	
	                                var mutation = _ref;
	
	                                if (mutation.target !== _this._node) {
	                                    // Only act on mutations of children
	                                    _this.scaleChildToFit(_this.state.zoomed);
	                                    break;
	                                }
	                            }
	                        }
	                    });
	
	                    _this._observer.observe(_this._node, {
	                        childList: true,
	                        subtree: true,
	                        attributes: true
	                    });
	                }
	                window.addEventListener("resize", _this.reset);
	            }
	        });
	    },
	    componentWillUnmount: function componentWillUnmount() {
	        window.removeEventListener("resize", this.reset);
	        if (this._observer) {
	            this._observer.disconnect();
	        }
	    },
	    reset: function reset() {
	        var _this2 = this;
	
	        if (!this.isMounted()) {
	            return;
	        }
	        if (!this.state.visible) {
	            return;
	        }
	        this._originalWidth = null;
	        this.setState({
	            visible: false,
	            compactHeight: null,
	            expandedHeight: null,
	            zoomed: true
	        }, function () {
	            _this2.scaleChildToFit(false);
	        });
	    },
	    stopPropagationIfZoomed: function stopPropagationIfZoomed(e) {
	        if (!this.state.zoomed) {
	            // We only allow touch events (which trigger interactive elements)
	            // to be propagated to children if we are already zoomed.
	            e.stopPropagation();
	        }
	    },
	
	
	    // TODO(benkomalo): call this on viewport width changes?
	    // https://github.com/Khan/math-input/blob/master/src/components/math-keypad.js#L43
	    scaleChildToFit: function scaleChildToFit(zoomed) {
	        var _this3 = this;
	
	        var parentBounds = {
	            width: this._node.offsetWidth,
	            height: this._node.offsetHeight
	        };
	        var childBounds = this.props.computeChildBounds(this._node, parentBounds);
	
	        var childWidth = childBounds.width;
	        var childHeight = childBounds.height;
	
	        if (childWidth > parentBounds.width) {
	            var scale = parentBounds.width / childWidth;
	
	            this.setState({
	                scale: scale,
	                zoomed: zoomed,
	
	                compactHeight: Math.ceil(scale * childHeight),
	                expandedHeight: childHeight
	            });
	
	            // TODO(charlie): Do this as a callback to `setState`. Something is
	            // going wrong with that approach in initial testing.
	            setTimeout(function () {
	                // Only show it after the next paint, to allow for CSS
	                // transitions to fade it in.
	                if (_this3.isMounted()) {
	                    _this3.setState({
	                        visible: true
	                    });
	                }
	            });
	        } else {
	            this.setState({
	                visible: true
	            });
	        }
	    },
	    handleClickIfZoomed: function handleClickIfZoomed(e) {
	        if (!this.state.zoomed) {
	            e.stopPropagation();
	            this.handleClick();
	        }
	    },
	    handleClick: function handleClick() {
	        this.setState({
	            zoomed: !this.state.zoomed
	        });
	    },
	    render: function render() {
	        var _state = this.state,
	            visible = _state.visible,
	            scale = _state.scale,
	            compactHeight = _state.compactHeight,
	            expandedHeight = _state.expandedHeight,
	            zoomed = _state.zoomed;
	        var animateHeight = this.props.animateHeight;
	
	
	        var property = animateHeight ? "opacity transform height" : "opacity transform";
	
	        // Since we're not using aphrodite, we have to prefix ourselves.
	        /* eslint-disable indent */
	        var transitionStyle = visible ? {
	            transitionProperty: property,
	            WebkitTransitionProperty: property,
	            msTransitionProperty: property,
	            transitionDuration: "0.3s",
	            WebkitTransitionDuration: "0.3s",
	            msTransitionDuration: "0.3s",
	            transitionTimingFunction: "ease-out",
	            WebkitTransitionTimingfunction: "ease-out",
	            msTransitionTmingFunction: "ease-out"
	        } : {};
	        /* eslint-enable indent */
	
	        // Do a fancy little slide as we fade the contents in the first time.
	        var translateOffset = visible ? "" : " translate(0, 8px)";
	        var transform = zoomed ? "scale(1, 1) " + translateOffset : "scale(" + scale + ", " + scale + ") " + translateOffset;
	
	        var style = _extends({
	            display: "block",
	            width: "100%",
	            height: zoomed ? expandedHeight : compactHeight,
	            transform: transform,
	            WebkitTransform: transform,
	            msTransform: transform,
	            transformOrigin: "0 0",
	            WebkitTransformOrigin: "0 0",
	            msTransformOrigin: "0 0",
	            opacity: visible ? 1 : 0,
	            WebkitTapHighlightColor: "transparent"
	        }, transitionStyle);
	
	        return React.createElement(
	            "span",
	            {
	                onClick: this.handleClick,
	                onClickCapture: this.handleClickIfZoomed,
	                onTouchCancelCapture: this.stopPropagationIfZoomed,
	                onTouchEndCapture: this.stopPropagationIfZoomed,
	                onTouchStartCapture: this.stopPropagationIfZoomed,
	                style: style
	            },
	            this.props.children
	        );
	    }
	});
	
	module.exports = Zoomable;

/***/ },
/* 206 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * Simple version of jQuery's Deferred.
	 */
	
	var Deferred = function () {
	    function Deferred() {
	        var _this = this;
	
	        _classCallCheck(this, Deferred);
	
	        this.promise = new Promise(function (resolve, reject) {
	            _this.resolve = resolve;
	            _this.reject = reject;
	        });
	    }
	
	    Deferred.prototype.then = function then(callback) {
	        return this.promise.then(callback);
	    };
	
	    return Deferred;
	}();
	
	module.exports = Deferred;

/***/ },
/* 207 */
/***/ function(module, exports, __webpack_require__) {

	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * This is the base class for all Selector types. The key method that all
	 * selector subclasses must implement is match(). It takes a TraversalState
	 * object (from a TreeTransformer traversal) and tests whether the selector
	 * matches at the current node. See the comment at the start of this file for
	 * more details on the match() method.
	 */
	var babelPluginFlowReactPropTypes_proptype_TraversalState = __webpack_require__(85).babelPluginFlowReactPropTypes_proptype_TraversalState || __webpack_require__(43).PropTypes.any; /**
	                                                                                                                                                                                       * The Selector class implements a CSS-like system for matching nodes in a
	                                                                                                                                                                                       * parse tree based on the structure of the tree. Create a Selector object by
	                                                                                                                                                                                       * calling the static Selector.parse() method on a string that describes the
	                                                                                                                                                                                       * tree structure you want to match. For example, if you want to find text
	                                                                                                                                                                                       * nodes that are direct children of paragraph nodes that immediately follow
	                                                                                                                                                                                       * heading nodes, you could create an appropriate selector like this:
	                                                                                                                                                                                       *
	                                                                                                                                                                                       *   selector = Selector.parse("heading + paragraph > text");
	                                                                                                                                                                                       *
	                                                                                                                                                                                       * Recall from the TreeTransformer class, that we consider any object with a
	                                                                                                                                                                                       * string-valued `type` property to be a tree node. The words "heading",
	                                                                                                                                                                                       * "paragraph" and "text" in the selector string above specify node types and
	                                                                                                                                                                                       * will match nodes in a parse tree that have `type` properties with those
	                                                                                                                                                                                       * values.
	                                                                                                                                                                                       *
	                                                                                                                                                                                       * Selectors are designed for use during tree traversals done with the
	                                                                                                                                                                                       * TreeTransformer traverse() method. To test whether the node currently being
	                                                                                                                                                                                       * traversed matches a selector, simply pass the TraversalState object to the
	                                                                                                                                                                                       * match() method of the Selector object. If the node does not match the
	                                                                                                                                                                                       * selector, match() returns null. If it does match, then match() returns an
	                                                                                                                                                                                       * array of nodes that match the selector. In the example above the first
	                                                                                                                                                                                       * element of the array would be the node the heading node, the second would
	                                                                                                                                                                                       * be the paragraph node that follows it, and the third would be the text node
	                                                                                                                                                                                       * that is a child of the paragraph.  The last element of a returned array of
	                                                                                                                                                                                       * nodes is always equal to the current node of the tree traversal.
	                                                                                                                                                                                       *
	                                                                                                                                                                                       * Code that uses a selector might look like this:
	                                                                                                                                                                                       *
	                                                                                                                                                                                       *   matchingNodes = selector.match(state);
	                                                                                                                                                                                       *   if (matchingNodes) {
	                                                                                                                                                                                       *       let heading = matchingNodes[0];
	                                                                                                                                                                                       *       let text = matchingNodes[2];
	                                                                                                                                                                                       *       // do something with those nodes
	                                                                                                                                                                                       *   }
	                                                                                                                                                                                       *
	                                                                                                                                                                                       * The Selector.parse() method recognizes a grammar that is similar to CSS
	                                                                                                                                                                                       * selectors:
	                                                                                                                                                                                       *
	                                                                                                                                                                                       * selector := treeSelector (, treeSelector)*
	                                                                                                                                                                                       *
	                                                                                                                                                                                       *    A selector is one or more comma-separated treeSelectors. A node matches
	                                                                                                                                                                                       *    the selector if it matches any of the treeSelectors.
	                                                                                                                                                                                       *
	                                                                                                                                                                                       * treeSelector := (treeSelector combinator)? nodeSelector
	                                                                                                                                                                                       *
	                                                                                                                                                                                       *    A treeSelector is a nodeSelector optionally preceeded by a combinator
	                                                                                                                                                                                       *    and another tree selector. The tree selector matches if the current node
	                                                                                                                                                                                       *    matches the node selector and a sibling or ancestor (depending on the
	                                                                                                                                                                                       *    combinator) of the current node matches the optional treeSelector.
	                                                                                                                                                                                       *
	                                                                                                                                                                                       * combinator := ' ' | '>' | '+' | '~'   // standard CSS3 combinators
	                                                                                                                                                                                       *
	                                                                                                                                                                                       *    A combinator is a space or punctuation character that specifies the
	                                                                                                                                                                                       *    relationship between two nodeSelectors. A space between two
	                                                                                                                                                                                       *    nodeSelectors means that the first selector much match an ancestor of
	                                                                                                                                                                                       *    the node that matches the second selector. A '>' character means that
	                                                                                                                                                                                       *    the first selector must match the parent of the node matched by the
	                                                                                                                                                                                       *    second. The '~' combinator means that the first selector must match a
	                                                                                                                                                                                       *    previous sibling of the node matched by the second. And the '+' selector
	                                                                                                                                                                                       *    means that first selector must match the immediate previous sibling of
	                                                                                                                                                                                       *    the node that matched the second.
	                                                                                                                                                                                       *
	                                                                                                                                                                                       * nodeSelector := <IDENTIFIER> | '*'
	                                                                                                                                                                                       *
	                                                                                                                                                                                       *    A nodeSelector is simply an identifier (a letter followed by any number
	                                                                                                                                                                                       *    of letters, digits, hypens, and underscores) or the wildcard asterisk
	                                                                                                                                                                                       *    character. A wildcard node selector matches any node. An identifier
	                                                                                                                                                                                       *    selector matches any node that has a `type` property whose value matches
	                                                                                                                                                                                       *    the identifier.
	                                                                                                                                                                                       *
	                                                                                                                                                                                       * If you call Selector.parse() on a string that does not match this grammar,
	                                                                                                                                                                                       * it will throw an exception
	                                                                                                                                                                                       *
	                                                                                                                                                                                       * TODO(davidflanagan): it might be useful to allow more sophsticated node
	                                                                                                                                                                                       * selector matching with attribute matches and pseudo-classes, like
	                                                                                                                                                                                       * "heading[level=2]" or "paragraph:first-child"
	                                                                                                                                                                                       *
	                                                                                                                                                                                       * Implementation Note: this file exports a very simple Selector class but all
	                                                                                                                                                                                       * the actual work is done in various internal classes. The Parser class
	                                                                                                                                                                                       * parses the string representation of a selector into a parse tree that
	                                                                                                                                                                                       * consists of instances of various subclasses of the Selector class. It is
	                                                                                                                                                                                       * these subclasses that implement the selector matching logic, often
	                                                                                                                                                                                       * depending on features of the TraversalState object from the TreeTransformer
	                                                                                                                                                                                       * traversal.
	                                                                                                                                                                                       */
	
	var babelPluginFlowReactPropTypes_proptype_TreeNode = __webpack_require__(85).babelPluginFlowReactPropTypes_proptype_TreeNode || __webpack_require__(43).PropTypes.any;
	
	var Selector = function () {
	    function Selector() {
	        _classCallCheck(this, Selector);
	    }
	
	    Selector.parse = function parse(selectorText) {
	        return new Parser(selectorText).parse();
	    };
	
	    /**
	     * Return an array of the nodes that matched or null if no match.
	     * This is the base class so we just throw an exception. All Selector
	     * subclasses must provide an implementation of this method.
	     */
	
	
	    Selector.prototype.match = function match(state) {
	        throw new Error("Selector subclasses must implement match()");
	    };
	
	    /**
	     * Selector subclasses all define a toString() method primarily
	     * because it makes it easy to write parser tests.
	     */
	
	
	    Selector.prototype.toString = function toString() {
	        return "Unknown selector class";
	    };
	
	    return Selector;
	}();
	
	/**
	 * This class implements a parser for the selector grammar. Pass the source
	 * text to the Parser() constructor, and then call the parse() method to
	 * obtain a corresponding Selector object. parse() throws an exception
	 * if there are syntax errors in the selector.
	 *
	 * This class is not exported, and you don't need to use it directly.
	 * Instead call the static Selector.parse() method.
	 */
	
	
	exports.default = Selector;
	
	var Parser = function () {
	    // Which token in the array we're looking at now
	
	    // We do lexing with a simple regular expression
	    function Parser(s) {
	        _classCallCheck(this, Parser);
	
	        // Normalize whitespace:
	        // - remove leading and trailing whitespace
	        // - replace runs of whitespace with single space characters
	        s = s.trim().replace(/\s+/g, " ");
	        // Convert the string to an array of tokens. Note that the TOKENS
	        // pattern ignores spaces that do not appear before identifiers
	        // or the * wildcard.
	        this.tokens = s.match(Parser.TOKENS) || [];
	        this.tokenIndex = 0;
	    }
	
	    // Return the next token or the empty string if there are no more
	    // The array of tokens
	
	
	    Parser.prototype.nextToken = function nextToken() {
	        return this.tokens[this.tokenIndex] || "";
	    };
	
	    // Increment the token index to "consume" the token we were looking at
	    // and move on to the next one.
	
	
	    Parser.prototype.consume = function consume() {
	        this.tokenIndex++;
	    };
	
	    // Return true if the current token is an identifier or false otherwise
	
	
	    Parser.prototype.isIdentifier = function isIdentifier() {
	        // The Parser.TOKENS regexp ensures that we only have to check
	        // the first character of a token to know what kind of token it is.
	        var c = this.tokens[this.tokenIndex][0];
	        return c >= "a" && c <= "z" || c >= "A" && c <= "Z";
	    };
	
	    // Consume space tokens until the next token is not a space.
	
	
	    Parser.prototype.skipSpace = function skipSpace() {
	        while (this.nextToken() === " ") {
	            this.consume();
	        }
	    };
	
	    // Parse a comma-separated sequence of tree selectors. This is the
	    // entry point for the Parser class and the only method that clients
	    // ever need to call.
	
	
	    Parser.prototype.parse = function parse() {
	        // We expect at least one tree selector
	        var ts = this.parseTreeSelector();
	
	        // Now see what's next
	        var token = this.nextToken();
	
	        // If there is no next token then we're done parsing and can return
	        // the tree selector object we got above
	        if (!token) {
	            return ts;
	        }
	
	        // Otherwise, there is more go come and we're going to need a
	        // list of tree selectors
	        var treeSelectors = [ts];
	        while (token) {
	            // The only character we allow after a tree selector is a comma
	            if (token === ",") {
	                this.consume();
	            } else {
	                throw new ParseError("Expected comma");
	            }
	
	            // And if we saw a comma, then it must be followed by another
	            // tree selector
	            treeSelectors.push(this.parseTreeSelector());
	            token = this.nextToken();
	        }
	
	        // If we parsed more than one tree selector, return them in a
	        // SelectorList object.
	        return new SelectorList(treeSelectors);
	    };
	
	    // Parse a sequence of node selectors linked together with
	    // hierarchy combinators: space, >, + and ~.
	
	
	    Parser.prototype.parseTreeSelector = function parseTreeSelector() {
	        this.skipSpace(); // Ignore space after a comma, for example
	
	        // A tree selector must begin with a node selector
	        var ns = this.parseNodeSelector();
	
	        for (;;) {
	            // Now check the next token. If there is none, or if it is a
	            // comma, then we're done with the treeSelector. Otherwise
	            // we expect a combinator followed by another node selector.
	            // If we don't see a combinator, we throw an error. If we
	            // do see a combinator and another node selector then we
	            // combine the current node selector with the new node selector
	            // using a Selector subclass that depends on the combinator.
	            var token = this.nextToken();
	
	            if (!token || token === ",") {
	                break;
	            } else if (token === " ") {
	                this.consume();
	                ns = new AncestorCombinator(ns, this.parseNodeSelector());
	            } else if (token === ">") {
	                this.consume();
	                ns = new ParentCombinator(ns, this.parseNodeSelector());
	            } else if (token === "+") {
	                this.consume();
	                ns = new PreviousCombinator(ns, this.parseNodeSelector());
	            } else if (token === "~") {
	                this.consume();
	                ns = new SiblingCombinator(ns, this.parseNodeSelector());
	            } else {
	                throw new ParseError("Unexpected token: " + token);
	            }
	        }
	
	        return ns;
	    };
	
	    // Parse a single node selector.
	    // For now, this is just a node type or a wildcard.
	    //
	    // TODO(davidflanagan): we may need to extend this with attribute
	    // selectors like 'heading[level=3]', or with pseudo-classes like
	    // paragraph:first-child
	
	
	    Parser.prototype.parseNodeSelector = function parseNodeSelector() {
	        // First, skip any whitespace
	        this.skipSpace();
	
	        var t = this.nextToken();
	        if (t === "*") {
	            this.consume();
	            return new AnyNode();
	        } else if (this.isIdentifier()) {
	            this.consume();
	            return new TypeSelector(t);
	        }
	
	        throw new ParseError("Expected node type");
	    };
	
	    return Parser;
	}();
	
	// We break the input string into tokens with this regexp. Token types
	// are identifiers, integers, punctuation and spaces. Note that spaces
	// tokens are only returned when they appear before an identifier or
	// wildcard token and are otherwise omitted.
	
	
	Parser.TOKENS = /([a-zA-Z][\w-]*)|(\d+)|[^\s]|(\s(?=[a-zA-Z\*]))/g;
	
	/**
	 * This is a trivial Error subclass that the Parser uses to signal parse errors
	 */
	
	var ParseError = function (_Error) {
	    _inherits(ParseError, _Error);
	
	    function ParseError(message) {
	        _classCallCheck(this, ParseError);
	
	        return _possibleConstructorReturn(this, _Error.call(this, message));
	    }
	
	    return ParseError;
	}(Error);
	
	/**
	 * This Selector subclass is a list of selectors. It matches a node if any of
	 * the selectors on the list matches the node. It considers the selectors in
	 * order, and returns the array of nodes returned by whichever one matches
	 * first.
	 */
	
	
	var SelectorList = function (_Selector) {
	    _inherits(SelectorList, _Selector);
	
	    function SelectorList(selectors) {
	        _classCallCheck(this, SelectorList);
	
	        var _this2 = _possibleConstructorReturn(this, _Selector.call(this));
	
	        _this2.selectors = selectors;
	        return _this2;
	    }
	
	    SelectorList.prototype.match = function match(state) {
	        for (var i = 0; i < this.selectors.length; i++) {
	            var s = this.selectors[i];
	            var result = s.match(state);
	            if (result) {
	                return result;
	            }
	        }
	        return null;
	    };
	
	    SelectorList.prototype.toString = function toString() {
	        var result = "";
	        for (var i = 0; i < this.selectors.length; i++) {
	            result += i > 0 ? ", " : "";
	            result += this.selectors[i].toString();
	        }
	        return result;
	    };
	
	    return SelectorList;
	}(Selector);
	
	/**
	 * This trivial Selector subclass implements the '*' wildcard and
	 * matches any node.
	 */
	
	
	var AnyNode = function (_Selector2) {
	    _inherits(AnyNode, _Selector2);
	
	    function AnyNode() {
	        _classCallCheck(this, AnyNode);
	
	        return _possibleConstructorReturn(this, _Selector2.apply(this, arguments));
	    }
	
	    AnyNode.prototype.match = function match(state) {
	        return [state.currentNode()];
	    };
	
	    AnyNode.prototype.toString = function toString() {
	        return "*";
	    };
	
	    return AnyNode;
	}(Selector);
	
	/**
	 * This selector subclass implements the <IDENTIFIER> part of the grammar.
	 * it matches any node whose `type` property is a specified string
	 */
	
	
	var TypeSelector = function (_Selector3) {
	    _inherits(TypeSelector, _Selector3);
	
	    function TypeSelector(type) {
	        _classCallCheck(this, TypeSelector);
	
	        var _this4 = _possibleConstructorReturn(this, _Selector3.call(this));
	
	        _this4.type = type;
	        return _this4;
	    }
	
	    TypeSelector.prototype.match = function match(state) {
	        var node = state.currentNode();
	        if (node.type === this.type) {
	            return [node];
	        } else {
	            return null;
	        }
	    };
	
	    TypeSelector.prototype.toString = function toString() {
	        return this.type;
	    };
	
	    return TypeSelector;
	}(Selector);
	
	/**
	 * This selector subclass is the superclass of the classes that implement
	 * matching for the four combinators. It defines left and right properties for
	 * the two selectors that are to be combined, but does not define a match
	 * method.
	 */
	
	
	var SelectorCombinator = function (_Selector4) {
	    _inherits(SelectorCombinator, _Selector4);
	
	    function SelectorCombinator(left, right) {
	        _classCallCheck(this, SelectorCombinator);
	
	        var _this5 = _possibleConstructorReturn(this, _Selector4.call(this));
	
	        _this5.left = left;
	        _this5.right = right;
	        return _this5;
	    }
	
	    return SelectorCombinator;
	}(Selector);
	
	/**
	 * This Selector subclass implements the space combinator. It matches if the
	 * right selector matches the current node and the left selector matches some
	 * ancestor of the current node.
	 */
	
	
	var AncestorCombinator = function (_SelectorCombinator) {
	    _inherits(AncestorCombinator, _SelectorCombinator);
	
	    function AncestorCombinator(left, right) {
	        _classCallCheck(this, AncestorCombinator);
	
	        return _possibleConstructorReturn(this, _SelectorCombinator.call(this, left, right));
	    }
	
	    AncestorCombinator.prototype.match = function match(state) {
	        var rightResult = this.right.match(state);
	        if (rightResult) {
	            state = state.clone();
	            while (state.hasParent()) {
	                state.goToParent();
	                var leftResult = this.left.match(state);
	                if (leftResult) {
	                    return leftResult.concat(rightResult);
	                }
	            }
	        }
	        return null;
	    };
	
	    AncestorCombinator.prototype.toString = function toString() {
	        return this.left.toString() + " " + this.right.toString();
	    };
	
	    return AncestorCombinator;
	}(SelectorCombinator);
	
	/**
	 * This Selector subclass implements the > combinator. It matches if the
	 * right selector matches the current node and the left selector matches
	 * the parent of the current node.
	 */
	
	
	var ParentCombinator = function (_SelectorCombinator2) {
	    _inherits(ParentCombinator, _SelectorCombinator2);
	
	    function ParentCombinator(left, right) {
	        _classCallCheck(this, ParentCombinator);
	
	        return _possibleConstructorReturn(this, _SelectorCombinator2.call(this, left, right));
	    }
	
	    ParentCombinator.prototype.match = function match(state) {
	        var rightResult = this.right.match(state);
	        if (rightResult) {
	            if (state.hasParent()) {
	                state = state.clone();
	                state.goToParent();
	                var leftResult = this.left.match(state);
	                if (leftResult) {
	                    return leftResult.concat(rightResult);
	                }
	            }
	        }
	        return null;
	    };
	
	    ParentCombinator.prototype.toString = function toString() {
	        return this.left.toString() + " > " + this.right.toString();
	    };
	
	    return ParentCombinator;
	}(SelectorCombinator);
	
	/**
	 * This Selector subclass implements the + combinator. It matches if the
	 * right selector matches the current node and the left selector matches
	 * the immediate previous sibling of the current node.
	 */
	
	
	var PreviousCombinator = function (_SelectorCombinator3) {
	    _inherits(PreviousCombinator, _SelectorCombinator3);
	
	    function PreviousCombinator(left, right) {
	        _classCallCheck(this, PreviousCombinator);
	
	        return _possibleConstructorReturn(this, _SelectorCombinator3.call(this, left, right));
	    }
	
	    PreviousCombinator.prototype.match = function match(state) {
	        var rightResult = this.right.match(state);
	        if (rightResult) {
	            if (state.hasPreviousSibling()) {
	                state = state.clone();
	                state.goToPreviousSibling();
	                var leftResult = this.left.match(state);
	                if (leftResult) {
	                    return leftResult.concat(rightResult);
	                }
	            }
	        }
	        return null;
	    };
	
	    PreviousCombinator.prototype.toString = function toString() {
	        return this.left.toString() + " + " + this.right.toString();
	    };
	
	    return PreviousCombinator;
	}(SelectorCombinator);
	
	/**
	 * This Selector subclass implements the ~ combinator. It matches if the
	 * right selector matches the current node and the left selector matches
	 * any previous sibling of the current node.
	 */
	
	
	var SiblingCombinator = function (_SelectorCombinator4) {
	    _inherits(SiblingCombinator, _SelectorCombinator4);
	
	    function SiblingCombinator(left, right) {
	        _classCallCheck(this, SiblingCombinator);
	
	        return _possibleConstructorReturn(this, _SelectorCombinator4.call(this, left, right));
	    }
	
	    SiblingCombinator.prototype.match = function match(state) {
	        var rightResult = this.right.match(state);
	        if (rightResult) {
	            state = state.clone();
	            while (state.hasPreviousSibling()) {
	                state.goToPreviousSibling();
	                var leftResult = this.left.match(state);
	                if (leftResult) {
	                    return leftResult.concat(rightResult);
	                }
	            }
	        }
	        return null;
	    };
	
	    SiblingCombinator.prototype.toString = function toString() {
	        return this.left.toString() + " ~ " + this.right.toString();
	    };
	
	    return SiblingCombinator;
	}(SelectorCombinator);

/***/ },
/* 208 */
/***/ function(module, exports, __webpack_require__) {

	var _ = __webpack_require__(56);
	var knumber = __webpack_require__(275).number;
	
	var KhanMath = {
	    // Simplify formulas before display
	    cleanMath: function cleanMath(expr) {
	        return typeof expr === "string" ? expr.replace(/\+\s*-/g, "- ").replace(/-\s*-/g, "+ ").replace(/\^1/g, "") : expr;
	    },
	
	    // Bound a number by 1e-6 and 1e20 to avoid exponents after toString
	    bound: function bound(num) {
	        if (num === 0) {
	            return num;
	        } else if (num < 0) {
	            return -KhanMath.bound(-num);
	        } else {
	            return Math.max(1e-6, Math.min(num, 1e20));
	        }
	    },
	
	    factorial: function factorial(x) {
	        if (x <= 1) {
	            return x;
	        } else {
	            return x * KhanMath.factorial(x - 1);
	        }
	    },
	
	    getGCD: function getGCD(a, b) {
	        if (arguments.length > 2) {
	            var rest = [].slice.call(arguments, 1);
	            return KhanMath.getGCD(a, KhanMath.getGCD.apply(KhanMath, rest));
	        } else {
	            var mod = void 0;
	
	            a = Math.abs(a);
	            b = Math.abs(b);
	
	            while (b) {
	                mod = a % b;
	                a = b;
	                b = mod;
	            }
	
	            return a;
	        }
	    },
	
	    getLCM: function getLCM(a, b) {
	        if (arguments.length > 2) {
	            var rest = [].slice.call(arguments, 1);
	            return KhanMath.getLCM(a, KhanMath.getLCM.apply(KhanMath, rest));
	        } else {
	            return Math.abs(a * b) / KhanMath.getGCD(a, b);
	        }
	    },
	
	    primes: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97],
	
	    isPrime: function isPrime(n) {
	        if (n <= 1) {
	            return false;
	        } else if (n < 101) {
	            return !!$.grep(KhanMath.primes, function (p, i) {
	                return Math.abs(p - n) <= 0.5;
	            }).length;
	        } else {
	            if (n <= 1 || n > 2 && n % 2 === 0) {
	                return false;
	            } else {
	                for (var i = 3, sqrt = Math.sqrt(n); i <= sqrt; i += 2) {
	                    if (n % i === 0) {
	                        return false;
	                    }
	                }
	            }
	
	            return true;
	        }
	    },
	
	    getPrimeFactorization: function getPrimeFactorization(number) {
	        if (number === 1) {
	            return [];
	        } else if (KhanMath.isPrime(number)) {
	            return [number];
	        }
	
	        var maxf = Math.sqrt(number);
	        for (var f = 2; f <= maxf; f++) {
	            if (number % f === 0) {
	                return $.merge(KhanMath.getPrimeFactorization(f), KhanMath.getPrimeFactorization(number / f));
	            }
	        }
	    },
	
	    // Round a number to the nearest increment
	    // E.g., if increment = 30 and num = 40, return 30. if increment = 30 and
	    //     num = 45, return 60.
	    roundToNearest: function roundToNearest(increment, num) {
	        return Math.round(num / increment) * increment;
	    },
	
	    // Round a number to a certain number of decimal places
	    roundTo: function roundTo(precision, num) {
	        var factor = Math.pow(10, precision).toFixed(5);
	        return Math.round((num * factor).toFixed(5)) / factor;
	    },
	
	    /**
	     * Return a string of num rounded to a fixed precision decimal places,
	     * with an approx symbol if num had to be rounded, and trailing 0s
	     */
	    toFixedApprox: function toFixedApprox(num, precision) {
	        // TODO(aria): Make this locale-dependent like KhanUtil.localeToFixed
	        var fixedStr = num.toFixed(precision);
	        if (knumber.equal(+fixedStr, num)) {
	            return fixedStr;
	        } else {
	            return "\\approx " + fixedStr;
	        }
	    },
	
	    /**
	     * Return a string of num rounded to precision decimal places, with an
	     * approx symbol if num had to be rounded, but no trailing 0s if it was
	     * not rounded.
	     */
	    roundToApprox: function roundToApprox(num, precision) {
	        var fixed = KhanMath.roundTo(precision, num);
	        if (knumber.equal(fixed, num)) {
	            return String(fixed);
	        } else {
	            return KhanMath.toFixedApprox(num, precision);
	        }
	    },
	
	    // toFraction(4/8) => [1, 2]
	    // toFraction(0.666) => [333, 500]
	    // toFraction(0.666, 0.001) => [2, 3]
	    //
	    // tolerance can't be bigger than 1, sorry
	    toFraction: function toFraction(decimal, tolerance) {
	        if (tolerance == null) {
	            tolerance = Math.pow(2, -46);
	        }
	
	        if (decimal < 0 || decimal > 1) {
	            var fract = decimal % 1;
	            fract += fract < 0 ? 1 : 0;
	
	            var nd = KhanMath.toFraction(fract, tolerance);
	            nd[0] += Math.round(decimal - fract) * nd[1];
	            return nd;
	        } else if (Math.abs(Math.round(Number(decimal)) - decimal) <= tolerance) {
	            return [Math.round(decimal), 1];
	        } else {
	            var loN = 0;
	            var loD = 1;
	            var hiN = 1;
	            var hiD = 1;
	            var midN = 1;
	            var midD = 2;
	
	            while (true) {
	                // eslint-disable-line no-constant-condition
	                if (Math.abs(Number(midN / midD) - decimal) <= tolerance) {
	                    return [midN, midD];
	                } else if (midN / midD < decimal) {
	                    loN = midN;
	                    loD = midD;
	                } else {
	                    hiN = midN;
	                    hiD = midD;
	                }
	
	                midN = loN + hiN;
	                midD = loD + hiD;
	            }
	        }
	    },
	
	    // Returns the format (string) of a given numeric string
	    // Note: purposively more inclusive than answer-types' predicate.forms
	    // That is, it is not necessarily true that interpreted input are numeric
	    getNumericFormat: function getNumericFormat(text) {
	        text = $.trim(text);
	        text = text.replace(/\u2212/, "-").replace(/([+-])\s+/g, "$1");
	        if (text.match(/^[+-]?\d+$/)) {
	            return "integer";
	        } else if (text.match(/^[+-]?\d+\s+\d+\s*\/\s*\d+$/)) {
	            return "mixed";
	        }
	        var fraction = text.match(/^[+-]?(\d+)\s*\/\s*(\d+)$/);
	        if (fraction) {
	            return parseFloat(fraction[1]) > parseFloat(fraction[2]) ? "improper" : "proper";
	        } else if (text.replace(/[,. ]/g, "").match(/^\d+$/)) {
	            return "decimal";
	        } else if (text.match(/(pi?|\u03c0|t(?:au)?|\u03c4|pau)/)) {
	            return "pi";
	        } else {
	            return null;
	        }
	    },
	
	    // Returns a string of the number in a specified format
	    toNumericString: function toNumericString(number, format) {
	        if (number == null) {
	            return "";
	        } else if (number === 0) {
	            return "0"; // otherwise it might end up as 0% or 0pi
	        }
	
	        if (format === "percent") {
	            return number * 100 + "%";
	        }
	
	        if (format === "pi") {
	            var fraction = knumber.toFraction(number / Math.PI);
	            var numerator = Math.abs(fraction[0]);
	            var denominator = fraction[1];
	            if (knumber.isInteger(numerator)) {
	                var sign = number < 0 ? "-" : "";
	                var pi = "\u03C0";
	                return sign + (numerator === 1 ? "" : numerator) + pi + (denominator === 1 ? "" : "/" + denominator);
	            }
	        }
	
	        if (_(["proper", "improper", "mixed", "fraction"]).contains(format)) {
	            var _fraction = knumber.toFraction(number);
	            var _numerator = Math.abs(_fraction[0]);
	            var _denominator = _fraction[1];
	            var _sign = number < 0 ? "-" : "";
	            if (_denominator === 1) {
	                return _sign + _numerator; // for integers, irrational, d > 1000
	            } else if (format === "mixed") {
	                var modulus = _numerator % _denominator;
	                var integer = (_numerator - modulus) / _denominator;
	                return _sign + (integer ? integer + " " : "") + modulus + "/" + _denominator;
	            } // otherwise proper, improper, or fraction
	            return _sign + _numerator + "/" + _denominator;
	        }
	
	        // otherwise (decimal, float, long long)
	        return String(number);
	    }
	};
	
	module.exports = KhanMath;

/***/ },
/* 209 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	var _lintUtils = __webpack_require__(279);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "absolute-url",
	    severity: _rule2.default.Severity.GUIDELINE,
	    selector: "link, image",
	    lint: function lint(state, content, nodes, match) {
	        var url = nodes[0].target;
	        var hostname = (0, _lintUtils.getHostname)(url);
	
	        if (hostname === "khanacademy.org" || hostname.endsWith(".khanacademy.org")) {
	            return "Don't use absolute URLs:\nWhen linking to KA content or images, omit the\nhttps://www.khanacademy.org URL prefix.\nUse a relative URL beginning with / instead.";
	        }
	    }
	});

/***/ },
/* 210 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "blockquoted-math",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "blockQuote math, blockQuote blockMath",
	    message: "Blockquoted math:\nmath should not be indented."
	});

/***/ },
/* 211 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "blockquoted-widget",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "blockQuote widget",
	    message: "Blockquoted widget:\nwidgets should not be indented."
	});

/***/ },
/* 212 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "double-spacing-after-terminal",
	    severity: _rule2.default.Severity.BULK_WARNING,
	    selector: "paragraph",
	    pattern: /[.!\?] {2}/i,
	    message: "Use a single space after a sentence-ending period, or\nany other kind of terminal punctuation."
	});

/***/ },
/* 213 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "extra-content-spacing",
	    selector: "paragraph",
	    pattern: /\s+$/,
	    applies: function applies(context) {
	        return context.contentType === 'article';
	    },
	    message: "No extra whitespace at the end of content blocks."
	});

/***/ },
/* 214 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "heading-level-1",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "heading",
	    lint: function lint(state, content, nodes, match) {
	        if (nodes[0].level === 1) {
	            return "Don't use level-1 headings:\nBegin headings with two or more # characters.";
	        }
	    }
	});

/***/ },
/* 215 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "heading-level-skip",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "heading ~ heading",
	    lint: function lint(state, content, nodes, match) {
	        var currentHeading = nodes[1];
	        var previousHeading = nodes[0];
	        // A heading can have a level less than, the same as
	        // or one more than the previous heading. But going up
	        // by 2 or more levels is not right
	        if (currentHeading.level > previousHeading.level + 1) {
	            return "Skipped heading level:\nthis heading is level " + currentHeading.level + " but\nthe previous heading was level " + previousHeading.level;
	        }
	    }
	});

/***/ },
/* 216 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "heading-sentence-case",
	    severity: _rule2.default.Severity.GUIDELINE,
	    selector: "heading",
	    pattern: /^\W*[a-z]/, // first letter is lowercase
	    message: "First letter is lowercase:\nthe first letter of a heading should be capitalized."
	});

/***/ },
/* 217 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	// These are 3-letter and longer words that we would not expect to be
	// capitalized even in a title-case heading.  See
	// http://blog.apastyle.org/apastyle/2012/03/title-case-and-sentence-case-capitalization-in-apa-style.html
	var littleWords = { and: true, nor: true, but: true, the: true, for: true };
	
	function isCapitalized(word) {
	    var c = word[0];
	    return c === c.toUpperCase();
	}
	
	module.exports = _rule2.default.makeRule({
	    name: "heading-title-case",
	    severity: _rule2.default.Severity.GUIDELINE,
	    selector: "heading",
	    pattern: /[^\s:]\s+[A-Z]+[a-z]/,
	    locale: "en",
	    lint: function lint(state, content, nodes, match) {
	        // We want to assert that heading text is in sentence case, not
	        // title case. The pattern above requires a capital letter at the
	        // start of the heading and allows them after a colon, or in
	        // acronyms that are all capitalized.
	        //
	        // But we can't warn just because the pattern matched because
	        // proper nouns are also allowed bo be capitalized. We're not
	        // going to do dictionary lookup to check for proper nouns, so
	        // we try a heuristic: if the title is more than 3 words long
	        // and if all the words are capitalized or are on the list of
	        // words that don't get capitalized, then we'll assume that
	        // the heading is incorrectly in title case and will warn.
	        // But if there is at least one non-capitalized long word then
	        // we're not in title case and we should not warn.
	        //
	        // TODO(davidflanagan): if this rule causes a lot of false
	        // positives, we should tweak it or remove it. Note that it will
	        // fail for headings like "World War II in Russia"
	        //
	        // TODO(davidflanagan): This rule is specific to English.
	        // It is marked with a locale property above, but that is NYI
	        //
	        // for APA style rules for title case
	
	        var heading = content.trim();
	        var words = heading.split(/\s+/);
	
	        // Remove the first word and the little words
	        words.shift();
	        words = words.filter(function (w) {
	            return w.length > 2 && !littleWords.hasOwnProperty(w);
	        });
	
	        // If there are at least 3 remaining words and all
	        // are capitalized, then the heading is in title case.
	        if (words.length >= 3 && words.every(function (w) {
	            return isCapitalized(w);
	        })) {
	            return "Title-case heading:\nThis heading appears to be in title-case, but should be sentence-case.\nOnly capitalize the first letter and proper nouns.";
	        }
	    }
	});

/***/ },
/* 218 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "image-alt-text",
	    severity: _rule2.default.Severity.BULK_WARNING,
	    selector: "image",
	    lint: function lint(state, content, nodes, match) {
	        var image = nodes[0];
	        if (!image.alt || !image.alt.trim()) {
	            return "Images should have alt text:\nfor accessibility, all images should have alt text.\nSpecify alt text inside square brackets after the !.";
	        } else if (image.alt.length < 8) {
	            return "Images should have alt text:\nfor accessibility, all images should have descriptive alt text.\nThis image's alt text is only " + image.alt.length + " characters long.";
	        }
	    }
	});

/***/ },
/* 219 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "image-in-table",
	    severity: _rule2.default.Severity.BULK_WARNING,
	    selector: "table image",
	    message: "Image in table:\ndo not put images inside of tables."
	});

/***/ },
/* 220 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "link-click-here",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "link",
	    pattern: /click here/i,
	    message: "Inappropriate link text:\nDo not use the words \"click here\" in links."
	});

/***/ },
/* 221 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "long-paragraph",
	    severity: _rule2.default.Severity.GUIDELINE,
	    selector: "paragraph",
	    pattern: /^.{501,}/,
	    lint: function lint(state, content, nodes, match) {
	        return "Paragraph too long:\nThis paragraph is " + content.length + " characters long.\nShorten it to 500 characters or fewer.";
	    }
	});

/***/ },
/* 222 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "math-adjacent",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "blockMath+blockMath",
	    message: "Adjacent math blocks:\ncombine the blocks between \\begin{align} and \\end{align}"
	});

/***/ },
/* 223 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "math-align-extra-break",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "blockMath",
	    pattern: /(\\{2,})\s*\\end{align}/,
	    message: "Extra space at end of block:\nDon't end an align block with backslashes"
	});

/***/ },
/* 224 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "math-align-linebreaks",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "blockMath",
	    pattern: /\\begin{align}.*[^\\](\\{2,3}[^\\]|\\{5,}).*\\end{align}/,
	    message: "Use four backslashes between lines of an align block"
	});

/***/ },
/* 225 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "math-empty",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "math, blockMath",
	    pattern: /^$/,
	    message: "Empty math: don't use $$ in your markdown."
	});

/***/ },
/* 226 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "math-font-size",
	    severity: _rule2.default.Severity.GUIDELINE,
	    selector: "math, blockMath",
	    // eslint-disable-next-line max-len
	    pattern: /\\(tiny|Tiny|small|large|Large|LARGE|huge|Huge|scriptsize|normalsize)\s*{/,
	    message: "Math font size:\nDon't change the default font size with \\Large{} or similar commands"
	});

/***/ },
/* 227 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "math-frac",
	    severity: _rule2.default.Severity.GUIDELINE,
	    selector: "math, blockMath",
	    pattern: /\\frac[ {]/,
	    message: "Use \\dfrac instead of \\frac in your math expressions."
	});

/***/ },
/* 228 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "math-nested",
	    severity: _rule2.default.Severity.ERROR,
	    selector: "math, blockMath",
	    pattern: /\\text{[^$}]*\$[^$}]*\$[^}]*}/,
	    message: "Nested math:\nDon't nest math expressions inside \\text{} blocks"
	});

/***/ },
/* 229 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "math-starts-with-space",
	    severity: _rule2.default.Severity.GUIDELINE,
	    selector: "math, blockMath",
	    pattern: /^\s*(~|\\qquad|\\quad|\\,|\\;|\\:|\\ |\\!|\\enspace|\\phantom)/,
	    message: "Math starts with space:\nmath should not be indented. Do not begin math expressions with\nLaTeX space commands like ~, \\;, \\quad, or \\phantom"
	});

/***/ },
/* 230 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "math-text-empty",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "math, blockMath",
	    pattern: /\\text{\s*}/,
	    message: "Empty \\text{} block in math expression"
	});

/***/ },
/* 231 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "nested-lists",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "list list",
	    message: "Nested lists:\nnested lists are hard to read on mobile devices;\ndo not use additional indentation."
	});

/***/ },
/* 232 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "table-missing-cells",
	    severity: _rule2.default.Severity.WARNING,
	    selector: "table",
	    lint: function lint(state, content, nodes, match) {
	        var table = nodes[0];
	        var headerLength = table.header.length;
	        var rowLengths = table.cells.map(function (r) {
	            return r.length;
	        });
	        for (var r = 0; r < rowLengths.length; r++) {
	            if (rowLengths[r] !== headerLength) {
	                return "Table rows don't match header:\nThe table header has " + headerLength + " cells, but\nRow " + (r + 1) + " has " + rowLengths[r] + " cells.";
	            }
	        }
	    }
	});

/***/ },
/* 233 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "unescaped-dollar",
	    severity: _rule2.default.Severity.ERROR,
	    selector: "unescapedDollar",
	    message: "Unescaped dollar sign:\nDollar signs must appear in pairs or be escaped as \\$"
	});

/***/ },
/* 234 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "widget-in-table",
	    severity: _rule2.default.Severity.BULK_WARNING,
	    selector: "table widget",
	    message: "Widget in table:\ndo not put widgets inside of tables."
	});

/***/ },
/* 235 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "profanity",
	    // This list could obviously be expanded a lot, but I figured we
	    // could start with https://en.wikipedia.org/wiki/Seven_dirty_words
	    pattern: /\b(shit|piss|fuck|cunt|cocksucker|motherfucker|tits)\b/i,
	    message: "Avoid profanity"
	});

/***/ },
/* 236 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	// Because no selector is specified, this rule only applies to text nodes.
	// Math and code hold their content directly and do not have text nodes
	// beneath them (unlike the HTML DOM) so this rule automatically does not
	// apply inside $$ or ``.
	module.exports = _rule2.default.makeRule({
	    name: "math-without-dollars",
	    severity: _rule2.default.Severity.GUIDELINE,
	    pattern: /\\\w+{[^}]*}|{|}/,
	    message: "This looks like LaTeX:\ndid you mean to put it inside dollar signs?"
	});

/***/ },
/* 237 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	// Because no selector is specified, this rule only applies to text nodes.
	// Math and code hold their content directly and do not have text nodes
	// beneath them (unlike the HTML DOM) so this rule automatically does not
	// apply inside $$ or ``.
	module.exports = _rule2.default.makeRule({
	    name: "unbalanced-code-delimiters",
	    severity: _rule2.default.Severity.ERROR,
	    pattern: /[`~]+/,
	    message: "Unbalanced code delimiters:\ncode blocks should begin and end with the same type and number of delimiters"
	});

/***/ },
/* 238 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	module.exports = _rule2.default.makeRule({
	    name: "image-spaces-around-urls",
	    severity: _rule2.default.Severity.ERROR,
	    selector: "image",
	    lint: function lint(state, content, nodes, match, context) {
	        var image = nodes[0];
	        var url = image.target;
	
	        // The markdown parser strips leading and trailing spaces for us,
	        // but they're still a problem for our translation process, so
	        // we need to go check for them in the unparsed source string
	        // if we have it.
	        if (context && context.content) {
	            // Find the url in the original content and make sure that the
	            // character before is '(' and the character after is ')'
	            var index = context.content.indexOf(url);
	            if (index === -1) {
	                // It is not an error if we didn't find it.
	                return;
	            }
	
	            if (context.content[index - 1] !== "(" || context.content[index + url.length] !== ")") {
	                return "Whitespace before or after image url:\nFor images, don't include any space or newlines after '(' or before ')'.\nWhitespace in image URLs causes translation difficulties.";
	            }
	        }
	    }
	});

/***/ },
/* 239 */
/***/ function(module, exports, __webpack_require__) {

	var _rule = __webpack_require__(84);
	
	var _rule2 = _interopRequireDefault(_rule);
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
	
	// Normally we have one rule per file. But since our selector class
	// can't match specific widget types directly, this rule implements
	// a number of image widget related rules in one place. This should
	// slightly increase efficiency, but it means that if there is more
	// than one problem with an image widget, the user will only see one
	// problem at a time.
	module.exports = _rule2.default.makeRule({
	    name: "image-widget",
	    severity: _rule2.default.Severity.BULK_WARNING,
	    selector: "widget",
	    lint: function lint(state, content, nodes, match, context) {
	        // This rule only looks at image widgets
	        if (state.currentNode().widgetType !== "image") {
	            return;
	        }
	
	        // If it can't find a definition for the widget it does nothing
	        var widget = context && context.widgets && context.widgets[state.currentNode().id];
	        if (!widget) {
	            return;
	        }
	
	        // Make sure there is alt text
	        var alt = widget.options.alt;
	        if (!alt) {
	            return "Images should have alt text:\nfor accessibility, all images should have a text description.\nAdd a description in the \"Alt Text\" box of the image widget.";
	        }
	
	        // Make sure the alt text it is not trivial
	        if (alt.trim().length < 8) {
	            return "Images should have alt text:\nfor accessibility, all images should have descriptive alt text.\nThis image's alt text is only " + alt.trim().length + " characters long.";
	        }
	
	        // Make sure there is no math in the caption
	        if (widget.options.caption && widget.options.caption.match(/[^\\]\$/)) {
	            return "No math in image captions:\nDon't include math expressions in image captions.";
	        }
	    }
	});

/***/ },
/* 240 */,
/* 241 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable object-curly-spacing */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var _require = __webpack_require__(77),
	    interactiveSizes = _require.interactiveSizes;
	
	// Note: these size cutoffs represent content-width cutoffs as
	// specified in http://zpl.io/1mVmvU
	// TODO(benkomalo): these values aren't used in JS outside of this file, but
	// are coupled to the values in
	// stylesheets/exercise-content-package/articles.less - DRY it up at some point
	
	
	var React = __webpack_require__(43);
	
	var smMax = 512;
	var mdMax = 688;
	
	var containerSizeClass = {
	    SMALL: "small",
	    MEDIUM: "medium",
	    LARGE: "large",
	    XLARGE: "xlarge"
	};
	
	module.exports = {
	    containerSizeClass: containerSizeClass,
	    containerSizeClassPropType: React.PropTypes.oneOf(Object.values(containerSizeClass)),
	
	    getClassFromWidth: function getClassFromWidth(width) {
	        if (!width) {
	            return containerSizeClass.MEDIUM;
	        }
	
	        if (width <= smMax) {
	            return containerSizeClass.SMALL;
	        } else if (width <= mdMax) {
	            return containerSizeClass.MEDIUM;
	        } else {
	            return containerSizeClass.LARGE;
	        }
	    },
	
	    getInteractiveBoxFromSizeClass: function getInteractiveBoxFromSizeClass(sizeClass) {
	        if (sizeClass === containerSizeClass.SMALL) {
	            return [interactiveSizes.defaultBoxSizeSmall, interactiveSizes.defaultBoxSizeSmall];
	        } else {
	            return [interactiveSizes.defaultBoxSize, interactiveSizes.defaultBoxSize];
	        }
	    }
	};

/***/ },
/* 242 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable comma-dangle, no-var */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	/* Free implementation of getUserInput. This should be used sparingly, since it
	 * just returns all the widget's props rather than picking out those which were
	 * input by the user.
	 */
	var WIDGET_PROP_BLACKLIST = __webpack_require__(93);
	var _ = __webpack_require__(56);
	
	var WidgetJsonifyDeprecated = {
	    getUserInput: function getUserInput() {
	        // Omit props that get passed to all widgets
	        return _.omit(this.props, WIDGET_PROP_BLACKLIST);
	    }
	};
	
	module.exports = WidgetJsonifyDeprecated;

/***/ },
/* 243 */,
/* 244 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A wrapper around graphie.js and interactive.js to make sure interactive.js
	 * is always required at the same time as graphie.js. This is because
	 * interactive.js has side effects that are hard to see (it adds things to
	 * `Graphie.prototype`), so someone might forget to require interactive.js.
	 *
	 * To use the utilities exported from interactive.js, require that file
	 * itself.
	 */
	var GraphUtils = __webpack_require__(280);
	__webpack_require__(281); // For side effects
	
	module.exports = GraphUtils;

/***/ },
/* 245 */,
/* 246 */,
/* 247 */,
/* 248 */,
/* 249 */,
/* 250 */,
/* 251 */,
/* 252 */,
/* 253 */,
/* 254 */,
/* 255 */
/***/ function(module, exports, __webpack_require__) {

	/* eslint-disable react/sort-comp */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var _ = __webpack_require__(56);
	var TeX = __webpack_require__(178);
	var ApiClassNames = __webpack_require__(12).ClassNames;
	var ModifyTex = __webpack_require__(183).modifyTex;
	
	var MathOutput = React.createClass({
	    displayName: "MathOutput",
	
	    propTypes: {
	        value: React.PropTypes.oneOfType([React.PropTypes.string, React.PropTypes.number]),
	        className: React.PropTypes.string,
	        labelText: React.PropTypes.string,
	        onFocus: React.PropTypes.func,
	        onBlur: React.PropTypes.func
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            value: "",
	            onFocus: function onFocus() {},
	            onBlur: function onBlur() {}
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            focused: false,
	            selectorNamespace: _.uniqueId("math-output")
	        };
	    },
	
	    _getInputClassName: function _getInputClassName() {
	        var className = "math-output " + ApiClassNames.INPUT + " " + ApiClassNames.INTERACTIVE;
	        if (this.state.focused) {
	            className += " " + ApiClassNames.FOCUSED;
	        }
	        if (this.props.className) {
	            className += " " + this.props.className;
	        }
	        return className;
	    },
	
	    _getDisplayValue: function _getDisplayValue(value) {
	        // Cast from (potentially a) number to string
	        var displayText = void 0;
	        if (value != null) {
	            displayText = "" + value;
	        } else {
	            displayText = "";
	        }
	        return ModifyTex(displayText);
	    },
	
	    render: function render() {
	        var divStyle = {
	            textAlign: "center"
	        };
	
	        return React.createElement(
	            "span",
	            {
	                ref: "input",
	                className: this._getInputClassName(),
	                "aria-label": this.props.labelText,
	                onMouseDown: this.focus,
	                onTouchStart: this.focus
	            },
	            React.createElement(
	                "div",
	                { style: divStyle },
	                React.createElement(
	                    TeX,
	                    null,
	                    this._getDisplayValue(this.props.value)
	                )
	            )
	        );
	    },
	
	    getValue: function getValue() {
	        return this.props.value;
	    },
	
	    focus: function focus() {
	        if (!this.state.focused) {
	            this.props.onFocus();
	            this._bindBlurHandler();
	            this.setState({
	                focused: true
	            });
	        }
	    },
	
	    blur: function blur() {
	        if (this.state.focused) {
	            this.props.onBlur();
	            this._unbindBlurHandler();
	            this.setState({
	                focused: false
	            });
	        }
	    },
	
	    _bindBlurHandler: function _bindBlurHandler() {
	        var _this = this;
	
	        $(document).bind("vclick." + this.state.selectorNamespace, function (e) {
	            // Detect whether the target has our React DOM node as a parent
	            var $closestWidget = $(e.target).closest(ReactDOM.findDOMNode(_this));
	            if (!$closestWidget.length) {
	                _this.blur();
	            }
	        });
	    },
	
	    _unbindBlurHandler: function _unbindBlurHandler() {
	        $(document).unbind("." + this.state.selectorNamespace);
	    },
	
	    componentWillUnmount: function componentWillUnmount() {
	        this._unbindBlurHandler();
	    }
	});
	
	module.exports = MathOutput;

/***/ },
/* 256 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Utility functions for writing Interactive2 movablethings
	 */
	
	var _ = __webpack_require__(56);
	var MovableHelperMethods = __webpack_require__(282);
	
	/**
	 * Compute the correct vendor-prefixed `transform`.
	 */
	var prefixedTransform = null;
	function computePrefixedTransform() {
	    // Temporary element for testing prefix validity
	    var el = document.createElement("div");
	
	    var prefixes = ["transform", "msTransform", "MozTransform", "WebkitTransform", "OTransform"];
	    var correctPrefix = null;
	    _.each(prefixes, function (prefix) {
	        if (typeof el.style[prefix] !== 'undefined') {
	            correctPrefix = prefix;
	        }
	    });
	    return correctPrefix;
	}
	
	/**
	 * Compute whether the browser can use 3d transforms by trying to use the
	 * translateZ transformation.
	 */
	var canUse3dTransform = null;
	function computeCanUse3dTransform() {
	    var el = document.createElement("div");
	
	    var prefix = InteractiveUtil.getPrefixedTransform();
	
	    el.style[prefix] = "translateZ(0px)";
	    return !!el.style[prefix];
	}
	
	var InteractiveUtil = {
	    assert: function assert(isTrue, message) {
	        if (!isTrue) {
	            throw new Error("Assertion Error" + (message ? ": " + message : ""));
	        }
	    },
	
	    /**
	     * Create getters for this.state, based on the default state, `defaults`
	     */
	    createGettersFor: function createGettersFor(Class, defaults) {
	        _.each(_.keys(defaults), function (key) {
	            if (Class.prototype[key] === undefined) {
	                Class.prototype[key] = function () {
	                    return this.state[key];
	                };
	            }
	        });
	    },
	
	    /**
	     * Add MovableHelperMethods methods to a MovableThing class
	     */
	    addMovableHelperMethodsTo: function addMovableHelperMethodsTo(Class) {
	        _.each(MovableHelperMethods, function (methodFunc, methodName) {
	            if (Class.prototype[methodName] === undefined) {
	                Class.prototype[methodName] = methodFunc;
	            }
	        });
	    },
	
	    /**
	     * Turn a function or an array of functions into an array of functions
	     */
	    arrayify: function arrayify(funcOrArray) {
	        if (funcOrArray == null) {
	            return [];
	        } else if (_.isArray(funcOrArray)) {
	            return _.filter(_.flatten(funcOrArray), _.identity);
	        } else {
	            return [funcOrArray];
	        }
	    },
	
	    /**
	     * Convert all function-or-array arguments to arrays of functions
	     */
	    normalizeOptions: function normalizeOptions(arrayOptionNames, options) {
	        // TODO(jack): Having to clone here is annoying; this
	        // function should really just modify this.state in place
	        // (and maybe be a function on MovableHelperMethods to get access
	        // to this.state), which would also be nicer because we could
	        // normalizeOptions once in this.modify
	        var result = _.clone(options);
	        _.each(arrayOptionNames, function (eventName) {
	            var funcOrArray = options[eventName];
	            // Only propagate values which were set; not present values
	            // shouldn't be added to options because we'd like them to
	            // fall through to defaults
	            if (funcOrArray !== undefined) {
	                var funcArray = InteractiveUtil.arrayify(funcOrArray);
	                result[eventName] = funcArray;
	            }
	        });
	        return result;
	    },
	
	    /**
	     * Get the correct vendor-prefixed `transform`.
	     */
	    getPrefixedTransform: function getPrefixedTransform() {
	        // Cache result to avoid re-computation
	        prefixedTransform = prefixedTransform || computePrefixedTransform();
	        return prefixedTransform;
	    },
	
	    /**
	     * Get whether the browser can use 3d transforms.
	     */
	    getCanUse3dTransform: function getCanUse3dTransform() {
	        if (canUse3dTransform == null) {
	            canUse3dTransform = computeCanUse3dTransform();
	        }
	        return canUse3dTransform;
	    }
	};
	
	module.exports = InteractiveUtil;

/***/ },
/* 257 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A single entry-point for all of the external-facing functionality.
	 */
	
	var components = {
	    Keypad: __webpack_require__(294),
	    KeypadInput: __webpack_require__(296)
	};
	
	var _require = __webpack_require__(283),
	    KeypadTypes = _require.KeypadTypes;
	
	var consts = { KeypadTypes: KeypadTypes };
	
	var _require2 = __webpack_require__(295),
	    keypadConfigurationPropType = _require2.keypadConfigurationPropType,
	    keypadElementPropType = _require2.keypadElementPropType;
	
	var propTypes = { keypadConfigurationPropType: keypadConfigurationPropType, keypadElementPropType: keypadElementPropType };
	
	module.exports = {
	    components: components,
	    consts: consts,
	    propTypes: propTypes
	};

/***/ },
/* 258 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	    value: true
	});
	
	var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _inlineStylePrefixAll = __webpack_require__(312);
	
	var _inlineStylePrefixAll2 = _interopRequireDefault(_inlineStylePrefixAll);
	
	var _util = __webpack_require__(174);
	
	var generateCSS = function generateCSS(selector, styleTypes, stringHandlers, useImportant) {
	    var merged = styleTypes.reduce(_util.recursiveMerge);
	
	    var declarations = {};
	    var mediaQueries = {};
	    var pseudoStyles = {};
	
	    Object.keys(merged).forEach(function (key) {
	        if (key[0] === ':') {
	            pseudoStyles[key] = merged[key];
	        } else if (key[0] === '@') {
	            mediaQueries[key] = merged[key];
	        } else {
	            declarations[key] = merged[key];
	        }
	    });
	
	    return generateCSSRuleset(selector, declarations, stringHandlers, useImportant) + Object.keys(pseudoStyles).map(function (pseudoSelector) {
	        return generateCSSRuleset(selector + pseudoSelector, pseudoStyles[pseudoSelector], stringHandlers, useImportant);
	    }).join("") + Object.keys(mediaQueries).map(function (mediaQuery) {
	        var ruleset = generateCSS(selector, [mediaQueries[mediaQuery]], stringHandlers, useImportant);
	        return mediaQuery + '{' + ruleset + '}';
	    }).join("");
	};
	
	exports.generateCSS = generateCSS;
	var runStringHandlers = function runStringHandlers(declarations, stringHandlers) {
	    var result = {};
	
	    Object.keys(declarations).forEach(function (key) {
	        // If a handler exists for this particular key, let it interpret
	        // that value first before continuing
	        if (stringHandlers && stringHandlers.hasOwnProperty(key)) {
	            result[key] = stringHandlers[key](declarations[key]);
	        } else {
	            result[key] = declarations[key];
	        }
	    });
	
	    return result;
	};
	
	var generateCSSRuleset = function generateCSSRuleset(selector, declarations, stringHandlers, useImportant) {
	    var handledDeclarations = runStringHandlers(declarations, stringHandlers);
	
	    var prefixedDeclarations = (0, _inlineStylePrefixAll2['default'])(handledDeclarations);
	
	    var prefixedRules = (0, _util.flatten)((0, _util.objectToPairs)(prefixedDeclarations).map(function (_ref) {
	        var _ref2 = _slicedToArray(_ref, 2);
	
	        var key = _ref2[0];
	        var value = _ref2[1];
	
	        if (Array.isArray(value)) {
	            var _ret = (function () {
	                // inline-style-prefix-all returns an array when there should be
	                // multiple rules, we will flatten to single rules
	
	                var prefixedValues = [];
	                var unprefixedValues = [];
	
	                value.forEach(function (v) {
	                    if (v.indexOf('-') === 0) {
	                        prefixedValues.push(v);
	                    } else {
	                        unprefixedValues.push(v);
	                    }
	                });
	
	                prefixedValues.sort();
	                unprefixedValues.sort();
	
	                return {
	                    v: prefixedValues.concat(unprefixedValues).map(function (v) {
	                        return [key, v];
	                    })
	                };
	            })();
	
	            if (typeof _ret === 'object') return _ret.v;
	        }
	        return [[key, value]];
	    }));
	
	    var rules = prefixedRules.map(function (_ref3) {
	        var _ref32 = _slicedToArray(_ref3, 2);
	
	        var key = _ref32[0];
	        var value = _ref32[1];
	
	        var stringValue = (0, _util.stringifyValue)(key, value);
	        var ret = (0, _util.kebabifyStyleName)(key) + ':' + stringValue + ';';
	        return useImportant === false ? ret : (0, _util.importantify)(ret);
	    }).join("");
	
	    if (rules) {
	        return selector + '{' + rules + '}';
	    } else {
	        return "";
	    }
	};
	exports.generateCSSRuleset = generateCSSRuleset;

/***/ },
/* 259 */
/***/ function(module, exports, __webpack_require__) {

	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var React = __webpack_require__(43);
	
	var colors = {
	    grayLight: '#aaa',
	    basicBorderColor: '#ccc',
	    white: '#fff'
	};
	
	var triangleBeforeAfter = {
	    borderBottom: '9px solid transparent',
	    borderTop: '9px solid transparent',
	    content: '" "',
	    height: '0',
	    position: 'absolute',
	    top: '0',
	    width: '0'
	};
	
	var styles = StyleSheet.create({
	    infoTip: {
	        display: 'inline-block',
	        marginLeft: '5px',
	        position: 'relative'
	    },
	
	    infoTipContainer: {
	        position: 'absolute',
	        top: '-12px',
	        left: '22px',
	        zIndex: '1000'
	    },
	
	    infoTipTriangle: {
	        height: '10px',
	        left: '0',
	        position: 'absolute',
	        top: '8px',
	        width: '0',
	        zIndex: '1',
	
	        ':before': Object.assign({}, triangleBeforeAfter, {
	            borderRight: '9px solid #bbb',
	            right: '0'
	        }),
	
	        ':after': Object.assign({}, triangleBeforeAfter, {
	            borderRight: '9px solid ' + colors.white,
	            right: '-1px'
	        })
	    },
	
	    verticalShadow: {
	        border: '1px solid ' + colors.basicBorderColor,
	        boxShadow: '0 1px 3px ' + colors.basicBorderColor,
	        borderBottom: '1px solid ' + colors.grayLight
	    },
	
	    infoTipContentContainer: {
	        background: colors.white,
	        padding: '5px 10px',
	        width: '240px'
	    }
	});
	
	var questionMark = 'data:image/png;base64,' + 'iVBORw0KGgoAAAANSUhEUgAAAAoAAAAKCAYAAACNMs+9AAAAGXRFWHRTb2Z0d2FyZQBB' + 'ZG9iZSBJbWFnZVJlYWR5ccllPAAAA3NpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/' + 'eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+' + 'IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2Jl' + 'IFhNUCBDb3JlIDUuNS1jMDIxIDc5LjE1NDkxMSwgMjAxMy8xMC8yOS0xMTo0NzoxNiAg' + 'ICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5' + 'LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9' + 'IiIgeG1sbnM6eG1wTU09Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9tbS8iIHht' + 'bG5zOnN0UmVmPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvc1R5cGUvUmVzb3Vy' + 'Y2VSZWYjIiB4bWxuczp4bXA9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC8iIHht' + 'cE1NOk9yaWdpbmFsRG9jdW1lbnRJRD0ieG1wLmRpZDo2N2M3NTAxYS04YmVlLTQ0M2Mt' + 'YmRiNS04OGM2N2IxN2NhYzEiIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6OUJCRTk4' + 'Qjc4NjAwMTFFMzg3QUJDNEI4Mzk2QTRGQkQiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5p' + 'aWQ6OUJCRTk4QjY4NjAwMTFFMzg3QUJDNEI4Mzk2QTRGQkQiIHhtcDpDcmVhdG9yVG9v' + 'bD0iQWRvYmUgUGhvdG9zaG9wIENDIChNYWNpbnRvc2gpIj4gPHhtcE1NOkRlcml2ZWRG' + 'cm9tIHN0UmVmOmluc3RhbmNlSUQ9InhtcC5paWQ6NGE5ZDI0OTMtODk1NC00OGFkLTlh' + 'MTgtZDAwM2MwYWNjNDJlIiBzdFJlZjpkb2N1bWVudElEPSJ4bXAuZGlkOjY3Yzc1MDFh' + 'LThiZWUtNDQzYy1iZGI1LTg4YzY3YjE3Y2FjMSIvPiA8L3JkZjpEZXNjcmlwdGlvbj4g' + 'PC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/Pqm89uYAAADM' + 'SURBVHjaXJA9DoJAEIUH1M4TUHIFsCMGen9OwCGw1YRGW2ntKel0exsojHIBC0ouQAyU' + 'viFDstmXfNmZeS+zm7XSNCXRFiRgJf0bXIHixpbhGdxBBJYC1w/xaA424MhNEATkui71' + 'fU9KqfEU78UbD9PdbJRlOdae55GmhIP+1NV1TcMwkOM41DSNHvRtMhTHMRVFQW3b6mOL' + 'gx99kue5GRp/gIOZuZGvNpTNwjD8oliANU+qqqKu6/TQBdymN57AHjzBT+B6Jx79BRgA' + 'vc49kQA4yxgAAAAASUVORK5CYII=';
	
	var InfoTip = React.createClass({
	    displayName: 'InfoTip',
	
	    propTypes: {
	        children: React.PropTypes.node
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            hover: false
	        };
	    },
	
	    handleMouseEnter: function handleMouseEnter() {
	        this.setState({ hover: true });
	    },
	
	    handleMouseLeave: function handleMouseLeave() {
	        this.setState({ hover: false });
	    },
	
	    render: function render() {
	        return React.createElement(
	            'div',
	            { className: css(styles.infoTip) },
	            React.createElement('img', { width: 10,
	                height: 10,
	                src: questionMark,
	                onMouseEnter: this.handleMouseEnter,
	                onMouseLeave: this.handleMouseLeave
	            }),
	            React.createElement(
	                'div',
	                {
	                    className: css(styles.infoTipContainer),
	                    style: { display: this.state.hover ? 'block' : 'none' }
	                },
	                React.createElement('div', { className: css(styles.infoTipTriangle) }),
	                React.createElement(
	                    'div',
	                    { className: css(styles.verticalShadow, styles.infoTipContentContainer)
	                    },
	                    this.props.children
	                )
	            )
	        );
	    }
	});
	
	module.exports = InfoTip;

/***/ },
/* 260 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/* @flow */
	
	/**
	 * Simple-Markdown
	 * ===============
	 *
	 * Simple-Markdown's primary goal is to be easy to adapt. It aims
	 * to be compliant with John Gruber's [Markdown Syntax page][1],
	 * but compatiblity with other markdown implementations' edge-cases
	 * will be sacrificed where it conflicts with simplicity or
	 * extensibility.
	 *
	 * If your goal is to simply embed a standard markdown implementation
	 * in your website, simple-markdown is probably not the best library
	 * for you (although it should work). But if you have struggled to
	 * customize an existing library to meet your needs, simple-markdown
	 * might be able to help.
	 *
	 * Many of the regexes and original logic has been adapted from
	 * the wonderful [marked.js](https://github.com/chjj/marked)
	 *
	 * LICENSE (MIT):
	 * New code copyright (c) 2014 Khan Academy.
	 *
	 * Portions adapted from marked.js copyright (c) 2011-2014
	 * Christopher Jeffrey (https://github.com/chjj/).
	 *
	 * Permission is hereby granted, free of charge, to any person obtaining a copy
	 * of this software and associated documentation files (the "Software"), to deal
	 * in the Software without restriction, including without limitation the rights
	 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	 * copies of the Software, and to permit persons to whom the Software is
	 * furnished to do so, subject to the following conditions:
	 *
	 * The above copyright notice and this permission notice shall be included in
	 * all copies or substantial portions of the Software.
	 *
	 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	 * THE SOFTWARE.
	 */
	(function() {
	
	var CR_NEWLINE_R = /\r\n?/g;
	var TAB_R = /\t/g;
	var FORMFEED_R = /\f/g
	// Turn various crazy whitespace into easy to process things
	var preprocess = function(source) {
	    return source.replace(CR_NEWLINE_R, '\n')
	            .replace(FORMFEED_R, '')
	            .replace(TAB_R, '    ');
	};
	
	/**
	 * Creates a parser for a given set of rules, with the precedence
	 * specified as a list of rules.
	 *
	 * @rules: an object containing
	 * rule type -> {match, order, parse} objects
	 * (lower order is higher precedence)
	 * (Note: `order` is added to defaultRules after creation so that
	 *  the `order` of defaultRules in the source matches the `order`
	 *  of defaultRules in terms of `order` fields.)
	 *
	 * @returns The resulting parse function, with the following parameters:
	 *   @source: the input source string to be parsed
	 *   @state: an optional object to be threaded through parse
	 *     calls. Allows clients to add stateful operations to
	 *     parsing, such as keeping track of how many levels deep
	 *     some nesting is. For an example use-case, see passage-ref
	 *     parsing in src/widgets/passage/passage-markdown.jsx
	 */
	var parserFor = function(rules) {
	    // Sorts rules in order of increasing order, then
	    // ascending rule name in case of ties.
	    var ruleList = Object.keys(rules);
	    ruleList.sort(function(typeA, typeB) {
	        var orderA = rules[typeA].order;
	        var orderB = rules[typeB].order;
	
	        // First sort based on increasing order
	        if (orderA !== orderB) {
	            return orderA - orderB;
	
	        // Then based on increasing unicode lexicographic ordering
	        } else if (typeA < typeB) {
	            return -1;
	        } else if (typeA > typeB) {
	            return 1;
	
	        } else {
	            // Rules should never have the same name,
	            // but this is provided for completeness.
	            return 0;
	        }
	    });
	
	    var nestedParse = function(source, state) {
	        var result = [];
	        state = state || {};
	        // We store the previous capture so that match functions can
	        // use some limited amount of lookbehind. Lists use this to
	        // ensure they don't match arbitrary '- ' or '* ' in inline
	        // text (see the list rule for more information).
	        var prevCapture = "";
	        while (source) {
	            var i = 0;
	            while (i < ruleList.length) {
	                var ruleType = ruleList[i];
	                var rule = rules[ruleType];
	                var capture;
	                if (rule.match) {
	                    capture = rule.match(source, state, prevCapture);
	                } else {
	                    capture = rule.regex.exec(source);
	                }
	                if (capture) {
	                    var currCaptureString = capture[0];
	                    source = source.substring(currCaptureString.length);
	                    var parsed = rule.parse(capture, nestedParse, state);
	                    // We maintain the same object here so that rules can
	                    // store references to the objects they return and
	                    // modify them later. (oops sorry! but this adds a lot
	                    // of power--see reflinks.)
	                    // We also let rules override the default type of
	                    // their parsed node if they would like to, so that
	                    // there can be a single output function for all links,
	                    // even if there are several rules to parse them.
	                    if (parsed.type == null) {
	                        parsed.type = ruleType;
	                    }
	                    result.push(parsed);
	
	                    prevCapture = currCaptureString;
	                    break;
	                }
	                i++;
	            }
	
	            // TODO(aria): Write tests for this
	            if (i === ruleList.length) {
	                throw new Error(
	                    "could not find rule to match content: " + source
	                );
	            }
	        }
	        return result;
	    };
	
	    var outerParse = function(source, state) {
	        return nestedParse(preprocess(source), state);
	    };
	    return outerParse;
	};
	
	// Creates a match function for an inline scoped element from a regex
	var inlineRegex = function(regex) {
	    var match = function(source, state) {
	        if (state.inline) {
	            return regex.exec(source);
	        } else {
	            return null;
	        }
	    };
	    match.regex = regex;
	    return match;
	};
	
	// Creates a match function for a block scoped element from a regex
	var blockRegex = function(regex) {
	    var match = function(source, state) {
	        if (state.inline) {
	            return null;
	        } else {
	            return regex.exec(source);
	        }
	    };
	    match.regex = regex;
	    return match;
	};
	
	// Creates a match function from a regex, ignoring block/inline scope
	var anyScopeRegex = function(regex) {
	    var match = function(source, state) {
	        return regex.exec(source);
	    };
	    match.regex = regex;
	    return match;
	};
	
	var reactFor = function(outputFunc) {
	    var nestedOutput = function(ast, state) {
	        state = state || {};
	        if (Array.isArray(ast)) {
	            var oldKey = state.key;
	            var result = [];
	
	            // map nestedOutput over the ast, except group any text
	            // nodes together into a single string output.
	            var lastWasString = false;
	            for (var i = 0; i < ast.length; i++) {
	                state.key = i;
	                var nodeOut = nestedOutput(ast[i], state);
	                var isString = (typeof nodeOut === "string");
	                if (isString && lastWasString) {
	                    result[result.length - 1] += nodeOut;
	                } else {
	                    result.push(nodeOut);
	                }
	                lastWasString = isString;
	            }
	
	            state.key = oldKey;
	            return result;
	        } else {
	            return outputFunc(ast, nestedOutput, state);
	        }
	    };
	    return nestedOutput;
	};
	
	var htmlFor = function(outputFunc) {
	    var nestedOutput = function(ast, state) {
	        state = state || {};
	        if (Array.isArray(ast)) {
	            return ast.map(function(node) {
	                return nestedOutput(node, state);
	            }).join("");
	        } else {
	            return outputFunc(ast, nestedOutput, state);
	        }
	    };
	    return nestedOutput;
	};
	
	var TYPE_SYMBOL =
	    (typeof Symbol === 'function' && Symbol.for &&
	     Symbol.for('react.element')) ||
	    0xeac7;
	
	var reactElement = function(element) {
	    // Debugging assertions. To be commented out when committed
	    // TODO(aria): Figure out a better way of having dev asserts
	/*
	    if (typeof element.props !== "object") {
	        throw new Error("props of " + element.type + " must be an object");
	    }
	    if (!element.$$typeof) {
	        throw new Error(
	            "must set $$typeof on element " +
	            element.type
	        );
	    }
	    if (element._store !== null) { // === because we don't want to count
	                                   // undefined here
	        throw new Error(
	            "must set _store to null on element " +
	            element.type
	        );
	    }
	*/
	
	    // This should just override an already present element._store, which
	    // exists so that the class of this object doesn't change in V8
	    element._store = {
	        validated: true,
	        originalProps: element.props
	    };
	    return element;
	};
	
	// Returns a closed HTML tag.
	// tagName: Name of HTML tag (eg. "em" or "a")
	// content: Inner content of tag
	// attributes: Optional extra attributes of tag as an object of key-value pairs
	//   eg. { "href": "http://google.com" }. Falsey attributes are filtered out.
	// isClosed: boolean that controls whether tag is closed or not (eg. img tags).
	//   defaults to true
	var htmlTag = function(tagName, content, attributes, isClosed) {
	    attributes = attributes || {};
	    isClosed = typeof isClosed !== 'undefined' ? isClosed : true;
	
	    var attributeString = "";
	    for (var attr in attributes) {
	        // Removes falsey attributes
	        if (Object.prototype.hasOwnProperty.call(attributes, attr) &&
	                attributes[attr]) {
	            attributeString += " " + attr + '="' + attributes[attr] + '"';
	        }
	    }
	
	    var unclosedTag = "<" + tagName + attributeString + ">";
	
	    if (isClosed) {
	        return unclosedTag + content + "</" + tagName + ">";
	    } else {
	        return unclosedTag;
	    }
	};
	
	var EMPTY_PROPS = {};
	
	var sanitizeUrl = function(url) {
	    if (url == null) {
	        return null;
	    }
	    try {
	        var prot = decodeURIComponent(url)
	            .replace(/[^A-Za-z0-9/:]/g, '')
	            .toLowerCase();
	        if (prot.indexOf('javascript:') === 0) {
	            return null;
	        }
	    } catch (e) {
	        // decodeURIComponent sometimes throws a URIError
	        // See `decodeURIComponent('a%AFc');`
	        // http://stackoverflow.com/questions/9064536/javascript-decodeuricomponent-malformed-uri-exception
	        return null;
	    }
	    return url;
	};
	
	// Parse some content with the parser `parse`, with state.inline
	// set to true. Useful for block elements; not generally necessary
	// to be used by inline elements (where state.inline is already true.
	var parseInline = function(parse, content, state) {
	    var isCurrentlyInline = state.inline || false;
	    state.inline = true;
	    var result = parse(content, state);
	    state.inline = isCurrentlyInline;
	    return result;
	};
	var parseBlock = function(parse, content, state) {
	    var isCurrentlyInline = state.inline || false;
	    state.inline = false;
	    var result = parse(content + "\n\n", state);
	    state.inline = isCurrentlyInline;
	    return result;
	};
	
	var parseCaptureInline = function(capture, parse, state) {
	    return {
	        content: parseInline(parse, capture[1], state)
	    };
	};
	var ignoreCapture = function() { return {}; };
	
	// recognize a `*` `-`, `+`, `1.`, `2.`... list bullet
	var LIST_BULLET = "(?:[*+-]|\\d+\\.)";
	// recognize the start of a list item:
	// leading space plus a bullet plus a space (`   * `)
	var LIST_ITEM_PREFIX = "( *)(" + LIST_BULLET + ") +";
	var LIST_ITEM_PREFIX_R = new RegExp("^" + LIST_ITEM_PREFIX);
	// recognize an individual list item:
	//  * hi
	//    this is part of the same item
	//
	//    as is this, which is a new paragraph in the same item
	//
	//  * but this is not part of the same item
	var LIST_ITEM_R = new RegExp(
	    LIST_ITEM_PREFIX +
	    "[^\\n]*(?:\\n" +
	    "(?!\\1" + LIST_BULLET + " )[^\\n]*)*(\n|$)",
	    "gm"
	);
	var BLOCK_END_R = /\n{2,}$/;
	// recognize the end of a paragraph block inside a list item:
	// two or more newlines at end end of the item
	var LIST_BLOCK_END_R = BLOCK_END_R;
	var LIST_ITEM_END_R = / *\n+$/;
	// check whether a list item has paragraphs: if it does,
	// we leave the newlines at the end
	var LIST_R = new RegExp(
	    "^( *)(" + LIST_BULLET + ") " +
	    "[\\s\\S]+?(?:\n{2,}(?! )" +
	    "(?!\\1" + LIST_BULLET + " )\\n*" +
	    // the \\s*$ here is so that we can parse the inside of nested
	    // lists, where our content might end before we receive two `\n`s
	    "|\\s*\n*$)"
	);
	var LIST_LOOKBEHIND_R = /^$|\n *$/;
	
	var TABLES = (function() {
	    // predefine regexes so we don't have to create them inside functions
	    // sure, regex literals should be fast, even inside functions, but they
	    // aren't in all browsers.
	    var TABLE_HEADER_TRIM = /^ *| *\| *$/g;
	    var TABLE_ALIGN_TRIM = /^ *|\| *$/g;
	
	    var TABLE_CELLS_TRIM = /(?: *\| *)?\n$/;
	    var NPTABLE_CELLS_TRIM = /\n$/;
	    var PLAIN_TABLE_ROW_TRIM = /^ *\| *| *\| *$/g;
	    var TABLE_ROW_SPLIT = / *\| */;
	
	    var TABLE_RIGHT_ALIGN = /^ *-+: *$/;
	    var TABLE_CENTER_ALIGN = /^ *:-+: *$/;
	    var TABLE_LEFT_ALIGN = /^ *:-+ *$/;
	
	    var parseTableAlignCapture = function(alignCapture) {
	        if (TABLE_RIGHT_ALIGN.test(alignCapture)) {
	            return "right";
	        } else if (TABLE_CENTER_ALIGN.test(alignCapture)) {
	            return "center";
	        } else if (TABLE_LEFT_ALIGN.test(alignCapture)) {
	            return "left";
	        } else {
	            return null;
	        }
	    };
	
	    var parseTableHeader = function(capture, parse, state) {
	        var headerText = capture[1]
	            .replace(TABLE_HEADER_TRIM, "")
	            .split(TABLE_ROW_SPLIT);
	        return headerText.map(function(text) {
	            return parse(text, state);
	        });
	    };
	
	    var parseTableAlign = function(capture, parse, state) {
	        var alignText = capture[2]
	            .replace(TABLE_ALIGN_TRIM, "")
	            .split(TABLE_ROW_SPLIT);
	
	        return alignText.map(parseTableAlignCapture);
	    };
	
	    var parseTableCells = function(capture, parse, state) {
	        var rowsText = capture[3]
	            .replace(TABLE_CELLS_TRIM, "")
	            .split("\n");
	
	        return rowsText.map(function(rowText) {
	            var cellText = rowText
	                .replace(PLAIN_TABLE_ROW_TRIM, "")
	                .split(TABLE_ROW_SPLIT);
	            return cellText.map(function(text) {
	                return parse(text, state);
	            });
	        });
	    };
	
	    var parseNpTableCells = function(capture, parse, state) {
	        var rowsText = capture[3]
	            .replace(NPTABLE_CELLS_TRIM, "")
	            .split("\n");
	
	        return rowsText.map(function(rowText) {
	            var cellText = rowText.split(TABLE_ROW_SPLIT);
	            return cellText.map(function(text) {
	                return parse(text, state);
	            });
	        });
	    };
	
	    var parseTable = function(capture, parse, state) {
	        state.inline = true;
	        var header = parseTableHeader(capture, parse, state);
	        var align = parseTableAlign(capture, parse, state);
	        var cells = parseTableCells(capture, parse, state);
	        state.inline = false;
	
	        return {
	            type: "table",
	            header: header,
	            align: align,
	            cells: cells
	        };
	    };
	
	    var parseNpTable = function(capture, parse, state) {
	        state.inline = true;
	        var header = parseTableHeader(capture, parse, state);
	        var align = parseTableAlign(capture, parse, state);
	        var cells = parseNpTableCells(capture, parse, state);
	        state.inline = false;
	
	        return {
	            type: "table",
	            header: header,
	            align: align,
	            cells: cells
	        };
	    };
	
	    return {
	        parseTable: parseTable,
	        parseNpTable: parseNpTable,
	        NPTABLE_REGEX: /^ *(\S.*\|.*)\n *([-:]+ *\|[-| :]*)\n((?:.*\|.*(?:\n|$))*)\n*/
	    };
	})();
	
	var LINK_INSIDE = "(?:\\[[^\\]]*\\]|[^\\]]|\\](?=[^\\[]*\\]))*";
	var LINK_HREF_AND_TITLE =
	        "\\s*<?([^\\s]*?)>?(?:\\s+['\"]([\\s\\S]*?)['\"])?\\s*";
	var AUTOLINK_MAILTO_CHECK_R = /mailto:/i;
	
	var parseRef = function(capture, state, refNode) {
	    var ref = (capture[2] || capture[1])
	        .replace(/\s+/g, ' ')
	        .toLowerCase();
	
	    // We store information about previously seen defs on
	    // state._defs (_ to deconflict with client-defined
	    // state). If the def for this reflink/refimage has
	    // already been seen, we can use its target/source
	    // and title here:
	    if (state._defs && state._defs[ref]) {
	        var def = state._defs[ref];
	        // `refNode` can be a link or an image. Both use
	        // target and title properties.
	        refNode.target = def.target;
	        refNode.title = def.title;
	    }
	
	    // In case we haven't seen our def yet (or if someone
	    // overwrites that def later on), we add this node
	    // to the list of ref nodes for that def. Then, when
	    // we find the def, we can modify this link/image AST
	    // node :).
	    // I'm sorry.
	    state._refs = state._refs || {};
	    state._refs[ref] = state._refs[ref] || [];
	    state._refs[ref].push(refNode);
	
	    return refNode;
	};
	
	var defaultRules = {
	    heading: {
	        match: blockRegex(/^ *(#{1,6}) *([^\n]+?) *#* *(?:\n *)+\n/),
	        parse: function(capture, parse, state) {
	            return {
	                level: capture[1].length,
	                content: parseInline(parse, capture[2], state)
	            };
	        },
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'h' + node.level,
	                key: state.key,
	                props: {
	                    children: output(node.content, state)
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null
	            });
	        },
	        html: function(node, output, state) {
	            return htmlTag("h" + node.level, output(node.content, state));
	        }
	    },
	    nptable: {
	        match: blockRegex(TABLES.NPTABLE_REGEX),
	        // For perseus-markdown temporary backcompat:
	        regex: TABLES.NPTABLE_REGEX,
	        parse: TABLES.parseNpTable
	    },
	    lheading: {
	        match: blockRegex(/^([^\n]+)\n *(=|-){3,} *(?:\n *)+\n/),
	        parse: function(capture, parse, state) {
	            return {
	                type: "heading",
	                level: capture[2] === '=' ? 1 : 2,
	                content: parseInline(parse, capture[1], state)
	            };
	        }
	    },
	    hr: {
	        match: blockRegex(/^( *[-*_]){3,} *(?:\n *)+\n/),
	        parse: ignoreCapture,
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'hr',
	                key: state.key,
	                props: EMPTY_PROPS,
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            return "<hr>";
	        }
	    },
	    codeBlock: {
	        match: blockRegex(/^(?:    [^\n]+\n*)+(?:\n *)+\n/),
	        parse: function(capture, parse, state) {
	            var content = capture[0]
	                .replace(/^    /gm, '')
	                .replace(/\n+$/, '');
	            return {
	                lang: undefined,
	                content: content
	            };
	        },
	        react: function(node, output, state) {
	            var className = node.lang ?
	                "markdown-code-" + node.lang :
	                undefined;
	
	            return reactElement({
	                type: 'pre',
	                key: state.key,
	                props: {
	                    children: reactElement({
	                        type: 'code',
	                        props: {
	                            className: className,
	                            children: node.content
	                        },
	                        $$typeof: TYPE_SYMBOL,
	                        _store: null
	                    })
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null
	            });
	        },
	        html: function(node, output, state) {
	            var className = node.lang ?
	                "markdown-code-" + node.lang :
	                undefined;
	
	            var codeBlock = htmlTag("code", node.content, {
	                class: className
	            });
	            return htmlTag("pre", codeBlock);
	        }
	    },
	    fence: {
	        match: blockRegex(/^ *(`{3,}|~{3,}) *(\S+)? *\n([\s\S]+?)\s*\1 *(?:\n *)+\n/),
	        parse: function(capture, parse, state) {
	            return {
	                type: "codeBlock",
	                lang: capture[2] || undefined,
	                content: capture[3]
	            };
	        }
	    },
	    blockQuote: {
	        match: blockRegex(/^( *>[^\n]+(\n[^\n]+)*\n*)+\n{2,}/),
	        parse: function(capture, parse, state) {
	            var content = capture[0].replace(/^ *> ?/gm, '');
	            return {
	                content: parse(content, state)
	            };
	        },
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'blockquote',
	                key: state.key,
	                props: {
	                    children: output(node.content, state)
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null
	            });
	        },
	        html: function(node, output, state) {
	            return htmlTag("blockquote", output(node.content, state));
	        }
	    },
	    list: {
	        match: function(source, state, prevCapture) {
	            // We only want to break into a list if we are at the start of a
	            // line. This is to avoid parsing "hi * there" with "* there"
	            // becoming a part of a list.
	            // You might wonder, "but that's inline, so of course it wouldn't
	            // start a list?". You would be correct! Except that some of our
	            // lists can be inline, because they might be inside another list,
	            // in which case we can parse with inline scope, but need to allow
	            // nested lists inside this inline scope.
	            var isStartOfLine = LIST_LOOKBEHIND_R.test(prevCapture);
	            var isListBlock = state._list || !state.inline;
	
	            if (isStartOfLine && isListBlock) {
	                return LIST_R.exec(source);
	            } else {
	                return null;
	            }
	        },
	        parse: function(capture, parse, state) {
	            var bullet = capture[2];
	            var ordered = bullet.length > 1;
	            var start = ordered ? +bullet : undefined;
	            var items = capture[0]
	                .replace(LIST_BLOCK_END_R, "\n")
	                .match(LIST_ITEM_R);
	
	            var lastItemWasAParagraph = false;
	            var itemContent = items.map(function(item, i) {
	                // We need to see how far indented this item is:
	                var space = LIST_ITEM_PREFIX_R.exec(item)[0].length;
	                // And then we construct a regex to "unindent" the subsequent
	                // lines of the items by that amount:
	                var spaceRegex = new RegExp("^ {1," + space + "}", "gm");
	
	                // Before processing the item, we need a couple things
	                var content = item
	                         // remove indents on trailing lines:
	                        .replace(spaceRegex, '')
	                         // remove the bullet:
	                        .replace(LIST_ITEM_PREFIX_R, '');
	
	                // Handling "loose" lists, like:
	                //
	                //  * this is wrapped in a paragraph
	                //
	                //  * as is this
	                //
	                //  * as is this
	                var isLastItem = (i === items.length - 1);
	                var containsBlocks = content.indexOf("\n\n") !== -1;
	
	                // Any element in a list is a block if it contains multiple
	                // newlines. The last element in the list can also be a block
	                // if the previous item in the list was a block (this is
	                // because non-last items in the list can end with \n\n, but
	                // the last item can't, so we just "inherit" this property
	                // from our previous element).
	                var thisItemIsAParagraph = containsBlocks ||
	                        (isLastItem && lastItemWasAParagraph);
	                lastItemWasAParagraph = thisItemIsAParagraph;
	
	                // backup our state for restoration afterwards. We're going to
	                // want to set state._list to true, and state.inline depending
	                // on our list's looseness.
	                var oldStateInline = state.inline;
	                var oldStateList = state._list;
	                state._list = true;
	
	                // Parse inline if we're in a tight list, or block if we're in
	                // a loose list.
	                var adjustedContent;
	                if (thisItemIsAParagraph) {
	                    state.inline = false;
	                    adjustedContent = content.replace(LIST_ITEM_END_R, "\n\n");
	                } else {
	                    state.inline = true;
	                    adjustedContent = content.replace(LIST_ITEM_END_R, "");
	                }
	
	                var result = parse(adjustedContent, state);
	
	                // Restore our state before returning
	                state.inline = oldStateInline;
	                state._list = oldStateList;
	                return result;
	            });
	
	            return {
	                ordered: ordered,
	                start: start,
	                items: itemContent
	            };
	        },
	        react: function(node, output, state) {
	            var ListWrapper = node.ordered ? "ol" : "ul";
	
	            return reactElement({
	                type: ListWrapper,
	                key: state.key,
	                props: {
	                    start: node.start,
	                    children: node.items.map(function(item, i) {
	                        return reactElement({
	                            type: 'li',
	                            key: i,
	                            props: {
	                                children: output(item, state)
	                            },
	                            $$typeof: TYPE_SYMBOL,
	                            _store: null,
	                        });
	                    })
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            var listItems = node.items.map(function(item) {
	                return htmlTag("li", output(item, state));
	            }).join("");
	
	            var listTag = node.ordered ? "ol" : "ul";
	            var attributes = {
	                start: node.start
	            };
	            return htmlTag(listTag, listItems, attributes);
	        }
	    },
	    def: {
	        // TODO(aria): This will match without a blank line before the next
	        // block element, which is inconsistent with most of the rest of
	        // simple-markdown.
	        match: blockRegex(
	            /^ *\[([^\]]+)\]: *<?([^\s>]*)>?(?: +["(]([^\n]+)[")])? *\n(?: *\n)?/
	        ),
	        parse: function(capture, parse, state) {
	            var def = capture[1]
	                .replace(/\s+/g, ' ')
	                .toLowerCase();
	            var target = capture[2];
	            var title = capture[3];
	
	            // Look for previous links/images using this def
	            // If any links/images using this def have already been declared,
	            // they will have added themselves to the state._refs[def] list
	            // (_ to deconflict with client-defined state). We look through
	            // that list of reflinks for this def, and modify those AST nodes
	            // with our newly found information now.
	            // Sorry :(.
	            if (state._refs && state._refs[def]) {
	                // `refNode` can be a link or an image
	                state._refs[def].forEach(function(refNode) {
	                    refNode.target = target;
	                    refNode.title = title;
	                });
	            }
	
	            // Add this def to our map of defs for any future links/images
	            // In case we haven't found any or all of the refs referring to
	            // this def yet, we add our def to the table of known defs, so
	            // that future reflinks can modify themselves appropriately with
	            // this information.
	            state._defs = state._defs || {};
	            state._defs[def] = {
	                target: target,
	                title: title,
	            };
	
	            // return the relevant parsed information
	            // for debugging only.
	            return {
	                def: def,
	                target: target,
	                title: title,
	            };
	        },
	        react: function() { return null; },
	        html: function() { return null; }
	    },
	    table: {
	        match: blockRegex(/^ *\|(.+)\n *\|( *[-:]+[-| :]*)\n((?: *\|.*(?:\n|$))*)\n*/),
	        parse: TABLES.parseTable,
	        react: function(node, output, state) {
	            var getStyle = function(colIndex) {
	                return node.align[colIndex] == null ? {} : {
	                    textAlign: node.align[colIndex]
	                };
	            };
	
	            var headers = node.header.map(function(content, i) {
	                return reactElement({
	                    type: 'th',
	                    key: i,
	                    props: {
	                        style: getStyle(i),
	                        children: output(content, state)
	                    },
	                    $$typeof: TYPE_SYMBOL,
	                    _store: null
	                });
	            });
	
	            var rows = node.cells.map(function(row, r) {
	                return reactElement({
	                    type: 'tr',
	                    key: r,
	                    props: {
	                        children: row.map(function(content, c) {
	                            return reactElement({
	                                type: 'td',
	                                key: c,
	                                props: {
	                                    style: getStyle(c),
	                                    children: output(content, state)
	                                },
	                                $$typeof: TYPE_SYMBOL,
	                                _store: null,
	                            });
	                        })
	                    },
	                    $$typeof: TYPE_SYMBOL,
	                    _store: null,
	                });
	            });
	
	            return reactElement({
	                type: 'table',
	                key: state.key,
	                props: {
	                    children: [reactElement({
	                        type: 'thead',
	                        key: 'thead',
	                        props: {
	                            children: reactElement({
	                                type: 'tr',
	                                props: {
	                                    children: headers
	                                },
	                                $$typeof: TYPE_SYMBOL,
	                                _store: null,
	                            })
	                        },
	                        $$typeof: TYPE_SYMBOL,
	                        _store: null,
	                    }), reactElement({
	                        type: 'tbody',
	                        key: 'tbody',
	                        props: {
	                            children: rows
	                        },
	                        $$typeof: TYPE_SYMBOL,
	                        _store: null,
	                    })]
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            var getStyle = function(colIndex) {
	                return node.align[colIndex] == null ? "" :
	                    "text-align:" + node.align[colIndex] + ";";
	            };
	
	            var headers = node.header.map(function(content, i) {
	                return htmlTag("th", output(content, state),
	                    { style: getStyle(i) });
	            }).join("");
	
	            var rows = node.cells.map(function(row) {
	                var cols = row.map(function(content, c) {
	                    return htmlTag("td", output(content, state),
	                        { style: getStyle(c) });
	                }).join("");
	
	                return htmlTag("tr", cols);
	            }).join("");
	
	            var thead = htmlTag("thead", htmlTag("tr", headers));
	            var tbody = htmlTag("tbody", rows);
	
	            return htmlTag("table", thead + tbody);
	        }
	    },
	    newline: {
	        match: blockRegex(/^(?:\n *)*\n/),
	        parse: ignoreCapture,
	        react: function(node, output, state) { return "\n"; },
	        html: function(node, output, state) { return "\n"; }
	    },
	    paragraph: {
	        match: blockRegex(/^((?:[^\n]|\n(?! *\n))+)(?:\n *)+\n/),
	        parse: parseCaptureInline,
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'div',
	                key: state.key,
	                props: {
	                    className: 'paragraph',
	                    children: output(node.content, state)
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            var attributes = {
	                class: 'paragraph'
	            };
	            return htmlTag("div", output(node.content, state), attributes);
	        }
	    },
	    escape: {
	        // We don't allow escaping numbers, letters, or spaces here so that
	        // backslashes used in plain text still get rendered. But allowing
	        // escaping anything else provides a very flexible escape mechanism,
	        // regardless of how this grammar is extended.
	        match: inlineRegex(/^\\([^0-9A-Za-z\s])/),
	        parse: function(capture, parse, state) {
	            return {
	                type: "text",
	                content: capture[1]
	            };
	        }
	    },
	    autolink: {
	        match: inlineRegex(/^<([^ >]+:\/[^ >]+)>/),
	        parse: function(capture, parse, state) {
	            return {
	                type: "link",
	                content: [{
	                    type: "text",
	                    content: capture[1]
	                }],
	                target: capture[1]
	            };
	        }
	    },
	    mailto: {
	        match: inlineRegex(/^<([^ >]+@[^ >]+)>/),
	        parse: function(capture, parse, state) {
	            var address = capture[1];
	            var target = capture[1];
	
	            // Check for a `mailto:` already existing in the link:
	            if (!AUTOLINK_MAILTO_CHECK_R.test(target)) {
	                target = "mailto:" + target;
	            }
	
	            return {
	                type: "link",
	                content: [{
	                    type: "text",
	                    content: address
	                }],
	                target: target
	            };
	        }
	    },
	    url: {
	        match: inlineRegex(/^(https?:\/\/[^\s<]+[^<.,:;"')\]\s])/),
	        parse: function(capture, parse, state) {
	            return {
	                type: "link",
	                content: [{
	                    type: "text",
	                    content: capture[1]
	                }],
	                target: capture[1],
	                title: undefined
	            };
	        }
	    },
	    link: {
	        match: inlineRegex(new RegExp(
	            "^\\[(" + LINK_INSIDE + ")\\]\\(" + LINK_HREF_AND_TITLE + "\\)"
	        )),
	        parse: function(capture, parse, state) {
	            var link ={
	                content: parse(capture[1], state),
	                target: capture[2],
	                title: capture[3]
	            };
	            return link;
	        },
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'a',
	                key: state.key,
	                props: {
	                    href: sanitizeUrl(node.target),
	                    title: node.title,
	                    children: output(node.content, state)
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            var attributes = {
	                href: sanitizeUrl(node.target),
	                title: node.title
	            };
	
	            return htmlTag("a", output(node.content, state), attributes);
	        }
	    },
	    image: {
	        match: inlineRegex(new RegExp(
	            "^!\\[(" + LINK_INSIDE + ")\\]\\(" + LINK_HREF_AND_TITLE + "\\)"
	        )),
	        parse: function(capture, parse, state) {
	            var image = {
	                alt: capture[1],
	                target: capture[2],
	                title: capture[3]
	            };
	            return image;
	        },
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'img',
	                key: state.key,
	                props: {
	                    src: sanitizeUrl(node.target),
	                    alt: node.alt,
	                    title: node.title
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            var attributes = {
	                src: sanitizeUrl(node.target),
	                alt: node.alt,
	                title: node.title
	            };
	
	            return htmlTag("img", "", attributes, false);
	        }
	    },
	    reflink: {
	        match: inlineRegex(new RegExp(
	            // The first [part] of the link
	            "^\\[(" + LINK_INSIDE + ")\\]" +
	            // The [ref] target of the link
	            "\\s*\\[([^\\]]*)\\]"
	        )),
	        parse: function(capture, parse, state) {
	            return parseRef(capture, state, {
	                type: "link",
	                content: parse(capture[1], state)
	            });
	        }
	    },
	    refimage: {
	        match: inlineRegex(new RegExp(
	            // The first [part] of the link
	            "^!\\[(" + LINK_INSIDE + ")\\]" +
	            // The [ref] target of the link
	            "\\s*\\[([^\\]]*)\\]"
	        )),
	        parse: function(capture, parse, state) {
	            return parseRef(capture, state, {
	                type: "image",
	                alt: capture[1]
	            });
	        }
	    },
	    strong: {
	        match: inlineRegex(/^\*\*([\s\S]+?)\*\*(?!\*)/),
	        parse: parseCaptureInline,
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'strong',
	                key: state.key,
	                props: {
	                    children: output(node.content, state)
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            return htmlTag("strong", output(node.content, state));
	        }
	    },
	    u: {
	        match: inlineRegex(/^__([\s\S]+?)__(?!_)/),
	        parse: parseCaptureInline,
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'u',
	                key: state.key,
	                props: {
	                    children: output(node.content, state)
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            return htmlTag("u", output(node.content, state));
	        }
	    },
	    em: {
	        match: inlineRegex(
	            new RegExp(
	                // only match _s surrounding words.
	                "^\\b_" +
	                "((?:__|[\\s\\S])+?)_" +
	                "\\b" +
	                // Or match *s:
	                "|" +
	                // Only match *s that are followed by a non-space:
	                "^\\*(?=\\S)(" +
	                // Match any of:
	                //  - `**`: so that bolds inside italics don't close the
	                //          italics
	                //  - whitespace: if it's not followed by a * (we don't
	                //          want ' *' to close an italics--it might
	                //          start a list)
	                //  - non-whitespace, non-* characters
	                "(?:\\*\\*|\\s+[^\\*\\s]|[^\\s\\*])*?" +
	                // followed by a non-space, non-* then *
	                "[^\\s\\*])\\*(?!\\*)"
	            )
	        ),
	        parse: function(capture, parse, state) {
	            return {
	                content: parse(capture[2] || capture[1], state)
	            };
	        },
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'em',
	                key: state.key,
	                props: {
	                    children: output(node.content, state)
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            return htmlTag("em", output(node.content, state));
	        }
	    },
	    del: {
	        match: inlineRegex(/^~~(?=\S)([\s\S]*?\S)~~/),
	        parse: parseCaptureInline,
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'del',
	                key: state.key,
	                props: {
	                    children: output(node.content, state)
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            return htmlTag("del", output(node.content, state));
	        }
	    },
	    inlineCode: {
	        match: inlineRegex(/^(`+)\s*([\s\S]*?[^`])\s*\1(?!`)/),
	        parse: function(capture, parse, state) {
	            return {
	                content: capture[2]
	            };
	        },
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'code',
	                key: state.key,
	                props: {
	                    children: node.content
	                },
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            return htmlTag("code", node.content);
	        }
	    },
	    br: {
	        match: anyScopeRegex(/^ {2,}\n/),
	        parse: ignoreCapture,
	        react: function(node, output, state) {
	            return reactElement({
	                type: 'br',
	                key: state.key,
	                props: EMPTY_PROPS,
	                $$typeof: TYPE_SYMBOL,
	                _store: null,
	            });
	        },
	        html: function(node, output, state) {
	            return "<br>";
	        }
	    },
	    text: {
	        // Here we look for anything followed by non-symbols,
	        // double newlines, or double-space-newlines
	        // We break on any symbol characters so that this grammar
	        // is easy to extend without needing to modify this regex
	        match: inlineRegex(
	            /^[\s\S]+?(?=[^0-9A-Za-z\s\u00ff-\uffff]|\n\n| {2,}\n|\w+:\S|$)/
	        ),
	        parse: function(capture, parse, state) {
	            return {
	                content: capture[0]
	            };
	        },
	        react: function(node, output, state) {
	            return node.content;
	        },
	        html: function(node, output, state) {
	            return node.content;
	        }
	    }
	};
	
	Object.keys(defaultRules).forEach(function(type, i) {
	    defaultRules[type].order = i;
	});
	
	var ruleOutput = function(rules, property) {
	    if (!property && typeof console !== "undefined") {
	        console.warn("simple-markdown ruleOutput should take 'react' or " +
	            "'html' as the second argument."
	        );
	    }
	
	    // deprecated:
	    property = property || "react";
	
	    var nestedRuleOutput = function(ast, outputFunc, state) {
	        return rules[ast.type][property](ast, outputFunc, state);
	    };
	    return nestedRuleOutput;
	};
	
	var defaultRawParse = parserFor(defaultRules);
	var defaultBlockParse = function(source) {
	    return defaultRawParse(source + "\n\n", {
	        inline: false
	    });
	};
	var defaultInlineParse = function(source) {
	    return defaultRawParse(source, {
	        inline: true
	    });
	};
	var defaultImplicitParse = function(source) {
	    return defaultRawParse(source, {
	        inline: !(BLOCK_END_R.test(source))
	    });
	};
	
	var defaultReactOutput = reactFor(ruleOutput(defaultRules, "react"));
	var defaultHtmlOutput = htmlFor(ruleOutput(defaultRules, "html"));
	
	var SimpleMarkdown = {
	    defaultRules: defaultRules,
	    parserFor: parserFor,
	    ruleOutput: ruleOutput,
	    reactFor: reactFor,
	    htmlFor: htmlFor,
	
	    inlineRegex: inlineRegex,
	    blockRegex: blockRegex,
	    anyScopeRegex: anyScopeRegex,
	    parseInline: parseInline,
	    parseBlock: parseBlock,
	
	    defaultRawParse: defaultRawParse,
	    defaultBlockParse: defaultBlockParse,
	    defaultInlineParse: defaultInlineParse,
	    defaultImplicitParse: defaultImplicitParse,
	
	    defaultReactOutput: defaultReactOutput,
	    defaultHtmlOutput: defaultHtmlOutput,
	
	    preprocess: preprocess,
	    sanitizeUrl: sanitizeUrl,
	
	    // deprecated:
	    defaultParse: defaultImplicitParse,
	    outputFor: reactFor,
	    defaultOutput: defaultReactOutput,
	};
	
	if (typeof module !== "undefined" && module.exports) {
	    module.exports = SimpleMarkdown;
	} else if (typeof global !== "undefined") {
	    global.SimpleMarkdown = SimpleMarkdown;
	} else {
	    window.SimpleMarkdown = SimpleMarkdown;
	}
	
	})();
	
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 261 */
/***/ function(module, exports, __webpack_require__) {

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	/**
	 * KaTeX A11y
	 * A library for converting KaTeX math into readable strings.
	 */
	
	// NOTE(jeresig): We need to keep this file as pure ES5 to avoid import
	// problems into webapp.
	/* eslint-disable no-var */
	/* global katex */
	
	var stringMap = {
	    "(": "left parenthesis",
	    ")": "right parenthesis",
	    "[": "open bracket",
	    "]": "close bracket",
	    "\\{": "left brace",
	    "\\}": "right brace",
	    "\\lvert": "open vertical bar",
	    "\\rvert": "close vertical bar",
	    "|": "vertical bar",
	    "\\uparrow": "up arrow",
	    "\\Uparrow": "up arrow",
	    "\\downarrow": "down arrow",
	    "\\Downarrow": "down arrow",
	    "\\updownarrow": "up down arrow",
	    "\\leftarrow": "left arrow",
	    "\\Leftarrow": "left arrow",
	    "\\rightarrow": "right arrow",
	    "\\Rightarrow": "right arrow",
	    "\\langle": "open angle",
	    "\\rangle": "close angle",
	    "\\lfloor": "open floor",
	    "\\rfloor": "close floor",
	    "\\int": "integral",
	    "\\intop": "integral",
	    "\\lim": "limit",
	    "\\ln": "natural log",
	    "\\log": "log",
	    "\\sin": "sine",
	    "\\cos": "cosine",
	    "\\tan": "tangent",
	    "\\cot": "cotangent",
	    "\\sum": "sum",
	    "/": "slash",
	    ",": "comma",
	    ".": "point",
	    "-": "negative",
	    "+": "plus",
	    "~": "tilde",
	    ":": "colon",
	    "?": "question mark",
	    "'": "apostrophe",
	    "\\%": "percent",
	    " ": "space",
	    "\\ ": "space",
	    "\\$": "dollar sign",
	    "\\angle": "angle",
	    "\\degree": "degree",
	    "\\circ": "circle",
	    "\\vec": "vector",
	    "\\triangle": "triangle",
	    "\\pi": "pi",
	    "\\prime": "prime",
	    "\\infty": "infinity",
	    "\\alpha": "alpha",
	    "\\beta": "beta",
	    "\\gamma": "gamma",
	    "\\omega": "omega",
	    "\\theta": "theta",
	    "\\sigma": "sigma",
	    "\\lambda": "lambda",
	    "\\tau": "tau",
	    "\\Delta": "delta",
	    "\\delta": "delta",
	    "\\mu": "mu",
	    "\\rho": "rho",
	    "\\nabla": "del",
	    "\\ell": "ell",
	    "\\ldots": "dots"
	};
	
	var powerMap = {
	    "\\prime": "prime",
	    "\\degree": "degree",
	    "\\circ": "degree"
	};
	
	var openMap = {
	    "|": "open vertical bar",
	    ".": ""
	};
	
	var closeMap = {
	    "|": "close vertical bar",
	    ".": ""
	};
	
	var binMap = {
	    "+": "plus",
	    "-": "minus",
	    "\\pm": "plus minus",
	    "\\cdot": "dot",
	    "*": "times",
	    "/": "divided by",
	    "\\times": "times",
	    "\\div": "divided by",
	    "\\circ": "circle",
	    "\\bullet": "bullet"
	};
	
	var relMap = {
	    "=": "equals",
	    "\\approx": "approximately equals",
	    "\\neq": "does not equal",
	    "\\ne": "does not equal",
	    "\\geq": "is greater than or equal to",
	    "\\ge": "is greater than or equal to",
	    "\\leq": "is less than or equal to",
	    "\\le": "is less than or equal to",
	    ">": "is greater than",
	    "<": "is less than",
	    "\\leftarrow": "left arrow",
	    "\\Leftarrow": "left arrow",
	    "\\rightarrow": "right arrow",
	    "\\Rightarrow": "right arrow",
	    ":": "colon"
	};
	
	var buildString = function buildString(str, type, a11yStrings) {
	    if (!str) {
	        return;
	    }
	
	    var ret;
	
	    if (type === "open") {
	        ret = str in openMap ? openMap[str] : stringMap[str] || str;
	    } else if (type === "close") {
	        ret = str in closeMap ? closeMap[str] : stringMap[str] || str;
	    } else if (type === "bin") {
	        ret = binMap[str] || str;
	    } else if (type === "rel") {
	        ret = relMap[str] || str;
	    } else {
	        ret = stringMap[str] || str;
	    }
	
	    // If nothing was found and it's not a plain string or number
	    if (ret === str && !/^\w+$/.test(str)) {
	        // This is likely a case that we'll need to handle
	        throw new Error("KaTeX a11y " + type + " string not found: " + str);
	    }
	
	    // If the text to add is a number and there is already a string
	    // in the list and the last string is a number then we should
	    // combine them into a single number
	    if (/^\d+$/.test(ret) && a11yStrings.length > 0 && /^\d+$/.test(a11yStrings[a11yStrings.length - 1])) {
	        a11yStrings[a11yStrings.length - 1] += ret;
	    } else if (ret) {
	        a11yStrings.push(ret);
	    }
	};
	
	var buildRegion = function buildRegion(a11yStrings, callback) {
	    var region = [];
	    a11yStrings.push(region);
	    callback(region);
	};
	
	var typeHandlers = {
	    accent: function accent(tree, a11yStrings) {
	        buildRegion(a11yStrings, function (a11yStrings) {
	            buildA11yStrings(tree.value.base, a11yStrings);
	            a11yStrings.push("with");
	            buildA11yStrings(tree.value.accent, a11yStrings);
	            a11yStrings.push("on top");
	        });
	    },
	
	    bin: function bin(tree, a11yStrings) {
	        buildString(tree.value, "bin", a11yStrings);
	    },
	
	    close: function close(tree, a11yStrings) {
	        buildString(tree.value, "close", a11yStrings);
	    },
	
	    color: function color(tree, a11yStrings) {
	        var color = tree.value.color.replace(/katex-/, "");
	
	        buildRegion(a11yStrings, function (a11yStrings) {
	            a11yStrings.push("start color " + color);
	            buildA11yStrings(tree.value.value, a11yStrings);
	            a11yStrings.push("end color " + color);
	        });
	    },
	
	    delimsizing: function delimsizing(tree, a11yStrings) {
	        if (tree.value.value && tree.value.value !== ".") {
	            buildString(tree.value.value, "normal", a11yStrings);
	        }
	    },
	
	    genfrac: function genfrac(tree, a11yStrings) {
	        buildRegion(a11yStrings, function (a11yStrings) {
	            // NOTE: Not sure if this is a safe assumption
	            // hasBarLine true -> fraction, false -> binomial
	            if (tree.value.hasBarLine) {
	                a11yStrings.push("start fraction");
	                buildString(tree.value.leftDelim, "open", a11yStrings);
	                buildA11yStrings(tree.value.numer, a11yStrings);
	                a11yStrings.push("divided by");
	                buildA11yStrings(tree.value.denom, a11yStrings);
	                buildString(tree.value.rightDelim, "close", a11yStrings);
	                a11yStrings.push("end fraction");
	            } else {
	                a11yStrings.push("start binomial");
	                buildString(tree.value.leftDelim, "open", a11yStrings);
	                buildA11yStrings(tree.value.numer, a11yStrings);
	                a11yStrings.push("over");
	                buildA11yStrings(tree.value.denom, a11yStrings);
	                buildString(tree.value.rightDelim, "close", a11yStrings);
	                a11yStrings.push("end binomial");
	            }
	        });
	    },
	
	    // inner
	
	    katex: function katex(tree, a11yStrings) {
	        a11yStrings.push("KaTeX");
	    },
	
	    leftright: function leftright(tree, a11yStrings) {
	        buildRegion(a11yStrings, function (a11yStrings) {
	            buildString(tree.value.left, "open", a11yStrings);
	            buildA11yStrings(tree.value.body, a11yStrings);
	            buildString(tree.value.right, "close", a11yStrings);
	        });
	    },
	
	    llap: function llap(tree, a11yStrings) {
	        buildA11yStrings(tree.value.body, a11yStrings);
	    },
	
	    mathord: function mathord(tree, a11yStrings) {
	        buildA11yStrings(tree.value, a11yStrings);
	    },
	
	    op: function op(tree, a11yStrings) {
	        buildString(tree.value.body, "normal", a11yStrings);
	    },
	
	    open: function open(tree, a11yStrings) {
	        buildString(tree.value, "open", a11yStrings);
	    },
	
	    ordgroup: function ordgroup(tree, a11yStrings) {
	        buildA11yStrings(tree.value, a11yStrings);
	    },
	
	    overline: function overline(tree, a11yStrings) {
	        buildRegion(a11yStrings, function (a11yStrings) {
	            a11yStrings.push("start overline");
	            buildA11yStrings(tree.value.body, a11yStrings);
	            a11yStrings.push("end overline");
	        });
	    },
	
	    phantom: function phantom(tree, a11yStrings) {
	        a11yStrings.push("empty space");
	    },
	
	    punct: function punct(tree, a11yStrings) {
	        buildString(tree.value, "punct", a11yStrings);
	    },
	
	    rel: function rel(tree, a11yStrings) {
	        buildString(tree.value, "rel", a11yStrings);
	    },
	
	    rlap: function rlap(tree, a11yStrings) {
	        buildA11yStrings(tree.value.body, a11yStrings);
	    },
	
	    rule: function rule(tree, a11yStrings) {
	        // NOTE: Is there something more useful that we can put here?
	        a11yStrings.push("rule");
	    },
	
	    sizing: function sizing(tree, a11yStrings) {
	        buildA11yStrings(tree.value.value, a11yStrings);
	    },
	
	    spacing: function spacing(tree, a11yStrings) {
	        a11yStrings.push("space");
	    },
	
	    styling: function styling(tree, a11yStrings) {
	        // We ignore the styling and just pass through the contents
	        buildA11yStrings(tree.value.value, a11yStrings);
	    },
	
	    sqrt: function sqrt(tree, a11yStrings) {
	        buildRegion(a11yStrings, function (a11yStrings) {
	            if (tree.value.index) {
	                a11yStrings.push("root");
	                a11yStrings.push("start index");
	                buildA11yStrings(tree.value.index, a11yStrings);
	                a11yStrings.push("end index");
	            }
	
	            a11yStrings.push("square root of");
	            buildA11yStrings(tree.value.body, a11yStrings);
	            a11yStrings.push("end square root");
	        });
	    },
	
	    supsub: function supsub(tree, a11yStrings) {
	        if (tree.value.base) {
	            buildA11yStrings(tree.value.base, a11yStrings);
	        }
	
	        if (tree.value.sub) {
	            buildRegion(a11yStrings, function (a11yStrings) {
	                a11yStrings.push("start subscript");
	                buildA11yStrings(tree.value.sub, a11yStrings);
	                a11yStrings.push("end subscript");
	            });
	        }
	
	        var sup = tree.value.sup;
	
	        if (sup) {
	            // There are some cases that just read better if we don't have
	            // the extra start/end baggage, so we skip the extra text
	            var newPower = powerMap[sup];
	            var supValue = sup.value;
	
	            // The value stored inside the sup property is not always
	            // consistent. It could be a string (handled above), an object
	            // with a string property in value, or an array of objects that
	            // have a value property.
	            if (!newPower && supValue) {
	                // If supValue is an object and it has a length of 1 we assume
	                // it's an array that has only a single item in it. This is the
	                // case that we care about and we only check that one value.
	                if ((typeof supValue === "undefined" ? "undefined" : _typeof(supValue)) === "object" && supValue.length === 1) {
	                    newPower = powerMap[supValue[0].value];
	
	                    // This is the case where it's a string in the value property
	                } else {
	                    newPower = powerMap[supValue];
	                }
	            }
	
	            buildRegion(a11yStrings, function (a11yStrings) {
	                if (newPower) {
	                    a11yStrings.push(newPower);
	                    return;
	                }
	
	                a11yStrings.push("start superscript");
	                buildA11yStrings(tree.value.sup, a11yStrings);
	                a11yStrings.push("end superscript");
	            });
	        }
	    },
	
	    text: function text(tree, a11yStrings) {
	        if (typeof tree.value !== "string") {
	            buildA11yStrings(tree.value.body, a11yStrings);
	        } else {
	            buildString(tree, "normal", a11yStrings);
	        }
	    },
	
	    textord: function textord(tree, a11yStrings) {
	        buildA11yStrings(tree.value, a11yStrings);
	    }
	};
	
	var buildA11yStrings = function buildA11yStrings(tree, a11yStrings) {
	    a11yStrings = a11yStrings || [];
	
	    // Handle strings
	    if (typeof tree === "string") {
	        buildString(tree, "normal", a11yStrings);
	
	        // Handle arrays
	    } else if (tree.constructor === Array) {
	        for (var i = 0; i < tree.length; i++) {
	            buildA11yStrings(tree[i], a11yStrings);
	        }
	
	        // Everything else is assumed to be an object...
	    } else {
	        if (!tree.type || !(tree.type in typeHandlers)) {
	            throw new Error("KaTeX a11y un-recognized type: " + tree.type);
	        } else {
	            typeHandlers[tree.type](tree, a11yStrings);
	        }
	    }
	
	    return a11yStrings;
	};
	
	var renderStrings = function renderStrings(a11yStrings, a11yNode) {
	    var doc = a11yNode.ownerDocument;
	
	    for (var i = 0; i < a11yStrings.length; i++) {
	        var a11yString = a11yStrings[i];
	
	        if (i > 0) {
	            // Note: We insert commas in (not just spaces) to provide
	            // screen readers with some "breathing room". When inserting the
	            // commas the screen reader knows to pause slightly and it provides
	            // an overall better listening experience.
	            a11yNode.appendChild(doc.createTextNode(", "));
	        }
	
	        if (typeof a11yString === "string") {
	            a11yNode.appendChild(doc.createTextNode(a11yString));
	        } else {
	            var newBaseNode = doc.createElement("span");
	            // NOTE(jeresig): We may want to add in a tabIndex property
	            // to the node here, in order to support keyboard navigation.
	            a11yNode.appendChild(newBaseNode);
	            renderStrings(a11yString, newBaseNode);
	        }
	    }
	};
	
	var flattenStrings = function flattenStrings(a11yStrings, results) {
	    if (!results) {
	        results = [];
	    }
	
	    for (var i = 0; i < a11yStrings.length; i++) {
	        var a11yString = a11yStrings[i];
	
	        if (typeof a11yString === "string") {
	            results.push(a11yString);
	        } else {
	            flattenStrings(a11yString, results);
	        }
	    }
	
	    return results;
	};
	
	var parseMath = function parseMath(text) {
	    // NOTE: `katex` is a global, should be included using require
	    return katex.__parse(text);
	};
	
	var render = function render(text, a11yNode) {
	    var tree = parseMath(text);
	    var a11yStrings = buildA11yStrings(tree);
	    renderStrings(a11yStrings, a11yNode);
	};
	
	var flatten = function flatten(array) {
	    var result = [];
	
	    array.forEach(function (item) {
	        if (Array.isArray(item)) {
	            result = result.concat(flatten(item));
	        } else {
	            result.push(item);
	        }
	    });
	
	    return result;
	};
	
	var renderString = function renderString(text) {
	    var tree = parseMath(text);
	    var a11yStrings = buildA11yStrings(tree);
	    return flatten(a11yStrings).join(", ");
	};
	
	if (true) {
	    module.exports = {
	        render: render,
	        renderString: renderString,
	        parseMath: parseMath
	    };
	} else {
	    this.katexA11yRender = render;
	}

/***/ },
/* 262 */
/***/ function(module, exports, __webpack_require__) {

	var isObject = function(obj) {
	    return obj === Object(obj);;
	}
	
	var merge = function() {
	    var obj = {};
	
	    for (var i = 0; i < arguments.length; i++) {
	        var source = arguments[i];
	        if (source) {
	            for (var prop in source) {
	                obj[prop] = source[prop];
	            }
	        }
	    }
	
	    return obj;
	};
	
	var clone = function(obj) {
	    if (!isObject(obj)) {
	        return obj;
	    }
	
	    return Array.isArray(obj) ? obj.slice() : merge(obj);
	};
	
	module.exports = { isObject: isObject, merge: merge, clone: clone };


/***/ },
/* 263 */
/***/ function(module, exports, __webpack_require__) {

	var get = function(arr, monocle) {
	    return arr[monocle];
	};
	
	var set = function(arr, monocle, val) {
	    var newArr = arr.splice();
	    newArr[monocle] = val;
	    return newArr;
	};
	
	var mod = function(arr, monocle, f) {
	    var newArr = arr.slice();
	    newArr[monocle] = f(arr[monocle]);
	    return newArr;
	};
	
	var del = function(arr, monocle) {
	    var newArr = arr.slice();
	    newArr.splice(monocle, 1);
	    return newArr;
	};
	
	/*
	// Lens must point to a member of an array. We'll insert into that array.
	lens.prototype.insertAt = function(lensArr, toInsert) {
	    var obj = this._wrapped;
	
	    var arrLens = lensArr.slice(0, -1);
	    var arr = lens(obj).get(arrLens).slice(); // slice to copy
	
	    var arrIdx = lensArr[lensArr.length-1];
	    arr.splice(arrIdx, 0, toInsert);
	    return lens(obj).set(arrLens, arr);
	};
	
	lens.prototype.insertBefore = lens.prototype.insertAt;
	lens.prototype.insertAfter = function(lensArr, toInsert) {
	    var newLens = lensArr.slice();
	    newLens[newLens.length-1] += 1;
	    return lens(this._wrapped).insertAt(newLens, toInsert);
	};
	*/
	
	module.exports = { get: get, set: set, mod: mod, del: del };


/***/ },
/* 264 */
/***/ function(module, exports, __webpack_require__) {

	var clone = __webpack_require__(262).clone;
	
	var get = function(obj, monocle) {
	    return obj[monocle];
	};
	
	var set = function(obj, monocle, val) {
	    var newObj = clone(obj);
	    newObj[monocle] = val;
	    return newObj;
	};
	
	var mod = function(obj, monocle, f) {
	    var newObj = clone(obj);
	    newObj[monocle] = f(obj[monocle]);
	    return newObj;
	};
	
	var del = function(obj, monocle) {
	    var newObj = clone(obj);
	    delete newObj[monocle];
	    return newObj;
	};
	
	module.exports = { get: get, set: set, mod: mod, del: del };


/***/ },
/* 265 */
/***/ function(module, exports, __webpack_require__) {

	var get = function(arr, monocle) {
	    return arr[monocle];
	};
	
	var set = function(arr, monocle, val) {
	    var newArr = arr.splice();
	    newArr[monocle] = val;
	    return newArr;
	};
	
	var mod = function(arr, monocle, f) {
	    var newArr = arr.splice();
	    newArr[monocle] = f(arr[monocle]);
	    return newArr;
	};
	
	var del = function(arr, monocle) {
	    var newArr = arr.slice();
	    newArr.splice(monocle);
	    return newArr;
	};
	
	module.exports = { get: get, set: set, mod: mod, del: del };


/***/ },
/* 266 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var Movable = __webpack_require__(284);
	var MovablePoint = __webpack_require__(285);
	var MovableLine = __webpack_require__(286);
	var MovablePolygon = __webpack_require__(287);
	
	var KhanColors = __webpack_require__(268);
	
	var Interactive2 = {
	    MovablePoint: MovablePoint,
	    addMovablePoint: function addMovablePoint(graphie, options) {
	        var movable = new Movable(graphie, {});
	        return new MovablePoint(graphie, movable, options);
	    },
	    MovableLine: MovableLine,
	    addMovableLine: function addMovableLine(graphie, options) {
	        var movable = new Movable(graphie, {});
	        return new MovableLine(graphie, movable, options);
	    },
	    MovablePolygon: MovablePolygon,
	    addMovablePolygon: function addMovablePolygon(graphie, options) {
	        var movable = new Movable(graphie, {});
	        return new MovablePolygon(graphie, movable, options);
	    },
	
	    addMaybeMobileMovablePoint: function addMaybeMobileMovablePoint(widget, extraProps) {
	        var isMobile = widget.props.apiOptions.isMobile;
	
	        var commonStyle = isMobile ? {
	            stroke: "#ffffff",
	            "stroke-width": 3,
	            fill: KhanColors.INTERACTIVE
	        } : {
	            stroke: KhanColors.INTERACTIVE,
	            fill: KhanColors.INTERACTIVE
	        };
	
	        var normalStyle = Object.assign(commonStyle, extraProps.normalStyle);
	
	        var highlightStyle = Object.assign(isMobile ? _extends({}, commonStyle, {
	            "stroke-width": 0,
	            scale: 0.75
	        }) : {}, extraProps.highlightStyle);
	
	        var props = Object.assign({
	            normalStyle: normalStyle,
	            highlightStyle: highlightStyle,
	            shadow: isMobile,
	            tooltip: isMobile && widget.props.showTooltips,
	            showHairlines: widget.showHairlines,
	            hideHairlines: widget.hideHairlines
	        }, isMobile ? { pointSize: 7 } : {});
	
	        return Interactive2.addMovablePoint(widget.graphie, Object.assign(extraProps, props));
	    }
	};
	
	module.exports = Interactive2;

/***/ },
/* 267 */
/***/ function(module, exports, __webpack_require__) {

	var _ = __webpack_require__(56);
	var InteractiveUtil = __webpack_require__(256);
	var WrappedDefaults = __webpack_require__(288);
	var kpoint = __webpack_require__(275).point;
	var kvector = __webpack_require__(275).vector;
	var KhanMath = __webpack_require__(208);
	
	var DEFAULT_OPTIONS = {
	    thickness: 2,
	    mouselayer: false
	};
	
	var WrappedLine = function WrappedLine(graphie, start, end, options) {
	    options = _.extend({}, DEFAULT_OPTIONS, options);
	
	    // Always make the line as large as possible and horizontal; this
	    // simplifies a lot of the transforms, e.g., we can rotate by exactly the
	    // angle of the argument points in `moveTo`.
	    var initialStart = [graphie.range[0][0], 0];
	    var initialEnd = [graphie.range[0][1], 0];
	
	    // Add `wrapper` and `visibleShape`
	    _.extend(this, graphie.fixedLine(initialStart, initialEnd, options.thickness));
	
	    this.visibleShape.attr(options.normalStyle);
	
	    // Save properties for computing transformations
	    _.extend(this, {
	        graphie: graphie,
	        initialPoint: graphie.scalePoint(initialStart),
	        initialLength: kpoint.distanceToPoint(graphie.scalePoint(initialStart), graphie.scalePoint(initialEnd))
	    });
	
	    // Add to appropriate graphie layer
	    if (options.mouselayer) {
	        // Disable browser handling of all panning and zooming gestures on the
	        // movable wrapper so that when moved the browser does not scroll page
	        this.wrapper.style.touchAction = "none";
	
	        this.graphie.addToMouseLayerWrapper(this.wrapper);
	    } else {
	        this.graphie.addToVisibleLayerWrapper(this.wrapper);
	    }
	
	    // Move to argument points
	    this.moveTo(start, end);
	};
	
	_.extend(WrappedLine.prototype, WrappedDefaults, {
	    getMouseTarget: function getMouseTarget() {
	        return this.wrapper;
	    },
	
	    moveTo: function moveTo(start, end) {
	        var scaledStart = this.graphie.scalePoint(start);
	        var scaledEnd = this.graphie.scalePoint(end);
	
	        // Compute transformation parameters
	        var polarDiff = kvector.polarDegFromCart(kvector.subtract(scaledEnd, scaledStart));
	        var lineLength = polarDiff[0];
	        var angle = KhanMath.bound(polarDiff[1]);
	        var delta = kvector.subtract(scaledStart, this.initialPoint);
	        var scale = KhanMath.bound(lineLength / this.initialLength);
	
	        // Construct and apply transformation string
	        var do3dTransform = InteractiveUtil.getCanUse3dTransform();
	        var transformation = "translateX(" + delta[0] + "px) " + "translateY(" + delta[1] + "px) " + (do3dTransform ? " translateZ(0)" : "") + "rotate(" + angle + "deg) " + "scaleX(" + scale + ") scaleY(1)";
	        this.transform(transformation);
	    }
	});
	
	module.exports = WrappedLine;

/***/ },
/* 268 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Color constants we use throughout Perseus (originally on KhanUtil).
	 *
	 * Note that if the color palette changes substantially, it may also need to be
	 * updated in khan-exercises and cherry-picked into graphie-to-png's
	 * khan-exercises submodule, as graphie-to-png still relies on the palette
	 * provided on KhanUtil.
	 */
	var KhanColors = {
	    BLUE: "#6495ED",
	    ORANGE: "#FFA500",
	    PINK: "#FF00AF",
	    GREEN: "#28AE7B",
	    PURPLE: "#9D38BD",
	    RED: "#DF0030",
	    GRAY: "gray",
	    BLACK: "black",
	    LIGHT_BLUE: "#9AB8ED",
	    LIGHT_ORANGE: "#EDD19B",
	    LIGHT_PINK: "#ED9BD3",
	    LIGHT_GREEN: "#9BEDCE",
	    LIGHT_PURPLE: "#DA9BED",
	    LIGHT_RED: "#ED9AAC",
	    LIGHT_GRAY: "#ED9B9B",
	    LIGHT_BLACK: "#ED9B9B",
	    GRAY10: "#D6D6D6",
	    GRAY20: "#CDCDCD",
	    GRAY30: "#B3B3B3",
	    GRAY40: "#9A9A9A",
	    GRAY50: "#808080",
	    GRAY60: "#666666",
	    GRAY70: "#4D4D4D",
	    GRAY80: "#333333",
	    GRAY90: "#1A1A1A",
	    BLUE_A: "#CCFAFF",
	    BLUE_B: "#80F6FF",
	    BLUE_C: "#63D9EA",
	    BLUE_D: "#11ACCD",
	    BLUE_E: "#0C7F99",
	    TEAL_A: "#94FFF5",
	    TEAL_B: "#26EDD5",
	    TEAL_C: "#01D1C1",
	    TEAL_D: "#01A995",
	    TEAL_E: "#208170",
	    GREEN_A: "#B6FFB0",
	    GREEN_B: "#8AF281",
	    GREEN_C: "#74CF70",
	    GREEN_D: "#1FAB54",
	    GREEN_E: "#0D923F",
	    GOLD_A: "#FFD0A9",
	    GOLD_B: "#FFBB71",
	    GOLD_C: "#FF9C39",
	    GOLD_D: "#E07D10",
	    GOLD_E: "#A75A05",
	    RED_A: "#FCA9A9",
	    RED_B: "#FF8482",
	    RED_C: "#F9685D",
	    RED_D: "#E84D39",
	    RED_E: "#BC2612",
	    MAROON_A: "#FFBDE0",
	    MAROON_B: "#FF92C6",
	    MAROON_C: "#ED5FA6",
	    MAROON_D: "#CA337C",
	    MAROON_E: "#9E034E",
	    PURPLE_A: "#DDD7FF",
	    PURPLE_B: "#C6B9FC",
	    PURPLE_C: "#AA87FF",
	    PURPLE_D: "#7854AB",
	    PURPLE_E: "#543B78",
	    MINT_A: "#F5F9E8",
	    MINT_B: "#EDF2DF",
	    MINT_C: "#E0E5CC",
	    GRAY_A: "#F6F7F7",
	    GRAY_B: "#F0F1F2",
	    GRAY_C: "#E3E5E6",
	    GRAY_D: "#D6D8DA",
	    GRAY_E: "#BABEC2",
	    GRAY_F: "#888D93",
	    GRAY_G: "#626569",
	    GRAY_H: "#3B3E40",
	    GRAY_I: "#21242C",
	    KA_BLUE: "#314453",
	    KA_GREEN: "#71B307",
	    // Don't actually use _BACKGROUND! Make things transparent instead. The
	    // background color used in exercises is subject to change at the whim
	    // of any redesigns.
	    _BACKGROUND: "#FDFDFD" // TODO(eater): Get rid of this altogether.
	};
	
	KhanColors.INTERACTING = KhanColors.KA_GREEN;
	KhanColors.INTERACTIVE = KhanColors.KA_GREEN;
	KhanColors.DYNAMIC = KhanColors.BLUE;
	
	module.exports = KhanColors;

/***/ },
/* 269 */
/***/ function(module, exports, __webpack_require__) {

	/*
	Draft.js can seem pretty low level, and its library is highly imperative.
	While this gives the user a very good grasp of the underlying mechanisms,
	making it easier to understand, it can get verbose.
	
	This file contains various utility functions to search and edit Draft.js
	data.
	
	NOTE:
	
	Return values for functions which cause mutations to the content must return
	
	{
	    editorState?: EditorState,
	    contentState: ContentState
	}
	
	The issue with returning only the `editorState` is that editing it through
	the suggested way (EditorState.push) may add a state onto the undo/redo stack.
	This stops the function from being able to be used in the middle of a set of
	operations, undo/redo should not bring you to an intermediate step.
	
	The issue with returning only the `contentState` is that the verbose
	EditorState.push step ends up being repeated quite often
	
	Therefore both must always be returned
	*/
	
	var _require = __webpack_require__(298),
	    CharacterMetadata = _require.CharacterMetadata,
	    BlockMapBuilder = _require.BlockMapBuilder,
	    ContentBlock = _require.ContentBlock,
	    EditorState = _require.EditorState,
	    Entity = _require.Entity,
	    Modifier = _require.Modifier,
	    SelectionState = _require.SelectionState,
	    genKey = _require.genKey;
	
	var _require2 = __webpack_require__(346),
	    List = _require2.List;
	
	// This provides sensible defaults for editorState, contentState, and selection.
	// This means that if I wanted to insert text at the current cursor location,
	// I could just pass in editorState, but if I wanted it to insert text at a
	// custom location, I would just pass in a selection as well
	
	
	var _fillData = function _fillData(draftData) {
	    var editorState = draftData.editorState,
	        contentState = draftData.contentState,
	        selection = draftData.selection;
	
	    var newData = {};
	    newData.editorState = editorState || null;
	    newData.contentState = contentState || editorState && editorState.getCurrentContent() || null;
	    newData.selection = selection || editorState && editorState.getSelection() || contentState && contentState.getSelectionAfter() || null;
	    return newData;
	};
	
	// Draft.js bugs currently emerge when the editor doesn't have focus.  This
	// avoids those by ensuring that the editor state always assumes it is focused
	var _createEmptySelection = function _createEmptySelection(block) {
	    return SelectionState.createEmpty(block.getKey()).set("hasFocus", true);
	};
	
	function regexStrategy(contentBlock, callback, regex, selectionFromMatch) {
	    var text = contentBlock.getText();
	    var matchArr = void 0;
	    while ((matchArr = regex.exec(text)) !== null) {
	        if (selectionFromMatch) {
	            var _selectionFromMatch = selectionFromMatch(matchArr),
	                start = _selectionFromMatch.start,
	                end = _selectionFromMatch.end;
	
	            callback(start, end);
	        } else {
	            var _start = matchArr.index;
	            callback(_start, _start + matchArr[0].length);
	        }
	    }
	}
	
	// TODO: Make this return an array of all matches, rather than first
	function findPattern(contentState, regExp) {
	    // The entire content is organized into blocks, and so each one must be
	    // searched in order to find every widget
	    var blocks = contentState.getBlockMap().values();
	    for (var _iterator = blocks, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
	        var _ref;
	
	        if (_isArray) {
	            if (_i >= _iterator.length) break;
	            _ref = _iterator[_i++];
	        } else {
	            _i = _iterator.next();
	            if (_i.done) break;
	            _ref = _i.value;
	        }
	
	        var block = _ref;
	
	        var match = regExp.exec(block.getText());
	        if (match !== null) {
	            var base = _createEmptySelection(block);
	            var selection = base.merge({
	                anchorOffset: match.index,
	                focusOffset: match.index + match[0].length
	            });
	            return selection;
	        }
	    }
	}
	
	function replaceSelection(draftData, text) {
	    var entity = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
	
	    var data = _fillData(draftData);
	    var newData = {};
	    newData.contentState = Modifier.replaceText(data.contentState, data.selection, text, null, // For custom styling, but we use a decorator instead
	    entity);
	
	    if (data.editorState) {
	        newData.editorState = EditorState.push(data.editorState, newData.contentState, "insert-characters");
	    }
	
	    return newData;
	}
	
	function deleteSelection(draftData) {
	    var data = _fillData(draftData);
	    var newData = {};
	    newData.contentState = Modifier.removeRange(data.contentState, data.selection, "backward");
	
	    if (data.editorState) {
	        newData.editorState = EditorState.push(data.editorState, newData.contentState, "remove-range");
	    }
	
	    return newData;
	}
	
	var _getBlocksForSelection = function _getBlocksForSelection(contentState, selection) {
	    var blocks = [];
	    var startKey = selection.getStartKey();
	    var endKey = selection.getEndKey();
	    var pastEndKey = contentState.getKeyAfter(endKey);
	
	    for (var blockKey = startKey; blockKey !== pastEndKey; blockKey = contentState.getKeyAfter(blockKey)) {
	        blocks.push(contentState.getBlockForKey(blockKey));
	    }
	
	    return blocks;
	};
	
	// Returns an array of all entiies contained within
	// the provided selection, or in the entire contentState
	// if no selection is provided
	function getEntities(contentState, selection) {
	    var blockMap = null;
	
	    // Overriden if a selection is specified
	    var filter = function filter() {
	        return true;
	    };
	
	    if (!selection) {
	        blockMap = contentState.getBlockMap();
	    } else {
	        var blocks = _getBlocksForSelection(contentState, selection);
	        blockMap = BlockMapBuilder.createFromArray(blocks);
	
	        // Ensure that entities in the same block as the start/end of the
	        // selection are not included if they are not fully contained
	        // within the selection
	        var startKey = selection.getStartKey();
	        var endKey = selection.getEndKey();
	        filter = function filter(key, start, end) {
	            if (key === startKey && start < selection.getStartOffset()) {
	                return false;
	            }
	            if (key === endKey && end > selection.getEndOffset()) {
	                return false;
	            }
	            return true;
	        };
	    }
	
	    var entities = [];
	    blockMap.forEach(function (block, blockKey) {
	        block.findEntityRanges(function (char) {
	            return char.getEntity() !== null;
	        }, function (start, end) {
	            if (filter(blockKey, start, end)) {
	                entities.push(Entity.get(block.getEntityAt(start)));
	            }
	        });
	    });
	    return entities;
	}
	
	function findEntity(contentState, filter) {
	    var blocks = contentState.getBlocksAsArray();
	
	    var selection = null;
	    blocks.some(function (block) {
	        block.findEntityRanges(function (char) {
	            return char.getEntity() !== null && filter(Entity.get(char.getEntity()));
	        }, function (start, end) {
	            var base = _createEmptySelection(block);
	            selection = base.merge({
	                anchorOffset: start,
	                focusOffset: end,
	                isBackward: false
	            });
	        });
	        return !!selection;
	    });
	
	    return selection;
	}
	
	/*
	    This function is needed in cases like pasting, where raw text must be
	    converted into Draft.js ContentBlocks.
	    The sanitizer allows for actions such as stripping characters and
	    adding in entities where needed
	    */
	var NEWLINE_REGEX = /\r\n?|\n/g;
	function insertText(draftData, rawText) {
	    var sanitizer = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {
	        return null;
	    };
	
	    var data = _fillData(draftData);
	    var newData = {};
	
	    // To insert text such that it will appear as multiple blocks,
	    // createFragment must be used.  A fragment is an ordered map of
	    // ContentBlocks.  There should be a ContentBlock for each paragraph
	    var textLines = rawText.split(NEWLINE_REGEX);
	
	    // Without basic character data, the text appears blank
	    var charData = CharacterMetadata.create();
	
	    // Create an array of ContentBlock objects, one for each line
	    var contentBlocks = textLines.map(function (textLine) {
	        // Styles and entities in draft.js are applied per character, therefore
	        // each block uses a list, where each element corresponds to a single
	        // character.
	        var text = textLine;
	        var characterList = Array(textLine.length).fill(charData);
	        var sanitizedObj = sanitizer(text, characterList);
	        if (sanitizedObj !== null) {
	            text = sanitizedObj.text;
	            characterList = sanitizedObj.characterList;
	        }
	
	        return new ContentBlock({
	            key: genKey(),
	            text: text,
	            type: "unstyled",
	            characterList: List(characterList)
	        });
	    });
	    var fragment = BlockMapBuilder.createFromArray(contentBlocks);
	
	    newData.contentState = Modifier.replaceWithFragment(data.contentState, data.selection, fragment);
	
	    if (data.editorState) {
	        newData.editorState = EditorState.push(data.editorState, newData.contentState, "insert-fragment");
	    }
	
	    return newData;
	}
	
	function selectEnd(block) {
	    var emptySelection = _createEmptySelection(block);
	    var newSelection = emptySelection.merge({
	        focusOffset: block.getCharacterList().size,
	        anchorOffset: block.getCharacterList().size
	    });
	    return newSelection;
	}
	
	// An offset is editable if it is not inside an immutable entity
	var _canEditOffset = function _canEditOffset(block, offset) {
	    if (offset === 0 || offset === block.getLength()) {
	        return true;
	    }
	    var leftKey = block.getEntityAt(offset - 1);
	    var rightKey = block.getEntityAt(offset);
	    var isImmutableEntity = rightKey ? Entity.get(rightKey).mutability === "IMMUTABLE" : false; // false if not an entity at all
	    return !(isImmutableEntity && leftKey === rightKey);
	};
	
	var _getSkippedOffset = function _getSkippedOffset(contentBlock, startOffset, step) {
	    var currOffset = startOffset;
	    while (currOffset > 0 && currOffset < contentBlock.getLength() && !_canEditOffset(contentBlock, currOffset)) {
	        currOffset += step;
	    }
	    return currOffset;
	};
	
	function snapSelectionOutsideEntities(draftData, prevSelection) {
	    var data = _fillData(draftData);
	    var contentState = data.contentState,
	        selection = data.selection,
	        editorState = data.editorState;
	
	
	    var anchorBlock = contentState.getBlockForKey(selection.getAnchorKey());
	    var focusBlock = contentState.getBlockForKey(selection.getFocusKey());
	    var anchorOffset = selection.getAnchorOffset();
	    var focusOffset = selection.getFocusOffset();
	    var direction = selection.getIsBackward() ? -1 : 1;
	
	    // If the cursor has moved by one, that means the user is moving it
	    // manually with the arrow keys.  If that is happening and the cursor
	    // moves from non-entity to entity, it should skip over the entity.
	    var focusDiff = focusOffset - prevSelection.getFocusOffset();
	    var isSameBlock = selection.getFocusKey() === prevSelection.getFocusKey();
	    if (isSameBlock && Math.abs(focusDiff) === 1 && !_canEditOffset(focusBlock, focusOffset)) {
	        focusOffset = _getSkippedOffset(focusBlock, focusOffset, focusDiff);
	    }
	
	    // These no-op if the offsets aren't/are no longer on entities
	    focusOffset = _getSkippedOffset(focusBlock, focusOffset, direction);
	    anchorOffset = _getSkippedOffset(anchorBlock, anchorOffset, -direction);
	
	    if (selection.isCollapsed()) {
	        anchorOffset = focusOffset;
	    }
	
	    var newData = { contentState: contentState };
	    newData.selection = selection.merge({
	        focusOffset: focusOffset,
	        anchorOffset: anchorOffset
	    });
	
	    if (editorState) {
	        // EditorState.forceSelection results in strange behavior
	        // where characters are repeated when typing normally
	        newData.editorState = EditorState.set(editorState, {
	            selection: newData.selection,
	            forceSelection: true
	        });
	    }
	
	    return newData;
	}
	
	var _surroundWithText = function _surroundWithText(contentState, block, left, right, text) {
	    var area = _createEmptySelection(block);
	    var content = contentState;
	
	    area = area.merge({ anchorOffset: right, focusOffset: right });
	    content = Modifier.insertText(content, area, text);
	
	    area = area.merge({ anchorOffset: left, focusOffset: left });
	    content = Modifier.insertText(content, area, text);
	
	    return content;
	};
	
	var _clearSurrounding = function _clearSurrounding(contentState, block, left, right, text) {
	    var area = _createEmptySelection(block);
	    var content = contentState;
	    area = area.merge({ anchorOffset: right - text.length, focusOffset: right });
	    content = Modifier.removeRange(content, area);
	
	    area = area.merge({ anchorOffset: left, focusOffset: left + text.length });
	    content = Modifier.removeRange(content, area);
	
	    return content;
	};
	
	function toggleDecoration(draftData, decoration) {
	    var data = _fillData(draftData);
	    var newData = {};
	
	    var contentState = data.contentState,
	        selection = data.selection;
	
	    var blocks = _getBlocksForSelection(contentState, selection);
	
	    // If all the blocks are already surrounded by the decoration, we must
	    // instead be disabling the decoration.  To do this without duplicating
	    // code, two copies are made, one as if we were decorating, and another
	    // as if we were removing a decoration.  If it was the case that all
	    // the selected text was already decorated, we use the version which
	    // removed all decoration, otherwise we use the newly decorated one
	    var allSurrounded = true;
	    var decorated = data.contentState;
	    var undecorated = data.contentState;
	    blocks.forEach(function (block) {
	        var leftOffset = 0;
	        var rightOffset = block.getLength();
	        if (block.getKey() === selection.getStartKey()) {
	            leftOffset = selection.getStartOffset();
	        }
	        if (block.getKey() === selection.getEndKey()) {
	            rightOffset = selection.getEndOffset();
	        }
	
	        // Ignore unless there is something to decorate
	        if (leftOffset === rightOffset) {
	            return;
	        }
	
	        // Check if we are undecorating
	        var selectedStr = block.getText().substring(leftOffset, rightOffset);
	        if (!allSurrounded || !selectedStr.endsWith(decoration) || !selectedStr.startsWith(decoration)) {
	            allSurrounded = false;
	        } else {
	            undecorated = _clearSurrounding(undecorated, block, leftOffset, rightOffset, decoration);
	        }
	
	        // Decorate the decorated version
	        decorated = _surroundWithText(decorated, block, leftOffset, rightOffset, decoration);
	    });
	
	    if (allSurrounded) {
	        newData.contentState = undecorated;
	    } else {
	        newData.contentState = decorated;
	    }
	
	    if (data.editorState) {
	        newData.editorState = EditorState.push(data.editorState, newData.contentState, allSurrounded ? "remove-range" : "insert-characters");
	
	        // Shift the selection to deal with the added/removed characters
	        var newEndOffset = selection.getEndOffset();
	        if (newEndOffset > 0) {
	            // If not ending on an empty block (no-ops)
	            var change = allSurrounded ? -2 : 2;
	            newEndOffset += change * decoration.length;
	        }
	
	        var newSelection = null;
	        if (selection.getIsBackward()) {
	            newSelection = selection.merge({ anchorOffset: newEndOffset });
	        } else {
	            newSelection = selection.merge({ focusOFfset: newEndOffset });
	        }
	
	        newData.editorState = EditorState.forceSelection(newData.editorState, newSelection);
	    }
	
	    return newData;
	}
	
	module.exports = {
	    regexStrategy: regexStrategy,
	    findPattern: findPattern,
	    replaceSelection: replaceSelection,
	    deleteSelection: deleteSelection,
	    getEntities: getEntities,
	    findEntity: findEntity,
	    insertText: insertText,
	    selectEnd: selectEnd,
	    snapSelectionOutsideEntities: snapSelectionOutsideEntities,
	    toggleDecoration: toggleDecoration
	};

/***/ },
/* 270 */
/***/ function(module, exports, __webpack_require__) {

	/* NOTE: This mimics what we do in webapp and links to our custom version of
	React -- this was not added with npm */
	module.exports = __webpack_require__(43).__internalAddons.PureRenderMixin;


/***/ },
/* 271 */,
/* 272 */,
/* 273 */,
/* 274 */,
/* 275 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = {
	    number: __webpack_require__(301),
	    vector: __webpack_require__(302),
	    point: __webpack_require__(303),
	    line: __webpack_require__(304),
	    ray: __webpack_require__(305),
	};


/***/ },
/* 276 */
/***/ function(module, exports, __webpack_require__) {

	var Util = __webpack_require__(17);
	var nestedMap = Util.nestedMap;
	var deepEq = Util.deepEq;
	var _ = __webpack_require__(56);
	
	/**
	 * A base class for all Graphie Movables
	 *
	 * Used for checking that all Graphie children are, in fact,
	 * GraphieMovables
	 */
	function GraphieMovable(descriptor) {
	    _.extend(this, descriptor);
	}
	
	var abstractMethod = function abstractMethod() {
	    throw new Error("Abstract method! Must be implemented by Graphie Movable" + this.constructor.displayName);
	};
	
	_.extend(GraphieMovable.prototype, {
	    movableProps: [],
	    add: abstractMethod,
	    modify: abstractMethod,
	    remove: abstractMethod,
	    toFront: function toFront() {
	        /* no op */
	    }
	});
	
	/**
	 * returns cloned props modified with `children: childrenArray`
	 */
	var rewriteProps = function rewriteProps(props, childrenArray) {
	    // Clone the props and add `children:`
	    // childrenArray is always an array here because this is only called
	    // from createClass, which initializes childrenArray as _.rest(arguments)
	    return _.extend({}, props, {
	        children: _.filter(_.flatten(childrenArray), _.identity)
	    });
	};
	
	/**
	 * Create a custom GraphieMovable class
	 */
	var createClass = function createClass(spec) {
	    var GraphieClass = function GraphieClass(props) {
	        if (!(this instanceof GraphieClass)) {
	            throw new Error("Use createElement or JSX with graphie movables");
	        }
	        this.props = rewriteProps(props, props.children || []);
	        return this;
	    };
	
	    spec.displayName = spec.displayName || _.uniqueId("GraphieClass");
	
	    // Add the displayName to the constructor for compatibility with
	    // React's myDescriptor.constructor.displayName
	    GraphieClass.displayName = spec.displayName;
	
	    GraphieClass.prototype = new GraphieMovable(spec);
	    GraphieClass.prototype.constructor = GraphieClass;
	
	    return GraphieClass;
	};
	
	/**
	 * Create a GraphieMovable class from a function that describes
	 * how to add said class to a graphie, and returns an array of
	 * `.remove()`able elements to be used when a remove() or
	 * modify() is called.
	 *
	 * This convenience method creates an inefficient class, although
	 * it does check for a difference in this.props and prevProps before
	 * removing and re-adding itself.
	 *
	 * The primary benefit of this is being able to very easily create
	 * a wrapper for old graphie code to make it interface with <Graphie>
	 *
	 * Commonly used elements should use the fully-fledged createClass
	 * and implement an efficient modify() operation.
	 */
	var createSimpleClass = function createSimpleClass(addFunction) {
	    return createClass({
	        displayName: addFunction.name || _.uniqueId("GraphieSimpleClass"),
	        movableProps: ["children"],
	
	        add: function add(graphie) {
	            this._elements = addFunction(graphie, this.props);
	            this._prevProps = this.props;
	        },
	
	        modify: function modify(graphie) {
	            if (!deepEq(this.props, this._prevProps)) {
	                this.remove();
	                this.add(graphie);
	                this._prevProps = this.props;
	                return "reordered";
	            }
	        },
	
	        remove: function remove() {
	            nestedMap(this._elements, function (elem) {
	                if (elem) {
	                    elem.remove();
	                }
	            });
	            this._elements = null;
	            this._prevProps = null;
	        },
	
	        toFront: function toFront() {
	            nestedMap(this._elements, function (elem) {
	                if (_.isFunction(elem.toFront)) {
	                    elem.toFront();
	                }
	            });
	        }
	    });
	};
	
	module.exports = {
	    GraphieMovable: GraphieMovable,
	    createClass: createClass,
	    createSimpleClass: createSimpleClass
	};

/***/ },
/* 277 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var _ = __webpack_require__(56);
	var GraphieClasses = __webpack_require__(276);
	var Interactive2 = __webpack_require__(266);
	
	var KhanColors = __webpack_require__(268);
	
	var MovablePoint = GraphieClasses.createClass({
	    displayName: "MovablePoint",
	
	    movableProps: ["children"],
	
	    _getProps: function _getProps() {
	        if (this.props.isMobile) {
	            var isMobile = this.props.isMobile;
	
	            // TODO(kevinb) precompute commonStyle and commonMobileStyle
	            /* eslint-disable indent */
	            var commonStyle = isMobile ? {
	                stroke: "#ffffff",
	                "stroke-width": 3,
	                fill: KhanColors.INTERACTIVE
	            } : {
	                stroke: KhanColors.INTERACTIVE,
	                fill: KhanColors.INTERACTIVE
	            };
	
	            // TODO(kevinb) precompute normalStyle and normalMobileStyle
	            var normalStyle = isMobile ? Object.assign(commonStyle, this.props.mobileStyleOverride || {}) : Object.assign(commonStyle, this.props.normalStyle);
	
	            // TODO(kevinb) precompute highlightStyle and highlightMobileStyle
	            var highlightStyle = isMobile ? _extends({}, commonStyle, {
	                "stroke-width": 0,
	                scale: 0.75
	            }) : this.props.highlightStyle;
	            /* eslint-enable indent */
	
	            var addedProps = Object.assign({
	                normalStyle: normalStyle,
	                highlightStyle: highlightStyle,
	                shadow: isMobile,
	                tooltip: isMobile && this.props.showTooltips
	            }, isMobile ? { pointSize: 7 } : {});
	
	            return Object.assign(this.props, addedProps);
	        } else {
	            return this.props;
	        }
	    },
	
	    add: function add(graphie) {
	        this.point = Interactive2.addMovablePoint(graphie, this._getProps());
	    },
	
	    modify: function modify() {
	        this.point.modify(this._getProps());
	    },
	
	    remove: function remove() {
	        this.point.remove();
	    },
	
	    toFront: function toFront() {
	        this.point.toFront();
	    },
	
	    grab: function grab(coord) {
	        this.point.grab(coord);
	    }
	});
	
	// Include helper methods, such as MovablePoint.constrain.snap()
	_.extend(MovablePoint, Interactive2.MovablePoint);
	
	var MovableLine = GraphieClasses.createClass({
	    displayName: "MovableLine",
	
	    movableProps: ["children"],
	
	    add: function add(graphie) {
	        // Add MovablePoint children
	        var points = _.pluck(this.props.children, "point");
	        var props = _.extend({}, this.props, {
	            points: points
	        });
	        this.line = Interactive2.addMovableLine(graphie, props);
	    },
	
	    modify: function modify() {
	        // Add MovablePoint children
	        var points = _.pluck(this.props.children, "point");
	        var props = _.extend({}, this.props, {
	            points: points
	        });
	        this.line.modify(props);
	    },
	
	    remove: function remove() {
	        this.line.remove();
	    },
	
	    toFront: function toFront() {
	        this.line.toFront();
	    }
	});
	
	// Include helper methods, such as MovableLine.constrain.snap()
	_.extend(MovableLine, Interactive2.MovableLine);
	
	var Label = GraphieClasses.createSimpleClass(function (graphie, props) {
	    var coord = props.coord;
	    if (props.unscaled) {
	        coord = graphie.unscalePoint(coord);
	    }
	
	    return graphie.label(coord, props.text, props.direction, props.tex, props.style);
	});
	
	var Line = GraphieClasses.createClass({
	    displayName: "Line",
	
	    movableProps: ["children"],
	
	    add: function add(graphie) {
	        var props = this.props;
	        this.graphie = graphie;
	        this.line = this.graphie.line(props.start, props.end, props.style);
	    },
	
	    modify: function modify() {
	        var props = this.props;
	        var path = this.graphie.svgPath([props.start, props.end]);
	        this.line.attr(_.extend({}, props.style, { path: path }));
	    },
	
	    remove: function remove() {
	        this.line.remove();
	    },
	
	    toFront: function toFront() {
	        this.line.toFront();
	    }
	});
	
	var Parabola = GraphieClasses.createClass({
	    displayName: "Parabola",
	
	    movableProps: ["children"],
	
	    add: function add(graphie) {
	        var props = this.props;
	        this.graphie = graphie;
	        this.parabola = this.graphie.parabola(props.a, props.b, props.c, props.style);
	    },
	
	    modify: function modify() {
	        var props = this.props;
	        var path = this.graphie.svgParabolaPath(props.a, props.b, props.c);
	        this.parabola.attr(_.extend({}, props.style, { path: path }));
	    },
	
	    remove: function remove() {
	        this.parabola.remove();
	    },
	
	    toFront: function toFront() {
	        this.parabola.toFront();
	    }
	});
	
	var Sinusoid = GraphieClasses.createClass({
	    displayName: "Sinusoid",
	
	    movableProps: ["children"],
	
	    add: function add(graphie) {
	        var props = this.props;
	        this.graphie = graphie;
	        this.sinusoid = this.graphie.sinusoid(props.a, props.b, props.c, props.d, props.style);
	    },
	
	    modify: function modify() {
	        var props = this.props;
	        var path = this.graphie.svgSinusoidPath(props.a, props.b, props.c, props.d);
	        this.sinusoid.attr(_.extend({}, props.style, { path: path }));
	    },
	
	    remove: function remove() {
	        this.sinusoid.remove();
	    },
	
	    toFront: function toFront() {
	        this.sinusoid.toFront();
	    }
	});
	
	var Plot = GraphieClasses.createSimpleClass(function (graphie, props) {
	    return graphie.plot(props.fn, props.range, props.style);
	});
	
	var PlotParametric = GraphieClasses.createSimpleClass(function (graphie, props) {
	    return graphie.plotParametric(props.fn, props.range, props.style);
	});
	
	var Point = GraphieClasses.createSimpleClass(function (graphie, props) {
	    return graphie.ellipse(props.coord, graphie.unscaleVector([4, 4]), {
	        fill: props.color || KhanColors.BLACK,
	        stroke: props.color || KhanColors.BLACK
	    });
	});
	
	var Path = GraphieClasses.createClass({
	    displayName: "Path",
	
	    movableProps: ["children"],
	
	    add: function add(graphie) {
	        var props = this.props;
	        this.graphie = graphie;
	        this.path = this.graphie.path(props.coords, props.style);
	    },
	
	    modify: function modify() {
	        var props = this.props;
	        var path = this.graphie.svgPath(props.coords);
	        this.path.attr({ path: path });
	    },
	
	    remove: function remove() {
	        this.path.remove();
	    },
	
	    toFront: function toFront() {
	        this.path.toFront();
	    }
	});
	
	var Arc = GraphieClasses.createSimpleClass(function (graphie, props) {
	    var center = props.center;
	    var radius = props.radius;
	    if (props.unscaled) {
	        center = graphie.unscalePoint(center);
	        radius = graphie.unscaleVector(radius);
	    }
	
	    return graphie.arc(center, radius, props.startAngle, props.endAngle, props.sector, props.style);
	});
	
	var Circle = GraphieClasses.createSimpleClass(function (graphie, props) {
	    return graphie.circle(props.center, props.radius, props.style);
	});
	
	var Rect = GraphieClasses.createSimpleClass(function (graphie, props) {
	    return graphie.rect(props.x, props.y, props.width, props.height, props.style);
	});
	
	module.exports = {
	    Arc: Arc,
	    Circle: Circle,
	    Label: Label,
	    Line: Line,
	    MovableLine: MovableLine,
	    MovablePoint: MovablePoint,
	    Parabola: Parabola,
	    Path: Path,
	    Plot: Plot,
	    PlotParametric: PlotParametric,
	    Point: Point,
	    Sinusoid: Sinusoid,
	    Rect: Rect
	};

/***/ },
/* 278 */
/***/ function(module, exports, __webpack_require__) {

	var _nonSatRationale, _intermediateResponsi;
	
	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/* eslint-disable object-curly-spacing */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	/* global i18n */
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var _ = __webpack_require__(56);
	var React = __webpack_require__(43);
	var classNames = __webpack_require__(86);
	
	var _require2 = __webpack_require__(12),
	    ClassNames = _require2.ClassNames;
	
	var sharedStyles = __webpack_require__(78);
	var styleConstants = __webpack_require__(77);
	var mediaQueries = __webpack_require__(76);
	
	var ToggleableRadioButton = __webpack_require__(307);
	var ChoiceIcon = __webpack_require__(308);
	var OptionStatus = __webpack_require__(309);
	
	var focusedStyleMixin = {
	    backgroundColor: styleConstants.satSelectedBackgroundColor,
	    outline: "2px solid " + styleConstants.satBlue,
	    // Render the outline higher than the next element's border
	    zIndex: 1
	};
	
	var intermediateCheckboxPadding = "16px 16px";
	var intermediateCheckboxPaddingPhone = "12px 16px";
	
	var Choice = React.createClass({
	    displayName: "Choice",
	
	    propTypes: {
	        // TODO(kevinb) use Options.propTypes from perseus-api.jsx
	        // This change will also require make sure that item-renderer.jsx and
	        // server-item-renderer.jsx have appropriate defaults for apiOptions
	        // because many of the properties on Options.propTypes are required.
	        apiOptions: React.PropTypes.shape({
	            satStyling: React.PropTypes.bool,
	            isMobile: React.PropTypes.bool,
	            styling: React.PropTypes.shape({
	                radioStyleVersion: React.PropTypes.oneOf(["intermediate", "final"]),
	                primaryProductColor: React.PropTypes.string
	            }),
	            readOnly: React.PropTypes.bool
	        }),
	        checked: React.PropTypes.bool,
	        className: React.PropTypes.string,
	        rationale: React.PropTypes.node,
	        content: React.PropTypes.node,
	        correct: React.PropTypes.bool,
	        deselectEnabled: React.PropTypes.bool,
	        disabled: React.PropTypes.bool,
	        editMode: React.PropTypes.bool,
	        groupName: React.PropTypes.string,
	        isLastChoice: React.PropTypes.bool, // Needed for border styling
	        // This indicates the position of the choice relative to others
	        // (so that we can display a nice little (A), (B), etc. next to it)
	        // Also used to generate an id for each input.
	        pos: React.PropTypes.number,
	        reviewMode: React.PropTypes.bool,
	        showRationale: React.PropTypes.bool,
	        showCorrectness: React.PropTypes.bool,
	        type: React.PropTypes.string,
	
	        // Indicates whether the user has "crossed out" this choice, meaning
	        // that they don't think it's correct. This value does not affect
	        // scoring or other behavior; it's just a note for the user's
	        // reference.
	        crossedOut: React.PropTypes.bool,
	
	        // A callback indicating that this choice has changed. Its argument is
	        // an object with two keys: `checked` and `crossedOut`. Each contains a
	        // boolean value specifying the new checked and crossed-out value of
	        // this choice.
	        onChange: React.PropTypes.func
	    },
	
	    statics: {
	        styles: StyleSheet.create({
	            pos: {
	                display: "none"
	            },
	
	            description: {
	                display: "inline-block",
	                width: "100%"
	            },
	
	            satDescription: {
	                display: "block",
	                position: "relative",
	                boxSizing: "border-box",
	                cursor: "pointer",
	                marginLeft: 0,
	                padding: "17px 14px"
	            },
	
	            satDescriptionInputFocused: _extends({}, focusedStyleMixin),
	
	            satDescriptionInputActive: _extends({}, focusedStyleMixin, {
	                backgroundColor: styleConstants.satActiveBackgroundColor
	            }),
	
	            satDescriptionCorrect: {
	                color: styleConstants.satCorrectColor
	            },
	
	            satDescriptionCorrectChecked: {
	                backgroundColor: styleConstants.satCorrectBackgroundColor
	            },
	
	            satDescriptionIncorrectChecked: {
	                color: styleConstants.satIncorrectColor,
	                backgroundColor: styleConstants.satIncorrectBackgroundColor
	            },
	
	            input: {
	                display: "inline-block",
	                width: 20,
	                margin: 3,
	                marginLeft: -20,
	                marginRight: 0,
	                float: "none"
	            },
	
	            satReviewInput: {
	                pointerEvents: "none"
	            },
	
	            satRadioOptionContent: {
	                userSelect: "text",
	                display: "block",
	                marginLeft: 45,
	                // Overriding here, not sure why typically set
	                // to "cursor: default" in js
	                cursor: "inherit"
	            },
	
	            satReviewRadioOptionContent: {
	                fontWeight: "bold"
	            },
	
	            satCheckboxOptionContent: {
	                position: "absolute",
	                display: "block",
	                top: "50%",
	                margin: "-16px 0 0 0",
	                width: "auto"
	            },
	
	            choiceIconWrapper: {
	                display: "flex",
	                marginRight: 12,
	
	                // NOTE(mdr): Without this style, the bubbles shrink on iOS
	                //     when answer text gets long.
	                flexShrink: 0
	            },
	
	            optionStatusContainer: {
	                display: "block"
	            },
	
	            rationale: {
	                display: "block"
	            },
	
	            nonSatRationale: (_nonSatRationale = {
	                padding: intermediateCheckboxPadding,
	                paddingTop: 0,
	                marginLeft: 44
	            }, _nonSatRationale[mediaQueries.smOrSmaller] = {
	                padding: intermediateCheckboxPaddingPhone,
	                paddingTop: 0
	            }, _nonSatRationale),
	
	            satReviewRationale: {
	                marginTop: 13,
	                marginLeft: 45
	            },
	
	            label: {
	                display: "block"
	            },
	
	            responsiveLabel: {
	                WebkitTapHighlightColor: "transparent",
	                display: "flex"
	            },
	
	            satLabel: {
	                cursor: "pointer"
	            },
	
	            intermediateResponsiveCheckbox: (_intermediateResponsi = {
	                display: "flex",
	                alignItems: "center",
	
	                padding: intermediateCheckboxPadding
	            }, _intermediateResponsi[mediaQueries.smOrSmaller] = {
	                padding: intermediateCheckboxPaddingPhone
	            }, _intermediateResponsi),
	            intermediateResponsiveCheckboxReview: {
	                alignItems: 'flex-start'
	            },
	
	            crossOutLink: {
	                textAlign: "right",
	                alignSelf: "center",
	                width: 100
	            }
	        })
	    },
	
	    getDefaultProps: function getDefaultProps() {
	        return {
	            checked: false,
	            classSet: {},
	            disabled: false,
	            editMode: false,
	            showRationale: false,
	            type: "radio",
	            pos: 0
	        };
	    },
	
	    getInitialState: function getInitialState() {
	        return {
	            isInputFocused: false,
	            isInputActive: false
	        };
	    },
	
	    componentWillUpdate: function componentWillUpdate(nextProps) {
	        if (this.state.isInputFocused && nextProps.disabled) {
	            this.setState({
	                isInputFocused: false
	            });
	        }
	    },
	
	
	    onInputFocus: function onInputFocus() {
	        this.setState({ isInputFocused: true });
	    },
	
	    onInputBlur: function onInputBlur() {
	        this.setState({ isInputFocused: false });
	    },
	
	    onInputMouseDown: function onInputMouseDown(e) {
	        if (e.type === "mousedown" && this.justFinishedTouch) {
	            return;
	        }
	
	        this.setState({ isInputActive: true });
	
	        // Simulate Chrome's radio button behavior in all browsers: when the
	        // mouse goes down or up, the radio button should become focused.
	        // That way, the newly-selected answer becomes highlighted after click.
	        if (this.props.apiOptions.satStyling && this._input) {
	            this._input.focus();
	        }
	    },
	
	    onInputMouseUp: function onInputMouseUp(e) {
	        var _this = this;
	
	        if (e.type === "mouseup" && this.justFinishedTouch) {
	            return;
	        }
	
	        // NOTE(emily): We do some special handling here of touch events to
	        // make the "active" effect look better. In particular, when you click
	        // using touch events, we get a series of events going
	        // touchstart -> (delay) -> touchend -> mousedown -> mouseup -> click
	        // In order to make sure that we don't turn the active state of and on
	        // and off again during the touchend -> mousedown -> mouseup series, we
	        // set a flag (this.justFinishedTouch) after the touchend, and ignore
	        // the mousedown and mouseup events. Then, a little while later, we
	        // turn the flag off. Instead of turning the active state off right at
	        // the beginning, we wait for a little bit to sync it up better with
	        // the click event.
	        if (e.type === "touchend") {
	            this.justFinishedTouch = true;
	
	            setTimeout(function () {
	                _this.setState({ isInputActive: false });
	                _this.justFinishedTouch = false;
	            }, 10);
	            return;
	        }
	
	        this.setState({ isInputActive: false });
	
	        // Simulate Chrome's radio button behavior in all browsers: when the
	        // mouse goes down or up, the radio button should become focused.
	        // That way, the newly-selected answer becomes highlighted after click.
	        if (this.props.apiOptions.satStyling && this._input) {
	            this._input.focus();
	        }
	    },
	
	    onInputMouseOut: function onInputMouseOut() {
	        this.setState({ isInputActive: false });
	    },
	
	    inputRef: function inputRef(ref) {
	        this._input = ref;
	    },
	
	    renderOptionStatus: function renderOptionStatus() {
	        var _props = this.props,
	            correct = _props.correct,
	            checked = _props.checked,
	            reviewMode = _props.reviewMode;
	        // Option status is shown only in review mode, and excluded for SAT
	
	        if (!reviewMode || this.props.apiOptions.satStyling) {
	            return;
	        }
	        return React.createElement(OptionStatus, {
	            checked: checked,
	            correct: correct
	        });
	    },
	    renderChoiceIcon: function renderChoiceIcon() {
	        var _props$apiOptions$sty = this.props.apiOptions.styling,
	            radioStyleVersion = _props$apiOptions$sty.radioStyleVersion,
	            primaryProductColor = _props$apiOptions$sty.primaryProductColor;
	
	        var finalStyles = typeof radioStyleVersion === "undefined" ? false : radioStyleVersion === "final";
	
	        if (!finalStyles && !this.props.apiOptions.satStyling) {
	            return null;
	        }
	
	        return React.createElement(ChoiceIcon, {
	            pos: this.props.pos,
	            correct: this.props.correct,
	            pressed: this.state.isInputActive,
	            focused: this.state.isInputFocused,
	            checked: this.props.checked,
	            showCorrectness: this.props.showCorrectness,
	            reviewMode: this.props.reviewMode,
	            product: this.props.apiOptions.satStyling ? "sat" : "library",
	            primaryProductColor: primaryProductColor
	        });
	    },
	
	
	    // NOTE(mdr): This method expects to be auto-bound. If this component is
	    //     converted to an ES6 class, take care to auto-bind this method!
	    _toggleCrossOut: function _toggleCrossOut() {
	        var willBeCrossedOut = !this.props.crossedOut;
	
	        if (willBeCrossedOut) {
	            // If we're crossing out a checked option, let's also uncheck it.
	            this._sendChange({ checked: false, crossedOut: true });
	        } else {
	            this._sendChange({ crossedOut: false });
	        }
	    },
	
	    // Call `this.props.onChange` with the given values. Any keys that are not
	    // specified will be filled in with the current value. (For example, if
	    // `checked` is specified but `crossedOut` is not, then `crossedOut` will
	    // be filled in with `this.props.crossedOut`.)
	    //
	    // This enables us to use shorthand inside this component, while
	    // maintaining a consistent API for the parent.
	    _sendChange: function _sendChange(newValues) {
	        var checked = newValues.checked != null ? newValues.checked : this.props.checked;
	
	        var crossedOut = newValues.crossedOut != null ? newValues.crossedOut : this.props.crossedOut;
	
	        this.props.onChange({ checked: checked, crossedOut: crossedOut });
	    },
	
	    render: function render() {
	        var _this2 = this;
	
	        var styles = Choice.styles;
	        var sat = this.props.apiOptions.satStyling;
	        var isMobile = this.props.apiOptions.isMobile;
	
	        var radioStyleVersion = this.props.apiOptions.styling.radioStyleVersion;
	
	        var finalStyles = typeof radioStyleVersion === "undefined" ? false : radioStyleVersion === "final";
	
	        var className = classNames(this.props.className, "checkbox-label", css(styles.label, isMobile && sharedStyles.disableTextSelection, !sat && styles.responsiveLabel, sat && styles.satLabel));
	
	        // There's two different input components we could use (the builtin
	        // input component, or the ToggleableRadioButton component). These are
	        // the props that we will pass to either.
	        var commonInputProps = {
	            type: this.props.type,
	            name: this.props.groupName,
	            id: this.props.groupName + "-choice-" + this.props.pos,
	            checked: this.props.checked,
	            disabled: this.props.disabled,
	            onFocus: this.onInputFocus,
	            onBlur: this.onInputBlur,
	            className: css(
	            // intermediate styles are not different for radio and
	            // checkbox, and have a separate active state.
	            !finalStyles && sharedStyles.perseusInteractive, !finalStyles && styles.input, !finalStyles && sharedStyles.responsiveInput, !finalStyles && !sat && sharedStyles.responsiveRadioInput, !finalStyles && !sat && this.state.isInputActive && sharedStyles.responsiveRadioInputActive, finalStyles && sharedStyles.perseusSrOnly, sat && sharedStyles.perseusSrOnly, sat && this.props.reviewMode && styles.satReviewInput)
	        };
	
	        var input = null;
	        if (this.props.type === "radio") {
	            // This is a special radio button that allows a user to deselect
	            // it by merely clicking/selecting it again.
	            input = React.createElement(ToggleableRadioButton, _extends({
	                onChecked: function onChecked(willBeChecked) {
	                    _this2._sendChange({ checked: willBeChecked });
	                },
	                inputRef: this.inputRef
	            }, commonInputProps));
	        } else {
	            input = React.createElement("input", _extends({
	                onChange: function onChange(event) {
	                    _this2._sendChange({ checked: event.target.checked });
	                },
	                ref: this.inputRef
	            }, commonInputProps));
	        }
	
	        var _props2 = this.props,
	            reviewMode = _props2.reviewMode,
	            correct = _props2.correct,
	            checked = _props2.checked,
	            isLastChoice = _props2.isLastChoice;
	        // HACK: while most of the styling for rendering SAT items is handled
	        // via aphrodite, we also need to assign normal CSS classnames here to
	        // special-case the coloring of MathJax formulas (see .MathJax .math in
	        // stylesheets/task-package/tasks.less)
	
	        var satCorrectChoice = sat && reviewMode && correct;
	        var satIncorrectChecked = sat && reviewMode && !correct && checked;
	        var descriptionClassName = classNames("description", satCorrectChoice && "sat-correct", satIncorrectChecked && "sat-incorrect", css(!sat && styles.description, sat && this.state.isInputFocused && styles.satDescriptionInputFocused, sat && this.state.isInputActive && styles.satDescriptionInputActive, sat && styles.satDescription, satCorrectChoice && styles.satDescriptionCorrect, satCorrectChoice && checked && styles.satDescriptionCorrectChecked, satIncorrectChecked && styles.satDescriptionIncorrectChecked, sat && isLastChoice && styles.satDescriptionLastChoice));
	
	        var checkboxContentClassName = classNames("checkbox", css(sharedStyles.perseusInteractive, !sat && styles.choiceIconWrapper, sat && styles.satCheckboxOptionContent));
	
	        var checkboxAndOptionClassName = classNames("checkbox-and-option", css(!sat && styles.intermediateResponsiveCheckbox, !sat && reviewMode && styles.intermediateResponsiveCheckboxReview));
	
	        var rationaleClassName = classNames("perseus-radio-rationale-content", css(styles.rationale, !sat && styles.nonSatRationale, sat && styles.satReviewRationale));
	
	        // In edit mode, we must allow selection of the contentEditable
	        // element inside, therefore we cannot use a label, which makes
	        // selection of anything inside automatically select the input
	        // element instead
	        var LabelOrDiv = this.props.editMode ? "div" : "label";
	
	        var showCrossOut = !this.props.showCorrectness && !sat &&
	        // HACK(mdr): This should go behind a real flag; this is just a
	        //     quick hack so I can ship this code for review (and maybe
	        //     land before the Nov 2017 TSM) before overcommitting to arch.
	        //     https://app.asana.com/0/329800276300868/467694510751339
	        document.location.href.indexOf("PERSEUS-HACK-SHOW-CROSS-OUT") >= 0;
	
	        // We want to show the choices as dimmed out when the choices are
	        // disabled. However, we don't want to do this in the SAT product and
	        // we also don't want to do this when we're in review mode in the
	        // content library.
	        var showDimmed = !sat && !reviewMode && this.props.apiOptions.readOnly ||
	        // HACK(mdr): This is a temporary way of showing the crossedOut
	        //     state. Eventually, we'll have custom visuals for this state,
	        //     at which point we'll remove this condition.
	        //     https://app.asana.com/0/329800276300868/467694510751336
	        showCrossOut && this.props.crossedOut;
	
	        return React.createElement(
	            LabelOrDiv,
	            {
	                htmlFor: !this.props.editMode && commonInputProps.id,
	                className: className,
	                style: { opacity: showDimmed ? 0.5 : 1.0 }
	            },
	            React.createElement(
	                "div",
	                {
	                    className: descriptionClassName,
	                    onMouseDown: this.onInputMouseDown,
	                    onMouseUp: this.onInputMouseUp,
	                    onMouseOut: this.onInputMouseOut,
	                    onTouchStart: this.onInputMouseDown,
	                    onTouchEnd: this.onInputMouseUp
	                },
	                React.createElement(
	                    "div",
	                    { className: checkboxAndOptionClassName },
	                    React.createElement(
	                        "span",
	                        { className: checkboxContentClassName },
	                        input,
	                        this.renderChoiceIcon()
	                    ),
	                    React.createElement(
	                        "span",
	                        {
	                            className: classNames(ClassNames.RADIO.OPTION_CONTENT, ClassNames.INTERACTIVE, css(sat && styles.satRadioOptionContent, sat && reviewMode && styles.satReviewRadioOptionContent)),
	                            style: { cursor: "default" }
	                        },
	                        React.createElement(
	                            "div",
	                            { className: css(styles.optionStatusContainer) },
	                            this.renderOptionStatus()
	                        ),
	                        React.createElement(
	                            "div",
	                            null,
	                            this.props.content
	                        )
	                    )
	                ),
	                this.props.showRationale && React.createElement(
	                    "div",
	                    { className: rationaleClassName },
	                    this.props.rationale
	                )
	            ),
	            showCrossOut && React.createElement(
	                "a",
	                {
	                    href: "javascript:void 0",
	                    onClick: this._toggleCrossOut,
	                    className: css(styles.crossOutLink)
	                },
	                this.props.crossedOut ? i18n.i18nDoNotTranslate("Uncross out") : i18n.i18nDoNotTranslate("Cross out")
	            )
	        );
	    }
	});
	
	module.exports = Choice;

/***/ },
/* 279 */
/***/ function(module, exports, __webpack_require__) {

	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	exports.getHostname = getHostname;
	exports.isInternalURL = isInternalURL;
	// Return the portion of a URL between // and /. This is the authority
	// portion which is usually just the hostname, but may also include
	// a username, password or port. We don't strip those things out because
	// we typically want to reject any URL that includes them
	var HOSTNAME = /\/\/([^\/]+)/;
	
	// Return the hostname of the URL, with any "www." prefix removed.
	// If this is a relative URL with no hostname, return an empty string.
	function getHostname(url) {
	    if (!url) {
	        return "";
	    }
	    var match = url.match(HOSTNAME);
	    return match ? match[1] : "";
	}
	
	// This list of domains that count as internal domains is from
	// webapp/content/models.py and webapp/url_util.py
	var internalDomains = {
	    "khanacademy.org": true,
	    "www.khanacademy.org": true,
	    "kasandbox.org": true,
	    "fastly.kastatic.org": true,
	    "cdn.kastatic.org": true,
	    "KA-youtube-converted.s3.amazonaws.com": true,
	    "KA-share.s3.amazonaws.com": true,
	    "ka-article-iframes.s3.amazonaws.com": true,
	    "ka-cs-algorithms.s3.amazonaws.com": true,
	    "ka-cs-challenge-images.s3.amazonaws.com": true,
	    "ka-cs-scratchpad-audio.s3.amazonaws.com": true,
	    "ka-exercise-screenshots.s3.amazonaws.com": true,
	    "ka-exercise-screenshots-2.s3.amazonaws.com": true,
	    "ka-exercise-screenshots-3.s3.amazonaws.com": true,
	    "ka-learnstorm.s3.amazonaws.com": true,
	    "ka-mobile.s3.amazonaws.com": true,
	    "ka-perseus-graphie.s3.amazonaws.com": true,
	    "ka-perseus-images.s3.amazonaws.com": true
	};
	
	// Returns true if this URL is relative, or if it is an absolute
	// URL with one of the domains listed above as its hostname.
	function isInternalURL(url) {
	    var hostname = getHostname(url);
	    return hostname === "" || internalDomains.hasOwnProperty(hostname);
	}

/***/ },
/* 280 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	/* eslint-disable brace-style, max-lines, object-curly-spacing */
	/* TODO(csilvers): fix these lint errors (http://eslint.org/docs/rules): */
	/* To fix, remove an entry above, run ka-lint, and fix errors. */
	
	var kpoint = __webpack_require__(275).point;
	var kvector = __webpack_require__(275).vector;
	var _ = __webpack_require__(56);
	
	// Minify Raphael ourselves because IE8 has a problem with the 1.5.2 minified
	// release
	// http://groups.google.com/group/raphaeljs/browse_thread/thread/c34c75ad8d431544
	/* globals Raphael:false */
	__webpack_require__(356);
	
	var KhanMath = __webpack_require__(208);
	var processMath = __webpack_require__(344).processMath;
	var KhanColors = __webpack_require__(268);
	
	/* Convert cartesian coordinates [x, y] to polar coordinates [r,
	 * theta], with theta in degrees, or in radians if angleInRadians is
	 * specified.
	 */
	function cartToPolar(coord, angleInRadians) {
	    var r = Math.sqrt(Math.pow(coord[0], 2) + Math.pow(coord[1], 2));
	    var theta = Math.atan2(coord[1], coord[0]);
	    // convert angle range from [-pi, pi] to [0, 2pi]
	    if (theta < 0) {
	        theta += 2 * Math.PI;
	    }
	    if (!angleInRadians) {
	        theta = theta * 180 / Math.PI;
	    }
	    return [r, theta];
	}
	
	function polar(r, th) {
	    if (typeof r === "number") {
	        r = [r, r];
	    }
	    th = th * Math.PI / 180;
	    return [r[0] * Math.cos(th), r[1] * Math.sin(th)];
	}
	
	var GraphUtils = {
	    unscaledSvgPath: function unscaledSvgPath(points) {
	        // If this is an empty closed path, return "" instead of "z", which
	        // would give an error
	        if (points[0] === true) {
	            return "";
	        }
	        return $.map(points, function (point, i) {
	            if (point === true) {
	                return "z";
	            }
	            return (i === 0 ? "M" : "L") + point[0] + " " + point[1];
	        }).join("");
	    },
	
	    getDistance: function getDistance(point1, point2) {
	        return kpoint.distanceToPoint(point1, point2);
	    },
	
	    /**
	    * Return the difference between two sets of coordinates
	    */
	    coordDiff: function coordDiff(startCoord, endCoord) {
	        return _.map(endCoord, function (val, i) {
	            return endCoord[i] - startCoord[i];
	        });
	    },
	
	    /**
	    * Round the given coordinates to a given snap value
	    * (e.g., nearest 0.2 increment)
	    */
	    snapCoord: function snapCoord(coord, snap) {
	        return _.map(coord, function (val, i) {
	            return KhanMath.roundToNearest(snap[i], val);
	        });
	    },
	
	    // Find the angle in degrees between two or three points
	    findAngle: function findAngle(point1, point2, vertex) {
	        if (vertex === undefined) {
	            var x = point1[0] - point2[0];
	            var y = point1[1] - point2[1];
	            if (!x && !y) {
	                return 0;
	            }
	            return (180 + Math.atan2(-y, -x) * 180 / Math.PI + 360) % 360;
	        } else {
	            return GraphUtils.findAngle(point1, vertex) - GraphUtils.findAngle(point2, vertex);
	        }
	    },
	
	    graphs: {}
	};
	
	var Graphie = GraphUtils.Graphie = function () {};
	
	_.extend(Graphie.prototype, {
	    cartToPolar: cartToPolar,
	    polar: polar
	});
	
	var labelDirections = {
	    center: [-0.5, -0.5],
	    above: [-0.5, -1.0],
	    "above right": [0.0, -1.0],
	    right: [0.0, -0.5],
	    "below right": [0.0, 0.0],
	    below: [-0.5, 0.0],
	    "below left": [-1.0, 0.0],
	    left: [-1.0, -0.5],
	    "above left": [-1.0, -1.0]
	};
	
	/**
	 * Safari applies some SVG-specific styles to things that are not SVGs, so we
	 * need to exclude those styles from things that are not SVGs.
	 *
	 * To see this behavior in action, open https://codepen.io/anon/pen/zENEoa in
	 * Safari.
	 *
	 * Usage `$.extend({}, someStyles, SVG_SPECIFIC_STYLE_MASK)`
	 */
	var SVG_SPECIFIC_STYLE_MASK = {
	    "stroke-width": null
	};
	
	GraphUtils.createGraphie = function (el) {
	    var xScale = 40;
	    var yScale = 40;
	    var xRange = void 0;
	    var yRange = void 0;
	
	    $(el).css("position", "relative");
	    var raphael = Raphael(el);
	
	    // For a sometimes-reproducible IE8 bug; doesn't affect SVG browsers at all
	    $(el).children("div").css("position", "absolute");
	
	    // Set up some reasonable defaults
	    var currentStyle = {
	        "stroke-width": 2,
	        fill: "none"
	    };
	
	    var scaleVector = function scaleVector(point) {
	        if (typeof point === "number") {
	            return scaleVector([point, point]);
	        }
	
	        var x = point[0];
	        var y = point[1];
	        return [x * xScale, y * yScale];
	    };
	
	    var scalePoint = function scalePoint(point) {
	        if (typeof point === "number") {
	            return scalePoint([point, point]);
	        }
	
	        var x = point[0];
	        var y = point[1];
	        return [(x - xRange[0]) * xScale, (yRange[1] - y) * yScale];
	    };
	
	    var unscalePoint = function unscalePoint(point) {
	        if (typeof point === "number") {
	            return unscalePoint([point, point]);
	        }
	
	        var x = point[0];
	        var y = point[1];
	        return [x / xScale + xRange[0], yRange[1] - y / yScale];
	    };
	
	    var unscaleVector = function unscaleVector(point) {
	        if (typeof point === "number") {
	            return unscaleVector([point, point]);
	        }
	
	        return [point[0] / xScale, point[1] / yScale];
	    };
	
	    var setLabelMargins = function setLabelMargins(span, size) {
	        var $span = $(span);
	        var direction = $span.data("labelDirection");
	        $span.css("visibility", "");
	
	        if (typeof direction === "number") {
	            var x = Math.cos(direction);
	            var y = Math.sin(direction);
	
	            var scale = Math.min(size[0] / 2 / Math.abs(x), size[1] / 2 / Math.abs(y));
	
	            $span.css({
	                marginLeft: -size[0] / 2 + x * scale,
	                marginTop: -size[1] / 2 - y * scale
	            });
	        } else {
	            var multipliers = labelDirections[direction || "center"];
	            $span.css({
	                marginLeft: Math.round(size[0] * multipliers[0]),
	                marginTop: Math.round(size[1] * multipliers[1])
	            });
	        }
	    };
	
	    var svgPath = function svgPath(points, alreadyScaled) {
	        return $.map(points, function (point, i) {
	            if (point === true) {
	                return "z";
	            } else {
	                var scaled = alreadyScaled ? point : scalePoint(point);
	                return (i === 0 ? "M" : "L") + KhanMath.bound(scaled[0]) + " " + KhanMath.bound(scaled[1]);
	            }
	        }).join("");
	    };
	
	    var svgParabolaPath = function svgParabolaPath(a, b, c) {
	        var computeParabola = function computeParabola(x) {
	            return (a * x + b) * x + c;
	        };
	
	        // If points are collinear, plot a line instead
	        if (a === 0) {
	            var _points = _.map(xRange, function (x) {
	                return [x, computeParabola(x)];
	            });
	            return svgPath(_points);
	        }
	
	        // Calculate x coordinates of points on parabola
	        var xVertex = -b / (2 * a);
	        var distToEdge = Math.max(Math.abs(xVertex - xRange[0]), Math.abs(xVertex - xRange[1]));
	
	        // To guarantee that drawn parabola to spans the viewport, use a point
	        // on the edge of the graph furtherest from the vertex
	        var xPoint = xVertex + distToEdge;
	
	        // Compute parabola and other point on the curve
	        var vertex = [xVertex, computeParabola(xVertex)];
	        var point = [xPoint, computeParabola(xPoint)];
	
	        // Calculate SVG 'control' point, defined by spec
	        var control = [vertex[0], vertex[1] - (point[1] - vertex[1])];
	
	        // Calculate mirror points across parabola's axis of symmetry
	        var dx = Math.abs(vertex[0] - point[0]);
	        var left = [vertex[0] - dx, point[1]];
	        var right = [vertex[0] + dx, point[1]];
	
	        // Scale and bound
	        var points = _.map([left, control, right], scalePoint);
	        var values = _.map(_.flatten(points), KhanMath.bound);
	        return "M" + values[0] + "," + values[1] + " Q" + values[2] + "," + values[3] + " " + values[4] + "," + values[5];
	    };
	
	    var svgSinusoidPath = function svgSinusoidPath(a, b, c, d) {
	        // Plot a sinusoid of the form: f(x) = a * sin(b * x - c) + d
	        var quarterPeriod = Math.abs(Math.PI / (2 * b));
	
	        var computeSine = function computeSine(x) {
	            return a * Math.sin(b * x - c) + d;
	        };
	
	        var computeDerivative = function computeDerivative(x) {
	            return a * b * Math.cos(c - b * x);
	        };
	
	        var coordsForOffset = function coordsForOffset(initial, i) {
	            // Return the cubic coordinates (including the two anchor and two
	            // control points) for the ith portion of the sinusoid.
	            var x0 = initial + quarterPeriod * i;
	            var x1 = x0 + quarterPeriod;
	
	            // Interpolate using derivative technique
	            // See: http://stackoverflow.com/questions/13932704/how-to-draw-sine-waves-with-svg-js
	            var xCoords = [x0, x0 * 2 / 3 + x1 * 1 / 3, x0 * 1 / 3 + x1 * 2 / 3, x1];
	            var yCoords = [computeSine(x0), computeSine(x0) + computeDerivative(x0) * (x1 - x0) / 3, computeSine(x1) - computeDerivative(x1) * (x1 - x0) / 3, computeSine(x1)];
	
	            // Zip and scale
	            return _.map(_.zip(xCoords, yCoords), scalePoint);
	        };
	
	        // How many quarter-periods do we need to span the graph?
	        var extent = xRange[1] - xRange[0];
	        var numQuarterPeriods = Math.ceil(extent / quarterPeriod) + 1;
	
	        // Find starting coordinate: first anchor point curve left of xRange[0]
	        var initial = c / b;
	        var distToEdge = initial - xRange[0];
	        initial -= quarterPeriod * Math.ceil(distToEdge / quarterPeriod);
	
	        // First portion of path is special-case, requiring move-to ('M')
	        var coords = coordsForOffset(initial, 0);
	        var path = "M" + coords[0][0] + "," + coords[0][1] + " C" + coords[1][0] + "," + coords[1][1] + " " + coords[2][0] + "," + coords[2][1] + " " + coords[3][0] + "," + coords[3][1];
	        for (var i = 1; i < numQuarterPeriods; i++) {
	            coords = coordsForOffset(initial, i);
	            path += " C" + coords[1][0] + "," + coords[1][1] + " " + coords[2][0] + "," + coords[2][1] + " " + coords[3][0] + "," + coords[3][1];
	        }
	
	        return path;
	    };
	
	    // `svgPath` is independent of graphie range, so we export it independently
	    GraphUtils.svgPath = svgPath;
	
	    var processAttributes = function processAttributes(attrs) {
	        var transformers = {
	            scale: function scale(_scale) {
	                if (typeof _scale === "number") {
	                    _scale = [_scale, _scale];
	                }
	
	                xScale = _scale[0];
	                yScale = _scale[1];
	
	                // Update the canvas size
	                raphael.setSize((xRange[1] - xRange[0]) * xScale, (yRange[1] - yRange[0]) * yScale);
	            },
	
	            clipRect: function clipRect(pair) {
	                var point = pair[0];
	                var size = pair[1];
	                point[1] += size[1]; // because our coordinates are flipped
	
	                return {
	                    "clip-rect": scalePoint(point).concat(scaleVector(size)).join(" ")
	                };
	            },
	
	            strokeWidth: function strokeWidth(val) {
	                return { "stroke-width": parseFloat(val) };
	            },
	
	            rx: function rx(val) {
	                return { rx: scaleVector([val, 0])[0] };
	            },
	
	            ry: function ry(val) {
	                return { ry: scaleVector([0, val])[1] };
	            },
	
	            r: function r(val) {
	                var scaled = scaleVector([val, val]);
	                return { rx: scaled[0], ry: scaled[1] };
	            }
	        };
	
	        var processed = {};
	        $.each(attrs || {}, function (key, value) {
	            var transformer = transformers[key];
	
	            if (typeof transformer === "function") {
	                $.extend(processed, transformer(value));
	            } else {
	                var dasherized = key.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
	                processed[dasherized] = value;
	            }
	        });
	
	        return processed;
	    };
	
	    var addArrowheads = function arrows(path) {
	        var type = path.constructor.prototype;
	
	        if (type === Raphael.el) {
	            if (path.type === "path" && typeof path.arrowheadsDrawn === "undefined") {
	                var w = path.attr("stroke-width");
	                var s = 0.6 + 0.4 * w;
	                var l = path.getTotalLength();
	                var set = raphael.set();
	                var head = raphael.path(graphie.isMobile ? "M-4,4 C-4,4 -0.25,0 -0.25,0 C-0.25,0 -4,-4 -4,-4" : "M-3 4 C-2.75 2.5 0 0.25 0.75 0C0 -0.25 -2.75 -2.5 -3 -4" // eslint-disable-line max-len
	                );
	                var end = path.getPointAtLength(l - 0.4);
	                var almostTheEnd = path.getPointAtLength(l - 0.75 * s);
	                var angle = Math.atan2(end.y - almostTheEnd.y, end.x - almostTheEnd.x) * 180 / Math.PI;
	                var attrs = path.attr();
	                delete attrs.path;
	
	                var subpath = path.getSubpath(0, l - 0.75 * s);
	                subpath = raphael.path(subpath).attr(attrs);
	                subpath.arrowheadsDrawn = true;
	                path.remove();
	
	                // For some unknown reason 0 doesn't work for the rotation
	                // origin so we use a tiny number.
	                head.rotate(angle, graphie.isMobile ? 1e-5 : 0.75, 0).scale(s, s, 0.75, 0).translate(almostTheEnd.x, almostTheEnd.y).attr(attrs).attr({
	                    "stroke-linejoin": "round",
	                    "stroke-linecap": "round"
	                });
	
	                head.arrowheadsDrawn = true;
	                set.push(subpath);
	                set.push(head);
	                return set;
	            }
	        } else if (type === Raphael.st) {
	            for (var i = 0, _l = path.items.length; i < _l; i++) {
	                arrows(path.items[i]);
	            }
	        }
	        return path;
	    };
	
	    var drawingTools = {
	        circle: function circle(center, radius) {
	            return raphael.ellipse.apply(raphael, scalePoint(center).concat(scaleVector([radius, radius])));
	        },
	
	        // (x, y) is coordinate of bottom left corner
	        rect: function rect(x, y, width, height) {
	            // Raphael needs (x, y) to be coordinate of upper left corner
	            var corner = scalePoint([x, y + height]);
	            var dims = scaleVector([width, height]);
	            var elem = raphael.rect.apply(raphael, corner.concat(dims));
	
	            if (graphie.isMobile) {
	                elem.node.style.shapeRendering = "crispEdges";
	            }
	
	            return elem;
	        },
	
	        ellipse: function ellipse(center, radii) {
	            return raphael.ellipse.apply(raphael, scalePoint(center).concat(scaleVector(radii)));
	        },
	
	        fixedEllipse: function fixedEllipse(center, radii, maxScale, padding) {
	            // Scale point and radius
	            var scaledPoint = scalePoint(center);
	            var scaledRadii = scaleVector(radii);
	
	            var width = 2 * scaledRadii[0] * maxScale + padding;
	            var height = 2 * scaledRadii[1] * maxScale + padding;
	
	            // Calculate absolute left, top
	            var left = scaledPoint[0] - width / 2;
	            var top = scaledPoint[1] - height / 2;
	
	            // Wrap in <div>
	            var wrapper = document.createElement("div");
	            $(wrapper).css({
	                position: "absolute",
	                width: width + "px",
	                height: height + "px",
	                left: left + "px",
	                top: top + "px"
	            });
	
	            // Create Raphael canvas
	            var localRaphael = Raphael(wrapper, width, height);
	            var visibleShape = localRaphael.ellipse(width / 2, height / 2, scaledRadii[0], scaledRadii[1]);
	
	            return {
	                wrapper: wrapper,
	                visibleShape: visibleShape
	            };
	        },
	
	        arc: function arc(center, radius, startAngle, endAngle, sector) {
	            startAngle = (startAngle % 360 + 360) % 360;
	            endAngle = (endAngle % 360 + 360) % 360;
	
	            var cent = scalePoint(center);
	            var radii = scaleVector(radius);
	            var startVector = polar(radius, startAngle);
	            var endVector = polar(radius, endAngle);
	
	            var startPoint = scalePoint([center[0] + startVector[0], center[1] + startVector[1]]);
	            var endPoint = scalePoint([center[0] + endVector[0], center[1] + endVector[1]]);
	
	            var largeAngle = ((endAngle - startAngle) % 360 + 360) % 360 > 180;
	
	            return raphael.path("M" + startPoint.join(" ") + "A" + radii.join(" ") + " 0 " + ( // ellipse rotation
	            largeAngle ? 1 : 0) + " 0 " + // sweep flag
	            endPoint.join(" ") + (sector ? "L" + cent.join(" ") + "z" : ""));
	        },
	
	        path: function path(points) {
	            var p = raphael.path(svgPath(points));
	            p.graphiePath = points;
	
	            return p;
	        },
	
	        fixedPath: function fixedPath(points, center, createPath) {
	            points = _.map(points, scalePoint);
	            center = center ? scalePoint(center) : null;
	            createPath = createPath || svgPath;
	
	            var pathLeft = _.min(_.pluck(points, 0));
	            var pathRight = _.max(_.pluck(points, 0));
	            var pathTop = _.min(_.pluck(points, 1));
	            var pathBottom = _.max(_.pluck(points, 1));
	
	            // Apply padding to line
	            var padding = [4, 4];
	
	            // Calculate and apply additional offset
	            var extraOffset = [pathLeft, pathTop];
	
	            // Apply padding and offset to points
	            points = _.map(points, function (point) {
	                return kvector.add(kvector.subtract(point, extraOffset), kvector.scale(padding, 0.5));
	            });
	
	            // Calculate <div> dimensions
	            var width = pathRight - pathLeft + padding[0];
	            var height = pathBottom - pathTop + padding[1];
	            var left = extraOffset[0] - padding[0] / 2;
	            var top = extraOffset[1] - padding[1] / 2;
	
	            // Create <div>
	            var wrapper = document.createElement("div");
	            $(wrapper).css({
	                position: "absolute",
	                width: width + "px",
	                height: height + "px",
	                left: left + "px",
	                top: top + "px",
	                // If user specified a center, set it
	                transformOrigin: center ? width / 2 + center[0] + "px " + (height / 2 + center[1]) + "px" : null
	            });
	
	            // Create Raphael canvas
	            var localRaphael = Raphael(wrapper, width, height);
	
	            // Calculate path
	            var visibleShape = localRaphael.path(createPath(points));
	
	            return {
	                wrapper: wrapper,
	                visibleShape: visibleShape
	            };
	        },
	
	        scaledPath: function scaledPath(points) {
	            var p = raphael.path(svgPath(points, /* alreadyScaled */true));
	            p.graphiePath = points;
	            return p;
	        },
	
	        line: function line(start, end) {
	            var l = this.path([start, end]);
	
	            if (graphie.isMobile) {
	                l.node.style.shapeRendering = "crispEdges";
	            }
	
	            return l;
	        },
	
	        parabola: function parabola(a, b, c) {
	            // Plot a parabola of the form: f(x) = (a * x + b) * x + c
	            return raphael.path(svgParabolaPath(a, b, c));
	        },
	
	        fixedLine: function fixedLine(start, end, thickness) {
	            // Apply padding to line
	            var padding = [thickness, thickness];
	
	            // Scale points to get values in pixels
	            start = scalePoint(start);
	            end = scalePoint(end);
	
	            // Calculate and apply additional offset
	            var extraOffset = [Math.min(start[0], end[0]), Math.min(start[1], end[1])];
	
	            // Apply padding and offset to start, end points
	            start = kvector.add(kvector.subtract(start, extraOffset), kvector.scale(padding, 0.5));
	            end = kvector.add(kvector.subtract(end, extraOffset), kvector.scale(padding, 0.5));
	
	            // Calculate <div> dimensions
	            var left = extraOffset[0] - padding[0] / 2;
	            var top = extraOffset[1] - padding[1] / 2;
	            var width = Math.abs(start[0] - end[0]) + padding[0];
	            var height = Math.abs(start[1] - end[1]) + padding[1];
	
	            // Create <div>
	            var wrapper = document.createElement("div");
	            $(wrapper).css({
	                position: "absolute",
	                width: width + "px",
	                height: height + "px",
	                left: left + "px",
	                top: top + "px",
	                // Outsiders should feel like the line's 'origin' (i.e., for
	                // rotation) is the starting point
	                transformOrigin: start[0] + "px " + start[1] + "px"
	            });
	
	            // Create Raphael canvas
	            var localRaphael = Raphael(wrapper, width, height);
	
	            // Calculate path
	            var path = "M" + start[0] + " " + start[1] + " " + "L" + end[0] + " " + end[1];
	            var visibleShape = localRaphael.path(path);
	            visibleShape.graphiePath = [start, end];
	
	            return {
	                wrapper: wrapper,
	                visibleShape: visibleShape
	            };
	        },
	
	        sinusoid: function sinusoid(a, b, c, d) {
	            // Plot a sinusoid of the form: f(x) = a * sin(b * x - c) + d
	            return raphael.path(svgSinusoidPath(a, b, c, d));
	        },
	
	        grid: function grid(xr, yr) {
	            var step = currentStyle.step || [1, 1];
	            var set = raphael.set();
	
	            var x = step[0] * Math.ceil(xr[0] / step[0]);
	            for (; x <= xr[1]; x += step[0]) {
	                set.push(this.line([x, yr[0]], [x, yr[1]]));
	            }
	
	            var y = step[1] * Math.ceil(yr[0] / step[1]);
	            for (; y <= yr[1]; y += step[1]) {
	                set.push(this.line([xr[0], y], [xr[1], y]));
	            }
	
	            return set;
	        },
	
	        label: function label(point, text, direction, latex) {
	            latex = typeof latex === "undefined" || latex;
	
	            var $span = $("<span>").addClass("graphie-label");
	
	            var pad = currentStyle["label-distance"];
	
	            $span.css($.extend({}, {
	                position: "absolute",
	                padding: (pad != null ? pad : 7) + "px"
	            })).data("labelDirection", direction).appendTo(el);
	
	            $span.setPosition = function (point) {
	                var scaledPoint = scalePoint(point);
	                $span.css({
	                    left: scaledPoint[0],
	                    top: scaledPoint[1]
	                });
	            };
	
	            $span.setPosition(point);
	
	            var span = $span[0];
	
	            $span.processMath = function (math, force) {
	                processMath(span, math, force, function () {
	                    var width = span.scrollWidth;
	                    var height = span.scrollHeight;
	                    setLabelMargins(span, [width, height]);
	                });
	            };
	
	            $span.processText = function (text) {
	                $span.html(text);
	                var width = span.scrollWidth;
	                var height = span.scrollHeight;
	                setLabelMargins(span, [width, height]);
	            };
	
	            if (latex) {
	                $span.processMath(text, /* force */false);
	            } else {
	                $span.processText(text);
	            }
	
	            return $span;
	        },
	
	        plotParametric: function plotParametric(fn, range, shade, fn2) {
	            // Note: fn2 should only be set if 'shade' is true, as it denotes
	            // the function between which fn should have its area shaded.
	            // In general, plotParametric shouldn't be used to shade the area
	            // between two arbitrary parametrics functions over an interval,
	            // as the method assumes that fn and fn2 are both of the form
	            // fn(t) = (t, fn'(t)) for some initial fn'.
	            fn2 = fn2 || function (t) {
	                return [t, 0];
	            };
	
	            // We truncate to 500,000, since anything bigger causes
	            // overflow in the firefox svg renderer.  This is safe
	            // since 500,000 is outside the viewport anyway.  We
	            // write these functions the way we do to handle undefined.
	            var clipper = function clipper(xy) {
	                if (Math.abs(xy[1]) > 500000) {
	                    return [xy[0], Math.min(Math.max(xy[1], -500000), 500000)];
	                }
	                return xy;
	            };
	            var clippedFn = function clippedFn(x) {
	                return clipper(fn(x));
	            };
	            var clippedFn2 = function clippedFn2(x) {
	                return clipper(fn2(x));
	            };
	
	            if (!currentStyle.strokeLinejoin) {
	                currentStyle.strokeLinejoin = "round";
	            }
	            if (!currentStyle.strokeLinecap) {
	                currentStyle.strokeLinecap = "round";
	            }
	
	            var min = range[0];
	            var max = range[1];
	            var step = (max - min) / (currentStyle["plot-points"] || 800);
	            if (step === 0) {
	                step = 1;
	            }
	
	            var paths = raphael.set();
	            var points = [];
	            var lastDiff = GraphUtils.coordDiff(clippedFn(min), clippedFn2(min));
	
	            var lastFlip = min;
	            for (var t = min; t <= max; t += step) {
	                var top = clippedFn(t);
	                var bottom = clippedFn2(t);
	                var diff = GraphUtils.coordDiff(top, bottom);
	
	                // Find points where it flips
	                // Create path that sketches area between the two functions
	                if (
	                // if there is an asymptote here, meaning that the graph
	                // switches signs and has a large difference
	                diff[1] < 0 !== lastDiff[1] < 0 && Math.abs(diff[1] - lastDiff[1]) > 2 * yScale ||
	                // or the function is undefined
	                isNaN(diff[1])) {
	                    // split the path at this point, and draw it
	                    if (shade) {
	                        points.push(top);
	
	                        // backtrack to draw paired function
	                        for (var u = t - step; u >= lastFlip; u -= step) {
	                            points.push(clippedFn2(u));
	                        }
	                        lastFlip = t;
	                    }
	                    paths.push(this.path(points));
	                    // restart the path, excluding this point
	                    points = [];
	                    if (shade) {
	                        points.push(top);
	                    }
	                } else {
	                    // otherwise, just add the point to the path
	                    points.push(top);
	                }
	
	                lastDiff = diff;
	            }
	
	            if (shade) {
	                // backtrack to draw paired function
	                for (var _u = max - step; _u >= lastFlip; _u -= step) {
	                    points.push(clippedFn2(_u));
	                }
	            }
	            paths.push(this.path(points));
	
	            return paths;
	        },
	
	        plotPolar: function plotPolar(fn, range) {
	            var min = range[0];
	            var max = range[1];
	
	            // There is probably a better heuristic for this
	            if (!currentStyle["plot-points"]) {
	                currentStyle["plot-points"] = 2 * (max - min) * xScale;
	            }
	
	            return this.plotParametric(function (th) {
	                return polar(fn(th), th * 180 / Math.PI);
	            }, range);
	        },
	
	        plot: function plot(fn, range, swapAxes, shade, fn2) {
	            var min = range[0];
	            var max = range[1];
	            if (!currentStyle["plot-points"]) {
	                currentStyle["plot-points"] = 2 * (max - min) * xScale;
	            }
	
	            if (swapAxes) {
	                if (fn2) {
	                    // TODO(charlie): support swapped axis area shading
	                    throw new Error("Can't shade area between functions with swapped axes.");
	                }
	                return this.plotParametric(function (y) {
	                    return [fn(y), y];
	                }, range, shade);
	            } else {
	                if (fn2) {
	                    if (shade) {
	                        return this.plotParametric(function (x) {
	                            return [x, fn(x)];
	                        }, range, shade, function (x) {
	                            return [x, fn2(x)];
	                        });
	                    } else {
	                        throw new Error("fn2 should only be set when 'shade' is True.");
	                    }
	                }
	                return this.plotParametric(function (x) {
	                    return [x, fn(x)];
	                }, range, shade);
	            }
	        },
	
	        /**
	         * Given a piecewise function, return a Raphael set of paths that
	         * can be used to draw the function, e.g. using style().
	         * Calls plotParametric.
	         *
	         * @param  {[]} fnArray    array of functions which when called
	         *                         with a parameter i return the value of
	         *                         the function at i
	         * @param  {[]} rangeArray array of ranges over which the
	         *                         corresponding functions are defined
	         * @return {Raphael set}
	         */
	        plotPiecewise: function plotPiecewise(fnArray, rangeArray) {
	            var paths = raphael.set();
	            var self = this;
	            _.times(fnArray.length, function (i) {
	                var fn = fnArray[i];
	                var range = rangeArray[i];
	                var fnPaths = self.plotParametric(function (x) {
	                    return [x, fn(x)];
	                }, range);
	                _.each(fnPaths, function (fnPath) {
	                    paths.push(fnPath);
	                });
	            });
	
	            return paths;
	        },
	
	        /**
	         * Given an array of coordinates of the form [x, y], create and
	         * return a Raphael set of Raphael circle objects at those
	         * coordinates
	         *
	         * @param  {Array of arrays} endpointArray
	         * @return {Raphael set}
	         */
	        plotEndpointCircles: function plotEndpointCircles(endpointArray) {
	            var circles = raphael.set();
	            var self = this;
	
	            _.each(endpointArray, function (coord, i) {
	                circles.push(self.circle(coord, 0.15));
	            });
	
	            return circles;
	        },
	
	        plotAsymptotes: function plotAsymptotes(fn, range) {
	            var min = range[0];
	            var max = range[1];
	            var step = (max - min) / (currentStyle["plot-points"] || 800);
	
	            var asymptotes = raphael.set();
	            var lastVal = fn(min);
	
	            for (var t = min; t <= max; t += step) {
	                var funcVal = fn(t);
	
	                if (funcVal < 0 !== lastVal < 0 && Math.abs(funcVal - lastVal) > 2 * yScale) {
	                    asymptotes.push(this.line([t, yScale], [t, -yScale]));
	                }
	
	                lastVal = funcVal;
	            }
	
	            return asymptotes;
	        }
	    };
	
	    var graphie = new Graphie();
	    _.extend(graphie, {
	        raphael: raphael,
	
	        init: function init(options) {
	            var scale = options.scale || [40, 40];
	            scale = typeof scale === "number" ? [scale, scale] : scale;
	
	            xScale = scale[0];
	            yScale = scale[1];
	
	            if (options.range == null) {
	                return Khan.error("range should be specified in graph init");
	            }
	
	            xRange = options.range[0];
	            yRange = options.range[1];
	
	            var w = (xRange[1] - xRange[0]) * xScale;
	            var h = (yRange[1] - yRange[0]) * yScale;
	            raphael.setSize(w, h);
	
	            $(el).css({
	                width: w,
	                height: h
	            });
	
	            this.range = options.range;
	            this.scale = scale;
	            this.dimensions = [w, h];
	            this.xpixels = w;
	            this.ypixels = h;
	
	            this.isMobile = options.isMobile;
	
	            return this;
	        },
	
	        style: function style(attrs, fn) {
	            var processed = processAttributes(attrs);
	
	            if (typeof fn === "function") {
	                var oldStyle = currentStyle;
	                currentStyle = $.extend({}, currentStyle, processed);
	                var result = fn.call(graphie);
	                currentStyle = oldStyle;
	                return result;
	            } else {
	                $.extend(currentStyle, processed);
	            }
	        },
	
	        scalePoint: scalePoint,
	        scaleVector: scaleVector,
	
	        unscalePoint: unscalePoint,
	        unscaleVector: unscaleVector,
	
	        // Custom SVG path functions that are dependent on graphie range
	        // `svgPath`, while independent of range, is exported for consistency
	        svgPath: svgPath,
	        svgParabolaPath: svgParabolaPath,
	        svgSinusoidPath: svgSinusoidPath
	    });
	
	    $.each(drawingTools, function (name) {
	        graphie[name] = function () {
	            var last = arguments[arguments.length - 1];
	            var oldStyle = currentStyle;
	            var result = void 0;
	
	            // The last argument is probably trying to change the style
	            if ((typeof last === "undefined" ? "undefined" : _typeof(last)) === "object" && !_.isArray(last)) {
	                currentStyle = _extends({}, currentStyle, processAttributes(last));
	
	                var rest = [].slice.call(arguments, 0, arguments.length - 1);
	                result = drawingTools[name].apply(drawingTools, rest);
	            } else {
	                currentStyle = $.extend({}, currentStyle);
	
	                result = drawingTools[name].apply(drawingTools, arguments);
	            }
	
	            // Bad heuristic for recognizing Raphael elements and sets
	            var type = result.constructor.prototype;
	            if (type === Raphael.el || type === Raphael.st) {
	                result.attr(currentStyle);
	
	                if (currentStyle.arrows) {
	                    result = addArrowheads(result);
	                }
	            } else if (result instanceof $) {
	                // We assume that if it's not a Raphael element/set, it
	                // does not contain SVG.
	                result.css(_extends({}, currentStyle, SVG_SPECIFIC_STYLE_MASK));
	            }
	
	            currentStyle = oldStyle;
	            return result;
	        };
	    });
	
	    // Initializes graphie settings for a graph and draws the basic graph
	    // features (axes, grid, tick marks, and axis labels)
	    // Options expected are:
	    // - range: [[a, b], [c, d]] or [a, b]
	    // - scale: [a, b] or number
	    // - gridOpacity: number (0 - 1)
	    // - gridStep: [a, b] or number (relative to units)
	    // - tickStep: [a, b] or number (relative to grid steps)
	    // - tickLen: [a, b] or number (in pixels)
	    // - labelStep: [a, b] or number (relative to tick steps)
	    // - yLabelFormat: fn to format label string for y-axis
	    // - xLabelFormat: fn to format label string for x-axis
	    // - smartLabelPositioning: true or false to ignore minus sign
	    graphie.graphInit = function (options) {
	        options = options || {};
	
	        $.each(options, function (prop, val) {
	            // allow options to be specified by a single number for shorthand if
	            // the horizontal and vertical components are the same
	            if (!prop.match(/.*Opacity$/) && prop !== "range" && typeof val === "number") {
	                options[prop] = [val, val];
	            }
	
	            // allow symmetric ranges to be specified by the absolute values
	            if (prop === "range" || prop === "gridRange") {
	                if (val.constructor === Array) {
	                    // but don't mandate symmetric ranges
	                    if (val[0].constructor !== Array) {
	                        options[prop] = [[-val[0], val[0]], [-val[1], val[1]]];
	                    }
	                } else if (typeof val === "number") {
	                    options[prop] = [[-val, val], [-val, val]];
	                }
	            }
	        });
	
	        var range = options.range || [[-10, 10], [-10, 10]];
	        var gridRange = options.gridRange || options.range;
	        var scale = options.scale || [20, 20];
	        var grid = options.grid != null ? options.grid : true;
	        var gridOpacity = options.gridOpacity || 0.1;
	        var gridStep = options.gridStep || [1, 1];
	        var axes = options.axes != null ? options.axes : true;
	        var axisArrows = options.axisArrows || "";
	        var axisOpacity = options.axisOpacity || 1.0;
	        var axisCenter = options.axisCenter || [Math.min(Math.max(range[0][0], 0), range[0][1]), Math.min(Math.max(range[1][0], 0), range[1][1])];
	        var axisLabels = options.axisLabels != null ? options.axisLabels : false;
	        var ticks = options.ticks != null ? options.ticks : true;
	        var tickStep = options.tickStep || [2, 2];
	        var tickLen = options.tickLen || [5, 5];
	        var tickOpacity = options.tickOpacity || 1.0;
	        var labels = options.labels || options.labelStep || false;
	        var labelStep = options.labelStep || [1, 1];
	        var labelOpacity = options.labelOpacity || 1.0;
	        var unityLabels = options.unityLabels || false;
	        var labelFormat = options.labelFormat || function (a) {
	            return a;
	        };
	        var xLabelFormat = options.xLabelFormat || labelFormat;
	        var yLabelFormat = options.yLabelFormat || labelFormat;
	        var smartLabelPositioning = options.smartLabelPositioning != null ? options.smartLabelPositioning : true;
	        var realRange = [[range[0][0] - (range[0][0] > 0 ? 1 : 0), range[0][1] + (range[0][1] < 0 ? 1 : 0)], [range[1][0] - (range[1][0] > 0 ? 1 : 0), range[1][1] + (range[1][1] < 0 ? 1 : 0)]];
	
	        if (!_.isArray(unityLabels)) {
	            unityLabels = [unityLabels, unityLabels];
	        }
	
	        if (smartLabelPositioning) {
	            var minusIgnorer = function minusIgnorer(lf) {
	                return function (a) {
	                    return (lf(a) + "").replace(/-(\d)/g, "\\llap{-}$1");
	                };
	            };
	
	            xLabelFormat = minusIgnorer(xLabelFormat);
	            yLabelFormat = minusIgnorer(yLabelFormat);
	        }
	
	        this.init({
	            range: realRange,
	            scale: scale,
	            isMobile: options.isMobile
	        });
	
	        // draw grid
	        if (grid) {
	            this.grid(gridRange[0], gridRange[1], {
	                stroke: options.isMobile ? KhanColors.GRAY_C : "#000000",
	                opacity: options.isMobile ? 1 : gridOpacity,
	                step: gridStep,
	                strokeWidth: options.isMobile ? 1 : 2
	            });
	        }
	
	        // draw axes
	        if (axes) {
	            // this is a slight hack until <-> arrowheads work
	            if (axisArrows === "<->" || axisArrows === true) {
	                this.style({
	                    stroke: options.isMobile ? KhanColors.GRAY_G : "#000000",
	                    opacity: options.isMobile ? 1 : axisOpacity,
	                    strokeWidth: options.isMobile ? 1 : 2,
	                    arrows: "->"
	                }, function () {
	                    if (range[1][0] < 0 && range[1][1] > 0) {
	                        this.path([axisCenter, [gridRange[0][0], axisCenter[1]]]);
	                        this.path([axisCenter, [gridRange[0][1], axisCenter[1]]]);
	                    }
	                    if (range[0][0] < 0 && range[0][1] > 0) {
	                        this.path([axisCenter, [axisCenter[0], gridRange[1][0]]]);
	                        this.path([axisCenter, [axisCenter[0], gridRange[1][1]]]);
	                    }
	                });
	
	                // also, we don't support "<-" arrows yet, but why you
	                // would want that on your graph is beyond me.
	            } else if (axisArrows === "->" || axisArrows === "") {
	                this.style({
	                    stroke: "#000000",
	                    opacity: axisOpacity,
	                    strokeWidth: 2,
	                    arrows: axisArrows
	                }, function () {
	                    this.path([[gridRange[0][0], axisCenter[1]], [gridRange[0][1], axisCenter[1]]]);
	                    this.path([[axisCenter[0], gridRange[1][0]], [axisCenter[0], gridRange[1][1]]]);
	                });
	            }
	
	            if (axisLabels && axisLabels.length === 2) {
	                this.label([gridRange[0][1], axisCenter[1]], axisLabels[0], "right");
	                this.label([axisCenter[0], gridRange[1][1]], axisLabels[1], "above");
	            }
	        }
	
	        // draw tick marks
	        if (ticks) {
	            var halfWidthTicks = options.isMobile;
	            this.style({
	                stroke: options.isMobile ? KhanColors.GRAY_G : "#000000",
	                opacity: options.isMobile ? 1 : tickOpacity,
	                strokeWidth: 1
	            }, function () {
	                // horizontal axis
	                var step = gridStep[0] * tickStep[0];
	                var len = tickLen[0] / scale[1];
	                var start = gridRange[0][0];
	                var stop = gridRange[0][1];
	
	                if (range[1][0] < 0 && range[1][1] > 0) {
	                    for (var x = step + axisCenter[0]; x <= stop; x += step) {
	                        if (x < stop || !axisArrows) {
	                            this.line([x, -len + axisCenter[1]], [x, halfWidthTicks ? 0 : len + axisCenter[1]]);
	                        }
	                    }
	
	                    for (var _x = -step + axisCenter[0]; _x >= start; _x -= step) {
	                        if (_x > start || !axisArrows) {
	                            this.line([_x, -len + axisCenter[1]], [_x, halfWidthTicks ? 0 : len + axisCenter[1]]);
	                        }
	                    }
	                }
	
	                // vertical axis
	                step = gridStep[1] * tickStep[1];
	                len = tickLen[1] / scale[0];
	                start = gridRange[1][0];
	                stop = gridRange[1][1];
	
	                if (range[0][0] < 0 && range[0][1] > 0) {
	                    for (var y = step + axisCenter[1]; y <= stop; y += step) {
	                        if (y < stop || !axisArrows) {
	                            this.line([-len + axisCenter[0], y], [halfWidthTicks ? 0 : len + axisCenter[0], y]);
	                        }
	                    }
	
	                    for (var _y = -step + axisCenter[1]; _y >= start; _y -= step) {
	                        if (_y > start || !axisArrows) {
	                            this.line([-len + axisCenter[0], _y], [halfWidthTicks ? 0 : len + axisCenter[0], _y]);
	                        }
	                    }
	                }
	            });
	        }
	
	        // draw axis labels
	        if (labels) {
	            this.style({
	                stroke: options.isMobile ? KhanColors.GRAY_G : "#000000",
	                opacity: options.isMobile ? 1 : labelOpacity
	            }, function () {
	                // horizontal axis
	                var step = gridStep[0] * tickStep[0] * labelStep[0];
	                var start = gridRange[0][0];
	                var stop = gridRange[0][1];
	                var xAxisPosition = axisCenter[0] < 0 ? "above" : "below";
	                var yAxisPosition = axisCenter[0] < 0 ? "right" : "left";
	                var xShowZero = axisCenter[0] === 0 && axisCenter[1] !== 0;
	                var yShowZero = axisCenter[0] !== 0 && axisCenter[1] === 0;
	                var axisOffCenter = axisCenter[0] !== 0 || axisCenter[1] !== 0;
	                var showUnityX = unityLabels[0] || axisOffCenter;
	                var showUnityY = unityLabels[1] || axisOffCenter;
	
	                // positive x-axis
	                for (var x = (xShowZero ? 0 : step) + axisCenter[0]; x <= stop; x += step) {
	                    if (x < stop || !axisArrows) {
	                        this.label([x, axisCenter[1]], xLabelFormat(x), xAxisPosition);
	                    }
	                }
	
	                // negative x-axis
	                for (var _x2 = -step * (showUnityX ? 1 : 2) + axisCenter[0]; _x2 >= start; _x2 -= step) {
	                    if (_x2 > start || !axisArrows) {
	                        this.label([_x2, axisCenter[1]], xLabelFormat(_x2), xAxisPosition);
	                    }
	                }
	
	                step = gridStep[1] * tickStep[1] * labelStep[1];
	                start = gridRange[1][0];
	                stop = gridRange[1][1];
	
	                // positive y-axis
	                for (var y = (yShowZero ? 0 : step) + axisCenter[1]; y <= stop; y += step) {
	                    if (y < stop || !axisArrows) {
	                        this.label([axisCenter[0], y], yLabelFormat(y), yAxisPosition);
	                    }
	                }
	
	                // negative y-axis
	                for (var _y2 = -step * (showUnityY ? 1 : 2) + axisCenter[1]; _y2 >= start; _y2 -= step) {
	                    if (_y2 > start || !axisArrows) {
	                        this.label([axisCenter[0], _y2], yLabelFormat(_y2), yAxisPosition);
	                    }
	                }
	            });
	        }
	    };
	
	    return graphie;
	};
	
	module.exports = GraphUtils;

/***/ },
/* 281 */
/***/ function(module, exports, __webpack_require__) {

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	/* eslint-disable max-lines */
	
	/**
	 * Interactive graphie utilities.
	 *
	 * This file exposes a couple functions, but mostly it adds functions to the
	 * `Graphie` prototype for dealing with interactive graphie elements.
	 */
	
	// TODO(emily): This file breaks our line length limits like nobody's business.
	// Figure out how to fix that.
	var _ = __webpack_require__(56);
	
	__webpack_require__(474);
	
	/* global Raphael:false */
	var GraphUtils = __webpack_require__(280);
	var kvector = __webpack_require__(275).vector;
	var kpoint = __webpack_require__(275).point;
	var kline = __webpack_require__(275).line;
	var WrappedEllipse = __webpack_require__(343);
	var WrappedLine = __webpack_require__(267);
	var WrappedPath = __webpack_require__(394);
	var KhanMath = __webpack_require__(208);
	var KhanColors = __webpack_require__(268);
	
	var _require = __webpack_require__(256),
	    getCanUse3dTransform = _require.getCanUse3dTransform;
	
	function sum(array) {
	    return _.reduce(array, function (memo, arg) {
	        return memo + arg;
	    }, 0);
	}
	
	function clockwise(points) {
	    var segments = _.zip(points, points.slice(1).concat(points.slice(0, 1)));
	    var areas = _.map(segments, function (segment) {
	        var p1 = segment[0];
	        var p2 = segment[1];
	        return (p2[0] - p1[0]) * (p2[1] + p1[1]);
	    });
	    return sum(areas) > 0;
	}
	
	/* vector-add multiple [x, y] coords/vectors */
	function addPoints() {
	    var points = _.toArray(arguments);
	    var zipped = _.zip.apply(_, points);
	    return _.map(zipped, sum);
	}
	
	function reverseVector(vector) {
	    return _.map(vector, function (coord) {
	        return coord * -1;
	    });
	}
	
	function scaledDistanceFromAngle(angle) {
	    var a = 3.51470560176242 * 20;
	    var b = 0.5687298702748785 * 20;
	    var c = -0.037587715462826674;
	    return (a - b) * Math.exp(c * angle) + b;
	}
	
	function scaledPolarRad(radius, radians) {
	    return [radius * Math.cos(radians), radius * Math.sin(radians) * -1];
	}
	
	function scaledPolarDeg(radius, degrees) {
	    var radians = degrees * Math.PI / 180;
	    return scaledPolarRad(radius, radians);
	}
	
	// Global dragging state
	var dragging = false;
	
	var InteractiveUtils = {
	    // Useful for shapes that are only sometimes drawn. If a shape isn't
	    // needed, it can be replaced with bogusShape which just has stub methods
	    // that successfully do nothing.
	    // The alternative would be 'if..typeof' checks all over the place.
	    bogusShape: {
	        animate: function animate() {},
	        attr: function attr() {},
	        remove: function remove() {}
	    }
	};
	
	_.extend(GraphUtils.Graphie.prototype, {
	    // graphie puts text spans on top of the SVG, which looks good, but gets
	    // in the way of mouse events. This adds another SVG element on top
	    // of everything else where we can add invisible shapes with mouse
	    // handlers wherever we want.
	    addMouseLayer: function addMouseLayer(options) {
	        var graph = this;
	        options = _.extend({
	            allowScratchpad: false,
	            setDrawingAreaAvailable: function setDrawingAreaAvailable() {}
	        }, options);
	
	        var mouselayerZIndex = 2;
	        graph.mouselayer = Raphael(graph.raphael.canvas.parentNode, graph.xpixels, graph.ypixels);
	        $(graph.mouselayer.canvas).css("z-index", mouselayerZIndex);
	        if (options.onClick || options.onMouseDown || options.onMouseMove || options.onMouseOver || options.onMouseOut) {
	            var canvasClickTarget = graph.mouselayer.rect(0, 0, graph.xpixels, graph.ypixels).attr({
	                fill: "#000",
	                opacity: 0
	            });
	            var isClickingCanvas = false;
	
	            $(graph.mouselayer.canvas).on("vmousedown", function (e) {
	                if (e.target === canvasClickTarget[0]) {
	                    if (options.onMouseDown) {
	                        options.onMouseDown(graph.getMouseCoord(e));
	                    }
	                    isClickingCanvas = true;
	
	                    if (options.onMouseMove) {
	                        $(document).bind("vmousemove.mouseLayer", function (e) {
	                            if (isClickingCanvas) {
	                                e.preventDefault();
	                                options.onMouseMove(graph.getMouseCoord(e));
	                            }
	                        });
	                    }
	
	                    $(document).bind("vmouseup.mouseLayer", function (e) {
	                        $(document).unbind(".mouseLayer");
	
	                        // Only register clicks that started on the canvas,
	                        // and not on another mouseLayer target
	                        if (isClickingCanvas && options.onClick) {
	                            options.onClick(graph.getMouseCoord(e));
	                        }
	                        isClickingCanvas = false;
	                    });
	                }
	            });
	            if (options.onMouseOver) {
	                $(graph.mouselayer.canvas).on("vmouseover", function (e) {
	                    options.onMouseOver(graph.getMouseCoord(e));
	                });
	            }
	            if (options.onMouseOut) {
	                $(graph.mouselayer.canvas).on("vmouseout", function (e) {
	                    options.onMouseOut(graph.getMouseCoord(e));
	                });
	            }
	        }
	        if (!options.allowScratchpad) {
	            options.setDrawingAreaAvailable(false);
	        }
	
	        // Add mouse and visible wrapper layers for DOM-node-wrapped movables
	        graph._mouselayerWrapper = document.createElement("div");
	        $(graph._mouselayerWrapper).css({
	            position: "absolute",
	            left: 0,
	            top: 0,
	            zIndex: mouselayerZIndex
	        });
	
	        graph._visiblelayerWrapper = document.createElement("div");
	        $(graph._visiblelayerWrapper).css({
	            position: "absolute",
	            left: 0,
	            top: 0
	        });
	
	        var el = graph.raphael.canvas.parentNode;
	        el.appendChild(graph._visiblelayerWrapper);
	        el.appendChild(graph._mouselayerWrapper);
	
	        // Add functions for adding to wrappers
	        graph.addToMouseLayerWrapper = function (el) {
	            this._mouselayerWrapper.appendChild(el);
	        };
	        graph.addToVisibleLayerWrapper = function (el) {
	            this._visiblelayerWrapper.appendChild(el);
	        };
	    },
	
	    /**
	     * Get mouse coordinates in pixels
	     */
	    getMousePx: function getMousePx(event) {
	        var graphie = this;
	
	        var mouseX = event.pageX - $(graphie.raphael.canvas.parentNode).offset().left;
	        var mouseY = event.pageY - $(graphie.raphael.canvas.parentNode).offset().top;
	
	        return [mouseX, mouseY];
	    },
	
	    /**
	     * Get mouse coordinates in graph coordinates
	     */
	    getMouseCoord: function getMouseCoord(event) {
	        return this.unscalePoint(this.getMousePx(event));
	    },
	
	    /**
	     * Unlike all other Graphie-related code, the following three functions use
	     * a lot of scaled coordinates (so that labels appear the same size
	     * regardless of current shape/figure scale). These are prefixed with 's'.
	     */
	    labelAngle: function labelAngle(options) {
	        var graphie = this;
	
	        _.defaults(options, {
	            point1: [0, 0],
	            vertex: [0, 0],
	            point3: [0, 0],
	            label: null,
	            numArcs: 1,
	            showRightAngleMarker: true,
	            pushOut: 0,
	            clockwise: false,
	            style: {}
	        });
	
	        var text = options.text === undefined ? "" : options.text;
	        var vertex = options.vertex;
	        var sVertex = graphie.scalePoint(vertex);
	        var p1 = void 0;
	        var p3 = void 0;
	        if (options.clockwise) {
	            p1 = options.point1;
	            p3 = options.point3;
	        } else {
	            p1 = options.point3;
	            p3 = options.point1;
	        }
	
	        var startAngle = GraphUtils.findAngle(p1, vertex);
	        var endAngle = GraphUtils.findAngle(p3, vertex);
	        var angle = (endAngle + 360 - startAngle) % 360;
	        var halfAngle = (startAngle + angle / 2) % 360;
	        var sPadding = 5 * options.pushOut;
	        var sRadius = sPadding + scaledDistanceFromAngle(angle);
	        var temp = [];
	
	        if (Math.abs(angle - 90) < 1e-9 && options.showRightAngleMarker) {
	            var v1 = addPoints(sVertex, scaledPolarDeg(sRadius, startAngle));
	            var v2 = addPoints(sVertex, scaledPolarDeg(sRadius, endAngle));
	
	            sRadius *= Math.SQRT2;
	            var v3 = addPoints(sVertex, scaledPolarDeg(sRadius, halfAngle));
	
	            _.each([v1, v2], function (v) {
	                temp.push(graphie.scaledPath([v, v3], options.style));
	            });
	        } else {
	            // Draw arcs
	            _.times(options.numArcs, function (i) {
	                temp.push(graphie.arc(vertex, graphie.unscaleVector(sRadius), startAngle, endAngle, options.style));
	                sRadius += 3;
	            });
	        }
	
	        if (text) {
	            var match = text.match(/\$deg(\d)?/);
	            if (match) {
	                var precision = match[1] || 1;
	                text = text.replace(match[0], KhanMath.toFixedApprox(angle, precision) + "^{\\circ}");
	            }
	
	            var sOffset = scaledPolarDeg(sRadius + 15, halfAngle);
	            var sPosition = addPoints(sVertex, sOffset);
	            var position = graphie.unscalePoint(sPosition);
	
	            // Reuse label if possible
	            if (options.label) {
	                options.label.setPosition(position);
	                options.label.processMath(text, /* force */true);
	            } else {
	                graphie.label(position, text, "center", options.style);
	            }
	        }
	
	        return temp;
	    },
	
	    labelSide: function labelSide(options) {
	        var graphie = this;
	
	        _.defaults(options, {
	            point1: [0, 0],
	            point2: [0, 0],
	            label: null,
	            text: "",
	            numTicks: 0,
	            numArrows: 0,
	            clockwise: false,
	            style: {}
	        });
	
	        var p1 = void 0;
	        var p2 = void 0;
	        if (options.clockwise) {
	            p1 = options.point1;
	            p2 = options.point2;
	        } else {
	            p1 = options.point2;
	            p2 = options.point1;
	        }
	
	        var midpoint = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2];
	        var sMidpoint = graphie.scalePoint(midpoint);
	        var parallelAngle = Math.atan2(p2[1] - p1[1], p2[0] - p1[0]);
	        var perpendicularAngle = parallelAngle + Math.PI / 2;
	        var temp = [];
	        var sCumulativeOffset = 0;
	
	        if (options.numTicks) {
	            var n = options.numTicks;
	
	            var sSpacing = 5;
	            var sHeight = 5;
	
	            var style = _.extend({}, options.style, {
	                strokeWidth: 2
	            });
	
	            _.times(n, function (i) {
	                var sOffset = sSpacing * (i - (n - 1) / 2);
	
	                var sOffsetVector = scaledPolarRad(sOffset, parallelAngle);
	                var sHeightVector = scaledPolarRad(sHeight, perpendicularAngle);
	
	                var sPath = [addPoints(sMidpoint, sOffsetVector, sHeightVector), addPoints(sMidpoint, sOffsetVector, reverseVector(sHeightVector))];
	
	                temp.push(graphie.scaledPath(sPath, style));
	            });
	
	            sCumulativeOffset += sSpacing * (n - 1) + 15;
	        }
	
	        if (options.numArrows) {
	            var _n = options.numArrows;
	
	            var start = [p1, p2].sort(function (a, b) {
	                if (a[1] === b[1]) {
	                    return a[0] - b[0];
	                } else {
	                    return a[1] - b[1];
	                }
	            })[0];
	            var sStart = graphie.scalePoint(start);
	
	            var _style = _.extend({}, options.style, {
	                arrows: "->",
	                strokeWidth: 2
	            });
	
	            var _sSpacing = 5;
	
	            _.times(_n, function (i) {
	                var sOffset = sCumulativeOffset + _sSpacing * i;
	                var sOffsetVector = scaledPolarRad(sOffset, parallelAngle);
	
	                if (start !== p1) {
	                    sOffsetVector = reverseVector(sOffsetVector);
	                }
	
	                var sEnd = addPoints(sMidpoint, sOffsetVector);
	
	                temp.push(graphie.scaledPath([sStart, sEnd], _style));
	            });
	        }
	
	        var text = options.text;
	        if (text) {
	            var match = text.match(/\$len(\d)?/);
	            if (match) {
	                var distance = GraphUtils.getDistance(p1, p2);
	                var precision = match[1] || 1;
	                text = text.replace(match[0], KhanMath.toFixedApprox(distance, precision));
	            }
	
	            var sOffset = 20;
	            var sOffsetVector = scaledPolarRad(sOffset, perpendicularAngle);
	            var sPosition = addPoints(sMidpoint, sOffsetVector);
	            var position = graphie.unscalePoint(sPosition);
	
	            // Reuse label if possible
	            if (options.label) {
	                options.label.setPosition(position);
	                options.label.processMath(text, /* force */true);
	            } else {
	                graphie.label(position, text, "center", options.style);
	            }
	        }
	
	        return temp;
	    },
	
	    /* Can also be used to label points that aren't vertices */
	    labelVertex: function labelVertex(options) {
	        var graphie = this;
	
	        _.defaults(options, {
	            point1: null,
	            vertex: [0, 0],
	            point3: null,
	            label: null,
	            text: "",
	            clockwise: false,
	            style: {}
	        });
	
	        if (!options.text) {
	            return;
	        }
	
	        var vertex = options.vertex;
	        var sVertex = graphie.scalePoint(vertex);
	        var p1 = void 0;
	        var p3 = void 0;
	        if (options.clockwise) {
	            p1 = options.point1;
	            p3 = options.point3;
	        } else {
	            p1 = options.point3;
	            p3 = options.point1;
	        }
	
	        var angle = 135;
	        var halfAngle = void 0;
	        if (p1 && p3) {
	            var startAngle = GraphUtils.findAngle(p1, vertex);
	            var endAngle = GraphUtils.findAngle(p3, vertex);
	            angle = (endAngle + 360 - startAngle) % 360;
	            halfAngle = (startAngle + angle / 2 + 180) % 360;
	        } else if (p1) {
	            var parallelAngle = GraphUtils.findAngle(vertex, p1);
	            halfAngle = parallelAngle + 90;
	        } else if (p3) {
	            var _parallelAngle = GraphUtils.findAngle(p3, vertex);
	            halfAngle = _parallelAngle + 90;
	        } else {
	            // Standalone point
	            halfAngle = 135;
	        }
	
	        var sRadius = 10 + scaledDistanceFromAngle(360 - angle);
	        var sOffsetVector = scaledPolarDeg(sRadius, halfAngle);
	        var sPosition = addPoints(sVertex, sOffsetVector);
	        var position = graphie.unscalePoint(sPosition);
	
	        // Reuse label if possible
	        if (options.label) {
	            options.label.setPosition(position);
	            options.label.processMath(options.text, /* force */true);
	        } else {
	            graphie.label(position, options.text, "center", options.style);
	        }
	    },
	
	    // Add a point to the graph that can be dragged around.
	    // It allows automatic constraints on its movement as well as automatically
	    // managing line segments that terminate at the point.
	    //
	    // Options can be set to control how the point behaves:
	    //   coord[]:
	    //     The initial position of the point
	    //   snapX, snapY:
	    //     The minimum increment the point can be moved
	    //
	    // The return value is an object that can be used to manipulate the point:
	    //   The coordX and coordY properties tell you the current position
	    //
	    //   By adding an onMove() method to the returned object, you can install an
	    //   event handler that gets called every time the user moves the point.
	    //
	    //   The returned object also provides a moveTo(x,y) method that will move
	    //   the point to a specific coordinate
	    //
	    // Constraints can be set on the on the returned object:
	    //
	    //  - Set point to be immovable:
	    //        movablePoint.constraints.fixed = true
	    //
	    //  - Constrain point to a fixed distance from another point. The resulting
	    //    point will move in a circle:
	    //        movablePoint.fixedDistance = {
	    //           dist: 2,
	    //           point: point1
	    //        }
	    //
	    //  - Constrain point to a line defined by a fixed angle between it and
	    //    two other points:
	    //        movablePoint.fixedAngle = {
	    //           angle: 45,
	    //           vertex: point1,
	    //           ref: point2
	    //        }
	    //
	    //  - Confined the point to traveling in a vertical or horizontal line,
	    //    respectively
	    //        movablePoint.constrainX = true;
	    //        movablePoint.constrainY = true;
	    //
	    //  - Connect a movableLineSegment to a movablePoint. The point is attached
	    //    to a specific end of the line segment by adding the segment either to
	    //    the list of lines that start at the point or the list of lines that
	    //    end at the point (movableLineSegment can do this for you):
	    //        movablePoint.lineStarts.push(movableLineSegment);
	    //          - or -
	    //        movablePoint.lineEnds.push(movableLineSegment);
	    //
	    //  - Connect a movablePolygon to a movablePoint in exacty the same way:
	    //        movablePoint.polygonVertices.push(movablePolygon);
	    //
	    addMovablePoint: function addMovablePoint(options) {
	        var movablePoint = $.extend(true, {
	            graph: this,
	            coord: [0, 0],
	            snapX: 0,
	            snapY: 0,
	            pointSize: 4,
	            highlight: false,
	            dragging: false,
	            visible: true,
	            bounded: true,
	            constraints: {
	                fixed: false,
	                constrainX: false,
	                constrainY: false,
	                fixedAngle: {},
	                fixedDistance: {}
	            },
	            lineStarts: [],
	            lineEnds: [],
	            polygonVertices: [],
	            normalStyle: {},
	            highlightStyle: {
	                fill: KhanColors.INTERACTING,
	                stroke: KhanColors.INTERACTING
	            },
	            labelStyle: {
	                color: KhanColors.INTERACTIVE
	            },
	            vertexLabel: "",
	            mouseTarget: null
	        }, options);
	
	        var normalColor = movablePoint.constraints.fixed ? KhanColors.DYNAMIC : KhanColors.INTERACTIVE;
	        movablePoint.normalStyle = _.extend({}, {
	            fill: normalColor,
	            stroke: normalColor
	        }, options.normalStyle);
	
	        // deprecated: don't use coordX/coordY; use coord[]
	        if (options.coordX !== undefined) {
	            movablePoint.coord[0] = options.coordX;
	        }
	        if (options.coordY !== undefined) {
	            movablePoint.coord[1] = options.coordY;
	        }
	
	        var graph = movablePoint.graph;
	
	        var applySnapAndConstraints = function applySnapAndConstraints(coord) {
	            // coord should be the scaled coordinate
	
	            // move point away from edge of graph unless it's invisible or fixed
	            if (movablePoint.visible && movablePoint.bounded && !movablePoint.constraints.fixed) {
	                // can't go beyond 10 pixels from the edge
	                coord = graph.constrainToBounds(coord, 10);
	            }
	
	            var coordX = coord[0];
	            var coordY = coord[1];
	
	            // snap coordinates to grid
	            if (movablePoint.snapX !== 0) {
	                coordX = Math.round(coordX / movablePoint.snapX) * movablePoint.snapX;
	            }
	            if (movablePoint.snapY !== 0) {
	                coordY = Math.round(coordY / movablePoint.snapY) * movablePoint.snapY;
	            }
	
	            // snap to points around circle
	            if (movablePoint.constraints.fixedDistance.snapPoints) {
	                var mouse = graph.scalePoint(coord);
	                var mouseX = mouse[0];
	                var mouseY = mouse[1];
	
	                var snapRadians = 2 * Math.PI / movablePoint.constraints.fixedDistance.snapPoints;
	                var radius = movablePoint.constraints.fixedDistance.dist;
	
	                var centerCoord = movablePoint.constraints.fixedDistance.point;
	                var centerX = (centerCoord[0] - graph.range[0][0]) * graph.scale[0];
	                var centerY = (-centerCoord[1] + graph.range[1][1]) * graph.scale[1];
	
	                var mouseXrel = mouseX - centerX;
	                var mouseYrel = -mouseY + centerY;
	                var radians = Math.atan(mouseYrel / mouseXrel);
	                var outsideArcTanRange = mouseXrel < 0;
	
	                // adjust so that angles increase from 0 to 2 pi as you go
	                // around the circle
	                if (outsideArcTanRange) {
	                    radians += Math.PI;
	                }
	
	                // perform the snap
	                radians = Math.round(radians / snapRadians) * snapRadians;
	
	                // convert from radians back to pixels
	                mouseXrel = radius * Math.cos(radians);
	                mouseYrel = radius * Math.sin(radians);
	                // convert back to coordinates relative to graphie canvas
	                mouseX = mouseXrel + centerX;
	                mouseY = -mouseYrel + centerY;
	                coordX = KhanMath.roundTo(5, mouseX / graph.scale[0] + graph.range[0][0]);
	                coordY = KhanMath.roundTo(5, graph.range[1][1] - mouseY / graph.scale[1]);
	            }
	
	            var result = movablePoint.applyConstraint([coordX, coordY]);
	            return result;
	        };
	
	        // Using the passed coordinates, apply any constraints and return
	        // the closest coordinates that match the constraints.
	        movablePoint.applyConstraint = function (coord, extraConstraints, override) {
	            var newCoord = coord.slice();
	            var constraints = {};
	            if (override) {
	                $.extend(constraints, {
	                    fixed: false,
	                    constrainX: false,
	                    constrainY: false,
	                    fixedAngle: {},
	                    fixedDistance: {}
	                }, extraConstraints);
	            } else {
	                $.extend(constraints, this.constraints, extraConstraints);
	            }
	
	            // constrain to vertical movement
	            if (constraints.constrainX) {
	                newCoord = [this.coord[0], coord[1]];
	
	                // constrain to horizontal movement
	            } else if (constraints.constrainY) {
	                newCoord = [coord[0], this.coord[1]];
	
	                // both distance and angle are constrained
	            } else if (typeof constraints.fixedAngle.angle === "number" && typeof constraints.fixedDistance.dist === "number") {
	                var vertex = constraints.fixedAngle.vertex.coord || constraints.fixedAngle.vertex;
	                var ref = constraints.fixedAngle.ref.coord || constraints.fixedAngle.ref;
	                var distPoint = constraints.fixedDistance.point.coord || constraints.fixedDistance.point;
	
	                var constrainedAngle = (constraints.fixedAngle.angle + GraphUtils.findAngle(ref, vertex)) * Math.PI / 180;
	                var length = constraints.fixedDistance.dist;
	                newCoord[0] = length * Math.cos(constrainedAngle) + distPoint[0];
	                newCoord[1] = length * Math.sin(constrainedAngle) + distPoint[1];
	
	                // angle is constrained
	            } else if (typeof constraints.fixedAngle.angle === "number") {
	                var _vertex = constraints.fixedAngle.vertex.coord || constraints.fixedAngle.vertex;
	                var _ref = constraints.fixedAngle.ref.coord || constraints.fixedAngle.ref;
	
	                var _constrainedAngle = (constraints.fixedAngle.angle + GraphUtils.findAngle(_ref, _vertex)) * Math.PI / 180;
	                var angle = GraphUtils.findAngle(coord, _vertex) * Math.PI / 180;
	                var distance = GraphUtils.getDistance(coord, _vertex);
	                var _length = distance * Math.cos(_constrainedAngle - angle);
	                _length = _length < 1.0 ? 1.0 : _length;
	                newCoord[0] = _length * Math.cos(_constrainedAngle) + _vertex[0];
	                newCoord[1] = _length * Math.sin(_constrainedAngle) + _vertex[1];
	
	                // distance is constrained
	            } else if (typeof constraints.fixedDistance.dist === "number") {
	                var _distPoint = constraints.fixedDistance.point.coord || constraints.fixedDistance.point;
	
	                var _angle = GraphUtils.findAngle(coord, _distPoint);
	                var _length2 = constraints.fixedDistance.dist;
	                _angle = _angle * Math.PI / 180;
	                newCoord[0] = _length2 * Math.cos(_angle) + _distPoint[0];
	                newCoord[1] = _length2 * Math.sin(_angle) + _distPoint[1];
	
	                // point is fixed
	            } else if (constraints.fixed) {
	                newCoord = movablePoint.coord;
	            }
	            return newCoord;
	        };
	
	        movablePoint.coord = applySnapAndConstraints(movablePoint.coord);
	
	        var highlightScale = 2;
	
	        if (movablePoint.visible) {
	            graph.style(movablePoint.normalStyle, function () {
	                var radii = [movablePoint.pointSize / graph.scale[0], movablePoint.pointSize / graph.scale[1]];
	                var options = {
	                    maxScale: highlightScale,
	                    // Add in 2px of padding to avoid clipping at the edges.
	                    padding: 2
	                };
	                movablePoint.visibleShape = new WrappedEllipse(graph, movablePoint.coord, radii, options);
	                movablePoint.visibleShape.attr(_.omit(movablePoint.normalStyle, "scale"));
	                movablePoint.visibleShape.toFront();
	            });
	        }
	        movablePoint.normalStyle.scale = 1;
	        movablePoint.highlightStyle.scale = highlightScale;
	
	        if (movablePoint.vertexLabel) {
	            movablePoint.labeledVertex = this.label([0, 0], "", "center", movablePoint.labelStyle);
	        }
	
	        movablePoint.drawLabel = function () {
	            if (movablePoint.vertexLabel) {
	                movablePoint.graph.labelVertex({
	                    vertex: movablePoint.coord,
	                    label: movablePoint.labeledVertex,
	                    text: movablePoint.vertexLabel,
	                    style: movablePoint.labelStyle
	                });
	            }
	        };
	
	        movablePoint.drawLabel();
	
	        movablePoint.grab = function (offset) {
	            // The offset for the gesture. When provided, the movable point will
	            // track the mouse's position, plus this offset. This is typically
	            // used to lock the distance between a user's finger and the movable
	            // point, when dragging.
	            offset = offset || [0, 0];
	
	            $(document).bind("vmousemove.point vmouseup.point", function (event) {
	                event.preventDefault();
	                movablePoint.dragging = true;
	                dragging = true;
	
	                // Adjust the target coordinate by accounting for the gesture's
	                // offset.
	                var coord = kvector.add(graph.getMouseCoord(event), offset);
	
	                coord = applySnapAndConstraints(coord);
	                var coordX = coord[0];
	                var coordY = coord[1];
	                var mouseX = void 0;
	                var mouseY = void 0;
	
	                if (event.type === "vmousemove") {
	                    var doMove = true;
	                    // The caller has the option of adding an onMove() method
	                    // to the movablePoint object we return as a sort of event
	                    // handler. By returning false from onMove(), the move
	                    // can be vetoed, providing custom constraints on where
	                    // the point can be moved. By returning array [x, y], the
	                    // move can be overridden
	                    if (_.isFunction(movablePoint.onMove)) {
	                        var result = movablePoint.onMove(coordX, coordY);
	                        if (result === false) {
	                            doMove = false;
	                        }
	                        if (_.isArray(result)) {
	                            coordX = result[0];
	                            coordY = result[1];
	                        }
	                    }
	                    // coord{X|Y} may have been modified by constraints or
	                    // onMove handler; adjust mouse{X|Y} to match
	                    mouseX = (coordX - graph.range[0][0]) * graph.scale[0];
	                    mouseY = (-coordY + graph.range[1][1]) * graph.scale[1];
	
	                    if (doMove) {
	                        var point = graph.unscalePoint([mouseX, mouseY]);
	                        movablePoint.visibleShape.moveTo(point);
	                        movablePoint.mouseTarget.moveTo(point);
	                        movablePoint.coord = [coordX, coordY];
	                        movablePoint.updateLineEnds();
	                        $(movablePoint).trigger("move");
	                    }
	
	                    movablePoint.drawLabel();
	                } else if (event.type === "vmouseup") {
	                    $(document).unbind(".point");
	                    movablePoint.dragging = false;
	                    dragging = false;
	                    if (_.isFunction(movablePoint.onMoveEnd)) {
	                        var _result = movablePoint.onMoveEnd(coordX, coordY);
	                        if (_.isArray(_result)) {
	                            coordX = _result[0];
	                            coordY = _result[1];
	                            mouseX = (coordX - graph.range[0][0]) * graph.scale[0];
	                            mouseY = (-coordY + graph.range[1][1]) * graph.scale[1];
	                            var _point = graph.unscalePoint([mouseX, mouseY]);
	                            movablePoint.visibleShape.moveTo(_point);
	                            movablePoint.mouseTarget.moveTo(_point);
	                            movablePoint.coord = [coordX, coordY];
	                        }
	                    }
	                    if (!movablePoint.highlight) {
	                        movablePoint.visibleShape.animate(movablePoint.normalStyle, 50);
	                        if (movablePoint.onUnhighlight) {
	                            movablePoint.onUnhighlight();
	                        }
	                    }
	                }
	            });
	        };
	
	        if (movablePoint.visible && !movablePoint.constraints.fixed) {
	            // the invisible shape in front of the point that gets mouse events
	            if (!movablePoint.mouseTarget) {
	                var radii = graph.unscaleVector(16);
	                var _options = {
	                    mouselayer: true,
	                    padding: 0,
	                    disableMouseEventsOnWrapper: true
	                };
	                movablePoint.mouseTarget = new WrappedEllipse(graph, movablePoint.coord, radii, _options);
	                movablePoint.mouseTarget.attr({ fill: "#000", opacity: 0.0 });
	            }
	
	            var $mouseTarget = $(movablePoint.mouseTarget.getMouseTarget());
	            $mouseTarget.css("cursor", "move");
	            $mouseTarget.bind("vmousedown vmouseover vmouseout", function (event) {
	                if (event.type === "vmouseover") {
	                    movablePoint.highlight = true;
	                    if (!dragging) {
	                        movablePoint.visibleShape.animate(movablePoint.highlightStyle, 50);
	                        if (movablePoint.onHighlight) {
	                            movablePoint.onHighlight();
	                        }
	                    }
	                } else if (event.type === "vmouseout") {
	                    movablePoint.highlight = false;
	                    if (!movablePoint.dragging && !dragging) {
	                        movablePoint.visibleShape.animate(movablePoint.normalStyle, 50);
	                        if (movablePoint.onUnhighlight) {
	                            movablePoint.onUnhighlight();
	                        }
	                    }
	                } else if (event.type === "vmousedown" && (event.which === 1 || event.which === 0)) {
	                    event.preventDefault();
	
	                    // The offset between the cursor or finger and the initial
	                    // coordinates of the point. This is tracked so as to avoid
	                    // locking the moving point to the user's finger on touch
	                    // devices, which would obscure it, no matter how large we
	                    // made the touch target. Instead, we respect the offset at
	                    // which the point was grabbed for the entirety of the
	                    // gesture, if it's a touch-based interaction.
	                    var startCoord = movablePoint.coord;
	                    var startMouseCoord = graph.getMouseCoord(event);
	                    var isMouse = !("ontouchstart" in window);
	                    var touchOffset = isMouse ? [0, 0] : kvector.subtract(startCoord, startMouseCoord);
	
	                    movablePoint.grab(touchOffset);
	                }
	            });
	        }
	
	        // Method to let the caller animate the point to a new position.
	        // Useful as part of a hint to show the user the correct place
	        // to put the point.
	        movablePoint.moveTo = function (coordX, coordY, updateLines) {
	            var distance = GraphUtils.getDistance(this.graph.scalePoint([coordX, coordY]), this.graph.scalePoint(this.coord));
	
	            var time = distance * 5;
	
	            var cb = updateLines && function (coord) {
	                movablePoint.coord = coord;
	                movablePoint.updateLineEnds();
	            };
	            this.visibleShape.animateTo([coordX, coordY], time, cb);
	            this.mouseTarget.animateTo([coordX, coordY], time, cb);
	            this.coord = [coordX, coordY];
	            if (_.isFunction(this.onMove)) {
	                this.onMove(coordX, coordY);
	            }
	        };
	
	        // After moving the point, call this to update all line segments
	        // terminating at the point
	        movablePoint.updateLineEnds = function () {
	            $(this.lineStarts).each(function () {
	                this.coordA = movablePoint.coord;
	                this.transform();
	            });
	            $(this.lineEnds).each(function () {
	                this.coordZ = movablePoint.coord;
	                this.transform();
	            });
	            $(this.polygonVertices).each(function () {
	                this.transform();
	            });
	        };
	
	        // Put the point at a new position without any checks, animation,
	        // or callbacks
	        movablePoint.setCoord = function (coord) {
	            if (this.visible) {
	                this.visibleShape.moveTo(coord);
	                if (this.mouseTarget != null) {
	                    this.mouseTarget.moveTo(coord);
	                }
	            }
	            this.coord = coord.slice();
	        };
	
	        // Put the point at the new position, checking that it is
	        // within the graph's bounds
	        movablePoint.setCoordConstrained = function (coord) {
	            this.setCoord(applySnapAndConstraints(coord));
	        };
	
	        // Change z-order to back
	        movablePoint.toBack = function () {
	            if (this.visible) {
	                if (this.mouseTarget != null) {
	                    this.mouseTarget.toBack();
	                }
	                this.visibleShape.toBack();
	            }
	        };
	
	        // Change z-order to front
	        movablePoint.toFront = function () {
	            if (this.visible) {
	                if (this.mouseTarget != null) {
	                    this.mouseTarget.toFront();
	                }
	                this.visibleShape.toFront();
	            }
	        };
	
	        movablePoint.remove = function () {
	            if (this.visibleShape) {
	                this.visibleShape.remove();
	            }
	            if (this.mouseTarget) {
	                this.mouseTarget.remove();
	            }
	            if (this.labeledVertex) {
	                this.labeledVertex.remove();
	            }
	        };
	
	        return movablePoint;
	    },
	
	    // MovableLineSegment is a line segment that can be dragged around the
	    // screen. By attaching a smartPoint to each (or one) end, the ends can be
	    // manipulated individually.
	    //
	    // To use with smartPoints, add the smartPoints first, then:
	    //   addMovableLineSegment({ pointA: smartPoint1, pointZ: smartPoint2 });
	    // Or just one end:
	    //   addMovableLineSegment({ pointA: smartPoint, coordZ: [0, 0] });
	    //
	    // Include "fixed: true" in the options if you don't want the entire line
	    // to be draggable (you can still use points to make the endpoints
	    // draggable)
	    //
	    // The returned object includes the following properties/methods:
	    //
	    //   - lineSegment.coordA / lineSegment.coordZ
	    //         The coordinates of each end of the line segment
	    //
	    //   - lineSegment.transform(syncToPoints)
	    //         Repositions the line segment. Call after changing coordA
	    //         and/or coordZ, or pass syncToPoints = true to use the current
	    //         position of the corresponding smartPoints, if the segment was
	    //         defined using smartPoints
	    //
	    addMovableLineSegment: function addMovableLineSegment(options) {
	        var lineSegment = $.extend({
	            graph: this,
	            coordA: [0, 0],
	            coordZ: [1, 1],
	            snapX: 0,
	            snapY: 0,
	            fixed: false,
	            ticks: 0,
	            normalStyle: {},
	            highlightStyle: {
	                stroke: KhanColors.INTERACTING,
	                "stroke-width": 6
	            },
	            labelStyle: {
	                stroke: KhanColors.INTERACTIVE,
	                color: KhanColors.INTERACTIVE
	            },
	            highlight: false,
	            dragging: false,
	            tick: [],
	            extendLine: false,
	            extendRay: false,
	            constraints: {
	                fixed: false,
	                constrainX: false,
	                constrainY: false
	            },
	            sideLabel: "",
	            vertexLabels: [],
	            numArrows: 0,
	            numTicks: 0,
	            movePointsWithLine: false
	        }, options);
	
	        var normalColor = lineSegment.fixed ? KhanColors.DYNAMIC : KhanColors.INTERACTIVE;
	        lineSegment.normalStyle = _.extend({}, {
	            "stroke-width": 2,
	            stroke: normalColor
	        }, options.normalStyle);
	        // arrowStyle should be kept in sync with styling of the line
	        lineSegment.arrowStyle = _.extend({}, lineSegment.normalStyle, {
	            color: lineSegment.normalStyle.stroke
	        });
	
	        // If the line segment is defined by movablePoints, coordA/coordZ are
	        // owned by the points, otherwise they're owned by us
	        if (options.pointA !== undefined) {
	            lineSegment.coordA = options.pointA.coord;
	            lineSegment.pointA.lineStarts.push(lineSegment);
	        } else if (options.coordA !== undefined) {
	            lineSegment.coordA = options.coordA.slice();
	        }
	
	        if (options.pointZ !== undefined) {
	            lineSegment.coordZ = options.pointZ.coord;
	            lineSegment.pointZ.lineEnds.push(lineSegment);
	        } else if (options.coordA !== undefined) {
	            lineSegment.coordA = lineSegment.coordA.slice();
	        }
	
	        var graph = lineSegment.graph;
	
	        graph.style(lineSegment.normalStyle);
	        for (var i = 0; i < lineSegment.ticks; ++i) {
	            lineSegment.tick[i] = InteractiveUtils.bogusShape;
	        }
	        // TODO(kevinb) figure out why path isn't being used
	        /* eslint-disable */
	        var path = GraphUtils.unscaledSvgPath([[0, 0], [1, 0]]);
	        for (var _i = 0; _i < lineSegment.ticks; ++_i) {
	            var tickoffset = 0.5 - (lineSegment.ticks - 1 + _i * 2) / graph.scale[0];
	            path += GraphUtils.unscaledSvgPath([[tickoffset, -7], [tickoffset, 7]]);
	        }
	        /* eslint-enable */
	
	        options = {
	            thickness: Math.max(lineSegment.normalStyle["stroke-width"], lineSegment.highlightStyle["stroke-width"])
	        };
	        lineSegment.visibleLine = new WrappedLine(graph, [0, 0], [1, 0], options);
	        lineSegment.visibleLine.attr(lineSegment.normalStyle);
	
	        // Add mouse target
	        if (!lineSegment.fixed) {
	            var _options2 = {
	                thickness: 30,
	                mouselayer: true
	            };
	            lineSegment.mouseTarget = new WrappedLine(graph, [0, 0], [1, 0], _options2);
	            lineSegment.mouseTarget.attr({ fill: "#000", opacity: 0.0 });
	        }
	
	        // Reposition the line segment. Call after changing coordA and/or
	        // coordZ, or pass syncToPoints = true to use the current position of
	        // the corresponding movablePoints, if the segment was defined using
	        // movablePoints
	        lineSegment.transform = function (syncToPoints) {
	            if (syncToPoints) {
	                if (_typeof(this.pointA) === "object") {
	                    this.coordA = this.pointA.coord;
	                }
	                if (_typeof(this.pointZ) === "object") {
	                    this.coordZ = this.pointZ.coord;
	                }
	            }
	
	            var getScaledAngle = function getScaledAngle(line) {
	                var scaledA = line.graph.scalePoint(line.coordA);
	                var scaledZ = line.graph.scalePoint(line.coordZ);
	                return kvector.polarDegFromCart(kvector.subtract(scaledZ, scaledA))[1];
	            };
	
	            var getClipPoint = function getClipPoint(graph, coord, angle) {
	                graph = lineSegment.graph;
	                var xExtent = graph.range[0][1] - graph.range[0][0];
	                var yExtent = graph.range[1][1] - graph.range[1][0];
	
	                var distance = xExtent + yExtent;
	                var angleVec = graph.unscaleVector(kvector.cartFromPolarDeg([1, angle]));
	                var distVec = kvector.scale(kvector.normalize(angleVec), distance);
	                var farCoord = kvector.add(coord, distVec);
	                var scaledAngle = kvector.polarDegFromCart(angleVec)[1];
	                var clipPoint = graph.constrainToBoundsOnAngle(farCoord, 4, scaledAngle * Math.PI / 180);
	                return clipPoint;
	            };
	
	            var angle = getScaledAngle(this);
	            var start = this.coordA;
	            var end = this.coordZ;
	
	            // Extend start, end if necessary (i.e., if not a line segment)
	            if (this.extendLine) {
	                start = getClipPoint(graph, start, 360 - angle);
	                end = getClipPoint(graph, end, (540 - angle) % 360);
	            } else if (this.extendRay) {
	                end = getClipPoint(graph, start, 360 - angle);
	            }
	
	            var elements = [this.visibleLine];
	            if (!this.fixed) {
	                elements.push(this.mouseTarget);
	            }
	            _.each(elements, function (element) {
	                element.moveTo(start, end);
	            });
	
	            var createArrow = function createArrow(graph, style) {
	                var center = [0.75, 0];
	                var points = [[-3, 4], [-2.75, 2.5], [0, 0.25], center, [0, -0.25], [-2.75, -2.5], [-3, -4]];
	
	                var scale = 1.4;
	                points = _.map(points, function (point) {
	                    var pv = kvector.subtract(point, center);
	                    var pvScaled = kvector.scale(pv, scale);
	                    return kvector.add(center, pvScaled);
	                });
	
	                var createCubicPath = function createCubicPath(points) {
	                    var path = "M" + points[0][0] + " " + points[0][1];
	                    for (var _i2 = 1; _i2 < points.length; _i2 += 3) {
	                        path += "C" + points[_i2][0] + " " + points[_i2][1] + " " + points[_i2 + 1][0] + " " + points[_i2 + 1][1] + " " + points[_i2 + 2][0] + " " + points[_i2 + 2][1];
	                    }
	                    return path;
	                };
	
	                var unscaledPoints = _.map(points, graph.unscalePoint);
	                var options = {
	                    center: graph.unscalePoint(center),
	                    createPath: createCubicPath
	                };
	                var arrowHead = new WrappedPath(graph, unscaledPoints, options);
	                arrowHead.attr(_.extend({
	                    "stroke-linejoin": "round",
	                    "stroke-linecap": "round",
	                    "stroke-dasharray": ""
	                }, style));
	
	                // Add custom function for transforming arrowheads that
	                // accounts for center, scaling, etc.
	                arrowHead.toCoordAtAngle = function (coord, angle) {
	                    var clipPoint = graph.scalePoint(getClipPoint(graph, coord, angle));
	                    var do3dTransform = getCanUse3dTransform();
	                    arrowHead.transform("translateX(" + (clipPoint[0] + scale * center[0]) + "px) " + "translateY(" + (clipPoint[1] + scale * center[1]) + "px) " + (do3dTransform ? "translateZ(0) " : "") + "rotate(" + (360 - KhanMath.bound(angle)) + "deg)");
	                };
	
	                return arrowHead;
	            };
	
	            // Add arrows
	            if (this._arrows == null) {
	                this._arrows = [];
	
	                if (this.extendLine) {
	                    this._arrows.push(createArrow(graph, this.normalStyle));
	                    this._arrows.push(createArrow(graph, this.normalStyle));
	                } else if (this.extendRay) {
	                    this._arrows.push(createArrow(graph, this.normalStyle));
	                }
	            }
	
	            var coordForArrow = [this.coordA, this.coordZ];
	            var angleForArrow = [360 - angle, (540 - angle) % 360];
	            _.each(this._arrows, function (arrow, i) {
	                arrow.toCoordAtAngle(coordForArrow[i], angleForArrow[i]);
	            });
	
	            // Temporary objects: array of SVG nodes that get recreated on drag
	            _.invoke(this.temp, "remove");
	            this.temp = [];
	
	            var isClockwise = this.coordA[0] < this.coordZ[0] || this.coordA[0] === this.coordZ[0] && this.coordA[1] > this.coordZ[1];
	
	            // Update side label
	            if (this.sideLabel) {
	                this.temp.push(this.graph.labelSide({
	                    point1: this.coordA,
	                    point2: this.coordZ,
	                    label: this.labeledSide,
	                    text: this.sideLabel,
	                    numArrows: this.numArrows,
	                    numTicks: this.numTicks,
	                    clockwise: isClockwise,
	                    style: this.labelStyle
	                }));
	            }
	
	            // Update vertex labels
	            if (this.vertexLabels.length) {
	                this.graph.labelVertex({
	                    vertex: this.coordA,
	                    point3: this.coordZ,
	                    label: this.labeledVertices[0],
	                    text: this.vertexLabels[0],
	                    clockwise: isClockwise,
	                    style: this.labelStyle
	                });
	
	                this.graph.labelVertex({
	                    point1: this.coordA,
	                    vertex: this.coordZ,
	                    label: this.labeledVertices[1],
	                    text: this.vertexLabels[1],
	                    clockwise: isClockwise,
	                    style: this.labelStyle
	                });
	            }
	
	            this.temp = _.flatten(this.temp);
	        };
	
	        // Change z-order to back;
	        lineSegment.toBack = function () {
	            if (!lineSegment.fixed) {
	                lineSegment.mouseTarget.toBack();
	            }
	            lineSegment.visibleLine.toBack();
	        };
	
	        // Change z-order to front
	        lineSegment.toFront = function () {
	            if (!lineSegment.fixed) {
	                lineSegment.mouseTarget.toFront();
	            }
	            lineSegment.visibleLine.toFront();
	        };
	
	        lineSegment.remove = function () {
	            if (!lineSegment.fixed) {
	                lineSegment.mouseTarget.remove();
	            }
	            lineSegment.visibleLine.remove();
	            if (lineSegment.labeledSide) {
	                lineSegment.labeledSide.remove();
	            }
	            if (lineSegment.labeledVertices) {
	                _.invoke(lineSegment.labeledVertices, "remove");
	            }
	            if (lineSegment._arrows) {
	                _.invoke(lineSegment._arrows, "remove");
	            }
	            if (lineSegment.temp.length) {
	                _.invoke(lineSegment.temp, "remove");
	            }
	        };
	
	        lineSegment.hide = function () {
	            lineSegment.visibleLine.hide();
	            if (lineSegment.temp.length) {
	                _.invoke(lineSegment.temp, "hide");
	            }
	            if (lineSegment._arrows) {
	                _.invoke(lineSegment._arrows, "hide");
	            }
	        };
	
	        lineSegment.show = function () {
	            lineSegment.visibleLine.show();
	            if (lineSegment.temp.length) {
	                _.invoke(lineSegment.temp, "show");
	            }
	            if (lineSegment._arrows) {
	                _.invoke(lineSegment._arrows, "show");
	            }
	        };
	
	        if (lineSegment.sideLabel) {
	            lineSegment.labeledSide = this.label([0, 0], "", "center", lineSegment.labelStyle);
	        }
	
	        if (lineSegment.vertexLabels.length) {
	            lineSegment.labeledVertices = _.map(lineSegment.vertexLabels, function (label) {
	                return this.label([0, 0], "", "center", lineSegment.labelStyle);
	            }, this);
	        }
	
	        if (!lineSegment.fixed && !lineSegment.constraints.fixed) {
	            var $mouseTarget = $(lineSegment.mouseTarget.getMouseTarget());
	            $mouseTarget.css("cursor", "move");
	            $mouseTarget.bind("vmousedown vmouseover vmouseout", function (event) {
	                if (event.type === "vmouseover") {
	                    if (!dragging) {
	                        lineSegment.highlight = true;
	                        lineSegment.visibleLine.animate(lineSegment.highlightStyle, 50);
	                        lineSegment.arrowStyle = _.extend({}, lineSegment.arrowStyle, {
	                            color: lineSegment.highlightStyle.stroke,
	                            stroke: lineSegment.highlightStyle.stroke
	                        });
	                        lineSegment.transform();
	                    }
	                } else if (event.type === "vmouseout") {
	                    lineSegment.highlight = false;
	                    if (!lineSegment.dragging) {
	                        lineSegment.visibleLine.animate(lineSegment.normalStyle, 50);
	                        lineSegment.arrowStyle = _.extend({}, lineSegment.arrowStyle, {
	                            color: lineSegment.normalStyle.stroke,
	                            stroke: lineSegment.normalStyle.stroke
	                        });
	                        lineSegment.transform();
	                    }
	                } else if (event.type === "vmousedown" && (event.which === 1 || event.which === 0)) {
	                    event.preventDefault();
	                    var coordX = (event.pageX - $(graph.raphael.canvas.parentNode).offset().left) / graph.scale[0] + graph.range[0][0];
	                    var coordY = graph.range[1][1] - (event.pageY - $(graph.raphael.canvas.parentNode).offset().top) / graph.scale[1];
	                    if (lineSegment.snapX > 0) {
	                        coordX = Math.round(coordX / lineSegment.snapX) * lineSegment.snapX;
	                    }
	                    if (lineSegment.snapY > 0) {
	                        coordY = Math.round(coordY / lineSegment.snapY) * lineSegment.snapY;
	                    }
	                    var mouseOffsetA = [lineSegment.coordA[0] - coordX, lineSegment.coordA[1] - coordY];
	                    var mouseOffsetZ = [lineSegment.coordZ[0] - coordX, lineSegment.coordZ[1] - coordY];
	
	                    var offsetLeft = -Math.min(graph.scaleVector(mouseOffsetA)[0], graph.scaleVector(mouseOffsetZ)[0]);
	                    var offsetRight = Math.max(graph.scaleVector(mouseOffsetA)[0], graph.scaleVector(mouseOffsetZ)[0]);
	                    var offsetTop = Math.max(graph.scaleVector(mouseOffsetA)[1], graph.scaleVector(mouseOffsetZ)[1]);
	                    var offsetBottom = -Math.min(graph.scaleVector(mouseOffsetA)[1], graph.scaleVector(mouseOffsetZ)[1]);
	
	                    $(document).bind("vmousemove.lineSegment vmouseup.lineSegment", function (event) {
	                        event.preventDefault();
	                        lineSegment.dragging = true;
	                        dragging = true;
	
	                        var mouseX = event.pageX - $(graph.raphael.canvas.parentNode).offset().left;
	                        var mouseY = event.pageY - $(graph.raphael.canvas.parentNode).offset().top;
	                        // no part of the line segment can go beyond 10
	                        // pixels from the edge
	                        mouseX = Math.max(offsetLeft + 10, Math.min(graph.xpixels - 10 - offsetRight, mouseX));
	                        mouseY = Math.max(offsetTop + 10, Math.min(graph.ypixels - 10 - offsetBottom, mouseY));
	
	                        var coordX = mouseX / graph.scale[0] + graph.range[0][0];
	                        var coordY = graph.range[1][1] - mouseY / graph.scale[1];
	                        if (lineSegment.snapX > 0) {
	                            coordX = Math.round(coordX / lineSegment.snapX) * lineSegment.snapX;
	                        }
	                        if (lineSegment.snapY > 0) {
	                            coordY = Math.round(coordY / lineSegment.snapY) * lineSegment.snapY;
	                        }
	
	                        if (event.type === "vmousemove") {
	                            if (lineSegment.constraints.constrainX) {
	                                coordX = lineSegment.coordA[0] - mouseOffsetA[0];
	                            }
	                            if (lineSegment.constraints.constrainY) {
	                                coordY = lineSegment.coordA[1] - mouseOffsetA[1];
	                            }
	                            var dX = coordX + mouseOffsetA[0] - lineSegment.coordA[0];
	                            var dY = coordY + mouseOffsetA[1] - lineSegment.coordA[1];
	                            lineSegment.coordA = [coordX + mouseOffsetA[0], coordY + mouseOffsetA[1]];
	                            lineSegment.coordZ = [coordX + mouseOffsetZ[0], coordY + mouseOffsetZ[1]];
	                            lineSegment.transform();
	
	                            if (lineSegment.movePointsWithLine) {
	                                // If the points are movablePoints, adjust
	                                // their coordinates when the line itself is
	                                // dragged
	                                if (_typeof(lineSegment.pointA) === "object") {
	                                    lineSegment.pointA.setCoord([lineSegment.pointA.coord[0] + dX, lineSegment.pointA.coord[1] + dY]);
	                                }
	                                if (_typeof(lineSegment.pointZ) === "object") {
	                                    lineSegment.pointZ.setCoord([lineSegment.pointZ.coord[0] + dX, lineSegment.pointZ.coord[1] + dY]);
	                                }
	                            }
	
	                            if (_.isFunction(lineSegment.onMove)) {
	                                lineSegment.onMove(dX, dY);
	                            }
	                        } else if (event.type === "vmouseup") {
	                            $(document).unbind(".lineSegment");
	                            lineSegment.dragging = false;
	                            dragging = false;
	                            if (!lineSegment.highlight) {
	                                lineSegment.visibleLine.animate(lineSegment.normalStyle, 50);
	                                lineSegment.arrowStyle = _.extend({}, lineSegment.arrowStyle, {
	                                    color: lineSegment.normalStyle.stroke,
	                                    stroke: lineSegment.normalStyle.stroke
	                                });
	                                lineSegment.transform();
	                            }
	                            if (_.isFunction(lineSegment.onMoveEnd)) {
	                                lineSegment.onMoveEnd();
	                            }
	                        }
	
	                        $(lineSegment).trigger("move");
	                    });
	                }
	            });
	        }
	
	        if (lineSegment.pointA !== undefined) {
	            lineSegment.pointA.toFront();
	        }
	        if (lineSegment.pointZ !== undefined) {
	            lineSegment.pointZ.toFront();
	        }
	        lineSegment.transform();
	        return lineSegment;
	    },
	
	    // MovablePolygon is a polygon that can be dragged around the screen.
	    // By attaching a smartPoint to each vertex, the points can be
	    // manipulated individually.
	    //
	    // To use with smartPoints, add the smartPoints first, then:
	    //   addMovablePolygon({points: [...]});
	    //
	    // Include "fixed: true" in the options if you don't want the entire
	    // polygon to be draggable (you can still use points to make the
	    // vertices draggable)
	    //
	    // The returned object includes the following properties/methods:
	    //
	    //   - polygon.points
	    //         The polygon's dynamic smartPoints and static coordinates, mixed.
	    //
	    //   - polygon.coords
	    //         The polygon's current coordinates (generated, don't edit).
	    //
	    //   - polygon.transform()
	    //         Repositions the polygon. Call after changing any points.
	    //
	    addMovablePolygon: function addMovablePolygon(options) {
	        var graphie = this;
	
	        var polygon = $.extend({
	            snapX: 0,
	            snapY: 0,
	            fixed: false,
	            constrainToGraph: true,
	            normalStyle: {},
	            highlightStyle: {
	                stroke: KhanColors.INTERACTING,
	                "stroke-width": 2,
	                fill: KhanColors.INTERACTING,
	                "fill-opacity": 0.05
	            },
	            pointHighlightStyle: {
	                fill: KhanColors.INTERACTING,
	                stroke: KhanColors.INTERACTING
	            },
	            labelStyle: {
	                stroke: KhanColors.DYNAMIC,
	                "stroke-width": 1,
	                color: KhanColors.DYNAMIC
	            },
	            angleLabels: [],
	            showRightAngleMarkers: [],
	            sideLabels: [],
	            vertexLabels: [],
	            numArcs: [],
	            numArrows: [],
	            numTicks: [],
	            updateOnPointMove: true,
	            closed: true
	        }, _.omit(options, "points"));
	
	        var normalColor = polygon.fixed ? KhanColors.DYNAMIC : KhanColors.INTERACTIVE;
	        polygon.normalStyle = _.extend({
	            "stroke-width": 2,
	            "fill-opacity": 0,
	            fill: normalColor,
	            stroke: normalColor
	        }, options.normalStyle);
	
	        // don't deep copy the points array with $.extend;
	        // we may want to append to it later for click-to-add-points
	        polygon.points = options.points;
	
	        var isPoint = function isPoint(coordOrPoint) {
	            return !_.isArray(coordOrPoint);
	        };
	
	        polygon.update = function () {
	            var n = polygon.points.length;
	
	            // Update coords
	            polygon.coords = _.map(polygon.points, function (coordOrPoint, i) {
	                if (isPoint(coordOrPoint)) {
	                    return coordOrPoint.coord;
	                } else {
	                    return coordOrPoint;
	                }
	            });
	
	            // Calculate bounding box
	            polygon.left = _.min(_.pluck(polygon.coords, 0));
	            polygon.right = _.max(_.pluck(polygon.coords, 0));
	            polygon.top = _.max(_.pluck(polygon.coords, 1));
	            polygon.bottom = _.min(_.pluck(polygon.coords, 1));
	
	            var scaledCoords = _.map(polygon.coords, function (coord) {
	                return graphie.scalePoint(coord);
	            });
	
	            // Create path
	            if (polygon.closed) {
	                scaledCoords.push(true);
	            } else {
	                // For open polygons, concatenate a reverse of the path,
	                // to remove the inside area of the path, which would
	                // otherwise be clickable (even if the closing line segment
	                // wasn't drawn
	                scaledCoords = scaledCoords.concat(_.clone(scaledCoords).reverse());
	            }
	            polygon.path = GraphUtils.unscaledSvgPath(scaledCoords);
	
	            // Temporary objects
	            _.invoke(polygon.temp, "remove");
	            polygon.temp = [];
	
	            var isClockwise = clockwise(polygon.coords);
	
	            // Update angle labels
	            if (polygon.angleLabels.length || polygon.showRightAngleMarkers.length) {
	                _.each(polygon.labeledAngles, function (label, i) {
	                    polygon.temp.push(graphie.labelAngle({
	                        point1: polygon.coords[(i - 1 + n) % n],
	                        vertex: polygon.coords[i],
	                        point3: polygon.coords[(i + 1) % n],
	                        label: label,
	                        text: polygon.angleLabels[i],
	                        showRightAngleMarker: polygon.showRightAngleMarkers[i],
	                        numArcs: polygon.numArcs[i],
	                        clockwise: isClockwise,
	                        style: polygon.labelStyle
	                    }));
	                });
	            }
	
	            // Update side labels
	            if (polygon.sideLabels.length) {
	                _.each(polygon.labeledSides, function (label, i) {
	                    polygon.temp.push(graphie.labelSide({
	                        point1: polygon.coords[i],
	                        point2: polygon.coords[(i + 1) % n],
	                        label: label,
	                        text: polygon.sideLabels[i],
	                        numArrows: polygon.numArrows[i],
	                        numTicks: polygon.numTicks[i],
	                        clockwise: isClockwise,
	                        style: polygon.labelStyle
	                    }));
	                });
	            }
	
	            // Update vertex labels
	            if (polygon.vertexLabels.length) {
	                _.each(polygon.labeledVertices, function (label, i) {
	                    graphie.labelVertex({
	                        point1: polygon.coords[(i - 1 + n) % n],
	                        vertex: polygon.coords[i],
	                        point3: polygon.coords[(i + 1) % n],
	                        label: label,
	                        text: polygon.vertexLabels[i],
	                        clockwise: isClockwise,
	                        style: polygon.labelStyle
	                    });
	                });
	            }
	
	            polygon.temp = _.flatten(polygon.temp);
	        };
	
	        polygon.transform = function () {
	            polygon.update();
	
	            polygon.visibleShape.attr({ path: polygon.path });
	
	            if (!polygon.fixed) {
	                polygon.mouseTarget.attr({ path: polygon.path });
	            }
	        };
	
	        polygon.remove = function () {
	            polygon.visibleShape.remove();
	
	            if (!polygon.fixed) {
	                polygon.mouseTarget.remove();
	            }
	
	            if (polygon.labeledAngles) {
	                _.invoke(polygon.labeledAngles, "remove");
	            }
	
	            if (polygon.labeledSides) {
	                _.invoke(polygon.labeledSides, "remove");
	            }
	
	            if (polygon.labeledVertices) {
	                _.invoke(polygon.labeledVertices, "remove");
	            }
	
	            if (polygon.temp.length) {
	                _.invoke(polygon.temp, "remove");
	            }
	        };
	
	        polygon.toBack = function () {
	            if (!polygon.fixed) {
	                polygon.mouseTarget.toBack();
	            }
	
	            polygon.visibleShape.toBack();
	        };
	
	        polygon.toFront = function () {
	            if (!polygon.fixed) {
	                polygon.mouseTarget.toFront();
	            }
	
	            polygon.visibleShape.toFront();
	        };
	
	        // Setup
	
	        if (polygon.updateOnPointMove) {
	            _.each(_.filter(polygon.points, isPoint), function (coordOrPoint) {
	                coordOrPoint.polygonVertices.push(polygon);
	            });
	        }
	
	        polygon.coords = new Array(polygon.points.length);
	
	        if (polygon.angleLabels.length) {
	            var numLabels = Math.max(polygon.angleLabels.length, polygon.showRightAngleMarkers.length);
	            polygon.labeledAngles = _.times(numLabels, function () {
	                return this.label([0, 0], "", "center", polygon.labelStyle);
	            }, this);
	        }
	
	        if (polygon.sideLabels.length) {
	            polygon.labeledSides = _.map(polygon.sideLabels, function (label) {
	                return this.label([0, 0], "", "center", polygon.labelStyle);
	            }, this);
	        }
	
	        if (polygon.vertexLabels.length) {
	            polygon.labeledVertices = _.map(polygon.vertexLabels, function (label) {
	                return this.label([0, 0], "", "center", polygon.labelStyle);
	            }, this);
	        }
	
	        polygon.update();
	
	        polygon.visibleShape = graphie.raphael.path(polygon.path);
	        polygon.visibleShape.attr(polygon.normalStyle);
	
	        if (!polygon.fixed) {
	            polygon.mouseTarget = graphie.mouselayer.path(polygon.path);
	            polygon.mouseTarget.attr({
	                fill: "#000",
	                opacity: 0,
	                cursor: "move"
	            });
	
	            $(polygon.mouseTarget[0]).bind("vmousedown vmouseover vmouseout", function (event) {
	                if (event.type === "vmouseover") {
	                    if (!dragging || polygon.dragging) {
	                        polygon.highlight = true;
	                        polygon.visibleShape.animate(polygon.highlightStyle, 50);
	                        _.each(_.filter(polygon.points, isPoint), function (point) {
	                            point.visibleShape.animate(polygon.pointHighlightStyle, 50);
	                        });
	                    }
	                } else if (event.type === "vmouseout") {
	                    polygon.highlight = false;
	                    if (!polygon.dragging) {
	                        polygon.visibleShape.animate(polygon.normalStyle, 50);
	                        var points = _.filter(polygon.points, isPoint);
	                        if (!_.any(_.pluck(points, "dragging"))) {
	                            _.each(points, function (point) {
	                                point.visibleShape.animate(point.normalStyle, 50);
	                            });
	                        }
	                    }
	                } else if (event.type === "vmousedown" && (event.which === 1 || event.which === 0)) {
	                    event.preventDefault();
	
	                    _.each(_.filter(polygon.points, isPoint), function (point) {
	                        point.dragging = true;
	                    });
	
	                    var startX = (event.pageX - $(graphie.raphael.canvas.parentNode).offset().left) / graphie.scale[0] + graphie.range[0][0];
	                    var startY = graphie.range[1][1] - (event.pageY - $(graphie.raphael.canvas.parentNode).offset().top) / graphie.scale[1];
	                    if (polygon.snapX > 0) {
	                        startX = Math.round(startX / polygon.snapX) * polygon.snapX;
	                    }
	                    if (polygon.snapY > 0) {
	                        startY = Math.round(startY / polygon.snapY) * polygon.snapY;
	                    }
	                    var lastX = startX;
	                    var lastY = startY;
	
	                    var polygonCoords = polygon.coords.slice();
	
	                    var offsetLeft = (startX - polygon.left) * graphie.scale[0];
	                    var offsetRight = (polygon.right - startX) * graphie.scale[0];
	                    var offsetTop = (polygon.top - startY) * graphie.scale[1];
	                    var offsetBottom = (startY - polygon.bottom) * graphie.scale[1];
	
	                    $(document).bind("vmousemove.polygon vmouseup.polygon", function (event) {
	                        event.preventDefault();
	
	                        polygon.dragging = true;
	                        dragging = true;
	
	                        var mouseX = event.pageX - $(graphie.raphael.canvas.parentNode).offset().left;
	                        var mouseY = event.pageY - $(graphie.raphael.canvas.parentNode).offset().top;
	
	                        // no part of the polygon can go beyond 10 pixels from
	                        // the edge
	                        if (polygon.constrainToGraph) {
	                            mouseX = Math.max(offsetLeft + 10, Math.min(graphie.xpixels - 10 - offsetRight, mouseX));
	                            mouseY = Math.max(offsetTop + 10, Math.min(graphie.ypixels - 10 - offsetBottom, mouseY));
	                        }
	
	                        var currentX = mouseX / graphie.scale[0] + graphie.range[0][0];
	                        var currentY = graphie.range[1][1] - mouseY / graphie.scale[1];
	                        if (polygon.snapX > 0) {
	                            currentX = Math.round(currentX / polygon.snapX) * polygon.snapX;
	                        }
	                        if (polygon.snapY > 0) {
	                            currentY = Math.round(currentY / polygon.snapY) * polygon.snapY;
	                        }
	
	                        if (event.type === "vmousemove") {
	                            var dX = currentX - startX;
	                            var dY = currentY - startY;
	
	                            var doMove = true;
	                            if (_.isFunction(polygon.onMove)) {
	                                var onMoveResult = polygon.onMove(dX, dY);
	                                if (onMoveResult === false) {
	                                    doMove = false;
	                                } else if (_.isArray(onMoveResult)) {
	                                    dX = onMoveResult[0];
	                                    dY = onMoveResult[1];
	                                    currentX = startX + dX;
	                                    currentY = startY + dY;
	                                }
	                            }
	
	                            var increment = function increment(i) {
	                                return [polygonCoords[i][0] + dX, polygonCoords[i][1] + dY];
	                            };
	
	                            if (doMove) {
	                                _.each(polygon.points, function (coordOrPoint, i) {
	                                    if (isPoint(coordOrPoint)) {
	                                        coordOrPoint.setCoord(increment(i));
	                                    } else {
	                                        polygon.points[i] = increment(i);
	                                    }
	                                });
	
	                                polygon.transform();
	
	                                $(polygon).trigger("move");
	
	                                lastX = currentX;
	                                lastY = currentY;
	                            }
	                        } else if (event.type === "vmouseup") {
	                            $(document).unbind(".polygon");
	
	                            var _points = _.filter(polygon.points, isPoint);
	                            _.each(_points, function (point) {
	                                point.dragging = false;
	                            });
	
	                            polygon.dragging = false;
	                            dragging = false;
	                            if (!polygon.highlight) {
	                                polygon.visibleShape.animate(polygon.normalStyle, 50);
	
	                                _.each(_points, function (point) {
	                                    point.visibleShape.animate(point.normalStyle, 50);
	                                });
	                            }
	                            if (_.isFunction(polygon.onMoveEnd)) {
	                                polygon.onMoveEnd(lastX - startX, lastY - startY);
	                            }
	                        }
	                    });
	                }
	            });
	        }
	
	        // Bring any movable points to the front
	        _.invoke(_.filter(polygon.points, isPoint), "toFront");
	
	        return polygon;
	    },
	
	    /**
	     * Constrain a point to be within the graph (including padding).
	     * If outside graph, point's x and y coordinates are clamped within
	     * the graph.
	     */
	    constrainToBounds: function constrainToBounds(point, padding) {
	        var lower = this.unscalePoint([padding, this.ypixels - padding]);
	        var upper = this.unscalePoint([this.xpixels - padding, padding]);
	        var coordX = Math.max(lower[0], Math.min(upper[0], point[0]));
	        var coordY = Math.max(lower[1], Math.min(upper[1], point[1]));
	        return [coordX, coordY];
	    },
	
	    /**
	     * Constrain a point to be within the graph (including padding).
	     * If outside graph, point is moved along the ray specified by angle
	     * until inside graph.
	     */
	    constrainToBoundsOnAngle: function constrainToBoundsOnAngle(point, padding, angle) {
	        var lower = this.unscalePoint([padding, this.ypixels - padding]);
	        var upper = this.unscalePoint([this.xpixels - padding, padding]);
	
	        var result = point.slice();
	
	        if (result[0] < lower[0]) {
	            result = [lower[0], result[1] + (lower[0] - result[0]) * Math.tan(angle)];
	        } else if (result[0] > upper[0]) {
	            result = [upper[0], result[1] - (result[0] - upper[0]) * Math.tan(angle)];
	        }
	
	        if (result[1] < lower[1]) {
	            result = [result[0] + (lower[1] - result[1]) / Math.tan(angle), lower[1]];
	        } else if (result[1] > upper[1]) {
	            result = [result[0] - (result[1] - upper[1]) / Math.tan(angle), upper[1]];
	        }
	
	        return result;
	    },
	
	    // MovableAngle is an angle that can be dragged around the screen.
	    // By attaching a smartPoint to the vertex and ray control points, the
	    // rays can be manipulated individually.
	    //
	    // Use only with smartPoints; add the smartPoints first, then:
	    //   addMovableAngle({points: [...]});
	    //
	    // The rays can be controlled to snap on degrees (more useful than snapping
	    // on coordinates) by setting snapDegrees to a positive integer.
	    //
	    // The returned object includes the following properties/methods:
	    //
	    //   - movableAngle.points
	    //         The movableAngle's dynamic smartPoints.
	    //
	    //   - movableAngle.coords
	    //         The movableAngle's current coordinates (generated, don't edit).
	    //
	    addMovableAngle: function addMovableAngle(options) {
	        return new MovableAngle(this, options);
	    },
	
	    // center: movable point
	    // radius: int
	    // circ: graphie circle
	    // perim: invisible mouse target for dragging/changing radius
	    addCircleGraph: function addCircleGraph(options) {
	        var _this = this;
	
	        var graphie = this;
	        var circle = $.extend({
	            center: [0, 0],
	            radius: 2,
	            snapX: 0.5,
	            snapY: 0.5,
	            snapRadius: 0.5,
	            minRadius: 1,
	            centerConstraints: {},
	            centerNormalStyle: {},
	            centerHighlightStyle: {
	                stroke: KhanColors.INTERACTING,
	                fill: KhanColors.INTERACTING
	            },
	            circleNormalStyle: {
	                stroke: KhanColors.INTERACTIVE,
	                "fill-opacity": 0
	            },
	            circleHighlightStyle: {
	                stroke: KhanColors.INTERACTING,
	                fill: KhanColors.INTERACTING,
	                "fill-opacity": 0.05
	            }
	        }, options);
	
	        var normalColor = circle.centerConstraints.fixed ? KhanColors.DYNAMIC : KhanColors.INTERACTIVE;
	        var centerNormalStyle = options ? options.centerNormalStyle : null;
	        circle.centerNormalStyle = _.extend({}, {
	            fill: normalColor,
	            stroke: normalColor
	        }, centerNormalStyle);
	
	        circle.centerPoint = graphie.addMovablePoint({
	            graph: graphie,
	            coord: circle.center,
	            normalStyle: circle.centerNormalStyle,
	            snapX: circle.snapX,
	            snapY: circle.snapY,
	            constraints: circle.centerConstraints
	        });
	        circle.circ = graphie.circle(circle.center, circle.radius, circle.circleNormalStyle);
	        circle.perim = graphie.mouselayer.circle(graphie.scalePoint(circle.center)[0], graphie.scalePoint(circle.center)[1], graphie.scaleVector(circle.radius)[0]).attr({
	            "stroke-width": 20,
	            opacity: 0.002 // This is as close to 0 as MSIE will allow
	        });
	
	        // Highlight circle circumference on center point hover
	        if (!circle.centerConstraints.fixed) {
	            $(circle.centerPoint.mouseTarget.getMouseTarget()).on("vmouseover vmouseout", function (event) {
	                if (circle.centerPoint.highlight || circle.centerPoint.dragging) {
	                    circle.circ.animate(circle.circleHighlightStyle, 50);
	                } else {
	                    circle.circ.animate(circle.circleNormalStyle, 50);
	                }
	            });
	        }
	
	        circle.toFront = function () {
	            circle.circ.toFront();
	            circle.perim.toFront();
	            circle.centerPoint.visibleShape.toFront();
	            if (!circle.centerConstraints.fixed) {
	                circle.centerPoint.mouseTarget.toFront();
	            }
	        };
	
	        circle.centerPoint.onMove = function (x, y) {
	            circle.toFront();
	            circle.circ.attr({
	                cx: graphie.scalePoint(x)[0],
	                cy: graphie.scalePoint(y)[1]
	            });
	            circle.perim.attr({
	                cx: graphie.scalePoint(x)[0],
	                cy: graphie.scalePoint(y)[1]
	            });
	            if (circle.onMove) {
	                circle.onMove(x, y);
	            }
	        };
	
	        $(circle.centerPoint).on("move", function () {
	            circle.center = this.coord;
	            $(circle).trigger("move");
	        });
	
	        // circle.setCenter(x, y) moves the circle to the specified
	        // x, y coordinate as if the user had dragged it there.
	        circle.setCenter = function (x, y) {
	            circle.centerPoint.setCoord([x, y]);
	            circle.centerPoint.onMove(x, y);
	            circle.center = [x, y];
	        };
	
	        // circle.setRadius(r) sets the circle's radius to the specified
	        // value as if the user had dragged it there.
	        circle.setRadius = function (r) {
	            circle.radius = r;
	
	            circle.perim.attr({
	                r: graphie.scaleVector(r)[0]
	            });
	            circle.circ.attr({
	                rx: graphie.scaleVector(r)[0],
	                ry: graphie.scaleVector(r)[1]
	            });
	        };
	
	        circle.remove = function () {
	            circle.centerPoint.remove();
	            circle.circ.remove();
	            circle.perim.remove();
	        };
	
	        // Define a set of axes using polar coordinates to specify
	        // which resizing cursor we want to show based on where the
	        // mouse position lies in relation to the circle's center.
	        // The first two columns in cursorAxes refer to the minimum
	        // and maximum angle values bounding a circle sector, and
	        // the third column refers to the cursor name that will be
	        // applied if the mouse position falls inside the given sector.
	        var cursorAxes = [[Math.PI * -1.0, Math.PI * -0.875, "ew-resize"], [Math.PI * -0.875, Math.PI * -0.625, "nesw-resize"], [Math.PI * -0.625, Math.PI * -0.375, "ns-resize"], [Math.PI * -0.375, Math.PI * -0.125, "nwse-resize"], [Math.PI * -0.125, Math.PI * 0.125, "ew-resize"], [Math.PI * 0.125, Math.PI * 0.375, "nesw-resize"], [Math.PI * 0.375, Math.PI * 0.625, "ns-resize"], [Math.PI * 0.625, Math.PI * 0.875, "nwse-resize"], [Math.PI * 0.875, Math.PI * 1.0, "ew-resize"]];
	
	        // When the mouse moves along the circle's perimeter, we
	        // dynamically set a CSS rule to show the correct
	        // bidirectional cursor so a student knows they can resize
	        // our circle. To do this, we convert the x and y coordinates
	        // of the mouse position into polar coordinates and use the
	        // defined cursorAxes above to set our rule.
	        $(circle.perim.node).on("vmousemove", function (event) {
	            var _getMouseCoord = _this.getMouseCoord(event),
	                x = _getMouseCoord[0],
	                y = _getMouseCoord[1];
	
	            x -= circle.center[0];
	            y -= circle.center[1];
	
	            var theta = Math.atan2(y, x);
	
	            cursorAxes.forEach(function (axes) {
	                var min = axes[0],
	                    max = axes[1],
	                    cursorName = axes[2];
	
	                if (theta >= min && theta < max) {
	                    $(circle.perim.node).css("cursor", cursorName);
	                }
	            });
	        });
	
	        // Set a default resizing-friendly cursor to be safe.
	        $(circle.perim.node).css("cursor", "nesw-resize");
	
	        // Prevent the page from scrolling when we grab and drag the circle on
	        // a mobile device.
	        circle.perim.node.addEventListener("touchstart", function (event) {
	            event.preventDefault();
	        }, { passive: false });
	
	        $(circle.perim.node).on("vmouseover vmouseout vmousedown", function (event) {
	            if (event.type === "vmouseover") {
	                circle.highlight = true;
	                if (!dragging) {
	                    // TODO(jack): Figure out why this doesn't work
	                    // for circleHighlightStyle's that change
	                    // stroke-dasharray
	                    circle.circ.animate(circle.circleHighlightStyle, 50);
	                    circle.centerPoint.visibleShape.animate(circle.centerHighlightStyle, 50);
	                }
	            } else if (event.type === "vmouseout") {
	                circle.highlight = false;
	                if (!circle.dragging && !circle.centerPoint.dragging) {
	                    circle.circ.animate(circle.circleNormalStyle, 50);
	                    circle.centerPoint.visibleShape.animate(circle.centerNormalStyle, 50);
	                }
	            } else if (event.type === "vmousedown" && (event.which === 1 || event.which === 0)) {
	                event.preventDefault();
	                circle.toFront();
	                var startRadius = circle.radius;
	
	                $(document).on("vmousemove vmouseup", function (event) {
	                    event.preventDefault();
	                    circle.dragging = true;
	                    dragging = true;
	
	                    if (event.type === "vmousemove") {
	                        var coord = graphie.constrainToBounds(graphie.getMouseCoord(event), 10);
	
	                        var radius = GraphUtils.getDistance(circle.centerPoint.coord, coord);
	                        radius = Math.max(circle.minRadius, Math.round(radius / circle.snapRadius) * circle.snapRadius);
	                        var oldRadius = circle.radius;
	                        var doResize = true;
	                        if (circle.onResize) {
	                            var onResizeResult = circle.onResize(radius, oldRadius);
	                            if (_.isNumber(onResizeResult)) {
	                                radius = onResizeResult;
	                            } else if (onResizeResult === false) {
	                                doResize = false;
	                            }
	                        }
	                        if (doResize) {
	                            circle.setRadius(radius);
	                            $(circle).trigger("move");
	                        }
	                    } else if (event.type === "vmouseup") {
	                        $(document).off("vmousemove vmouseup");
	                        circle.dragging = false;
	                        dragging = false;
	                        if (circle.onResizeEnd) {
	                            circle.onResizeEnd(circle.radius, startRadius);
	                        }
	                    }
	                });
	            }
	        });
	
	        return circle;
	    },
	
	    addRotateHandle: function () {
	        var drawRotateHandle = function drawRotateHandle(graphie, center, radius, halfWidth, lengthAngle, angle, interacting) {
	            var getRotateHandlePoint = function getRotateHandlePoint(offset, distanceFromArrowMidline) {
	                var distFromRotationCenter = radius + distanceFromArrowMidline;
	                var vec = kvector.cartFromPolarDeg([distFromRotationCenter, angle + offset]);
	                var absolute = kvector.add(center, vec);
	                var pixels = graphie.scalePoint(absolute);
	                return pixels[0] + "," + pixels[1];
	            };
	
	            var innerR = graphie.scaleVector(radius - halfWidth);
	            var outerR = graphie.scaleVector(radius + halfWidth);
	
	            // Draw the double-headed arrow thing that shows users where to
	            // click and drag to rotate
	            return graphie.raphael.path(
	            // upper arrowhead
	            " M" + getRotateHandlePoint(lengthAngle, -halfWidth) + " L" + getRotateHandlePoint(lengthAngle, -3 * halfWidth) + " L" + getRotateHandlePoint(2 * lengthAngle, 0) + " L" + getRotateHandlePoint(lengthAngle, 3 * halfWidth) + " L" + getRotateHandlePoint(lengthAngle, halfWidth) +
	            // outer arc
	            " A" + outerR[0] + "," + outerR[1] + ",0,0,1," + getRotateHandlePoint(-lengthAngle, halfWidth) +
	            // lower arrowhead
	            " L" + getRotateHandlePoint(-lengthAngle, 3 * halfWidth) + " L" + getRotateHandlePoint(-2 * lengthAngle, 0) + " L" + getRotateHandlePoint(-lengthAngle, -3 * halfWidth) + " L" + getRotateHandlePoint(-lengthAngle, -halfWidth) +
	            // inner arc
	            " A" + innerR[0] + "," + innerR[1] + ",0,0,0," + getRotateHandlePoint(lengthAngle, -halfWidth) + " Z").attr({
	                stroke: null,
	                fill: interacting ? KhanColors.INTERACTING : KhanColors.INTERACTIVE
	            });
	        };
	
	        return function (options) {
	            var graph = this;
	
	            var rotatePoint = options.center;
	            var radius = options.radius;
	            var lengthAngle = options.lengthAngle || 30;
	            var hideArrow = options.hideArrow || false;
	            var mouseTarget = options.mouseTarget;
	            var id = _.uniqueId("rotateHandle");
	
	            // Normalize rotatePoint into something that always looks
	            // like a movablePoint
	            if (_.isArray(rotatePoint)) {
	                rotatePoint = {
	                    coord: rotatePoint
	                };
	            }
	
	            var rotateHandle = graph.addMovablePoint({
	                coord: kpoint.addVector(rotatePoint.coord, kvector.cartFromPolarDeg(radius, options.angleDeg || 0)),
	                constraints: {
	                    fixedDistance: {
	                        dist: radius,
	                        point: rotatePoint
	                    }
	                },
	                mouseTarget: mouseTarget
	            });
	
	            // move the rotatePoint in front of the rotateHandle to avoid
	            // confusing clicking/scaling of the rotateHandle when the user
	            // intends to click on the rotatePoint
	            rotatePoint.toFront();
	
	            var rotatePointPrevCoord = rotatePoint.coord;
	            var rotateHandlePrevCoord = rotateHandle.coord;
	            var rotateHandleStartCoord = rotateHandlePrevCoord;
	            var isRotating = false;
	            var isHovering = false;
	            var drawnRotateHandle = void 0;
	
	            var redrawRotateHandle = function redrawRotateHandle(handleCoord) {
	                if (hideArrow) {
	                    return; // Don't draw anything!
	                }
	
	                var handleVec = kvector.subtract(handleCoord, rotatePoint.coord);
	                var handlePolar = kvector.polarDegFromCart(handleVec);
	                var angle = handlePolar[1];
	
	                if (drawnRotateHandle) {
	                    drawnRotateHandle.remove();
	                }
	
	                drawnRotateHandle = drawRotateHandle(graph, rotatePoint.coord, options.radius, isRotating || isHovering ? options.hoverWidth / 2 : options.width / 2, lengthAngle, angle, isRotating || isHovering);
	            };
	
	            // when the rotation center moves, we need to move
	            // the rotationHandle as well, or it will end up out
	            // of sync
	            $(rotatePoint).on("move." + id, function () {
	                var delta = kvector.subtract(rotatePoint.coord, rotatePointPrevCoord);
	
	                rotateHandle.setCoord(kvector.add(rotateHandle.coord, delta));
	
	                redrawRotateHandle(rotateHandle.coord);
	
	                rotatePointPrevCoord = rotatePoint.coord;
	                rotateHandle.constraints.fixedDistance.point = rotatePoint;
	                rotateHandlePrevCoord = rotateHandle.coord;
	            });
	
	            // Rotate polygon with rotateHandle
	            rotateHandle.onMove = function (x, y) {
	                if (!isRotating) {
	                    rotateHandleStartCoord = rotateHandlePrevCoord;
	                    isRotating = true;
	                }
	
	                var coord = [x, y];
	
	                if (options.onMove) {
	                    var oldPolar = kvector.polarDegFromCart(kvector.subtract(rotateHandlePrevCoord, rotatePoint.coord));
	                    var newPolar = kvector.polarDegFromCart(kvector.subtract(coord, rotatePoint.coord));
	
	                    var oldAngle = oldPolar[1];
	                    var newAngle = newPolar[1];
	                    var result = options.onMove(newAngle, oldAngle);
	                    if (result != null && result !== true) {
	                        if (result === false) {
	                            result = oldAngle;
	                        }
	                        coord = kvector.add(rotatePoint.coord, kvector.cartFromPolarDeg([oldPolar[0], result]));
	                    }
	                }
	
	                redrawRotateHandle(coord);
	
	                rotateHandlePrevCoord = coord;
	                return coord;
	            };
	
	            rotateHandle.onMoveEnd = function () {
	                isRotating = false;
	                redrawRotateHandle(rotateHandle.coord);
	                if (options.onMoveEnd) {
	                    var oldPolar = kvector.polarDegFromCart(kvector.subtract(rotateHandleStartCoord, rotatePoint.coord));
	                    var newPolar = kvector.polarDegFromCart(kvector.subtract(rotateHandle.coord, rotatePoint.coord));
	                    options.onMoveEnd(newPolar[1], oldPolar[1]);
	                }
	            };
	
	            // Remove the default dot added by the movablePoint since we have
	            // our double-arrow thing
	            rotateHandle.visibleShape.remove();
	
	            if (!mouseTarget) {
	                // Make the default mouse target bigger to encompass the whole
	                // area around the double-arrow thing
	                rotateHandle.mouseTarget.attr({ scale: 2 });
	            }
	
	            var $mouseTarget = $(rotateHandle.mouseTarget.getMouseTarget());
	            $mouseTarget.bind("vmouseover", function (e) {
	                isHovering = true;
	                redrawRotateHandle(rotateHandle.coord);
	            });
	            $mouseTarget.bind("vmouseout", function (e) {
	                isHovering = false;
	                redrawRotateHandle(rotateHandle.coord);
	            });
	
	            redrawRotateHandle(rotateHandle.coord);
	
	            var oldRemove = rotateHandle.remove;
	            rotateHandle.remove = function () {
	                oldRemove.call(rotateHandle);
	                if (drawnRotateHandle) {
	                    drawnRotateHandle.remove();
	                }
	                $(rotatePoint).off("move." + id);
	            };
	
	            rotateHandle.update = function () {
	                redrawRotateHandle(rotateHandle.coord);
	            };
	
	            return rotateHandle;
	        };
	    }(),
	
	    addReflectButton: function () {
	        var drawButton = function drawButton(graphie, buttonCoord, lineCoords, size, distanceFromCenter, leftStyle, rightStyle) {
	            // Avoid invalid lines
	            if (kpoint.equal(lineCoords[0], lineCoords[1])) {
	                lineCoords = [lineCoords[0], kpoint.addVector(lineCoords[0], [1, 1])];
	            }
	
	            var lineDirection = kvector.normalize(kvector.subtract(lineCoords[1], lineCoords[0]));
	
	            var lineVec = kvector.scale(lineDirection, size / 2);
	
	            var centerVec = kvector.scale(lineDirection, distanceFromCenter);
	            var leftCenterVec = kvector.rotateDeg(centerVec, 90);
	            var rightCenterVec = kvector.rotateDeg(centerVec, -90);
	
	            var negLineVec = kvector.negate(lineVec);
	            var leftVec = kvector.rotateDeg(lineVec, 90);
	            var rightVec = kvector.rotateDeg(lineVec, -90);
	
	            var leftCenter = kpoint.addVectors(buttonCoord, leftCenterVec);
	            var rightCenter = kpoint.addVectors(buttonCoord, rightCenterVec);
	
	            var leftCoord1 = kpoint.addVectors(buttonCoord, leftCenterVec, lineVec, leftVec);
	            var leftCoord2 = kpoint.addVectors(buttonCoord, leftCenterVec, negLineVec, leftVec);
	            var rightCoord1 = kpoint.addVectors(buttonCoord, rightCenterVec, lineVec, rightVec);
	            var rightCoord2 = kpoint.addVectors(buttonCoord, rightCenterVec, negLineVec, rightVec);
	
	            var leftButton = graphie.path([leftCenter, leftCoord1, leftCoord2, true], leftStyle);
	            var rightButton = graphie.path([rightCenter, rightCoord1, rightCoord2, true], rightStyle);
	
	            return {
	                remove: function remove() {
	                    leftButton.remove();
	                    rightButton.remove();
	                }
	            };
	        };
	
	        return function (options) {
	            var graphie = this;
	
	            var line = options.line;
	
	            var button = graphie.addMovablePoint({
	                constraints: options.constraints,
	                coord: kline.midpoint([line.pointA.coord, line.pointZ.coord]),
	                snapX: graphie.snap[0],
	                snapY: graphie.snap[1],
	                onMove: function onMove(x, y) {
	                    // Don't allow the button to actually move. This is a hack
	                    // around the inability to both set a point as fixed AND
	                    // allow it to be clicked.
	                    return false;
	                },
	                onMoveEnd: function onMoveEnd(x, y) {
	                    if (options.onMoveEnd) {
	                        options.onMoveEnd.call(this, x, y);
	                    }
	                }
	            });
	
	            var isHovering = false;
	            var isFlipped = false;
	            var currentlyDrawnButton = void 0;
	
	            var isHighlight = function isHighlight() {
	                return isHovering;
	            };
	
	            var styles = _.map([0, 1], function (isHighlight) {
	                var baseStyle = isHighlight ? options.highlightStyle : options.normalStyle;
	
	                return _.map([0, 1], function (opacity) {
	                    return _.defaults({
	                        "fill-opacity": opacity
	                    }, baseStyle);
	                });
	            });
	
	            var getStyle = function getStyle(isRight) {
	                if (isFlipped) {
	                    isRight = !isRight;
	                }
	                return styles[+isHighlight()][+isRight];
	            };
	
	            var redraw = function redraw(coord, lineCoords) {
	                if (currentlyDrawnButton) {
	                    currentlyDrawnButton.remove();
	                }
	                currentlyDrawnButton = drawButton(graphie, coord, lineCoords, isHighlight() ? options.size * 1.5 : options.size, isHighlight() ? options.size * 0.125 : 0.25, getStyle(0), getStyle(1));
	            };
	
	            var update = function update(coordA, coordZ) {
	                coordA = coordA || line.pointA.coord;
	                coordZ = coordZ || line.pointZ.coord;
	
	                var buttonCoord = kline.midpoint([coordA, coordZ]);
	                button.setCoord(buttonCoord);
	
	                redraw(buttonCoord, [coordA, coordZ]);
	            };
	
	            $(line).on("move", _.bind(update, button, null, null));
	
	            var $mouseTarget = $(button.mouseTarget.getMouseTarget());
	            $mouseTarget.on("vclick", function () {
	                var result = options.onClick();
	                if (result !== false) {
	                    isFlipped = !isFlipped;
	                    redraw(button.coord, [line.pointA.coord, line.pointZ.coord]);
	                }
	            });
	
	            // Bring the reflection line handles in front of the button, so
	            // that if we drag the reflectPoints really close together, we can
	            // still move the handles away from each other, rather than only
	            // being able to apply the reflection.
	            line.pointA.toFront();
	            line.pointZ.toFront();
	
	            // Replace the visual point with the double triangle thing
	            button.visibleShape.remove();
	            var pointScale = graphie.scaleVector(options.size)[0] / 20;
	            button.mouseTarget.attr({ scale: 1.5 * pointScale });
	            $mouseTarget.css("cursor", "pointer");
	
	            // Make the arrow-thing grow and shrink with mouseover/out
	            $mouseTarget.bind("vmouseover", function (e) {
	                isHovering = true;
	                redraw(button.coord, [line.pointA.coord, line.pointZ.coord]);
	            });
	            $mouseTarget.bind("vmouseout", function (e) {
	                isHovering = false;
	                redraw(button.coord, [line.pointA.coord, line.pointZ.coord]);
	            });
	
	            var oldButtonRemove = button.remove;
	            button.remove = function () {
	                currentlyDrawnButton.remove();
	                oldButtonRemove.call(button);
	            };
	
	            button.update = update;
	            button.isFlipped = function () {
	                return isFlipped;
	            };
	
	            update();
	            return button;
	        };
	    }(),
	
	    protractor: function protractor(center) {
	        return new Protractor(this, center);
	    },
	
	    ruler: function ruler(options) {
	        return new Ruler(this, options || {});
	    },
	
	    addPoints: addPoints
	});
	
	function Protractor(graph, center) {
	    this.set = graph.raphael.set();
	
	    this.cx = center[0];
	    this.cy = center[1];
	    var pro = this;
	
	    var r = graph.unscaleVector(180.5)[0];
	    var imgPos = graph.scalePoint([this.cx - r, this.cy + r - graph.unscaleVector(10.5)[1]]);
	    var image = graph.mouselayer.image("https://ka-perseus-graphie.s3.amazonaws.com/e9d032f2ab8b95979f674fbfa67056442ba1ff6a.png", imgPos[0], imgPos[1], 360, 180);
	    this.set.push(image);
	
	    // Prevent the page from scrolling when we grab and drag the image on a
	    // mobile device.
	    image.node.addEventListener("touchstart", function (event) {
	        event.preventDefault();
	    }, { passive: false });
	
	    var arrowHelper = function arrowHelper(angle, pixelsFromEdge) {
	        var scaledRadius = graph.scaleVector(r);
	        scaledRadius[0] -= 16;
	        scaledRadius[1] -= 16;
	        var scaledCenter = graph.scalePoint(center);
	        var x = Math.sin((angle + 90) * Math.PI / 180) * (scaledRadius[0] + pixelsFromEdge) + scaledCenter[0];
	        var y = Math.cos((angle + 90) * Math.PI / 180) * (scaledRadius[1] + pixelsFromEdge) + scaledCenter[1];
	        return x + "," + y;
	    };
	
	    var arrow = graph.raphael.path(" M" + arrowHelper(180, 6) + " L" + arrowHelper(180, 2) + " L" + arrowHelper(183, 10) + " L" + arrowHelper(180, 18) + " L" + arrowHelper(180, 14) + " A" + (graph.scaleVector(r)[0] + 10) + "," + (graph.scaleVector(r)[1] + 10) + ",0,0,1," + arrowHelper(170, 14) + " L" + arrowHelper(170, 18) + " L" + arrowHelper(167, 10) + " L" + arrowHelper(170, 2) + " L" + arrowHelper(170, 6) + " A" + (graph.scaleVector(r)[0] + 10) + "," + (graph.scaleVector(r)[1] + 10) + ",0,0,0," + arrowHelper(180, 6) + " Z").attr({
	        stroke: null,
	        fill: KhanColors.INTERACTIVE
	    });
	
	    // add it to the set so it translates with everything else
	    this.set.push(arrow);
	
	    this.centerPoint = graph.addMovablePoint({
	        coord: center,
	        visible: false
	    });
	
	    // Use a movablePoint for rotation
	    this.rotateHandle = graph.addMovablePoint({
	        bounded: false,
	        coord: [Math.sin(275 * Math.PI / 180) * r + this.cx, Math.cos(275 * Math.PI / 180) * r + this.cy],
	        onMove: function onMove(x, y) {
	            var angle = Math.atan2(pro.centerPoint.coord[1] - y, pro.centerPoint.coord[0] - x) * 180 / Math.PI;
	            pro.rotate(-angle - 5, true);
	        }
	    });
	
	    // Add a constraint so the point moves in a circle
	    this.rotateHandle.constraints.fixedDistance.dist = r;
	    this.rotateHandle.constraints.fixedDistance.point = this.centerPoint;
	
	    // Remove the default dot added by the movablePoint since we have our
	    // double-arrow thing
	    this.rotateHandle.visibleShape.remove();
	    // Make the mouse target bigger to encompass the whole area around the
	    // double-arrow thing
	    this.rotateHandle.mouseTarget.attr({ scale: 2.0 });
	
	    var isDragging = false;
	    var isHovering = false;
	    var isHighlight = function isHighlight() {
	        return isHovering || isDragging;
	    };
	
	    var self = this;
	    var $mouseTarget = $(self.rotateHandle.mouseTarget.getMouseTarget());
	    $mouseTarget.bind("vmousedown", function (event) {
	        isDragging = true;
	        $mouseTarget.css("cursor", "-webkit-grabbing");
	        $mouseTarget.css("cursor", "grabbing");
	        arrow.animate({ scale: 1.5, fill: KhanColors.INTERACTING }, 50);
	
	        $(document).bind("vmouseup.rotateHandle", function (event) {
	            isDragging = false;
	            $mouseTarget.css("cursor", "-webkit-grab");
	            $mouseTarget.css("cursor", "grab");
	
	            if (!isHighlight()) {
	                arrow.animate({ scale: 1.0, fill: KhanColors.INTERACTIVE }, 50);
	            }
	
	            $(document).unbind("vmouseup.rotateHandle");
	        });
	    });
	
	    $mouseTarget.bind("vmouseover", function (event) {
	        isHovering = true;
	        arrow.animate({ scale: 1.5, fill: KhanColors.INTERACTING }, 50);
	    });
	    $mouseTarget.bind("vmouseout", function (event) {
	        isHovering = false;
	        if (!isHighlight()) {
	            arrow.animate({ scale: 1.0, fill: KhanColors.INTERACTIVE }, 50);
	        }
	    });
	
	    var setNodes = $.map(this.set, function (el) {
	        return el.node;
	    });
	    this.makeTranslatable = function makeTranslatable() {
	        $(setNodes).css("cursor", "move");
	        $mouseTarget.css("cursor", "-webkit-grab");
	        $mouseTarget.css("cursor", "grab");
	
	        $(setNodes).bind("vmousedown", function (event) {
	            event.preventDefault();
	            var startx = event.pageX - $(graph.raphael.canvas.parentNode).offset().left;
	            var starty = event.pageY - $(graph.raphael.canvas.parentNode).offset().top;
	
	            $(document).bind("vmousemove.protractor", function (event) {
	                var mouseX = event.pageX - $(graph.raphael.canvas.parentNode).offset().left;
	                var mouseY = event.pageY - $(graph.raphael.canvas.parentNode).offset().top;
	                // can't go beyond 10 pixels from the edge
	                mouseX = Math.max(10, Math.min(graph.xpixels - 10, mouseX));
	                mouseY = Math.max(10, Math.min(graph.ypixels - 10, mouseY));
	
	                var dx = mouseX - startx;
	                var dy = mouseY - starty;
	
	                $.each(pro.set.items, function () {
	                    this.translate(dx, dy);
	                });
	                pro.centerPoint.setCoord([pro.centerPoint.coord[0] + dx / graph.scale[0], pro.centerPoint.coord[1] - dy / graph.scale[1]]);
	                pro.rotateHandle.setCoord([pro.rotateHandle.coord[0] + dx / graph.scale[0], pro.rotateHandle.coord[1] - dy / graph.scale[1]]);
	                startx = mouseX;
	                starty = mouseY;
	            });
	
	            $(document).one("vmouseup", function (event) {
	                $(document).unbind("vmousemove.protractor");
	            });
	        });
	    };
	
	    this.rotation = 0;
	
	    this.rotate = function (offset, absolute) {
	        var center = graph.scalePoint(this.centerPoint.coord);
	
	        if (absolute) {
	            this.rotation = 0;
	        }
	
	        this.set.rotate(this.rotation + offset, center[0], center[1]);
	        this.rotation = this.rotation + offset;
	
	        return this;
	    };
	
	    this.moveTo = function moveTo(x, y) {
	        var start = graph.scalePoint(pro.centerPoint.coord);
	        var end = graph.scalePoint([x, y]);
	        var time = GraphUtils.getDistance(start, end) * 2;
	
	        $({ x: start[0], y: start[1] }).animate({ x: end[0], y: end[1] }, {
	            duration: time,
	            step: function step(now, fx) {
	                var dx = 0;
	                var dy = 0;
	                if (fx.prop === "x") {
	                    dx = now - graph.scalePoint(pro.centerPoint.coord)[0];
	                } else if (fx.prop === "y") {
	                    dy = now - graph.scalePoint(pro.centerPoint.coord)[1];
	                }
	                $.each(pro.set.items, function () {
	                    this.translate(dx, dy);
	                });
	                pro.centerPoint.setCoord([pro.centerPoint.coord[0] + dx / graph.scale[0], pro.centerPoint.coord[1] - dy / graph.scale[1]]);
	                pro.rotateHandle.setCoord([pro.rotateHandle.coord[0] + dx / graph.scale[0], pro.rotateHandle.coord[1] - dy / graph.scale[1]]);
	            }
	        });
	    };
	
	    this.rotateTo = function rotateTo(angle) {
	        if (Math.abs(this.rotation - angle) > 180) {
	            this.rotation += 360;
	        }
	        var time = Math.abs(this.rotation - angle) * 5;
	        $({ 0: this.rotation }).animate({ 0: angle }, {
	            duration: time,
	            step: function step(now, fx) {
	                pro.rotate(now, true);
	                pro.rotateHandle.setCoord([Math.sin((now + 275) * Math.PI / 180) * r + pro.centerPoint.coord[0], Math.cos((now + 275) * Math.PI / 180) * r + pro.centerPoint.coord[1]]);
	            }
	        });
	    };
	
	    this.remove = function () {
	        this.set.remove();
	    };
	
	    this.makeTranslatable();
	    return this;
	}
	
	function Ruler(graphie, options) {
	    _.defaults(options, {
	        center: [0, 0],
	        pixelsPerUnit: 40,
	        ticksPerUnit: 10, // 10 or power of 2
	        units: 10, // the length the ruler can measure
	        label: "", // e.g "cm" (the shorter, the better)
	        style: {
	            fill: null,
	            stroke: KhanColors.GRAY
	        }
	    });
	
	    var light = _.extend({}, options.style, { strokeWidth: 1 });
	    var bold = _.extend({}, options.style, { strokeWidth: 2 });
	
	    var width = options.units * options.pixelsPerUnit;
	    var height = 50;
	
	    var leftBottom = graphie.unscalePoint(kvector.subtract(graphie.scalePoint(options.center), kvector.scale([width, -height], 0.5)));
	
	    var graphieUnitsPerUnit = options.pixelsPerUnit / graphie.scale[0];
	    var graphieUnitsHeight = height / graphie.scale[0];
	
	    var rightTop = kvector.add(leftBottom, [options.units * graphieUnitsPerUnit, graphieUnitsHeight]);
	
	    var tickHeight = 1.0;
	    var tickHeightMap = void 0;
	
	    if (options.ticksPerUnit === 10) {
	        // decimal, as on a centimeter ruler
	        tickHeightMap = {
	            10: tickHeight,
	            5: tickHeight * 0.55,
	            1: tickHeight * 0.35
	        };
	    } else {
	        var sizes = [1, 0.6, 0.45, 0.3];
	
	        tickHeightMap = {};
	        for (var i = options.ticksPerUnit; i >= 1; i /= 2) {
	            tickHeightMap[i] = tickHeight * (sizes.shift() || 0.2);
	        }
	    }
	
	    var tickFrequencies = _.keys(tickHeightMap).sort(function (a, b) {
	        return b - a;
	    });
	
	    function getTickHeight(i) {
	        for (var k = 0; k < tickFrequencies.length; k++) {
	            var key = tickFrequencies[k];
	            if (i % key === 0) {
	                return tickHeightMap[key];
	            }
	        }
	    }
	
	    var left = leftBottom[0];
	    var bottom = leftBottom[1];
	    var right = rightTop[0];
	    var top = rightTop[1];
	
	    var numTicks = options.units * options.ticksPerUnit + 1;
	
	    var set = graphie.raphael.set();
	
	    var px = 1 / graphie.scale[0];
	    set.push(graphie.line([left - px, bottom], [right + px, bottom], bold));
	    set.push(graphie.line([left - px, top], [right + px, top], bold));
	
	    _.times(numTicks, function (i) {
	        var n = i / options.ticksPerUnit;
	        var x = left + n * graphieUnitsPerUnit;
	        var height = getTickHeight(i) * graphieUnitsHeight;
	
	        var style = i === 0 || i === numTicks - 1 ? bold : light;
	        set.push(graphie.line([x, bottom], [x, bottom + height], style));
	
	        if (n % 1 === 0) {
	            var coord = graphie.scalePoint([x, top]);
	            var text = void 0;
	            var offset = void 0;
	
	            if (n === 0) {
	                // Unit label
	                text = options.label;
	                offset = {
	                    mm: 13,
	                    cm: 11,
	                    m: 8,
	                    km: 11,
	                    in: 8,
	                    ft: 8,
	                    yd: 10,
	                    mi: 10
	                }[text] || 3 * text.toString().length;
	            } else {
	                // Tick label
	                text = n;
	                offset = -3 * (n.toString().length + 1);
	            }
	            var label = graphie.raphael.text(coord[0] + offset, coord[1] + 10, text);
	            label.attr({
	                "font-family": "KaTeX_Main",
	                "font-size": "12px",
	                color: "#444"
	            });
	            set.push(label);
	        }
	    });
	
	    var mouseTarget = graphie.mouselayer.path(GraphUtils.svgPath([leftBottom, [left, top], rightTop, [right, bottom],
	    /* closed */true]));
	    mouseTarget.attr({
	        fill: "#000",
	        opacity: 0,
	        stroke: "#000",
	        "stroke-width": 2
	    });
	    set.push(mouseTarget);
	
	    // Prevent the page from scrolling when we grab and drag the ruler on a
	    // mobile device.
	    mouseTarget.node.addEventListener("touchstart", function (event) {
	        event.preventDefault();
	    }, { passive: false });
	
	    var setNodes = $.map(set, function (el) {
	        return el.node;
	    });
	    $(setNodes).css("cursor", "move");
	
	    $(setNodes).bind("vmousedown", function (event) {
	        event.preventDefault();
	        var startx = event.pageX - $(graphie.raphael.canvas.parentNode).offset().left;
	        var starty = event.pageY - $(graphie.raphael.canvas.parentNode).offset().top;
	
	        $(document).bind("vmousemove.ruler", function (event) {
	            var mouseX = event.pageX - $(graphie.raphael.canvas.parentNode).offset().left;
	            var mouseY = event.pageY - $(graphie.raphael.canvas.parentNode).offset().top;
	            // can't go beyond 10 pixels from the edge
	            mouseX = Math.max(10, Math.min(graphie.xpixels - 10, mouseX));
	            mouseY = Math.max(10, Math.min(graphie.ypixels - 10, mouseY));
	
	            var dx = mouseX - startx;
	            var dy = mouseY - starty;
	
	            set.translate(dx, dy);
	            leftBottomHandle.setCoord([leftBottomHandle.coord[0] + dx / graphie.scale[0], leftBottomHandle.coord[1] - dy / graphie.scale[1]]);
	            rightBottomHandle.setCoord([rightBottomHandle.coord[0] + dx / graphie.scale[0], rightBottomHandle.coord[1] - dy / graphie.scale[1]]);
	
	            startx = mouseX;
	            starty = mouseY;
	        });
	
	        $(document).one("vmouseup", function (event) {
	            $(document).unbind("vmousemove.ruler");
	        });
	    });
	
	    var leftBottomHandle = graphie.addMovablePoint({
	        coord: leftBottom,
	        normalStyle: {
	            fill: KhanColors.INTERACTIVE,
	            "fill-opacity": 0,
	            stroke: KhanColors.INTERACTIVE
	        },
	        highlightStyle: {
	            fill: KhanColors.INTERACTING,
	            "fill-opacity": 0.1,
	            stroke: KhanColors.INTERACTING
	        },
	        pointSize: 6, // or 8 maybe?
	        onMove: function onMove(x, y) {
	            var dy = rightBottomHandle.coord[1] - y;
	            var dx = rightBottomHandle.coord[0] - x;
	            var angle = Math.atan2(dy, dx) * 180 / Math.PI;
	            var center = kvector.scale(kvector.add([x, y], rightBottomHandle.coord), 0.5);
	            var scaledCenter = graphie.scalePoint(center);
	            var oldCenter = kvector.scale(kvector.add(leftBottomHandle.coord, rightBottomHandle.coord), 0.5);
	            var scaledOldCenter = graphie.scalePoint(oldCenter);
	            var diff = kvector.subtract(scaledCenter, scaledOldCenter);
	            set.rotate(-angle, scaledOldCenter[0], scaledOldCenter[1]);
	            set.translate(diff[0], diff[1]);
	        }
	    });
	    var rightBottomHandle = graphie.addMovablePoint({
	        coord: [right, bottom],
	        normalStyle: {
	            fill: KhanColors.INTERACTIVE,
	            "fill-opacity": 0,
	            stroke: KhanColors.INTERACTIVE
	        },
	        highlightStyle: {
	            fill: KhanColors.INTERACTING,
	            "fill-opacity": 0.1,
	            stroke: KhanColors.INTERACTING
	        },
	        pointSize: 6, // or 8 maybe?
	        onMove: function onMove(x, y) {
	            var dy = y - leftBottomHandle.coord[1];
	            var dx = x - leftBottomHandle.coord[0];
	            var angle = Math.atan2(dy, dx) * 180 / Math.PI;
	            var center = kvector.scale(kvector.add([x, y], leftBottomHandle.coord), 0.5);
	            var scaledCenter = graphie.scalePoint(center);
	            var oldCenter = kvector.scale(kvector.add(leftBottomHandle.coord, rightBottomHandle.coord), 0.5);
	            var scaledOldCenter = graphie.scalePoint(oldCenter);
	            var diff = kvector.subtract(scaledCenter, scaledOldCenter);
	            set.rotate(-angle, scaledOldCenter[0], scaledOldCenter[1]);
	            set.translate(diff[0], diff[1]);
	        }
	    });
	
	    // Make each handle rotate the ruler about the other one
	    leftBottomHandle.constraints.fixedDistance.dist = width / graphie.scale[0];
	    leftBottomHandle.constraints.fixedDistance.point = rightBottomHandle;
	    rightBottomHandle.constraints.fixedDistance.dist = width / graphie.scale[0];
	    rightBottomHandle.constraints.fixedDistance.point = leftBottomHandle;
	
	    this.remove = function () {
	        set.remove();
	        leftBottomHandle.remove();
	        rightBottomHandle.remove();
	    };
	
	    return this;
	}
	
	function MovableAngle(graphie, options) {
	    this.graphie = graphie;
	
	    // TODO(alex): Move standard colors from math.js to somewhere else
	    // so that they are available when this file is first parsed
	    _.extend(this, options);
	    _.defaults(this, {
	        normalStyle: {
	            stroke: KhanColors.INTERACTIVE,
	            "stroke-width": 2,
	            fill: KhanColors.INTERACTIVE
	        },
	        highlightStyle: {
	            stroke: KhanColors.INTERACTING,
	            "stroke-width": 2,
	            fill: KhanColors.INTERACTING
	        },
	        labelStyle: {
	            stroke: KhanColors.DYNAMIC,
	            "stroke-width": 1,
	            color: KhanColors.DYNAMIC
	        },
	        angleStyle: {
	            stroke: KhanColors.DYNAMIC,
	            "stroke-width": 1,
	            color: KhanColors.DYNAMIC
	        },
	        allowReflex: true // not on MovableAngle.prototype so that
	        // it is not overridden by undefined
	    });
	
	    if (!this.points || this.points.length !== 3) {
	        throw new Error("MovableAngle requires 3 points");
	    }
	
	    // Handle coordinates that are not MovablePoints (i.e. [2, 4])
	    this.points = _.map(options.points, function (point) {
	        if (_.isArray(point)) {
	            return graphie.addMovablePoint({
	                coord: point,
	                visible: false,
	                constraints: {
	                    fixed: true
	                },
	                normalStyle: this.normalStyle
	            });
	        } else {
	            return point;
	        }
	    }, this);
	    this.coords = _.pluck(this.points, "coord");
	    if (this.reflex == null) {
	        if (this.allowReflex) {
	            this.reflex = this._getClockwiseAngle(this.coords) > 180;
	        } else {
	            this.reflex = false;
	        }
	    }
	
	    this.rays = _.map([0, 2], function (i) {
	        return graphie.addMovableLineSegment({
	            pointA: this.points[1],
	            pointZ: this.points[i],
	            fixed: true,
	            extendRay: true
	        });
	    }, this);
	
	    this.temp = [];
	    this.labeledAngle = graphie.label([0, 0], "", "center", this.labelStyle);
	
	    if (!this.fixed) {
	        this.addMoveHandlers();
	        this.addHighlightHandlers();
	    }
	    this.update();
	}
	
	_.extend(MovableAngle.prototype, {
	    points: [],
	    snapDegrees: 0,
	    snapOffsetDeg: 0,
	    angleLabel: "",
	    numArcs: 1,
	    pushOut: 0,
	    fixed: false,
	
	    addMoveHandlers: function addMoveHandlers() {
	        var graphie = this.graphie;
	
	        function tooClose(point1, point2) {
	            var safeDistance = 30;
	            var distance = GraphUtils.getDistance(graphie.scalePoint(point1), graphie.scalePoint(point2));
	            return distance < safeDistance;
	        }
	
	        var points = this.points;
	
	        // Drag the vertex to move the entire angle
	        points[1].onMove = function (x, y) {
	            var oldVertex = points[1].coord;
	            var newVertex = [x, y];
	            var delta = addPoints(newVertex, reverseVector(oldVertex));
	
	            var valid = true;
	            var newPoints = {};
	            _.each([0, 2], function (i) {
	                var oldPoint = points[i].coord;
	                var newPoint = addPoints(oldPoint, delta);
	
	                var angle = GraphUtils.findAngle(newVertex, newPoint);
	                angle *= Math.PI / 180;
	                newPoint = graphie.constrainToBoundsOnAngle(newPoint, 10, angle);
	                newPoints[i] = newPoint;
	
	                if (tooClose(newVertex, newPoint)) {
	                    valid = false;
	                }
	            });
	
	            // Only move points if all new positions are valid
	            if (valid) {
	                _.each(newPoints, function (newPoint, i) {
	                    points[i].setCoord(newPoint);
	                });
	            }
	            return valid;
	        };
	
	        var snap = this.snapDegrees;
	        var snapOffset = this.snapOffsetDeg;
	
	        // Drag ray control points to move each ray individually
	        _.each([0, 2], function (i) {
	            points[i].onMove = function (x, y) {
	                var newPoint = [x, y];
	                var vertex = points[1].coord;
	
	                if (tooClose(vertex, newPoint)) {
	                    return false;
	                } else if (snap) {
	                    var angle = GraphUtils.findAngle(newPoint, vertex);
	                    angle = Math.round((angle - snapOffset) / snap) * snap + snapOffset;
	                    var distance = GraphUtils.getDistance(newPoint, vertex);
	                    return addPoints(vertex, graphie.polar(distance, angle));
	                } else {
	                    return true;
	                }
	            };
	        });
	
	        // Expose only a single move event
	        $(points).on("move", function () {
	            this.update();
	            $(this).trigger("move");
	        }.bind(this));
	    },
	
	    addHighlightHandlers: function addHighlightHandlers() {
	        var vertex = this.points[1];
	
	        vertex.onHighlight = function () {
	            _.each(this.points, function (point) {
	                point.visibleShape.animate(this.highlightStyle, 50);
	            }, this);
	            _.each(this.rays, function (ray) {
	                ray.visibleLine.animate(this.highlightStyle, 50);
	                ray.arrowStyle = _.extend({}, ray.arrowStyle, {
	                    color: this.highlightStyle.stroke,
	                    stroke: this.highlightStyle.stroke
	                });
	            }, this);
	
	            this.angleStyle = _.extend({}, this.angleStyle, {
	                color: this.highlightStyle.stroke,
	                stroke: this.highlightStyle.stroke
	            });
	            this.update();
	        }.bind(this);
	
	        vertex.onUnhighlight = function () {
	            _.each(this.points, function (point) {
	                point.visibleShape.animate(this.normalStyle, 50);
	            }, this);
	            _.each(this.rays, function (ray) {
	                ray.visibleLine.animate(ray.normalStyle, 50);
	                ray.arrowStyle = _.extend({}, ray.arrowStyle, {
	                    color: ray.normalStyle.stroke,
	                    stroke: ray.normalStyle.stroke
	                });
	            }, this);
	
	            this.angleStyle = _.extend({}, this.angleStyle, {
	                color: KhanColors.DYNAMIC,
	                stroke: KhanColors.DYNAMIC
	            });
	            this.update();
	        }.bind(this);
	    },
	
	    /**
	     * Returns the angle in [0, 360) degrees created by the
	     * coords when interpreted in a clockwise direction.
	     */
	    _getClockwiseAngle: function _getClockwiseAngle(coords) {
	        var rawAngle = GraphUtils.findAngle(
	        // The order of these is "weird" to match what a clockwise
	        // order is in graphie.labelAngle
	        coords[2], // from the second point
	        coords[0], // clockwise to the first point
	        coords[1] // the vertex parameter is last
	        );
	        var clockwiseAngle = rawAngle + 360 % 360;
	
	        return clockwiseAngle;
	    },
	
	    isReflex: function isReflex() {
	        return this.reflex;
	    },
	
	    isClockwise: function isClockwise() {
	        var clockwiseReflexive = this._getClockwiseAngle(this.coords) > 180;
	        return clockwiseReflexive === this.reflex;
	    },
	
	    getClockwiseCoords: function getClockwiseCoords() {
	        if (this.isClockwise()) {
	            return _.clone(this.coords);
	        } else {
	            return _.clone(this.coords).reverse();
	        }
	    },
	
	    update: function update(shouldChangeReflexivity) {
	        var prevCoords = this.coords;
	        this.coords = _.pluck(this.points, "coord");
	
	        // Update lines
	        _.invoke(this.points, "updateLineEnds");
	
	        var prevAngle = this._getClockwiseAngle(prevCoords);
	        var angle = this._getClockwiseAngle(this.coords);
	        var prevClockwiseReflexive = prevAngle > 180;
	        var clockwiseReflexive = angle > 180;
	
	        if (this.allowReflex) {
	            if (shouldChangeReflexivity == null) {
	                shouldChangeReflexivity = prevClockwiseReflexive !== clockwiseReflexive && Math.abs(angle - prevAngle) < 180;
	            }
	
	            if (shouldChangeReflexivity) {
	                this.reflex = !this.reflex;
	            }
	        }
	
	        _.invoke(this.temp, "remove");
	        this.temp = this.graphie.labelAngle({
	            point1: this.coords[0],
	            vertex: this.coords[1],
	            point3: this.coords[2],
	            label: this.labeledAngle,
	            text: this.angleLabel,
	            numArcs: this.numArcs,
	            pushOut: this.pushOut,
	            clockwise: this.reflex === clockwiseReflexive,
	            style: this.angleStyle
	        });
	    },
	
	    remove: function remove() {
	        _.invoke(this.rays, "remove");
	        _.invoke(this.temp, "remove");
	        this.labeledAngle.remove();
	    }
	});
	
	module.exports = InteractiveUtils;

/***/ },
/* 282 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/**
	 * MovableThing convenience methods
	 *
	 * Usually added to a Movable* class through
	 * InteractiveUtils.addMovableHelperMethodsTo(), but these implementations
	 * are simply for convenience.
	 */
	
	var _ = __webpack_require__(56);
	var kpoint = __webpack_require__(275).point;
	
	/* Local helper methods. */
	
	function getKey(eventName, id) {
	    return eventName + ":" + id;
	}
	
	function getEventName(key) {
	    return key.split(":")[0];
	}
	
	var MovableHelperMethods = {
	    /**
	     * Fire an onSomething type event to all functions in listeners
	     */
	    _fireEvent: function _fireEvent(listeners, currentValue, previousValue) {
	        _.invoke(listeners, "call", this, currentValue, previousValue);
	    },
	
	    /**
	     * Combine the array of constraints functions
	     * Returns either an [x, y] coordinate or false
	     */
	    _applyConstraints: function _applyConstraints(current, previous, extraOptions) {
	        var _this = this;
	
	        var skipRemaining = false;
	
	        return _.reduce(this.state.constraints, function (memo, constraint) {
	            // A move that has been cancelled won't be propagated to later
	            // constraints calls
	            if (memo === false) {
	                return false;
	            }
	
	            if (skipRemaining) {
	                return memo;
	            }
	
	            var result = constraint.call(_this, memo, previous, _extends({
	                onSkipRemaining: function onSkipRemaining() {
	                    skipRemaining = true;
	                }
	            }, extraOptions));
	
	            if (result === false) {
	                // Returning false cancels the move
	                return false;
	            } else if (kpoint.is(result, 2)) {
	                // Returning a coord from constraints overrides the move
	                return result;
	            } else if (result === true || result == null) {
	                // Returning true or undefined allow the move to occur
	                return memo;
	            } else {
	                // Anything else is an error
	                throw new Error("Constraint returned invalid result: " + result);
	            }
	        }, current, this);
	    },
	
	    /**
	     * Call all draw functions, and update our prevState for the next
	     * draw function
	     */
	    draw: function draw() {
	        var currState = this.cloneState();
	        MovableHelperMethods._fireEvent.call(this, this.state.draw, currState, this.prevState);
	        this.prevState = currState;
	    },
	
	    /**
	     * Add a listener to any event: startMove, constraints, onMove, onMoveEnd,
	     * etc. If a listener is already bound to the given eventName and id, then
	     * it is overwritten by func.
	     *
	     * eventName: the string name of the event to listen to. one of:
	     *   "onMoveStart", "onMove", "onMoveEnd", "draw", "remove"
	     *
	     * id: a string id that can be used to remove this event at a later time
	     *   note: adding multiple listeners with the same id is undefined behavior
	     *
	     * func: the function to call when the event happens, which is called
	     *   with the event's standard parameters [usually (coord, prevCoord) or
	     *   (state, prevState)]
	     */
	    listen: function listen(eventName, id, func) {
	        this._listenerMap = this._listenerMap || {};
	
	        // If there's an existing handler, replace it by using its index in
	        // `this.state[eventName]`; otherwise, add this handler to the end
	        var key = getKey(eventName, id);
	        var index = this._listenerMap[key] = this._listenerMap[key] || this.state[eventName].length;
	        this.state[eventName][index] = func;
	    },
	
	    /**
	     * Remove a previously added listener, by the id specified in the
	     * corresponding listen() call
	     *
	     * If the given id has not been registered already, this is a no-op
	     */
	    unlisten: function unlisten(eventName, id) {
	        this._listenerMap = this._listenerMap || {};
	
	        var key = getKey(eventName, id);
	        var index = this._listenerMap[key];
	        if (index !== undefined) {
	            // Remove handler from list of event handlers and listenerMap
	            this.state[eventName].splice(index, 1);
	            delete this._listenerMap[key];
	
	            // Re-index existing events: if they occur after `index`, decrement
	            var keys = _.keys(this._listenerMap);
	            _.each(keys, function (key) {
	                if (getEventName(key) === eventName && this._listenerMap[key] > index) {
	                    this._listenerMap[key]--;
	                }
	            }, this);
	        }
	    }
	};
	
	module.exports = MovableHelperMethods;

/***/ },
/* 283 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Constants that are shared between multiple files.
	 */
	
	module.exports = {
	    KeypadTypes: {
	        FRACTION: 'FRACTION',
	        EXPRESSION: 'EXPRESSION'
	    },
	
	    KeyTypes: {
	        EMPTY: 'EMPTY',
	        // For numerals, variables, and any other characters that themselves
	        // compose 'values'.
	        VALUE: 'VALUE',
	        // For buttons that insert or adjust math in an input.
	        OPERATOR: 'OPERATOR',
	        // For buttons that move the cursor in an input (including via
	        // deletion).
	        INPUT_NAVIGATION: 'INPUT_NAVIGATION',
	        // For buttons that modify the broader keypad state (e.g., by changing
	        // the visible pane).
	        KEYPAD_NAVIGATION: 'KEYPAD_NAVIGATION',
	        // For buttons that house multiple buttons and have no action
	        // themselves.
	        MANY: 'MANY',
	        // For the echo animation that appears on press.
	        ECHO: 'ECHO'
	    },
	
	    DeviceOrientations: {
	        LANDSCAPE: 'LANDSCAPE',
	        PORTRAIT: 'PORTRAIT'
	    },
	
	    DeviceTypes: {
	        PHONE: 'PHONE',
	        TABLET: 'TABLET'
	    },
	
	    LayoutModes: {
	        FULLSCREEN: 'FULLSCREEN',
	        COMPACT: 'COMPACT'
	    },
	
	    BorderDirections: {
	        LEFT: 'LEFT',
	        BOTTOM: 'BOTTOM'
	    },
	    BorderStyles: {
	        LEFT: ['LEFT'],
	        BOTTOM: ['BOTTOM'],
	        ALL: ['LEFT', 'BOTTOM'],
	        NONE: []
	    },
	
	    IconTypes: {
	        MATH: 'MATH',
	        SVG: 'SVG',
	        TEXT: 'TEXT'
	    },
	
	    DecimalSeparators: {
	        COMMA: 'COMMA',
	        PERIOD: 'PERIOD'
	    },
	
	    EchoAnimationTypes: {
	        SLIDE_AND_FADE: 'SLIDE_AND_FADE',
	        FADE_ONLY: 'FADE_ONLY',
	        LONG_FADE_ONLY: 'LONG_FADE_ONLY'
	    }
	};

/***/ },
/* 284 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Movable
	 *
	 * A Movable Something, that sends onMove events based on the
	 * mouse coordinate (graphie unscaled, non-pixel-value) of the
	 * move.
	 *
	 * Other MovableThings should generally have a Movable field, and
	 * let this class handle all of the virtual mouse events, and then
	 * take appropriate action in onMoveStart, onMove, onMoveEnd
	 */
	var _ = __webpack_require__(56);
	
	var InteractiveUtil = __webpack_require__(256);
	var normalizeOptions = InteractiveUtil.normalizeOptions;
	
	var assert = InteractiveUtil.assert;
	var kpoint = __webpack_require__(275).point;
	
	// state parameters that should be converted into an array of
	// functions
	var FUNCTION_ARRAY_OPTIONS = ["add", "modify", "draw", "remove", "onMoveStart", "onMove", "onMoveEnd", "onClick"];
	
	// Default "props" and "state". Both are added to this.state and
	// receive magic getter methods (this.isHovering() etc).
	// However, properties in DEFAULT_PROPS are updated on `modify()`,
	// while those in DEFAULT_STATE persist and are not updated.
	// Things that the user might want to change should be on "props",
	// while things used to render the movable should be on "state".
	var DEFAULT_PROPS = {
	    cursor: null
	};
	var DEFAULT_STATE = {
	    added: false,
	    isHovering: false,
	    isMouseOver: false,
	    isDragging: false,
	    mouseTarget: null
	};
	
	var Movable = function Movable(graphie, options) {
	    _.extend(this, {
	        graphie: graphie,
	        state: {
	            // Set here because this must be unique for each instance
	            id: _.uniqueId("movable")
	        }
	    });
	
	    // We only set DEFAULT_STATE once, here
	    this.modify(_.extend({}, DEFAULT_STATE, options));
	};
	
	InteractiveUtil.createGettersFor(Movable, _.extend({}, DEFAULT_PROPS, DEFAULT_STATE));
	InteractiveUtil.addMovableHelperMethodsTo(Movable);
	
	_.extend(Movable.prototype, {
	
	    cloneState: function cloneState() {
	        return _.clone(this.state);
	    },
	
	    _createDefaultState: function _createDefaultState() {
	        return _.extend({
	            id: this.state.id,
	            add: [],
	            modify: [],
	            draw: [],
	            remove: [],
	            onMoveStart: [],
	            onMove: [],
	            onMoveEnd: [],
	            onClick: []
	
	            // We only update props here, because we want things on state to
	            // be persistent, and updated appropriately in modify()
	        }, DEFAULT_PROPS);
	    },
	
	    /**
	     * Resets the object to its state as if it were constructed with
	     * `options` originally. The only state maintained is `state.id`
	     *
	     * Analogous to React.js's replaceProps
	     */
	    modify: function modify(options) {
	        this.update(_.extend({}, this._createDefaultState(), options));
	    },
	
	    /**
	     * Simulates a mouse grab event on the movable object.
	     */
	    grab: function grab(coord) {
	        assert(kpoint.is(coord));
	        var self = this;
	        var graphie = self.graphie;
	        var state = self.state;
	
	        state.isHovering = true;
	        state.isDragging = true;
	        graphie.isDragging = true;
	
	        var startMouseCoord = coord;
	        var prevMouseCoord = startMouseCoord;
	        self._fireEvent(state.onMoveStart, startMouseCoord, startMouseCoord);
	
	        var moveHandler = function moveHandler(e) {
	            e.preventDefault();
	
	            var mouseCoord = graphie.getMouseCoord(e);
	            self._fireEvent(state.onMove, mouseCoord, prevMouseCoord);
	            self.draw();
	            prevMouseCoord = mouseCoord;
	        };
	
	        var upHandler = function upHandler(e) {
	            $(document).unbind("vmousemove", moveHandler);
	            $(document).unbind("vmouseup", upHandler);
	            if (state.isHovering) {
	                self._fireEvent(state.onClick, prevMouseCoord, startMouseCoord);
	            }
	            state.isHovering = self.state.isMouseOver;
	            state.isDragging = false;
	            graphie.isDragging = false;
	            self._fireEvent(state.onMoveEnd, prevMouseCoord, startMouseCoord);
	            self.draw();
	        };
	
	        $(document).bind("vmousemove", moveHandler);
	        $(document).bind("vmouseup", upHandler);
	    },
	
	    /**
	     * Adjusts constructor parameters without changing previous settings
	     * for any option not specified
	     *
	     * Analogous to React.js's setProps
	     */
	    update: function update(options) {
	        var self = this;
	        var graphie = self.graphie;
	
	        var prevState = self.cloneState();
	        var state = _.extend(self.state, normalizeOptions(FUNCTION_ARRAY_OPTIONS, options));
	
	        // the invisible shape in front of the point that gets mouse events
	        if (state.mouseTarget && !prevState.mouseTarget) {
	            var $mouseTarget = void 0;
	            if (state.mouseTarget.getMouseTarget) {
	                $mouseTarget = $(state.mouseTarget.getMouseTarget());
	            } else {
	                $mouseTarget = $(state.mouseTarget[0]);
	            }
	
	            var isMouse = !('ontouchstart' in window);
	
	            if (isMouse) {
	                $mouseTarget.on("vmouseover", function () {
	                    state.isMouseOver = true;
	                    if (!graphie.isDragging) {
	                        state.isHovering = true;
	                    }
	                    if (self.state.added) {
	                        // Avoid drawing if the point has been removed
	                        self.draw();
	                    }
	                });
	
	                $mouseTarget.on("vmouseout", function () {
	                    state.isMouseOver = false;
	                    if (!state.isDragging) {
	                        state.isHovering = false;
	                    }
	                    if (self.state.added) {
	                        // Avoid drawing if the point has been removed
	                        self.draw();
	                    }
	                });
	            }
	
	            // Prevent the page from scrolling when we grab and drag the
	            // movable object on a mobile device.
	            $mouseTarget[0].addEventListener("touchstart", function (event) {
	                event.preventDefault();
	            }, { passive: false });
	
	            $mouseTarget.on("vmousedown", function (e) {
	                if (e.which !== 0 && e.which !== 1) {
	                    return;
	                }
	                e.preventDefault();
	
	                var mouseCoord = graphie.getMouseCoord(e);
	                self.grab(mouseCoord);
	            });
	        }
	
	        if (state.mouseTarget && state.cursor !== undefined) {
	            var _$mouseTarget = void 0;
	            if (state.mouseTarget.getMouseTarget) {
	                _$mouseTarget = $(state.mouseTarget.getMouseTarget());
	            } else {
	                _$mouseTarget = $(state.mouseTarget[0]);
	            }
	
	            // "" removes the css cursor if state.cursor is null
	            _$mouseTarget.css("cursor", state.cursor || "");
	        }
	
	        // Trigger an add event if this hasn't been added before
	        if (!state.added) {
	            self._fireEvent(state.modify, self.cloneState(), {});
	            state.added = true;
	
	            // Update the state for `added` and in case the add event
	            // changed it
	            self.prevState = self.cloneState();
	        }
	
	        // Trigger a modify event
	        self._fireEvent(state.modify, self.cloneState(), self.prevState);
	    },
	
	    remove: function remove() {
	        this.state.added = false;
	        this._fireEvent(this.state.remove);
	        if (this.state.mouseTarget) {
	            $(this.state.mouseTarget).off();
	            this.state.mouseTarget.remove();
	            this.state.mouseTarget = null;
	        }
	    },
	
	    // Change z-order to back
	    toBack: function toBack() {
	        if (this.state.mouseTarget) {
	            this.state.mouseTarget.toBack();
	        }
	    },
	
	    // Change z-order to front
	    toFront: function toFront() {
	        if (this.state.mouseTarget) {
	            this.state.mouseTarget.toFront();
	        }
	    }
	});
	
	module.exports = Movable;

/***/ },
/* 285 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/**
	 * Creates and adds a point to the graph that can be dragged around.
	 * It allows constraints on its movement and draws when moves happen.
	 *
	 * Options can be passed to the constructor to control how the point behaves:
	 *   coord: [x, y]
	 *     The initial position of the point
	 *   pointSize:
	 *     changes the size of the point. defaults to 4
	 *   static: boolean
	 *     draw the point, but don't let it be interactable
	 *   cursor: "move", "pointer"
	 *     css cursor for this point
	 *   add: [function(state)]
	 *     called immediately when this movablePoint is added
	 *     default: apply any constraints and draw
	 *   draw: [function(prevState, currentState)]
	 *     drawing functions. default to [basic, highlight]
	 *   remove: [function(state)]
	 *     called when this movablePoint is removed
	 *   onMoveStart: [function(coord)]
	 *     called when this point is clicked on
	 *   constraints: [function(coord)]
	 *     called when this point is dragged
	 *     return true or nothing to accept the move
	 *     return false to cancel the move
	 *     return an [x, y] coordinate to override the move
	 *   onMove: [function(coord)]
	 *     called after all constraints functions pass and the point
	 *     is moved to a new location
	 *   onMoveEnd: [function(coord)]
	 *     called when the mouse is released from a click or move
	 *   onClick: [function(coord)]
	 *     called when someone mouses down, doesn't move the point,
	 *     and mouses up.
	 *   normalStyle:
	 *     the raphael/graphie style of the point when not hovering
	 *   highlightStyle:
	 *     the raphael/graphie style of the point when hovering, if
	 *     MovablePoint.draw.highlight is used
	 *
	 * This creates a MovablePoint object with the following methods:
	 *   setCoord: [x, y]
	 *     changes the point's coordinate
	 *   draw:
	 *     redraws the coord
	 *   modify: {options}
	 *     modifies the original options passed to the point
	 *   remove:
	 *     removes the point from graphie
	 */
	var _ = __webpack_require__(56);
	
	var MovablePointOptions = __webpack_require__(342);
	var WrappedEllipse = __webpack_require__(343);
	var InteractiveUtil = __webpack_require__(256);
	var objective_ = __webpack_require__(80);
	var assert = InteractiveUtil.assert;
	var normalizeOptions = InteractiveUtil.normalizeOptions;
	
	var kpoint = __webpack_require__(275).point;
	var kvector = __webpack_require__(275).vector;
	var KhanColors = __webpack_require__(268);
	var processMath = __webpack_require__(344).processMath;
	
	var _require = __webpack_require__(47),
	    iconTrash = _require.iconTrash;
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var InlineIcon = __webpack_require__(48);
	
	// State parameters that should be converted into an array of
	// functions
	var FUNCTION_ARRAY_OPTIONS = _.keys(MovablePointOptions);
	
	// Default "props" and "state". Both are added to this.state and
	// receive magic getter methods (this.coord() etc).
	// However, properties in DEFAULT_PROPS are updated on `modify()`,
	// while those in DEFAULT_STATE persist and are not updated.
	// Things that the user might want to change should be on "props",
	// while things used to render the point should be on "state".
	var DEFAULT_PROPS = {
	    coord: [0, 0],
	    pointSize: 4,
	    static: false,
	    cursor: "move",
	    normalStyle: null, // turned into an object in this.modify
	    highlightStyle: null, // likewise
	    shadow: false,
	    tooltip: false
	};
	var DEFAULT_STATE = {
	    added: false,
	    hasMoved: false,
	    visibleShape: null,
	    outOfBounds: false,
	    mouseTarget: null,
	    touchOffset: null
	};
	
	var tooltipResetFunctions = [];
	
	var MovablePoint = function MovablePoint(graphie, movable, options) {
	    _.extend(this, {
	        graphie: graphie,
	        movable: movable,
	        state: {
	            // Set here because this must be unique for each instance
	            id: _.uniqueId("movablePoint")
	        }
	    });
	
	    // We only set DEFAULT_STATE once, here
	    this.modify(_.extend({}, DEFAULT_STATE, options));
	};
	
	_.extend(MovablePoint, MovablePointOptions);
	InteractiveUtil.createGettersFor(MovablePoint, _.extend({}, DEFAULT_PROPS, DEFAULT_STATE));
	InteractiveUtil.addMovableHelperMethodsTo(MovablePoint);
	
	_.extend(MovablePoint.prototype, {
	
	    cloneState: function cloneState() {
	        return _.extend(this.movable.cloneState(), this.state);
	    },
	
	    _createDefaultState: function _createDefaultState() {
	        return _.extend({
	            id: this.state.id
	        }, normalizeOptions(FUNCTION_ARRAY_OPTIONS,
	        // Defaults are copied from MovablePointOptions.*.standard
	        // These defaults are set here instead of DEFAULT_PROPS/STATE
	        // because they:
	        //    - are objects, not primitives (and need a deeper copy)
	        //    - they don't need getters created for them
	        // TODO(jack): Consider "default" once we es3ify perseus
	        objective_.pluck(MovablePointOptions, "standard")
	
	        // We only update props here, because we want things on state to
	        // be persistent, and updated appropriately in modify()
	        ), DEFAULT_PROPS);
	    },
	
	    /**
	     * Resets the object to its state as if it were constructed with
	     * `options` originally. state not on DEFAULT_PROPS is maintained.
	     *
	     * Analogous to React.js's replaceProps
	     */
	    modify: function modify(options) {
	        this.update(_.extend(this._createDefaultState(), options));
	    },
	
	    /**
	     * Displays a tooltip above the point, replacing any previous contents. If
	     * there is no tooltip initialized, adds the tooltip.
	     *
	     * If the type of contents is string, the contents will be rendered with
	     * KaTeX. Otherwise, the content will be assumed to be a DOM node and will
	     * be appended inside the tooltip.
	     */
	    _showTooltip: function _showTooltip(contents) {
	        var _this = this;
	
	        if (!this._tooltip) {
	            this._tooltip = document.createElement("div");
	            this._tooltip.className = "tooltip-content";
	            this.state.visibleShape.wrapper.className = "tooltip";
	            this.state.visibleShape.wrapper.appendChild(this._tooltip);
	
	            // Only one tooltip should be displayed at a time, so store a list
	            // of all the tooltips initialized.
	            tooltipResetFunctions.push(function () {
	                if (_this.state.added) {
	                    _this._hideTooltip();
	                }
	            });
	        }
	
	        if (this._tooltip.firstChild) {
	            this._tooltip.removeChild(this._tooltip.firstChild);
	        }
	
	        this.state.visibleShape.wrapper.className = "tooltip visible";
	        this._tooltip.appendChild(document.createElement("span"));
	
	        if (typeof contents === "string") {
	            processMath(this._tooltip.firstChild, contents, false);
	        } else if (typeof contents === "function") {
	            contents(this._tooltip.firstChild);
	        } else {
	            this._tooltip.firstChild.appendChild(contents);
	        }
	    },
	
	    _hideTooltip: function _hideTooltip() {
	        if (this._tooltip) {
	            // Without the visible class, tooltips have display: none set
	            this.state.visibleShape.wrapper.className = "tooltip";
	        }
	    },
	
	    /**
	     * Adjusts constructor parameters without changing previous settings
	     * for any option not specified
	     *
	     * Analogous to React.js's setProps
	     */
	    update: function update(options) {
	        var _this2 = this;
	
	        var self = this;
	        var graphie = self.graphie;
	        var state = _.extend(self.state, normalizeOptions(FUNCTION_ARRAY_OPTIONS, options));
	
	        assert(kpoint.is(state.coord));
	
	        // Default things inside the state.normalStyle object, because
	        // _.extend is not deep.
	        // We use _.extend instead of _.defaults because we don't want
	        // to modify the passed-in copy (especially if it's from
	        // DEFAULT_PROPS/STATE!)
	        var normalColor = state.static ? KhanColors.DYNAMIC : KhanColors.INTERACTIVE;
	        state.normalStyle = _.extend({
	            fill: normalColor,
	            stroke: normalColor,
	            scale: 1
	        }, state.normalStyle);
	
	        state.highlightStyle = _.extend({
	            fill: KhanColors.INTERACTING,
	            stroke: KhanColors.INTERACTING,
	            scale: 2
	        }, state.highlightStyle);
	
	        if (!state.static) {
	            // the invisible shape in front of the point that gets mouse events
	            if (!state.mouseTarget) {
	                var center = self.state.coord;
	                var radii = graphie.unscaleVector(24);
	                var _options = {
	                    mouselayer: true,
	                    padding: 0
	                };
	                state.mouseTarget = new WrappedEllipse(graphie, center, radii, _options);
	                state.mouseTarget.attr({ fill: "#000", opacity: 0.0 });
	            }
	        }
	
	        var showTrashTooltip = function showTrashTooltip() {
	            _this2._showTooltip(function (container) {
	                ReactDOM.render(React.createElement(
	                    "span",
	                    { style: { fontSize: "2em" } },
	                    React.createElement(InlineIcon, _extends({}, iconTrash, { style: {
	                            position: "static",
	                            color: KhanColors.INTERACTIVE,
	                            marginLeft: 9,
	                            marginRight: 9
	                        }
	                    }))
	                ), container);
	            });
	        };
	
	        // The starting coord of any move, sent to onMoveEnd as the previous
	        // value
	        var startCoord = state.coord;
	
	        // The Movable representing this movablePoint's representation
	        // This handles mouse events for us, which we propagate in
	        // onMove
	        self.movable.modify(_.extend({}, state, {
	            add: null,
	            modify: null,
	            draw: self.draw.bind(self),
	            remove: null,
	            onMoveStart: function onMoveStart(startMouseCoord) {
	                state.hasMoved = false;
	                startCoord = state.coord;
	
	                // Save the offset between the cursor and the initial coordinate
	                // of the point. This is tracked so as to avoid locking the
	                // moving point to the user's finger on touch devices, which
	                // would obscure it, no matter how large we made the touch
	                // target. Instead, we respect the offset at which the point was
	                // grabbed for the entirety of the gesture, if it's a
	                // touch-based interaction.
	                if (state.touchOffset == null) {
	                    var isMouse = !('ontouchstart' in window);
	                    state.touchOffset = isMouse ? [0, 0] : kvector.subtract(startCoord, startMouseCoord);
	                }
	
	                var svgElem = state.visibleShape.wrapper;
	                if (state.shadow) {
	                    var filter = "none";
	                    svgElem.style.webkitFilter = filter;
	                    svgElem.style.filter = filter;
	                }
	
	                if (state.showHairlines) {
	                    state.showHairlines(state.coord);
	                }
	
	                tooltipResetFunctions.forEach(function (f) {
	                    return f();
	                });
	                if (state.tooltip) {
	                    if (state.xOnlyTooltip) {
	                        _this2._showTooltip("" + state.coord[0]);
	                    } else {
	                        _this2._showTooltip("(" + state.coord[0] + ", " + state.coord[1] + ")");
	                    }
	
	                    if (state.shadow) {
	                        var content = svgElem.getElementsByClassName("tooltip-content")[0];
	                        var _filter = "drop-shadow(0px 0px 5px rgba(0, 0, 0, 0.5))";
	
	                        content.style.webkitFilter = _filter;
	                        content.style.filter = _filter;
	                    }
	                }
	
	                self._fireEvent(state.onMoveStart, startCoord, startCoord);
	                self.draw();
	            },
	            onMove: function onMove(mouseCoord, prevMouseCoord) {
	                var transformedCoord = kvector.add(mouseCoord, state.touchOffset);
	
	                self.moveTo(transformedCoord);
	
	                if (state.showHairlines) {
	                    if (!_this2.state.outOfBounds) {
	                        state.showHairlines(state.coord);
	                    } else {
	                        state.hideHairlines();
	                    }
	                }
	
	                if (state.tooltip) {
	                    if (!_this2.state.outOfBounds) {
	                        if (state.xOnlyTooltip) {
	                            _this2._showTooltip("" + state.coord[0]);
	                        } else {
	                            _this2._showTooltip("(" + state.coord[0] + ", " + state.coord[1] + ")");
	                        }
	                    }
	                }
	
	                if (state.onRemove && _this2.state.outOfBounds) {
	                    showTrashTooltip();
	                }
	            },
	            onMoveEnd: function onMoveEnd() {
	                if (self.isHovering() && !state.hasMoved) {
	                    self._fireEvent(state.onClick, state.coord, startCoord);
	                }
	
	                var svgElem = state.visibleShape.wrapper;
	
	                if (state.shadow) {
	                    var filter = "drop-shadow(0px 0px 5px rgba(0, 0, 0, 0.5))";
	                    svgElem.style.webkitFilter = filter;
	                    svgElem.style.filter = filter;
	                }
	
	                if (state.hideHairlines) {
	                    state.hideHairlines();
	                }
	
	                if (state.hasMoved) {
	                    _this2._hideTooltip();
	                } else if (state.onRemove) {
	                    // If we haven't moved and we should be displaying trash
	                    // tooltips.
	                    showTrashTooltip();
	
	                    var content = svgElem.getElementsByClassName("tooltip-content")[0];
	
	                    content.style.webkitFilter = "none";
	                    content.style.filter = "none";
	
	                    _this2._tooltip.firstChild.addEventListener("touchstart", function (e) {
	                        // Prevent creation of a new point when the event is
	                        // propagated up the DOM.
	                        e.stopPropagation();
	                    }, true);
	
	                    _this2._tooltip.firstChild.addEventListener("touchend", function (e) {
	                        // Remove the point and prevent creation of a
	                        // new point.
	                        state.onRemove();
	                        e.stopPropagation();
	                    }, true);
	                } else if (state.tooltip) {
	                    _this2._hideTooltip();
	                }
	
	                if (state.outOfBounds) {
	                    state.onRemove();
	                }
	
	                self._fireEvent(state.onMoveEnd, state.coord, startCoord);
	                state.hasMoved = false;
	                state.touchOffset = null;
	                self.draw();
	            }
	        }));
	
	        // Trigger an add event if this hasn't been added before
	        if (!state.added) {
	            self.prevState = {};
	            self._fireEvent(state.add, self.cloneState(), self.prevState);
	            state.added = true;
	
	            // Update the state for `added` and in case the add event
	            // changed it
	            self.prevState = self.cloneState();
	        }
	
	        // Trigger a modify event
	        self._fireEvent(state.modify, self.cloneState(), self.prevState);
	    },
	
	    remove: function remove() {
	        this.state.added = false;
	        this._fireEvent(this.state.remove);
	        if (this.movable) {
	            this.movable.remove();
	        }
	        // TODO(jack): This should really be moved off of
	        // movablePoint.state and only kept on movable.state
	        this.state.mouseTarget = null;
	    },
	
	    constrain: function constrain() {
	        var result = this._applyConstraints(this.coord(), this.coord());
	        if (kpoint.is(result)) {
	            this.setCoord(result);
	        }
	        return result !== false;
	    },
	
	    setCoord: function setCoord(coord) {
	        assert(kpoint.is(coord, 2));
	        this.state.coord = _.clone(coord);
	        this.draw();
	    },
	
	    setCoordConstrained: function setCoordConstrained(coord) {
	        assert(kpoint.is(coord, 2));
	        var result = this._applyConstraints(coord, this.coord());
	        if (result !== false) {
	            this.state.coord = _.clone(result);
	            this.draw();
	        }
	    },
	
	    moveTo: function moveTo(coord) {
	        var _this3 = this;
	
	        // The caller has the option of adding an onMove() method to the
	        // movablePoint object we return as a sort of event handler
	        // By returning false from onMove(), the move can be vetoed,
	        // providing custom constraints on where the point can be moved.
	        // By returning array [x, y], the move can be overridden
	
	        var state = this.state;
	
	        this.state.outOfBounds = false;
	        var result = this._applyConstraints(coord, state.coord, state.onRemove ? {
	            onOutOfBounds: function onOutOfBounds() {
	                _this3.state.outOfBounds = true;
	            }
	        } : {});
	
	        if (result === false) {
	            return;
	        } else if (kpoint.is(result)) {
	            coord = result;
	        }
	        if (!kpoint.equal(coord, state.coord)) {
	            var prevCoord = state.coord;
	            state.coord = coord;
	            state.hasMoved = true;
	            this._fireEvent(state.onMove, state.coord, prevCoord);
	            this.draw();
	        }
	    },
	
	    // Clone these for use with raphael, which modifies the input
	    // style parameters
	    normalStyle: function normalStyle() {
	        return _.clone(this.state.normalStyle);
	    },
	
	    highlightStyle: function highlightStyle() {
	        return _.clone(this.state.highlightStyle);
	    },
	
	    // Change z-order to back
	    toBack: function toBack() {
	        this.movable.toBack();
	        if (this.state.visibleShape) {
	            this.state.visibleShape.toBack();
	        }
	    },
	
	    // Change z-order to front
	    toFront: function toFront() {
	        if (this.state.visibleShape) {
	            this.state.visibleShape.toFront();
	        }
	        this.movable.toFront();
	    },
	
	    /**
	     * Forwarding methods to this.movable:
	     */
	    isHovering: function isHovering() {
	        return this.movable.isHovering();
	    },
	
	    isDragging: function isDragging() {
	        return this.movable.isDragging();
	    },
	
	    mouseTarget: function mouseTarget() {
	        return this.movable.mouseTarget();
	    },
	
	    grab: function grab(coord) {
	        // Provide an explicit touchOffset override, so that we track the user's
	        // finger when a point has been grabbed.
	        this.state.touchOffset = [0, 0];
	
	        this.movable.grab(coord);
	        this.moveTo(coord);
	    }
	});
	
	module.exports = MovablePoint;

/***/ },
/* 286 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * MovableLine
	 */
	var _ = __webpack_require__(56);
	
	var MovableLineOptions = __webpack_require__(314);
	var WrappedLine = __webpack_require__(267);
	var InteractiveUtil = __webpack_require__(256);
	var objective_ = __webpack_require__(80);
	var assert = InteractiveUtil.assert;
	var normalizeOptions = InteractiveUtil.normalizeOptions;
	
	var kvector = __webpack_require__(275).vector;
	var KhanColors = __webpack_require__(268);
	
	var FUNCTION_ARRAY_OPTIONS = ["add", "draw", "remove", "onMoveStart", "constraints", "onMove", "onMoveEnd"];
	
	// Default "props" and "state". Both are added to this.state and
	// receive magic getter methods (this.cursor() etc).
	// However, properties in DEFAULT_PROPS are updated on `modify()`,
	// while those in DEFAULT_STATE persist and are not updated.
	// Things that the user might want to change should be on "props",
	// while things used to render the point should be on "state".
	var DEFAULT_PROPS = {
	    points: null,
	    static: false,
	    cursor: "move",
	    normalStyle: null, // turned into an object in this.modify
	    highlightStyle: null, // likewise
	    extendLine: false,
	    extendRay: false
	};
	var DEFAULT_STATE = {
	    visibleShape: null,
	    mouseTarget: null
	};
	
	var MovableLine = function MovableLine(graphie, movable, options) {
	    assert(graphie != null);
	    assert(options != null);
	
	    _.extend(this, {
	        graphie: graphie,
	        movable: movable,
	        state: {
	            // Set here because this must be unique for each instance
	            id: _.uniqueId("movableLine")
	        }
	    });
	
	    // We only set DEFAULT_STATE once, here
	    this.modify(_.extend({}, DEFAULT_STATE, options));
	};
	
	_.extend(MovableLine, MovableLineOptions);
	InteractiveUtil.createGettersFor(MovableLine, _.extend({}, DEFAULT_PROPS, DEFAULT_STATE));
	InteractiveUtil.addMovableHelperMethodsTo(MovableLine);
	
	_.extend(MovableLine.prototype, {
	
	    cloneState: function cloneState() {
	        return _.extend(this.movable.cloneState(), {
	            coords: this.coords()
	        }, this.state);
	    },
	
	    _createDefaultState: function _createDefaultState() {
	        return _.extend({
	            id: this.state.id
	        }, normalizeOptions(FUNCTION_ARRAY_OPTIONS,
	        // Defaults are copied from MovableLineOptions.*.standard
	        // These defaults are set here instead of DEFAULT_PROPS/STATE
	        // because they:
	        //    - are objects, not primitives (and need a deeper copy)
	        //    - they don't need getters created for them
	        // TODO(jack): Consider "default" once we es3ify perseus
	        objective_.pluck(MovableLineOptions, "standard")), DEFAULT_PROPS);
	    },
	
	    /**
	     * Resets the object to its state as if it were constructed with
	     * `options` originally. state not on DEFAULT_PROPS is maintained.
	     *
	     * Analogous to React.js's replaceProps
	     */
	    modify: function modify(options) {
	        this.update(_.extend(this._createDefaultState(), options));
	    },
	
	    /**
	     * Adjusts constructor parameters without changing previous settings
	     * for any option not specified
	     *
	     * Analogous to React.js's setProps
	     */
	    update: function update(options) {
	        var self = this;
	        var graphie = this.graphie;
	        var state = self.state = _.extend(self.state, normalizeOptions(FUNCTION_ARRAY_OPTIONS, options));
	
	        // Default things inside the state.normalStyle object, because
	        // _.extend is not deep.
	        // We use _.extend instead of _.defaults because we don't want
	        // to modify the passed-in copy (especially if it's from
	        // DEFAULT_PROPERTIES!)
	        var normalColor = state.static ? KhanColors.DYNAMIC : KhanColors.INTERACTIVE;
	        state.normalStyle = _.extend({
	            stroke: normalColor,
	            "stroke-width": 2
	        }, state.normalStyle);
	
	        state.highlightStyle = _.extend({
	            stroke: KhanColors.INTERACTING,
	            "stroke-width": 3
	        }, state.highlightStyle);
	
	        if (!state.static) {
	            // the invisible shape in front of the line that gets mouse events
	            if (!state.mouseTarget) {
	                var _options = {
	                    thickness: 30,
	                    mouselayer: true
	                };
	                state.mouseTarget = new WrappedLine(graphie, this.coord(0), this.coord(1), _options);
	                state.mouseTarget.attr({ fill: "#000", "opacity": 0.0 });
	            }
	        }
	
	        if (state.static && state.mouseTarget) {
	            // state.static was specified, remove any previously
	            // existing mousetarget (from a previous modify)
	            state.mouseTarget.remove();
	            state.mouseTarget = null;
	        }
	
	        // The movable that handles mouse events for us
	        self.movable.modify(_.extend({}, state, {
	            mouseTarget: state.mouseTarget,
	
	            // We null out the add/modify/remove to avoid propagating our
	            // state.add... to the movable, so that we can fire those
	            // events ourselves, rather than letting the movable handle
	            // them
	            add: null,
	            modify: null,
	            draw: self.draw.bind(self),
	            remove: null,
	
	            onMoveStart: function onMoveStart() {
	                self._initialRefCoord = self.coord(0);
	                self._prevRefCoord = self._initialRefCoord;
	                self._totalDelta = [0, 0];
	
	                self._fireEvent(self.state.onMoveStart, self.coord(0), self.coord(0));
	            },
	
	            onMove: function onMove(mouseCoord, prevMouseCoord) {
	                var delta = kvector.subtract(mouseCoord, prevMouseCoord);
	                self._totalDelta = kvector.add(self._totalDelta, delta);
	                var refCoord = kvector.add(self._initialRefCoord, self._totalDelta);
	
	                refCoord = self._applyConstraints(refCoord, self._prevRefCoord);
	                if (refCoord === false) {
	                    return;
	                }
	
	                self._fireEvent(self.state.onMove, refCoord, self._prevRefCoord);
	                self._prevRefCoord = refCoord;
	            },
	
	            onMoveEnd: function onMoveEnd() {
	                self._fireEvent(self.state.onMoveEnd, self._prevRefCoord, self._initialRefCoord);
	            }
	        }));
	
	        // Trigger an add event if this hasn't been added before
	        if (!state.added) {
	            self.prevState = {};
	            self._fireEvent(state.add, self.cloneState(), self.prevState);
	            state.added = true;
	
	            // Update the line with the points' movement
	            _.invoke(state.points, "listen", "onMove", state.id, self.draw.bind(self));
	
	            // Update the state for `added` and in case the add event
	            // changed it
	            self.prevState = self.cloneState();
	        }
	
	        // Trigger a modify event
	        self._fireEvent(state.modify, self.cloneState(), self.prevState);
	    },
	
	    coords: function coords() {
	        return _.invoke(this.state.points, "coord");
	    },
	
	    point: function point(index) {
	        return this.state.points[index];
	    },
	
	    coord: function coord(index) {
	        return this.point(index).coord();
	    },
	
	    remove: function remove() {
	        this.state.added = false;
	        this._fireEvent(this.state.remove);
	        if (this.points) {
	            _.invoke(this.points, "unlisten", "onMove", this.state.id);
	        }
	
	        if (this.movable) {
	            // We need this to be guarded because it is called on the initial
	            // constructor/modify call, before this.movable is created
	            this.movable.remove();
	        }
	    },
	
	    // Change z-order to back
	    toBack: function toBack() {
	        this.movable.toBack();
	        if (this.state.visibleShape) {
	            this.state.visibleShape.toBack();
	        }
	    },
	
	    // Change z-order to front
	    toFront: function toFront() {
	        if (this.state.visibleShape) {
	            this.state.visibleShape.toFront();
	        }
	        this.movable.toFront();
	    },
	
	    /**
	     * Forwarding methods to this.movable:
	     */
	    isHovering: function isHovering() {
	        return this.movable.isHovering();
	    },
	
	    isDragging: function isDragging() {
	        return this.movable.isDragging();
	    },
	
	    mouseTarget: function mouseTarget() {
	        return this.movable.mouseTarget();
	    }
	});
	
	module.exports = MovableLine;

/***/ },
/* 287 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Creates and adds a polygon to the graph that can be dragged around.
	 * It allows constraints on its movement and draws when moves happen.
	 */
	var kvector = __webpack_require__(275).vector;
	var _ = __webpack_require__(56);
	
	var MovablePolygonOptions = __webpack_require__(313);
	var InteractiveUtil = __webpack_require__(256);
	var objective_ = __webpack_require__(80);
	var assert = InteractiveUtil.assert;
	var normalizeOptions = InteractiveUtil.normalizeOptions;
	var KhanColors = __webpack_require__(268);
	var GraphUtils = __webpack_require__(244);
	
	// State parameters that should be converted into an array of
	// functions
	var FUNCTION_ARRAY_OPTIONS = _.keys(MovablePolygonOptions);
	
	// Default "props" and "state". Both are added to this.state and
	// receive magic getter methods (this.points() etc).
	// However, properties in DEFAULT_PROPS are updated on `modify()`,
	// while those in DEFAULT_STATE persist and are not updated.
	// Things that the user might want to change should be on "props",
	// while things used to render the point should be on "state".
	var DEFAULT_PROPS = {
	    points: null,
	    angleLabels: [],
	    showRightAngleMarkers: [],
	    sideLabels: [],
	    vertexLabels: [],
	    numArcs: [],
	    numArrows: [],
	    numTicks: [],
	    closed: true,
	    static: false,
	    cursor: "move",
	    normalStyle: null, // turned into an object in this.modify
	    highlightStyle: null, // likewise
	    labelStyle: null // likewise
	};
	var DEFAULT_STATE = {
	    added: false,
	    hasMoved: false,
	    visibleShape: null,
	    mouseTarget: null
	};
	
	var MovablePolygon = function MovablePolygon(graphie, movable, options) {
	    assert(graphie != null);
	    assert(options != null);
	
	    _.extend(this, {
	        graphie: graphie,
	        movable: movable,
	        state: {
	            // Set here because this must be unique for each instance
	            id: _.uniqueId("movablePolygon")
	        }
	    });
	
	    // We only set DEFAULT_STATE once, here
	    this.modify(_.extend({}, DEFAULT_STATE, options));
	};
	
	_.extend(MovablePolygon, MovablePolygonOptions);
	InteractiveUtil.createGettersFor(MovablePolygon, _.extend({}, DEFAULT_PROPS, DEFAULT_STATE));
	InteractiveUtil.addMovableHelperMethodsTo(MovablePolygon);
	
	_.extend(MovablePolygon.prototype, {
	
	    cloneState: function cloneState() {
	        return _.extend(this.movable.cloneState(), this.state);
	    },
	
	    _createDefaultState: function _createDefaultState() {
	        return _.extend({
	            id: this.state.id
	        }, normalizeOptions(FUNCTION_ARRAY_OPTIONS,
	        // Defaults are copied from MovablePolygonOptions.*.standard
	        // These defaults are set here instead of DEFAULT_PROPS/STATE
	        // because they:
	        //    - are objects, not primitives (and need a deeper copy)
	        //    - they don't need getters created for them
	        // TODO(jack): Consider "default" once we es3ify perseus
	        objective_.pluck(MovablePolygonOptions, "standard")
	
	        // We only update props here, because we want things on state to
	        // be persistent, and updated appropriately in modify()
	        ), DEFAULT_PROPS);
	    },
	
	    /**
	     * Resets the object to its state as if it were constructed with
	     * `options` originally. state not on DEFAULT_PROPS is maintained.
	     *
	     * Analogous to React.js's replaceProps
	     */
	    modify: function modify(options) {
	        this.update(_.extend(this._createDefaultState(), options));
	    },
	
	    /**
	     * Adjusts constructor parameters without changing previous settings
	     * for any option not specified
	     *
	     * Analogous to React.js's setProps
	     */
	    update: function update(options) {
	        var self = this;
	        var graphie = self.graphie;
	        var state = _.extend(self.state, normalizeOptions(FUNCTION_ARRAY_OPTIONS, options));
	
	        // Default things inside the state.normalStyle object, because
	        // _.extend is not deep.
	        // We use _.extend instead of _.defaults because we don't want
	        // to modify the passed-in copy (especially if it's from
	        // DEFAULT_PROPS/STATE!)
	        var normalColor = state.static ? KhanColors.DYNAMIC : KhanColors.INTERACTIVE;
	        state.normalStyle = _.extend({}, state.normalStyle, {
	            "stroke-width": 2,
	            "fill-opacity": 0,
	            "fill": normalColor,
	            "stroke": normalColor
	        }, options.normalStyle);
	
	        state.highlightStyle = _.extend({}, {
	            "stroke": KhanColors.INTERACTING,
	            "stroke-width": 2,
	            "fill": KhanColors.INTERACTING,
	            "fill-opacity": 0.05
	        }, state.highlightStyle);
	
	        state.labelStyle = _.extend({}, {
	            "stroke": KhanColors.DYNAMIC,
	            "stroke-width": 1,
	            "color": KhanColors.DYNAMIC
	        }, state.labelStyle);
	
	        if (!state.static) {
	            // the invisible shape in front of the point that gets mouse events
	            if (!state.mouseTarget) {
	                state.mouseTarget = graphie.mouselayer.path(this.path());
	                state.mouseTarget.attr({ fill: "#000", opacity: 0,
	                    cursor: "move" });
	            }
	        }
	
	        // The Movable representing this MovablePolygon's representation
	        // This handles mouse events for us, which we propagate in
	        // onMove. The onMoveStart-onMove-onMoveEnd logic is borrowed from
	        // movable-line.js.
	        self.movable.modify(_.extend({}, state, {
	            modify: null,
	            draw: self.draw.bind(self),
	            remove: null,
	            onMoveStart: function onMoveStart() {
	                self._initialRefCoord = self.coord(0);
	                self._prevRefCoord = self._initialRefCoord;
	                self._totalDelta = [0, 0];
	
	                self._fireEvent(self.state.onMoveStart, self.coord(0), self.coord(0));
	            },
	            onMove: function onMove(mouseCoord, prevMouseCoord) {
	                var delta = kvector.subtract(mouseCoord, prevMouseCoord);
	                self._totalDelta = kvector.add(self._totalDelta, delta);
	                var refCoord = kvector.add(self._initialRefCoord, self._totalDelta);
	
	                refCoord = self._applyConstraints(refCoord, self._prevRefCoord);
	                if (refCoord === false) {
	                    return;
	                }
	
	                self._fireEvent(self.state.onMove, refCoord, self._prevRefCoord);
	                self._prevRefCoord = refCoord;
	            },
	            onMoveEnd: function onMoveEnd() {
	                self._fireEvent(self.state.onMoveEnd, self._prevRefCoord, self._initialRefCoord);
	            }
	        }));
	
	        // Update the polygon with the points' movement
	        _.invoke(state.points, "listen", "onMove", state.id, self.draw.bind(self));
	
	        // Trigger an add event if this hasn't been added before
	        if (!state.added) {
	            self.prevState = {};
	            self._fireEvent(state.add, self.cloneState(), self.prevState);
	            state.added = true;
	
	            // Update the state for `added` and in case the add event
	            // changed it
	            self.prevState = self.cloneState();
	        }
	
	        // Trigger a modify event
	        self._fireEvent(state.modify, self.cloneState(), self.prevState);
	    },
	
	    path: function path(state) {
	        var graphie = this.graphie;
	        state = state || this.state;
	
	        var coords = _.map(state.points, function (point) {
	            return graphie.scalePoint(point.coord());
	        });
	
	        // Create path
	        if (state.closed) {
	            coords.push(true);
	        } else {
	            // For open polygons, concatenate a reverse of the path,
	            // to remove the inside area of the path, which would
	            // otherwise be clickable (even if the closing line segment
	            // wasn't drawn
	            coords = coords.concat(_.clone(coords).reverse());
	        }
	
	        return GraphUtils.unscaledSvgPath(coords);
	    },
	
	    coords: function coords() {
	        return _.invoke(this.state.points, "coord");
	    },
	
	    point: function point(index) {
	        return this.state.points[index];
	    },
	
	    coord: function coord(index) {
	        return this.point(index).coord();
	    },
	
	    remove: function remove() {
	        this.state.added = false;
	        this._fireEvent(this.state.remove);
	        if (this.state.points) {
	            _.invoke(this.state.points, "unlisten", "onMove", this.state.id);
	        }
	
	        if (this.movable) {
	            // We need this to be guarded because it is called on the initial
	            // constructor/modify call, before this.movable is created
	            this.movable.remove();
	        }
	
	        // TODO(jack): This should really be moved off of
	        // movablePolygon.state and only kept on movable.state
	        this.state.mouseTarget = null;
	    },
	
	    constrain: function constrain() {
	        if (this.points == null || this.points.length === 0) {
	            return;
	        }
	
	        var prevRefCoord = this.coord(0);
	        var refCoord = this._applyConstraints(prevRefCoord, prevRefCoord);
	        if (refCoord !== false) {
	            this._fireEvent(this.state.onMove, refCoord, prevRefCoord);
	        }
	    },
	
	    // Clone these for use with raphael, which modifies the input
	    // style parameters
	    normalStyle: function normalStyle() {
	        return _.clone(this.state.normalStyle);
	    },
	
	    highlightStyle: function highlightStyle() {
	        return _.clone(this.state.highlightStyle);
	    },
	
	    // Change z-order to back
	    toBack: function toBack() {
	        this.movable.toBack();
	        if (this.state.visibleShape) {
	            this.state.visibleShape.toBack();
	        }
	    },
	
	    // Change z-order to front
	    toFront: function toFront() {
	        if (this.state.visibleShape) {
	            this.state.visibleShape.toFront();
	        }
	        this.movable.toFront();
	    },
	
	    /**
	     * Forwarding methods to this.movable:
	     */
	    isHovering: function isHovering() {
	        return this.movable.isHovering();
	    },
	
	    isDragging: function isDragging() {
	        return this.movable.isDragging();
	    },
	
	    mouseTarget: function mouseTarget() {
	        return this.movable.mouseTarget();
	    }
	});
	
	module.exports = MovablePolygon;

/***/ },
/* 288 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Default methods for a wrapped movable.
	 */
	
	var _ = __webpack_require__(56);
	var InteractiveUtil = __webpack_require__(256);
	var objective_ = __webpack_require__(80);
	var kvector = __webpack_require__(275).vector;
	
	/*
	 * These functions, when called on the wrapped object, simply pass the
	 * arguments to the underlying Raphael object.
	 */
	var PASS_TO_RAPHAEL = ["attr", "animate"];
	
	var WrappedDefaults = _.extend({
	    transform: function transform(transformation) {
	        var prefixedTransform = InteractiveUtil.getPrefixedTransform();
	        this.wrapper.style[prefixedTransform] = transformation;
	    },
	
	    toFront: function toFront() {
	        var parentNode = this.wrapper.parentNode;
	        // TODO(emily): Sometimes, we call `.remove()` but then hold a
	        // reference to this object, and sometimes call `.toFront` on it.
	        // Notably, this happens in the reflection transformation in the
	        // Transformer widget. This is a hacky fix. Make this less bad.
	        if (parentNode) {
	            parentNode.appendChild(this.wrapper);
	        }
	    },
	
	    toBack: function toBack() {
	        var parentNode = this.wrapper.parentNode;
	        if (parentNode.firstChild !== this.wrapper) {
	            parentNode.insertBefore(this.wrapper, parentNode.firstChild);
	        }
	    },
	
	    remove: function remove() {
	        this.visibleShape.remove();
	        $(this.wrapper).remove();
	    },
	
	    getMouseTarget: function getMouseTarget() {
	        return this.visibleShape[0];
	    },
	
	    moveTo: function moveTo(point) {
	        var delta = kvector.subtract(this.graphie.scalePoint(point), this.graphie.scalePoint(this.initialPoint));
	        var do3dTransform = InteractiveUtil.getCanUse3dTransform();
	        var transformation = "translateX(" + delta[0] + "px) " + "translateY(" + delta[1] + "px)" + (do3dTransform ? " translateZ(0)" : "");
	        this.transform(transformation);
	    },
	
	    hide: function hide() {
	        this.visibleShape.hide();
	    },
	
	    show: function show() {
	        this.visibleShape.show();
	    }
	}, objective_.mapObjectFromArray(PASS_TO_RAPHAEL, function (attribute) {
	    return function () {
	        var _visibleShape;
	
	        (_visibleShape = this.visibleShape)[attribute].apply(_visibleShape, arguments);
	    };
	}));
	
	module.exports = WrappedDefaults;

/***/ },
/* 289 */,
/* 290 */,
/* 291 */,
/* 292 */,
/* 293 */,
/* 294 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(397),
	    Provider = _require.Provider;
	
	var KeypadContainer = __webpack_require__(311);
	
	var _require2 = __webpack_require__(316),
	    activateKeypad = _require2.activateKeypad,
	    dismissKeypad = _require2.dismissKeypad,
	    configureKeypad = _require2.configureKeypad,
	    setCursor = _require2.setCursor,
	    setKeyHandler = _require2.setKeyHandler;
	
	var createStore = __webpack_require__(317);
	
	var ProvidedKeypad = function (_React$Component) {
	    _inherits(ProvidedKeypad, _React$Component);
	
	    function ProvidedKeypad() {
	        var _temp, _this, _ret;
	
	        _classCallCheck(this, ProvidedKeypad);
	
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.activate = function () {
	            _this.store.dispatch(activateKeypad());
	        }, _this.dismiss = function () {
	            _this.store.dispatch(dismissKeypad());
	        }, _this.configure = function (configuration, cb) {
	            _this.store.dispatch(configureKeypad(configuration));
	
	            // HACK(charlie): In Perseus, triggering a focus causes the keypad to
	            // animate into view and re-configure. We'd like to provide the option
	            // to re-render the re-configured keypad before animating it into view,
	            // to avoid jank in the animation. As such, we support passing a
	            // callback into `configureKeypad`. However, implementing this properly
	            // would require middleware, etc., so we just hack it on with
	            // `setTimeout` for now.
	            setTimeout(function () {
	                return cb && cb();
	            });
	        }, _this.setCursor = function (cursor) {
	            _this.store.dispatch(setCursor(cursor));
	        }, _this.setKeyHandler = function (keyHandler) {
	            _this.store.dispatch(setKeyHandler(keyHandler));
	        }, _temp), _possibleConstructorReturn(_this, _ret);
	    }
	
	    ProvidedKeypad.prototype.componentWillMount = function componentWillMount() {
	        this.store = createStore();
	    };
	
	    ProvidedKeypad.prototype.render = function render() {
	        var _this2 = this;
	
	        var _props = this.props,
	            _onElementMounted = _props.onElementMounted,
	            rest = _objectWithoutProperties(_props, ['onElementMounted']);
	
	        return React.createElement(
	            Provider,
	            { store: this.store },
	            React.createElement(KeypadContainer, _extends({
	                onElementMounted: function onElementMounted(element) {
	                    // Append the dispatch methods that we want to expose
	                    // externally to the returned React element.
	                    var elementWithDispatchMethods = _extends({}, element, {
	                        activate: _this2.activate,
	                        dismiss: _this2.dismiss,
	                        configure: _this2.configure,
	                        setCursor: _this2.setCursor,
	                        setKeyHandler: _this2.setKeyHandler
	                    });
	                    _onElementMounted && _onElementMounted(elementWithDispatchMethods);
	                }
	            }, rest))
	        );
	    };
	
	    return ProvidedKeypad;
	}(React.Component);
	
	ProvidedKeypad.propTypes = {
	    onElementMounted: React.PropTypes.func
	};
	
	
	module.exports = ProvidedKeypad;

/***/ },
/* 295 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * React PropTypes that may be shared between components.
	 */
	
	var React = __webpack_require__(43);
	
	var KeyConfigs = __webpack_require__(315);
	var CursorContexts = __webpack_require__(310);
	
	var _require = __webpack_require__(283),
	    BorderDirections = _require.BorderDirections,
	    EchoAnimationTypes = _require.EchoAnimationTypes,
	    IconTypes = _require.IconTypes,
	    KeyTypes = _require.KeyTypes,
	    KeypadTypes = _require.KeypadTypes;
	
	var iconPropType = React.PropTypes.shape({
	    type: React.PropTypes.oneOf(Object.keys(IconTypes)).isRequired,
	    data: React.PropTypes.string.isRequired
	});
	
	var keyIdPropType = React.PropTypes.oneOf(Object.keys(KeyConfigs));
	
	var keyConfigPropType = React.PropTypes.shape({
	    ariaLabel: React.PropTypes.string,
	    id: keyIdPropType.isRequired,
	    type: React.PropTypes.oneOf(Object.keys(KeyTypes)).isRequired,
	    childKeyIds: React.PropTypes.arrayOf(keyIdPropType),
	    icon: iconPropType.isRequired
	});
	
	var keypadConfigurationPropType = React.PropTypes.shape({
	    keypadType: React.PropTypes.oneOf(Object.keys(KeypadTypes)).isRequired,
	    extraKeys: React.PropTypes.arrayOf(keyIdPropType)
	});
	
	// NOTE(charlie): This is a React element.
	var keypadElementPropType = React.PropTypes.shape({
	    activate: React.PropTypes.func.isRequired,
	    dismiss: React.PropTypes.func.isRequired,
	    configure: React.PropTypes.func.isRequired,
	    setCursor: React.PropTypes.func.isRequired,
	    setKeyHandler: React.PropTypes.func.isRequired
	});
	
	var bordersPropType = React.PropTypes.arrayOf(React.PropTypes.oneOf(Object.keys(BorderDirections)));
	
	var boundingBoxPropType = React.PropTypes.shape({
	    height: React.PropTypes.number,
	    width: React.PropTypes.number,
	    top: React.PropTypes.number,
	    right: React.PropTypes.number,
	    bottom: React.PropTypes.number,
	    left: React.PropTypes.number
	});
	
	var echoPropType = React.PropTypes.shape({
	    animationId: React.PropTypes.string.isRequired,
	    animationType: React.PropTypes.oneOf(Object.keys(EchoAnimationTypes)).isRequired,
	    borders: bordersPropType,
	    id: keyIdPropType.isRequired,
	    initialBounds: boundingBoxPropType.isRequired
	});
	
	var cursorContextPropType = React.PropTypes.oneOf(Object.keys(CursorContexts));
	
	var popoverPropType = React.PropTypes.shape({
	    parentId: keyIdPropType.isRequired,
	    bounds: boundingBoxPropType.isRequired,
	    childKeyIds: React.PropTypes.arrayOf(keyIdPropType).isRequired
	});
	
	var childrenPropType = React.PropTypes.oneOfType([React.PropTypes.arrayOf(React.PropTypes.node), React.PropTypes.node]);
	
	module.exports = {
	    keyConfigPropType: keyConfigPropType,
	    keyIdPropType: keyIdPropType,
	    keypadConfigurationPropType: keypadConfigurationPropType,
	    keypadElementPropType: keypadElementPropType,
	    bordersPropType: bordersPropType,
	    boundingBoxPropType: boundingBoxPropType,
	    echoPropType: echoPropType,
	    cursorContextPropType: cursorContextPropType,
	    popoverPropType: popoverPropType,
	    iconPropType: iconPropType,
	    childrenPropType: childrenPropType
	};

/***/ },
/* 296 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/* globals i18n */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet;
	
	var _require2 = __webpack_require__(357),
	    View = _require2.View;
	
	var CursorHandle = __webpack_require__(351);
	var MathWrapper = __webpack_require__(352);
	var scrollIntoView = __webpack_require__(353);
	var DragListener = __webpack_require__(354);
	
	var _require3 = __webpack_require__(355),
	    cursorHandleRadiusPx = _require3.cursorHandleRadiusPx,
	    cursorHandleDistanceMultiplier = _require3.cursorHandleDistanceMultiplier,
	    gray76 = _require3.gray76;
	
	var _require4 = __webpack_require__(295),
	    keypadElementPropType = _require4.keypadElementPropType;
	
	var _require5 = __webpack_require__(355),
	    brightGreen = _require5.brightGreen,
	    gray17 = _require5.gray17;
	
	var constrainingFrictionFactor = 0.8;
	
	var MathInput = function (_React$Component) {
	    _inherits(MathInput, _React$Component);
	
	    function MathInput() {
	        var _temp, _this, _ret;
	
	        _classCallCheck(this, MathInput);
	
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {
	            focused: false,
	            handle: {
	                animateIntoPosition: false,
	                visible: false,
	                x: 0,
	                y: 0
	            }
	        }, _this._clearKeypadBoundsCache = function (keypadNode) {
	            _this._keypadBounds = null;
	        }, _this._cacheKeypadBounds = function (keypadNode) {
	            _this._keypadBounds = keypadNode.getBoundingClientRect();
	        }, _this._getKeypadBounds = function () {
	            if (!_this._keypadBounds) {
	                var node = ReactDOM.findDOMNode(_this.props.keypadElement);
	                _this._cacheKeypadBounds(node);
	            }
	            return _this._keypadBounds;
	        }, _this._updateCursorHandle = function (animateIntoPosition) {
	            var containerBounds = _this._container.getBoundingClientRect();
	            var cursor = _this._container.querySelector('.mq-cursor');
	            var cursorBounds = cursor.getBoundingClientRect();
	
	            var cursorWidth = cursorBounds.width;
	            var gapBelowCursor = 2;
	
	            _this.setState({
	                handle: {
	                    visible: true,
	                    animateIntoPosition: animateIntoPosition,
	                    // We subtract containerBounds' left/top to correct for the
	                    // position of the container within the page.
	                    x: cursorBounds.left + cursorWidth / 2 - containerBounds.left,
	                    y: cursorBounds.bottom + gapBelowCursor - containerBounds.top
	                }
	            });
	        }, _this._hideCursorHandle = function () {
	            _this.setState({
	                handle: {
	                    visible: false,
	                    x: 0,
	                    y: 0
	                }
	            });
	        }, _this.blur = function () {
	            _this.mathField.blur();
	            _this.props.onBlur && _this.props.onBlur();
	            _this.setState({ focused: false, handle: { visible: false } });
	        }, _this.focus = function () {
	            // Pass this component's handleKey method to the keypad so it can call
	            // it whenever it needs to trigger a keypress action.
	            _this.props.keypadElement.setKeyHandler(function (key) {
	                var cursor = _this.mathField.pressKey(key);
	
	                // Trigger an `onChange` if the value in the input changed, and hide
	                // the cursor handle whenever the user types a key. If the value
	                // changed as a result of a keypress, we need to be careful not to
	                // call `setState` until after `onChange` has resolved.
	                var hideCursor = function hideCursor() {
	                    _this.setState({
	                        handle: {
	                            visible: false
	                        }
	                    });
	                };
	                var value = _this.mathField.getContent();
	                if (_this.props.value !== value) {
	                    _this.props.onChange(value, hideCursor);
	                } else {
	                    hideCursor();
	                }
	
	                return cursor;
	            });
	
	            _this.mathField.focus();
	            _this.props.onFocus && _this.props.onFocus();
	            _this.setState({ focused: true }, function () {
	                // NOTE(charlie): We use `setTimeout` to allow for a layout pass to
	                // occur. Otherwise, the keypad is measured incorrectly. Ideally,
	                // we'd use requestAnimationFrame here, but it's unsupported on
	                // Android Browser 4.3.
	                setTimeout(function () {
	                    if (_this._isMounted) {
	                        // TODO(benkomalo): the keypad is animating at this point,
	                        // so we can't call _cacheKeypadBounds(), even though
	                        // it'd be nice to do so. It should probably be the case
	                        // that the higher level controller tells us when the
	                        // keypad is settled (then scrollIntoView wouldn't have
	                        // to make assumptions about that either).
	                        var maybeKeypadNode = _this.props.keypadElement && ReactDOM.findDOMNode(_this.props.keypadElement);
	                        scrollIntoView(_this._container, maybeKeypadNode);
	                    }
	                });
	            });
	        }, _this._findHitNode = function (containerBounds, x, y, dx, dy) {
	            while (y >= containerBounds.top && y <= containerBounds.bottom) {
	                y += dy;
	
	                var points = [[x - dx, y], [x, y], [x + dx, y]];
	
	                var elements = points.map(function (point) {
	                    var _document;
	
	                    return (_document = document).elementFromPoint.apply(_document, point);
	                })
	                // We exclude the root container itself and any nodes marked
	                // as non-leaf which are fractions, parens, and roots.  The
	                // children of those nodes are included in the list because
	                // those are the items we care about placing the cursor next
	                // to.
	                //
	                // MathQuill's mq-non-leaf is not applied to all non-leaf nodes
	                // so the naming is a bit confusing.  Although fractions are
	                // included, neither mq-numerator nor mq-denominator nodes are
	                // and neither are subscripts or superscripts.
	                .filter(function (element) {
	                    return element && _this._root.contains(element) && (!element.classList.contains('mq-root-block') && !element.classList.contains('mq-non-leaf') || element.classList.contains('mq-empty') || element.classList.contains('mq-hasCursor'));
	                });
	
	                var hitNode = null;
	
	                // Contains only DOMNodes without child elements.  These should
	                // contain some amount of text though.
	                var leafElements = [];
	
	                // Contains only DOMNodes with child elements.
	                var nonLeafElements = [];
	
	                var max = 0;
	                var counts = {};
	                var elementsById = {};
	
	                for (var _iterator = elements, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
	                    var _ref;
	
	                    if (_isArray) {
	                        if (_i >= _iterator.length) break;
	                        _ref = _iterator[_i++];
	                    } else {
	                        _i = _iterator.next();
	                        if (_i.done) break;
	                        _ref = _i.value;
	                    }
	
	                    var element = _ref;
	
	                    var id = element.getAttribute('mathquill-command-id');
	                    if (id != null) {
	                        leafElements.push(element);
	
	                        counts[id] = (counts[id] || 0) + 1;
	                        elementsById[id] = element;
	                    } else {
	                        nonLeafElements.push(element);
	                    }
	                }
	
	                // When determining which DOMNode to place the cursor beside, we
	                // prefer leaf nodes.  Hitting a leaf node is a good sign that the
	                // cursor is really close to some piece of math that has been
	                // rendered because leaf nodes contain text.  Non-leaf nodes may
	                // contain a lot of whitespace so the cursor may be further away
	                // from actual text within the expression.
	                //
	                // Since we're doing three hit tests per loop it's possible that
	                // we hit multiple leaf nodes at the same time.  In this case we
	                // we prefer the DOMNode with the most hits.
	                // TODO(kevinb) consider preferring nodes hit by [x, y].
	                for (var _iterator2 = Object.entries(counts), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
	                    var _ref2;
	
	                    if (_isArray2) {
	                        if (_i2 >= _iterator2.length) break;
	                        _ref2 = _iterator2[_i2++];
	                    } else {
	                        _i2 = _iterator2.next();
	                        if (_i2.done) break;
	                        _ref2 = _i2.value;
	                    }
	
	                    var _ref3 = _ref2,
	                        _id = _ref3[0],
	                        count = _ref3[1];
	
	                    if (count > max) {
	                        max = count;
	                        hitNode = elementsById[_id];
	                    }
	                }
	
	                // It's possible that two non-leaf nodes are right beside each
	                // other.  We don't bother counting the number of hits for each,
	                // b/c this seems like an unlikely situation.  Also, ignoring the
	                // hit count in the situation should not have serious effects on
	                // the overall accuracy of the algorithm.
	                if (hitNode == null && nonLeafElements.length > 0) {
	                    hitNode = nonLeafElements[0];
	                }
	
	                if (hitNode !== null) {
	                    _this.mathField.setCursorPosition(x, y, hitNode);
	                    return true;
	                }
	            }
	
	            return false;
	        }, _this._insertCursorAtClosestNode = function (x, y) {
	            var cursor = _this.mathField.getCursor();
	
	            // Pre-emptively check if the input has any child nodes; if not, the
	            // input is empty, so we throw the cursor at the start.
	            if (!_this._root.hasChildNodes()) {
	                cursor.insAtLeftEnd(_this.mathField.mathField.__controller.root);
	                return;
	            }
	
	            if (y > _this._containerBounds.bottom) {
	                y = _this._containerBounds.bottom;
	            } else if (y < _this._containerBounds.top) {
	                y = _this._containerBounds.top + 10;
	            }
	
	            var dy = void 0;
	
	            // Vertical spacing between hit tests
	            // dy is negative because we're moving upwards.
	            dy = -8;
	
	            // Horizontal spacing between hit tests
	            // Note: This value depends on the font size.  If the gap is too small
	            // we end up placing the cursor at the end of the expression when we
	            // shouldn't.
	            var dx = 5;
	
	            if (_this._findHitNode(_this._containerBounds, x, y, dx, dy)) {
	                return;
	            }
	
	            // If we haven't found anything start from the top.
	            y = _this._containerBounds.top;
	
	            // dy is positive b/c we're going downwards.
	            dy = 8;
	
	            if (_this._findHitNode(_this._containerBounds, x, y, dx, dy)) {
	                return;
	            }
	
	            var firstChildBounds = _this._root.firstChild.getBoundingClientRect();
	            var lastChildBounds = _this._root.lastChild.getBoundingClientRect();
	
	            var left = firstChildBounds.left;
	            var right = lastChildBounds.right;
	
	            // We've exhausted all of the options. We're likely either to the right
	            // or left of all of the math, so we place the cursor at the end to
	            // which it's closest.
	            if (Math.abs(x - right) < Math.abs(x - left)) {
	                cursor.insAtRightEnd(_this.mathField.mathField.__controller.root);
	            } else {
	                cursor.insAtLeftEnd(_this.mathField.mathField.__controller.root);
	            }
	            // In that event, we need to update the cursor context ourselves.
	            _this.props.keypadElement && _this.props.keypadElement.setCursor({
	                context: _this.mathField.contextForCursor(cursor)
	            });
	        }, _this.handleTouchStart = function (e) {
	            e.stopPropagation();
	
	            // Hide the cursor handle on touch start, if the handle itself isn't
	            // handling the touch event.
	            _this._hideCursorHandle();
	
	            // Cache the container bounds, so as to avoid re-computing. If we don't
	            // have any content, then it's not necessary, since the cursor can't be
	            // moved anyway.
	            if (_this.mathField.getContent() !== "") {
	                _this._containerBounds = _this._container.getBoundingClientRect();
	
	                // Make the cursor visible and set the handle-less cursor's
	                // location.
	                var touch = e.changedTouches[0];
	                _this._insertCursorAtClosestNode(touch.clientX, touch.clientY);
	            }
	
	            // Trigger a focus event, if we're not already focused.
	            if (!_this.state.focused) {
	                _this.focus();
	            }
	        }, _this.handleTouchMove = function (e) {
	            e.stopPropagation();
	
	            // Update the handle-less cursor's location on move, if there's any
	            // content in the box. Note that if the user touched outside the keypad
	            // (e.g., with a different finger) during this touch interaction, we
	            // may have blurred, in which case we should ignore the touch (since
	            // the cursor is no longer visible and the input is no longer
	            // highlighted).
	            if (_this.mathField.getContent() !== "" && _this.state.focused) {
	                var touch = e.changedTouches[0];
	                _this._insertCursorAtClosestNode(touch.clientX, touch.clientY);
	            }
	        }, _this.handleTouchEnd = function (e) {
	            e.stopPropagation();
	
	            // And on touch-end, reveal the cursor, unless the input is empty. Note
	            // that if the user touched outside the keypad (e.g., with a different
	            // finger) during this touch interaction, we may have blurred, in which
	            // case we should ignore the touch (since the cursor is no longer
	            // visible and the input is no longer highlighted).
	            if (_this.mathField.getContent() !== "" && _this.state.focused) {
	                _this._updateCursorHandle();
	            }
	        }, _this.onCursorHandleTouchStart = function (e) {
	            // NOTE(charlie): The cursor handle is a child of this view, so whenever
	            // it receives a touch event, that event would also typically be bubbled
	            // up to our own handlers. However, we want the cursor to handle its own
	            // touch events, and for this view to only handle touch events that
	            // don't affect the cursor. As such, we `stopPropagation` on any touch
	            // events that are being handled by the cursor, so as to avoid handling
	            // them in our own touch handlers.
	            e.stopPropagation();
	
	            e.preventDefault();
	
	            // Cache the container bounds, so as to avoid re-computing.
	            _this._containerBounds = _this._container.getBoundingClientRect();
	        }, _this._constrainToBound = function (value, min, max, friction) {
	            if (value < min) {
	                return min + (value - min) * friction;
	            } else if (value > max) {
	                return max + (value - max) * friction;
	            } else {
	                return value;
	            }
	        }, _this.onCursorHandleTouchMove = function (e) {
	            e.stopPropagation();
	
	            var x = e.changedTouches[0].clientX;
	            var y = e.changedTouches[0].clientY;
	
	            var relativeX = x - _this._containerBounds.left;
	            var relativeY = y - 2 * cursorHandleRadiusPx * cursorHandleDistanceMultiplier - _this._containerBounds.top;
	
	            // We subtract the containerBounds left/top to correct for the
	            // MathInput's position on the page. On top of that, we subtract an
	            // additional 2 x {height of the cursor} so that the bottom of the
	            // cursor tracks the user's finger, to make it visible under their
	            // touch.
	            _this.setState({
	                handle: {
	                    animateIntoPosition: false,
	                    visible: true,
	                    // TODO(charlie): Use clientX and clientY to avoid the need for
	                    // scroll offsets. This likely also means that the cursor
	                    // detection doesn't work when scrolled, since we're not
	                    // offsetting those values.
	                    x: _this._constrainToBound(relativeX, 0, _this._containerBounds.width, constrainingFrictionFactor),
	                    y: _this._constrainToBound(relativeY, 0, _this._containerBounds.height, constrainingFrictionFactor)
	                }
	            });
	
	            // Use a y-coordinate that's just above where the user is actually
	            // touching because they're dragging the handle which is a little
	            // below where the cursor actually is.
	            var distanceAboveFingerToTrySelecting = 22;
	            var adjustedY = y - distanceAboveFingerToTrySelecting;
	
	            _this._insertCursorAtClosestNode(x, adjustedY);
	        }, _this.onCursorHandleTouchEnd = function (e) {
	            e.stopPropagation();
	
	            _this._updateCursorHandle(true);
	        }, _this.onCursorHandleTouchCancel = function (e) {
	            e.stopPropagation();
	
	            _this._updateCursorHandle(true);
	        }, _temp), _possibleConstructorReturn(_this, _ret);
	    }
	
	    MathInput.prototype.componentDidMount = function componentDidMount() {
	        var _this2 = this;
	
	        this._isMounted = true;
	
	        this.mathField = new MathWrapper(this._mathContainer, {}, {
	            onCursorMove: function onCursorMove(cursor) {
	                // TODO(charlie): It's not great that there is so much coupling
	                // between this keypad and the input behavior. We should wrap
	                // this `MathInput` component in an intermediary component
	                // that translates accesses on the keypad into vanilla props,
	                // to make this input keypad-agnostic.
	                _this2.props.keypadElement && _this2.props.keypadElement.setCursor(cursor);
	            }
	        });
	
	        // NOTE(charlie): MathQuill binds this handler to manage its
	        // drag-to-select behavior. For reasons that I can't explain, the event
	        // itself gets triggered even if you tap slightly outside of the
	        // bound container (maybe 5px outside of any boundary). As a result, the
	        // cursor appears when tapping at those locations, even though the input
	        // itself doesn't receive any touch start or mouse down event and, as
	        // such, doesn't focus itself. This makes for a confusing UX, as the
	        // cursor appears, but the keypad does not and the input otherwise
	        // treats itself as unfocused. Thankfully, we don't need this behavior--
	        // we manage all of the cursor interactions ourselves--so we can safely
	        // unbind the handler.
	        this.mathField.mathField.__controller.container.unbind('mousedown.mathquill');
	
	        // NOTE(charlie): MathQuill uses this method to do some layout in the
	        // case that an input overflows its bounds and must become scrollable.
	        // As it causes layout jank due to jQuery animations of scroll
	        // properties, we disable it unless it is explicitly requested (as it
	        // should be in the case of a fixed-width input).
	        if (!this.props.scrollable) {
	            this.mathField.mathField.__controller.scrollHoriz = function () {};
	        }
	
	        this.mathField.setContent(this.props.value);
	
	        this._container = ReactDOM.findDOMNode(this);
	
	        this._root = this._container.querySelector('.mq-root-block');
	        this._root.style.fontSize = fontSizePt + 'pt';
	
	        // Record the initial scroll displacement on touch start. This allows
	        // us to detect whether a touch event was a scroll and only blur the
	        // input on non-scrolls--blurring the input on scroll makes for a
	        // frustrating user experience.
	        this.touchStartInitialScroll = null;
	        this.recordTouchStartOutside = function (evt) {
	            if (_this2.state.focused) {
	                // Only blur if the touch is both outside of the input, and
	                // above or to the left or right of the keypad (if it has been
	                // provided). The reasoning for not blurring when touches occur
	                // below the keypad is that the keypad may be anchored above
	                // the 'Check answer' bottom bar, in which case, we don't want
	                // to dismiss the keypad on check.
	                // TODO(charlie): Inject this logic.
	                if (!_this2._container.contains(evt.target)) {
	                    var touchDidStartInOrBelowKeypad = false;
	                    if (_this2.props.keypadElement) {
	                        var bounds = _this2._getKeypadBounds();
	                        for (var i = 0; i < evt.changedTouches.length; i++) {
	                            var _ref4 = [evt.changedTouches[i].clientX, evt.changedTouches[i].clientY],
	                                x = _ref4[0],
	                                y = _ref4[1];
	
	                            if (bounds.left <= x && bounds.right >= x && bounds.top <= y && bounds.bottom >= y || bounds.bottom < y) {
	                                touchDidStartInOrBelowKeypad = true;
	                                break;
	                            }
	                        }
	                    }
	
	                    if (!touchDidStartInOrBelowKeypad) {
	                        _this2.didTouchOutside = true;
	
	                        if (_this2.dragListener) {
	                            _this2.dragListener.detach();
	                        }
	
	                        _this2.dragListener = new DragListener(function () {
	                            _this2.didScroll = true;
	                            _this2.dragListener.detach();
	                        }, evt);
	                        _this2.dragListener.attach();
	                    }
	                }
	            }
	        };
	
	        this.blurOnTouchEndOutside = function (evt) {
	            // If the user didn't scroll, blur the input.
	            // TODO(charlie): Verify that the touch that ended actually started
	            // outside the keypad. Right now, you can touch down on the keypad,
	            // touch elsewhere, release the finger on the keypad, and trigger a
	            // dismissal. This code needs to be generalized to handle
	            // multi-touch.
	            if (_this2.state.focused && _this2.didTouchOutside && !_this2.didScroll) {
	                _this2.blur();
	            }
	
	            _this2.didTouchOutside = false;
	            _this2.didScroll = false;
	
	            if (_this2.dragListener) {
	                _this2.dragListener.detach();
	                _this2.removeListeners = null;
	            }
	        };
	
	        window.addEventListener('touchstart', this.recordTouchStartOutside);
	        window.addEventListener('touchend', this.blurOnTouchEndOutside);
	        window.addEventListener('touchcancel', this.blurOnTouchEndOutside);
	
	        // HACK(benkomalo): if the window resizes, the keypad bounds can
	        // change. That's a bit peeking into the internals of the keypad
	        // itself, since we know bounds can change only when the viewport
	        // changes, but seems like a rare enough thing to get wrong that it's
	        // not worth wiring up extra things for the technical "purity" of
	        // having the keypad notify of changes to us.
	        window.addEventListener('resize', this._clearKeypadBoundsCache);
	        window.addEventListener('orientationchange', this._clearKeypadBoundsCache);
	    };
	
	    MathInput.prototype.componentWillReceiveProps = function componentWillReceiveProps(props) {
	        if (this.props.keypadElement !== props.keypadElement) {
	            this._clearKeypadBoundsCache();
	        }
	    };
	
	    MathInput.prototype.componentDidUpdate = function componentDidUpdate() {
	        if (this.mathField.getContent() !== this.props.value) {
	            this.mathField.setContent(this.props.value);
	        }
	    };
	
	    MathInput.prototype.componentWillUnmount = function componentWillUnmount() {
	        this._isMounted = false;
	
	        window.removeEventListener('touchstart', this.recordTouchStartOutside);
	        window.removeEventListener('touchend', this.blurOnTouchEndOutside);
	        window.removeEventListener('touchcancel', this.blurOnTouchEndOutside);
	        window.removeEventListener('resize', this._clearKeypadBoundsCache());
	        window.removeEventListener('orientationchange', this._clearKeypadBoundsCache());
	    };
	
	    /** Gets and cache they bounds of the keypadElement */
	
	
	    /**
	     * Tries to determine which DOM node to place the cursor next to based on
	     * where the user drags the cursor handle.  If it finds a node it will
	     * place the cursor next to it, update the handle to be under the cursor,
	     * and return true.  If it doesn't find a node, it returns false.
	     *
	     * It searches for nodes by doing it tests at the following points:
	     *
	     *   (x - dx, y), (x, y), (x + dx, y)
	     *
	     * If it doesn't find any nodes from the rendered math it will update y
	     * by adding dy.
	     *
	     * The algorithm ends its search when y goes outside the bounds of
	     * containerBounds.
	     *
	     * @param {ClientRect} containerBounds - bounds of the container node
	     * @param {number} x - the initial x coordinate in the viewport
	     * @param {number} y - the initial y coordinate in the viewport
	     * @param {number} dx - horizontal spacing between elementFromPoint calls
	     * @param {number} dy - vertical spacing between elementFromPoint calls,
	     *                      sign determines direction.
	     * @returns {boolean} - true if a node was hit, false otherwise.
	     */
	
	
	    /**
	     * Inserts the cursor at the DOM node closest to the given coordinates,
	     * based on hit-tests conducted using #_findHitNode.
	     *
	     * @param {number} x - the x coordinate in the viewport
	     * @param {number} y - the y coordinate in the viewport
	     */
	
	
	    /**
	     * When a touch starts in the cursor handle, we track it so as to avoid
	     * handling any touch events ourself.
	     *
	     * @param {TouchEvent} e - the raw touch event from the browser
	     */
	
	
	    /**
	     * When the user moves the cursor handle update the position of the cursor
	     * and the handle.
	     *
	     * @param {TouchEvent} e - the raw touch event from the browser
	     */
	
	
	    /**
	     * When the user releases the cursor handle, animate it back into place.
	     *
	     * @param {TouchEvent} e - the raw touch event from the browser
	     */
	
	
	    /**
	     * If the gesture is cancelled mid-drag, simply hide it.
	     *
	     * @param {TouchEvent} e - the raw touch event from the browser
	     */
	
	
	    MathInput.prototype.render = function render() {
	        var _this3 = this;
	
	        var _state = this.state,
	            focused = _state.focused,
	            handle = _state.handle;
	        var style = this.props.style;
	
	        // Calculate the appropriate padding based on the border width (which is
	        // considered 'padding', since we're using 'border-box') and the fact
	        // that MathQuill automatically applies 2px of padding to the inner
	        // input.
	
	        var normalBorderWidthPx = 1;
	        var focusedBorderWidthPx = 2;
	        var borderWidthPx = this.state.focused ? focusedBorderWidthPx : normalBorderWidthPx;
	        var builtInMathQuillPadding = 2;
	        var paddingInset = totalDesiredPadding - borderWidthPx - builtInMathQuillPadding;
	
	        // Now, translate that to the appropriate padding for each direction.
	        // The complication here is that we want numerals to be centered within
	        // the input. However, Symbola (MathQuill's font of choice) renders
	        // numerals with approximately 3px of padding below and 1px of padding
	        // above (to make room for ascenders and descenders). So we ignore those
	        // padding values for the vertical directions.
	        var symbolaPaddingBottom = 3;
	        var symbolaPaddingTop = 1;
	        var padding = {
	            paddingTop: paddingInset - symbolaPaddingTop,
	            paddingRight: paddingInset,
	            paddingBottom: paddingInset - symbolaPaddingBottom,
	            paddingLeft: paddingInset
	        };
	
	        var innerStyle = _extends({}, inlineStyles.innerContainer, {
	            borderWidth: borderWidthPx
	        }, padding, focused ? { borderColor: brightGreen } : {}, style);
	
	        return React.createElement(
	            View,
	            {
	                style: styles.input,
	                onTouchStart: this.handleTouchStart,
	                onTouchMove: this.handleTouchMove,
	                onTouchEnd: this.handleTouchEnd,
	                onClick: function onClick(e) {
	                    return e.stopPropagation();
	                },
	                role: 'textbox',
	                ariaLabel: i18n._('Math input box')
	            },
	            React.createElement(
	                'div',
	                { className: 'keypad-input' },
	                React.createElement('div', {
	                    ref: function ref(node) {
	                        _this3._mathContainer = ReactDOM.findDOMNode(node);
	                    },
	                    style: innerStyle
	                })
	            ),
	            focused && handle.visible && React.createElement(CursorHandle, _extends({}, handle, {
	                onTouchStart: this.onCursorHandleTouchStart,
	                onTouchMove: this.onCursorHandleTouchMove,
	                onTouchEnd: this.onCursorHandleTouchEnd,
	                onTouchCancel: this.onCursorHandleTouchCancel
	            }))
	        );
	    };
	
	    return MathInput;
	}(React.Component);
	
	MathInput.propTypes = {
	    // The React element node associated with the keypad that will send
	    // key-press events to this input. If provided, this can be used to:
	    //   (1) Avoid blurring the input, on user interaction with the keypad.
	    //   (2) Scroll the input into view, if it would otherwise be obscured
	    //       by the keypad on focus.
	    keypadElement: keypadElementPropType,
	    onBlur: React.PropTypes.func,
	    onChange: React.PropTypes.func.isRequired,
	    onFocus: React.PropTypes.func,
	    // Whether the input should be scrollable. This is typically only
	    // necessary when a fixed width has been provided through the `style`
	    // prop.
	    scrollable: React.PropTypes.bool,
	    // An extra, vanilla style object, to be applied to the math input.
	    style: React.PropTypes.any,
	    value: React.PropTypes.string
	};
	MathInput.defaultProps = {
	    scrollable: false,
	    style: {},
	    value: ""
	};
	
	
	var fontSizePt = 18;
	
	// The height of numerals in Symbola (rendered at 18pt) is about 20px (though
	// they render at 24px due to padding for ascenders and descenders). We want our
	// box to be laid out such that there's 8px of padding between a numeral and the
	// edge of the input, so we use this 20px number as our 'base height' and
	// account for the ascender and descender padding when computing the additional
	// padding in our `render` method.
	var numeralHeightPx = 20;
	var totalDesiredPadding = 8;
	var minHeightPx = numeralHeightPx + totalDesiredPadding * 2;
	var minWidthPx = 64;
	
	var styles = StyleSheet.create({
	    input: {
	        position: 'relative',
	        display: 'inline-block',
	        verticalAlign: 'middle'
	    }
	});
	
	var inlineStyles = {
	    // Styles for the inner, MathQuill-ified input element. It's important that
	    // these are done with regular inline styles rather than Aphrodite classes
	    // as MathQuill adds CSS class names to the element outside of the typical
	    // React flow; assigning a class to the element can thus disrupt MathQuill
	    // behavior. For example, if the client provided new styles to be applied
	    // on focus and the styles here were applied with Aphrodite, then Aphrodite
	    // would merge the provided styles with the base styles here, producing a
	    // new CSS class name that we would apply to the element, clobbering any CSS
	    // class names that MathQuill had applied itself.
	    innerContainer: {
	        backgroundColor: 'white',
	        display: 'flex',
	        minHeight: minHeightPx,
	        minWidth: minWidthPx,
	        boxSizing: 'border-box',
	        position: 'relative',
	        overflow: 'hidden',
	        borderStyle: 'solid',
	        borderColor: gray76,
	        borderRadius: 4,
	        color: gray17
	    }
	};
	
	module.exports = MathInput;

/***/ },
/* 297 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	// rawAsap provides everything we need except exception management.
	var rawAsap = __webpack_require__(318);
	// RawTasks are recycled to reduce GC churn.
	var freeTasks = [];
	// We queue errors to ensure they are thrown in right order (FIFO).
	// Array-as-queue is good enough here, since we are just dealing with exceptions.
	var pendingErrors = [];
	var requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);
	
	function throwFirstError() {
	    if (pendingErrors.length) {
	        throw pendingErrors.shift();
	    }
	}
	
	/**
	 * Calls a task as soon as possible after returning, in its own event, with priority
	 * over other events like animation, reflow, and repaint. An error thrown from an
	 * event will not interrupt, nor even substantially slow down the processing of
	 * other events, but will be rather postponed to a lower priority event.
	 * @param {{call}} task A callable object, typically a function that takes no
	 * arguments.
	 */
	module.exports = asap;
	function asap(task) {
	    var rawTask;
	    if (freeTasks.length) {
	        rawTask = freeTasks.pop();
	    } else {
	        rawTask = new RawTask();
	    }
	    rawTask.task = task;
	    rawAsap(rawTask);
	}
	
	// We wrap tasks with recyclable task objects.  A task object implements
	// `call`, just like a function.
	function RawTask() {
	    this.task = null;
	}
	
	// The sole purpose of wrapping the task is to catch the exception and recycle
	// the task object after its single use.
	RawTask.prototype.call = function () {
	    try {
	        this.task.call();
	    } catch (error) {
	        if (asap.onerror) {
	            // This hook exists purely for testing purposes.
	            // Its name will be periodically randomized to break any code that
	            // depends on its existence.
	            asap.onerror(error);
	        } else {
	            // In a web browser, exceptions are not fatal. However, to avoid
	            // slowing down the queue of pending tasks, we rethrow the error in a
	            // lower priority turn.
	            pendingErrors.push(error);
	            requestErrorThrow();
	        }
	    } finally {
	        this.task = null;
	        freeTasks[freeTasks.length] = this;
	    }
	};


/***/ },
/* 298 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule Draft
	 */
	
	'use strict';
	
	var AtomicBlockUtils = __webpack_require__(319);
	var BlockMapBuilder = __webpack_require__(320);
	var CharacterMetadata = __webpack_require__(321);
	var CompositeDraftDecorator = __webpack_require__(322);
	var ContentBlock = __webpack_require__(323);
	var ContentState = __webpack_require__(324);
	var DefaultDraftBlockRenderMap = __webpack_require__(325);
	var DefaultDraftInlineStyle = __webpack_require__(326);
	var DraftEditor = __webpack_require__(327);
	var DraftEditorBlock = __webpack_require__(328);
	var DraftModifier = __webpack_require__(329);
	var DraftEntity = __webpack_require__(330);
	var DraftEntityInstance = __webpack_require__(331);
	var EditorState = __webpack_require__(332);
	var KeyBindingUtil = __webpack_require__(333);
	var RichTextEditorUtil = __webpack_require__(334);
	var SelectionState = __webpack_require__(335);
	
	var convertFromDraftStateToRaw = __webpack_require__(336);
	var convertFromHTMLToContentBlocks = __webpack_require__(337);
	var convertFromRawToDraftState = __webpack_require__(338);
	var generateRandomKey = __webpack_require__(339);
	var getDefaultKeyBinding = __webpack_require__(340);
	var getVisibleSelectionRect = __webpack_require__(341);
	
	var DraftPublic = {
	  Editor: DraftEditor,
	  EditorBlock: DraftEditorBlock,
	  EditorState: EditorState,
	
	  CompositeDecorator: CompositeDraftDecorator,
	  Entity: DraftEntity,
	  EntityInstance: DraftEntityInstance,
	
	  BlockMapBuilder: BlockMapBuilder,
	  CharacterMetadata: CharacterMetadata,
	  ContentBlock: ContentBlock,
	  ContentState: ContentState,
	  SelectionState: SelectionState,
	
	  AtomicBlockUtils: AtomicBlockUtils,
	  KeyBindingUtil: KeyBindingUtil,
	  Modifier: DraftModifier,
	  RichUtils: RichTextEditorUtil,
	
	  DefaultDraftBlockRenderMap: DefaultDraftBlockRenderMap,
	  DefaultDraftInlineStyle: DefaultDraftInlineStyle,
	
	  convertFromHTML: convertFromHTMLToContentBlocks,
	  convertFromRaw: convertFromRawToDraftState,
	  convertToRaw: convertFromDraftStateToRaw,
	  genKey: generateRandomKey,
	  getDefaultKeyBinding: getDefaultKeyBinding,
	  getVisibleSelectionRect: getVisibleSelectionRect
	};
	
	module.exports = DraftPublic;

/***/ },
/* 299 */,
/* 300 */,
/* 301 */
/***/ function(module, exports, __webpack_require__) {

	/*
	 * Number Utils
	 * A number is a js-number, e.g. 5.12
	 */
	
	var _ = __webpack_require__(56);
	
	var DEFAULT_TOLERANCE = 1e-9;
	var EPSILON = Math.pow(2, -42);
	
	var knumber = {
	
	    DEFAULT_TOLERANCE: DEFAULT_TOLERANCE,
	    EPSILON: EPSILON,
	
	    is: function(x) {
	        return _.isNumber(x) && !_.isNaN(x);
	    },
	
	    equal: function(x, y, tolerance) {
	        // Checking for undefined makes this function behave nicely
	        // with vectors of different lengths that are _.zip'd together
	        if (x == null || y == null) {
	            return x === y;
	        }
	        // We check === here so that +/-Infinity comparisons work correctly
	        if (x === y) {
	            return true;
	        }
	        if (tolerance == null) {
	            tolerance = DEFAULT_TOLERANCE;
	        }
	        return Math.abs(x - y) < tolerance;
	    },
	
	    sign: function(x, tolerance) {
	        return knumber.equal(x, 0, tolerance) ? 0 : Math.abs(x) / x;
	    },
	
	    isInteger: function(num, tolerance) {
	        return knumber.equal(Math.round(num), num, tolerance);
	    },
	
	
	    // Round a number to a certain number of decimal places
	    round: function(num, precision) {
	        var factor = Math.pow(10, precision);
	        return Math.round(num * factor) / factor;
	    },
	
	    // Round num to the nearest multiple of increment
	    // i.e. roundTo(83, 5) -> 85
	    roundTo: function(num, increment) {
	        return Math.round(num / increment) * increment;
	    },
	
	    floorTo: function(num, increment) {
	        return Math.floor(num / increment) * increment;
	    },
	
	    ceilTo: function(num, increment) {
	        return Math.ceil(num / increment) * increment;
	    },
	
	    /**
	     * toFraction
	     *
	     * Returns a [numerator, denominator] array rational representation
	     * of `decimal`
	     *
	     * See http://en.wikipedia.org/wiki/Continued_fraction for implementation
	     * details
	     *
	     * toFraction(4/8) => [1, 2]
	     * toFraction(0.66) => [33, 50]
	     * toFraction(0.66, 0.01) => [2/3]
	     * toFraction(283 + 1/3) => [850, 3]
	     */
	    toFraction: function(decimal, tolerance, max_denominator) {
	        max_denominator = max_denominator || 1000;
	        tolerance = tolerance || EPSILON; // can't be 0
	
	        // Initialize everything to compute successive terms of
	        // continued-fraction approximations via recurrence relation
	        var n = [1, 0], d = [0, 1];
	        var a = Math.floor(decimal), t;
	        var rem = decimal - a;
	
	        while (d[0] <= max_denominator) {
	            if (knumber.equal(n[0] / d[0], decimal, tolerance)) {
	                return [n[0], d[0]];
	            }
	            n = [a*n[0] + n[1], n[0]];
	            d = [a*d[0] + d[1], d[0]];
	            a = Math.floor(1 / rem);
	            rem = 1/rem - a;
	        }
	
	        // We failed to find a nice rational representation,
	        // so return an irrational "fraction"
	        return [decimal, 1];
	    }
	};
	
	module.exports = knumber;
	


/***/ },
/* 302 */
/***/ function(module, exports, __webpack_require__) {

	/*
	 * Vector Utils 
	 * A vector is an array of numbers e.g. [0, 3, 4].
	 */
	
	var _ = __webpack_require__(56);
	var knumber = __webpack_require__(301);
	
	function arraySum(array) {
	    return _.reduce(array, function(memo, arg) { return memo + arg; }, 0);
	}
	
	function arrayProduct(array) {
	    return _.reduce(array, function(memo, arg) { return memo * arg; }, 1);
	}
	
	var kvector = {
	
	    is: function(vec, length) {
	        if (!_.isArray(vec)) {
	            return false;
	        }
	        if (length !== undefined && vec.length !== length) {
	            return false;
	        }
	        return _.all(vec, knumber.is);
	    },
	
	    // Normalize to a unit vector
	    normalize: function(v) {
	        return kvector.scale(v, 1 / kvector.length(v));
	    },
	
	    // Length/magnitude of a vector
	    length: function(v) {
	        return Math.sqrt(kvector.dot(v, v));
	    },
	
	    // Dot product of two vectors
	    dot: function(a, b) {
	        var vecs = _.toArray(arguments);
	        var zipped = _.zip.apply(_, vecs);
	        var multiplied = _.map(zipped, arrayProduct);
	        return arraySum(multiplied);
	    },
	
	    /* vector-add multiple [x, y] coords/vectors
	     *
	     * kvector.add([1, 2], [3, 4]) -> [4, 6]
	     */
	    add: function() {
	        var points = _.toArray(arguments);
	        var zipped = _.zip.apply(_, points);
	        return _.map(zipped, arraySum);
	    },
	
	    subtract: function(v1, v2) {
	        return _.map(_.zip(v1, v2), function(dim) {
	            return dim[0] - dim[1];
	        });
	    },
	
	    negate: function(v) {
	        return _.map(v, function(x) {
	            return -x;
	        });
	    },
	
	    // Scale a vector
	    scale: function(v1, scalar) {
	        return _.map(v1, function(x) {
	            return x * scalar;
	        });
	    },
	
	    equal: function(v1, v2, tolerance) {
	        // _.zip will nicely deal with the lengths, going through
	        // the length of the longest vector. knumber.equal then
	        // returns false for any number compared to the undefined
	        // passed in if one of the vectors is shorter.
	        return _.all(_.zip(v1, v2), function(pair) {
	            return knumber.equal(pair[0], pair[1], tolerance);
	        });
	    },
	
	    codirectional: function(v1, v2, tolerance) {
	        // The origin is trivially codirectional with all other vectors.
	        // This gives nice semantics for codirectionality between points when
	        // comparing their difference vectors.
	        if (knumber.equal(kvector.length(v1), 0, tolerance) ||
	                knumber.equal(kvector.length(v2), 0, tolerance)) {
	            return true;
	        }
	
	        v1 = kvector.normalize(v1);
	        v2 = kvector.normalize(v2);
	
	        return kvector.equal(v1, v2, tolerance);
	    },
	
	    collinear: function(v1, v2, tolerance) {
	        return kvector.codirectional(v1, v2, tolerance) ||
	                kvector.codirectional(v1, kvector.negate(v2), tolerance);
	    },
	
	    // Convert a cartesian coordinate into a radian polar coordinate
	    polarRadFromCart: function(v) {
	        var radius = kvector.length(v);
	        var theta = Math.atan2(v[1], v[0]);
	
	        // Convert angle range from [-pi, pi] to [0, 2pi]
	        if (theta < 0) {
	            theta += 2 * Math.PI;
	        }
	
	        return [radius, theta];
	    },
	
	    // Converts a cartesian coordinate into a degree polar coordinate
	    polarDegFromCart: function(v) {
	        var polar = kvector.polarRadFromCart(v);
	        return [polar[0], polar[1] * 180 / Math.PI];
	    },
	
	    /* Convert a polar coordinate into a cartesian coordinate
	     *
	     * Examples:
	     * cartFromPolarRad(5, Math.PI)
	     * cartFromPolarRad([5, Math.PI])
	     */
	    cartFromPolarRad: function(radius, theta) {
	        if (_.isUndefined(theta)) {
	            theta = radius[1];
	            radius = radius[0];
	        }
	
	        return [radius * Math.cos(theta), radius * Math.sin(theta)];
	    },
	
	    /* Convert a polar coordinate into a cartesian coordinate
	     *
	     * Examples:
	     * cartFromPolarDeg(5, 30)
	     * cartFromPolarDeg([5, 30])
	     */
	    cartFromPolarDeg: function(radius, theta) {
	        if (_.isUndefined(theta)) {
	            theta = radius[1];
	            radius = radius[0];
	        }
	
	        return kvector.cartFromPolarRad(radius, theta * Math.PI / 180);
	    },
	
	    // Rotate vector
	    rotateRad: function(v, theta) {
	        var polar = kvector.polarRadFromCart(v);
	        var angle = polar[1] + theta;
	        return kvector.cartFromPolarRad(polar[0], angle);
	    },
	
	    rotateDeg: function(v, theta) {
	        var polar = kvector.polarDegFromCart(v);
	        var angle = polar[1] + theta;
	        return kvector.cartFromPolarDeg(polar[0], angle);
	    },
	
	    // Angle between two vectors
	    angleRad: function(v1, v2) {
	        return Math.acos(kvector.dot(v1, v2) /
	            (kvector.length(v1) * kvector.length(v2)));
	    },
	
	    angleDeg: function(v1, v2) {
	        return kvector.angleRad(v1, v2) * 180 / Math.PI;
	    },
	
	    // Vector projection of v1 onto v2
	    projection: function(v1, v2) {
	        var scalar = kvector.dot(v1, v2) / kvector.dot(v2, v2);
	        return kvector.scale(v2, scalar);
	    },
	
	    // Round each number to a certain number of decimal places
	    round: function(vec, precision) {
	        return _.map(vec, function(elem, i) {
	            return knumber.round(elem, precision[i] || precision);
	        });
	    },
	
	    // Round each number to the nearest increment
	    roundTo: function(vec, increment) {
	        return _.map(vec, function(elem, i) {
	            return knumber.roundTo(elem, increment[i] || increment);
	        });
	    },
	
	    floorTo: function(vec, increment) {
	        return _.map(vec, function(elem, i) {
	            return knumber.floorTo(elem, increment[i] || increment);
	        });
	    },
	
	    ceilTo: function(vec, increment) {
	        return _.map(vec, function(elem, i) {
	            return knumber.ceilTo(elem, increment[i] || increment);
	        });
	    }
	};
	
	module.exports = kvector;
	


/***/ },
/* 303 */
/***/ function(module, exports, __webpack_require__) {

	/*
	 * Point Utils
	 * A point is an array of two numbers e.g. [0, 0].
	 */
	
	var _ = __webpack_require__(56);
	var kvector = __webpack_require__(302);
	var knumber = __webpack_require__(301);
	
	var kpoint = {
	
	    // Rotate point (around origin unless a center is specified)
	    rotateRad: function(point, theta, center) {
	        if (center === undefined) {
	            return kvector.rotateRad(point, theta);
	        } else {
	            return kvector.add(
	                center,
	                kvector.rotateRad(
	                    kvector.subtract(point, center),
	                    theta
	                )
	            );
	        }
	    },
	
	    rotateDeg: function(point, theta, center) {
	        if (center === undefined) {
	            return kvector.rotateDeg(point, theta);
	        } else {
	            return kvector.add(
	                center,
	                kvector.rotateDeg(
	                    kvector.subtract(point, center),
	                    theta
	                )
	            );
	        }
	    },
	
	    // Distance between two points
	    distanceToPoint: function(point1, point2) {
	        return kvector.length(kvector.subtract(point1, point2));
	    },
	
	    // Distance between point and line
	    distanceToLine: function(point, line) {
	        var lv = kvector.subtract(line[1], line[0]);
	        var pv = kvector.subtract(point, line[0]);
	        var projectedPv = kvector.projection(pv, lv);
	        var distancePv = kvector.subtract(projectedPv, pv);
	        return kvector.length(distancePv);
	    },
	
	    // Reflect point over line
	    reflectOverLine: function(point, line) {
	        var lv = kvector.subtract(line[1], line[0]);
	        var pv = kvector.subtract(point, line[0]);
	        var projectedPv = kvector.projection(pv, lv);
	        var reflectedPv = kvector.subtract(kvector.scale(projectedPv, 2), pv);
	        return kvector.add(line[0], reflectedPv);
	    },
	
	    /**
	     * Compares two points, returning -1, 0, or 1, for use with
	     * Array.prototype.sort
	     *
	     * Note: This technically doesn't satisfy the total-ordering
	     * requirements of Array.prototype.sort unless equalityTolerance
	     * is 0. In some cases very close points that compare within a
	     * few equalityTolerances could appear in the wrong order.
	     */
	    compare: function(point1, point2, equalityTolerance) {
	        if (point1.length !== point2.length) {
	            return point1.length - point2.length;
	        }
	        for (var i = 0; i < point1.length; i++) {
	            if (!knumber.equal(point1[i], point2[i], equalityTolerance)) {
	                return point1[i] - point2[i];
	            }
	        }
	        return 0;
	    }
	};
	
	_.extend(kpoint, {
	    // Check if a value is a point
	    is: kvector.is,
	
	    // Add and subtract vector(s)
	    addVector: kvector.add,
	    addVectors: kvector.add,
	    subtractVector: kvector.subtract,
	    equal: kvector.equal,
	
	    // Convert from cartesian to polar and back
	    polarRadFromCart: kvector.polarRadFromCart,
	    polarDegFromCart: kvector.polarDegFromCart,
	    cartFromPolarRad: kvector.cartFromPolarRad,
	    cartFromPolarDeg: kvector.cartFromPolarDeg,
	
	    // Rounding
	    round: kvector.round,
	    roundTo: kvector.roundTo,
	    floorTo: kvector.floorTo,
	    ceilTo: kvector.ceilTo
	});
	
	module.exports = kpoint;
	


/***/ },
/* 304 */
/***/ function(module, exports, __webpack_require__) {

	/*
	 * Line Utils
	 * A line is an array of two points e.g. [[-5, 0], [5, 0]].
	 */
	
	var kpoint = __webpack_require__(303);
	var kvector = __webpack_require__(302);
	
	var kline = {
	
	    distanceToPoint: function(line, point) {
	        return kpoint.distanceToLine(point, line);
	    },
	
	    reflectPoint: function(line, point) {
	        return kpoint.reflectOverLine(point, line);
	    },
	
	    midpoint: function(line) {
	        return [
	            (line[0][0] + line[1][0]) / 2,
	            (line[0][1] + line[1][1]) / 2
	        ];
	    },
	
	    equal: function(line1, line2, tolerance) {
	        // TODO: A nicer implementation might just check collinearity of
	        // vectors using underscore magick
	        // Compare the directions of the lines
	        var v1 = kvector.subtract(line1[1],line1[0]);
	        var v2 = kvector.subtract(line2[1],line2[0]);
	        if (!kvector.collinear(v1, v2, tolerance)) {
	            return false;
	        }
	        // If the start point is the same for the two lines, then they are the same
	        if (kpoint.equal(line1[0], line2[0])) {
	            return true;
	        }
	        // Make sure that the direction to get from line1 to
	        // line2 is the same as the direction of the lines
	        var line1ToLine2Vector = kvector.subtract(line2[0], line1[0]);
	        return kvector.collinear(v1, line1ToLine2Vector, tolerance);
	    }
	};
	
	module.exports = kline;
	


/***/ },
/* 305 */
/***/ function(module, exports, __webpack_require__) {

	/*
	 * Ray Utils
	 * A ray is an array of an endpoint and another point along the ray.
	 * For example, [[0, 0], [1, 0]] is the ray starting at the origin and
	 * traveling along the positive x-axis.
	 */
	
	var kvector = __webpack_require__(302);
	var kpoint = __webpack_require__(303);
	
	var kray = {
	
	    equal: function(ray1, ray2, tolerance) {
	        // Compare the directions of the rays
	        var v1 = kvector.subtract(ray1[1],ray1[0]);
	        var v2 = kvector.subtract(ray2[1],ray2[0]);
	
	        var sameOrigin = kpoint.equal(ray1[0], ray2[0]);
	        var codirectional = kvector.codirectional(v1, v2, tolerance);
	
	        return sameOrigin && codirectional;
	    }
	};
	
	module.exports = kray;
	


/***/ },
/* 306 */,
/* 307 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
	
	var React = __webpack_require__(43);
	var _ = __webpack_require__(56);
	
	/**
	 * A radio button that can be unchecked by clicking it again.
	 *
	 * This component behaves much like a checkbox in that when you click it again
	 * (or hit space bar or select it in some other way), it will become unchecked.
	 * (Hopefully) it behaves exactly like a radio button in every other way though
	 * (arrow keys can still be used to select it within a group for example).
	 *
	 * Here's a summary of which of our event handlers fire for each way to select
	 * or deselect the button:
	 *
	 * - Clicking a button: handleClick, handleChange
	 * - Pressing spacebar with button focussed: handleKeyDown, handleKeyUp (we
	 *   suppress the default behavior of some browsers to synthesize a click event
	 *   here).
	 * - When radio button A is selected, pressing down arrow to select B:
	 *   handleKeyDown (A), handleClick (B), handleChange (B), handleKeyUp (B)
	 * - Clicking with mac screenreader: handleClick, handleChange
	 */
	var ToggleableRadioButton = React.createClass({
	    displayName: "ToggleableRadioButton",
	
	    propTypes: {
	        // Whether the radio button should be checked or unchecked (this is a
	        // controlled component).
	        checked: React.PropTypes.bool.isRequired,
	
	        // A ref function to attach to the <input> element.
	        inputRef: React.PropTypes.func,
	
	        // A function that will be called whenever the radio button is checked
	        // or unchecked. It's possible for this to be called twice for a single
	        // checking or unchecking.
	        onChecked: React.PropTypes.func.isRequired
	    },
	
	    handleClick: function handleClick(event) {
	        this.props.onChecked(!this.props.checked);
	
	        // NOTE(johnsullivan): Preventing default would make sense to do here
	        //     because we're fully controlling the state of the check box and
	        //     don't really want it to be (un)checked accidently. React
	        //     requires that we *don't* call preventDefault from the onClick or
	        //     onChecked handlers of a controlled component though.
	    },
	
	    handleKeyUp: function handleKeyUp(event) {
	        // Make hitting the spacebar with the element selected equivalent to
	        // clicking it. Some browsers do this as part of the radio button's
	        // default behavior, but since some browsers don't we normalize the
	        // behavior here.
	        if (event.key === " ") {
	            this.props.onChecked(!this.props.checked);
	            event.preventDefault();
	        }
	    },
	
	    handleChange: function handleChange(event) {
	        // If the checkbox is going from unchecked to checked, we'll handle it
	        // here.
	        // NOTE(johnsullivan): The onClick/onKeyUp handler most likely *also*
	        //     handled this, but we're being defensive against browsers/devices
	        //     that might not call those handlers like we'd expect. It's
	        //     unclear to me whether this is strictly necessary.
	        if (!this.props.checked && event.target.checked) {
	            this.props.onChecked(true);
	        }
	    },
	
	    handleKeyDown: function handleKeyDown(event) {
	        // This is necessary in order to prevent IE9 from creating a duplicate
	        // click event on the radio button when the space bar is hit.
	        if (event.key === " ") {
	            event.preventDefault();
	        }
	    },
	
	    render: function render() {
	        var _props = this.props,
	            inputRef = _props.inputRef,
	            onChecked = _props.onChecked,
	            otherProps = _objectWithoutProperties(_props, ["inputRef", "onChecked"]);
	
	        return React.createElement("input", _extends({}, otherProps, {
	            type: "radio",
	            onChange: this.handleChange,
	            onClick: this.handleClick,
	            onKeyDown: this.handleKeyDown,
	            onKeyUp: this.handleKeyUp,
	            ref: this.props.inputRef
	        }));
	    }
	});
	
	module.exports = ToggleableRadioButton;

/***/ },
/* 308 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/* Component for rendering a letter icon in radio choice */
	
	/* global i18n */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var styleConstants = __webpack_require__(77);
	
	var _require2 = __webpack_require__(47),
	    iconCheck = _require2.iconCheck,
	    iconMinus = _require2.iconMinus;
	
	var InlineIcon = __webpack_require__(48);
	var FocusRing = __webpack_require__(358);
	
	var SATChoiceIcon = function (_React$Component) {
	    _inherits(SATChoiceIcon, _React$Component);
	
	    function SATChoiceIcon() {
	        _classCallCheck(this, SATChoiceIcon);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    // TODO(amy): figure out a better scheme for specifying these
	    // styles that isn't such a pain to grok. See some neat ideas
	    // from MDR in https://phabricator.khanacademy.org/D35249.
	    SATChoiceIcon.prototype.constructStyles = function constructStyles(reviewMode, correct, checked) {
	        var backgroundColor = void 0;
	        var borderColor = styleConstants.satBlue;
	        var color = styleConstants.satBlue;
	        if (reviewMode) {
	            if (correct) {
	                borderColor = styleConstants.satCorrectColor;
	                color = checked ? styleConstants.white : styleConstants.satCorrectColor;
	                backgroundColor = checked ? styleConstants.satCorrectColor : styleConstants.white;
	            } else if (checked) {
	                borderColor = styleConstants.satIncorrectColor;
	                color = styleConstants.white;
	                backgroundColor = styleConstants.satIncorrectColor;
	            }
	        } else if (checked) {
	            color = styleConstants.white;
	            backgroundColor = styleConstants.satBlue;
	        }
	        return { color: color, backgroundColor: backgroundColor, borderColor: borderColor };
	    };
	
	    SATChoiceIcon.prototype.render = function render() {
	        var _props = this.props,
	            letter = _props.letter,
	            a11yText = _props.a11yText,
	            reviewMode = _props.reviewMode,
	            checked = _props.checked,
	            correct = _props.correct;
	
	        var _constructStyles = this.constructStyles(reviewMode, correct, checked),
	            color = _constructStyles.color,
	            backgroundColor = _constructStyles.backgroundColor,
	            borderColor = _constructStyles.borderColor;
	
	        return React.createElement(
	            "div",
	            null,
	            React.createElement("div", {
	                className: css(styles.satCircle),
	                style: { backgroundColor: backgroundColor, borderColor: borderColor }
	            }),
	            React.createElement(
	                "div",
	                { style: { color: color }, className: css(styles.letter) },
	                React.createElement(
	                    "span",
	                    { className: "perseus-sr-only" },
	                    a11yText
	                ),
	                React.createElement(
	                    "span",
	                    { "aria-hidden": "true" },
	                    letter
	                )
	            )
	        );
	    };
	
	    return SATChoiceIcon;
	}(React.Component);
	
	SATChoiceIcon.propTypes = {
	    letter: __webpack_require__(43).PropTypes.string.isRequired,
	    a11yText: __webpack_require__(43).PropTypes.string.isRequired,
	    checked: __webpack_require__(43).PropTypes.bool.isRequired,
	    correct: __webpack_require__(43).PropTypes.bool.isRequired,
	    reviewMode: __webpack_require__(43).PropTypes.bool.isRequired
	};
	
	var LibraryChoiceIcon = function (_React$Component2) {
	    _inherits(LibraryChoiceIcon, _React$Component2);
	
	    function LibraryChoiceIcon() {
	        _classCallCheck(this, LibraryChoiceIcon);
	
	        return _possibleConstructorReturn(this, _React$Component2.apply(this, arguments));
	    }
	
	    LibraryChoiceIcon.prototype.getChoiceInner = function getChoiceInner() {
	        var _props2 = this.props,
	            letter = _props2.letter,
	            showCorrectness = _props2.showCorrectness,
	            correct = _props2.correct;
	
	
	        if (!showCorrectness) {
	            return letter;
	        } else if (correct) {
	            return React.createElement(InlineIcon, _extends({}, iconCheck, {
	                style: {
	                    position: "relative",
	                    top: -1
	                }
	            }));
	        } else {
	            return React.createElement(InlineIcon, iconMinus);
	        }
	    };
	
	    // Handle dynamic styling of the multiple choice icon. Most
	    // MC icon styles are constant, but we do allow the caller
	    // to specify the selected color, and thus must control styles
	    // related to the selected state dynamically.
	
	
	    LibraryChoiceIcon.prototype.getDynamicStyles = function getDynamicStyles() {
	        var _props3 = this.props,
	            checked = _props3.checked,
	            showCorrectness = _props3.showCorrectness,
	            pressed = _props3.pressed,
	            primaryProductColor = _props3.primaryProductColor,
	            correct = _props3.correct;
	
	        if (!showCorrectness && pressed) {
	            return {
	                borderColor: primaryProductColor,
	                color: primaryProductColor,
	                backgroundColor: styleConstants.white
	            };
	        } else if (checked) {
	            // Note: kaGreen is not only the default product color,
	            // but also the "correctness" color
	            var bg = showCorrectness && correct ? styleConstants.kaGreen : primaryProductColor;
	            return {
	                color: styleConstants.white,
	                backgroundColor: bg,
	                borderColor: bg
	            };
	        } else {
	            return {
	                borderColor: styleConstants.gray68,
	                color: styleConstants.gray68
	            };
	        }
	    };
	
	    LibraryChoiceIcon.prototype.render = function render() {
	        var _props4 = this.props,
	            checked = _props4.checked,
	            showCorrectness = _props4.showCorrectness,
	            correct = _props4.correct,
	            focused = _props4.focused,
	            primaryProductColor = _props4.primaryProductColor;
	
	        return React.createElement(
	            FocusRing,
	            { color: primaryProductColor, visible: focused },
	            React.createElement(
	                "div",
	                {
	                    style: this.getDynamicStyles(),
	                    className: css(styles.libraryCircle, showCorrectness && correct && styles.libraryCircleCorrect, showCorrectness && !correct && styles.libraryCircleIncorrect, showCorrectness && !correct && checked && styles.libraryCircleIncorrectSelected)
	                    // used in BaseRadio to check if we actually clicked on the
	                    // radio icon
	                    , "data-is-radio-icon": true
	                },
	                this.getChoiceInner()
	            )
	        );
	    };
	
	    return LibraryChoiceIcon;
	}(React.Component);
	
	LibraryChoiceIcon.propTypes = {
	    letter: __webpack_require__(43).PropTypes.string.isRequired,
	    a11yText: __webpack_require__(43).PropTypes.string.isRequired,
	    checked: __webpack_require__(43).PropTypes.bool.isRequired,
	    pressed: __webpack_require__(43).PropTypes.bool.isRequired,
	    focused: __webpack_require__(43).PropTypes.bool.isRequired,
	    correct: __webpack_require__(43).PropTypes.bool,
	    reviewMode: __webpack_require__(43).PropTypes.bool.isRequired,
	    showCorrectness: __webpack_require__(43).PropTypes.bool.isRequired,
	    primaryProductColor: __webpack_require__(43).PropTypes.string.isRequired
	};
	
	var ChoiceIcon = function (_React$Component3) {
	    _inherits(ChoiceIcon, _React$Component3);
	
	    function ChoiceIcon() {
	        _classCallCheck(this, ChoiceIcon);
	
	        return _possibleConstructorReturn(this, _React$Component3.apply(this, arguments));
	    }
	
	    ChoiceIcon.prototype.a11yText = function a11yText(letter) {
	        // If the option was checked we need to reveal more context about
	        // what the result was (correct/incorrect)
	        if (this.props.checked) {
	            if (this.props.showCorrectness) {
	                if (this.props.correct) {
	                    return i18n._("(Choice %(letter)s, Checked, Correct)", {
	                        letter: letter
	                    });
	                } else {
	                    return i18n._("(Choice %(letter)s, Checked, Incorrect)", {
	                        letter: letter
	                    });
	                }
	            }
	
	            return i18n._("(Choice %(letter)s, Checked)", { letter: letter });
	
	            // If the option wasn't checked, but was correct, we need to tell
	            // the user that this was, in fact, the correct answer.
	        } else if (this.props.showCorrectness && this.props.correct) {
	            return i18n._("(Choice %(letter)s, Correct Answer)", {
	                letter: letter
	            });
	        }
	
	        return i18n._("(Choice %(letter)s)", { letter: letter });
	    };
	
	    ChoiceIcon.prototype.getLetter = function getLetter() {
	        /* I18N: This is a list of single-character labels that will appear in
	         * front of multiple-choice options. For instance, a multiple-choice
	         * question with three options would display
	         *  (A) first option
	         *  (B) second option
	         *  (C) third option
	         * There must be spaces between each of the different characters. The
	         * characters will show up next to options in the order that they are
	         * listed here. Most multiple choice questions have 5 or fewer options.
	         */
	        var lettersString = i18n._("A B C D E F G H I J K L M N O P Q R S T U V W X Y Z");
	
	        var letters = lettersString.split(" ");
	        var pos = this.props.pos;
	
	        if (pos < letters.length) {
	            // If the position we need is listed in the localized string, use
	            // that.
	            return letters[pos];
	        } else {
	            // If we're out of letters, give up and return a space.
	            return " ";
	        }
	    };
	
	    ChoiceIcon.prototype.render = function render() {
	        var _props5 = this.props,
	            reviewMode = _props5.reviewMode,
	            checked = _props5.checked,
	            correct = _props5.correct,
	            product = _props5.product,
	            showCorrectness = _props5.showCorrectness,
	            pressed = _props5.pressed,
	            focused = _props5.focused,
	            primaryProductColor = _props5.primaryProductColor;
	
	
	        var letter = this.getLetter();
	
	        if (product === "sat") {
	            return React.createElement(SATChoiceIcon, {
	                letter: letter,
	                a11yText: this.a11yText(letter),
	                reviewMode: reviewMode,
	                checked: checked,
	                correct: correct
	            });
	        } else {
	            return React.createElement(LibraryChoiceIcon, {
	                letter: letter,
	                a11yText: this.a11yText(letter),
	                reviewMode: reviewMode,
	                checked: checked,
	                pressed: pressed,
	                focused: focused,
	                correct: correct,
	                showCorrectness: showCorrectness,
	                primaryProductColor: primaryProductColor
	            });
	        }
	    };
	
	    return ChoiceIcon;
	}(React.Component);
	
	ChoiceIcon.defaultProps = {
	    primaryProductColor: styleConstants.kaGreen
	};
	ChoiceIcon.propTypes = {
	    pos: __webpack_require__(43).PropTypes.number.isRequired,
	    checked: __webpack_require__(43).PropTypes.bool.isRequired,
	    pressed: __webpack_require__(43).PropTypes.bool.isRequired,
	    focused: __webpack_require__(43).PropTypes.bool.isRequired,
	    correct: __webpack_require__(43).PropTypes.bool.isRequired,
	    showCorrectness: __webpack_require__(43).PropTypes.bool.isRequired,
	    product: __webpack_require__(43).PropTypes.oneOf(["sat", "library"]).isRequired,
	    primaryProductColor: __webpack_require__(43).PropTypes.string.isRequired,
	    reviewMode: __webpack_require__(43).PropTypes.bool.isRequired
	};
	
	
	var styles = StyleSheet.create({
	    satCircle: {
	        display: "block",
	        borderRadius: 25,
	        borderStyle: "solid",
	        borderWidth: 2,
	        content: "''",
	        height: 25,
	        width: 25,
	        position: "absolute",
	        top: 1,
	        left: 1
	    },
	
	    libraryCircle: {
	        // Make the circle
	        width: 24,
	        height: 24,
	        boxSizing: "border-box",
	        borderRadius: 24,
	        borderStyle: "solid",
	        borderWidth: 2,
	
	        // The default icons have letters in them. Style those letters.
	        fontFamily: styleConstants.baseFontFamily,
	        // NOTE(emily): We explicitly set the font weight instead of using the
	        // "bold font family" so that characters which fall back to the default
	        // font get bolded too.
	        fontWeight: "bold",
	        fontSize: 12,
	
	        // Center the contents of the icon.
	        display: "flex",
	        alignItems: "center",
	        justifyContent: "center",
	        // HACK(emily): I don't know why adding this line height makes the text
	        // appear centered better than any other value, but it does. In
	        // particular, at large zoom levels this line height does almost
	        // nothing, but at the default size this shifts the letter down one
	        // pixel so it is much better centered.
	        lineHeight: "1px"
	    },
	
	    libraryCircleCorrect: {
	        fontSize: 24
	    },
	
	    libraryCircleIncorrect: {
	        fontSize: 24,
	        borderColor: styleConstants.warning1,
	        color: styleConstants.warning1
	    },
	
	    libraryCircleIncorrectSelected: {
	        backgroundColor: styleConstants.warning1,
	        color: styleConstants.white
	    },
	
	    letter: {
	        // These properties make sure that this element has the exact
	        // same size as `circle` so that we can center things
	        // inside of it.
	        border: "2px solid transparent",
	        width: 25,
	        height: 25,
	        position: "absolute",
	        left: 1,
	        top: 1,
	
	        // Center contained items.
	        display: "flex",
	        alignItems: "center",
	        justifyContent: "center",
	
	        fontFamily: styleConstants.boldFontFamily,
	        fontSize: 13
	    }
	});
	
	module.exports = ChoiceIcon;

/***/ },
/* 309 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * Renders text indicating whether the choice was correct or
	 * not and whether the choice was selected or not.
	 * This information is redundant with that provided in the
	 * ChoiceIcon visualizations but is meant to make the distinctions
	 * between the states more immediately clear to users.
	 */
	
	/* globals i18n */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var styleConstants = __webpack_require__(77);
	
	var OptionStatus = function (_React$Component) {
	    _inherits(OptionStatus, _React$Component);
	
	    function OptionStatus() {
	        _classCallCheck(this, OptionStatus);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    OptionStatus.prototype.render = function render() {
	        var _props = this.props,
	            checked = _props.checked,
	            correct = _props.correct;
	
	        var correctness = correct ? i18n._("correct") : i18n._("incorrect");
	        var selectedness = checked ? i18n._("(selected)") : "";
	        var text = correctness + " " + selectedness;
	        var textStyle = correct ? styles.correct : styles.incorrect;
	        return React.createElement(
	            "div",
	            { className: css(styles.text, textStyle) },
	            text
	        );
	    };
	
	    return OptionStatus;
	}(React.Component);
	
	OptionStatus.propTypes = {
	    correct: __webpack_require__(43).PropTypes.bool.isRequired,
	    checked: __webpack_require__(43).PropTypes.bool.isRequired
	};
	
	
	var styles = StyleSheet.create({
	    text: {
	        alignItems: "center",
	        display: "flex",
	        fontSize: 12,
	        height: 32,
	        textTransform: "uppercase"
	    },
	    correct: {
	        color: styleConstants.kaGreen
	    },
	    incorrect: {
	        color: styleConstants.warning1
	    }
	});
	
	module.exports = OptionStatus;

/***/ },
/* 310 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Constants that define the various contexts in which a cursor can exist. The
	 * active context is determined first by looking at the cursor's siblings (e.g.,
	 * for the `BEFORE_FRACTION` context), and then at its direct parent. Though a
	 * cursor could in theory be nested in multiple contexts, we only care about the
	 * immediate context.
	 *
	 * TODO(charlie): Add a context to represent being inside of a radical. Right
	 * now, we show the dismiss button rather than allowing the user to jump out of
	 * the radical.
	 */
	
	module.exports = {
	    // The cursor is not in any of the other viable contexts.
	    NONE: 'NONE',
	    // The cursor is within a set of parentheses.
	    IN_PARENS: 'IN_PARENS',
	    // The cursor is within a superscript (e.g., an exponent).
	    IN_SUPER_SCRIPT: 'IN_SUPER_SCRIPT',
	    // The cursor is within a subscript (e.g., the base of a custom logarithm).
	    IN_SUB_SCRIPT: 'IN_SUB_SCRIPT',
	    // The cursor is in the numerator of a fraction.
	    IN_NUMERATOR: 'IN_NUMERATOR',
	    // The cursor is in the denominator of a fraction.
	    IN_DENOMINATOR: 'IN_DENOMINATOR',
	    // The cursor is sitting before a fraction; that is, the cursor is within
	    // what looks to be a mixed number preceding a fraction. This will only be
	    // the case when the only math between the cursor and the fraction to its
	    // write is non-leaf math (numbers and variables).
	    BEFORE_FRACTION: 'BEFORE_FRACTION'
	};

/***/ },
/* 311 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(397),
	    connect = _require.connect;
	
	var _require2 = __webpack_require__(414),
	    StyleSheet = _require2.StyleSheet;
	
	var _require3 = __webpack_require__(357),
	    View = _require3.View;
	
	var FractionKeypad = __webpack_require__(360);
	var ExpressionKeypad = __webpack_require__(361);
	var NavigationPad = __webpack_require__(362);
	var zIndexes = __webpack_require__(363);
	
	var _require4 = __webpack_require__(316),
	    setPageSize = _require4.setPageSize;
	
	var _require5 = __webpack_require__(295),
	    keyIdPropType = _require5.keyIdPropType;
	
	var _require6 = __webpack_require__(283),
	    KeypadTypes = _require6.KeypadTypes,
	    LayoutModes = _require6.LayoutModes;
	
	var _require7 = __webpack_require__(364),
	    row = _require7.row,
	    centered = _require7.centered,
	    fullWidth = _require7.fullWidth;
	
	var _require8 = __webpack_require__(355),
	    innerBorderColor = _require8.innerBorderColor,
	    innerBorderStyle = _require8.innerBorderStyle,
	    innerBorderWidthPx = _require8.innerBorderWidthPx,
	    compactKeypadBorderRadiusPx = _require8.compactKeypadBorderRadiusPx;
	
	var KeypadContainer = function (_React$Component) {
	    _inherits(KeypadContainer, _React$Component);
	
	    function KeypadContainer() {
	        var _temp, _this, _ret;
	
	        _classCallCheck(this, KeypadContainer);
	
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {
	            hasBeenActivated: false,
	            viewportWidth: "100vw"
	        }, _this._throttleResizeHandler = function () {
	            // Throttle the resize callbacks.
	            // https://developer.mozilla.org/en-US/docs/Web/Events/resize
	            if (_this._resizeTimeout == null) {
	                _this._resizeTimeout = setTimeout(function () {
	                    _this._resizeTimeout = null;
	
	                    _this._onResize();
	                }, 66);
	            }
	        }, _this._onResize = function () {
	            // Whenever the page resizes, we need to force an update, as the button
	            // heights and keypad width are computed based on horizontal space.
	            _this.setState({
	                viewportWidth: window.innerWidth
	            });
	
	            _this.props.onPageSizeChange(window.innerWidth, window.innerHeight);
	        }, _this.renderKeypad = function () {
	            var _this$props = _this.props,
	                extraKeys = _this$props.extraKeys,
	                keypadType = _this$props.keypadType,
	                layoutMode = _this$props.layoutMode,
	                navigationPadEnabled = _this$props.navigationPadEnabled;
	
	
	            var keypadProps = {
	                extraKeys: extraKeys,
	                // HACK(charlie): In order to properly round the corners of the
	                // compact keypad, we need to instruct some of our child views to
	                // crop themselves. At least we're colocating all the layout
	                // information in this component, though.
	                roundTopLeft: layoutMode === LayoutModes.COMPACT && !navigationPadEnabled,
	                roundTopRight: layoutMode === LayoutModes.COMPACT
	            };
	
	            // Select the appropriate keyboard given the type.
	            // TODO(charlie): In the future, we might want to move towards a
	            // data-driven approach to defining keyboard layouts, and have a
	            // generic keyboard that takes some "keyboard data" and renders it.
	            // However, the keyboards differ pretty heavily right now and it's not
	            // clear what that format would look like exactly. Plus, there aren't
	            // very many of them. So to keep us moving, we'll just hardcode.
	            switch (keypadType) {
	                case KeypadTypes.FRACTION:
	                    return React.createElement(FractionKeypad, keypadProps);
	
	                case KeypadTypes.EXPRESSION:
	                    return React.createElement(ExpressionKeypad, keypadProps);
	
	                default:
	                    throw new Error("Invalid keypad type: " + keypadType);
	            }
	        }, _temp), _possibleConstructorReturn(_this, _ret);
	    }
	
	    KeypadContainer.prototype.componentWillMount = function componentWillMount() {
	        if (this.props.active) {
	            this.setState({
	                hasBeenActivated: this.props.active
	            });
	        }
	    };
	
	    KeypadContainer.prototype.componentDidMount = function componentDidMount() {
	        // Relay the initial size metrics.
	        this._onResize();
	
	        // And update it on resize.
	        window.addEventListener("resize", this._throttleResizeHandler);
	        window.addEventListener("orientationchange", this._throttleResizeHandler);
	    };
	
	    KeypadContainer.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	        if (!this.state.hasBeenActivated && nextProps.active) {
	            this.setState({
	                hasBeenActivated: true
	            });
	        }
	    };
	
	    KeypadContainer.prototype.componentDidUpdate = function componentDidUpdate(prevProps) {
	        if (prevProps.active && !this.props.active) {
	            this.props.onDismiss && this.props.onDismiss();
	        }
	    };
	
	    KeypadContainer.prototype.componentWillUnmount = function componentWillUnmount() {
	        window.removeEventListener("resize", this._throttleResizeHandler);
	        window.removeEventListener("orientationchange", this._throttleResizeHandler);
	    };
	
	    KeypadContainer.prototype.render = function render() {
	        var _this2 = this;
	
	        var _props = this.props,
	            active = _props.active,
	            layoutMode = _props.layoutMode,
	            navigationPadEnabled = _props.navigationPadEnabled,
	            onElementMounted = _props.onElementMounted,
	            style = _props.style;
	        var hasBeenActivated = this.state.hasBeenActivated;
	
	        // NOTE(charlie): We render the transforms as pure inline styles to
	        // avoid an Aphrodite bug in mobile Safari.
	        //   See: https://github.com/Khan/aphrodite/issues/68.
	
	        var dynamicStyle = _extends({}, active ? inlineStyles.active : inlineStyles.hidden, !active && !hasBeenActivated ? inlineStyles.invisible : {});
	
	        var keypadContainerStyle = [row, centered, fullWidth, styles.keypadContainer].concat(Array.isArray(style) ? style : [style]);
	
	        var keypadStyle = [row, styles.keypadBorder, layoutMode === LayoutModes.FULLSCREEN ? styles.fullscreen : styles.compact];
	
	        // TODO(charlie): When the keypad is shorter than the width of the
	        // screen, add a border on its left and right edges, and round out the
	        // corners.
	        return React.createElement(
	            View,
	            {
	                style: keypadContainerStyle,
	                dynamicStyle: dynamicStyle,
	                extraClassName: 'keypad-container'
	            },
	            React.createElement(
	                View,
	                {
	                    style: keypadStyle,
	                    ref: function ref(element) {
	                        if (!_this2.hasMounted && element) {
	                            _this2.hasMounted = true;
	                            onElementMounted(element);
	                        }
	                    }
	                },
	                navigationPadEnabled && React.createElement(NavigationPad, {
	                    roundTopLeft: layoutMode === LayoutModes.COMPACT,
	                    style: styles.navigationPadContainer
	                }),
	                React.createElement(
	                    View,
	                    { style: styles.keypadLayout },
	                    this.renderKeypad()
	                )
	            )
	        );
	    };
	
	    return KeypadContainer;
	}(React.Component);
	
	KeypadContainer.propTypes = {
	    active: React.PropTypes.bool,
	    extraKeys: React.PropTypes.arrayOf(keyIdPropType),
	    keypadType: React.PropTypes.oneOf(Object.keys(KeypadTypes)).isRequired,
	    layoutMode: React.PropTypes.oneOf(Object.keys(LayoutModes)).isRequired,
	    navigationPadEnabled: React.PropTypes.bool.isRequired,
	    onDismiss: React.PropTypes.func,
	    // A callback that should be triggered with the root React element on
	    // mount.
	    onElementMounted: React.PropTypes.func,
	    onPageSizeChange: React.PropTypes.func.isRequired,
	    style: React.PropTypes.any
	};
	
	
	var keypadAnimationDurationMs = 300;
	var borderWidthPx = 1;
	
	var styles = StyleSheet.create({
	    keypadContainer: {
	        bottom: 0,
	        left: 0,
	        right: 0,
	        position: 'fixed',
	        transition: keypadAnimationDurationMs + 'ms ease-out',
	        transitionProperty: 'transform',
	        zIndex: zIndexes.keypad
	    },
	
	    keypadBorder: {
	        boxShadow: '0 1px 4px 0 rgba(0, 0, 0, 0.1)',
	        borderColor: 'rgba(0, 0, 0, 0.2)',
	        borderStyle: 'solid'
	    },
	
	    fullscreen: {
	        borderTopWidth: borderWidthPx
	    },
	
	    compact: {
	        borderTopRightRadius: compactKeypadBorderRadiusPx,
	        borderTopLeftRadius: compactKeypadBorderRadiusPx,
	
	        borderTopWidth: borderWidthPx,
	        borderRightWidth: borderWidthPx,
	        borderLeftWidth: borderWidthPx
	    },
	
	    navigationPadContainer: {
	        // Add a separator between the navigation pad and the keypad.
	        borderRight: innerBorderWidthPx + 'px ' + innerBorderStyle + ' ' + ('' + innerBorderColor),
	        boxSizing: 'content-box'
	    },
	
	    // Defer to the navigation pad, such that the navigation pad is always
	    // rendered at full-width, and the keypad takes up just the remaining space.
	    // TODO(charlie): Avoid shrinking the keys and, instead, make the keypad
	    // scrollable.
	    keypadLayout: {
	        flexGrow: 1,
	        // Avoid unitless flex-basis, per: https://philipwalton.com/articles/normalizing-cross-browser-flexbox-bugs/
	        flexBasis: '0%'
	    }
	});
	
	// Note: these don't go through an autoprefixer/aphrodite.
	var inlineStyles = {
	    // If the keypad is yet to have ever been activated, we keep it invisible
	    // so as to avoid, e.g., the keypad flashing at the bottom of the page
	    // during the initial render.
	    invisible: {
	        visibility: 'hidden'
	    },
	
	    hidden: {
	        msTransform: 'translate3d(0, 100%, 0)',
	        WebkitTransform: 'translate3d(0, 100%, 0)',
	        transform: 'translate3d(0, 100%, 0)'
	    },
	
	    active: {
	        msTransform: 'translate3d(0, 0, 0)',
	        WebkitTransform: 'translate3d(0, 0, 0)',
	        transform: 'translate3d(0, 0, 0)'
	    }
	};
	
	var mapStateToProps = function mapStateToProps(state) {
	    return _extends({}, state.keypad, {
	        layoutMode: state.layout.layoutMode,
	        navigationPadEnabled: state.layout.navigationPadEnabled
	    });
	};
	
	var mapDispatchToProps = function mapDispatchToProps(dispatch) {
	    return {
	        onPageSizeChange: function onPageSizeChange(pageWidthPx, pageHeightPx) {
	            dispatch(setPageSize(pageWidthPx, pageHeightPx));
	        }
	    };
	};
	
	module.exports = connect(mapStateToProps, mapDispatchToProps)(KeypadContainer);

/***/ },
/* 312 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = prefixAll;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _prefixProps = __webpack_require__(359);
	
	var _prefixProps2 = _interopRequireDefault(_prefixProps);
	
	var _utilsCapitalizeString = __webpack_require__(365);
	
	var _utilsCapitalizeString2 = _interopRequireDefault(_utilsCapitalizeString);
	
	var _utilsAssign = __webpack_require__(366);
	
	var _utilsAssign2 = _interopRequireDefault(_utilsAssign);
	
	var _pluginsCalc = __webpack_require__(367);
	
	var _pluginsCalc2 = _interopRequireDefault(_pluginsCalc);
	
	var _pluginsCursor = __webpack_require__(368);
	
	var _pluginsCursor2 = _interopRequireDefault(_pluginsCursor);
	
	var _pluginsFlex = __webpack_require__(369);
	
	var _pluginsFlex2 = _interopRequireDefault(_pluginsFlex);
	
	var _pluginsSizing = __webpack_require__(370);
	
	var _pluginsSizing2 = _interopRequireDefault(_pluginsSizing);
	
	var _pluginsGradient = __webpack_require__(371);
	
	var _pluginsGradient2 = _interopRequireDefault(_pluginsGradient);
	
	var _pluginsTransition = __webpack_require__(372);
	
	var _pluginsTransition2 = _interopRequireDefault(_pluginsTransition);
	
	// special flexbox specifications
	
	var _pluginsFlexboxIE = __webpack_require__(373);
	
	var _pluginsFlexboxIE2 = _interopRequireDefault(_pluginsFlexboxIE);
	
	var _pluginsFlexboxOld = __webpack_require__(374);
	
	var _pluginsFlexboxOld2 = _interopRequireDefault(_pluginsFlexboxOld);
	
	var plugins = [_pluginsCalc2['default'], _pluginsCursor2['default'], _pluginsSizing2['default'], _pluginsGradient2['default'], _pluginsTransition2['default'], _pluginsFlexboxIE2['default'], _pluginsFlexboxOld2['default'], _pluginsFlex2['default']];
	
	/**
	 * Returns a prefixed version of the style object using all vendor prefixes
	 * @param {Object} styles - Style object that gets prefixed properties added
	 * @returns {Object} - Style object with prefixed properties and values
	 */
	
	function prefixAll(styles) {
	  return Object.keys(styles).reduce(function (prefixedStyles, property) {
	    var value = styles[property];
	    if (value instanceof Object && !Array.isArray(value)) {
	      // recurse through nested style objects
	      prefixedStyles[property] = prefixAll(value);
	    } else {
	      Object.keys(_prefixProps2['default']).forEach(function (prefix) {
	        var properties = _prefixProps2['default'][prefix];
	        // add prefixes if needed
	        if (properties[property]) {
	          prefixedStyles[prefix + (0, _utilsCapitalizeString2['default'])(property)] = value;
	        }
	      });
	
	      // resolve every special plugins
	      plugins.forEach(function (plugin) {
	        return (0, _utilsAssign2['default'])(prefixedStyles, plugin(property, value));
	      });
	    }
	
	    return prefixedStyles;
	  }, styles);
	}
	
	module.exports = exports['default'];

/***/ },
/* 313 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A library of options to pass to add/draw/remove/constraints
	 */
	
	var _ = __webpack_require__(56);
	var kpoint = __webpack_require__(275).point;
	var kvector = __webpack_require__(275).vector;
	
	function sum(array) {
	    return _.reduce(array, function (memo, arg) {
	        return memo + arg;
	    }, 0);
	}
	
	function clockwise(points) {
	    var segments = _.zip(points, points.slice(1).concat(points.slice(0, 1)));
	    var areas = _.map(segments, function (segment) {
	        var p1 = segment[0];
	        var p2 = segment[1];
	        return (p2[0] - p1[0]) * (p2[1] + p1[1]);
	    });
	    return sum(areas) > 0;
	}
	
	var add = {
	    constrain: function constrain() {
	        this.constrain();
	    },
	
	    pointsToFront: function pointsToFront(state) {
	        _.invoke(state.points, "toFront");
	    }
	};
	
	add.standard = [add.constrain, add.pointsToFront];
	
	var modify = {
	    draw: function draw() {
	        this.draw();
	    }
	};
	
	modify.standard = [modify.draw];
	
	var draw = {
	    basic: function basic(state, prevState) {
	        var graphie = this.graphie;
	        var path = this.path(state);
	
	        if (!this.state.visibleShape) {
	            this.state.visibleShape = graphie.raphael.path(path);
	            this.state.visibleShape.attr(this.normalStyle());
	        }
	        if (state.normalStyle !== prevState.normalStyle && !_.isEqual(state.normalStyle, prevState.normalStyle)) {
	            this.state.visibleShape.attr(this.normalStyle());
	        }
	        this.state.visibleShape.attr({ path: path });
	        if (this.mouseTarget()) {
	            this.mouseTarget().attr({ path: path });
	        }
	    },
	
	    /* Labels are handled primarily by label objects, but sometimes require
	     * extra movables, e.g., for the arcs drawn at labeled angles. These extra
	     * movables are stored in the label cache. */
	    labels: function labels(state, prevState) {
	        var graphie = this.graphie;
	        var self = this;
	
	        var coords = _.invoke(state.points, "coord");
	        var isClockwise = clockwise(coords);
	        var n = coords.length;
	
	        // graphie.labelAngle and similar methods attempt to re-use the label
	        // provided, which will have been stored on state._labeledAngles.
	        // If they cannot re-use the label, they make a new one, which will
	        // get stored on state._labelCache. These will all be cleared out when
	        // we remove the polygon.
	        // (This logic is borrowed from graphie:addMovablePolygon.)
	        if (self.state._labelCache != null) {
	            _.invoke(self.state._labelCache, "remove");
	        }
	        self.state._labelCache = [];
	
	        // Update angle labels
	        if (state.angleLabels.length || state.showRightAngleMarkers.length) {
	            // Generate labels
	            if (self.state._labeledAngles == null) {
	                self.state._labeledAngles = _.times(Math.max(state.angleLabels.length, state.showRightAngleMarkers.length), function () {
	                    return graphie.label([0, 0], "", "center", state.labelStyle);
	                });
	            }
	
	            _.each(self.state._labeledAngles, function (label, i) {
	                self.state._labelCache.push(graphie.labelAngle({
	                    point1: coords[(i - 1 + n) % n],
	                    vertex: coords[i],
	                    point3: coords[(i + 1) % n],
	                    label: label,
	                    text: state.angleLabels[i],
	                    showRightAngleMarker: state.showRightAngleMarkers[i],
	                    numArcs: state.numArcs[i],
	                    clockwise: isClockwise,
	                    style: state.labelStyle
	                }));
	            });
	        }
	
	        // Update side labels
	        if (state.sideLabels.length) {
	            // Generate labels
	            if (self.state._labeledSides == null) {
	                self.state._labeledSides = _.map(state.sideLabels, function (label) {
	                    return graphie.label([0, 0], "", "center", state.labelStyle);
	                });
	            }
	
	            _.each(self.state._labeledSides, function (label, i) {
	                self.state._labelCache.push(graphie.labelSide({
	                    point1: coords[i],
	                    point2: coords[(i + 1) % n],
	                    label: label,
	                    text: state.sideLabels[i],
	                    numArrows: state.numArrows[i],
	                    numTicks: state.numTicks[i],
	                    clockwise: isClockwise,
	                    style: state.labelStyle
	                }));
	            });
	        }
	
	        // Update vertex labels
	        if (state.vertexLabels.length) {
	            // Generate labels
	            if (self.state._labeledVertices == null) {
	                self.state._labeledVertices = _.map(state.vertexLabels, function (label) {
	                    return graphie.label([0, 0], "", "center", state.labelStyle);
	                });
	            }
	
	            _.each(self.state._labeledVertices, function (label, i) {
	                self.state._labelCache.push(graphie.labelVertex({
	                    point1: coords[(i - 1 + n) % n],
	                    vertex: coords[i],
	                    point3: coords[(i + 1) % n],
	                    label: label,
	                    text: state.vertexLabels[i],
	                    clockwise: isClockwise,
	                    style: state.labelStyle
	                }));
	            });
	        }
	
	        // graphie.labelVertex and its peer methods return an array of movables
	        self.state._labelCache = _.flatten(self.state._labelCache);
	    },
	
	    highlight: function highlight(state, prevState) {
	        if (state.isHovering && !prevState.isHovering) {
	            state.visibleShape.animate(this.highlightStyle(), 50);
	        } else if (!state.isHovering && prevState.isHovering) {
	            state.visibleShape.animate(this.normalStyle(), 50);
	        }
	    }
	};
	
	draw.standard = [draw.basic, draw.labels, draw.highlight];
	
	var remove = {
	    basic: function basic() {
	        if (this.state.visibleShape) {
	            this.state.visibleShape.remove();
	        }
	    },
	    labels: function labels() {
	        var labels = [this.state._labeledSides, this.state._labeledVertices, this.state._labeledAngles, this.state._labelCache];
	
	        _.each(labels, function (labelType) {
	            if (labelType != null && labelType.length) {
	                _.invoke(labelType, "remove");
	            }
	        });
	    }
	};
	
	remove.standard = [remove.basic, remove.labels];
	
	var constraints = {
	    fixed: function fixed() {
	        return function () {
	            return false;
	        };
	    },
	
	    snap: function snap(_snap) {
	        return function (coord) {
	            if (_snap === null) {
	                return true;
	            }
	            _snap = _snap || this.graphie.snap;
	            return kpoint.roundTo(coord, _snap);
	        };
	    },
	
	    bound: function bound(range, snap, paddingPx) {
	        if (paddingPx === undefined) {
	            if (range === undefined) {
	                paddingPx = 10;
	            } else {
	                paddingPx = 0;
	            }
	        }
	        return function (coord, prevCoord) {
	            var graphie = this.graphie;
	            var delta = kvector.subtract(coord, prevCoord);
	            var range = range || graphie.range;
	            // A null snap means no snap; an undefined snap means
	            // default to graphie's
	            if (snap === undefined) {
	                snap = graphie.snap;
	            }
	
	            // Calculate the bounds for both points
	            var absoluteLower = graphie.unscalePoint([paddingPx, graphie.ypixels - paddingPx]);
	            var absoluteUpper = graphie.unscalePoint([graphie.xpixels - paddingPx, paddingPx]);
	            if (snap) {
	                absoluteLower = kpoint.ceilTo(absoluteLower, snap);
	                absoluteUpper = kpoint.floorTo(absoluteUpper, snap);
	            }
	
	            // Calculate the bounds for the delta.
	            var deltaBounds = _.map(this.coords(), function (coord, i) {
	                var max = kvector.subtract(absoluteUpper, coord);
	                var min = kvector.subtract(absoluteLower, coord);
	                return [min, max];
	            });
	
	            // bound the delta by the calculated bounds
	            var boundedDelta = _.reduce(deltaBounds, function (delta, bound) {
	                var lower = bound[0];
	                var upper = bound[1];
	                var deltaX = Math.max(lower[0], Math.min(upper[0], delta[0]));
	                var deltaY = Math.max(lower[1], Math.min(upper[1], delta[1]));
	                return [deltaX, deltaY];
	            }, delta);
	
	            return kvector.add(prevCoord, boundedDelta);
	        };
	    }
	};
	
	constraints.standard = null;
	
	var onMove = {
	    updatePoints: function updatePoints(coord, prevCoord) {
	        var actualDelta = kvector.subtract(coord, prevCoord);
	        _.each(this.state.points, function (point) {
	            point.setCoord(kvector.add(point.coord(), actualDelta));
	        });
	    }
	};
	
	onMove.standard = null;
	
	module.exports = {
	    add: add,
	    modify: modify,
	    draw: draw,
	    remove: remove,
	
	    onMoveStart: { standard: null },
	    constraints: constraints,
	    onMove: onMove,
	    onMoveEnd: { standard: null },
	    onClick: { standard: null }
	};

/***/ },
/* 314 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A library of options to pass to add/draw/remove/constraints
	 */
	var _ = __webpack_require__(56);
	var WrappedLine = __webpack_require__(267);
	var WrappedPath = __webpack_require__(394);
	var kvector = __webpack_require__(275).vector;
	var kpoint = __webpack_require__(275).point;
	var KhanMath = __webpack_require__(208);
	
	/**
	 * Helper functions
	 */
	var getScaledAngle = function getScaledAngle(line) {
	    var scaledA = line.graphie.scalePoint(line.coord(0));
	    var scaledZ = line.graphie.scalePoint(line.coord(1));
	    return kvector.polarDegFromCart(kvector.subtract(scaledZ, scaledA))[1];
	};
	
	// Given `coord` and `angle`, find the point where a line extended
	// from `coord` in the direction of `angle` would be clipped by the
	// edge of the graphie canvas. Then draw an arrowhead at that point
	// pointing in the direction of `angle`.
	var getClipPoint = function getClipPoint(graph, coord, angle) {
	    // Actually put the arrowheads 4px from the edge so they have
	    // a bit of room
	    var xExtent = graph.range[0][1] - graph.range[0][0];
	    var yExtent = graph.range[1][1] - graph.range[1][0];
	
	    // shoot a point off into the distance ...
	    var distance = xExtent + yExtent;
	    // we need to scale the point according to the scale of the axes
	    var angleVec = graph.unscaleVector(kvector.cartFromPolarDeg([1, angle]));
	    var distVec = kvector.scale(kvector.normalize(angleVec), distance);
	    var farCoord = kvector.add(coord, distVec);
	    var scaledAngle = kvector.polarDegFromCart(angleVec)[1];
	    // ... and then bring it back
	    var clipPoint = graph.constrainToBoundsOnAngle(farCoord, 4, scaledAngle * Math.PI / 180);
	    return clipPoint;
	};
	
	// Given `coord` and `angle`, find the point where a line extended
	// from `coord` in the direction of `angle` would be clipped by the
	// edge of the graphie canvas. Then draw an arrowhead at that point
	// pointing in the direction of `angle`.
	var createArrow = function createArrow(graph, style) {
	    // Points that define the arrowhead
	    var center = [0.75, 0];
	    var points = [[-3, 4], [-2.75, 2.5], [0, 0.25], center, [0, -0.25], [-2.75, -2.5], [-3, -4]];
	
	    // Scale points by 1.4 around (0.75, 0)
	    var scale = 1.4;
	    points = _.map(points, function (point) {
	        var pv = kvector.subtract(point, center);
	        var pvScaled = kvector.scale(pv, scale);
	        return kvector.add(center, pvScaled);
	    });
	
	    // We can't just pass in a path to `graph.fixedPath` as we need to modify
	    // the points in some way, so instead we provide a function for creating
	    // the path once the points have been transformed
	    var createCubicPath = function createCubicPath(points) {
	        var path = "M" + points[0][0] + " " + points[0][1];
	        for (var i = 1; i < points.length; i += 3) {
	            path += "C" + points[i][0] + " " + points[i][1] + " " + points[i + 1][0] + " " + points[i + 1][1] + " " + points[i + 2][0] + " " + points[i + 2][1];
	        }
	        return path;
	    };
	
	    // Create arrowhead
	    var unscaledPoints = _.map(points, graph.unscalePoint);
	    var options = {
	        center: graph.unscalePoint(center),
	        createPath: createCubicPath
	    };
	    var arrowHead = new WrappedPath(graph, unscaledPoints, options);
	    arrowHead.attr(_.extend({
	        "stroke-linejoin": "round",
	        "stroke-linecap": "round",
	        "stroke-dasharray": ""
	    }, style));
	
	    // Add custom function for transforming arrowheads that accounts for
	    // center, scaling, etc.
	    arrowHead.toCoordAtAngle = function (coord, angle) {
	        var clipPoint = graph.scalePoint(getClipPoint(graph, coord, angle));
	        arrowHead.transform("translateX(" + (clipPoint[0] + scale * center[0]) + "px) " + "translateY(" + (clipPoint[1] + scale * center[1]) + "px) " + "translateZ(0) " + "rotate(" + (360 - KhanMath.bound(angle)) + "deg)");
	    };
	
	    return arrowHead;
	};
	
	/**
	 * MovableLine option functions
	 */
	var add = {
	    // We do this in add as well as in standard so that we can call
	    // pointsToFront after the first draw (which adds `this.visibleShape`)
	    draw: function draw() {
	        this.draw();
	    },
	
	    pointsToFront: function pointsToFront(state) {
	        _.invoke(state.points, "toFront");
	    }
	};
	
	add.standard = [add.draw, add.pointsToFront];
	
	var modify = {
	    draw: function draw() {
	        this.draw();
	    }
	};
	
	modify.standard = [modify.draw];
	
	var draw = {
	    basic: function basic(state) {
	        var graphie = this.graphie;
	        var start = this.coord(0);
	        var end = this.coord(1);
	
	        if (!this.state.visibleShape) {
	            var options = {
	                thickness: 10
	            };
	            this.state.visibleShape = new WrappedLine(graphie, start, end, options);
	            this.state.visibleShape.attr(this.normalStyle());
	            this.state.visibleShape.toFront();
	
	            if (this.mouseTarget()) {
	                this.mouseTarget().toFront();
	            }
	        }
	
	        // Compute angle
	        var angle = getScaledAngle(this);
	
	        // Extend start, end if necessary (i.e., if not a line segment)
	        if (state.extendLine) {
	            start = getClipPoint(graphie, start, 360 - angle);
	            end = getClipPoint(graphie, end, (540 - angle) % 360);
	        } else if (state.extendRay) {
	            end = getClipPoint(graphie, end, 360 - angle);
	        }
	
	        // Move elements
	        var elements = [this.state.visibleShape];
	
	        if (this.mouseTarget()) {
	            elements.push(this.mouseTarget());
	        }
	        _.each(elements, function (element) {
	            element.moveTo(start, end);
	        });
	    },
	
	    arrows: function arrows(state) {
	        // Create arrows, if not yet created
	        if (this._arrows == null) {
	            this._arrows = [];
	            if (state.extendLine) {
	                this._arrows.push(createArrow(this.graphie, this.normalStyle()));
	                this._arrows.push(createArrow(this.graphie, this.normalStyle()));
	            } else if (state.extendRay) {
	                this._arrows.push(createArrow(this.graphie, this.normalStyle()));
	            }
	        }
	
	        // Transform arrows
	        var angle = getScaledAngle(this);
	        var angleForArrow = [360 - angle, (540 - angle) % 360];
	        _.each(this._arrows, function (arrow, i) {
	            arrow.toCoordAtAngle(this.coord(i), angleForArrow[i]);
	        }, this);
	    },
	
	    highlight: function highlight(state, prevState) {
	        // TODO(jack): Figure out a way to highlight the points attached to
	        // the line. Maybe this means an additional isHovering: []
	        // function to state of movable/movablepoint to define [additional?]
	        // times it should be highlighted
	        if (state.isHovering && !prevState.isHovering) {
	            state.visibleShape.animate(state.highlightStyle, 50);
	        } else if (!state.isHovering && prevState.isHovering) {
	            state.visibleShape.animate(state.normalStyle, 50);
	        }
	    }
	};
	
	draw.standard = [draw.basic, draw.arrows, draw.highlight];
	
	var remove = {
	    basic: function basic() {
	        if (this.state.visibleShape) {
	            this.state.visibleShape.remove();
	        }
	    },
	
	    arrows: function arrows() {
	        if (this._arrows != null) {
	            _.invoke(this._arrows, "remove");
	        }
	        this._arrows = null;
	    }
	};
	
	remove.standard = [remove.basic, remove.arrows];
	
	var constraints = {
	    fixed: function fixed() {
	        return function () {
	            return false;
	        };
	    },
	
	    snap: function snap(_snap) {
	        return function (coord, prevCoord) {
	            if (_snap === null) {
	                return true;
	            }
	            var delta = kvector.subtract(coord, prevCoord);
	            _snap = _snap || this.graphie.snap;
	            delta = kpoint.roundTo(delta, _snap);
	            return kvector.add(prevCoord, delta);
	        };
	    },
	
	    bound: function bound(range, snap, paddingPx) {
	        if (paddingPx === undefined) {
	            if (range === undefined) {
	                paddingPx = 10;
	            } else {
	                paddingPx = 0;
	            }
	        }
	        return function (coord, prevCoord) {
	            var graphie = this.graphie;
	            var delta = kvector.subtract(coord, prevCoord);
	            var range = range || graphie.range;
	            // A null snap means no snap; an undefined snap means
	            // default to graphie's
	            if (snap === undefined) {
	                snap = graphie.snap;
	            }
	
	            // Calculate the bounds for both points
	            var absoluteLower = graphie.unscalePoint([paddingPx, graphie.ypixels - paddingPx]);
	            var absoluteUpper = graphie.unscalePoint([graphie.xpixels - paddingPx, paddingPx]);
	            if (snap) {
	                absoluteLower = kpoint.ceilTo(absoluteLower, snap);
	                absoluteUpper = kpoint.floorTo(absoluteUpper, snap);
	            }
	
	            // Calculate the bounds for the delta.
	            var deltaBounds = _.map(this.coords(), function (coord, i) {
	                var max = kvector.subtract(absoluteUpper, coord);
	                var min = kvector.subtract(absoluteLower, coord);
	                return [min, max];
	            });
	
	            // bound the delta by the calculated bounds
	            var boundedDelta = _.reduce(deltaBounds, function (delta, bound) {
	                var lower = bound[0];
	                var upper = bound[1];
	                var deltaX = Math.max(lower[0], Math.min(upper[0], delta[0]));
	                var deltaY = Math.max(lower[1], Math.min(upper[1], delta[1]));
	                return [deltaX, deltaY];
	            }, delta);
	
	            return kvector.add(prevCoord, boundedDelta);
	        };
	    }
	};
	
	constraints.standard = null;
	
	var onMove = {
	    updatePoints: function updatePoints(coord, prevCoord) {
	        var actualDelta = kvector.subtract(coord, prevCoord);
	        _.each(this.state.points, function (point) {
	            point.setCoord(kvector.add(point.coord(), actualDelta));
	        });
	    }
	};
	
	onMove.standard = null;
	
	module.exports = {
	    add: add,
	    modify: modify,
	    draw: draw,
	    remove: remove,
	
	    onMoveStart: { standard: null },
	    constraints: constraints,
	    onMove: onMove,
	    onMoveEnd: { standard: null }
	};

/***/ },
/* 315 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var _KeyConfigs;
	
	/**
	 * This file contains configuration settings for the buttons in the keypad.
	 */
	
	/* globals i18n */
	
	var Keys = __webpack_require__(395);
	
	var _require = __webpack_require__(283),
	    DecimalSeparators = _require.DecimalSeparators,
	    IconTypes = _require.IconTypes,
	    KeyTypes = _require.KeyTypes;
	
	var _require2 = __webpack_require__(396),
	    decimalSeparator = _require2.decimalSeparator;
	
	var KeyConfigs = (_KeyConfigs = {}, _KeyConfigs[Keys.PLUS] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a plus sign.
	    ariaLabel: i18n._('Plus')
	}, _KeyConfigs[Keys.MINUS] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a minus sign.
	    ariaLabel: i18n._('Minus')
	}, _KeyConfigs[Keys.NEGATIVE] = {
	    type: KeyTypes.VALUE,
	    // I18N: A label for a minus sign.
	    ariaLabel: i18n._('Negative')
	}, _KeyConfigs[Keys.TIMES] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a multiplication sign (represented with an 'x').
	    ariaLabel: i18n._('Multiply')
	}, _KeyConfigs[Keys.DIVIDE] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a division sign.
	    ariaLabel: i18n._('Divide')
	}, _KeyConfigs[Keys.DECIMAL] = {
	    type: KeyTypes.VALUE,
	    // I18N: A label for a decimal symbol.
	    ariaLabel: i18n._('Decimal'),
	    icon: decimalSeparator === DecimalSeparators.COMMA ? {
	        // TODO(charlie): Get an SVG icon for the comma, or verify with
	        // design that the text-rendered version is acceptable.
	        type: IconTypes.TEXT,
	        data: ','
	    } : {
	        type: IconTypes.SVG,
	        data: Keys.PERIOD
	    }
	}, _KeyConfigs[Keys.PERCENT] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a percent sign.
	    ariaLabel: i18n._('Percent')
	}, _KeyConfigs[Keys.CDOT] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a multiplication sign (represented as a dot).
	    ariaLabel: i18n._('Multiply')
	}, _KeyConfigs[Keys.EQUAL] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Equals sign')
	}, _KeyConfigs[Keys.NEQ] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Not-equals sign')
	}, _KeyConfigs[Keys.GT] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a 'greater than' sign (represented as '>').
	    ariaLabel: i18n._('Greater than sign')
	}, _KeyConfigs[Keys.LT] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a 'less than' sign (represented as '<').
	    ariaLabel: i18n._('Less than sign')
	}, _KeyConfigs[Keys.GEQ] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Greater than or equal to sign')
	}, _KeyConfigs[Keys.LEQ] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Less than or equal to sign')
	}, _KeyConfigs[Keys.FRAC_INCLUSIVE] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a button that creates a new fraction and puts the
	    // current expression in the numerator of that fraction.
	    ariaLabel: i18n._('Fraction, with current expression in numerator')
	}, _KeyConfigs[Keys.FRAC_EXCLUSIVE] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a button that creates a new fraction next to the
	    // cursor.
	    ariaLabel: i18n._('Fraction, excluding the current expression')
	}, _KeyConfigs[Keys.EXP] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a button that will allow the user to input a custom
	    // exponent.
	    ariaLabel: i18n._('Custom exponent')
	}, _KeyConfigs[Keys.EXP_2] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a button that will square (take to the second
	    // power) some math.
	    ariaLabel: i18n._('Square')
	}, _KeyConfigs[Keys.EXP_3] = {
	    type: KeyTypes.OPERATOR,
	    // I18N: A label for a button that will cube (take to the third power)
	    // some math.
	    ariaLabel: i18n._('Cube')
	}, _KeyConfigs[Keys.SQRT] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Square root')
	}, _KeyConfigs[Keys.CUBE_ROOT] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Cube root')
	}, _KeyConfigs[Keys.RADICAL] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Radical with custom root')
	}, _KeyConfigs[Keys.LEFT_PAREN] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Left parenthesis')
	}, _KeyConfigs[Keys.RIGHT_PAREN] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Right parenthesis')
	}, _KeyConfigs[Keys.LN] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Natural logarithm')
	}, _KeyConfigs[Keys.LOG] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Logarithm with base 10')
	}, _KeyConfigs[Keys.LOG_N] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Logarithm with custom base')
	}, _KeyConfigs[Keys.SIN] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Sine')
	}, _KeyConfigs[Keys.COS] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Cosine')
	}, _KeyConfigs[Keys.TAN] = {
	    type: KeyTypes.OPERATOR,
	    ariaLabel: i18n._('Tangent')
	}, _KeyConfigs[Keys.PI] = {
	    type: KeyTypes.VALUE,
	    ariaLabel: i18n._('Pi'),
	    icon: {
	        type: IconTypes.MATH,
	        data: '\\pi'
	    }
	}, _KeyConfigs[Keys.THETA] = {
	    type: KeyTypes.VALUE,
	    ariaLabel: i18n._('Theta'),
	    icon: {
	        type: IconTypes.MATH,
	        data: '\\theta'
	    }
	}, _KeyConfigs[Keys.NOOP] = {
	    type: KeyTypes.EMPTY
	}, _KeyConfigs[Keys.UP] = {
	    type: KeyTypes.INPUT_NAVIGATION,
	    ariaLabel: i18n._('Up arrow')
	}, _KeyConfigs[Keys.RIGHT] = {
	    type: KeyTypes.INPUT_NAVIGATION,
	    ariaLabel: i18n._('Right arrow')
	}, _KeyConfigs[Keys.DOWN] = {
	    type: KeyTypes.INPUT_NAVIGATION,
	    ariaLabel: i18n._('Down arrow')
	}, _KeyConfigs[Keys.LEFT] = {
	    type: KeyTypes.INPUT_NAVIGATION,
	    ariaLabel: i18n._('Left arrow')
	}, _KeyConfigs[Keys.JUMP_OUT_PARENTHESES] = {
	    type: KeyTypes.INPUT_NAVIGATION,
	    ariaLabel: i18n._('Navigate right out of a set of parentheses')
	}, _KeyConfigs[Keys.JUMP_OUT_EXPONENT] = {
	    type: KeyTypes.INPUT_NAVIGATION,
	    ariaLabel: i18n._('Navigate right out of an exponent')
	}, _KeyConfigs[Keys.JUMP_OUT_BASE] = {
	    type: KeyTypes.INPUT_NAVIGATION,
	    ariaLabel: i18n._('Navigate right out of a base')
	}, _KeyConfigs[Keys.JUMP_INTO_NUMERATOR] = {
	    type: KeyTypes.INPUT_NAVIGATION,
	    ariaLabel: i18n._('Navigate right into the numerator of a fraction')
	}, _KeyConfigs[Keys.JUMP_OUT_NUMERATOR] = {
	    type: KeyTypes.INPUT_NAVIGATION,
	    ariaLabel: i18n._('Navigate right out of the numerator and into the denominator')
	}, _KeyConfigs[Keys.JUMP_OUT_DENOMINATOR] = {
	    type: KeyTypes.INPUT_NAVIGATION,
	    ariaLabel: i18n._('Navigate right out of the denominator of a fraction')
	}, _KeyConfigs[Keys.BACKSPACE] = {
	    type: KeyTypes.INPUT_NAVIGATION,
	    // I18N: A label for a button that will delete some input.
	    ariaLabel: i18n._('Delete')
	}, _KeyConfigs[Keys.DISMISS] = {
	    type: KeyTypes.KEYPAD_NAVIGATION,
	    // I18N: A label for a button that will dismiss/hide a keypad.
	    ariaLabel: i18n._('Dismiss')
	}, _KeyConfigs);
	
	// Add in any multi-function buttons. By default, these keys will mix in any
	// configuration settings from their default child key (i.e., the first key in
	// the `childKeyIds` array).
	// TODO(charlie): Make the multi-function button's long-press interaction
	// accessible.
	KeyConfigs[Keys.FRAC_MULTI] = {
	    childKeyIds: [Keys.FRAC_INCLUSIVE, Keys.FRAC_EXCLUSIVE]
	};
	
	// TODO(charlie): Use the numeral color for the 'Many' key.
	KeyConfigs[Keys.MANY] = {
	    type: KeyTypes.MANY
	    // childKeyIds will be configured by the client.
	};
	
	// Add in every numeral.
	var NUMBERS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
	for (var _iterator = NUMBERS, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
	    var _ref;
	
	    if (_isArray) {
	        if (_i >= _iterator.length) break;
	        _ref = _iterator[_i++];
	    } else {
	        _i = _iterator.next();
	        if (_i.done) break;
	        _ref = _i.value;
	    }
	
	    var num = _ref;
	
	    // TODO(charlie): Consider removing the SVG icons that we have for the
	    // numeral keys. They can be rendered just as easily with text (though that
	    // would mean that we'd be using text beyond the variable key).
	    var textRepresentation = '' + num;
	    KeyConfigs['NUM_' + num] = {
	        type: KeyTypes.VALUE,
	        ariaLabel: textRepresentation,
	        icon: {
	            type: IconTypes.TEXT,
	            data: textRepresentation
	        }
	    };
	}
	
	// Add in every variable.
	var LETTERS = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
	for (var _iterator2 = LETTERS, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
	    var _ref2;
	
	    if (_isArray2) {
	        if (_i2 >= _iterator2.length) break;
	        _ref2 = _iterator2[_i2++];
	    } else {
	        _i2 = _iterator2.next();
	        if (_i2.done) break;
	        _ref2 = _i2.value;
	    }
	
	    var letter = _ref2;
	
	    var lowerCaseVariable = letter.toLowerCase();
	    var upperCaseVariable = letter.toUpperCase();
	
	    var _arr = [lowerCaseVariable, upperCaseVariable];
	    for (var _i4 = 0; _i4 < _arr.length; _i4++) {
	        var _textRepresentation = _arr[_i4];
	        KeyConfigs[_textRepresentation] = {
	            type: KeyTypes.VALUE,
	            ariaLabel: _textRepresentation,
	            icon: {
	                type: IconTypes.MATH,
	                data: _textRepresentation
	            }
	        };
	    }
	}
	
	for (var _iterator3 = Object.keys(KeyConfigs), _isArray3 = Array.isArray(_iterator3), _i3 = 0, _iterator3 = _isArray3 ? _iterator3 : _iterator3[Symbol.iterator]();;) {
	    var _ref3;
	
	    if (_isArray3) {
	        if (_i3 >= _iterator3.length) break;
	        _ref3 = _iterator3[_i3++];
	    } else {
	        _i3 = _iterator3.next();
	        if (_i3.done) break;
	        _ref3 = _i3.value;
	    }
	
	    var key = _ref3;
	
	    KeyConfigs[key] = _extends({
	        id: key,
	        // Default to an SVG icon indexed by the key name.
	        icon: {
	            type: IconTypes.SVG,
	            data: key
	        }
	    }, KeyConfigs[key]);
	}
	
	module.exports = KeyConfigs;

/***/ },
/* 316 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = {
	    // naming convetion: verb + noun
	    // the noun should be one of the other properties in the object that's
	    // being dispatched
	    dismissKeypad: function dismissKeypad() {
	        return {
	            type: 'DismissKeypad'
	        };
	    },
	    activateKeypad: function activateKeypad() {
	        return {
	            type: 'ActivateKeypad'
	        };
	    },
	
	
	    /**
	     * Configure the keypad with the provided configuration parameters.
	     *
	     * See: `prop-types.js#keypadConfigurationPropType`.
	     */
	    configureKeypad: function configureKeypad(configuration) {
	        return {
	            type: 'ConfigureKeypad',
	            configuration: configuration
	        };
	    },
	    setPageSize: function setPageSize(pageWidthPx, pageHeightPx) {
	        return {
	            type: 'SetPageSize',
	            pageWidthPx: pageWidthPx,
	            pageHeightPx: pageHeightPx
	        };
	    },
	    removeEcho: function removeEcho(animationId) {
	        return {
	            type: 'RemoveEcho',
	            animationId: animationId
	        };
	    },
	
	
	    // Input-related actions.
	    setKeyHandler: function setKeyHandler(keyHandler) {
	        return {
	            type: 'SetKeyHandler',
	            keyHandler: keyHandler
	        };
	    },
	    setCursor: function setCursor(cursor) {
	        return {
	            type: 'SetCursor',
	            cursor: cursor
	        };
	    }
	};

/***/ },
/* 317 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var _keypadForType;
	
	var Redux = __webpack_require__(470);
	
	var _require = __webpack_require__(355),
	    tabletCutoffPx = _require.tabletCutoffPx;
	
	var computeLayoutParameters = __webpack_require__(404);
	
	var _require2 = __webpack_require__(283),
	    DeviceOrientations = _require2.DeviceOrientations,
	    DeviceTypes = _require2.DeviceTypes,
	    EchoAnimationTypes = _require2.EchoAnimationTypes,
	    KeyTypes = _require2.KeyTypes,
	    KeypadTypes = _require2.KeypadTypes,
	    LayoutModes = _require2.LayoutModes;
	
	var Keys = __webpack_require__(395);
	var KeyConfigs = __webpack_require__(315);
	var CursorContexts = __webpack_require__(310);
	var GestureManager = __webpack_require__(405);
	var VelocityTracker = __webpack_require__(406);
	
	var FractionKeypad = __webpack_require__(360);
	var ExpressionKeypad = __webpack_require__(361);
	
	var keypadForType = (_keypadForType = {}, _keypadForType[KeypadTypes.FRACTION] = FractionKeypad, _keypadForType[KeypadTypes.EXPRESSION] = ExpressionKeypad, _keypadForType);
	
	var createStore = function createStore() {
	    var initialInputState = {
	        keyHandler: null,
	        cursor: {
	            context: CursorContexts.NONE
	        }
	    };
	
	    var inputReducer = function inputReducer() {
	        var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialInputState;
	        var action = arguments[1];
	
	        switch (action.type) {
	            case 'SetKeyHandler':
	                return _extends({}, state, {
	                    keyHandler: action.keyHandler
	                });
	
	            case 'PressKey':
	                var keyConfig = KeyConfigs[action.key];
	                if (keyConfig.type !== KeyTypes.KEYPAD_NAVIGATION) {
	                    // This is probably an anti-pattern but it works for the
	                    // case where we don't actually control the state but we
	                    // still want to communicate with the other object
	                    return _extends({}, state, {
	                        cursor: state.keyHandler(keyConfig.id)
	                    });
	                }
	
	                // TODO(kevinb) get state from MathQuill and store it?
	                return state;
	
	            case 'SetCursor':
	                return _extends({}, state, {
	                    cursor: action.cursor
	                });
	
	            default:
	                return state;
	        }
	    };
	
	    var defaultKeypadType = KeypadTypes.EXPRESSION;
	
	    var initialKeypadState = {
	        extraKeys: ['x', 'y', Keys.THETA, Keys.PI],
	        keypadType: defaultKeypadType,
	        active: false
	    };
	
	    var keypadReducer = function keypadReducer() {
	        var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialKeypadState;
	        var action = arguments[1];
	
	        switch (action.type) {
	            case 'DismissKeypad':
	                return _extends({}, state, {
	                    active: false
	                });
	
	            case 'ActivateKeypad':
	                return _extends({}, state, {
	                    active: true
	                });
	
	            case 'ConfigureKeypad':
	                return _extends({}, state, {
	                    // Default `extraKeys` to the empty array.
	                    extraKeys: []
	                }, action.configuration);
	
	            case 'PressKey':
	                var keyConfig = KeyConfigs[action.key];
	                // NOTE(charlie): Our keypad system operates by triggering key
	                // presses with key IDs in a dumb manner, such that the keys
	                // don't know what they can do--instead, the store is
	                // responsible for interpreting key presses and triggering the
	                // right actions when they occur. Hence, we figure off a
	                // dismissal here rather than dispatching a dismiss action in
	                // the first place.
	                if (keyConfig.id === Keys.DISMISS) {
	                    return keypadReducer(state, { type: 'DismissKeypad' });
	                }
	                return state;
	
	            default:
	                return state;
	        }
	    };
	
	    // We default to the right-most page. This is done so-as to enforce a
	    // consistent orientation between the view pager layout and the flattened
	    // layout, where our default page appears on the far right.
	    var getDefaultPage = function getDefaultPage(numPages) {
	        return numPages - 1;
	    };
	
	    var initialPagerState = {
	        animateToPosition: false,
	        currentPage: getDefaultPage(keypadForType[defaultKeypadType].numPages),
	        // The cumulative differential in the horizontal direction for the
	        // current swipe.
	        dx: 0,
	        numPages: keypadForType[defaultKeypadType].numPages,
	        pageWidthPx: 0,
	        velocityTracker: new VelocityTracker()
	    };
	
	    var pagerReducer = function pagerReducer() {
	        var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialPagerState;
	        var action = arguments[1];
	
	        switch (action.type) {
	            case 'ConfigureKeypad':
	                var keypadType = action.configuration.keypadType;
	                var numPages = keypadForType[keypadType].numPages;
	
	                return _extends({}, state, {
	                    numPages: numPages,
	                    animateToPosition: false,
	                    currentPage: getDefaultPage(numPages),
	                    dx: 0
	                });
	
	            case 'SetPageSize':
	                return _extends({}, state, {
	                    pageWidthPx: action.pageWidthPx
	                });
	
	            case 'PressKey':
	                var keyConfig = KeyConfigs[action.key];
	
	                // Reset the keypad page if the user performs a math operation.
	                if (keyConfig.type === KeyTypes.VALUE || keyConfig.type === KeyTypes.OPERATOR) {
	                    return pagerReducer(state, { type: 'ResetKeypadPage' });
	                }
	                return state;
	
	            case 'ResetKeypadPage':
	                return _extends({}, state, {
	                    animateToPosition: true,
	                    // We start at the right-most page.
	                    currentPage: getDefaultPage(state.numPages),
	                    dx: 0
	                });
	
	            case 'PageKeypadRight':
	                var nextPage = Math.min(state.currentPage + 1, state.numPages - 1);
	                return _extends({}, state, {
	                    animateToPosition: true,
	                    currentPage: nextPage,
	                    dx: 0
	                });
	
	            case 'PageKeypadLeft':
	                var prevPage = Math.max(state.currentPage - 1, 0);
	                return _extends({}, state, {
	                    animateToPosition: true,
	                    currentPage: prevPage,
	                    dx: 0
	                });
	
	            case 'OnSwipeChange':
	                state.velocityTracker.push(action.dx);
	
	                return _extends({}, state, {
	                    animateToPosition: false,
	                    dx: action.dx
	                });
	
	            case 'OnSwipeEnd':
	                var pageWidthPx = state.pageWidthPx,
	                    velocityTracker = state.velocityTracker;
	                var dx = action.dx;
	
	                var velocity = velocityTracker.getVelocity();
	
	                // NOTE(charlie): These will need refinement. The velocity comes
	                // from Framer.
	                var minFlingVelocity = 0.1;
	                var minFlingDistance = 10;
	
	                var shouldPageRight = dx < -pageWidthPx / 2 || velocity < -minFlingVelocity && dx < -minFlingDistance;
	
	                var shouldPageLeft = dx > pageWidthPx / 2 || velocity > minFlingVelocity && dx > minFlingDistance;
	
	                if (shouldPageRight) {
	                    return pagerReducer(state, { type: 'PageKeypadRight' });
	                } else if (shouldPageLeft) {
	                    return pagerReducer(state, { type: 'PageKeypadLeft' });
	                }
	
	                return _extends({}, state, {
	                    animateToPosition: true,
	                    dx: 0
	                });
	
	            default:
	                return state;
	        }
	    };
	
	    var createGestureManager = function createGestureManager(swipeEnabled) {
	        return new GestureManager({
	            swipeEnabled: swipeEnabled
	        }, {
	            onSwipeChange: function onSwipeChange(dx) {
	                store.dispatch({
	                    type: 'OnSwipeChange',
	                    dx: dx
	                });
	            },
	            onSwipeEnd: function onSwipeEnd(dx) {
	                store.dispatch({
	                    type: 'OnSwipeEnd',
	                    dx: dx
	                });
	            },
	            onActiveNodesChanged: function onActiveNodesChanged(activeNodes) {
	                store.dispatch({
	                    type: 'SetActiveNodes',
	                    activeNodes: activeNodes
	                });
	            },
	            onClick: function onClick(key, layoutProps, inPopover) {
	                store.dispatch(_extends({
	                    type: 'PressKey',
	                    key: key
	                }, layoutProps, {
	                    inPopover: inPopover
	                }));
	            }
	        }, [], [Keys.BACKSPACE, Keys.UP, Keys.RIGHT, Keys.DOWN, Keys.LEFT]);
	    };
	
	    var initialGestureState = {
	        popover: null,
	        focus: null,
	        gestureManager: createGestureManager(keypadForType[defaultKeypadType].numPages > 1)
	    };
	
	    var gestureReducer = function gestureReducer() {
	        var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialGestureState;
	        var action = arguments[1];
	
	        switch (action.type) {
	            case 'DismissKeypad':
	                // NOTE(charlie): In the past, we enforced the "gesture manager
	                // will not receive any events when the keypad is hidden"
	                // assumption by assuming that the keypad would be hidden when
	                // dismissed and, as such, that none of its managed DOM nodes
	                // would be able to receive touch events. However, on mobile
	                // Safari, we're seeing that some of the keys receive touch
	                // events even when off-screen, inexplicably. So, to guard
	                // against that bug and make the contract explicit, we enable
	                // and disable event tracking on activation and dismissal.
	                state.gestureManager.disableEventTracking();
	                return state;
	
	            case 'ActivateKeypad':
	                state.gestureManager.enableEventTracking();
	                return state;
	
	            case 'SetActiveNodes':
	                return _extends({}, state, action.activeNodes);
	
	            case 'ConfigureKeypad':
	                var keypadType = action.configuration.keypadType;
	                var numPages = keypadForType[keypadType].numPages;
	
	                var swipeEnabled = numPages > 1;
	                return {
	                    popover: null,
	                    focus: null,
	                    gestureManager: createGestureManager(swipeEnabled)
	                };
	
	            default:
	                return state;
	        }
	    };
	
	    // Used to generate unique animation IDs for the echo animations. The actual
	    // values are irrelevant as long as they are unique.
	    var _lastAnimationId = 0;
	
	    var initialEchoState = {
	        echoes: []
	    };
	
	    var echoReducer = function echoReducer() {
	        var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialEchoState;
	        var action = arguments[1];
	
	        switch (action.type) {
	            case 'PressKey':
	                var keyConfig = KeyConfigs[action.key];
	
	                // Add in the echo animation if the user performs a math
	                // operation.
	                if (keyConfig.type === KeyTypes.VALUE || keyConfig.type === KeyTypes.OPERATOR) {
	                    return _extends({}, state, {
	                        echoes: [].concat(state.echoes, [{
	                            animationId: "" + _lastAnimationId++,
	                            animationType: action.inPopover ? EchoAnimationTypes.LONG_FADE_ONLY : EchoAnimationTypes.FADE_ONLY,
	                            borders: action.borders,
	                            id: keyConfig.id,
	                            initialBounds: action.initialBounds
	                        }])
	                    });
	                }
	                return state;
	
	            case 'RemoveEcho':
	                var remainingEchoes = state.echoes.filter(function (echo) {
	                    return echo.animationId !== action.animationId;
	                });
	                return _extends({}, state, {
	                    echoes: remainingEchoes
	                });
	
	            default:
	                return state;
	        }
	    };
	
	    var initialLayoutState = {
	        gridDimensions: {
	            numRows: keypadForType[defaultKeypadType].rows,
	            numColumns: keypadForType[defaultKeypadType].columns,
	            numMaxVisibleRows: keypadForType[defaultKeypadType].maxVisibleRows,
	            numPages: keypadForType[defaultKeypadType].numPages
	        },
	        buttonDimensions: {
	            widthPx: 48,
	            heightPx: 48
	        },
	        pageDimensions: {
	            pageWidthPx: 0,
	            pageHeightPx: 0
	        },
	        layoutMode: LayoutModes.FULLSCREEN,
	        paginationEnabled: false,
	        navigationPadEnabled: false
	    };
	
	    /**
	     * Compute the additional layout state based on the provided page and grid
	     * dimensions.
	     */
	    var layoutParametersForDimensions = function layoutParametersForDimensions(pageDimensions, gridDimensions) {
	        var pageWidthPx = pageDimensions.pageWidthPx,
	            pageHeightPx = pageDimensions.pageHeightPx;
	
	        // Determine the device type and orientation.
	
	        var deviceOrientation = pageWidthPx > pageHeightPx ? DeviceOrientations.LANDSCAPE : DeviceOrientations.PORTRAIT;
	        var deviceType = Math.min(pageWidthPx, pageHeightPx) > tabletCutoffPx ? DeviceTypes.TABLET : DeviceTypes.PHONE;
	
	        // Using that information, make some decisions (or assumptions)
	        // about the resulting layout.
	        var navigationPadEnabled = deviceType === DeviceTypes.TABLET;
	        var paginationEnabled = deviceType === DeviceTypes.PHONE && deviceOrientation === DeviceOrientations.PORTRAIT;
	
	        var deviceInfo = { deviceOrientation: deviceOrientation, deviceType: deviceType };
	        var layoutOptions = {
	            navigationPadEnabled: navigationPadEnabled,
	            paginationEnabled: paginationEnabled,
	            // HACK(charlie): It's not great that we're making assumptions about
	            // the toolbar (which is rendered by webapp, and should always be
	            // visible and anchored to the bottom of the page for phone and
	            // tablet exercises). But this is primarily a heuristic (the goal is
	            // to preserve a 'good' amount of space between the top of the
	            // keypad and the top of the page) so we afford to have some margin
	            // of error.
	            toolbarEnabled: true
	        };
	
	        return _extends({}, computeLayoutParameters(gridDimensions, pageDimensions, deviceInfo, layoutOptions), {
	            // Pass along some of the layout information, so that other
	            // components in the heirarchy can adapt appropriately.
	            navigationPadEnabled: navigationPadEnabled,
	            paginationEnabled: paginationEnabled
	        });
	    };
	
	    var layoutReducer = function layoutReducer() {
	        var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : initialLayoutState;
	        var action = arguments[1];
	
	        switch (action.type) {
	            case 'ConfigureKeypad':
	                var keypadType = action.configuration.keypadType;
	
	                var gridDimensions = {
	                    numRows: keypadForType[keypadType].rows,
	                    numColumns: keypadForType[keypadType].columns,
	                    numMaxVisibleRows: keypadForType[keypadType].maxVisibleRows,
	                    numPages: keypadForType[keypadType].numPages
	                };
	
	                return _extends({}, state, layoutParametersForDimensions(state.pageDimensions, gridDimensions), {
	                    gridDimensions: gridDimensions
	                });
	
	            case 'SetPageSize':
	                var pageWidthPx = action.pageWidthPx,
	                    pageHeightPx = action.pageHeightPx;
	
	                var pageDimensions = { pageWidthPx: pageWidthPx, pageHeightPx: pageHeightPx };
	
	                return _extends({}, state, layoutParametersForDimensions(pageDimensions, state.gridDimensions), {
	                    pageDimensions: pageDimensions
	                });
	
	            default:
	                return state;
	        }
	    };
	
	    var reducer = Redux.combineReducers({
	        input: inputReducer,
	        keypad: keypadReducer,
	        pager: pagerReducer,
	        gestures: gestureReducer,
	        echoes: echoReducer,
	        layout: layoutReducer
	    });
	
	    // TODO(charlie): This non-inlined return is necessary so as to allow the
	    // gesture manager to dispatch actions on the store in its callbacks. We
	    // should come up with a better pattern to remove the two-way dependency.
	    var store = Redux.createStore(reducer);
	
	    return store;
	};
	
	module.exports = createStore;

/***/ },
/* 318 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {"use strict";
	
	// Use the fastest means possible to execute a task in its own turn, with
	// priority over other events including IO, animation, reflow, and redraw
	// events in browsers.
	//
	// An exception thrown by a task will permanently interrupt the processing of
	// subsequent tasks. The higher level `asap` function ensures that if an
	// exception is thrown by a task, that the task queue will continue flushing as
	// soon as possible, but if you use `rawAsap` directly, you are responsible to
	// either ensure that no exceptions are thrown from your task, or to manually
	// call `rawAsap.requestFlush` if an exception is thrown.
	module.exports = rawAsap;
	function rawAsap(task) {
	    if (!queue.length) {
	        requestFlush();
	        flushing = true;
	    }
	    // Equivalent to push, but avoids a function call.
	    queue[queue.length] = task;
	}
	
	var queue = [];
	// Once a flush has been requested, no further calls to `requestFlush` are
	// necessary until the next `flush` completes.
	var flushing = false;
	// `requestFlush` is an implementation-specific method that attempts to kick
	// off a `flush` event as quickly as possible. `flush` will attempt to exhaust
	// the event queue before yielding to the browser's own event loop.
	var requestFlush;
	// The position of the next task to execute in the task queue. This is
	// preserved between calls to `flush` so that it can be resumed if
	// a task throws an exception.
	var index = 0;
	// If a task schedules additional tasks recursively, the task queue can grow
	// unbounded. To prevent memory exhaustion, the task queue will periodically
	// truncate already-completed tasks.
	var capacity = 1024;
	
	// The flush function processes all tasks that have been scheduled with
	// `rawAsap` unless and until one of those tasks throws an exception.
	// If a task throws an exception, `flush` ensures that its state will remain
	// consistent and will resume where it left off when called again.
	// However, `flush` does not make any arrangements to be called again if an
	// exception is thrown.
	function flush() {
	    while (index < queue.length) {
	        var currentIndex = index;
	        // Advance the index before calling the task. This ensures that we will
	        // begin flushing on the next task the task throws an error.
	        index = index + 1;
	        queue[currentIndex].call();
	        // Prevent leaking memory for long chains of recursive calls to `asap`.
	        // If we call `asap` within tasks scheduled by `asap`, the queue will
	        // grow, but to avoid an O(n) walk for every task we execute, we don't
	        // shift tasks off the queue after they have been executed.
	        // Instead, we periodically shift 1024 tasks off the queue.
	        if (index > capacity) {
	            // Manually shift all values starting at the index back to the
	            // beginning of the queue.
	            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
	                queue[scan] = queue[scan + index];
	            }
	            queue.length -= index;
	            index = 0;
	        }
	    }
	    queue.length = 0;
	    index = 0;
	    flushing = false;
	}
	
	// `requestFlush` is implemented using a strategy based on data collected from
	// every available SauceLabs Selenium web driver worker at time of writing.
	// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593
	
	// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that
	// have WebKitMutationObserver but not un-prefixed MutationObserver.
	// Must use `global` or `self` instead of `window` to work in both frames and web
	// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.
	
	/* globals self */
	var scope = typeof global !== "undefined" ? global : self;
	var BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;
	
	// MutationObservers are desirable because they have high priority and work
	// reliably everywhere they are implemented.
	// They are implemented in all modern browsers.
	//
	// - Android 4-4.3
	// - Chrome 26-34
	// - Firefox 14-29
	// - Internet Explorer 11
	// - iPad Safari 6-7.1
	// - iPhone Safari 7-7.1
	// - Safari 6-7
	if (typeof BrowserMutationObserver === "function") {
	    requestFlush = makeRequestCallFromMutationObserver(flush);
	
	// MessageChannels are desirable because they give direct access to the HTML
	// task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera
	// 11-12, and in web workers in many engines.
	// Although message channels yield to any queued rendering and IO tasks, they
	// would be better than imposing the 4ms delay of timers.
	// However, they do not work reliably in Internet Explorer or Safari.
	
	// Internet Explorer 10 is the only browser that has setImmediate but does
	// not have MutationObservers.
	// Although setImmediate yields to the browser's renderer, it would be
	// preferrable to falling back to setTimeout since it does not have
	// the minimum 4ms penalty.
	// Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and
	// Desktop to a lesser extent) that renders both setImmediate and
	// MessageChannel useless for the purposes of ASAP.
	// https://github.com/kriskowal/q/issues/396
	
	// Timers are implemented universally.
	// We fall back to timers in workers in most engines, and in foreground
	// contexts in the following browsers.
	// However, note that even this simple case requires nuances to operate in a
	// broad spectrum of browsers.
	//
	// - Firefox 3-13
	// - Internet Explorer 6-9
	// - iPad Safari 4.3
	// - Lynx 2.8.7
	} else {
	    requestFlush = makeRequestCallFromTimer(flush);
	}
	
	// `requestFlush` requests that the high priority event queue be flushed as
	// soon as possible.
	// This is useful to prevent an error thrown in a task from stalling the event
	// queue if the exception handled by Node.js’s
	// `process.on("uncaughtException")` or by a domain.
	rawAsap.requestFlush = requestFlush;
	
	// To request a high priority event, we induce a mutation observer by toggling
	// the text of a text node between "1" and "-1".
	function makeRequestCallFromMutationObserver(callback) {
	    var toggle = 1;
	    var observer = new BrowserMutationObserver(callback);
	    var node = document.createTextNode("");
	    observer.observe(node, {characterData: true});
	    return function requestCall() {
	        toggle = -toggle;
	        node.data = toggle;
	    };
	}
	
	// The message channel technique was discovered by Malte Ubl and was the
	// original foundation for this library.
	// http://www.nonblocking.io/2011/06/windownexttick.html
	
	// Safari 6.0.5 (at least) intermittently fails to create message ports on a
	// page's first load. Thankfully, this version of Safari supports
	// MutationObservers, so we don't need to fall back in that case.
	
	// function makeRequestCallFromMessageChannel(callback) {
	//     var channel = new MessageChannel();
	//     channel.port1.onmessage = callback;
	//     return function requestCall() {
	//         channel.port2.postMessage(0);
	//     };
	// }
	
	// For reasons explained above, we are also unable to use `setImmediate`
	// under any circumstances.
	// Even if we were, there is another bug in Internet Explorer 10.
	// It is not sufficient to assign `setImmediate` to `requestFlush` because
	// `setImmediate` must be called *by name* and therefore must be wrapped in a
	// closure.
	// Never forget.
	
	// function makeRequestCallFromSetImmediate(callback) {
	//     return function requestCall() {
	//         setImmediate(callback);
	//     };
	// }
	
	// Safari 6.0 has a problem where timers will get lost while the user is
	// scrolling. This problem does not impact ASAP because Safari 6.0 supports
	// mutation observers, so that implementation is used instead.
	// However, if we ever elect to use timers in Safari, the prevalent work-around
	// is to add a scroll event listener that calls for a flush.
	
	// `setTimeout` does not call the passed callback if the delay is less than
	// approximately 7 in web workers in Firefox 8 through 18, and sometimes not
	// even then.
	
	function makeRequestCallFromTimer(callback) {
	    return function requestCall() {
	        // We dispatch a timeout with a specified delay of 0 for engines that
	        // can reliably accommodate that request. This will usually be snapped
	        // to a 4 milisecond delay, but once we're flushing, there's no delay
	        // between events.
	        var timeoutHandle = setTimeout(handleTimer, 0);
	        // However, since this timer gets frequently dropped in Firefox
	        // workers, we enlist an interval handle that will try to fire
	        // an event 20 times per second until it succeeds.
	        var intervalHandle = setInterval(handleTimer, 50);
	
	        function handleTimer() {
	            // Whichever timer succeeds will cancel both timers and
	            // execute the callback.
	            clearTimeout(timeoutHandle);
	            clearInterval(intervalHandle);
	            callback();
	        }
	    };
	}
	
	// This is for `asap.js` only.
	// Its name will be periodically randomized to break any code that depends on
	// its existence.
	rawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;
	
	// ASAP was originally a nextTick shim included in Q. This was factored out
	// into this ASAP package. It was later adapted to RSVP which made further
	// amendments. These decisions, particularly to marginalize MessageChannel and
	// to capture the MutationObserver implementation in a closure, were integrated
	// back into ASAP proper.
	// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js
	
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 319 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule AtomicBlockUtils
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var BlockMapBuilder = __webpack_require__(320);
	var CharacterMetadata = __webpack_require__(321);
	var ContentBlock = __webpack_require__(323);
	var DraftModifier = __webpack_require__(329);
	var EditorState = __webpack_require__(332);
	var Immutable = __webpack_require__(346);
	
	var generateRandomKey = __webpack_require__(339);
	
	var List = Immutable.List;
	var Repeat = Immutable.Repeat;
	
	var AtomicBlockUtils = {
	  insertAtomicBlock: function insertAtomicBlock(editorState, entityKey, character) {
	    var contentState = editorState.getCurrentContent();
	    var selectionState = editorState.getSelection();
	
	    var afterRemoval = DraftModifier.removeRange(contentState, selectionState, 'backward');
	
	    var targetSelection = afterRemoval.getSelectionAfter();
	    var afterSplit = DraftModifier.splitBlock(afterRemoval, targetSelection);
	    var insertionTarget = afterSplit.getSelectionAfter();
	
	    var asAtomicBlock = DraftModifier.setBlockType(afterSplit, insertionTarget, 'atomic');
	
	    var charData = CharacterMetadata.create({ entity: entityKey });
	
	    var fragmentArray = [new ContentBlock({
	      key: generateRandomKey(),
	      type: 'atomic',
	      text: character,
	      characterList: List(Repeat(charData, character.length))
	    }), new ContentBlock({
	      key: generateRandomKey(),
	      type: 'unstyled',
	      text: '',
	      characterList: List()
	    })];
	
	    var fragment = BlockMapBuilder.createFromArray(fragmentArray);
	
	    var withAtomicBlock = DraftModifier.replaceWithFragment(asAtomicBlock, insertionTarget, fragment);
	
	    var newContent = withAtomicBlock.merge({
	      selectionBefore: selectionState,
	      selectionAfter: withAtomicBlock.getSelectionAfter().set('hasFocus', true)
	    });
	
	    return EditorState.push(editorState, newContent, 'insert-fragment');
	  }
	};
	
	module.exports = AtomicBlockUtils;

/***/ },
/* 320 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule BlockMapBuilder
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(346);
	
	var OrderedMap = Immutable.OrderedMap;
	
	var BlockMapBuilder = {
	  createFromArray: function createFromArray(blocks) {
	    return OrderedMap(blocks.map(function (block) {
	      return [block.getKey(), block];
	    }));
	  }
	};
	
	module.exports = BlockMapBuilder;

/***/ },
/* 321 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule CharacterMetadata
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var _require = __webpack_require__(346);
	
	var Map = _require.Map;
	var OrderedSet = _require.OrderedSet;
	var Record = _require.Record;
	
	var EMPTY_SET = OrderedSet();
	
	var defaultRecord = {
	  style: EMPTY_SET,
	  entity: null
	};
	
	var CharacterMetadataRecord = Record(defaultRecord);
	
	var CharacterMetadata = (function (_CharacterMetadataRecord) {
	  _inherits(CharacterMetadata, _CharacterMetadataRecord);
	
	  function CharacterMetadata() {
	    _classCallCheck(this, CharacterMetadata);
	
	    _get(Object.getPrototypeOf(CharacterMetadata.prototype), 'constructor', this).apply(this, arguments);
	  }
	
	  _createClass(CharacterMetadata, [{
	    key: 'getStyle',
	    value: function getStyle() {
	      return this.get('style');
	    }
	  }, {
	    key: 'getEntity',
	    value: function getEntity() {
	      return this.get('entity');
	    }
	  }, {
	    key: 'hasStyle',
	    value: function hasStyle(style) {
	      return this.getStyle().has(style);
	    }
	  }], [{
	    key: 'applyStyle',
	    value: function applyStyle(record, style) {
	      var withStyle = record.set('style', record.getStyle().add(style));
	      return CharacterMetadata.create(withStyle);
	    }
	  }, {
	    key: 'removeStyle',
	    value: function removeStyle(record, style) {
	      var withoutStyle = record.set('style', record.getStyle().remove(style));
	      return CharacterMetadata.create(withoutStyle);
	    }
	  }, {
	    key: 'applyEntity',
	    value: function applyEntity(record, entityKey) {
	      var withEntity = record.getEntity() === entityKey ? record : record.set('entity', entityKey);
	      return CharacterMetadata.create(withEntity);
	    }
	
	    /**
	     * Use this function instead of the `CharacterMetadata` constructor.
	     * Since most content generally uses only a very small number of
	     * style/entity permutations, we can reuse these objects as often as
	     * possible.
	     */
	  }, {
	    key: 'create',
	    value: function create(config) {
	      if (!config) {
	        return EMPTY;
	      }
	
	      // Fill in unspecified properties, if necessary.
	      var configMap = Map({ style: EMPTY_SET, entity: null }).merge(config);
	
	      var existing = pool.get(configMap);
	      if (existing) {
	        return existing;
	      }
	
	      var newCharacter = new CharacterMetadata(configMap);
	      pool = pool.set(configMap, newCharacter);
	      return newCharacter;
	    }
	  }]);
	
	  return CharacterMetadata;
	})(CharacterMetadataRecord);
	
	var EMPTY = new CharacterMetadata();
	var pool = Map([[Map(defaultRecord), EMPTY]]);
	
	CharacterMetadata.EMPTY = EMPTY;
	
	module.exports = CharacterMetadata;

/***/ },
/* 322 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule CompositeDraftDecorator
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	var Immutable = __webpack_require__(346);
	
	var List = Immutable.List;
	
	var DELIMITER = '.';
	
	/**
	 * A CompositeDraftDecorator traverses through a list of DraftDecorator
	 * instances to identify sections of a ContentBlock that should be rendered
	 * in a "decorated" manner. For example, hashtags, mentions, and links may
	 * be intended to stand out visually, be rendered as anchors, etc.
	 *
	 * The list of decorators supplied to the constructor will be used in the
	 * order they are provided. This allows the caller to specify a priority for
	 * string matching, in case of match collisions among decorators.
	 *
	 * For instance, I may have a link with a `#` in its text. Though this section
	 * of text may match our hashtag decorator, it should not be treated as a
	 * hashtag. I should therefore list my link DraftDecorator
	 * before my hashtag DraftDecorator when constructing this composite
	 * decorator instance.
	 *
	 * Thus, when a collision like this is encountered, the earlier match is
	 * preserved and the new match is discarded.
	 */
	
	var CompositeDraftDecorator = (function () {
	  function CompositeDraftDecorator(decorators) {
	    _classCallCheck(this, CompositeDraftDecorator);
	
	    // Copy the decorator array, since we use this array order to determine
	    // precedence of decoration matching. If the array is mutated externally,
	    // we don't want to be affected here.
	    this._decorators = decorators.slice();
	  }
	
	  /**
	   * Determine whether we can occupy the specified slice of the decorations
	   * array.
	   */
	
	  _createClass(CompositeDraftDecorator, [{
	    key: 'getDecorations',
	    value: function getDecorations(block) {
	      var decorations = Array(block.getText().length).fill(null);
	
	      this._decorators.forEach(function ( /*object*/decorator, /*number*/ii) {
	        var counter = 0;
	        var strategy = decorator.strategy;
	        strategy(block, function ( /*number*/start, /*number*/end) {
	          // Find out if any of our matching range is already occupied
	          // by another decorator. If so, discard the match. Otherwise, store
	          // the component key for rendering.
	          if (canOccupySlice(decorations, start, end)) {
	            occupySlice(decorations, start, end, ii + DELIMITER + counter);
	            counter++;
	          }
	        });
	      });
	
	      return List(decorations);
	    }
	  }, {
	    key: 'getComponentForKey',
	    value: function getComponentForKey(key) {
	      var componentKey = parseInt(key.split(DELIMITER)[0], 10);
	      return this._decorators[componentKey].component;
	    }
	  }, {
	    key: 'getPropsForKey',
	    value: function getPropsForKey(key) {
	      var componentKey = parseInt(key.split(DELIMITER)[0], 10);
	      return this._decorators[componentKey].props;
	    }
	  }]);
	
	  return CompositeDraftDecorator;
	})();
	
	function canOccupySlice(decorations, start, end) {
	  for (var ii = start; ii < end; ii++) {
	    if (decorations[ii] != null) {
	      return false;
	    }
	  }
	  return true;
	}
	
	/**
	 * Splice the specified component into our decoration array at the desired
	 * range.
	 */
	function occupySlice(targetArr, start, end, componentKey) {
	  for (var ii = start; ii < end; ii++) {
	    targetArr[ii] = componentKey;
	  }
	}
	
	module.exports = CompositeDraftDecorator;

/***/ },
/* 323 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule ContentBlock
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var Immutable = __webpack_require__(346);
	
	var findRangesImmutable = __webpack_require__(376);
	
	var List = Immutable.List;
	var OrderedSet = Immutable.OrderedSet;
	var Record = Immutable.Record;
	
	var EMPTY_SET = OrderedSet();
	
	var defaultRecord = {
	  key: '',
	  type: 'unstyled',
	  text: '',
	  characterList: List(),
	  depth: 0
	};
	
	var ContentBlockRecord = Record(defaultRecord);
	
	var ContentBlock = (function (_ContentBlockRecord) {
	  _inherits(ContentBlock, _ContentBlockRecord);
	
	  function ContentBlock() {
	    _classCallCheck(this, ContentBlock);
	
	    _get(Object.getPrototypeOf(ContentBlock.prototype), 'constructor', this).apply(this, arguments);
	  }
	
	  _createClass(ContentBlock, [{
	    key: 'getKey',
	    value: function getKey() {
	      return this.get('key');
	    }
	  }, {
	    key: 'getType',
	    value: function getType() {
	      return this.get('type');
	    }
	  }, {
	    key: 'getText',
	    value: function getText() {
	      return this.get('text');
	    }
	  }, {
	    key: 'getCharacterList',
	    value: function getCharacterList() {
	      return this.get('characterList');
	    }
	  }, {
	    key: 'getLength',
	    value: function getLength() {
	      return this.getText().length;
	    }
	  }, {
	    key: 'getDepth',
	    value: function getDepth() {
	      return this.get('depth');
	    }
	  }, {
	    key: 'getInlineStyleAt',
	    value: function getInlineStyleAt(offset) {
	      var character = this.getCharacterList().get(offset);
	      return character ? character.getStyle() : EMPTY_SET;
	    }
	  }, {
	    key: 'getEntityAt',
	    value: function getEntityAt(offset) {
	      var character = this.getCharacterList().get(offset);
	      return character ? character.getEntity() : null;
	    }
	
	    /**
	     * Execute a callback for every contiguous range of styles within the block.
	     */
	  }, {
	    key: 'findStyleRanges',
	    value: function findStyleRanges(filterFn, callback) {
	      findRangesImmutable(this.getCharacterList(), haveEqualStyle, filterFn, callback);
	    }
	
	    /**
	     * Execute a callback for every contiguous range of entities within the block.
	     */
	  }, {
	    key: 'findEntityRanges',
	    value: function findEntityRanges(filterFn, callback) {
	      findRangesImmutable(this.getCharacterList(), haveEqualEntity, filterFn, callback);
	    }
	  }]);
	
	  return ContentBlock;
	})(ContentBlockRecord);
	
	function haveEqualStyle(charA, charB) {
	  return charA.getStyle() === charB.getStyle();
	}
	
	function haveEqualEntity(charA, charB) {
	  return charA.getEntity() === charB.getEntity();
	}
	
	module.exports = ContentBlock;

/***/ },
/* 324 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule ContentState
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	var _get = function get(_x2, _x3, _x4) { var _again = true; _function: while (_again) { var object = _x2, property = _x3, receiver = _x4; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x2 = parent; _x3 = property; _x4 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var BlockMapBuilder = __webpack_require__(320);
	var CharacterMetadata = __webpack_require__(321);
	var ContentBlock = __webpack_require__(323);
	var Immutable = __webpack_require__(346);
	var SelectionState = __webpack_require__(335);
	
	var generateRandomKey = __webpack_require__(339);
	var sanitizeDraftText = __webpack_require__(375);
	
	var List = Immutable.List;
	var Record = Immutable.Record;
	var Repeat = Immutable.Repeat;
	
	var defaultRecord = {
	  blockMap: null,
	  selectionBefore: null,
	  selectionAfter: null
	};
	
	var ContentStateRecord = Record(defaultRecord);
	
	var ContentState = (function (_ContentStateRecord) {
	  _inherits(ContentState, _ContentStateRecord);
	
	  function ContentState() {
	    _classCallCheck(this, ContentState);
	
	    _get(Object.getPrototypeOf(ContentState.prototype), 'constructor', this).apply(this, arguments);
	  }
	
	  _createClass(ContentState, [{
	    key: 'getBlockMap',
	    value: function getBlockMap() {
	      return this.get('blockMap');
	    }
	  }, {
	    key: 'getSelectionBefore',
	    value: function getSelectionBefore() {
	      return this.get('selectionBefore');
	    }
	  }, {
	    key: 'getSelectionAfter',
	    value: function getSelectionAfter() {
	      return this.get('selectionAfter');
	    }
	  }, {
	    key: 'getBlockForKey',
	    value: function getBlockForKey(key) {
	      var block = this.getBlockMap().get(key);
	      return block;
	    }
	  }, {
	    key: 'getKeyBefore',
	    value: function getKeyBefore(key) {
	      return this.getBlockMap().reverse().keySeq().skipUntil(function (v) {
	        return v === key;
	      }).skip(1).first();
	    }
	  }, {
	    key: 'getKeyAfter',
	    value: function getKeyAfter(key) {
	      return this.getBlockMap().keySeq().skipUntil(function (v) {
	        return v === key;
	      }).skip(1).first();
	    }
	  }, {
	    key: 'getBlockAfter',
	    value: function getBlockAfter(key) {
	      return this.getBlockMap().skipUntil(function (_, k) {
	        return k === key;
	      }).skip(1).first();
	    }
	  }, {
	    key: 'getBlockBefore',
	    value: function getBlockBefore(key) {
	      return this.getBlockMap().reverse().skipUntil(function (_, k) {
	        return k === key;
	      }).skip(1).first();
	    }
	  }, {
	    key: 'getBlocksAsArray',
	    value: function getBlocksAsArray() {
	      return this.getBlockMap().toArray();
	    }
	  }, {
	    key: 'getFirstBlock',
	    value: function getFirstBlock() {
	      return this.getBlockMap().first();
	    }
	  }, {
	    key: 'getLastBlock',
	    value: function getLastBlock() {
	      return this.getBlockMap().last();
	    }
	  }, {
	    key: 'getPlainText',
	    value: function getPlainText(delimiter) {
	      return this.getBlockMap().map(function (block) {
	        return block ? block.getText() : '';
	      }).join(delimiter || '\n');
	    }
	  }, {
	    key: 'hasText',
	    value: function hasText() {
	      var blockMap = this.getBlockMap();
	      return blockMap.size > 1 || blockMap.first().getLength() > 0;
	    }
	  }], [{
	    key: 'createFromBlockArray',
	    value: function createFromBlockArray(blocks) {
	      var blockMap = BlockMapBuilder.createFromArray(blocks);
	      var selectionState = SelectionState.createEmpty(blockMap.first().getKey());
	      return new ContentState({
	        blockMap: blockMap,
	        selectionBefore: selectionState,
	        selectionAfter: selectionState
	      });
	    }
	  }, {
	    key: 'createFromText',
	    value: function createFromText(text) {
	      var delimiter = arguments.length <= 1 || arguments[1] === undefined ? /\r\n?|\n/g : arguments[1];
	
	      var strings = text.split(delimiter);
	      var blocks = strings.map(function (block) {
	        block = sanitizeDraftText(block);
	        return new ContentBlock({
	          key: generateRandomKey(),
	          text: block,
	          type: 'unstyled',
	          characterList: List(Repeat(CharacterMetadata.EMPTY, block.length))
	        });
	      });
	      return ContentState.createFromBlockArray(blocks);
	    }
	  }]);
	
	  return ContentState;
	})(ContentStateRecord);
	
	module.exports = ContentState;

/***/ },
/* 325 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DefaultDraftBlockRenderMap
	 * 
	 */
	
	'use strict';
	
	var _require = __webpack_require__(346);
	
	var Map = _require.Map;
	
	var React = __webpack_require__(43);
	
	var cx = __webpack_require__(431);
	
	var UL_WRAP = React.createElement('ul', { className: cx('public/DraftStyleDefault/ul') });
	var OL_WRAP = React.createElement('ol', { className: cx('public/DraftStyleDefault/ol') });
	var PRE_WRAP = React.createElement('pre', { className: cx('public/DraftStyleDefault/pre') });
	
	module.exports = Map({
	  'header-one': {
	    element: 'h1'
	  },
	  'header-two': {
	    element: 'h2'
	  },
	  'header-three': {
	    element: 'h3'
	  },
	  'header-four': {
	    element: 'h4'
	  },
	  'header-five': {
	    element: 'h5'
	  },
	  'header-six': {
	    element: 'h6'
	  },
	  'unordered-list-item': {
	    element: 'li',
	    wrapper: UL_WRAP
	  },
	  'ordered-list-item': {
	    element: 'li',
	    wrapper: OL_WRAP
	  },
	  'blockquote': {
	    element: 'blockquote'
	  },
	  'atomic': {
	    element: 'figure'
	  },
	  'code-block': {
	    element: 'pre',
	    wrapper: PRE_WRAP
	  },
	  'unstyled': {
	    element: 'div'
	  }
	});

/***/ },
/* 326 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DefaultDraftInlineStyle
	 * 
	 */
	
	'use strict';
	
	module.exports = {
	  BOLD: {
	    fontWeight: 'bold'
	  },
	
	  CODE: {
	    fontFamily: 'monospace',
	    wordWrap: 'break-word'
	  },
	
	  ITALIC: {
	    fontStyle: 'italic'
	  },
	
	  STRIKETHROUGH: {
	    textDecoration: 'line-through'
	  },
	
	  UNDERLINE: {
	    textDecoration: 'underline'
	  }
	};

/***/ },
/* 327 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditor.react
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var DefaultDraftBlockRenderMap = __webpack_require__(325);
	var DefaultDraftInlineStyle = __webpack_require__(326);
	var DraftEditorCompositionHandler = __webpack_require__(407);
	var DraftEditorContents = __webpack_require__(408);
	var DraftEditorDragHandler = __webpack_require__(409);
	var DraftEditorEditHandler = __webpack_require__(410);
	var DraftEditorPlaceholder = __webpack_require__(411);
	var EditorState = __webpack_require__(332);
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var Scroll = __webpack_require__(435);
	var Style = __webpack_require__(436);
	var UserAgent = __webpack_require__(433);
	
	var cx = __webpack_require__(431);
	var emptyFunction = __webpack_require__(444);
	var generateRandomKey = __webpack_require__(339);
	var getDefaultKeyBinding = __webpack_require__(340);
	var nullthrows = __webpack_require__(442);
	var getScrollPosition = __webpack_require__(440);
	
	var isIE = UserAgent.isBrowser('IE');
	
	// IE does not support the `input` event on contentEditable, so we can't
	// observe spellcheck behavior.
	var allowSpellCheck = !isIE;
	
	// Define a set of handler objects to correspond to each possible `mode`
	// of editor behavior.
	var handlerMap = {
	  'edit': DraftEditorEditHandler,
	  'composite': DraftEditorCompositionHandler,
	  'drag': DraftEditorDragHandler,
	  'cut': null,
	  'render': null
	};
	
	/**
	 * `DraftEditor` is the root editor component. It composes a `contentEditable`
	 * div, and provides a wide variety of useful function props for managing the
	 * state of the editor. See `DraftEditorProps` for details.
	 */
	
	var DraftEditor = (function (_React$Component) {
	  _inherits(DraftEditor, _React$Component);
	
	  _createClass(DraftEditor, null, [{
	    key: 'defaultProps',
	    value: {
	      blockRenderMap: DefaultDraftBlockRenderMap,
	      blockRendererFn: emptyFunction.thatReturnsNull,
	      blockStyleFn: emptyFunction.thatReturns(''),
	      keyBindingFn: getDefaultKeyBinding,
	      readOnly: false,
	      spellCheck: false,
	      stripPastedStyles: false
	    },
	    enumerable: true
	  }]);
	
	  function DraftEditor(props) {
	    var _this = this;
	
	    _classCallCheck(this, DraftEditor);
	
	    _get(Object.getPrototypeOf(DraftEditor.prototype), 'constructor', this).call(this, props);
	
	    this._blockSelectEvents = false;
	    this._clipboard = null;
	    this._guardAgainstRender = false;
	    this._handler = null;
	    this._dragCount = 0;
	    this._editorKey = generateRandomKey();
	    this._placeholderAccessibilityID = 'placeholder-' + this._editorKey;
	
	    this._onBeforeInput = this._buildHandler('onBeforeInput');
	    this._onBlur = this._buildHandler('onBlur');
	    this._onCharacterData = this._buildHandler('onCharacterData');
	    this._onCompositionEnd = this._buildHandler('onCompositionEnd');
	    this._onCompositionStart = this._buildHandler('onCompositionStart');
	    this._onCopy = this._buildHandler('onCopy');
	    this._onCut = this._buildHandler('onCut');
	    this._onDragEnd = this._buildHandler('onDragEnd');
	    this._onDragOver = this._buildHandler('onDragOver');
	    this._onDragStart = this._buildHandler('onDragStart');
	    this._onDrop = this._buildHandler('onDrop');
	    this._onInput = this._buildHandler('onInput');
	    this._onFocus = this._buildHandler('onFocus');
	    this._onKeyDown = this._buildHandler('onKeyDown');
	    this._onKeyPress = this._buildHandler('onKeyPress');
	    this._onKeyUp = this._buildHandler('onKeyUp');
	    this._onMouseDown = this._buildHandler('onMouseDown');
	    this._onMouseUp = this._buildHandler('onMouseUp');
	    this._onPaste = this._buildHandler('onPaste');
	    this._onSelect = this._buildHandler('onSelect');
	
	    // Manual binding for public and internal methods.
	    this.focus = this._focus.bind(this);
	    this.blur = this._blur.bind(this);
	    this.setMode = this._setMode.bind(this);
	    this.exitCurrentMode = this._exitCurrentMode.bind(this);
	    this.restoreEditorDOM = this._restoreEditorDOM.bind(this);
	    this.setRenderGuard = this._setRenderGuard.bind(this);
	    this.removeRenderGuard = this._removeRenderGuard.bind(this);
	    this.setClipboard = this._setClipboard.bind(this);
	    this.getClipboard = this._getClipboard.bind(this);
	    this.getEditorKey = function () {
	      return _this._editorKey;
	    };
	    this.update = this._update.bind(this);
	    this.onDragEnter = this._onDragEnter.bind(this);
	    this.onDragLeave = this._onDragLeave.bind(this);
	
	    // See `_restoreEditorDOM()`.
	    this.state = { containerKey: 0 };
	  }
	
	  /**
	   * Build a method that will pass the event to the specified handler method.
	   * This allows us to look up the correct handler function for the current
	   * editor mode, if any has been specified.
	   */
	
	  _createClass(DraftEditor, [{
	    key: '_buildHandler',
	    value: function _buildHandler(eventName) {
	      var _this2 = this;
	
	      return function (e) {
	        if (!_this2.props.readOnly) {
	          var method = _this2._handler && _this2._handler[eventName];
	          method && method.call(_this2, e);
	        }
	      };
	    }
	  }, {
	    key: '_showPlaceholder',
	    value: function _showPlaceholder() {
	      return !!this.props.placeholder && !this.props.editorState.isInCompositionMode() && !this.props.editorState.getCurrentContent().hasText();
	    }
	  }, {
	    key: '_renderPlaceholder',
	    value: function _renderPlaceholder() {
	      if (this._showPlaceholder()) {
	        return React.createElement(DraftEditorPlaceholder, {
	          text: nullthrows(this.props.placeholder),
	          editorState: this.props.editorState,
	          textAlignment: this.props.textAlignment,
	          accessibilityID: this._placeholderAccessibilityID
	        });
	      }
	      return null;
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props = this.props;
	      var readOnly = _props.readOnly;
	      var textAlignment = _props.textAlignment;
	
	      var rootClass = cx({
	        'DraftEditor/root': true,
	        'DraftEditor/alignLeft': textAlignment === 'left',
	        'DraftEditor/alignRight': textAlignment === 'right',
	        'DraftEditor/alignCenter': textAlignment === 'center'
	      });
	      var hasContent = this.props.editorState.getCurrentContent().hasText();
	
	      var contentStyle = {
	        outline: 'none',
	        whiteSpace: 'pre-wrap',
	        wordWrap: 'break-word'
	      };
	
	      return React.createElement(
	        'div',
	        { className: rootClass },
	        this._renderPlaceholder(),
	        React.createElement(
	          'div',
	          {
	            className: cx('DraftEditor/editorContainer'),
	            key: 'editor' + this.state.containerKey,
	            ref: 'editorContainer' },
	          React.createElement(
	            'div',
	            {
	              'aria-activedescendant': readOnly ? null : this.props.ariaActiveDescendantID,
	              'aria-autocomplete': readOnly ? null : this.props.ariaAutoComplete,
	              'aria-describedby': this._showPlaceholder() ? this._placeholderAccessibilityID : null,
	              'aria-expanded': readOnly ? null : this.props.ariaExpanded,
	              'aria-haspopup': readOnly ? null : this.props.ariaHasPopup,
	              'aria-label': this.props.ariaLabel,
	              'aria-owns': readOnly ? null : this.props.ariaOwneeID,
	              className: cx('public/DraftEditor/content'),
	              contentEditable: !readOnly,
	              'data-testid': this.props.webDriverTestID,
	              onBeforeInput: this._onBeforeInput,
	              onBlur: this._onBlur,
	              onCompositionEnd: this._onCompositionEnd,
	              onCompositionStart: this._onCompositionStart,
	              onCopy: this._onCopy,
	              onCut: this._onCut,
	              onDragEnd: this._onDragEnd,
	              onDragEnter: this.onDragEnter,
	              onDragLeave: this.onDragLeave,
	              onDragOver: this._onDragOver,
	              onDragStart: this._onDragStart,
	              onDrop: this._onDrop,
	              onFocus: this._onFocus,
	              onInput: this._onInput,
	              onKeyDown: this._onKeyDown,
	              onKeyPress: this._onKeyPress,
	              onKeyUp: this._onKeyUp,
	              onMouseUp: this._onMouseUp,
	              onPaste: this._onPaste,
	              onSelect: this._onSelect,
	              ref: 'editor',
	              role: readOnly ? null : this.props.role || 'textbox',
	              spellCheck: allowSpellCheck && this.props.spellCheck,
	              style: contentStyle,
	              suppressContentEditableWarning: true,
	              tabIndex: this.props.tabIndex },
	            React.createElement(DraftEditorContents, {
	              blockRenderMap: this.props.blockRenderMap,
	              blockRendererFn: this.props.blockRendererFn,
	              blockStyleFn: this.props.blockStyleFn,
	              customStyleMap: _extends({}, DefaultDraftInlineStyle, this.props.customStyleMap),
	              editorKey: this._editorKey,
	              editorState: this.props.editorState
	            })
	          )
	        )
	      );
	    }
	  }, {
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      this.setMode('edit');
	
	      /**
	       * IE has a hardcoded "feature" that attempts to convert link text into
	       * anchors in contentEditable DOM. This breaks the editor's expectations of
	       * the DOM, and control is lost. Disable it to make IE behave.
	       * See: http://blogs.msdn.com/b/ieinternals/archive/2010/09/15/
	       * ie9-beta-minor-change-list.aspx
	       */
	      if (isIE) {
	        document.execCommand('AutoUrlDetect', false, false);
	      }
	    }
	
	    /**
	     * Prevent selection events from affecting the current editor state. This
	     * is mostly intended to defend against IE, which fires off `selectionchange`
	     * events regardless of whether the selection is set via the browser or
	     * programmatically. We only care about selection events that occur because
	     * of browser interaction, not re-renders and forced selections.
	     */
	  }, {
	    key: 'componentWillUpdate',
	    value: function componentWillUpdate() {
	      this._blockSelectEvents = true;
	    }
	  }, {
	    key: 'componentDidUpdate',
	    value: function componentDidUpdate() {
	      this._blockSelectEvents = false;
	    }
	
	    /**
	     * Used via `this.focus()`.
	     *
	     * Force focus back onto the editor node.
	     *
	     * Forcing focus causes the browser to scroll to the top of the editor, which
	     * may be undesirable when the editor is taller than the viewport. To solve
	     * this, either use a specified scroll position (in cases like `cut` behavior
	     * where it should be restored to a known position) or store the current
	     * scroll state and put it back in place after focus has been forced.
	     */
	  }, {
	    key: '_focus',
	    value: function _focus(scrollPosition) {
	      var editorState = this.props.editorState;
	
	      var alreadyHasFocus = editorState.getSelection().getHasFocus();
	      var editorNode = ReactDOM.findDOMNode(this.refs.editor);
	
	      var scrollParent = Style.getScrollParent(editorNode);
	
	      var _ref = scrollPosition || getScrollPosition(scrollParent);
	
	      var x = _ref.x;
	      var y = _ref.y;
	
	      editorNode.focus();
	      if (scrollParent === window) {
	        window.scrollTo(x, y);
	      } else {
	        Scroll.setTop(scrollParent, y);
	      }
	
	      // On Chrome and Safari, calling focus on contenteditable focuses the
	      // cursor at the first character. This is something you don't expect when
	      // you're clicking on an input element but not directly on a character.
	      // Put the cursor back where it was before the blur.
	      if (!alreadyHasFocus) {
	        this.update(EditorState.forceSelection(editorState, editorState.getSelection()));
	      }
	    }
	  }, {
	    key: '_blur',
	    value: function _blur() {
	      ReactDOM.findDOMNode(this.refs.editor).blur();
	    }
	
	    /**
	     * Used via `this.setMode(...)`.
	     *
	     * Set the behavior mode for the editor component. This switches the current
	     * handler module to ensure that DOM events are managed appropriately for
	     * the active mode.
	     */
	  }, {
	    key: '_setMode',
	    value: function _setMode(mode) {
	      this._handler = handlerMap[mode];
	    }
	  }, {
	    key: '_exitCurrentMode',
	    value: function _exitCurrentMode() {
	      this.setMode('edit');
	    }
	
	    /**
	     * Used via `this.restoreEditorDOM()`.
	     *
	     * Force a complete re-render of the editor based on the current EditorState.
	     * This is useful when we know we are going to lose control of the DOM
	     * state (cut command, IME) and we want to make sure that reconciliation
	     * occurs on a version of the DOM that is synchronized with our EditorState.
	     */
	  }, {
	    key: '_restoreEditorDOM',
	    value: function _restoreEditorDOM(scrollPosition) {
	      var _this3 = this;
	
	      this.setState({ containerKey: this.state.containerKey + 1 }, function () {
	        _this3._focus(scrollPosition);
	      });
	    }
	
	    /**
	     * Guard against rendering. Intended for use when we need to manually
	     * reset editor contents, to ensure that no outside influences lead to
	     * React reconciliation when we are in an uncertain state.
	     */
	  }, {
	    key: '_setRenderGuard',
	    value: function _setRenderGuard() {
	      this._guardAgainstRender = true;
	    }
	  }, {
	    key: '_removeRenderGuard',
	    value: function _removeRenderGuard() {
	      this._guardAgainstRender = false;
	    }
	
	    /**
	     * Used via `this.setClipboard(...)`.
	     *
	     * Set the clipboard state for a cut/copy event.
	     */
	  }, {
	    key: '_setClipboard',
	    value: function _setClipboard(clipboard) {
	      this._clipboard = clipboard;
	    }
	
	    /**
	     * Used via `this.getClipboard()`.
	     *
	     * Retrieve the clipboard state for a cut/copy event.
	     */
	  }, {
	    key: '_getClipboard',
	    value: function _getClipboard() {
	      return this._clipboard;
	    }
	
	    /**
	     * Used via `this.update(...)`.
	     *
	     * Propagate a new `EditorState` object to higher-level components. This is
	     * the method by which event handlers inform the `DraftEditor` component of
	     * state changes. A component that composes a `DraftEditor` **must** provide
	     * an `onChange` prop to receive state updates passed along from this
	     * function.
	     */
	  }, {
	    key: '_update',
	    value: function _update(editorState) {
	      this.props.onChange(editorState);
	    }
	
	    /**
	     * Used in conjunction with `_onDragLeave()`, by counting the number of times
	     * a dragged element enters and leaves the editor (or any of its children),
	     * to determine when the dragged element absolutely leaves the editor.
	     */
	  }, {
	    key: '_onDragEnter',
	    value: function _onDragEnter() {
	      this._dragCount++;
	    }
	
	    /**
	     * See `_onDragEnter()`.
	     */
	  }, {
	    key: '_onDragLeave',
	    value: function _onDragLeave() {
	      this._dragCount--;
	      if (this._dragCount === 0) {
	        this.exitCurrentMode();
	      }
	    }
	  }]);
	
	  return DraftEditor;
	})(React.Component);
	
	module.exports = DraftEditor;
	
	/**
	 * Define proxies that can route events to the current handler.
	 */

/***/ },
/* 328 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorBlock.react
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var ContentBlock = __webpack_require__(323);
	var DraftEditorLeaf = __webpack_require__(398);
	var DraftOffsetKey = __webpack_require__(399);
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var Scroll = __webpack_require__(435);
	var SelectionState = __webpack_require__(335);
	var Style = __webpack_require__(436);
	var UnicodeBidi = __webpack_require__(437);
	var UnicodeBidiDirection = __webpack_require__(438);
	
	var cx = __webpack_require__(431);
	var getElementPosition = __webpack_require__(439);
	var getScrollPosition = __webpack_require__(440);
	var getViewportDimensions = __webpack_require__(441);
	var nullthrows = __webpack_require__(442);
	
	var SCROLL_BUFFER = 10;
	
	/**
	 * The default block renderer for a `DraftEditor` component.
	 *
	 * A `DraftEditorBlock` is able to render a given `ContentBlock` to its
	 * appropriate decorator and inline style components.
	 */
	
	var DraftEditorBlock = (function (_React$Component) {
	  _inherits(DraftEditorBlock, _React$Component);
	
	  function DraftEditorBlock() {
	    _classCallCheck(this, DraftEditorBlock);
	
	    _get(Object.getPrototypeOf(DraftEditorBlock.prototype), 'constructor', this).apply(this, arguments);
	  }
	
	  /**
	   * Return whether a block overlaps with either edge of the `SelectionState`.
	   */
	
	  _createClass(DraftEditorBlock, [{
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate(nextProps) {
	      return this.props.block !== nextProps.block || this.props.tree !== nextProps.tree || this.props.direction !== nextProps.direction || isBlockOnSelectionEdge(nextProps.selection, nextProps.block.getKey()) && nextProps.forceSelection;
	    }
	
	    /**
	     * When a block is mounted and overlaps the selection state, we need to make
	     * sure that the cursor is visible to match native behavior. This may not
	     * be the case if the user has pressed `RETURN` or pasted some content, since
	     * programatically creating these new blocks and setting the DOM selection
	     * will miss out on the browser natively scrolling to that position.
	     *
	     * To replicate native behavior, if the block overlaps the selection state
	     * on mount, force the scroll position. Check the scroll state of the scroll
	     * parent, and adjust it to align the entire block to the bottom of the
	     * scroll parent.
	     */
	  }, {
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      var selection = this.props.selection;
	      var endKey = selection.getEndKey();
	      if (!selection.getHasFocus() || endKey !== this.props.block.getKey()) {
	        return;
	      }
	
	      var blockNode = ReactDOM.findDOMNode(this);
	      var scrollParent = Style.getScrollParent(blockNode);
	      var scrollPosition = getScrollPosition(scrollParent);
	      var scrollDelta;
	
	      if (scrollParent === window) {
	        var nodePosition = getElementPosition(blockNode);
	        var nodeBottom = nodePosition.y + nodePosition.height;
	        var viewportHeight = getViewportDimensions().height;
	        scrollDelta = nodeBottom - viewportHeight;
	        if (scrollDelta > 0) {
	          window.scrollTo(scrollPosition.x, scrollPosition.y + scrollDelta + SCROLL_BUFFER);
	        }
	      } else {
	        var blockBottom = blockNode.offsetHeight + blockNode.offsetTop;
	        var scrollBottom = scrollParent.offsetHeight + scrollPosition.y;
	        scrollDelta = blockBottom - scrollBottom;
	        if (scrollDelta > 0) {
	          Scroll.setTop(scrollParent, Scroll.getTop(scrollParent) + scrollDelta + SCROLL_BUFFER);
	        }
	      }
	    }
	  }, {
	    key: '_renderChildren',
	    value: function _renderChildren() {
	      var _this = this;
	
	      var block = this.props.block;
	      var blockKey = block.getKey();
	      var text = block.getText();
	      var lastLeafSet = this.props.tree.size - 1;
	      var hasSelection = isBlockOnSelectionEdge(this.props.selection, blockKey);
	
	      return this.props.tree.map(function (leafSet, ii) {
	        var leavesForLeafSet = leafSet.get('leaves');
	        var lastLeaf = leavesForLeafSet.size - 1;
	        var leaves = leavesForLeafSet.map(function (leaf, jj) {
	          var offsetKey = DraftOffsetKey.encode(blockKey, ii, jj);
	          var start = leaf.get('start');
	          var end = leaf.get('end');
	          return React.createElement(DraftEditorLeaf, {
	            key: offsetKey,
	            offsetKey: offsetKey,
	            blockKey: blockKey,
	            start: start,
	            selection: hasSelection ? _this.props.selection : undefined,
	            forceSelection: _this.props.forceSelection,
	            text: text.slice(start, end),
	            styleSet: block.getInlineStyleAt(start),
	            customStyleMap: _this.props.customStyleMap,
	            isLast: ii === lastLeafSet && jj === lastLeaf
	          });
	        }).toArray();
	
	        var decoratorKey = leafSet.get('decoratorKey');
	        if (decoratorKey == null) {
	          return leaves;
	        }
	
	        if (!_this.props.decorator) {
	          return leaves;
	        }
	
	        var decorator = nullthrows(_this.props.decorator);
	
	        var DecoratorComponent = decorator.getComponentForKey(decoratorKey);
	        if (!DecoratorComponent) {
	          return leaves;
	        }
	
	        var decoratorProps = decorator.getPropsForKey(decoratorKey);
	        var decoratorOffsetKey = DraftOffsetKey.encode(blockKey, ii, 0);
	        var decoratedText = text.slice(leavesForLeafSet.first().get('start'), leavesForLeafSet.last().get('end'));
	
	        // Resetting dir to the same value on a child node makes Chrome/Firefox
	        // confused on cursor movement. See http://jsfiddle.net/d157kLck/3/
	        var dir = UnicodeBidiDirection.getHTMLDirIfDifferent(UnicodeBidi.getDirection(decoratedText), _this.props.direction);
	
	        return React.createElement(
	          DecoratorComponent,
	          _extends({}, decoratorProps, {
	            decoratedText: decoratedText,
	            dir: dir,
	            key: decoratorOffsetKey,
	            entityKey: block.getEntityAt(leafSet.get('start')),
	            offsetKey: decoratorOffsetKey }),
	          leaves
	        );
	      }).toArray();
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props = this.props;
	      var direction = _props.direction;
	      var offsetKey = _props.offsetKey;
	
	      var className = cx({
	        'public/DraftStyleDefault/block': true,
	        'public/DraftStyleDefault/ltr': direction === 'LTR',
	        'public/DraftStyleDefault/rtl': direction === 'RTL'
	      });
	
	      return React.createElement(
	        'div',
	        { 'data-offset-key': offsetKey, className: className },
	        this._renderChildren()
	      );
	    }
	  }]);
	
	  return DraftEditorBlock;
	})(React.Component);
	
	function isBlockOnSelectionEdge(selection, key) {
	  return selection.getAnchorKey() === key || selection.getFocusKey() === key;
	}
	
	module.exports = DraftEditorBlock;

/***/ },
/* 329 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftModifier
	 * @typechecks
	 * 
	 */
	
	/**
	 * `DraftModifier` provides a set of convenience methods that apply
	 * modifications to a `ContentState` object based on a target `SelectionState`.
	 *
	 * Any change to a `ContentState` should be decomposable into a series of
	 * transaction functions that apply the required changes and return output
	 * `ContentState` objects.
	 *
	 * These functions encapsulate some of the most common transaction sequences.
	 */
	'use strict';
	
	var CharacterMetadata = __webpack_require__(321);
	var ContentStateInlineStyle = __webpack_require__(377);
	
	var _require = __webpack_require__(346);
	
	var OrderedSet = _require.OrderedSet;
	
	var applyEntityToContentState = __webpack_require__(378);
	var getCharacterRemovalRange = __webpack_require__(379);
	var getContentStateFragment = __webpack_require__(380);
	var insertFragmentIntoContentState = __webpack_require__(381);
	var insertTextIntoContentState = __webpack_require__(382);
	var invariant = __webpack_require__(432);
	var removeEntitiesAtEdges = __webpack_require__(383);
	var removeRangeFromContentState = __webpack_require__(384);
	var setBlockTypeForContentState = __webpack_require__(385);
	var splitBlockInContentState = __webpack_require__(386);
	
	var DraftModifier = {
	  replaceText: function replaceText(contentState, rangeToReplace, text, inlineStyle, entityKey) {
	    var withoutEntities = removeEntitiesAtEdges(contentState, rangeToReplace);
	    var withoutText = removeRangeFromContentState(withoutEntities, rangeToReplace);
	
	    var character = CharacterMetadata.create({
	      style: inlineStyle || OrderedSet(),
	      entity: entityKey || null
	    });
	
	    return insertTextIntoContentState(withoutText, withoutText.getSelectionAfter(), text, character);
	  },
	
	  insertText: function insertText(contentState, targetRange, text, inlineStyle, entityKey) {
	    !targetRange.isCollapsed() ? true ? invariant(false, 'Target range must be collapsed for `insertText`.') : invariant(false) : undefined;
	    return DraftModifier.replaceText(contentState, targetRange, text, inlineStyle, entityKey);
	  },
	
	  moveText: function moveText(contentState, removalRange, targetRange) {
	    var movedFragment = getContentStateFragment(contentState, removalRange);
	
	    var afterRemoval = DraftModifier.removeRange(contentState, removalRange, 'backward');
	
	    return DraftModifier.replaceWithFragment(afterRemoval, targetRange, movedFragment);
	  },
	
	  replaceWithFragment: function replaceWithFragment(contentState, targetRange, fragment) {
	    var withoutEntities = removeEntitiesAtEdges(contentState, targetRange);
	    var withoutText = removeRangeFromContentState(withoutEntities, targetRange);
	
	    return insertFragmentIntoContentState(withoutText, withoutText.getSelectionAfter(), fragment);
	  },
	
	  removeRange: function removeRange(contentState, rangeToRemove, removalDirection) {
	    // Check whether the selection state overlaps with a single entity.
	    // If so, try to remove the appropriate substring of the entity text.
	    if (rangeToRemove.getAnchorKey() === rangeToRemove.getFocusKey()) {
	      var key = rangeToRemove.getAnchorKey();
	      var startOffset = rangeToRemove.getStartOffset();
	      var endOffset = rangeToRemove.getEndOffset();
	      var block = contentState.getBlockForKey(key);
	
	      var startEntity = block.getEntityAt(startOffset);
	      var endEntity = block.getEntityAt(endOffset - 1);
	      if (startEntity && startEntity === endEntity) {
	        var adjustedRemovalRange = getCharacterRemovalRange(block, rangeToRemove, removalDirection);
	        return removeRangeFromContentState(contentState, adjustedRemovalRange);
	      }
	    }
	
	    var withoutEntities = removeEntitiesAtEdges(contentState, rangeToRemove);
	    return removeRangeFromContentState(withoutEntities, rangeToRemove);
	  },
	
	  splitBlock: function splitBlock(contentState, selectionState) {
	    var withoutEntities = removeEntitiesAtEdges(contentState, selectionState);
	    var withoutText = removeRangeFromContentState(withoutEntities, selectionState);
	
	    return splitBlockInContentState(withoutText, withoutText.getSelectionAfter());
	  },
	
	  applyInlineStyle: function applyInlineStyle(contentState, selectionState, inlineStyle) {
	    return ContentStateInlineStyle.add(contentState, selectionState, inlineStyle);
	  },
	
	  removeInlineStyle: function removeInlineStyle(contentState, selectionState, inlineStyle) {
	    return ContentStateInlineStyle.remove(contentState, selectionState, inlineStyle);
	  },
	
	  setBlockType: function setBlockType(contentState, selectionState, blockType) {
	    return setBlockTypeForContentState(contentState, selectionState, blockType);
	  },
	
	  applyEntity: function applyEntity(contentState, selectionState, entityKey) {
	    var withoutEntities = removeEntitiesAtEdges(contentState, selectionState);
	    return applyEntityToContentState(withoutEntities, selectionState, entityKey);
	  }
	};
	
	module.exports = DraftModifier;

/***/ },
/* 330 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEntity
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var DraftEntityInstance = __webpack_require__(331);
	var Immutable = __webpack_require__(346);
	
	var invariant = __webpack_require__(432);
	
	var Map = Immutable.Map;
	
	var instances = Map();
	var instanceKey = 0;
	
	/**
	 * A "document entity" is an object containing metadata associated with a
	 * piece of text in a ContentBlock.
	 *
	 * For example, a `link` entity might include a `uri` property. When a
	 * ContentBlock is rendered in the browser, text that refers to that link
	 * entity may be rendered as an anchor, with the `uri` as the href value.
	 *
	 * In a ContentBlock, every position in the text may correspond to zero
	 * or one entities. This correspondence is tracked using a key string,
	 * generated via DraftEntity.create() and used to obtain entity metadata
	 * via DraftEntity.get().
	 */
	var DraftEntity = {
	  /**
	   * Create a DraftEntityInstance and store it for later retrieval.
	   *
	   * A random key string will be generated and returned. This key may
	   * be used to track the entity's usage in a ContentBlock, and for
	   * retrieving data about the entity at render time.
	   */
	  create: function create(type, mutability, data) {
	    return DraftEntity.add(new DraftEntityInstance({ type: type, mutability: mutability, data: data || {} }));
	  },
	
	  /**
	   * Add an existing DraftEntityInstance to the DraftEntity map. This is
	   * useful when restoring instances from the server.
	   */
	  add: function add(instance) {
	    var key = '' + ++instanceKey;
	    instances = instances.set(key, instance);
	    return key;
	  },
	
	  /**
	   * Retrieve the entity corresponding to the supplied key string.
	   */
	  get: function get(key) {
	    var instance = instances.get(key);
	    !!!instance ? true ? invariant(false, 'Unknown DraftEntity key.') : invariant(false) : undefined;
	    return instance;
	  },
	
	  /**
	   * Entity instances are immutable. If you need to update the data for an
	   * instance, this method will merge your data updates and return a new
	   * instance.
	   */
	  mergeData: function mergeData(key, toMerge) {
	    var instance = DraftEntity.get(key);
	    var newData = _extends({}, instance.getData(), toMerge);
	    var newInstance = instance.set('data', newData);
	    instances = instances.set(key, newInstance);
	    return newInstance;
	  },
	
	  /**
	   * Completely replace the data for a given instance.
	   */
	  replaceData: function replaceData(key, newData) {
	    var instance = DraftEntity.get(key);
	    var newInstance = instance.set('data', newData);
	    instances = instances.set(key, newInstance);
	    return newInstance;
	  }
	};
	
	module.exports = DraftEntity;

/***/ },
/* 331 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEntityInstance
	 * 
	 */
	
	'use strict';
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var Immutable = __webpack_require__(346);
	
	var Record = Immutable.Record;
	
	var DraftEntityInstanceRecord = Record({
	  type: 'TOKEN',
	  mutability: 'IMMUTABLE',
	  data: Object
	});
	
	/**
	 * An instance of a document entity, consisting of a `type` and relevant
	 * `data`, metadata about the entity.
	 *
	 * For instance, a "link" entity might provide a URI, and a "mention"
	 * entity might provide the mentioned user's ID. These pieces of data
	 * may be used when rendering the entity as part of a ContentBlock DOM
	 * representation. For a link, the data would be used as an href for
	 * the rendered anchor. For a mention, the ID could be used to retrieve
	 * a hovercard.
	 */
	
	var DraftEntityInstance = (function (_DraftEntityInstanceRecord) {
	  _inherits(DraftEntityInstance, _DraftEntityInstanceRecord);
	
	  function DraftEntityInstance() {
	    _classCallCheck(this, DraftEntityInstance);
	
	    _get(Object.getPrototypeOf(DraftEntityInstance.prototype), 'constructor', this).apply(this, arguments);
	  }
	
	  _createClass(DraftEntityInstance, [{
	    key: 'getType',
	    value: function getType() {
	      return this.get('type');
	    }
	  }, {
	    key: 'getMutability',
	    value: function getMutability() {
	      return this.get('mutability');
	    }
	  }, {
	    key: 'getData',
	    value: function getData() {
	      return this.get('data');
	    }
	  }]);
	
	  return DraftEntityInstance;
	})(DraftEntityInstanceRecord);
	
	module.exports = DraftEntityInstance;

/***/ },
/* 332 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule EditorState
	 * 
	 */
	
	'use strict';
	
	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	var BlockTree = __webpack_require__(412);
	var ContentState = __webpack_require__(324);
	var EditorBidiService = __webpack_require__(413);
	var Immutable = __webpack_require__(346);
	var SelectionState = __webpack_require__(335);
	
	var OrderedSet = Immutable.OrderedSet;
	var Record = Immutable.Record;
	var Stack = Immutable.Stack;
	
	var defaultRecord = {
	  allowUndo: true,
	  currentContent: null,
	  decorator: null,
	  directionMap: null,
	  forceSelection: false,
	  inCompositionMode: false,
	  inlineStyleOverride: null,
	  lastChangeType: null,
	  nativelyRenderedContent: null,
	  redoStack: Stack(),
	  selection: null,
	  treeMap: null,
	  undoStack: Stack()
	};
	
	var EditorStateRecord = Record(defaultRecord);
	
	var EditorState = (function () {
	  _createClass(EditorState, [{
	    key: 'toJS',
	    value: function toJS() {
	      return this.getImmutable().toJS();
	    }
	  }, {
	    key: 'getAllowUndo',
	    value: function getAllowUndo() {
	      return this.getImmutable().get('allowUndo');
	    }
	  }, {
	    key: 'getCurrentContent',
	    value: function getCurrentContent() {
	      return this.getImmutable().get('currentContent');
	    }
	  }, {
	    key: 'getUndoStack',
	    value: function getUndoStack() {
	      return this.getImmutable().get('undoStack');
	    }
	  }, {
	    key: 'getRedoStack',
	    value: function getRedoStack() {
	      return this.getImmutable().get('redoStack');
	    }
	  }, {
	    key: 'getSelection',
	    value: function getSelection() {
	      return this.getImmutable().get('selection');
	    }
	  }, {
	    key: 'getDecorator',
	    value: function getDecorator() {
	      return this.getImmutable().get('decorator');
	    }
	  }, {
	    key: 'isInCompositionMode',
	    value: function isInCompositionMode() {
	      return this.getImmutable().get('inCompositionMode');
	    }
	  }, {
	    key: 'mustForceSelection',
	    value: function mustForceSelection() {
	      return this.getImmutable().get('forceSelection');
	    }
	  }, {
	    key: 'getNativelyRenderedContent',
	    value: function getNativelyRenderedContent() {
	      return this.getImmutable().get('nativelyRenderedContent');
	    }
	  }, {
	    key: 'getLastChangeType',
	    value: function getLastChangeType() {
	      return this.getImmutable().get('lastChangeType');
	    }
	
	    /**
	     * While editing, the user may apply inline style commands with a collapsed
	     * cursor, intending to type text that adopts the specified style. In this
	     * case, we track the specified style as an "override" that takes precedence
	     * over the inline style of the text adjacent to the cursor.
	     *
	     * If null, there is no override in place.
	     */
	  }, {
	    key: 'getInlineStyleOverride',
	    value: function getInlineStyleOverride() {
	      return this.getImmutable().get('inlineStyleOverride');
	    }
	  }, {
	    key: 'getCurrentInlineStyle',
	
	    /**
	     * Get the appropriate inline style for the editor state. If an
	     * override is in place, use it. Otherwise, the current style is
	     * based on the location of the selection state.
	     */
	    value: function getCurrentInlineStyle() {
	      var override = this.getInlineStyleOverride();
	      if (override != null) {
	        return override;
	      }
	
	      var content = this.getCurrentContent();
	      var selection = this.getSelection();
	
	      if (selection.isCollapsed()) {
	        return getInlineStyleForCollapsedSelection(content, selection);
	      }
	
	      return getInlineStyleForNonCollapsedSelection(content, selection);
	    }
	  }, {
	    key: 'getBlockTree',
	    value: function getBlockTree(blockKey) {
	      return this.getImmutable().getIn(['treeMap', blockKey]);
	    }
	  }, {
	    key: 'isSelectionAtStartOfContent',
	    value: function isSelectionAtStartOfContent() {
	      var firstKey = this.getCurrentContent().getBlockMap().first().getKey();
	      return this.getSelection().hasEdgeWithin(firstKey, 0, 0);
	    }
	  }, {
	    key: 'isSelectionAtEndOfContent',
	    value: function isSelectionAtEndOfContent() {
	      var content = this.getCurrentContent();
	      var blockMap = content.getBlockMap();
	      var last = blockMap.last();
	      var end = last.getLength();
	      return this.getSelection().hasEdgeWithin(last.getKey(), end, end);
	    }
	  }, {
	    key: 'getDirectionMap',
	    value: function getDirectionMap() {
	      return this.getImmutable().get('directionMap');
	    }
	
	    /**
	     * Incorporate native DOM selection changes into the EditorState. This
	     * method can be used when we simply want to accept whatever the DOM
	     * has given us to represent selection, and we do not need to re-render
	     * the editor.
	     *
	     * To forcibly move the DOM selection, see `EditorState.forceSelection`.
	     */
	  }], [{
	    key: 'createEmpty',
	    value: function createEmpty(decorator) {
	      return EditorState.createWithContent(ContentState.createFromText(''), decorator);
	    }
	  }, {
	    key: 'createWithContent',
	    value: function createWithContent(contentState, decorator) {
	      var firstKey = contentState.getBlockMap().first().getKey();
	      return EditorState.create({
	        currentContent: contentState,
	        undoStack: Stack(),
	        redoStack: Stack(),
	        decorator: decorator || null,
	        selection: SelectionState.createEmpty(firstKey)
	      });
	    }
	  }, {
	    key: 'create',
	    value: function create(config) {
	      var currentContent = config.currentContent;
	      var decorator = config.decorator;
	
	      var recordConfig = _extends({}, config, {
	        treeMap: generateNewTreeMap(currentContent, decorator),
	        directionMap: EditorBidiService.getDirectionMap(currentContent)
	      });
	      return new EditorState(new EditorStateRecord(recordConfig));
	    }
	  }, {
	    key: 'set',
	    value: function set(editorState, put) {
	      var map = editorState.getImmutable().withMutations(function (state) {
	        var existingDecorator = state.get('decorator');
	        var decorator = existingDecorator;
	        if (put.decorator === null) {
	          decorator = null;
	        } else if (put.decorator) {
	          decorator = put.decorator;
	        }
	
	        var newContent = put.currentContent || editorState.getCurrentContent();
	
	        if (decorator !== existingDecorator) {
	          var treeMap = state.get('treeMap');
	          var newTreeMap;
	          if (decorator && existingDecorator) {
	            newTreeMap = regenerateTreeForNewDecorator(newContent.getBlockMap(), treeMap, decorator, existingDecorator);
	          } else {
	            newTreeMap = generateNewTreeMap(newContent, decorator);
	          }
	
	          state.merge({
	            decorator: decorator,
	            treeMap: newTreeMap,
	            nativelyRenderedContent: null
	          });
	          return;
	        }
	
	        var existingContent = editorState.getCurrentContent();
	        if (newContent !== existingContent) {
	          state.set('treeMap', regenerateTreeForNewBlocks(editorState, newContent.getBlockMap(), decorator));
	        }
	
	        state.merge(put);
	      });
	
	      return new EditorState(map);
	    }
	  }, {
	    key: 'setInlineStyleOverride',
	    value: function setInlineStyleOverride(editorState, inlineStyleOverride) {
	      return EditorState.set(editorState, { inlineStyleOverride: inlineStyleOverride });
	    }
	  }, {
	    key: 'acceptSelection',
	    value: function acceptSelection(editorState, selection) {
	      return updateSelection(editorState, selection, false);
	    }
	
	    /**
	     * At times, we need to force the DOM selection to be where we
	     * need it to be. This can occur when the anchor or focus nodes
	     * are non-text nodes, for instance. In this case, we want to trigger
	     * a re-render of the editor, which in turn forces selection into
	     * the correct place in the DOM. The `forceSelection` method
	     * accomplishes this.
	     *
	     * This method should be used in cases where you need to explicitly
	     * move the DOM selection from one place to another without a change
	     * in ContentState.
	     */
	  }, {
	    key: 'forceSelection',
	    value: function forceSelection(editorState, selection) {
	      if (!selection.getHasFocus()) {
	        selection = selection.set('hasFocus', true);
	      }
	      return updateSelection(editorState, selection, true);
	    }
	
	    /**
	     * Move selection to the end of the editor without forcing focus.
	     */
	  }, {
	    key: 'moveSelectionToEnd',
	    value: function moveSelectionToEnd(editorState) {
	      var content = editorState.getCurrentContent();
	      var lastBlock = content.getLastBlock();
	      var lastKey = lastBlock.getKey();
	      var length = lastBlock.getLength();
	
	      return EditorState.acceptSelection(editorState, new SelectionState({
	        anchorKey: lastKey,
	        anchorOffset: length,
	        focusKey: lastKey,
	        focusOffset: length,
	        isBackward: false
	      }));
	    }
	
	    /**
	     * Force focus to the end of the editor. This is useful in scenarios
	     * where we want to programmatically focus the input and it makes sense
	     * to allow the user to continue working seamlessly.
	     */
	  }, {
	    key: 'moveFocusToEnd',
	    value: function moveFocusToEnd(editorState) {
	      var afterSelectionMove = EditorState.moveSelectionToEnd(editorState);
	      return EditorState.forceSelection(afterSelectionMove, afterSelectionMove.getSelection());
	    }
	
	    /**
	     * Push the current ContentState onto the undo stack if it should be
	     * considered a boundary state, and set the provided ContentState as the
	     * new current content.
	     */
	  }, {
	    key: 'push',
	    value: function push(editorState, contentState, changeType) {
	      if (editorState.getCurrentContent() === contentState) {
	        return editorState;
	      }
	
	      var forceSelection = changeType !== 'insert-characters';
	      var directionMap = EditorBidiService.getDirectionMap(contentState, editorState.getDirectionMap());
	
	      if (!editorState.getAllowUndo()) {
	        return EditorState.set(editorState, {
	          currentContent: contentState,
	          directionMap: directionMap,
	          lastChangeType: changeType,
	          selection: contentState.getSelectionAfter(),
	          forceSelection: forceSelection,
	          inlineStyleOverride: null
	        });
	      }
	
	      var selection = editorState.getSelection();
	      var currentContent = editorState.getCurrentContent();
	      var undoStack = editorState.getUndoStack();
	      var newContent = contentState;
	
	      if (selection !== currentContent.getSelectionAfter() || mustBecomeBoundary(editorState, changeType)) {
	        undoStack = undoStack.push(currentContent);
	        newContent = newContent.set('selectionBefore', selection);
	      } else if (changeType === 'insert-characters' || changeType === 'backspace-character' || changeType === 'delete-character') {
	        // Preserve the previous selection.
	        newContent = newContent.set('selectionBefore', currentContent.getSelectionBefore());
	      }
	
	      var inlineStyleOverride = editorState.getInlineStyleOverride();
	
	      // Don't discard inline style overrides on block type or depth changes.
	      if (changeType !== 'adjust-depth' && changeType !== 'change-block-type') {
	        inlineStyleOverride = null;
	      }
	
	      var editorStateChanges = {
	        currentContent: newContent,
	        directionMap: directionMap,
	        undoStack: undoStack,
	        redoStack: Stack(),
	        lastChangeType: changeType,
	        selection: contentState.getSelectionAfter(),
	        forceSelection: forceSelection,
	        inlineStyleOverride: inlineStyleOverride
	      };
	
	      return EditorState.set(editorState, editorStateChanges);
	    }
	
	    /**
	     * Make the top ContentState in the undo stack the new current content and
	     * push the current content onto the redo stack.
	     */
	  }, {
	    key: 'undo',
	    value: function undo(editorState) {
	      if (!editorState.getAllowUndo()) {
	        return editorState;
	      }
	
	      var undoStack = editorState.getUndoStack();
	      var newCurrentContent = undoStack.peek();
	      if (!newCurrentContent) {
	        return editorState;
	      }
	
	      var currentContent = editorState.getCurrentContent();
	      var directionMap = EditorBidiService.getDirectionMap(newCurrentContent, editorState.getDirectionMap());
	
	      return EditorState.set(editorState, {
	        currentContent: newCurrentContent,
	        directionMap: directionMap,
	        undoStack: undoStack.shift(),
	        redoStack: editorState.getRedoStack().push(currentContent),
	        forceSelection: true,
	        inlineStyleOverride: null,
	        lastChangeType: 'undo',
	        nativelyRenderedContent: null,
	        selection: currentContent.getSelectionBefore()
	      });
	    }
	
	    /**
	     * Make the top ContentState in the redo stack the new current content and
	     * push the current content onto the undo stack.
	     */
	  }, {
	    key: 'redo',
	    value: function redo(editorState) {
	      if (!editorState.getAllowUndo()) {
	        return editorState;
	      }
	
	      var redoStack = editorState.getRedoStack();
	      var newCurrentContent = redoStack.peek();
	      if (!newCurrentContent) {
	        return editorState;
	      }
	
	      var currentContent = editorState.getCurrentContent();
	      var directionMap = EditorBidiService.getDirectionMap(newCurrentContent, editorState.getDirectionMap());
	
	      return EditorState.set(editorState, {
	        currentContent: newCurrentContent,
	        directionMap: directionMap,
	        undoStack: editorState.getUndoStack().push(currentContent),
	        redoStack: redoStack.shift(),
	        forceSelection: true,
	        inlineStyleOverride: null,
	        lastChangeType: 'redo',
	        nativelyRenderedContent: null,
	        selection: newCurrentContent.getSelectionAfter()
	      });
	    }
	
	    /**
	     * Not for public consumption.
	     */
	  }]);
	
	  function EditorState(immutable) {
	    _classCallCheck(this, EditorState);
	
	    this._immutable = immutable;
	  }
	
	  /**
	   * Set the supplied SelectionState as the new current selection, and set
	   * the `force` flag to trigger manual selection placement by the view.
	   */
	
	  /**
	   * Not for public consumption.
	   */
	
	  _createClass(EditorState, [{
	    key: 'getImmutable',
	    value: function getImmutable() {
	      return this._immutable;
	    }
	  }]);
	
	  return EditorState;
	})();
	
	function updateSelection(editorState, selection, forceSelection) {
	  return EditorState.set(editorState, {
	    selection: selection,
	    forceSelection: forceSelection,
	    nativelyRenderedContent: null,
	    inlineStyleOverride: null
	  });
	}
	
	/**
	 * Regenerate the entire tree map for a given ContentState and decorator.
	 * Returns an OrderedMap that maps all available ContentBlock objects.
	 */
	function generateNewTreeMap(contentState, decorator) {
	  return contentState.getBlockMap().map(function (block) {
	    return BlockTree.generate(block, decorator);
	  }).toOrderedMap();
	}
	
	/**
	 * Regenerate tree map objects for all ContentBlocks that have changed
	 * between the current editorState and newContent. Returns an OrderedMap
	 * with only changed regenerated tree map objects.
	 */
	function regenerateTreeForNewBlocks(editorState, newBlockMap, decorator) {
	  var prevBlockMap = editorState.getCurrentContent().getBlockMap();
	  var prevTreeMap = editorState.getImmutable().get('treeMap');
	  return prevTreeMap.merge(newBlockMap.toSeq().filter(function (block, key) {
	    return block !== prevBlockMap.get(key);
	  }).map(function (block) {
	    return BlockTree.generate(block, decorator);
	  }));
	}
	
	/**
	 * Generate tree map objects for a new decorator object, preserving any
	 * decorations that are unchanged from the previous decorator.
	 *
	 * Note that in order for this to perform optimally, decoration Lists for
	 * decorators should be preserved when possible to allow for direct immutable
	 * List comparison.
	 */
	function regenerateTreeForNewDecorator(blockMap, previousTreeMap, decorator, existingDecorator) {
	  return previousTreeMap.merge(blockMap.toSeq().filter(function (block) {
	    return decorator.getDecorations(block) !== existingDecorator.getDecorations(block);
	  }).map(function (block) {
	    return BlockTree.generate(block, decorator);
	  }));
	}
	
	/**
	 * Return whether a change should be considered a boundary state, given
	 * the previous change type. Allows us to discard potential boundary states
	 * during standard typing or deletion behavior.
	 */
	function mustBecomeBoundary(editorState, changeType) {
	  var lastChangeType = editorState.getLastChangeType();
	  return changeType !== lastChangeType || changeType !== 'insert-characters' && changeType !== 'backspace-character' && changeType !== 'delete-character';
	}
	
	function getInlineStyleForCollapsedSelection(content, selection) {
	  var startKey = selection.getStartKey();
	  var startOffset = selection.getStartOffset();
	  var startBlock = content.getBlockForKey(startKey);
	
	  // If the cursor is not at the start of the block, look backward to
	  // preserve the style of the preceding character.
	  if (startOffset > 0) {
	    return startBlock.getInlineStyleAt(startOffset - 1);
	  }
	
	  // The caret is at position zero in this block. If the block has any
	  // text at all, use the style of the first character.
	  if (startBlock.getLength()) {
	    return startBlock.getInlineStyleAt(0);
	  }
	
	  // Otherwise, look upward in the document to find the closest character.
	  return lookUpwardForInlineStyle(content, startKey);
	}
	
	function getInlineStyleForNonCollapsedSelection(content, selection) {
	  var startKey = selection.getStartKey();
	  var startOffset = selection.getStartOffset();
	  var startBlock = content.getBlockForKey(startKey);
	
	  // If there is a character just inside the selection, use its style.
	  if (startOffset < startBlock.getLength()) {
	    return startBlock.getInlineStyleAt(startOffset);
	  }
	
	  // Check if the selection at the end of a non-empty block. Use the last
	  // style in the block.
	  if (startOffset > 0) {
	    return startBlock.getInlineStyleAt(startOffset - 1);
	  }
	
	  // Otherwise, look upward in the document to find the closest character.
	  return lookUpwardForInlineStyle(content, startKey);
	}
	
	function lookUpwardForInlineStyle(content, fromKey) {
	  var previousBlock = content.getBlockBefore(fromKey);
	  var previousLength;
	
	  while (previousBlock) {
	    previousLength = previousBlock.getLength();
	    if (previousLength) {
	      return previousBlock.getInlineStyleAt(previousLength - 1);
	    }
	    previousBlock = content.getBlockBefore(previousBlock.getKey());
	  }
	
	  return OrderedSet();
	}
	
	module.exports = EditorState;

/***/ },
/* 333 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule KeyBindingUtil
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var UserAgent = __webpack_require__(433);
	
	var isOSX = UserAgent.isPlatform('Mac OS X');
	
	var KeyBindingUtil = {
	  /**
	   * Check whether the ctrlKey modifier is *not* being used in conjunction with
	   * the altKey modifier. If they are combined, the result is an `altGraph`
	   * key modifier, which should not be handled by this set of key bindings.
	   */
	  isCtrlKeyCommand: function isCtrlKeyCommand(e) {
	    return !!e.ctrlKey && !e.altKey;
	  },
	
	  isOptionKeyCommand: function isOptionKeyCommand(e) {
	    return isOSX && e.altKey;
	  },
	
	  hasCommandModifier: function hasCommandModifier(e) {
	    return isOSX ? !!e.metaKey && !e.altKey : KeyBindingUtil.isCtrlKeyCommand(e);
	  }
	};
	
	module.exports = KeyBindingUtil;

/***/ },
/* 334 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule RichTextEditorUtil
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var DraftEntity = __webpack_require__(330);
	var DraftModifier = __webpack_require__(329);
	var EditorState = __webpack_require__(332);
	var SelectionState = __webpack_require__(335);
	
	var adjustBlockDepthForContentState = __webpack_require__(400);
	var nullthrows = __webpack_require__(442);
	
	var RichTextEditorUtil = {
	  currentBlockContainsLink: function currentBlockContainsLink(editorState) {
	    var selection = editorState.getSelection();
	    return editorState.getCurrentContent().getBlockForKey(selection.getAnchorKey()).getCharacterList().slice(selection.getStartOffset(), selection.getEndOffset()).some(function (v) {
	      var entity = v.getEntity();
	      return !!entity && DraftEntity.get(entity).getType() === 'LINK';
	    });
	  },
	
	  getCurrentBlockType: function getCurrentBlockType(editorState) {
	    var selection = editorState.getSelection();
	    return editorState.getCurrentContent().getBlockForKey(selection.getStartKey()).getType();
	  },
	
	  getDataObjectForLinkURL: function getDataObjectForLinkURL(uri) {
	    return { url: uri.toString() };
	  },
	
	  handleKeyCommand: function handleKeyCommand(editorState, command) {
	    switch (command) {
	      case 'bold':
	        return RichTextEditorUtil.toggleInlineStyle(editorState, 'BOLD');
	      case 'italic':
	        return RichTextEditorUtil.toggleInlineStyle(editorState, 'ITALIC');
	      case 'underline':
	        return RichTextEditorUtil.toggleInlineStyle(editorState, 'UNDERLINE');
	      case 'code':
	        return RichTextEditorUtil.toggleCode(editorState);
	      case 'backspace':
	      case 'backspace-word':
	      case 'backspace-to-start-of-line':
	        return RichTextEditorUtil.onBackspace(editorState);
	      case 'delete':
	      case 'delete-word':
	      case 'delete-to-end-of-block':
	        return RichTextEditorUtil.onDelete(editorState);
	      default:
	        return null;
	    }
	  },
	
	  insertSoftNewline: function insertSoftNewline(editorState) {
	    var contentState = DraftModifier.insertText(editorState.getCurrentContent(), editorState.getSelection(), '\n', editorState.getCurrentInlineStyle(), null);
	
	    var newEditorState = EditorState.push(editorState, contentState, 'insert-characters');
	
	    return EditorState.forceSelection(newEditorState, contentState.getSelectionAfter());
	  },
	
	  /**
	   * For collapsed selections at the start of styled blocks, backspace should
	   * just remove the existing style.
	   */
	  onBackspace: function onBackspace(editorState) {
	    var selection = editorState.getSelection();
	    if (!selection.isCollapsed() || selection.getAnchorOffset() || selection.getFocusOffset()) {
	      return null;
	    }
	
	    // First, try to remove a preceding atomic block.
	    var content = editorState.getCurrentContent();
	    var startKey = selection.getStartKey();
	    var blockBefore = content.getBlockBefore(startKey);
	
	    if (blockBefore && blockBefore.getType() === 'atomic') {
	      var atomicBlockTarget = selection.merge({
	        anchorKey: blockBefore.getKey(),
	        anchorOffset: 0
	      });
	      var asCurrentStyle = DraftModifier.setBlockType(content, atomicBlockTarget, content.getBlockForKey(startKey).getType());
	      var withoutAtomicBlock = DraftModifier.removeRange(asCurrentStyle, atomicBlockTarget, 'backward');
	      if (withoutAtomicBlock !== content) {
	        return EditorState.push(editorState, withoutAtomicBlock, 'remove-range');
	      }
	    }
	
	    // If that doesn't succeed, try to remove the current block style.
	    var withoutBlockStyle = RichTextEditorUtil.tryToRemoveBlockStyle(editorState);
	
	    if (withoutBlockStyle) {
	      return EditorState.push(editorState, withoutBlockStyle, 'change-block-type');
	    }
	
	    return null;
	  },
	
	  onDelete: function onDelete(editorState) {
	    var selection = editorState.getSelection();
	    if (!selection.isCollapsed()) {
	      return null;
	    }
	
	    var content = editorState.getCurrentContent();
	    var startKey = selection.getStartKey();
	    var block = content.getBlockForKey(startKey);
	    var length = block.getLength();
	
	    // The cursor is somewhere within the text. Behave normally.
	    if (selection.getStartOffset() < length) {
	      return null;
	    }
	
	    var blockAfter = content.getBlockAfter(startKey);
	
	    if (!blockAfter || blockAfter.getType() !== 'atomic') {
	      return null;
	    }
	
	    var atomicBlockTarget = selection.merge({
	      focusKey: blockAfter.getKey(),
	      focusOffset: blockAfter.getLength()
	    });
	
	    var withoutAtomicBlock = DraftModifier.removeRange(content, atomicBlockTarget, 'forward');
	
	    if (withoutAtomicBlock !== content) {
	      return EditorState.push(editorState, withoutAtomicBlock, 'remove-range');
	    }
	
	    return null;
	  },
	
	  onTab: function onTab(event, editorState, maxDepth) {
	    var selection = editorState.getSelection();
	    var key = selection.getAnchorKey();
	    if (key !== selection.getFocusKey()) {
	      return editorState;
	    }
	
	    var content = editorState.getCurrentContent();
	    var block = content.getBlockForKey(key);
	    var type = block.getType();
	    if (type !== 'unordered-list-item' && type !== 'ordered-list-item') {
	      return editorState;
	    }
	
	    event.preventDefault();
	
	    // Only allow indenting one level beyond the block above, and only if
	    // the block above is a list item as well.
	    var blockAbove = content.getBlockBefore(key);
	    if (!blockAbove) {
	      return editorState;
	    }
	
	    var typeAbove = blockAbove.getType();
	    if (typeAbove !== 'unordered-list-item' && typeAbove !== 'ordered-list-item') {
	      return editorState;
	    }
	
	    var depth = block.getDepth();
	    if (!event.shiftKey && depth === maxDepth) {
	      return editorState;
	    }
	
	    maxDepth = Math.min(blockAbove.getDepth() + 1, maxDepth);
	
	    var withAdjustment = adjustBlockDepthForContentState(content, selection, event.shiftKey ? -1 : 1, maxDepth);
	
	    return EditorState.push(editorState, withAdjustment, 'adjust-depth');
	  },
	
	  toggleBlockType: function toggleBlockType(editorState, blockType) {
	    var selection = editorState.getSelection();
	    var startKey = selection.getStartKey();
	    var endKey = selection.getEndKey();
	    var content = editorState.getCurrentContent();
	    var target = selection;
	
	    // Triple-click can lead to a selection that includes offset 0 of the
	    // following block. The `SelectionState` for this case is accurate, but
	    // we should avoid toggling block type for the trailing block because it
	    // is a confusing interaction.
	    if (startKey !== endKey && selection.getEndOffset() === 0) {
	      var blockBefore = nullthrows(content.getBlockBefore(endKey));
	      endKey = blockBefore.getKey();
	      target = target.merge({
	        anchorKey: startKey,
	        anchorOffset: selection.getStartOffset(),
	        focusKey: endKey,
	        focusOffset: blockBefore.getLength(),
	        isBackward: false
	      });
	    }
	
	    var hasAtomicBlock = content.getBlockMap().skipWhile(function (_, k) {
	      return k !== startKey;
	    }).takeWhile(function (_, k) {
	      return k !== endKey;
	    }).some(function (v) {
	      return v.getType() === 'atomic';
	    });
	
	    if (hasAtomicBlock) {
	      return editorState;
	    }
	
	    var typeToSet = content.getBlockForKey(startKey).getType() === blockType ? 'unstyled' : blockType;
	
	    return EditorState.push(editorState, DraftModifier.setBlockType(content, target, typeToSet), 'change-block-type');
	  },
	
	  toggleCode: function toggleCode(editorState) {
	    var selection = editorState.getSelection();
	    var anchorKey = selection.getAnchorKey();
	    var focusKey = selection.getFocusKey();
	
	    if (selection.isCollapsed() || anchorKey !== focusKey) {
	      return RichTextEditorUtil.toggleBlockType(editorState, 'code-block');
	    }
	
	    return RichTextEditorUtil.toggleInlineStyle(editorState, 'CODE');
	  },
	
	  /**
	   * Toggle the specified inline style for the selection. If the
	   * user's selection is collapsed, apply or remove the style for the
	   * internal state. If it is not collapsed, apply the change directly
	   * to the document state.
	   */
	  toggleInlineStyle: function toggleInlineStyle(editorState, inlineStyle) {
	    var selection = editorState.getSelection();
	    var currentStyle = editorState.getCurrentInlineStyle();
	
	    // If the selection is collapsed, toggle the specified style on or off and
	    // set the result as the new inline style override. This will then be
	    // used as the inline style for the next character to be inserted.
	    if (selection.isCollapsed()) {
	      return EditorState.setInlineStyleOverride(editorState, currentStyle.has(inlineStyle) ? currentStyle.remove(inlineStyle) : currentStyle.add(inlineStyle));
	    }
	
	    // If characters are selected, immediately apply or remove the
	    // inline style on the document state itself.
	    var content = editorState.getCurrentContent();
	    var newContent;
	
	    // If the style is already present for the selection range, remove it.
	    // Otherwise, apply it.
	    if (currentStyle.has(inlineStyle)) {
	      newContent = DraftModifier.removeInlineStyle(content, selection, inlineStyle);
	    } else {
	      newContent = DraftModifier.applyInlineStyle(content, selection, inlineStyle);
	    }
	
	    return EditorState.push(editorState, newContent, 'change-inline-style');
	  },
	
	  toggleLink: function toggleLink(editorState, targetSelection, entityKey) {
	    var withoutLink = DraftModifier.applyEntity(editorState.getCurrentContent(), targetSelection, entityKey);
	
	    return EditorState.push(editorState, withoutLink, 'apply-entity');
	  },
	
	  /**
	   * When a collapsed cursor is at the start of an empty styled block, allow
	   * certain key commands (newline, backspace) to simply change the
	   * style of the block instead of the default behavior.
	   */
	  tryToRemoveBlockStyle: function tryToRemoveBlockStyle(editorState) {
	    var selection = editorState.getSelection();
	    var offset = selection.getAnchorOffset();
	    if (selection.isCollapsed() && offset === 0) {
	      var key = selection.getAnchorKey();
	      var content = editorState.getCurrentContent();
	      var block = content.getBlockForKey(key);
	      if (block.getLength() > 0) {
	        return null;
	      }
	
	      var type = block.getType();
	      var blockBefore = content.getBlockBefore(key);
	      if (type === 'code-block' && blockBefore && blockBefore.getType() === 'code-block') {
	        return null;
	      }
	
	      if (type !== 'unstyled') {
	        return DraftModifier.setBlockType(content, selection, 'unstyled');
	      }
	    }
	    return null;
	  }
	};
	
	module.exports = RichTextEditorUtil;

/***/ },
/* 335 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule SelectionState
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var Immutable = __webpack_require__(346);
	
	var Record = Immutable.Record;
	
	var defaultRecord = {
	  anchorKey: '',
	  anchorOffset: 0,
	  focusKey: '',
	  focusOffset: 0,
	  isBackward: false,
	  hasFocus: false
	};
	
	var SelectionStateRecord = Record(defaultRecord);
	
	var SelectionState = (function (_SelectionStateRecord) {
	  _inherits(SelectionState, _SelectionStateRecord);
	
	  function SelectionState() {
	    _classCallCheck(this, SelectionState);
	
	    _get(Object.getPrototypeOf(SelectionState.prototype), 'constructor', this).apply(this, arguments);
	  }
	
	  _createClass(SelectionState, [{
	    key: 'serialize',
	    value: function serialize() {
	      return 'Anchor: ' + this.getAnchorKey() + ':' + this.getAnchorOffset() + ', ' + 'Focus: ' + this.getFocusKey() + ':' + this.getFocusOffset() + ', ' + 'Is Backward: ' + String(this.getIsBackward()) + ', ' + 'Has Focus: ' + String(this.getHasFocus());
	    }
	  }, {
	    key: 'getAnchorKey',
	    value: function getAnchorKey() {
	      return this.get('anchorKey');
	    }
	  }, {
	    key: 'getAnchorOffset',
	    value: function getAnchorOffset() {
	      return this.get('anchorOffset');
	    }
	  }, {
	    key: 'getFocusKey',
	    value: function getFocusKey() {
	      return this.get('focusKey');
	    }
	  }, {
	    key: 'getFocusOffset',
	    value: function getFocusOffset() {
	      return this.get('focusOffset');
	    }
	  }, {
	    key: 'getIsBackward',
	    value: function getIsBackward() {
	      return this.get('isBackward');
	    }
	  }, {
	    key: 'getHasFocus',
	    value: function getHasFocus() {
	      return this.get('hasFocus');
	    }
	
	    /**
	     * Return whether the specified range overlaps with an edge of the
	     * SelectionState.
	     */
	  }, {
	    key: 'hasEdgeWithin',
	    value: function hasEdgeWithin(blockKey, start, end) {
	      var anchorKey = this.getAnchorKey();
	      var focusKey = this.getFocusKey();
	
	      if (anchorKey === focusKey && anchorKey === blockKey) {
	        var selectionStart = this.getStartOffset();
	        var selectionEnd = this.getEndOffset();
	        return start <= selectionEnd && selectionStart <= end;
	      }
	
	      if (blockKey !== anchorKey && blockKey !== focusKey) {
	        return false;
	      }
	
	      var offsetToCheck = blockKey === anchorKey ? this.getAnchorOffset() : this.getFocusOffset();
	
	      return start <= offsetToCheck && end >= offsetToCheck;
	    }
	  }, {
	    key: 'isCollapsed',
	    value: function isCollapsed() {
	      return this.getAnchorKey() === this.getFocusKey() && this.getAnchorOffset() === this.getFocusOffset();
	    }
	  }, {
	    key: 'getStartKey',
	    value: function getStartKey() {
	      return this.getIsBackward() ? this.getFocusKey() : this.getAnchorKey();
	    }
	  }, {
	    key: 'getStartOffset',
	    value: function getStartOffset() {
	      return this.getIsBackward() ? this.getFocusOffset() : this.getAnchorOffset();
	    }
	  }, {
	    key: 'getEndKey',
	    value: function getEndKey() {
	      return this.getIsBackward() ? this.getAnchorKey() : this.getFocusKey();
	    }
	  }, {
	    key: 'getEndOffset',
	    value: function getEndOffset() {
	      return this.getIsBackward() ? this.getAnchorOffset() : this.getFocusOffset();
	    }
	  }], [{
	    key: 'createEmpty',
	    value: function createEmpty(key) {
	      return new SelectionState({
	        anchorKey: key,
	        anchorOffset: 0,
	        focusKey: key,
	        focusOffset: 0,
	        isBackward: false,
	        hasFocus: false
	      });
	    }
	  }]);
	
	  return SelectionState;
	})(SelectionStateRecord);
	
	module.exports = SelectionState;

/***/ },
/* 336 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule convertFromDraftStateToRaw
	 * 
	 */
	
	'use strict';
	
	var DraftEntity = __webpack_require__(330);
	var DraftStringKey = __webpack_require__(387);
	
	var encodeEntityRanges = __webpack_require__(388);
	var encodeInlineStyleRanges = __webpack_require__(389);
	
	function convertFromDraftStateToRaw(contentState) {
	  var entityStorageKey = 0;
	  var entityStorageMap = {};
	  var rawBlocks = [];
	
	  contentState.getBlockMap().forEach(function (block, blockKey) {
	    block.findEntityRanges(function (character) {
	      return character.getEntity() !== null;
	    }, function (start) {
	      // Stringify to maintain order of otherwise numeric keys.
	      var stringifiedEntityKey = DraftStringKey.stringify(block.getEntityAt(start));
	      if (!entityStorageMap.hasOwnProperty(stringifiedEntityKey)) {
	        entityStorageMap[stringifiedEntityKey] = '' + entityStorageKey++;
	      }
	    });
	
	    rawBlocks.push({
	      key: blockKey,
	      text: block.getText(),
	      type: block.getType(),
	      depth: canHaveDepth(block) ? block.getDepth() : 0,
	      inlineStyleRanges: encodeInlineStyleRanges(block),
	      entityRanges: encodeEntityRanges(block, entityStorageMap)
	    });
	  });
	
	  // Flip storage map so that our storage keys map to global
	  // DraftEntity keys.
	  var entityKeys = Object.keys(entityStorageMap);
	  var flippedStorageMap = {};
	  entityKeys.forEach(function (key, jj) {
	    var entity = DraftEntity.get(DraftStringKey.unstringify(key));
	    flippedStorageMap[jj] = {
	      type: entity.getType(),
	      mutability: entity.getMutability(),
	      data: entity.getData()
	    };
	  });
	
	  return {
	    entityMap: flippedStorageMap,
	    blocks: rawBlocks
	  };
	}
	
	function canHaveDepth(block) {
	  var type = block.getType();
	  return type === 'ordered-list-item' || type === 'unordered-list-item';
	}
	
	module.exports = convertFromDraftStateToRaw;

/***/ },
/* 337 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule convertFromHTMLToContentBlocks
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var CharacterMetadata = __webpack_require__(321);
	var ContentBlock = __webpack_require__(323);
	var DefaultDraftBlockRenderMap = __webpack_require__(325);
	var DraftEntity = __webpack_require__(330);
	var Immutable = __webpack_require__(346);
	var URI = __webpack_require__(443);
	
	var generateRandomKey = __webpack_require__(339);
	var getSafeBodyFromHTML = __webpack_require__(401);
	var invariant = __webpack_require__(432);
	var nullthrows = __webpack_require__(442);
	var sanitizeDraftText = __webpack_require__(375);
	
	var List = Immutable.List;
	var OrderedSet = Immutable.OrderedSet;
	
	var NBSP = '&nbsp;';
	var SPACE = ' ';
	
	// Arbitrary max indent
	var MAX_DEPTH = 4;
	
	// used for replacing characters in HTML
	var REGEX_CR = new RegExp('\r', 'g');
	var REGEX_LF = new RegExp('\n', 'g');
	var REGEX_NBSP = new RegExp(NBSP, 'g');
	
	// Block tag flow is different because LIs do not have
	// a deterministic style ;_;
	var inlineTags = {
	  b: 'BOLD',
	  code: 'CODE',
	  del: 'STRIKETHROUGH',
	  em: 'ITALIC',
	  i: 'ITALIC',
	  s: 'STRIKETHROUGH',
	  strike: 'STRIKETHROUGH',
	  strong: 'BOLD',
	  u: 'UNDERLINE'
	};
	
	var lastBlock;
	
	function getEmptyChunk() {
	  return {
	    text: '',
	    inlines: [],
	    entities: [],
	    blocks: []
	  };
	}
	
	function getWhitespaceChunk(inEntity) {
	  var entities = new Array(1);
	  if (inEntity) {
	    entities[0] = inEntity;
	  }
	  return {
	    text: SPACE,
	    inlines: [OrderedSet()],
	    entities: entities,
	    blocks: []
	  };
	}
	
	function getSoftNewlineChunk() {
	  return {
	    text: '\n',
	    inlines: [OrderedSet()],
	    entities: new Array(1),
	    blocks: []
	  };
	}
	
	function getBlockDividerChunk(block, depth) {
	  return {
	    text: '\r',
	    inlines: [OrderedSet()],
	    entities: new Array(1),
	    blocks: [{
	      type: block,
	      depth: Math.max(0, Math.min(MAX_DEPTH, depth))
	    }]
	  };
	}
	
	function getListBlockType(tag, lastList) {
	  if (tag === 'li') {
	    return lastList === 'ol' ? 'ordered-list-item' : 'unordered-list-item';
	  }
	  return null;
	}
	
	function getBlockMapSupportedTags(blockRenderMap) {
	  var unstyledElement = blockRenderMap.get('unstyled').element;
	  return blockRenderMap.map(function (config) {
	    return config.element;
	  }).valueSeq().toSet().filter(function (tag) {
	    return tag !== unstyledElement;
	  }).toArray().sort();
	}
	
	// custom element conversions
	function getMultiMatchedType(tag, lastList, multiMatchExtractor) {
	  for (var ii = 0; ii < multiMatchExtractor.length; ii++) {
	    var matchType = multiMatchExtractor[ii](tag, lastList);
	    if (matchType) {
	      return matchType;
	    }
	  }
	  return null;
	}
	
	function getBlockTypeForTag(tag, lastList, blockRenderMap) {
	  var matchedTypes = blockRenderMap.filter(function (config) {
	    return config.element === tag || config.wrapper === tag;
	  }).keySeq().toSet().toArray().sort();
	
	  // if we dont have any matched type, return unstyled
	  // if we have one matched type return it
	  // if we have multi matched types use the multi-match function to gather type
	  switch (matchedTypes.length) {
	    case 0:
	      return 'unstyled';
	    case 1:
	      return matchedTypes[0];
	    default:
	      return getMultiMatchedType(tag, lastList, [getListBlockType]) || 'unstyled';
	  }
	}
	
	function processInlineTag(tag, node, currentStyle) {
	  var styleToCheck = inlineTags[tag];
	  if (styleToCheck) {
	    currentStyle = currentStyle.add(styleToCheck).toOrderedSet();
	  } else if (node instanceof HTMLElement) {
	    (function () {
	      var htmlElement = node;
	      currentStyle = currentStyle.withMutations(function (style) {
	        if (htmlElement.style.fontWeight === 'bold') {
	          style.add('BOLD');
	        }
	
	        if (htmlElement.style.fontStyle === 'italic') {
	          style.add('ITALIC');
	        }
	
	        if (htmlElement.style.textDecoration === 'underline') {
	          style.add('UNDERLINE');
	        }
	
	        if (htmlElement.style.textDecoration === 'line-through') {
	          style.add('STRIKETHROUGH');
	        }
	      }).toOrderedSet();
	    })();
	  }
	  return currentStyle;
	}
	
	function joinChunks(A, B) {
	  // Sometimes two blocks will touch in the DOM and we need to strip the
	  // extra delimiter to preserve niceness.
	  var lastInB = B.text.slice(0, 1);
	
	  if (A.text.slice(-1) === '\r' && lastInB === '\r') {
	    A.text = A.text.slice(0, -1);
	    A.inlines.pop();
	    A.entities.pop();
	    A.blocks.pop();
	  }
	
	  // Kill whitespace after blocks
	  if (A.text.slice(-1) === '\r') {
	    if (B.text === SPACE || B.text === '\n') {
	      return A;
	    } else if (lastInB === SPACE || lastInB === '\n') {
	      B.text = B.text.slice(1);
	      B.inlines.shift();
	      B.entities.shift();
	    }
	  }
	
	  return {
	    text: A.text + B.text,
	    inlines: A.inlines.concat(B.inlines),
	    entities: A.entities.concat(B.entities),
	    blocks: A.blocks.concat(B.blocks)
	  };
	}
	
	/**
	 * Check to see if we have anything like <p> <blockquote> <h1>... to create
	 * block tags from. If we do, we can use those and ignore <div> tags. If we
	 * don't, we can treat <div> tags as meaningful (unstyled) blocks.
	 */
	function containsSemanticBlockMarkup(html, blockTags) {
	  return blockTags.some(function (tag) {
	    return html.indexOf('<' + tag) !== -1;
	  });
	}
	
	function hasValidLinkText(link) {
	  !(link instanceof HTMLAnchorElement) ? true ? invariant(false, 'Link must be an HTMLAnchorElement.') : invariant(false) : undefined;
	  var protocol = link.protocol;
	  return protocol === 'http:' || protocol === 'https:';
	}
	
	function genFragment(node, inlineStyle, lastList, inBlock, blockTags, depth, blockRenderMap, inEntity) {
	  var nodeName = node.nodeName.toLowerCase();
	  var newBlock = false;
	  var nextBlockType = 'unstyled';
	  var lastLastBlock = lastBlock;
	
	  // Base Case
	  if (nodeName === '#text') {
	    var text = node.textContent;
	    if (text.trim() === '' && inBlock !== 'pre') {
	      return getWhitespaceChunk(inEntity);
	    }
	    if (inBlock !== 'pre') {
	      // Can't use empty string because MSWord
	      text = text.replace(REGEX_LF, SPACE);
	    }
	
	    // save the last block so we can use it later
	    lastBlock = nodeName;
	
	    return {
	      text: text,
	      inlines: Array(text.length).fill(inlineStyle),
	      entities: Array(text.length).fill(inEntity),
	      blocks: []
	    };
	  }
	
	  // save the last block so we can use it later
	  lastBlock = nodeName;
	
	  // BR tags
	  if (nodeName === 'br') {
	    if (lastLastBlock === 'br' && (!inBlock || getBlockTypeForTag(inBlock, lastList, blockRenderMap) === 'unstyled')) {
	      return getBlockDividerChunk('unstyled', depth);
	    }
	    return getSoftNewlineChunk();
	  }
	
	  var chunk = getEmptyChunk();
	  var newChunk = null;
	
	  // Inline tags
	  inlineStyle = processInlineTag(nodeName, node, inlineStyle);
	
	  // Handle lists
	  if (nodeName === 'ul' || nodeName === 'ol') {
	    if (lastList) {
	      depth += 1;
	    }
	    lastList = nodeName;
	  }
	
	  // Block Tags
	  if (!inBlock && blockTags.indexOf(nodeName) !== -1) {
	    chunk = getBlockDividerChunk(getBlockTypeForTag(nodeName, lastList, blockRenderMap), depth);
	    inBlock = nodeName;
	    newBlock = true;
	  } else if (lastList && inBlock === 'li' && nodeName === 'li') {
	    chunk = getBlockDividerChunk(getBlockTypeForTag(nodeName, lastList, blockRenderMap), depth);
	    inBlock = nodeName;
	    newBlock = true;
	    nextBlockType = lastList === 'ul' ? 'unordered-list-item' : 'ordered-list-item';
	  }
	
	  // Recurse through children
	  var child = node.firstChild;
	  if (child != null) {
	    nodeName = child.nodeName.toLowerCase();
	  }
	
	  var entityId = null;
	  var href = null;
	
	  while (child) {
	    if (nodeName === 'a' && child.href && hasValidLinkText(child)) {
	      href = new URI(child.href).toString();
	      entityId = DraftEntity.create('LINK', 'MUTABLE', { url: href });
	    } else {
	      entityId = undefined;
	    }
	
	    newChunk = genFragment(child, inlineStyle, lastList, inBlock, blockTags, depth, blockRenderMap, entityId || inEntity);
	
	    chunk = joinChunks(chunk, newChunk);
	    var sibling = child.nextSibling;
	
	    // Put in a newline to break up blocks inside blocks
	    if (sibling && blockTags.indexOf(nodeName) >= 0 && inBlock) {
	      chunk = joinChunks(chunk, getSoftNewlineChunk());
	    }
	    if (sibling) {
	      nodeName = sibling.nodeName.toLowerCase();
	    }
	    child = sibling;
	  }
	
	  if (newBlock) {
	    chunk = joinChunks(chunk, getBlockDividerChunk(nextBlockType, depth));
	  }
	
	  return chunk;
	}
	
	function getChunkForHTML(html, DOMBuilder, blockRenderMap) {
	  html = html.trim().replace(REGEX_CR, '').replace(REGEX_NBSP, SPACE);
	
	  var supportedBlockTags = getBlockMapSupportedTags(blockRenderMap);
	
	  var safeBody = DOMBuilder(html);
	  if (!safeBody) {
	    return null;
	  }
	  lastBlock = null;
	
	  // Sometimes we aren't dealing with content that contains nice semantic
	  // tags. In this case, use divs to separate everything out into paragraphs
	  // and hope for the best.
	  var workingBlocks = containsSemanticBlockMarkup(html, supportedBlockTags) ? supportedBlockTags : ['div'];
	
	  // Start with -1 block depth to offset the fact that we are passing in a fake
	  // UL block to start with.
	  var chunk = genFragment(safeBody, OrderedSet(), 'ul', null, workingBlocks, -1, blockRenderMap);
	
	  // join with previous block to prevent weirdness on paste
	  if (chunk.text.indexOf('\r') === 0) {
	    chunk = {
	      text: chunk.text.slice(1),
	      inlines: chunk.inlines.slice(1),
	      entities: chunk.entities.slice(1),
	      blocks: chunk.blocks
	    };
	  }
	
	  // Kill block delimiter at the end
	  if (chunk.text.slice(-1) === '\r') {
	    chunk.text = chunk.text.slice(0, -1);
	    chunk.inlines = chunk.inlines.slice(0, -1);
	    chunk.entities = chunk.entities.slice(0, -1);
	    chunk.blocks.pop();
	  }
	
	  // If we saw no block tags, put an unstyled one in
	  if (chunk.blocks.length === 0) {
	    chunk.blocks.push({ type: 'unstyled', depth: 0 });
	  }
	
	  // Sometimes we start with text that isn't in a block, which is then
	  // followed by blocks. Need to fix up the blocks to add in
	  // an unstyled block for this content
	  if (chunk.text.split('\r').length === chunk.blocks.length + 1) {
	    chunk.blocks.unshift({ type: 'unstyled', depth: 0 });
	  }
	
	  return chunk;
	}
	
	function convertFromHTMLtoContentBlocks(html) {
	  var DOMBuilder = arguments.length <= 1 || arguments[1] === undefined ? getSafeBodyFromHTML : arguments[1];
	  var blockRenderMap = arguments.length <= 2 || arguments[2] === undefined ? DefaultDraftBlockRenderMap : arguments[2];
	
	  // Be ABSOLUTELY SURE that the dom builder you pass hare won't execute
	  // arbitrary code in whatever environment you're running this in. For an
	  // example of how we try to do this in-browser, see getSafeBodyFromHTML.
	
	  var chunk = getChunkForHTML(html, DOMBuilder, blockRenderMap);
	
	  if (chunk == null) {
	    return null;
	  }
	  var start = 0;
	  return chunk.text.split('\r').map(function (textBlock, ii) {
	    // Make absolutely certain that our text is acceptable.
	    textBlock = sanitizeDraftText(textBlock);
	    var end = start + textBlock.length;
	    var inlines = nullthrows(chunk).inlines.slice(start, end);
	    var entities = nullthrows(chunk).entities.slice(start, end);
	    var characterList = List(inlines.map(function (style, ii) {
	      var data = { style: style, entity: null };
	      if (entities[ii]) {
	        data.entity = entities[ii];
	      }
	      return CharacterMetadata.create(data);
	    }));
	    start = end + 1;
	
	    return new ContentBlock({
	      key: generateRandomKey(),
	      type: nullthrows(chunk).blocks[ii].type,
	      depth: nullthrows(chunk).blocks[ii].depth,
	      text: textBlock,
	      characterList: characterList
	    });
	  });
	}
	
	module.exports = convertFromHTMLtoContentBlocks;

/***/ },
/* 338 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule convertFromRawToDraftState
	 * 
	 */
	
	'use strict';
	
	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var ContentBlock = __webpack_require__(323);
	var ContentState = __webpack_require__(324);
	var DraftEntity = __webpack_require__(330);
	
	var createCharacterList = __webpack_require__(390);
	var decodeEntityRanges = __webpack_require__(391);
	var decodeInlineStyleRanges = __webpack_require__(392);
	var generateRandomKey = __webpack_require__(339);
	
	function convertFromRawToDraftState(rawState) {
	  var blocks = rawState.blocks;
	  var entityMap = rawState.entityMap;
	
	  var fromStorageToLocal = {};
	  Object.keys(entityMap).forEach(function (storageKey) {
	    var encodedEntity = entityMap[storageKey];
	    var type = encodedEntity.type;
	    var mutability = encodedEntity.mutability;
	    var data = encodedEntity.data;
	
	    var newKey = DraftEntity.create(type, mutability, data || {});
	    fromStorageToLocal[storageKey] = newKey;
	  });
	
	  var contentBlocks = blocks.map(function (block) {
	    var key = block.key;
	    var type = block.type;
	    var text = block.text;
	    var depth = block.depth;
	    var inlineStyleRanges = block.inlineStyleRanges;
	    var entityRanges = block.entityRanges;
	
	    key = key || generateRandomKey();
	    depth = depth || 0;
	    inlineStyleRanges = inlineStyleRanges || [];
	    entityRanges = entityRanges || [];
	
	    var inlineStyles = decodeInlineStyleRanges(text, inlineStyleRanges);
	
	    // Translate entity range keys to the DraftEntity map.
	    var filteredEntityRanges = entityRanges.filter(function (range) {
	      return fromStorageToLocal.hasOwnProperty(range.key);
	    }).map(function (range) {
	      return _extends({}, range, { key: fromStorageToLocal[range.key] });
	    });
	
	    var entities = decodeEntityRanges(text, filteredEntityRanges);
	    var characterList = createCharacterList(inlineStyles, entities);
	
	    return new ContentBlock({ key: key, type: type, text: text, depth: depth, characterList: characterList });
	  });
	
	  return ContentState.createFromBlockArray(contentBlocks);
	}
	
	module.exports = convertFromRawToDraftState;

/***/ },
/* 339 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule generateRandomKey
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var seenKeys = {};
	var MULTIPLIER = Math.pow(2, 24);
	
	function generateRandomKey() {
	  var key = undefined;
	  while (key === undefined || seenKeys.hasOwnProperty(key) || !isNaN(+key)) {
	    key = Math.floor(Math.random() * MULTIPLIER).toString(32);
	  }
	  seenKeys[key] = true;
	  return key;
	}
	
	module.exports = generateRandomKey;

/***/ },
/* 340 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getDefaultKeyBinding
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var KeyBindingUtil = __webpack_require__(333);
	var Keys = __webpack_require__(434);
	var UserAgent = __webpack_require__(433);
	
	var isOSX = UserAgent.isPlatform('Mac OS X');
	var isWindows = UserAgent.isPlatform('Windows');
	
	// Firefox on OSX had a bug resulting in navigation instead of cursor movement.
	// This bug was fixed in Firefox 29. Feature detection is virtually impossible
	// so we just check the version number. See #342765.
	var shouldFixFirefoxMovement = isOSX && UserAgent.isBrowser('Firefox < 29');
	
	var hasCommandModifier = KeyBindingUtil.hasCommandModifier;
	var isCtrlKeyCommand = KeyBindingUtil.isCtrlKeyCommand;
	
	function shouldRemoveWord(e) {
	  return isOSX && e.altKey || isCtrlKeyCommand(e);
	}
	
	/**
	 * Get the appropriate undo/redo command for a Z key command.
	 */
	function getZCommand(e) {
	  if (hasCommandModifier(e)) {
	    return e.shiftKey ? 'redo' : 'undo';
	  }
	}
	
	function getDeleteCommand(e) {
	  // Allow default "cut" behavior for Windows on Shift + Delete.
	  if (isWindows && e.shiftKey) {
	    return null;
	  }
	  return shouldRemoveWord(e) ? 'delete-word' : 'delete';
	}
	
	function getBackspaceCommand(e) {
	  if (hasCommandModifier(e) && isOSX) {
	    return 'backspace-to-start-of-line';
	  }
	  return shouldRemoveWord(e) ? 'backspace-word' : 'backspace';
	}
	
	/**
	 * Retrieve a bound key command for the given event.
	 */
	function getDefaultKeyBinding(e) {
	  switch (e.keyCode) {
	    case 66:
	      // B
	      return hasCommandModifier(e) ? 'bold' : null;
	    case 68:
	      // D
	      return isCtrlKeyCommand(e) ? 'delete' : null;
	    case 72:
	      // H
	      return isCtrlKeyCommand(e) ? 'backspace' : null;
	    case 73:
	      // I
	      return hasCommandModifier(e) ? 'italic' : null;
	    case 74:
	      // J
	      return hasCommandModifier(e) ? 'code' : null;
	    case 75:
	      // K
	      return !isWindows && isCtrlKeyCommand(e) ? 'secondary-cut' : null;
	    case 77:
	      // M
	      return isCtrlKeyCommand(e) ? 'split-block' : null;
	    case 79:
	      // O
	      return isCtrlKeyCommand(e) ? 'split-block' : null;
	    case 84:
	      // T
	      return isOSX && isCtrlKeyCommand(e) ? 'transpose-characters' : null;
	    case 85:
	      // U
	      return hasCommandModifier(e) ? 'underline' : null;
	    case 87:
	      // W
	      return isOSX && isCtrlKeyCommand(e) ? 'backspace-word' : null;
	    case 89:
	      // Y
	      if (isCtrlKeyCommand(e)) {
	        return isWindows ? 'redo' : 'secondary-paste';
	      }
	      return null;
	    case 90:
	      // Z
	      return getZCommand(e) || null;
	    case Keys.RETURN:
	      return 'split-block';
	    case Keys.DELETE:
	      return getDeleteCommand(e);
	    case Keys.BACKSPACE:
	      return getBackspaceCommand(e);
	    // LEFT/RIGHT handlers serve as a workaround for a Firefox bug.
	    case Keys.LEFT:
	      return shouldFixFirefoxMovement && hasCommandModifier(e) ? 'move-selection-to-start-of-block' : null;
	    case Keys.RIGHT:
	      return shouldFixFirefoxMovement && hasCommandModifier(e) ? 'move-selection-to-end-of-block' : null;
	    default:
	      return null;
	  }
	}
	
	module.exports = getDefaultKeyBinding;

/***/ },
/* 341 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getVisibleSelectionRect
	 * @typechecks
	 * 
	 */
	
	/**
	 * Return the bounding ClientRect for the visible DOM selection, if any.
	 * In cases where there are no selected ranges or the bounding rect is
	 * temporarily invalid, return null.
	 */
	'use strict';
	
	var getRangeBoundingClientRect = __webpack_require__(393);
	
	function getVisibleSelectionRect(global) {
	  var selection = global.getSelection();
	  if (!selection.rangeCount) {
	    return null;
	  }
	
	  var range = selection.getRangeAt(0);
	  var boundingRect = getRangeBoundingClientRect(range);
	  var top = boundingRect.top;
	  var right = boundingRect.right;
	  var bottom = boundingRect.bottom;
	  var left = boundingRect.left;
	
	  // When a re-render leads to a node being removed, the DOM selection will
	  // temporarily be placed on an ancestor node, which leads to an invalid
	  // bounding rect. Discard this state.
	  if (top === 0 && right === 0 && bottom === 0 && left === 0) {
	    return null;
	  }
	
	  return boundingRect;
	}
	
	module.exports = getVisibleSelectionRect;

/***/ },
/* 342 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A library of options to pass to add/draw/remove/constraints
	 */
	var _ = __webpack_require__(56);
	
	var WrappedEllipse = __webpack_require__(343);
	var kpoint = __webpack_require__(275).point;
	
	var add = {
	    constrain: function constrain() {
	        this.constrain();
	    }
	};
	
	add.standard = [add.constrain];
	
	var modify = {
	    draw: function draw() {
	        this.draw();
	    }
	};
	
	modify.standard = [modify.draw];
	
	var draw = {
	    basic: function basic(state, prevState) {
	        var graphie = this.graphie;
	        if (!this.state.visibleShape) {
	            var radii = [this.pointSize() / graphie.scale[0], this.pointSize() / graphie.scale[1]];
	            var options = {
	                maxScale: Math.max(this.highlightStyle().scale, this.normalStyle().scale),
	                // Add in 10px of padding to avoid clipping at the edges.
	                padding: 10,
	                shadow: state.shadow
	            };
	            this.state.visibleShape = new WrappedEllipse(graphie, this.coord(), radii, options);
	
	            this.state.visibleShape.attr(_.omit(this.normalStyle(), "scale"));
	            this.state.visibleShape.toFront();
	
	            // Keep mouseTarget in front of visible shape
	            if (this.mouseTarget()) {
	                this.mouseTarget().toFront();
	            }
	        }
	        if (state.normalStyle !== prevState.normalStyle && !_.isEqual(state.normalStyle, prevState.normalStyle)) {
	            this.state.visibleShape.attr(this.normalStyle());
	        }
	
	        this.state.visibleShape.moveTo(this.coord());
	        if (this.mouseTarget()) {
	            this.mouseTarget().moveTo(this.coord());
	        }
	    },
	
	    highlight: function highlight(state, prevState) {
	        if (state.isHovering && !prevState.isHovering) {
	            state.visibleShape.animate(this.highlightStyle(), 50);
	        } else if (!state.isHovering && prevState.isHovering) {
	            state.visibleShape.animate(this.normalStyle(), 50);
	        }
	    }
	};
	
	draw.standard = [draw.basic, draw.highlight];
	
	var remove = {
	    basic: function basic() {
	        if (this.state.visibleShape) {
	            this.state.visibleShape.remove();
	            this.state.visibleShape = null;
	        }
	    }
	};
	
	remove.standard = remove.basic;
	
	var constraints = {
	    fixed: function fixed() {
	        return function () {
	            return false;
	        };
	    },
	
	    snap: function snap(_snap) {
	        return function (coord) {
	            if (_snap === null) {
	                return true;
	            }
	            _snap = _snap || this.graphie.snap;
	            return kpoint.roundTo(coord, _snap);
	        };
	    },
	
	    bound: function bound(range, snap, paddingPx) {
	        if (paddingPx === undefined) {
	            if (range === undefined) {
	                paddingPx = 10;
	            } else {
	                paddingPx = 0;
	            }
	        }
	        return function (coord, prev, options) {
	            var graphie = this.graphie;
	            range = range || graphie.range;
	
	            if (snap === undefined) {
	                snap = graphie.snap;
	            }
	
	            var lower = graphie.unscalePoint([paddingPx, graphie.ypixels - paddingPx]);
	
	            var upper = graphie.unscalePoint([graphie.xpixels - paddingPx, paddingPx]);
	
	            if (snap) {
	                lower = kpoint.ceilTo(lower, snap);
	                upper = kpoint.floorTo(upper, snap);
	            }
	
	            if (!!options && !!options.onOutOfBounds) {
	                if (coord[0] > upper[0] || coord[0] < lower[0] || coord[1] > upper[1] || coord[1] < lower[1]) {
	                    options.onSkipRemaining();
	                    options.onOutOfBounds();
	                }
	
	                return coord;
	            }
	
	            var coordX = Math.max(lower[0], Math.min(upper[0], coord[0]));
	            var coordY = Math.max(lower[1], Math.min(upper[1], coord[1]));
	
	            return [coordX, coordY];
	        };
	    }
	};
	
	constraints.standard = null;
	
	module.exports = {
	    add: add,
	    modify: modify,
	    draw: draw,
	    remove: remove,
	
	    onMoveStart: { standard: null },
	    constraints: constraints,
	    onMove: { standard: null },
	    onMoveEnd: { standard: null },
	    onClick: { standard: null }
	};

/***/ },
/* 343 */
/***/ function(module, exports, __webpack_require__) {

	var _ = __webpack_require__(56);
	var WrappedDefaults = __webpack_require__(288);
	var InteractiveUtil = __webpack_require__(256);
	var kvector = __webpack_require__(275).vector;
	
	var DEFAULT_OPTIONS = {
	    maxScale: 1,
	    mouselayer: false,
	    shadow: false,
	    disableMouseEventsOnWrapper: false
	};
	
	var WrappedEllipse = function WrappedEllipse(graphie, center, radii, options) {
	    options = _.extend({}, DEFAULT_OPTIONS, options);
	
	    // Add `wrapper`, `visibleShape`, and remaining properties.
	    var fixedEllipse = graphie.fixedEllipse(center, radii, options.maxScale, options.padding);
	    _.extend(this, fixedEllipse, {
	        graphie: graphie,
	        initialPoint: center
	    });
	
	    // Add to appropriate graphie layer
	    if (options.mouselayer) {
	        // Disable browser handling of all panning and zooming gestures on the
	        // movable wrapper so that when moved the browser does not scroll page
	        this.wrapper.style.touchAction = "none";
	
	        this.graphie.addToMouseLayerWrapper(this.wrapper);
	    } else {
	        this.graphie.addToVisibleLayerWrapper(this.wrapper);
	    }
	
	    if (options.shadow) {
	        var filter = "drop-shadow(0px 0px 5px rgba(0, 0, 0, 0.5))";
	        var wrapper = this.wrapper;
	        wrapper.style.webkitFilter = filter;
	        wrapper.style.filter = filter;
	
	        this.moveTo = function (point) {
	            var delta = kvector.subtract(this.graphie.scalePoint(point), this.graphie.scalePoint(this.initialPoint));
	            var do3dTransform = InteractiveUtil.getCanUse3dTransform();
	            var transform = "translateX(" + Math.round(delta[0]) + "px) " + "translateY(" + Math.round(delta[1]) + "px)" + (do3dTransform ? " translateZ(0)" : "");
	            this.transform(transform);
	        };
	    }
	
	    if (options.disableMouseEventsOnWrapper) {
	        this.wrapper.style.pointerEvents = "none";
	        this.visibleShape.node.style.pointerEvents = "auto";
	    }
	};
	
	_.extend(WrappedEllipse.prototype, WrappedDefaults);
	
	module.exports = WrappedEllipse;

/***/ },
/* 344 */
/***/ function(module, exports, __webpack_require__) {

	/* globals katex:false, MathJax:false, Exercises:false */
	
	var KhanMath = __webpack_require__(208);
	
	function findChildOrAdd(elem, className) {
	    var $child = $(elem).find("." + className);
	    if ($child.length === 0) {
	        return $("<span>").addClass(className).appendTo($(elem));
	    } else {
	        return $child;
	    }
	}
	
	function doCallback(elem, callback) {
	    var tries = 0;
	    (function check() {
	        var height = elem.scrollHeight;
	        // Heuristic to guess if the font has kicked in
	        // so we have box metrics (magic number ick,
	        // but this seems to work mostly-consistently)
	        if (height > 18 || tries >= 10) {
	            callback();
	        } else {
	            tries++;
	            setTimeout(check, 100);
	        }
	    })();
	}
	
	module.exports = {
	    // Process a node and add math inside of it. This attempts to use KaTeX to
	    // format the math, and if that fails it falls back to MathJax.
	    //
	    // elem: The element which the math should be added to.
	    //
	    // text: The text that should be formatted inside of the node. If the node
	    //       has already had math formatted inside of it before, this doesn't
	    //       have to be provided. If this is not provided, and the node hasn't
	    //       been formatted before, the text content of the node is used.
	    //
	    // force: (optional) if the node has been processed before, then it will
	    //        not be formatted again, unless this argument is true
	    //
	    // callback: (optional) a callback to be run after the math has been
	    //           processed (note: this might be called synchronously or
	    //           asynchronously, depending on whether KaTeX or MathJax is used)
	    processMath: function processMath(elem, text, force, callback) {
	        var $elem = $(elem);
	
	        // Only process if it hasn't been done before, or it is forced
	        if ($elem.attr("data-math-formula") == null || force) {
	            var $katexHolder = findChildOrAdd($elem, "katex-holder");
	            var $mathjaxHolder = findChildOrAdd($elem, "mathjax-holder");
	
	            // Search for MathJax-y script tags inside of the node. These are
	            // used by MathJax to denote the formula to be typeset. Before, we
	            // would update the formula by updating the contents of the script
	            // tag, which shouldn't happen any more, but we manage them just in
	            // case.
	            var script = $mathjaxHolder.find("script[type='math/tex']")[0];
	
	            // If text wasn't provided, we look in two places
	            if (text == null) {
	                if ($elem.attr("data-math-formula")) {
	                    // The old typeset formula
	                    text = $elem.attr("data-math-formula");
	                } else if (script) {
	                    // The contents of the <script> tag
	                    text = script.text || script.textContent;
	                }
	            }
	
	            text = text != null ? text + "" : "";
	
	            // Attempt to clean up some of the math
	            text = KhanMath.cleanMath(text);
	
	            // Store the formula that we're using
	            $elem.attr("data-math-formula", text);
	
	            if (Exercises.useKatex) {
	                // Try to process the nodes with KaTeX first
	                try {
	                    katex.render(text, $katexHolder[0]);
	                    // If that worked, and we previously formatted with
	                    // mathjax, do some mathjax cleanup
	                    if ($elem.attr("data-math-type") === "mathjax") {
	                        // Remove the old mathjax stuff
	                        var jax = MathJax.Hub.getJaxFor(script);
	                        if (jax) {
	                            var e = jax.SourceElement();
	                            if (e.previousSibling && e.previousSibling.className) {
	                                jax.Remove();
	                            }
	                        }
	                    }
	                    $elem.attr("data-math-type", "katex");
	                    // Call the callback
	                    if (callback) {
	                        doCallback(elem, callback);
	                    }
	                    return;
	                } catch (err) {
	                    // IE doesn't do instanceof correctly, so we resort to
	                    // manual checking
	                    /* jshint -W103 */
	                    if (err.__proto__ !== katex.ParseError.prototype) {
	                        throw err;
	                    }
	                    /* jshint +W103 */
	                }
	            }
	
	            // Otherwise, fallback to MathJax
	
	            // (Note: we don't need to do any katex cleanup here, because
	            // KaTeX is smart and cleans itself up)
	            $elem.attr("data-math-type", "mathjax");
	            // Update the script tag, or add one if necessary
	            if (!script) {
	                $mathjaxHolder.append("<script type='math/tex'>" + text.replace(/<\//g, "< /") + "</script>");
	            } else {
	                if ("text" in script) {
	                    // IE8, etc
	                    script.text = text;
	                } else {
	                    script.textContent = text;
	                }
	            }
	            if (typeof MathJax !== "undefined") {
	                // Put the process, a debug log, and the callback into the
	                // MathJax queue
	                MathJax.Hub.Queue(["Reprocess", MathJax.Hub, $mathjaxHolder[0]]);
	                MathJax.Hub.Queue(function () {
	                    KhanUtil.debugLog("MathJax done typesetting (" + text + ")");
	                });
	                if (callback) {
	                    MathJax.Hub.Queue(function () {
	                        var cb = MathJax.Callback(function () {});
	                        doCallback(elem, function () {
	                            callback();
	                            cb();
	                        });
	                        return cb;
	                    });
	                }
	            }
	        }
	    },
	
	    processAllMath: function processAllMath(elem, force) {
	        var $elem = $(elem);
	        $elem.filter("code").add($elem.find("code")).each(function () {
	            var $this = $(this);
	            var text = $this.attr("data-math-formula");
	            if (text == null) {
	                text = $this.text();
	                $this.empty();
	            }
	            KhanUtil.processMath(this, text, force);
	        });
	    },
	
	    // Function to restore a node to a non-math-processed state
	    cleanupMath: function cleanupMath(elem) {
	        var $elem = $(elem);
	
	        // Only mess with it if it's been processed before
	        if ($elem.attr("data-math-formula")) {
	            // Remove MathJax remnants
	            if (typeof MathJax !== "undefined") {
	                var jax = MathJax.Hub.getJaxFor($elem.find("script")[0]);
	                if (jax) {
	                    var e = jax.SourceElement();
	                    if (e.previousSibling && e.previousSibling.className) {
	                        jax.Remove();
	                    }
	                }
	            }
	
	            $elem.text($elem.attr("data-math-formula"));
	            $elem.attr("data-math-formula", null);
	            $elem.attr("data-math-type", null);
	        }
	
	        return elem;
	    },
	
	    // Function to retrieve the formula of a typeset math node
	    retrieveMathFormula: function retrieveMathFormula(elem) {
	        return $(elem).attr("data-math-formula");
	    }
	};

/***/ },
/* 345 */,
/* 346 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 *  Copyright (c) 2014-2015, Facebook, Inc.
	 *  All rights reserved.
	 *
	 *  This source code is licensed under the BSD-style license found in the
	 *  LICENSE file in the root directory of this source tree. An additional grant
	 *  of patent rights can be found in the PATENTS file in the same directory.
	 */
	
	(function (global, factory) {
	  true ? module.exports = factory() :
	  typeof define === 'function' && define.amd ? define(factory) :
	  global.Immutable = factory();
	}(this, function () { 'use strict';var SLICE$0 = Array.prototype.slice;
	
	  function createClass(ctor, superClass) {
	    if (superClass) {
	      ctor.prototype = Object.create(superClass.prototype);
	    }
	    ctor.prototype.constructor = ctor;
	  }
	
	  function Iterable(value) {
	      return isIterable(value) ? value : Seq(value);
	    }
	
	
	  createClass(KeyedIterable, Iterable);
	    function KeyedIterable(value) {
	      return isKeyed(value) ? value : KeyedSeq(value);
	    }
	
	
	  createClass(IndexedIterable, Iterable);
	    function IndexedIterable(value) {
	      return isIndexed(value) ? value : IndexedSeq(value);
	    }
	
	
	  createClass(SetIterable, Iterable);
	    function SetIterable(value) {
	      return isIterable(value) && !isAssociative(value) ? value : SetSeq(value);
	    }
	
	
	
	  function isIterable(maybeIterable) {
	    return !!(maybeIterable && maybeIterable[IS_ITERABLE_SENTINEL]);
	  }
	
	  function isKeyed(maybeKeyed) {
	    return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL]);
	  }
	
	  function isIndexed(maybeIndexed) {
	    return !!(maybeIndexed && maybeIndexed[IS_INDEXED_SENTINEL]);
	  }
	
	  function isAssociative(maybeAssociative) {
	    return isKeyed(maybeAssociative) || isIndexed(maybeAssociative);
	  }
	
	  function isOrdered(maybeOrdered) {
	    return !!(maybeOrdered && maybeOrdered[IS_ORDERED_SENTINEL]);
	  }
	
	  Iterable.isIterable = isIterable;
	  Iterable.isKeyed = isKeyed;
	  Iterable.isIndexed = isIndexed;
	  Iterable.isAssociative = isAssociative;
	  Iterable.isOrdered = isOrdered;
	
	  Iterable.Keyed = KeyedIterable;
	  Iterable.Indexed = IndexedIterable;
	  Iterable.Set = SetIterable;
	
	
	  var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
	  var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
	  var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';
	  var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
	
	  // Used for setting prototype methods that IE8 chokes on.
	  var DELETE = 'delete';
	
	  // Constants describing the size of trie nodes.
	  var SHIFT = 5; // Resulted in best performance after ______?
	  var SIZE = 1 << SHIFT;
	  var MASK = SIZE - 1;
	
	  // A consistent shared value representing "not set" which equals nothing other
	  // than itself, and nothing that could be provided externally.
	  var NOT_SET = {};
	
	  // Boolean references, Rough equivalent of `bool &`.
	  var CHANGE_LENGTH = { value: false };
	  var DID_ALTER = { value: false };
	
	  function MakeRef(ref) {
	    ref.value = false;
	    return ref;
	  }
	
	  function SetRef(ref) {
	    ref && (ref.value = true);
	  }
	
	  // A function which returns a value representing an "owner" for transient writes
	  // to tries. The return value will only ever equal itself, and will not equal
	  // the return of any subsequent call of this function.
	  function OwnerID() {}
	
	  // http://jsperf.com/copy-array-inline
	  function arrCopy(arr, offset) {
	    offset = offset || 0;
	    var len = Math.max(0, arr.length - offset);
	    var newArr = new Array(len);
	    for (var ii = 0; ii < len; ii++) {
	      newArr[ii] = arr[ii + offset];
	    }
	    return newArr;
	  }
	
	  function ensureSize(iter) {
	    if (iter.size === undefined) {
	      iter.size = iter.__iterate(returnTrue);
	    }
	    return iter.size;
	  }
	
	  function wrapIndex(iter, index) {
	    // This implements "is array index" which the ECMAString spec defines as:
	    //
	    //     A String property name P is an array index if and only if
	    //     ToString(ToUint32(P)) is equal to P and ToUint32(P) is not equal
	    //     to 2^32−1.
	    //
	    // http://www.ecma-international.org/ecma-262/6.0/#sec-array-exotic-objects
	    if (typeof index !== 'number') {
	      var uint32Index = index >>> 0; // N >>> 0 is shorthand for ToUint32
	      if ('' + uint32Index !== index || uint32Index === 4294967295) {
	        return NaN;
	      }
	      index = uint32Index;
	    }
	    return index < 0 ? ensureSize(iter) + index : index;
	  }
	
	  function returnTrue() {
	    return true;
	  }
	
	  function wholeSlice(begin, end, size) {
	    return (begin === 0 || (size !== undefined && begin <= -size)) &&
	      (end === undefined || (size !== undefined && end >= size));
	  }
	
	  function resolveBegin(begin, size) {
	    return resolveIndex(begin, size, 0);
	  }
	
	  function resolveEnd(end, size) {
	    return resolveIndex(end, size, size);
	  }
	
	  function resolveIndex(index, size, defaultIndex) {
	    return index === undefined ?
	      defaultIndex :
	      index < 0 ?
	        Math.max(0, size + index) :
	        size === undefined ?
	          index :
	          Math.min(size, index);
	  }
	
	  /* global Symbol */
	
	  var ITERATE_KEYS = 0;
	  var ITERATE_VALUES = 1;
	  var ITERATE_ENTRIES = 2;
	
	  var REAL_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
	  var FAUX_ITERATOR_SYMBOL = '@@iterator';
	
	  var ITERATOR_SYMBOL = REAL_ITERATOR_SYMBOL || FAUX_ITERATOR_SYMBOL;
	
	
	  function Iterator(next) {
	      this.next = next;
	    }
	
	    Iterator.prototype.toString = function() {
	      return '[Iterator]';
	    };
	
	
	  Iterator.KEYS = ITERATE_KEYS;
	  Iterator.VALUES = ITERATE_VALUES;
	  Iterator.ENTRIES = ITERATE_ENTRIES;
	
	  Iterator.prototype.inspect =
	  Iterator.prototype.toSource = function () { return this.toString(); }
	  Iterator.prototype[ITERATOR_SYMBOL] = function () {
	    return this;
	  };
	
	
	  function iteratorValue(type, k, v, iteratorResult) {
	    var value = type === 0 ? k : type === 1 ? v : [k, v];
	    iteratorResult ? (iteratorResult.value = value) : (iteratorResult = {
	      value: value, done: false
	    });
	    return iteratorResult;
	  }
	
	  function iteratorDone() {
	    return { value: undefined, done: true };
	  }
	
	  function hasIterator(maybeIterable) {
	    return !!getIteratorFn(maybeIterable);
	  }
	
	  function isIterator(maybeIterator) {
	    return maybeIterator && typeof maybeIterator.next === 'function';
	  }
	
	  function getIterator(iterable) {
	    var iteratorFn = getIteratorFn(iterable);
	    return iteratorFn && iteratorFn.call(iterable);
	  }
	
	  function getIteratorFn(iterable) {
	    var iteratorFn = iterable && (
	      (REAL_ITERATOR_SYMBOL && iterable[REAL_ITERATOR_SYMBOL]) ||
	      iterable[FAUX_ITERATOR_SYMBOL]
	    );
	    if (typeof iteratorFn === 'function') {
	      return iteratorFn;
	    }
	  }
	
	  function isArrayLike(value) {
	    return value && typeof value.length === 'number';
	  }
	
	  createClass(Seq, Iterable);
	    function Seq(value) {
	      return value === null || value === undefined ? emptySequence() :
	        isIterable(value) ? value.toSeq() : seqFromValue(value);
	    }
	
	    Seq.of = function(/*...values*/) {
	      return Seq(arguments);
	    };
	
	    Seq.prototype.toSeq = function() {
	      return this;
	    };
	
	    Seq.prototype.toString = function() {
	      return this.__toString('Seq {', '}');
	    };
	
	    Seq.prototype.cacheResult = function() {
	      if (!this._cache && this.__iterateUncached) {
	        this._cache = this.entrySeq().toArray();
	        this.size = this._cache.length;
	      }
	      return this;
	    };
	
	    // abstract __iterateUncached(fn, reverse)
	
	    Seq.prototype.__iterate = function(fn, reverse) {
	      return seqIterate(this, fn, reverse, true);
	    };
	
	    // abstract __iteratorUncached(type, reverse)
	
	    Seq.prototype.__iterator = function(type, reverse) {
	      return seqIterator(this, type, reverse, true);
	    };
	
	
	
	  createClass(KeyedSeq, Seq);
	    function KeyedSeq(value) {
	      return value === null || value === undefined ?
	        emptySequence().toKeyedSeq() :
	        isIterable(value) ?
	          (isKeyed(value) ? value.toSeq() : value.fromEntrySeq()) :
	          keyedSeqFromValue(value);
	    }
	
	    KeyedSeq.prototype.toKeyedSeq = function() {
	      return this;
	    };
	
	
	
	  createClass(IndexedSeq, Seq);
	    function IndexedSeq(value) {
	      return value === null || value === undefined ? emptySequence() :
	        !isIterable(value) ? indexedSeqFromValue(value) :
	        isKeyed(value) ? value.entrySeq() : value.toIndexedSeq();
	    }
	
	    IndexedSeq.of = function(/*...values*/) {
	      return IndexedSeq(arguments);
	    };
	
	    IndexedSeq.prototype.toIndexedSeq = function() {
	      return this;
	    };
	
	    IndexedSeq.prototype.toString = function() {
	      return this.__toString('Seq [', ']');
	    };
	
	    IndexedSeq.prototype.__iterate = function(fn, reverse) {
	      return seqIterate(this, fn, reverse, false);
	    };
	
	    IndexedSeq.prototype.__iterator = function(type, reverse) {
	      return seqIterator(this, type, reverse, false);
	    };
	
	
	
	  createClass(SetSeq, Seq);
	    function SetSeq(value) {
	      return (
	        value === null || value === undefined ? emptySequence() :
	        !isIterable(value) ? indexedSeqFromValue(value) :
	        isKeyed(value) ? value.entrySeq() : value
	      ).toSetSeq();
	    }
	
	    SetSeq.of = function(/*...values*/) {
	      return SetSeq(arguments);
	    };
	
	    SetSeq.prototype.toSetSeq = function() {
	      return this;
	    };
	
	
	
	  Seq.isSeq = isSeq;
	  Seq.Keyed = KeyedSeq;
	  Seq.Set = SetSeq;
	  Seq.Indexed = IndexedSeq;
	
	  var IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
	
	  Seq.prototype[IS_SEQ_SENTINEL] = true;
	
	
	
	  createClass(ArraySeq, IndexedSeq);
	    function ArraySeq(array) {
	      this._array = array;
	      this.size = array.length;
	    }
	
	    ArraySeq.prototype.get = function(index, notSetValue) {
	      return this.has(index) ? this._array[wrapIndex(this, index)] : notSetValue;
	    };
	
	    ArraySeq.prototype.__iterate = function(fn, reverse) {
	      var array = this._array;
	      var maxIndex = array.length - 1;
	      for (var ii = 0; ii <= maxIndex; ii++) {
	        if (fn(array[reverse ? maxIndex - ii : ii], ii, this) === false) {
	          return ii + 1;
	        }
	      }
	      return ii;
	    };
	
	    ArraySeq.prototype.__iterator = function(type, reverse) {
	      var array = this._array;
	      var maxIndex = array.length - 1;
	      var ii = 0;
	      return new Iterator(function() 
	        {return ii > maxIndex ?
	          iteratorDone() :
	          iteratorValue(type, ii, array[reverse ? maxIndex - ii++ : ii++])}
	      );
	    };
	
	
	
	  createClass(ObjectSeq, KeyedSeq);
	    function ObjectSeq(object) {
	      var keys = Object.keys(object);
	      this._object = object;
	      this._keys = keys;
	      this.size = keys.length;
	    }
	
	    ObjectSeq.prototype.get = function(key, notSetValue) {
	      if (notSetValue !== undefined && !this.has(key)) {
	        return notSetValue;
	      }
	      return this._object[key];
	    };
	
	    ObjectSeq.prototype.has = function(key) {
	      return this._object.hasOwnProperty(key);
	    };
	
	    ObjectSeq.prototype.__iterate = function(fn, reverse) {
	      var object = this._object;
	      var keys = this._keys;
	      var maxIndex = keys.length - 1;
	      for (var ii = 0; ii <= maxIndex; ii++) {
	        var key = keys[reverse ? maxIndex - ii : ii];
	        if (fn(object[key], key, this) === false) {
	          return ii + 1;
	        }
	      }
	      return ii;
	    };
	
	    ObjectSeq.prototype.__iterator = function(type, reverse) {
	      var object = this._object;
	      var keys = this._keys;
	      var maxIndex = keys.length - 1;
	      var ii = 0;
	      return new Iterator(function()  {
	        var key = keys[reverse ? maxIndex - ii : ii];
	        return ii++ > maxIndex ?
	          iteratorDone() :
	          iteratorValue(type, key, object[key]);
	      });
	    };
	
	  ObjectSeq.prototype[IS_ORDERED_SENTINEL] = true;
	
	
	  createClass(IterableSeq, IndexedSeq);
	    function IterableSeq(iterable) {
	      this._iterable = iterable;
	      this.size = iterable.length || iterable.size;
	    }
	
	    IterableSeq.prototype.__iterateUncached = function(fn, reverse) {
	      if (reverse) {
	        return this.cacheResult().__iterate(fn, reverse);
	      }
	      var iterable = this._iterable;
	      var iterator = getIterator(iterable);
	      var iterations = 0;
	      if (isIterator(iterator)) {
	        var step;
	        while (!(step = iterator.next()).done) {
	          if (fn(step.value, iterations++, this) === false) {
	            break;
	          }
	        }
	      }
	      return iterations;
	    };
	
	    IterableSeq.prototype.__iteratorUncached = function(type, reverse) {
	      if (reverse) {
	        return this.cacheResult().__iterator(type, reverse);
	      }
	      var iterable = this._iterable;
	      var iterator = getIterator(iterable);
	      if (!isIterator(iterator)) {
	        return new Iterator(iteratorDone);
	      }
	      var iterations = 0;
	      return new Iterator(function()  {
	        var step = iterator.next();
	        return step.done ? step : iteratorValue(type, iterations++, step.value);
	      });
	    };
	
	
	
	  createClass(IteratorSeq, IndexedSeq);
	    function IteratorSeq(iterator) {
	      this._iterator = iterator;
	      this._iteratorCache = [];
	    }
	
	    IteratorSeq.prototype.__iterateUncached = function(fn, reverse) {
	      if (reverse) {
	        return this.cacheResult().__iterate(fn, reverse);
	      }
	      var iterator = this._iterator;
	      var cache = this._iteratorCache;
	      var iterations = 0;
	      while (iterations < cache.length) {
	        if (fn(cache[iterations], iterations++, this) === false) {
	          return iterations;
	        }
	      }
	      var step;
	      while (!(step = iterator.next()).done) {
	        var val = step.value;
	        cache[iterations] = val;
	        if (fn(val, iterations++, this) === false) {
	          break;
	        }
	      }
	      return iterations;
	    };
	
	    IteratorSeq.prototype.__iteratorUncached = function(type, reverse) {
	      if (reverse) {
	        return this.cacheResult().__iterator(type, reverse);
	      }
	      var iterator = this._iterator;
	      var cache = this._iteratorCache;
	      var iterations = 0;
	      return new Iterator(function()  {
	        if (iterations >= cache.length) {
	          var step = iterator.next();
	          if (step.done) {
	            return step;
	          }
	          cache[iterations] = step.value;
	        }
	        return iteratorValue(type, iterations, cache[iterations++]);
	      });
	    };
	
	
	
	
	  // # pragma Helper functions
	
	  function isSeq(maybeSeq) {
	    return !!(maybeSeq && maybeSeq[IS_SEQ_SENTINEL]);
	  }
	
	  var EMPTY_SEQ;
	
	  function emptySequence() {
	    return EMPTY_SEQ || (EMPTY_SEQ = new ArraySeq([]));
	  }
	
	  function keyedSeqFromValue(value) {
	    var seq =
	      Array.isArray(value) ? new ArraySeq(value).fromEntrySeq() :
	      isIterator(value) ? new IteratorSeq(value).fromEntrySeq() :
	      hasIterator(value) ? new IterableSeq(value).fromEntrySeq() :
	      typeof value === 'object' ? new ObjectSeq(value) :
	      undefined;
	    if (!seq) {
	      throw new TypeError(
	        'Expected Array or iterable object of [k, v] entries, '+
	        'or keyed object: ' + value
	      );
	    }
	    return seq;
	  }
	
	  function indexedSeqFromValue(value) {
	    var seq = maybeIndexedSeqFromValue(value);
	    if (!seq) {
	      throw new TypeError(
	        'Expected Array or iterable object of values: ' + value
	      );
	    }
	    return seq;
	  }
	
	  function seqFromValue(value) {
	    var seq = maybeIndexedSeqFromValue(value) ||
	      (typeof value === 'object' && new ObjectSeq(value));
	    if (!seq) {
	      throw new TypeError(
	        'Expected Array or iterable object of values, or keyed object: ' + value
	      );
	    }
	    return seq;
	  }
	
	  function maybeIndexedSeqFromValue(value) {
	    return (
	      isArrayLike(value) ? new ArraySeq(value) :
	      isIterator(value) ? new IteratorSeq(value) :
	      hasIterator(value) ? new IterableSeq(value) :
	      undefined
	    );
	  }
	
	  function seqIterate(seq, fn, reverse, useKeys) {
	    var cache = seq._cache;
	    if (cache) {
	      var maxIndex = cache.length - 1;
	      for (var ii = 0; ii <= maxIndex; ii++) {
	        var entry = cache[reverse ? maxIndex - ii : ii];
	        if (fn(entry[1], useKeys ? entry[0] : ii, seq) === false) {
	          return ii + 1;
	        }
	      }
	      return ii;
	    }
	    return seq.__iterateUncached(fn, reverse);
	  }
	
	  function seqIterator(seq, type, reverse, useKeys) {
	    var cache = seq._cache;
	    if (cache) {
	      var maxIndex = cache.length - 1;
	      var ii = 0;
	      return new Iterator(function()  {
	        var entry = cache[reverse ? maxIndex - ii : ii];
	        return ii++ > maxIndex ?
	          iteratorDone() :
	          iteratorValue(type, useKeys ? entry[0] : ii - 1, entry[1]);
	      });
	    }
	    return seq.__iteratorUncached(type, reverse);
	  }
	
	  function fromJS(json, converter) {
	    return converter ?
	      fromJSWith(converter, json, '', {'': json}) :
	      fromJSDefault(json);
	  }
	
	  function fromJSWith(converter, json, key, parentJSON) {
	    if (Array.isArray(json)) {
	      return converter.call(parentJSON, key, IndexedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));
	    }
	    if (isPlainObj(json)) {
	      return converter.call(parentJSON, key, KeyedSeq(json).map(function(v, k)  {return fromJSWith(converter, v, k, json)}));
	    }
	    return json;
	  }
	
	  function fromJSDefault(json) {
	    if (Array.isArray(json)) {
	      return IndexedSeq(json).map(fromJSDefault).toList();
	    }
	    if (isPlainObj(json)) {
	      return KeyedSeq(json).map(fromJSDefault).toMap();
	    }
	    return json;
	  }
	
	  function isPlainObj(value) {
	    return value && (value.constructor === Object || value.constructor === undefined);
	  }
	
	  /**
	   * An extension of the "same-value" algorithm as [described for use by ES6 Map
	   * and Set](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#Key_equality)
	   *
	   * NaN is considered the same as NaN, however -0 and 0 are considered the same
	   * value, which is different from the algorithm described by
	   * [`Object.is`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is).
	   *
	   * This is extended further to allow Objects to describe the values they
	   * represent, by way of `valueOf` or `equals` (and `hashCode`).
	   *
	   * Note: because of this extension, the key equality of Immutable.Map and the
	   * value equality of Immutable.Set will differ from ES6 Map and Set.
	   *
	   * ### Defining custom values
	   *
	   * The easiest way to describe the value an object represents is by implementing
	   * `valueOf`. For example, `Date` represents a value by returning a unix
	   * timestamp for `valueOf`:
	   *
	   *     var date1 = new Date(1234567890000); // Fri Feb 13 2009 ...
	   *     var date2 = new Date(1234567890000);
	   *     date1.valueOf(); // 1234567890000
	   *     assert( date1 !== date2 );
	   *     assert( Immutable.is( date1, date2 ) );
	   *
	   * Note: overriding `valueOf` may have other implications if you use this object
	   * where JavaScript expects a primitive, such as implicit string coercion.
	   *
	   * For more complex types, especially collections, implementing `valueOf` may
	   * not be performant. An alternative is to implement `equals` and `hashCode`.
	   *
	   * `equals` takes another object, presumably of similar type, and returns true
	   * if the it is equal. Equality is symmetrical, so the same result should be
	   * returned if this and the argument are flipped.
	   *
	   *     assert( a.equals(b) === b.equals(a) );
	   *
	   * `hashCode` returns a 32bit integer number representing the object which will
	   * be used to determine how to store the value object in a Map or Set. You must
	   * provide both or neither methods, one must not exist without the other.
	   *
	   * Also, an important relationship between these methods must be upheld: if two
	   * values are equal, they *must* return the same hashCode. If the values are not
	   * equal, they might have the same hashCode; this is called a hash collision,
	   * and while undesirable for performance reasons, it is acceptable.
	   *
	   *     if (a.equals(b)) {
	   *       assert( a.hashCode() === b.hashCode() );
	   *     }
	   *
	   * All Immutable collections implement `equals` and `hashCode`.
	   *
	   */
	  function is(valueA, valueB) {
	    if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
	      return true;
	    }
	    if (!valueA || !valueB) {
	      return false;
	    }
	    if (typeof valueA.valueOf === 'function' &&
	        typeof valueB.valueOf === 'function') {
	      valueA = valueA.valueOf();
	      valueB = valueB.valueOf();
	      if (valueA === valueB || (valueA !== valueA && valueB !== valueB)) {
	        return true;
	      }
	      if (!valueA || !valueB) {
	        return false;
	      }
	    }
	    if (typeof valueA.equals === 'function' &&
	        typeof valueB.equals === 'function' &&
	        valueA.equals(valueB)) {
	      return true;
	    }
	    return false;
	  }
	
	  function deepEqual(a, b) {
	    if (a === b) {
	      return true;
	    }
	
	    if (
	      !isIterable(b) ||
	      a.size !== undefined && b.size !== undefined && a.size !== b.size ||
	      a.__hash !== undefined && b.__hash !== undefined && a.__hash !== b.__hash ||
	      isKeyed(a) !== isKeyed(b) ||
	      isIndexed(a) !== isIndexed(b) ||
	      isOrdered(a) !== isOrdered(b)
	    ) {
	      return false;
	    }
	
	    if (a.size === 0 && b.size === 0) {
	      return true;
	    }
	
	    var notAssociative = !isAssociative(a);
	
	    if (isOrdered(a)) {
	      var entries = a.entries();
	      return b.every(function(v, k)  {
	        var entry = entries.next().value;
	        return entry && is(entry[1], v) && (notAssociative || is(entry[0], k));
	      }) && entries.next().done;
	    }
	
	    var flipped = false;
	
	    if (a.size === undefined) {
	      if (b.size === undefined) {
	        if (typeof a.cacheResult === 'function') {
	          a.cacheResult();
	        }
	      } else {
	        flipped = true;
	        var _ = a;
	        a = b;
	        b = _;
	      }
	    }
	
	    var allEqual = true;
	    var bSize = b.__iterate(function(v, k)  {
	      if (notAssociative ? !a.has(v) :
	          flipped ? !is(v, a.get(k, NOT_SET)) : !is(a.get(k, NOT_SET), v)) {
	        allEqual = false;
	        return false;
	      }
	    });
	
	    return allEqual && a.size === bSize;
	  }
	
	  createClass(Repeat, IndexedSeq);
	
	    function Repeat(value, times) {
	      if (!(this instanceof Repeat)) {
	        return new Repeat(value, times);
	      }
	      this._value = value;
	      this.size = times === undefined ? Infinity : Math.max(0, times);
	      if (this.size === 0) {
	        if (EMPTY_REPEAT) {
	          return EMPTY_REPEAT;
	        }
	        EMPTY_REPEAT = this;
	      }
	    }
	
	    Repeat.prototype.toString = function() {
	      if (this.size === 0) {
	        return 'Repeat []';
	      }
	      return 'Repeat [ ' + this._value + ' ' + this.size + ' times ]';
	    };
	
	    Repeat.prototype.get = function(index, notSetValue) {
	      return this.has(index) ? this._value : notSetValue;
	    };
	
	    Repeat.prototype.includes = function(searchValue) {
	      return is(this._value, searchValue);
	    };
	
	    Repeat.prototype.slice = function(begin, end) {
	      var size = this.size;
	      return wholeSlice(begin, end, size) ? this :
	        new Repeat(this._value, resolveEnd(end, size) - resolveBegin(begin, size));
	    };
	
	    Repeat.prototype.reverse = function() {
	      return this;
	    };
	
	    Repeat.prototype.indexOf = function(searchValue) {
	      if (is(this._value, searchValue)) {
	        return 0;
	      }
	      return -1;
	    };
	
	    Repeat.prototype.lastIndexOf = function(searchValue) {
	      if (is(this._value, searchValue)) {
	        return this.size;
	      }
	      return -1;
	    };
	
	    Repeat.prototype.__iterate = function(fn, reverse) {
	      for (var ii = 0; ii < this.size; ii++) {
	        if (fn(this._value, ii, this) === false) {
	          return ii + 1;
	        }
	      }
	      return ii;
	    };
	
	    Repeat.prototype.__iterator = function(type, reverse) {var this$0 = this;
	      var ii = 0;
	      return new Iterator(function() 
	        {return ii < this$0.size ? iteratorValue(type, ii++, this$0._value) : iteratorDone()}
	      );
	    };
	
	    Repeat.prototype.equals = function(other) {
	      return other instanceof Repeat ?
	        is(this._value, other._value) :
	        deepEqual(other);
	    };
	
	
	  var EMPTY_REPEAT;
	
	  function invariant(condition, error) {
	    if (!condition) throw new Error(error);
	  }
	
	  createClass(Range, IndexedSeq);
	
	    function Range(start, end, step) {
	      if (!(this instanceof Range)) {
	        return new Range(start, end, step);
	      }
	      invariant(step !== 0, 'Cannot step a Range by 0');
	      start = start || 0;
	      if (end === undefined) {
	        end = Infinity;
	      }
	      step = step === undefined ? 1 : Math.abs(step);
	      if (end < start) {
	        step = -step;
	      }
	      this._start = start;
	      this._end = end;
	      this._step = step;
	      this.size = Math.max(0, Math.ceil((end - start) / step - 1) + 1);
	      if (this.size === 0) {
	        if (EMPTY_RANGE) {
	          return EMPTY_RANGE;
	        }
	        EMPTY_RANGE = this;
	      }
	    }
	
	    Range.prototype.toString = function() {
	      if (this.size === 0) {
	        return 'Range []';
	      }
	      return 'Range [ ' +
	        this._start + '...' + this._end +
	        (this._step > 1 ? ' by ' + this._step : '') +
	      ' ]';
	    };
	
	    Range.prototype.get = function(index, notSetValue) {
	      return this.has(index) ?
	        this._start + wrapIndex(this, index) * this._step :
	        notSetValue;
	    };
	
	    Range.prototype.includes = function(searchValue) {
	      var possibleIndex = (searchValue - this._start) / this._step;
	      return possibleIndex >= 0 &&
	        possibleIndex < this.size &&
	        possibleIndex === Math.floor(possibleIndex);
	    };
	
	    Range.prototype.slice = function(begin, end) {
	      if (wholeSlice(begin, end, this.size)) {
	        return this;
	      }
	      begin = resolveBegin(begin, this.size);
	      end = resolveEnd(end, this.size);
	      if (end <= begin) {
	        return new Range(0, 0);
	      }
	      return new Range(this.get(begin, this._end), this.get(end, this._end), this._step);
	    };
	
	    Range.prototype.indexOf = function(searchValue) {
	      var offsetValue = searchValue - this._start;
	      if (offsetValue % this._step === 0) {
	        var index = offsetValue / this._step;
	        if (index >= 0 && index < this.size) {
	          return index
	        }
	      }
	      return -1;
	    };
	
	    Range.prototype.lastIndexOf = function(searchValue) {
	      return this.indexOf(searchValue);
	    };
	
	    Range.prototype.__iterate = function(fn, reverse) {
	      var maxIndex = this.size - 1;
	      var step = this._step;
	      var value = reverse ? this._start + maxIndex * step : this._start;
	      for (var ii = 0; ii <= maxIndex; ii++) {
	        if (fn(value, ii, this) === false) {
	          return ii + 1;
	        }
	        value += reverse ? -step : step;
	      }
	      return ii;
	    };
	
	    Range.prototype.__iterator = function(type, reverse) {
	      var maxIndex = this.size - 1;
	      var step = this._step;
	      var value = reverse ? this._start + maxIndex * step : this._start;
	      var ii = 0;
	      return new Iterator(function()  {
	        var v = value;
	        value += reverse ? -step : step;
	        return ii > maxIndex ? iteratorDone() : iteratorValue(type, ii++, v);
	      });
	    };
	
	    Range.prototype.equals = function(other) {
	      return other instanceof Range ?
	        this._start === other._start &&
	        this._end === other._end &&
	        this._step === other._step :
	        deepEqual(this, other);
	    };
	
	
	  var EMPTY_RANGE;
	
	  createClass(Collection, Iterable);
	    function Collection() {
	      throw TypeError('Abstract');
	    }
	
	
	  createClass(KeyedCollection, Collection);function KeyedCollection() {}
	
	  createClass(IndexedCollection, Collection);function IndexedCollection() {}
	
	  createClass(SetCollection, Collection);function SetCollection() {}
	
	
	  Collection.Keyed = KeyedCollection;
	  Collection.Indexed = IndexedCollection;
	  Collection.Set = SetCollection;
	
	  var imul =
	    typeof Math.imul === 'function' && Math.imul(0xffffffff, 2) === -2 ?
	    Math.imul :
	    function imul(a, b) {
	      a = a | 0; // int
	      b = b | 0; // int
	      var c = a & 0xffff;
	      var d = b & 0xffff;
	      // Shift by 0 fixes the sign on the high part.
	      return (c * d) + ((((a >>> 16) * d + c * (b >>> 16)) << 16) >>> 0) | 0; // int
	    };
	
	  // v8 has an optimization for storing 31-bit signed numbers.
	  // Values which have either 00 or 11 as the high order bits qualify.
	  // This function drops the highest order bit in a signed number, maintaining
	  // the sign bit.
	  function smi(i32) {
	    return ((i32 >>> 1) & 0x40000000) | (i32 & 0xBFFFFFFF);
	  }
	
	  function hash(o) {
	    if (o === false || o === null || o === undefined) {
	      return 0;
	    }
	    if (typeof o.valueOf === 'function') {
	      o = o.valueOf();
	      if (o === false || o === null || o === undefined) {
	        return 0;
	      }
	    }
	    if (o === true) {
	      return 1;
	    }
	    var type = typeof o;
	    if (type === 'number') {
	      var h = o | 0;
	      if (h !== o) {
	        h ^= o * 0xFFFFFFFF;
	      }
	      while (o > 0xFFFFFFFF) {
	        o /= 0xFFFFFFFF;
	        h ^= o;
	      }
	      return smi(h);
	    }
	    if (type === 'string') {
	      return o.length > STRING_HASH_CACHE_MIN_STRLEN ? cachedHashString(o) : hashString(o);
	    }
	    if (typeof o.hashCode === 'function') {
	      return o.hashCode();
	    }
	    if (type === 'object') {
	      return hashJSObj(o);
	    }
	    if (typeof o.toString === 'function') {
	      return hashString(o.toString());
	    }
	    throw new Error('Value type ' + type + ' cannot be hashed.');
	  }
	
	  function cachedHashString(string) {
	    var hash = stringHashCache[string];
	    if (hash === undefined) {
	      hash = hashString(string);
	      if (STRING_HASH_CACHE_SIZE === STRING_HASH_CACHE_MAX_SIZE) {
	        STRING_HASH_CACHE_SIZE = 0;
	        stringHashCache = {};
	      }
	      STRING_HASH_CACHE_SIZE++;
	      stringHashCache[string] = hash;
	    }
	    return hash;
	  }
	
	  // http://jsperf.com/hashing-strings
	  function hashString(string) {
	    // This is the hash from JVM
	    // The hash code for a string is computed as
	    // s[0] * 31 ^ (n - 1) + s[1] * 31 ^ (n - 2) + ... + s[n - 1],
	    // where s[i] is the ith character of the string and n is the length of
	    // the string. We "mod" the result to make it between 0 (inclusive) and 2^31
	    // (exclusive) by dropping high bits.
	    var hash = 0;
	    for (var ii = 0; ii < string.length; ii++) {
	      hash = 31 * hash + string.charCodeAt(ii) | 0;
	    }
	    return smi(hash);
	  }
	
	  function hashJSObj(obj) {
	    var hash;
	    if (usingWeakMap) {
	      hash = weakMap.get(obj);
	      if (hash !== undefined) {
	        return hash;
	      }
	    }
	
	    hash = obj[UID_HASH_KEY];
	    if (hash !== undefined) {
	      return hash;
	    }
	
	    if (!canDefineProperty) {
	      hash = obj.propertyIsEnumerable && obj.propertyIsEnumerable[UID_HASH_KEY];
	      if (hash !== undefined) {
	        return hash;
	      }
	
	      hash = getIENodeHash(obj);
	      if (hash !== undefined) {
	        return hash;
	      }
	    }
	
	    hash = ++objHashUID;
	    if (objHashUID & 0x40000000) {
	      objHashUID = 0;
	    }
	
	    if (usingWeakMap) {
	      weakMap.set(obj, hash);
	    } else if (isExtensible !== undefined && isExtensible(obj) === false) {
	      throw new Error('Non-extensible objects are not allowed as keys.');
	    } else if (canDefineProperty) {
	      Object.defineProperty(obj, UID_HASH_KEY, {
	        'enumerable': false,
	        'configurable': false,
	        'writable': false,
	        'value': hash
	      });
	    } else if (obj.propertyIsEnumerable !== undefined &&
	               obj.propertyIsEnumerable === obj.constructor.prototype.propertyIsEnumerable) {
	      // Since we can't define a non-enumerable property on the object
	      // we'll hijack one of the less-used non-enumerable properties to
	      // save our hash on it. Since this is a function it will not show up in
	      // `JSON.stringify` which is what we want.
	      obj.propertyIsEnumerable = function() {
	        return this.constructor.prototype.propertyIsEnumerable.apply(this, arguments);
	      };
	      obj.propertyIsEnumerable[UID_HASH_KEY] = hash;
	    } else if (obj.nodeType !== undefined) {
	      // At this point we couldn't get the IE `uniqueID` to use as a hash
	      // and we couldn't use a non-enumerable property to exploit the
	      // dontEnum bug so we simply add the `UID_HASH_KEY` on the node
	      // itself.
	      obj[UID_HASH_KEY] = hash;
	    } else {
	      throw new Error('Unable to set a non-enumerable property on object.');
	    }
	
	    return hash;
	  }
	
	  // Get references to ES5 object methods.
	  var isExtensible = Object.isExtensible;
	
	  // True if Object.defineProperty works as expected. IE8 fails this test.
	  var canDefineProperty = (function() {
	    try {
	      Object.defineProperty({}, '@', {});
	      return true;
	    } catch (e) {
	      return false;
	    }
	  }());
	
	  // IE has a `uniqueID` property on DOM nodes. We can construct the hash from it
	  // and avoid memory leaks from the IE cloneNode bug.
	  function getIENodeHash(node) {
	    if (node && node.nodeType > 0) {
	      switch (node.nodeType) {
	        case 1: // Element
	          return node.uniqueID;
	        case 9: // Document
	          return node.documentElement && node.documentElement.uniqueID;
	      }
	    }
	  }
	
	  // If possible, use a WeakMap.
	  var usingWeakMap = typeof WeakMap === 'function';
	  var weakMap;
	  if (usingWeakMap) {
	    weakMap = new WeakMap();
	  }
	
	  var objHashUID = 0;
	
	  var UID_HASH_KEY = '__immutablehash__';
	  if (typeof Symbol === 'function') {
	    UID_HASH_KEY = Symbol(UID_HASH_KEY);
	  }
	
	  var STRING_HASH_CACHE_MIN_STRLEN = 16;
	  var STRING_HASH_CACHE_MAX_SIZE = 255;
	  var STRING_HASH_CACHE_SIZE = 0;
	  var stringHashCache = {};
	
	  function assertNotInfinite(size) {
	    invariant(
	      size !== Infinity,
	      'Cannot perform this action with an infinite size.'
	    );
	  }
	
	  createClass(Map, KeyedCollection);
	
	    // @pragma Construction
	
	    function Map(value) {
	      return value === null || value === undefined ? emptyMap() :
	        isMap(value) && !isOrdered(value) ? value :
	        emptyMap().withMutations(function(map ) {
	          var iter = KeyedIterable(value);
	          assertNotInfinite(iter.size);
	          iter.forEach(function(v, k)  {return map.set(k, v)});
	        });
	    }
	
	    Map.prototype.toString = function() {
	      return this.__toString('Map {', '}');
	    };
	
	    // @pragma Access
	
	    Map.prototype.get = function(k, notSetValue) {
	      return this._root ?
	        this._root.get(0, undefined, k, notSetValue) :
	        notSetValue;
	    };
	
	    // @pragma Modification
	
	    Map.prototype.set = function(k, v) {
	      return updateMap(this, k, v);
	    };
	
	    Map.prototype.setIn = function(keyPath, v) {
	      return this.updateIn(keyPath, NOT_SET, function()  {return v});
	    };
	
	    Map.prototype.remove = function(k) {
	      return updateMap(this, k, NOT_SET);
	    };
	
	    Map.prototype.deleteIn = function(keyPath) {
	      return this.updateIn(keyPath, function()  {return NOT_SET});
	    };
	
	    Map.prototype.update = function(k, notSetValue, updater) {
	      return arguments.length === 1 ?
	        k(this) :
	        this.updateIn([k], notSetValue, updater);
	    };
	
	    Map.prototype.updateIn = function(keyPath, notSetValue, updater) {
	      if (!updater) {
	        updater = notSetValue;
	        notSetValue = undefined;
	      }
	      var updatedValue = updateInDeepMap(
	        this,
	        forceIterator(keyPath),
	        notSetValue,
	        updater
	      );
	      return updatedValue === NOT_SET ? undefined : updatedValue;
	    };
	
	    Map.prototype.clear = function() {
	      if (this.size === 0) {
	        return this;
	      }
	      if (this.__ownerID) {
	        this.size = 0;
	        this._root = null;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return emptyMap();
	    };
	
	    // @pragma Composition
	
	    Map.prototype.merge = function(/*...iters*/) {
	      return mergeIntoMapWith(this, undefined, arguments);
	    };
	
	    Map.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
	      return mergeIntoMapWith(this, merger, iters);
	    };
	
	    Map.prototype.mergeIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);
	      return this.updateIn(
	        keyPath,
	        emptyMap(),
	        function(m ) {return typeof m.merge === 'function' ?
	          m.merge.apply(m, iters) :
	          iters[iters.length - 1]}
	      );
	    };
	
	    Map.prototype.mergeDeep = function(/*...iters*/) {
	      return mergeIntoMapWith(this, deepMerger, arguments);
	    };
	
	    Map.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
	      return mergeIntoMapWith(this, deepMergerWith(merger), iters);
	    };
	
	    Map.prototype.mergeDeepIn = function(keyPath) {var iters = SLICE$0.call(arguments, 1);
	      return this.updateIn(
	        keyPath,
	        emptyMap(),
	        function(m ) {return typeof m.mergeDeep === 'function' ?
	          m.mergeDeep.apply(m, iters) :
	          iters[iters.length - 1]}
	      );
	    };
	
	    Map.prototype.sort = function(comparator) {
	      // Late binding
	      return OrderedMap(sortFactory(this, comparator));
	    };
	
	    Map.prototype.sortBy = function(mapper, comparator) {
	      // Late binding
	      return OrderedMap(sortFactory(this, comparator, mapper));
	    };
	
	    // @pragma Mutability
	
	    Map.prototype.withMutations = function(fn) {
	      var mutable = this.asMutable();
	      fn(mutable);
	      return mutable.wasAltered() ? mutable.__ensureOwner(this.__ownerID) : this;
	    };
	
	    Map.prototype.asMutable = function() {
	      return this.__ownerID ? this : this.__ensureOwner(new OwnerID());
	    };
	
	    Map.prototype.asImmutable = function() {
	      return this.__ensureOwner();
	    };
	
	    Map.prototype.wasAltered = function() {
	      return this.__altered;
	    };
	
	    Map.prototype.__iterator = function(type, reverse) {
	      return new MapIterator(this, type, reverse);
	    };
	
	    Map.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      var iterations = 0;
	      this._root && this._root.iterate(function(entry ) {
	        iterations++;
	        return fn(entry[1], entry[0], this$0);
	      }, reverse);
	      return iterations;
	    };
	
	    Map.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        this.__altered = false;
	        return this;
	      }
	      return makeMap(this.size, this._root, ownerID, this.__hash);
	    };
	
	
	  function isMap(maybeMap) {
	    return !!(maybeMap && maybeMap[IS_MAP_SENTINEL]);
	  }
	
	  Map.isMap = isMap;
	
	  var IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
	
	  var MapPrototype = Map.prototype;
	  MapPrototype[IS_MAP_SENTINEL] = true;
	  MapPrototype[DELETE] = MapPrototype.remove;
	  MapPrototype.removeIn = MapPrototype.deleteIn;
	
	
	  // #pragma Trie Nodes
	
	
	
	    function ArrayMapNode(ownerID, entries) {
	      this.ownerID = ownerID;
	      this.entries = entries;
	    }
	
	    ArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {
	      var entries = this.entries;
	      for (var ii = 0, len = entries.length; ii < len; ii++) {
	        if (is(key, entries[ii][0])) {
	          return entries[ii][1];
	        }
	      }
	      return notSetValue;
	    };
	
	    ArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	      var removed = value === NOT_SET;
	
	      var entries = this.entries;
	      var idx = 0;
	      for (var len = entries.length; idx < len; idx++) {
	        if (is(key, entries[idx][0])) {
	          break;
	        }
	      }
	      var exists = idx < len;
	
	      if (exists ? entries[idx][1] === value : removed) {
	        return this;
	      }
	
	      SetRef(didAlter);
	      (removed || !exists) && SetRef(didChangeSize);
	
	      if (removed && entries.length === 1) {
	        return; // undefined
	      }
	
	      if (!exists && !removed && entries.length >= MAX_ARRAY_MAP_SIZE) {
	        return createNodes(ownerID, entries, key, value);
	      }
	
	      var isEditable = ownerID && ownerID === this.ownerID;
	      var newEntries = isEditable ? entries : arrCopy(entries);
	
	      if (exists) {
	        if (removed) {
	          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());
	        } else {
	          newEntries[idx] = [key, value];
	        }
	      } else {
	        newEntries.push([key, value]);
	      }
	
	      if (isEditable) {
	        this.entries = newEntries;
	        return this;
	      }
	
	      return new ArrayMapNode(ownerID, newEntries);
	    };
	
	
	
	
	    function BitmapIndexedNode(ownerID, bitmap, nodes) {
	      this.ownerID = ownerID;
	      this.bitmap = bitmap;
	      this.nodes = nodes;
	    }
	
	    BitmapIndexedNode.prototype.get = function(shift, keyHash, key, notSetValue) {
	      if (keyHash === undefined) {
	        keyHash = hash(key);
	      }
	      var bit = (1 << ((shift === 0 ? keyHash : keyHash >>> shift) & MASK));
	      var bitmap = this.bitmap;
	      return (bitmap & bit) === 0 ? notSetValue :
	        this.nodes[popCount(bitmap & (bit - 1))].get(shift + SHIFT, keyHash, key, notSetValue);
	    };
	
	    BitmapIndexedNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	      if (keyHash === undefined) {
	        keyHash = hash(key);
	      }
	      var keyHashFrag = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
	      var bit = 1 << keyHashFrag;
	      var bitmap = this.bitmap;
	      var exists = (bitmap & bit) !== 0;
	
	      if (!exists && value === NOT_SET) {
	        return this;
	      }
	
	      var idx = popCount(bitmap & (bit - 1));
	      var nodes = this.nodes;
	      var node = exists ? nodes[idx] : undefined;
	      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);
	
	      if (newNode === node) {
	        return this;
	      }
	
	      if (!exists && newNode && nodes.length >= MAX_BITMAP_INDEXED_SIZE) {
	        return expandNodes(ownerID, nodes, bitmap, keyHashFrag, newNode);
	      }
	
	      if (exists && !newNode && nodes.length === 2 && isLeafNode(nodes[idx ^ 1])) {
	        return nodes[idx ^ 1];
	      }
	
	      if (exists && newNode && nodes.length === 1 && isLeafNode(newNode)) {
	        return newNode;
	      }
	
	      var isEditable = ownerID && ownerID === this.ownerID;
	      var newBitmap = exists ? newNode ? bitmap : bitmap ^ bit : bitmap | bit;
	      var newNodes = exists ? newNode ?
	        setIn(nodes, idx, newNode, isEditable) :
	        spliceOut(nodes, idx, isEditable) :
	        spliceIn(nodes, idx, newNode, isEditable);
	
	      if (isEditable) {
	        this.bitmap = newBitmap;
	        this.nodes = newNodes;
	        return this;
	      }
	
	      return new BitmapIndexedNode(ownerID, newBitmap, newNodes);
	    };
	
	
	
	
	    function HashArrayMapNode(ownerID, count, nodes) {
	      this.ownerID = ownerID;
	      this.count = count;
	      this.nodes = nodes;
	    }
	
	    HashArrayMapNode.prototype.get = function(shift, keyHash, key, notSetValue) {
	      if (keyHash === undefined) {
	        keyHash = hash(key);
	      }
	      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
	      var node = this.nodes[idx];
	      return node ? node.get(shift + SHIFT, keyHash, key, notSetValue) : notSetValue;
	    };
	
	    HashArrayMapNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	      if (keyHash === undefined) {
	        keyHash = hash(key);
	      }
	      var idx = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
	      var removed = value === NOT_SET;
	      var nodes = this.nodes;
	      var node = nodes[idx];
	
	      if (removed && !node) {
	        return this;
	      }
	
	      var newNode = updateNode(node, ownerID, shift + SHIFT, keyHash, key, value, didChangeSize, didAlter);
	      if (newNode === node) {
	        return this;
	      }
	
	      var newCount = this.count;
	      if (!node) {
	        newCount++;
	      } else if (!newNode) {
	        newCount--;
	        if (newCount < MIN_HASH_ARRAY_MAP_SIZE) {
	          return packNodes(ownerID, nodes, newCount, idx);
	        }
	      }
	
	      var isEditable = ownerID && ownerID === this.ownerID;
	      var newNodes = setIn(nodes, idx, newNode, isEditable);
	
	      if (isEditable) {
	        this.count = newCount;
	        this.nodes = newNodes;
	        return this;
	      }
	
	      return new HashArrayMapNode(ownerID, newCount, newNodes);
	    };
	
	
	
	
	    function HashCollisionNode(ownerID, keyHash, entries) {
	      this.ownerID = ownerID;
	      this.keyHash = keyHash;
	      this.entries = entries;
	    }
	
	    HashCollisionNode.prototype.get = function(shift, keyHash, key, notSetValue) {
	      var entries = this.entries;
	      for (var ii = 0, len = entries.length; ii < len; ii++) {
	        if (is(key, entries[ii][0])) {
	          return entries[ii][1];
	        }
	      }
	      return notSetValue;
	    };
	
	    HashCollisionNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	      if (keyHash === undefined) {
	        keyHash = hash(key);
	      }
	
	      var removed = value === NOT_SET;
	
	      if (keyHash !== this.keyHash) {
	        if (removed) {
	          return this;
	        }
	        SetRef(didAlter);
	        SetRef(didChangeSize);
	        return mergeIntoNode(this, ownerID, shift, keyHash, [key, value]);
	      }
	
	      var entries = this.entries;
	      var idx = 0;
	      for (var len = entries.length; idx < len; idx++) {
	        if (is(key, entries[idx][0])) {
	          break;
	        }
	      }
	      var exists = idx < len;
	
	      if (exists ? entries[idx][1] === value : removed) {
	        return this;
	      }
	
	      SetRef(didAlter);
	      (removed || !exists) && SetRef(didChangeSize);
	
	      if (removed && len === 2) {
	        return new ValueNode(ownerID, this.keyHash, entries[idx ^ 1]);
	      }
	
	      var isEditable = ownerID && ownerID === this.ownerID;
	      var newEntries = isEditable ? entries : arrCopy(entries);
	
	      if (exists) {
	        if (removed) {
	          idx === len - 1 ? newEntries.pop() : (newEntries[idx] = newEntries.pop());
	        } else {
	          newEntries[idx] = [key, value];
	        }
	      } else {
	        newEntries.push([key, value]);
	      }
	
	      if (isEditable) {
	        this.entries = newEntries;
	        return this;
	      }
	
	      return new HashCollisionNode(ownerID, this.keyHash, newEntries);
	    };
	
	
	
	
	    function ValueNode(ownerID, keyHash, entry) {
	      this.ownerID = ownerID;
	      this.keyHash = keyHash;
	      this.entry = entry;
	    }
	
	    ValueNode.prototype.get = function(shift, keyHash, key, notSetValue) {
	      return is(key, this.entry[0]) ? this.entry[1] : notSetValue;
	    };
	
	    ValueNode.prototype.update = function(ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	      var removed = value === NOT_SET;
	      var keyMatch = is(key, this.entry[0]);
	      if (keyMatch ? value === this.entry[1] : removed) {
	        return this;
	      }
	
	      SetRef(didAlter);
	
	      if (removed) {
	        SetRef(didChangeSize);
	        return; // undefined
	      }
	
	      if (keyMatch) {
	        if (ownerID && ownerID === this.ownerID) {
	          this.entry[1] = value;
	          return this;
	        }
	        return new ValueNode(ownerID, this.keyHash, [key, value]);
	      }
	
	      SetRef(didChangeSize);
	      return mergeIntoNode(this, ownerID, shift, hash(key), [key, value]);
	    };
	
	
	
	  // #pragma Iterators
	
	  ArrayMapNode.prototype.iterate =
	  HashCollisionNode.prototype.iterate = function (fn, reverse) {
	    var entries = this.entries;
	    for (var ii = 0, maxIndex = entries.length - 1; ii <= maxIndex; ii++) {
	      if (fn(entries[reverse ? maxIndex - ii : ii]) === false) {
	        return false;
	      }
	    }
	  }
	
	  BitmapIndexedNode.prototype.iterate =
	  HashArrayMapNode.prototype.iterate = function (fn, reverse) {
	    var nodes = this.nodes;
	    for (var ii = 0, maxIndex = nodes.length - 1; ii <= maxIndex; ii++) {
	      var node = nodes[reverse ? maxIndex - ii : ii];
	      if (node && node.iterate(fn, reverse) === false) {
	        return false;
	      }
	    }
	  }
	
	  ValueNode.prototype.iterate = function (fn, reverse) {
	    return fn(this.entry);
	  }
	
	  createClass(MapIterator, Iterator);
	
	    function MapIterator(map, type, reverse) {
	      this._type = type;
	      this._reverse = reverse;
	      this._stack = map._root && mapIteratorFrame(map._root);
	    }
	
	    MapIterator.prototype.next = function() {
	      var type = this._type;
	      var stack = this._stack;
	      while (stack) {
	        var node = stack.node;
	        var index = stack.index++;
	        var maxIndex;
	        if (node.entry) {
	          if (index === 0) {
	            return mapIteratorValue(type, node.entry);
	          }
	        } else if (node.entries) {
	          maxIndex = node.entries.length - 1;
	          if (index <= maxIndex) {
	            return mapIteratorValue(type, node.entries[this._reverse ? maxIndex - index : index]);
	          }
	        } else {
	          maxIndex = node.nodes.length - 1;
	          if (index <= maxIndex) {
	            var subNode = node.nodes[this._reverse ? maxIndex - index : index];
	            if (subNode) {
	              if (subNode.entry) {
	                return mapIteratorValue(type, subNode.entry);
	              }
	              stack = this._stack = mapIteratorFrame(subNode, stack);
	            }
	            continue;
	          }
	        }
	        stack = this._stack = this._stack.__prev;
	      }
	      return iteratorDone();
	    };
	
	
	  function mapIteratorValue(type, entry) {
	    return iteratorValue(type, entry[0], entry[1]);
	  }
	
	  function mapIteratorFrame(node, prev) {
	    return {
	      node: node,
	      index: 0,
	      __prev: prev
	    };
	  }
	
	  function makeMap(size, root, ownerID, hash) {
	    var map = Object.create(MapPrototype);
	    map.size = size;
	    map._root = root;
	    map.__ownerID = ownerID;
	    map.__hash = hash;
	    map.__altered = false;
	    return map;
	  }
	
	  var EMPTY_MAP;
	  function emptyMap() {
	    return EMPTY_MAP || (EMPTY_MAP = makeMap(0));
	  }
	
	  function updateMap(map, k, v) {
	    var newRoot;
	    var newSize;
	    if (!map._root) {
	      if (v === NOT_SET) {
	        return map;
	      }
	      newSize = 1;
	      newRoot = new ArrayMapNode(map.__ownerID, [[k, v]]);
	    } else {
	      var didChangeSize = MakeRef(CHANGE_LENGTH);
	      var didAlter = MakeRef(DID_ALTER);
	      newRoot = updateNode(map._root, map.__ownerID, 0, undefined, k, v, didChangeSize, didAlter);
	      if (!didAlter.value) {
	        return map;
	      }
	      newSize = map.size + (didChangeSize.value ? v === NOT_SET ? -1 : 1 : 0);
	    }
	    if (map.__ownerID) {
	      map.size = newSize;
	      map._root = newRoot;
	      map.__hash = undefined;
	      map.__altered = true;
	      return map;
	    }
	    return newRoot ? makeMap(newSize, newRoot) : emptyMap();
	  }
	
	  function updateNode(node, ownerID, shift, keyHash, key, value, didChangeSize, didAlter) {
	    if (!node) {
	      if (value === NOT_SET) {
	        return node;
	      }
	      SetRef(didAlter);
	      SetRef(didChangeSize);
	      return new ValueNode(ownerID, keyHash, [key, value]);
	    }
	    return node.update(ownerID, shift, keyHash, key, value, didChangeSize, didAlter);
	  }
	
	  function isLeafNode(node) {
	    return node.constructor === ValueNode || node.constructor === HashCollisionNode;
	  }
	
	  function mergeIntoNode(node, ownerID, shift, keyHash, entry) {
	    if (node.keyHash === keyHash) {
	      return new HashCollisionNode(ownerID, keyHash, [node.entry, entry]);
	    }
	
	    var idx1 = (shift === 0 ? node.keyHash : node.keyHash >>> shift) & MASK;
	    var idx2 = (shift === 0 ? keyHash : keyHash >>> shift) & MASK;
	
	    var newNode;
	    var nodes = idx1 === idx2 ?
	      [mergeIntoNode(node, ownerID, shift + SHIFT, keyHash, entry)] :
	      ((newNode = new ValueNode(ownerID, keyHash, entry)), idx1 < idx2 ? [node, newNode] : [newNode, node]);
	
	    return new BitmapIndexedNode(ownerID, (1 << idx1) | (1 << idx2), nodes);
	  }
	
	  function createNodes(ownerID, entries, key, value) {
	    if (!ownerID) {
	      ownerID = new OwnerID();
	    }
	    var node = new ValueNode(ownerID, hash(key), [key, value]);
	    for (var ii = 0; ii < entries.length; ii++) {
	      var entry = entries[ii];
	      node = node.update(ownerID, 0, undefined, entry[0], entry[1]);
	    }
	    return node;
	  }
	
	  function packNodes(ownerID, nodes, count, excluding) {
	    var bitmap = 0;
	    var packedII = 0;
	    var packedNodes = new Array(count);
	    for (var ii = 0, bit = 1, len = nodes.length; ii < len; ii++, bit <<= 1) {
	      var node = nodes[ii];
	      if (node !== undefined && ii !== excluding) {
	        bitmap |= bit;
	        packedNodes[packedII++] = node;
	      }
	    }
	    return new BitmapIndexedNode(ownerID, bitmap, packedNodes);
	  }
	
	  function expandNodes(ownerID, nodes, bitmap, including, node) {
	    var count = 0;
	    var expandedNodes = new Array(SIZE);
	    for (var ii = 0; bitmap !== 0; ii++, bitmap >>>= 1) {
	      expandedNodes[ii] = bitmap & 1 ? nodes[count++] : undefined;
	    }
	    expandedNodes[including] = node;
	    return new HashArrayMapNode(ownerID, count + 1, expandedNodes);
	  }
	
	  function mergeIntoMapWith(map, merger, iterables) {
	    var iters = [];
	    for (var ii = 0; ii < iterables.length; ii++) {
	      var value = iterables[ii];
	      var iter = KeyedIterable(value);
	      if (!isIterable(value)) {
	        iter = iter.map(function(v ) {return fromJS(v)});
	      }
	      iters.push(iter);
	    }
	    return mergeIntoCollectionWith(map, merger, iters);
	  }
	
	  function deepMerger(existing, value, key) {
	    return existing && existing.mergeDeep && isIterable(value) ?
	      existing.mergeDeep(value) :
	      is(existing, value) ? existing : value;
	  }
	
	  function deepMergerWith(merger) {
	    return function(existing, value, key)  {
	      if (existing && existing.mergeDeepWith && isIterable(value)) {
	        return existing.mergeDeepWith(merger, value);
	      }
	      var nextValue = merger(existing, value, key);
	      return is(existing, nextValue) ? existing : nextValue;
	    };
	  }
	
	  function mergeIntoCollectionWith(collection, merger, iters) {
	    iters = iters.filter(function(x ) {return x.size !== 0});
	    if (iters.length === 0) {
	      return collection;
	    }
	    if (collection.size === 0 && !collection.__ownerID && iters.length === 1) {
	      return collection.constructor(iters[0]);
	    }
	    return collection.withMutations(function(collection ) {
	      var mergeIntoMap = merger ?
	        function(value, key)  {
	          collection.update(key, NOT_SET, function(existing )
	            {return existing === NOT_SET ? value : merger(existing, value, key)}
	          );
	        } :
	        function(value, key)  {
	          collection.set(key, value);
	        }
	      for (var ii = 0; ii < iters.length; ii++) {
	        iters[ii].forEach(mergeIntoMap);
	      }
	    });
	  }
	
	  function updateInDeepMap(existing, keyPathIter, notSetValue, updater) {
	    var isNotSet = existing === NOT_SET;
	    var step = keyPathIter.next();
	    if (step.done) {
	      var existingValue = isNotSet ? notSetValue : existing;
	      var newValue = updater(existingValue);
	      return newValue === existingValue ? existing : newValue;
	    }
	    invariant(
	      isNotSet || (existing && existing.set),
	      'invalid keyPath'
	    );
	    var key = step.value;
	    var nextExisting = isNotSet ? NOT_SET : existing.get(key, NOT_SET);
	    var nextUpdated = updateInDeepMap(
	      nextExisting,
	      keyPathIter,
	      notSetValue,
	      updater
	    );
	    return nextUpdated === nextExisting ? existing :
	      nextUpdated === NOT_SET ? existing.remove(key) :
	      (isNotSet ? emptyMap() : existing).set(key, nextUpdated);
	  }
	
	  function popCount(x) {
	    x = x - ((x >> 1) & 0x55555555);
	    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
	    x = (x + (x >> 4)) & 0x0f0f0f0f;
	    x = x + (x >> 8);
	    x = x + (x >> 16);
	    return x & 0x7f;
	  }
	
	  function setIn(array, idx, val, canEdit) {
	    var newArray = canEdit ? array : arrCopy(array);
	    newArray[idx] = val;
	    return newArray;
	  }
	
	  function spliceIn(array, idx, val, canEdit) {
	    var newLen = array.length + 1;
	    if (canEdit && idx + 1 === newLen) {
	      array[idx] = val;
	      return array;
	    }
	    var newArray = new Array(newLen);
	    var after = 0;
	    for (var ii = 0; ii < newLen; ii++) {
	      if (ii === idx) {
	        newArray[ii] = val;
	        after = -1;
	      } else {
	        newArray[ii] = array[ii + after];
	      }
	    }
	    return newArray;
	  }
	
	  function spliceOut(array, idx, canEdit) {
	    var newLen = array.length - 1;
	    if (canEdit && idx === newLen) {
	      array.pop();
	      return array;
	    }
	    var newArray = new Array(newLen);
	    var after = 0;
	    for (var ii = 0; ii < newLen; ii++) {
	      if (ii === idx) {
	        after = 1;
	      }
	      newArray[ii] = array[ii + after];
	    }
	    return newArray;
	  }
	
	  var MAX_ARRAY_MAP_SIZE = SIZE / 4;
	  var MAX_BITMAP_INDEXED_SIZE = SIZE / 2;
	  var MIN_HASH_ARRAY_MAP_SIZE = SIZE / 4;
	
	  createClass(List, IndexedCollection);
	
	    // @pragma Construction
	
	    function List(value) {
	      var empty = emptyList();
	      if (value === null || value === undefined) {
	        return empty;
	      }
	      if (isList(value)) {
	        return value;
	      }
	      var iter = IndexedIterable(value);
	      var size = iter.size;
	      if (size === 0) {
	        return empty;
	      }
	      assertNotInfinite(size);
	      if (size > 0 && size < SIZE) {
	        return makeList(0, size, SHIFT, null, new VNode(iter.toArray()));
	      }
	      return empty.withMutations(function(list ) {
	        list.setSize(size);
	        iter.forEach(function(v, i)  {return list.set(i, v)});
	      });
	    }
	
	    List.of = function(/*...values*/) {
	      return this(arguments);
	    };
	
	    List.prototype.toString = function() {
	      return this.__toString('List [', ']');
	    };
	
	    // @pragma Access
	
	    List.prototype.get = function(index, notSetValue) {
	      index = wrapIndex(this, index);
	      if (index >= 0 && index < this.size) {
	        index += this._origin;
	        var node = listNodeFor(this, index);
	        return node && node.array[index & MASK];
	      }
	      return notSetValue;
	    };
	
	    // @pragma Modification
	
	    List.prototype.set = function(index, value) {
	      return updateList(this, index, value);
	    };
	
	    List.prototype.remove = function(index) {
	      return !this.has(index) ? this :
	        index === 0 ? this.shift() :
	        index === this.size - 1 ? this.pop() :
	        this.splice(index, 1);
	    };
	
	    List.prototype.insert = function(index, value) {
	      return this.splice(index, 0, value);
	    };
	
	    List.prototype.clear = function() {
	      if (this.size === 0) {
	        return this;
	      }
	      if (this.__ownerID) {
	        this.size = this._origin = this._capacity = 0;
	        this._level = SHIFT;
	        this._root = this._tail = null;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return emptyList();
	    };
	
	    List.prototype.push = function(/*...values*/) {
	      var values = arguments;
	      var oldSize = this.size;
	      return this.withMutations(function(list ) {
	        setListBounds(list, 0, oldSize + values.length);
	        for (var ii = 0; ii < values.length; ii++) {
	          list.set(oldSize + ii, values[ii]);
	        }
	      });
	    };
	
	    List.prototype.pop = function() {
	      return setListBounds(this, 0, -1);
	    };
	
	    List.prototype.unshift = function(/*...values*/) {
	      var values = arguments;
	      return this.withMutations(function(list ) {
	        setListBounds(list, -values.length);
	        for (var ii = 0; ii < values.length; ii++) {
	          list.set(ii, values[ii]);
	        }
	      });
	    };
	
	    List.prototype.shift = function() {
	      return setListBounds(this, 1);
	    };
	
	    // @pragma Composition
	
	    List.prototype.merge = function(/*...iters*/) {
	      return mergeIntoListWith(this, undefined, arguments);
	    };
	
	    List.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
	      return mergeIntoListWith(this, merger, iters);
	    };
	
	    List.prototype.mergeDeep = function(/*...iters*/) {
	      return mergeIntoListWith(this, deepMerger, arguments);
	    };
	
	    List.prototype.mergeDeepWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
	      return mergeIntoListWith(this, deepMergerWith(merger), iters);
	    };
	
	    List.prototype.setSize = function(size) {
	      return setListBounds(this, 0, size);
	    };
	
	    // @pragma Iteration
	
	    List.prototype.slice = function(begin, end) {
	      var size = this.size;
	      if (wholeSlice(begin, end, size)) {
	        return this;
	      }
	      return setListBounds(
	        this,
	        resolveBegin(begin, size),
	        resolveEnd(end, size)
	      );
	    };
	
	    List.prototype.__iterator = function(type, reverse) {
	      var index = 0;
	      var values = iterateList(this, reverse);
	      return new Iterator(function()  {
	        var value = values();
	        return value === DONE ?
	          iteratorDone() :
	          iteratorValue(type, index++, value);
	      });
	    };
	
	    List.prototype.__iterate = function(fn, reverse) {
	      var index = 0;
	      var values = iterateList(this, reverse);
	      var value;
	      while ((value = values()) !== DONE) {
	        if (fn(value, index++, this) === false) {
	          break;
	        }
	      }
	      return index;
	    };
	
	    List.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        return this;
	      }
	      return makeList(this._origin, this._capacity, this._level, this._root, this._tail, ownerID, this.__hash);
	    };
	
	
	  function isList(maybeList) {
	    return !!(maybeList && maybeList[IS_LIST_SENTINEL]);
	  }
	
	  List.isList = isList;
	
	  var IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
	
	  var ListPrototype = List.prototype;
	  ListPrototype[IS_LIST_SENTINEL] = true;
	  ListPrototype[DELETE] = ListPrototype.remove;
	  ListPrototype.setIn = MapPrototype.setIn;
	  ListPrototype.deleteIn =
	  ListPrototype.removeIn = MapPrototype.removeIn;
	  ListPrototype.update = MapPrototype.update;
	  ListPrototype.updateIn = MapPrototype.updateIn;
	  ListPrototype.mergeIn = MapPrototype.mergeIn;
	  ListPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
	  ListPrototype.withMutations = MapPrototype.withMutations;
	  ListPrototype.asMutable = MapPrototype.asMutable;
	  ListPrototype.asImmutable = MapPrototype.asImmutable;
	  ListPrototype.wasAltered = MapPrototype.wasAltered;
	
	
	
	    function VNode(array, ownerID) {
	      this.array = array;
	      this.ownerID = ownerID;
	    }
	
	    // TODO: seems like these methods are very similar
	
	    VNode.prototype.removeBefore = function(ownerID, level, index) {
	      if (index === level ? 1 << level : 0 || this.array.length === 0) {
	        return this;
	      }
	      var originIndex = (index >>> level) & MASK;
	      if (originIndex >= this.array.length) {
	        return new VNode([], ownerID);
	      }
	      var removingFirst = originIndex === 0;
	      var newChild;
	      if (level > 0) {
	        var oldChild = this.array[originIndex];
	        newChild = oldChild && oldChild.removeBefore(ownerID, level - SHIFT, index);
	        if (newChild === oldChild && removingFirst) {
	          return this;
	        }
	      }
	      if (removingFirst && !newChild) {
	        return this;
	      }
	      var editable = editableVNode(this, ownerID);
	      if (!removingFirst) {
	        for (var ii = 0; ii < originIndex; ii++) {
	          editable.array[ii] = undefined;
	        }
	      }
	      if (newChild) {
	        editable.array[originIndex] = newChild;
	      }
	      return editable;
	    };
	
	    VNode.prototype.removeAfter = function(ownerID, level, index) {
	      if (index === (level ? 1 << level : 0) || this.array.length === 0) {
	        return this;
	      }
	      var sizeIndex = ((index - 1) >>> level) & MASK;
	      if (sizeIndex >= this.array.length) {
	        return this;
	      }
	
	      var newChild;
	      if (level > 0) {
	        var oldChild = this.array[sizeIndex];
	        newChild = oldChild && oldChild.removeAfter(ownerID, level - SHIFT, index);
	        if (newChild === oldChild && sizeIndex === this.array.length - 1) {
	          return this;
	        }
	      }
	
	      var editable = editableVNode(this, ownerID);
	      editable.array.splice(sizeIndex + 1);
	      if (newChild) {
	        editable.array[sizeIndex] = newChild;
	      }
	      return editable;
	    };
	
	
	
	  var DONE = {};
	
	  function iterateList(list, reverse) {
	    var left = list._origin;
	    var right = list._capacity;
	    var tailPos = getTailOffset(right);
	    var tail = list._tail;
	
	    return iterateNodeOrLeaf(list._root, list._level, 0);
	
	    function iterateNodeOrLeaf(node, level, offset) {
	      return level === 0 ?
	        iterateLeaf(node, offset) :
	        iterateNode(node, level, offset);
	    }
	
	    function iterateLeaf(node, offset) {
	      var array = offset === tailPos ? tail && tail.array : node && node.array;
	      var from = offset > left ? 0 : left - offset;
	      var to = right - offset;
	      if (to > SIZE) {
	        to = SIZE;
	      }
	      return function()  {
	        if (from === to) {
	          return DONE;
	        }
	        var idx = reverse ? --to : from++;
	        return array && array[idx];
	      };
	    }
	
	    function iterateNode(node, level, offset) {
	      var values;
	      var array = node && node.array;
	      var from = offset > left ? 0 : (left - offset) >> level;
	      var to = ((right - offset) >> level) + 1;
	      if (to > SIZE) {
	        to = SIZE;
	      }
	      return function()  {
	        do {
	          if (values) {
	            var value = values();
	            if (value !== DONE) {
	              return value;
	            }
	            values = null;
	          }
	          if (from === to) {
	            return DONE;
	          }
	          var idx = reverse ? --to : from++;
	          values = iterateNodeOrLeaf(
	            array && array[idx], level - SHIFT, offset + (idx << level)
	          );
	        } while (true);
	      };
	    }
	  }
	
	  function makeList(origin, capacity, level, root, tail, ownerID, hash) {
	    var list = Object.create(ListPrototype);
	    list.size = capacity - origin;
	    list._origin = origin;
	    list._capacity = capacity;
	    list._level = level;
	    list._root = root;
	    list._tail = tail;
	    list.__ownerID = ownerID;
	    list.__hash = hash;
	    list.__altered = false;
	    return list;
	  }
	
	  var EMPTY_LIST;
	  function emptyList() {
	    return EMPTY_LIST || (EMPTY_LIST = makeList(0, 0, SHIFT));
	  }
	
	  function updateList(list, index, value) {
	    index = wrapIndex(list, index);
	
	    if (index !== index) {
	      return list;
	    }
	
	    if (index >= list.size || index < 0) {
	      return list.withMutations(function(list ) {
	        index < 0 ?
	          setListBounds(list, index).set(0, value) :
	          setListBounds(list, 0, index + 1).set(index, value)
	      });
	    }
	
	    index += list._origin;
	
	    var newTail = list._tail;
	    var newRoot = list._root;
	    var didAlter = MakeRef(DID_ALTER);
	    if (index >= getTailOffset(list._capacity)) {
	      newTail = updateVNode(newTail, list.__ownerID, 0, index, value, didAlter);
	    } else {
	      newRoot = updateVNode(newRoot, list.__ownerID, list._level, index, value, didAlter);
	    }
	
	    if (!didAlter.value) {
	      return list;
	    }
	
	    if (list.__ownerID) {
	      list._root = newRoot;
	      list._tail = newTail;
	      list.__hash = undefined;
	      list.__altered = true;
	      return list;
	    }
	    return makeList(list._origin, list._capacity, list._level, newRoot, newTail);
	  }
	
	  function updateVNode(node, ownerID, level, index, value, didAlter) {
	    var idx = (index >>> level) & MASK;
	    var nodeHas = node && idx < node.array.length;
	    if (!nodeHas && value === undefined) {
	      return node;
	    }
	
	    var newNode;
	
	    if (level > 0) {
	      var lowerNode = node && node.array[idx];
	      var newLowerNode = updateVNode(lowerNode, ownerID, level - SHIFT, index, value, didAlter);
	      if (newLowerNode === lowerNode) {
	        return node;
	      }
	      newNode = editableVNode(node, ownerID);
	      newNode.array[idx] = newLowerNode;
	      return newNode;
	    }
	
	    if (nodeHas && node.array[idx] === value) {
	      return node;
	    }
	
	    SetRef(didAlter);
	
	    newNode = editableVNode(node, ownerID);
	    if (value === undefined && idx === newNode.array.length - 1) {
	      newNode.array.pop();
	    } else {
	      newNode.array[idx] = value;
	    }
	    return newNode;
	  }
	
	  function editableVNode(node, ownerID) {
	    if (ownerID && node && ownerID === node.ownerID) {
	      return node;
	    }
	    return new VNode(node ? node.array.slice() : [], ownerID);
	  }
	
	  function listNodeFor(list, rawIndex) {
	    if (rawIndex >= getTailOffset(list._capacity)) {
	      return list._tail;
	    }
	    if (rawIndex < 1 << (list._level + SHIFT)) {
	      var node = list._root;
	      var level = list._level;
	      while (node && level > 0) {
	        node = node.array[(rawIndex >>> level) & MASK];
	        level -= SHIFT;
	      }
	      return node;
	    }
	  }
	
	  function setListBounds(list, begin, end) {
	    // Sanitize begin & end using this shorthand for ToInt32(argument)
	    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
	    if (begin !== undefined) {
	      begin = begin | 0;
	    }
	    if (end !== undefined) {
	      end = end | 0;
	    }
	    var owner = list.__ownerID || new OwnerID();
	    var oldOrigin = list._origin;
	    var oldCapacity = list._capacity;
	    var newOrigin = oldOrigin + begin;
	    var newCapacity = end === undefined ? oldCapacity : end < 0 ? oldCapacity + end : oldOrigin + end;
	    if (newOrigin === oldOrigin && newCapacity === oldCapacity) {
	      return list;
	    }
	
	    // If it's going to end after it starts, it's empty.
	    if (newOrigin >= newCapacity) {
	      return list.clear();
	    }
	
	    var newLevel = list._level;
	    var newRoot = list._root;
	
	    // New origin might need creating a higher root.
	    var offsetShift = 0;
	    while (newOrigin + offsetShift < 0) {
	      newRoot = new VNode(newRoot && newRoot.array.length ? [undefined, newRoot] : [], owner);
	      newLevel += SHIFT;
	      offsetShift += 1 << newLevel;
	    }
	    if (offsetShift) {
	      newOrigin += offsetShift;
	      oldOrigin += offsetShift;
	      newCapacity += offsetShift;
	      oldCapacity += offsetShift;
	    }
	
	    var oldTailOffset = getTailOffset(oldCapacity);
	    var newTailOffset = getTailOffset(newCapacity);
	
	    // New size might need creating a higher root.
	    while (newTailOffset >= 1 << (newLevel + SHIFT)) {
	      newRoot = new VNode(newRoot && newRoot.array.length ? [newRoot] : [], owner);
	      newLevel += SHIFT;
	    }
	
	    // Locate or create the new tail.
	    var oldTail = list._tail;
	    var newTail = newTailOffset < oldTailOffset ?
	      listNodeFor(list, newCapacity - 1) :
	      newTailOffset > oldTailOffset ? new VNode([], owner) : oldTail;
	
	    // Merge Tail into tree.
	    if (oldTail && newTailOffset > oldTailOffset && newOrigin < oldCapacity && oldTail.array.length) {
	      newRoot = editableVNode(newRoot, owner);
	      var node = newRoot;
	      for (var level = newLevel; level > SHIFT; level -= SHIFT) {
	        var idx = (oldTailOffset >>> level) & MASK;
	        node = node.array[idx] = editableVNode(node.array[idx], owner);
	      }
	      node.array[(oldTailOffset >>> SHIFT) & MASK] = oldTail;
	    }
	
	    // If the size has been reduced, there's a chance the tail needs to be trimmed.
	    if (newCapacity < oldCapacity) {
	      newTail = newTail && newTail.removeAfter(owner, 0, newCapacity);
	    }
	
	    // If the new origin is within the tail, then we do not need a root.
	    if (newOrigin >= newTailOffset) {
	      newOrigin -= newTailOffset;
	      newCapacity -= newTailOffset;
	      newLevel = SHIFT;
	      newRoot = null;
	      newTail = newTail && newTail.removeBefore(owner, 0, newOrigin);
	
	    // Otherwise, if the root has been trimmed, garbage collect.
	    } else if (newOrigin > oldOrigin || newTailOffset < oldTailOffset) {
	      offsetShift = 0;
	
	      // Identify the new top root node of the subtree of the old root.
	      while (newRoot) {
	        var beginIndex = (newOrigin >>> newLevel) & MASK;
	        if (beginIndex !== (newTailOffset >>> newLevel) & MASK) {
	          break;
	        }
	        if (beginIndex) {
	          offsetShift += (1 << newLevel) * beginIndex;
	        }
	        newLevel -= SHIFT;
	        newRoot = newRoot.array[beginIndex];
	      }
	
	      // Trim the new sides of the new root.
	      if (newRoot && newOrigin > oldOrigin) {
	        newRoot = newRoot.removeBefore(owner, newLevel, newOrigin - offsetShift);
	      }
	      if (newRoot && newTailOffset < oldTailOffset) {
	        newRoot = newRoot.removeAfter(owner, newLevel, newTailOffset - offsetShift);
	      }
	      if (offsetShift) {
	        newOrigin -= offsetShift;
	        newCapacity -= offsetShift;
	      }
	    }
	
	    if (list.__ownerID) {
	      list.size = newCapacity - newOrigin;
	      list._origin = newOrigin;
	      list._capacity = newCapacity;
	      list._level = newLevel;
	      list._root = newRoot;
	      list._tail = newTail;
	      list.__hash = undefined;
	      list.__altered = true;
	      return list;
	    }
	    return makeList(newOrigin, newCapacity, newLevel, newRoot, newTail);
	  }
	
	  function mergeIntoListWith(list, merger, iterables) {
	    var iters = [];
	    var maxSize = 0;
	    for (var ii = 0; ii < iterables.length; ii++) {
	      var value = iterables[ii];
	      var iter = IndexedIterable(value);
	      if (iter.size > maxSize) {
	        maxSize = iter.size;
	      }
	      if (!isIterable(value)) {
	        iter = iter.map(function(v ) {return fromJS(v)});
	      }
	      iters.push(iter);
	    }
	    if (maxSize > list.size) {
	      list = list.setSize(maxSize);
	    }
	    return mergeIntoCollectionWith(list, merger, iters);
	  }
	
	  function getTailOffset(size) {
	    return size < SIZE ? 0 : (((size - 1) >>> SHIFT) << SHIFT);
	  }
	
	  createClass(OrderedMap, Map);
	
	    // @pragma Construction
	
	    function OrderedMap(value) {
	      return value === null || value === undefined ? emptyOrderedMap() :
	        isOrderedMap(value) ? value :
	        emptyOrderedMap().withMutations(function(map ) {
	          var iter = KeyedIterable(value);
	          assertNotInfinite(iter.size);
	          iter.forEach(function(v, k)  {return map.set(k, v)});
	        });
	    }
	
	    OrderedMap.of = function(/*...values*/) {
	      return this(arguments);
	    };
	
	    OrderedMap.prototype.toString = function() {
	      return this.__toString('OrderedMap {', '}');
	    };
	
	    // @pragma Access
	
	    OrderedMap.prototype.get = function(k, notSetValue) {
	      var index = this._map.get(k);
	      return index !== undefined ? this._list.get(index)[1] : notSetValue;
	    };
	
	    // @pragma Modification
	
	    OrderedMap.prototype.clear = function() {
	      if (this.size === 0) {
	        return this;
	      }
	      if (this.__ownerID) {
	        this.size = 0;
	        this._map.clear();
	        this._list.clear();
	        return this;
	      }
	      return emptyOrderedMap();
	    };
	
	    OrderedMap.prototype.set = function(k, v) {
	      return updateOrderedMap(this, k, v);
	    };
	
	    OrderedMap.prototype.remove = function(k) {
	      return updateOrderedMap(this, k, NOT_SET);
	    };
	
	    OrderedMap.prototype.wasAltered = function() {
	      return this._map.wasAltered() || this._list.wasAltered();
	    };
	
	    OrderedMap.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      return this._list.__iterate(
	        function(entry ) {return entry && fn(entry[1], entry[0], this$0)},
	        reverse
	      );
	    };
	
	    OrderedMap.prototype.__iterator = function(type, reverse) {
	      return this._list.fromEntrySeq().__iterator(type, reverse);
	    };
	
	    OrderedMap.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      var newMap = this._map.__ensureOwner(ownerID);
	      var newList = this._list.__ensureOwner(ownerID);
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        this._map = newMap;
	        this._list = newList;
	        return this;
	      }
	      return makeOrderedMap(newMap, newList, ownerID, this.__hash);
	    };
	
	
	  function isOrderedMap(maybeOrderedMap) {
	    return isMap(maybeOrderedMap) && isOrdered(maybeOrderedMap);
	  }
	
	  OrderedMap.isOrderedMap = isOrderedMap;
	
	  OrderedMap.prototype[IS_ORDERED_SENTINEL] = true;
	  OrderedMap.prototype[DELETE] = OrderedMap.prototype.remove;
	
	
	
	  function makeOrderedMap(map, list, ownerID, hash) {
	    var omap = Object.create(OrderedMap.prototype);
	    omap.size = map ? map.size : 0;
	    omap._map = map;
	    omap._list = list;
	    omap.__ownerID = ownerID;
	    omap.__hash = hash;
	    return omap;
	  }
	
	  var EMPTY_ORDERED_MAP;
	  function emptyOrderedMap() {
	    return EMPTY_ORDERED_MAP || (EMPTY_ORDERED_MAP = makeOrderedMap(emptyMap(), emptyList()));
	  }
	
	  function updateOrderedMap(omap, k, v) {
	    var map = omap._map;
	    var list = omap._list;
	    var i = map.get(k);
	    var has = i !== undefined;
	    var newMap;
	    var newList;
	    if (v === NOT_SET) { // removed
	      if (!has) {
	        return omap;
	      }
	      if (list.size >= SIZE && list.size >= map.size * 2) {
	        newList = list.filter(function(entry, idx)  {return entry !== undefined && i !== idx});
	        newMap = newList.toKeyedSeq().map(function(entry ) {return entry[0]}).flip().toMap();
	        if (omap.__ownerID) {
	          newMap.__ownerID = newList.__ownerID = omap.__ownerID;
	        }
	      } else {
	        newMap = map.remove(k);
	        newList = i === list.size - 1 ? list.pop() : list.set(i, undefined);
	      }
	    } else {
	      if (has) {
	        if (v === list.get(i)[1]) {
	          return omap;
	        }
	        newMap = map;
	        newList = list.set(i, [k, v]);
	      } else {
	        newMap = map.set(k, list.size);
	        newList = list.set(list.size, [k, v]);
	      }
	    }
	    if (omap.__ownerID) {
	      omap.size = newMap.size;
	      omap._map = newMap;
	      omap._list = newList;
	      omap.__hash = undefined;
	      return omap;
	    }
	    return makeOrderedMap(newMap, newList);
	  }
	
	  createClass(ToKeyedSequence, KeyedSeq);
	    function ToKeyedSequence(indexed, useKeys) {
	      this._iter = indexed;
	      this._useKeys = useKeys;
	      this.size = indexed.size;
	    }
	
	    ToKeyedSequence.prototype.get = function(key, notSetValue) {
	      return this._iter.get(key, notSetValue);
	    };
	
	    ToKeyedSequence.prototype.has = function(key) {
	      return this._iter.has(key);
	    };
	
	    ToKeyedSequence.prototype.valueSeq = function() {
	      return this._iter.valueSeq();
	    };
	
	    ToKeyedSequence.prototype.reverse = function() {var this$0 = this;
	      var reversedSequence = reverseFactory(this, true);
	      if (!this._useKeys) {
	        reversedSequence.valueSeq = function()  {return this$0._iter.toSeq().reverse()};
	      }
	      return reversedSequence;
	    };
	
	    ToKeyedSequence.prototype.map = function(mapper, context) {var this$0 = this;
	      var mappedSequence = mapFactory(this, mapper, context);
	      if (!this._useKeys) {
	        mappedSequence.valueSeq = function()  {return this$0._iter.toSeq().map(mapper, context)};
	      }
	      return mappedSequence;
	    };
	
	    ToKeyedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      var ii;
	      return this._iter.__iterate(
	        this._useKeys ?
	          function(v, k)  {return fn(v, k, this$0)} :
	          ((ii = reverse ? resolveSize(this) : 0),
	            function(v ) {return fn(v, reverse ? --ii : ii++, this$0)}),
	        reverse
	      );
	    };
	
	    ToKeyedSequence.prototype.__iterator = function(type, reverse) {
	      if (this._useKeys) {
	        return this._iter.__iterator(type, reverse);
	      }
	      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
	      var ii = reverse ? resolveSize(this) : 0;
	      return new Iterator(function()  {
	        var step = iterator.next();
	        return step.done ? step :
	          iteratorValue(type, reverse ? --ii : ii++, step.value, step);
	      });
	    };
	
	  ToKeyedSequence.prototype[IS_ORDERED_SENTINEL] = true;
	
	
	  createClass(ToIndexedSequence, IndexedSeq);
	    function ToIndexedSequence(iter) {
	      this._iter = iter;
	      this.size = iter.size;
	    }
	
	    ToIndexedSequence.prototype.includes = function(value) {
	      return this._iter.includes(value);
	    };
	
	    ToIndexedSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      var iterations = 0;
	      return this._iter.__iterate(function(v ) {return fn(v, iterations++, this$0)}, reverse);
	    };
	
	    ToIndexedSequence.prototype.__iterator = function(type, reverse) {
	      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
	      var iterations = 0;
	      return new Iterator(function()  {
	        var step = iterator.next();
	        return step.done ? step :
	          iteratorValue(type, iterations++, step.value, step)
	      });
	    };
	
	
	
	  createClass(ToSetSequence, SetSeq);
	    function ToSetSequence(iter) {
	      this._iter = iter;
	      this.size = iter.size;
	    }
	
	    ToSetSequence.prototype.has = function(key) {
	      return this._iter.includes(key);
	    };
	
	    ToSetSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      return this._iter.__iterate(function(v ) {return fn(v, v, this$0)}, reverse);
	    };
	
	    ToSetSequence.prototype.__iterator = function(type, reverse) {
	      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
	      return new Iterator(function()  {
	        var step = iterator.next();
	        return step.done ? step :
	          iteratorValue(type, step.value, step.value, step);
	      });
	    };
	
	
	
	  createClass(FromEntriesSequence, KeyedSeq);
	    function FromEntriesSequence(entries) {
	      this._iter = entries;
	      this.size = entries.size;
	    }
	
	    FromEntriesSequence.prototype.entrySeq = function() {
	      return this._iter.toSeq();
	    };
	
	    FromEntriesSequence.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      return this._iter.__iterate(function(entry ) {
	        // Check if entry exists first so array access doesn't throw for holes
	        // in the parent iteration.
	        if (entry) {
	          validateEntry(entry);
	          var indexedIterable = isIterable(entry);
	          return fn(
	            indexedIterable ? entry.get(1) : entry[1],
	            indexedIterable ? entry.get(0) : entry[0],
	            this$0
	          );
	        }
	      }, reverse);
	    };
	
	    FromEntriesSequence.prototype.__iterator = function(type, reverse) {
	      var iterator = this._iter.__iterator(ITERATE_VALUES, reverse);
	      return new Iterator(function()  {
	        while (true) {
	          var step = iterator.next();
	          if (step.done) {
	            return step;
	          }
	          var entry = step.value;
	          // Check if entry exists first so array access doesn't throw for holes
	          // in the parent iteration.
	          if (entry) {
	            validateEntry(entry);
	            var indexedIterable = isIterable(entry);
	            return iteratorValue(
	              type,
	              indexedIterable ? entry.get(0) : entry[0],
	              indexedIterable ? entry.get(1) : entry[1],
	              step
	            );
	          }
	        }
	      });
	    };
	
	
	  ToIndexedSequence.prototype.cacheResult =
	  ToKeyedSequence.prototype.cacheResult =
	  ToSetSequence.prototype.cacheResult =
	  FromEntriesSequence.prototype.cacheResult =
	    cacheResultThrough;
	
	
	  function flipFactory(iterable) {
	    var flipSequence = makeSequence(iterable);
	    flipSequence._iter = iterable;
	    flipSequence.size = iterable.size;
	    flipSequence.flip = function()  {return iterable};
	    flipSequence.reverse = function () {
	      var reversedSequence = iterable.reverse.apply(this); // super.reverse()
	      reversedSequence.flip = function()  {return iterable.reverse()};
	      return reversedSequence;
	    };
	    flipSequence.has = function(key ) {return iterable.includes(key)};
	    flipSequence.includes = function(key ) {return iterable.has(key)};
	    flipSequence.cacheResult = cacheResultThrough;
	    flipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;
	      return iterable.__iterate(function(v, k)  {return fn(k, v, this$0) !== false}, reverse);
	    }
	    flipSequence.__iteratorUncached = function(type, reverse) {
	      if (type === ITERATE_ENTRIES) {
	        var iterator = iterable.__iterator(type, reverse);
	        return new Iterator(function()  {
	          var step = iterator.next();
	          if (!step.done) {
	            var k = step.value[0];
	            step.value[0] = step.value[1];
	            step.value[1] = k;
	          }
	          return step;
	        });
	      }
	      return iterable.__iterator(
	        type === ITERATE_VALUES ? ITERATE_KEYS : ITERATE_VALUES,
	        reverse
	      );
	    }
	    return flipSequence;
	  }
	
	
	  function mapFactory(iterable, mapper, context) {
	    var mappedSequence = makeSequence(iterable);
	    mappedSequence.size = iterable.size;
	    mappedSequence.has = function(key ) {return iterable.has(key)};
	    mappedSequence.get = function(key, notSetValue)  {
	      var v = iterable.get(key, NOT_SET);
	      return v === NOT_SET ?
	        notSetValue :
	        mapper.call(context, v, key, iterable);
	    };
	    mappedSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;
	      return iterable.__iterate(
	        function(v, k, c)  {return fn(mapper.call(context, v, k, c), k, this$0) !== false},
	        reverse
	      );
	    }
	    mappedSequence.__iteratorUncached = function (type, reverse) {
	      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
	      return new Iterator(function()  {
	        var step = iterator.next();
	        if (step.done) {
	          return step;
	        }
	        var entry = step.value;
	        var key = entry[0];
	        return iteratorValue(
	          type,
	          key,
	          mapper.call(context, entry[1], key, iterable),
	          step
	        );
	      });
	    }
	    return mappedSequence;
	  }
	
	
	  function reverseFactory(iterable, useKeys) {
	    var reversedSequence = makeSequence(iterable);
	    reversedSequence._iter = iterable;
	    reversedSequence.size = iterable.size;
	    reversedSequence.reverse = function()  {return iterable};
	    if (iterable.flip) {
	      reversedSequence.flip = function () {
	        var flipSequence = flipFactory(iterable);
	        flipSequence.reverse = function()  {return iterable.flip()};
	        return flipSequence;
	      };
	    }
	    reversedSequence.get = function(key, notSetValue) 
	      {return iterable.get(useKeys ? key : -1 - key, notSetValue)};
	    reversedSequence.has = function(key )
	      {return iterable.has(useKeys ? key : -1 - key)};
	    reversedSequence.includes = function(value ) {return iterable.includes(value)};
	    reversedSequence.cacheResult = cacheResultThrough;
	    reversedSequence.__iterate = function (fn, reverse) {var this$0 = this;
	      return iterable.__iterate(function(v, k)  {return fn(v, k, this$0)}, !reverse);
	    };
	    reversedSequence.__iterator =
	      function(type, reverse)  {return iterable.__iterator(type, !reverse)};
	    return reversedSequence;
	  }
	
	
	  function filterFactory(iterable, predicate, context, useKeys) {
	    var filterSequence = makeSequence(iterable);
	    if (useKeys) {
	      filterSequence.has = function(key ) {
	        var v = iterable.get(key, NOT_SET);
	        return v !== NOT_SET && !!predicate.call(context, v, key, iterable);
	      };
	      filterSequence.get = function(key, notSetValue)  {
	        var v = iterable.get(key, NOT_SET);
	        return v !== NOT_SET && predicate.call(context, v, key, iterable) ?
	          v : notSetValue;
	      };
	    }
	    filterSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;
	      var iterations = 0;
	      iterable.__iterate(function(v, k, c)  {
	        if (predicate.call(context, v, k, c)) {
	          iterations++;
	          return fn(v, useKeys ? k : iterations - 1, this$0);
	        }
	      }, reverse);
	      return iterations;
	    };
	    filterSequence.__iteratorUncached = function (type, reverse) {
	      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
	      var iterations = 0;
	      return new Iterator(function()  {
	        while (true) {
	          var step = iterator.next();
	          if (step.done) {
	            return step;
	          }
	          var entry = step.value;
	          var key = entry[0];
	          var value = entry[1];
	          if (predicate.call(context, value, key, iterable)) {
	            return iteratorValue(type, useKeys ? key : iterations++, value, step);
	          }
	        }
	      });
	    }
	    return filterSequence;
	  }
	
	
	  function countByFactory(iterable, grouper, context) {
	    var groups = Map().asMutable();
	    iterable.__iterate(function(v, k)  {
	      groups.update(
	        grouper.call(context, v, k, iterable),
	        0,
	        function(a ) {return a + 1}
	      );
	    });
	    return groups.asImmutable();
	  }
	
	
	  function groupByFactory(iterable, grouper, context) {
	    var isKeyedIter = isKeyed(iterable);
	    var groups = (isOrdered(iterable) ? OrderedMap() : Map()).asMutable();
	    iterable.__iterate(function(v, k)  {
	      groups.update(
	        grouper.call(context, v, k, iterable),
	        function(a ) {return (a = a || [], a.push(isKeyedIter ? [k, v] : v), a)}
	      );
	    });
	    var coerce = iterableClass(iterable);
	    return groups.map(function(arr ) {return reify(iterable, coerce(arr))});
	  }
	
	
	  function sliceFactory(iterable, begin, end, useKeys) {
	    var originalSize = iterable.size;
	
	    // Sanitize begin & end using this shorthand for ToInt32(argument)
	    // http://www.ecma-international.org/ecma-262/6.0/#sec-toint32
	    if (begin !== undefined) {
	      begin = begin | 0;
	    }
	    if (end !== undefined) {
	      end = end | 0;
	    }
	
	    if (wholeSlice(begin, end, originalSize)) {
	      return iterable;
	    }
	
	    var resolvedBegin = resolveBegin(begin, originalSize);
	    var resolvedEnd = resolveEnd(end, originalSize);
	
	    // begin or end will be NaN if they were provided as negative numbers and
	    // this iterable's size is unknown. In that case, cache first so there is
	    // a known size and these do not resolve to NaN.
	    if (resolvedBegin !== resolvedBegin || resolvedEnd !== resolvedEnd) {
	      return sliceFactory(iterable.toSeq().cacheResult(), begin, end, useKeys);
	    }
	
	    // Note: resolvedEnd is undefined when the original sequence's length is
	    // unknown and this slice did not supply an end and should contain all
	    // elements after resolvedBegin.
	    // In that case, resolvedSize will be NaN and sliceSize will remain undefined.
	    var resolvedSize = resolvedEnd - resolvedBegin;
	    var sliceSize;
	    if (resolvedSize === resolvedSize) {
	      sliceSize = resolvedSize < 0 ? 0 : resolvedSize;
	    }
	
	    var sliceSeq = makeSequence(iterable);
	
	    // If iterable.size is undefined, the size of the realized sliceSeq is
	    // unknown at this point unless the number of items to slice is 0
	    sliceSeq.size = sliceSize === 0 ? sliceSize : iterable.size && sliceSize || undefined;
	
	    if (!useKeys && isSeq(iterable) && sliceSize >= 0) {
	      sliceSeq.get = function (index, notSetValue) {
	        index = wrapIndex(this, index);
	        return index >= 0 && index < sliceSize ?
	          iterable.get(index + resolvedBegin, notSetValue) :
	          notSetValue;
	      }
	    }
	
	    sliceSeq.__iterateUncached = function(fn, reverse) {var this$0 = this;
	      if (sliceSize === 0) {
	        return 0;
	      }
	      if (reverse) {
	        return this.cacheResult().__iterate(fn, reverse);
	      }
	      var skipped = 0;
	      var isSkipping = true;
	      var iterations = 0;
	      iterable.__iterate(function(v, k)  {
	        if (!(isSkipping && (isSkipping = skipped++ < resolvedBegin))) {
	          iterations++;
	          return fn(v, useKeys ? k : iterations - 1, this$0) !== false &&
	                 iterations !== sliceSize;
	        }
	      });
	      return iterations;
	    };
	
	    sliceSeq.__iteratorUncached = function(type, reverse) {
	      if (sliceSize !== 0 && reverse) {
	        return this.cacheResult().__iterator(type, reverse);
	      }
	      // Don't bother instantiating parent iterator if taking 0.
	      var iterator = sliceSize !== 0 && iterable.__iterator(type, reverse);
	      var skipped = 0;
	      var iterations = 0;
	      return new Iterator(function()  {
	        while (skipped++ < resolvedBegin) {
	          iterator.next();
	        }
	        if (++iterations > sliceSize) {
	          return iteratorDone();
	        }
	        var step = iterator.next();
	        if (useKeys || type === ITERATE_VALUES) {
	          return step;
	        } else if (type === ITERATE_KEYS) {
	          return iteratorValue(type, iterations - 1, undefined, step);
	        } else {
	          return iteratorValue(type, iterations - 1, step.value[1], step);
	        }
	      });
	    }
	
	    return sliceSeq;
	  }
	
	
	  function takeWhileFactory(iterable, predicate, context) {
	    var takeSequence = makeSequence(iterable);
	    takeSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;
	      if (reverse) {
	        return this.cacheResult().__iterate(fn, reverse);
	      }
	      var iterations = 0;
	      iterable.__iterate(function(v, k, c) 
	        {return predicate.call(context, v, k, c) && ++iterations && fn(v, k, this$0)}
	      );
	      return iterations;
	    };
	    takeSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;
	      if (reverse) {
	        return this.cacheResult().__iterator(type, reverse);
	      }
	      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
	      var iterating = true;
	      return new Iterator(function()  {
	        if (!iterating) {
	          return iteratorDone();
	        }
	        var step = iterator.next();
	        if (step.done) {
	          return step;
	        }
	        var entry = step.value;
	        var k = entry[0];
	        var v = entry[1];
	        if (!predicate.call(context, v, k, this$0)) {
	          iterating = false;
	          return iteratorDone();
	        }
	        return type === ITERATE_ENTRIES ? step :
	          iteratorValue(type, k, v, step);
	      });
	    };
	    return takeSequence;
	  }
	
	
	  function skipWhileFactory(iterable, predicate, context, useKeys) {
	    var skipSequence = makeSequence(iterable);
	    skipSequence.__iterateUncached = function (fn, reverse) {var this$0 = this;
	      if (reverse) {
	        return this.cacheResult().__iterate(fn, reverse);
	      }
	      var isSkipping = true;
	      var iterations = 0;
	      iterable.__iterate(function(v, k, c)  {
	        if (!(isSkipping && (isSkipping = predicate.call(context, v, k, c)))) {
	          iterations++;
	          return fn(v, useKeys ? k : iterations - 1, this$0);
	        }
	      });
	      return iterations;
	    };
	    skipSequence.__iteratorUncached = function(type, reverse) {var this$0 = this;
	      if (reverse) {
	        return this.cacheResult().__iterator(type, reverse);
	      }
	      var iterator = iterable.__iterator(ITERATE_ENTRIES, reverse);
	      var skipping = true;
	      var iterations = 0;
	      return new Iterator(function()  {
	        var step, k, v;
	        do {
	          step = iterator.next();
	          if (step.done) {
	            if (useKeys || type === ITERATE_VALUES) {
	              return step;
	            } else if (type === ITERATE_KEYS) {
	              return iteratorValue(type, iterations++, undefined, step);
	            } else {
	              return iteratorValue(type, iterations++, step.value[1], step);
	            }
	          }
	          var entry = step.value;
	          k = entry[0];
	          v = entry[1];
	          skipping && (skipping = predicate.call(context, v, k, this$0));
	        } while (skipping);
	        return type === ITERATE_ENTRIES ? step :
	          iteratorValue(type, k, v, step);
	      });
	    };
	    return skipSequence;
	  }
	
	
	  function concatFactory(iterable, values) {
	    var isKeyedIterable = isKeyed(iterable);
	    var iters = [iterable].concat(values).map(function(v ) {
	      if (!isIterable(v)) {
	        v = isKeyedIterable ?
	          keyedSeqFromValue(v) :
	          indexedSeqFromValue(Array.isArray(v) ? v : [v]);
	      } else if (isKeyedIterable) {
	        v = KeyedIterable(v);
	      }
	      return v;
	    }).filter(function(v ) {return v.size !== 0});
	
	    if (iters.length === 0) {
	      return iterable;
	    }
	
	    if (iters.length === 1) {
	      var singleton = iters[0];
	      if (singleton === iterable ||
	          isKeyedIterable && isKeyed(singleton) ||
	          isIndexed(iterable) && isIndexed(singleton)) {
	        return singleton;
	      }
	    }
	
	    var concatSeq = new ArraySeq(iters);
	    if (isKeyedIterable) {
	      concatSeq = concatSeq.toKeyedSeq();
	    } else if (!isIndexed(iterable)) {
	      concatSeq = concatSeq.toSetSeq();
	    }
	    concatSeq = concatSeq.flatten(true);
	    concatSeq.size = iters.reduce(
	      function(sum, seq)  {
	        if (sum !== undefined) {
	          var size = seq.size;
	          if (size !== undefined) {
	            return sum + size;
	          }
	        }
	      },
	      0
	    );
	    return concatSeq;
	  }
	
	
	  function flattenFactory(iterable, depth, useKeys) {
	    var flatSequence = makeSequence(iterable);
	    flatSequence.__iterateUncached = function(fn, reverse) {
	      var iterations = 0;
	      var stopped = false;
	      function flatDeep(iter, currentDepth) {var this$0 = this;
	        iter.__iterate(function(v, k)  {
	          if ((!depth || currentDepth < depth) && isIterable(v)) {
	            flatDeep(v, currentDepth + 1);
	          } else if (fn(v, useKeys ? k : iterations++, this$0) === false) {
	            stopped = true;
	          }
	          return !stopped;
	        }, reverse);
	      }
	      flatDeep(iterable, 0);
	      return iterations;
	    }
	    flatSequence.__iteratorUncached = function(type, reverse) {
	      var iterator = iterable.__iterator(type, reverse);
	      var stack = [];
	      var iterations = 0;
	      return new Iterator(function()  {
	        while (iterator) {
	          var step = iterator.next();
	          if (step.done !== false) {
	            iterator = stack.pop();
	            continue;
	          }
	          var v = step.value;
	          if (type === ITERATE_ENTRIES) {
	            v = v[1];
	          }
	          if ((!depth || stack.length < depth) && isIterable(v)) {
	            stack.push(iterator);
	            iterator = v.__iterator(type, reverse);
	          } else {
	            return useKeys ? step : iteratorValue(type, iterations++, v, step);
	          }
	        }
	        return iteratorDone();
	      });
	    }
	    return flatSequence;
	  }
	
	
	  function flatMapFactory(iterable, mapper, context) {
	    var coerce = iterableClass(iterable);
	    return iterable.toSeq().map(
	      function(v, k)  {return coerce(mapper.call(context, v, k, iterable))}
	    ).flatten(true);
	  }
	
	
	  function interposeFactory(iterable, separator) {
	    var interposedSequence = makeSequence(iterable);
	    interposedSequence.size = iterable.size && iterable.size * 2 -1;
	    interposedSequence.__iterateUncached = function(fn, reverse) {var this$0 = this;
	      var iterations = 0;
	      iterable.__iterate(function(v, k) 
	        {return (!iterations || fn(separator, iterations++, this$0) !== false) &&
	        fn(v, iterations++, this$0) !== false},
	        reverse
	      );
	      return iterations;
	    };
	    interposedSequence.__iteratorUncached = function(type, reverse) {
	      var iterator = iterable.__iterator(ITERATE_VALUES, reverse);
	      var iterations = 0;
	      var step;
	      return new Iterator(function()  {
	        if (!step || iterations % 2) {
	          step = iterator.next();
	          if (step.done) {
	            return step;
	          }
	        }
	        return iterations % 2 ?
	          iteratorValue(type, iterations++, separator) :
	          iteratorValue(type, iterations++, step.value, step);
	      });
	    };
	    return interposedSequence;
	  }
	
	
	  function sortFactory(iterable, comparator, mapper) {
	    if (!comparator) {
	      comparator = defaultComparator;
	    }
	    var isKeyedIterable = isKeyed(iterable);
	    var index = 0;
	    var entries = iterable.toSeq().map(
	      function(v, k)  {return [k, v, index++, mapper ? mapper(v, k, iterable) : v]}
	    ).toArray();
	    entries.sort(function(a, b)  {return comparator(a[3], b[3]) || a[2] - b[2]}).forEach(
	      isKeyedIterable ?
	      function(v, i)  { entries[i].length = 2; } :
	      function(v, i)  { entries[i] = v[1]; }
	    );
	    return isKeyedIterable ? KeyedSeq(entries) :
	      isIndexed(iterable) ? IndexedSeq(entries) :
	      SetSeq(entries);
	  }
	
	
	  function maxFactory(iterable, comparator, mapper) {
	    if (!comparator) {
	      comparator = defaultComparator;
	    }
	    if (mapper) {
	      var entry = iterable.toSeq()
	        .map(function(v, k)  {return [v, mapper(v, k, iterable)]})
	        .reduce(function(a, b)  {return maxCompare(comparator, a[1], b[1]) ? b : a});
	      return entry && entry[0];
	    } else {
	      return iterable.reduce(function(a, b)  {return maxCompare(comparator, a, b) ? b : a});
	    }
	  }
	
	  function maxCompare(comparator, a, b) {
	    var comp = comparator(b, a);
	    // b is considered the new max if the comparator declares them equal, but
	    // they are not equal and b is in fact a nullish value.
	    return (comp === 0 && b !== a && (b === undefined || b === null || b !== b)) || comp > 0;
	  }
	
	
	  function zipWithFactory(keyIter, zipper, iters) {
	    var zipSequence = makeSequence(keyIter);
	    zipSequence.size = new ArraySeq(iters).map(function(i ) {return i.size}).min();
	    // Note: this a generic base implementation of __iterate in terms of
	    // __iterator which may be more generically useful in the future.
	    zipSequence.__iterate = function(fn, reverse) {
	      /* generic:
	      var iterator = this.__iterator(ITERATE_ENTRIES, reverse);
	      var step;
	      var iterations = 0;
	      while (!(step = iterator.next()).done) {
	        iterations++;
	        if (fn(step.value[1], step.value[0], this) === false) {
	          break;
	        }
	      }
	      return iterations;
	      */
	      // indexed:
	      var iterator = this.__iterator(ITERATE_VALUES, reverse);
	      var step;
	      var iterations = 0;
	      while (!(step = iterator.next()).done) {
	        if (fn(step.value, iterations++, this) === false) {
	          break;
	        }
	      }
	      return iterations;
	    };
	    zipSequence.__iteratorUncached = function(type, reverse) {
	      var iterators = iters.map(function(i )
	        {return (i = Iterable(i), getIterator(reverse ? i.reverse() : i))}
	      );
	      var iterations = 0;
	      var isDone = false;
	      return new Iterator(function()  {
	        var steps;
	        if (!isDone) {
	          steps = iterators.map(function(i ) {return i.next()});
	          isDone = steps.some(function(s ) {return s.done});
	        }
	        if (isDone) {
	          return iteratorDone();
	        }
	        return iteratorValue(
	          type,
	          iterations++,
	          zipper.apply(null, steps.map(function(s ) {return s.value}))
	        );
	      });
	    };
	    return zipSequence
	  }
	
	
	  // #pragma Helper Functions
	
	  function reify(iter, seq) {
	    return isSeq(iter) ? seq : iter.constructor(seq);
	  }
	
	  function validateEntry(entry) {
	    if (entry !== Object(entry)) {
	      throw new TypeError('Expected [K, V] tuple: ' + entry);
	    }
	  }
	
	  function resolveSize(iter) {
	    assertNotInfinite(iter.size);
	    return ensureSize(iter);
	  }
	
	  function iterableClass(iterable) {
	    return isKeyed(iterable) ? KeyedIterable :
	      isIndexed(iterable) ? IndexedIterable :
	      SetIterable;
	  }
	
	  function makeSequence(iterable) {
	    return Object.create(
	      (
	        isKeyed(iterable) ? KeyedSeq :
	        isIndexed(iterable) ? IndexedSeq :
	        SetSeq
	      ).prototype
	    );
	  }
	
	  function cacheResultThrough() {
	    if (this._iter.cacheResult) {
	      this._iter.cacheResult();
	      this.size = this._iter.size;
	      return this;
	    } else {
	      return Seq.prototype.cacheResult.call(this);
	    }
	  }
	
	  function defaultComparator(a, b) {
	    return a > b ? 1 : a < b ? -1 : 0;
	  }
	
	  function forceIterator(keyPath) {
	    var iter = getIterator(keyPath);
	    if (!iter) {
	      // Array might not be iterable in this environment, so we need a fallback
	      // to our wrapped type.
	      if (!isArrayLike(keyPath)) {
	        throw new TypeError('Expected iterable or array-like: ' + keyPath);
	      }
	      iter = getIterator(Iterable(keyPath));
	    }
	    return iter;
	  }
	
	  createClass(Record, KeyedCollection);
	
	    function Record(defaultValues, name) {
	      var hasInitialized;
	
	      var RecordType = function Record(values) {
	        if (values instanceof RecordType) {
	          return values;
	        }
	        if (!(this instanceof RecordType)) {
	          return new RecordType(values);
	        }
	        if (!hasInitialized) {
	          hasInitialized = true;
	          var keys = Object.keys(defaultValues);
	          setProps(RecordTypePrototype, keys);
	          RecordTypePrototype.size = keys.length;
	          RecordTypePrototype._name = name;
	          RecordTypePrototype._keys = keys;
	          RecordTypePrototype._defaultValues = defaultValues;
	        }
	        this._map = Map(values);
	      };
	
	      var RecordTypePrototype = RecordType.prototype = Object.create(RecordPrototype);
	      RecordTypePrototype.constructor = RecordType;
	
	      return RecordType;
	    }
	
	    Record.prototype.toString = function() {
	      return this.__toString(recordName(this) + ' {', '}');
	    };
	
	    // @pragma Access
	
	    Record.prototype.has = function(k) {
	      return this._defaultValues.hasOwnProperty(k);
	    };
	
	    Record.prototype.get = function(k, notSetValue) {
	      if (!this.has(k)) {
	        return notSetValue;
	      }
	      var defaultVal = this._defaultValues[k];
	      return this._map ? this._map.get(k, defaultVal) : defaultVal;
	    };
	
	    // @pragma Modification
	
	    Record.prototype.clear = function() {
	      if (this.__ownerID) {
	        this._map && this._map.clear();
	        return this;
	      }
	      var RecordType = this.constructor;
	      return RecordType._empty || (RecordType._empty = makeRecord(this, emptyMap()));
	    };
	
	    Record.prototype.set = function(k, v) {
	      if (!this.has(k)) {
	        throw new Error('Cannot set unknown key "' + k + '" on ' + recordName(this));
	      }
	      var newMap = this._map && this._map.set(k, v);
	      if (this.__ownerID || newMap === this._map) {
	        return this;
	      }
	      return makeRecord(this, newMap);
	    };
	
	    Record.prototype.remove = function(k) {
	      if (!this.has(k)) {
	        return this;
	      }
	      var newMap = this._map && this._map.remove(k);
	      if (this.__ownerID || newMap === this._map) {
	        return this;
	      }
	      return makeRecord(this, newMap);
	    };
	
	    Record.prototype.wasAltered = function() {
	      return this._map.wasAltered();
	    };
	
	    Record.prototype.__iterator = function(type, reverse) {var this$0 = this;
	      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterator(type, reverse);
	    };
	
	    Record.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      return KeyedIterable(this._defaultValues).map(function(_, k)  {return this$0.get(k)}).__iterate(fn, reverse);
	    };
	
	    Record.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      var newMap = this._map && this._map.__ensureOwner(ownerID);
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        this._map = newMap;
	        return this;
	      }
	      return makeRecord(this, newMap, ownerID);
	    };
	
	
	  var RecordPrototype = Record.prototype;
	  RecordPrototype[DELETE] = RecordPrototype.remove;
	  RecordPrototype.deleteIn =
	  RecordPrototype.removeIn = MapPrototype.removeIn;
	  RecordPrototype.merge = MapPrototype.merge;
	  RecordPrototype.mergeWith = MapPrototype.mergeWith;
	  RecordPrototype.mergeIn = MapPrototype.mergeIn;
	  RecordPrototype.mergeDeep = MapPrototype.mergeDeep;
	  RecordPrototype.mergeDeepWith = MapPrototype.mergeDeepWith;
	  RecordPrototype.mergeDeepIn = MapPrototype.mergeDeepIn;
	  RecordPrototype.setIn = MapPrototype.setIn;
	  RecordPrototype.update = MapPrototype.update;
	  RecordPrototype.updateIn = MapPrototype.updateIn;
	  RecordPrototype.withMutations = MapPrototype.withMutations;
	  RecordPrototype.asMutable = MapPrototype.asMutable;
	  RecordPrototype.asImmutable = MapPrototype.asImmutable;
	
	
	  function makeRecord(likeRecord, map, ownerID) {
	    var record = Object.create(Object.getPrototypeOf(likeRecord));
	    record._map = map;
	    record.__ownerID = ownerID;
	    return record;
	  }
	
	  function recordName(record) {
	    return record._name || record.constructor.name || 'Record';
	  }
	
	  function setProps(prototype, names) {
	    try {
	      names.forEach(setProp.bind(undefined, prototype));
	    } catch (error) {
	      // Object.defineProperty failed. Probably IE8.
	    }
	  }
	
	  function setProp(prototype, name) {
	    Object.defineProperty(prototype, name, {
	      get: function() {
	        return this.get(name);
	      },
	      set: function(value) {
	        invariant(this.__ownerID, 'Cannot set on an immutable record.');
	        this.set(name, value);
	      }
	    });
	  }
	
	  createClass(Set, SetCollection);
	
	    // @pragma Construction
	
	    function Set(value) {
	      return value === null || value === undefined ? emptySet() :
	        isSet(value) && !isOrdered(value) ? value :
	        emptySet().withMutations(function(set ) {
	          var iter = SetIterable(value);
	          assertNotInfinite(iter.size);
	          iter.forEach(function(v ) {return set.add(v)});
	        });
	    }
	
	    Set.of = function(/*...values*/) {
	      return this(arguments);
	    };
	
	    Set.fromKeys = function(value) {
	      return this(KeyedIterable(value).keySeq());
	    };
	
	    Set.prototype.toString = function() {
	      return this.__toString('Set {', '}');
	    };
	
	    // @pragma Access
	
	    Set.prototype.has = function(value) {
	      return this._map.has(value);
	    };
	
	    // @pragma Modification
	
	    Set.prototype.add = function(value) {
	      return updateSet(this, this._map.set(value, true));
	    };
	
	    Set.prototype.remove = function(value) {
	      return updateSet(this, this._map.remove(value));
	    };
	
	    Set.prototype.clear = function() {
	      return updateSet(this, this._map.clear());
	    };
	
	    // @pragma Composition
	
	    Set.prototype.union = function() {var iters = SLICE$0.call(arguments, 0);
	      iters = iters.filter(function(x ) {return x.size !== 0});
	      if (iters.length === 0) {
	        return this;
	      }
	      if (this.size === 0 && !this.__ownerID && iters.length === 1) {
	        return this.constructor(iters[0]);
	      }
	      return this.withMutations(function(set ) {
	        for (var ii = 0; ii < iters.length; ii++) {
	          SetIterable(iters[ii]).forEach(function(value ) {return set.add(value)});
	        }
	      });
	    };
	
	    Set.prototype.intersect = function() {var iters = SLICE$0.call(arguments, 0);
	      if (iters.length === 0) {
	        return this;
	      }
	      iters = iters.map(function(iter ) {return SetIterable(iter)});
	      var originalSet = this;
	      return this.withMutations(function(set ) {
	        originalSet.forEach(function(value ) {
	          if (!iters.every(function(iter ) {return iter.includes(value)})) {
	            set.remove(value);
	          }
	        });
	      });
	    };
	
	    Set.prototype.subtract = function() {var iters = SLICE$0.call(arguments, 0);
	      if (iters.length === 0) {
	        return this;
	      }
	      iters = iters.map(function(iter ) {return SetIterable(iter)});
	      var originalSet = this;
	      return this.withMutations(function(set ) {
	        originalSet.forEach(function(value ) {
	          if (iters.some(function(iter ) {return iter.includes(value)})) {
	            set.remove(value);
	          }
	        });
	      });
	    };
	
	    Set.prototype.merge = function() {
	      return this.union.apply(this, arguments);
	    };
	
	    Set.prototype.mergeWith = function(merger) {var iters = SLICE$0.call(arguments, 1);
	      return this.union.apply(this, iters);
	    };
	
	    Set.prototype.sort = function(comparator) {
	      // Late binding
	      return OrderedSet(sortFactory(this, comparator));
	    };
	
	    Set.prototype.sortBy = function(mapper, comparator) {
	      // Late binding
	      return OrderedSet(sortFactory(this, comparator, mapper));
	    };
	
	    Set.prototype.wasAltered = function() {
	      return this._map.wasAltered();
	    };
	
	    Set.prototype.__iterate = function(fn, reverse) {var this$0 = this;
	      return this._map.__iterate(function(_, k)  {return fn(k, k, this$0)}, reverse);
	    };
	
	    Set.prototype.__iterator = function(type, reverse) {
	      return this._map.map(function(_, k)  {return k}).__iterator(type, reverse);
	    };
	
	    Set.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      var newMap = this._map.__ensureOwner(ownerID);
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        this._map = newMap;
	        return this;
	      }
	      return this.__make(newMap, ownerID);
	    };
	
	
	  function isSet(maybeSet) {
	    return !!(maybeSet && maybeSet[IS_SET_SENTINEL]);
	  }
	
	  Set.isSet = isSet;
	
	  var IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
	
	  var SetPrototype = Set.prototype;
	  SetPrototype[IS_SET_SENTINEL] = true;
	  SetPrototype[DELETE] = SetPrototype.remove;
	  SetPrototype.mergeDeep = SetPrototype.merge;
	  SetPrototype.mergeDeepWith = SetPrototype.mergeWith;
	  SetPrototype.withMutations = MapPrototype.withMutations;
	  SetPrototype.asMutable = MapPrototype.asMutable;
	  SetPrototype.asImmutable = MapPrototype.asImmutable;
	
	  SetPrototype.__empty = emptySet;
	  SetPrototype.__make = makeSet;
	
	  function updateSet(set, newMap) {
	    if (set.__ownerID) {
	      set.size = newMap.size;
	      set._map = newMap;
	      return set;
	    }
	    return newMap === set._map ? set :
	      newMap.size === 0 ? set.__empty() :
	      set.__make(newMap);
	  }
	
	  function makeSet(map, ownerID) {
	    var set = Object.create(SetPrototype);
	    set.size = map ? map.size : 0;
	    set._map = map;
	    set.__ownerID = ownerID;
	    return set;
	  }
	
	  var EMPTY_SET;
	  function emptySet() {
	    return EMPTY_SET || (EMPTY_SET = makeSet(emptyMap()));
	  }
	
	  createClass(OrderedSet, Set);
	
	    // @pragma Construction
	
	    function OrderedSet(value) {
	      return value === null || value === undefined ? emptyOrderedSet() :
	        isOrderedSet(value) ? value :
	        emptyOrderedSet().withMutations(function(set ) {
	          var iter = SetIterable(value);
	          assertNotInfinite(iter.size);
	          iter.forEach(function(v ) {return set.add(v)});
	        });
	    }
	
	    OrderedSet.of = function(/*...values*/) {
	      return this(arguments);
	    };
	
	    OrderedSet.fromKeys = function(value) {
	      return this(KeyedIterable(value).keySeq());
	    };
	
	    OrderedSet.prototype.toString = function() {
	      return this.__toString('OrderedSet {', '}');
	    };
	
	
	  function isOrderedSet(maybeOrderedSet) {
	    return isSet(maybeOrderedSet) && isOrdered(maybeOrderedSet);
	  }
	
	  OrderedSet.isOrderedSet = isOrderedSet;
	
	  var OrderedSetPrototype = OrderedSet.prototype;
	  OrderedSetPrototype[IS_ORDERED_SENTINEL] = true;
	
	  OrderedSetPrototype.__empty = emptyOrderedSet;
	  OrderedSetPrototype.__make = makeOrderedSet;
	
	  function makeOrderedSet(map, ownerID) {
	    var set = Object.create(OrderedSetPrototype);
	    set.size = map ? map.size : 0;
	    set._map = map;
	    set.__ownerID = ownerID;
	    return set;
	  }
	
	  var EMPTY_ORDERED_SET;
	  function emptyOrderedSet() {
	    return EMPTY_ORDERED_SET || (EMPTY_ORDERED_SET = makeOrderedSet(emptyOrderedMap()));
	  }
	
	  createClass(Stack, IndexedCollection);
	
	    // @pragma Construction
	
	    function Stack(value) {
	      return value === null || value === undefined ? emptyStack() :
	        isStack(value) ? value :
	        emptyStack().unshiftAll(value);
	    }
	
	    Stack.of = function(/*...values*/) {
	      return this(arguments);
	    };
	
	    Stack.prototype.toString = function() {
	      return this.__toString('Stack [', ']');
	    };
	
	    // @pragma Access
	
	    Stack.prototype.get = function(index, notSetValue) {
	      var head = this._head;
	      index = wrapIndex(this, index);
	      while (head && index--) {
	        head = head.next;
	      }
	      return head ? head.value : notSetValue;
	    };
	
	    Stack.prototype.peek = function() {
	      return this._head && this._head.value;
	    };
	
	    // @pragma Modification
	
	    Stack.prototype.push = function(/*...values*/) {
	      if (arguments.length === 0) {
	        return this;
	      }
	      var newSize = this.size + arguments.length;
	      var head = this._head;
	      for (var ii = arguments.length - 1; ii >= 0; ii--) {
	        head = {
	          value: arguments[ii],
	          next: head
	        };
	      }
	      if (this.__ownerID) {
	        this.size = newSize;
	        this._head = head;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return makeStack(newSize, head);
	    };
	
	    Stack.prototype.pushAll = function(iter) {
	      iter = IndexedIterable(iter);
	      if (iter.size === 0) {
	        return this;
	      }
	      assertNotInfinite(iter.size);
	      var newSize = this.size;
	      var head = this._head;
	      iter.reverse().forEach(function(value ) {
	        newSize++;
	        head = {
	          value: value,
	          next: head
	        };
	      });
	      if (this.__ownerID) {
	        this.size = newSize;
	        this._head = head;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return makeStack(newSize, head);
	    };
	
	    Stack.prototype.pop = function() {
	      return this.slice(1);
	    };
	
	    Stack.prototype.unshift = function(/*...values*/) {
	      return this.push.apply(this, arguments);
	    };
	
	    Stack.prototype.unshiftAll = function(iter) {
	      return this.pushAll(iter);
	    };
	
	    Stack.prototype.shift = function() {
	      return this.pop.apply(this, arguments);
	    };
	
	    Stack.prototype.clear = function() {
	      if (this.size === 0) {
	        return this;
	      }
	      if (this.__ownerID) {
	        this.size = 0;
	        this._head = undefined;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return emptyStack();
	    };
	
	    Stack.prototype.slice = function(begin, end) {
	      if (wholeSlice(begin, end, this.size)) {
	        return this;
	      }
	      var resolvedBegin = resolveBegin(begin, this.size);
	      var resolvedEnd = resolveEnd(end, this.size);
	      if (resolvedEnd !== this.size) {
	        // super.slice(begin, end);
	        return IndexedCollection.prototype.slice.call(this, begin, end);
	      }
	      var newSize = this.size - resolvedBegin;
	      var head = this._head;
	      while (resolvedBegin--) {
	        head = head.next;
	      }
	      if (this.__ownerID) {
	        this.size = newSize;
	        this._head = head;
	        this.__hash = undefined;
	        this.__altered = true;
	        return this;
	      }
	      return makeStack(newSize, head);
	    };
	
	    // @pragma Mutability
	
	    Stack.prototype.__ensureOwner = function(ownerID) {
	      if (ownerID === this.__ownerID) {
	        return this;
	      }
	      if (!ownerID) {
	        this.__ownerID = ownerID;
	        this.__altered = false;
	        return this;
	      }
	      return makeStack(this.size, this._head, ownerID, this.__hash);
	    };
	
	    // @pragma Iteration
	
	    Stack.prototype.__iterate = function(fn, reverse) {
	      if (reverse) {
	        return this.reverse().__iterate(fn);
	      }
	      var iterations = 0;
	      var node = this._head;
	      while (node) {
	        if (fn(node.value, iterations++, this) === false) {
	          break;
	        }
	        node = node.next;
	      }
	      return iterations;
	    };
	
	    Stack.prototype.__iterator = function(type, reverse) {
	      if (reverse) {
	        return this.reverse().__iterator(type);
	      }
	      var iterations = 0;
	      var node = this._head;
	      return new Iterator(function()  {
	        if (node) {
	          var value = node.value;
	          node = node.next;
	          return iteratorValue(type, iterations++, value);
	        }
	        return iteratorDone();
	      });
	    };
	
	
	  function isStack(maybeStack) {
	    return !!(maybeStack && maybeStack[IS_STACK_SENTINEL]);
	  }
	
	  Stack.isStack = isStack;
	
	  var IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
	
	  var StackPrototype = Stack.prototype;
	  StackPrototype[IS_STACK_SENTINEL] = true;
	  StackPrototype.withMutations = MapPrototype.withMutations;
	  StackPrototype.asMutable = MapPrototype.asMutable;
	  StackPrototype.asImmutable = MapPrototype.asImmutable;
	  StackPrototype.wasAltered = MapPrototype.wasAltered;
	
	
	  function makeStack(size, head, ownerID, hash) {
	    var map = Object.create(StackPrototype);
	    map.size = size;
	    map._head = head;
	    map.__ownerID = ownerID;
	    map.__hash = hash;
	    map.__altered = false;
	    return map;
	  }
	
	  var EMPTY_STACK;
	  function emptyStack() {
	    return EMPTY_STACK || (EMPTY_STACK = makeStack(0));
	  }
	
	  /**
	   * Contributes additional methods to a constructor
	   */
	  function mixin(ctor, methods) {
	    var keyCopier = function(key ) { ctor.prototype[key] = methods[key]; };
	    Object.keys(methods).forEach(keyCopier);
	    Object.getOwnPropertySymbols &&
	      Object.getOwnPropertySymbols(methods).forEach(keyCopier);
	    return ctor;
	  }
	
	  Iterable.Iterator = Iterator;
	
	  mixin(Iterable, {
	
	    // ### Conversion to other types
	
	    toArray: function() {
	      assertNotInfinite(this.size);
	      var array = new Array(this.size || 0);
	      this.valueSeq().__iterate(function(v, i)  { array[i] = v; });
	      return array;
	    },
	
	    toIndexedSeq: function() {
	      return new ToIndexedSequence(this);
	    },
	
	    toJS: function() {
	      return this.toSeq().map(
	        function(value ) {return value && typeof value.toJS === 'function' ? value.toJS() : value}
	      ).__toJS();
	    },
	
	    toJSON: function() {
	      return this.toSeq().map(
	        function(value ) {return value && typeof value.toJSON === 'function' ? value.toJSON() : value}
	      ).__toJS();
	    },
	
	    toKeyedSeq: function() {
	      return new ToKeyedSequence(this, true);
	    },
	
	    toMap: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return Map(this.toKeyedSeq());
	    },
	
	    toObject: function() {
	      assertNotInfinite(this.size);
	      var object = {};
	      this.__iterate(function(v, k)  { object[k] = v; });
	      return object;
	    },
	
	    toOrderedMap: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return OrderedMap(this.toKeyedSeq());
	    },
	
	    toOrderedSet: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return OrderedSet(isKeyed(this) ? this.valueSeq() : this);
	    },
	
	    toSet: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return Set(isKeyed(this) ? this.valueSeq() : this);
	    },
	
	    toSetSeq: function() {
	      return new ToSetSequence(this);
	    },
	
	    toSeq: function() {
	      return isIndexed(this) ? this.toIndexedSeq() :
	        isKeyed(this) ? this.toKeyedSeq() :
	        this.toSetSeq();
	    },
	
	    toStack: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return Stack(isKeyed(this) ? this.valueSeq() : this);
	    },
	
	    toList: function() {
	      // Use Late Binding here to solve the circular dependency.
	      return List(isKeyed(this) ? this.valueSeq() : this);
	    },
	
	
	    // ### Common JavaScript methods and properties
	
	    toString: function() {
	      return '[Iterable]';
	    },
	
	    __toString: function(head, tail) {
	      if (this.size === 0) {
	        return head + tail;
	      }
	      return head + ' ' + this.toSeq().map(this.__toStringMapper).join(', ') + ' ' + tail;
	    },
	
	
	    // ### ES6 Collection methods (ES6 Array and Map)
	
	    concat: function() {var values = SLICE$0.call(arguments, 0);
	      return reify(this, concatFactory(this, values));
	    },
	
	    includes: function(searchValue) {
	      return this.some(function(value ) {return is(value, searchValue)});
	    },
	
	    entries: function() {
	      return this.__iterator(ITERATE_ENTRIES);
	    },
	
	    every: function(predicate, context) {
	      assertNotInfinite(this.size);
	      var returnValue = true;
	      this.__iterate(function(v, k, c)  {
	        if (!predicate.call(context, v, k, c)) {
	          returnValue = false;
	          return false;
	        }
	      });
	      return returnValue;
	    },
	
	    filter: function(predicate, context) {
	      return reify(this, filterFactory(this, predicate, context, true));
	    },
	
	    find: function(predicate, context, notSetValue) {
	      var entry = this.findEntry(predicate, context);
	      return entry ? entry[1] : notSetValue;
	    },
	
	    findEntry: function(predicate, context) {
	      var found;
	      this.__iterate(function(v, k, c)  {
	        if (predicate.call(context, v, k, c)) {
	          found = [k, v];
	          return false;
	        }
	      });
	      return found;
	    },
	
	    findLastEntry: function(predicate, context) {
	      return this.toSeq().reverse().findEntry(predicate, context);
	    },
	
	    forEach: function(sideEffect, context) {
	      assertNotInfinite(this.size);
	      return this.__iterate(context ? sideEffect.bind(context) : sideEffect);
	    },
	
	    join: function(separator) {
	      assertNotInfinite(this.size);
	      separator = separator !== undefined ? '' + separator : ',';
	      var joined = '';
	      var isFirst = true;
	      this.__iterate(function(v ) {
	        isFirst ? (isFirst = false) : (joined += separator);
	        joined += v !== null && v !== undefined ? v.toString() : '';
	      });
	      return joined;
	    },
	
	    keys: function() {
	      return this.__iterator(ITERATE_KEYS);
	    },
	
	    map: function(mapper, context) {
	      return reify(this, mapFactory(this, mapper, context));
	    },
	
	    reduce: function(reducer, initialReduction, context) {
	      assertNotInfinite(this.size);
	      var reduction;
	      var useFirst;
	      if (arguments.length < 2) {
	        useFirst = true;
	      } else {
	        reduction = initialReduction;
	      }
	      this.__iterate(function(v, k, c)  {
	        if (useFirst) {
	          useFirst = false;
	          reduction = v;
	        } else {
	          reduction = reducer.call(context, reduction, v, k, c);
	        }
	      });
	      return reduction;
	    },
	
	    reduceRight: function(reducer, initialReduction, context) {
	      var reversed = this.toKeyedSeq().reverse();
	      return reversed.reduce.apply(reversed, arguments);
	    },
	
	    reverse: function() {
	      return reify(this, reverseFactory(this, true));
	    },
	
	    slice: function(begin, end) {
	      return reify(this, sliceFactory(this, begin, end, true));
	    },
	
	    some: function(predicate, context) {
	      return !this.every(not(predicate), context);
	    },
	
	    sort: function(comparator) {
	      return reify(this, sortFactory(this, comparator));
	    },
	
	    values: function() {
	      return this.__iterator(ITERATE_VALUES);
	    },
	
	
	    // ### More sequential methods
	
	    butLast: function() {
	      return this.slice(0, -1);
	    },
	
	    isEmpty: function() {
	      return this.size !== undefined ? this.size === 0 : !this.some(function()  {return true});
	    },
	
	    count: function(predicate, context) {
	      return ensureSize(
	        predicate ? this.toSeq().filter(predicate, context) : this
	      );
	    },
	
	    countBy: function(grouper, context) {
	      return countByFactory(this, grouper, context);
	    },
	
	    equals: function(other) {
	      return deepEqual(this, other);
	    },
	
	    entrySeq: function() {
	      var iterable = this;
	      if (iterable._cache) {
	        // We cache as an entries array, so we can just return the cache!
	        return new ArraySeq(iterable._cache);
	      }
	      var entriesSequence = iterable.toSeq().map(entryMapper).toIndexedSeq();
	      entriesSequence.fromEntrySeq = function()  {return iterable.toSeq()};
	      return entriesSequence;
	    },
	
	    filterNot: function(predicate, context) {
	      return this.filter(not(predicate), context);
	    },
	
	    findLast: function(predicate, context, notSetValue) {
	      return this.toKeyedSeq().reverse().find(predicate, context, notSetValue);
	    },
	
	    first: function() {
	      return this.find(returnTrue);
	    },
	
	    flatMap: function(mapper, context) {
	      return reify(this, flatMapFactory(this, mapper, context));
	    },
	
	    flatten: function(depth) {
	      return reify(this, flattenFactory(this, depth, true));
	    },
	
	    fromEntrySeq: function() {
	      return new FromEntriesSequence(this);
	    },
	
	    get: function(searchKey, notSetValue) {
	      return this.find(function(_, key)  {return is(key, searchKey)}, undefined, notSetValue);
	    },
	
	    getIn: function(searchKeyPath, notSetValue) {
	      var nested = this;
	      // Note: in an ES6 environment, we would prefer:
	      // for (var key of searchKeyPath) {
	      var iter = forceIterator(searchKeyPath);
	      var step;
	      while (!(step = iter.next()).done) {
	        var key = step.value;
	        nested = nested && nested.get ? nested.get(key, NOT_SET) : NOT_SET;
	        if (nested === NOT_SET) {
	          return notSetValue;
	        }
	      }
	      return nested;
	    },
	
	    groupBy: function(grouper, context) {
	      return groupByFactory(this, grouper, context);
	    },
	
	    has: function(searchKey) {
	      return this.get(searchKey, NOT_SET) !== NOT_SET;
	    },
	
	    hasIn: function(searchKeyPath) {
	      return this.getIn(searchKeyPath, NOT_SET) !== NOT_SET;
	    },
	
	    isSubset: function(iter) {
	      iter = typeof iter.includes === 'function' ? iter : Iterable(iter);
	      return this.every(function(value ) {return iter.includes(value)});
	    },
	
	    isSuperset: function(iter) {
	      iter = typeof iter.isSubset === 'function' ? iter : Iterable(iter);
	      return iter.isSubset(this);
	    },
	
	    keySeq: function() {
	      return this.toSeq().map(keyMapper).toIndexedSeq();
	    },
	
	    last: function() {
	      return this.toSeq().reverse().first();
	    },
	
	    max: function(comparator) {
	      return maxFactory(this, comparator);
	    },
	
	    maxBy: function(mapper, comparator) {
	      return maxFactory(this, comparator, mapper);
	    },
	
	    min: function(comparator) {
	      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator);
	    },
	
	    minBy: function(mapper, comparator) {
	      return maxFactory(this, comparator ? neg(comparator) : defaultNegComparator, mapper);
	    },
	
	    rest: function() {
	      return this.slice(1);
	    },
	
	    skip: function(amount) {
	      return this.slice(Math.max(0, amount));
	    },
	
	    skipLast: function(amount) {
	      return reify(this, this.toSeq().reverse().skip(amount).reverse());
	    },
	
	    skipWhile: function(predicate, context) {
	      return reify(this, skipWhileFactory(this, predicate, context, true));
	    },
	
	    skipUntil: function(predicate, context) {
	      return this.skipWhile(not(predicate), context);
	    },
	
	    sortBy: function(mapper, comparator) {
	      return reify(this, sortFactory(this, comparator, mapper));
	    },
	
	    take: function(amount) {
	      return this.slice(0, Math.max(0, amount));
	    },
	
	    takeLast: function(amount) {
	      return reify(this, this.toSeq().reverse().take(amount).reverse());
	    },
	
	    takeWhile: function(predicate, context) {
	      return reify(this, takeWhileFactory(this, predicate, context));
	    },
	
	    takeUntil: function(predicate, context) {
	      return this.takeWhile(not(predicate), context);
	    },
	
	    valueSeq: function() {
	      return this.toIndexedSeq();
	    },
	
	
	    // ### Hashable Object
	
	    hashCode: function() {
	      return this.__hash || (this.__hash = hashIterable(this));
	    }
	
	
	    // ### Internal
	
	    // abstract __iterate(fn, reverse)
	
	    // abstract __iterator(type, reverse)
	  });
	
	  // var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
	  // var IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
	  // var IS_INDEXED_SENTINEL = '@@__IMMUTABLE_INDEXED__@@';
	  // var IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
	
	  var IterablePrototype = Iterable.prototype;
	  IterablePrototype[IS_ITERABLE_SENTINEL] = true;
	  IterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.values;
	  IterablePrototype.__toJS = IterablePrototype.toArray;
	  IterablePrototype.__toStringMapper = quoteString;
	  IterablePrototype.inspect =
	  IterablePrototype.toSource = function() { return this.toString(); };
	  IterablePrototype.chain = IterablePrototype.flatMap;
	  IterablePrototype.contains = IterablePrototype.includes;
	
	  // Temporary warning about using length
	  (function () {
	    try {
	      Object.defineProperty(IterablePrototype, 'length', {
	        get: function () {
	          if (!Iterable.noLengthWarning) {
	            var stack;
	            try {
	              throw new Error();
	            } catch (error) {
	              stack = error.stack;
	            }
	            if (stack.indexOf('_wrapObject') === -1) {
	              console && console.warn && console.warn(
	                'iterable.length has been deprecated, '+
	                'use iterable.size or iterable.count(). '+
	                'This warning will become a silent error in a future version. ' +
	                stack
	              );
	              return this.size;
	            }
	          }
	        }
	      });
	    } catch (e) {}
	  })();
	
	
	
	  mixin(KeyedIterable, {
	
	    // ### More sequential methods
	
	    flip: function() {
	      return reify(this, flipFactory(this));
	    },
	
	    findKey: function(predicate, context) {
	      var entry = this.findEntry(predicate, context);
	      return entry && entry[0];
	    },
	
	    findLastKey: function(predicate, context) {
	      return this.toSeq().reverse().findKey(predicate, context);
	    },
	
	    keyOf: function(searchValue) {
	      return this.findKey(function(value ) {return is(value, searchValue)});
	    },
	
	    lastKeyOf: function(searchValue) {
	      return this.findLastKey(function(value ) {return is(value, searchValue)});
	    },
	
	    mapEntries: function(mapper, context) {var this$0 = this;
	      var iterations = 0;
	      return reify(this,
	        this.toSeq().map(
	          function(v, k)  {return mapper.call(context, [k, v], iterations++, this$0)}
	        ).fromEntrySeq()
	      );
	    },
	
	    mapKeys: function(mapper, context) {var this$0 = this;
	      return reify(this,
	        this.toSeq().flip().map(
	          function(k, v)  {return mapper.call(context, k, v, this$0)}
	        ).flip()
	      );
	    }
	
	  });
	
	  var KeyedIterablePrototype = KeyedIterable.prototype;
	  KeyedIterablePrototype[IS_KEYED_SENTINEL] = true;
	  KeyedIterablePrototype[ITERATOR_SYMBOL] = IterablePrototype.entries;
	  KeyedIterablePrototype.__toJS = IterablePrototype.toObject;
	  KeyedIterablePrototype.__toStringMapper = function(v, k)  {return JSON.stringify(k) + ': ' + quoteString(v)};
	
	
	
	  mixin(IndexedIterable, {
	
	    // ### Conversion to other types
	
	    toKeyedSeq: function() {
	      return new ToKeyedSequence(this, false);
	    },
	
	
	    // ### ES6 Collection methods (ES6 Array and Map)
	
	    filter: function(predicate, context) {
	      return reify(this, filterFactory(this, predicate, context, false));
	    },
	
	    findIndex: function(predicate, context) {
	      var entry = this.findEntry(predicate, context);
	      return entry ? entry[0] : -1;
	    },
	
	    indexOf: function(searchValue) {
	      var key = this.toKeyedSeq().keyOf(searchValue);
	      return key === undefined ? -1 : key;
	    },
	
	    lastIndexOf: function(searchValue) {
	      var key = this.toKeyedSeq().reverse().keyOf(searchValue);
	      return key === undefined ? -1 : key;
	
	      // var index =
	      // return this.toSeq().reverse().indexOf(searchValue);
	    },
	
	    reverse: function() {
	      return reify(this, reverseFactory(this, false));
	    },
	
	    slice: function(begin, end) {
	      return reify(this, sliceFactory(this, begin, end, false));
	    },
	
	    splice: function(index, removeNum /*, ...values*/) {
	      var numArgs = arguments.length;
	      removeNum = Math.max(removeNum | 0, 0);
	      if (numArgs === 0 || (numArgs === 2 && !removeNum)) {
	        return this;
	      }
	      // If index is negative, it should resolve relative to the size of the
	      // collection. However size may be expensive to compute if not cached, so
	      // only call count() if the number is in fact negative.
	      index = resolveBegin(index, index < 0 ? this.count() : this.size);
	      var spliced = this.slice(0, index);
	      return reify(
	        this,
	        numArgs === 1 ?
	          spliced :
	          spliced.concat(arrCopy(arguments, 2), this.slice(index + removeNum))
	      );
	    },
	
	
	    // ### More collection methods
	
	    findLastIndex: function(predicate, context) {
	      var key = this.toKeyedSeq().findLastKey(predicate, context);
	      return key === undefined ? -1 : key;
	    },
	
	    first: function() {
	      return this.get(0);
	    },
	
	    flatten: function(depth) {
	      return reify(this, flattenFactory(this, depth, false));
	    },
	
	    get: function(index, notSetValue) {
	      index = wrapIndex(this, index);
	      return (index < 0 || (this.size === Infinity ||
	          (this.size !== undefined && index > this.size))) ?
	        notSetValue :
	        this.find(function(_, key)  {return key === index}, undefined, notSetValue);
	    },
	
	    has: function(index) {
	      index = wrapIndex(this, index);
	      return index >= 0 && (this.size !== undefined ?
	        this.size === Infinity || index < this.size :
	        this.indexOf(index) !== -1
	      );
	    },
	
	    interpose: function(separator) {
	      return reify(this, interposeFactory(this, separator));
	    },
	
	    interleave: function(/*...iterables*/) {
	      var iterables = [this].concat(arrCopy(arguments));
	      var zipped = zipWithFactory(this.toSeq(), IndexedSeq.of, iterables);
	      var interleaved = zipped.flatten(true);
	      if (zipped.size) {
	        interleaved.size = zipped.size * iterables.length;
	      }
	      return reify(this, interleaved);
	    },
	
	    last: function() {
	      return this.get(-1);
	    },
	
	    skipWhile: function(predicate, context) {
	      return reify(this, skipWhileFactory(this, predicate, context, false));
	    },
	
	    zip: function(/*, ...iterables */) {
	      var iterables = [this].concat(arrCopy(arguments));
	      return reify(this, zipWithFactory(this, defaultZipper, iterables));
	    },
	
	    zipWith: function(zipper/*, ...iterables */) {
	      var iterables = arrCopy(arguments);
	      iterables[0] = this;
	      return reify(this, zipWithFactory(this, zipper, iterables));
	    }
	
	  });
	
	  IndexedIterable.prototype[IS_INDEXED_SENTINEL] = true;
	  IndexedIterable.prototype[IS_ORDERED_SENTINEL] = true;
	
	
	
	  mixin(SetIterable, {
	
	    // ### ES6 Collection methods (ES6 Array and Map)
	
	    get: function(value, notSetValue) {
	      return this.has(value) ? value : notSetValue;
	    },
	
	    includes: function(value) {
	      return this.has(value);
	    },
	
	
	    // ### More sequential methods
	
	    keySeq: function() {
	      return this.valueSeq();
	    }
	
	  });
	
	  SetIterable.prototype.has = IterablePrototype.includes;
	
	
	  // Mixin subclasses
	
	  mixin(KeyedSeq, KeyedIterable.prototype);
	  mixin(IndexedSeq, IndexedIterable.prototype);
	  mixin(SetSeq, SetIterable.prototype);
	
	  mixin(KeyedCollection, KeyedIterable.prototype);
	  mixin(IndexedCollection, IndexedIterable.prototype);
	  mixin(SetCollection, SetIterable.prototype);
	
	
	  // #pragma Helper functions
	
	  function keyMapper(v, k) {
	    return k;
	  }
	
	  function entryMapper(v, k) {
	    return [k, v];
	  }
	
	  function not(predicate) {
	    return function() {
	      return !predicate.apply(this, arguments);
	    }
	  }
	
	  function neg(predicate) {
	    return function() {
	      return -predicate.apply(this, arguments);
	    }
	  }
	
	  function quoteString(value) {
	    return typeof value === 'string' ? JSON.stringify(value) : value;
	  }
	
	  function defaultZipper() {
	    return arrCopy(arguments);
	  }
	
	  function defaultNegComparator(a, b) {
	    return a < b ? 1 : a > b ? -1 : 0;
	  }
	
	  function hashIterable(iterable) {
	    if (iterable.size === Infinity) {
	      return 0;
	    }
	    var ordered = isOrdered(iterable);
	    var keyed = isKeyed(iterable);
	    var h = ordered ? 1 : 0;
	    var size = iterable.__iterate(
	      keyed ?
	        ordered ?
	          function(v, k)  { h = 31 * h + hashMerge(hash(v), hash(k)) | 0; } :
	          function(v, k)  { h = h + hashMerge(hash(v), hash(k)) | 0; } :
	        ordered ?
	          function(v ) { h = 31 * h + hash(v) | 0; } :
	          function(v ) { h = h + hash(v) | 0; }
	    );
	    return murmurHashOfSize(size, h);
	  }
	
	  function murmurHashOfSize(size, h) {
	    h = imul(h, 0xCC9E2D51);
	    h = imul(h << 15 | h >>> -15, 0x1B873593);
	    h = imul(h << 13 | h >>> -13, 5);
	    h = (h + 0xE6546B64 | 0) ^ size;
	    h = imul(h ^ h >>> 16, 0x85EBCA6B);
	    h = imul(h ^ h >>> 13, 0xC2B2AE35);
	    h = smi(h ^ h >>> 16);
	    return h;
	  }
	
	  function hashMerge(a, b) {
	    return a ^ b + 0x9E3779B9 + (a << 6) + (a >> 2) | 0; // int
	  }
	
	  var Immutable = {
	
	    Iterable: Iterable,
	
	    Seq: Seq,
	    Collection: Collection,
	    Map: Map,
	    OrderedMap: OrderedMap,
	    List: List,
	    Stack: Stack,
	    Set: Set,
	    OrderedSet: OrderedSet,
	
	    Record: Record,
	    Range: Range,
	    Repeat: Repeat,
	
	    is: is,
	    fromJS: fromJS
	
	  };
	
	  return Immutable;
	
	}));

/***/ },
/* 347 */,
/* 348 */,
/* 349 */,
/* 350 */,
/* 351 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * Renders the green tear-shaped handle under the cursor.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(355),
	    cursorHandleRadiusPx = _require.cursorHandleRadiusPx,
	    brightGreen = _require.brightGreen,
	    cursorHandleDistanceMultiplier = _require.cursorHandleDistanceMultiplier;
	
	var touchTargetRadiusPx = 22;
	var touchTargetHeightPx = 2 * touchTargetRadiusPx;
	var touchTargetWidthPx = 2 * touchTargetRadiusPx;
	
	var cursorRadiusPx = cursorHandleRadiusPx;
	var cursorHeightPx = cursorHandleDistanceMultiplier * cursorRadiusPx + cursorRadiusPx;
	var cursorWidthPx = 2 * cursorRadiusPx;
	
	var CursorHandle = function (_React$Component) {
	    _inherits(CursorHandle, _React$Component);
	
	    function CursorHandle() {
	        _classCallCheck(this, CursorHandle);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    CursorHandle.prototype.render = function render() {
	        var _props = this.props,
	            x = _props.x,
	            y = _props.y,
	            animateIntoPosition = _props.animateIntoPosition;
	
	
	        var animationStyle = animateIntoPosition ? {
	            msTransitionDuration: '100ms',
	            WebkitTransitionDuration: '100ms',
	            transitionDuration: '100ms',
	            msTransitionProperty: 'transform',
	            WebkitTransitionProperty: 'transform',
	            transitionProperty: 'transform'
	        } : {};
	        var transformString = 'translate(' + x + 'px, ' + y + 'px)';
	
	        var outerStyle = _extends({
	            position: 'absolute',
	            // This is essentially webapp's interactiveComponent + 1.
	            // TODO(charlie): Pull in those styles somehow to avoid breakages.
	            zIndex: 4,
	            left: -touchTargetWidthPx / 2,
	            top: 0,
	            msTransform: transformString,
	            WebkitTransform: transformString,
	            transform: transformString,
	            width: touchTargetWidthPx,
	            height: touchTargetHeightPx,
	            // Touch events that start on the cursor shouldn't be allowed to
	            // produce page scrolls.
	            touchAction: "none"
	        }, animationStyle);
	
	        var innerStyle = {
	            marginLeft: touchTargetRadiusPx - cursorRadiusPx
	        };
	
	        return React.createElement(
	            'span',
	            {
	                style: outerStyle,
	                onTouchStart: this.props.onTouchStart,
	                onTouchMove: this.props.onTouchMove,
	                onTouchEnd: this.props.onTouchEnd,
	                onTouchCancel: this.props.onTouchCancel
	            },
	            React.createElement(
	                'svg',
	                {
	                    width: cursorWidthPx,
	                    height: cursorHeightPx,
	                    viewBox: '-' + cursorRadiusPx + ' 0 ' + cursorWidthPx + ' ' + cursorHeightPx,
	                    style: innerStyle
	                },
	                React.createElement('path', {
	                    d: 'M 0 0\n                        L -' + 0.707 * cursorRadiusPx + ' ' + 0.707 * cursorRadiusPx + '\n                        A ' + cursorRadiusPx + ' ' + cursorRadiusPx + ', 0, 1, 0,\n                          ' + 0.707 * cursorRadiusPx + ' ' + 0.707 * cursorRadiusPx + '\n                        Z',
	                    fill: brightGreen
	                })
	            )
	        );
	    };
	
	    return CursorHandle;
	}(React.Component);
	
	CursorHandle.propTypes = {
	    animateIntoPosition: React.PropTypes.bool,
	    onTouchCancel: React.PropTypes.func.isRequired,
	    onTouchEnd: React.PropTypes.func.isRequired,
	    onTouchMove: React.PropTypes.func.isRequired,
	    onTouchStart: React.PropTypes.func.isRequired,
	    visible: React.PropTypes.bool.isRequired,
	    x: React.PropTypes.number.isRequired,
	    y: React.PropTypes.number.isRequired
	};
	CursorHandle.defaultProps = {
	    animateIntoPosition: false,
	    visible: false,
	    x: 0,
	    y: 0
	};
	
	
	module.exports = CursorHandle;

/***/ },
/* 352 */
/***/ function(module, exports, __webpack_require__) {

	var _KeyActions, _NormalCommands, _KeysForJumpContext;
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * This file contains a wrapper around MathQuill so that we can provide a
	 * more regular interface for the functionality we need while insulating us
	 * from MathQuill changes.
	 */
	
	var $ = __webpack_require__(491);
	// TODO(kevinb) allow test code to use const MathQuill = require('mathquill');
	var MathQuill = window.MathQuill;
	
	var Keys = __webpack_require__(395);
	var CursorContexts = __webpack_require__(310);
	
	var _require = __webpack_require__(283),
	    DecimalSeparators = _require.DecimalSeparators;
	
	var _require2 = __webpack_require__(396),
	    decimalSeparator = _require2.decimalSeparator;
	
	var decimalSymbol = decimalSeparator === DecimalSeparators.COMMA ? ',' : '.';
	
	var WRITE = 'write';
	var CMD = 'cmd';
	var KEYSTROKE = 'keystroke';
	var MQ_END = 0;
	
	// A mapping from keys that can be pressed on a keypad to the way in which
	// MathQuill should modify its input in response to that key-press. Any keys
	// that do not provide explicit actions (like the numeral keys) will merely
	// write their contents to MathQuill.
	var KeyActions = (_KeyActions = {}, _KeyActions[Keys.PLUS] = { str: '+', fn: WRITE }, _KeyActions[Keys.MINUS] = { str: '-', fn: WRITE }, _KeyActions[Keys.NEGATIVE] = { str: '-', fn: WRITE }, _KeyActions[Keys.TIMES] = { str: '\\times', fn: WRITE }, _KeyActions[Keys.DIVIDE] = { str: '\\div', fn: WRITE }, _KeyActions[Keys.DECIMAL] = {
	    str: decimalSymbol,
	    fn: WRITE
	}, _KeyActions[Keys.EQUAL] = { str: '=', fn: WRITE }, _KeyActions[Keys.NEQ] = { str: '\\neq', fn: WRITE }, _KeyActions[Keys.CDOT] = { str: '\\cdot', fn: WRITE }, _KeyActions[Keys.PERCENT] = { str: '%', fn: WRITE }, _KeyActions[Keys.LEFT_PAREN] = { str: '(', fn: CMD }, _KeyActions[Keys.RIGHT_PAREN] = { str: ')', fn: CMD }, _KeyActions[Keys.SQRT] = { str: 'sqrt', fn: CMD }, _KeyActions[Keys.PI] = { str: 'pi', fn: CMD }, _KeyActions[Keys.THETA] = { str: 'theta', fn: CMD }, _KeyActions[Keys.RADICAL] = { str: 'nthroot', fn: CMD }, _KeyActions[Keys.LT] = { str: '<', fn: WRITE }, _KeyActions[Keys.LEQ] = { str: '\\leq', fn: WRITE }, _KeyActions[Keys.GT] = { str: '>', fn: WRITE }, _KeyActions[Keys.GEQ] = { str: '\\geq', fn: WRITE }, _KeyActions[Keys.UP] = { str: 'Up', fn: KEYSTROKE }, _KeyActions[Keys.DOWN] = { str: 'Down', fn: KEYSTROKE }, _KeyActions[Keys.FRAC_INCLUSIVE] = { str: '/', fn: CMD }, _KeyActions);
	
	var NormalCommands = (_NormalCommands = {}, _NormalCommands[Keys.LOG] = 'log', _NormalCommands[Keys.LN] = 'ln', _NormalCommands[Keys.SIN] = 'sin', _NormalCommands[Keys.COS] = 'cos', _NormalCommands[Keys.TAN] = 'tan', _NormalCommands);
	
	var ArithmeticOperators = ['+', '-', '\\cdot', '\\times', '\\div'];
	var EqualityOperators = ['=', '\\neq', '<', '\\leq', '>', '\\geq'];
	
	var Numerals = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
	var GreekLetters = ['\\theta', '\\pi'];
	var Letters = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'];
	
	// We only consider numerals, variables, and Greek Letters to be proper
	// leaf nodes.
	var ValidLeaves = [].concat(Numerals, GreekLetters, Letters.map(function (letter) {
	    return letter.toLowerCase();
	}), Letters.map(function (letter) {
	    return letter.toUpperCase();
	}));
	
	var KeysForJumpContext = (_KeysForJumpContext = {}, _KeysForJumpContext[CursorContexts.IN_PARENS] = Keys.JUMP_OUT_PARENTHESES, _KeysForJumpContext[CursorContexts.IN_SUPER_SCRIPT] = Keys.JUMP_OUT_EXPONENT, _KeysForJumpContext[CursorContexts.IN_SUB_SCRIPT] = Keys.JUMP_OUT_BASE, _KeysForJumpContext[CursorContexts.BEFORE_FRACTION] = Keys.JUMP_INTO_NUMERATOR, _KeysForJumpContext[CursorContexts.IN_NUMERATOR] = Keys.JUMP_OUT_NUMERATOR, _KeysForJumpContext[CursorContexts.IN_DENOMINATOR] = Keys.JUMP_OUT_DENOMINATOR, _KeysForJumpContext);
	
	var MathWrapper = function () {
	    function MathWrapper(element) {
	        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
	        var callbacks = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
	
	        _classCallCheck(this, MathWrapper);
	
	        this.MQ = MathQuill.getInterface(2);
	        this.mathField = this.MQ.MathField(element, {
	            // use a span instead of a textarea so that we don't bring up the
	            // native keyboard on mobile when selecting the input
	            substituteTextarea: function substituteTextarea() {
	                return document.createElement('span');
	            }
	        });
	        this.callbacks = callbacks;
	    }
	
	    MathWrapper.prototype.focus = function focus() {
	        // HACK(charlie): We shouldn't reaching into MathQuill internals like
	        // this, but it's the easiest way to allow us to manage the focus state
	        // ourselves.
	        var controller = this.mathField.__controller;
	        controller.cursor.show();
	
	        // Set MathQuill's internal state to reflect the focus, otherwise it
	        // will consistently try to hide the cursor on key-press and introduce
	        // layout jank.
	        controller.blurred = false;
	    };
	
	    MathWrapper.prototype.blur = function blur() {
	        var controller = this.mathField.__controller;
	        controller.cursor.hide();
	        controller.blurred = true;
	    };
	
	    MathWrapper.prototype._writeNormalFunction = function _writeNormalFunction(name) {
	        this.mathField.write('\\' + name + '\\left(\\right)');
	        this.mathField.keystroke('Left');
	    };
	
	    /**
	     * Handle a key press and return the resulting cursor state.
	     *
	     * @param {Key} key - an enum representing the key that was pressed
	     * @returns {object} a cursor object, consisting of a cursor context
	     */
	
	
	    MathWrapper.prototype.pressKey = function pressKey(key) {
	        var cursor = this.mathField.__controller.cursor;
	
	        if (key in KeyActions) {
	            var _KeyActions$key = KeyActions[key],
	                str = _KeyActions$key.str,
	                fn = _KeyActions$key.fn;
	
	
	            if (str && fn) {
	                this.mathField[fn](str);
	            }
	        } else if (Object.keys(NormalCommands).includes(key)) {
	            this._writeNormalFunction(NormalCommands[key]);
	        } else if (key === Keys.FRAC_EXCLUSIVE) {
	            // If there's nothing to the left of the cursor, then we want to
	            // leave the cursor to the left of the fraction after creating it.
	            var shouldNavigateLeft = cursor[this.MQ.L] === MQ_END;
	            this.mathField.cmd('\\frac');
	            if (shouldNavigateLeft) {
	                this.mathField.keystroke('Left');
	            }
	        } else if (key === Keys.LOG_N) {
	            this.mathField.write('log_{ }\\left(\\right)');
	            this.mathField.keystroke('Left'); // into parentheses
	            this.mathField.keystroke('Left'); // out of parentheses
	            this.mathField.keystroke('Left'); // into index
	        } else if (key === Keys.CUBE_ROOT) {
	            this.mathField.write('\\sqrt[3]{}');
	            this.mathField.keystroke('Left'); // under the root
	        } else if (key === Keys.EXP || key === Keys.EXP_2 || key === Keys.EXP_3) {
	            this._handleExponent(cursor, key);
	        } else if (key === Keys.JUMP_OUT_PARENTHESES || key === Keys.JUMP_OUT_EXPONENT || key === Keys.JUMP_OUT_BASE || key === Keys.JUMP_INTO_NUMERATOR || key === Keys.JUMP_OUT_NUMERATOR || key === Keys.JUMP_OUT_DENOMINATOR) {
	            this._handleJumpOut(cursor, key);
	        } else if (key === Keys.BACKSPACE) {
	            this._handleBackspace(cursor);
	        } else if (key === Keys.LEFT) {
	            this._handleLeftArrow(cursor);
	        } else if (key === Keys.RIGHT || key === Keys.JUMP_OUT) {
	            this._handleRightArrow(cursor);
	        } else if (/^[a-zA-Z]$/.test(key)) {
	            this.mathField[WRITE](key);
	        } else if (/^NUM_\d/.test(key)) {
	            this.mathField[WRITE](key[4]);
	        }
	
	        if (!cursor.selection) {
	            // don't show the cursor for selections
	            cursor.show();
	        }
	
	        if (this.callbacks.onSelectionChanged) {
	            this.callbacks.onSelectionChanged(cursor.selection);
	        }
	
	        // NOTE(charlie): It's insufficient to do this as an `edited` handler
	        // on the MathField, as that handler isn't triggered on navigation
	        // events.
	        return {
	            context: this.contextForCursor(cursor)
	        };
	    };
	
	    /**
	     * Place the cursor beside the node located at the given coordinates.
	     *
	     * @param {number} x - the x coordinate in the viewport
	     * @param {number} y - the y coordinate in the viewport
	     * @param {Node} hitNode - the node next to which the cursor should be
	     *                         placed; if provided, the coordinates will be used
	     *                         to determine on which side of the node the cursor
	     *                         should be placed
	     */
	
	
	    MathWrapper.prototype.setCursorPosition = function setCursorPosition(x, y, hitNode) {
	        var el = hitNode || document.elementFromPoint(x, y);
	
	        if (el) {
	            var cursor = this.getCursor();
	
	            if (el.hasAttribute('mq-root-block')) {
	                // If we're in the empty area place the cursor at the right
	                // end of the expression.
	                cursor.insAtRightEnd(this.mathField.__controller.root);
	            } else {
	                // Otherwise place beside the element at x, y.
	                var controller = this.mathField.__controller;
	
	                var pageX = x - document.body.scrollLeft;
	                var pageY = y - document.body.scrollTop;
	                controller.seek($(el), pageX, pageY).cursor.startSelection();
	
	                // Unless that would leave us mid-command, in which case, we
	                // need to adjust and place the cursor inside the parens
	                // following the command.
	                var command = this._maybeFindCommand(cursor[this.MQ.L]);
	                if (command && command.endNode) {
	                    // NOTE(charlie): endNode should definitely be \left(.
	                    cursor.insLeftOf(command.endNode);
	                    this.mathField.keystroke('Right');
	                }
	            }
	
	            if (this.callbacks.onCursorMove) {
	                this.callbacks.onCursorMove({
	                    context: this.contextForCursor(cursor)
	                });
	            }
	        }
	    };
	
	    MathWrapper.prototype.getCursor = function getCursor() {
	        return this.mathField.__controller.cursor;
	    };
	
	    MathWrapper.prototype.getSelection = function getSelection() {
	        return this.getCursor().selection;
	    };
	
	    MathWrapper.prototype.getContent = function getContent() {
	        return this.mathField.latex();
	    };
	
	    MathWrapper.prototype.setContent = function setContent(latex) {
	        this.mathField.latex(latex);
	    };
	
	    MathWrapper.prototype.isEmpty = function isEmpty() {
	        var cursor = this.getCursor();
	        return cursor.parent.id === 1 && cursor[1] === 0 && cursor[-1] === 0;
	    };
	
	    // Notes about MathQuill
	    //
	    // MathQuill's stores its layout as nested linked lists.  Each node in the
	    // list has this.MQ.L '-1' and this.MQ.R '1' properties that define links to
	    // the left and right nodes respectively.  They also have
	    //
	    // ctrlSeq: contains the latex code snippet that defines that node.
	    // jQ: jQuery object for the DOM node(s) for this MathQuill node.
	    // ends: pointers to the nodes at the ends of the container.
	    // parent: parent node.
	    // blocks: an array containing one or more nodes that make up the node.
	    // sub?: subscript node if there is one as is the case in log_n
	    //
	    // All of the code below is super fragile.  Please be especially careful
	    // when upgrading MathQuill.
	
	    MathWrapper.prototype._handleBackspaceInNthRoot = function _handleBackspaceInNthRoot(cursor) {
	        var isAtLeftEnd = cursor[this.MQ.L] === MQ_END;
	
	        var isRootEmpty = this._isInsideEmptyNode(cursor.parent.parent.blocks[0].ends);
	
	        if (isAtLeftEnd) {
	            this._selectNode(cursor.parent.parent, cursor);
	
	            if (isRootEmpty) {
	                this.mathField.keystroke('Backspace');
	            }
	        } else {
	            this.mathField.keystroke('Backspace');
	        }
	    };
	
	    /**
	     * Advances the cursor to the next logical position.
	     *
	     * @param {cursor} cursor
	     * @private
	     */
	
	
	    MathWrapper.prototype._handleJumpOut = function _handleJumpOut(cursor, key) {
	        var context = this.contextForCursor(cursor);
	
	        // Validate that the current cursor context matches the key's intent.
	        if (KeysForJumpContext[context] !== key) {
	            // If we don't have a valid cursor context, yet the user was able
	            // to trigger a jump-out key, that's a broken invariant. Rather
	            // than throw an error (which would kick the user out of the
	            // exercise), we do nothing, as a fallback strategy. The user can
	            // still move the cursor manually.
	            return;
	        }
	
	        switch (context) {
	            case CursorContexts.IN_PARENS:
	                // Insert at the end of the parentheses, and then navigate right
	                // once more to get 'beyond' the parentheses.
	                cursor.insRightOf(cursor.parent.parent);
	                break;
	
	            case CursorContexts.BEFORE_FRACTION:
	                // Find the nearest fraction to the right of the cursor.
	                var fractionNode = void 0;
	                var visitor = cursor;
	                while (visitor[this.MQ.R] !== MQ_END) {
	                    if (this._isFraction(visitor[this.MQ.R])) {
	                        fractionNode = visitor[this.MQ.R];
	                    }
	                    visitor = visitor[this.MQ.R];
	                }
	
	                // Jump into it!
	                cursor.insLeftOf(fractionNode);
	                this.mathField.keystroke('Right');
	                break;
	
	            case CursorContexts.IN_NUMERATOR:
	                // HACK(charlie): I can't find a better way to do this. The goal
	                // is to place the cursor at the start of the matching
	                // denominator. So, we identify the appropriate node, and
	                // continue rightwards until we find ourselves inside of it.
	                // It's possible that there are cases in which we don't reach
	                // the denominator, though I can't think of any.
	                var siblingDenominator = cursor.parent.parent.blocks[1];
	                while (cursor.parent !== siblingDenominator) {
	                    this.mathField.keystroke('Right');
	                }
	                break;
	
	            case CursorContexts.IN_DENOMINATOR:
	                cursor.insRightOf(cursor.parent.parent);
	                break;
	
	            case CursorContexts.IN_SUB_SCRIPT:
	                // Insert just beyond the superscript.
	                cursor.insRightOf(cursor.parent.parent);
	
	                // Navigate right once more, if we're right before parens. This
	                // is to handle the standard case in which the subscript is the
	                // base of a custom log.
	                if (this._isParens(cursor[this.MQ.R])) {
	                    this.mathField.keystroke('Right');
	                }
	                break;
	
	            case CursorContexts.IN_SUPER_SCRIPT:
	                // Insert just beyond the superscript.
	                cursor.insRightOf(cursor.parent.parent);
	                break;
	
	            default:
	                throw new Error('Attempted to \'Jump Out\' from node, but found no ' + ('appropriate cursor context: ' + context));
	        }
	    };
	
	    /**
	     * Selects and deletes part of the expression based on the cursor location.
	     * See inline comments for precise behavior of different cases.
	     *
	     * @param {cursor} cursor
	     * @private
	     */
	
	
	    MathWrapper.prototype._handleBackspace = function _handleBackspace(cursor) {
	        if (!cursor.selection) {
	            var parent = cursor.parent;
	            var grandparent = parent.parent;
	            var leftNode = cursor[this.MQ.L];
	
	            if (this._isFraction(leftNode)) {
	                this._selectNode(leftNode, cursor);
	            } else if (this._isSquareRoot(leftNode)) {
	                this._selectNode(leftNode, cursor);
	            } else if (this._isNthRoot(leftNode)) {
	                this._selectNode(leftNode, cursor);
	            } else if (this._isNthRootIndex(parent)) {
	                this._handleBackspaceInRootIndex(cursor);
	            } else if (leftNode.ctrlSeq === '\\left(') {
	                this._handleBackspaceOutsideParens(cursor);
	            } else if (grandparent.ctrlSeq === '\\left(') {
	                this._handleBackspaceInsideParens(cursor);
	            } else if (this._isInsideLogIndex(cursor)) {
	                this._handleBackspaceInLogIndex(cursor);
	            } else if (leftNode.ctrlSeq === '\\ge ' || leftNode.ctrlSeq === '\\le ') {
	                this._handleBackspaceAfterLigaturedSymbol(cursor);
	            } else if (this._isNthRoot(grandparent) && leftNode === MQ_END) {
	                this._handleBackspaceInNthRoot(cursor);
	            } else {
	                this.mathField.keystroke('Backspace');
	            }
	        } else {
	            this.mathField.keystroke('Backspace');
	        }
	    };
	
	    MathWrapper.prototype._handleLeftArrow = function _handleLeftArrow(cursor) {
	        // If we're inside a function, and just after the left parentheses, we
	        // need to skip the entire function name, rather than move the cursor
	        // inside of it. For example, when hitting left from within the
	        // parentheses in `cos()`, we want to place the cursor to the left of
	        // the entire expression, rather than between the `s` and the left
	        // parenthesis.
	        // From the cursor's perspective, this requires that our left node is
	        // the MQ_END node, that our grandparent is the left parenthesis, and
	        // the nodes to the left of our grandparent comprise a valid function
	        // name.
	        if (cursor[this.MQ.L] === MQ_END) {
	            var parent = cursor.parent;
	            var grandparent = parent.parent;
	            if (grandparent.ctrlSeq === '\\left(') {
	                var command = this._maybeFindCommandBeforeParens(grandparent);
	                if (command) {
	                    cursor.insLeftOf(command.startNode);
	                    return;
	                }
	            }
	        }
	
	        // Otherwise, we default to the standard MathQull left behavior.
	        this.mathField.keystroke('Left');
	    };
	
	    MathWrapper.prototype._handleRightArrow = function _handleRightArrow(cursor) {
	        var command = this._maybeFindCommand(cursor[this.MQ.R]);
	        if (command) {
	            // Similarly, if a function is to our right, then we need to place
	            // the cursor at the start of its parenthetical content, which is
	            // done by putting it to the left of ites parentheses and then
	            // moving right once.
	            cursor.insLeftOf(command.endNode);
	            this.mathField.keystroke('Right');
	        } else {
	            // Otherwise, we default to the standard MathQull right behavior.
	            this.mathField.keystroke('Right');
	        }
	    };
	
	    MathWrapper.prototype._handleExponent = function _handleExponent(cursor, key) {
	        // If there's an invalid operator preceding the cursor (anything that
	        // knowingly cannot be raised to a power), add an empty set of
	        // parentheses and apply the exponent to that.
	        var invalidPrefixes = [].concat(ArithmeticOperators, EqualityOperators);
	
	        var precedingNode = cursor[this.MQ.L];
	        var shouldPrefixWithParens = precedingNode === MQ_END || invalidPrefixes.includes(precedingNode.ctrlSeq.trim());
	        if (shouldPrefixWithParens) {
	            this.mathField.write('\\left(\\right)');
	        }
	
	        // Insert the appropriate exponent operator.
	        switch (key) {
	            case Keys.EXP:
	                this.mathField.cmd('^');
	                break;
	
	            case Keys.EXP_2:
	            case Keys.EXP_3:
	                this.mathField.write('^' + (key === Keys.EXP_2 ? 2 : 3));
	
	                // If we enter a square or a cube, we should leave the cursor
	                // within the newly inserted parens, if they exist. This takes
	                // exactly four left strokes, since the cursor by default would
	                // end up to the right of the exponent.
	                if (shouldPrefixWithParens) {
	                    this.mathField.keystroke('Left');
	                    this.mathField.keystroke('Left');
	                    this.mathField.keystroke('Left');
	                    this.mathField.keystroke('Left');
	                }
	                break;
	
	            default:
	                throw new Error('Invalid exponent key: ' + key);
	        }
	    };
	
	    /**
	     * Return the start node, end node, and full name of the command of which
	     * the initial node is a part, or `null` if the node is not part of a
	     * command.
	     *
	     * @param {node} initialNode - the node to included as part of the command
	     * @returns {null|object} - `null` or an object containing the start node
	     *                          (`startNode`), end node (`endNode`), and full
	     *                          name (`name`) of the command
	     * @private
	     */
	
	
	    MathWrapper.prototype._maybeFindCommand = function _maybeFindCommand(initialNode) {
	        if (!initialNode) {
	            return null;
	        }
	
	        // MathQuill stores commands as separate characters so that
	        // users can delete commands one character at a time.  We iterate over
	        // the nodes from right to left until we hit a sequence starting with a
	        // '\\', which signifies the start of a command; then we iterate from
	        // left to right until we hit a '\\left(', which signifies the end of a
	        // command.  If we encounter any character that doesn't belong in a
	        // command, we return null.  We match a single character at a time.
	        // Ex) ['\\l', 'o', 'g ', '\\left(', ...]
	        var commandCharRegex = /^[a-z]$/;
	        var commandStartRegex = /^\\[a-z]$/;
	        var commandEndSeq = '\\left(';
	
	        // Note: We whitelist the set of valid commands, since relying solely on
	        // a command being prefixed with a backslash leads to undesired
	        // behavior. For example, Greek symbols, left parentheses, and square
	        // roots all get treated as commands.
	        var validCommands = ['\\log', '\\ln', '\\cos', '\\sin', '\\tan'];
	
	        var name = '';
	        var startNode = void 0;
	        var endNode = void 0;
	
	        // Collect the portion of the command from the current node, leftwards
	        // until the start of the command.
	        var node = initialNode;
	        while (node !== 0) {
	            var ctrlSeq = node.ctrlSeq.trim();
	            if (commandCharRegex.test(ctrlSeq)) {
	                name = ctrlSeq + name;
	            } else if (commandStartRegex.test(ctrlSeq)) {
	                name = ctrlSeq + name;
	                startNode = node;
	                break;
	            } else {
	                break;
	            }
	
	            node = node[this.MQ.L];
	        }
	
	        // If we hit the start of a command, then grab the rest of it by
	        // iterating rightwards to compute the full name of the command, along
	        // with its terminal node.
	        if (startNode) {
	            // Next, iterate from the start to the right.
	            node = initialNode[this.MQ.R];
	            while (node !== 0) {
	                var _ctrlSeq = node.ctrlSeq.trim();
	                if (commandCharRegex.test(_ctrlSeq)) {
	                    // If we have a single character, add it to the command
	                    // name.
	                    name = name + _ctrlSeq;
	                } else if (_ctrlSeq === commandEndSeq) {
	                    // If we hit the command end delimiter (the left
	                    // parentheses surrounding its arguments), stop.
	                    endNode = node;
	                    break;
	                }
	
	                node = node[this.MQ.R];
	            }
	            if (validCommands.includes(name)) {
	                return { name: name, startNode: startNode, endNode: endNode };
	            } else {
	                return null;
	            }
	        } else {
	            return null;
	        }
	    };
	
	    /**
	     * Return the start node, end node, and full name of the command to the left
	     * of `\\left(`, or `null` if there is no command.
	     *
	     * @param {node} leftParenNode - node where .ctrlSeq == `\\left(`
	     * @returns {null|object} - `null` or an object containing the start node
	     *                          (`startNode`), end node (`endNode`), and full
	     *                          name (`name`) of the command
	     * @private
	     */
	
	
	    MathWrapper.prototype._maybeFindCommandBeforeParens = function _maybeFindCommandBeforeParens(leftParenNode) {
	        return this._maybeFindCommand(leftParenNode[this.MQ.L]);
	    };
	
	    MathWrapper.prototype._selectNode = function _selectNode(node, cursor) {
	        cursor.insLeftOf(node);
	        cursor.startSelection();
	        cursor.insRightOf(node);
	        cursor.select();
	        cursor.endSelection();
	    };
	
	    MathWrapper.prototype._isFraction = function _isFraction(node) {
	        return node.jQ && node.jQ.hasClass('mq-fraction');
	    };
	
	    MathWrapper.prototype._isNumerator = function _isNumerator(node) {
	        return node.jQ && node.jQ.hasClass('mq-numerator');
	    };
	
	    MathWrapper.prototype._isDenominator = function _isDenominator(node) {
	        return node.jQ && node.jQ.hasClass('mq-denominator');
	    };
	
	    MathWrapper.prototype._isSubScript = function _isSubScript(node) {
	        // NOTE(charlie): MyScript has a structure whereby its superscripts seem
	        // to be represented as a parent node with 'mq-sup-only' containing a
	        // single child with 'mq-sup'.
	        return node.jQ && (node.jQ.hasClass('mq-sub-only') || node.jQ.hasClass('mq-sub'));
	    };
	
	    MathWrapper.prototype._isSuperScript = function _isSuperScript(node) {
	        // NOTE(charlie): MyScript has a structure whereby its superscripts seem
	        // to be represented as a parent node with 'mq-sup-only' containing a
	        // single child with 'mq-sup'.
	        return node.jQ && (node.jQ.hasClass('mq-sup-only') || node.jQ.hasClass('mq-sup'));
	    };
	
	    MathWrapper.prototype._isParens = function _isParens(node) {
	        return node && node.ctrlSeq === '\\left(';
	    };
	
	    MathWrapper.prototype._isLeaf = function _isLeaf(node) {
	        return node && node.ctrlSeq && ValidLeaves.includes(node.ctrlSeq.trim());
	    };
	
	    MathWrapper.prototype._isSquareRoot = function _isSquareRoot(node) {
	        return node.blocks && node.blocks[0].jQ && node.blocks[0].jQ.hasClass('mq-sqrt-stem');
	    };
	
	    MathWrapper.prototype._isNthRoot = function _isNthRoot(node) {
	        return node.blocks && node.blocks[0].jQ && node.blocks[0].jQ.hasClass('mq-nthroot');
	    };
	
	    MathWrapper.prototype._isNthRootIndex = function _isNthRootIndex(node) {
	        return node.jQ && node.jQ.hasClass('mq-nthroot');
	    };
	
	    MathWrapper.prototype._isInsideLogIndex = function _isInsideLogIndex(cursor) {
	        var grandparent = cursor.parent.parent;
	
	        if (grandparent && grandparent.jQ.hasClass('mq-supsub')) {
	            var command = this._maybeFindCommandBeforeParens(grandparent);
	
	            if (command && command.name === '\\log') {
	                return true;
	            }
	        }
	
	        return false;
	    };
	
	    MathWrapper.prototype._isInsideEmptyNode = function _isInsideEmptyNode(cursor) {
	        return cursor[this.MQ.L] === MQ_END && cursor[this.MQ.R] === MQ_END;
	    };
	
	    MathWrapper.prototype._handleBackspaceInRootIndex = function _handleBackspaceInRootIndex(cursor) {
	        if (this._isInsideEmptyNode(cursor)) {
	            // When deleting the index in a nthroot, we change from the nthroot
	            // to a sqrt, e.g. \sqrt[|]{35x-5} => |\sqrt{35x-5}.  If there's no
	            // content under the root, then we delete the whole thing.
	
	            var grandparent = cursor.parent.parent;
	            var latex = grandparent.latex();
	            var reinsertionPoint = grandparent[this.MQ.L];
	
	            this._selectNode(grandparent, cursor);
	
	            var rootIsEmpty = grandparent.blocks[1].jQ.text() === '';
	
	            if (rootIsEmpty) {
	                // If there is not content under the root then simply delete
	                // the whole thing.
	                this.mathField.keystroke('Backspace');
	            } else {
	                // Replace the nthroot with a sqrt if there was content under
	                // the root.
	
	                // Start by deleting the selection.
	                this.mathField.keystroke('Backspace');
	
	                // Replace the nth-root with a sqrt.
	                this.mathField.write(latex.replace(/^\\sqrt\[\]/, '\\sqrt'));
	
	                // Adjust the cursor to be to the left the sqrt.
	                if (reinsertionPoint === MQ_END) {
	                    this.mathField.moveToDirEnd(this.MQ.L);
	                } else {
	                    cursor.insRightOf(reinsertionPoint);
	                }
	            }
	        } else {
	            if (cursor[this.MQ.L] !== MQ_END) {
	                // If the cursor is not at the leftmost position inside the
	                // root's index, delete a character.
	                this.mathField.keystroke('Backspace');
	            } else {
	                // TODO(kevinb) verify that we want this behavior after testing
	                // Do nothing because we haven't completely deleted the
	                // index of the radical.
	            }
	        }
	    };
	
	    MathWrapper.prototype._handleBackspaceInLogIndex = function _handleBackspaceInLogIndex(cursor) {
	        if (this._isInsideEmptyNode(cursor)) {
	            var grandparent = cursor.parent.parent;
	            var command = this._maybeFindCommandBeforeParens(grandparent);
	
	            cursor.insLeftOf(command.startNode);
	            cursor.startSelection();
	
	            if (grandparent[this.MQ.R] !== MQ_END) {
	                cursor.insRightOf(grandparent[this.MQ.R]);
	            } else {
	                cursor.insRightOf(grandparent);
	            }
	
	            cursor.select();
	            cursor.endSelection();
	
	            var isLogBodyEmpty = grandparent[this.MQ.R].contentjQ.text() === '';
	
	            if (isLogBodyEmpty) {
	                // If there's no content inside the log's parens then delete the
	                // whole thing.
	                this.mathField.keystroke('Backspace');
	            }
	        } else {
	            this.mathField.keystroke('Backspace');
	        }
	    };
	
	    MathWrapper.prototype._handleBackspaceOutsideParens = function _handleBackspaceOutsideParens(cursor) {
	        // In this case the node with '\\left(' for its ctrlSeq
	        // is the parent of the expression contained within the
	        // parentheses.
	        //
	        // Handle selecting an expression before deleting:
	        // (x+1)| => |(x+1)|
	        // \log(x+1)| => |\log(x+1)|
	
	        var leftNode = cursor[this.MQ.L];
	        var rightNode = cursor[this.MQ.R];
	        var command = this._maybeFindCommandBeforeParens(leftNode);
	
	        if (command && command.startNode) {
	            // There's a command before the parens so we select it as well as
	            // the parens.
	            cursor.insLeftOf(command.startNode);
	            cursor.startSelection();
	            if (rightNode === MQ_END) {
	                cursor.insAtRightEnd(cursor.parent);
	            } else {
	                cursor.insLeftOf(rightNode);
	            }
	            cursor.select();
	            cursor.endSelection();
	        } else {
	            cursor.startSelection();
	            cursor.insLeftOf(leftNode); // left of \\left(
	            cursor.select();
	            cursor.endSelection();
	        }
	    };
	
	    MathWrapper.prototype._handleBackspaceInsideParens = function _handleBackspaceInsideParens(cursor) {
	        // Handle situations when the cursor is inside parens or a
	        // command that uses parens, e.g. \log() or \tan()
	        //
	        // MathQuill represents log(x+1) in roughly the following way
	        // [l, o, g, \\left[parent:[x, +, 1]]]
	        //
	        // If the cursor is inside the parentheses it's next to one of:
	        // x, +, or 1.  This makes sub_sub_expr its parent and sub_expr
	        // it's parent.
	        //
	        // Interestingly parent doesn't have any nodes to the left or
	        // right of it (even though the corresponding DOM node has
	        // ( and ) characters on either side.
	        //
	        // The grandparent's ctrlSeq is `\\left(`. The `\\right)` isn't
	        // stored anywhere.  NOTE(kevinb): I believe this is because
	        // MathQuill knows what the close paren should be and does the
	        // right thing at render time.
	        //
	        // This conditional branch handles the following cases:
	        // - \log(x+1|) => \log(x+|)
	        // - \log(|x+1) => |\log(x+1)|
	        // - \log(|) => |
	
	        if (cursor[this.MQ.L] !== MQ_END) {
	            // This command contains math and there's some math to
	            // the left of the cursor that we should delete normally
	            // before doing anything special.
	            this.mathField.keystroke('Backspace');
	            return;
	        }
	
	        var grandparent = cursor.parent.parent;
	
	        // If the cursors is inside the parens at the start but the command
	        // has a subscript as is the case in log_n then move the cursor into
	        // the subscript, e.g. \log_{5}(|x+1) => \log_{5|}(x+1)
	
	        if (grandparent[this.MQ.L].sub) {
	            // if there is a subscript
	            if (grandparent[this.MQ.L].sub.jQ.text()) {
	                // and it contains text
	                // move the cursor to the right end of the subscript
	                cursor.insAtRightEnd(grandparent[this.MQ.L].sub);
	                return;
	            }
	        }
	
	        // Determine if the parens are empty before we modify the
	        // cursor's position.
	        var isEmpty = this._isInsideEmptyNode(cursor);
	
	        // Insert the cursor to the left of the command if there is one
	        // or before the '\\left(` if there isn't
	        var command = this._maybeFindCommandBeforeParens(grandparent);
	
	        cursor.insLeftOf(command && command.startNode || grandparent);
	        cursor.startSelection();
	        cursor.insRightOf(grandparent);
	        cursor.select();
	        cursor.endSelection();
	
	        // Delete the selection, but only if the parens were empty to
	        // begin with.
	        if (isEmpty) {
	            this.mathField.keystroke('Backspace');
	        }
	    };
	
	    MathWrapper.prototype._handleBackspaceAfterLigaturedSymbol = function _handleBackspaceAfterLigaturedSymbol(cursor) {
	        this.mathField.keystroke('Backspace');
	        this.mathField.keystroke('Backspace');
	    };
	
	    MathWrapper.prototype.contextForCursor = function contextForCursor(cursor) {
	        // First, try to find any fraction to the right, unimpeded.
	        var visitor = cursor;
	        while (visitor[this.MQ.R] !== MQ_END) {
	            if (this._isFraction(visitor[this.MQ.R])) {
	                return CursorContexts.BEFORE_FRACTION;
	            } else if (!this._isLeaf(visitor[this.MQ.R])) {
	                break;
	            }
	            visitor = visitor[this.MQ.R];
	        }
	
	        // If that didn't work, check if the parent or grandparent is a special
	        // context, so that we can jump outwards.
	        if (this._isParens(cursor.parent && cursor.parent.parent)) {
	            return CursorContexts.IN_PARENS;
	        } else if (this._isNumerator(cursor.parent)) {
	            return CursorContexts.IN_NUMERATOR;
	        } else if (this._isDenominator(cursor.parent)) {
	            return CursorContexts.IN_DENOMINATOR;
	        } else if (this._isSubScript(cursor.parent)) {
	            return CursorContexts.IN_SUB_SCRIPT;
	        } else if (this._isSuperScript(cursor.parent)) {
	            return CursorContexts.IN_SUPER_SCRIPT;
	        } else {
	            return CursorContexts.NONE;
	        }
	    };
	
	    MathWrapper.prototype._isAtTopLevel = function _isAtTopLevel(cursor) {
	        return !cursor.parent.parent;
	    };
	
	    return MathWrapper;
	}();
	
	module.exports = MathWrapper;

/***/ },
/* 353 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A single function used to scroll a DOM node into view, optionally taking into
	 * account that it may be obscured by the custom keypad. The logic makes the
	 * strong assumption that the keypad will be anchored to the bottom of the page
	 * in calculating its height, as this method may be called before the keypad has
	 * animated into view.
	 *
	 * TODO(charlie): Move this scroll logic out of our components and into a higher
	 * level in the component tree--perhaps even into webapp, beyond Perseus.
	 */
	
	var _require = __webpack_require__(355),
	    toolbarHeightPx = _require.toolbarHeightPx;
	
	var scrollIntoView = function scrollIntoView(containerNode, keypadNode) {
	    // TODO(charlie): There's no need for us to be reading the keypad bounds
	    // here, since they're pre-determined by logic in the store. We should
	    // instead pass around an object that knows the bounds.
	    var containerBounds = containerNode.getBoundingClientRect();
	    var containerBottomPx = containerBounds.bottom;
	    var containerTopPx = containerBounds.top;
	
	    var desiredMarginPx = 16;
	
	    if (keypadNode) {
	        // NOTE(charlie): We can't use the bounding rect of the keypad,
	        // as it is likely in the process of animating in. Instead, to
	        // calculate its top, we make the strong assumption that the
	        // keypad will end up anchored at the bottom of the page, but above the
	        // toolbar, and use its height, which is known at this point. Note that,
	        // in the native apps (where the toolbar is rendered natively), this
	        // will result in us leaving excess space between the input and the
	        // keypad, but that seems okay.
	        var pageHeightPx = window.innerHeight;
	        var keypadHeightPx = keypadNode.clientHeight;
	        var keypadTopPx = pageHeightPx - (keypadHeightPx + toolbarHeightPx);
	
	        if (containerBottomPx > keypadTopPx) {
	            // If the input would be obscured by the keypad, scroll such that
	            // the bottom of the input is just above the top of the keypad,
	            // taking care not to scroll the input out of view.
	            var scrollOffset = Math.min(containerBottomPx - keypadTopPx + desiredMarginPx, containerTopPx);
	
	            document.body.scrollTop += scrollOffset;
	            return;
	        }
	    }
	
	    // Alternatively, if the input is out of the viewport or nearly out
	    // of the viewport, scroll it into view. We can do this regardless
	    // of whether the keypad has been provided.
	    if (containerTopPx < desiredMarginPx) {
	        document.body.scrollTop -= containerBounds.height + desiredMarginPx;
	    }
	};
	
	module.exports = scrollIntoView;

/***/ },
/* 354 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * A gesture recognizer that detects 'drags', crudely defined as either scrolls
	 * or touches that move a sufficient distance.
	 */
	
	// The 'slop' factor, after which we consider the use to be dragging. The value
	// is taken from the Android SDK. It won't be robust to page zoom and the like,
	// but it should be good enough for our purposes.
	var touchSlopPx = 8;
	
	var DragListener = function () {
	    function DragListener(onDrag, initialEvent) {
	        _classCallCheck(this, DragListener);
	
	        // We detect drags in two ways. First, by listening for the window
	        // scroll event (we consider any legitimate scroll to be a drag).
	        this._scrollListener = function () {
	            onDrag();
	        };
	
	        // And second, by listening for touch moves and tracking the each
	        // finger's displacement. This allows us to track, e.g., when the user
	        // scrolls within an individual view.
	        var touchLocationsById = {};
	        for (var i = 0; i < initialEvent.changedTouches.length; i++) {
	            var touch = initialEvent.changedTouches[i];
	            touchLocationsById[touch.identifier] = [touch.clientX, touch.clientY];
	        }
	
	        this._moveListener = function (evt) {
	            for (var _i = 0; _i < evt.changedTouches.length; _i++) {
	                var _touch = evt.changedTouches[_i];
	                var initialTouchLocation = touchLocationsById[_touch.identifier];
	                if (initialTouchLocation) {
	                    var touchLocation = [_touch.clientX, _touch.clientY];
	                    var dx = touchLocation[0] - initialTouchLocation[0];
	                    var dy = touchLocation[1] - initialTouchLocation[1];
	
	                    var squaredDist = dx * dx + dy * dy;
	                    var squaredTouchSlop = touchSlopPx * touchSlopPx;
	
	                    if (squaredDist > squaredTouchSlop) {
	                        onDrag();
	                    }
	                }
	            }
	        };
	
	        // Clean-up any terminated gestures, since some browsers reuse
	        // identifiers.
	        this._endAndCancelListener = function (evt) {
	            for (var _i2 = 0; _i2 < evt.changedTouches.length; _i2++) {
	                delete touchLocationsById[evt.changedTouches[_i2].identifier];
	            }
	        };
	    }
	
	    DragListener.prototype.attach = function attach() {
	        window.addEventListener('scroll', this._scrollListener);
	        window.addEventListener('touchmove', this._moveListener);
	        window.addEventListener('touchend', this._endAndCancelListener);
	        window.addEventListener('touchcancel', this._endAndCancelListener);
	    };
	
	    DragListener.prototype.detach = function detach() {
	        window.removeEventListener('scroll', this._scrollListener);
	        window.removeEventListener('touchmove', this._moveListener);
	        window.removeEventListener('touchend', this._endAndCancelListener);
	        window.removeEventListener('touchcancel', this._endAndCancelListener);
	    };
	
	    return DragListener;
	}();
	
	module.exports = DragListener;

/***/ },
/* 355 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Common parameters used to style components.
	 */
	
	var gray85 = '#D6D8DA';
	
	module.exports = {
	    brightGreen: '#78C008',
	    gray17: '#21242C',
	    gray25: '#3B3E40',
	    gray68: '#888D93',
	    gray76: '#BABEC2',
	    gray85: gray85,
	    iconSizeHeightPx: 48,
	    iconSizeWidthPx: 48,
	    compactKeypadBorderRadiusPx: 4,
	    cursorHandleRadiusPx: 11,
	
	    // The amount to multiply the radius by to get the distance from the
	    // center to the tip of the cursor handle.  The cursor is a circle with
	    // one quadrant replace with a square.  The hypotenuse of the square is
	    // 1.41 times the radius of the circle.
	    cursorHandleDistanceMultiplier: 1.41,
	
	    // Keypad button colors
	    valueGrey: '#FFF',
	    operatorGrey: '#FAFAFA',
	    controlGrey: '#F6F7F7',
	    emptyGrey: '#F0F1F2',
	
	    // Constants defining any borders between elements in the keypad.
	    innerBorderColor: gray85,
	    innerBorderStyle: 'solid',
	    innerBorderWidthPx: 1,
	
	    // The width at which a device is classified as a "tablet" for the purposes
	    // of the keypad layout.
	    tabletCutoffPx: 600,
	
	    // The dimensions that define various components in the tree, which may be
	    // needed outside of those components in order to determine various layout
	    // parameters.
	    pageIndicatorHeightPx: 16,
	    navigationPadWidthPx: 192,
	    // HACK(charlie): This should be injected by webapp somehow.
	    // TODO(charlie): Add a link to the webapp location as soon as the footer
	    // has settled down.
	    toolbarHeightPx: 60
	};

/***/ },
/* 356 */
/***/ function(module, exports, __webpack_require__) {

	/*!
	 * Raphael 1.5.2 - JavaScript Vector Library
	 *
	 * Copyright (c) 2010 Dmitry Baranovskiy (http://raphaeljs.com)
	 * Licensed under the MIT (http://raphaeljs.com/license.html) license.
	 */
	(function () {
	    var setAttr;
	    if ("".trim) {
	        setAttr = function(node, att, value) {
	            node.setAttribute(att, String(value).trim());
	        };
	    } else {
	        setAttr = function(node, att, value) {
	            node.setAttribute(att, String(value));
	        };
	    }
	    function R() {
	        if (R.is(arguments[0], array)) {
	            var a = arguments[0],
	                cnv = create[apply](R, a.splice(0, 3 + R.is(a[0], nu))),
	                res = cnv.set();
	            for (var i = 0, ii = a[length]; i < ii; i++) {
	                var j = a[i] || {};
	                elements[has](j.type) && res[push](cnv[j.type]().attr(j));
	            }
	            return res;
	        }
	        return create[apply](R, arguments);
	    }
	    R.version = "1.5.2";
	    var separator = /[, ]+/,
	        elements = {circle: 1, rect: 1, path: 1, ellipse: 1, text: 1, image: 1},
	        formatrg = /\{(\d+)\}/g,
	        proto = "prototype",
	        has = "hasOwnProperty",
	        doc = document,
	        win = window,
	        oldRaphael = {
	            was: Object[proto][has].call(win, "Raphael"),
	            is: win.Raphael
	        },
	        Paper = function () {
	            this.customAttributes = {};
	        },
	        paperproto,
	        appendChild = "appendChild",
	        apply = "apply",
	        concat = "concat",
	        supportsTouch = "createTouch" in doc,
	        E = "",
	        S = " ",
	        Str = String,
	        split = "split",
	        events = "click dblclick mousedown mousemove mouseout mouseover mouseup touchstart touchmove touchend orientationchange touchcancel gesturestart gesturechange gestureend"[split](S),
	        touchMap = {
	            mousedown: "touchstart",
	            mousemove: "touchmove",
	            mouseup: "touchend"
	        },
	        join = "join",
	        length = "length",
	        lowerCase = Str[proto].toLowerCase,
	        math = Math,
	        mmax = math.max,
	        mmin = math.min,
	        abs = math.abs,
	        pow = math.pow,
	        PI = math.PI,
	        nu = "number",
	        string = "string",
	        array = "array",
	        toString = "toString",
	        fillString = "fill",
	        objectToString = Object[proto][toString],
	        paper = {},
	        push = "push",
	        ISURL = /^url\(['"]?([^\)]+?)['"]?\)$/i,
	        colourRegExp = /^\s*((#[a-f\d]{6})|(#[a-f\d]{3})|rgba?\(\s*([\d\.]+%?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?)%?\s*\)|hsba?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?)%?\s*\)|hsla?\(\s*([\d\.]+(?:deg|\xb0|%)?\s*,\s*[\d\.]+%?\s*,\s*[\d\.]+(?:%?\s*,\s*[\d\.]+)?)%?\s*\))\s*$/i,
	        isnan = {"NaN": 1, "Infinity": 1, "-Infinity": 1},
	        bezierrg = /^(?:cubic-)?bezier\(([^,]+),([^,]+),([^,]+),([^\)]+)\)/,
	        round = math.round,
	        toFloat = parseFloat,
	        toInt = parseInt,
	        ms = " progid:DXImageTransform.Microsoft",
	        upperCase = Str[proto].toUpperCase,
	        availableAttrs = {blur: 0, "clip-rect": "0 0 1e9 1e9", cursor: "default", cx: 0, cy: 0, fill: "#fff", "fill-opacity": 1, font: '10px "Arial"', "font-family": '"Arial"', "font-size": "10", "font-style": "normal", "font-weight": 400, gradient: 0, height: 0, href: "http://raphaeljs.com/", opacity: 1, path: "M0,0", r: 0, rotation: 0, rx: 0, ry: 0, scale: "1 1", src: "", stroke: "#000", "stroke-dasharray": "", "stroke-linecap": "butt", "stroke-linejoin": "butt", "stroke-miterlimit": 0, "stroke-opacity": 1, "stroke-width": 1, target: "_blank", "text-anchor": "middle", title: "Raphael", translation: "0 0", width: 0, x: 0, y: 0},
	        availableAnimAttrs = {along: "along", blur: nu, "clip-rect": "csv", cx: nu, cy: nu, fill: "colour", "fill-opacity": nu, "font-size": nu, height: nu, opacity: nu, path: "path", r: nu, rotation: "csv", rx: nu, ry: nu, scale: "csv", stroke: "colour", "stroke-opacity": nu, "stroke-width": nu, translation: "csv", width: nu, x: nu, y: nu},
	        rp = "replace",
	        animKeyFrames= /^(from|to|\d+%?)$/,
	        commaSpaces = /\s*,\s*/,
	        hsrg = {hs: 1, rg: 1},
	        p2s = /,?([achlmqrstvxz]),?/gi,
	        pathCommand = /([achlmqstvz])[\s,]*((-?\d*\.?\d*(?:e[-+]?\d+)?\s*,?\s*)+)/ig,
	        pathValues = /(-?\d*\.?\d*(?:e[-+]?\d+)?)\s*,?\s*/ig,
	        radial_gradient = /^r(?:\(([^,]+?)\s*,\s*([^\)]+?)\))?/,
	        sortByKey = function (a, b) {
	            return a.key - b.key;
	        };
	
	    R.type = (win.SVGAngle || doc.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#BasicStructure", "1.1") ? "SVG" : "VML");
	    if (R.type == "VML") {
	        var d = doc.createElement("div"),
	            b;
	        d.innerHTML = '<v:shape adj="1"/>';
	        b = d.firstChild;
	        b.style.behavior = "url(#default#VML)";
	        if (!(b && typeof b.adj == "object")) {
	            return R.type = null;
	        }
	        d = null;
	    }
	    R.svg = !(R.vml = R.type == "VML");
	    Paper[proto] = R[proto];
	    paperproto = Paper[proto];
	    R._id = 0;
	    R._oid = 0;
	    R.fn = {};
	    R.is = function (o, type) {
	        type = lowerCase.call(type);
	        if (type == "finite") {
	            return !isnan[has](+o);
	        }
	        return  (type == "null" && o === null) ||
	                (type == typeof o) ||
	                (type == "object" && o === Object(o)) ||
	                (type == "array" && Array.isArray && Array.isArray(o)) ||
	                objectToString.call(o).slice(8, -1).toLowerCase() == type;
	    };
	    R.angle = function (x1, y1, x2, y2, x3, y3) {
	        if (x3 == null) {
	            var x = x1 - x2,
	                y = y1 - y2;
	            if (!x && !y) {
	                return 0;
	            }
	            return ((x < 0) * 180 + math.atan(-y / -x) * 180 / PI + 360) % 360;
	        } else {
	            return R.angle(x1, y1, x3, y3) - R.angle(x2, y2, x3, y3);
	        }
	    };
	    R.rad = function (deg) {
	        return deg % 360 * PI / 180;
	    };
	    R.deg = function (rad) {
	        return rad * 180 / PI % 360;
	    };
	    R.snapTo = function (values, value, tolerance) {
	        tolerance = R.is(tolerance, "finite") ? tolerance : 10;
	        if (R.is(values, array)) {
	            var i = values.length;
	            while (i--) if (abs(values[i] - value) <= tolerance) {
	                return values[i];
	            }
	        } else {
	            values = +values;
	            var rem = value % values;
	            if (rem < tolerance) {
	                return value - rem;
	            }
	            if (rem > values - tolerance) {
	                return value - rem + values;
	            }
	        }
	        return value;
	    };
	    function createUUID() {
	        // http://www.ietf.org/rfc/rfc4122.txt
	        var s = [],
	            i = 0;
	        for (; i < 32; i++) {
	            s[i] = (~~(math.random() * 16))[toString](16);
	        }
	        s[12] = 4;  // bits 12-15 of the time_hi_and_version field to 0010
	        s[16] = ((s[16] & 3) | 8)[toString](16);  // bits 6-7 of the clock_seq_hi_and_reserved to 01
	        return "r-" + s[join]("");
	    }
	
	    R.setWindow = function (newwin) {
	        win = newwin;
	        doc = win.document;
	    };
	    // colour utilities
	    var toHex = function (color) {
	        if (R.vml) {
	            // http://dean.edwards.name/weblog/2009/10/convert-any-colour-value-to-hex-in-msie/
	            var trim = /^\s+|\s+$/g;
	            var bod;
	            try {
	                var docum = new ActiveXObject("htmlfile");
	                docum.write("<body>");
	                docum.close();
	                bod = docum.body;
	            } catch(e) {
	                bod = createPopup().document.body;
	            }
	            var range = bod.createTextRange();
	            toHex = cacher(function (color) {
	                try {
	                    bod.style.color = Str(color)[rp](trim, E);
	                    var value = range.queryCommandValue("ForeColor");
	                    value = ((value & 255) << 16) | (value & 65280) | ((value & 16711680) >>> 16);
	                    return "#" + ("000000" + value[toString](16)).slice(-6);
	                } catch(e) {
	                    return "none";
	                }
	            });
	        } else {
	            var i = doc.createElement("i");
	            i.title = "Rapha\xebl Colour Picker";
	            i.style.display = "none";
	            doc.body[appendChild](i);
	            toHex = cacher(function (color) {
	                i.style.color = color;
	                return doc.defaultView.getComputedStyle(i, E).getPropertyValue("color");
	            });
	        }
	        return toHex(color);
	    },
	    hsbtoString = function () {
	        return "hsb(" + [this.h, this.s, this.b] + ")";
	    },
	    hsltoString = function () {
	        return "hsl(" + [this.h, this.s, this.l] + ")";
	    },
	    rgbtoString = function () {
	        return this.hex;
	    };
	    R.hsb2rgb = function (h, s, b, o) {
	        if (R.is(h, "object") && "h" in h && "s" in h && "b" in h) {
	            b = h.b;
	            s = h.s;
	            h = h.h;
	            o = h.o;
	        }
	        return R.hsl2rgb(h, s, b / 2, o);
	    };
	    R.hsl2rgb = function (h, s, l, o) {
	        if (R.is(h, "object") && "h" in h && "s" in h && "l" in h) {
	            l = h.l;
	            s = h.s;
	            h = h.h;
	        }
	        if (h > 1 || s > 1 || l > 1) {
	            h /= 360;
	            s /= 100;
	            l /= 100;
	        }
	        var rgb = {},
	            channels = ["r", "g", "b"],
	            t2, t1, t3, r, g, b;
	        if (!s) {
	            rgb = {
	                r: l,
	                g: l,
	                b: l
	            };
	        } else {
	            if (l < .5) {
	                t2 = l * (1 + s);
	            } else {
	                t2 = l + s - l * s;
	            }
	            t1 = 2 * l - t2;
	            for (var i = 0; i < 3; i++) {
	                t3 = h + 1 / 3 * -(i - 1);
	                t3 < 0 && t3++;
	                t3 > 1 && t3--;
	                if (t3 * 6 < 1) {
	                    rgb[channels[i]] = t1 + (t2 - t1) * 6 * t3;
	                } else if (t3 * 2 < 1) {
	                    rgb[channels[i]] = t2;
	                } else if (t3 * 3 < 2) {
	                    rgb[channels[i]] = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
	                } else {
	                    rgb[channels[i]] = t1;
	                }
	            }
	        }
	        rgb.r *= 255;
	        rgb.g *= 255;
	        rgb.b *= 255;
	        rgb.hex = "#" + (16777216 | rgb.b | (rgb.g << 8) | (rgb.r << 16)).toString(16).slice(1);
	        R.is(o, "finite") && (rgb.opacity = o);
	        rgb.toString = rgbtoString;
	        return rgb;
	    };
	    R.rgb2hsb = function (red, green, blue) {
	        if (green == null && R.is(red, "object") && "r" in red && "g" in red && "b" in red) {
	            blue = red.b;
	            green = red.g;
	            red = red.r;
	        }
	        if (green == null && R.is(red, string)) {
	            var clr = R.getRGB(red);
	            red = clr.r;
	            green = clr.g;
	            blue = clr.b;
	        }
	        if (red > 1 || green > 1 || blue > 1) {
	            red /= 255;
	            green /= 255;
	            blue /= 255;
	        }
	        var max = mmax(red, green, blue),
	            min = mmin(red, green, blue),
	            hue,
	            saturation,
	            brightness = max;
	        if (min == max) {
	            return {h: 0, s: 0, b: max, toString: hsbtoString};
	        } else {
	            var delta = (max - min);
	            saturation = delta / max;
	            if (red == max) {
	                hue = (green - blue) / delta;
	            } else if (green == max) {
	                hue = 2 + ((blue - red) / delta);
	            } else {
	                hue = 4 + ((red - green) / delta);
	            }
	            hue /= 6;
	            hue < 0 && hue++;
	            hue > 1 && hue--;
	        }
	        return {h: hue, s: saturation, b: brightness, toString: hsbtoString};
	    };
	    R.rgb2hsl = function (red, green, blue) {
	        if (green == null && R.is(red, "object") && "r" in red && "g" in red && "b" in red) {
	            blue = red.b;
	            green = red.g;
	            red = red.r;
	        }
	        if (green == null && R.is(red, string)) {
	            var clr = R.getRGB(red);
	            red = clr.r;
	            green = clr.g;
	            blue = clr.b;
	        }
	        if (red > 1 || green > 1 || blue > 1) {
	            red /= 255;
	            green /= 255;
	            blue /= 255;
	        }
	        var max = mmax(red, green, blue),
	            min = mmin(red, green, blue),
	            h,
	            s,
	            l = (max + min) / 2,
	            hsl;
	        if (min == max) {
	            hsl =  {h: 0, s: 0, l: l};
	        } else {
	            var delta = max - min;
	            s = l < .5 ? delta / (max + min) : delta / (2 - max - min);
	            if (red == max) {
	                h = (green - blue) / delta;
	            } else if (green == max) {
	                h = 2 + (blue - red) / delta;
	            } else {
	                h = 4 + (red - green) / delta;
	            }
	            h /= 6;
	            h < 0 && h++;
	            h > 1 && h--;
	            hsl = {h: h, s: s, l: l};
	        }
	        hsl.toString = hsltoString;
	        return hsl;
	    };
	    R._path2string = function () {
	        return this.join(",")[rp](p2s, "$1");
	    };
	    function cacher(f, scope, postprocessor) {
	        function newf() {
	            var arg = Array[proto].slice.call(arguments, 0),
	                args = arg[join]("\u25ba"),
	                cache = newf.cache = newf.cache || {},
	                count = newf.count = newf.count || [];
	            if (cache[has](args)) {
	                return postprocessor ? postprocessor(cache[args]) : cache[args];
	            }
	            count[length] >= 1e3 && delete cache[count.shift()];
	            count[push](args);
	            cache[args] = f[apply](scope, arg);
	            return postprocessor ? postprocessor(cache[args]) : cache[args];
	        }
	        return newf;
	    }
	
	    R.getRGB = cacher(function (colour) {
	        if (!colour || !!((colour = Str(colour)).indexOf("-") + 1)) {
	            return {r: -1, g: -1, b: -1, hex: "none", error: 1};
	        }
	        if (colour == "none") {
	            return {r: -1, g: -1, b: -1, hex: "none"};
	        }
	        !(hsrg[has](colour.toLowerCase().substring(0, 2)) || colour.charAt() == "#") && (colour = toHex(colour));
	        var res,
	            red,
	            green,
	            blue,
	            opacity,
	            t,
	            values,
	            rgb = colour.match(colourRegExp);
	        if (rgb) {
	            if (rgb[2]) {
	                blue = toInt(rgb[2].substring(5), 16);
	                green = toInt(rgb[2].substring(3, 5), 16);
	                red = toInt(rgb[2].substring(1, 3), 16);
	            }
	            if (rgb[3]) {
	                blue = toInt((t = rgb[3].charAt(3)) + t, 16);
	                green = toInt((t = rgb[3].charAt(2)) + t, 16);
	                red = toInt((t = rgb[3].charAt(1)) + t, 16);
	            }
	            if (rgb[4]) {
	                values = rgb[4][split](commaSpaces);
	                red = toFloat(values[0]);
	                values[0].slice(-1) == "%" && (red *= 2.55);
	                green = toFloat(values[1]);
	                values[1].slice(-1) == "%" && (green *= 2.55);
	                blue = toFloat(values[2]);
	                values[2].slice(-1) == "%" && (blue *= 2.55);
	                rgb[1].toLowerCase().slice(0, 4) == "rgba" && (opacity = toFloat(values[3]));
	                values[3] && values[3].slice(-1) == "%" && (opacity /= 100);
	            }
	            if (rgb[5]) {
	                values = rgb[5][split](commaSpaces);
	                red = toFloat(values[0]);
	                values[0].slice(-1) == "%" && (red *= 2.55);
	                green = toFloat(values[1]);
	                values[1].slice(-1) == "%" && (green *= 2.55);
	                blue = toFloat(values[2]);
	                values[2].slice(-1) == "%" && (blue *= 2.55);
	                (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360);
	                rgb[1].toLowerCase().slice(0, 4) == "hsba" && (opacity = toFloat(values[3]));
	                values[3] && values[3].slice(-1) == "%" && (opacity /= 100);
	                return R.hsb2rgb(red, green, blue, opacity);
	            }
	            if (rgb[6]) {
	                values = rgb[6][split](commaSpaces);
	                red = toFloat(values[0]);
	                values[0].slice(-1) == "%" && (red *= 2.55);
	                green = toFloat(values[1]);
	                values[1].slice(-1) == "%" && (green *= 2.55);
	                blue = toFloat(values[2]);
	                values[2].slice(-1) == "%" && (blue *= 2.55);
	                (values[0].slice(-3) == "deg" || values[0].slice(-1) == "\xb0") && (red /= 360);
	                rgb[1].toLowerCase().slice(0, 4) == "hsla" && (opacity = toFloat(values[3]));
	                values[3] && values[3].slice(-1) == "%" && (opacity /= 100);
	                return R.hsl2rgb(red, green, blue, opacity);
	            }
	            rgb = {r: red, g: green, b: blue};
	            rgb.hex = "#" + (16777216 | blue | (green << 8) | (red << 16)).toString(16).slice(1);
	            R.is(opacity, "finite") && (rgb.opacity = opacity);
	            return rgb;
	        }
	        return {r: -1, g: -1, b: -1, hex: "none", error: 1};
	    }, R);
	    R.getColor = function (value) {
	        var start = this.getColor.start = this.getColor.start || {h: 0, s: 1, b: value || .75},
	            rgb = this.hsb2rgb(start.h, start.s, start.b);
	        start.h += .075;
	        if (start.h > 1) {
	            start.h = 0;
	            start.s -= .2;
	            start.s <= 0 && (this.getColor.start = {h: 0, s: 1, b: start.b});
	        }
	        return rgb.hex;
	    };
	    R.getColor.reset = function () {
	        delete this.start;
	    };
	    // path utilities
	    R.parsePathString = cacher(function (pathString) {
	        if (!pathString) {
	            return null;
	        }
	        var paramCounts = {a: 7, c: 6, h: 1, l: 2, m: 2, q: 4, s: 4, t: 2, v: 1, z: 0},
	            data = [];
	        if (R.is(pathString, array) && R.is(pathString[0], array)) { // rough assumption
	            data = pathClone(pathString);
	        }
	        if (!data[length]) {
	            Str(pathString)[rp](pathCommand, function (a, b, c) {
	                var params = [],
	                    name = lowerCase.call(b);
	                c[rp](pathValues, function (a, b) {
	                    b && params[push](+b);
	                });
	                if (name == "m" && params[length] > 2) {
	                    data[push]([b][concat](params.splice(0, 2)));
	                    name = "l";
	                    b = b == "m" ? "l" : "L";
	                }
	                while (params[length] >= paramCounts[name]) {
	                    data[push]([b][concat](params.splice(0, paramCounts[name])));
	                    if (!paramCounts[name]) {
	                        break;
	                    }
	                }
	            });
	        }
	        data[toString] = R._path2string;
	        return data;
	    });
	    R.findDotsAtSegment = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
	        var t1 = 1 - t,
	            x = pow(t1, 3) * p1x + pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + pow(t, 3) * p2x,
	            y = pow(t1, 3) * p1y + pow(t1, 2) * 3 * t * c1y + t1 * 3 * t * t * c2y + pow(t, 3) * p2y,
	            mx = p1x + 2 * t * (c1x - p1x) + t * t * (c2x - 2 * c1x + p1x),
	            my = p1y + 2 * t * (c1y - p1y) + t * t * (c2y - 2 * c1y + p1y),
	            nx = c1x + 2 * t * (c2x - c1x) + t * t * (p2x - 2 * c2x + c1x),
	            ny = c1y + 2 * t * (c2y - c1y) + t * t * (p2y - 2 * c2y + c1y),
	            ax = (1 - t) * p1x + t * c1x,
	            ay = (1 - t) * p1y + t * c1y,
	            cx = (1 - t) * c2x + t * p2x,
	            cy = (1 - t) * c2y + t * p2y,
	            alpha = (90 - math.atan((mx - nx) / (my - ny)) * 180 / PI);
	        (mx > nx || my < ny) && (alpha += 180);
	        return {x: x, y: y, m: {x: mx, y: my}, n: {x: nx, y: ny}, start: {x: ax, y: ay}, end: {x: cx, y: cy}, alpha: alpha};
	    };
	    var pathDimensions = cacher(function (path) {
	        if (!path) {
	            return {x: 0, y: 0, width: 0, height: 0};
	        }
	        path = path2curve(path);
	        var x = 0,
	            y = 0,
	            X = [],
	            Y = [],
	            p;
	        for (var i = 0, ii = path[length]; i < ii; i++) {
	            p = path[i];
	            if (p[0] == "M") {
	                x = p[1];
	                y = p[2];
	                X[push](x);
	                Y[push](y);
	            } else {
	                var dim = curveDim(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
	                X = X[concat](dim.min.x, dim.max.x);
	                Y = Y[concat](dim.min.y, dim.max.y);
	                x = p[5];
	                y = p[6];
	            }
	        }
	        var xmin = mmin[apply](0, X),
	            ymin = mmin[apply](0, Y);
	        return {
	            x: xmin,
	            y: ymin,
	            width: mmax[apply](0, X) - xmin,
	            height: mmax[apply](0, Y) - ymin
	        };
	    }),
	        pathClone = function (pathArray) {
	            var res = [];
	            if (!R.is(pathArray, array) || !R.is(pathArray && pathArray[0], array)) { // rough assumption
	                pathArray = R.parsePathString(pathArray);
	            }
	            for (var i = 0, ii = pathArray[length]; i < ii; i++) {
	                res[i] = [];
	                for (var j = 0, jj = pathArray[i][length]; j < jj; j++) {
	                    res[i][j] = pathArray[i][j];
	                }
	            }
	            res[toString] = R._path2string;
	            return res;
	        },
	        pathToRelative = cacher(function (pathArray) {
	            if (!R.is(pathArray, array) || !R.is(pathArray && pathArray[0], array)) { // rough assumption
	                pathArray = R.parsePathString(pathArray);
	            }
	            var res = [],
	                x = 0,
	                y = 0,
	                mx = 0,
	                my = 0,
	                start = 0;
	            if (pathArray[0][0] == "M") {
	                x = pathArray[0][1];
	                y = pathArray[0][2];
	                mx = x;
	                my = y;
	                start++;
	                res[push](["M", x, y]);
	            }
	            for (var i = start, ii = pathArray[length]; i < ii; i++) {
	                var r = res[i] = [],
	                    pa = pathArray[i];
	                if (pa[0] != lowerCase.call(pa[0])) {
	                    r[0] = lowerCase.call(pa[0]);
	                    switch (r[0]) {
	                        case "a":
	                            r[1] = pa[1];
	                            r[2] = pa[2];
	                            r[3] = pa[3];
	                            r[4] = pa[4];
	                            r[5] = pa[5];
	                            r[6] = +(pa[6] - x).toFixed(3);
	                            r[7] = +(pa[7] - y).toFixed(3);
	                            break;
	                        case "v":
	                            r[1] = +(pa[1] - y).toFixed(3);
	                            break;
	                        case "m":
	                            mx = pa[1];
	                            my = pa[2];
	                        default:
	                            for (var j = 1, jj = pa[length]; j < jj; j++) {
	                                r[j] = +(pa[j] - ((j % 2) ? x : y)).toFixed(3);
	                            }
	                    }
	                } else {
	                    r = res[i] = [];
	                    if (pa[0] == "m") {
	                        mx = pa[1] + x;
	                        my = pa[2] + y;
	                    }
	                    for (var k = 0, kk = pa[length]; k < kk; k++) {
	                        res[i][k] = pa[k];
	                    }
	                }
	                var len = res[i][length];
	                switch (res[i][0]) {
	                    case "z":
	                        x = mx;
	                        y = my;
	                        break;
	                    case "h":
	                        x += +res[i][len - 1];
	                        break;
	                    case "v":
	                        y += +res[i][len - 1];
	                        break;
	                    default:
	                        x += +res[i][len - 2];
	                        y += +res[i][len - 1];
	                }
	            }
	            res[toString] = R._path2string;
	            return res;
	        }, 0, pathClone),
	        pathToAbsolute = cacher(function (pathArray) {
	            if (!R.is(pathArray, array) || !R.is(pathArray && pathArray[0], array)) { // rough assumption
	                pathArray = R.parsePathString(pathArray);
	            }
	            var res = [],
	                x = 0,
	                y = 0,
	                mx = 0,
	                my = 0,
	                start = 0;
	            if (pathArray[0][0] == "M") {
	                x = +pathArray[0][1];
	                y = +pathArray[0][2];
	                mx = x;
	                my = y;
	                start++;
	                res[0] = ["M", x, y];
	            }
	            for (var i = start, ii = pathArray[length]; i < ii; i++) {
	                var r = res[i] = [],
	                    pa = pathArray[i];
	                if (pa[0] != upperCase.call(pa[0])) {
	                    r[0] = upperCase.call(pa[0]);
	                    switch (r[0]) {
	                        case "A":
	                            r[1] = pa[1];
	                            r[2] = pa[2];
	                            r[3] = pa[3];
	                            r[4] = pa[4];
	                            r[5] = pa[5];
	                            r[6] = +(pa[6] + x);
	                            r[7] = +(pa[7] + y);
	                            break;
	                        case "V":
	                            r[1] = +pa[1] + y;
	                            break;
	                        case "H":
	                            r[1] = +pa[1] + x;
	                            break;
	                        case "M":
	                            mx = +pa[1] + x;
	                            my = +pa[2] + y;
	                        default:
	                            for (var j = 1, jj = pa[length]; j < jj; j++) {
	                                r[j] = +pa[j] + ((j % 2) ? x : y);
	                            }
	                    }
	                } else {
	                    for (var k = 0, kk = pa[length]; k < kk; k++) {
	                        res[i][k] = pa[k];
	                    }
	                }
	                switch (r[0]) {
	                    case "Z":
	                        x = mx;
	                        y = my;
	                        break;
	                    case "H":
	                        x = r[1];
	                        break;
	                    case "V":
	                        y = r[1];
	                        break;
	                    case "M":
	                        mx = res[i][res[i][length] - 2];
	                        my = res[i][res[i][length] - 1];
	                    default:
	                        x = res[i][res[i][length] - 2];
	                        y = res[i][res[i][length] - 1];
	                }
	            }
	            res[toString] = R._path2string;
	            return res;
	        }, null, pathClone),
	        l2c = function (x1, y1, x2, y2) {
	            return [x1, y1, x2, y2, x2, y2];
	        },
	        q2c = function (x1, y1, ax, ay, x2, y2) {
	            var _13 = 1 / 3,
	                _23 = 2 / 3;
	            return [
	                    _13 * x1 + _23 * ax,
	                    _13 * y1 + _23 * ay,
	                    _13 * x2 + _23 * ax,
	                    _13 * y2 + _23 * ay,
	                    x2,
	                    y2
	                ];
	        },
	        a2c = function (x1, y1, rx, ry, angle, large_arc_flag, sweep_flag, x2, y2, recursive) {
	            // for more information of where this math came from visit:
	            // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
	            var _120 = PI * 120 / 180,
	                rad = PI / 180 * (+angle || 0),
	                res = [],
	                xy,
	                rotate = cacher(function (x, y, rad) {
	                    var X = x * math.cos(rad) - y * math.sin(rad),
	                        Y = x * math.sin(rad) + y * math.cos(rad);
	                    return {x: X, y: Y};
	                });
	            if (!recursive) {
	                xy = rotate(x1, y1, -rad);
	                x1 = xy.x;
	                y1 = xy.y;
	                xy = rotate(x2, y2, -rad);
	                x2 = xy.x;
	                y2 = xy.y;
	                var cos = math.cos(PI / 180 * angle),
	                    sin = math.sin(PI / 180 * angle),
	                    x = (x1 - x2) / 2,
	                    y = (y1 - y2) / 2;
	                var h = (x * x) / (rx * rx) + (y * y) / (ry * ry);
	                if (h > 1) {
	                    h = math.sqrt(h);
	                    rx = h * rx;
	                    ry = h * ry;
	                }
	                var rx2 = rx * rx,
	                    ry2 = ry * ry,
	                    k = (large_arc_flag == sweep_flag ? -1 : 1) *
	                        math.sqrt(abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x))),
	                    cx = k * rx * y / ry + (x1 + x2) / 2,
	                    cy = k * -ry * x / rx + (y1 + y2) / 2,
	                    f1 = math.asin(((y1 - cy) / ry).toFixed(9)),
	                    f2 = math.asin(((y2 - cy) / ry).toFixed(9));
	
	                f1 = x1 < cx ? PI - f1 : f1;
	                f2 = x2 < cx ? PI - f2 : f2;
	                f1 < 0 && (f1 = PI * 2 + f1);
	                f2 < 0 && (f2 = PI * 2 + f2);
	                if (sweep_flag && f1 > f2) {
	                    f1 = f1 - PI * 2;
	                }
	                if (!sweep_flag && f2 > f1) {
	                    f2 = f2 - PI * 2;
	                }
	            } else {
	                f1 = recursive[0];
	                f2 = recursive[1];
	                cx = recursive[2];
	                cy = recursive[3];
	            }
	            var df = f2 - f1;
	            if (abs(df) > _120) {
	                var f2old = f2,
	                    x2old = x2,
	                    y2old = y2;
	                f2 = f1 + _120 * (sweep_flag && f2 > f1 ? 1 : -1);
	                x2 = cx + rx * math.cos(f2);
	                y2 = cy + ry * math.sin(f2);
	                res = a2c(x2, y2, rx, ry, angle, 0, sweep_flag, x2old, y2old, [f2, f2old, cx, cy]);
	            }
	            df = f2 - f1;
	            var c1 = math.cos(f1),
	                s1 = math.sin(f1),
	                c2 = math.cos(f2),
	                s2 = math.sin(f2),
	                t = math.tan(df / 4),
	                hx = 4 / 3 * rx * t,
	                hy = 4 / 3 * ry * t,
	                m1 = [x1, y1],
	                m2 = [x1 + hx * s1, y1 - hy * c1],
	                m3 = [x2 + hx * s2, y2 - hy * c2],
	                m4 = [x2, y2];
	            m2[0] = 2 * m1[0] - m2[0];
	            m2[1] = 2 * m1[1] - m2[1];
	            if (recursive) {
	                return [m2, m3, m4][concat](res);
	            } else {
	                res = [m2, m3, m4][concat](res)[join]()[split](",");
	                var newres = [];
	                for (var i = 0, ii = res[length]; i < ii; i++) {
	                    newres[i] = i % 2 ? rotate(res[i - 1], res[i], rad).y : rotate(res[i], res[i + 1], rad).x;
	                }
	                return newres;
	            }
	        },
	        findDotAtSegment = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t) {
	            var t1 = 1 - t;
	            return {
	                x: pow(t1, 3) * p1x + pow(t1, 2) * 3 * t * c1x + t1 * 3 * t * t * c2x + pow(t, 3) * p2x,
	                y: pow(t1, 3) * p1y + pow(t1, 2) * 3 * t * c1y + t1 * 3 * t * t * c2y + pow(t, 3) * p2y
	            };
	        },
	        curveDim = cacher(function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y) {
	            var a = (c2x - 2 * c1x + p1x) - (p2x - 2 * c2x + c1x),
	                b = 2 * (c1x - p1x) - 2 * (c2x - c1x),
	                c = p1x - c1x,
	                t1 = (-b + math.sqrt(b * b - 4 * a * c)) / 2 / a,
	                t2 = (-b - math.sqrt(b * b - 4 * a * c)) / 2 / a,
	                y = [p1y, p2y],
	                x = [p1x, p2x],
	                dot;
	            abs(t1) > "1e12" && (t1 = .5);
	            abs(t2) > "1e12" && (t2 = .5);
	            if (t1 > 0 && t1 < 1) {
	                dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t1);
	                x[push](dot.x);
	                y[push](dot.y);
	            }
	            if (t2 > 0 && t2 < 1) {
	                dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t2);
	                x[push](dot.x);
	                y[push](dot.y);
	            }
	            a = (c2y - 2 * c1y + p1y) - (p2y - 2 * c2y + c1y);
	            b = 2 * (c1y - p1y) - 2 * (c2y - c1y);
	            c = p1y - c1y;
	            t1 = (-b + math.sqrt(b * b - 4 * a * c)) / 2 / a;
	            t2 = (-b - math.sqrt(b * b - 4 * a * c)) / 2 / a;
	            abs(t1) > "1e12" && (t1 = .5);
	            abs(t2) > "1e12" && (t2 = .5);
	            if (t1 > 0 && t1 < 1) {
	                dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t1);
	                x[push](dot.x);
	                y[push](dot.y);
	            }
	            if (t2 > 0 && t2 < 1) {
	                dot = findDotAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, t2);
	                x[push](dot.x);
	                y[push](dot.y);
	            }
	            return {
	                min: {x: mmin[apply](0, x), y: mmin[apply](0, y)},
	                max: {x: mmax[apply](0, x), y: mmax[apply](0, y)}
	            };
	        }),
	        path2curve = cacher(function (path, path2) {
	            var p = pathToAbsolute(path),
	                p2 = path2 && pathToAbsolute(path2),
	                attrs = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},
	                attrs2 = {x: 0, y: 0, bx: 0, by: 0, X: 0, Y: 0, qx: null, qy: null},
	                processPath = function (path, d) {
	                    var nx, ny;
	                    if (!path) {
	                        return ["C", d.x, d.y, d.x, d.y, d.x, d.y];
	                    }
	                    !(path[0] in {T:1, Q:1}) && (d.qx = d.qy = null);
	                    switch (path[0]) {
	                        case "M":
	                            d.X = path[1];
	                            d.Y = path[2];
	                            break;
	                        case "A":
	                            path = ["C"][concat](a2c[apply](0, [d.x, d.y][concat](path.slice(1))));
	                            break;
	                        case "S":
	                            nx = d.x + (d.x - (d.bx || d.x));
	                            ny = d.y + (d.y - (d.by || d.y));
	                            path = ["C", nx, ny][concat](path.slice(1));
	                            break;
	                        case "T":
	                            d.qx = d.x + (d.x - (d.qx || d.x));
	                            d.qy = d.y + (d.y - (d.qy || d.y));
	                            path = ["C"][concat](q2c(d.x, d.y, d.qx, d.qy, path[1], path[2]));
	                            break;
	                        case "Q":
	                            d.qx = path[1];
	                            d.qy = path[2];
	                            path = ["C"][concat](q2c(d.x, d.y, path[1], path[2], path[3], path[4]));
	                            break;
	                        case "L":
	                            path = ["C"][concat](l2c(d.x, d.y, path[1], path[2]));
	                            break;
	                        case "H":
	                            path = ["C"][concat](l2c(d.x, d.y, path[1], d.y));
	                            break;
	                        case "V":
	                            path = ["C"][concat](l2c(d.x, d.y, d.x, path[1]));
	                            break;
	                        case "Z":
	                            path = ["C"][concat](l2c(d.x, d.y, d.X, d.Y));
	                            break;
	                    }
	                    return path;
	                },
	                fixArc = function (pp, i) {
	                    if (pp[i][length] > 7) {
	                        pp[i].shift();
	                        var pi = pp[i];
	                        while (pi[length]) {
	                            pp.splice(i++, 0, ["C"][concat](pi.splice(0, 6)));
	                        }
	                        pp.splice(i, 1);
	                        ii = mmax(p[length], p2 && p2[length] || 0);
	                    }
	                },
	                fixM = function (path1, path2, a1, a2, i) {
	                    if (path1 && path2 && path1[i][0] == "M" && path2[i][0] != "M") {
	                        path2.splice(i, 0, ["M", a2.x, a2.y]);
	                        a1.bx = 0;
	                        a1.by = 0;
	                        a1.x = path1[i][1];
	                        a1.y = path1[i][2];
	                        ii = mmax(p[length], p2 && p2[length] || 0);
	                    }
	                };
	            for (var i = 0, ii = mmax(p[length], p2 && p2[length] || 0); i < ii; i++) {
	                p[i] = processPath(p[i], attrs);
	                fixArc(p, i);
	                p2 && (p2[i] = processPath(p2[i], attrs2));
	                p2 && fixArc(p2, i);
	                fixM(p, p2, attrs, attrs2, i);
	                fixM(p2, p, attrs2, attrs, i);
	                var seg = p[i],
	                    seg2 = p2 && p2[i],
	                    seglen = seg[length],
	                    seg2len = p2 && seg2[length];
	                attrs.x = seg[seglen - 2];
	                attrs.y = seg[seglen - 1];
	                attrs.bx = toFloat(seg[seglen - 4]) || attrs.x;
	                attrs.by = toFloat(seg[seglen - 3]) || attrs.y;
	                attrs2.bx = p2 && (toFloat(seg2[seg2len - 4]) || attrs2.x);
	                attrs2.by = p2 && (toFloat(seg2[seg2len - 3]) || attrs2.y);
	                attrs2.x = p2 && seg2[seg2len - 2];
	                attrs2.y = p2 && seg2[seg2len - 1];
	            }
	            return p2 ? [p, p2] : p;
	        }, null, pathClone),
	        parseDots = cacher(function (gradient) {
	            var dots = [];
	            for (var i = 0, ii = gradient[length]; i < ii; i++) {
	                var dot = {},
	                    par = gradient[i].match(/^([^:]*):?([\d\.]*)/);
	                dot.color = R.getRGB(par[1]);
	                if (dot.color.error) {
	                    return null;
	                }
	                dot.color = dot.color.hex;
	                par[2] && (dot.offset = par[2] + "%");
	                dots[push](dot);
	            }
	            for (i = 1, ii = dots[length] - 1; i < ii; i++) {
	                if (!dots[i].offset) {
	                    var start = toFloat(dots[i - 1].offset || 0),
	                        end = 0;
	                    for (var j = i + 1; j < ii; j++) {
	                        if (dots[j].offset) {
	                            end = dots[j].offset;
	                            break;
	                        }
	                    }
	                    if (!end) {
	                        end = 100;
	                        j = ii;
	                    }
	                    end = toFloat(end);
	                    var d = (end - start) / (j - i + 1);
	                    for (; i < j; i++) {
	                        start += d;
	                        dots[i].offset = start + "%";
	                    }
	                }
	            }
	            return dots;
	        }),
	        getContainer = function (x, y, w, h) {
	            var container;
	            if (R.is(x, string) || R.is(x, "object")) {
	                container = R.is(x, string) ? doc.getElementById(x) : x;
	                if (container.tagName) {
	                    if (y == null) {
	                        return {
	                            container: container,
	                            width: container.style.pixelWidth || container.offsetWidth,
	                            height: container.style.pixelHeight || container.offsetHeight
	                        };
	                    } else {
	                        return {container: container, width: y, height: w};
	                    }
	                }
	            } else {
	                return {container: 1, x: x, y: y, width: w, height: h};
	            }
	        },
	        plugins = function (con, add) {
	            var that = this;
	            for (var prop in add) {
	                if (add[has](prop) && !(prop in con)) {
	                    switch (typeof add[prop]) {
	                        case "function":
	                            (function (f) {
	                                con[prop] = con === that ? f : function () { return f[apply](that, arguments); };
	                            })(add[prop]);
	                        break;
	                        case "object":
	                            con[prop] = con[prop] || {};
	                            plugins.call(this, con[prop], add[prop]);
	                        break;
	                        default:
	                            con[prop] = add[prop];
	                        break;
	                    }
	                }
	            }
	        },
	        tear = function (el, paper) {
	            el == paper.top && (paper.top = el.prev);
	            el == paper.bottom && (paper.bottom = el.next);
	            el.next && (el.next.prev = el.prev);
	            el.prev && (el.prev.next = el.next);
	        },
	        tofront = function (el, paper) {
	            if (paper.top === el) {
	                return;
	            }
	            tear(el, paper);
	            el.next = null;
	            el.prev = paper.top;
	            paper.top.next = el;
	            paper.top = el;
	        },
	        toback = function (el, paper) {
	            if (paper.bottom === el) {
	                return;
	            }
	            tear(el, paper);
	            el.next = paper.bottom;
	            el.prev = null;
	            paper.bottom.prev = el;
	            paper.bottom = el;
	        },
	        insertafter = function (el, el2, paper) {
	            tear(el, paper);
	            el2 == paper.top && (paper.top = el);
	            el2.next && (el2.next.prev = el);
	            el.next = el2.next;
	            el.prev = el2;
	            el2.next = el;
	        },
	        insertbefore = function (el, el2, paper) {
	            tear(el, paper);
	            el2 == paper.bottom && (paper.bottom = el);
	            el2.prev && (el2.prev.next = el);
	            el.prev = el2.prev;
	            el2.prev = el;
	            el.next = el2;
	        },
	        removed = function (methodname) {
	            return function () {
	                throw new Error("Rapha\xebl: you are calling to method \u201c" + methodname + "\u201d of removed object");
	            };
	        };
	    R.pathToRelative = pathToRelative;
	    // SVG
	    if (R.svg) {
	        paperproto.svgns = "http://www.w3.org/2000/svg";
	        paperproto.xlink = "http://www.w3.org/1999/xlink";
	        round = function (num) {
	            return +num + (~~num === num) * .5;
	        };
	        var $ = function (el, attr) {
	            if (attr) {
	                for (var key in attr) {
	                    if (attr[has](key)) {
	                        setAttr(el, key, Str(attr[key]));
	                    }
	                }
	            } else {
	                el = doc.createElementNS(paperproto.svgns, el);
	                el.style.webkitTapHighlightColor = "rgba(0,0,0,0)";
	                return el;
	            }
	        };
	        R[toString] = function () {
	            return  "Your browser supports SVG.\nYou are running Rapha\xebl " + this.version;
	        };
	        var thePath = function (pathString, SVG) {
	            var el = $("path");
	            SVG.canvas && SVG.canvas[appendChild](el);
	            var p = new Element(el, SVG);
	            p.type = "path";
	            setFillAndStroke(p, {fill: "none", stroke: "#000", path: pathString});
	            return p;
	        };
	        var addGradientFill = function (o, gradient, SVG) {
	            var type = "linear",
	                fx = .5, fy = .5,
	                s = o.style;
	            gradient = Str(gradient)[rp](radial_gradient, function (all, _fx, _fy) {
	                type = "radial";
	                if (_fx && _fy) {
	                    fx = toFloat(_fx);
	                    fy = toFloat(_fy);
	                    var dir = ((fy > .5) * 2 - 1);
	                    pow(fx - .5, 2) + pow(fy - .5, 2) > .25 &&
	                        (fy = math.sqrt(.25 - pow(fx - .5, 2)) * dir + .5) &&
	                        fy != .5 &&
	                        (fy = fy.toFixed(5) - 1e-5 * dir);
	                }
	                return E;
	            });
	            gradient = gradient[split](/\s*\-\s*/);
	            if (type == "linear") {
	                var angle = gradient.shift();
	                angle = -toFloat(angle);
	                if (isNaN(angle)) {
	                    return null;
	                }
	                var vector = [0, 0, math.cos(angle * PI / 180), math.sin(angle * PI / 180)],
	                    max = 1 / (mmax(abs(vector[2]), abs(vector[3])) || 1);
	                vector[2] *= max;
	                vector[3] *= max;
	                if (vector[2] < 0) {
	                    vector[0] = -vector[2];
	                    vector[2] = 0;
	                }
	                if (vector[3] < 0) {
	                    vector[1] = -vector[3];
	                    vector[3] = 0;
	                }
	            }
	            var dots = parseDots(gradient);
	            if (!dots) {
	                return null;
	            }
	            var id = o.getAttribute(fillString);
	            id = id.match(/^url\(#(.*)\)$/);
	            id && SVG.defs.removeChild(doc.getElementById(id[1]));
	
	            var el = $(type + "Gradient");
	            el.id = createUUID();
	            $(el, type == "radial" ? {fx: fx, fy: fy} : {x1: vector[0], y1: vector[1], x2: vector[2], y2: vector[3]});
	            SVG.defs[appendChild](el);
	            for (var i = 0, ii = dots[length]; i < ii; i++) {
	                var stop = $("stop");
	                $(stop, {
	                    offset: dots[i].offset ? dots[i].offset : !i ? "0%" : "100%",
	                    "stop-color": dots[i].color || "#fff"
	                });
	                el[appendChild](stop);
	            }
	            $(o, {
	                fill: "url(#" + el.id + ")",
	                opacity: 1,
	                "fill-opacity": 1
	            });
	            s.fill = E;
	            s.opacity = 1;
	            s.fillOpacity = 1;
	            return 1;
	        };
	        var updatePosition = function (o) {
	            var bbox = o.getBBox();
	            $(o.pattern, {patternTransform: R.format("translate({0},{1})", bbox.x, bbox.y)});
	        };
	        var setFillAndStroke = function (o, params) {
	            var dasharray = {
	                    "": [0],
	                    "none": [0],
	                    "-": [3, 1],
	                    ".": [1, 1],
	                    "-.": [3, 1, 1, 1],
	                    "-..": [3, 1, 1, 1, 1, 1],
	                    ". ": [1, 3],
	                    "- ": [4, 3],
	                    "--": [8, 3],
	                    "- .": [4, 3, 1, 3],
	                    "--.": [8, 3, 1, 3],
	                    "--..": [8, 3, 1, 3, 1, 3]
	                },
	                node = o.node,
	                attrs = o.attrs,
	                rot = o.rotate(),
	                addDashes = function (o, value) {
	                    value = dasharray[lowerCase.call(value)];
	                    if (value) {
	                        var width = o.attrs["stroke-width"] || "1",
	                            butt = {round: width, square: width, butt: 0}[o.attrs["stroke-linecap"] || params["stroke-linecap"]] || 0,
	                            dashes = [];
	                        var i = value[length];
	                        while (i--) {
	                            dashes[i] = value[i] * width + ((i % 2) ? 1 : -1) * butt;
	                        }
	                        $(node, {"stroke-dasharray": dashes[join](",")});
	                    }
	                };
	            params[has]("rotation") && (rot = params.rotation);
	            var rotxy = Str(rot)[split](separator);
	            if (!(rotxy.length - 1)) {
	                rotxy = null;
	            } else {
	                rotxy[1] = +rotxy[1];
	                rotxy[2] = +rotxy[2];
	            }
	            toFloat(rot) && o.rotate(0, true);
	            for (var att in params) {
	                if (params[has](att)) {
	                    if (!availableAttrs[has](att)) {
	                        continue;
	                    }
	                    var value = params[att];
	                    attrs[att] = value;
	                    switch (att) {
	                        case "blur":
	                            o.blur(value);
	                            break;
	                        case "rotation":
	                            o.rotate(value, true);
	                            break;
	                        case "href":
	                        case "title":
	                        case "target":
	                            var pn = node.parentNode;
	                            if (lowerCase.call(pn.tagName) != "a") {
	                                var hl = $("a");
	                                pn.insertBefore(hl, node);
	                                hl[appendChild](node);
	                                pn = hl;
	                            }
	                            if (att == "target" && value == "blank") {
	                                pn.setAttributeNS(o.paper.xlink, "show", "new");
	                            } else {
	                                pn.setAttributeNS(o.paper.xlink, att, value);
	                            }
	                            break;
	                        case "cursor":
	                            node.style.cursor = value;
	                            break;
	                        case "clip-rect":
	                            var rect = Str(value)[split](separator);
	                            if (rect[length] == 4) {
	                                o.clip && o.clip.parentNode.parentNode.removeChild(o.clip.parentNode);
	                                var el = $("clipPath"),
	                                    rc = $("rect");
	                                el.id = createUUID();
	                                $(rc, {
	                                    x: rect[0],
	                                    y: rect[1],
	                                    width: rect[2],
	                                    height: rect[3]
	                                });
	                                el[appendChild](rc);
	                                o.paper.defs[appendChild](el);
	                                $(node, {"clip-path": "url(#" + el.id + ")"});
	                                o.clip = rc;
	                            }
	                            if (!value) {
	                                var clip = doc.getElementById(node.getAttribute("clip-path")[rp](/(^url\(#|\)$)/g, E));
	                                clip && clip.parentNode.removeChild(clip);
	                                $(node, {"clip-path": E});
	                                delete o.clip;
	                            }
	                        break;
	                        case "path":
	                            if (o.type == "path") {
	                                $(node, {d: value ? attrs.path = pathToAbsolute(value) : "M0,0"});
	                            }
	                            break;
	                        case "width":
	                            setAttr(node, att, value);
	                            if (attrs.fx) {
	                                att = "x";
	                                value = attrs.x;
	                            } else {
	                                break;
	                            }
	                        case "x":
	                            if (attrs.fx) {
	                                value = -attrs.x - (attrs.width || 0);
	                            }
	                        case "rx":
	                            if (att == "rx" && o.type == "rect") {
	                                break;
	                            }
	                        case "cx":
	                            rotxy && (att == "x" || att == "cx") && (rotxy[1] += value - attrs[att]);
	                            setAttr(node, att, value);
	                            o.pattern && updatePosition(o);
	                            break;
	                        case "height":
	                            setAttr(node, att, value);
	                            if (attrs.fy) {
	                                att = "y";
	                                value = attrs.y;
	                            } else {
	                                break;
	                            }
	                        case "y":
	                            if (attrs.fy) {
	                                value = -attrs.y - (attrs.height || 0);
	                            }
	                        case "ry":
	                            if (att == "ry" && o.type == "rect") {
	                                break;
	                            }
	                        case "cy":
	                            rotxy && (att == "y" || att == "cy") && (rotxy[2] += value - attrs[att]);
	                            setAttr(node, att, value);
	                            o.pattern && updatePosition(o);
	                            break;
	                        case "r":
	                            if (o.type == "rect") {
	                                $(node, {rx: value, ry: value});
	                            } else {
	                                setAttr(node, att, value);
	                            }
	                            break;
	                        case "src":
	                            if (o.type == "image") {
	                                node.setAttributeNS(o.paper.xlink, "href", value);
	                            }
	                            break;
	                        case "stroke-width":
	                            node.style.strokeWidth = value;
	                            // Need following line for Firefox
	                            setAttr(node, att, value);
	                            if (attrs["stroke-dasharray"]) {
	                                addDashes(o, attrs["stroke-dasharray"]);
	                            }
	                            break;
	                        case "stroke-dasharray":
	                            addDashes(o, value);
	                            break;
	                        case "translation":
	                            var xy = Str(value)[split](separator);
	                            xy[0] = +xy[0] || 0;
	                            xy[1] = +xy[1] || 0;
	                            if (rotxy) {
	                                rotxy[1] += xy[0];
	                                rotxy[2] += xy[1];
	                            }
	                            translate.call(o, xy[0], xy[1]);
	                            break;
	                        case "scale":
	                            xy = Str(value)[split](separator);
	                            o.scale(+xy[0] || 1, +xy[1] || +xy[0] || 1, isNaN(toFloat(xy[2])) ? null : +xy[2], isNaN(toFloat(xy[3])) ? null : +xy[3]);
	                            break;
	                        case fillString:
	                            var isURL = Str(value).match(ISURL);
	                            if (isURL) {
	                                el = $("pattern");
	                                var ig = $("image");
	                                el.id = createUUID();
	                                $(el, {x: 0, y: 0, patternUnits: "userSpaceOnUse", height: 1, width: 1});
	                                $(ig, {x: 0, y: 0});
	                                ig.setAttributeNS(o.paper.xlink, "href", isURL[1]);
	                                el[appendChild](ig);
	
	                                var img = doc.createElement("img");
	                                img.style.cssText = "position:absolute;left:-9999em;top-9999em";
	                                img.onload = function () {
	                                    $(el, {width: this.offsetWidth, height: this.offsetHeight});
	                                    $(ig, {width: this.offsetWidth, height: this.offsetHeight});
	                                    doc.body.removeChild(this);
	                                    o.paper.safari();
	                                };
	                                doc.body[appendChild](img);
	                                img.src = isURL[1];
	                                o.paper.defs[appendChild](el);
	                                node.style.fill = "url(#" + el.id + ")";
	                                $(node, {fill: "url(#" + el.id + ")"});
	                                o.pattern = el;
	                                o.pattern && updatePosition(o);
	                                break;
	                            }
	                            var clr = R.getRGB(value);
	                            if (!clr.error) {
	                                delete params.gradient;
	                                delete attrs.gradient;
	                                !R.is(attrs.opacity, "undefined") &&
	                                    R.is(params.opacity, "undefined") &&
	                                    $(node, {opacity: attrs.opacity});
	                                !R.is(attrs["fill-opacity"], "undefined") &&
	                                    R.is(params["fill-opacity"], "undefined") &&
	                                    $(node, {"fill-opacity": attrs["fill-opacity"]});
	                            } else if ((({circle: 1, ellipse: 1})[has](o.type) || Str(value).charAt() != "r") && addGradientFill(node, value, o.paper)) {
	                                attrs.gradient = value;
	                                attrs.fill = "none";
	                                break;
	                            }
	                            clr[has]("opacity") && $(node, {"fill-opacity": clr.opacity > 1 ? clr.opacity / 100 : clr.opacity});
	                        case "stroke":
	                            clr = R.getRGB(value);
	                            setAttr(node, att, clr.hex);
	                            att == "stroke" && clr[has]("opacity") && $(node, {"stroke-opacity": clr.opacity > 1 ? clr.opacity / 100 : clr.opacity});
	                            break;
	                        case "gradient":
	                            (({circle: 1, ellipse: 1})[has](o.type) || Str(value).charAt() != "r") && addGradientFill(node, value, o.paper);
	                            break;
	                        case "opacity":
	                            if (attrs.gradient && !attrs[has]("stroke-opacity")) {
	                                $(node, {"stroke-opacity": value > 1 ? value / 100 : value});
	                            }
	                            // fall
	                        case "fill-opacity":
	                            if (attrs.gradient) {
	                                var gradient = doc.getElementById(node.getAttribute(fillString)[rp](/^url\(#|\)$/g, E));
	                                if (gradient) {
	                                    var stops = gradient.getElementsByTagName("stop");
	                                    setAttr(stops[stops[length] - 1], "stop-opacity", value);
	                                }
	                                break;
	                            }
	                        default:
	                            att == "font-size" && (value = toInt(value, 10) + "px");
	                            var cssrule = att[rp](/(\-.)/g, function (w) {
	                                return upperCase.call(w.substring(1));
	                            });
	                            node.style[cssrule] = value;
	                            // Need following line for Firefox
	                            setAttr(node, att, value);
	                            break;
	                    }
	                }
	            }
	
	            tuneText(o, params);
	            if (rotxy) {
	                o.rotate(rotxy.join(S));
	            } else {
	                toFloat(rot) && o.rotate(rot, true);
	            }
	        };
	        var leading = 1.2,
	        tuneText = function (el, params) {
	            if (el.type != "text" || !(params[has]("text") || params[has]("font") || params[has]("font-size") || params[has]("x") || params[has]("y"))) {
	                return;
	            }
	            var a = el.attrs,
	                node = el.node,
	                fontSize = node.firstChild ? toInt(doc.defaultView.getComputedStyle(node.firstChild, E).getPropertyValue("font-size"), 10) : 10;
	
	            if (params[has]("text")) {
	                a.text = params.text;
	                while (node.firstChild) {
	                    node.removeChild(node.firstChild);
	                }
	                var texts = Str(params.text)[split]("\n");
	                for (var i = 0, ii = texts[length]; i < ii; i++) if (texts[i]) {
	                    var tspan = $("tspan");
	                    i && $(tspan, {dy: fontSize * leading, x: a.x});
	                    tspan[appendChild](doc.createTextNode(texts[i]));
	                    node[appendChild](tspan);
	                }
	            } else {
	                texts = node.getElementsByTagName("tspan");
	                for (i = 0, ii = texts[length]; i < ii; i++) {
	                    i && $(texts[i], {dy: fontSize * leading, x: a.x});
	                }
	            }
	            $(node, {y: a.y});
	            var bb = el.getBBox(),
	                dif = a.y - (bb.y + bb.height / 2);
	            dif && R.is(dif, "finite") && $(node, {y: a.y + dif});
	        },
	        Element = function (node, svg) {
	            var X = 0,
	                Y = 0;
	            this[0] = node;
	            this.id = R._oid++;
	            this.node = node;
	            node.raphael = this;
	            this.paper = svg;
	            this.attrs = this.attrs || {};
	            this.transformations = []; // rotate, translate, scale
	            this._ = {
	                tx: 0,
	                ty: 0,
	                rt: {deg: 0, cx: 0, cy: 0},
	                sx: 1,
	                sy: 1
	            };
	            !svg.bottom && (svg.bottom = this);
	            this.prev = svg.top;
	            svg.top && (svg.top.next = this);
	            svg.top = this;
	            this.next = null;
	        };
	        var elproto = Element[proto];
	        Element[proto].rotate = function (deg, cx, cy) {
	            if (this.removed) {
	                return this;
	            }
	            if (deg == null) {
	                if (this._.rt.cx) {
	                    return [this._.rt.deg, this._.rt.cx, this._.rt.cy][join](S);
	                }
	                return this._.rt.deg;
	            }
	            var bbox = this.getBBox();
	            deg = Str(deg)[split](separator);
	            if (deg[length] - 1) {
	                cx = toFloat(deg[1]);
	                cy = toFloat(deg[2]);
	            }
	            deg = toFloat(deg[0]);
	            if (cx != null && cx !== false) {
	                this._.rt.deg = deg;
	            } else {
	                this._.rt.deg += deg;
	            }
	            (cy == null) && (cx = null);
	            this._.rt.cx = cx;
	            this._.rt.cy = cy;
	            cx = cx == null ? bbox.x + bbox.width / 2 : cx;
	            cy = cy == null ? bbox.y + bbox.height / 2 : cy;
	            if (this._.rt.deg) {
	                this.transformations[0] = R.format("rotate({0} {1} {2})", this._.rt.deg, cx, cy);
	                this.clip && $(this.clip, {transform: R.format("rotate({0} {1} {2})", -this._.rt.deg, cx, cy)});
	            } else {
	                this.transformations[0] = E;
	                this.clip && $(this.clip, {transform: E});
	            }
	            $(this.node, {transform: this.transformations[join](S)});
	            return this;
	        };
	        Element[proto].hide = function () {
	            !this.removed && (this.node.style.display = "none");
	            return this;
	        };
	        Element[proto].show = function () {
	            !this.removed && (this.node.style.display = "");
	            return this;
	        };
	        Element[proto].remove = function () {
	            if (this.removed) {
	                return;
	            }
	            tear(this, this.paper);
	            this.node.parentNode.removeChild(this.node);
	            for (var i in this) {
	                delete this[i];
	            }
	            this.removed = true;
	        };
	        Element[proto].getBBox = function () {
	            if (this.removed) {
	                return this;
	            }
	            if (this.type == "path") {
	                return pathDimensions(this.attrs.path);
	            }
	            if (this.node.style.display == "none") {
	                this.show();
	                var hide = true;
	            }
	            var bbox = {};
	            try {
	                bbox = this.node.getBBox();
	            } catch(e) {
	                // Firefox 3.0.x plays badly here
	            } finally {
	                bbox = bbox || {};
	            }
	            if (this.type == "text") {
	                bbox = {x: bbox.x, y: Infinity, width: 0, height: 0};
	                for (var i = 0, ii = this.node.getNumberOfChars(); i < ii; i++) {
	                    var bb = this.node.getExtentOfChar(i);
	                    (bb.y < bbox.y) && (bbox.y = bb.y);
	                    (bb.y + bb.height - bbox.y > bbox.height) && (bbox.height = bb.y + bb.height - bbox.y);
	                    (bb.x + bb.width - bbox.x > bbox.width) && (bbox.width = bb.x + bb.width - bbox.x);
	                }
	            }
	            hide && this.hide();
	            return bbox;
	        };
	        Element[proto].attr = function (name, value) {
	            if (this.removed) {
	                return this;
	            }
	            if (name == null) {
	                var res = {};
	                for (var i in this.attrs) if (this.attrs[has](i)) {
	                    res[i] = this.attrs[i];
	                }
	                this._.rt.deg && (res.rotation = this.rotate());
	                (this._.sx != 1 || this._.sy != 1) && (res.scale = this.scale());
	                res.gradient && res.fill == "none" && (res.fill = res.gradient) && delete res.gradient;
	                return res;
	            }
	            if (value == null && R.is(name, string)) {
	                if (name == "translation") {
	                    return translate.call(this);
	                }
	                if (name == "rotation") {
	                    return this.rotate();
	                }
	                if (name == "scale") {
	                    return this.scale();
	                }
	                if (name == fillString && this.attrs.fill == "none" && this.attrs.gradient) {
	                    return this.attrs.gradient;
	                }
	                return this.attrs[name];
	            }
	            if (value == null && R.is(name, array)) {
	                var values = {};
	                for (var j = 0, jj = name.length; j < jj; j++) {
	                    values[name[j]] = this.attr(name[j]);
	                }
	                return values;
	            }
	            if (value != null) {
	                var params = {};
	                params[name] = value;
	            } else if (name != null && R.is(name, "object")) {
	                params = name;
	            }
	            for (var key in this.paper.customAttributes) if (this.paper.customAttributes[has](key) && params[has](key) && R.is(this.paper.customAttributes[key], "function")) {
	                var par = this.paper.customAttributes[key].apply(this, [][concat](params[key]));
	                this.attrs[key] = params[key];
	                for (var subkey in par) if (par[has](subkey)) {
	                    params[subkey] = par[subkey];
	                }
	            }
	            setFillAndStroke(this, params);
	            return this;
	        };
	        Element[proto].toFront = function () {
	            if (this.removed) {
	                return this;
	            }
	            this.node.parentNode[appendChild](this.node);
	            var svg = this.paper;
	            svg.top != this && tofront(this, svg);
	            return this;
	        };
	        Element[proto].toBack = function () {
	            if (this.removed) {
	                return this;
	            }
	            if (this.node.parentNode.firstChild != this.node) {
	                this.node.parentNode.insertBefore(this.node, this.node.parentNode.firstChild);
	                toback(this, this.paper);
	                var svg = this.paper;
	            }
	            return this;
	        };
	        Element[proto].insertAfter = function (element) {
	            if (this.removed) {
	                return this;
	            }
	            var node = element.node || element[element.length - 1].node;
	            if (node.nextSibling) {
	                node.parentNode.insertBefore(this.node, node.nextSibling);
	            } else {
	                node.parentNode[appendChild](this.node);
	            }
	            insertafter(this, element, this.paper);
	            return this;
	        };
	        Element[proto].insertBefore = function (element) {
	            if (this.removed) {
	                return this;
	            }
	            var node = element.node || element[0].node;
	            node.parentNode.insertBefore(this.node, node);
	            insertbefore(this, element, this.paper);
	            return this;
	        };
	        Element[proto].blur = function (size) {
	            // Experimental. No Safari support. Use it on your own risk.
	            var t = this;
	            if (+size !== 0) {
	                var fltr = $("filter"),
	                    blur = $("feGaussianBlur");
	                t.attrs.blur = size;
	                fltr.id = createUUID();
	                $(blur, {stdDeviation: +size || 1.5});
	                fltr.appendChild(blur);
	                t.paper.defs.appendChild(fltr);
	                t._blur = fltr;
	                $(t.node, {filter: "url(#" + fltr.id + ")"});
	            } else {
	                if (t._blur) {
	                    t._blur.parentNode.removeChild(t._blur);
	                    delete t._blur;
	                    delete t.attrs.blur;
	                }
	                t.node.removeAttribute("filter");
	            }
	        };
	        var theCircle = function (svg, x, y, r) {
	            var el = $("circle");
	            svg.canvas && svg.canvas[appendChild](el);
	            var res = new Element(el, svg);
	            res.attrs = {cx: x, cy: y, r: r, fill: "none", stroke: "#000"};
	            res.type = "circle";
	            $(el, res.attrs);
	            return res;
	        },
	        theRect = function (svg, x, y, w, h, r) {
	            var el = $("rect");
	            svg.canvas && svg.canvas[appendChild](el);
	            var res = new Element(el, svg);
	            res.attrs = {x: x, y: y, width: w, height: h, r: r || 0, rx: r || 0, ry: r || 0, fill: "none", stroke: "#000"};
	            res.type = "rect";
	            $(el, res.attrs);
	            return res;
	        },
	        theEllipse = function (svg, x, y, rx, ry) {
	            var el = $("ellipse");
	            svg.canvas && svg.canvas[appendChild](el);
	            var res = new Element(el, svg);
	            res.attrs = {cx: x, cy: y, rx: rx, ry: ry, fill: "none", stroke: "#000"};
	            res.type = "ellipse";
	            $(el, res.attrs);
	            return res;
	        },
	        theImage = function (svg, src, x, y, w, h) {
	            var el = $("image");
	            $(el, {x: x, y: y, width: w, height: h, preserveAspectRatio: "none"});
	            el.setAttributeNS(svg.xlink, "href", src);
	            svg.canvas && svg.canvas[appendChild](el);
	            var res = new Element(el, svg);
	            res.attrs = {x: x, y: y, width: w, height: h, src: src};
	            res.type = "image";
	            return res;
	        },
	        theText = function (svg, x, y, text) {
	            var el = $("text");
	            $(el, {x: x, y: y, "text-anchor": "middle"});
	            svg.canvas && svg.canvas[appendChild](el);
	            var res = new Element(el, svg);
	            res.attrs = {x: x, y: y, "text-anchor": "middle", text: text, font: availableAttrs.font, stroke: "none", fill: "#000"};
	            res.type = "text";
	            setFillAndStroke(res, res.attrs);
	            return res;
	        },
	        setSize = function (width, height) {
	            this.width = width || this.width;
	            this.height = height || this.height;
	            setAttr(this.canvas, "width", this.width);
	            setAttr(this.canvas, "height", this.height);
	            return this;
	        },
	        create = function () {
	            var con = getContainer[apply](0, arguments),
	                container = con && con.container,
	                x = con.x,
	                y = con.y,
	                width = con.width,
	                height = con.height;
	            if (!container) {
	                throw new Error("SVG container not found.");
	            }
	            var cnvs = $("svg");
	            x = x || 0;
	            y = y || 0;
	            width = width || 512;
	            height = height || 342;
	            $(cnvs, {
	                xmlns: "http://www.w3.org/2000/svg",
	                version: 1.1,
	                width: width,
	                height: height
	            });
	            if (container == 1) {
	                cnvs.style.cssText = "position:absolute;left:" + x + "px;top:" + y + "px";
	                doc.body[appendChild](cnvs);
	            } else {
	                if (container.firstChild) {
	                    container.insertBefore(cnvs, container.firstChild);
	                } else {
	                    container[appendChild](cnvs);
	                }
	            }
	            container = new Paper;
	            container.width = width;
	            container.height = height;
	            container.canvas = cnvs;
	            plugins.call(container, container, R.fn);
	            container.clear();
	            return container;
	        };
	        paperproto.clear = function () {
	            var c = this.canvas;
	            while (c.firstChild) {
	                c.removeChild(c.firstChild);
	            }
	            this.bottom = this.top = null;
	            (this.desc = $("desc"))[appendChild](doc.createTextNode("Created with Rapha\xebl"));
	            c[appendChild](this.desc);
	            c[appendChild](this.defs = $("defs"));
	        };
	        paperproto.remove = function () {
	            this.canvas.parentNode && this.canvas.parentNode.removeChild(this.canvas);
	            for (var i in this) {
	                this[i] = removed(i);
	            }
	        };
	    }
	
	    // VML
	    if (R.vml) {
	        var map = {M: "m", L: "l", C: "c", Z: "x", m: "t", l: "r", c: "v", z: "x"},
	            bites = /([clmz]),?([^clmz]*)/gi,
	            blurregexp = / progid:\S+Blur\([^\)]+\)/g,
	            val = /-?[^,\s-]+/g,
	            coordsize = 1e3 + S + 1e3,
	            zoom = 10,
	            pathlike = {path: 1, rect: 1},
	            path2vml = function (path) {
	                var total =  /[ahqstv]/ig,
	                    command = pathToAbsolute;
	                Str(path).match(total) && (command = path2curve);
	                total = /[clmz]/g;
	                if (command == pathToAbsolute && !Str(path).match(total)) {
	                    var res = Str(path)[rp](bites, function (all, command, args) {
	                        var vals = [],
	                            isMove = lowerCase.call(command) == "m",
	                            res = map[command];
	                        args[rp](val, function (value) {
	                            if (isMove && vals[length] == 2) {
	                                res += vals + map[command == "m" ? "l" : "L"];
	                                vals = [];
	                            }
	                            vals[push](round(value * zoom));
	                        });
	                        return res + vals;
	                    });
	                    return res;
	                }
	                var pa = command(path), p, r;
	                res = [];
	                for (var i = 0, ii = pa[length]; i < ii; i++) {
	                    p = pa[i];
	                    r = lowerCase.call(pa[i][0]);
	                    r == "z" && (r = "x");
	                    for (var j = 1, jj = p[length]; j < jj; j++) {
	                        r += round(p[j] * zoom) + (j != jj - 1 ? "," : E);
	                    }
	                    res[push](r);
	                }
	                return res[join](S);
	            };
	
	        R[toString] = function () {
	            return  "Your browser doesn\u2019t support SVG. Falling down to VML.\nYou are running Rapha\xebl " + this.version;
	        };
	        thePath = function (pathString, vml) {
	            var g = createNode("group");
	            g.style.cssText = "position:absolute;left:0;top:0;width:" + vml.width + "px;height:" + vml.height + "px";
	            g.coordsize = vml.coordsize;
	            g.coordorigin = vml.coordorigin;
	            var el = createNode("shape"), ol = el.style;
	            ol.width = vml.width + "px";
	            ol.height = vml.height + "px";
	            el.coordsize = coordsize;
	            el.coordorigin = vml.coordorigin;
	            g[appendChild](el);
	            var p = new Element(el, g, vml),
	                attr = {fill: "none", stroke: "#000"};
	            pathString && (attr.path = pathString);
	            p.type = "path";
	            p.path = [];
	            p.Path = E;
	            setFillAndStroke(p, attr);
	            vml.canvas[appendChild](g);
	            return p;
	        };
	        setFillAndStroke = function (o, params) {
	            o.attrs = o.attrs || {};
	            var node = o.node,
	                a = o.attrs,
	                s = node.style,
	                xy,
	                newpath = (params.x != a.x || params.y != a.y || params.width != a.width || params.height != a.height || params.r != a.r) && o.type == "rect",
	                res = o;
	
	            for (var par in params) if (params[has](par)) {
	                a[par] = params[par];
	            }
	            if (newpath) {
	                a.path = rectPath(a.x, a.y, a.width, a.height, a.r);
	                o.X = a.x;
	                o.Y = a.y;
	                o.W = a.width;
	                o.H = a.height;
	            }
	            params.href && (node.href = params.href);
	            params.title && (node.title = params.title);
	            params.target && (node.target = params.target);
	            params.cursor && (s.cursor = params.cursor);
	            "blur" in params && o.blur(params.blur);
	            if (params.path && o.type == "path" || newpath) {
	                node.path = path2vml(a.path);
	            }
	            if (params.rotation != null) {
	                o.rotate(params.rotation, true);
	            }
	            if (params.translation) {
	                xy = Str(params.translation)[split](separator);
	                translate.call(o, xy[0], xy[1]);
	                if (o._.rt.cx != null) {
	                    o._.rt.cx +=+ xy[0];
	                    o._.rt.cy +=+ xy[1];
	                    o.setBox(o.attrs, xy[0], xy[1]);
	                }
	            }
	            if (params.scale) {
	                xy = Str(params.scale)[split](separator);
	                o.scale(+xy[0] || 1, +xy[1] || +xy[0] || 1, +xy[2] || null, +xy[3] || null);
	            }
	            if ("clip-rect" in params) {
	                var rect = Str(params["clip-rect"])[split](separator);
	                if (rect[length] == 4) {
	                    rect[2] = +rect[2] + (+rect[0]);
	                    rect[3] = +rect[3] + (+rect[1]);
	                    var div = node.clipRect || doc.createElement("div"),
	                        dstyle = div.style,
	                        group = node.parentNode;
	                    dstyle.clip = R.format("rect({1}px {2}px {3}px {0}px)", rect);
	                    if (!node.clipRect) {
	                        dstyle.position = "absolute";
	                        dstyle.top = 0;
	                        dstyle.left = 0;
	                        dstyle.width = o.paper.width + "px";
	                        dstyle.height = o.paper.height + "px";
	                        group.parentNode.insertBefore(div, group);
	                        div[appendChild](group);
	                        node.clipRect = div;
	                    }
	                }
	                if (!params["clip-rect"]) {
	                    node.clipRect && (node.clipRect.style.clip = E);
	                }
	            }
	            if (o.type == "image" && params.src) {
	                node.src = params.src;
	            }
	            if (o.type == "image" && params.opacity) {
	                node.filterOpacity = ms + ".Alpha(opacity=" + (params.opacity * 100) + ")";
	                s.filter = (node.filterMatrix || E) + (node.filterOpacity || E);
	            }
	            params.font && (s.font = params.font);
	            params["font-family"] && (s.fontFamily = '"' + params["font-family"][split](",")[0][rp](/^['"]+|['"]+$/g, E) + '"');
	            params["font-size"] && (s.fontSize = params["font-size"]);
	            params["font-weight"] && (s.fontWeight = params["font-weight"]);
	            params["font-style"] && (s.fontStyle = params["font-style"]);
	            if (params.opacity != null ||
	                params["stroke-width"] != null ||
	                params.fill != null ||
	                params.stroke != null ||
	                params["stroke-width"] != null ||
	                params["stroke-opacity"] != null ||
	                params["fill-opacity"] != null ||
	                params["stroke-dasharray"] != null ||
	                params["stroke-miterlimit"] != null ||
	                params["stroke-linejoin"] != null ||
	                params["stroke-linecap"] != null) {
	                node = o.shape || node;
	                var fill = (node.getElementsByTagName(fillString) && node.getElementsByTagName(fillString)[0]),
	                    newfill = false;
	                !fill && (newfill = fill = createNode(fillString));
	                if ("fill-opacity" in params || "opacity" in params) {
	                    var opacity = ((+a["fill-opacity"] + 1 || 2) - 1) * ((+a.opacity + 1 || 2) - 1) * ((+R.getRGB(params.fill).o + 1 || 2) - 1);
	                    opacity = mmin(mmax(opacity, 0), 1);
	                    fill.opacity = opacity;
	                }
	                params.fill && (fill.on = true);
	                if (fill.on == null || params.fill == "none") {
	                    fill.on = false;
	                }
	                if (fill.on && params.fill) {
	                    var isURL = params.fill.match(ISURL);
	                    if (isURL) {
	                        fill.src = isURL[1];
	                        fill.type = "tile";
	                    } else {
	                        fill.color = R.getRGB(params.fill).hex;
	                        fill.src = E;
	                        fill.type = "solid";
	                        if (R.getRGB(params.fill).error && (res.type in {circle: 1, ellipse: 1} || Str(params.fill).charAt() != "r") && addGradientFill(res, params.fill)) {
	                            a.fill = "none";
	                            a.gradient = params.fill;
	                        }
	                    }
	                }
	                newfill && node[appendChild](fill);
	                var stroke = (node.getElementsByTagName("stroke") && node.getElementsByTagName("stroke")[0]),
	                newstroke = false;
	                !stroke && (newstroke = stroke = createNode("stroke"));
	                if ((params.stroke && params.stroke != "none") ||
	                    params["stroke-width"] ||
	                    params["stroke-opacity"] != null ||
	                    params["stroke-dasharray"] ||
	                    params["stroke-miterlimit"] ||
	                    params["stroke-linejoin"] ||
	                    params["stroke-linecap"]) {
	                    stroke.on = true;
	                }
	                (params.stroke == "none" || stroke.on == null || params.stroke == 0 || params["stroke-width"] == 0) && (stroke.on = false);
	                var strokeColor = R.getRGB(params.stroke);
	                stroke.on && params.stroke && (stroke.color = strokeColor.hex);
	                opacity = ((+a["stroke-opacity"] + 1 || 2) - 1) * ((+a.opacity + 1 || 2) - 1) * ((+strokeColor.o + 1 || 2) - 1);
	                var width = (toFloat(params["stroke-width"]) || 1) * .75;
	                opacity = mmin(mmax(opacity, 0), 1);
	                params["stroke-width"] == null && (width = a["stroke-width"]);
	                params["stroke-width"] && (stroke.weight = width);
	                width && width < 1 && (opacity *= width) && (stroke.weight = 1);
	                stroke.opacity = opacity;
	
	                params["stroke-linejoin"] && (stroke.joinstyle = params["stroke-linejoin"] || "miter");
	                stroke.miterlimit = params["stroke-miterlimit"] || 8;
	                params["stroke-linecap"] && (stroke.endcap = params["stroke-linecap"] == "butt" ? "flat" : params["stroke-linecap"] == "square" ? "square" : "round");
	                if (params["stroke-dasharray"]) {
	                    var dasharray = {
	                        "-": "shortdash",
	                        ".": "shortdot",
	                        "-.": "shortdashdot",
	                        "-..": "shortdashdotdot",
	                        ". ": "dot",
	                        "- ": "dash",
	                        "--": "longdash",
	                        "- .": "dashdot",
	                        "--.": "longdashdot",
	                        "--..": "longdashdotdot"
	                    };
	                    stroke.dashstyle = dasharray[has](params["stroke-dasharray"]) ? dasharray[params["stroke-dasharray"]] : E;
	                }
	                newstroke && node[appendChild](stroke);
	            }
	            if (res.type == "text") {
	                s = res.paper.span.style;
	                a.font && (s.font = a.font);
	                a["font-family"] && (s.fontFamily = a["font-family"]);
	                a["font-size"] && (s.fontSize = a["font-size"]);
	                a["font-weight"] && (s.fontWeight = a["font-weight"]);
	                a["font-style"] && (s.fontStyle = a["font-style"]);
	                res.node.string && (res.paper.span.innerHTML = Str(res.node.string)[rp](/</g, "&#60;")[rp](/&/g, "&#38;")[rp](/\n/g, "<br>"));
	                res.W = a.w = res.paper.span.offsetWidth;
	                res.H = a.h = res.paper.span.offsetHeight;
	                res.X = a.x;
	                res.Y = a.y + round(res.H / 2);
	
	                // text-anchor emulationm
	                switch (a["text-anchor"]) {
	                    case "start":
	                        res.node.style["v-text-align"] = "left";
	                        res.bbx = round(res.W / 2);
	                    break;
	                    case "end":
	                        res.node.style["v-text-align"] = "right";
	                        res.bbx = -round(res.W / 2);
	                    break;
	                    default:
	                        res.node.style["v-text-align"] = "center";
	                    break;
	                }
	            }
	        };
	        addGradientFill = function (o, gradient) {
	            o.attrs = o.attrs || {};
	            var attrs = o.attrs,
	                fill,
	                type = "linear",
	                fxfy = ".5 .5";
	            o.attrs.gradient = gradient;
	            gradient = Str(gradient)[rp](radial_gradient, function (all, fx, fy) {
	                type = "radial";
	                if (fx && fy) {
	                    fx = toFloat(fx);
	                    fy = toFloat(fy);
	                    pow(fx - .5, 2) + pow(fy - .5, 2) > .25 && (fy = math.sqrt(.25 - pow(fx - .5, 2)) * ((fy > .5) * 2 - 1) + .5);
	                    fxfy = fx + S + fy;
	                }
	                return E;
	            });
	            gradient = gradient[split](/\s*\-\s*/);
	            if (type == "linear") {
	                var angle = gradient.shift();
	                angle = -toFloat(angle);
	                if (isNaN(angle)) {
	                    return null;
	                }
	            }
	            var dots = parseDots(gradient);
	            if (!dots) {
	                return null;
	            }
	            o = o.shape || o.node;
	            fill = o.getElementsByTagName(fillString)[0] || createNode(fillString);
	            !fill.parentNode && o.appendChild(fill);
	            if (dots[length]) {
	                fill.on = true;
	                fill.method = "none";
	                fill.color = dots[0].color;
	                fill.color2 = dots[dots[length] - 1].color;
	                var clrs = [];
	                for (var i = 0, ii = dots[length]; i < ii; i++) {
	                    dots[i].offset && clrs[push](dots[i].offset + S + dots[i].color);
	                }
	                fill.colors && (fill.colors.value = clrs[length] ? clrs[join]() : "0% " + fill.color);
	                if (type == "radial") {
	                    fill.type = "gradientradial";
	                    fill.focus = "100%";
	                    fill.focussize = fxfy;
	                    fill.focusposition = fxfy;
	                } else {
	                    fill.type = "gradient";
	                    fill.angle = (270 - angle) % 360;
	                }
	            }
	            return 1;
	        };
	        Element = function (node, group, vml) {
	            var Rotation = 0,
	                RotX = 0,
	                RotY = 0,
	                Scale = 1;
	            this[0] = node;
	            this.id = R._oid++;
	            this.node = node;
	            node.raphael = this;
	            this.X = 0;
	            this.Y = 0;
	            this.attrs = {};
	            this.Group = group;
	            this.paper = vml;
	            this._ = {
	                tx: 0,
	                ty: 0,
	                rt: {deg:0},
	                sx: 1,
	                sy: 1
	            };
	            !vml.bottom && (vml.bottom = this);
	            this.prev = vml.top;
	            vml.top && (vml.top.next = this);
	            vml.top = this;
	            this.next = null;
	        };
	        elproto = Element[proto];
	        elproto.rotate = function (deg, cx, cy) {
	            if (this.removed) {
	                return this;
	            }
	            if (deg == null) {
	                if (this._.rt.cx) {
	                    return [this._.rt.deg, this._.rt.cx, this._.rt.cy][join](S);
	                }
	                return this._.rt.deg;
	            }
	            deg = Str(deg)[split](separator);
	            if (deg[length] - 1) {
	                cx = toFloat(deg[1]);
	                cy = toFloat(deg[2]);
	            }
	            deg = toFloat(deg[0]);
	            if (cx != null) {
	                this._.rt.deg = deg;
	            } else {
	                this._.rt.deg += deg;
	            }
	            cy == null && (cx = null);
	            this._.rt.cx = cx;
	            this._.rt.cy = cy;
	            this.setBox(this.attrs, cx, cy);
	            this.Group.style.rotation = this._.rt.deg;
	            // gradient fix for rotation. TODO
	            // var fill = (this.shape || this.node).getElementsByTagName(fillString);
	            // fill = fill[0] || {};
	            // var b = ((360 - this._.rt.deg) - 270) % 360;
	            // !R.is(fill.angle, "undefined") && (fill.angle = b);
	            return this;
	        };
	        elproto.setBox = function (params, cx, cy) {
	            if (this.removed) {
	                return this;
	            }
	            var gs = this.Group.style,
	                os = (this.shape && this.shape.style) || this.node.style;
	            params = params || {};
	            for (var i in params) if (params[has](i)) {
	                this.attrs[i] = params[i];
	            }
	            cx = cx || this._.rt.cx;
	            cy = cy || this._.rt.cy;
	            var attr = this.attrs,
	                x,
	                y,
	                w,
	                h;
	            switch (this.type) {
	                case "circle":
	                    x = attr.cx - attr.r;
	                    y = attr.cy - attr.r;
	                    w = h = attr.r * 2;
	                    break;
	                case "ellipse":
	                    x = attr.cx - attr.rx;
	                    y = attr.cy - attr.ry;
	                    w = attr.rx * 2;
	                    h = attr.ry * 2;
	                    break;
	                case "image":
	                    x = +attr.x;
	                    y = +attr.y;
	                    w = attr.width || 0;
	                    h = attr.height || 0;
	                    break;
	                case "text":
	                    this.textpath.v = ["m", round(attr.x), ", ", round(attr.y - 2), "l", round(attr.x) + 1, ", ", round(attr.y - 2)][join](E);
	                    x = attr.x - round(this.W / 2);
	                    y = attr.y - this.H / 2;
	                    w = this.W;
	                    h = this.H;
	                    break;
	                case "rect":
	                case "path":
	                    if (!this.attrs.path) {
	                        x = 0;
	                        y = 0;
	                        w = this.paper.width;
	                        h = this.paper.height;
	                    } else {
	                        var dim = pathDimensions(this.attrs.path);
	                        x = dim.x;
	                        y = dim.y;
	                        w = dim.width;
	                        h = dim.height;
	                    }
	                    break;
	                default:
	                    x = 0;
	                    y = 0;
	                    w = this.paper.width;
	                    h = this.paper.height;
	                    break;
	            }
	            cx = (cx == null) ? x + w / 2 : cx;
	            cy = (cy == null) ? y + h / 2 : cy;
	            var left = cx - this.paper.width / 2,
	                top = cy - this.paper.height / 2, t;
	            gs.left != (t = left + "px") && (gs.left = t);
	            gs.top != (t = top + "px") && (gs.top = t);
	            this.X = pathlike[has](this.type) ? -left : x;
	            this.Y = pathlike[has](this.type) ? -top : y;
	            this.W = w;
	            this.H = h;
	            if (pathlike[has](this.type)) {
	                os.left != (t = -left * zoom + "px") && (os.left = t);
	                os.top != (t = -top * zoom + "px") && (os.top = t);
	            } else if (this.type == "text") {
	                os.left != (t = -left + "px") && (os.left = t);
	                os.top != (t = -top + "px") && (os.top = t);
	            } else {
	                gs.width != (t = this.paper.width + "px") && (gs.width = t);
	                gs.height != (t = this.paper.height + "px") && (gs.height = t);
	                os.left != (t = x - left + "px") && (os.left = t);
	                os.top != (t = y - top + "px") && (os.top = t);
	                os.width != (t = w + "px") && (os.width = t);
	                os.height != (t = h + "px") && (os.height = t);
	            }
	        };
	        elproto.hide = function () {
	            !this.removed && (this.Group.style.display = "none");
	            return this;
	        };
	        elproto.show = function () {
	            !this.removed && (this.Group.style.display = "block");
	            return this;
	        };
	        elproto.getBBox = function () {
	            if (this.removed) {
	                return this;
	            }
	            if (pathlike[has](this.type)) {
	                return pathDimensions(this.attrs.path);
	            }
	            return {
	                x: this.X + (this.bbx || 0),
	                y: this.Y,
	                width: this.W,
	                height: this.H
	            };
	        };
	        elproto.remove = function () {
	            if (this.removed) {
	                return;
	            }
	            tear(this, this.paper);
	            this.node.parentNode.removeChild(this.node);
	            this.Group.parentNode.removeChild(this.Group);
	            this.shape && this.shape.parentNode.removeChild(this.shape);
	            for (var i in this) {
	                delete this[i];
	            }
	            this.removed = true;
	        };
	        elproto.attr = function (name, value) {
	            if (this.removed) {
	                return this;
	            }
	            if (name == null) {
	                var res = {};
	                for (var i in this.attrs) if (this.attrs[has](i)) {
	                    res[i] = this.attrs[i];
	                }
	                this._.rt.deg && (res.rotation = this.rotate());
	                (this._.sx != 1 || this._.sy != 1) && (res.scale = this.scale());
	                res.gradient && res.fill == "none" && (res.fill = res.gradient) && delete res.gradient;
	                return res;
	            }
	            if (value == null && R.is(name, "string")) {
	                if (name == "translation") {
	                    return translate.call(this);
	                }
	                if (name == "rotation") {
	                    return this.rotate();
	                }
	                if (name == "scale") {
	                    return this.scale();
	                }
	                if (name == fillString && this.attrs.fill == "none" && this.attrs.gradient) {
	                    return this.attrs.gradient;
	                }
	                return this.attrs[name];
	            }
	            if (this.attrs && value == null && R.is(name, array)) {
	                var ii, values = {};
	                for (i = 0, ii = name[length]; i < ii; i++) {
	                    values[name[i]] = this.attr(name[i]);
	                }
	                return values;
	            }
	            var params;
	            if (value != null) {
	                params = {};
	                params[name] = value;
	            }
	            value == null && R.is(name, "object") && (params = name);
	            if (params) {
	                for (var key in this.paper.customAttributes) if (this.paper.customAttributes[has](key) && params[has](key) && R.is(this.paper.customAttributes[key], "function")) {
	                    var par = this.paper.customAttributes[key].apply(this, [][concat](params[key]));
	                    this.attrs[key] = params[key];
	                    for (var subkey in par) if (par[has](subkey)) {
	                        params[subkey] = par[subkey];
	                    }
	                }
	                if (params.text && this.type == "text") {
	                    this.node.string = params.text;
	                }
	                setFillAndStroke(this, params);
	                if (params.gradient && (({circle: 1, ellipse: 1})[has](this.type) || Str(params.gradient).charAt() != "r")) {
	                    addGradientFill(this, params.gradient);
	                }
	                (!pathlike[has](this.type) || this._.rt.deg) && this.setBox(this.attrs);
	            }
	            return this;
	        };
	        elproto.toFront = function () {
	            !this.removed && this.Group.parentNode[appendChild](this.Group);
	            this.paper.top != this && tofront(this, this.paper);
	            return this;
	        };
	        elproto.toBack = function () {
	            if (this.removed) {
	                return this;
	            }
	            if (this.Group.parentNode.firstChild != this.Group) {
	                this.Group.parentNode.insertBefore(this.Group, this.Group.parentNode.firstChild);
	                toback(this, this.paper);
	            }
	            return this;
	        };
	        elproto.insertAfter = function (element) {
	            if (this.removed) {
	                return this;
	            }
	            if (element.constructor == Set) {
	                element = element[element.length - 1];
	            }
	            if (element.Group.nextSibling) {
	                element.Group.parentNode.insertBefore(this.Group, element.Group.nextSibling);
	            } else {
	                element.Group.parentNode[appendChild](this.Group);
	            }
	            insertafter(this, element, this.paper);
	            return this;
	        };
	        elproto.insertBefore = function (element) {
	            if (this.removed) {
	                return this;
	            }
	            if (element.constructor == Set) {
	                element = element[0];
	            }
	            element.Group.parentNode.insertBefore(this.Group, element.Group);
	            insertbefore(this, element, this.paper);
	            return this;
	        };
	        elproto.blur = function (size) {
	            var s = this.node.runtimeStyle,
	                f = s.filter;
	            f = f.replace(blurregexp, E);
	            if (+size !== 0) {
	                this.attrs.blur = size;
	                s.filter = f + S + ms + ".Blur(pixelradius=" + (+size || 1.5) + ")";
	                s.margin = R.format("-{0}px 0 0 -{0}px", round(+size || 1.5));
	            } else {
	                s.filter = f;
	                s.margin = 0;
	                delete this.attrs.blur;
	            }
	        };
	
	        theCircle = function (vml, x, y, r) {
	            var g = createNode("group"),
	                o = createNode("oval"),
	                ol = o.style;
	            g.style.cssText = "position:absolute;left:0;top:0;width:" + vml.width + "px;height:" + vml.height + "px";
	            g.coordsize = coordsize;
	            g.coordorigin = vml.coordorigin;
	            g[appendChild](o);
	            var res = new Element(o, g, vml);
	            res.type = "circle";
	            setFillAndStroke(res, {stroke: "#000", fill: "none"});
	            res.attrs.cx = x;
	            res.attrs.cy = y;
	            res.attrs.r = r;
	            res.setBox({x: x - r, y: y - r, width: r * 2, height: r * 2});
	            vml.canvas[appendChild](g);
	            return res;
	        };
	        function rectPath(x, y, w, h, r) {
	            if (r) {
	                return R.format("M{0},{1}l{2},0a{3},{3},0,0,1,{3},{3}l0,{5}a{3},{3},0,0,1,{4},{3}l{6},0a{3},{3},0,0,1,{4},{4}l0,{7}a{3},{3},0,0,1,{3},{4}z", x + r, y, w - r * 2, r, -r, h - r * 2, r * 2 - w, r * 2 - h);
	            } else {
	                return R.format("M{0},{1}l{2},0,0,{3},{4},0z", x, y, w, h, -w);
	            }
	        }
	        theRect = function (vml, x, y, w, h, r) {
	            var path = rectPath(x, y, w, h, r),
	                res = vml.path(path),
	                a = res.attrs;
	            res.X = a.x = x;
	            res.Y = a.y = y;
	            res.W = a.width = w;
	            res.H = a.height = h;
	            a.r = r;
	            a.path = path;
	            res.type = "rect";
	            return res;
	        };
	        theEllipse = function (vml, x, y, rx, ry) {
	            var g = createNode("group"),
	                o = createNode("oval"),
	                ol = o.style;
	            g.style.cssText = "position:absolute;left:0;top:0;width:" + vml.width + "px;height:" + vml.height + "px";
	            g.coordsize = coordsize;
	            g.coordorigin = vml.coordorigin;
	            g[appendChild](o);
	            var res = new Element(o, g, vml);
	            res.type = "ellipse";
	            setFillAndStroke(res, {stroke: "#000"});
	            res.attrs.cx = x;
	            res.attrs.cy = y;
	            res.attrs.rx = rx;
	            res.attrs.ry = ry;
	            res.setBox({x: x - rx, y: y - ry, width: rx * 2, height: ry * 2});
	            vml.canvas[appendChild](g);
	            return res;
	        };
	        theImage = function (vml, src, x, y, w, h) {
	            var g = createNode("group"),
	                o = createNode("image");
	            g.style.cssText = "position:absolute;left:0;top:0;width:" + vml.width + "px;height:" + vml.height + "px";
	            g.coordsize = coordsize;
	            g.coordorigin = vml.coordorigin;
	            o.src = src;
	            g[appendChild](o);
	            var res = new Element(o, g, vml);
	            res.type = "image";
	            res.attrs.src = src;
	            res.attrs.x = x;
	            res.attrs.y = y;
	            res.attrs.w = w;
	            res.attrs.h = h;
	            res.setBox({x: x, y: y, width: w, height: h});
	            vml.canvas[appendChild](g);
	            return res;
	        };
	        theText = function (vml, x, y, text) {
	            var g = createNode("group"),
	                el = createNode("shape"),
	                ol = el.style,
	                path = createNode("path"),
	                ps = path.style,
	                o = createNode("textpath");
	            g.style.cssText = "position:absolute;left:0;top:0;width:" + vml.width + "px;height:" + vml.height + "px";
	            g.coordsize = coordsize;
	            g.coordorigin = vml.coordorigin;
	            path.v = R.format("m{0},{1}l{2},{1}", round(x * 10), round(y * 10), round(x * 10) + 1);
	            path.textpathok = true;
	            ol.width = vml.width;
	            ol.height = vml.height;
	            o.string = Str(text);
	            o.on = true;
	            el[appendChild](o);
	            el[appendChild](path);
	            g[appendChild](el);
	            var res = new Element(o, g, vml);
	            res.shape = el;
	            res.textpath = path;
	            res.type = "text";
	            res.attrs.text = text;
	            res.attrs.x = x;
	            res.attrs.y = y;
	            res.attrs.w = 1;
	            res.attrs.h = 1;
	            setFillAndStroke(res, {font: availableAttrs.font, stroke: "none", fill: "#000"});
	            res.setBox();
	            vml.canvas[appendChild](g);
	            return res;
	        };
	        setSize = function (width, height) {
	            var cs = this.canvas.style;
	            width == +width && (width += "px");
	            height == +height && (height += "px");
	            cs.width = width;
	            cs.height = height;
	            cs.clip = "rect(0 " + width + " " + height + " 0)";
	            return this;
	        };
	        var createNode;
	        doc.createStyleSheet().addRule(".rvml", "behavior:url(#default#VML)");
	        try {
	            !doc.namespaces.rvml && doc.namespaces.add("rvml", "urn:schemas-microsoft-com:vml");
	            createNode = function (tagName) {
	                return doc.createElement('<rvml:' + tagName + ' class="rvml">');
	            };
	        } catch (e) {
	            createNode = function (tagName) {
	                return doc.createElement('<' + tagName + ' xmlns="urn:schemas-microsoft.com:vml" class="rvml">');
	            };
	        }
	        create = function () {
	            var con = getContainer[apply](0, arguments),
	                container = con.container,
	                height = con.height,
	                s,
	                width = con.width,
	                x = con.x,
	                y = con.y;
	            if (!container) {
	                throw new Error("VML container not found.");
	            }
	            var res = new Paper,
	                c = res.canvas = doc.createElement("div"),
	                cs = c.style;
	            x = x || 0;
	            y = y || 0;
	            width = width || 512;
	            height = height || 342;
	            width == +width && (width += "px");
	            height == +height && (height += "px");
	            res.width = 1e3;
	            res.height = 1e3;
	            res.coordsize = zoom * 1e3 + S + zoom * 1e3;
	            res.coordorigin = "0 0";
	            res.span = doc.createElement("span");
	            res.span.style.cssText = "position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;display:inline;";
	            c[appendChild](res.span);
	            cs.cssText = R.format("top:0;left:0;width:{0};height:{1};display:inline-block;position:relative;clip:rect(0 {0} {1} 0);overflow:hidden", width, height);
	            if (container == 1) {
	                doc.body[appendChild](c);
	                cs.left = x + "px";
	                cs.top = y + "px";
	                cs.position = "absolute";
	            } else {
	                if (container.firstChild) {
	                    container.insertBefore(c, container.firstChild);
	                } else {
	                    container[appendChild](c);
	                }
	            }
	            plugins.call(res, res, R.fn);
	            return res;
	        };
	        paperproto.clear = function () {
	            this.canvas.innerHTML = E;
	            this.span = doc.createElement("span");
	            this.span.style.cssText = "position:absolute;left:-9999em;top:-9999em;padding:0;margin:0;line-height:1;display:inline;";
	            this.canvas[appendChild](this.span);
	            this.bottom = this.top = null;
	        };
	        paperproto.remove = function () {
	            this.canvas.parentNode.removeChild(this.canvas);
	            for (var i in this) {
	                this[i] = removed(i);
	            }
	            return true;
	        };
	    }
	
	    // rest
	    // WebKit rendering bug workaround method
	    var version = navigator.userAgent.match(/Version\/(.*?)\s/);
	    if ((navigator.vendor == "Apple Computer, Inc.") && (version && version[1] < 4 || navigator.platform.slice(0, 2) == "iP")) {
	        paperproto.safari = function () {
	            var rect = this.rect(-99, -99, this.width + 99, this.height + 99).attr({stroke: "none"});
	            win.setTimeout(function () {rect.remove();});
	        };
	    } else {
	        paperproto.safari = function () {};
	    }
	
	    // Events
	    var preventDefault = function () {
	        this.returnValue = false;
	    },
	    preventTouch = function () {
	        return this.originalEvent.preventDefault();
	    },
	    stopPropagation = function () {
	        this.cancelBubble = true;
	    },
	    stopTouch = function () {
	        return this.originalEvent.stopPropagation();
	    },
	    addEvent = (function () {
	        if (doc.addEventListener) {
	            return function (obj, type, fn, element) {
	                var realName = supportsTouch && touchMap[type] ? touchMap[type] : type;
	                var f = function (e) {
	                    if (supportsTouch && touchMap[has](type)) {
	                        for (var i = 0, ii = e.targetTouches && e.targetTouches.length; i < ii; i++) {
	                            if (e.targetTouches[i].target == obj) {
	                                var olde = e;
	                                e = e.targetTouches[i];
	                                e.originalEvent = olde;
	                                e.preventDefault = preventTouch;
	                                e.stopPropagation = stopTouch;
	                                break;
	                            }
	                        }
	                    }
	                    return fn.call(element, e);
	                };
	                obj.addEventListener(realName, f, false);
	                return function () {
	                    obj.removeEventListener(realName, f, false);
	                    return true;
	                };
	            };
	        } else if (doc.attachEvent) {
	            return function (obj, type, fn, element) {
	                var f = function (e) {
	                    e = e || win.event;
	                    e.preventDefault = e.preventDefault || preventDefault;
	                    e.stopPropagation = e.stopPropagation || stopPropagation;
	                    return fn.call(element, e);
	                };
	                obj.attachEvent("on" + type, f);
	                var detacher = function () {
	                    obj.detachEvent("on" + type, f);
	                    return true;
	                };
	                return detacher;
	            };
	        }
	    })(),
	    drag = [],
	    dragMove = function (e) {
	        var x = e.clientX,
	            y = e.clientY,
	            scrollY = doc.documentElement.scrollTop || doc.body.scrollTop,
	            scrollX = doc.documentElement.scrollLeft || doc.body.scrollLeft,
	            dragi,
	            j = drag.length;
	        while (j--) {
	            dragi = drag[j];
	            if (supportsTouch) {
	                var i = e.touches.length,
	                    touch;
	                while (i--) {
	                    touch = e.touches[i];
	                    if (touch.identifier == dragi.el._drag.id) {
	                        x = touch.clientX;
	                        y = touch.clientY;
	                        (e.originalEvent ? e.originalEvent : e).preventDefault();
	                        break;
	                    }
	                }
	            } else {
	                e.preventDefault();
	            }
	            x += scrollX;
	            y += scrollY;
	            dragi.move && dragi.move.call(dragi.move_scope || dragi.el, x - dragi.el._drag.x, y - dragi.el._drag.y, x, y, e);
	        }
	    },
	    dragUp = function (e) {
	        R.unmousemove(dragMove).unmouseup(dragUp);
	        var i = drag.length,
	            dragi;
	        while (i--) {
	            dragi = drag[i];
	            dragi.el._drag = {};
	            dragi.end && dragi.end.call(dragi.end_scope || dragi.start_scope || dragi.move_scope || dragi.el, e);
	        }
	        drag = [];
	    };
	    for (var i = events[length]; i--;) {
	        (function (eventName) {
	            R[eventName] = Element[proto][eventName] = function (fn, scope) {
	                if (R.is(fn, "function")) {
	                    this.events = this.events || [];
	                    this.events.push({name: eventName, f: fn, unbind: addEvent(this.shape || this.node || doc, eventName, fn, scope || this)});
	                }
	                return this;
	            };
	            R["un" + eventName] = Element[proto]["un" + eventName] = function (fn) {
	                var events = this.events,
	                    l = events[length];
	                while (l--) if (events[l].name == eventName && events[l].f == fn) {
	                    events[l].unbind();
	                    events.splice(l, 1);
	                    !events.length && delete this.events;
	                    return this;
	                }
	                return this;
	            };
	        })(events[i]);
	    }
	    elproto.hover = function (f_in, f_out, scope_in, scope_out) {
	        return this.mouseover(f_in, scope_in).mouseout(f_out, scope_out || scope_in);
	    };
	    elproto.unhover = function (f_in, f_out) {
	        return this.unmouseover(f_in).unmouseout(f_out);
	    };
	    elproto.drag = function (onmove, onstart, onend, move_scope, start_scope, end_scope) {
	        this._drag = {};
	        this.mousedown(function (e) {
	            (e.originalEvent || e).preventDefault();
	            var scrollY = doc.documentElement.scrollTop || doc.body.scrollTop,
	                scrollX = doc.documentElement.scrollLeft || doc.body.scrollLeft;
	            this._drag.x = e.clientX + scrollX;
	            this._drag.y = e.clientY + scrollY;
	            this._drag.id = e.identifier;
	            onstart && onstart.call(start_scope || move_scope || this, e.clientX + scrollX, e.clientY + scrollY, e);
	            !drag.length && R.mousemove(dragMove).mouseup(dragUp);
	            drag.push({el: this, move: onmove, end: onend, move_scope: move_scope, start_scope: start_scope, end_scope: end_scope});
	        });
	        return this;
	    };
	    elproto.undrag = function (onmove, onstart, onend) {
	        var i = drag.length;
	        while (i--) {
	            drag[i].el == this && (drag[i].move == onmove && drag[i].end == onend) && drag.splice(i++, 1);
	        }
	        !drag.length && R.unmousemove(dragMove).unmouseup(dragUp);
	    };
	    paperproto.circle = function (x, y, r) {
	        return theCircle(this, x || 0, y || 0, r || 0);
	    };
	    paperproto.rect = function (x, y, w, h, r) {
	        return theRect(this, x || 0, y || 0, w || 0, h || 0, r || 0);
	    };
	    paperproto.ellipse = function (x, y, rx, ry) {
	        return theEllipse(this, x || 0, y || 0, rx || 0, ry || 0);
	    };
	    paperproto.path = function (pathString) {
	        pathString && !R.is(pathString, string) && !R.is(pathString[0], array) && (pathString += E);
	        return thePath(R.format[apply](R, arguments), this);
	    };
	    paperproto.image = function (src, x, y, w, h) {
	        return theImage(this, src || "about:blank", x || 0, y || 0, w || 0, h || 0);
	    };
	    paperproto.text = function (x, y, text) {
	        return theText(this, x || 0, y || 0, Str(text));
	    };
	    paperproto.set = function (itemsArray) {
	        arguments[length] > 1 && (itemsArray = Array[proto].splice.call(arguments, 0, arguments[length]));
	        return new Set(itemsArray);
	    };
	    paperproto.setSize = setSize;
	    paperproto.top = paperproto.bottom = null;
	    paperproto.raphael = R;
	    function x_y() {
	        return this.x + S + this.y;
	    }
	    elproto.resetScale = function () {
	        if (this.removed) {
	            return this;
	        }
	        this._.sx = 1;
	        this._.sy = 1;
	        this.attrs.scale = "1 1";
	    };
	    elproto.scale = function (x, y, cx, cy) {
	        if (this.removed) {
	            return this;
	        }
	        if (x == null && y == null) {
	            return {
	                x: this._.sx,
	                y: this._.sy,
	                toString: x_y
	            };
	        }
	        y = y || x;
	        !+y && (y = x);
	        var dx,
	            dy,
	            dcx,
	            dcy,
	            a = this.attrs;
	        if (x != 0) {
	            var bb = this.getBBox(),
	                rcx = bb.x + bb.width / 2,
	                rcy = bb.y + bb.height / 2,
	                kx = abs(x / this._.sx),
	                ky = abs(y / this._.sy);
	            cx = (+cx || cx == 0) ? cx : rcx;
	            cy = (+cy || cy == 0) ? cy : rcy;
	            var posx = this._.sx > 0,
	                posy = this._.sy > 0,
	                dirx = ~~(x / abs(x)),
	                diry = ~~(y / abs(y)),
	                dkx = kx * dirx,
	                dky = ky * diry,
	                s = this.node.style,
	                ncx = cx + abs(rcx - cx) * dkx * (rcx > cx == posx ? 1 : -1),
	                ncy = cy + abs(rcy - cy) * dky * (rcy > cy == posy ? 1 : -1),
	                fr = (x * dirx > y * diry ? ky : kx);
	            switch (this.type) {
	                case "rect":
	                case "image":
	                    var neww = a.width * kx,
	                        newh = a.height * ky;
	                    this.attr({
	                        height: newh,
	                        r: a.r * fr,
	                        width: neww,
	                        x: ncx - neww / 2,
	                        y: ncy - newh / 2
	                    });
	                    break;
	                case "circle":
	                case "ellipse":
	                    this.attr({
	                        rx: a.rx * kx,
	                        ry: a.ry * ky,
	                        r: a.r * fr,
	                        cx: ncx,
	                        cy: ncy
	                    });
	                    break;
	                case "text":
	                    this.attr({
	                        x: ncx,
	                        y: ncy
	                    });
	                    break;
	                case "path":
	                    var path = pathToRelative(a.path),
	                        skip = true,
	                        fx = posx ? dkx : kx,
	                        fy = posy ? dky : ky;
	                    for (var i = 0, ii = path[length]; i < ii; i++) {
	                        var p = path[i],
	                            P0 = upperCase.call(p[0]);
	                        if (P0 == "M" && skip) {
	                            continue;
	                        } else {
	                            skip = false;
	                        }
	                        if (P0 == "A") {
	                            p[path[i][length] - 2] *= fx;
	                            p[path[i][length] - 1] *= fy;
	                            p[1] *= kx;
	                            p[2] *= ky;
	                            p[5] = +(dirx + diry ? !!+p[5] : !+p[5]);
	                        } else if (P0 == "H") {
	                            for (var j = 1, jj = p[length]; j < jj; j++) {
	                                p[j] *= fx;
	                            }
	                        } else if (P0 == "V") {
	                            for (j = 1, jj = p[length]; j < jj; j++) {
	                                p[j] *= fy;
	                            }
	                         } else {
	                            for (j = 1, jj = p[length]; j < jj; j++) {
	                                p[j] *= (j % 2) ? fx : fy;
	                            }
	                        }
	                    }
	                    var dim2 = pathDimensions(path);
	                    dx = ncx - dim2.x - dim2.width / 2;
	                    dy = ncy - dim2.y - dim2.height / 2;
	                    path[0][1] += dx;
	                    path[0][2] += dy;
	                    this.attr({path: path});
	                break;
	            }
	            if (this.type in {text: 1, image:1} && (dirx != 1 || diry != 1)) {
	                if (this.transformations) {
	                    this.transformations[2] = "scale("[concat](dirx, ",", diry, ")");
	                    setAttr(this.node, "transform", this.transformations[join](S));
	                    dx = (dirx == -1) ? -a.x - (neww || 0) : a.x;
	                    dy = (diry == -1) ? -a.y - (newh || 0) : a.y;
	                    this.attr({x: dx, y: dy});
	                    a.fx = dirx - 1;
	                    a.fy = diry - 1;
	                } else {
	                    this.node.filterMatrix = ms + ".Matrix(M11="[concat](dirx,
	                        ", M12=0, M21=0, M22=", diry,
	                        ", Dx=0, Dy=0, sizingmethod='auto expand', filtertype='bilinear')");
	                    s.filter = (this.node.filterMatrix || E) + (this.node.filterOpacity || E);
	                }
	            } else {
	                if (this.transformations) {
	                    this.transformations[2] = E;
	                    setAttr(this.node, "transform", this.transformations[join](S));
	                    a.fx = 0;
	                    a.fy = 0;
	                } else {
	                    this.node.filterMatrix = E;
	                    s.filter = (this.node.filterMatrix || E) + (this.node.filterOpacity || E);
	                }
	            }
	            a.scale = [x, y, cx, cy][join](S);
	            this._.sx = x;
	            this._.sy = y;
	        }
	        return this;
	    };
	    elproto.clone = function () {
	        if (this.removed) {
	            return null;
	        }
	        var attr = this.attr();
	        delete attr.scale;
	        delete attr.translation;
	        return this.paper[this.type]().attr(attr);
	    };
	    var curveslengths = {},
	    getPointAtSegmentLength = function (p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, length) {
	        // Is this a straight line?
	        // Added for huge speed improvements
	        if ( p1x === c1x && p1y === c1y && c2x === p2x && c2y == p2y ) {
	            var dx = p2x - p1x, dy = p2y - p1y;
	            var totalLength = Math.sqrt( dx * dx + dy * dy );
	
	            if ( length == null ) {
	                return totalLength;
	            } else {
	                var fract = length / totalLength;
	                return {
	                    start: { x: p1x, y: p1y },
	                    m: { x: p1x, y: p1y },
	                    n: { x: p2x, y: p2y },
	                    end: { x: p2x, y: p2y },
	                    x: p1x + fract * dx,
	                    y: p1y + fract * dy,
	                    alpha: (90 - math.atan(dx / dy) * 180 / PI)
	                };
	            }
	        }
	
	        var len = 0,
	            precision = 100,
	            name = [p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y].join(),
	            cache = curveslengths[name],
	            old, dot;
	        !cache && (curveslengths[name] = cache = {data: []});
	        cache.timer && clearTimeout(cache.timer);
	        cache.timer = setTimeout(function () {delete curveslengths[name];}, 2000);
	        if (length != null) {
	            var total = getPointAtSegmentLength(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y);
	            precision = ~~total * 10;
	        }
	        for (var i = 0; i < precision + 1; i++) {
	            if (cache.data[length] > i) {
	                dot = cache.data[i * precision];
	            } else {
	                dot = R.findDotsAtSegment(p1x, p1y, c1x, c1y, c2x, c2y, p2x, p2y, i / precision);
	                cache.data[i] = dot;
	            }
	            i && (len += pow(pow(old.x - dot.x, 2) + pow(old.y - dot.y, 2), .5));
	            if (length != null && len >= length) {
	                return dot;
	            }
	            old = dot;
	        }
	        if (length == null) {
	            return len;
	        }
	    },
	    getLengthFactory = function (istotal, subpath) {
	        return function (path, length, onlystart) {
	            path = path2curve(path);
	            var x, y, p, l, sp = "", subpaths = {}, point,
	                len = 0;
	            for (var i = 0, ii = path.length; i < ii; i++) {
	                p = path[i];
	                if (p[0] == "M") {
	                    x = +p[1];
	                    y = +p[2];
	                } else {
	                    l = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6]);
	                    if (len + l > length) {
	                        if (subpath && !subpaths.start) {
	                            point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);
	                            sp += ["C", point.start.x, point.start.y, point.m.x, point.m.y, point.x, point.y];
	                            if (onlystart) {return sp;}
	                            subpaths.start = sp;
	                            sp = ["M", point.x, point.y + "C", point.n.x, point.n.y, point.end.x, point.end.y, p[5], p[6]][join]();
	                            len += l;
	                            x = +p[5];
	                            y = +p[6];
	                            continue;
	                        }
	                        if (!istotal && !subpath) {
	                            point = getPointAtSegmentLength(x, y, p[1], p[2], p[3], p[4], p[5], p[6], length - len);
	                            return {x: point.x, y: point.y, alpha: point.alpha};
	                        }
	                    }
	                    len += l;
	                    x = +p[5];
	                    y = +p[6];
	                }
	                sp += p;
	            }
	            subpaths.end = sp;
	            point = istotal ? len : subpath ? subpaths : R.findDotsAtSegment(x, y, p[1], p[2], p[3], p[4], p[5], p[6], 1);
	            point.alpha && (point = {x: point.x, y: point.y, alpha: point.alpha});
	            return point;
	        };
	    };
	    var getTotalLength = getLengthFactory(1),
	        getPointAtLength = getLengthFactory(),
	        getSubpathsAtLength = getLengthFactory(0, 1);
	    elproto.getTotalLength = function () {
	        if (this.type != "path") {return;}
	        if (this.node.getTotalLength) {
	            return this.node.getTotalLength();
	        }
	        return getTotalLength(this.attrs.path);
	    };
	    elproto.getPointAtLength = function (length) {
	        if (this.type != "path") {return;}
	        return getPointAtLength(this.attrs.path, length);
	    };
	    elproto.getSubpath = function (from, to) {
	        if (this.type != "path") {return;}
	        if (abs(this.getTotalLength() - to) < "1e-6") {
	            return getSubpathsAtLength(this.attrs.path, from).end;
	        }
	        var a = getSubpathsAtLength(this.attrs.path, to, 1);
	        return from ? getSubpathsAtLength(a, from).end : a;
	    };
	
	    // animation easing formulas
	    R.easing_formulas = {
	        linear: function (n) {
	            return n;
	        },
	        "<": function (n) {
	            return pow(n, 3);
	        },
	        ">": function (n) {
	            return pow(n - 1, 3) + 1;
	        },
	        "<>": function (n) {
	            n = n * 2;
	            if (n < 1) {
	                return pow(n, 3) / 2;
	            }
	            n -= 2;
	            return (pow(n, 3) + 2) / 2;
	        },
	        backIn: function (n) {
	            var s = 1.70158;
	            return n * n * ((s + 1) * n - s);
	        },
	        backOut: function (n) {
	            n = n - 1;
	            var s = 1.70158;
	            return n * n * ((s + 1) * n + s) + 1;
	        },
	        elastic: function (n) {
	            if (n == 0 || n == 1) {
	                return n;
	            }
	            var p = .3,
	                s = p / 4;
	            return pow(2, -10 * n) * math.sin((n - s) * (2 * PI) / p) + 1;
	        },
	        bounce: function (n) {
	            var s = 7.5625,
	                p = 2.75,
	                l;
	            if (n < (1 / p)) {
	                l = s * n * n;
	            } else {
	                if (n < (2 / p)) {
	                    n -= (1.5 / p);
	                    l = s * n * n + .75;
	                } else {
	                    if (n < (2.5 / p)) {
	                        n -= (2.25 / p);
	                        l = s * n * n + .9375;
	                    } else {
	                        n -= (2.625 / p);
	                        l = s * n * n + .984375;
	                    }
	                }
	            }
	            return l;
	        }
	    };
	
	    var animationElements = [],
	        animation = function () {
	            var Now = +new Date;
	            for (var l = 0; l < animationElements[length]; l++) {
	                var e = animationElements[l];
	                if (e.stop || e.el.removed) {
	                    continue;
	                }
	                var time = Now - e.start,
	                    ms = e.ms,
	                    easing = e.easing,
	                    from = e.from,
	                    diff = e.diff,
	                    to = e.to,
	                    t = e.t,
	                    that = e.el,
	                    set = {},
	                    now;
	                if (time < ms) {
	                    var pos = easing(time / ms);
	                    for (var attr in from) if (from[has](attr)) {
	                        switch (availableAnimAttrs[attr]) {
	                            case "along":
	                                now = pos * ms * diff[attr];
	                                to.back && (now = to.len - now);
	                                var point = getPointAtLength(to[attr], now);
	                                that.translate(diff.sx - diff.x || 0, diff.sy - diff.y || 0);
	                                diff.x = point.x;
	                                diff.y = point.y;
	                                that.translate(point.x - diff.sx, point.y - diff.sy);
	                                to.rot && that.rotate(diff.r + point.alpha, point.x, point.y);
	                                break;
	                            case nu:
	                                now = +from[attr] + pos * ms * diff[attr];
	                                break;
	                            case "colour":
	                                now = "rgb(" + [
	                                    upto255(round(from[attr].r + pos * ms * diff[attr].r)),
	                                    upto255(round(from[attr].g + pos * ms * diff[attr].g)),
	                                    upto255(round(from[attr].b + pos * ms * diff[attr].b))
	                                ][join](",") + ")";
	                                break;
	                            case "path":
	                                now = [];
	                                for (var i = 0, ii = from[attr][length]; i < ii; i++) {
	                                    now[i] = [from[attr][i][0]];
	                                    for (var j = 1, jj = from[attr][i][length]; j < jj; j++) {
	                                        now[i][j] = +from[attr][i][j] + pos * ms * diff[attr][i][j];
	                                    }
	                                    now[i] = now[i][join](S);
	                                }
	                                now = now[join](S);
	                                break;
	                            case "csv":
	                                switch (attr) {
	                                    case "translation":
	                                        var x = pos * ms * diff[attr][0] - t.x,
	                                            y = pos * ms * diff[attr][1] - t.y;
	                                        t.x += x;
	                                        t.y += y;
	                                        now = x + S + y;
	                                    break;
	                                    case "rotation":
	                                        now = +from[attr][0] + pos * ms * diff[attr][0];
	                                        from[attr][1] && (now += "," + from[attr][1] + "," + from[attr][2]);
	                                    break;
	                                    case "scale":
	                                        now = [+from[attr][0] + pos * ms * diff[attr][0], +from[attr][1] + pos * ms * diff[attr][1], (2 in to[attr] ? to[attr][2] : E), (3 in to[attr] ? to[attr][3] : E)][join](S);
	                                    break;
	                                    case "clip-rect":
	                                        now = [];
	                                        i = 4;
	                                        while (i--) {
	                                            now[i] = +from[attr][i] + pos * ms * diff[attr][i];
	                                        }
	                                    break;
	                                }
	                                break;
	                            default:
	                              var from2 = [].concat(from[attr]);
	                                now = [];
	                                i = that.paper.customAttributes[attr].length;
	                                while (i--) {
	                                    now[i] = +from2[i] + pos * ms * diff[attr][i];
	                                }
	                                break;
	                        }
	                        set[attr] = now;
	                    }
	                    that.attr(set);
	                    that._run && that._run.call(that);
	                } else {
	                    if (to.along) {
	                        point = getPointAtLength(to.along, to.len * !to.back);
	                        that.translate(diff.sx - (diff.x || 0) + point.x - diff.sx, diff.sy - (diff.y || 0) + point.y - diff.sy);
	                        to.rot && that.rotate(diff.r + point.alpha, point.x, point.y);
	                    }
	                    (t.x || t.y) && that.translate(-t.x, -t.y);
	                    to.scale && (to.scale += E);
	                    that.attr(to);
	                    animationElements.splice(l--, 1);
	                }
	            }
	            R.svg && that && that.paper && that.paper.safari();
	            animationElements[length] && setTimeout(animation);
	        },
	        keyframesRun = function (attr, element, time, prev, prevcallback) {
	            var dif = time - prev;
	            element.timeouts.push(setTimeout(function () {
	                R.is(prevcallback, "function") && prevcallback.call(element);
	                element.animate(attr, dif, attr.easing);
	            }, prev));
	        },
	        upto255 = function (color) {
	            return mmax(mmin(color, 255), 0);
	        },
	        translate = function (x, y) {
	            if (x == null) {
	                return {x: this._.tx, y: this._.ty, toString: x_y};
	            }
	            this._.tx += +x;
	            this._.ty += +y;
	            switch (this.type) {
	                case "circle":
	                case "ellipse":
	                    this.attr({cx: +x + this.attrs.cx, cy: +y + this.attrs.cy});
	                    break;
	                case "rect":
	                case "image":
	                case "text":
	                    this.attr({x: +x + this.attrs.x, y: +y + this.attrs.y});
	                    break;
	                case "path":
	                    var path = pathToRelative(this.attrs.path);
	                    path[0][1] += +x;
	                    path[0][2] += +y;
	                    this.attr({path: path});
	                break;
	            }
	            return this;
	        };
	    elproto.animateWith = function (element, params, ms, easing, callback) {
	        for (var i = 0, ii = animationElements.length; i < ii; i++) {
	            if (animationElements[i].el.id == element.id) {
	                params.start = animationElements[i].start;
	            }
	        }
	        return this.animate(params, ms, easing, callback);
	    };
	    elproto.animateAlong = along();
	    elproto.animateAlongBack = along(1);
	    function along(isBack) {
	        return function (path, ms, rotate, callback) {
	            var params = {back: isBack};
	            R.is(rotate, "function") ? (callback = rotate) : (params.rot = rotate);
	            path && path.constructor == Element && (path = path.attrs.path);
	            path && (params.along = path);
	            return this.animate(params, ms, callback);
	        };
	    }
	    function CubicBezierAtTime(t, p1x, p1y, p2x, p2y, duration) {
	        var cx = 3 * p1x,
	            bx = 3 * (p2x - p1x) - cx,
	            ax = 1 - cx - bx,
	            cy = 3 * p1y,
	            by = 3 * (p2y - p1y) - cy,
	            ay = 1 - cy - by;
	        function sampleCurveX(t) {
	            return ((ax * t + bx) * t + cx) * t;
	        }
	        function solve(x, epsilon) {
	            var t = solveCurveX(x, epsilon);
	            return ((ay * t + by) * t + cy) * t;
	        }
	        function solveCurveX(x, epsilon) {
	            var t0, t1, t2, x2, d2, i;
	            for(t2 = x, i = 0; i < 8; i++) {
	                x2 = sampleCurveX(t2) - x;
	                if (abs(x2) < epsilon) {
	                    return t2;
	                }
	                d2 = (3 * ax * t2 + 2 * bx) * t2 + cx;
	                if (abs(d2) < 1e-6) {
	                    break;
	                }
	                t2 = t2 - x2 / d2;
	            }
	            t0 = 0;
	            t1 = 1;
	            t2 = x;
	            if (t2 < t0) {
	                return t0;
	            }
	            if (t2 > t1) {
	                return t1;
	            }
	            while (t0 < t1) {
	                x2 = sampleCurveX(t2);
	                if (abs(x2 - x) < epsilon) {
	                    return t2;
	                }
	                if (x > x2) {
	                    t0 = t2;
	                } else {
	                    t1 = t2;
	                }
	                t2 = (t1 - t0) / 2 + t0;
	            }
	            return t2;
	        }
	        return solve(t, 1 / (200 * duration));
	    }
	    elproto.onAnimation = function (f) {
	        this._run = f || 0;
	        return this;
	    };
	    elproto.animate = function (params, ms, easing, callback) {
	        var element = this;
	        element.timeouts = element.timeouts || [];
	        if (R.is(easing, "function") || !easing) {
	            callback = easing || null;
	        }
	        if (element.removed) {
	            callback && callback.call(element);
	            return element;
	        }
	        var from = {},
	            to = {},
	            animateable = false,
	            diff = {};
	        for (var attr in params) if (params[has](attr)) {
	            if (availableAnimAttrs[has](attr) || element.paper.customAttributes[has](attr)) {
	                animateable = true;
	                from[attr] = element.attr(attr);
	                (from[attr] == null) && (from[attr] = availableAttrs[attr]);
	                to[attr] = params[attr];
	                switch (availableAnimAttrs[attr]) {
	                    case "along":
	                        var len = getTotalLength(params[attr]);
	                        var point = getPointAtLength(params[attr], len * !!params.back);
	                        var bb = element.getBBox();
	                        diff[attr] = len / ms;
	                        diff.tx = bb.x;
	                        diff.ty = bb.y;
	                        diff.sx = point.x;
	                        diff.sy = point.y;
	                        to.rot = params.rot;
	                        to.back = params.back;
	                        to.len = len;
	                        params.rot && (diff.r = toFloat(element.rotate()) || 0);
	                        break;
	                    case nu:
	                        diff[attr] = (to[attr] - from[attr]) / ms;
	                        break;
	                    case "colour":
	                        from[attr] = R.getRGB(from[attr]);
	                        var toColour = R.getRGB(to[attr]);
	                        diff[attr] = {
	                            r: (toColour.r - from[attr].r) / ms,
	                            g: (toColour.g - from[attr].g) / ms,
	                            b: (toColour.b - from[attr].b) / ms
	                        };
	                        break;
	                    case "path":
	                        var pathes = path2curve(from[attr], to[attr]);
	                        from[attr] = pathes[0];
	                        var toPath = pathes[1];
	                        diff[attr] = [];
	                        for (var i = 0, ii = from[attr][length]; i < ii; i++) {
	                            diff[attr][i] = [0];
	                            for (var j = 1, jj = from[attr][i][length]; j < jj; j++) {
	                                diff[attr][i][j] = (toPath[i][j] - from[attr][i][j]) / ms;
	                            }
	                        }
	                        break;
	                    case "csv":
	                        var values = Str(params[attr])[split](separator),
	                            from2 = Str(from[attr])[split](separator);
	                        switch (attr) {
	                            case "translation":
	                                from[attr] = [0, 0];
	                                diff[attr] = [values[0] / ms, values[1] / ms];
	                            break;
	                            case "rotation":
	                                from[attr] = (from2[1] == values[1] && from2[2] == values[2]) ? from2 : [0, values[1], values[2]];
	                                diff[attr] = [(values[0] - from[attr][0]) / ms, 0, 0];
	                            break;
	                            case "scale":
	                                params[attr] = values;
	                                from[attr] = Str(from[attr])[split](separator);
	                                diff[attr] = [(values[0] - from[attr][0]) / ms, (values[1] - from[attr][1]) / ms, 0, 0];
	                            break;
	                            case "clip-rect":
	                                from[attr] = Str(from[attr])[split](separator);
	                                diff[attr] = [];
	                                i = 4;
	                                while (i--) {
	                                    diff[attr][i] = (values[i] - from[attr][i]) / ms;
	                                }
	                            break;
	                        }
	                        to[attr] = values;
	                        break;
	                    default:
	                        values = [].concat(params[attr]);
	                        from2 = [].concat(from[attr]);
	                        diff[attr] = [];
	                        i = element.paper.customAttributes[attr][length];
	                        while (i--) {
	                            diff[attr][i] = ((values[i] || 0) - (from2[i] || 0)) / ms;
	                        }
	                        break;
	                }
	            }
	        }
	        if (!animateable) {
	            var attrs = [],
	                lastcall;
	            for (var key in params) if (params[has](key) && animKeyFrames.test(key)) {
	                attr = {value: params[key]};
	                key == "from" && (key = 0);
	                key == "to" && (key = 100);
	                attr.key = toInt(key, 10);
	                attrs.push(attr);
	            }
	            attrs.sort(sortByKey);
	            if (attrs[0].key) {
	                attrs.unshift({key: 0, value: element.attrs});
	            }
	            for (i = 0, ii = attrs[length]; i < ii; i++) {
	                keyframesRun(attrs[i].value, element, ms / 100 * attrs[i].key, ms / 100 * (attrs[i - 1] && attrs[i - 1].key || 0), attrs[i - 1] && attrs[i - 1].value.callback);
	            }
	            lastcall = attrs[attrs[length] - 1].value.callback;
	            if (lastcall) {
	                element.timeouts.push(setTimeout(function () {lastcall.call(element);}, ms));
	            }
	        } else {
	            var easyeasy = R.easing_formulas[easing];
	            if (!easyeasy) {
	                easyeasy = Str(easing).match(bezierrg);
	                if (easyeasy && easyeasy[length] == 5) {
	                    var curve = easyeasy;
	                    easyeasy = function (t) {
	                        return CubicBezierAtTime(t, +curve[1], +curve[2], +curve[3], +curve[4], ms);
	                    };
	                } else {
	                    easyeasy = function (t) {
	                        return t;
	                    };
	                }
	            }
	            animationElements.push({
	                start: params.start || +new Date,
	                ms: ms,
	                easing: easyeasy,
	                from: from,
	                diff: diff,
	                to: to,
	                el: element,
	                t: {x: 0, y: 0}
	            });
	            R.is(callback, "function") && (element._ac = setTimeout(function () {
	                callback.call(element);
	            }, ms));
	            animationElements[length] == 1 && setTimeout(animation);
	        }
	        return this;
	    };
	    elproto.stop = function () {
	        for (var i = 0; i < animationElements.length; i++) {
	            animationElements[i].el.id == this.id && animationElements.splice(i--, 1);
	        }
	        for (i = 0, ii = this.timeouts && this.timeouts.length; i < ii; i++) {
	            clearTimeout(this.timeouts[i]);
	        }
	        this.timeouts = [];
	        clearTimeout(this._ac);
	        delete this._ac;
	        return this;
	    };
	    elproto.translate = function (x, y) {
	        return this.attr({translation: x + " " + y});
	    };
	    elproto[toString] = function () {
	        return "Rapha\xebl\u2019s object";
	    };
	    R.ae = animationElements;
	
	    // Set
	    var Set = function (items) {
	        this.items = [];
	        this[length] = 0;
	        this.type = "set";
	        if (items) {
	            for (var i = 0, ii = items[length]; i < ii; i++) {
	                if (items[i] && (items[i].constructor == Element || items[i].constructor == Set)) {
	                    this[this.items[length]] = this.items[this.items[length]] = items[i];
	                    this[length]++;
	                }
	            }
	        }
	    };
	    Set[proto][push] = function () {
	        var item,
	            len;
	        for (var i = 0, ii = arguments[length]; i < ii; i++) {
	            item = arguments[i];
	            if (item && (item.constructor == Element || item.constructor == Set)) {
	                len = this.items[length];
	                this[len] = this.items[len] = item;
	                this[length]++;
	            }
	        }
	        return this;
	    };
	    Set[proto].pop = function () {
	        delete this[this[length]--];
	        return this.items.pop();
	    };
	    for (var method in elproto) if (elproto[has](method)) {
	        Set[proto][method] = (function (methodname) {
	            return function () {
	                for (var i = 0, ii = this.items[length]; i < ii; i++) {
	                    this.items[i][methodname][apply](this.items[i], arguments);
	                }
	                return this;
	            };
	        })(method);
	    }
	    Set[proto].attr = function (name, value) {
	        if (name && R.is(name, array) && R.is(name[0], "object")) {
	            for (var j = 0, jj = name[length]; j < jj; j++) {
	                this.items[j].attr(name[j]);
	            }
	        } else {
	            for (var i = 0, ii = this.items[length]; i < ii; i++) {
	                this.items[i].attr(name, value);
	            }
	        }
	        return this;
	    };
	    Set[proto].animate = function (params, ms, easing, callback) {
	        (R.is(easing, "function") || !easing) && (callback = easing || null);
	        var len = this.items[length],
	            i = len,
	            item,
	            set = this,
	            collector;
	        callback && (collector = function () {
	            !--len && callback.call(set);
	        });
	        easing = R.is(easing, string) ? easing : collector;
	        item = this.items[--i].animate(params, ms, easing, collector);
	        while (i--) {
	            this.items[i] && !this.items[i].removed && this.items[i].animateWith(item, params, ms, easing, collector);
	        }
	        return this;
	    };
	    Set[proto].insertAfter = function (el) {
	        var i = this.items[length];
	        while (i--) {
	            this.items[i].insertAfter(el);
	        }
	        return this;
	    };
	    Set[proto].getBBox = function () {
	        var x = [],
	            y = [],
	            w = [],
	            h = [];
	        for (var i = this.items[length]; i--;) {
	            var box = this.items[i].getBBox();
	            x[push](box.x);
	            y[push](box.y);
	            w[push](box.x + box.width);
	            h[push](box.y + box.height);
	        }
	        x = mmin[apply](0, x);
	        y = mmin[apply](0, y);
	        return {
	            x: x,
	            y: y,
	            width: mmax[apply](0, w) - x,
	            height: mmax[apply](0, h) - y
	        };
	    };
	    Set[proto].clone = function (s) {
	        s = new Set;
	        for (var i = 0, ii = this.items[length]; i < ii; i++) {
	            s[push](this.items[i].clone());
	        }
	        return s;
	    };
	
	    R.registerFont = function (font) {
	        if (!font.face) {
	            return font;
	        }
	        this.fonts = this.fonts || {};
	        var fontcopy = {
	                w: font.w,
	                face: {},
	                glyphs: {}
	            },
	            family = font.face["font-family"];
	        for (var prop in font.face) if (font.face[has](prop)) {
	            fontcopy.face[prop] = font.face[prop];
	        }
	        if (this.fonts[family]) {
	            this.fonts[family][push](fontcopy);
	        } else {
	            this.fonts[family] = [fontcopy];
	        }
	        if (!font.svg) {
	            fontcopy.face["units-per-em"] = toInt(font.face["units-per-em"], 10);
	            for (var glyph in font.glyphs) if (font.glyphs[has](glyph)) {
	                var path = font.glyphs[glyph];
	                fontcopy.glyphs[glyph] = {
	                    w: path.w,
	                    k: {},
	                    d: path.d && "M" + path.d[rp](/[mlcxtrv]/g, function (command) {
	                            return {l: "L", c: "C", x: "z", t: "m", r: "l", v: "c"}[command] || "M";
	                        }) + "z"
	                };
	                if (path.k) {
	                    for (var k in path.k) if (path[has](k)) {
	                        fontcopy.glyphs[glyph].k[k] = path.k[k];
	                    }
	                }
	            }
	        }
	        return font;
	    };
	    paperproto.getFont = function (family, weight, style, stretch) {
	        stretch = stretch || "normal";
	        style = style || "normal";
	        weight = +weight || {normal: 400, bold: 700, lighter: 300, bolder: 800}[weight] || 400;
	        if (!R.fonts) {
	            return;
	        }
	        var font = R.fonts[family];
	        if (!font) {
	            var name = new RegExp("(^|\\s)" + family[rp](/[^\w\d\s+!~.:_-]/g, E) + "(\\s|$)", "i");
	            for (var fontName in R.fonts) if (R.fonts[has](fontName)) {
	                if (name.test(fontName)) {
	                    font = R.fonts[fontName];
	                    break;
	                }
	            }
	        }
	        var thefont;
	        if (font) {
	            for (var i = 0, ii = font[length]; i < ii; i++) {
	                thefont = font[i];
	                if (thefont.face["font-weight"] == weight && (thefont.face["font-style"] == style || !thefont.face["font-style"]) && thefont.face["font-stretch"] == stretch) {
	                    break;
	                }
	            }
	        }
	        return thefont;
	    };
	    paperproto.print = function (x, y, string, font, size, origin, letter_spacing) {
	        origin = origin || "middle"; // baseline|middle
	        letter_spacing = mmax(mmin(letter_spacing || 0, 1), -1);
	        var out = this.set(),
	            letters = Str(string)[split](E),
	            shift = 0,
	            path = E,
	            scale;
	        R.is(font, string) && (font = this.getFont(font));
	        if (font) {
	            scale = (size || 16) / font.face["units-per-em"];
	            var bb = font.face.bbox.split(separator),
	                top = +bb[0],
	                height = +bb[1] + (origin == "baseline" ? bb[3] - bb[1] + (+font.face.descent) : (bb[3] - bb[1]) / 2);
	            for (var i = 0, ii = letters[length]; i < ii; i++) {
	                var prev = i && font.glyphs[letters[i - 1]] || {},
	                    curr = font.glyphs[letters[i]];
	                shift += i ? (prev.w || font.w) + (prev.k && prev.k[letters[i]] || 0) + (font.w * letter_spacing) : 0;
	                curr && curr.d && out[push](this.path(curr.d).attr({fill: "#000", stroke: "none", translation: [shift, 0]}));
	            }
	            out.scale(scale, scale, top, height).translate(x - top, y - height);
	        }
	        return out;
	    };
	
	    R.format = function (token, params) {
	        var args = R.is(params, array) ? [0][concat](params) : arguments;
	        token && R.is(token, string) && args[length] - 1 && (token = token[rp](formatrg, function (str, i) {
	            return args[++i] == null ? E : args[i];
	        }));
	        return token || E;
	    };
	    R.ninja = function () {
	        oldRaphael.was ? (win.Raphael = oldRaphael.is) : delete win.Raphael;
	        return R;
	    };
	    R.el = elproto;
	    R.st = Set[proto];
	
	    oldRaphael.was ? (win.Raphael = R) : (Raphael = R);
	})();


/***/ },
/* 357 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * This file exports components View and Text which wrap <div> and <span>.
	 * We do this so that someday in the future we can use these components with
	 * React Native.
	 *
	 * Inspired by https://github.com/necolas/react-native-web. We use aphrodite
	 * StyleSheets instead.
	 */
	
	module.exports = {
	  Text: __webpack_require__(415),
	  View: __webpack_require__(416)
	};

/***/ },
/* 358 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * Renders a circular selection ring around the child.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(79),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var styleConstants = __webpack_require__(77);
	
	var FocusRing = function (_React$Component) {
	    _inherits(FocusRing, _React$Component);
	
	    function FocusRing() {
	        _classCallCheck(this, FocusRing);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    FocusRing.prototype.render = function render() {
	        var borderColor = this.props.visible ? this.props.color : "transparent";
	        var style = {
	            borderColor: borderColor
	        };
	        return React.createElement(
	            "span",
	            { className: css(styles.ring), style: style },
	            this.props.children
	        );
	    };
	
	    return FocusRing;
	}(React.Component);
	
	FocusRing.defaultProps = {
	    visible: true,
	    color: styleConstants.kaGreen
	};
	FocusRing.propTypes = {
	    children: __webpack_require__(43).PropTypes.any,
	    visible: __webpack_require__(43).PropTypes.bool.isRequired,
	    color: __webpack_require__(43).PropTypes.string.isRequired
	};
	
	
	var styles = StyleSheet.create({
	    ring: {
	        margin: "auto",
	        display: "inline-block",
	        borderRadius: "50%",
	        borderWidth: 2,
	        padding: 2,
	        borderStyle: "solid"
	    }
	});
	
	module.exports = FocusRing;

/***/ },
/* 359 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = { "Webkit": { "transform": true, "transformOrigin": true, "transformOriginX": true, "transformOriginY": true, "backfaceVisibility": true, "perspective": true, "perspectiveOrigin": true, "transformStyle": true, "transformOriginZ": true, "animation": true, "animationDelay": true, "animationDirection": true, "animationFillMode": true, "animationDuration": true, "animationIterationCount": true, "animationName": true, "animationPlayState": true, "animationTimingFunction": true, "appearance": true, "userSelect": true, "fontKerning": true, "textEmphasisPosition": true, "textEmphasis": true, "textEmphasisStyle": true, "textEmphasisColor": true, "boxDecorationBreak": true, "clipPath": true, "maskImage": true, "maskMode": true, "maskRepeat": true, "maskPosition": true, "maskClip": true, "maskOrigin": true, "maskSize": true, "maskComposite": true, "mask": true, "maskBorderSource": true, "maskBorderMode": true, "maskBorderSlice": true, "maskBorderWidth": true, "maskBorderOutset": true, "maskBorderRepeat": true, "maskBorder": true, "maskType": true, "textDecorationStyle": true, "textDecorationSkip": true, "textDecorationLine": true, "textDecorationColor": true, "filter": true, "fontFeatureSettings": true, "breakAfter": true, "breakBefore": true, "breakInside": true, "columnCount": true, "columnFill": true, "columnGap": true, "columnRule": true, "columnRuleColor": true, "columnRuleStyle": true, "columnRuleWidth": true, "columns": true, "columnSpan": true, "columnWidth": true, "flex": true, "flexBasis": true, "flexDirection": true, "flexGrow": true, "flexFlow": true, "flexShrink": true, "flexWrap": true, "alignContent": true, "alignItems": true, "alignSelf": true, "justifyContent": true, "order": true, "transition": true, "transitionDelay": true, "transitionDuration": true, "transitionProperty": true, "transitionTimingFunction": true, "backdropFilter": true, "scrollSnapType": true, "scrollSnapPointsX": true, "scrollSnapPointsY": true, "scrollSnapDestination": true, "scrollSnapCoordinate": true, "shapeImageThreshold": true, "shapeImageMargin": true, "shapeImageOutside": true, "hyphens": true, "flowInto": true, "flowFrom": true, "regionFragment": true, "textSizeAdjust": true, "borderImage": true, "borderImageOutset": true, "borderImageRepeat": true, "borderImageSlice": true, "borderImageSource": true, "borderImageWidth": true, "tabSize": true, "objectFit": true, "objectPosition": true }, "Moz": { "appearance": true, "userSelect": true, "boxSizing": true, "textAlignLast": true, "textDecorationStyle": true, "textDecorationSkip": true, "textDecorationLine": true, "textDecorationColor": true, "tabSize": true, "hyphens": true, "fontFeatureSettings": true, "breakAfter": true, "breakBefore": true, "breakInside": true, "columnCount": true, "columnFill": true, "columnGap": true, "columnRule": true, "columnRuleColor": true, "columnRuleStyle": true, "columnRuleWidth": true, "columns": true, "columnSpan": true, "columnWidth": true }, "ms": { "flex": true, "flexBasis": false, "flexDirection": true, "flexGrow": false, "flexFlow": true, "flexShrink": false, "flexWrap": true, "alignContent": false, "alignItems": false, "alignSelf": false, "justifyContent": false, "order": false, "transform": true, "transformOrigin": true, "transformOriginX": true, "transformOriginY": true, "userSelect": true, "wrapFlow": true, "wrapThrough": true, "wrapMargin": true, "scrollSnapType": true, "scrollSnapPointsX": true, "scrollSnapPointsY": true, "scrollSnapDestination": true, "scrollSnapCoordinate": true, "touchAction": true, "hyphens": true, "flowInto": true, "flowFrom": true, "breakBefore": true, "breakAfter": true, "breakInside": true, "regionFragment": true, "gridTemplateColumns": true, "gridTemplateRows": true, "gridTemplateAreas": true, "gridTemplate": true, "gridAutoColumns": true, "gridAutoRows": true, "gridAutoFlow": true, "grid": true, "gridRowStart": true, "gridColumnStart": true, "gridRowEnd": true, "gridRow": true, "gridColumn": true, "gridColumnEnd": true, "gridColumnGap": true, "gridRowGap": true, "gridArea": true, "gridGap": true, "textSizeAdjust": true } };
	module.exports = exports["default"];

/***/ },
/* 360 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A keypad that includes the digits, as well as the symbols required to deal
	 * with fractions, decimals, and percents.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(397),
	    connect = _require.connect;
	
	var _require2 = __webpack_require__(357),
	    View = _require2.View;
	
	var Keypad = __webpack_require__(417);
	var TouchableKeypadButton = __webpack_require__(418);
	
	var _require3 = __webpack_require__(364),
	    row = _require3.row,
	    roundedTopLeft = _require3.roundedTopLeft,
	    roundedTopRight = _require3.roundedTopRight;
	
	var _require4 = __webpack_require__(283),
	    BorderStyles = _require4.BorderStyles;
	
	var CursorContexts = __webpack_require__(310);
	
	var _require5 = __webpack_require__(295),
	    cursorContextPropType = _require5.cursorContextPropType;
	
	var KeyConfigs = __webpack_require__(315);
	
	var FractionKeypad = function (_React$Component) {
	    _inherits(FractionKeypad, _React$Component);
	
	    function FractionKeypad() {
	        _classCallCheck(this, FractionKeypad);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    // Since we include a two-key popover in the top-right, when the popover
	    // is visible, the keypad will expand to fill the equivalent of five
	    // rows vertically.
	    FractionKeypad.prototype.render = function render() {
	        var _props = this.props,
	            cursorContext = _props.cursorContext,
	            dynamicJumpOut = _props.dynamicJumpOut,
	            roundTopLeft = _props.roundTopLeft,
	            roundTopRight = _props.roundTopRight;
	
	
	        var dismissOrJumpOutKey = void 0;
	        if (dynamicJumpOut) {
	            switch (cursorContext) {
	                case CursorContexts.IN_PARENS:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_OUT_PARENTHESES;
	                    break;
	
	                case CursorContexts.IN_SUPER_SCRIPT:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_OUT_EXPONENT;
	                    break;
	
	                case CursorContexts.IN_SUB_SCRIPT:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_OUT_BASE;
	                    break;
	
	                case CursorContexts.BEFORE_FRACTION:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_INTO_NUMERATOR;
	                    break;
	
	                case CursorContexts.IN_NUMERATOR:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_OUT_NUMERATOR;
	                    break;
	
	                case CursorContexts.IN_DENOMINATOR:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_OUT_DENOMINATOR;
	                    break;
	
	                case CursorContexts.NONE:
	                default:
	                    dismissOrJumpOutKey = KeyConfigs.DISMISS;
	                    break;
	            }
	        } else {
	            dismissOrJumpOutKey = KeyConfigs.DISMISS;
	        }
	
	        return React.createElement(
	            Keypad,
	            null,
	            React.createElement(
	                View,
	                { style: row },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_7,
	                    borders: BorderStyles.NONE,
	                    style: roundTopLeft && roundedTopLeft
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_8,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_9,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.FRAC_MULTI,
	                    disabled:
	                    // NOTE(charlie): It's only sufficient to use
	                    // `IN_NUMERATOR` and `IN_DENOMINATOR` here because we
	                    // don't support parentheses in this keypad. If we did,
	                    // then when the cursor was inside a parenthetical
	                    // expression in a numerator or denominator, this check
	                    // would fail.
	                    cursorContext === CursorContexts.IN_NUMERATOR || cursorContext === CursorContexts.IN_DENOMINATOR,
	                    style: roundTopRight && roundedTopRight
	                })
	            ),
	            React.createElement(
	                View,
	                { style: row },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_4,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_5,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_6,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, { keyConfig: KeyConfigs.PERCENT })
	            ),
	            React.createElement(
	                View,
	                { style: row },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_1,
	                    borders: BorderStyles.BOTTOM
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_2,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_3,
	                    borders: BorderStyles.BOTTOM
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.BACKSPACE,
	                    borders: BorderStyles.LEFT
	                })
	            ),
	            React.createElement(
	                View,
	                { style: row },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NEGATIVE,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_0,
	                    borders: BorderStyles.LEFT
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.DECIMAL,
	                    borders: BorderStyles.LEFT
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: dismissOrJumpOutKey,
	                    borders: BorderStyles.LEFT
	                })
	            )
	        );
	    };
	
	    return FractionKeypad;
	}(React.Component);
	
	FractionKeypad.propTypes = {
	    cursorContext: cursorContextPropType.isRequired,
	    dynamicJumpOut: React.PropTypes.bool,
	    roundTopLeft: React.PropTypes.bool,
	    roundTopRight: React.PropTypes.bool
	};
	FractionKeypad.rows = 4;
	FractionKeypad.columns = 4;
	FractionKeypad.maxVisibleRows = 5;
	FractionKeypad.numPages = 1;
	
	
	var mapStateToProps = function mapStateToProps(state) {
	    return {
	        cursorContext: state.input.cursor.context,
	        dynamicJumpOut: !state.layout.navigationPadEnabled
	    };
	};
	
	module.exports = connect(mapStateToProps)(FractionKeypad);

/***/ },
/* 361 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A keypad that includes all of the expression symbols.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(397),
	    connect = _require.connect;
	
	var _require2 = __webpack_require__(414),
	    StyleSheet = _require2.StyleSheet;
	
	var _require3 = __webpack_require__(357),
	    View = _require3.View;
	
	var TwoPageKeypad = __webpack_require__(427);
	var ManyKeypadButton = __webpack_require__(428);
	var TouchableKeypadButton = __webpack_require__(418);
	
	var _require4 = __webpack_require__(364),
	    row = _require4.row,
	    column = _require4.column,
	    oneColumn = _require4.oneColumn,
	    fullWidth = _require4.fullWidth,
	    roundedTopLeft = _require4.roundedTopLeft,
	    roundedTopRight = _require4.roundedTopRight;
	
	var _require5 = __webpack_require__(283),
	    BorderStyles = _require5.BorderStyles;
	
	var _require6 = __webpack_require__(355),
	    valueGrey = _require6.valueGrey,
	    controlGrey = _require6.controlGrey;
	
	var _require7 = __webpack_require__(295),
	    cursorContextPropType = _require7.cursorContextPropType,
	    keyIdPropType = _require7.keyIdPropType;
	
	var KeyConfigs = __webpack_require__(315);
	var CursorContexts = __webpack_require__(310);
	
	var ExpressionKeypad = function (_React$Component) {
	    _inherits(ExpressionKeypad, _React$Component);
	
	    function ExpressionKeypad() {
	        _classCallCheck(this, ExpressionKeypad);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    // Though we include an infinite-key popover in the bottom-left, it's
	    // assumed that we don't need to accommodate cases in which that key
	    // contains more than four children.
	    ExpressionKeypad.prototype.render = function render() {
	        var _props = this.props,
	            currentPage = _props.currentPage,
	            cursorContext = _props.cursorContext,
	            dynamicJumpOut = _props.dynamicJumpOut,
	            extraKeys = _props.extraKeys,
	            roundTopLeft = _props.roundTopLeft,
	            roundTopRight = _props.roundTopRight;
	
	
	        var dismissOrJumpOutKey = void 0;
	        if (dynamicJumpOut) {
	            switch (cursorContext) {
	                case CursorContexts.IN_PARENS:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_OUT_PARENTHESES;
	                    break;
	
	                case CursorContexts.IN_SUPER_SCRIPT:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_OUT_EXPONENT;
	                    break;
	
	                case CursorContexts.IN_SUB_SCRIPT:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_OUT_BASE;
	                    break;
	
	                case CursorContexts.BEFORE_FRACTION:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_INTO_NUMERATOR;
	                    break;
	
	                case CursorContexts.IN_NUMERATOR:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_OUT_NUMERATOR;
	                    break;
	
	                case CursorContexts.IN_DENOMINATOR:
	                    dismissOrJumpOutKey = KeyConfigs.JUMP_OUT_DENOMINATOR;
	                    break;
	
	                case CursorContexts.NONE:
	                default:
	                    dismissOrJumpOutKey = KeyConfigs.DISMISS;
	                    break;
	            }
	        } else {
	            dismissOrJumpOutKey = KeyConfigs.DISMISS;
	        }
	
	        var rightPageStyle = [row, fullWidth, styles.rightPage, roundTopRight && roundedTopRight];
	        var rightPage = React.createElement(
	            View,
	            { style: rightPageStyle },
	            React.createElement(
	                View,
	                { style: [column, oneColumn] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_7,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_4,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_1,
	                    borders: BorderStyles.BOTTOM
	                }),
	                React.createElement(ManyKeypadButton, {
	                    keys: extraKeys,
	                    borders: BorderStyles.NONE
	                })
	            ),
	            React.createElement(
	                View,
	                { style: [column, oneColumn] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_8,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_5,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_2,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_0,
	                    borders: BorderStyles.LEFT
	                })
	            ),
	            React.createElement(
	                View,
	                { style: [column, oneColumn] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_9,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_6,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NUM_3,
	                    borders: BorderStyles.BOTTOM
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.DECIMAL,
	                    borders: BorderStyles.LEFT
	                })
	            ),
	            React.createElement(
	                View,
	                { style: [column, oneColumn] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.DIVIDE,
	                    borders: BorderStyles.LEFT
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.TIMES,
	                    borders: BorderStyles.LEFT
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.MINUS,
	                    borders: BorderStyles.LEFT
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.PLUS,
	                    borders: BorderStyles.LEFT
	                })
	            ),
	            React.createElement(
	                View,
	                { style: [column, oneColumn] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.FRAC_INCLUSIVE,
	                    style: roundTopRight && roundedTopRight
	                }),
	                React.createElement(TouchableKeypadButton, { keyConfig: KeyConfigs.CDOT }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.BACKSPACE,
	                    borders: BorderStyles.LEFT
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: dismissOrJumpOutKey,
	                    borders: BorderStyles.LEFT
	                })
	            )
	        );
	
	        var leftPageStyle = [row, fullWidth, styles.leftPage, roundTopLeft && roundedTopLeft];
	        var leftPage = React.createElement(
	            View,
	            { style: leftPageStyle },
	            React.createElement(
	                View,
	                { style: [column, oneColumn] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.EXP_2,
	                    borders: BorderStyles.NONE,
	                    style: roundTopLeft && roundedTopLeft
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.SQRT,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.LOG,
	                    borders: BorderStyles.BOTTOM
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.SIN,
	                    borders: BorderStyles.NONE
	                })
	            ),
	            React.createElement(
	                View,
	                { style: [column, oneColumn] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.EXP_3,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.CUBE_ROOT,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.LN,
	                    borders: BorderStyles.BOTTOM
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.COS,
	                    borders: BorderStyles.NONE
	                })
	            ),
	            React.createElement(
	                View,
	                { style: [column, oneColumn] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.EXP,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.RADICAL,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.LOG_N,
	                    borders: BorderStyles.BOTTOM
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.TAN,
	                    borders: BorderStyles.NONE
	                })
	            ),
	            React.createElement(
	                View,
	                { style: [column, oneColumn] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.GEQ,
	                    borders: BorderStyles.LEFT
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.EQUAL,
	                    borders: BorderStyles.LEFT
	                }),
	                React.createElement(TouchableKeypadButton, { keyConfig: KeyConfigs.LEQ }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.LEFT_PAREN,
	                    borders: BorderStyles.LEFT
	                })
	            ),
	            React.createElement(
	                View,
	                { style: [column, oneColumn] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.GT,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.NEQ,
	                    borders: BorderStyles.NONE
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.LT,
	                    borders: BorderStyles.BOTTOM
	                }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.RIGHT_PAREN,
	                    borders: BorderStyles.NONE
	                })
	            )
	        );
	
	        return React.createElement(TwoPageKeypad, {
	            currentPage: currentPage,
	            rightPage: rightPage,
	            leftPage: leftPage
	        });
	    };
	
	    return ExpressionKeypad;
	}(React.Component);
	
	ExpressionKeypad.propTypes = {
	    currentPage: React.PropTypes.number.isRequired,
	    cursorContext: cursorContextPropType.isRequired,
	    dynamicJumpOut: React.PropTypes.bool,
	    extraKeys: React.PropTypes.arrayOf(keyIdPropType),
	    roundTopLeft: React.PropTypes.bool,
	    roundTopRight: React.PropTypes.bool
	};
	ExpressionKeypad.rows = 4;
	ExpressionKeypad.columns = 5;
	ExpressionKeypad.maxVisibleRows = 4;
	ExpressionKeypad.numPages = 2;
	
	
	var styles = StyleSheet.create({
	    // NOTE(charlie): These backgrounds are applied to as to fill in some
	    // unfortunate 'cracks' in the layout. However, not all keys in the first
	    // page use this background color (namely, the 'command' keys, backspace and
	    // dismiss).
	    // TODO(charlie): Apply the proper background between the 'command' keys.
	    rightPage: {
	        backgroundColor: valueGrey
	    },
	
	    leftPage: {
	        backgroundColor: controlGrey
	    }
	});
	
	var mapStateToProps = function mapStateToProps(state) {
	    return {
	        currentPage: state.pager.currentPage,
	        cursorContext: state.input.cursor.context,
	        dynamicJumpOut: !state.layout.navigationPadEnabled
	    };
	};
	
	module.exports = connect(mapStateToProps)(ExpressionKeypad);

/***/ },
/* 362 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A component that renders a navigation pad, which consists of an arrow for
	 * each possible direction.
	 */
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet;
	
	var _require2 = __webpack_require__(357),
	    View = _require2.View;
	
	var TouchableKeypadButton = __webpack_require__(418);
	
	var _require3 = __webpack_require__(364),
	    row = _require3.row,
	    column = _require3.column,
	    centered = _require3.centered,
	    stretch = _require3.stretch,
	    roundedTopLeft = _require3.roundedTopLeft;
	
	var _require4 = __webpack_require__(355),
	    navigationPadWidthPx = _require4.navigationPadWidthPx,
	    controlGrey = _require4.controlGrey,
	    valueGrey = _require4.valueGrey,
	    gray85 = _require4.gray85;
	
	var _require5 = __webpack_require__(283),
	    BorderStyles = _require5.BorderStyles;
	
	var KeyConfigs = __webpack_require__(315);
	
	var NavigationPad = function (_React$Component) {
	    _inherits(NavigationPad, _React$Component);
	
	    function NavigationPad() {
	        _classCallCheck(this, NavigationPad);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    NavigationPad.prototype.render = function render() {
	        // TODO(charlie): Disable the navigational arrows depending on the
	        // cursor context.
	        var _props = this.props,
	            roundTopLeft = _props.roundTopLeft,
	            style = _props.style;
	
	
	        var containerStyle = [column, centered, styles.container, roundTopLeft && roundedTopLeft].concat(Array.isArray(style) ? style : [style]);
	
	        return React.createElement(
	            View,
	            { style: containerStyle },
	            React.createElement(
	                View,
	                { style: [row, centered] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.UP,
	                    borders: BorderStyles.NONE,
	                    style: [styles.navigationKey, styles.topArrow]
	                })
	            ),
	            React.createElement(
	                View,
	                { style: [row, centered, stretch] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.LEFT,
	                    borders: BorderStyles.NONE,
	                    style: [styles.navigationKey, styles.leftArrow]
	                }),
	                React.createElement(View, { style: styles.horizontalSpacer }),
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.RIGHT,
	                    borders: BorderStyles.NONE,
	                    style: [styles.navigationKey, styles.rightArrow]
	                })
	            ),
	            React.createElement(
	                View,
	                { style: [row, centered] },
	                React.createElement(TouchableKeypadButton, {
	                    keyConfig: KeyConfigs.DOWN,
	                    borders: BorderStyles.NONE,
	                    style: [styles.navigationKey, styles.bottomArrow]
	                })
	            )
	        );
	    };
	
	    return NavigationPad;
	}(React.Component);
	
	NavigationPad.propTypes = {
	    roundTopLeft: React.PropTypes.bool,
	    style: React.PropTypes.any
	};
	
	
	var buttonSizePx = 48;
	var borderRadiusPx = 4;
	var borderWidthPx = 1;
	
	var styles = StyleSheet.create({
	    container: {
	        backgroundColor: controlGrey,
	        width: navigationPadWidthPx
	    },
	
	    navigationKey: {
	        borderColor: gray85,
	        backgroundColor: valueGrey,
	        width: buttonSizePx,
	        height: buttonSizePx,
	
	        // Override the default box-sizing so that our buttons are
	        // `buttonSizePx` exclusive of their borders.
	        boxSizing: 'content-box'
	    },
	
	    topArrow: {
	        borderTopWidth: borderWidthPx,
	        borderLeftWidth: borderWidthPx,
	        borderRightWidth: borderWidthPx,
	        borderTopLeftRadius: borderRadiusPx,
	        borderTopRightRadius: borderRadiusPx
	    },
	
	    rightArrow: {
	        borderTopWidth: borderWidthPx,
	        borderRightWidth: borderWidthPx,
	        borderBottomWidth: borderWidthPx,
	        borderTopRightRadius: borderRadiusPx,
	        borderBottomRightRadius: borderRadiusPx
	    },
	
	    bottomArrow: {
	        borderBottomWidth: borderWidthPx,
	        borderLeftWidth: borderWidthPx,
	        borderRightWidth: borderWidthPx,
	        borderBottomLeftRadius: borderRadiusPx,
	        borderBottomRightRadius: borderRadiusPx
	    },
	
	    leftArrow: {
	        borderTopWidth: borderWidthPx,
	        borderBottomWidth: borderWidthPx,
	        borderLeftWidth: borderWidthPx,
	        borderTopLeftRadius: borderRadiusPx,
	        borderBottomLeftRadius: borderRadiusPx
	    },
	
	    horizontalSpacer: {
	        background: valueGrey,
	        // No need to set a height -- the spacer will be stretched by its
	        // parent.
	        width: buttonSizePx
	    }
	});
	
	module.exports = NavigationPad;

/***/ },
/* 363 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * This file contains all of the z-index values used throughout the math-input
	 * component and its children.
	 */
	
	module.exports = {
	  popover: 1,
	  echo: 2,
	  keypad: 1060
	};

/***/ },
/* 364 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Common styles shared across components.
	 */
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet;
	
	var _require2 = __webpack_require__(355),
	    compactKeypadBorderRadiusPx = _require2.compactKeypadBorderRadiusPx;
	
	module.exports = StyleSheet.create({
	    row: {
	        flexDirection: 'row'
	    },
	    column: {
	        flexDirection: 'column'
	    },
	    oneColumn: {
	        flexGrow: 1
	    },
	    fullWidth: {
	        width: '100%'
	    },
	    stretch: {
	        alignItems: 'stretch'
	    },
	    centered: {
	        justifyContent: 'center',
	        alignItems: 'center'
	    },
	    centeredText: {
	        textAlign: 'center'
	    },
	    roundedTopLeft: {
	        borderTopLeftRadius: compactKeypadBorderRadiusPx
	    },
	    roundedTopRight: {
	        borderTopRightRadius: compactKeypadBorderRadiusPx
	    }
	});

/***/ },
/* 365 */
/***/ function(module, exports, __webpack_require__) {

	// helper to capitalize strings
	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports["default"] = function (str) {
	  return str.charAt(0).toUpperCase() + str.slice(1);
	};
	
	module.exports = exports["default"];

/***/ },
/* 366 */
/***/ function(module, exports, __webpack_require__) {

	// leight polyfill for Object.assign
	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports["default"] = function (base) {
	  var extend = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
	  return Object.keys(extend).reduce(function (out, key) {
	    base[key] = extend[key];
	    return out;
	  }, {});
	};
	
	module.exports = exports["default"];

/***/ },
/* 367 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = calc;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _utilsJoinPrefixedRules = __webpack_require__(419);
	
	var _utilsJoinPrefixedRules2 = _interopRequireDefault(_utilsJoinPrefixedRules);
	
	var _utilsIsPrefixedValue = __webpack_require__(420);
	
	var _utilsIsPrefixedValue2 = _interopRequireDefault(_utilsIsPrefixedValue);
	
	function calc(property, value) {
	  if (typeof value === 'string' && value.indexOf('calc(') > -1) {
	    if ((0, _utilsIsPrefixedValue2['default'])(value)) return;
	
	    return (0, _utilsJoinPrefixedRules2['default'])(property, value, function (prefix, value) {
	      return value.replace(/calc\(/g, prefix + 'calc(');
	    });
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 368 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = cursor;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _utilsJoinPrefixedRules = __webpack_require__(419);
	
	var _utilsJoinPrefixedRules2 = _interopRequireDefault(_utilsJoinPrefixedRules);
	
	var values = {
	  'zoom-in': true,
	  'zoom-out': true,
	  'grab': true,
	  'grabbing': true
	};
	
	function cursor(property, value) {
	  if (property === 'cursor' && values[value]) {
	    return (0, _utilsJoinPrefixedRules2['default'])(property, value);
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 369 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = flex;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _utilsCamelToDashCase = __webpack_require__(421);
	
	var _utilsCamelToDashCase2 = _interopRequireDefault(_utilsCamelToDashCase);
	
	var values = { flex: true, 'inline-flex': true };
	
	function flex(property, value) {
	  if (property === 'display' && values[value]) {
	    return {
	      display: ['-webkit-box', '-moz-box', '-ms-' + value + 'box', '-webkit-' + value, value]
	    };
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 370 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = sizing;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _utilsJoinPrefixedRules = __webpack_require__(419);
	
	var _utilsJoinPrefixedRules2 = _interopRequireDefault(_utilsJoinPrefixedRules);
	
	var properties = {
	  maxHeight: true,
	  maxWidth: true,
	  width: true,
	  height: true,
	  columnWidth: true,
	  minWidth: true,
	  minHeight: true
	};
	var values = {
	  'min-content': true,
	  'max-content': true,
	  'fill-available': true,
	  'fit-content': true,
	  'contain-floats': true
	};
	
	function sizing(property, value) {
	  if (properties[property] && values[value]) {
	    return (0, _utilsJoinPrefixedRules2['default'])(property, value);
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 371 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = gradient;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	var _utilsJoinPrefixedRules = __webpack_require__(419);
	
	var _utilsJoinPrefixedRules2 = _interopRequireDefault(_utilsJoinPrefixedRules);
	
	var _utilsIsPrefixedValue = __webpack_require__(420);
	
	var _utilsIsPrefixedValue2 = _interopRequireDefault(_utilsIsPrefixedValue);
	
	var values = /linear-gradient|radial-gradient|repeating-linear-gradient|repeating-radial-gradient/;
	
	function gradient(property, value) {
	  if (typeof value === 'string' && value.match(values) !== null) {
	    if ((0, _utilsIsPrefixedValue2['default'])(value)) return;
	
	    return (0, _utilsJoinPrefixedRules2['default'])(property, value);
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 372 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = transition;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
	
	var _utilsCamelToDashCase = __webpack_require__(421);
	
	var _utilsCamelToDashCase2 = _interopRequireDefault(_utilsCamelToDashCase);
	
	var _utilsCapitalizeString = __webpack_require__(365);
	
	var _utilsCapitalizeString2 = _interopRequireDefault(_utilsCapitalizeString);
	
	var _utilsIsPrefixedValue = __webpack_require__(420);
	
	var _utilsIsPrefixedValue2 = _interopRequireDefault(_utilsIsPrefixedValue);
	
	var _prefixProps = __webpack_require__(359);
	
	var _prefixProps2 = _interopRequireDefault(_prefixProps);
	
	var properties = {
	  transition: true,
	  transitionProperty: true,
	  WebkitTransition: true,
	  WebkitTransitionProperty: true
	};
	
	function transition(property, value) {
	  // also check for already prefixed transitions
	  if (typeof value === 'string' && properties[property]) {
	    var _ref2;
	
	    var outputValue = prefixValue(value);
	    var webkitOutput = outputValue.split(',').filter(function (value) {
	      return value.match(/-moz-|-ms-/) === null;
	    }).join(',');
	
	    // if the property is already prefixed
	    if (property.indexOf('Webkit') > -1) {
	      return _defineProperty({}, property, webkitOutput);
	    }
	
	    return _ref2 = {}, _defineProperty(_ref2, 'Webkit' + (0, _utilsCapitalizeString2['default'])(property), webkitOutput), _defineProperty(_ref2, property, outputValue), _ref2;
	  }
	}
	
	function prefixValue(value) {
	  if ((0, _utilsIsPrefixedValue2['default'])(value)) {
	    return value;
	  }
	
	  // only split multi values, not cubic beziers
	  var multipleValues = value.split(/,(?![^()]*(?:\([^()]*\))?\))/g);
	
	  // iterate each single value and check for transitioned properties
	  // that need to be prefixed as well
	  multipleValues.forEach(function (val, index) {
	    multipleValues[index] = Object.keys(_prefixProps2['default']).reduce(function (out, prefix) {
	      var dashCasePrefix = '-' + prefix.toLowerCase() + '-';
	
	      Object.keys(_prefixProps2['default'][prefix]).forEach(function (prop) {
	        var dashCaseProperty = (0, _utilsCamelToDashCase2['default'])(prop);
	
	        if (val.indexOf(dashCaseProperty) > -1) {
	          // join all prefixes and create a new value
	          out = val.replace(dashCaseProperty, dashCasePrefix + dashCaseProperty) + ',' + out;
	        }
	      });
	      return out;
	    }, val);
	  });
	
	  return multipleValues.join(',');
	}
	module.exports = exports['default'];

/***/ },
/* 373 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = flexboxIE;
	
	function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
	
	var alternativeValues = {
	  'space-around': 'distribute',
	  'space-between': 'justify',
	  'flex-start': 'start',
	  'flex-end': 'end'
	};
	var alternativeProps = {
	  alignContent: 'msFlexLinePack',
	  alignSelf: 'msFlexItemAlign',
	  alignItems: 'msFlexAlign',
	  justifyContent: 'msFlexPack',
	  order: 'msFlexOrder',
	  flexGrow: 'msFlexPositive',
	  flexShrink: 'msFlexNegative',
	  flexBasis: 'msPreferredSize'
	};
	
	function flexboxIE(property, value) {
	  if (alternativeProps[property]) {
	    return _defineProperty({}, alternativeProps[property], alternativeValues[value] || value);
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 374 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = flexboxOld;
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
	
	var _utilsCamelToDashCase = __webpack_require__(421);
	
	var _utilsCamelToDashCase2 = _interopRequireDefault(_utilsCamelToDashCase);
	
	var alternativeValues = {
	  'space-around': 'justify',
	  'space-between': 'justify',
	  'flex-start': 'start',
	  'flex-end': 'end',
	  'wrap-reverse': 'multiple',
	  wrap: 'multiple'
	};
	
	var alternativeProps = {
	  alignItems: 'WebkitBoxAlign',
	  justifyContent: 'WebkitBoxPack',
	  flexWrap: 'WebkitBoxLines'
	};
	
	function flexboxOld(property, value) {
	  if (property === 'flexDirection') {
	    return {
	      WebkitBoxOrient: value.indexOf('column') > -1 ? 'vertical' : 'horizontal',
	      WebkitBoxDirection: value.indexOf('reverse') > -1 ? 'reverse' : 'normal'
	    };
	  }
	  if (alternativeProps[property]) {
	    return _defineProperty({}, alternativeProps[property], alternativeValues[value] || value);
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 375 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule sanitizeDraftText
	 * 
	 */
	
	'use strict';
	
	var REGEX_BLOCK_DELIMITER = new RegExp('\r', 'g');
	
	function sanitizeDraftText(input) {
	  return input.replace(REGEX_BLOCK_DELIMITER, '');
	}
	
	module.exports = sanitizeDraftText;

/***/ },
/* 376 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule findRangesImmutable
	 * 
	 */
	
	/**
	 * Search through an array to find contiguous stretches of elements that
	 * match a specified filter function.
	 *
	 * When ranges are found, execute a specified `found` function to supply
	 * the values to the caller.
	 */
	'use strict';
	
	function findRangesImmutable(haystack, areEqualFn, filterFn, foundFn) {
	  if (!haystack.size) {
	    return;
	  }
	
	  var cursor = 0;
	
	  haystack.reduce(function (value, nextValue, nextIndex) {
	    if (!areEqualFn(value, nextValue)) {
	      if (filterFn(value)) {
	        foundFn(cursor, nextIndex);
	      }
	      cursor = nextIndex;
	    }
	    return nextValue;
	  });
	
	  filterFn(haystack.last()) && foundFn(cursor, haystack.count());
	}
	
	module.exports = findRangesImmutable;

/***/ },
/* 377 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule ContentStateInlineStyle
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var CharacterMetadata = __webpack_require__(321);
	
	var _require = __webpack_require__(346);
	
	var Map = _require.Map;
	
	var ContentStateInlineStyle = {
	  add: function add(contentState, selectionState, inlineStyle) {
	    return modifyInlineStyle(contentState, selectionState, inlineStyle, true);
	  },
	
	  remove: function remove(contentState, selectionState, inlineStyle) {
	    return modifyInlineStyle(contentState, selectionState, inlineStyle, false);
	  }
	};
	
	function modifyInlineStyle(contentState, selectionState, inlineStyle, addOrRemove) {
	  var blockMap = contentState.getBlockMap();
	  var startKey = selectionState.getStartKey();
	  var startOffset = selectionState.getStartOffset();
	  var endKey = selectionState.getEndKey();
	  var endOffset = selectionState.getEndOffset();
	
	  var newBlocks = blockMap.skipUntil(function (_, k) {
	    return k === startKey;
	  }).takeUntil(function (_, k) {
	    return k === endKey;
	  }).concat(Map([[endKey, blockMap.get(endKey)]])).map(function (block, blockKey) {
	    var sliceStart;
	    var sliceEnd;
	
	    if (startKey === endKey) {
	      sliceStart = startOffset;
	      sliceEnd = endOffset;
	    } else {
	      sliceStart = blockKey === startKey ? startOffset : 0;
	      sliceEnd = blockKey === endKey ? endOffset : block.getLength();
	    }
	
	    var chars = block.getCharacterList();
	    var current;
	    while (sliceStart < sliceEnd) {
	      current = chars.get(sliceStart);
	      chars = chars.set(sliceStart, addOrRemove ? CharacterMetadata.applyStyle(current, inlineStyle) : CharacterMetadata.removeStyle(current, inlineStyle));
	      sliceStart++;
	    }
	
	    return block.set('characterList', chars);
	  });
	
	  return contentState.merge({
	    blockMap: blockMap.merge(newBlocks),
	    selectionBefore: selectionState,
	    selectionAfter: selectionState
	  });
	}
	
	module.exports = ContentStateInlineStyle;

/***/ },
/* 378 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule applyEntityToContentState
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(346);
	
	var applyEntityToContentBlock = __webpack_require__(422);
	
	function applyEntityToContentState(contentState, selectionState, entityKey) {
	  var blockMap = contentState.getBlockMap();
	  var startKey = selectionState.getStartKey();
	  var startOffset = selectionState.getStartOffset();
	  var endKey = selectionState.getEndKey();
	  var endOffset = selectionState.getEndOffset();
	
	  var newBlocks = blockMap.skipUntil(function (_, k) {
	    return k === startKey;
	  }).takeUntil(function (_, k) {
	    return k === endKey;
	  }).toOrderedMap().merge(Immutable.OrderedMap([[endKey, blockMap.get(endKey)]])).map(function (block, blockKey) {
	    var sliceStart = blockKey === startKey ? startOffset : 0;
	    var sliceEnd = blockKey === endKey ? endOffset : block.getLength();
	    return applyEntityToContentBlock(block, sliceStart, sliceEnd, entityKey);
	  });
	
	  return contentState.merge({
	    blockMap: blockMap.merge(newBlocks),
	    selectionBefore: selectionState,
	    selectionAfter: selectionState
	  });
	}
	
	module.exports = applyEntityToContentState;

/***/ },
/* 379 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getCharacterRemovalRange
	 * @typechecks
	 * 
	 */
	
	/**
	 * Given a SelectionState and a removal direction, determine the entire range
	 * that should be removed from a ContentState. This is based on any entities
	 * within the target, with their `mutability` values taken into account.
	 *
	 * For instance, if we are attempting to remove part of an "immutable" entity
	 * range, the entire entity must be removed. The returned `SelectionState`
	 * will be adjusted accordingly.
	 */
	'use strict';
	
	var DraftEntity = __webpack_require__(330);
	var DraftEntitySegments = __webpack_require__(423);
	
	var getRangesForDraftEntity = __webpack_require__(424);
	var invariant = __webpack_require__(432);
	
	function getCharacterRemovalRange(block, selectionState, direction) {
	  var start = selectionState.getStartOffset();
	  var end = selectionState.getEndOffset();
	  var entityKey = block.getEntityAt(start);
	  if (!entityKey) {
	    return selectionState;
	  }
	
	  var entity = DraftEntity.get(entityKey);
	  var mutability = entity.getMutability();
	
	  // `MUTABLE` entities can just have the specified range of text removed
	  // directly. No adjustments are needed.
	  if (mutability === 'MUTABLE') {
	    return selectionState;
	  }
	
	  // Find the entity range that overlaps with our removal range.
	  var entityRanges = getRangesForDraftEntity(block, entityKey).filter(function (range) {
	    return start < range.end && end > range.start;
	  });
	
	  !(entityRanges.length == 1) ? true ? invariant(false, 'There should only be one entity range within this removal range.') : invariant(false) : undefined;
	
	  var entityRange = entityRanges[0];
	
	  // For `IMMUTABLE` entity types, we will remove the entire entity range.
	  if (mutability === 'IMMUTABLE') {
	    return selectionState.merge({
	      anchorOffset: entityRange.start,
	      focusOffset: entityRange.end,
	      isBackward: false
	    });
	  }
	
	  // For `SEGMENTED` entity types, determine the appropriate segment to
	  // remove.
	  var removalRange = DraftEntitySegments.getRemovalRange(start, end, block.getText().slice(entityRange.start, entityRange.end), entityRange.start, direction);
	
	  return selectionState.merge({
	    anchorOffset: removalRange.start,
	    focusOffset: removalRange.end,
	    isBackward: false
	  });
	}
	
	module.exports = getCharacterRemovalRange;

/***/ },
/* 380 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getContentStateFragment
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var generateRandomKey = __webpack_require__(339);
	var removeEntitiesAtEdges = __webpack_require__(383);
	
	function getContentStateFragment(contentState, selectionState) {
	  var startKey = selectionState.getStartKey();
	  var startOffset = selectionState.getStartOffset();
	  var endKey = selectionState.getEndKey();
	  var endOffset = selectionState.getEndOffset();
	
	  // Edge entities should be stripped to ensure that we don't preserve
	  // invalid partial entities when the fragment is reused. We do, however,
	  // preserve entities that are entirely within the selection range.
	  var contentWithoutEdgeEntities = removeEntitiesAtEdges(contentState, selectionState);
	
	  var blockMap = contentWithoutEdgeEntities.getBlockMap();
	  var blockKeys = blockMap.keySeq();
	  var startIndex = blockKeys.indexOf(startKey);
	  var endIndex = blockKeys.indexOf(endKey) + 1;
	
	  var slice = blockMap.slice(startIndex, endIndex).map(function (block, blockKey) {
	    var newKey = generateRandomKey();
	
	    var text = block.getText();
	    var chars = block.getCharacterList();
	
	    if (startKey === endKey) {
	      return block.merge({
	        key: newKey,
	        text: text.slice(startOffset, endOffset),
	        characterList: chars.slice(startOffset, endOffset)
	      });
	    }
	
	    if (blockKey === startKey) {
	      return block.merge({
	        key: newKey,
	        text: text.slice(startOffset),
	        characterList: chars.slice(startOffset)
	      });
	    }
	
	    if (blockKey === endKey) {
	      return block.merge({
	        key: newKey,
	        text: text.slice(0, endOffset),
	        characterList: chars.slice(0, endOffset)
	      });
	    }
	
	    return block.set('key', newKey);
	  });
	
	  return slice.toOrderedMap();
	}
	
	module.exports = getContentStateFragment;

/***/ },
/* 381 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule insertFragmentIntoContentState
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var BlockMapBuilder = __webpack_require__(320);
	
	var generateRandomKey = __webpack_require__(339);
	var insertIntoList = __webpack_require__(425);
	var invariant = __webpack_require__(432);
	
	function insertFragmentIntoContentState(contentState, selectionState, fragment) {
	  !selectionState.isCollapsed() ? true ? invariant(false, '`insertFragment` should only be called with a collapsed selection state.') : invariant(false) : undefined;
	
	  var targetKey = selectionState.getStartKey();
	  var targetOffset = selectionState.getStartOffset();
	
	  var blockMap = contentState.getBlockMap();
	
	  var fragmentSize = fragment.size;
	  var finalKey;
	  var finalOffset;
	
	  if (fragmentSize === 1) {
	    var targetBlock = blockMap.get(targetKey);
	    var pastedBlock = fragment.first();
	    var text = targetBlock.getText();
	    var chars = targetBlock.getCharacterList();
	
	    var newBlock = targetBlock.merge({
	      text: text.slice(0, targetOffset) + pastedBlock.getText() + text.slice(targetOffset),
	      characterList: insertIntoList(chars, pastedBlock.getCharacterList(), targetOffset)
	    });
	
	    blockMap = blockMap.set(targetKey, newBlock);
	
	    finalKey = targetKey;
	    finalOffset = targetOffset + pastedBlock.getText().length;
	
	    return contentState.merge({
	      blockMap: blockMap.set(targetKey, newBlock),
	      selectionBefore: selectionState,
	      selectionAfter: selectionState.merge({
	        anchorKey: finalKey,
	        anchorOffset: finalOffset,
	        focusKey: finalKey,
	        focusOffset: finalOffset,
	        isBackward: false
	      })
	    });
	  }
	
	  var newBlockArr = [];
	
	  contentState.getBlockMap().forEach(function (block, blockKey) {
	    if (blockKey !== targetKey) {
	      newBlockArr.push(block);
	      return;
	    }
	
	    var text = block.getText();
	    var chars = block.getCharacterList();
	
	    // Modify head portion of block.
	    var blockSize = text.length;
	    var headText = text.slice(0, targetOffset);
	    var headCharacters = chars.slice(0, targetOffset);
	    var appendToHead = fragment.first();
	
	    var modifiedHead = block.merge({
	      text: headText + appendToHead.getText(),
	      characterList: headCharacters.concat(appendToHead.getCharacterList())
	    });
	
	    newBlockArr.push(modifiedHead);
	
	    // Insert fragment blocks after the head and before the tail.
	    fragment.slice(1, fragmentSize - 1).forEach(function (fragmentBlock) {
	      newBlockArr.push(fragmentBlock.set('key', generateRandomKey()));
	    });
	
	    // Modify tail portion of block.
	    var tailText = text.slice(targetOffset, blockSize);
	    var tailCharacters = chars.slice(targetOffset, blockSize);
	    var prependToTail = fragment.last();
	    finalKey = generateRandomKey();
	
	    var modifiedTail = prependToTail.merge({
	      key: finalKey,
	      text: prependToTail.getText() + tailText,
	      characterList: prependToTail.getCharacterList().concat(tailCharacters)
	    });
	
	    newBlockArr.push(modifiedTail);
	  });
	
	  finalOffset = fragment.last().getLength();
	
	  return contentState.merge({
	    blockMap: BlockMapBuilder.createFromArray(newBlockArr),
	    selectionBefore: selectionState,
	    selectionAfter: selectionState.merge({
	      anchorKey: finalKey,
	      anchorOffset: finalOffset,
	      focusKey: finalKey,
	      focusOffset: finalOffset,
	      isBackward: false
	    })
	  });
	}
	
	module.exports = insertFragmentIntoContentState;

/***/ },
/* 382 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule insertTextIntoContentState
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(346);
	
	var insertIntoList = __webpack_require__(425);
	var invariant = __webpack_require__(432);
	
	var Repeat = Immutable.Repeat;
	
	function insertTextIntoContentState(contentState, selectionState, text, characterMetadata) {
	  !selectionState.isCollapsed() ? true ? invariant(false, '`insertText` should only be called with a collapsed range.') : invariant(false) : undefined;
	
	  var len = text.length;
	  if (!len) {
	    return contentState;
	  }
	
	  var blockMap = contentState.getBlockMap();
	  var key = selectionState.getStartKey();
	  var offset = selectionState.getStartOffset();
	  var block = blockMap.get(key);
	  var blockText = block.getText();
	
	  var newBlock = block.merge({
	    text: blockText.slice(0, offset) + text + blockText.slice(offset, block.getLength()),
	    characterList: insertIntoList(block.getCharacterList(), Repeat(characterMetadata, len).toList(), offset)
	  });
	
	  var newOffset = offset + len;
	
	  return contentState.merge({
	    blockMap: blockMap.set(key, newBlock),
	    selectionAfter: selectionState.merge({
	      anchorOffset: newOffset,
	      focusOffset: newOffset
	    })
	  });
	}
	
	module.exports = insertTextIntoContentState;

/***/ },
/* 383 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule removeEntitiesAtEdges
	 * 
	 */
	
	'use strict';
	
	var CharacterMetadata = __webpack_require__(321);
	var DraftEntity = __webpack_require__(330);
	
	var findRangesImmutable = __webpack_require__(376);
	var invariant = __webpack_require__(432);
	
	function removeEntitiesAtEdges(contentState, selectionState) {
	  var blockMap = contentState.getBlockMap();
	
	  var updatedBlocks = {};
	
	  var startKey = selectionState.getStartKey();
	  var startOffset = selectionState.getStartOffset();
	  var startBlock = blockMap.get(startKey);
	  var updatedStart = removeForBlock(startBlock, startOffset);
	
	  if (updatedStart !== startBlock) {
	    updatedBlocks[startKey] = updatedStart;
	  }
	
	  var endKey = selectionState.getEndKey();
	  var endOffset = selectionState.getEndOffset();
	  var endBlock = blockMap.get(endKey);
	  if (startKey === endKey) {
	    endBlock = updatedStart;
	  }
	
	  var updatedEnd = removeForBlock(endBlock, endOffset);
	
	  if (updatedEnd !== endBlock) {
	    updatedBlocks[endKey] = updatedEnd;
	  }
	
	  if (!Object.keys(updatedBlocks).length) {
	    return contentState.set('selectionAfter', selectionState);
	  }
	
	  return contentState.merge({
	    blockMap: blockMap.merge(updatedBlocks),
	    selectionAfter: selectionState
	  });
	}
	
	function getRemovalRange(characters, key, offset) {
	  var removalRange;
	  findRangesImmutable(characters, function (a, b) {
	    return a.getEntity() === b.getEntity();
	  }, function (element) {
	    return element.getEntity() === key;
	  }, function (start, end) {
	    if (start <= offset && end >= offset) {
	      removalRange = { start: start, end: end };
	    }
	  });
	  !(typeof removalRange === 'object') ? true ? invariant(false, 'Removal range must exist within character list.') : invariant(false) : undefined;
	  return removalRange;
	}
	
	function removeForBlock(block, offset) {
	  var chars = block.getCharacterList();
	  var charBefore = offset > 0 ? chars.get(offset - 1) : undefined;
	  var charAfter = offset < chars.count() ? chars.get(offset) : undefined;
	  var entityBeforeCursor = charBefore ? charBefore.getEntity() : undefined;
	  var entityAfterCursor = charAfter ? charAfter.getEntity() : undefined;
	
	  if (entityAfterCursor && entityAfterCursor === entityBeforeCursor) {
	    var entity = DraftEntity.get(entityAfterCursor);
	    if (entity.getMutability() !== 'MUTABLE') {
	      var _getRemovalRange = getRemovalRange(chars, entityAfterCursor, offset);
	
	      var start = _getRemovalRange.start;
	      var end = _getRemovalRange.end;
	
	      var current;
	      while (start < end) {
	        current = chars.get(start);
	        chars = chars.set(start, CharacterMetadata.applyEntity(current, null));
	        start++;
	      }
	      return block.set('characterList', chars);
	    }
	  }
	
	  return block;
	}
	
	module.exports = removeEntitiesAtEdges;

/***/ },
/* 384 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule removeRangeFromContentState
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(346);
	
	function removeRangeFromContentState(contentState, selectionState) {
	  if (selectionState.isCollapsed()) {
	    return contentState;
	  }
	
	  var blockMap = contentState.getBlockMap();
	  var startKey = selectionState.getStartKey();
	  var startOffset = selectionState.getStartOffset();
	  var endKey = selectionState.getEndKey();
	  var endOffset = selectionState.getEndOffset();
	
	  var startBlock = blockMap.get(startKey);
	  var endBlock = blockMap.get(endKey);
	  var characterList;
	
	  if (startBlock === endBlock) {
	    characterList = removeFromList(startBlock.getCharacterList(), startOffset, endOffset);
	  } else {
	    characterList = startBlock.getCharacterList().slice(0, startOffset).concat(endBlock.getCharacterList().slice(endOffset));
	  }
	
	  var modifiedStart = startBlock.merge({
	    text: startBlock.getText().slice(0, startOffset) + endBlock.getText().slice(endOffset),
	    characterList: characterList
	  });
	
	  var newBlocks = blockMap.toSeq().skipUntil(function (_, k) {
	    return k === startKey;
	  }).takeUntil(function (_, k) {
	    return k === endKey;
	  }).concat(Immutable.Map([[endKey, null]])).map(function (_, k) {
	    return k === startKey ? modifiedStart : null;
	  });
	
	  blockMap = blockMap.merge(newBlocks).filter(function (block) {
	    return !!block;
	  });
	
	  return contentState.merge({
	    blockMap: blockMap,
	    selectionBefore: selectionState,
	    selectionAfter: selectionState.merge({
	      anchorKey: startKey,
	      anchorOffset: startOffset,
	      focusKey: startKey,
	      focusOffset: startOffset,
	      isBackward: false
	    })
	  });
	}
	
	/**
	 * Maintain persistence for target list when removing characters on the
	 * head and tail of the character list.
	 */
	function removeFromList(targetList, startOffset, endOffset) {
	  if (startOffset === 0) {
	    while (startOffset < endOffset) {
	      targetList = targetList.shift();
	      startOffset++;
	    }
	  } else if (endOffset === targetList.count()) {
	    while (endOffset > startOffset) {
	      targetList = targetList.pop();
	      endOffset--;
	    }
	  } else {
	    var head = targetList.slice(0, startOffset);
	    var tail = targetList.slice(endOffset);
	    targetList = head.concat(tail).toList();
	  }
	  return targetList;
	}
	
	module.exports = removeRangeFromContentState;

/***/ },
/* 385 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule setBlockTypeForContentState
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(346);
	
	function setBlockTypeForContentState(contentState, selectionState, blockType) {
	  var startKey = selectionState.getStartKey();
	  var endKey = selectionState.getEndKey();
	  var blockMap = contentState.getBlockMap();
	  var newBlocks = blockMap.toSeq().skipUntil(function (_, k) {
	    return k === startKey;
	  }).takeUntil(function (_, k) {
	    return k === endKey;
	  }).concat(Immutable.Map([[endKey, blockMap.get(endKey)]])).map(function (block) {
	    return block.merge({ type: blockType, depth: 0 });
	  });
	
	  return contentState.merge({
	    blockMap: blockMap.merge(newBlocks),
	    selectionBefore: selectionState,
	    selectionAfter: selectionState
	  });
	}
	
	module.exports = setBlockTypeForContentState;

/***/ },
/* 386 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule splitBlockInContentState
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var generateRandomKey = __webpack_require__(339);
	var invariant = __webpack_require__(432);
	
	function splitBlockInContentState(contentState, selectionState) {
	  !selectionState.isCollapsed() ? true ? invariant(false, 'Selection range must be collapsed.') : invariant(false) : undefined;
	
	  var key = selectionState.getAnchorKey();
	  var offset = selectionState.getAnchorOffset();
	  var blockMap = contentState.getBlockMap();
	  var blockToSplit = blockMap.get(key);
	
	  var text = blockToSplit.getText();
	  var chars = blockToSplit.getCharacterList();
	
	  var blockAbove = blockToSplit.merge({
	    text: text.slice(0, offset),
	    characterList: chars.slice(0, offset)
	  });
	
	  var keyBelow = generateRandomKey();
	  var blockBelow = blockAbove.merge({
	    key: keyBelow,
	    text: text.slice(offset),
	    characterList: chars.slice(offset)
	  });
	
	  var blocksBefore = blockMap.toSeq().takeUntil(function (v) {
	    return v === blockToSplit;
	  });
	  var blocksAfter = blockMap.toSeq().skipUntil(function (v) {
	    return v === blockToSplit;
	  }).rest();
	  var newBlocks = blocksBefore.concat([[blockAbove.getKey(), blockAbove], [blockBelow.getKey(), blockBelow]], blocksAfter).toOrderedMap();
	
	  return contentState.merge({
	    blockMap: newBlocks,
	    selectionBefore: selectionState,
	    selectionAfter: selectionState.merge({
	      anchorKey: keyBelow,
	      anchorOffset: 0,
	      focusKey: keyBelow,
	      focusOffset: 0,
	      isBackward: false
	    })
	  });
	}
	
	module.exports = splitBlockInContentState;

/***/ },
/* 387 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftStringKey
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var DraftStringKey = {
	  stringify: function stringify(key) {
	    return '_' + String(key);
	  },
	
	  unstringify: function unstringify(key) {
	    return key.slice(1);
	  }
	};
	
	module.exports = DraftStringKey;

/***/ },
/* 388 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule encodeEntityRanges
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var DraftStringKey = __webpack_require__(387);
	var UnicodeUtils = __webpack_require__(445);
	
	var strlen = UnicodeUtils.strlen;
	
	/**
	 * Convert to UTF-8 character counts for storage.
	 */
	function encodeEntityRanges(block, storageMap) {
	  var encoded = [];
	  block.findEntityRanges(function (character) {
	    return !!character.getEntity();
	  }, function ( /*number*/start, /*number*/end) {
	    var text = block.getText();
	    var key = block.getEntityAt(start);
	    encoded.push({
	      offset: strlen(text.slice(0, start)),
	      length: strlen(text.slice(start, end)),
	      // Encode the key as a number for range storage.
	      key: Number(storageMap[DraftStringKey.stringify(key)])
	    });
	  });
	  return encoded;
	}
	
	module.exports = encodeEntityRanges;

/***/ },
/* 389 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule encodeInlineStyleRanges
	 * 
	 */
	
	'use strict';
	
	var UnicodeUtils = __webpack_require__(445);
	
	var findRangesImmutable = __webpack_require__(376);
	
	var areEqual = function areEqual(a, b) {
	  return a === b;
	};
	var isTruthy = function isTruthy(a) {
	  return !!a;
	};
	var EMPTY_ARRAY = [];
	
	/**
	 * Helper function for getting encoded styles for each inline style. Convert
	 * to UTF-8 character counts for storage.
	 */
	function getEncodedInlinesForType(block, styleList, styleToEncode) {
	  var ranges = [];
	
	  // Obtain an array with ranges for only the specified style.
	  var filteredInlines = styleList.map(function (style) {
	    return style.has(styleToEncode);
	  }).toList();
	
	  findRangesImmutable(filteredInlines, areEqual,
	  // We only want to keep ranges with nonzero style values.
	  isTruthy, function (start, end) {
	    var text = block.getText();
	    ranges.push({
	      offset: UnicodeUtils.strlen(text.slice(0, start)),
	      length: UnicodeUtils.strlen(text.slice(start, end)),
	      style: styleToEncode
	    });
	  });
	
	  return ranges;
	}
	
	/*
	 * Retrieve the encoded arrays of inline styles, with each individual style
	 * treated separately.
	 */
	function encodeInlineStyleRanges(block) {
	  var styleList = block.getCharacterList().map(function (c) {
	    return c.getStyle();
	  }).toList();
	  var ranges = styleList.flatten().toSet().map(function (style) {
	    return getEncodedInlinesForType(block, styleList, style);
	  });
	
	  return Array.prototype.concat.apply(EMPTY_ARRAY, ranges.toJS());
	}
	
	module.exports = encodeInlineStyleRanges;

/***/ },
/* 390 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule createCharacterList
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var CharacterMetadata = __webpack_require__(321);
	var Immutable = __webpack_require__(346);
	
	var List = Immutable.List;
	
	function createCharacterList(inlineStyles, entities) {
	  var characterArray = inlineStyles.map(function (style, ii) {
	    var entity = entities[ii];
	    return CharacterMetadata.create({ style: style, entity: entity });
	  });
	  return List(characterArray);
	}
	
	module.exports = createCharacterList;

/***/ },
/* 391 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule decodeEntityRanges
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var UnicodeUtils = __webpack_require__(445);
	
	var substr = UnicodeUtils.substr;
	
	/**
	 * Convert to native JavaScript string lengths to determine ranges.
	 */
	function decodeEntityRanges(text, ranges) {
	  var entities = Array(text.length).fill(null);
	  if (ranges) {
	    ranges.forEach(function (range) {
	      // Using Unicode-enabled substrings converted to JavaScript lengths,
	      // fill the output array with entity keys.
	      var start = substr(text, 0, range.offset).length;
	      var end = start + substr(text, range.offset, range.length).length;
	      for (var ii = start; ii < end; ii++) {
	        entities[ii] = range.key;
	      }
	    });
	  }
	  return entities;
	}
	
	module.exports = decodeEntityRanges;

/***/ },
/* 392 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule decodeInlineStyleRanges
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var UnicodeUtils = __webpack_require__(445);
	
	var _require = __webpack_require__(346);
	
	var OrderedSet = _require.OrderedSet;
	var substr = UnicodeUtils.substr;
	
	var EMPTY_SET = OrderedSet();
	
	/**
	 * Convert to native JavaScript string lengths to determine ranges.
	 */
	function decodeInlineStyleRanges(text, ranges) {
	  var styles = Array(text.length).fill(EMPTY_SET);
	  if (ranges) {
	    ranges.forEach(function ( /*object*/range) {
	      var cursor = substr(text, 0, range.offset).length;
	      var end = cursor + substr(text, range.offset, range.length).length;
	      while (cursor < end) {
	        styles[cursor] = styles[cursor].add(range.style);
	        cursor++;
	      }
	    });
	  }
	  return styles;
	}
	
	module.exports = decodeInlineStyleRanges;

/***/ },
/* 393 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getRangeBoundingClientRect
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	var getRangeClientRects = __webpack_require__(426);
	
	/**
	 * Like range.getBoundingClientRect() but normalizes for browser bugs.
	 */
	function getRangeBoundingClientRect(range) {
	  // "Return a DOMRect object describing the smallest rectangle that includes
	  // the first rectangle in list and all of the remaining rectangles of which
	  // the height or width is not zero."
	  // http://www.w3.org/TR/cssom-view/#dom-range-getboundingclientrect
	  var rects = getRangeClientRects(range);
	  var top = 0;
	  var right = 0;
	  var bottom = 0;
	  var left = 0;
	
	  if (rects.length) {
	    var _rects$0 = rects[0];
	    top = _rects$0.top;
	    right = _rects$0.right;
	    bottom = _rects$0.bottom;
	    left = _rects$0.left;
	
	    for (var ii = 1; ii < rects.length; ii++) {
	      var rect = rects[ii];
	      if (rect.height !== 0 || rect.width !== 0) {
	        top = Math.min(top, rect.top);
	        right = Math.max(right, rect.right);
	        bottom = Math.max(bottom, rect.bottom);
	        left = Math.min(left, rect.left);
	      }
	    }
	  }
	
	  return {
	    top: top,
	    right: right,
	    bottom: bottom,
	    left: left,
	    width: right - left,
	    height: bottom - top
	  };
	}
	
	module.exports = getRangeBoundingClientRect;

/***/ },
/* 394 */
/***/ function(module, exports, __webpack_require__) {

	var _ = __webpack_require__(56);
	var WrappedDefaults = __webpack_require__(288);
	
	var DEFAULT_OPTIONS = {
	    center: null, // gets ignored in `graphie.fixedPath` if `null`
	    createPath: null, // gets defaulted in `graphie.fixedPath` if `null`
	    mouselayer: false
	};
	
	var WrappedPath = function WrappedPath(graphie, points, options) {
	    options = _.extend({}, DEFAULT_OPTIONS, options);
	
	    // Add `wrapper` and `visibleShape`
	    _.extend(this, graphie.fixedPath(points, options.center, options.createPath));
	
	    // Add remaining properties
	    _.extend(this, {
	        graphie: graphie,
	        initialPoint: graphie.scalePoint(_.head(points))
	    });
	
	    // Add to appropriate graphie layer
	    if (options.mouselayer) {
	        // Disable browser handling of all panning and zooming gestures on the
	        // movable wrapper so that when moved the browser does not scroll page
	        this.wrapper.style.touchAction = "none";
	
	        this.graphie.addToMouseLayerWrapper(this.wrapper);
	    } else {
	        this.graphie.addToVisibleLayerWrapper(this.wrapper);
	    }
	};
	
	_.extend(WrappedPath.prototype, WrappedDefaults);
	
	module.exports = WrappedPath;

/***/ },
/* 395 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * This file contains constants for keypad buttons that aren't single
	 * alphanumeric characters.
	 */
	
	// TODO(charlie): There's duplication between this file and key-configs.js.
	// We should clean it up by removing this file and requiring clients to use the
	// `id` field on the key configurations.
	var Keys = {
	    PLUS: 'PLUS',
	    MINUS: 'MINUS',
	    NEGATIVE: 'NEGATIVE',
	    TIMES: 'TIMES',
	    DIVIDE: 'DIVIDE',
	    DECIMAL: 'DECIMAL',
	    PERIOD: 'PERIOD',
	    PERCENT: 'PERCENT',
	    CDOT: 'CDOT',
	    EQUAL: 'EQUAL',
	    NEQ: 'NEQ',
	    GT: 'GT',
	    LT: 'LT',
	    GEQ: 'GEQ',
	    LEQ: 'LEQ',
	    FRAC_INCLUSIVE: 'FRAC_INCLUSIVE',
	    FRAC_EXCLUSIVE: 'FRAC_EXCLUSIVE',
	    EXP: 'EXP',
	    EXP_2: 'EXP_2',
	    EXP_3: 'EXP_3',
	    SQRT: 'SQRT',
	    CUBE_ROOT: 'CUBE_ROOT',
	    RADICAL: 'RADICAL',
	    LEFT_PAREN: 'LEFT_PAREN',
	    RIGHT_PAREN: 'RIGHT_PAREN',
	    LN: 'LN',
	    LOG: 'LOG',
	    LOG_N: 'LOG_N',
	    SIN: 'SIN',
	    COS: 'COS',
	    TAN: 'TAN',
	
	    // TODO(charlie): Add in additional Greek letters.
	    PI: 'PI',
	    THETA: 'THETA',
	
	    UP: 'UP',
	    RIGHT: 'RIGHT',
	    DOWN: 'DOWN',
	    LEFT: 'LEFT',
	    BACKSPACE: 'BACKSPACE',
	    DISMISS: 'DISMISS',
	
	    JUMP_OUT_PARENTHESES: 'JUMP_OUT_PARENTHESES',
	    JUMP_OUT_EXPONENT: 'JUMP_OUT_EXPONENT',
	    JUMP_OUT_BASE: 'JUMP_OUT_BASE',
	    JUMP_INTO_NUMERATOR: 'JUMP_INTO_NUMERATOR',
	    JUMP_OUT_NUMERATOR: 'JUMP_OUT_NUMERATOR',
	    JUMP_OUT_DENOMINATOR: 'JUMP_OUT_DENOMINATOR',
	
	    NOOP: 'NOOP',
	
	    // Multi-functional keys.
	    FRAC_MULTI: 'FRAC_MULTI',
	
	    // A custom key that captures an arbitrary number of symbols but has no
	    // 'default' symbol or action.
	    MANY: 'MANY'
	};
	
	module.exports = Keys;

/***/ },
/* 396 */
/***/ function(module, exports, __webpack_require__) {

	var _require = __webpack_require__(283),
	    DecimalSeparators = _require.DecimalSeparators;
	
	// We expect `window.icu` to be exposed by the parent. When in doubt, we fall
	// back to a period. We can only depend on a subset of what localeplanet
	// provides, however -- the things in `icu-slim.js` (there's a copy in ../lib/
	// for reference).
	
	
	var decimalSeparator = void 0;
	if (typeof window !== 'undefined' && window.icu && window.icu.getDecimalFormatSymbols().decimal_separator === ',') {
	    decimalSeparator = DecimalSeparators.COMMA;
	} else {
	    decimalSeparator = DecimalSeparators.PERIOD;
	}
	
	module.exports = {
	    decimalSeparator: decimalSeparator
	};

/***/ },
/* 397 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.connect = exports.Provider = undefined;
	
	var _Provider = __webpack_require__(446);
	
	var _Provider2 = _interopRequireDefault(_Provider);
	
	var _connect = __webpack_require__(447);
	
	var _connect2 = _interopRequireDefault(_connect);
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { "default": obj };
	}
	
	exports.Provider = _Provider2["default"];
	exports.connect = _connect2["default"];

/***/ },
/* 398 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorLeaf.react
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var DraftEditorTextNode = __webpack_require__(429);
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var SelectionState = __webpack_require__(335);
	
	var setDraftEditorSelection = __webpack_require__(430);
	
	/**
	 * All leaf nodes in the editor are spans with single text nodes. Leaf
	 * elements are styled based on the merging of an optional custom style map
	 * and a default style map.
	 *
	 * `DraftEditorLeaf` also provides a wrapper for calling into the imperative
	 * DOM Selection API. In this way, top-level components can declaratively
	 * maintain the selection state.
	 */
	
	var DraftEditorLeaf = (function (_React$Component) {
	  _inherits(DraftEditorLeaf, _React$Component);
	
	  function DraftEditorLeaf() {
	    _classCallCheck(this, DraftEditorLeaf);
	
	    _get(Object.getPrototypeOf(DraftEditorLeaf.prototype), 'constructor', this).apply(this, arguments);
	  }
	
	  _createClass(DraftEditorLeaf, [{
	    key: '_setSelection',
	
	    /**
	     * By making individual leaf instances aware of their context within
	     * the text of the editor, we can set our selection range more
	     * easily than we could in the non-React world.
	     *
	     * Note that this depends on our maintaining tight control over the
	     * DOM structure of the TextEditor component. If leaves had multiple
	     * text nodes, this would be harder.
	     */
	    value: function _setSelection() {
	      var selection = this.props.selection;
	
	      // If selection state is irrelevant to the parent block, no-op.
	      if (selection == null || !selection.getHasFocus()) {
	        return;
	      }
	
	      var _props = this.props;
	      var blockKey = _props.blockKey;
	      var start = _props.start;
	      var text = _props.text;
	
	      var end = start + text.length;
	      if (!selection.hasEdgeWithin(blockKey, start, end)) {
	        return;
	      }
	
	      // Determine the appropriate target node for selection. If the child
	      // is not a text node, it is a <br /> spacer. In this case, use the
	      // <span> itself as the selection target.
	      var node = ReactDOM.findDOMNode(this);
	      var child = node.firstChild;
	      var targetNode = undefined;
	
	      if (child.nodeType === Node.TEXT_NODE) {
	        targetNode = child;
	      } else if (child.tagName === 'BR') {
	        targetNode = node;
	      } else {
	        targetNode = child.firstChild;
	      }
	
	      setDraftEditorSelection(selection, targetNode, blockKey, start, end);
	    }
	  }, {
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate(nextProps) {
	      return ReactDOM.findDOMNode(this.refs.leaf).textContent !== nextProps.text || nextProps.styleSet !== this.props.styleSet || nextProps.forceSelection;
	    }
	  }, {
	    key: 'componentDidUpdate',
	    value: function componentDidUpdate() {
	      this._setSelection();
	    }
	  }, {
	    key: 'componentDidMount',
	    value: function componentDidMount() {
	      this._setSelection();
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var text = this.props.text;
	
	      // If the leaf is at the end of its block and ends in a soft newline, append
	      // an extra line feed character. Browsers collapse trailing newline
	      // characters, which leaves the cursor in the wrong place after a
	      // shift+enter. The extra character repairs this.
	      if (text.endsWith('\n') && this.props.isLast) {
	        text += '\n';
	      }
	
	      var _props2 = this.props;
	      var customStyleMap = _props2.customStyleMap;
	      var offsetKey = _props2.offsetKey;
	      var styleSet = _props2.styleSet;
	
	      var styleObj = styleSet.reduce(function (map, styleName) {
	        var mergedStyles = {};
	        var style = customStyleMap[styleName];
	
	        if (style !== undefined && map.textDecoration !== style.textDecoration) {
	          mergedStyles.textDecoration = [map.textDecoration, style.textDecoration].join(' ');
	        }
	
	        return Object.assign(map, style, mergedStyles);
	      }, {});
	
	      return React.createElement(
	        'span',
	        {
	          'data-offset-key': offsetKey,
	          ref: 'leaf',
	          style: styleObj },
	        React.createElement(
	          DraftEditorTextNode,
	          null,
	          text
	        )
	      );
	    }
	  }]);
	
	  return DraftEditorLeaf;
	})(React.Component);
	
	module.exports = DraftEditorLeaf;
	
	// A function passed through from the the top level to define a cx
	// style map for the provided style value.
	
	// Mapping of style names to CSS declarations.
	
	// Whether to force the DOM selection after render.
	
	// Whether this leaf is the last in its block. Used for a DOM hack.
	
	// The current `SelectionState`, used to
	
	// The offset of this string within its block.
	
	// The set of style(s) names to apply to the node.
	
	// The full text to be rendered within this node.

/***/ },
/* 399 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftOffsetKey
	 * 
	 */
	
	'use strict';
	
	var _slicedToArray = (function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i['return']) _i['return'](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError('Invalid attempt to destructure non-iterable instance'); } }; })();
	
	var KEY_DELIMITER = '-';
	
	var DraftOffsetKey = {
	  encode: function encode(blockKey, decoratorKey, leafKey) {
	    return blockKey + KEY_DELIMITER + decoratorKey + KEY_DELIMITER + leafKey;
	  },
	
	  decode: function decode(offsetKey) {
	    var _offsetKey$split = offsetKey.split(KEY_DELIMITER);
	
	    var _offsetKey$split2 = _slicedToArray(_offsetKey$split, 3);
	
	    var blockKey = _offsetKey$split2[0];
	    var decoratorKey = _offsetKey$split2[1];
	    var leafKey = _offsetKey$split2[2];
	
	    return {
	      blockKey: blockKey,
	      decoratorKey: parseInt(decoratorKey, 10),
	      leafKey: parseInt(leafKey, 10)
	    };
	  }
	};
	
	module.exports = DraftOffsetKey;

/***/ },
/* 400 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule adjustBlockDepthForContentState
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	function adjustBlockDepthForContentState(contentState, selectionState, adjustment, maxDepth) {
	  var startKey = selectionState.getStartKey();
	  var endKey = selectionState.getEndKey();
	  var blockMap = contentState.getBlockMap();
	  var blocks = blockMap.toSeq().skipUntil(function (_, k) {
	    return k === startKey;
	  }).takeUntil(function (_, k) {
	    return k === endKey;
	  }).concat([[endKey, blockMap.get(endKey)]]).map(function (block) {
	    var depth = block.getDepth() + adjustment;
	    depth = Math.max(0, Math.min(depth, maxDepth));
	    return block.set('depth', depth);
	  });
	
	  blockMap = blockMap.merge(blocks);
	
	  return contentState.merge({
	    blockMap: blockMap,
	    selectionBefore: selectionState,
	    selectionAfter: selectionState
	  });
	}
	
	module.exports = adjustBlockDepthForContentState;

/***/ },
/* 401 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getSafeBodyFromHTML
	 * 
	 */
	
	'use strict';
	
	var UserAgent = __webpack_require__(433);
	
	var isOldIE = UserAgent.isBrowser('IE <= 9');
	
	// Provides a dom node that will not execute scripts
	// https://developer.mozilla.org/en-US/docs/Web/API/DOMImplementation.createHTMLDocument
	// https://developer.mozilla.org/en-US/Add-ons/Code_snippets/HTML_to_DOM
	
	function getSafeBodyFromHTML(html) {
	  var doc;
	  var root = null;
	  // Provides a safe context
	  if (!isOldIE && document.implementation && document.implementation.createHTMLDocument) {
	    doc = document.implementation.createHTMLDocument('foo');
	    doc.documentElement.innerHTML = html;
	    root = doc.getElementsByTagName('body')[0];
	  }
	  return root;
	}
	
	module.exports = getSafeBodyFromHTML;

/***/ },
/* 402 */,
/* 403 */,
/* 404 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * An algorithm for computing the appropriate layout parameters for the keypad,
	 * including the size of the buttons and whether or not to render fullscreen,
	 * taking into account a number of factors including the size of the screen, the
	 * orientation of the screen, the presence of browser chrome, the presence of
	 * other exercise-related chrome, the size of the input box, the parameters that
	 * define the keypad (i.e., the number of rows, columns, and pages), and so
	 * forth.
	 *
	 * The computations herein make some strong assumptions about the sizes of
	 * various other elements and the situations under which they will be visible
	 * (e.g., browser chrome). However, this is just a heuristic--it's not crucial
	 * that our buttons are sized in a pixel-perfect manner, but rather, that we
	 * make a balanced use of space.
	 *
	 * Note that one goal of the algorithm is to avoid resizing the keypad in the
	 * face of dynamic browser chrome. In order to avoid that awkwardness, we tend
	 * to be conservative in our measurements and make things smaller than they
	 * might need to be.
	 */
	
	var _require = __webpack_require__(283),
	    DeviceTypes = _require.DeviceTypes,
	    DeviceOrientations = _require.DeviceOrientations,
	    LayoutModes = _require.LayoutModes;
	
	var _require2 = __webpack_require__(355),
	    pageIndicatorHeightPx = _require2.pageIndicatorHeightPx,
	    toolbarHeightPx = _require2.toolbarHeightPx,
	    navigationPadWidthPx = _require2.navigationPadWidthPx,
	    innerBorderWidthPx = _require2.innerBorderWidthPx;
	
	var minButtonHeight = 48;
	var maxButtonSize = 64;
	var minSpaceAboveKeypad = 32;
	
	// These values are taken from an iPhone 5, but should be consistent with the
	// iPhone 4 as well. Regardless, these are meant to be representative of the
	// possible types of browser chrome that could appear in various context, rather
	// than pixel-perfect for every device.
	var safariNavBarWhenShrunk = 44;
	var safariNavBarWhenExpanded = 64;
	var safariToolbar = 44;
	
	// In mobile Safari, the browser chrome is completely hidden in landscape,
	// though a shrunken navbar and full-sized toolbar on scroll. In portrait, the
	// shrunken navbar is always visible, but expands on scroll (and the toolbar
	// appears as well).
	var maxLandscapeBrowserChrome = safariNavBarWhenShrunk + safariToolbar;
	var maxPortraitBrowserChrome = safariToolbar + (safariNavBarWhenExpanded - safariNavBarWhenShrunk);
	
	// This represents the 'worst case' aspect ratio that we care about (for
	// portrait layouts). It's taken from the iPhone 4. The height is computed by
	// taking the height of the device and removing the persistent, shrunken navbar.
	// (We don't need to account for the expanded navbar, since we include the
	// difference when reserving space above the keypad.)
	var worstCaseAspectRatio = 320 / (480 - safariNavBarWhenShrunk);
	
	var computeLayoutParameters = function computeLayoutParameters(_ref, _ref2, _ref3, _ref4) {
	    var numColumns = _ref.numColumns,
	        numMaxVisibleRows = _ref.numMaxVisibleRows,
	        numPages = _ref.numPages;
	    var pageWidthPx = _ref2.pageWidthPx,
	        pageHeightPx = _ref2.pageHeightPx;
	    var deviceOrientation = _ref3.deviceOrientation,
	        deviceType = _ref3.deviceType;
	    var navigationPadEnabled = _ref4.navigationPadEnabled,
	        paginationEnabled = _ref4.paginationEnabled,
	        toolbarEnabled = _ref4.toolbarEnabled;
	
	    // First, compute some values that will be used in multiple computations.
	    var effectiveNumColumns = paginationEnabled ? numColumns : numColumns * numPages;
	
	    // Then, compute the button dimensions based on the provided parameters.
	    var buttonDimensions = void 0;
	    if (deviceType === DeviceTypes.PHONE) {
	        var isLandscape = deviceOrientation === DeviceOrientations.LANDSCAPE;
	
	        // In many cases, the browser chrome will already have been factored
	        // into `pageHeightPx`. But we have no way of knowing if that's
	        // the case or not. As such, we take a conservative approach and
	        // assume that the chrome is _never_ included in `pageHeightPx`.
	        var browserChromeHeight = isLandscape ? maxLandscapeBrowserChrome : maxPortraitBrowserChrome;
	
	        // Count up all the space that we need to reserve on the page.
	        // Namely, we need to account for:
	        //  1. Space between the keypad and the top of the page.
	        //  2. The presence of the exercise toolbar.
	        //  3. The presence of the view pager indicator.
	        //  4. Any browser chrome that may appear later.
	        var reservedSpace = minSpaceAboveKeypad + browserChromeHeight + (toolbarEnabled ? toolbarHeightPx : 0) + (paginationEnabled ? pageIndicatorHeightPx : 0);
	
	        // Next, compute the effective width and height. We can use the page
	        // width as the effective width. For the height, though, we take
	        // another conservative measure when in portrait by assuming that
	        // the device has the worst possible aspect ratio. In other words,
	        // we ignore the device height in portrait and assume the worst.
	        // This prevents the keypad from changing size when browser chrome
	        // appears and disappears.
	        var effectiveWidth = pageWidthPx;
	        var effectiveHeight = isLandscape ? pageHeightPx : pageWidthPx / worstCaseAspectRatio;
	        var maxKeypadHeight = effectiveHeight - reservedSpace;
	
	        // Finally, compute the button height and width. In computing the
	        // height, accommodate for the maximum number of rows that will ever be
	        // visible (since the toggling of popovers can increase the number of
	        // visible rows).
	        var buttonHeightPx = Math.max(Math.min(maxKeypadHeight / numMaxVisibleRows, maxButtonSize), minButtonHeight);
	
	        var buttonWidthPx = void 0;
	        if (numPages > 1) {
	            var _effectiveNumColumns = paginationEnabled ? numColumns : numColumns * numPages;
	            buttonWidthPx = effectiveWidth / _effectiveNumColumns;
	        } else {
	            buttonWidthPx = isLandscape ? maxButtonSize : effectiveWidth / numColumns;
	        }
	
	        buttonDimensions = {
	            widthPx: buttonWidthPx,
	            heightPx: buttonHeightPx
	        };
	    } else if (deviceType === DeviceTypes.TABLET) {
	        buttonDimensions = {
	            widthPx: maxButtonSize,
	            heightPx: maxButtonSize
	        };
	    } else {
	        throw new Error("Invalid device type: " + deviceType);
	    }
	
	    // Finally, determine whether the keypad should be rendered in the
	    // fullscreen layout by determining its resultant width.
	    var numSeparators = (navigationPadEnabled ? 1 : 0) + (!paginationEnabled ? numPages - 1 : 0);
	    var keypadWidth = effectiveNumColumns * buttonDimensions.widthPx + (navigationPadEnabled ? navigationPadWidthPx : 0) + numSeparators * innerBorderWidthPx;
	    return {
	        buttonDimensions: buttonDimensions,
	        layoutMode: keypadWidth >= pageWidthPx ? LayoutModes.FULLSCREEN : LayoutModes.COMPACT
	    };
	};
	
	module.exports = computeLayoutParameters;

/***/ },
/* 405 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * A high-level manager for our gesture system. In particular, this class
	 * connects our various bits of logic for managing gestures and interactions,
	 * and links them together.
	 */
	
	var NodeManager = __webpack_require__(448);
	var PopoverStateMachine = __webpack_require__(449);
	var GestureStateMachine = __webpack_require__(450);
	
	var coordsForEvent = function coordsForEvent(evt) {
	    return [evt.changedTouches[0].clientX, evt.changedTouches[0].clientY];
	};
	
	var GestureManager = function () {
	    function GestureManager(options, handlers, disabledSwipeKeys, multiPressableKeys) {
	        var _this = this;
	
	        _classCallCheck(this, GestureManager);
	
	        var swipeEnabled = options.swipeEnabled;
	
	
	        this.swipeEnabled = swipeEnabled;
	
	        // Events aren't tracked until event tracking is enabled.
	        this.trackEvents = false;
	
	        this.nodeManager = new NodeManager();
	        this.popoverStateMachine = new PopoverStateMachine({
	            onActiveNodesChanged: function onActiveNodesChanged(activeNodes) {
	                var popover = activeNodes.popover,
	                    rest = _objectWithoutProperties(activeNodes, ['popover']);
	
	                handlers.onActiveNodesChanged(_extends({
	                    popover: popover && {
	                        parentId: popover.parentId,
	                        bounds: _this.nodeManager.layoutPropsForId(popover.parentId).initialBounds,
	                        childKeyIds: popover.childIds
	                    }
	                }, rest));
	            },
	            /**
	             * `onClick` takes two arguments:
	             *
	             * @param {string} keyId - the identifier key that should initiate
	             *                         a click
	             * @param {string} domNodeId - the identifier of the DOM node on
	             *                             which the click should be considered
	             *                             to have occurred
	             * @param {bool} inPopover - whether the key was contained within a
	             *                           popover
	             *
	             * These two parameters will often be equivalent. They will differ,
	             * though, when a popover button is itself clicked, in which case
	             * we need to mimic the effects of clicking on its 'primary' child
	             * key, but animate the click on the popover button.
	             */
	            onClick: function onClick(keyId, domNodeId, inPopover) {
	                handlers.onClick(keyId, _this.nodeManager.layoutPropsForId(domNodeId), inPopover);
	            }
	        });
	        this.gestureStateMachine = new GestureStateMachine({
	            onFocus: function onFocus(id) {
	                _this.popoverStateMachine.onFocus(id);
	            },
	            onLongPress: function onLongPress(id) {
	                _this.popoverStateMachine.onLongPress(id);
	            },
	            onTouchEnd: function onTouchEnd(id) {
	                _this.popoverStateMachine.onTouchEnd(id);
	            },
	            onBlur: function onBlur() {
	                _this.popoverStateMachine.onBlur();
	            },
	            onSwipeChange: handlers.onSwipeChange,
	            onSwipeEnd: handlers.onSwipeEnd,
	            onTrigger: function onTrigger(id) {
	                _this.popoverStateMachine.onTrigger(id);
	            }
	        }, {}, disabledSwipeKeys, multiPressableKeys);
	    }
	
	    /**
	     * Handle a touch-start event that originated in a node registered with the
	     * gesture system.
	     *
	     * @param {TouchEvent} evt - the raw touch event from the browser
	     * @param {string} id - the identifier of the DOM node in which the touch
	     *                      occurred
	     */
	
	
	    GestureManager.prototype.onTouchStart = function onTouchStart(evt, id) {
	        if (!this.trackEvents) {
	            return;
	        }
	
	        var _coordsForEvent = coordsForEvent(evt),
	            x = _coordsForEvent[0];
	
	        // TODO(charlie): It doesn't seem to be guaranteed that every touch
	        // event on `changedTouches` originates from the node through which this
	        // touch event was sent. In that case, we'd be inappropriately reporting
	        // the starting node ID.
	
	
	        for (var i = 0; i < evt.changedTouches.length; i++) {
	            this.gestureStateMachine.onTouchStart(function () {
	                return id;
	            }, evt.changedTouches[i].identifier, x);
	        }
	
	        // If an event started in a view that we're managing, we'll handle it
	        // all the way through.
	        evt.preventDefault();
	    };
	
	    /**
	     * Handle a touch-move event that originated in a node registered with the
	     * gesture system.
	     *
	     * @param {TouchEvent} evt - the raw touch event from the browser
	     */
	
	
	    GestureManager.prototype.onTouchMove = function onTouchMove(evt) {
	        var _this2 = this;
	
	        if (!this.trackEvents) {
	            return;
	        }
	
	        var swipeLocked = this.popoverStateMachine.isPopoverVisible();
	        var swipeEnabled = this.swipeEnabled && !swipeLocked;
	
	        var _coordsForEvent2 = coordsForEvent(evt),
	            x = _coordsForEvent2[0],
	            y = _coordsForEvent2[1];
	
	        for (var i = 0; i < evt.changedTouches.length; i++) {
	            this.gestureStateMachine.onTouchMove(function () {
	                return _this2.nodeManager.idForCoords(x, y);
	            }, evt.changedTouches[i].identifier, x, swipeEnabled);
	        }
	    };
	
	    /**
	     * Handle a touch-end event that originated in a node registered with the
	     * gesture system.
	     *
	     * @param {TouchEvent} evt - the raw touch event from the browser
	     */
	
	
	    GestureManager.prototype.onTouchEnd = function onTouchEnd(evt) {
	        var _this3 = this;
	
	        if (!this.trackEvents) {
	            return;
	        }
	
	        var _coordsForEvent3 = coordsForEvent(evt),
	            x = _coordsForEvent3[0],
	            y = _coordsForEvent3[1];
	
	        for (var i = 0; i < evt.changedTouches.length; i++) {
	            this.gestureStateMachine.onTouchEnd(function () {
	                return _this3.nodeManager.idForCoords(x, y);
	            }, evt.changedTouches[i].identifier, x);
	        }
	    };
	
	    /**
	     * Handle a touch-cancel event that originated in a node registered with the
	     * gesture system.
	     *
	     * @param {TouchEvent} evt - the raw touch event from the browser
	     */
	
	
	    GestureManager.prototype.onTouchCancel = function onTouchCancel(evt) {
	        if (!this.trackEvents) {
	            return;
	        }
	
	        for (var i = 0; i < evt.changedTouches.length; i++) {
	            this.gestureStateMachine.onTouchCancel(evt.changedTouches[i].identifier);
	        }
	    };
	
	    /**
	     * Register a DOM node with a given identifier.
	     *
	     * @param {string} id - the identifier of the given node
	     * @param {node} domNode - the DOM node linked to the identifier
	     * @param {string[]} childIds - the identifiers of any DOM nodes that
	     *                              should be considered children of this node,
	     *                              in that they should take priority when
	     *                              intercepting touch events
	     * @param {object} borders - an opaque object describing the node's borders
	     */
	
	
	    GestureManager.prototype.registerDOMNode = function registerDOMNode(id, domNode, childIds, borders) {
	        this.nodeManager.registerDOMNode(id, domNode, childIds, borders);
	        this.popoverStateMachine.registerPopover(id, childIds);
	    };
	
	    /**
	     * Unregister the DOM node with the given identifier.
	     *
	     * @param {string} id - the identifier of the node to unregister
	     */
	
	
	    GestureManager.prototype.unregisterDOMNode = function unregisterDOMNode(id) {
	        this.nodeManager.unregisterDOMNode(id);
	        this.popoverStateMachine.unregisterPopover(id);
	    };
	
	    /**
	     * Enable event tracking for the gesture manager.
	     */
	
	
	    GestureManager.prototype.enableEventTracking = function enableEventTracking() {
	        this.trackEvents = true;
	    };
	
	    /**
	     * Disable event tracking for the gesture manager. When called, the gesture
	     * manager will drop any events received by managed nodes.
	     */
	
	
	    GestureManager.prototype.disableEventTracking = function disableEventTracking() {
	        this.trackEvents = false;
	    };
	
	    return GestureManager;
	}();
	
	module.exports = GestureManager;

/***/ },
/* 406 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * A system for tracking gesture velocity in a single dimension.
	 *
	 * Velocity is computed by smoothing linearly over the gestures that have
	 * occurred in the last 100 milliseconds.
	 */
	
	var now = __webpack_require__(519);
	
	var VelocityTracker = function () {
	    function VelocityTracker(options) {
	        _classCallCheck(this, VelocityTracker);
	
	        this.options = _extends({
	            velocityTimeout: 100
	        }, options);
	        this._events = [];
	    }
	
	    /**
	     * Pushes an event with the given displacement onto the event buffer,
	     * associating it with a timestamp. Note that, as this method computes the
	     * timestamp for the event at calltime, it should be called immediately
	     * after the event occurs.
	     *
	     * @param {number} x - the cumulative displacement of the event
	     */
	
	
	    VelocityTracker.prototype.push = function push(x) {
	        this._events.push({
	            x: x,
	            t: now()
	        });
	    };
	
	    /**
	     * Compute the velocity with respect to the events that have been tracked
	     * by the system. Velocity is computed by smoothing linearly over recent
	     * displacement values.
	     *
	     * Note that, for performance reasons, a call to `getVelocity` will clear
	     * out the event buffer. As such, repeated calls will not return the same
	     * value (in particular, a second call in quick succession will return 0).
	     *
	     * @returns {number} the velocity associated with the tracker
	     */
	
	
	    VelocityTracker.prototype.getVelocity = function getVelocity() {
	        var events = this._getEvents();
	
	        if (events.length < 2) {
	            return 0;
	        } else {
	            var current = events[events.length - 1];
	            var first = events[0];
	            var dt = current.t - first.t;
	            return (current.x - first.x) / dt;
	        }
	    };
	
	    /**
	     * Filter the tracked events to exclude any events that occurred too far in
	     * the past, and reset the event buffer.
	     *
	     * @returns {number[]} an array of displacements corresponding to events
	     *                     that occurred in the past `velocityTimeout`
	     *                     milliseconds
	     */
	
	
	    VelocityTracker.prototype._getEvents = function _getEvents() {
	        var threshold = now() - this.options.velocityTimeout;
	        var recentEvents = this._events.filter(function (event) {
	            return event.t > threshold;
	        });
	        this._events = [];
	        return recentEvents;
	    };
	
	    return VelocityTracker;
	}();
	
	module.exports = VelocityTracker;

/***/ },
/* 407 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorCompositionHandler
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(329);
	var EditorState = __webpack_require__(332);
	var Keys = __webpack_require__(434);
	
	var getEntityKeyForSelection = __webpack_require__(451);
	var isSelectionAtLeafStart = __webpack_require__(452);
	
	/**
	 * Millisecond delay to allow `compositionstart` to fire again upon
	 * `compositionend`.
	 *
	 * This is used for Korean input to ensure that typing can continue without
	 * the editor trying to render too quickly. More specifically, Safari 7.1+
	 * triggers `compositionstart` a little slower than Chrome/FF, which
	 * leads to composed characters being resolved and re-render occurring
	 * sooner than we want.
	 */
	var RESOLVE_DELAY = 20;
	
	/**
	 * A handful of variables used to track the current composition and its
	 * resolution status. These exist at the module level because it is not
	 * possible to have compositions occurring in multiple editors simultaneously,
	 * and it simplifies state management with respect to the DraftEditor component.
	 */
	var resolved = false;
	var stillComposing = false;
	var textInputData = '';
	
	var DraftEditorCompositionHandler = {
	  onBeforeInput: function onBeforeInput(e) {
	    textInputData = (textInputData || '') + e.data;
	  },
	
	  /**
	   * A `compositionstart` event has fired while we're still in composition
	   * mode. Continue the current composition session to prevent a re-render.
	   */
	  onCompositionStart: function onCompositionStart() {
	    stillComposing = true;
	  },
	
	  /**
	   * Attempt to end the current composition session.
	   *
	   * Defer handling because browser will still insert the chars into active
	   * element after `compositionend`. If a `compositionstart` event fires
	   * before `resolveComposition` executes, our composition session will
	   * continue.
	   *
	   * The `resolved` flag is useful because certain IME interfaces fire the
	   * `compositionend` event multiple times, thus queueing up multiple attempts
	   * at handling the composition. Since handling the same composition event
	   * twice could break the DOM, we only use the first event. Example: Arabic
	   * Google Input Tools on Windows 8.1 fires `compositionend` three times.
	   */
	  onCompositionEnd: function onCompositionEnd() {
	    var _this = this;
	
	    resolved = false;
	    stillComposing = false;
	    setTimeout(function () {
	      if (!resolved) {
	        DraftEditorCompositionHandler.resolveComposition.call(_this);
	      }
	    }, RESOLVE_DELAY);
	  },
	
	  /**
	   * In Safari, keydown events may fire when committing compositions. If
	   * the arrow keys are used to commit, prevent default so that the cursor
	   * doesn't move, otherwise it will jump back noticeably on re-render.
	   */
	  onKeyDown: function onKeyDown(e) {
	    if (e.which === Keys.RIGHT || e.which === Keys.LEFT) {
	      e.preventDefault();
	    }
	  },
	
	  /**
	   * Keypress events may fire when committing compositions. In Firefox,
	   * pressing RETURN commits the composition and inserts extra newline
	   * characters that we do not want. `preventDefault` allows the composition
	   * to be committed while preventing the extra characters.
	   */
	  onKeyPress: function onKeyPress(e) {
	    if (e.which === Keys.RETURN) {
	      e.preventDefault();
	    }
	  },
	
	  /**
	   * Attempt to insert composed characters into the document.
	   *
	   * If we are still in a composition session, do nothing. Otherwise, insert
	   * the characters into the document and terminate the composition session.
	   *
	   * If no characters were composed -- for instance, the user
	   * deleted all composed characters and committed nothing new --
	   * force a re-render. We also re-render when the composition occurs
	   * at the beginning of a leaf, to ensure that if the browser has
	   * created a new text node for the composition, we will discard it.
	   *
	   * Resetting innerHTML will move focus to the beginning of the editor,
	   * so we update to force it back to the correct place.
	   */
	  resolveComposition: function resolveComposition() {
	    if (stillComposing) {
	      return;
	    }
	
	    resolved = true;
	    var composedChars = textInputData;
	    textInputData = '';
	
	    var editorState = EditorState.set(this.props.editorState, {
	      inCompositionMode: false
	    });
	
	    var currentStyle = editorState.getCurrentInlineStyle();
	    var entityKey = getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection());
	
	    var mustReset = !composedChars || isSelectionAtLeafStart(editorState) || currentStyle.size > 0 || entityKey !== null;
	
	    if (mustReset) {
	      this.restoreEditorDOM();
	    }
	
	    this.exitCurrentMode();
	    this.removeRenderGuard();
	
	    if (composedChars) {
	      // If characters have been composed, re-rendering with the update
	      // is sufficient to reset the editor.
	      var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), composedChars, currentStyle, entityKey);
	      this.update(EditorState.push(editorState, contentState, 'insert-characters'));
	      return;
	    }
	
	    if (mustReset) {
	      this.update(EditorState.set(editorState, {
	        nativelyRenderedContent: null,
	        forceSelection: true
	      }));
	    }
	  }
	};
	
	module.exports = DraftEditorCompositionHandler;

/***/ },
/* 408 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorContents.react
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var DraftEditorBlock = __webpack_require__(328);
	var DraftOffsetKey = __webpack_require__(399);
	var EditorState = __webpack_require__(332);
	var React = __webpack_require__(43);
	
	var cx = __webpack_require__(431);
	var joinClasses = __webpack_require__(473);
	var nullthrows = __webpack_require__(442);
	
	/**
	 * `DraftEditorContents` is the container component for all block components
	 * rendered for a `DraftEditor`. It is optimized to aggressively avoid
	 * re-rendering blocks whenever possible.
	 *
	 * This component is separate from `DraftEditor` because certain props
	 * (for instance, ARIA props) must be allowed to update without affecting
	 * the contents of the editor.
	 */
	
	var DraftEditorContents = (function (_React$Component) {
	  _inherits(DraftEditorContents, _React$Component);
	
	  function DraftEditorContents() {
	    _classCallCheck(this, DraftEditorContents);
	
	    _get(Object.getPrototypeOf(DraftEditorContents.prototype), 'constructor', this).apply(this, arguments);
	  }
	
	  /**
	   * Provide default styling for list items. This way, lists will be styled with
	   * proper counters and indentation even if the caller does not specify
	   * their own styling at all. If more than five levels of nesting are needed,
	   * the necessary CSS classes can be provided via `blockStyleFn` configuration.
	   */
	
	  _createClass(DraftEditorContents, [{
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate(nextProps) {
	      var prevEditorState = this.props.editorState;
	      var nextEditorState = nextProps.editorState;
	
	      var prevDirectionMap = prevEditorState.getDirectionMap();
	      var nextDirectionMap = nextEditorState.getDirectionMap();
	
	      // Text direction has changed for one or more blocks. We must re-render.
	      if (prevDirectionMap !== nextDirectionMap) {
	        return true;
	      }
	
	      var didHaveFocus = prevEditorState.getSelection().getHasFocus();
	      var nowHasFocus = nextEditorState.getSelection().getHasFocus();
	
	      if (didHaveFocus !== nowHasFocus) {
	        return true;
	      }
	
	      var nextNativeContent = nextEditorState.getNativelyRenderedContent();
	
	      var wasComposing = prevEditorState.isInCompositionMode();
	      var nowComposing = nextEditorState.isInCompositionMode();
	
	      // If the state is unchanged or we're currently rendering a natively
	      // rendered state, there's nothing new to be done.
	      if (prevEditorState === nextEditorState || nextNativeContent !== null && nextEditorState.getCurrentContent() === nextNativeContent || wasComposing && nowComposing) {
	        return false;
	      }
	
	      var prevContent = prevEditorState.getCurrentContent();
	      var nextContent = nextEditorState.getCurrentContent();
	      var prevDecorator = prevEditorState.getDecorator();
	      var nextDecorator = nextEditorState.getDecorator();
	      return wasComposing !== nowComposing || prevContent !== nextContent || prevDecorator !== nextDecorator || nextEditorState.mustForceSelection();
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var _props = this.props;
	      var blockRenderMap = _props.blockRenderMap;
	      var blockRendererFn = _props.blockRendererFn;
	      var customStyleMap = _props.customStyleMap;
	      var editorState = _props.editorState;
	
	      var content = editorState.getCurrentContent();
	      var selection = editorState.getSelection();
	      var forceSelection = editorState.mustForceSelection();
	      var decorator = editorState.getDecorator();
	      var directionMap = nullthrows(editorState.getDirectionMap());
	
	      var blocksAsArray = content.getBlocksAsArray();
	      var blocks = [];
	      var currentWrapperElement = null;
	      var currentWrapperTemplate = null;
	      var currentDepth = null;
	      var currentWrappedBlocks = undefined;
	      var block = undefined,
	          key = undefined,
	          blockType = undefined,
	          child = undefined,
	          childProps = undefined,
	          wrapperTemplate = undefined;
	
	      for (var ii = 0; ii < blocksAsArray.length; ii++) {
	        block = blocksAsArray[ii];
	        key = block.getKey();
	        blockType = block.getType();
	
	        var customRenderer = blockRendererFn(block);
	        var CustomComponent = undefined,
	            customProps = undefined,
	            customEditable = undefined;
	        if (customRenderer) {
	          CustomComponent = customRenderer.component;
	          customProps = customRenderer.props;
	          customEditable = customRenderer.editable;
	        }
	
	        var direction = directionMap.get(key);
	        var offsetKey = DraftOffsetKey.encode(key, 0, 0);
	        var componentProps = {
	          block: block,
	          blockProps: customProps,
	          customStyleMap: customStyleMap,
	          decorator: decorator,
	          direction: direction,
	          forceSelection: forceSelection,
	          key: key,
	          offsetKey: offsetKey,
	          selection: selection,
	          tree: editorState.getBlockTree(key)
	        };
	
	        // Block render map must have a configuration specified for this
	        // block type.
	        var configForType = nullthrows(blockRenderMap.get(blockType));
	
	        wrapperTemplate = configForType.wrapper;
	
	        var useNewWrapper = wrapperTemplate !== currentWrapperTemplate;
	
	        var _Element = blockRenderMap.get(blockType).element || blockRenderMap.get('unstyled').element;
	
	        var depth = block.getDepth();
	        var className = this.props.blockStyleFn(block);
	
	        // List items are special snowflakes, since we handle nesting and
	        // counters manually.
	        if (_Element === 'li') {
	          var shouldResetCount = useNewWrapper || currentDepth === null || depth > currentDepth;
	          className = joinClasses(className, getListItemClasses(blockType, depth, shouldResetCount, direction));
	        }
	
	        var Component = CustomComponent || DraftEditorBlock;
	        childProps = {
	          className: className,
	          'data-block': true,
	          'data-editor': this.props.editorKey,
	          'data-offset-key': offsetKey,
	          key: key
	        };
	        if (customEditable !== undefined) {
	          childProps = _extends({}, childProps, {
	            contentEditable: customEditable,
	            suppressContentEditableWarning: true
	          });
	        }
	
	        child = React.createElement(_Element, childProps, React.createElement(Component, componentProps));
	
	        if (wrapperTemplate) {
	          if (useNewWrapper) {
	            currentWrappedBlocks = [];
	            currentWrapperElement = React.cloneElement(wrapperTemplate, {
	              key: key + '-wrap',
	              'data-offset-key': offsetKey
	            }, currentWrappedBlocks);
	            currentWrapperTemplate = wrapperTemplate;
	            blocks.push(currentWrapperElement);
	          }
	          currentDepth = block.getDepth();
	          nullthrows(currentWrappedBlocks).push(child);
	        } else {
	          currentWrappedBlocks = null;
	          currentWrapperElement = null;
	          currentWrapperTemplate = null;
	          currentDepth = null;
	          blocks.push(child);
	        }
	      }
	
	      return React.createElement(
	        'div',
	        { 'data-contents': 'true' },
	        blocks
	      );
	    }
	  }]);
	
	  return DraftEditorContents;
	})(React.Component);
	
	function getListItemClasses(type, depth, shouldResetCount, direction) {
	  return cx({
	    'public/DraftStyleDefault/unorderedListItem': type === 'unordered-list-item',
	    'public/DraftStyleDefault/orderedListItem': type === 'ordered-list-item',
	    'public/DraftStyleDefault/reset': shouldResetCount,
	    'public/DraftStyleDefault/depth0': depth === 0,
	    'public/DraftStyleDefault/depth1': depth === 1,
	    'public/DraftStyleDefault/depth2': depth === 2,
	    'public/DraftStyleDefault/depth3': depth === 3,
	    'public/DraftStyleDefault/depth4': depth === 4,
	    'public/DraftStyleDefault/listLTR': direction === 'LTR',
	    'public/DraftStyleDefault/listRTL': direction === 'RTL'
	  });
	}
	
	module.exports = DraftEditorContents;

/***/ },
/* 409 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorDragHandler
	 * @typechecks
	 * 
	 */
	
	/**
	 * Get a SelectionState for the supplied mouse event.
	 */
	'use strict';
	
	var DataTransfer = __webpack_require__(453);
	var DraftModifier = __webpack_require__(329);
	var EditorState = __webpack_require__(332);
	
	var findAncestorOffsetKey = __webpack_require__(454);
	var getTextContentFromFiles = __webpack_require__(455);
	var getUpdatedSelectionState = __webpack_require__(456);
	var nullthrows = __webpack_require__(442);
	
	function getSelectionForEvent(event, editorState) {
	  var node = null;
	  var offset = null;
	
	  if (document.caretRangeFromPoint) {
	    var dropRange = document.caretRangeFromPoint(event.x, event.y);
	    node = dropRange.startContainer;
	    offset = dropRange.startOffset;
	  } else if (event.rangeParent) {
	    node = event.rangeParent;
	    offset = event.rangeOffset;
	  } else {
	    return null;
	  }
	
	  node = nullthrows(node);
	  offset = nullthrows(offset);
	  var offsetKey = nullthrows(findAncestorOffsetKey(node));
	
	  return getUpdatedSelectionState(editorState, offsetKey, offset, offsetKey, offset);
	}
	
	var DraftEditorDragHandler = {
	  /**
	   * Drag originating from input terminated.
	   */
	  onDragEnd: function onDragEnd() {
	    this.exitCurrentMode();
	  },
	
	  /**
	   * Handle data being dropped.
	   */
	  onDrop: function onDrop(e) {
	    var _this = this;
	
	    var data = new DataTransfer(e.nativeEvent.dataTransfer);
	
	    var editorState = this.props.editorState;
	    var dropSelection = getSelectionForEvent(e.nativeEvent, editorState);
	
	    e.preventDefault();
	    this.exitCurrentMode();
	
	    if (dropSelection == null) {
	      return;
	    }
	
	    var files = data.getFiles();
	    if (files.length > 0) {
	      if (this.props.handleDroppedFiles && this.props.handleDroppedFiles(dropSelection, files)) {
	        return;
	      }
	
	      getTextContentFromFiles(files, function (fileText) {
	        fileText && _this.update(insertTextAtSelection(editorState, nullthrows(dropSelection), // flow wtf
	        fileText));
	      });
	      return;
	    }
	
	    var dragType = this._internalDrag ? 'internal' : 'external';
	    if (this.props.handleDrop && this.props.handleDrop(dropSelection, data, dragType)) {
	      return;
	    }
	
	    if (this._internalDrag) {
	      this.update(moveText(editorState, dropSelection));
	      return;
	    }
	
	    this.update(insertTextAtSelection(editorState, dropSelection, data.getText()));
	  }
	
	};
	
	function moveText(editorState, targetSelection) {
	  var newContentState = DraftModifier.moveText(editorState.getCurrentContent(), editorState.getSelection(), targetSelection);
	  return EditorState.push(editorState, newContentState, 'insert-fragment');
	}
	
	/**
	 * Insert text at a specified selection.
	 */
	function insertTextAtSelection(editorState, selection, text) {
	  var newContentState = DraftModifier.insertText(editorState.getCurrentContent(), selection, text, editorState.getCurrentInlineStyle());
	  return EditorState.push(editorState, newContentState, 'insert-fragment');
	}
	
	module.exports = DraftEditorDragHandler;

/***/ },
/* 410 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorEditHandler
	 * 
	 */
	
	'use strict';
	
	var onBeforeInput = __webpack_require__(457);
	var onBlur = __webpack_require__(458);
	var onCompositionStart = __webpack_require__(459);
	var onCopy = __webpack_require__(460);
	var onCut = __webpack_require__(461);
	var onDragOver = __webpack_require__(462);
	var onDragStart = __webpack_require__(463);
	var onFocus = __webpack_require__(464);
	var onInput = __webpack_require__(465);
	var onKeyDown = __webpack_require__(466);
	var onPaste = __webpack_require__(467);
	var onSelect = __webpack_require__(468);
	
	var DraftEditorEditHandler = {
	  onBeforeInput: onBeforeInput,
	  onBlur: onBlur,
	  onCompositionStart: onCompositionStart,
	  onCopy: onCopy,
	  onCut: onCut,
	  onDragOver: onDragOver,
	  onDragStart: onDragStart,
	  onFocus: onFocus,
	  onInput: onInput,
	  onKeyDown: onKeyDown,
	  onPaste: onPaste,
	  onSelect: onSelect
	};
	
	module.exports = DraftEditorEditHandler;

/***/ },
/* 411 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorPlaceholder.react
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var React = __webpack_require__(43);
	
	var cx = __webpack_require__(431);
	
	/**
	 * This component is responsible for rendering placeholder text for the
	 * `DraftEditor` component.
	 *
	 * Override placeholder style via CSS.
	 */
	
	var DraftEditorPlaceholder = (function (_React$Component) {
	  _inherits(DraftEditorPlaceholder, _React$Component);
	
	  function DraftEditorPlaceholder() {
	    _classCallCheck(this, DraftEditorPlaceholder);
	
	    _get(Object.getPrototypeOf(DraftEditorPlaceholder.prototype), 'constructor', this).apply(this, arguments);
	  }
	
	  _createClass(DraftEditorPlaceholder, [{
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate(nextProps) {
	      return this.props.text !== nextProps.text || this.props.editorState.getSelection().getHasFocus() !== nextProps.editorState.getSelection().getHasFocus();
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      var hasFocus = this.props.editorState.getSelection().getHasFocus();
	
	      var className = cx({
	        'public/DraftEditorPlaceholder/root': true,
	        'public/DraftEditorPlaceholder/hasFocus': hasFocus
	      });
	
	      return React.createElement(
	        'div',
	        { className: className },
	        React.createElement(
	          'div',
	          {
	            className: cx('public/DraftEditorPlaceholder/inner'),
	            id: this.props.accessibilityID },
	          this.props.text
	        )
	      );
	    }
	  }]);
	
	  return DraftEditorPlaceholder;
	})(React.Component);
	
	module.exports = DraftEditorPlaceholder;

/***/ },
/* 412 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule BlockTree
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(346);
	
	var emptyFunction = __webpack_require__(444);
	var findRangesImmutable = __webpack_require__(376);
	
	var List = Immutable.List;
	var Repeat = Immutable.Repeat;
	var Record = Immutable.Record;
	
	var returnTrue = emptyFunction.thatReturnsTrue;
	
	var FINGERPRINT_DELIMITER = '-';
	
	var defaultLeafRange = {
	  start: null,
	  end: null
	};
	
	var LeafRange = Record(defaultLeafRange);
	
	var defaultDecoratorRange = {
	  start: null,
	  end: null,
	  decoratorKey: null,
	  leaves: null
	};
	
	var DecoratorRange = Record(defaultDecoratorRange);
	
	var BlockTree = {
	  /**
	   * Generate a block tree for a given ContentBlock/decorator pair.
	   */
	  generate: function generate(block, decorator) {
	    var textLength = block.getLength();
	    if (!textLength) {
	      return List.of(new DecoratorRange({
	        start: 0,
	        end: 0,
	        decoratorKey: null,
	        leaves: List.of(new LeafRange({ start: 0, end: 0 }))
	      }));
	    }
	
	    var leafSets = [];
	    var decorations = decorator ? decorator.getDecorations(block) : List(Repeat(null, textLength));
	
	    var chars = block.getCharacterList();
	
	    findRangesImmutable(decorations, areEqual, returnTrue, function (start, end) {
	      leafSets.push(new DecoratorRange({
	        start: start,
	        end: end,
	        decoratorKey: decorations.get(start),
	        leaves: generateLeaves(chars.slice(start, end).toList(), start)
	      }));
	    });
	
	    return List(leafSets);
	  },
	
	  /**
	   * Create a string representation of the given tree map. This allows us
	   * to rapidly determine whether a tree has undergone a significant
	   * structural change.
	   */
	  getFingerprint: function getFingerprint(tree) {
	    return tree.map(function (leafSet) {
	      var decoratorKey = leafSet.get('decoratorKey');
	      var fingerprintString = decoratorKey !== null ? decoratorKey + '.' + (leafSet.get('end') - leafSet.get('start')) : '';
	      return '' + fingerprintString + '.' + leafSet.get('leaves').size;
	    }).join(FINGERPRINT_DELIMITER);
	  }
	};
	
	/**
	 * Generate LeafRange records for a given character list.
	 */
	function generateLeaves(characters, offset) {
	  var leaves = [];
	  var inlineStyles = characters.map(function (c) {
	    return c.getStyle();
	  }).toList();
	  findRangesImmutable(inlineStyles, areEqual, returnTrue, function (start, end) {
	    leaves.push(new LeafRange({
	      start: start + offset,
	      end: end + offset
	    }));
	  });
	  return List(leaves);
	}
	
	function areEqual(a, b) {
	  return a === b;
	}
	
	module.exports = BlockTree;

/***/ },
/* 413 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule EditorBidiService
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var Immutable = __webpack_require__(346);
	var UnicodeBidiService = __webpack_require__(469);
	
	var nullthrows = __webpack_require__(442);
	
	var OrderedMap = Immutable.OrderedMap;
	
	var bidiService;
	
	var EditorBidiService = {
	  getDirectionMap: function getDirectionMap(content, prevBidiMap) {
	    if (!bidiService) {
	      bidiService = new UnicodeBidiService();
	    } else {
	      bidiService.reset();
	    }
	
	    var blockMap = content.getBlockMap();
	    var nextBidi = blockMap.valueSeq().map(function (block) {
	      return nullthrows(bidiService).getDirection(block.getText());
	    });
	    var bidiMap = OrderedMap(blockMap.keySeq().zip(nextBidi));
	
	    if (prevBidiMap != null && Immutable.is(prevBidiMap, bidiMap)) {
	      return prevBidiMap;
	    }
	
	    return bidiMap;
	  }
	};
	
	module.exports = EditorBidiService;

/***/ },
/* 414 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	    value: true
	});
	
	var _slicedToArray = function () {
	    function sliceIterator(arr, i) {
	        var _arr = [];var _n = true;var _d = false;var _e = undefined;try {
	            for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
	                _arr.push(_s.value);if (i && _arr.length === i) break;
	            }
	        } catch (err) {
	            _d = true;_e = err;
	        } finally {
	            try {
	                if (!_n && _i['return']) _i['return']();
	            } finally {
	                if (_d) throw _e;
	            }
	        }return _arr;
	    }return function (arr, i) {
	        if (Array.isArray(arr)) {
	            return arr;
	        } else if (Symbol.iterator in Object(arr)) {
	            return sliceIterator(arr, i);
	        } else {
	            throw new TypeError('Invalid attempt to destructure non-iterable instance');
	        }
	    };
	}();
	
	var _util = __webpack_require__(471);
	
	var _inject = __webpack_require__(472);
	
	var StyleSheet = {
	    create: function create(sheetDefinition) {
	        return (0, _util.mapObj)(sheetDefinition, function (_ref) {
	            var _ref2 = _slicedToArray(_ref, 2);
	
	            var key = _ref2[0];
	            var val = _ref2[1];
	
	            return [key, {
	                // TODO(emily): Make a 'production' mode which doesn't prepend
	                // the class name here, to make the generated CSS smaller.
	                _name: key + '_' + (0, _util.hashObject)(val),
	                _definition: val
	            }];
	        });
	    },
	
	    rehydrate: function rehydrate() {
	        var renderedClassNames = arguments.length <= 0 || arguments[0] === undefined ? [] : arguments[0];
	
	        (0, _inject.addRenderedClassNames)(renderedClassNames);
	    }
	};
	
	var StyleSheetServer = {
	    renderStatic: function renderStatic(renderFunc) {
	        (0, _inject.reset)();
	        (0, _inject.startBuffering)();
	        var html = renderFunc();
	        var cssContent = (0, _inject.flushToString)();
	
	        return {
	            html: html,
	            css: {
	                content: cssContent,
	                renderedClassNames: (0, _inject.getRenderedClassNames)()
	            }
	        };
	    }
	};
	
	var css = function css() {
	    for (var _len = arguments.length, styleDefinitions = Array(_len), _key = 0; _key < _len; _key++) {
	        styleDefinitions[_key] = arguments[_key];
	    }
	
	    // Filter out falsy values from the input, to allow for
	    // `css(a, test && c)`
	    var validDefinitions = styleDefinitions.filter(function (def) {
	        return def;
	    });
	
	    // Break if there aren't any valid styles.
	    if (validDefinitions.length === 0) {
	        return "";
	    }
	
	    var className = validDefinitions.map(function (s) {
	        return s._name;
	    }).join("-o_O-");
	    (0, _inject.injectStyleOnce)(className, '.' + className, validDefinitions.map(function (d) {
	        return d._definition;
	    }));
	
	    return className;
	};
	
	exports['default'] = {
	    StyleSheet: StyleSheet,
	    StyleSheetServer: StyleSheetServer,
	    css: css
	};
	module.exports = exports['default'];

/***/ },
/* 415 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var Text = function (_React$Component) {
	    _inherits(Text, _React$Component);
	
	    function Text() {
	        _classCallCheck(this, Text);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Text.prototype.render = function render() {
	        var _props = this.props,
	            numberOfLines = _props.numberOfLines,
	            style = _props.style;
	
	
	        var className = css.apply(undefined, [styles.initial].concat(Array.isArray(style) ? style : [style], [numberOfLines === 1 && styles.singleLineStyle]));
	
	        return React.createElement(
	            'span',
	            { className: className, style: this.props.dynamicStyle },
	            this.props.children
	        );
	    };
	
	    return Text;
	}(React.Component);
	
	// https://github.com/necolas/react-native-web/blob/master/src/components/Text/index.js
	
	
	Text.propTypes = {
	    children: React.PropTypes.oneOfType([React.PropTypes.arrayOf(React.PropTypes.node), React.PropTypes.node]),
	    // The `dynamicStyle` prop is provided for animating dynamic
	    // properties, as creating Aphrodite StyleSheets in animation loops is
	    // expensive. `dynamicStyle` should be a raw style object, rather than
	    // a StyleSheet.
	    dynamicStyle: React.PropTypes.any,
	    numberOfLines: React.PropTypes.number,
	    style: React.PropTypes.any
	};
	var styles = StyleSheet.create({
	    initial: {
	        color: 'inherit',
	        display: 'inline',
	        font: 'inherit',
	        margin: 0,
	        padding: 0,
	        textDecorationLine: 'none',
	        wordWrap: 'break-word'
	    },
	    singleLineStyle: {
	        maxWidth: '100%',
	        overflow: 'hidden',
	        textOverflow: 'ellipsis',
	        whiteSpace: 'nowrap'
	    }
	});
	
	module.exports = Text;

/***/ },
/* 416 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet,
	    css = _require.css;
	
	var View = function (_React$Component) {
	    _inherits(View, _React$Component);
	
	    function View() {
	        _classCallCheck(this, View);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    View.prototype.render = function render() {
	        var className = css.apply(undefined, [View.styles.initial].concat(Array.isArray(this.props.style) ? this.props.style : [this.props.style])) + (this.props.extraClassName ? ' ' + this.props.extraClassName : "");
	
	        return React.createElement(
	            'div',
	            {
	                className: className,
	                style: this.props.dynamicStyle,
	                onClick: this.props.onClick,
	                onTouchCancel: this.props.onTouchCancel,
	                onTouchEnd: this.props.onTouchEnd,
	                onTouchMove: this.props.onTouchMove,
	                onTouchStart: this.props.onTouchStart,
	                'aria-label': this.props.ariaLabel,
	                role: this.props.role
	            },
	            this.props.children
	        );
	    };
	
	    return View;
	}(React.Component);
	
	View.propTypes = {
	    ariaLabel: React.PropTypes.string,
	    children: React.PropTypes.oneOfType([React.PropTypes.arrayOf(React.PropTypes.node), React.PropTypes.node]),
	    // The `dynamicStyle` prop is provided for animating dynamic
	    // properties, as creating Aphrodite StyleSheets in animation loops is
	    // expensive. `dynamicStyle` should be a raw style object, rather than
	    // a StyleSheet.
	    dynamicStyle: React.PropTypes.any,
	    // The `extraClassName` prop should almost never be used. It gives the
	    // client a way to provide an additional CSS class name, to augment
	    // the class name generated by Aphrodite. (Right now, it's only used to
	    // disable some externally-applied CSS that would otherwise be far too
	    // difficult to override with inline styles.)
	    extraClassName: React.PropTypes.string,
	    numberOfLines: React.PropTypes.number,
	    onClick: React.PropTypes.func,
	    onTouchCancel: React.PropTypes.func,
	    onTouchEnd: React.PropTypes.func,
	    onTouchMove: React.PropTypes.func,
	    onTouchStart: React.PropTypes.func,
	    role: React.PropTypes.string,
	    style: React.PropTypes.any
	};
	View.styles = StyleSheet.create({
	    // From: https://github.com/necolas/react-native-web/blob/master/src/components/View/index.js
	    initial: {
	        alignItems: 'stretch',
	        borderWidth: 0,
	        borderStyle: 'solid',
	        boxSizing: 'border-box',
	        display: 'flex',
	        flexBasis: 'auto',
	        flexDirection: 'column',
	        margin: 0,
	        padding: 0,
	        position: 'relative',
	        // button and anchor reset
	        backgroundColor: 'transparent',
	        color: 'inherit',
	        font: 'inherit',
	        textAlign: 'inherit',
	        textDecorationLine: 'none',
	        // list reset
	        listStyle: 'none',
	        // fix flexbox bugs
	        maxWidth: '100%',
	        minHeight: 0,
	        minWidth: 0
	    }
	});
	
	
	module.exports = View;

/***/ },
/* 417 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A keypad component that acts as a container for rows or columns of buttons,
	 * and manages the rendering of echo animations on top of those buttons.
	 */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var _require = __webpack_require__(397),
	    connect = _require.connect;
	
	var _require2 = __webpack_require__(316),
	    removeEcho = _require2.removeEcho;
	
	var _require3 = __webpack_require__(357),
	    View = _require3.View;
	
	var EchoManager = __webpack_require__(476);
	var PopoverManager = __webpack_require__(477);
	
	var _require4 = __webpack_require__(295),
	    echoPropType = _require4.echoPropType,
	    popoverPropType = _require4.popoverPropType;
	
	var Keypad = function (_React$Component) {
	    _inherits(Keypad, _React$Component);
	
	    function Keypad() {
	        var _temp, _this, _ret;
	
	        _classCallCheck(this, Keypad);
	
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this._computeContainer = function () {
	            var domNode = ReactDOM.findDOMNode(_this);
	            _this._container = domNode.getBoundingClientRect();
	        }, _this._updateSizeAndPosition = function () {
	            // Mark the container for recalculation next time the keypad is
	            // opened.
	            // TODO(charlie): Since we're not recalculating the container
	            // immediately, if you were to resize the page while a popover were
	            // active, you'd likely get unexpected behavior. This seems very
	            // difficult to do and, as such, incredibly unlikely, but we may
	            // want to reconsider the caching here.
	            _this._container = null;
	        }, _this._onResize = function () {
	            // Whenever the page resizes, we need to recompute the container's
	            // bounding box. This is the only time that the bounding box can change.
	
	            // Throttle resize events -- taken from:
	            //    https://developer.mozilla.org/en-US/docs/Web/Events/resize
	            if (_this._resizeTimeout == null) {
	                _this._resizeTimeout = setTimeout(function () {
	                    _this._resizeTimeout = null;
	
	                    if (_this._isMounted) {
	                        _this._updateSizeAndPosition();
	                    }
	                }, 66);
	            }
	        }, _temp), _possibleConstructorReturn(_this, _ret);
	    }
	
	    Keypad.prototype.componentDidMount = function componentDidMount() {
	        this._isMounted = true;
	
	        window.addEventListener("resize", this._onResize);
	        this._updateSizeAndPosition();
	    };
	
	    Keypad.prototype.componentWillReceiveProps = function componentWillReceiveProps(newProps) {
	        if (!this._container && (newProps.popover || newProps.echoes.length)) {
	            this._computeContainer();
	        }
	    };
	
	    Keypad.prototype.componentWillUnmount = function componentWillUnmount() {
	        this._isMounted = false;
	
	        window.removeEventListener("resize", this._onResize);
	    };
	
	    Keypad.prototype.render = function render() {
	        var _this2 = this;
	
	        var _props = this.props,
	            children = _props.children,
	            echoes = _props.echoes,
	            removeEcho = _props.removeEcho,
	            popover = _props.popover,
	            style = _props.style;
	
	        // Translate the echo boxes, as they'll be positioned absolutely to
	        // this relative container.
	
	        var relativeEchoes = echoes.map(function (echo) {
	            var initialBounds = echo.initialBounds,
	                rest = _objectWithoutProperties(echo, ['initialBounds']);
	
	            return _extends({}, rest, {
	                initialBounds: {
	                    top: initialBounds.top - _this2._container.top,
	                    right: initialBounds.right - _this2._container.left,
	                    bottom: initialBounds.bottom - _this2._container.top,
	                    left: initialBounds.left - _this2._container.left,
	                    width: initialBounds.width,
	                    height: initialBounds.height
	                }
	            });
	        });
	
	        // Translate the popover bounds from page-absolute to keypad-relative.
	        // Note that we only need three bounds, since popovers are anchored to
	        // the bottom left corners of the keys over which they appear.
	        var relativePopover = popover && _extends({}, popover, {
	            bounds: {
	                bottom: this._container.height - (popover.bounds.bottom - this._container.top),
	                left: popover.bounds.left - this._container.left,
	                width: popover.bounds.width
	            }
	        });
	
	        return React.createElement(
	            View,
	            { style: style },
	            children,
	            React.createElement(EchoManager, {
	                echoes: relativeEchoes,
	                onAnimationFinish: removeEcho
	            }),
	            React.createElement(PopoverManager, { popover: relativePopover })
	        );
	    };
	
	    return Keypad;
	}(React.Component);
	
	Keypad.propTypes = {
	    // Whether the keypad is active, i.e., whether it should be rendered as
	    // visible or invisible.
	    active: React.PropTypes.bool,
	    children: React.PropTypes.oneOfType([React.PropTypes.arrayOf(React.PropTypes.node), React.PropTypes.node]),
	    echoes: React.PropTypes.arrayOf(echoPropType).isRequired,
	    popover: popoverPropType,
	    removeEcho: React.PropTypes.func.isRequired,
	    style: React.PropTypes.any
	};
	
	
	var mapStateToProps = function mapStateToProps(state) {
	    return _extends({}, state.echoes, {
	        active: state.keypad.active,
	        popover: state.gestures.popover
	    });
	};
	
	var mapDispatchToProps = function mapDispatchToProps(dispatch) {
	    return {
	        removeEcho: function (_removeEcho) {
	            function removeEcho(_x) {
	                return _removeEcho.apply(this, arguments);
	            }
	
	            removeEcho.toString = function () {
	                return _removeEcho.toString();
	            };
	
	            return removeEcho;
	        }(function (animationId) {
	            dispatch(removeEcho(animationId));
	        })
	    };
	};
	
	module.exports = connect(mapStateToProps, mapDispatchToProps)(Keypad);

/***/ },
/* 418 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A touchable wrapper around the base KeypadButton component. This button is
	 * responsible for keeping our button ID system (which will be used to handle
	 * touch events globally) opaque to the KeypadButton.
	 */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var _require = __webpack_require__(397),
	    connect = _require.connect;
	
	var _require2 = __webpack_require__(414),
	    StyleSheet = _require2.StyleSheet;
	
	var KeypadButton = __webpack_require__(475);
	var KeyConfigs = __webpack_require__(315);
	var GestureManager = __webpack_require__(405);
	
	var _require3 = __webpack_require__(295),
	    bordersPropType = _require3.bordersPropType,
	    keyIdPropType = _require3.keyIdPropType;
	
	var _require4 = __webpack_require__(283),
	    KeyTypes = _require4.KeyTypes;
	
	var TouchableKeypadButton = function (_React$Component) {
	    _inherits(TouchableKeypadButton, _React$Component);
	
	    function TouchableKeypadButton() {
	        _classCallCheck(this, TouchableKeypadButton);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    TouchableKeypadButton.prototype.shouldComponentUpdate = function shouldComponentUpdate(newProps) {
	        // We take advantage of a few different properties of our key
	        // configuration system. Namely, we know that the other props flow
	        // directly from the ID, and thus don't need to be checked. If a key has
	        // a custom style, we bail out (this should be rare).
	        return newProps.id !== this.props.id || newProps.gestureManager !== this.props.gestureManager || newProps.focused !== this.props.focused || newProps.disabled !== this.props.disabled || newProps.popoverEnabled !== this.props.popoverEnabled || newProps.type !== this.props.type || !!newProps.style;
	    };
	
	    TouchableKeypadButton.prototype.componentWillUnmount = function componentWillUnmount() {
	        var _props = this.props,
	            gestureManager = _props.gestureManager,
	            id = _props.id;
	
	        gestureManager.unregisterDOMNode(id);
	    };
	
	    TouchableKeypadButton.prototype.render = function render() {
	        var _props2 = this.props,
	            borders = _props2.borders,
	            childKeyIds = _props2.childKeyIds,
	            disabled = _props2.disabled,
	            gestureManager = _props2.gestureManager,
	            id = _props2.id,
	            style = _props2.style,
	            rest = _objectWithoutProperties(_props2, ['borders', 'childKeyIds', 'disabled', 'gestureManager', 'id', 'style']);
	
	        // Only bind the relevant event handlers if the key is enabled.
	
	
	        var eventHandlers = disabled ? {
	            onTouchStart: function onTouchStart(evt) {
	                return evt.preventDefault();
	            }
	        } : {
	            onTouchStart: function onTouchStart(evt) {
	                return gestureManager.onTouchStart(evt, id);
	            },
	            onTouchEnd: function onTouchEnd(evt) {
	                return gestureManager.onTouchEnd(evt);
	            },
	            onTouchMove: function onTouchMove(evt) {
	                return gestureManager.onTouchMove(evt);
	            },
	            onTouchCancel: function onTouchCancel(evt) {
	                return gestureManager.onTouchCancel(evt);
	            }
	        };
	
	        var styleWithAddons = [].concat(Array.isArray(style) ? style : [style], [styles.preventScrolls]);
	
	        return React.createElement(KeypadButton, _extends({
	            ref: function ref(node) {
	                return gestureManager.registerDOMNode(id, ReactDOM.findDOMNode(node), childKeyIds, borders);
	            },
	            borders: borders,
	            disabled: disabled,
	            style: styleWithAddons
	        }, eventHandlers, rest));
	    };
	
	    return TouchableKeypadButton;
	}(React.Component);
	
	TouchableKeypadButton.propTypes = {
	    borders: bordersPropType,
	    childKeyIds: React.PropTypes.arrayOf(keyIdPropType),
	    disabled: React.PropTypes.bool,
	    focused: React.PropTypes.bool,
	    gestureManager: React.PropTypes.instanceOf(GestureManager),
	    id: keyIdPropType.isRequired,
	    popoverEnabled: React.PropTypes.bool,
	    style: React.PropTypes.any,
	    type: React.PropTypes.oneOf(Object.keys(KeyTypes)).isRequired
	};
	
	
	var extractProps = function extractProps(keyConfig) {
	    var ariaLabel = keyConfig.ariaLabel,
	        icon = keyConfig.icon,
	        type = keyConfig.type;
	
	    return { ariaLabel: ariaLabel, icon: icon, type: type };
	};
	
	var mapStateToProps = function mapStateToProps(state, ownProps) {
	    var gestures = state.gestures;
	
	    var keyConfig = ownProps.keyConfig,
	        rest = _objectWithoutProperties(ownProps, ['keyConfig']);
	
	    var id = keyConfig.id,
	        childKeyIds = keyConfig.childKeyIds,
	        type = keyConfig.type;
	
	
	    var childKeys = childKeyIds && childKeyIds.map(function (id) {
	        return KeyConfigs[id];
	    });
	
	    // Override with the default child props, if the key is a multi-symbol key
	    // (but not a many-symbol key, which operates under different rules).
	    var useFirstChildProps = type !== KeyTypes.MANY && childKeys && childKeys.length > 0;
	
	    return _extends({}, rest, {
	        childKeyIds: childKeyIds,
	        gestureManager: gestures.gestureManager,
	        id: id,
	
	        // Add in some gesture state.
	        focused: gestures.focus === id,
	        popoverEnabled: gestures.popover && gestures.popover.parentId === id,
	
	        // Pass down the child keys and any extracted props.
	        childKeys: childKeys
	    }, extractProps(useFirstChildProps ? childKeys[0] : keyConfig));
	};
	
	var styles = StyleSheet.create({
	    preventScrolls: {
	        // Touch events that start in the touchable buttons shouldn't be
	        // allowed to produce page scrolls.
	        touchAction: "none"
	    }
	});
	
	module.exports = connect(mapStateToProps)(TouchableKeypadButton);

/***/ },
/* 419 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	
	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
	
	function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
	
	var _camelToDashCase = __webpack_require__(421);
	
	var _camelToDashCase2 = _interopRequireDefault(_camelToDashCase);
	
	// returns a style object with a single concated prefixed value string
	
	exports['default'] = function (property, value) {
	  var replacer = arguments.length <= 2 || arguments[2] === undefined ? function (prefix, value) {
	    return prefix + value;
	  } : arguments[2];
	  return (function () {
	    return _defineProperty({}, property, ['-webkit-', '-moz-', ''].map(function (prefix) {
	      return replacer(prefix, value);
	    }));
	  })();
	};
	
	module.exports = exports['default'];

/***/ },
/* 420 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	
	exports['default'] = function (value) {
	  if (Array.isArray(value)) value = value.join(',');
	
	  return value.match(/-webkit-|-moz-|-ms-/) !== null;
	};
	
	module.exports = exports['default'];

/***/ },
/* 421 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Converts a camel-case string to a dash-case string
	 * @param {string} str - str that gets converted to dash-case
	 */
	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	
	exports['default'] = function (str) {
	  return str.replace(/([a-z]|^)([A-Z])/g, function (match, p1, p2) {
	    return p1 + '-' + p2.toLowerCase();
	  }).replace('ms-', '-ms-');
	};
	
	module.exports = exports['default'];

/***/ },
/* 422 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule applyEntityToContentBlock
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var CharacterMetadata = __webpack_require__(321);
	
	function applyEntityToContentBlock(contentBlock, start, end, entityKey) {
	  var characterList = contentBlock.getCharacterList();
	  while (start < end) {
	    characterList = characterList.set(start, CharacterMetadata.applyEntity(characterList.get(start), entityKey));
	    start++;
	  }
	  return contentBlock.set('characterList', characterList);
	}
	
	module.exports = applyEntityToContentBlock;

/***/ },
/* 423 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEntitySegments
	 * @typechecks
	 * 
	 */
	
	/**
	 * Identify the range to delete from a segmented entity.
	 *
	 * Rules:
	 *
	 *  Example: 'John F. Kennedy'
	 *
	 *   - Deletion from within any non-whitespace (i.e. ['John', 'F.', 'Kennedy'])
	 *     will return the range of that text.
	 *
	 *       'John F. Kennedy' -> 'John F.'
	 *                  ^
	 *
	 *   - Forward deletion of whitespace will remove the following section:
	 *
	 *       'John F. Kennedy' -> 'John Kennedy'
	 *            ^
	 *
	 *   - Backward deletion of whitespace will remove the previous section:
	 *
	 *       'John F. Kennedy' -> 'F. Kennedy'
	 *            ^
	 */
	'use strict';
	
	var DraftEntitySegments = {
	  getRemovalRange: function getRemovalRange(selectionStart, selectionEnd, text, entityStart, direction) {
	    var segments = text.split(' ');
	    segments = segments.map(function ( /*string*/segment, /*number*/ii) {
	      if (direction === 'forward') {
	        if (ii > 0) {
	          return ' ' + segment;
	        }
	      } else if (ii < segments.length - 1) {
	        return segment + ' ';
	      }
	      return segment;
	    });
	
	    var segmentStart = entityStart;
	    var segmentEnd;
	    var segment;
	    var removalStart = null;
	    var removalEnd = null;
	
	    for (var jj = 0; jj < segments.length; jj++) {
	      segment = segments[jj];
	      segmentEnd = segmentStart + segment.length;
	
	      // Our selection overlaps this segment.
	      if (selectionStart < segmentEnd && segmentStart < selectionEnd) {
	        if (removalStart !== null) {
	          removalEnd = segmentEnd;
	        } else {
	          removalStart = segmentStart;
	          removalEnd = segmentEnd;
	        }
	      } else if (removalStart !== null) {
	        break;
	      }
	
	      segmentStart = segmentEnd;
	    }
	
	    var entityEnd = entityStart + text.length;
	    var atStart = removalStart === entityStart;
	    var atEnd = removalEnd === entityEnd;
	
	    if (!atStart && atEnd || atStart && !atEnd) {
	      if (direction === 'forward') {
	        if (removalEnd !== entityEnd) {
	          removalEnd++;
	        }
	      } else if (removalStart !== entityStart) {
	        removalStart--;
	      }
	    }
	
	    return {
	      start: removalStart,
	      end: removalEnd
	    };
	  }
	};
	
	module.exports = DraftEntitySegments;

/***/ },
/* 424 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getRangesForDraftEntity
	 * @typechecks
	 * 
	 */
	
	/**
	 * Obtain the start and end positions of the range that has the
	 * specified entity applied to it.
	 *
	 * Entity keys are applied only to contiguous stretches of text, so this
	 * method searches for the first instance of the entity key and returns
	 * the subsequent range.
	 */
	'use strict';
	
	var invariant = __webpack_require__(432);
	
	function getRangesForDraftEntity(block, key) {
	  var ranges = [];
	  block.findEntityRanges(function (c) {
	    return c.getEntity() === key;
	  }, function (start, end) {
	    ranges.push({ start: start, end: end });
	  });
	
	  !!!ranges.length ? true ? invariant(false, 'Entity key not found in this range.') : invariant(false) : undefined;
	
	  return ranges;
	}
	
	module.exports = getRangesForDraftEntity;

/***/ },
/* 425 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule insertIntoList
	 * 
	 */
	
	/**
	 * Maintain persistence for target list when appending and prepending.
	 */
	'use strict';
	
	function insertIntoList(targetList, toInsert, offset) {
	  if (offset === targetList.count()) {
	    toInsert.forEach(function (c) {
	      targetList = targetList.push(c);
	    });
	  } else if (offset === 0) {
	    toInsert.reverse().forEach(function (c) {
	      targetList = targetList.unshift(c);
	    });
	  } else {
	    var head = targetList.slice(0, offset);
	    var tail = targetList.slice(offset);
	    targetList = head.concat(toInsert, tail).toList();
	  }
	  return targetList;
	}
	
	module.exports = insertIntoList;

/***/ },
/* 426 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getRangeClientRects
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var UserAgent = __webpack_require__(433);
	
	var invariant = __webpack_require__(432);
	
	var isChrome = UserAgent.isBrowser('Chrome');
	
	// In Chrome, the client rects will include the entire bounds of all nodes that
	// begin (have a start tag) within the selection, even if the selection does
	// not overlap the entire node. To resolve this, we split the range at each
	// start tag and join the client rects together.
	// https://code.google.com/p/chromium/issues/detail?id=324437
	function getRangeClientRectsChrome(range) {
	  var tempRange = range.cloneRange();
	  var clientRects = [];
	
	  for (var ancestor = range.endContainer; ancestor != null; ancestor = ancestor.parentNode) {
	    // If we've climbed up to the common ancestor, we can now use the
	    // original start point and stop climbing the tree.
	    var atCommonAncestor = ancestor === range.commonAncestorContainer;
	    if (atCommonAncestor) {
	      tempRange.setStart(range.startContainer, range.startOffset);
	    } else {
	      tempRange.setStart(tempRange.endContainer, 0);
	    }
	    var rects = Array.from(tempRange.getClientRects());
	    clientRects.push(rects);
	    if (atCommonAncestor) {
	      var _ref;
	
	      clientRects.reverse();
	      return (_ref = []).concat.apply(_ref, clientRects);
	    }
	    tempRange.setEndBefore(ancestor);
	  }
	
	  true ? true ? invariant(false, 'Found an unexpected detached subtree when getting range client rects.') : invariant(false) : undefined;
	}
	
	/**
	 * Like range.getClientRects() but normalizes for browser bugs.
	 */
	var getRangeClientRects = isChrome ? getRangeClientRectsChrome : function (range) {
	  return Array.from(range.getClientRects());
	};
	
	module.exports = getRangeClientRects;

/***/ },
/* 427 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A keypad with two pages of keys.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(397),
	    connect = _require.connect;
	
	var _require2 = __webpack_require__(414),
	    StyleSheet = _require2.StyleSheet;
	
	var Keypad = __webpack_require__(417);
	var ViewPager = __webpack_require__(478);
	var PagerIndicator = __webpack_require__(479);
	
	var _require3 = __webpack_require__(357),
	    View = _require3.View;
	
	var _require4 = __webpack_require__(364),
	    column = _require4.column,
	    row = _require4.row,
	    fullWidth = _require4.fullWidth;
	
	var _require5 = __webpack_require__(355),
	    innerBorderColor = _require5.innerBorderColor,
	    innerBorderStyle = _require5.innerBorderStyle,
	    innerBorderWidthPx = _require5.innerBorderWidthPx,
	    gray85 = _require5.gray85;
	
	var TwoPageKeypad = function (_React$Component) {
	    _inherits(TwoPageKeypad, _React$Component);
	
	    function TwoPageKeypad() {
	        _classCallCheck(this, TwoPageKeypad);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    TwoPageKeypad.prototype.render = function render() {
	        var _props = this.props,
	            currentPage = _props.currentPage,
	            leftPage = _props.leftPage,
	            paginationEnabled = _props.paginationEnabled,
	            rightPage = _props.rightPage;
	
	
	        if (paginationEnabled) {
	            return React.createElement(
	                Keypad,
	                { style: [column, styles.keypad] },
	                React.createElement(PagerIndicator, { numPages: 2, currentPage: currentPage }),
	                React.createElement(
	                    View,
	                    { style: styles.borderTop },
	                    React.createElement(
	                        ViewPager,
	                        null,
	                        leftPage,
	                        rightPage
	                    )
	                )
	            );
	        } else {
	            return React.createElement(
	                Keypad,
	                { style: styles.keypad },
	                React.createElement(
	                    View,
	                    { style: row },
	                    React.createElement(
	                        View,
	                        { style: fullWidth },
	                        leftPage
	                    ),
	                    React.createElement(
	                        View,
	                        { style: [styles.borderLeft, fullWidth] },
	                        rightPage
	                    )
	                )
	            );
	        }
	    };
	
	    return TwoPageKeypad;
	}(React.Component);
	
	TwoPageKeypad.propTypes = {
	    currentPage: React.PropTypes.oneOf([0, 1]).isRequired,
	    leftPage: React.PropTypes.node.isRequired,
	    paginationEnabled: React.PropTypes.bool.isRequired,
	    rightPage: React.PropTypes.node.isRequired
	};
	
	
	var styles = StyleSheet.create({
	    keypad: {
	        // Set the background to light grey, so that when the user drags the
	        // keypad pages past the edges, there's a grey backdrop.
	        backgroundColor: gray85
	    },
	
	    borderTop: {
	        borderTop: innerBorderWidthPx + 'px ' + innerBorderStyle + ' ' + ('' + innerBorderColor)
	    },
	    borderLeft: {
	        borderLeft: innerBorderWidthPx + 'px ' + innerBorderStyle + ' ' + ('' + innerBorderColor),
	        boxSizing: 'content-box'
	    }
	});
	
	var mapStateToProps = function mapStateToProps(state) {
	    return {
	        paginationEnabled: state.layout.paginationEnabled
	    };
	};
	
	module.exports = connect(mapStateToProps)(TwoPageKeypad);

/***/ },
/* 428 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A keypad button that displays an arbitrary number of symbols, with no
	 * 'default' symbol.
	 */
	
	var React = __webpack_require__(43);
	
	var EmptyKeypadButton = __webpack_require__(480);
	var TouchableKeypadButton = __webpack_require__(418);
	
	var Keys = __webpack_require__(395);
	var KeyConfigs = __webpack_require__(315);
	
	var _require = __webpack_require__(283),
	    KeyTypes = _require.KeyTypes;
	
	var _require2 = __webpack_require__(295),
	    keyIdPropType = _require2.keyIdPropType;
	
	var ManyKeypadButton = function (_React$Component) {
	    _inherits(ManyKeypadButton, _React$Component);
	
	    function ManyKeypadButton() {
	        _classCallCheck(this, ManyKeypadButton);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    ManyKeypadButton.prototype.render = function render() {
	        var _props = this.props,
	            keys = _props.keys,
	            rest = _objectWithoutProperties(_props, ['keys']);
	
	        // If we have no extra symbols, render an empty button. If we have just
	        // one, render a standard button. Otherwise, capture them all in a
	        // single button.
	
	
	        if (keys.length === 0) {
	            return React.createElement(EmptyKeypadButton, rest);
	        } else if (keys.length === 1) {
	            var keyConfig = KeyConfigs[keys[0]];
	            return React.createElement(TouchableKeypadButton, _extends({ keyConfig: keyConfig }, rest));
	        } else {
	            var _keyConfig = {
	                id: Keys.MANY,
	                type: KeyTypes.MANY,
	                childKeyIds: keys
	            };
	            return React.createElement(TouchableKeypadButton, _extends({ keyConfig: _keyConfig }, rest));
	        }
	    };
	
	    return ManyKeypadButton;
	}(React.Component);
	
	ManyKeypadButton.propTypes = {
	    keys: React.PropTypes.arrayOf(keyIdPropType).isRequired
	};
	
	
	module.exports = ManyKeypadButton;

/***/ },
/* 429 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftEditorTextNode.react
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	var _get = function get(_x, _x2, _x3) { var _again = true; _function: while (_again) { var object = _x, property = _x2, receiver = _x3; _again = false; if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { _x = parent; _x2 = property; _x3 = receiver; _again = true; desc = parent = undefined; continue _function; } } else if ('value' in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } } };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	var UserAgent = __webpack_require__(433);
	
	// In IE, spans with <br> tags render as two newlines. By rendering a span
	// with only a newline character, we can be sure to render a single line.
	var useNewlineChar = UserAgent.isBrowser('IE <= 11');
	
	/**
	 * Check whether the node should be considered a newline.
	 */
	function isNewline(node) {
	  return useNewlineChar ? node.textContent === '\n' : node.tagName === 'BR';
	}
	
	/**
	 * Placeholder elements for empty text content.
	 *
	 * What is this `data-text` attribute, anyway? It turns out that we need to
	 * put an attribute on the lowest-level text node in order to preserve correct
	 * spellcheck handling. If the <span> is naked, Chrome and Safari may do
	 * bizarre things to do the DOM -- split text nodes, create extra spans, etc.
	 * If the <span> has an attribute, this appears not to happen.
	 * See http://jsfiddle.net/9khdavod/ for the failure case, and
	 * http://jsfiddle.net/7pg143f7/ for the fixed case.
	 */
	var NEWLINE_A = useNewlineChar ? React.createElement(
	  'span',
	  { key: 'A', 'data-text': 'true' },
	  '\n'
	) : React.createElement('br', { key: 'A', 'data-text': 'true' });
	
	var NEWLINE_B = useNewlineChar ? React.createElement(
	  'span',
	  { key: 'B', 'data-text': 'true' },
	  '\n'
	) : React.createElement('br', { key: 'B', 'data-text': 'true' });
	
	/**
	 * The lowest-level component in a `DraftEditor`, the text node component
	 * replaces the default React text node implementation. This allows us to
	 * perform custom handling of newline behavior and avoid re-rendering text
	 * nodes with DOM state that already matches the expectations of our immutable
	 * editor state.
	 */
	
	var DraftEditorTextNode = (function (_React$Component) {
	  _inherits(DraftEditorTextNode, _React$Component);
	
	  function DraftEditorTextNode(props) {
	    _classCallCheck(this, DraftEditorTextNode);
	
	    _get(Object.getPrototypeOf(DraftEditorTextNode.prototype), 'constructor', this).call(this, props);
	    this._forceFlag = false;
	  }
	
	  _createClass(DraftEditorTextNode, [{
	    key: 'shouldComponentUpdate',
	    value: function shouldComponentUpdate(nextProps) {
	      var node = ReactDOM.findDOMNode(this);
	      var shouldBeNewline = nextProps.children === '';
	      if (shouldBeNewline) {
	        return !isNewline(node);
	      }
	      return node.textContent !== nextProps.children;
	    }
	  }, {
	    key: 'componentWillUpdate',
	    value: function componentWillUpdate() {
	      // By flipping this flag, we also keep flipping keys which forces
	      // React to remount this node every time it rerenders.
	      this._forceFlag = !this._forceFlag;
	    }
	  }, {
	    key: 'render',
	    value: function render() {
	      if (this.props.children === '') {
	        return this._forceFlag ? NEWLINE_A : NEWLINE_B;
	      }
	      return React.createElement(
	        'span',
	        { key: this._forceFlag ? 'A' : 'B', 'data-text': 'true' },
	        this.props.children
	      );
	    }
	  }]);
	
	  return DraftEditorTextNode;
	})(React.Component);
	
	module.exports = DraftEditorTextNode;

/***/ },
/* 430 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule setDraftEditorSelection
	 * @typechecks
	 * 
	 */
	
	/**
	 * In modern non-IE browsers, we can support both forward and backward
	 * selections.
	 *
	 * Note: IE10+ supports the Selection object, but it does not support
	 * the `extend` method, which means that even in modern IE, it's not possible
	 * to programatically create a backward selection. Thus, for all IE
	 * versions, we use the old IE API to create our selections.
	 */
	'use strict';
	
	var containsNode = __webpack_require__(481);
	var getActiveElement = __webpack_require__(482);
	
	function setDraftEditorSelection(selectionState, node, blockKey, nodeStart, nodeEnd) {
	  // It's possible that the editor has been removed from the DOM but
	  // our selection code doesn't know it yet. Forcing selection in
	  // this case may lead to errors, so just bail now.
	  if (!containsNode(document.documentElement, node)) {
	    return;
	  }
	
	  var selection = global.getSelection();
	  var anchorKey = selectionState.getAnchorKey();
	  var anchorOffset = selectionState.getAnchorOffset();
	  var focusKey = selectionState.getFocusKey();
	  var focusOffset = selectionState.getFocusOffset();
	  var isBackward = selectionState.getIsBackward();
	
	  // IE doesn't support backward selection. Swap key/offset pairs.
	  if (!selection.extend && isBackward) {
	    var tempKey = anchorKey;
	    var tempOffset = anchorOffset;
	    anchorKey = focusKey;
	    anchorOffset = focusOffset;
	    focusKey = tempKey;
	    focusOffset = tempOffset;
	    isBackward = false;
	  }
	
	  var hasAnchor = anchorKey === blockKey && nodeStart <= anchorOffset && nodeEnd >= anchorOffset;
	
	  var hasFocus = focusKey === blockKey && nodeStart <= focusOffset && nodeEnd >= focusOffset;
	
	  // If the selection is entirely bound within this node, set the selection
	  // and be done.
	  if (hasAnchor && hasFocus) {
	    selection.removeAllRanges();
	    addPointToSelection(selection, node, anchorOffset - nodeStart);
	    addFocusToSelection(selection, node, focusOffset - nodeStart);
	    return;
	  }
	
	  if (!isBackward) {
	    // If the anchor is within this node, set the range start.
	    if (hasAnchor) {
	      selection.removeAllRanges();
	      addPointToSelection(selection, node, anchorOffset - nodeStart);
	    }
	
	    // If the focus is within this node, we can assume that we have
	    // already set the appropriate start range on the selection, and
	    // can simply extend the selection.
	    if (hasFocus) {
	      addFocusToSelection(selection, node, focusOffset - nodeStart);
	    }
	  } else {
	    // If this node has the focus, set the selection range to be a
	    // collapsed range beginning here. Later, when we encounter the anchor,
	    // we'll use this information to extend the selection.
	    if (hasFocus) {
	      selection.removeAllRanges();
	      addPointToSelection(selection, node, focusOffset - nodeStart);
	    }
	
	    // If this node has the anchor, we may assume that the correct
	    // focus information is already stored on the selection object.
	    // We keep track of it, reset the selection range, and extend it
	    // back to the focus point.
	    if (hasAnchor) {
	      var storedFocusNode = selection.focusNode;
	      var storedFocusOffset = selection.focusOffset;
	
	      selection.removeAllRanges();
	      addPointToSelection(selection, node, anchorOffset - nodeStart);
	      addFocusToSelection(selection, storedFocusNode, storedFocusOffset);
	    }
	  }
	}
	
	/**
	 * Extend selection towards focus point.
	 */
	function addFocusToSelection(selection, node, offset) {
	  if (selection.extend && containsNode(getActiveElement(), node)) {
	    // If `extend` is called while another element has focus, an error is
	    // thrown. We therefore disable `extend` if the active element is somewhere
	    // other than the node we are selecting. This should only occur in Firefox,
	    // since it is the only browser to support multiple selections.
	    // See https://bugzilla.mozilla.org/show_bug.cgi?id=921444.
	    selection.extend(node, offset);
	  } else {
	    // IE doesn't support extend. This will mean no backward selection.
	    // Extract the existing selection range and add focus to it.
	    // Additionally, clone the selection range. IE11 throws an
	    // InvalidStateError when attempting to access selection properties
	    // after the range is detached.
	    var range = selection.getRangeAt(0);
	    range.setEnd(node, offset);
	    selection.addRange(range.cloneRange());
	  }
	}
	
	function addPointToSelection(selection, node, offset) {
	  var range = document.createRange();
	  range.setStart(node, offset);
	  selection.addRange(range);
	}
	
	module.exports = setDraftEditorSelection;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 431 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	/**
	 * This function is used to mark string literals representing CSS class names
	 * so that they can be transformed statically. This allows for modularization
	 * and minification of CSS class names.
	 *
	 * In static_upstream, this function is actually implemented, but it should
	 * eventually be replaced with something more descriptive, and the transform
	 * that is used in the main stack should be ported for use elsewhere.
	 *
	 * @param string|object className to modularize, or an object of key/values.
	 *                      In the object case, the values are conditions that
	 *                      determine if the className keys should be included.
	 * @param [string ...]  Variable list of classNames in the string case.
	 * @return string       Renderable space-separated CSS className.
	 */
	function cx(classNames) {
	  if (typeof classNames == 'object') {
	    return Object.keys(classNames).filter(function (className) {
	      return classNames[className];
	    }).map(replace).join(' ');
	  }
	  return Array.prototype.map.call(arguments, replace).join(' ');
	}
	
	function replace(str) {
	  return str.replace(/\//g, '-');
	}
	
	module.exports = cx;

/***/ },
/* 432 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	/**
	 * Use invariant() to assert state which your program assumes to be true.
	 *
	 * Provide sprintf-style format (only %s is supported) and arguments
	 * to provide information about what broke and what you were
	 * expecting.
	 *
	 * The invariant message will be stripped in production, but the invariant
	 * will remain to ensure logic does not differ in production.
	 */
	
	var validateFormat = function validateFormat(format) {};
	
	if (true) {
	  validateFormat = function validateFormat(format) {
	    if (format === undefined) {
	      throw new Error('invariant requires an error message argument');
	    }
	  };
	}
	
	function invariant(condition, format, a, b, c, d, e, f) {
	  validateFormat(format);
	
	  if (!condition) {
	    var error;
	    if (format === undefined) {
	      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];
	      var argIndex = 0;
	      error = new Error(format.replace(/%s/g, function () {
	        return args[argIndex++];
	      }));
	      error.name = 'Invariant Violation';
	    }
	
	    error.framesToPop = 1; // we don't care about invariant's own frame
	    throw error;
	  }
	}
	
	module.exports = invariant;

/***/ },
/* 433 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	var UserAgentData = __webpack_require__(483);
	var VersionRange = __webpack_require__(484);
	
	var mapObject = __webpack_require__(485);
	var memoizeStringOnly = __webpack_require__(486);
	
	/**
	 * Checks to see whether `name` and `version` satisfy `query`.
	 *
	 * @param {string} name Name of the browser, device, engine or platform
	 * @param {?string} version Version of the browser, engine or platform
	 * @param {string} query Query of form "Name [range expression]"
	 * @param {?function} normalizer Optional pre-processor for range expression
	 * @return {boolean}
	 */
	function compare(name, version, query, normalizer) {
	  // check for exact match with no version
	  if (name === query) {
	    return true;
	  }
	
	  // check for non-matching names
	  if (!query.startsWith(name)) {
	    return false;
	  }
	
	  // full comparison with version
	  var range = query.slice(name.length);
	  if (version) {
	    range = normalizer ? normalizer(range) : range;
	    return VersionRange.contains(range, version);
	  }
	
	  return false;
	}
	
	/**
	 * Normalizes `version` by stripping any "NT" prefix, but only on the Windows
	 * platform.
	 *
	 * Mimics the stripping performed by the `UserAgentWindowsPlatform` PHP class.
	 *
	 * @param {string} version
	 * @return {string}
	 */
	function normalizePlatformVersion(version) {
	  if (UserAgentData.platformName === 'Windows') {
	    return version.replace(/^\s*NT/, '');
	  }
	
	  return version;
	}
	
	/**
	 * Provides client-side access to the authoritative PHP-generated User Agent
	 * information supplied by the server.
	 */
	var UserAgent = {
	  /**
	   * Check if the User Agent browser matches `query`.
	   *
	   * `query` should be a string like "Chrome" or "Chrome > 33".
	   *
	   * Valid browser names include:
	   *
	   * - ACCESS NetFront
	   * - AOL
	   * - Amazon Silk
	   * - Android
	   * - BlackBerry
	   * - BlackBerry PlayBook
	   * - Chrome
	   * - Chrome for iOS
	   * - Chrome frame
	   * - Facebook PHP SDK
	   * - Facebook for iOS
	   * - Firefox
	   * - IE
	   * - IE Mobile
	   * - Mobile Safari
	   * - Motorola Internet Browser
	   * - Nokia
	   * - Openwave Mobile Browser
	   * - Opera
	   * - Opera Mini
	   * - Opera Mobile
	   * - Safari
	   * - UIWebView
	   * - Unknown
	   * - webOS
	   * - etc...
	   *
	   * An authoritative list can be found in the PHP `BrowserDetector` class and
	   * related classes in the same file (see calls to `new UserAgentBrowser` here:
	   * https://fburl.com/50728104).
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "Name [range expression]"
	   * @return {boolean}
	   */
	  isBrowser: function isBrowser(query) {
	    return compare(UserAgentData.browserName, UserAgentData.browserFullVersion, query);
	  },
	
	
	  /**
	   * Check if the User Agent browser uses a 32 or 64 bit architecture.
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "32" or "64".
	   * @return {boolean}
	   */
	  isBrowserArchitecture: function isBrowserArchitecture(query) {
	    return compare(UserAgentData.browserArchitecture, null, query);
	  },
	
	
	  /**
	   * Check if the User Agent device matches `query`.
	   *
	   * `query` should be a string like "iPhone" or "iPad".
	   *
	   * Valid device names include:
	   *
	   * - Kindle
	   * - Kindle Fire
	   * - Unknown
	   * - iPad
	   * - iPhone
	   * - iPod
	   * - etc...
	   *
	   * An authoritative list can be found in the PHP `DeviceDetector` class and
	   * related classes in the same file (see calls to `new UserAgentDevice` here:
	   * https://fburl.com/50728332).
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "Name"
	   * @return {boolean}
	   */
	  isDevice: function isDevice(query) {
	    return compare(UserAgentData.deviceName, null, query);
	  },
	
	
	  /**
	   * Check if the User Agent rendering engine matches `query`.
	   *
	   * `query` should be a string like "WebKit" or "WebKit >= 537".
	   *
	   * Valid engine names include:
	   *
	   * - Gecko
	   * - Presto
	   * - Trident
	   * - WebKit
	   * - etc...
	   *
	   * An authoritative list can be found in the PHP `RenderingEngineDetector`
	   * class related classes in the same file (see calls to `new
	   * UserAgentRenderingEngine` here: https://fburl.com/50728617).
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "Name [range expression]"
	   * @return {boolean}
	   */
	  isEngine: function isEngine(query) {
	    return compare(UserAgentData.engineName, UserAgentData.engineVersion, query);
	  },
	
	
	  /**
	   * Check if the User Agent platform matches `query`.
	   *
	   * `query` should be a string like "Windows" or "iOS 5 - 6".
	   *
	   * Valid platform names include:
	   *
	   * - Android
	   * - BlackBerry OS
	   * - Java ME
	   * - Linux
	   * - Mac OS X
	   * - Mac OS X Calendar
	   * - Mac OS X Internet Account
	   * - Symbian
	   * - SymbianOS
	   * - Windows
	   * - Windows Mobile
	   * - Windows Phone
	   * - iOS
	   * - iOS Facebook Integration Account
	   * - iOS Facebook Social Sharing UI
	   * - webOS
	   * - Chrome OS
	   * - etc...
	   *
	   * An authoritative list can be found in the PHP `PlatformDetector` class and
	   * related classes in the same file (see calls to `new UserAgentPlatform`
	   * here: https://fburl.com/50729226).
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "Name [range expression]"
	   * @return {boolean}
	   */
	  isPlatform: function isPlatform(query) {
	    return compare(UserAgentData.platformName, UserAgentData.platformFullVersion, query, normalizePlatformVersion);
	  },
	
	
	  /**
	   * Check if the User Agent platform is a 32 or 64 bit architecture.
	   *
	   * @note Function results are memoized
	   *
	   * @param {string} query Query of the form "32" or "64".
	   * @return {boolean}
	   */
	  isPlatformArchitecture: function isPlatformArchitecture(query) {
	    return compare(UserAgentData.platformArchitecture, null, query);
	  }
	};
	
	module.exports = mapObject(UserAgent, memoizeStringOnly);

/***/ },
/* 434 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	module.exports = {
	  BACKSPACE: 8,
	  TAB: 9,
	  RETURN: 13,
	  ALT: 18,
	  ESC: 27,
	  SPACE: 32,
	  PAGE_UP: 33,
	  PAGE_DOWN: 34,
	  END: 35,
	  HOME: 36,
	  LEFT: 37,
	  UP: 38,
	  RIGHT: 39,
	  DOWN: 40,
	  DELETE: 46,
	  COMMA: 188,
	  PERIOD: 190,
	  A: 65,
	  Z: 90,
	  ZERO: 48,
	  NUMPAD_0: 96,
	  NUMPAD_9: 105
	};

/***/ },
/* 435 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	/**
	 * @param {DOMElement} element
	 * @param {DOMDocument} doc
	 * @return {boolean}
	 */
	function _isViewportScrollElement(element, doc) {
	  return !!doc && (element === doc.documentElement || element === doc.body);
	}
	
	/**
	 * Scroll Module. This class contains 4 simple static functions
	 * to be used to access Element.scrollTop/scrollLeft properties.
	 * To solve the inconsistencies between browsers when either
	 * document.body or document.documentElement is supplied,
	 * below logic will be used to alleviate the issue:
	 *
	 * 1. If 'element' is either 'document.body' or 'document.documentElement,
	 *    get whichever element's 'scroll{Top,Left}' is larger.
	 * 2. If 'element' is either 'document.body' or 'document.documentElement',
	 *    set the 'scroll{Top,Left}' on both elements.
	 */
	
	var Scroll = {
	  /**
	   * @param {DOMElement} element
	   * @return {number}
	   */
	  getTop: function getTop(element) {
	    var doc = element.ownerDocument;
	    return _isViewportScrollElement(element, doc) ?
	    // In practice, they will either both have the same value,
	    // or one will be zero and the other will be the scroll position
	    // of the viewport. So we can use `X || Y` instead of `Math.max(X, Y)`
	    doc.body.scrollTop || doc.documentElement.scrollTop : element.scrollTop;
	  },
	
	  /**
	   * @param {DOMElement} element
	   * @param {number} newTop
	   */
	  setTop: function setTop(element, newTop) {
	    var doc = element.ownerDocument;
	    if (_isViewportScrollElement(element, doc)) {
	      doc.body.scrollTop = doc.documentElement.scrollTop = newTop;
	    } else {
	      element.scrollTop = newTop;
	    }
	  },
	
	  /**
	   * @param {DOMElement} element
	   * @return {number}
	   */
	  getLeft: function getLeft(element) {
	    var doc = element.ownerDocument;
	    return _isViewportScrollElement(element, doc) ? doc.body.scrollLeft || doc.documentElement.scrollLeft : element.scrollLeft;
	  },
	
	  /**
	   * @param {DOMElement} element
	   * @param {number} newLeft
	   */
	  setLeft: function setLeft(element, newLeft) {
	    var doc = element.ownerDocument;
	    if (_isViewportScrollElement(element, doc)) {
	      doc.body.scrollLeft = doc.documentElement.scrollLeft = newLeft;
	    } else {
	      element.scrollLeft = newLeft;
	    }
	  }
	};
	
	module.exports = Scroll;

/***/ },
/* 436 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var getStyleProperty = __webpack_require__(487);
	
	/**
	 * @param {DOMNode} element [description]
	 * @param {string} name Overflow style property name.
	 * @return {boolean} True if the supplied ndoe is scrollable.
	 */
	function _isNodeScrollable(element, name) {
	  var overflow = Style.get(element, name);
	  return overflow === 'auto' || overflow === 'scroll';
	}
	
	/**
	 * Utilities for querying and mutating style properties.
	 */
	var Style = {
	  /**
	   * Gets the style property for the supplied node. This will return either the
	   * computed style, if available, or the declared style.
	   *
	   * @param {DOMNode} node
	   * @param {string} name Style property name.
	   * @return {?string} Style property value.
	   */
	  get: getStyleProperty,
	
	  /**
	   * Determines the nearest ancestor of a node that is scrollable.
	   *
	   * NOTE: This can be expensive if used repeatedly or on a node nested deeply.
	   *
	   * @param {?DOMNode} node Node from which to start searching.
	   * @return {?DOMWindow|DOMElement} Scroll parent of the supplied node.
	   */
	  getScrollParent: function getScrollParent(node) {
	    if (!node) {
	      return null;
	    }
	    var ownerDocument = node.ownerDocument;
	    while (node && node !== ownerDocument.body) {
	      if (_isNodeScrollable(node, 'overflow') || _isNodeScrollable(node, 'overflowY') || _isNodeScrollable(node, 'overflowX')) {
	        return node;
	      }
	      node = node.parentNode;
	    }
	    return ownerDocument.defaultView || ownerDocument.parentWindow;
	  }
	
	};
	
	module.exports = Style;

/***/ },
/* 437 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 * 
	 */
	
	/**
	 * Basic (stateless) API for text direction detection
	 *
	 * Part of our implementation of Unicode Bidirectional Algorithm (UBA)
	 * Unicode Standard Annex #9 (UAX9)
	 * http://www.unicode.org/reports/tr9/
	 */
	
	'use strict';
	
	var UnicodeBidiDirection = __webpack_require__(438);
	
	var invariant = __webpack_require__(432);
	
	/**
	 * RegExp ranges of characters with a *Strong* Bidi_Class value.
	 *
	 * Data is based on DerivedBidiClass.txt in UCD version 7.0.0.
	 *
	 * NOTE: For performance reasons, we only support Unicode's
	 *       Basic Multilingual Plane (BMP) for now.
	 */
	var RANGE_BY_BIDI_TYPE = {
	
	  L: 'A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u01BA\u01BB' + '\u01BC-\u01BF\u01C0-\u01C3\u01C4-\u0293\u0294\u0295-\u02AF\u02B0-\u02B8' + '\u02BB-\u02C1\u02D0-\u02D1\u02E0-\u02E4\u02EE\u0370-\u0373\u0376-\u0377' + '\u037A\u037B-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1' + '\u03A3-\u03F5\u03F7-\u0481\u0482\u048A-\u052F\u0531-\u0556\u0559' + '\u055A-\u055F\u0561-\u0587\u0589\u0903\u0904-\u0939\u093B\u093D' + '\u093E-\u0940\u0949-\u094C\u094E-\u094F\u0950\u0958-\u0961\u0964-\u0965' + '\u0966-\u096F\u0970\u0971\u0972-\u0980\u0982-\u0983\u0985-\u098C' + '\u098F-\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD' + '\u09BE-\u09C0\u09C7-\u09C8\u09CB-\u09CC\u09CE\u09D7\u09DC-\u09DD' + '\u09DF-\u09E1\u09E6-\u09EF\u09F0-\u09F1\u09F4-\u09F9\u09FA\u0A03' + '\u0A05-\u0A0A\u0A0F-\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32-\u0A33' + '\u0A35-\u0A36\u0A38-\u0A39\u0A3E-\u0A40\u0A59-\u0A5C\u0A5E\u0A66-\u0A6F' + '\u0A72-\u0A74\u0A83\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0' + '\u0AB2-\u0AB3\u0AB5-\u0AB9\u0ABD\u0ABE-\u0AC0\u0AC9\u0ACB-\u0ACC\u0AD0' + '\u0AE0-\u0AE1\u0AE6-\u0AEF\u0AF0\u0B02-\u0B03\u0B05-\u0B0C\u0B0F-\u0B10' + '\u0B13-\u0B28\u0B2A-\u0B30\u0B32-\u0B33\u0B35-\u0B39\u0B3D\u0B3E\u0B40' + '\u0B47-\u0B48\u0B4B-\u0B4C\u0B57\u0B5C-\u0B5D\u0B5F-\u0B61\u0B66-\u0B6F' + '\u0B70\u0B71\u0B72-\u0B77\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95' + '\u0B99-\u0B9A\u0B9C\u0B9E-\u0B9F\u0BA3-\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9' + '\u0BBE-\u0BBF\u0BC1-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCC\u0BD0\u0BD7' + '\u0BE6-\u0BEF\u0BF0-\u0BF2\u0C01-\u0C03\u0C05-\u0C0C\u0C0E-\u0C10' + '\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C41-\u0C44\u0C58-\u0C59\u0C60-\u0C61' + '\u0C66-\u0C6F\u0C7F\u0C82-\u0C83\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8' + '\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CBE\u0CBF\u0CC0-\u0CC4\u0CC6' + '\u0CC7-\u0CC8\u0CCA-\u0CCB\u0CD5-\u0CD6\u0CDE\u0CE0-\u0CE1\u0CE6-\u0CEF' + '\u0CF1-\u0CF2\u0D02-\u0D03\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D' + '\u0D3E-\u0D40\u0D46-\u0D48\u0D4A-\u0D4C\u0D4E\u0D57\u0D60-\u0D61' + '\u0D66-\u0D6F\u0D70-\u0D75\u0D79\u0D7A-\u0D7F\u0D82-\u0D83\u0D85-\u0D96' + '\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0DCF-\u0DD1\u0DD8-\u0DDF' + '\u0DE6-\u0DEF\u0DF2-\u0DF3\u0DF4\u0E01-\u0E30\u0E32-\u0E33\u0E40-\u0E45' + '\u0E46\u0E4F\u0E50-\u0E59\u0E5A-\u0E5B\u0E81-\u0E82\u0E84\u0E87-\u0E88' + '\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7' + '\u0EAA-\u0EAB\u0EAD-\u0EB0\u0EB2-\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6' + '\u0ED0-\u0ED9\u0EDC-\u0EDF\u0F00\u0F01-\u0F03\u0F04-\u0F12\u0F13\u0F14' + '\u0F15-\u0F17\u0F1A-\u0F1F\u0F20-\u0F29\u0F2A-\u0F33\u0F34\u0F36\u0F38' + '\u0F3E-\u0F3F\u0F40-\u0F47\u0F49-\u0F6C\u0F7F\u0F85\u0F88-\u0F8C' + '\u0FBE-\u0FC5\u0FC7-\u0FCC\u0FCE-\u0FCF\u0FD0-\u0FD4\u0FD5-\u0FD8' + '\u0FD9-\u0FDA\u1000-\u102A\u102B-\u102C\u1031\u1038\u103B-\u103C\u103F' + '\u1040-\u1049\u104A-\u104F\u1050-\u1055\u1056-\u1057\u105A-\u105D\u1061' + '\u1062-\u1064\u1065-\u1066\u1067-\u106D\u106E-\u1070\u1075-\u1081' + '\u1083-\u1084\u1087-\u108C\u108E\u108F\u1090-\u1099\u109A-\u109C' + '\u109E-\u109F\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FB\u10FC' + '\u10FD-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288' + '\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5' + '\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1360-\u1368' + '\u1369-\u137C\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166D-\u166E' + '\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EB-\u16ED\u16EE-\u16F0' + '\u16F1-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1735-\u1736' + '\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17B6\u17BE-\u17C5' + '\u17C7-\u17C8\u17D4-\u17D6\u17D7\u17D8-\u17DA\u17DC\u17E0-\u17E9' + '\u1810-\u1819\u1820-\u1842\u1843\u1844-\u1877\u1880-\u18A8\u18AA' + '\u18B0-\u18F5\u1900-\u191E\u1923-\u1926\u1929-\u192B\u1930-\u1931' + '\u1933-\u1938\u1946-\u194F\u1950-\u196D\u1970-\u1974\u1980-\u19AB' + '\u19B0-\u19C0\u19C1-\u19C7\u19C8-\u19C9\u19D0-\u19D9\u19DA\u1A00-\u1A16' + '\u1A19-\u1A1A\u1A1E-\u1A1F\u1A20-\u1A54\u1A55\u1A57\u1A61\u1A63-\u1A64' + '\u1A6D-\u1A72\u1A80-\u1A89\u1A90-\u1A99\u1AA0-\u1AA6\u1AA7\u1AA8-\u1AAD' + '\u1B04\u1B05-\u1B33\u1B35\u1B3B\u1B3D-\u1B41\u1B43-\u1B44\u1B45-\u1B4B' + '\u1B50-\u1B59\u1B5A-\u1B60\u1B61-\u1B6A\u1B74-\u1B7C\u1B82\u1B83-\u1BA0' + '\u1BA1\u1BA6-\u1BA7\u1BAA\u1BAE-\u1BAF\u1BB0-\u1BB9\u1BBA-\u1BE5\u1BE7' + '\u1BEA-\u1BEC\u1BEE\u1BF2-\u1BF3\u1BFC-\u1BFF\u1C00-\u1C23\u1C24-\u1C2B' + '\u1C34-\u1C35\u1C3B-\u1C3F\u1C40-\u1C49\u1C4D-\u1C4F\u1C50-\u1C59' + '\u1C5A-\u1C77\u1C78-\u1C7D\u1C7E-\u1C7F\u1CC0-\u1CC7\u1CD3\u1CE1' + '\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF2-\u1CF3\u1CF5-\u1CF6\u1D00-\u1D2B' + '\u1D2C-\u1D6A\u1D6B-\u1D77\u1D78\u1D79-\u1D9A\u1D9B-\u1DBF\u1E00-\u1F15' + '\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D' + '\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC' + '\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u200E' + '\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D' + '\u2124\u2126\u2128\u212A-\u212D\u212F-\u2134\u2135-\u2138\u2139' + '\u213C-\u213F\u2145-\u2149\u214E\u214F\u2160-\u2182\u2183-\u2184' + '\u2185-\u2188\u2336-\u237A\u2395\u249C-\u24E9\u26AC\u2800-\u28FF' + '\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2C7B\u2C7C-\u2C7D\u2C7E-\u2CE4' + '\u2CEB-\u2CEE\u2CF2-\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F' + '\u2D70\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE' + '\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u3005\u3006\u3007' + '\u3021-\u3029\u302E-\u302F\u3031-\u3035\u3038-\u303A\u303B\u303C' + '\u3041-\u3096\u309D-\u309E\u309F\u30A1-\u30FA\u30FC-\u30FE\u30FF' + '\u3105-\u312D\u3131-\u318E\u3190-\u3191\u3192-\u3195\u3196-\u319F' + '\u31A0-\u31BA\u31F0-\u31FF\u3200-\u321C\u3220-\u3229\u322A-\u3247' + '\u3248-\u324F\u3260-\u327B\u327F\u3280-\u3289\u328A-\u32B0\u32C0-\u32CB' + '\u32D0-\u32FE\u3300-\u3376\u337B-\u33DD\u33E0-\u33FE\u3400-\u4DB5' + '\u4E00-\u9FCC\uA000-\uA014\uA015\uA016-\uA48C\uA4D0-\uA4F7\uA4F8-\uA4FD' + '\uA4FE-\uA4FF\uA500-\uA60B\uA60C\uA610-\uA61F\uA620-\uA629\uA62A-\uA62B' + '\uA640-\uA66D\uA66E\uA680-\uA69B\uA69C-\uA69D\uA6A0-\uA6E5\uA6E6-\uA6EF' + '\uA6F2-\uA6F7\uA722-\uA76F\uA770\uA771-\uA787\uA789-\uA78A\uA78B-\uA78E' + '\uA790-\uA7AD\uA7B0-\uA7B1\uA7F7\uA7F8-\uA7F9\uA7FA\uA7FB-\uA801' + '\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA823-\uA824\uA827\uA830-\uA835' + '\uA836-\uA837\uA840-\uA873\uA880-\uA881\uA882-\uA8B3\uA8B4-\uA8C3' + '\uA8CE-\uA8CF\uA8D0-\uA8D9\uA8F2-\uA8F7\uA8F8-\uA8FA\uA8FB\uA900-\uA909' + '\uA90A-\uA925\uA92E-\uA92F\uA930-\uA946\uA952-\uA953\uA95F\uA960-\uA97C' + '\uA983\uA984-\uA9B2\uA9B4-\uA9B5\uA9BA-\uA9BB\uA9BD-\uA9C0\uA9C1-\uA9CD' + '\uA9CF\uA9D0-\uA9D9\uA9DE-\uA9DF\uA9E0-\uA9E4\uA9E6\uA9E7-\uA9EF' + '\uA9F0-\uA9F9\uA9FA-\uA9FE\uAA00-\uAA28\uAA2F-\uAA30\uAA33-\uAA34' + '\uAA40-\uAA42\uAA44-\uAA4B\uAA4D\uAA50-\uAA59\uAA5C-\uAA5F\uAA60-\uAA6F' + '\uAA70\uAA71-\uAA76\uAA77-\uAA79\uAA7A\uAA7B\uAA7D\uAA7E-\uAAAF\uAAB1' + '\uAAB5-\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADC\uAADD\uAADE-\uAADF' + '\uAAE0-\uAAEA\uAAEB\uAAEE-\uAAEF\uAAF0-\uAAF1\uAAF2\uAAF3-\uAAF4\uAAF5' + '\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E' + '\uAB30-\uAB5A\uAB5B\uAB5C-\uAB5F\uAB64-\uAB65\uABC0-\uABE2\uABE3-\uABE4' + '\uABE6-\uABE7\uABE9-\uABEA\uABEB\uABEC\uABF0-\uABF9\uAC00-\uD7A3' + '\uD7B0-\uD7C6\uD7CB-\uD7FB\uE000-\uF8FF\uF900-\uFA6D\uFA70-\uFAD9' + '\uFB00-\uFB06\uFB13-\uFB17\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFF6F\uFF70' + '\uFF71-\uFF9D\uFF9E-\uFF9F\uFFA0-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF' + '\uFFD2-\uFFD7\uFFDA-\uFFDC',
	
	  R: '\u0590\u05BE\u05C0\u05C3\u05C6\u05C8-\u05CF\u05D0-\u05EA\u05EB-\u05EF' + '\u05F0-\u05F2\u05F3-\u05F4\u05F5-\u05FF\u07C0-\u07C9\u07CA-\u07EA' + '\u07F4-\u07F5\u07FA\u07FB-\u07FF\u0800-\u0815\u081A\u0824\u0828' + '\u082E-\u082F\u0830-\u083E\u083F\u0840-\u0858\u085C-\u085D\u085E' + '\u085F-\u089F\u200F\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB37\uFB38-\uFB3C' + '\uFB3D\uFB3E\uFB3F\uFB40-\uFB41\uFB42\uFB43-\uFB44\uFB45\uFB46-\uFB4F',
	
	  AL: '\u0608\u060B\u060D\u061B\u061C\u061D\u061E-\u061F\u0620-\u063F\u0640' + '\u0641-\u064A\u066D\u066E-\u066F\u0671-\u06D3\u06D4\u06D5\u06E5-\u06E6' + '\u06EE-\u06EF\u06FA-\u06FC\u06FD-\u06FE\u06FF\u0700-\u070D\u070E\u070F' + '\u0710\u0712-\u072F\u074B-\u074C\u074D-\u07A5\u07B1\u07B2-\u07BF' + '\u08A0-\u08B2\u08B3-\u08E3\uFB50-\uFBB1\uFBB2-\uFBC1\uFBC2-\uFBD2' + '\uFBD3-\uFD3D\uFD40-\uFD4F\uFD50-\uFD8F\uFD90-\uFD91\uFD92-\uFDC7' + '\uFDC8-\uFDCF\uFDF0-\uFDFB\uFDFC\uFDFE-\uFDFF\uFE70-\uFE74\uFE75' + '\uFE76-\uFEFC\uFEFD-\uFEFE'
	
	};
	
	var REGEX_STRONG = new RegExp('[' + RANGE_BY_BIDI_TYPE.L + RANGE_BY_BIDI_TYPE.R + RANGE_BY_BIDI_TYPE.AL + ']');
	
	var REGEX_RTL = new RegExp('[' + RANGE_BY_BIDI_TYPE.R + RANGE_BY_BIDI_TYPE.AL + ']');
	
	/**
	 * Returns the first strong character (has Bidi_Class value of L, R, or AL).
	 *
	 * @param str  A text block; e.g. paragraph, table cell, tag
	 * @return     A character with strong bidi direction, or null if not found
	 */
	function firstStrongChar(str) {
	  var match = REGEX_STRONG.exec(str);
	  return match == null ? null : match[0];
	}
	
	/**
	 * Returns the direction of a block of text, based on the direction of its
	 * first strong character (has Bidi_Class value of L, R, or AL).
	 *
	 * @param str  A text block; e.g. paragraph, table cell, tag
	 * @return     The resolved direction
	 */
	function firstStrongCharDir(str) {
	  var strongChar = firstStrongChar(str);
	  if (strongChar == null) {
	    return UnicodeBidiDirection.NEUTRAL;
	  }
	  return REGEX_RTL.exec(strongChar) ? UnicodeBidiDirection.RTL : UnicodeBidiDirection.LTR;
	}
	
	/**
	 * Returns the direction of a block of text, based on the direction of its
	 * first strong character (has Bidi_Class value of L, R, or AL), or a fallback
	 * direction, if no strong character is found.
	 *
	 * This function is supposed to be used in respect to Higher-Level Protocol
	 * rule HL1. (http://www.unicode.org/reports/tr9/#HL1)
	 *
	 * @param str       A text block; e.g. paragraph, table cell, tag
	 * @param fallback  Fallback direction, used if no strong direction detected
	 *                  for the block (default = NEUTRAL)
	 * @return          The resolved direction
	 */
	function resolveBlockDir(str, fallback) {
	  fallback = fallback || UnicodeBidiDirection.NEUTRAL;
	  if (!str.length) {
	    return fallback;
	  }
	  var blockDir = firstStrongCharDir(str);
	  return blockDir === UnicodeBidiDirection.NEUTRAL ? fallback : blockDir;
	}
	
	/**
	 * Returns the direction of a block of text, based on the direction of its
	 * first strong character (has Bidi_Class value of L, R, or AL), or a fallback
	 * direction, if no strong character is found.
	 *
	 * NOTE: This function is similar to resolveBlockDir(), but uses the global
	 * direction as the fallback, so it *always* returns a Strong direction,
	 * making it useful for integration in places that you need to make the final
	 * decision, like setting some CSS class.
	 *
	 * This function is supposed to be used in respect to Higher-Level Protocol
	 * rule HL1. (http://www.unicode.org/reports/tr9/#HL1)
	 *
	 * @param str             A text block; e.g. paragraph, table cell
	 * @param strongFallback  Fallback direction, used if no strong direction
	 *                        detected for the block (default = global direction)
	 * @return                The resolved Strong direction
	 */
	function getDirection(str, strongFallback) {
	  if (!strongFallback) {
	    strongFallback = UnicodeBidiDirection.getGlobalDir();
	  }
	  !UnicodeBidiDirection.isStrong(strongFallback) ? true ? invariant(false, 'Fallback direction must be a strong direction') : invariant(false) : void 0;
	  return resolveBlockDir(str, strongFallback);
	}
	
	/**
	 * Returns true if getDirection(arguments...) returns LTR.
	 *
	 * @param str             A text block; e.g. paragraph, table cell
	 * @param strongFallback  Fallback direction, used if no strong direction
	 *                        detected for the block (default = global direction)
	 * @return                True if the resolved direction is LTR
	 */
	function isDirectionLTR(str, strongFallback) {
	  return getDirection(str, strongFallback) === UnicodeBidiDirection.LTR;
	}
	
	/**
	 * Returns true if getDirection(arguments...) returns RTL.
	 *
	 * @param str             A text block; e.g. paragraph, table cell
	 * @param strongFallback  Fallback direction, used if no strong direction
	 *                        detected for the block (default = global direction)
	 * @return                True if the resolved direction is RTL
	 */
	function isDirectionRTL(str, strongFallback) {
	  return getDirection(str, strongFallback) === UnicodeBidiDirection.RTL;
	}
	
	var UnicodeBidi = {
	  firstStrongChar: firstStrongChar,
	  firstStrongCharDir: firstStrongCharDir,
	  resolveBlockDir: resolveBlockDir,
	  getDirection: getDirection,
	  isDirectionLTR: isDirectionLTR,
	  isDirectionRTL: isDirectionRTL
	};
	
	module.exports = UnicodeBidi;

/***/ },
/* 438 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 * 
	 */
	
	/**
	 * Constants to represent text directionality
	 *
	 * Also defines a *global* direciton, to be used in bidi algorithms as a
	 * default fallback direciton, when no better direction is found or provided.
	 *
	 * NOTE: Use `setGlobalDir()`, or update `initGlobalDir()`, to set the initial
	 *       global direction value based on the application.
	 *
	 * Part of the implementation of Unicode Bidirectional Algorithm (UBA)
	 * Unicode Standard Annex #9 (UAX9)
	 * http://www.unicode.org/reports/tr9/
	 */
	
	'use strict';
	
	var invariant = __webpack_require__(432);
	
	var NEUTRAL = 'NEUTRAL'; // No strong direction
	var LTR = 'LTR'; // Left-to-Right direction
	var RTL = 'RTL'; // Right-to-Left direction
	
	var globalDir = null;
	
	// == Helpers ==
	
	/**
	 * Check if a directionality value is a Strong one
	 */
	function isStrong(dir) {
	  return dir === LTR || dir === RTL;
	}
	
	/**
	 * Get string value to be used for `dir` HTML attribute or `direction` CSS
	 * property.
	 */
	function getHTMLDir(dir) {
	  !isStrong(dir) ? true ? invariant(false, '`dir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;
	  return dir === LTR ? 'ltr' : 'rtl';
	}
	
	/**
	 * Get string value to be used for `dir` HTML attribute or `direction` CSS
	 * property, but returns null if `dir` has same value as `otherDir`.
	 * `null`.
	 */
	function getHTMLDirIfDifferent(dir, otherDir) {
	  !isStrong(dir) ? true ? invariant(false, '`dir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;
	  !isStrong(otherDir) ? true ? invariant(false, '`otherDir` must be a strong direction to be converted to HTML Direction') : invariant(false) : void 0;
	  return dir === otherDir ? null : getHTMLDir(dir);
	}
	
	// == Global Direction ==
	
	/**
	 * Set the global direction.
	 */
	function setGlobalDir(dir) {
	  globalDir = dir;
	}
	
	/**
	 * Initialize the global direction
	 */
	function initGlobalDir() {
	  setGlobalDir(LTR);
	}
	
	/**
	 * Get the global direction
	 */
	function getGlobalDir() {
	  if (!globalDir) {
	    this.initGlobalDir();
	  }
	  !globalDir ? true ? invariant(false, 'Global direction not set.') : invariant(false) : void 0;
	  return globalDir;
	}
	
	var UnicodeBidiDirection = {
	  // Values
	  NEUTRAL: NEUTRAL,
	  LTR: LTR,
	  RTL: RTL,
	  // Helpers
	  isStrong: isStrong,
	  getHTMLDir: getHTMLDir,
	  getHTMLDirIfDifferent: getHTMLDirIfDifferent,
	  // Global Direction
	  setGlobalDir: setGlobalDir,
	  initGlobalDir: initGlobalDir,
	  getGlobalDir: getGlobalDir
	};
	
	module.exports = UnicodeBidiDirection;

/***/ },
/* 439 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var getElementRect = __webpack_require__(488);
	
	/**
	 * Gets an element's position in pixels relative to the viewport. The returned
	 * object represents the position of the element's top left corner.
	 *
	 * @param {DOMElement} element
	 * @return {object}
	 */
	function getElementPosition(element) {
	  var rect = getElementRect(element);
	  return {
	    x: rect.left,
	    y: rect.top,
	    width: rect.right - rect.left,
	    height: rect.bottom - rect.top
	  };
	}
	
	module.exports = getElementPosition;

/***/ },
/* 440 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	'use strict';
	
	var getDocumentScrollElement = __webpack_require__(489);
	var getUnboundedScrollPosition = __webpack_require__(490);
	
	/**
	 * Gets the scroll position of the supplied element or window.
	 *
	 * The return values are bounded. This means that if the scroll position is
	 * negative or exceeds the element boundaries (which is possible using inertial
	 * scrolling), you will get zero or the maximum scroll position, respectively.
	 *
	 * If you need the unbound scroll position, use `getUnboundedScrollPosition`.
	 *
	 * @param {DOMWindow|DOMElement} scrollable
	 * @return {object} Map with `x` and `y` keys.
	 */
	function getScrollPosition(scrollable) {
	  var documentScrollElement = getDocumentScrollElement(scrollable.ownerDocument || scrollable.document);
	  if (scrollable.Window && scrollable instanceof scrollable.Window) {
	    scrollable = documentScrollElement;
	  }
	  var scrollPosition = getUnboundedScrollPosition(scrollable);
	
	  var viewport = scrollable === documentScrollElement ? scrollable.ownerDocument.documentElement : scrollable;
	
	  var xMax = scrollable.scrollWidth - viewport.clientWidth;
	  var yMax = scrollable.scrollHeight - viewport.clientHeight;
	
	  scrollPosition.x = Math.max(0, Math.min(scrollPosition.x, xMax));
	  scrollPosition.y = Math.max(0, Math.min(scrollPosition.y, yMax));
	
	  return scrollPosition;
	}
	
	module.exports = getScrollPosition;

/***/ },
/* 441 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	function getViewportWidth() {
	  var width = void 0;
	  if (document.documentElement) {
	    width = document.documentElement.clientWidth;
	  }
	
	  if (!width && document.body) {
	    width = document.body.clientWidth;
	  }
	
	  return width || 0;
	} /**
	   * Copyright (c) 2013-present, Facebook, Inc.
	   *
	   * This source code is licensed under the MIT license found in the
	   * LICENSE file in the root directory of this source tree.
	   *
	   * 
	   * @typechecks
	   */
	
	function getViewportHeight() {
	  var height = void 0;
	  if (document.documentElement) {
	    height = document.documentElement.clientHeight;
	  }
	
	  if (!height && document.body) {
	    height = document.body.clientHeight;
	  }
	
	  return height || 0;
	}
	
	/**
	 * Gets the viewport dimensions including any scrollbars.
	 */
	function getViewportDimensions() {
	  return {
	    width: window.innerWidth || getViewportWidth(),
	    height: window.innerHeight || getViewportHeight()
	  };
	}
	
	/**
	 * Gets the viewport dimensions excluding any scrollbars.
	 */
	getViewportDimensions.withoutScrollbars = function () {
	  return {
	    width: getViewportWidth(),
	    height: getViewportHeight()
	  };
	};
	
	module.exports = getViewportDimensions;

/***/ },
/* 442 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * 
	 */
	
	var nullthrows = function nullthrows(x) {
	  if (x != null) {
	    return x;
	  }
	  throw new Error("Got unexpected null or undefined");
	};
	
	module.exports = nullthrows;

/***/ },
/* 443 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * 
	 */
	
	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	var URI = function () {
	  function URI(uri) {
	    _classCallCheck(this, URI);
	
	    this._uri = uri;
	  }
	
	  URI.prototype.toString = function toString() {
	    return this._uri;
	  };
	
	  return URI;
	}();
	
	module.exports = URI;

/***/ },
/* 444 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * 
	 */
	
	function makeEmptyFunction(arg) {
	  return function () {
	    return arg;
	  };
	}
	
	/**
	 * This function accepts and discards inputs; it has no side effects. This is
	 * primarily useful idiomatically for overridable function endpoints which
	 * always need to be callable, since JS lacks a null-call idiom ala Cocoa.
	 */
	var emptyFunction = function emptyFunction() {};
	
	emptyFunction.thatReturns = makeEmptyFunction;
	emptyFunction.thatReturnsFalse = makeEmptyFunction(false);
	emptyFunction.thatReturnsTrue = makeEmptyFunction(true);
	emptyFunction.thatReturnsNull = makeEmptyFunction(null);
	emptyFunction.thatReturnsThis = function () {
	  return this;
	};
	emptyFunction.thatReturnsArgument = function (arg) {
	  return arg;
	};
	
	module.exports = emptyFunction;

/***/ },
/* 445 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	/**
	 * Unicode-enabled replacesments for basic String functions.
	 *
	 * All the functions in this module assume that the input string is a valid
	 * UTF-16 encoding of a Unicode sequence. If it's not the case, the behavior
	 * will be undefined.
	 *
	 * WARNING: Since this module is typechecks-enforced, you may find new bugs
	 * when replacing normal String functions with ones provided here.
	 */
	
	'use strict';
	
	var invariant = __webpack_require__(432);
	
	// These two ranges are consecutive so anything in [HIGH_START, LOW_END] is a
	// surrogate code unit.
	var SURROGATE_HIGH_START = 0xD800;
	var SURROGATE_HIGH_END = 0xDBFF;
	var SURROGATE_LOW_START = 0xDC00;
	var SURROGATE_LOW_END = 0xDFFF;
	var SURROGATE_UNITS_REGEX = /[\uD800-\uDFFF]/;
	
	/**
	 * @param {number} codeUnit   A Unicode code-unit, in range [0, 0x10FFFF]
	 * @return {boolean}          Whether code-unit is in a surrogate (hi/low) range
	 */
	function isCodeUnitInSurrogateRange(codeUnit) {
	  return SURROGATE_HIGH_START <= codeUnit && codeUnit <= SURROGATE_LOW_END;
	}
	
	/**
	 * Returns whether the two characters starting at `index` form a surrogate pair.
	 * For example, given the string s = "\uD83D\uDE0A", (s, 0) returns true and
	 * (s, 1) returns false.
	 *
	 * @param {string} str
	 * @param {number} index
	 * @return {boolean}
	 */
	function isSurrogatePair(str, index) {
	  !(0 <= index && index < str.length) ? true ? invariant(false, 'isSurrogatePair: Invalid index %s for string length %s.', index, str.length) : invariant(false) : void 0;
	  if (index + 1 === str.length) {
	    return false;
	  }
	  var first = str.charCodeAt(index);
	  var second = str.charCodeAt(index + 1);
	  return SURROGATE_HIGH_START <= first && first <= SURROGATE_HIGH_END && SURROGATE_LOW_START <= second && second <= SURROGATE_LOW_END;
	}
	
	/**
	 * @param {string} str  Non-empty string
	 * @return {boolean}    True if the input includes any surrogate code units
	 */
	function hasSurrogateUnit(str) {
	  return SURROGATE_UNITS_REGEX.test(str);
	}
	
	/**
	 * Return the length of the original Unicode character at given position in the
	 * String by looking into the UTF-16 code unit; that is equal to 1 for any
	 * non-surrogate characters in BMP ([U+0000..U+D7FF] and [U+E000, U+FFFF]); and
	 * returns 2 for the hi/low surrogates ([U+D800..U+DFFF]), which are in fact
	 * representing non-BMP characters ([U+10000..U+10FFFF]).
	 *
	 * Examples:
	 * - '\u0020' => 1
	 * - '\u3020' => 1
	 * - '\uD835' => 2
	 * - '\uD835\uDDEF' => 2
	 * - '\uDDEF' => 2
	 *
	 * @param {string} str  Non-empty string
	 * @param {number} pos  Position in the string to look for one code unit
	 * @return {number}      Number 1 or 2
	 */
	function getUTF16Length(str, pos) {
	  return 1 + isCodeUnitInSurrogateRange(str.charCodeAt(pos));
	}
	
	/**
	 * Fully Unicode-enabled replacement for String#length
	 *
	 * @param {string} str  Valid Unicode string
	 * @return {number}     The number of Unicode characters in the string
	 */
	function strlen(str) {
	  // Call the native functions if there's no surrogate char
	  if (!hasSurrogateUnit(str)) {
	    return str.length;
	  }
	
	  var len = 0;
	  for (var pos = 0; pos < str.length; pos += getUTF16Length(str, pos)) {
	    len++;
	  }
	  return len;
	}
	
	/**
	 * Fully Unicode-enabled replacement for String#substr()
	 *
	 * @param {string} str      Valid Unicode string
	 * @param {number} start    Location in Unicode sequence to begin extracting
	 * @param {?number} length  The number of Unicode characters to extract
	 *                          (default: to the end of the string)
	 * @return {string}         Extracted sub-string
	 */
	function substr(str, start, length) {
	  start = start || 0;
	  length = length === undefined ? Infinity : length || 0;
	
	  // Call the native functions if there's no surrogate char
	  if (!hasSurrogateUnit(str)) {
	    return str.substr(start, length);
	  }
	
	  // Obvious cases
	  var size = str.length;
	  if (size <= 0 || start > size || length <= 0) {
	    return '';
	  }
	
	  // Find the actual starting position
	  var posA = 0;
	  if (start > 0) {
	    for (; start > 0 && posA < size; start--) {
	      posA += getUTF16Length(str, posA);
	    }
	    if (posA >= size) {
	      return '';
	    }
	  } else if (start < 0) {
	    for (posA = size; start < 0 && 0 < posA; start++) {
	      posA -= getUTF16Length(str, posA - 1);
	    }
	    if (posA < 0) {
	      posA = 0;
	    }
	  }
	
	  // Find the actual ending position
	  var posB = size;
	  if (length < size) {
	    for (posB = posA; length > 0 && posB < size; length--) {
	      posB += getUTF16Length(str, posB);
	    }
	  }
	
	  return str.substring(posA, posB);
	}
	
	/**
	 * Fully Unicode-enabled replacement for String#substring()
	 *
	 * @param {string} str    Valid Unicode string
	 * @param {number} start  Location in Unicode sequence to begin extracting
	 * @param {?number} end   Location in Unicode sequence to end extracting
	 *                        (default: end of the string)
	 * @return {string}       Extracted sub-string
	 */
	function substring(str, start, end) {
	  start = start || 0;
	  end = end === undefined ? Infinity : end || 0;
	
	  if (start < 0) {
	    start = 0;
	  }
	  if (end < 0) {
	    end = 0;
	  }
	
	  var length = Math.abs(end - start);
	  start = start < end ? start : end;
	  return substr(str, start, length);
	}
	
	/**
	 * Get a list of Unicode code-points from a String
	 *
	 * @param {string} str        Valid Unicode string
	 * @return {array<number>}    A list of code-points in [0..0x10FFFF]
	 */
	function getCodePoints(str) {
	  var codePoints = [];
	  for (var pos = 0; pos < str.length; pos += getUTF16Length(str, pos)) {
	    codePoints.push(str.codePointAt(pos));
	  }
	  return codePoints;
	}
	
	var UnicodeUtils = {
	  getCodePoints: getCodePoints,
	  getUTF16Length: getUTF16Length,
	  hasSurrogateUnit: hasSurrogateUnit,
	  isCodeUnitInSurrogateRange: isCodeUnitInSurrogateRange,
	  isSurrogatePair: isSurrogatePair,
	  strlen: strlen,
	  substring: substring,
	  substr: substr
	};
	
	module.exports = UnicodeUtils;

/***/ },
/* 446 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	exports.__esModule = true;
	exports["default"] = undefined;
	
	var _react = __webpack_require__(43);
	
	var _propTypes = __webpack_require__(523);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	var _storeShape = __webpack_require__(510);
	
	var _storeShape2 = _interopRequireDefault(_storeShape);
	
	var _warning = __webpack_require__(511);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { "default": obj };
	}
	
	function _classCallCheck(instance, Constructor) {
	  if (!(instance instanceof Constructor)) {
	    throw new TypeError("Cannot call a class as a function");
	  }
	}
	
	function _possibleConstructorReturn(self, call) {
	  if (!self) {
	    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
	  }return call && ((typeof call === 'undefined' ? 'undefined' : _typeof(call)) === "object" || typeof call === "function") ? call : self;
	}
	
	function _inherits(subClass, superClass) {
	  if (typeof superClass !== "function" && superClass !== null) {
	    throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === 'undefined' ? 'undefined' : _typeof(superClass)));
	  }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
	}
	
	var didWarnAboutReceivingStore = false;
	function warnAboutReceivingStore() {
	  if (didWarnAboutReceivingStore) {
	    return;
	  }
	  didWarnAboutReceivingStore = true;
	
	  (0, _warning2["default"])('<Provider> does not support changing `store` on the fly. ' + 'It is most likely that you see this error because you updated to ' + 'Redux 2.x and React Redux 2.x which no longer hot reload reducers ' + 'automatically. See https://github.com/reactjs/react-redux/releases/' + 'tag/v2.0.0 for the migration instructions.');
	}
	
	var Provider = function (_Component) {
	  _inherits(Provider, _Component);
	
	  Provider.prototype.getChildContext = function getChildContext() {
	    return { store: this.store };
	  };
	
	  function Provider(props, context) {
	    _classCallCheck(this, Provider);
	
	    var _this = _possibleConstructorReturn(this, _Component.call(this, props, context));
	
	    _this.store = props.store;
	    return _this;
	  }
	
	  Provider.prototype.render = function render() {
	    return _react.Children.only(this.props.children);
	  };
	
	  return Provider;
	}(_react.Component);
	
	exports["default"] = Provider;
	
	if (true) {
	  Provider.prototype.componentWillReceiveProps = function (nextProps) {
	    var store = this.store;
	    var nextStore = nextProps.store;
	
	    if (store !== nextStore) {
	      warnAboutReceivingStore();
	    }
	  };
	}
	
	Provider.propTypes = {
	  store: _storeShape2["default"].isRequired,
	  children: _propTypes2["default"].element.isRequired
	};
	Provider.childContextTypes = {
	  store: _storeShape2["default"].isRequired
	};

/***/ },
/* 447 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	exports.__esModule = true;
	
	var _extends = Object.assign || function (target) {
	  for (var i = 1; i < arguments.length; i++) {
	    var source = arguments[i];for (var key in source) {
	      if (Object.prototype.hasOwnProperty.call(source, key)) {
	        target[key] = source[key];
	      }
	    }
	  }return target;
	};
	
	exports["default"] = connect;
	
	var _react = __webpack_require__(43);
	
	var _storeShape = __webpack_require__(510);
	
	var _storeShape2 = _interopRequireDefault(_storeShape);
	
	var _shallowEqual = __webpack_require__(512);
	
	var _shallowEqual2 = _interopRequireDefault(_shallowEqual);
	
	var _wrapActionCreators = __webpack_require__(513);
	
	var _wrapActionCreators2 = _interopRequireDefault(_wrapActionCreators);
	
	var _warning = __webpack_require__(511);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	var _isPlainObject = __webpack_require__(537);
	
	var _isPlainObject2 = _interopRequireDefault(_isPlainObject);
	
	var _hoistNonReactStatics = __webpack_require__(539);
	
	var _hoistNonReactStatics2 = _interopRequireDefault(_hoistNonReactStatics);
	
	var _invariant = __webpack_require__(538);
	
	var _invariant2 = _interopRequireDefault(_invariant);
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { "default": obj };
	}
	
	function _classCallCheck(instance, Constructor) {
	  if (!(instance instanceof Constructor)) {
	    throw new TypeError("Cannot call a class as a function");
	  }
	}
	
	function _possibleConstructorReturn(self, call) {
	  if (!self) {
	    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
	  }return call && ((typeof call === 'undefined' ? 'undefined' : _typeof(call)) === "object" || typeof call === "function") ? call : self;
	}
	
	function _inherits(subClass, superClass) {
	  if (typeof superClass !== "function" && superClass !== null) {
	    throw new TypeError("Super expression must either be null or a function, not " + (typeof superClass === 'undefined' ? 'undefined' : _typeof(superClass)));
	  }subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } });if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
	}
	
	var defaultMapStateToProps = function defaultMapStateToProps(state) {
	  return {};
	}; // eslint-disable-line no-unused-vars
	var defaultMapDispatchToProps = function defaultMapDispatchToProps(dispatch) {
	  return { dispatch: dispatch };
	};
	var defaultMergeProps = function defaultMergeProps(stateProps, dispatchProps, parentProps) {
	  return _extends({}, parentProps, stateProps, dispatchProps);
	};
	
	function getDisplayName(WrappedComponent) {
	  return WrappedComponent.displayName || WrappedComponent.name || 'Component';
	}
	
	var errorObject = { value: null };
	function tryCatch(fn, ctx) {
	  try {
	    return fn.apply(ctx);
	  } catch (e) {
	    errorObject.value = e;
	    return errorObject;
	  }
	}
	
	// Helps track hot reloading.
	var nextVersion = 0;
	
	function connect(mapStateToProps, mapDispatchToProps, mergeProps) {
	  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
	
	  var shouldSubscribe = Boolean(mapStateToProps);
	  var mapState = mapStateToProps || defaultMapStateToProps;
	
	  var mapDispatch = void 0;
	  if (typeof mapDispatchToProps === 'function') {
	    mapDispatch = mapDispatchToProps;
	  } else if (!mapDispatchToProps) {
	    mapDispatch = defaultMapDispatchToProps;
	  } else {
	    mapDispatch = (0, _wrapActionCreators2["default"])(mapDispatchToProps);
	  }
	
	  var finalMergeProps = mergeProps || defaultMergeProps;
	  var _options$pure = options.pure,
	      pure = _options$pure === undefined ? true : _options$pure,
	      _options$withRef = options.withRef,
	      withRef = _options$withRef === undefined ? false : _options$withRef;
	
	  var checkMergedEquals = pure && finalMergeProps !== defaultMergeProps;
	
	  // Helps track hot reloading.
	  var version = nextVersion++;
	
	  return function wrapWithConnect(WrappedComponent) {
	    var connectDisplayName = 'Connect(' + getDisplayName(WrappedComponent) + ')';
	
	    function checkStateShape(props, methodName) {
	      if (!(0, _isPlainObject2["default"])(props)) {
	        (0, _warning2["default"])(methodName + '() in ' + connectDisplayName + ' must return a plain object. ' + ('Instead received ' + props + '.'));
	      }
	    }
	
	    function computeMergedProps(stateProps, dispatchProps, parentProps) {
	      var mergedProps = finalMergeProps(stateProps, dispatchProps, parentProps);
	      if (true) {
	        checkStateShape(mergedProps, 'mergeProps');
	      }
	      return mergedProps;
	    }
	
	    var Connect = function (_Component) {
	      _inherits(Connect, _Component);
	
	      Connect.prototype.shouldComponentUpdate = function shouldComponentUpdate() {
	        return !pure || this.haveOwnPropsChanged || this.hasStoreStateChanged;
	      };
	
	      function Connect(props, context) {
	        _classCallCheck(this, Connect);
	
	        var _this = _possibleConstructorReturn(this, _Component.call(this, props, context));
	
	        _this.version = version;
	        _this.store = props.store || context.store;
	
	        (0, _invariant2["default"])(_this.store, 'Could not find "store" in either the context or ' + ('props of "' + connectDisplayName + '". ') + 'Either wrap the root component in a <Provider>, ' + ('or explicitly pass "store" as a prop to "' + connectDisplayName + '".'));
	
	        var storeState = _this.store.getState();
	        _this.state = { storeState: storeState };
	        _this.clearCache();
	        return _this;
	      }
	
	      Connect.prototype.computeStateProps = function computeStateProps(store, props) {
	        if (!this.finalMapStateToProps) {
	          return this.configureFinalMapState(store, props);
	        }
	
	        var state = store.getState();
	        var stateProps = this.doStatePropsDependOnOwnProps ? this.finalMapStateToProps(state, props) : this.finalMapStateToProps(state);
	
	        if (true) {
	          checkStateShape(stateProps, 'mapStateToProps');
	        }
	        return stateProps;
	      };
	
	      Connect.prototype.configureFinalMapState = function configureFinalMapState(store, props) {
	        var mappedState = mapState(store.getState(), props);
	        var isFactory = typeof mappedState === 'function';
	
	        this.finalMapStateToProps = isFactory ? mappedState : mapState;
	        this.doStatePropsDependOnOwnProps = this.finalMapStateToProps.length !== 1;
	
	        if (isFactory) {
	          return this.computeStateProps(store, props);
	        }
	
	        if (true) {
	          checkStateShape(mappedState, 'mapStateToProps');
	        }
	        return mappedState;
	      };
	
	      Connect.prototype.computeDispatchProps = function computeDispatchProps(store, props) {
	        if (!this.finalMapDispatchToProps) {
	          return this.configureFinalMapDispatch(store, props);
	        }
	
	        var dispatch = store.dispatch;
	
	        var dispatchProps = this.doDispatchPropsDependOnOwnProps ? this.finalMapDispatchToProps(dispatch, props) : this.finalMapDispatchToProps(dispatch);
	
	        if (true) {
	          checkStateShape(dispatchProps, 'mapDispatchToProps');
	        }
	        return dispatchProps;
	      };
	
	      Connect.prototype.configureFinalMapDispatch = function configureFinalMapDispatch(store, props) {
	        var mappedDispatch = mapDispatch(store.dispatch, props);
	        var isFactory = typeof mappedDispatch === 'function';
	
	        this.finalMapDispatchToProps = isFactory ? mappedDispatch : mapDispatch;
	        this.doDispatchPropsDependOnOwnProps = this.finalMapDispatchToProps.length !== 1;
	
	        if (isFactory) {
	          return this.computeDispatchProps(store, props);
	        }
	
	        if (true) {
	          checkStateShape(mappedDispatch, 'mapDispatchToProps');
	        }
	        return mappedDispatch;
	      };
	
	      Connect.prototype.updateStatePropsIfNeeded = function updateStatePropsIfNeeded() {
	        var nextStateProps = this.computeStateProps(this.store, this.props);
	        if (this.stateProps && (0, _shallowEqual2["default"])(nextStateProps, this.stateProps)) {
	          return false;
	        }
	
	        this.stateProps = nextStateProps;
	        return true;
	      };
	
	      Connect.prototype.updateDispatchPropsIfNeeded = function updateDispatchPropsIfNeeded() {
	        var nextDispatchProps = this.computeDispatchProps(this.store, this.props);
	        if (this.dispatchProps && (0, _shallowEqual2["default"])(nextDispatchProps, this.dispatchProps)) {
	          return false;
	        }
	
	        this.dispatchProps = nextDispatchProps;
	        return true;
	      };
	
	      Connect.prototype.updateMergedPropsIfNeeded = function updateMergedPropsIfNeeded() {
	        var nextMergedProps = computeMergedProps(this.stateProps, this.dispatchProps, this.props);
	        if (this.mergedProps && checkMergedEquals && (0, _shallowEqual2["default"])(nextMergedProps, this.mergedProps)) {
	          return false;
	        }
	
	        this.mergedProps = nextMergedProps;
	        return true;
	      };
	
	      Connect.prototype.isSubscribed = function isSubscribed() {
	        return typeof this.unsubscribe === 'function';
	      };
	
	      Connect.prototype.trySubscribe = function trySubscribe() {
	        if (shouldSubscribe && !this.unsubscribe) {
	          this.unsubscribe = this.store.subscribe(this.handleChange.bind(this));
	          this.handleChange();
	        }
	      };
	
	      Connect.prototype.tryUnsubscribe = function tryUnsubscribe() {
	        if (this.unsubscribe) {
	          this.unsubscribe();
	          this.unsubscribe = null;
	        }
	      };
	
	      Connect.prototype.componentDidMount = function componentDidMount() {
	        this.trySubscribe();
	      };
	
	      Connect.prototype.componentWillReceiveProps = function componentWillReceiveProps(nextProps) {
	        if (!pure || !(0, _shallowEqual2["default"])(nextProps, this.props)) {
	          this.haveOwnPropsChanged = true;
	        }
	      };
	
	      Connect.prototype.componentWillUnmount = function componentWillUnmount() {
	        this.tryUnsubscribe();
	        this.clearCache();
	      };
	
	      Connect.prototype.clearCache = function clearCache() {
	        this.dispatchProps = null;
	        this.stateProps = null;
	        this.mergedProps = null;
	        this.haveOwnPropsChanged = true;
	        this.hasStoreStateChanged = true;
	        this.haveStatePropsBeenPrecalculated = false;
	        this.statePropsPrecalculationError = null;
	        this.renderedElement = null;
	        this.finalMapDispatchToProps = null;
	        this.finalMapStateToProps = null;
	      };
	
	      Connect.prototype.handleChange = function handleChange() {
	        if (!this.unsubscribe) {
	          return;
	        }
	
	        var storeState = this.store.getState();
	        var prevStoreState = this.state.storeState;
	        if (pure && prevStoreState === storeState) {
	          return;
	        }
	
	        if (pure && !this.doStatePropsDependOnOwnProps) {
	          var haveStatePropsChanged = tryCatch(this.updateStatePropsIfNeeded, this);
	          if (!haveStatePropsChanged) {
	            return;
	          }
	          if (haveStatePropsChanged === errorObject) {
	            this.statePropsPrecalculationError = errorObject.value;
	          }
	          this.haveStatePropsBeenPrecalculated = true;
	        }
	
	        this.hasStoreStateChanged = true;
	        this.setState({ storeState: storeState });
	      };
	
	      Connect.prototype.getWrappedInstance = function getWrappedInstance() {
	        (0, _invariant2["default"])(withRef, 'To access the wrapped instance, you need to specify ' + '{ withRef: true } as the fourth argument of the connect() call.');
	
	        return this.refs.wrappedInstance;
	      };
	
	      Connect.prototype.render = function render() {
	        var haveOwnPropsChanged = this.haveOwnPropsChanged,
	            hasStoreStateChanged = this.hasStoreStateChanged,
	            haveStatePropsBeenPrecalculated = this.haveStatePropsBeenPrecalculated,
	            statePropsPrecalculationError = this.statePropsPrecalculationError,
	            renderedElement = this.renderedElement;
	
	        this.haveOwnPropsChanged = false;
	        this.hasStoreStateChanged = false;
	        this.haveStatePropsBeenPrecalculated = false;
	        this.statePropsPrecalculationError = null;
	
	        if (statePropsPrecalculationError) {
	          throw statePropsPrecalculationError;
	        }
	
	        var shouldUpdateStateProps = true;
	        var shouldUpdateDispatchProps = true;
	        if (pure && renderedElement) {
	          shouldUpdateStateProps = hasStoreStateChanged || haveOwnPropsChanged && this.doStatePropsDependOnOwnProps;
	          shouldUpdateDispatchProps = haveOwnPropsChanged && this.doDispatchPropsDependOnOwnProps;
	        }
	
	        var haveStatePropsChanged = false;
	        var haveDispatchPropsChanged = false;
	        if (haveStatePropsBeenPrecalculated) {
	          haveStatePropsChanged = true;
	        } else if (shouldUpdateStateProps) {
	          haveStatePropsChanged = this.updateStatePropsIfNeeded();
	        }
	        if (shouldUpdateDispatchProps) {
	          haveDispatchPropsChanged = this.updateDispatchPropsIfNeeded();
	        }
	
	        var haveMergedPropsChanged = true;
	        if (haveStatePropsChanged || haveDispatchPropsChanged || haveOwnPropsChanged) {
	          haveMergedPropsChanged = this.updateMergedPropsIfNeeded();
	        } else {
	          haveMergedPropsChanged = false;
	        }
	
	        if (!haveMergedPropsChanged && renderedElement) {
	          return renderedElement;
	        }
	
	        if (withRef) {
	          this.renderedElement = (0, _react.createElement)(WrappedComponent, _extends({}, this.mergedProps, {
	            ref: 'wrappedInstance'
	          }));
	        } else {
	          this.renderedElement = (0, _react.createElement)(WrappedComponent, this.mergedProps);
	        }
	
	        return this.renderedElement;
	      };
	
	      return Connect;
	    }(_react.Component);
	
	    Connect.displayName = connectDisplayName;
	    Connect.WrappedComponent = WrappedComponent;
	    Connect.contextTypes = {
	      store: _storeShape2["default"]
	    };
	    Connect.propTypes = {
	      store: _storeShape2["default"]
	    };
	
	    if (true) {
	      Connect.prototype.componentWillUpdate = function componentWillUpdate() {
	        if (this.version === version) {
	          return;
	        }
	
	        // We are hot reloading!
	        this.version = version;
	        this.trySubscribe();
	        this.clearCache();
	      };
	    }
	
	    return (0, _hoistNonReactStatics2["default"])(Connect, WrappedComponent);
	  };
	}

/***/ },
/* 448 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * A manager for our node-to-ID system. In particular, this class is
	 * responsible for maintaing a mapping between DOM nodes and node IDs, and
	 * translating touch events from the raw positions at which they occur to the
	 * nodes over which they are occurring. This differs from browser behavior, in
	 * which touch events are only sent to the node in which a touch started.
	 */
	
	var NodeManager = function () {
	    function NodeManager() {
	        var _this = this;
	
	        _classCallCheck(this, NodeManager);
	
	        // A mapping from IDs to DOM nodes.
	        this._nodesById = {};
	
	        // A mapping from IDs to the borders around the DOM nodes, which can be
	        // useful for layout purposes.
	        this._bordersById = {};
	
	        // An ordered list of IDs, where DOM nodes that are "higher" on the
	        // page come earlier in the list. Note that an ID may be present in
	        // this ordered list but not be registered to a DOM node (i.e., if it
	        // is registered as a child of another DOM node, but hasn't appeared in
	        // the DOM yet).
	        this._orderedIds = [];
	
	        // Cache bounding boxes aggressively, re-computing on page resize. Our
	        // caching here makes the strict assumption that if a node is reasonably
	        // assumed to be on-screen, its bounds won't change. For example, if we
	        // see that a touch occurred within the bounds of a node, we cache those
	        // bounds.
	        // TODO(charlie): It'd be great if we could pre-compute these when the
	        // page is idle and the keypad is visible (i.e., the nodes are in their
	        // proper positions).
	        this._cachedBoundingBoxesById = {};
	        window.addEventListener('resize', function () {
	            _this._cachedBoundingBoxesById = {};
	        });
	    }
	
	    /**
	     * Register a DOM node with a given identifier.
	     *
	     * @param {string} id - the identifier of the given node
	     * @param {node} domNode - the DOM node linked to the identifier
	     * @param {object} borders - an opaque object describing the node's borders
	     */
	
	
	    NodeManager.prototype.registerDOMNode = function registerDOMNode(id, domNode, childIds, borders) {
	        this._nodesById[id] = domNode;
	        this._bordersById[id] = borders;
	
	        // Make sure that any children appear first.
	        // TODO(charlie): This is a very simplistic system that wouldn't
	        // properly handle multiple levels of nesting.
	        var allIds = [].concat(childIds || [], [id], this._orderedIds);
	
	        // De-dupe the list of IDs.
	        var orderedIds = [];
	        var seenIds = {};
	        for (var _iterator = allIds, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
	            var _ref;
	
	            if (_isArray) {
	                if (_i >= _iterator.length) break;
	                _ref = _iterator[_i++];
	            } else {
	                _i = _iterator.next();
	                if (_i.done) break;
	                _ref = _i.value;
	            }
	
	            var _id = _ref;
	
	            if (!seenIds[_id]) {
	                orderedIds.push(_id);
	                seenIds[_id] = true;
	            }
	        }
	
	        this._orderedIds = orderedIds;
	    };
	
	    /**
	     * Unregister the DOM node with the given identifier.
	     *
	     * @param {string} id - the identifier of the node to unregister
	     */
	
	
	    NodeManager.prototype.unregisterDOMNode = function unregisterDOMNode(id) {
	        delete this._nodesById[id];
	    };
	
	    /**
	     * Return the identifier of the topmost node located at the given
	     * coordinates.
	     *
	     * @param {number} x - the x coordinate at which to search for a node
	     * @param {number} y - the y coordinate at which to search for a node
	     * @returns {null|string} - null or the identifier of the topmost node at
	     *                          the given coordinates
	     */
	
	
	    NodeManager.prototype.idForCoords = function idForCoords(x, y) {
	        for (var _iterator2 = this._orderedIds, _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
	            var _ref2;
	
	            if (_isArray2) {
	                if (_i2 >= _iterator2.length) break;
	                _ref2 = _iterator2[_i2++];
	            } else {
	                _i2 = _iterator2.next();
	                if (_i2.done) break;
	                _ref2 = _i2.value;
	            }
	
	            var id = _ref2;
	
	            var domNode = this._nodesById[id];
	            if (domNode) {
	                var bounds = domNode.getBoundingClientRect();
	                if (bounds.left <= x && bounds.right > x && bounds.top <= y && bounds.bottom > y) {
	                    this._cachedBoundingBoxesById[id] = bounds;
	                    return id;
	                }
	            }
	        }
	    };
	
	    /**
	     * Return the necessary layout information, including the bounds and border
	     * values, for the node with the given identifier.
	     *
	     * @param {string} id - the identifier of the node for which to return the
	     *                      layout information
	     * @returns {object} - the bounding client rect for the given node, along
	     *                     with its borders
	     */
	
	
	    NodeManager.prototype.layoutPropsForId = function layoutPropsForId(id) {
	        if (!this._cachedBoundingBoxesById[id]) {
	            this._cachedBoundingBoxesById[id] = this._nodesById[id].getBoundingClientRect();
	        }
	
	        return {
	            initialBounds: this._cachedBoundingBoxesById[id],
	            borders: this._bordersById[id]
	        };
	    };
	
	    return NodeManager;
	}();
	
	module.exports = NodeManager;

/***/ },
/* 449 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * A state machine for the popover state. In particular, this class manages the
	 * mapping of parent nodes to their children, and translates touch events that
	 * traverse various nodes to actions that are conditioned on whether a popover
	 * is present.
	 */
	
	var PopoverStateMachine = function () {
	    function PopoverStateMachine(handlers) {
	        _classCallCheck(this, PopoverStateMachine);
	
	        this.handlers = handlers;
	
	        this.activePopover = null;
	        this.popovers = {};
	    }
	
	    /**
	     * Register a popover container as containing a set of children.
	     *
	     * @param {string} id - the identifier of the popover container
	     * @param {string[]} childIds - the identifiers of the nodes contained in
	     *                              the popover container
	     */
	
	
	    PopoverStateMachine.prototype.registerPopover = function registerPopover(id, childIds) {
	        this.popovers[id] = childIds;
	    };
	
	    /**
	     * Unregister a popover container.
	     *
	     * @param {string} id - the identifier of the popover container to
	     *                      unregister
	     */
	
	
	    PopoverStateMachine.prototype.unregisterPopover = function unregisterPopover(id) {
	        delete this.popovers[id];
	    };
	
	    /**
	     * @returns {boolean} - whether a popover is active and visible
	     */
	
	
	    PopoverStateMachine.prototype.isPopoverVisible = function isPopoverVisible() {
	        return this.activePopover != null;
	    };
	
	    /**
	     * Blur the active nodes.
	     */
	
	
	    PopoverStateMachine.prototype.onBlur = function onBlur() {
	        this.activePopover = null;
	        this.handlers.onActiveNodesChanged({
	            popover: null,
	            focus: null
	        });
	    };
	
	    /**
	     * Handle a focus event on the node with the given identifier.
	     *
	     * @param {string} id - the identifier of the node that was focused
	     */
	
	
	    PopoverStateMachine.prototype.onFocus = function onFocus(id) {
	        if (this.activePopover) {
	            // If we have a popover that is currently active, we focus this
	            // node if it's in the popover, and remove any highlight otherwise.
	            if (this._isNodeInsidePopover(this.activePopover, id)) {
	                this.handlers.onActiveNodesChanged({
	                    popover: {
	                        parentId: this.activePopover,
	                        childIds: this.popovers[this.activePopover]
	                    },
	                    focus: id
	                });
	            } else {
	                this.handlers.onActiveNodesChanged({
	                    popover: {
	                        parentId: this.activePopover,
	                        childIds: this.popovers[this.activePopover]
	                    },
	                    focus: null
	                });
	            }
	        } else {
	            this.activePopover = null;
	            this.handlers.onActiveNodesChanged({
	                popover: null,
	                focus: id
	            });
	        }
	    };
	
	    /**
	     * Handle a long press event on the node with the given identifier.
	     *
	     * @param {string} id - the identifier of the node that was long-pressed
	     */
	
	
	    PopoverStateMachine.prototype.onLongPress = function onLongPress(id) {
	        // We only care about long presses if they occur on a popover, and we
	        // don't already have a popover active.
	        if (!this.activePopover && this.popovers[id]) {
	            // NOTE(charlie): There's an assumption here that focusing the
	            // first child is the correct behavior for a newly focused popover.
	            // This relies on the fact that the children are rendered
	            // bottom-up. If that rendering changes, this logic will need to
	            // change as well.
	            this.activePopover = id;
	            this.handlers.onActiveNodesChanged({
	                popover: {
	                    parentId: this.activePopover,
	                    childIds: this.popovers[this.activePopover]
	                },
	                focus: this._defaultNodeForPopover(this.activePopover)
	            });
	        }
	    };
	
	    /**
	     * Handle the trigger (click or hold) of the node with the given identifier.
	     *
	     * @param {string} id - the identifier of the node that was triggered
	    */
	
	
	    PopoverStateMachine.prototype.onTrigger = function onTrigger(id) {
	        this.handlers.onClick(id, id, false);
	    };
	
	    /**
	     * Handle a touch-end event on the node with the given identifier.
	     *
	     * @param {string} id - the identifier of the node over which the touch
	     *                      ended
	     */
	
	
	    PopoverStateMachine.prototype.onTouchEnd = function onTouchEnd(id) {
	        var inPopover = !!this.activePopover;
	        if (inPopover) {
	            // If we have a popover that is currently active, we trigger a
	            // click on this node if and only if it's in the popover, with the
	            // exception that, if the node passed back _is_ the active popover,
	            // then we trigger its default node. This latter case should only
	            // be triggered if the user were to tap down on a popover-enabled
	            // node, hold for long enough for the popover to appear, and then
	            // release without ever moving their finger, in which case, the
	            // underlying gesture system would have no idea that the popover's
	            // first child node was now focused.
	            if (this._isNodeInsidePopover(this.activePopover, id)) {
	                this.handlers.onClick(id, id, inPopover);
	            } else if (this.activePopover === id) {
	                var keyId = this._defaultNodeForPopover(id);
	                this.handlers.onClick(keyId, keyId, inPopover);
	            }
	        } else if (this.popovers[id]) {
	            // Otherwise, if the node is itself a popover revealer, trigger the
	            // clicking of its default node, but pass back the popover node ID
	            // for layout purposes.
	            var _keyId = this._defaultNodeForPopover(id);
	            var domNodeId = id;
	            this.handlers.onClick(_keyId, domNodeId, inPopover);
	        } else if (id != null) {
	            // Finally, if we have no active popover, and we touched up over a
	            // valid key, trigger a click.
	            this.onTrigger(id);
	        }
	
	        this.onBlur();
	    };
	
	    PopoverStateMachine.prototype._isNodeInsidePopover = function _isNodeInsidePopover(popover, id) {
	        return this.popovers[popover].includes(id);
	    };
	
	    PopoverStateMachine.prototype._defaultNodeForPopover = function _defaultNodeForPopover(popover) {
	        return this.popovers[popover][0];
	    };
	
	    return PopoverStateMachine;
	}();
	
	module.exports = PopoverStateMachine;

/***/ },
/* 450 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * The state machine that backs our gesture system. In particular, this state
	 * machine manages the interplay between focuses, touch ups, and swiping.
	 * It is entirely ignorant of the existence of popovers and the positions of
	 * DOM nodes, operating solely on IDs. The state machine does accommodate for
	 * multi-touch interactions, tracking gesture state on a per-touch basis.
	 */
	
	var defaults = {
	    longPressWaitTimeMs: 50,
	    swipeThresholdPx: 20,
	    holdIntervalMs: 250
	};
	
	var GestureStateMachine = function () {
	    function GestureStateMachine(handlers, options, swipeDisabledNodeIds, multiPressableKeys) {
	        _classCallCheck(this, GestureStateMachine);
	
	        this.handlers = handlers;
	        this.options = _extends({}, defaults, options);
	        this.swipeDisabledNodeIds = swipeDisabledNodeIds || [];
	        this.multiPressableKeys = multiPressableKeys || [];
	
	        // TODO(charlie): Flow-type this file. It's not great that we're now
	        // passing around these opaque state objects.
	        this.touchState = {};
	        this.swipeState = null;
	    }
	
	    GestureStateMachine.prototype._maybeCancelLongPressForTouch = function _maybeCancelLongPressForTouch(touchId) {
	        var longPressTimeoutId = this.touchState[touchId].longPressTimeoutId;
	
	        if (longPressTimeoutId) {
	            clearTimeout(longPressTimeoutId);
	            this.touchState[touchId] = _extends({}, this.touchState[touchId], {
	                longPressTimeoutId: null
	            });
	        }
	    };
	
	    GestureStateMachine.prototype._maybeCancelPressAndHoldForTouch = function _maybeCancelPressAndHoldForTouch(touchId) {
	        var pressAndHoldIntervalId = this.touchState[touchId].pressAndHoldIntervalId;
	
	        if (pressAndHoldIntervalId) {
	            // If there was an interval set to detect holds, clear it out.
	            clearInterval(pressAndHoldIntervalId);
	            this.touchState[touchId] = _extends({}, this.touchState[touchId], {
	                pressAndHoldIntervalId: null
	            });
	        }
	    };
	
	    GestureStateMachine.prototype._cleanupTouchEvent = function _cleanupTouchEvent(touchId) {
	        this._maybeCancelLongPressForTouch(touchId);
	        this._maybeCancelPressAndHoldForTouch(touchId);
	        delete this.touchState[touchId];
	    };
	
	    /**
	     * Handle a focus event on the node with the given identifier, which may be
	     * `null` to indicate that the user has dragged their finger off of any
	     * registered nodes, but is still in the middle of a gesture.
	     *
	     * @param {string|null} id - the identifier of the newly focused node, or
	     *                           `null` if no node is focused
	     * @param {number} touchId - a unique identifier associated with the touch
	     */
	
	
	    GestureStateMachine.prototype._onFocus = function _onFocus(id, touchId) {
	        var _this = this;
	
	        // If we're in the middle of a long-press, cancel it.
	        this._maybeCancelLongPressForTouch(touchId);
	
	        // Reset any existing hold-detecting interval.
	        this._maybeCancelPressAndHoldForTouch(touchId);
	
	        // Set the focused node ID and handle the focus event.
	        // Note: we can call `onFocus` with `null` IDs. The semantics of an
	        // `onFocus` with a `null` ID differs from that of `onBlur`. The former
	        // indicates that a gesture that can focus future nodes is still in
	        // progress, but that no node is currently focused. The latter
	        // indicates that the gesture has ended and nothing will be focused.
	        this.touchState[touchId] = _extends({}, this.touchState[touchId], {
	            activeNodeId: id
	        });
	        this.handlers.onFocus(id);
	
	        if (id) {
	            // Handle logic for repeating button presses.
	            if (this.multiPressableKeys.includes(id)) {
	                // Start by triggering a click, iOS style.
	                this.handlers.onTrigger(id);
	
	                // Set up a new hold detector for the current button.
	                this.touchState[touchId] = _extends({}, this.touchState[touchId], {
	                    pressAndHoldIntervalId: setInterval(function () {
	                        // On every cycle, trigger the click handler.
	                        _this.handlers.onTrigger(id);
	                    }, this.options.holdIntervalMs)
	                });
	            } else {
	                // Set up a new hold detector for the current button.
	                this.touchState[touchId] = _extends({}, this.touchState[touchId], {
	                    longPressTimeoutId: setTimeout(function () {
	                        _this.handlers.onLongPress(id);
	                        _this.touchState[touchId] = _extends({}, _this.touchState[touchId], {
	                            longPressTimeoutId: null
	                        });
	                    }, this.options.longPressWaitTimeMs)
	                });
	            }
	        }
	    };
	
	    /**
	     * Clear out all active gesture information.
	     */
	
	
	    GestureStateMachine.prototype._onSwipeStart = function _onSwipeStart() {
	        for (var _iterator = Object.keys(this.touchState), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
	            var _ref;
	
	            if (_isArray) {
	                if (_i >= _iterator.length) break;
	                _ref = _iterator[_i++];
	            } else {
	                _i = _iterator.next();
	                if (_i.done) break;
	                _ref = _i.value;
	            }
	
	            var activeTouchId = _ref;
	
	            this._maybeCancelLongPressForTouch(activeTouchId);
	            this._maybeCancelPressAndHoldForTouch(activeTouchId);
	        }
	        this.touchState = {};
	        this.handlers.onBlur();
	    };
	
	    /**
	     * A function that returns the identifier of the node over which the touch
	     * event occurred. This is provided as a piece of lazy computation, as
	     * computing the DOM node for a given point is expensive, and the state
	     * machine won't always need that information. For example, if the user is
	     * swiping, then `onTouchMove` needs to be performant and doesn't care about
	     * the node over which the touch occurred.
	     *
	     * @typedef idComputation
	     * @returns {DOMNode} - the identifier of the node over which the touch
	     *                      occurred
	     */
	
	    /**
	     * Handle a touch-start event on the node with the given identifer.
	     *
	     * @param {idComputation} getId - a function that returns identifier of the
	     *                                node over which the start event occurred
	     * @param {number} touchId - a unique identifier associated with the touch
	     */
	
	
	    GestureStateMachine.prototype.onTouchStart = function onTouchStart(getId, touchId, pageX) {
	        // Ignore any touch events that start mid-swipe.
	        if (this.swipeState) {
	            return;
	        }
	
	        if (this.touchState[touchId]) {
	            // It turns out we can get multiple touch starts with no
	            // intervening move, end, or cancel events in Android WebViews.
	            // TODO(benkomalo): it's not entirely clear why this happens, but
	            // it seems to happen with the backspace button. It may be related
	            // to FastClick (https://github.com/ftlabs/fastclick/issues/71)
	            // though I haven't verified, and it's probably good to be robust
	            // here anyways.
	            return;
	        }
	
	        var startingNodeId = getId();
	        this.touchState[touchId] = {
	            swipeLocked: this.swipeDisabledNodeIds.includes(startingNodeId),
	            startX: pageX
	        };
	
	        this._onFocus(startingNodeId, touchId);
	    };
	
	    /**
	     * Handle a touch-move event on the node with the given identifer.
	     *
	     * @param {idComputation} getId - a function that returns identifier of the
	     *                                node over which the move event occurred
	     * @param {number} touchId - a unique identifier associated with the touch
	     * @param {number} pageX - the x coordinate of the touch
	     * @param {boolean} swipeEnabled - whether the system should allow for
	     *                                 transitions into a swiping state
	     */
	
	
	    GestureStateMachine.prototype.onTouchMove = function onTouchMove(getId, touchId, pageX, swipeEnabled) {
	        if (this.swipeState) {
	            // Only respect the finger that started a swipe. Any other lingering
	            // gestures are ignored.
	            if (this.swipeState.touchId === touchId) {
	                this.handlers.onSwipeChange(pageX - this.swipeState.startX);
	            }
	        } else if (this.touchState[touchId]) {
	            // It could be touch events started outside the keypad and
	            // moved into it; ignore them.
	            var _touchState$touchId = this.touchState[touchId],
	                activeNodeId = _touchState$touchId.activeNodeId,
	                startX = _touchState$touchId.startX,
	                swipeLocked = _touchState$touchId.swipeLocked;
	
	
	            var dx = pageX - startX;
	            var shouldBeginSwiping = swipeEnabled && !swipeLocked && Math.abs(dx) > this.options.swipeThresholdPx;
	
	            if (shouldBeginSwiping) {
	                this._onSwipeStart();
	
	                // Trigger the swipe.
	                this.swipeState = {
	                    touchId: touchId,
	                    startX: startX
	                };
	                this.handlers.onSwipeChange(pageX - this.swipeState.startX);
	            } else {
	                var id = getId();
	                if (id !== activeNodeId) {
	                    this._onFocus(id, touchId);
	                }
	            }
	        }
	    };
	
	    /**
	     * Handle a touch-end event on the node with the given identifer.
	     *
	     * @param {idComputation} getId - a function that returns identifier of the
	     *                                node over which the end event occurred
	     * @param {number} touchId - a unique identifier associated with the touch
	     * @param {number} pageX - the x coordinate of the touch
	     */
	
	
	    GestureStateMachine.prototype.onTouchEnd = function onTouchEnd(getId, touchId, pageX) {
	        if (this.swipeState) {
	            // Only respect the finger that started a swipe. Any other lingering
	            // gestures are ignored.
	            if (this.swipeState.touchId === touchId) {
	                this.handlers.onSwipeEnd(pageX - this.swipeState.startX);
	                this.swipeState = null;
	            }
	        } else if (this.touchState[touchId]) {
	            // It could be touch events started outside the keypad and
	            // moved into it; ignore them.
	            var _touchState$touchId2 = this.touchState[touchId],
	                activeNodeId = _touchState$touchId2.activeNodeId,
	                pressAndHoldIntervalId = _touchState$touchId2.pressAndHoldIntervalId;
	
	
	            this._cleanupTouchEvent(touchId);
	
	            var didPressAndHold = !!pressAndHoldIntervalId;
	            if (didPressAndHold) {
	                // We don't trigger a touch end if there was a press and hold,
	                // because the key has been triggered at least once and calling
	                // the onTouchEnd handler would add an extra trigger.
	                this.handlers.onBlur();
	            } else {
	                // Trigger a touch-end. There's no need to notify clients of a
	                // blur as clients are responsible for handling any cleanup in
	                // their touch-end handlers.
	                this.handlers.onTouchEnd(activeNodeId);
	            }
	        }
	    };
	
	    /**
	     * Handle a touch-cancel event.
	     */
	
	
	    GestureStateMachine.prototype.onTouchCancel = function onTouchCancel(touchId) {
	        // If a touch is cancelled and we're swiping, end the swipe with no
	        // displacement.
	        if (this.swipeState) {
	            if (this.swipeState.touchId === touchId) {
	                this.handlers.onSwipeEnd(0);
	                this.swipeState = null;
	            }
	        } else if (this.touchState[touchId]) {
	            // Otherwise, trigger a full blur. We don't want to trigger a
	            // touch-up, since the cancellation means that the user probably
	            // didn't release over a key intentionally.
	            this._cleanupTouchEvent(touchId);
	            this.handlers.onBlur();
	        }
	    };
	
	    return GestureStateMachine;
	}();
	
	module.exports = GestureStateMachine;

/***/ },
/* 451 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getEntityKeyForSelection
	 * @typechecks
	 * 
	 */
	
	/**
	 * Return the entity key that should be used when inserting text for the
	 * specified target selection, only if the entity is `MUTABLE`. `IMMUTABLE`
	 * and `SEGMENTED` entities should not be used for insertion behavior.
	 */
	'use strict';
	
	var DraftEntity = __webpack_require__(330);
	
	function getEntityKeyForSelection(contentState, targetSelection) {
	  var entityKey;
	
	  if (targetSelection.isCollapsed()) {
	    var key = targetSelection.getAnchorKey();
	    var offset = targetSelection.getAnchorOffset();
	    if (offset > 0) {
	      entityKey = contentState.getBlockForKey(key).getEntityAt(offset - 1);
	      return filterKey(entityKey);
	    }
	    return null;
	  }
	
	  var startKey = targetSelection.getStartKey();
	  var startOffset = targetSelection.getStartOffset();
	  var startBlock = contentState.getBlockForKey(startKey);
	
	  entityKey = startOffset === startBlock.getLength() ? null : startBlock.getEntityAt(startOffset);
	
	  return filterKey(entityKey);
	}
	
	/**
	 * Determine whether an entity key corresponds to a `MUTABLE` entity. If so,
	 * return it. If not, return null.
	 */
	function filterKey(entityKey) {
	  if (entityKey) {
	    var entity = DraftEntity.get(entityKey);
	    return entity.getMutability() === 'MUTABLE' ? entityKey : null;
	  }
	  return null;
	}
	
	module.exports = getEntityKeyForSelection;

/***/ },
/* 452 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule isSelectionAtLeafStart
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	function isSelectionAtLeafStart(editorState) {
	  var selection = editorState.getSelection();
	  var anchorKey = selection.getAnchorKey();
	  var blockTree = editorState.getBlockTree(anchorKey);
	  var offset = selection.getStartOffset();
	
	  var isAtStart = false;
	
	  blockTree.some(function (leafSet) {
	    if (offset === leafSet.get('start')) {
	      isAtStart = true;
	      return true;
	    }
	
	    if (offset < leafSet.get('end')) {
	      return leafSet.get('leaves').some(function (leaf) {
	        var leafStart = leaf.get('start');
	        if (offset === leafStart) {
	          isAtStart = true;
	          return true;
	        }
	        if (offset < leafStart) {
	          return false;
	        }
	      });
	    }
	
	    return false;
	  });
	
	  return isAtStart;
	}
	
	module.exports = isSelectionAtLeafStart;

/***/ },
/* 453 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var PhotosMimeType = __webpack_require__(492);
	
	var createArrayFromMixed = __webpack_require__(493);
	var emptyFunction = __webpack_require__(444);
	
	var CR_LF_REGEX = new RegExp('\r\n', 'g');
	var LF_ONLY = '\n';
	
	var RICH_TEXT_TYPES = {
	  'text/rtf': 1,
	  'text/html': 1
	};
	
	/**
	 * If DataTransferItem is a file then return the Blob of data.
	 *
	 * @param {object} item
	 * @return {?blob}
	 */
	function getFileFromDataTransfer(item) {
	  if (item.kind == 'file') {
	    return item.getAsFile();
	  }
	}
	
	var DataTransfer = function () {
	  /**
	   * @param {object} data
	   */
	  function DataTransfer(data) {
	    _classCallCheck(this, DataTransfer);
	
	    this.data = data;
	
	    // Types could be DOMStringList or array
	    this.types = data.types ? createArrayFromMixed(data.types) : [];
	  }
	
	  /**
	   * Is this likely to be a rich text data transfer?
	   *
	   * @return {boolean}
	   */
	
	
	  DataTransfer.prototype.isRichText = function isRichText() {
	    // If HTML is available, treat this data as rich text. This way, we avoid
	    // using a pasted image if it is packaged with HTML -- this may occur with
	    // pastes from MS Word, for example.  However this is only rich text if
	    // there's accompanying text.
	    if (this.getHTML() && this.getText()) {
	      return true;
	    }
	
	    // When an image is copied from a preview window, you end up with two
	    // DataTransferItems one of which is a file's metadata as text.  Skip those.
	    if (this.isImage()) {
	      return false;
	    }
	
	    return this.types.some(function (type) {
	      return RICH_TEXT_TYPES[type];
	    });
	  };
	
	  /**
	   * Get raw text.
	   *
	   * @return {?string}
	   */
	
	
	  DataTransfer.prototype.getText = function getText() {
	    var text;
	    if (this.data.getData) {
	      if (!this.types.length) {
	        text = this.data.getData('Text');
	      } else if (this.types.indexOf('text/plain') != -1) {
	        text = this.data.getData('text/plain');
	      }
	    }
	    return text ? text.replace(CR_LF_REGEX, LF_ONLY) : null;
	  };
	
	  /**
	   * Get HTML paste data
	   *
	   * @return {?string}
	   */
	
	
	  DataTransfer.prototype.getHTML = function getHTML() {
	    if (this.data.getData) {
	      if (!this.types.length) {
	        return this.data.getData('Text');
	      } else if (this.types.indexOf('text/html') != -1) {
	        return this.data.getData('text/html');
	      }
	    }
	  };
	
	  /**
	   * Is this a link data transfer?
	   *
	   * @return {boolean}
	   */
	
	
	  DataTransfer.prototype.isLink = function isLink() {
	    return this.types.some(function (type) {
	      return type.indexOf('Url') != -1 || type.indexOf('text/uri-list') != -1 || type.indexOf('text/x-moz-url');
	    });
	  };
	
	  /**
	   * Get a link url.
	   *
	   * @return {?string}
	   */
	
	
	  DataTransfer.prototype.getLink = function getLink() {
	    if (this.data.getData) {
	      if (this.types.indexOf('text/x-moz-url') != -1) {
	        var url = this.data.getData('text/x-moz-url').split('\n');
	        return url[0];
	      }
	      return this.types.indexOf('text/uri-list') != -1 ? this.data.getData('text/uri-list') : this.data.getData('url');
	    }
	
	    return null;
	  };
	
	  /**
	   * Is this an image data transfer?
	   *
	   * @return {boolean}
	   */
	
	
	  DataTransfer.prototype.isImage = function isImage() {
	    var isImage = this.types.some(function (type) {
	      // Firefox will have a type of application/x-moz-file for images during
	      // dragging
	      return type.indexOf('application/x-moz-file') != -1;
	    });
	
	    if (isImage) {
	      return true;
	    }
	
	    var items = this.getFiles();
	    for (var i = 0; i < items.length; i++) {
	      var type = items[i].type;
	      if (!PhotosMimeType.isImage(type)) {
	        return false;
	      }
	    }
	
	    return true;
	  };
	
	  DataTransfer.prototype.getCount = function getCount() {
	    if (this.data.hasOwnProperty('items')) {
	      return this.data.items.length;
	    } else if (this.data.hasOwnProperty('mozItemCount')) {
	      return this.data.mozItemCount;
	    } else if (this.data.files) {
	      return this.data.files.length;
	    }
	    return null;
	  };
	
	  /**
	   * Get files.
	   *
	   * @return {array}
	   */
	
	
	  DataTransfer.prototype.getFiles = function getFiles() {
	    if (this.data.items) {
	      // createArrayFromMixed doesn't properly handle DataTransferItemLists.
	      return Array.prototype.slice.call(this.data.items).map(getFileFromDataTransfer).filter(emptyFunction.thatReturnsArgument);
	    } else if (this.data.files) {
	      return Array.prototype.slice.call(this.data.files);
	    } else {
	      return [];
	    }
	  };
	
	  /**
	   * Are there any files to fetch?
	   *
	   * @return {boolean}
	   */
	
	
	  DataTransfer.prototype.hasFiles = function hasFiles() {
	    return this.getFiles().length > 0;
	  };
	
	  return DataTransfer;
	}();
	
	module.exports = DataTransfer;

/***/ },
/* 454 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule findAncestorOffsetKey
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var getSelectionOffsetKeyForNode = __webpack_require__(494);
	
	/**
	 * Get the key from the node's nearest offset-aware ancestor.
	 */
	function findAncestorOffsetKey(node) {
	  while (node && node !== document.documentElement) {
	    var key = getSelectionOffsetKeyForNode(node);
	    if (key != null) {
	      return key;
	    }
	    node = node.parentNode;
	  }
	  return null;
	}
	
	module.exports = findAncestorOffsetKey;

/***/ },
/* 455 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getTextContentFromFiles
	 * 
	 */
	
	'use strict';
	
	var TEXT_CLIPPING_REGEX = /\.textClipping$/;
	
	var TEXT_TYPES = {
	  'text/plain': true,
	  'text/html': true,
	  'text/rtf': true
	};
	
	// Somewhat arbitrary upper bound on text size. Let's not lock up the browser.
	var TEXT_SIZE_UPPER_BOUND = 5000;
	
	/**
	 * Extract the text content from a file list.
	 */
	function getTextContentFromFiles(files, callback) {
	  var readCount = 0;
	  var results = [];
	  files.forEach(function ( /*blob*/file) {
	    readFile(file, function ( /*string*/text) {
	      readCount++;
	      text && results.push(text.slice(0, TEXT_SIZE_UPPER_BOUND));
	      if (readCount == files.length) {
	        callback(results.join('\r'));
	      }
	    });
	  });
	}
	
	/**
	 * todo isaac: Do work to turn html/rtf into a content fragment.
	 */
	function readFile(file, callback) {
	  if (!global.FileReader || file.type && !(file.type in TEXT_TYPES)) {
	    callback('');
	    return;
	  }
	
	  if (file.type === '') {
	    var contents = '';
	    // Special-case text clippings, which have an empty type but include
	    // `.textClipping` in the file name. `readAsText` results in an empty
	    // string for text clippings, so we force the file name to serve
	    // as the text value for the file.
	    if (TEXT_CLIPPING_REGEX.test(file.name)) {
	      contents = file.name.replace(TEXT_CLIPPING_REGEX, '');
	    }
	    callback(contents);
	    return;
	  }
	
	  var reader = new FileReader();
	  reader.onload = function () {
	    callback(reader.result);
	  };
	  reader.onerror = function () {
	    callback('');
	  };
	  reader.readAsText(file);
	}
	
	module.exports = getTextContentFromFiles;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 456 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getUpdatedSelectionState
	 * 
	 */
	
	'use strict';
	
	var DraftOffsetKey = __webpack_require__(399);
	
	var nullthrows = __webpack_require__(442);
	
	function getUpdatedSelectionState(editorState, anchorKey, anchorOffset, focusKey, focusOffset) {
	  var selection = nullthrows(editorState.getSelection());
	  if (true) {
	    if (!anchorKey || !focusKey) {
	      /*eslint-disable no-console */
	      console.warn('Invalid selection state.', arguments, editorState.toJS());
	      /*eslint-enable no-console */
	      return selection;
	    }
	  }
	
	  var anchorPath = DraftOffsetKey.decode(anchorKey);
	  var anchorBlockKey = anchorPath.blockKey;
	  var anchorLeaf = editorState.getBlockTree(anchorBlockKey).getIn([anchorPath.decoratorKey, 'leaves', anchorPath.leafKey]);
	
	  var focusPath = DraftOffsetKey.decode(focusKey);
	  var focusBlockKey = focusPath.blockKey;
	  var focusLeaf = editorState.getBlockTree(focusBlockKey).getIn([focusPath.decoratorKey, 'leaves', focusPath.leafKey]);
	
	  var anchorLeafStart = anchorLeaf.get('start');
	  var focusLeafStart = focusLeaf.get('start');
	
	  var anchorBlockOffset = anchorLeaf ? anchorLeafStart + anchorOffset : null;
	  var focusBlockOffset = focusLeaf ? focusLeafStart + focusOffset : null;
	
	  var areEqual = selection.getAnchorKey() === anchorBlockKey && selection.getAnchorOffset() === anchorBlockOffset && selection.getFocusKey() === focusBlockKey && selection.getFocusOffset() === focusBlockOffset;
	
	  if (areEqual) {
	    return selection;
	  }
	
	  var isBackward = false;
	  if (anchorBlockKey === focusBlockKey) {
	    var anchorLeafEnd = anchorLeaf.get('end');
	    var focusLeafEnd = focusLeaf.get('end');
	    if (focusLeafStart === anchorLeafStart && focusLeafEnd === anchorLeafEnd) {
	      isBackward = focusOffset < anchorOffset;
	    } else {
	      isBackward = focusLeafStart < anchorLeafStart;
	    }
	  } else {
	    var startKey = editorState.getCurrentContent().getBlockMap().keySeq().skipUntil(function (v) {
	      return v === anchorBlockKey || v === focusBlockKey;
	    }).first();
	    isBackward = startKey === focusBlockKey;
	  }
	
	  return selection.merge({
	    anchorKey: anchorBlockKey,
	    anchorOffset: anchorBlockOffset,
	    focusKey: focusBlockKey,
	    focusOffset: focusBlockOffset,
	    isBackward: isBackward
	  });
	}
	
	module.exports = getUpdatedSelectionState;

/***/ },
/* 457 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnBeforeInput
	 * 
	 */
	
	// When nothing is focused, Firefox regards two characters, `'` and `/`, as
	// commands that should open and focus the "quickfind" search bar. This should
	// *never* happen while a contenteditable is focused, but as of v28, it
	// sometimes does, even when the keypress event target is the contenteditable.
	// This breaks the input. Special case these characters to ensure that when
	// they are typed, we prevent default on the event to make sure not to
	// trigger quickfind.
	'use strict';
	
	var BlockTree = __webpack_require__(412);
	var DraftModifier = __webpack_require__(329);
	var EditorState = __webpack_require__(332);
	var UserAgent = __webpack_require__(433);
	
	var getEntityKeyForSelection = __webpack_require__(451);
	var isSelectionAtLeafStart = __webpack_require__(452);
	var nullthrows = __webpack_require__(442);
	
	var FF_QUICKFIND_CHAR = '\'';
	var FF_QUICKFIND_LINK_CHAR = '\/';
	var isFirefox = UserAgent.isBrowser('Firefox');
	
	function mustPreventDefaultForCharacter(character) {
	  return isFirefox && (character == FF_QUICKFIND_CHAR || character == FF_QUICKFIND_LINK_CHAR);
	}
	
	/**
	 * Replace the current selection with the specified text string, with the
	 * inline style and entity key applied to the newly inserted text.
	 */
	function replaceText(editorState, text, inlineStyle, entityKey) {
	  var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), text, inlineStyle, entityKey);
	  return EditorState.push(editorState, contentState, 'insert-characters');
	}
	
	/**
	 * When `onBeforeInput` executes, the browser is attempting to insert a
	 * character into the editor. Apply this character data to the document,
	 * allowing native insertion if possible.
	 *
	 * Native insertion is encouraged in order to limit re-rendering and to
	 * preserve spellcheck highlighting, which disappears or flashes if re-render
	 * occurs on the relevant text nodes.
	 */
	function editOnBeforeInput(e) {
	  var chars = e.data;
	
	  // In some cases (ex: IE ideographic space insertion) no character data
	  // is provided. There's nothing to do when this happens.
	  if (!chars) {
	    return;
	  }
	
	  // Allow the top-level component to handle the insertion manually. This is
	  // useful when triggering interesting behaviors for a character insertion,
	  // Simple examples: replacing a raw text ':)' with a smile emoji or image
	  // decorator, or setting a block to be a list item after typing '- ' at the
	  // start of the block.
	  if (this.props.handleBeforeInput && this.props.handleBeforeInput(chars)) {
	    e.preventDefault();
	    return;
	  }
	
	  // If selection is collapsed, conditionally allow native behavior. This
	  // reduces re-renders and preserves spellcheck highlighting. If the selection
	  // is not collapsed, we will re-render.
	  var editorState = this.props.editorState;
	  var selection = editorState.getSelection();
	
	  if (!selection.isCollapsed()) {
	    e.preventDefault();
	    this.update(replaceText(editorState, chars, editorState.getCurrentInlineStyle(), getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())));
	    return;
	  }
	
	  var mayAllowNative = !isSelectionAtLeafStart(editorState);
	  var newEditorState = replaceText(editorState, chars, editorState.getCurrentInlineStyle(), getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection()));
	
	  if (!mayAllowNative) {
	    e.preventDefault();
	    this.update(newEditorState);
	    return;
	  }
	
	  var anchorKey = selection.getAnchorKey();
	  var anchorTree = editorState.getBlockTree(anchorKey);
	
	  // Check the old and new "fingerprints" of the current block to determine
	  // whether this insertion requires any addition or removal of text nodes,
	  // in which case we would prevent the native character insertion.
	  var originalFingerprint = BlockTree.getFingerprint(anchorTree);
	  var newFingerprint = BlockTree.getFingerprint(newEditorState.getBlockTree(anchorKey));
	
	  if (mustPreventDefaultForCharacter(chars) || originalFingerprint !== newFingerprint || nullthrows(newEditorState.getDirectionMap()).get(anchorKey) !== nullthrows(editorState.getDirectionMap()).get(anchorKey)) {
	    e.preventDefault();
	  } else {
	    // The native event is allowed to occur.
	    newEditorState = EditorState.set(newEditorState, {
	      nativelyRenderedContent: newEditorState.getCurrentContent()
	    });
	  }
	
	  this.update(newEditorState);
	}
	
	module.exports = editOnBeforeInput;

/***/ },
/* 458 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnBlur
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(332);
	var UserAgent = __webpack_require__(433);
	
	var getActiveElement = __webpack_require__(482);
	
	var isWebKit = UserAgent.isEngine('WebKit');
	
	function editOnBlur(e) {
	  // Webkit has a bug in which blurring a contenteditable by clicking on
	  // other active elements will trigger the `blur` event but will not remove
	  // the DOM selection from the contenteditable. We therefore force the
	  // issue to be certain, checking whether the active element is `body`
	  // to force it when blurring occurs within the window (as opposed to
	  // clicking to another tab or window).
	  if (isWebKit && getActiveElement() === document.body) {
	    global.getSelection().removeAllRanges();
	  }
	
	  var editorState = this.props.editorState;
	  var currentSelection = editorState.getSelection();
	  if (!currentSelection.getHasFocus()) {
	    return;
	  }
	
	  var selection = currentSelection.set('hasFocus', false);
	  this.props.onBlur && this.props.onBlur(e);
	  this.update(EditorState.acceptSelection(editorState, selection));
	}
	
	module.exports = editOnBlur;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 459 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnCompositionStart
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(332);
	
	/**
	 * The user has begun using an IME input system. Switching to `composite` mode
	 * allows handling composition input and disables other edit behavior.
	 */
	function editOnCompositionStart() {
	  this.setRenderGuard();
	  this.setMode('composite');
	  this.update(EditorState.set(this.props.editorState, { inCompositionMode: true }));
	}
	
	module.exports = editOnCompositionStart;

/***/ },
/* 460 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnCopy
	 * 
	 */
	
	'use strict';
	
	var getFragmentFromSelection = __webpack_require__(495);
	
	/**
	 * If we have a selection, create a ContentState fragment and store
	 * it in our internal clipboard. Subsequent paste events will use this
	 * fragment if no external clipboard data is supplied.
	 */
	function editOnCopy(e) {
	  var editorState = this.props.editorState;
	  var selection = editorState.getSelection();
	
	  // No selection, so there's nothing to copy.
	  if (selection.isCollapsed()) {
	    e.preventDefault();
	    return;
	  }
	
	  this.setClipboard(getFragmentFromSelection(this.props.editorState));
	}
	
	module.exports = editOnCopy;

/***/ },
/* 461 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnCut
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(329);
	var EditorState = __webpack_require__(332);
	var Style = __webpack_require__(436);
	
	var getFragmentFromSelection = __webpack_require__(495);
	var getScrollPosition = __webpack_require__(440);
	
	/**
	 * On `cut` events, native behavior is allowed to occur so that the system
	 * clipboard is set properly. This means that we need to take steps to recover
	 * the editor DOM state after the `cut` has occurred in order to maintain
	 * control of the component.
	 *
	 * In addition, we can keep a copy of the removed fragment, including all
	 * styles and entities, for use as an internal paste.
	 */
	function editOnCut(e) {
	  var _this = this;
	
	  var editorState = this.props.editorState;
	  var selection = editorState.getSelection();
	
	  // No selection, so there's nothing to cut.
	  if (selection.isCollapsed()) {
	    e.preventDefault();
	    return;
	  }
	
	  // Track the current scroll position so that it can be forced back in place
	  // after the editor regains control of the DOM.
	  var scrollParent = Style.getScrollParent(e.target);
	
	  var _getScrollPosition = getScrollPosition(scrollParent);
	
	  var x = _getScrollPosition.x;
	  var y = _getScrollPosition.y;
	
	  var fragment = getFragmentFromSelection(editorState);
	  this.setClipboard(fragment);
	
	  // Set `cut` mode to disable all event handling temporarily.
	  this.setRenderGuard();
	  this.setMode('cut');
	
	  // Let native `cut` behavior occur, then recover control.
	  setTimeout(function () {
	    _this.restoreEditorDOM({ x: x, y: y });
	    _this.removeRenderGuard();
	    _this.exitCurrentMode();
	    _this.update(removeFragment(editorState));
	  }, 0);
	}
	
	function removeFragment(editorState) {
	  var newContent = DraftModifier.removeRange(editorState.getCurrentContent(), editorState.getSelection(), 'forward');
	  return EditorState.push(editorState, newContent, 'remove-range');
	}
	
	module.exports = editOnCut;

/***/ },
/* 462 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnDragOver
	 * 
	 */
	
	'use strict';
	
	/**
	 * Drag behavior has begun from outside the editor element.
	 */
	function editOnDragOver(e) {
	  this._internalDrag = false;
	  this.setMode('drag');
	  e.preventDefault();
	}
	
	module.exports = editOnDragOver;

/***/ },
/* 463 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnDragStart
	 * 
	 */
	
	'use strict';
	
	/**
	 * A `dragstart` event has begun within the text editor component.
	 */
	function editOnDragStart() {
	  this._internalDrag = true;
	  this.setMode('drag');
	}
	
	module.exports = editOnDragStart;

/***/ },
/* 464 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnFocus
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(332);
	
	function editOnFocus(e) {
	  var editorState = this.props.editorState;
	  var currentSelection = editorState.getSelection();
	  if (currentSelection.getHasFocus()) {
	    return;
	  }
	
	  var selection = currentSelection.set('hasFocus', true);
	  this.props.onFocus && this.props.onFocus(e);
	
	  // When the tab containing this text editor is hidden and the user does a
	  // find-in-page in a _different_ tab, Chrome on Mac likes to forget what the
	  // selection was right after sending this focus event and (if you let it)
	  // moves the cursor back to the beginning of the editor, so we force the
	  // selection here instead of simply accepting it in order to preserve the
	  // old cursor position. See https://crbug.com/540004.
	  this.update(EditorState.forceSelection(editorState, selection));
	}
	
	module.exports = editOnFocus;

/***/ },
/* 465 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnInput
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(329);
	var DraftOffsetKey = __webpack_require__(399);
	var EditorState = __webpack_require__(332);
	var Entity = __webpack_require__(330);
	var UserAgent = __webpack_require__(433);
	
	var findAncestorOffsetKey = __webpack_require__(454);
	var nullthrows = __webpack_require__(442);
	
	var isGecko = UserAgent.isEngine('Gecko');
	
	var DOUBLE_NEWLINE = '\n\n';
	
	/**
	 * This function is intended to handle spellcheck and autocorrect changes,
	 * which occur in the DOM natively without any opportunity to observe or
	 * interpret the changes before they occur.
	 *
	 * The `input` event fires in contentEditable elements reliably for non-IE
	 * browsers, immediately after changes occur to the editor DOM. Since our other
	 * handlers override or otherwise handle cover other varieties of text input,
	 * the DOM state should match the model in all controlled input cases. Thus,
	 * when an `input` change leads to a DOM/model mismatch, the change should be
	 * due to a spellcheck change, and we can incorporate it into our model.
	 */
	function editOnInput() {
	  var domSelection = global.getSelection();
	
	  var anchorNode = domSelection.anchorNode;
	  var isCollapsed = domSelection.isCollapsed;
	
	  if (anchorNode.nodeType !== Node.TEXT_NODE) {
	    return;
	  }
	
	  var domText = anchorNode.textContent;
	  var editorState = this.props.editorState;
	
	  var offsetKey = nullthrows(findAncestorOffsetKey(anchorNode));
	
	  var _DraftOffsetKey$decode = DraftOffsetKey.decode(offsetKey);
	
	  var blockKey = _DraftOffsetKey$decode.blockKey;
	  var decoratorKey = _DraftOffsetKey$decode.decoratorKey;
	  var leafKey = _DraftOffsetKey$decode.leafKey;
	
	  var _editorState$getBlockTree$getIn = editorState.getBlockTree(blockKey).getIn([decoratorKey, 'leaves', leafKey]);
	
	  var start = _editorState$getBlockTree$getIn.start;
	  var end = _editorState$getBlockTree$getIn.end;
	
	  var content = editorState.getCurrentContent();
	  var block = content.getBlockForKey(blockKey);
	  var modelText = block.getText().slice(start, end);
	
	  // Special-case soft newlines here. If the DOM text ends in a soft newline,
	  // we will have manually inserted an extra soft newline in DraftEditorLeaf.
	  // We want to remove this extra newline for the purpose of our comparison
	  // of DOM and model text.
	  if (domText.endsWith(DOUBLE_NEWLINE)) {
	    domText = domText.slice(0, -1);
	  }
	
	  // No change -- the DOM is up to date. Nothing to do here.
	  if (domText === modelText) {
	    return;
	  }
	
	  var selection = editorState.getSelection();
	
	  // We'll replace the entire leaf with the text content of the target.
	  var targetRange = selection.merge({
	    anchorOffset: start,
	    focusOffset: end,
	    isBackward: false
	  });
	
	  var entityKey = block.getEntityAt(start);
	  var entity = entityKey && Entity.get(entityKey);
	  var entityType = entity && entity.getMutability();
	  var preserveEntity = entityType === 'MUTABLE';
	
	  // Immutable or segmented entities cannot properly be handled by the
	  // default browser undo, so we have to use a different change type to
	  // force using our internal undo method instead of falling through to the
	  // native browser undo.
	  var changeType = preserveEntity ? 'spellcheck-change' : 'apply-entity';
	
	  var newContent = DraftModifier.replaceText(content, targetRange, domText, block.getInlineStyleAt(start), preserveEntity ? block.getEntityAt(start) : null);
	
	  var anchorOffset, focusOffset, startOffset, endOffset;
	
	  if (isGecko) {
	    // Firefox selection does not change while the context menu is open, so
	    // we preserve the anchor and focus values of the DOM selection.
	    anchorOffset = domSelection.anchorOffset;
	    focusOffset = domSelection.focusOffset;
	    startOffset = start + Math.min(anchorOffset, focusOffset);
	    endOffset = startOffset + Math.abs(anchorOffset - focusOffset);
	    anchorOffset = startOffset;
	    focusOffset = endOffset;
	  } else {
	    // Browsers other than Firefox may adjust DOM selection while the context
	    // menu is open, and Safari autocorrect is prone to providing an inaccurate
	    // DOM selection. Don't trust it. Instead, use our existing SelectionState
	    // and adjust it based on the number of characters changed during the
	    // mutation.
	    var charDelta = domText.length - modelText.length;
	    startOffset = selection.getStartOffset();
	    endOffset = selection.getEndOffset();
	
	    anchorOffset = isCollapsed ? endOffset + charDelta : startOffset;
	    focusOffset = endOffset + charDelta;
	  }
	
	  // Segmented entities are completely or partially removed when their
	  // text content changes. For this case we do not want any text to be selected
	  // after the change, so we are not merging the selection.
	  var contentWithAdjustedDOMSelection = newContent.merge({
	    selectionBefore: content.getSelectionAfter(),
	    selectionAfter: selection.merge({ anchorOffset: anchorOffset, focusOffset: focusOffset })
	  });
	
	  this.update(EditorState.push(editorState, contentWithAdjustedDOMSelection, changeType));
	}
	
	module.exports = editOnInput;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 466 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnKeyDown
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(329);
	var EditorState = __webpack_require__(332);
	var KeyBindingUtil = __webpack_require__(333);
	var Keys = __webpack_require__(434);
	var SecondaryClipboard = __webpack_require__(496);
	var UserAgent = __webpack_require__(433);
	
	var keyCommandBackspaceToStartOfLine = __webpack_require__(497);
	var keyCommandBackspaceWord = __webpack_require__(498);
	var keyCommandDeleteWord = __webpack_require__(499);
	var keyCommandInsertNewline = __webpack_require__(500);
	var keyCommandPlainBackspace = __webpack_require__(501);
	var keyCommandPlainDelete = __webpack_require__(502);
	var keyCommandMoveSelectionToEndOfBlock = __webpack_require__(503);
	var keyCommandMoveSelectionToStartOfBlock = __webpack_require__(504);
	var keyCommandTransposeCharacters = __webpack_require__(505);
	var keyCommandUndo = __webpack_require__(506);
	
	var isOptionKeyCommand = KeyBindingUtil.isOptionKeyCommand;
	
	var isChrome = UserAgent.isBrowser('Chrome');
	
	/**
	 * Map a `DraftEditorCommand` command value to a corresponding function.
	 */
	function onKeyCommand(command, editorState) {
	  switch (command) {
	    case 'redo':
	      return EditorState.redo(editorState);
	    case 'delete':
	      return keyCommandPlainDelete(editorState);
	    case 'delete-word':
	      return keyCommandDeleteWord(editorState);
	    case 'backspace':
	      return keyCommandPlainBackspace(editorState);
	    case 'backspace-word':
	      return keyCommandBackspaceWord(editorState);
	    case 'backspace-to-start-of-line':
	      return keyCommandBackspaceToStartOfLine(editorState);
	    case 'split-block':
	      return keyCommandInsertNewline(editorState);
	    case 'transpose-characters':
	      return keyCommandTransposeCharacters(editorState);
	    case 'move-selection-to-start-of-block':
	      return keyCommandMoveSelectionToStartOfBlock(editorState);
	    case 'move-selection-to-end-of-block':
	      return keyCommandMoveSelectionToEndOfBlock(editorState);
	    case 'secondary-cut':
	      return SecondaryClipboard.cut(editorState);
	    case 'secondary-paste':
	      return SecondaryClipboard.paste(editorState);
	    default:
	      return editorState;
	  }
	}
	
	/**
	 * Intercept keydown behavior to handle keys and commands manually, if desired.
	 *
	 * Keydown combinations may be mapped to `DraftCommand` values, which may
	 * correspond to command functions that modify the editor or its contents.
	 *
	 * See `getDefaultKeyBinding` for defaults. Alternatively, the top-level
	 * component may provide a custom mapping via the `keyBindingFn` prop.
	 */
	function editOnKeyDown(e) {
	  var keyCode = e.which;
	  var editorState = this.props.editorState;
	
	  switch (keyCode) {
	    case Keys.RETURN:
	      e.preventDefault();
	      // The top-level component may manually handle newline insertion. If
	      // no special handling is performed, fall through to command handling.
	      if (this.props.handleReturn && this.props.handleReturn(e)) {
	        return;
	      }
	      break;
	    case Keys.ESC:
	      e.preventDefault();
	      this.props.onEscape && this.props.onEscape(e);
	      return;
	    case Keys.TAB:
	      this.props.onTab && this.props.onTab(e);
	      return;
	    case Keys.UP:
	      this.props.onUpArrow && this.props.onUpArrow(e);
	      return;
	    case Keys.DOWN:
	      this.props.onDownArrow && this.props.onDownArrow(e);
	      return;
	    case Keys.SPACE:
	      // Handling for OSX where option + space scrolls.
	      if (isChrome && isOptionKeyCommand(e)) {
	        e.preventDefault();
	        // Insert a nbsp into the editor.
	        var contentState = DraftModifier.replaceText(editorState.getCurrentContent(), editorState.getSelection(), ' ');
	        this.update(EditorState.push(editorState, contentState, 'insert-characters'));
	        return;
	      }
	  }
	
	  var command = this.props.keyBindingFn(e);
	
	  // If no command is specified, allow keydown event to continue.
	  if (!command) {
	    return;
	  }
	
	  if (command === 'undo') {
	    // Since undo requires some special updating behavior to keep the editor
	    // in sync, handle it separately.
	    keyCommandUndo(e, editorState, this.update);
	    return;
	  }
	
	  // At this point, we know that we're handling a command of some kind, so
	  // we don't want to insert a character following the keydown.
	  e.preventDefault();
	
	  // Allow components higher up the tree to handle the command first.
	  if (this.props.handleKeyCommand && this.props.handleKeyCommand(command)) {
	    return;
	  }
	
	  var newState = onKeyCommand(command, editorState);
	  if (newState !== editorState) {
	    this.update(newState);
	  }
	}
	
	module.exports = editOnKeyDown;

/***/ },
/* 467 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnPaste
	 * 
	 */
	
	/**
	 * Paste content.
	 */
	'use strict';
	
	var BlockMapBuilder = __webpack_require__(320);
	var CharacterMetadata = __webpack_require__(321);
	var DataTransfer = __webpack_require__(453);
	var DraftModifier = __webpack_require__(329);
	var DraftPasteProcessor = __webpack_require__(507);
	var EditorState = __webpack_require__(332);
	
	var getEntityKeyForSelection = __webpack_require__(451);
	var getTextContentFromFiles = __webpack_require__(455);
	var splitTextIntoTextBlocks = __webpack_require__(508);
	
	function editOnPaste(e) {
	  var _this = this;
	
	  e.preventDefault();
	  var data = new DataTransfer(e.clipboardData);
	
	  // Get files, unless this is likely to be a string the user wants inline.
	  if (!data.isRichText()) {
	    var files = data.getFiles();
	    var defaultFileText = data.getText();
	    if (files.length > 0) {
	      // Allow customized paste handling for images, etc. Otherwise, fall
	      // through to insert text contents into the editor.
	      if (this.props.handlePastedFiles && this.props.handlePastedFiles(files)) {
	        return;
	      }
	
	      getTextContentFromFiles(files, function ( /*string*/fileText) {
	        fileText = fileText || defaultFileText;
	        if (!fileText) {
	          return;
	        }
	
	        var editorState = _this.props.editorState;
	
	        var blocks = splitTextIntoTextBlocks(fileText);
	        var character = CharacterMetadata.create({
	          style: editorState.getCurrentInlineStyle(),
	          entity: getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())
	        });
	
	        var text = DraftPasteProcessor.processText(blocks, character);
	        var fragment = BlockMapBuilder.createFromArray(text);
	
	        var withInsertedText = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), fragment);
	
	        _this.update(EditorState.push(editorState, withInsertedText, 'insert-fragment'));
	      });
	
	      return;
	    }
	  }
	
	  var textBlocks = [];
	  var text = data.getText();
	  var html = data.getHTML();
	
	  if (this.props.handlePastedText && this.props.handlePastedText(text, html)) {
	    return;
	  }
	
	  if (text) {
	    textBlocks = splitTextIntoTextBlocks(text);
	  }
	
	  if (!this.props.stripPastedStyles) {
	    // If the text from the paste event is rich content that matches what we
	    // already have on the internal clipboard, assume that we should just use
	    // the clipboard fragment for the paste. This will allow us to preserve
	    // styling and entities, if any are present. Note that newlines are
	    // stripped during comparison -- this is because copy/paste within the
	    // editor in Firefox and IE will not include empty lines. The resulting
	    // paste will preserve the newlines correctly.
	    var internalClipboard = this.getClipboard();
	    if (data.isRichText() && internalClipboard) {
	      if (
	      // If the editorKey is present in the pasted HTML, it should be safe to
	      // assume this is an internal paste.
	      html.indexOf(this.getEditorKey()) !== -1 ||
	      // The copy may have been made within a single block, in which case the
	      // editor key won't be part of the paste. In this case, just check
	      // whether the pasted text matches the internal clipboard.
	      textBlocks.length === 1 && internalClipboard.size === 1 && internalClipboard.first().getText() === text) {
	        this.update(insertFragment(this.props.editorState, internalClipboard));
	        return;
	      }
	    }
	
	    // If there is html paste data, try to parse that.
	    if (html) {
	      var htmlFragment = DraftPasteProcessor.processHTML(html, this.props.blockRenderMap);
	      if (htmlFragment) {
	        var htmlMap = BlockMapBuilder.createFromArray(htmlFragment);
	        this.update(insertFragment(this.props.editorState, htmlMap));
	        return;
	      }
	    }
	    // Otherwise, create a new fragment from our pasted text. Also
	    // empty the internal clipboard, since it's no longer valid.
	    this.setClipboard(null);
	  }
	
	  if (textBlocks) {
	    var editorState = this.props.editorState;
	
	    var character = CharacterMetadata.create({
	      style: editorState.getCurrentInlineStyle(),
	      entity: getEntityKeyForSelection(editorState.getCurrentContent(), editorState.getSelection())
	    });
	
	    var textFragment = DraftPasteProcessor.processText(textBlocks, character);
	
	    var textMap = BlockMapBuilder.createFromArray(textFragment);
	    this.update(insertFragment(this.props.editorState, textMap));
	  }
	}
	
	function insertFragment(editorState, fragment) {
	  var newContent = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), fragment);
	  return EditorState.push(editorState, newContent, 'insert-fragment');
	}
	
	module.exports = editOnPaste;

/***/ },
/* 468 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule editOnSelect
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(332);
	var ReactDOM = __webpack_require__(44);
	
	var getDraftEditorSelection = __webpack_require__(509);
	
	function editOnSelect() {
	  if (this._blockSelectEvents) {
	    return;
	  }
	
	  var editorState = this.props.editorState;
	  var documentSelection = getDraftEditorSelection(editorState, ReactDOM.findDOMNode(this.refs.editorContainer).firstChild);
	  var updatedSelectionState = documentSelection.selectionState;
	
	  if (updatedSelectionState !== editorState.getSelection()) {
	    if (documentSelection.needsRecovery) {
	      editorState = EditorState.forceSelection(editorState, updatedSelectionState);
	    } else {
	      editorState = EditorState.acceptSelection(editorState, updatedSelectionState);
	    }
	    this.update(editorState);
	  }
	}
	
	module.exports = editOnSelect;

/***/ },
/* 469 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 * 
	 */
	
	/**
	 * Stateful API for text direction detection
	 *
	 * This class can be used in applications where you need to detect the
	 * direction of a sequence of text blocks, where each direction shall be used
	 * as the fallback direction for the next one.
	 *
	 * NOTE: A default direction, if not provided, is set based on the global
	 *       direction, as defined by `UnicodeBidiDirection`.
	 *
	 * == Example ==
	 * ```
	 * var UnicodeBidiService = require('UnicodeBidiService');
	 *
	 * var bidiService = new UnicodeBidiService();
	 *
	 * ...
	 *
	 * bidiService.reset();
	 * for (var para in paragraphs) {
	 *   var dir = bidiService.getDirection(para);
	 *   ...
	 * }
	 * ```
	 *
	 * Part of our implementation of Unicode Bidirectional Algorithm (UBA)
	 * Unicode Standard Annex #9 (UAX9)
	 * http://www.unicode.org/reports/tr9/
	 */
	
	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	var UnicodeBidi = __webpack_require__(437);
	var UnicodeBidiDirection = __webpack_require__(438);
	
	var invariant = __webpack_require__(432);
	
	var UnicodeBidiService = function () {
	
	  /**
	   * Stateful class for paragraph direction detection
	   *
	   * @param defaultDir  Default direction of the service
	   */
	  function UnicodeBidiService(defaultDir) {
	    _classCallCheck(this, UnicodeBidiService);
	
	    if (!defaultDir) {
	      defaultDir = UnicodeBidiDirection.getGlobalDir();
	    } else {
	      !UnicodeBidiDirection.isStrong(defaultDir) ? true ? invariant(false, 'Default direction must be a strong direction (LTR or RTL)') : invariant(false) : void 0;
	    }
	    this._defaultDir = defaultDir;
	    this.reset();
	  }
	
	  /**
	   * Reset the internal state
	   *
	   * Instead of creating a new instance, you can just reset() your instance
	   * everytime you start a new loop.
	   */
	
	
	  UnicodeBidiService.prototype.reset = function reset() {
	    this._lastDir = this._defaultDir;
	  };
	
	  /**
	   * Returns the direction of a block of text, and remembers it as the
	   * fall-back direction for the next paragraph.
	   *
	   * @param str  A text block, e.g. paragraph, table cell, tag
	   * @return     The resolved direction
	   */
	
	
	  UnicodeBidiService.prototype.getDirection = function getDirection(str) {
	    this._lastDir = UnicodeBidi.getDirection(str, this._lastDir);
	    return this._lastDir;
	  };
	
	  return UnicodeBidiService;
	}();
	
	module.exports = UnicodeBidiService;

/***/ },
/* 470 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports.compose = exports.applyMiddleware = exports.bindActionCreators = exports.combineReducers = exports.createStore = undefined;
	
	var _createStore = __webpack_require__(514);
	
	var _createStore2 = _interopRequireDefault(_createStore);
	
	var _combineReducers = __webpack_require__(515);
	
	var _combineReducers2 = _interopRequireDefault(_combineReducers);
	
	var _bindActionCreators = __webpack_require__(516);
	
	var _bindActionCreators2 = _interopRequireDefault(_bindActionCreators);
	
	var _applyMiddleware = __webpack_require__(517);
	
	var _applyMiddleware2 = _interopRequireDefault(_applyMiddleware);
	
	var _compose = __webpack_require__(518);
	
	var _compose2 = _interopRequireDefault(_compose);
	
	var _warning = __webpack_require__(521);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	/*
	* This is a dummy function to check if the function name has been altered by minification.
	* If the function has been minified and NODE_ENV !== 'production', warn the user.
	*/
	function isCrushed() {}
	
	if (("undefined") !== 'production' && typeof isCrushed.name === 'string' && isCrushed.name !== 'isCrushed') {
	  (0, _warning2['default'])('You are currently using minified code outside of NODE_ENV === \'production\'. ' + 'This means that you are running a slower development build of Redux. ' + 'You can use loose-envify (https://github.com/zertosh/loose-envify) for browserify ' + 'or DefinePlugin for webpack (http://stackoverflow.com/questions/30030031) ' + 'to ensure you have the correct code for your production build.');
	}
	
	exports.createStore = _createStore2['default'];
	exports.combineReducers = _combineReducers2['default'];
	exports.bindActionCreators = _bindActionCreators2['default'];
	exports.applyMiddleware = _applyMiddleware2['default'];
	exports.compose = _compose2['default'];

/***/ },
/* 471 */
/***/ function(module, exports, __webpack_require__) {

	// {K1: V1, K2: V2, ...} -> [[K1, V1], [K2, V2]]
	'use strict';
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	Object.defineProperty(exports, '__esModule', {
	    value: true
	});
	
	var _slicedToArray = function () {
	    function sliceIterator(arr, i) {
	        var _arr = [];var _n = true;var _d = false;var _e = undefined;try {
	            for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
	                _arr.push(_s.value);if (i && _arr.length === i) break;
	            }
	        } catch (err) {
	            _d = true;_e = err;
	        } finally {
	            try {
	                if (!_n && _i['return']) _i['return']();
	            } finally {
	                if (_d) throw _e;
	            }
	        }return _arr;
	    }return function (arr, i) {
	        if (Array.isArray(arr)) {
	            return arr;
	        } else if (Symbol.iterator in Object(arr)) {
	            return sliceIterator(arr, i);
	        } else {
	            throw new TypeError('Invalid attempt to destructure non-iterable instance');
	        }
	    };
	}();
	
	var _extends = Object.assign || function (target) {
	    for (var i = 1; i < arguments.length; i++) {
	        var source = arguments[i];for (var key in source) {
	            if (Object.prototype.hasOwnProperty.call(source, key)) {
	                target[key] = source[key];
	            }
	        }
	    }return target;
	};
	
	var objectToPairs = function objectToPairs(obj) {
	    return Object.keys(obj).map(function (key) {
	        return [key, obj[key]];
	    });
	};
	
	exports.objectToPairs = objectToPairs;
	// [[K1, V1], [K2, V2]] -> {K1: V1, K2: V2, ...}
	var pairsToObject = function pairsToObject(pairs) {
	    var result = {};
	    pairs.forEach(function (_ref) {
	        var _ref2 = _slicedToArray(_ref, 2);
	
	        var key = _ref2[0];
	        var val = _ref2[1];
	
	        result[key] = val;
	    });
	    return result;
	};
	
	var mapObj = function mapObj(obj, fn) {
	    return pairsToObject(objectToPairs(obj).map(fn));
	};
	
	exports.mapObj = mapObj;
	// Flattens an array one level
	// [[A], [B, C, [D]]] -> [A, B, C, [D]]
	var flatten = function flatten(list) {
	    return list.reduce(function (memo, x) {
	        return memo.concat(x);
	    }, []);
	};
	
	exports.flatten = flatten;
	var UPPERCASE_RE = /([A-Z])/g;
	var MS_RE = /^ms-/;
	
	var kebabify = function kebabify(string) {
	    return string.replace(UPPERCASE_RE, '-$1').toLowerCase();
	};
	var kebabifyStyleName = function kebabifyStyleName(string) {
	    return kebabify(string).replace(MS_RE, '-ms-');
	};
	
	exports.kebabifyStyleName = kebabifyStyleName;
	var recursiveMerge = function recursiveMerge(a, b) {
	    // TODO(jlfwong): Handle malformed input where a and b are not the same
	    // type.
	
	    if ((typeof a === 'undefined' ? 'undefined' : _typeof(a)) !== 'object') {
	        return b;
	    }
	
	    var ret = _extends({}, a);
	
	    Object.keys(b).forEach(function (key) {
	        if (ret.hasOwnProperty(key)) {
	            ret[key] = recursiveMerge(a[key], b[key]);
	        } else {
	            ret[key] = b[key];
	        }
	    });
	
	    return ret;
	};
	
	exports.recursiveMerge = recursiveMerge;
	/**
	 * CSS properties which accept numbers but are not in units of "px".
	 * Taken from React's CSSProperty.js
	 */
	var isUnitlessNumber = {
	    animationIterationCount: true,
	    borderImageOutset: true,
	    borderImageSlice: true,
	    borderImageWidth: true,
	    boxFlex: true,
	    boxFlexGroup: true,
	    boxOrdinalGroup: true,
	    columnCount: true,
	    flex: true,
	    flexGrow: true,
	    flexPositive: true,
	    flexShrink: true,
	    flexNegative: true,
	    flexOrder: true,
	    gridRow: true,
	    gridColumn: true,
	    fontWeight: true,
	    lineClamp: true,
	    lineHeight: true,
	    opacity: true,
	    order: true,
	    orphans: true,
	    tabSize: true,
	    widows: true,
	    zIndex: true,
	    zoom: true,
	
	    // SVG-related properties
	    fillOpacity: true,
	    floodOpacity: true,
	    stopOpacity: true,
	    strokeDasharray: true,
	    strokeDashoffset: true,
	    strokeMiterlimit: true,
	    strokeOpacity: true,
	    strokeWidth: true
	};
	
	/**
	 * Taken from React's CSSProperty.js
	 *
	 * @param {string} prefix vendor-specific prefix, eg: Webkit
	 * @param {string} key style name, eg: transitionDuration
	 * @return {string} style name prefixed with `prefix`, properly camelCased, eg:
	 * WebkitTransitionDuration
	 */
	function prefixKey(prefix, key) {
	    return prefix + key.charAt(0).toUpperCase() + key.substring(1);
	}
	
	/**
	 * Support style names that may come passed in prefixed by adding permutations
	 * of vendor prefixes.
	 * Taken from React's CSSProperty.js
	 */
	var prefixes = ['Webkit', 'ms', 'Moz', 'O'];
	
	// Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an
	// infinite loop, because it iterates over the newly added props too.
	// Taken from React's CSSProperty.js
	Object.keys(isUnitlessNumber).forEach(function (prop) {
	    prefixes.forEach(function (prefix) {
	        isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop];
	    });
	});
	
	var stringifyValue = function stringifyValue(key, prop) {
	    if (typeof prop === "number") {
	        if (isUnitlessNumber[key]) {
	            return "" + prop;
	        } else {
	            return prop + "px";
	        }
	    } else {
	        return prop;
	    }
	};
	
	exports.stringifyValue = stringifyValue;
	/**
	 * JS Implementation of MurmurHash2
	 *
	 * @author <a href="mailto:gary.court@gmail.com">Gary Court</a>
	 * @see http://github.com/garycourt/murmurhash-js
	 * @author <a href="mailto:aappleby@gmail.com">Austin Appleby</a>
	 * @see http://sites.google.com/site/murmurhash/
	 *
	 * @param {string} str ASCII only
	 * @return {string} Base 36 encoded hash result
	 */
	function murmurhash2_32_gc(str) {
	    var l = str.length;
	    var h = l;
	    var i = 0;
	    var k = undefined;
	
	    while (l >= 4) {
	        k = str.charCodeAt(i) & 0xff | (str.charCodeAt(++i) & 0xff) << 8 | (str.charCodeAt(++i) & 0xff) << 16 | (str.charCodeAt(++i) & 0xff) << 24;
	
	        k = (k & 0xffff) * 0x5bd1e995 + (((k >>> 16) * 0x5bd1e995 & 0xffff) << 16);
	        k ^= k >>> 24;
	        k = (k & 0xffff) * 0x5bd1e995 + (((k >>> 16) * 0x5bd1e995 & 0xffff) << 16);
	
	        h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16) ^ k;
	
	        l -= 4;
	        ++i;
	    }
	
	    switch (l) {
	        case 3:
	            h ^= (str.charCodeAt(i + 2) & 0xff) << 16;
	        case 2:
	            h ^= (str.charCodeAt(i + 1) & 0xff) << 8;
	        case 1:
	            h ^= str.charCodeAt(i) & 0xff;
	            h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16);
	    }
	
	    h ^= h >>> 13;
	    h = (h & 0xffff) * 0x5bd1e995 + (((h >>> 16) * 0x5bd1e995 & 0xffff) << 16);
	    h ^= h >>> 15;
	
	    return (h >>> 0).toString(36);
	}
	
	// Hash a javascript object using JSON.stringify. This is very fast, about 3
	// microseconds on my computer for a sample object:
	// http://jsperf.com/test-hashfnv32a-hash/5
	//
	// Note that this uses JSON.stringify to stringify the objects so in order for
	// this to produce consistent hashes browsers need to have a consistent
	// ordering of objects. Ben Alpert says that Facebook depends on this, so we
	// can probably depend on this too.
	var hashObject = function hashObject(object) {
	    return murmurhash2_32_gc(JSON.stringify(object));
	};
	
	exports.hashObject = hashObject;
	var IMPORTANT_RE = /^([^:]+:.*?)( !important)?;$/;
	
	// Given a single style rule string like "a: b;", adds !important to generate
	// "a: b !important;".
	var importantify = function importantify(string) {
	    return string.replace(IMPORTANT_RE, function (_, base, important) {
	        return base + " !important;";
	    });
	};
	exports.importantify = importantify;

/***/ },
/* 472 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	Object.defineProperty(exports, '__esModule', {
	    value: true
	});
	
	function _interopRequireDefault(obj) {
	    return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	var _asap = __webpack_require__(540);
	
	var _asap2 = _interopRequireDefault(_asap);
	
	var _generate = __webpack_require__(520);
	
	var _util = __webpack_require__(471);
	
	// The current <style> tag we are inserting into, or null if we haven't
	// inserted anything yet. We could find this each time using
	// `document.querySelector("style[data-aphrodite"])`, but holding onto it is
	// faster.
	var styleTag = null;
	
	// Inject a string of styles into a <style> tag in the head of the document. This
	// will automatically create a style tag and then continue to use it for
	// multiple injections. It will also use a style tag with the `data-aphrodite`
	// tag on it if that exists in the DOM. This could be used for e.g. reusing the
	// same style tag that server-side rendering inserts.
	var injectStyleTag = function injectStyleTag(cssContents) {
	    if (styleTag == null) {
	        // Try to find a style tag with the `data-aphrodite` attribute first.
	        styleTag = document.querySelector("style[data-aphrodite]");
	
	        // If that doesn't work, generate a new style tag.
	        if (styleTag == null) {
	            // Taken from
	            // http://stackoverflow.com/questions/524696/how-to-create-a-style-tag-with-javascript
	            var head = document.head || document.getElementsByTagName('head')[0];
	            styleTag = document.createElement('style');
	
	            styleTag.type = 'text/css';
	            styleTag.setAttribute("data-aphrodite", "");
	            head.appendChild(styleTag);
	        }
	    }
	
	    if (styleTag.styleSheet) {
	        styleTag.styleSheet.cssText += cssContents;
	    } else {
	        styleTag.appendChild(document.createTextNode(cssContents));
	    }
	};
	
	// Custom handlers for stringifying CSS values that have side effects
	// (such as fontFamily, which can cause @font-face rules to be injected)
	var stringHandlers = {
	    // With fontFamily we look for objects that are passed in and interpret
	    // them as @font-face rules that we need to inject. The value of fontFamily
	    // can either be a string (as normal), an object (a single font face), or
	    // an array of objects and strings.
	    fontFamily: function fontFamily(val) {
	        if (Array.isArray(val)) {
	            return val.map(fontFamily).join(",");
	        } else if ((typeof val === 'undefined' ? 'undefined' : _typeof(val)) === "object") {
	            injectStyleOnce(val.fontFamily, "@font-face", [val], false);
	            return '"' + val.fontFamily + '"';
	        } else {
	            return val;
	        }
	    },
	
	    // With animationName we look for an object that contains keyframes and
	    // inject them as an `@keyframes` block, returning a uniquely generated
	    // name. The keyframes object should look like
	    //  animationName: {
	    //    from: {
	    //      left: 0,
	    //      top: 0,
	    //    },
	    //    '50%': {
	    //      left: 15,
	    //      top: 5,
	    //    },
	    //    to: {
	    //      left: 20,
	    //      top: 20,
	    //    }
	    //  }
	    // TODO(emily): `stringHandlers` doesn't let us rename the key, so I have
	    // to use `animationName` here. Improve that so we can call this
	    // `animation` instead of `animationName`.
	    animationName: function animationName(val) {
	        if ((typeof val === 'undefined' ? 'undefined' : _typeof(val)) !== "object") {
	            return val;
	        }
	
	        // Generate a unique name based on the hash of the object. We can't
	        // just use the hash because the name can't start with a number.
	        // TODO(emily): this probably makes debugging hard, allow a custom
	        // name?
	        var name = 'keyframe_' + (0, _util.hashObject)(val);
	
	        // Since keyframes need 3 layers of nesting, we use `generateCSS` to
	        // build the inner layers and wrap it in `@keyframes` ourselves.
	        var finalVal = '@keyframes ' + name + '{';
	        Object.keys(val).forEach(function (key) {
	            finalVal += (0, _generate.generateCSS)(key, [val[key]], stringHandlers, false);
	        });
	        finalVal += '}';
	
	        injectGeneratedCSSOnce(name, finalVal);
	
	        return name;
	    }
	};
	
	// This is a map from Aphrodite's generated class names to `true` (acting as a
	// set of class names)
	var alreadyInjected = {};
	
	// This is the buffer of styles which have not yet been flushed.
	var injectionBuffer = "";
	
	// A flag to tell if we are already buffering styles. This could happen either
	// because we scheduled a flush call already, so newly added styles will
	// already be flushed, or because we are statically buffering on the server.
	var isBuffering = false;
	
	var injectGeneratedCSSOnce = function injectGeneratedCSSOnce(key, generatedCSS) {
	    if (!alreadyInjected[key]) {
	        if (!isBuffering) {
	            // We should never be automatically buffering on the server (or any
	            // place without a document), so guard against that.
	            if (typeof document === "undefined") {
	                throw new Error("Cannot automatically buffer without a document");
	            }
	
	            // If we're not already buffering, schedule a call to flush the
	            // current styles.
	            isBuffering = true;
	            (0, _asap2['default'])(flushToStyleTag);
	        }
	
	        injectionBuffer += generatedCSS;
	        alreadyInjected[key] = true;
	    }
	};
	
	var injectStyleOnce = function injectStyleOnce(key, selector, definitions, useImportant) {
	    if (!alreadyInjected[key]) {
	        var generated = (0, _generate.generateCSS)(selector, definitions, stringHandlers, useImportant);
	
	        injectGeneratedCSSOnce(key, generated);
	    }
	};
	
	exports.injectStyleOnce = injectStyleOnce;
	var reset = function reset() {
	    injectionBuffer = "";
	    alreadyInjected = {};
	    isBuffering = false;
	    styleTag = null;
	};
	
	exports.reset = reset;
	var startBuffering = function startBuffering() {
	    if (isBuffering) {
	        throw new Error("Cannot buffer while already buffering");
	    }
	    isBuffering = true;
	};
	
	exports.startBuffering = startBuffering;
	var flushToString = function flushToString() {
	    isBuffering = false;
	    var ret = injectionBuffer;
	    injectionBuffer = "";
	    return ret;
	};
	
	exports.flushToString = flushToString;
	var flushToStyleTag = function flushToStyleTag() {
	    var cssContent = flushToString();
	    if (cssContent.length > 0) {
	        injectStyleTag(cssContent);
	    }
	};
	
	exports.flushToStyleTag = flushToStyleTag;
	var getRenderedClassNames = function getRenderedClassNames() {
	    return Object.keys(alreadyInjected);
	};
	
	exports.getRenderedClassNames = getRenderedClassNames;
	var addRenderedClassNames = function addRenderedClassNames(classNames) {
	    classNames.forEach(function (className) {
	        alreadyInjected[className] = true;
	    });
	};
	exports.addRenderedClassNames = addRenderedClassNames;

/***/ },
/* 473 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks static-only
	 */
	
	'use strict';
	
	/**
	 * Combines multiple className strings into one.
	 * http://jsperf.com/joinclasses-args-vs-array
	 *
	 * @param {...?string} className
	 * @return {string}
	 */
	
	function joinClasses(className /*, ... */) {
	  if (!className) {
	    className = '';
	  }
	  var nextClass = void 0;
	  var argLength = arguments.length;
	  if (argLength > 1) {
	    for (var ii = 1; ii < argLength; ii++) {
	      nextClass = arguments[ii];
	      if (nextClass) {
	        className = (className ? className + ' ' : '') + nextClass;
	      }
	    }
	  }
	  return className;
	}
	
	module.exports = joinClasses;

/***/ },
/* 474 */
/***/ function(module, exports, __webpack_require__) {

	/*
	* jQuery Mobile Framework : "mouse" plugin
	* Copyright (c) jQuery Project
	* Dual licensed under the MIT or GPL Version 2 licenses.
	* http://jquery.org/license
	*/
	
	// This plugin is an experiment for abstracting away the touch and mouse
	// events so that developers don't have to worry about which method of input
	// the device their document is loaded on supports.
	//
	// The idea here is to allow the developer to register listeners for the
	// basic mouse events, such as mousedown, mousemove, mouseup, and click,
	// and the plugin will take care of registering the correct listeners
	// behind the scenes to invoke the listener at the fastest possible time
	// for that device, while still retaining the order of event firing in
	// the traditional mouse environment, should multiple handlers be registered
	// on the same element for different events.
	//
	// The current version exposes the following virtual events to jQuery bind methods:
	// "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel"
	
	(function( $, window, document, undefined ) {
	
	var dataPropertyName = "virtualMouseBindings",
		touchTargetPropertyName = "virtualTouchID",
		virtualEventNames = "vmouseover vmousedown vmousemove vmouseup vclick vmouseout vmousecancel".split( " " ),
		touchEventProps = "clientX clientY pageX pageY screenX screenY".split( " " ),
		mouseHookProps = $.event.mouseHooks ? $.event.mouseHooks.props : [],
		mouseEventProps = $.event.props.concat( mouseHookProps ),
		activeDocHandlers = {},
		resetTimerID = 0,
		startX = 0,
		startY = 0,
		didScroll = false,
		clickBlockList = [],
		blockMouseTriggers = false,
		blockTouchTriggers = false,
		eventCaptureSupported = "addEventListener" in document,
		$document = $( document ),
		nextTouchID = 1,
		lastTouchID = 0;
	
	$.vmouse = {
		moveDistanceThreshold: 10,
		clickDistanceThreshold: 10,
		resetTimerDuration: 1500
	};
	
	function getNativeEvent( event ) {
	
		while ( event && typeof event.originalEvent !== "undefined" ) {
			event = event.originalEvent;
		}
		return event;
	}
	
	function createVirtualEvent( event, eventType ) {
	
		var t = event.type,
			oe, props, ne, prop, ct, touch, i, j;
	
		event = $.Event(event);
		event.type = eventType;
	
		oe = event.originalEvent;
		props = $.event.props;
	
		// addresses separation of $.event.props in to $.event.mouseHook.props and Issue 3280
		// https://github.com/jquery/jquery-mobile/issues/3280
		if ( t.search(/mouse/) >-1 ) {
			props = mouseEventProps;
		}
	
		// copy original event properties over to the new event
		// this would happen if we could call $.event.fix instead of $.Event
		// but we don't have a way to force an event to be fixed multiple times
		if ( oe ) {
			for ( i = props.length, prop; i; ) {
				prop = props[ --i ];
				event[ prop ] = oe[ prop ];
			}
		}
	
		// make sure that if the mouse and click virtual events are generated
		// without a .which one is defined
		if ( t.search(/mouse(down|up)|click/) > -1 && !event.which ){
			event.which = 1;
		}
	
		if ( t.search(/^touch/) !== -1 ) {
			ne = getNativeEvent( oe );
			t = ne.touches;
			ct = ne.changedTouches;
			touch = ( t && t.length ) ? t[0] : ( (ct && ct.length) ? ct[ 0 ] : undefined );
	
			if ( touch ) {
				for ( j = 0, len = touchEventProps.length; j < len; j++){
					prop = touchEventProps[ j ];
					event[ prop ] = touch[ prop ];
				}
			}
		}
	
		return event;
	}
	
	function getVirtualBindingFlags( element ) {
	
		var flags = {},
			b, k;
	
		while ( element ) {
	
			b = $.data( element, dataPropertyName );
	
			for (  k in b ) {
				if ( b[ k ] ) {
					flags[ k ] = flags.hasVirtualBinding = true;
				}
			}
			element = element.parentNode;
		}
		return flags;
	}
	
	function getClosestElementWithVirtualBinding( element, eventType ) {
		var b;
		while ( element ) {
	
			b = $.data( element, dataPropertyName );
	
			if ( b && ( !eventType || b[ eventType ] ) ) {
				return element;
			}
			element = element.parentNode;
		}
		return null;
	}
	
	function enableTouchBindings() {
		blockTouchTriggers = false;
	}
	
	function disableTouchBindings() {
		blockTouchTriggers = true;
	}
	
	function enableMouseBindings() {
		lastTouchID = 0;
		clickBlockList.length = 0;
		blockMouseTriggers = false;
	
		// When mouse bindings are enabled, our
		// touch bindings are disabled.
		disableTouchBindings();
	}
	
	function disableMouseBindings() {
		// When mouse bindings are disabled, our
		// touch bindings are enabled.
		enableTouchBindings();
	}
	
	function startResetTimer() {
		clearResetTimer();
		resetTimerID = setTimeout(function(){
			resetTimerID = 0;
			enableMouseBindings();
		}, $.vmouse.resetTimerDuration );
	}
	
	function clearResetTimer() {
		if ( resetTimerID ){
			clearTimeout( resetTimerID );
			resetTimerID = 0;
		}
	}
	
	function triggerVirtualEvent( eventType, event, flags ) {
		var ve;
	
		if ( ( flags && flags[ eventType ] ) ||
					( !flags && getClosestElementWithVirtualBinding( event.target, eventType ) ) ) {
	
			ve = createVirtualEvent( event, eventType );
	
			$( event.target).trigger( ve );
		}
	
		return ve;
	}
	
	function mouseEventCallback( event ) {
		var touchID = $.data(event.target, touchTargetPropertyName);
	
		if ( !blockMouseTriggers && ( !lastTouchID || lastTouchID !== touchID ) ){
			var ve = triggerVirtualEvent( "v" + event.type, event );
			if ( ve ) {
				if ( ve.isDefaultPrevented() ) {
					event.preventDefault();
				}
				if ( ve.isPropagationStopped() ) {
					event.stopPropagation();
				}
				if ( ve.isImmediatePropagationStopped() ) {
					event.stopImmediatePropagation();
				}
			}
		}
	}
	
	function handleTouchStart( event ) {
	
		var touches = getNativeEvent( event ).touches,
			target, flags;
	
		if ( touches && touches.length === 1 ) {
	
			target = event.target;
			flags = getVirtualBindingFlags( target );
	
			if ( flags.hasVirtualBinding ) {
	
				lastTouchID = nextTouchID++;
				$.data( target, touchTargetPropertyName, lastTouchID );
	
				clearResetTimer();
	
				disableMouseBindings();
				didScroll = false;
	
				var t = getNativeEvent( event ).touches[ 0 ];
				startX = t.pageX;
				startY = t.pageY;
	
				triggerVirtualEvent( "vmouseover", event, flags );
				triggerVirtualEvent( "vmousedown", event, flags );
			}
		}
	}
	
	function handleScroll( event ) {
		if ( blockTouchTriggers ) {
			return;
		}
	
		if ( !didScroll ) {
			triggerVirtualEvent( "vmousecancel", event, getVirtualBindingFlags( event.target ) );
		}
	
		didScroll = true;
		startResetTimer();
	}
	
	function handleTouchMove( event ) {
		if ( blockTouchTriggers ) {
			return;
		}
	
		var t = getNativeEvent( event ).touches[ 0 ],
			didCancel = didScroll,
			moveThreshold = $.vmouse.moveDistanceThreshold;
			didScroll = didScroll ||
				( Math.abs(t.pageX - startX) > moveThreshold ||
					Math.abs(t.pageY - startY) > moveThreshold ),
			flags = getVirtualBindingFlags( event.target );
	
		if ( didScroll && !didCancel ) {
			triggerVirtualEvent( "vmousecancel", event, flags );
		}
	
		triggerVirtualEvent( "vmousemove", event, flags );
		startResetTimer();
	}
	
	function handleTouchEnd( event ) {
		if ( blockTouchTriggers ) {
			return;
		}
	
		disableTouchBindings();
	
		var flags = getVirtualBindingFlags( event.target ),
			t;
		triggerVirtualEvent( "vmouseup", event, flags );
	
		if ( !didScroll ) {
			var ve = triggerVirtualEvent( "vclick", event, flags );
			if ( ve && ve.isDefaultPrevented() ) {
				// The target of the mouse events that follow the touchend
				// event don't necessarily match the target used during the
				// touch. This means we need to rely on coordinates for blocking
				// any click that is generated.
				t = getNativeEvent( event ).changedTouches[ 0 ];
				clickBlockList.push({
					touchID: lastTouchID,
					x: t.clientX,
					y: t.clientY
				});
	
				// Prevent any mouse events that follow from triggering
				// virtual event notifications.
				blockMouseTriggers = true;
			}
		}
		triggerVirtualEvent( "vmouseout", event, flags);
		didScroll = false;
	
		startResetTimer();
	}
	
	function hasVirtualBindings( ele ) {
		var bindings = $.data( ele, dataPropertyName ),
			k;
	
		if ( bindings ) {
			for ( k in bindings ) {
				if ( bindings[ k ] ) {
					return true;
				}
			}
		}
		return false;
	}
	
	function dummyMouseHandler(){}
	
	function getSpecialEventObject( eventType ) {
		var realType = eventType.substr( 1 );
	
		return {
			setup: function( data, namespace ) {
				// If this is the first virtual mouse binding for this element,
				// add a bindings object to its data.
	
				if ( !hasVirtualBindings( this ) ) {
					$.data( this, dataPropertyName, {});
				}
	
				// If setup is called, we know it is the first binding for this
				// eventType, so initialize the count for the eventType to zero.
				var bindings = $.data( this, dataPropertyName );
				bindings[ eventType ] = true;
	
				// If this is the first virtual mouse event for this type,
				// register a global handler on the document.
	
				activeDocHandlers[ eventType ] = ( activeDocHandlers[ eventType ] || 0 ) + 1;
	
				if ( activeDocHandlers[ eventType ] === 1 ) {
					$document.bind( realType, mouseEventCallback );
				}
	
				// Some browsers, like Opera Mini, won't dispatch mouse/click events
				// for elements unless they actually have handlers registered on them.
				// To get around this, we register dummy handlers on the elements.
	
				$( this ).bind( realType, dummyMouseHandler );
	
				// For now, if event capture is not supported, we rely on mouse handlers.
				if ( eventCaptureSupported ) {
					// If this is the first virtual mouse binding for the document,
					// register our touchstart handler on the document.
	
					activeDocHandlers[ "touchstart" ] = ( activeDocHandlers[ "touchstart" ] || 0) + 1;
	
					if (activeDocHandlers[ "touchstart" ] === 1) {
						$document.bind( "touchstart", handleTouchStart )
							.bind( "touchend", handleTouchEnd )
	
							// On touch platforms, touching the screen and then dragging your finger
							// causes the window content to scroll after some distance threshold is
							// exceeded. On these platforms, a scroll prevents a click event from being
							// dispatched, and on some platforms, even the touchend is suppressed. To
							// mimic the suppression of the click event, we need to watch for a scroll
							// event. Unfortunately, some platforms like iOS don't dispatch scroll
							// events until *AFTER* the user lifts their finger (touchend). This means
							// we need to watch both scroll and touchmove events to figure out whether
							// or not a scroll happenens before the touchend event is fired.
	
							.bind( "touchmove", handleTouchMove )
							.bind( "scroll", handleScroll );
					}
				}
			},
	
			teardown: function( data, namespace ) {
				// If this is the last virtual binding for this eventType,
				// remove its global handler from the document.
	
				--activeDocHandlers[ eventType ];
	
				if ( !activeDocHandlers[ eventType ] ) {
					$document.unbind( realType, mouseEventCallback );
				}
	
				if ( eventCaptureSupported ) {
					// If this is the last virtual mouse binding in existence,
					// remove our document touchstart listener.
	
					--activeDocHandlers[ "touchstart" ];
	
					if ( !activeDocHandlers[ "touchstart" ] ) {
						$document.unbind( "touchstart", handleTouchStart )
							.unbind( "touchmove", handleTouchMove )
							.unbind( "touchend", handleTouchEnd )
							.unbind( "scroll", handleScroll );
					}
				}
	
				var $this = $( this ),
					bindings = $.data( this, dataPropertyName );
	
				// teardown may be called when an element was
				// removed from the DOM. If this is the case,
				// jQuery core may have already stripped the element
				// of any data bindings so we need to check it before
				// using it.
				if ( bindings ) {
					bindings[ eventType ] = false;
				}
	
				// Unregister the dummy event handler.
	
				$this.unbind( realType, dummyMouseHandler );
	
				// If this is the last virtual mouse binding on the
				// element, remove the binding data from the element.
	
				if ( !hasVirtualBindings( this ) ) {
					$this.removeData( dataPropertyName );
				}
			}
		};
	}
	
	// Expose our custom events to the jQuery bind/unbind mechanism.
	
	for ( var i = 0; i < virtualEventNames.length; i++ ){
		$.event.special[ virtualEventNames[ i ] ] = getSpecialEventObject( virtualEventNames[ i ] );
	}
	
	// Add a capture click handler to block clicks.
	// Note that we require event capture support for this so if the device
	// doesn't support it, we punt for now and rely solely on mouse events.
	if ( eventCaptureSupported ) {
		document.addEventListener( "click", function( e ){
			var cnt = clickBlockList.length,
				target = e.target,
				x, y, ele, i, o, touchID;
	
			if ( cnt ) {
				x = e.clientX;
				y = e.clientY;
				threshold = $.vmouse.clickDistanceThreshold;
	
				// The idea here is to run through the clickBlockList to see if
				// the current click event is in the proximity of one of our
				// vclick events that had preventDefault() called on it. If we find
				// one, then we block the click.
				//
				// Why do we have to rely on proximity?
				//
				// Because the target of the touch event that triggered the vclick
				// can be different from the target of the click event synthesized
				// by the browser. The target of a mouse/click event that is syntehsized
				// from a touch event seems to be implementation specific. For example,
				// some browsers will fire mouse/click events for a link that is near
				// a touch event, even though the target of the touchstart/touchend event
				// says the user touched outside the link. Also, it seems that with most
				// browsers, the target of the mouse/click event is not calculated until the
				// time it is dispatched, so if you replace an element that you touched
				// with another element, the target of the mouse/click will be the new
				// element underneath that point.
				//
				// Aside from proximity, we also check to see if the target and any
				// of its ancestors were the ones that blocked a click. This is necessary
				// because of the strange mouse/click target calculation done in the
				// Android 2.1 browser, where if you click on an element, and there is a
				// mouse/click handler on one of its ancestors, the target will be the
				// innermost child of the touched element, even if that child is no where
				// near the point of touch.
	
				ele = target;
	
				while ( ele ) {
					for ( i = 0; i < cnt; i++ ) {
						o = clickBlockList[ i ];
						touchID = 0;
	
						if ( ( ele === target && Math.abs( o.x - x ) < threshold && Math.abs( o.y - y ) < threshold ) ||
									$.data( ele, touchTargetPropertyName ) === o.touchID ) {
							// XXX: We may want to consider removing matches from the block list
							//      instead of waiting for the reset timer to fire.
							e.preventDefault();
							e.stopPropagation();
							return;
						}
					}
					ele = ele.parentNode;
				}
			}
		}, true);
	}
	})( jQuery, window, document );


/***/ },
/* 475 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A component that renders a keypad button.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(397),
	    connect = _require.connect;
	
	var _require2 = __webpack_require__(414),
	    StyleSheet = _require2.StyleSheet,
	    css = _require2.css;
	
	var _require3 = __webpack_require__(357),
	    View = _require3.View;
	
	var Icon = __webpack_require__(524);
	var MultiSymbolGrid = __webpack_require__(525);
	var CornerDecal = __webpack_require__(526);
	
	var _require4 = __webpack_require__(283),
	    KeyTypes = _require4.KeyTypes,
	    BorderDirections = _require4.BorderDirections,
	    BorderStyles = _require4.BorderStyles;
	
	var _require5 = __webpack_require__(355),
	    brightGreen = _require5.brightGreen,
	    innerBorderColor = _require5.innerBorderColor,
	    innerBorderStyle = _require5.innerBorderStyle,
	    innerBorderWidthPx = _require5.innerBorderWidthPx,
	    valueGrey = _require5.valueGrey,
	    operatorGrey = _require5.operatorGrey,
	    controlGrey = _require5.controlGrey,
	    emptyGrey = _require5.emptyGrey;
	
	var _require6 = __webpack_require__(295),
	    bordersPropType = _require6.bordersPropType,
	    iconPropType = _require6.iconPropType,
	    keyConfigPropType = _require6.keyConfigPropType;
	
	var KeypadButton = function (_React$PureComponent) {
	    _inherits(KeypadButton, _React$PureComponent);
	
	    function KeypadButton() {
	        var _temp, _this, _ret;
	
	        _classCallCheck(this, KeypadButton);
	
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$PureComponent.call.apply(_React$PureComponent, [this].concat(args))), _this), _this._preInjectStyles = function () {
	            // HACK(charlie): Pre-inject all of the possible styles for the button.
	            // This avoids a flickering effect in the echo animation whereby the
	            // echoes vary in size as they animate. Note that we need to account for
	            // the "initial" styles that `View` will include, as these styles are
	            // applied to `View` components and Aphrodite will consolidate the style
	            // object. This method must be called whenever a property that
	            // influences the possible outcomes of `this._getFocusStyle` and
	            // `this._getButtonStyle` changes (such as `this.buttonSizeStyle`).
	            for (var _iterator = Object.keys(KeyTypes), _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
	                var _ref;
	
	                if (_isArray) {
	                    if (_i >= _iterator.length) break;
	                    _ref = _iterator[_i++];
	                } else {
	                    _i = _iterator.next();
	                    if (_i.done) break;
	                    _ref = _i.value;
	                }
	
	                var type = _ref;
	
	                css.apply(undefined, [View.styles.initial].concat(_this._getFocusStyle(type)));
	
	                for (var _iterator2 = Object.values(BorderStyles), _isArray2 = Array.isArray(_iterator2), _i2 = 0, _iterator2 = _isArray2 ? _iterator2 : _iterator2[Symbol.iterator]();;) {
	                    var _ref2;
	
	                    if (_isArray2) {
	                        if (_i2 >= _iterator2.length) break;
	                        _ref2 = _iterator2[_i2++];
	                    } else {
	                        _i2 = _iterator2.next();
	                        if (_i2.done) break;
	                        _ref2 = _i2.value;
	                    }
	
	                    var borders = _ref2;
	
	                    css.apply(undefined, [View.styles.initial].concat(_this._getButtonStyle(type, borders)));
	                }
	            }
	        }, _this._getFocusStyle = function (type) {
	            var focusBackgroundStyle = void 0;
	            if (type === KeyTypes.INPUT_NAVIGATION || type === KeyTypes.KEYPAD_NAVIGATION) {
	                focusBackgroundStyle = styles.light;
	            } else {
	                focusBackgroundStyle = styles.bright;
	            }
	
	            return [styles.focusBox, focusBackgroundStyle];
	        }, _this._getButtonStyle = function (type, borders, style) {
	            // Select the appropriate style for the button.
	            var backgroundStyle = void 0;
	            switch (type) {
	                case KeyTypes.EMPTY:
	                    backgroundStyle = styles.empty;
	                    break;
	
	                case KeyTypes.MANY:
	                case KeyTypes.VALUE:
	                    backgroundStyle = styles.value;
	                    break;
	
	                case KeyTypes.OPERATOR:
	                    backgroundStyle = styles.operator;
	                    break;
	
	                case KeyTypes.INPUT_NAVIGATION:
	                case KeyTypes.KEYPAD_NAVIGATION:
	                    backgroundStyle = styles.control;
	                    break;
	
	                case KeyTypes.ECHO:
	                    backgroundStyle = null;
	                    break;
	            }
	
	            var borderStyle = [];
	            if (borders.indexOf(BorderDirections.LEFT) !== -1) {
	                borderStyle.push(styles.leftBorder);
	            }
	            if (borders.indexOf(BorderDirections.BOTTOM) !== -1) {
	                borderStyle.push(styles.bottomBorder);
	            }
	
	            return [styles.buttonBase, backgroundStyle].concat(borderStyle, [type === KeyTypes.ECHO && styles.echo, _this.buttonSizeStyle], Array.isArray(style) ? style : [style]);
	        }, _temp), _possibleConstructorReturn(_this, _ret);
	    }
	
	    KeypadButton.prototype.componentWillMount = function componentWillMount() {
	        this.buttonSizeStyle = styleForButtonDimensions(this.props.heightPx, this.props.widthPx);
	    };
	
	    KeypadButton.prototype.componentDidMount = function componentDidMount() {
	        this._preInjectStyles();
	    };
	
	    KeypadButton.prototype.componentWillUpdate = function componentWillUpdate(newProps, newState) {
	        // Only recompute the Aphrodite StyleSheet when the button height has
	        // changed. Though it is safe to recompute the StyleSheet (since
	        // they're content-addressable), it saves us a bunch of hashing and
	        // other work to cache it here.
	        if (newProps.heightPx !== this.props.heightPx || newProps.widthPx !== this.props.widthPx) {
	            this.buttonSizeStyle = styleForButtonDimensions(newProps.heightPx, newProps.widthPx);
	
	            this._preInjectStyles();
	        }
	    };
	
	    KeypadButton.prototype.render = function render() {
	        var _props = this.props,
	            ariaLabel = _props.ariaLabel,
	            borders = _props.borders,
	            childKeys = _props.childKeys,
	            disabled = _props.disabled,
	            focused = _props.focused,
	            icon = _props.icon,
	            onTouchCancel = _props.onTouchCancel,
	            onTouchEnd = _props.onTouchEnd,
	            onTouchMove = _props.onTouchMove,
	            onTouchStart = _props.onTouchStart,
	            popoverEnabled = _props.popoverEnabled,
	            style = _props.style,
	            type = _props.type;
	
	        // We render in the focus state if the key is focused, or if it's an
	        // echo.
	
	        var renderFocused = !disabled && focused || popoverEnabled || type === KeyTypes.ECHO;
	        var buttonStyle = this._getButtonStyle(type, borders, style);
	        var focusStyle = this._getFocusStyle(type);
	        var iconWrapperStyle = [styles.iconWrapper, disabled && styles.disabled];
	
	        var eventHandlers = {
	            onTouchCancel: onTouchCancel, onTouchEnd: onTouchEnd, onTouchMove: onTouchMove, onTouchStart: onTouchStart
	        };
	
	        var maybeFocusBox = renderFocused && React.createElement(View, { style: focusStyle });
	        var maybeCornerDecal = !renderFocused && !disabled && childKeys && childKeys.length > 0 && React.createElement(CornerDecal, { style: styles.decalInset });
	
	        if (type === KeyTypes.EMPTY) {
	            return React.createElement(View, _extends({ style: buttonStyle }, eventHandlers));
	        } else if (type === KeyTypes.MANY) {
	            // TODO(charlie): Make the long-press interaction accessible. See
	            // the TODO in key-configs.js for more.
	            var manyButtonA11yMarkup = {
	                role: 'button',
	                ariaLabel: childKeys[0].ariaLabel
	            };
	            var icons = childKeys.map(function (keyConfig) {
	                return keyConfig.icon;
	            });
	            return React.createElement(
	                View,
	                _extends({
	                    style: buttonStyle
	                }, eventHandlers, manyButtonA11yMarkup),
	                maybeFocusBox,
	                React.createElement(
	                    View,
	                    { style: iconWrapperStyle },
	                    React.createElement(MultiSymbolGrid, { icons: icons, focused: renderFocused })
	                ),
	                maybeCornerDecal
	            );
	        } else {
	            var a11yMarkup = {
	                role: 'button',
	                ariaLabel: ariaLabel
	            };
	
	            return React.createElement(
	                View,
	                _extends({ style: buttonStyle }, eventHandlers, a11yMarkup),
	                maybeFocusBox,
	                React.createElement(
	                    View,
	                    { style: iconWrapperStyle },
	                    React.createElement(Icon, { icon: icon, focused: renderFocused })
	                ),
	                maybeCornerDecal
	            );
	        }
	    };
	
	    return KeypadButton;
	}(React.PureComponent);
	
	KeypadButton.propTypes = {
	    ariaLabel: React.PropTypes.string,
	    // The borders to display on the button. Typically, this should be set
	    // using one of the preset `BorderStyles` options.
	    borders: bordersPropType,
	    // Any additional keys that can be accessed by long-pressing on the
	    // button.
	    childKeys: React.PropTypes.arrayOf(keyConfigPropType),
	    // Whether the button should be rendered in a 'disabled' state, i.e.,
	    // without any touch feedback.
	    disabled: React.PropTypes.bool,
	    focused: React.PropTypes.bool,
	    heightPx: React.PropTypes.number.isRequired,
	    icon: iconPropType,
	    onTouchCancel: React.PropTypes.func,
	    onTouchEnd: React.PropTypes.func,
	    onTouchMove: React.PropTypes.func,
	    onTouchStart: React.PropTypes.func,
	    popoverEnabled: React.PropTypes.bool,
	    style: React.PropTypes.any,
	    type: React.PropTypes.oneOf(Object.keys(KeyTypes)).isRequired,
	    // NOTE(charlie): We may want to make this optional for phone layouts
	    // (and rely on Flexbox instead), since it might not be pixel perfect
	    // with borders and such.
	    widthPx: React.PropTypes.number.isRequired
	};
	KeypadButton.defaultProps = {
	    borders: BorderStyles.ALL,
	    childKeys: [],
	    disabled: false,
	    focused: false,
	    popoverEnabled: false
	};
	
	
	var focusInsetPx = 4;
	var focusBoxZIndex = 0;
	
	var styles = StyleSheet.create({
	    buttonBase: {
	        // HACK(benkomalo): support old style flex box in Android browsers
	        '-webkit-box-flex': '1',
	        flex: 1,
	        cursor: 'pointer',
	        // Make the text unselectable
	        userSelect: 'none',
	        justifyContent: 'center',
	        alignItems: 'center',
	        // Borders are made selectively visible.
	        borderColor: innerBorderColor,
	        borderStyle: innerBorderStyle,
	        boxSizing: 'border-box'
	    },
	
	    decalInset: {
	        top: focusInsetPx,
	        right: focusInsetPx
	    },
	
	    // Overrides for the echo state, where we want to render the borders for
	    // layout purposes, but we don't want them to be visible.
	    echo: {
	        borderColor: 'transparent'
	    },
	
	    // Background colors and other base styles that may vary between key types.
	    value: {
	        backgroundColor: valueGrey
	    },
	    operator: {
	        backgroundColor: operatorGrey
	    },
	    control: {
	        backgroundColor: controlGrey
	    },
	    empty: {
	        backgroundColor: emptyGrey,
	        cursor: 'default'
	    },
	
	    bright: {
	        backgroundColor: brightGreen
	    },
	    light: {
	        backgroundColor: 'rgba(33, 36, 44, 0.1)'
	    },
	
	    iconWrapper: {
	        zIndex: focusBoxZIndex + 1
	    },
	
	    focusBox: {
	        position: 'absolute',
	        zIndex: focusBoxZIndex,
	        left: focusInsetPx,
	        right: focusInsetPx,
	        bottom: focusInsetPx,
	        top: focusInsetPx,
	        borderRadius: 1
	    },
	
	    disabled: {
	        opacity: 0.3
	    },
	
	    // Styles used to render the appropriate borders. Buttons are only allowed
	    // to render left and bottom borders, to simplify layout.
	    leftBorder: {
	        borderLeftWidth: innerBorderWidthPx
	    },
	    bottomBorder: {
	        borderBottomWidth: innerBorderWidthPx
	    }
	});
	
	var styleForButtonDimensions = function styleForButtonDimensions(heightPx, widthPx) {
	    return StyleSheet.create({
	        buttonSize: {
	            height: heightPx,
	            width: widthPx,
	            maxWidth: widthPx
	        }
	    }).buttonSize;
	};
	
	var mapStateToProps = function mapStateToProps(state) {
	    return state.layout.buttonDimensions;
	};
	
	module.exports = connect(mapStateToProps)(KeypadButton);

/***/ },
/* 476 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A component that renders and animates the selection state effect effect.
	 */
	
	var React = __webpack_require__(43);
	var ReactCSSTransitionGroup = __webpack_require__(527);
	var KeypadButton = __webpack_require__(475);
	var KeyConfigs = __webpack_require__(315);
	
	var _require = __webpack_require__(283),
	    KeyTypes = _require.KeyTypes,
	    EchoAnimationTypes = _require.EchoAnimationTypes;
	
	var _require2 = __webpack_require__(295),
	    echoPropType = _require2.echoPropType,
	    bordersPropType = _require2.bordersPropType,
	    boundingBoxPropType = _require2.boundingBoxPropType,
	    keyIdPropType = _require2.keyIdPropType;
	
	var zIndexes = __webpack_require__(363);
	
	var Echo = function (_React$Component) {
	    _inherits(Echo, _React$Component);
	
	    function Echo() {
	        _classCallCheck(this, Echo);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Echo.prototype.componentDidMount = function componentDidMount() {
	        // NOTE(charlie): This is somewhat unfortunate, as the component is
	        // encoding information about its own animation, of which it should be
	        // ignorant. However, there doesn't seem to be a cleaner way to make
	        // this happen, and at least here, all the animation context is
	        // colocated in this file.
	        var _props = this.props,
	            animationDurationMs = _props.animationDurationMs,
	            onAnimationFinish = _props.onAnimationFinish;
	
	        setTimeout(function () {
	            return onAnimationFinish();
	        }, animationDurationMs);
	    };
	
	    Echo.prototype.render = function render() {
	        var _props2 = this.props,
	            borders = _props2.borders,
	            id = _props2.id,
	            initialBounds = _props2.initialBounds;
	        var icon = KeyConfigs[id].icon;
	
	
	        var containerStyle = _extends({
	            zIndex: zIndexes.echo,
	            position: 'absolute',
	            pointerEvents: 'none'
	        }, initialBounds);
	
	        // NOTE(charlie): In some browsers, Aphrodite doesn't seem to flush its
	        // styles quickly enough, so there's a flickering effect on the first
	        // animation. Thus, it's much safer to do the styles purely inline.
	        // <View> makes this difficult because some of its defaults, which are
	        // applied via StyleSheet, will override our inlines.
	        return React.createElement(
	            'div',
	            { style: containerStyle },
	            React.createElement(KeypadButton, {
	                name: id,
	                icon: icon,
	                type: KeyTypes.ECHO,
	                borders: borders
	            })
	        );
	    };
	
	    return Echo;
	}(React.Component);
	
	Echo.propTypes = {
	    animationDurationMs: React.PropTypes.number.isRequired,
	    borders: bordersPropType,
	    id: keyIdPropType.isRequired,
	    initialBounds: boundingBoxPropType.isRequired,
	    onAnimationFinish: React.PropTypes.func.isRequired
	};
	
	var EchoManager = function (_React$Component2) {
	    _inherits(EchoManager, _React$Component2);
	
	    function EchoManager() {
	        var _temp, _this2, _ret;
	
	        _classCallCheck(this, EchoManager);
	
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return _ret = (_temp = (_this2 = _possibleConstructorReturn(this, _React$Component2.call.apply(_React$Component2, [this].concat(args))), _this2), _this2._animationConfigForType = function (animationType) {
	            // NOTE(charlie): These must be kept in sync with the transition
	            // durations and classnames specified in echo.css.
	            var animationDurationMs = void 0;
	            var animationTransitionName = void 0;
	
	            switch (animationType) {
	                case EchoAnimationTypes.SLIDE_AND_FADE:
	                    animationDurationMs = 400;
	                    animationTransitionName = 'echo-slide-and-fade';
	                    break;
	
	                case EchoAnimationTypes.FADE_ONLY:
	                    animationDurationMs = 300;
	                    animationTransitionName = 'echo-fade-only';
	                    break;
	
	                case EchoAnimationTypes.LONG_FADE_ONLY:
	                    animationDurationMs = 400;
	                    animationTransitionName = 'echo-long-fade-only';
	                    break;
	
	                default:
	                    throw new Error("Invalid echo animation type:", animationType);
	            }
	
	            return {
	                animationDurationMs: animationDurationMs,
	                animationTransitionName: animationTransitionName
	            };
	        }, _temp), _possibleConstructorReturn(_this2, _ret);
	    }
	
	    EchoManager.prototype.render = function render() {
	        var _this3 = this;
	
	        var _props3 = this.props,
	            echoes = _props3.echoes,
	            _onAnimationFinish = _props3.onAnimationFinish;
	
	
	        return React.createElement(
	            'span',
	            null,
	            Object.keys(EchoAnimationTypes).map(function (animationType) {
	                // Collect the relevant parameters for the animation type, and
	                // filter for the appropriate echoes.
	                var _animationConfigForTy = _this3._animationConfigForType(animationType),
	                    animationDurationMs = _animationConfigForTy.animationDurationMs,
	                    animationTransitionName = _animationConfigForTy.animationTransitionName;
	
	                var echoesForType = echoes.filter(function (echo) {
	                    return echo.animationType === animationType;
	                });
	
	                // TODO(charlie): Manage this animation with Aphrodite styles.
	                // Right now, there's a bug in the autoprefixer that breaks CSS
	                // transitions on mobile Safari.
	                // See: https://github.com/Khan/aphrodite/issues/68.
	                // As such, we have to do this with a stylesheet.
	                return React.createElement(
	                    ReactCSSTransitionGroup,
	                    {
	                        transitionName: animationTransitionName,
	                        transitionEnter: true,
	                        transitionLeave: false,
	                        transitionEnterTimeout: animationDurationMs,
	                        key: animationType
	                    },
	                    echoesForType.map(function (echo) {
	                        var animationId = echo.animationId;
	
	                        return React.createElement(Echo, _extends({
	                            key: animationId,
	                            animationDurationMs: animationDurationMs,
	                            onAnimationFinish: function onAnimationFinish() {
	                                return _onAnimationFinish(animationId);
	                            }
	                        }, echo));
	                    })
	                );
	            })
	        );
	    };
	
	    return EchoManager;
	}(React.Component);
	
	EchoManager.propTypes = {
	    echoes: React.PropTypes.arrayOf(echoPropType),
	    onAnimationFinish: React.PropTypes.func.isRequired
	};
	
	
	module.exports = EchoManager;

/***/ },
/* 477 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A component that renders and animates the popovers that appear over the
	 * multi-functional keys.
	 */
	
	var React = __webpack_require__(43);
	var ReactCSSTransitionGroup = __webpack_require__(527);
	
	var KeyConfigs = __webpack_require__(315);
	var MultiSymbolPopover = __webpack_require__(522);
	
	var _require = __webpack_require__(295),
	    boundingBoxPropType = _require.boundingBoxPropType,
	    keyConfigPropType = _require.keyConfigPropType,
	    popoverPropType = _require.popoverPropType;
	
	// NOTE(charlie): These must be kept in sync with the transition durations and
	// classnames specified in popover.less.
	
	
	var animationTransitionName = 'popover';
	var animationDurationMs = 200;
	
	// A container component used to position a popover absolutely at a specific
	// position.
	
	var PopoverContainer = function (_React$Component) {
	    _inherits(PopoverContainer, _React$Component);
	
	    function PopoverContainer() {
	        _classCallCheck(this, PopoverContainer);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    PopoverContainer.prototype.render = function render() {
	        var _props = this.props,
	            bounds = _props.bounds,
	            childKeys = _props.childKeys;
	
	
	        var containerStyle = _extends({
	            position: 'absolute'
	        }, bounds);
	
	        return React.createElement(
	            'div',
	            { style: containerStyle },
	            React.createElement(MultiSymbolPopover, { keys: childKeys })
	        );
	    };
	
	    return PopoverContainer;
	}(React.Component);
	
	PopoverContainer.propTypes = {
	    bounds: boundingBoxPropType.isRequired,
	    childKeys: React.PropTypes.arrayOf(keyConfigPropType).isRequired
	};
	
	var PopoverManager = function (_React$Component2) {
	    _inherits(PopoverManager, _React$Component2);
	
	    function PopoverManager() {
	        _classCallCheck(this, PopoverManager);
	
	        return _possibleConstructorReturn(this, _React$Component2.apply(this, arguments));
	    }
	
	    PopoverManager.prototype.render = function render() {
	        var popover = this.props.popover;
	
	
	        return React.createElement(
	            ReactCSSTransitionGroup,
	            {
	                transitionName: animationTransitionName,
	                transitionEnter: true,
	                transitionLeave: false,
	                transitionEnterTimeout: animationDurationMs
	            },
	            popover && React.createElement(PopoverContainer, {
	                key: popover.childKeyIds[0],
	                bounds: popover.bounds,
	                childKeys: popover.childKeyIds.map(function (id) {
	                    return KeyConfigs[id];
	                })
	            })
	        );
	    };
	
	    return PopoverManager;
	}(React.Component);
	
	PopoverManager.propTypes = {
	    popover: popoverPropType
	};
	
	
	module.exports = PopoverManager;

/***/ },
/* 478 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A view pager that allows for pagination in the horizontal direction.
	 * Right now, there are a number of limitations built into the system. Namely:
	 *  - It only supports pagination in the horizontal direction.
	 *  - It supports exactly two pages.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(397),
	    connect = _require.connect;
	
	var _require2 = __webpack_require__(414),
	    StyleSheet = _require2.StyleSheet;
	
	var _require3 = __webpack_require__(357),
	    View = _require3.View;
	
	var _require4 = __webpack_require__(364),
	    row = _require4.row;
	
	var _require5 = __webpack_require__(295),
	    childrenPropType = _require5.childrenPropType;
	
	var _require6 = __webpack_require__(355),
	    innerBorderColor = _require6.innerBorderColor,
	    innerBorderStyle = _require6.innerBorderStyle,
	    innerBorderWidthPx = _require6.innerBorderWidthPx;
	
	var ViewPager = function (_React$Component) {
	    _inherits(ViewPager, _React$Component);
	
	    function ViewPager() {
	        var _temp, _this, _ret;
	
	        _classCallCheck(this, ViewPager);
	
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this.state = {
	            animationDurationMs: 0
	        }, _temp), _possibleConstructorReturn(_this, _ret);
	    }
	
	    ViewPager.prototype.componentWillReceiveProps = function componentWillReceiveProps(newProps) {
	        // Compute the appropriate animation length, if the pager should
	        // animate to its next position.
	        var animationDurationMs = void 0;
	        if (newProps.animateToPosition) {
	            var finalTranslateX = newProps.translateX;
	            var prevTranslateX = this.props.translateX;
	
	            // We animate at a rate of 1 pixel per millisecond, and thus we can
	            // use the displacement as the animation duration.
	            animationDurationMs = Math.abs(finalTranslateX - prevTranslateX);
	        } else {
	            animationDurationMs = 0;
	        }
	        this.setState({
	            animationDurationMs: animationDurationMs
	        });
	    };
	
	    ViewPager.prototype.render = function render() {
	        var _props = this.props,
	            children = _props.children,
	            pageWidthPx = _props.pageWidthPx,
	            translateX = _props.translateX;
	        var animationDurationMs = this.state.animationDurationMs;
	
	
	        var pagerStyle = [row, styles.twoPagePager];
	
	        var transform = {
	            msTransform: 'translate3d(' + translateX + 'px, 0, 0)',
	            WebkitTransform: 'translate3d(' + translateX + 'px, 0, 0)',
	            transform: 'translate3d(' + translateX + 'px, 0, 0)'
	        };
	        var animate = animationDurationMs ? {
	            msTransitionProperty: 'transform',
	            WebkitTransitionProperty: 'transform',
	            transitionProperty: 'transform',
	            msTransitionDuration: animationDurationMs + 'ms',
	            WebkitTransitionDuration: animationDurationMs + 'ms',
	            transitionDuration: animationDurationMs + 'ms',
	            msTransitionTimingFunction: 'ease-out',
	            WebkitTransitionTimingFunction: 'ease-out',
	            transitionTimingFunction: 'ease-out'
	        } : {};
	        var dynamicPagerStyle = _extends({}, transform, animate);
	
	        var dynamicPageStyle = {
	            width: pageWidthPx
	        };
	
	        return React.createElement(
	            View,
	            { style: pagerStyle, dynamicStyle: dynamicPagerStyle },
	            React.createElement(
	                View,
	                { dynamicStyle: dynamicPageStyle },
	                children[0]
	            ),
	            React.createElement(
	                View,
	                { style: styles.rightPage, dynamicStyle: dynamicPageStyle },
	                children[1]
	            )
	        );
	    };
	
	    return ViewPager;
	}(React.Component);
	
	ViewPager.propTypes = {
	    // Whether the page should animate to its next specified position.
	    animateToPosition: React.PropTypes.bool,
	    children: childrenPropType,
	    pageWidthPx: React.PropTypes.number.isRequired,
	    translateX: React.PropTypes.number.isRequired
	};
	
	
	var styles = StyleSheet.create({
	    twoPagePager: {
	        alignSelf: 'flex-start',
	        // Note: By default, <View> sets a `maxWidth` of 100% to fix some
	        // Flexbox bugs. We have to override it to accommodate for our two
	        // pages. The exact value here isn't super important, as long as it's
	        // large enough to accommodate for two pages (so, 200%) and some
	        // separators.
	        maxWidth: '250%'
	    },
	
	    rightPage: {
	        borderLeft: innerBorderWidthPx + 'px ' + innerBorderStyle + ' ' + ('' + innerBorderColor),
	        boxSizing: 'content-box'
	    }
	});
	
	var mapStateToProps = function mapStateToProps(state) {
	    var _state$pager = state.pager,
	        animateToPosition = _state$pager.animateToPosition,
	        currentPage = _state$pager.currentPage,
	        dx = _state$pager.dx,
	        pageWidthPx = _state$pager.pageWidthPx;
	
	    return {
	        animateToPosition: animateToPosition,
	        pageWidthPx: pageWidthPx,
	        translateX: -currentPage * (pageWidthPx + innerBorderWidthPx) + dx
	    };
	};
	
	module.exports = connect(mapStateToProps)(ViewPager);

/***/ },
/* 479 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A component that renders a view pager indicator, with a circular icon for
	 * each page.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet;
	
	var _require2 = __webpack_require__(357),
	    View = _require2.View;
	
	var _require3 = __webpack_require__(355),
	    pageIndicatorHeightPx = _require3.pageIndicatorHeightPx,
	    gray68 = _require3.gray68,
	    gray85 = _require3.gray85;
	
	var PagerIcon = function (_React$Component) {
	    _inherits(PagerIcon, _React$Component);
	
	    function PagerIcon() {
	        _classCallCheck(this, PagerIcon);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    PagerIcon.prototype.render = function render() {
	        var _props = this.props,
	            active = _props.active,
	            radiusPx = _props.radiusPx;
	
	
	        var fillColor = active ? gray68 : gray85;
	
	        return React.createElement(
	            'svg',
	            { width: 2 * radiusPx, height: 2 * radiusPx },
	            React.createElement('circle', {
	                cx: radiusPx,
	                cy: radiusPx,
	                r: radiusPx,
	                fill: fillColor
	            })
	        );
	    };
	
	    return PagerIcon;
	}(React.Component);
	
	PagerIcon.propTypes = {
	    active: React.PropTypes.bool,
	    radiusPx: React.PropTypes.number
	};
	PagerIcon.defaultProps = {
	    active: false,
	    radiusPx: 4
	};
	
	var PagerIndicator = function (_React$Component2) {
	    _inherits(PagerIndicator, _React$Component2);
	
	    function PagerIndicator() {
	        _classCallCheck(this, PagerIndicator);
	
	        return _possibleConstructorReturn(this, _React$Component2.apply(this, arguments));
	    }
	
	    PagerIndicator.prototype.render = function render() {
	        var _props2 = this.props,
	            currentPage = _props2.currentPage,
	            numPages = _props2.numPages;
	
	
	        var pagerIconRadiusPx = 4;
	
	        // Collect the various indicator circles.
	        var indicators = [];
	        for (var i = 0; i < numPages; i++) {
	            indicators.push(React.createElement(PagerIcon, {
	                key: i,
	                active: i === currentPage,
	                radiusPx: pagerIconRadiusPx
	            }));
	        }
	
	        // Size the box that contains the icons to accommodate for proper
	        // spacing, and let Flexbox take care of the details.
	        var totalIconWidthPx = 2 * pagerIconRadiusPx * numPages;
	        var totalSpacingWidthPx = 2 * pagerIconRadiusPx * (numPages - 1);
	        var iconStripSize = {
	            width: totalIconWidthPx + totalSpacingWidthPx
	        };
	
	        return React.createElement(
	            View,
	            { style: styles.indicatorStrip },
	            React.createElement(
	                View,
	                { style: styles.iconStrip, dynamicStyle: iconStripSize },
	                indicators
	            )
	        );
	    };
	
	    return PagerIndicator;
	}(React.Component);
	
	PagerIndicator.propTypes = {
	    currentPage: React.PropTypes.number.isRequired,
	    numPages: React.PropTypes.number.isRequired
	};
	
	
	var styles = StyleSheet.create({
	    indicatorStrip: {
	        backgroundColor: '#F0F1F2',
	        flexDirection: 'row',
	        justifyContent: 'center',
	        alignItems: 'center',
	        height: pageIndicatorHeightPx
	    },
	    iconStrip: {
	        flexDirection: 'row',
	        justifyContent: 'space-between'
	    }
	});
	
	module.exports = PagerIndicator;

/***/ },
/* 480 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A keypad button containing no symbols and triggering no actions on click.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(397),
	    connect = _require.connect;
	
	var GestureManager = __webpack_require__(405);
	var KeyConfigs = __webpack_require__(315);
	var KeypadButton = __webpack_require__(475);
	
	var EmptyKeypadButton = function (_React$Component) {
	    _inherits(EmptyKeypadButton, _React$Component);
	
	    function EmptyKeypadButton() {
	        _classCallCheck(this, EmptyKeypadButton);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    EmptyKeypadButton.prototype.render = function render() {
	        var _props = this.props,
	            gestureManager = _props.gestureManager,
	            rest = _objectWithoutProperties(_props, ['gestureManager']);
	
	        // Register touch events on the button, but don't register its DOM node
	        // or compute focus state or anything like that. We want the gesture
	        // manager to know about touch events that start on empty buttons, but
	        // we don't need it to know about their DOM nodes, as it doesn't need
	        // to focus them or trigger presses.
	
	
	        return React.createElement(KeypadButton, _extends({
	            onTouchStart: function onTouchStart(evt) {
	                return gestureManager.onTouchStart(evt);
	            },
	            onTouchEnd: function onTouchEnd(evt) {
	                return gestureManager.onTouchEnd(evt);
	            },
	            onTouchMove: function onTouchMove(evt) {
	                return gestureManager.onTouchMove(evt);
	            },
	            onTouchCancel: function onTouchCancel(evt) {
	                return gestureManager.onTouchCancel(evt);
	            }
	        }, KeyConfigs.NOOP, rest));
	    };
	
	    return EmptyKeypadButton;
	}(React.Component);
	
	EmptyKeypadButton.propTypes = {
	    gestureManager: React.PropTypes.instanceOf(GestureManager)
	};
	
	
	var mapStateToProps = function mapStateToProps(state) {
	    var gestures = state.gestures;
	
	    return {
	        gestureManager: gestures.gestureManager
	    };
	};
	
	module.exports = connect(mapStateToProps)(EmptyKeypadButton);

/***/ },
/* 481 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * 
	 */
	
	var isTextNode = __webpack_require__(528);
	
	/*eslint-disable no-bitwise */
	
	/**
	 * Checks if a given DOM node contains or is another DOM node.
	 */
	function containsNode(outerNode, innerNode) {
	  if (!outerNode || !innerNode) {
	    return false;
	  } else if (outerNode === innerNode) {
	    return true;
	  } else if (isTextNode(outerNode)) {
	    return false;
	  } else if (isTextNode(innerNode)) {
	    return containsNode(outerNode, innerNode.parentNode);
	  } else if ('contains' in outerNode) {
	    return outerNode.contains(innerNode);
	  } else if (outerNode.compareDocumentPosition) {
	    return !!(outerNode.compareDocumentPosition(innerNode) & 16);
	  } else {
	    return false;
	  }
	}
	
	module.exports = containsNode;

/***/ },
/* 482 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	/* eslint-disable fb-www/typeof-undefined */
	
	/**
	 * Same as document.activeElement but wraps in a try-catch block. In IE it is
	 * not safe to call document.activeElement if there is nothing focused.
	 *
	 * The activeElement will be null only if the document or document body is not
	 * yet defined.
	 *
	 * @param {?DOMDocument} doc Defaults to current document.
	 * @return {?DOMElement}
	 */
	function getActiveElement(doc) /*?DOMElement*/{
	  doc = doc || (typeof document !== 'undefined' ? document : undefined);
	  if (typeof doc === 'undefined') {
	    return null;
	  }
	  try {
	    return doc.activeElement || doc.body;
	  } catch (e) {
	    return doc.body;
	  }
	}
	
	module.exports = getActiveElement;

/***/ },
/* 483 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	/**
	 * Usage note:
	 * This module makes a best effort to export the same data we would internally.
	 * At Facebook we use a server-generated module that does the parsing and
	 * exports the data for the client to use. We can't rely on a server-side
	 * implementation in open source so instead we make use of an open source
	 * library to do the heavy lifting and then make some adjustments as necessary.
	 * It's likely there will be some differences. Some we can smooth over.
	 * Others are going to be harder.
	 */
	
	'use strict';
	
	var UAParser = __webpack_require__(551);
	
	var UNKNOWN = 'Unknown';
	
	var PLATFORM_MAP = {
	  'Mac OS': 'Mac OS X'
	};
	
	/**
	 * Convert from UAParser platform name to what we expect.
	 */
	function convertPlatformName(name) {
	  return PLATFORM_MAP[name] || name;
	}
	
	/**
	 * Get the version number in parts. This is very naive. We actually get major
	 * version as a part of UAParser already, which is generally good enough, but
	 * let's get the minor just in case.
	 */
	function getBrowserVersion(version) {
	  if (!version) {
	    return {
	      major: '',
	      minor: ''
	    };
	  }
	  var parts = version.split('.');
	  return {
	    major: parts[0],
	    minor: parts[1]
	  };
	}
	
	/**
	 * Get the UA data fom UAParser and then convert it to the format we're
	 * expecting for our APIS.
	 */
	var parser = new UAParser();
	var results = parser.getResult();
	
	// Do some conversion first.
	var browserVersionData = getBrowserVersion(results.browser.version);
	var uaData = {
	  browserArchitecture: results.cpu.architecture || UNKNOWN,
	  browserFullVersion: results.browser.version || UNKNOWN,
	  browserMinorVersion: browserVersionData.minor || UNKNOWN,
	  browserName: results.browser.name || UNKNOWN,
	  browserVersion: results.browser.major || UNKNOWN,
	  deviceName: results.device.model || UNKNOWN,
	  engineName: results.engine.name || UNKNOWN,
	  engineVersion: results.engine.version || UNKNOWN,
	  platformArchitecture: results.cpu.architecture || UNKNOWN,
	  platformName: convertPlatformName(results.os.name) || UNKNOWN,
	  platformVersion: results.os.version || UNKNOWN,
	  platformFullVersion: results.os.version || UNKNOWN
	};
	
	module.exports = uaData;

/***/ },
/* 484 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	var invariant = __webpack_require__(432);
	
	var componentRegex = /\./;
	var orRegex = /\|\|/;
	var rangeRegex = /\s+\-\s+/;
	var modifierRegex = /^(<=|<|=|>=|~>|~|>|)?\s*(.+)/;
	var numericRegex = /^(\d*)(.*)/;
	
	/**
	 * Splits input `range` on "||" and returns true if any subrange matches
	 * `version`.
	 *
	 * @param {string} range
	 * @param {string} version
	 * @returns {boolean}
	 */
	function checkOrExpression(range, version) {
	  var expressions = range.split(orRegex);
	
	  if (expressions.length > 1) {
	    return expressions.some(function (range) {
	      return VersionRange.contains(range, version);
	    });
	  } else {
	    range = expressions[0].trim();
	    return checkRangeExpression(range, version);
	  }
	}
	
	/**
	 * Splits input `range` on " - " (the surrounding whitespace is required) and
	 * returns true if version falls between the two operands.
	 *
	 * @param {string} range
	 * @param {string} version
	 * @returns {boolean}
	 */
	function checkRangeExpression(range, version) {
	  var expressions = range.split(rangeRegex);
	
	  !(expressions.length > 0 && expressions.length <= 2) ? true ? invariant(false, 'the "-" operator expects exactly 2 operands') : invariant(false) : void 0;
	
	  if (expressions.length === 1) {
	    return checkSimpleExpression(expressions[0], version);
	  } else {
	    var startVersion = expressions[0],
	        endVersion = expressions[1];
	
	    !(isSimpleVersion(startVersion) && isSimpleVersion(endVersion)) ? true ? invariant(false, 'operands to the "-" operator must be simple (no modifiers)') : invariant(false) : void 0;
	
	    return checkSimpleExpression('>=' + startVersion, version) && checkSimpleExpression('<=' + endVersion, version);
	  }
	}
	
	/**
	 * Checks if `range` matches `version`. `range` should be a "simple" range (ie.
	 * not a compound range using the " - " or "||" operators).
	 *
	 * @param {string} range
	 * @param {string} version
	 * @returns {boolean}
	 */
	function checkSimpleExpression(range, version) {
	  range = range.trim();
	  if (range === '') {
	    return true;
	  }
	
	  var versionComponents = version.split(componentRegex);
	
	  var _getModifierAndCompon = getModifierAndComponents(range),
	      modifier = _getModifierAndCompon.modifier,
	      rangeComponents = _getModifierAndCompon.rangeComponents;
	
	  switch (modifier) {
	    case '<':
	      return checkLessThan(versionComponents, rangeComponents);
	    case '<=':
	      return checkLessThanOrEqual(versionComponents, rangeComponents);
	    case '>=':
	      return checkGreaterThanOrEqual(versionComponents, rangeComponents);
	    case '>':
	      return checkGreaterThan(versionComponents, rangeComponents);
	    case '~':
	    case '~>':
	      return checkApproximateVersion(versionComponents, rangeComponents);
	    default:
	      return checkEqual(versionComponents, rangeComponents);
	  }
	}
	
	/**
	 * Checks whether `a` is less than `b`.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkLessThan(a, b) {
	  return compareComponents(a, b) === -1;
	}
	
	/**
	 * Checks whether `a` is less than or equal to `b`.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkLessThanOrEqual(a, b) {
	  var result = compareComponents(a, b);
	  return result === -1 || result === 0;
	}
	
	/**
	 * Checks whether `a` is equal to `b`.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkEqual(a, b) {
	  return compareComponents(a, b) === 0;
	}
	
	/**
	 * Checks whether `a` is greater than or equal to `b`.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkGreaterThanOrEqual(a, b) {
	  var result = compareComponents(a, b);
	  return result === 1 || result === 0;
	}
	
	/**
	 * Checks whether `a` is greater than `b`.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkGreaterThan(a, b) {
	  return compareComponents(a, b) === 1;
	}
	
	/**
	 * Checks whether `a` is "reasonably close" to `b` (as described in
	 * https://www.npmjs.org/doc/misc/semver.html). For example, if `b` is "1.3.1"
	 * then "reasonably close" is defined as ">= 1.3.1 and < 1.4".
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {boolean}
	 */
	function checkApproximateVersion(a, b) {
	  var lowerBound = b.slice();
	  var upperBound = b.slice();
	
	  if (upperBound.length > 1) {
	    upperBound.pop();
	  }
	  var lastIndex = upperBound.length - 1;
	  var numeric = parseInt(upperBound[lastIndex], 10);
	  if (isNumber(numeric)) {
	    upperBound[lastIndex] = numeric + 1 + '';
	  }
	
	  return checkGreaterThanOrEqual(a, lowerBound) && checkLessThan(a, upperBound);
	}
	
	/**
	 * Extracts the optional modifier (<, <=, =, >=, >, ~, ~>) and version
	 * components from `range`.
	 *
	 * For example, given `range` ">= 1.2.3" returns an object with a `modifier` of
	 * `">="` and `components` of `[1, 2, 3]`.
	 *
	 * @param {string} range
	 * @returns {object}
	 */
	function getModifierAndComponents(range) {
	  var rangeComponents = range.split(componentRegex);
	  var matches = rangeComponents[0].match(modifierRegex);
	  !matches ? true ? invariant(false, 'expected regex to match but it did not') : invariant(false) : void 0;
	
	  return {
	    modifier: matches[1],
	    rangeComponents: [matches[2]].concat(rangeComponents.slice(1))
	  };
	}
	
	/**
	 * Determines if `number` is a number.
	 *
	 * @param {mixed} number
	 * @returns {boolean}
	 */
	function isNumber(number) {
	  return !isNaN(number) && isFinite(number);
	}
	
	/**
	 * Tests whether `range` is a "simple" version number without any modifiers
	 * (">", "~" etc).
	 *
	 * @param {string} range
	 * @returns {boolean}
	 */
	function isSimpleVersion(range) {
	  return !getModifierAndComponents(range).modifier;
	}
	
	/**
	 * Zero-pads array `array` until it is at least `length` long.
	 *
	 * @param {array} array
	 * @param {number} length
	 */
	function zeroPad(array, length) {
	  for (var i = array.length; i < length; i++) {
	    array[i] = '0';
	  }
	}
	
	/**
	 * Normalizes `a` and `b` in preparation for comparison by doing the following:
	 *
	 * - zero-pads `a` and `b`
	 * - marks any "x", "X" or "*" component in `b` as equivalent by zero-ing it out
	 *   in both `a` and `b`
	 * - marks any final "*" component in `b` as a greedy wildcard by zero-ing it
	 *   and all of its successors in `a`
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {array<array<string>>}
	 */
	function normalizeVersions(a, b) {
	  a = a.slice();
	  b = b.slice();
	
	  zeroPad(a, b.length);
	
	  // mark "x" and "*" components as equal
	  for (var i = 0; i < b.length; i++) {
	    var matches = b[i].match(/^[x*]$/i);
	    if (matches) {
	      b[i] = a[i] = '0';
	
	      // final "*" greedily zeros all remaining components
	      if (matches[0] === '*' && i === b.length - 1) {
	        for (var j = i; j < a.length; j++) {
	          a[j] = '0';
	        }
	      }
	    }
	  }
	
	  zeroPad(b, a.length);
	
	  return [a, b];
	}
	
	/**
	 * Returns the numerical -- not the lexicographical -- ordering of `a` and `b`.
	 *
	 * For example, `10-alpha` is greater than `2-beta`.
	 *
	 * @param {string} a
	 * @param {string} b
	 * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,
	 * or greater than `b`, respectively
	 */
	function compareNumeric(a, b) {
	  var aPrefix = a.match(numericRegex)[1];
	  var bPrefix = b.match(numericRegex)[1];
	  var aNumeric = parseInt(aPrefix, 10);
	  var bNumeric = parseInt(bPrefix, 10);
	
	  if (isNumber(aNumeric) && isNumber(bNumeric) && aNumeric !== bNumeric) {
	    return compare(aNumeric, bNumeric);
	  } else {
	    return compare(a, b);
	  }
	}
	
	/**
	 * Returns the ordering of `a` and `b`.
	 *
	 * @param {string|number} a
	 * @param {string|number} b
	 * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,
	 * or greater than `b`, respectively
	 */
	function compare(a, b) {
	  !(typeof a === typeof b) ? true ? invariant(false, '"a" and "b" must be of the same type') : invariant(false) : void 0;
	
	  if (a > b) {
	    return 1;
	  } else if (a < b) {
	    return -1;
	  } else {
	    return 0;
	  }
	}
	
	/**
	 * Compares arrays of version components.
	 *
	 * @param {array<string>} a
	 * @param {array<string>} b
	 * @returns {number} -1, 0 or 1 to indicate whether `a` is less than, equal to,
	 * or greater than `b`, respectively
	 */
	function compareComponents(a, b) {
	  var _normalizeVersions = normalizeVersions(a, b),
	      aNormalized = _normalizeVersions[0],
	      bNormalized = _normalizeVersions[1];
	
	  for (var i = 0; i < bNormalized.length; i++) {
	    var result = compareNumeric(aNormalized[i], bNormalized[i]);
	    if (result) {
	      return result;
	    }
	  }
	
	  return 0;
	}
	
	var VersionRange = {
	  /**
	   * Checks whether `version` satisfies the `range` specification.
	   *
	   * We support a subset of the expressions defined in
	   * https://www.npmjs.org/doc/misc/semver.html:
	   *
	   *    version   Must match version exactly
	   *    =version  Same as just version
	   *    >version  Must be greater than version
	   *    >=version Must be greater than or equal to version
	   *    <version  Must be less than version
	   *    <=version Must be less than or equal to version
	   *    ~version  Must be at least version, but less than the next significant
	   *              revision above version:
	   *              "~1.2.3" is equivalent to ">= 1.2.3 and < 1.3"
	   *    ~>version Equivalent to ~version
	   *    1.2.x     Must match "1.2.x", where "x" is a wildcard that matches
	   *              anything
	   *    1.2.*     Similar to "1.2.x", but "*" in the trailing position is a
	   *              "greedy" wildcard, so will match any number of additional
	   *              components:
	   *              "1.2.*" will match "1.2.1", "1.2.1.1", "1.2.1.1.1" etc
	   *    *         Any version
	   *    ""        (Empty string) Same as *
	   *    v1 - v2   Equivalent to ">= v1 and <= v2"
	   *    r1 || r2  Passes if either r1 or r2 are satisfied
	   *
	   * @param {string} range
	   * @param {string} version
	   * @returns {boolean}
	   */
	  contains: function contains(range, version) {
	    return checkOrExpression(range.trim(), version.trim());
	  }
	};
	
	module.exports = VersionRange;

/***/ },
/* 485 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	
	'use strict';
	
	var hasOwnProperty = Object.prototype.hasOwnProperty;
	
	/**
	 * Executes the provided `callback` once for each enumerable own property in the
	 * object and constructs a new object from the results. The `callback` is
	 * invoked with three arguments:
	 *
	 *  - the property value
	 *  - the property name
	 *  - the object being traversed
	 *
	 * Properties that are added after the call to `mapObject` will not be visited
	 * by `callback`. If the values of existing properties are changed, the value
	 * passed to `callback` will be the value at the time `mapObject` visits them.
	 * Properties that are deleted before being visited are not visited.
	 *
	 * @grep function objectMap()
	 * @grep function objMap()
	 *
	 * @param {?object} object
	 * @param {function} callback
	 * @param {*} context
	 * @return {?object}
	 */
	function mapObject(object, callback, context) {
	  if (!object) {
	    return null;
	  }
	  var result = {};
	  for (var name in object) {
	    if (hasOwnProperty.call(object, name)) {
	      result[name] = callback.call(context, object[name], name, object);
	    }
	  }
	  return result;
	}
	
	module.exports = mapObject;

/***/ },
/* 486 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * 
	 * @typechecks static-only
	 */
	
	'use strict';
	
	/**
	 * Memoizes the return value of a function that accepts one string argument.
	 */
	
	function memoizeStringOnly(callback) {
	  var cache = {};
	  return function (string) {
	    if (!cache.hasOwnProperty(string)) {
	      cache[string] = callback.call(this, string);
	    }
	    return cache[string];
	  };
	}
	
	module.exports = memoizeStringOnly;

/***/ },
/* 487 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var camelize = __webpack_require__(529);
	var hyphenate = __webpack_require__(530);
	
	function asString(value) /*?string*/{
	  return value == null ? value : String(value);
	}
	
	function getStyleProperty( /*DOMNode*/node, /*string*/name) /*?string*/{
	  var computedStyle = void 0;
	
	  // W3C Standard
	  if (window.getComputedStyle) {
	    // In certain cases such as within an iframe in FF3, this returns null.
	    computedStyle = window.getComputedStyle(node, null);
	    if (computedStyle) {
	      return asString(computedStyle.getPropertyValue(hyphenate(name)));
	    }
	  }
	  // Safari
	  if (document.defaultView && document.defaultView.getComputedStyle) {
	    computedStyle = document.defaultView.getComputedStyle(node, null);
	    // A Safari bug causes this to return null for `display: none` elements.
	    if (computedStyle) {
	      return asString(computedStyle.getPropertyValue(hyphenate(name)));
	    }
	    if (name === 'display') {
	      return 'none';
	    }
	  }
	  // Internet Explorer
	  if (node.currentStyle) {
	    if (name === 'float') {
	      return asString(node.currentStyle.cssFloat || node.currentStyle.styleFloat);
	    }
	    return asString(node.currentStyle[camelize(name)]);
	  }
	  return asString(node.style && node.style[camelize(name)]);
	}
	
	module.exports = getStyleProperty;

/***/ },
/* 488 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var containsNode = __webpack_require__(481);
	
	/**
	 * Gets an element's bounding rect in pixels relative to the viewport.
	 *
	 * @param {DOMElement} elem
	 * @return {object}
	 */
	function getElementRect(elem) {
	  var docElem = elem.ownerDocument.documentElement;
	
	  // FF 2, Safari 3 and Opera 9.5- do not support getBoundingClientRect().
	  // IE9- will throw if the element is not in the document.
	  if (!('getBoundingClientRect' in elem) || !containsNode(docElem, elem)) {
	    return {
	      left: 0,
	      right: 0,
	      top: 0,
	      bottom: 0
	    };
	  }
	
	  // Subtracts clientTop/Left because IE8- added a 2px border to the
	  // <html> element (see http://fburl.com/1493213). IE 7 in
	  // Quicksmode does not report clientLeft/clientTop so there
	  // will be an unaccounted offset of 2px when in quirksmode
	  var rect = elem.getBoundingClientRect();
	
	  return {
	    left: Math.round(rect.left) - docElem.clientLeft,
	    right: Math.round(rect.right) - docElem.clientLeft,
	    top: Math.round(rect.top) - docElem.clientTop,
	    bottom: Math.round(rect.bottom) - docElem.clientTop
	  };
	}
	
	module.exports = getElementRect;

/***/ },
/* 489 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	'use strict';
	
	var isWebkit = typeof navigator !== 'undefined' && navigator.userAgent.indexOf('AppleWebKit') > -1;
	
	/**
	 * Gets the element with the document scroll properties such as `scrollLeft` and
	 * `scrollHeight`. This may differ across different browsers.
	 *
	 * NOTE: The return value can be null if the DOM is not yet ready.
	 *
	 * @param {?DOMDocument} doc Defaults to current document.
	 * @return {?DOMElement}
	 */
	function getDocumentScrollElement(doc) {
	  doc = doc || document;
	  if (doc.scrollingElement) {
	    return doc.scrollingElement;
	  }
	  return !isWebkit && doc.compatMode === 'CSS1Compat' ? doc.documentElement : doc.body;
	}
	
	module.exports = getDocumentScrollElement;

/***/ },
/* 490 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	'use strict';
	
	/**
	 * Gets the scroll position of the supplied element or window.
	 *
	 * The return values are unbounded, unlike `getScrollPosition`. This means they
	 * may be negative or exceed the element boundaries (which is possible using
	 * inertial scrolling).
	 *
	 * @param {DOMWindow|DOMElement} scrollable
	 * @return {object} Map with `x` and `y` keys.
	 */
	
	function getUnboundedScrollPosition(scrollable) {
	  if (scrollable.Window && scrollable instanceof scrollable.Window) {
	    return {
	      x: scrollable.pageXOffset || scrollable.document.documentElement.scrollLeft,
	      y: scrollable.pageYOffset || scrollable.document.documentElement.scrollTop
	    };
	  }
	  return {
	    x: scrollable.scrollLeft,
	    y: scrollable.scrollTop
	  };
	}
	
	module.exports = getUnboundedScrollPosition;

/***/ },
/* 491 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/* WEBPACK VAR INJECTION */(function(module) {var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	/*!
	 * jQuery JavaScript Library v2.2.4
	 * http://jquery.com/
	 *
	 * Includes Sizzle.js
	 * http://sizzlejs.com/
	 *
	 * Copyright jQuery Foundation and other contributors
	 * Released under the MIT license
	 * http://jquery.org/license
	 *
	 * Date: 2016-05-20T17:23Z
	 */
	
	(function (global, factory) {
	
		if ((false ? "undefined" : _typeof(module)) === "object" && _typeof(module.exports) === "object") {
			// For CommonJS and CommonJS-like environments where a proper `window`
			// is present, execute the factory and get jQuery.
			// For environments that do not have a `window` with a `document`
			// (such as Node.js), expose a factory as module.exports.
			// This accentuates the need for the creation of a real `window`.
			// e.g. var jQuery = require("jquery")(window);
			// See ticket #14549 for more info.
			module.exports = global.document ? factory(global, true) : function (w) {
				if (!w.document) {
					throw new Error("jQuery requires a window with a document");
				}
				return factory(w);
			};
		} else {
			factory(global);
		}
	
		// Pass this if window is not defined yet
	})(typeof window !== "undefined" ? window : this, function (window, noGlobal) {
	
		// Support: Firefox 18+
		// Can't be in strict mode, several libs including ASP.NET trace
		// the stack via arguments.caller.callee and Firefox dies if
		// you try to trace through "use strict" call chains. (#13335)
		//"use strict";
		var arr = [];
	
		var document = window.document;
	
		var _slice = arr.slice;
	
		var concat = arr.concat;
	
		var push = arr.push;
	
		var indexOf = arr.indexOf;
	
		var class2type = {};
	
		var toString = class2type.toString;
	
		var hasOwn = class2type.hasOwnProperty;
	
		var support = {};
	
		var version = "2.2.4",
	
	
		// Define a local copy of jQuery
		jQuery = function jQuery(selector, context) {
	
			// The jQuery object is actually just the init constructor 'enhanced'
			// Need init if jQuery is called (just allow error to be thrown if not included)
			return new jQuery.fn.init(selector, context);
		},
	
	
		// Support: Android<4.1
		// Make sure we trim BOM and NBSP
		rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
	
	
		// Matches dashed string for camelizing
		rmsPrefix = /^-ms-/,
		    rdashAlpha = /-([\da-z])/gi,
	
	
		// Used by jQuery.camelCase as callback to replace()
		fcamelCase = function fcamelCase(all, letter) {
			return letter.toUpperCase();
		};
	
		jQuery.fn = jQuery.prototype = {
	
			// The current version of jQuery being used
			jquery: version,
	
			constructor: jQuery,
	
			// Start with an empty selector
			selector: "",
	
			// The default length of a jQuery object is 0
			length: 0,
	
			toArray: function toArray() {
				return _slice.call(this);
			},
	
			// Get the Nth element in the matched element set OR
			// Get the whole matched element set as a clean array
			get: function get(num) {
				return num != null ?
	
				// Return just the one element from the set
				num < 0 ? this[num + this.length] : this[num] :
	
				// Return all the elements in a clean array
				_slice.call(this);
			},
	
			// Take an array of elements and push it onto the stack
			// (returning the new matched element set)
			pushStack: function pushStack(elems) {
	
				// Build a new jQuery matched element set
				var ret = jQuery.merge(this.constructor(), elems);
	
				// Add the old object onto the stack (as a reference)
				ret.prevObject = this;
				ret.context = this.context;
	
				// Return the newly-formed element set
				return ret;
			},
	
			// Execute a callback for every element in the matched set.
			each: function each(callback) {
				return jQuery.each(this, callback);
			},
	
			map: function map(callback) {
				return this.pushStack(jQuery.map(this, function (elem, i) {
					return callback.call(elem, i, elem);
				}));
			},
	
			slice: function slice() {
				return this.pushStack(_slice.apply(this, arguments));
			},
	
			first: function first() {
				return this.eq(0);
			},
	
			last: function last() {
				return this.eq(-1);
			},
	
			eq: function eq(i) {
				var len = this.length,
				    j = +i + (i < 0 ? len : 0);
				return this.pushStack(j >= 0 && j < len ? [this[j]] : []);
			},
	
			end: function end() {
				return this.prevObject || this.constructor();
			},
	
			// For internal use only.
			// Behaves like an Array's method, not like a jQuery method.
			push: push,
			sort: arr.sort,
			splice: arr.splice
		};
	
		jQuery.extend = jQuery.fn.extend = function () {
			var options,
			    name,
			    src,
			    copy,
			    copyIsArray,
			    clone,
			    target = arguments[0] || {},
			    i = 1,
			    length = arguments.length,
			    deep = false;
	
			// Handle a deep copy situation
			if (typeof target === "boolean") {
				deep = target;
	
				// Skip the boolean and the target
				target = arguments[i] || {};
				i++;
			}
	
			// Handle case when target is a string or something (possible in deep copy)
			if ((typeof target === "undefined" ? "undefined" : _typeof(target)) !== "object" && !jQuery.isFunction(target)) {
				target = {};
			}
	
			// Extend jQuery itself if only one argument is passed
			if (i === length) {
				target = this;
				i--;
			}
	
			for (; i < length; i++) {
	
				// Only deal with non-null/undefined values
				if ((options = arguments[i]) != null) {
	
					// Extend the base object
					for (name in options) {
						src = target[name];
						copy = options[name];
	
						// Prevent never-ending loop
						if (target === copy) {
							continue;
						}
	
						// Recurse if we're merging plain objects or arrays
						if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) {
	
							if (copyIsArray) {
								copyIsArray = false;
								clone = src && jQuery.isArray(src) ? src : [];
							} else {
								clone = src && jQuery.isPlainObject(src) ? src : {};
							}
	
							// Never move original objects, clone them
							target[name] = jQuery.extend(deep, clone, copy);
	
							// Don't bring in undefined values
						} else if (copy !== undefined) {
							target[name] = copy;
						}
					}
				}
			}
	
			// Return the modified object
			return target;
		};
	
		jQuery.extend({
	
			// Unique for each copy of jQuery on the page
			expando: "jQuery" + (version + Math.random()).replace(/\D/g, ""),
	
			// Assume jQuery is ready without the ready module
			isReady: true,
	
			error: function error(msg) {
				throw new Error(msg);
			},
	
			noop: function noop() {},
	
			isFunction: function isFunction(obj) {
				return jQuery.type(obj) === "function";
			},
	
			isArray: Array.isArray,
	
			isWindow: function isWindow(obj) {
				return obj != null && obj === obj.window;
			},
	
			isNumeric: function isNumeric(obj) {
	
				// parseFloat NaNs numeric-cast false positives (null|true|false|"")
				// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
				// subtraction forces infinities to NaN
				// adding 1 corrects loss of precision from parseFloat (#15100)
				var realStringObj = obj && obj.toString();
				return !jQuery.isArray(obj) && realStringObj - parseFloat(realStringObj) + 1 >= 0;
			},
	
			isPlainObject: function isPlainObject(obj) {
				var key;
	
				// Not plain objects:
				// - Any object or value whose internal [[Class]] property is not "[object Object]"
				// - DOM nodes
				// - window
				if (jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow(obj)) {
					return false;
				}
	
				// Not own constructor property must be Object
				if (obj.constructor && !hasOwn.call(obj, "constructor") && !hasOwn.call(obj.constructor.prototype || {}, "isPrototypeOf")) {
					return false;
				}
	
				// Own properties are enumerated firstly, so to speed up,
				// if last one is own, then all properties are own
				for (key in obj) {}
	
				return key === undefined || hasOwn.call(obj, key);
			},
	
			isEmptyObject: function isEmptyObject(obj) {
				var name;
				for (name in obj) {
					return false;
				}
				return true;
			},
	
			type: function type(obj) {
				if (obj == null) {
					return obj + "";
				}
	
				// Support: Android<4.0, iOS<6 (functionish RegExp)
				return (typeof obj === "undefined" ? "undefined" : _typeof(obj)) === "object" || typeof obj === "function" ? class2type[toString.call(obj)] || "object" : typeof obj === "undefined" ? "undefined" : _typeof(obj);
			},
	
			// Evaluates a script in a global context
			globalEval: function globalEval(code) {
				var script,
				    indirect = eval;
	
				code = jQuery.trim(code);
	
				if (code) {
	
					// If the code includes a valid, prologue position
					// strict mode pragma, execute code by injecting a
					// script tag into the document.
					if (code.indexOf("use strict") === 1) {
						script = document.createElement("script");
						script.text = code;
						document.head.appendChild(script).parentNode.removeChild(script);
					} else {
	
						// Otherwise, avoid the DOM node creation, insertion
						// and removal by using an indirect global eval
	
						indirect(code);
					}
				}
			},
	
			// Convert dashed to camelCase; used by the css and data modules
			// Support: IE9-11+
			// Microsoft forgot to hump their vendor prefix (#9572)
			camelCase: function camelCase(string) {
				return string.replace(rmsPrefix, "ms-").replace(rdashAlpha, fcamelCase);
			},
	
			nodeName: function nodeName(elem, name) {
				return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
			},
	
			each: function each(obj, callback) {
				var length,
				    i = 0;
	
				if (isArrayLike(obj)) {
					length = obj.length;
					for (; i < length; i++) {
						if (callback.call(obj[i], i, obj[i]) === false) {
							break;
						}
					}
				} else {
					for (i in obj) {
						if (callback.call(obj[i], i, obj[i]) === false) {
							break;
						}
					}
				}
	
				return obj;
			},
	
			// Support: Android<4.1
			trim: function trim(text) {
				return text == null ? "" : (text + "").replace(rtrim, "");
			},
	
			// results is for internal usage only
			makeArray: function makeArray(arr, results) {
				var ret = results || [];
	
				if (arr != null) {
					if (isArrayLike(Object(arr))) {
						jQuery.merge(ret, typeof arr === "string" ? [arr] : arr);
					} else {
						push.call(ret, arr);
					}
				}
	
				return ret;
			},
	
			inArray: function inArray(elem, arr, i) {
				return arr == null ? -1 : indexOf.call(arr, elem, i);
			},
	
			merge: function merge(first, second) {
				var len = +second.length,
				    j = 0,
				    i = first.length;
	
				for (; j < len; j++) {
					first[i++] = second[j];
				}
	
				first.length = i;
	
				return first;
			},
	
			grep: function grep(elems, callback, invert) {
				var callbackInverse,
				    matches = [],
				    i = 0,
				    length = elems.length,
				    callbackExpect = !invert;
	
				// Go through the array, only saving the items
				// that pass the validator function
				for (; i < length; i++) {
					callbackInverse = !callback(elems[i], i);
					if (callbackInverse !== callbackExpect) {
						matches.push(elems[i]);
					}
				}
	
				return matches;
			},
	
			// arg is for internal usage only
			map: function map(elems, callback, arg) {
				var length,
				    value,
				    i = 0,
				    ret = [];
	
				// Go through the array, translating each of the items to their new values
				if (isArrayLike(elems)) {
					length = elems.length;
					for (; i < length; i++) {
						value = callback(elems[i], i, arg);
	
						if (value != null) {
							ret.push(value);
						}
					}
	
					// Go through every key on the object,
				} else {
					for (i in elems) {
						value = callback(elems[i], i, arg);
	
						if (value != null) {
							ret.push(value);
						}
					}
				}
	
				// Flatten any nested arrays
				return concat.apply([], ret);
			},
	
			// A global GUID counter for objects
			guid: 1,
	
			// Bind a function to a context, optionally partially applying any
			// arguments.
			proxy: function proxy(fn, context) {
				var tmp, args, proxy;
	
				if (typeof context === "string") {
					tmp = fn[context];
					context = fn;
					fn = tmp;
				}
	
				// Quick check to determine if target is callable, in the spec
				// this throws a TypeError, but we will just return undefined.
				if (!jQuery.isFunction(fn)) {
					return undefined;
				}
	
				// Simulated bind
				args = _slice.call(arguments, 2);
				proxy = function proxy() {
					return fn.apply(context || this, args.concat(_slice.call(arguments)));
				};
	
				// Set the guid of unique handler to the same of original handler, so it can be removed
				proxy.guid = fn.guid = fn.guid || jQuery.guid++;
	
				return proxy;
			},
	
			now: Date.now,
	
			// jQuery.support is not used in Core but other projects attach their
			// properties to it so it needs to exist.
			support: support
		});
	
		// JSHint would error on this code due to the Symbol not being defined in ES5.
		// Defining this global in .jshintrc would create a danger of using the global
		// unguarded in another place, it seems safer to just disable JSHint for these
		// three lines.
		/* jshint ignore: start */
		if (typeof Symbol === "function") {
			jQuery.fn[Symbol.iterator] = arr[Symbol.iterator];
		}
		/* jshint ignore: end */
	
		// Populate the class2type map
		jQuery.each("Boolean Number String Function Array Date RegExp Object Error Symbol".split(" "), function (i, name) {
			class2type["[object " + name + "]"] = name.toLowerCase();
		});
	
		function isArrayLike(obj) {
	
			// Support: iOS 8.2 (not reproducible in simulator)
			// `in` check used to prevent JIT error (gh-2145)
			// hasOwn isn't used here due to false negatives
			// regarding Nodelist length in IE
			var length = !!obj && "length" in obj && obj.length,
			    type = jQuery.type(obj);
	
			if (type === "function" || jQuery.isWindow(obj)) {
				return false;
			}
	
			return type === "array" || length === 0 || typeof length === "number" && length > 0 && length - 1 in obj;
		}
		var Sizzle =
		/*!
	  * Sizzle CSS Selector Engine v2.2.1
	  * http://sizzlejs.com/
	  *
	  * Copyright jQuery Foundation and other contributors
	  * Released under the MIT license
	  * http://jquery.org/license
	  *
	  * Date: 2015-10-17
	  */
		function (window) {
	
			var i,
			    support,
			    Expr,
			    getText,
			    isXML,
			    tokenize,
			    compile,
			    select,
			    outermostContext,
			    sortInput,
			    hasDuplicate,
	
	
			// Local document vars
			setDocument,
			    document,
			    docElem,
			    documentIsHTML,
			    rbuggyQSA,
			    rbuggyMatches,
			    matches,
			    contains,
	
	
			// Instance-specific data
			expando = "sizzle" + 1 * new Date(),
			    preferredDoc = window.document,
			    dirruns = 0,
			    done = 0,
			    classCache = createCache(),
			    tokenCache = createCache(),
			    compilerCache = createCache(),
			    sortOrder = function sortOrder(a, b) {
				if (a === b) {
					hasDuplicate = true;
				}
				return 0;
			},
	
	
			// General-purpose constants
			MAX_NEGATIVE = 1 << 31,
	
	
			// Instance methods
			hasOwn = {}.hasOwnProperty,
			    arr = [],
			    pop = arr.pop,
			    push_native = arr.push,
			    push = arr.push,
			    slice = arr.slice,
	
			// Use a stripped-down indexOf as it's faster than native
			// http://jsperf.com/thor-indexof-vs-for/5
			indexOf = function indexOf(list, elem) {
				var i = 0,
				    len = list.length;
				for (; i < len; i++) {
					if (list[i] === elem) {
						return i;
					}
				}
				return -1;
			},
			    booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
	
	
			// Regular expressions
	
			// http://www.w3.org/TR/css3-selectors/#whitespace
			whitespace = "[\\x20\\t\\r\\n\\f]",
	
	
			// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
			identifier = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
	
	
			// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
			attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
			// Operator (capture 2)
			"*([*^$|!~]?=)" + whitespace +
			// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
			"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + "*\\]",
			    pseudos = ":(" + identifier + ")(?:\\((" +
			// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
			// 1. quoted (capture 3; capture 4 or capture 5)
			"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
			// 2. simple (capture 6)
			"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
			// 3. anything else (capture 2)
			".*" + ")\\)|)",
	
	
			// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
			rwhitespace = new RegExp(whitespace + "+", "g"),
			    rtrim = new RegExp("^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g"),
			    rcomma = new RegExp("^" + whitespace + "*," + whitespace + "*"),
			    rcombinators = new RegExp("^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*"),
			    rattributeQuotes = new RegExp("=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g"),
			    rpseudo = new RegExp(pseudos),
			    ridentifier = new RegExp("^" + identifier + "$"),
			    matchExpr = {
				"ID": new RegExp("^#(" + identifier + ")"),
				"CLASS": new RegExp("^\\.(" + identifier + ")"),
				"TAG": new RegExp("^(" + identifier + "|[*])"),
				"ATTR": new RegExp("^" + attributes),
				"PSEUDO": new RegExp("^" + pseudos),
				"CHILD": new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i"),
				"bool": new RegExp("^(?:" + booleans + ")$", "i"),
				// For use in libraries implementing .is()
				// We use this for POS matching in `select`
				"needsContext": new RegExp("^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i")
			},
			    rinputs = /^(?:input|select|textarea|button)$/i,
			    rheader = /^h\d$/i,
			    rnative = /^[^{]+\{\s*\[native \w/,
	
	
			// Easily-parseable/retrievable ID or TAG or CLASS selectors
			rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
			    rsibling = /[+~]/,
			    rescape = /'|\\/g,
	
	
			// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
			runescape = new RegExp("\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig"),
			    funescape = function funescape(_, escaped, escapedWhitespace) {
				var high = "0x" + escaped - 0x10000;
				// NaN means non-codepoint
				// Support: Firefox<24
				// Workaround erroneous numeric interpretation of +"0x"
				return high !== high || escapedWhitespace ? escaped : high < 0 ?
				// BMP codepoint
				String.fromCharCode(high + 0x10000) :
				// Supplemental Plane codepoint (surrogate pair)
				String.fromCharCode(high >> 10 | 0xD800, high & 0x3FF | 0xDC00);
			},
	
	
			// Used for iframes
			// See setDocument()
			// Removing the function wrapper causes a "Permission Denied"
			// error in IE
			unloadHandler = function unloadHandler() {
				setDocument();
			};
	
			// Optimize for push.apply( _, NodeList )
			try {
				push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes);
				// Support: Android<4.0
				// Detect silently failing push.apply
				arr[preferredDoc.childNodes.length].nodeType;
			} catch (e) {
				push = { apply: arr.length ?
	
					// Leverage slice if possible
					function (target, els) {
						push_native.apply(target, slice.call(els));
					} :
	
					// Support: IE<9
					// Otherwise append directly
					function (target, els) {
						var j = target.length,
						    i = 0;
						// Can't trust NodeList.length
						while (target[j++] = els[i++]) {}
						target.length = j - 1;
					}
				};
			}
	
			function Sizzle(selector, context, results, seed) {
				var m,
				    i,
				    elem,
				    nid,
				    nidselect,
				    match,
				    groups,
				    newSelector,
				    newContext = context && context.ownerDocument,
	
	
				// nodeType defaults to 9, since context defaults to document
				nodeType = context ? context.nodeType : 9;
	
				results = results || [];
	
				// Return early from calls with invalid selector or context
				if (typeof selector !== "string" || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {
	
					return results;
				}
	
				// Try to shortcut find operations (as opposed to filters) in HTML documents
				if (!seed) {
	
					if ((context ? context.ownerDocument || context : preferredDoc) !== document) {
						setDocument(context);
					}
					context = context || document;
	
					if (documentIsHTML) {
	
						// If the selector is sufficiently simple, try using a "get*By*" DOM method
						// (excepting DocumentFragment context, where the methods don't exist)
						if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {
	
							// ID selector
							if (m = match[1]) {
	
								// Document context
								if (nodeType === 9) {
									if (elem = context.getElementById(m)) {
	
										// Support: IE, Opera, Webkit
										// TODO: identify versions
										// getElementById can match elements by name instead of ID
										if (elem.id === m) {
											results.push(elem);
											return results;
										}
									} else {
										return results;
									}
	
									// Element context
								} else {
	
									// Support: IE, Opera, Webkit
									// TODO: identify versions
									// getElementById can match elements by name instead of ID
									if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) {
	
										results.push(elem);
										return results;
									}
								}
	
								// Type selector
							} else if (match[2]) {
								push.apply(results, context.getElementsByTagName(selector));
								return results;
	
								// Class selector
							} else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {
	
								push.apply(results, context.getElementsByClassName(m));
								return results;
							}
						}
	
						// Take advantage of querySelectorAll
						if (support.qsa && !compilerCache[selector + " "] && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
	
							if (nodeType !== 1) {
								newContext = context;
								newSelector = selector;
	
								// qSA looks outside Element context, which is not what we want
								// Thanks to Andrew Dupont for this workaround technique
								// Support: IE <=8
								// Exclude object elements
							} else if (context.nodeName.toLowerCase() !== "object") {
	
								// Capture the context ID, setting it first if necessary
								if (nid = context.getAttribute("id")) {
									nid = nid.replace(rescape, "\\$&");
								} else {
									context.setAttribute("id", nid = expando);
								}
	
								// Prefix every selector in the list
								groups = tokenize(selector);
								i = groups.length;
								nidselect = ridentifier.test(nid) ? "#" + nid : "[id='" + nid + "']";
								while (i--) {
									groups[i] = nidselect + " " + toSelector(groups[i]);
								}
								newSelector = groups.join(",");
	
								// Expand context for sibling selectors
								newContext = rsibling.test(selector) && testContext(context.parentNode) || context;
							}
	
							if (newSelector) {
								try {
									push.apply(results, newContext.querySelectorAll(newSelector));
									return results;
								} catch (qsaError) {} finally {
									if (nid === expando) {
										context.removeAttribute("id");
									}
								}
							}
						}
					}
				}
	
				// All others
				return select(selector.replace(rtrim, "$1"), context, results, seed);
			}
	
			/**
	   * Create key-value caches of limited size
	   * @returns {function(string, object)} Returns the Object data after storing it on itself with
	   *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
	   *	deleting the oldest entry
	   */
			function createCache() {
				var keys = [];
	
				function cache(key, value) {
					// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
					if (keys.push(key + " ") > Expr.cacheLength) {
						// Only keep the most recent entries
						delete cache[keys.shift()];
					}
					return cache[key + " "] = value;
				}
				return cache;
			}
	
			/**
	   * Mark a function for special use by Sizzle
	   * @param {Function} fn The function to mark
	   */
			function markFunction(fn) {
				fn[expando] = true;
				return fn;
			}
	
			/**
	   * Support testing using an element
	   * @param {Function} fn Passed the created div and expects a boolean result
	   */
			function assert(fn) {
				var div = document.createElement("div");
	
				try {
					return !!fn(div);
				} catch (e) {
					return false;
				} finally {
					// Remove from its parent by default
					if (div.parentNode) {
						div.parentNode.removeChild(div);
					}
					// release memory in IE
					div = null;
				}
			}
	
			/**
	   * Adds the same handler for all of the specified attrs
	   * @param {String} attrs Pipe-separated list of attributes
	   * @param {Function} handler The method that will be applied
	   */
			function addHandle(attrs, handler) {
				var arr = attrs.split("|"),
				    i = arr.length;
	
				while (i--) {
					Expr.attrHandle[arr[i]] = handler;
				}
			}
	
			/**
	   * Checks document order of two siblings
	   * @param {Element} a
	   * @param {Element} b
	   * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
	   */
			function siblingCheck(a, b) {
				var cur = b && a,
				    diff = cur && a.nodeType === 1 && b.nodeType === 1 && (~b.sourceIndex || MAX_NEGATIVE) - (~a.sourceIndex || MAX_NEGATIVE);
	
				// Use IE sourceIndex if available on both nodes
				if (diff) {
					return diff;
				}
	
				// Check if b follows a
				if (cur) {
					while (cur = cur.nextSibling) {
						if (cur === b) {
							return -1;
						}
					}
				}
	
				return a ? 1 : -1;
			}
	
			/**
	   * Returns a function to use in pseudos for input types
	   * @param {String} type
	   */
			function createInputPseudo(type) {
				return function (elem) {
					var name = elem.nodeName.toLowerCase();
					return name === "input" && elem.type === type;
				};
			}
	
			/**
	   * Returns a function to use in pseudos for buttons
	   * @param {String} type
	   */
			function createButtonPseudo(type) {
				return function (elem) {
					var name = elem.nodeName.toLowerCase();
					return (name === "input" || name === "button") && elem.type === type;
				};
			}
	
			/**
	   * Returns a function to use in pseudos for positionals
	   * @param {Function} fn
	   */
			function createPositionalPseudo(fn) {
				return markFunction(function (argument) {
					argument = +argument;
					return markFunction(function (seed, matches) {
						var j,
						    matchIndexes = fn([], seed.length, argument),
						    i = matchIndexes.length;
	
						// Match elements found at the specified indexes
						while (i--) {
							if (seed[j = matchIndexes[i]]) {
								seed[j] = !(matches[j] = seed[j]);
							}
						}
					});
				});
			}
	
			/**
	   * Checks a node for validity as a Sizzle context
	   * @param {Element|Object=} context
	   * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
	   */
			function testContext(context) {
				return context && typeof context.getElementsByTagName !== "undefined" && context;
			}
	
			// Expose support vars for convenience
			support = Sizzle.support = {};
	
			/**
	   * Detects XML nodes
	   * @param {Element|Object} elem An element or a document
	   * @returns {Boolean} True iff elem is a non-HTML XML node
	   */
			isXML = Sizzle.isXML = function (elem) {
				// documentElement is verified for cases where it doesn't yet exist
				// (such as loading iframes in IE - #4833)
				var documentElement = elem && (elem.ownerDocument || elem).documentElement;
				return documentElement ? documentElement.nodeName !== "HTML" : false;
			};
	
			/**
	   * Sets document-related variables once based on the current document
	   * @param {Element|Object} [doc] An element or document object to use to set the document
	   * @returns {Object} Returns the current document
	   */
			setDocument = Sizzle.setDocument = function (node) {
				var hasCompare,
				    parent,
				    doc = node ? node.ownerDocument || node : preferredDoc;
	
				// Return early if doc is invalid or already selected
				if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
					return document;
				}
	
				// Update global variables
				document = doc;
				docElem = document.documentElement;
				documentIsHTML = !isXML(document);
	
				// Support: IE 9-11, Edge
				// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
				if ((parent = document.defaultView) && parent.top !== parent) {
					// Support: IE 11
					if (parent.addEventListener) {
						parent.addEventListener("unload", unloadHandler, false);
	
						// Support: IE 9 - 10 only
					} else if (parent.attachEvent) {
						parent.attachEvent("onunload", unloadHandler);
					}
				}
	
				/* Attributes
	   ---------------------------------------------------------------------- */
	
				// Support: IE<8
				// Verify that getAttribute really returns attributes and not properties
				// (excepting IE8 booleans)
				support.attributes = assert(function (div) {
					div.className = "i";
					return !div.getAttribute("className");
				});
	
				/* getElement(s)By*
	   ---------------------------------------------------------------------- */
	
				// Check if getElementsByTagName("*") returns only elements
				support.getElementsByTagName = assert(function (div) {
					div.appendChild(document.createComment(""));
					return !div.getElementsByTagName("*").length;
				});
	
				// Support: IE<9
				support.getElementsByClassName = rnative.test(document.getElementsByClassName);
	
				// Support: IE<10
				// Check if getElementById returns elements by name
				// The broken getElementById methods don't pick up programatically-set names,
				// so use a roundabout getElementsByName test
				support.getById = assert(function (div) {
					docElem.appendChild(div).id = expando;
					return !document.getElementsByName || !document.getElementsByName(expando).length;
				});
	
				// ID find and filter
				if (support.getById) {
					Expr.find["ID"] = function (id, context) {
						if (typeof context.getElementById !== "undefined" && documentIsHTML) {
							var m = context.getElementById(id);
							return m ? [m] : [];
						}
					};
					Expr.filter["ID"] = function (id) {
						var attrId = id.replace(runescape, funescape);
						return function (elem) {
							return elem.getAttribute("id") === attrId;
						};
					};
				} else {
					// Support: IE6/7
					// getElementById is not reliable as a find shortcut
					delete Expr.find["ID"];
	
					Expr.filter["ID"] = function (id) {
						var attrId = id.replace(runescape, funescape);
						return function (elem) {
							var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
							return node && node.value === attrId;
						};
					};
				}
	
				// Tag
				Expr.find["TAG"] = support.getElementsByTagName ? function (tag, context) {
					if (typeof context.getElementsByTagName !== "undefined") {
						return context.getElementsByTagName(tag);
	
						// DocumentFragment nodes don't have gEBTN
					} else if (support.qsa) {
						return context.querySelectorAll(tag);
					}
				} : function (tag, context) {
					var elem,
					    tmp = [],
					    i = 0,
	
					// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
					results = context.getElementsByTagName(tag);
	
					// Filter out possible comments
					if (tag === "*") {
						while (elem = results[i++]) {
							if (elem.nodeType === 1) {
								tmp.push(elem);
							}
						}
	
						return tmp;
					}
					return results;
				};
	
				// Class
				Expr.find["CLASS"] = support.getElementsByClassName && function (className, context) {
					if (typeof context.getElementsByClassName !== "undefined" && documentIsHTML) {
						return context.getElementsByClassName(className);
					}
				};
	
				/* QSA/matchesSelector
	   ---------------------------------------------------------------------- */
	
				// QSA and matchesSelector support
	
				// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
				rbuggyMatches = [];
	
				// qSa(:focus) reports false when true (Chrome 21)
				// We allow this because of a bug in IE8/9 that throws an error
				// whenever `document.activeElement` is accessed on an iframe
				// So, we allow :focus to pass through QSA all the time to avoid the IE error
				// See http://bugs.jquery.com/ticket/13378
				rbuggyQSA = [];
	
				if (support.qsa = rnative.test(document.querySelectorAll)) {
					// Build QSA regex
					// Regex strategy adopted from Diego Perini
					assert(function (div) {
						// Select is set to empty string on purpose
						// This is to test IE's treatment of not explicitly
						// setting a boolean content attribute,
						// since its presence should be enough
						// http://bugs.jquery.com/ticket/12359
						docElem.appendChild(div).innerHTML = "<a id='" + expando + "'></a>" + "<select id='" + expando + "-\r\\' msallowcapture=''>" + "<option selected=''></option></select>";
	
						// Support: IE8, Opera 11-12.16
						// Nothing should be selected when empty strings follow ^= or $= or *=
						// The test attribute must be unknown in Opera but "safe" for WinRT
						// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
						if (div.querySelectorAll("[msallowcapture^='']").length) {
							rbuggyQSA.push("[*^$]=" + whitespace + "*(?:''|\"\")");
						}
	
						// Support: IE8
						// Boolean attributes and "value" are not treated correctly
						if (!div.querySelectorAll("[selected]").length) {
							rbuggyQSA.push("\\[" + whitespace + "*(?:value|" + booleans + ")");
						}
	
						// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
						if (!div.querySelectorAll("[id~=" + expando + "-]").length) {
							rbuggyQSA.push("~=");
						}
	
						// Webkit/Opera - :checked should return selected option elements
						// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
						// IE8 throws error here and will not see later tests
						if (!div.querySelectorAll(":checked").length) {
							rbuggyQSA.push(":checked");
						}
	
						// Support: Safari 8+, iOS 8+
						// https://bugs.webkit.org/show_bug.cgi?id=136851
						// In-page `selector#id sibing-combinator selector` fails
						if (!div.querySelectorAll("a#" + expando + "+*").length) {
							rbuggyQSA.push(".#.+[+~]");
						}
					});
	
					assert(function (div) {
						// Support: Windows 8 Native Apps
						// The type and name attributes are restricted during .innerHTML assignment
						var input = document.createElement("input");
						input.setAttribute("type", "hidden");
						div.appendChild(input).setAttribute("name", "D");
	
						// Support: IE8
						// Enforce case-sensitivity of name attribute
						if (div.querySelectorAll("[name=d]").length) {
							rbuggyQSA.push("name" + whitespace + "*[*^$|!~]?=");
						}
	
						// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
						// IE8 throws error here and will not see later tests
						if (!div.querySelectorAll(":enabled").length) {
							rbuggyQSA.push(":enabled", ":disabled");
						}
	
						// Opera 10-11 does not throw on post-comma invalid pseudos
						div.querySelectorAll("*,:x");
						rbuggyQSA.push(",.*:");
					});
				}
	
				if (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) {
	
					assert(function (div) {
						// Check to see if it's possible to do matchesSelector
						// on a disconnected node (IE 9)
						support.disconnectedMatch = matches.call(div, "div");
	
						// This should fail with an exception
						// Gecko does not error, returns false instead
						matches.call(div, "[s!='']:x");
						rbuggyMatches.push("!=", pseudos);
					});
				}
	
				rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join("|"));
				rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join("|"));
	
				/* Contains
	   ---------------------------------------------------------------------- */
				hasCompare = rnative.test(docElem.compareDocumentPosition);
	
				// Element contains another
				// Purposefully self-exclusive
				// As in, an element does not contain itself
				contains = hasCompare || rnative.test(docElem.contains) ? function (a, b) {
					var adown = a.nodeType === 9 ? a.documentElement : a,
					    bup = b && b.parentNode;
					return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16));
				} : function (a, b) {
					if (b) {
						while (b = b.parentNode) {
							if (b === a) {
								return true;
							}
						}
					}
					return false;
				};
	
				/* Sorting
	   ---------------------------------------------------------------------- */
	
				// Document order sorting
				sortOrder = hasCompare ? function (a, b) {
	
					// Flag for duplicate removal
					if (a === b) {
						hasDuplicate = true;
						return 0;
					}
	
					// Sort on method existence if only one input has compareDocumentPosition
					var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
					if (compare) {
						return compare;
					}
	
					// Calculate position if both inputs belong to the same document
					compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) :
	
					// Otherwise we know they are disconnected
					1;
	
					// Disconnected nodes
					if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {
	
						// Choose the first element that is related to our preferred document
						if (a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) {
							return -1;
						}
						if (b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) {
							return 1;
						}
	
						// Maintain original order
						return sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
					}
	
					return compare & 4 ? -1 : 1;
				} : function (a, b) {
					// Exit early if the nodes are identical
					if (a === b) {
						hasDuplicate = true;
						return 0;
					}
	
					var cur,
					    i = 0,
					    aup = a.parentNode,
					    bup = b.parentNode,
					    ap = [a],
					    bp = [b];
	
					// Parentless nodes are either documents or disconnected
					if (!aup || !bup) {
						return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0;
	
						// If the nodes are siblings, we can do a quick check
					} else if (aup === bup) {
						return siblingCheck(a, b);
					}
	
					// Otherwise we need full lists of their ancestors for comparison
					cur = a;
					while (cur = cur.parentNode) {
						ap.unshift(cur);
					}
					cur = b;
					while (cur = cur.parentNode) {
						bp.unshift(cur);
					}
	
					// Walk down the tree looking for a discrepancy
					while (ap[i] === bp[i]) {
						i++;
					}
	
					return i ?
					// Do a sibling check if the nodes have a common ancestor
					siblingCheck(ap[i], bp[i]) :
	
					// Otherwise nodes in our document sort first
					ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0;
				};
	
				return document;
			};
	
			Sizzle.matches = function (expr, elements) {
				return Sizzle(expr, null, null, elements);
			};
	
			Sizzle.matchesSelector = function (elem, expr) {
				// Set document vars if needed
				if ((elem.ownerDocument || elem) !== document) {
					setDocument(elem);
				}
	
				// Make sure that attribute selectors are quoted
				expr = expr.replace(rattributeQuotes, "='$1']");
	
				if (support.matchesSelector && documentIsHTML && !compilerCache[expr + " "] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {
	
					try {
						var ret = matches.call(elem, expr);
	
						// IE 9's matchesSelector returns false on disconnected nodes
						if (ret || support.disconnectedMatch ||
						// As well, disconnected nodes are said to be in a document
						// fragment in IE 9
						elem.document && elem.document.nodeType !== 11) {
							return ret;
						}
					} catch (e) {}
				}
	
				return Sizzle(expr, document, null, [elem]).length > 0;
			};
	
			Sizzle.contains = function (context, elem) {
				// Set document vars if needed
				if ((context.ownerDocument || context) !== document) {
					setDocument(context);
				}
				return contains(context, elem);
			};
	
			Sizzle.attr = function (elem, name) {
				// Set document vars if needed
				if ((elem.ownerDocument || elem) !== document) {
					setDocument(elem);
				}
	
				var fn = Expr.attrHandle[name.toLowerCase()],
	
				// Don't get fooled by Object.prototype properties (jQuery #13807)
				val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined;
	
				return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
			};
	
			Sizzle.error = function (msg) {
				throw new Error("Syntax error, unrecognized expression: " + msg);
			};
	
			/**
	   * Document sorting and removing duplicates
	   * @param {ArrayLike} results
	   */
			Sizzle.uniqueSort = function (results) {
				var elem,
				    duplicates = [],
				    j = 0,
				    i = 0;
	
				// Unless we *know* we can detect duplicates, assume their presence
				hasDuplicate = !support.detectDuplicates;
				sortInput = !support.sortStable && results.slice(0);
				results.sort(sortOrder);
	
				if (hasDuplicate) {
					while (elem = results[i++]) {
						if (elem === results[i]) {
							j = duplicates.push(i);
						}
					}
					while (j--) {
						results.splice(duplicates[j], 1);
					}
				}
	
				// Clear input after sorting to release objects
				// See https://github.com/jquery/sizzle/pull/225
				sortInput = null;
	
				return results;
			};
	
			/**
	   * Utility function for retrieving the text value of an array of DOM nodes
	   * @param {Array|Element} elem
	   */
			getText = Sizzle.getText = function (elem) {
				var node,
				    ret = "",
				    i = 0,
				    nodeType = elem.nodeType;
	
				if (!nodeType) {
					// If no nodeType, this is expected to be an array
					while (node = elem[i++]) {
						// Do not traverse comment nodes
						ret += getText(node);
					}
				} else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
					// Use textContent for elements
					// innerText usage removed for consistency of new lines (jQuery #11153)
					if (typeof elem.textContent === "string") {
						return elem.textContent;
					} else {
						// Traverse its children
						for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
							ret += getText(elem);
						}
					}
				} else if (nodeType === 3 || nodeType === 4) {
					return elem.nodeValue;
				}
				// Do not include comment or processing instruction nodes
	
				return ret;
			};
	
			Expr = Sizzle.selectors = {
	
				// Can be adjusted by the user
				cacheLength: 50,
	
				createPseudo: markFunction,
	
				match: matchExpr,
	
				attrHandle: {},
	
				find: {},
	
				relative: {
					">": { dir: "parentNode", first: true },
					" ": { dir: "parentNode" },
					"+": { dir: "previousSibling", first: true },
					"~": { dir: "previousSibling" }
				},
	
				preFilter: {
					"ATTR": function ATTR(match) {
						match[1] = match[1].replace(runescape, funescape);
	
						// Move the given value to match[3] whether quoted or unquoted
						match[3] = (match[3] || match[4] || match[5] || "").replace(runescape, funescape);
	
						if (match[2] === "~=") {
							match[3] = " " + match[3] + " ";
						}
	
						return match.slice(0, 4);
					},
	
					"CHILD": function CHILD(match) {
						/* matches from matchExpr["CHILD"]
	     	1 type (only|nth|...)
	     	2 what (child|of-type)
	     	3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
	     	4 xn-component of xn+y argument ([+-]?\d*n|)
	     	5 sign of xn-component
	     	6 x of xn-component
	     	7 sign of y-component
	     	8 y of y-component
	     */
						match[1] = match[1].toLowerCase();
	
						if (match[1].slice(0, 3) === "nth") {
							// nth-* requires argument
							if (!match[3]) {
								Sizzle.error(match[0]);
							}
	
							// numeric x and y parameters for Expr.filter.CHILD
							// remember that false/true cast respectively to 0/1
							match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === "even" || match[3] === "odd"));
							match[5] = +(match[7] + match[8] || match[3] === "odd");
	
							// other types prohibit arguments
						} else if (match[3]) {
							Sizzle.error(match[0]);
						}
	
						return match;
					},
	
					"PSEUDO": function PSEUDO(match) {
						var excess,
						    unquoted = !match[6] && match[2];
	
						if (matchExpr["CHILD"].test(match[0])) {
							return null;
						}
	
						// Accept quoted arguments as-is
						if (match[3]) {
							match[2] = match[4] || match[5] || "";
	
							// Strip excess characters from unquoted arguments
						} else if (unquoted && rpseudo.test(unquoted) && (
						// Get excess from tokenize (recursively)
						excess = tokenize(unquoted, true)) && (
						// advance to the next closing parenthesis
						excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
	
							// excess is a negative index
							match[0] = match[0].slice(0, excess);
							match[2] = unquoted.slice(0, excess);
						}
	
						// Return only captures needed by the pseudo filter method (type and argument)
						return match.slice(0, 3);
					}
				},
	
				filter: {
	
					"TAG": function TAG(nodeNameSelector) {
						var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
						return nodeNameSelector === "*" ? function () {
							return true;
						} : function (elem) {
							return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
						};
					},
	
					"CLASS": function CLASS(className) {
						var pattern = classCache[className + " "];
	
						return pattern || (pattern = new RegExp("(^|" + whitespace + ")" + className + "(" + whitespace + "|$)")) && classCache(className, function (elem) {
							return pattern.test(typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "");
						});
					},
	
					"ATTR": function ATTR(name, operator, check) {
						return function (elem) {
							var result = Sizzle.attr(elem, name);
	
							if (result == null) {
								return operator === "!=";
							}
							if (!operator) {
								return true;
							}
	
							result += "";
	
							return operator === "=" ? result === check : operator === "!=" ? result !== check : operator === "^=" ? check && result.indexOf(check) === 0 : operator === "*=" ? check && result.indexOf(check) > -1 : operator === "$=" ? check && result.slice(-check.length) === check : operator === "~=" ? (" " + result.replace(rwhitespace, " ") + " ").indexOf(check) > -1 : operator === "|=" ? result === check || result.slice(0, check.length + 1) === check + "-" : false;
						};
					},
	
					"CHILD": function CHILD(type, what, argument, first, last) {
						var simple = type.slice(0, 3) !== "nth",
						    forward = type.slice(-4) !== "last",
						    ofType = what === "of-type";
	
						return first === 1 && last === 0 ?
	
						// Shortcut for :nth-*(n)
						function (elem) {
							return !!elem.parentNode;
						} : function (elem, context, xml) {
							var cache,
							    uniqueCache,
							    outerCache,
							    node,
							    nodeIndex,
							    start,
							    dir = simple !== forward ? "nextSibling" : "previousSibling",
							    parent = elem.parentNode,
							    name = ofType && elem.nodeName.toLowerCase(),
							    useCache = !xml && !ofType,
							    diff = false;
	
							if (parent) {
	
								// :(first|last|only)-(child|of-type)
								if (simple) {
									while (dir) {
										node = elem;
										while (node = node[dir]) {
											if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {
	
												return false;
											}
										}
										// Reverse direction for :only-* (if we haven't yet done so)
										start = dir = type === "only" && !start && "nextSibling";
									}
									return true;
								}
	
								start = [forward ? parent.firstChild : parent.lastChild];
	
								// non-xml :nth-child(...) stores cache data on `parent`
								if (forward && useCache) {
	
									// Seek `elem` from a previously-cached index
	
									// ...in a gzip-friendly way
									node = parent;
									outerCache = node[expando] || (node[expando] = {});
	
									// Support: IE <9 only
									// Defend against cloned attroperties (jQuery gh-1709)
									uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
	
									cache = uniqueCache[type] || [];
									nodeIndex = cache[0] === dirruns && cache[1];
									diff = nodeIndex && cache[2];
									node = nodeIndex && parent.childNodes[nodeIndex];
	
									while (node = ++nodeIndex && node && node[dir] || (
	
									// Fallback to seeking `elem` from the start
									diff = nodeIndex = 0) || start.pop()) {
	
										// When found, cache indexes on `parent` and break
										if (node.nodeType === 1 && ++diff && node === elem) {
											uniqueCache[type] = [dirruns, nodeIndex, diff];
											break;
										}
									}
								} else {
									// Use previously-cached element index if available
									if (useCache) {
										// ...in a gzip-friendly way
										node = elem;
										outerCache = node[expando] || (node[expando] = {});
	
										// Support: IE <9 only
										// Defend against cloned attroperties (jQuery gh-1709)
										uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
	
										cache = uniqueCache[type] || [];
										nodeIndex = cache[0] === dirruns && cache[1];
										diff = nodeIndex;
									}
	
									// xml :nth-child(...)
									// or :nth-last-child(...) or :nth(-last)?-of-type(...)
									if (diff === false) {
										// Use the same loop as above to seek `elem` from the start
										while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {
	
											if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {
	
												// Cache the index of each encountered element
												if (useCache) {
													outerCache = node[expando] || (node[expando] = {});
	
													// Support: IE <9 only
													// Defend against cloned attroperties (jQuery gh-1709)
													uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
	
													uniqueCache[type] = [dirruns, diff];
												}
	
												if (node === elem) {
													break;
												}
											}
										}
									}
								}
	
								// Incorporate the offset, then check against cycle size
								diff -= last;
								return diff === first || diff % first === 0 && diff / first >= 0;
							}
						};
					},
	
					"PSEUDO": function PSEUDO(pseudo, argument) {
						// pseudo-class names are case-insensitive
						// http://www.w3.org/TR/selectors/#pseudo-classes
						// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
						// Remember that setFilters inherits from pseudos
						var args,
						    fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error("unsupported pseudo: " + pseudo);
	
						// The user may use createPseudo to indicate that
						// arguments are needed to create the filter function
						// just as Sizzle does
						if (fn[expando]) {
							return fn(argument);
						}
	
						// But maintain support for old signatures
						if (fn.length > 1) {
							args = [pseudo, pseudo, "", argument];
							return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) {
								var idx,
								    matched = fn(seed, argument),
								    i = matched.length;
								while (i--) {
									idx = indexOf(seed, matched[i]);
									seed[idx] = !(matches[idx] = matched[i]);
								}
							}) : function (elem) {
								return fn(elem, 0, args);
							};
						}
	
						return fn;
					}
				},
	
				pseudos: {
					// Potentially complex pseudos
					"not": markFunction(function (selector) {
						// Trim the selector passed to compile
						// to avoid treating leading and trailing
						// spaces as combinators
						var input = [],
						    results = [],
						    matcher = compile(selector.replace(rtrim, "$1"));
	
						return matcher[expando] ? markFunction(function (seed, matches, context, xml) {
							var elem,
							    unmatched = matcher(seed, null, xml, []),
							    i = seed.length;
	
							// Match elements unmatched by `matcher`
							while (i--) {
								if (elem = unmatched[i]) {
									seed[i] = !(matches[i] = elem);
								}
							}
						}) : function (elem, context, xml) {
							input[0] = elem;
							matcher(input, null, xml, results);
							// Don't keep the element (issue #299)
							input[0] = null;
							return !results.pop();
						};
					}),
	
					"has": markFunction(function (selector) {
						return function (elem) {
							return Sizzle(selector, elem).length > 0;
						};
					}),
	
					"contains": markFunction(function (text) {
						text = text.replace(runescape, funescape);
						return function (elem) {
							return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1;
						};
					}),
	
					// "Whether an element is represented by a :lang() selector
					// is based solely on the element's language value
					// being equal to the identifier C,
					// or beginning with the identifier C immediately followed by "-".
					// The matching of C against the element's language value is performed case-insensitively.
					// The identifier C does not have to be a valid language name."
					// http://www.w3.org/TR/selectors/#lang-pseudo
					"lang": markFunction(function (lang) {
						// lang value must be a valid identifier
						if (!ridentifier.test(lang || "")) {
							Sizzle.error("unsupported lang: " + lang);
						}
						lang = lang.replace(runescape, funescape).toLowerCase();
						return function (elem) {
							var elemLang;
							do {
								if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute("xml:lang") || elem.getAttribute("lang")) {
	
									elemLang = elemLang.toLowerCase();
									return elemLang === lang || elemLang.indexOf(lang + "-") === 0;
								}
							} while ((elem = elem.parentNode) && elem.nodeType === 1);
							return false;
						};
					}),
	
					// Miscellaneous
					"target": function target(elem) {
						var hash = window.location && window.location.hash;
						return hash && hash.slice(1) === elem.id;
					},
	
					"root": function root(elem) {
						return elem === docElem;
					},
	
					"focus": function focus(elem) {
						return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
					},
	
					// Boolean properties
					"enabled": function enabled(elem) {
						return elem.disabled === false;
					},
	
					"disabled": function disabled(elem) {
						return elem.disabled === true;
					},
	
					"checked": function checked(elem) {
						// In CSS3, :checked should return both checked and selected elements
						// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
						var nodeName = elem.nodeName.toLowerCase();
						return nodeName === "input" && !!elem.checked || nodeName === "option" && !!elem.selected;
					},
	
					"selected": function selected(elem) {
						// Accessing this property makes selected-by-default
						// options in Safari work properly
						if (elem.parentNode) {
							elem.parentNode.selectedIndex;
						}
	
						return elem.selected === true;
					},
	
					// Contents
					"empty": function empty(elem) {
						// http://www.w3.org/TR/selectors/#empty-pseudo
						// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
						//   but not by others (comment: 8; processing instruction: 7; etc.)
						// nodeType < 6 works because attributes (2) do not appear as children
						for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
							if (elem.nodeType < 6) {
								return false;
							}
						}
						return true;
					},
	
					"parent": function parent(elem) {
						return !Expr.pseudos["empty"](elem);
					},
	
					// Element/input types
					"header": function header(elem) {
						return rheader.test(elem.nodeName);
					},
	
					"input": function input(elem) {
						return rinputs.test(elem.nodeName);
					},
	
					"button": function button(elem) {
						var name = elem.nodeName.toLowerCase();
						return name === "input" && elem.type === "button" || name === "button";
					},
	
					"text": function text(elem) {
						var attr;
						return elem.nodeName.toLowerCase() === "input" && elem.type === "text" && (
	
						// Support: IE<8
						// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
						(attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text");
					},
	
					// Position-in-collection
					"first": createPositionalPseudo(function () {
						return [0];
					}),
	
					"last": createPositionalPseudo(function (matchIndexes, length) {
						return [length - 1];
					}),
	
					"eq": createPositionalPseudo(function (matchIndexes, length, argument) {
						return [argument < 0 ? argument + length : argument];
					}),
	
					"even": createPositionalPseudo(function (matchIndexes, length) {
						var i = 0;
						for (; i < length; i += 2) {
							matchIndexes.push(i);
						}
						return matchIndexes;
					}),
	
					"odd": createPositionalPseudo(function (matchIndexes, length) {
						var i = 1;
						for (; i < length; i += 2) {
							matchIndexes.push(i);
						}
						return matchIndexes;
					}),
	
					"lt": createPositionalPseudo(function (matchIndexes, length, argument) {
						var i = argument < 0 ? argument + length : argument;
						for (; --i >= 0;) {
							matchIndexes.push(i);
						}
						return matchIndexes;
					}),
	
					"gt": createPositionalPseudo(function (matchIndexes, length, argument) {
						var i = argument < 0 ? argument + length : argument;
						for (; ++i < length;) {
							matchIndexes.push(i);
						}
						return matchIndexes;
					})
				}
			};
	
			Expr.pseudos["nth"] = Expr.pseudos["eq"];
	
			// Add button/input type pseudos
			for (i in { radio: true, checkbox: true, file: true, password: true, image: true }) {
				Expr.pseudos[i] = createInputPseudo(i);
			}
			for (i in { submit: true, reset: true }) {
				Expr.pseudos[i] = createButtonPseudo(i);
			}
	
			// Easy API for creating new setFilters
			function setFilters() {}
			setFilters.prototype = Expr.filters = Expr.pseudos;
			Expr.setFilters = new setFilters();
	
			tokenize = Sizzle.tokenize = function (selector, parseOnly) {
				var matched,
				    match,
				    tokens,
				    type,
				    soFar,
				    groups,
				    preFilters,
				    cached = tokenCache[selector + " "];
	
				if (cached) {
					return parseOnly ? 0 : cached.slice(0);
				}
	
				soFar = selector;
				groups = [];
				preFilters = Expr.preFilter;
	
				while (soFar) {
	
					// Comma and first run
					if (!matched || (match = rcomma.exec(soFar))) {
						if (match) {
							// Don't consume trailing commas as valid
							soFar = soFar.slice(match[0].length) || soFar;
						}
						groups.push(tokens = []);
					}
	
					matched = false;
	
					// Combinators
					if (match = rcombinators.exec(soFar)) {
						matched = match.shift();
						tokens.push({
							value: matched,
							// Cast descendant combinators to space
							type: match[0].replace(rtrim, " ")
						});
						soFar = soFar.slice(matched.length);
					}
	
					// Filters
					for (type in Expr.filter) {
						if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
							matched = match.shift();
							tokens.push({
								value: matched,
								type: type,
								matches: match
							});
							soFar = soFar.slice(matched.length);
						}
					}
	
					if (!matched) {
						break;
					}
				}
	
				// Return the length of the invalid excess
				// if we're just parsing
				// Otherwise, throw an error or return tokens
				return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) :
				// Cache the tokens
				tokenCache(selector, groups).slice(0);
			};
	
			function toSelector(tokens) {
				var i = 0,
				    len = tokens.length,
				    selector = "";
				for (; i < len; i++) {
					selector += tokens[i].value;
				}
				return selector;
			}
	
			function addCombinator(matcher, combinator, base) {
				var dir = combinator.dir,
				    checkNonElements = base && dir === "parentNode",
				    doneName = done++;
	
				return combinator.first ?
				// Check against closest ancestor/preceding element
				function (elem, context, xml) {
					while (elem = elem[dir]) {
						if (elem.nodeType === 1 || checkNonElements) {
							return matcher(elem, context, xml);
						}
					}
				} :
	
				// Check against all ancestor/preceding elements
				function (elem, context, xml) {
					var oldCache,
					    uniqueCache,
					    outerCache,
					    newCache = [dirruns, doneName];
	
					// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
					if (xml) {
						while (elem = elem[dir]) {
							if (elem.nodeType === 1 || checkNonElements) {
								if (matcher(elem, context, xml)) {
									return true;
								}
							}
						}
					} else {
						while (elem = elem[dir]) {
							if (elem.nodeType === 1 || checkNonElements) {
								outerCache = elem[expando] || (elem[expando] = {});
	
								// Support: IE <9 only
								// Defend against cloned attroperties (jQuery gh-1709)
								uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});
	
								if ((oldCache = uniqueCache[dir]) && oldCache[0] === dirruns && oldCache[1] === doneName) {
	
									// Assign to newCache so results back-propagate to previous elements
									return newCache[2] = oldCache[2];
								} else {
									// Reuse newcache so results back-propagate to previous elements
									uniqueCache[dir] = newCache;
	
									// A match means we're done; a fail means we have to keep checking
									if (newCache[2] = matcher(elem, context, xml)) {
										return true;
									}
								}
							}
						}
					}
				};
			}
	
			function elementMatcher(matchers) {
				return matchers.length > 1 ? function (elem, context, xml) {
					var i = matchers.length;
					while (i--) {
						if (!matchers[i](elem, context, xml)) {
							return false;
						}
					}
					return true;
				} : matchers[0];
			}
	
			function multipleContexts(selector, contexts, results) {
				var i = 0,
				    len = contexts.length;
				for (; i < len; i++) {
					Sizzle(selector, contexts[i], results);
				}
				return results;
			}
	
			function condense(unmatched, map, filter, context, xml) {
				var elem,
				    newUnmatched = [],
				    i = 0,
				    len = unmatched.length,
				    mapped = map != null;
	
				for (; i < len; i++) {
					if (elem = unmatched[i]) {
						if (!filter || filter(elem, context, xml)) {
							newUnmatched.push(elem);
							if (mapped) {
								map.push(i);
							}
						}
					}
				}
	
				return newUnmatched;
			}
	
			function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
				if (postFilter && !postFilter[expando]) {
					postFilter = setMatcher(postFilter);
				}
				if (postFinder && !postFinder[expando]) {
					postFinder = setMatcher(postFinder, postSelector);
				}
				return markFunction(function (seed, results, context, xml) {
					var temp,
					    i,
					    elem,
					    preMap = [],
					    postMap = [],
					    preexisting = results.length,
	
	
					// Get initial elements from seed or context
					elems = seed || multipleContexts(selector || "*", context.nodeType ? [context] : context, []),
	
	
					// Prefilter to get matcher input, preserving a map for seed-results synchronization
					matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems,
					    matcherOut = matcher ?
					// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
					postFinder || (seed ? preFilter : preexisting || postFilter) ?
	
					// ...intermediate processing is necessary
					[] :
	
					// ...otherwise use results directly
					results : matcherIn;
	
					// Find primary matches
					if (matcher) {
						matcher(matcherIn, matcherOut, context, xml);
					}
	
					// Apply postFilter
					if (postFilter) {
						temp = condense(matcherOut, postMap);
						postFilter(temp, [], context, xml);
	
						// Un-match failing elements by moving them back to matcherIn
						i = temp.length;
						while (i--) {
							if (elem = temp[i]) {
								matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem);
							}
						}
					}
	
					if (seed) {
						if (postFinder || preFilter) {
							if (postFinder) {
								// Get the final matcherOut by condensing this intermediate into postFinder contexts
								temp = [];
								i = matcherOut.length;
								while (i--) {
									if (elem = matcherOut[i]) {
										// Restore matcherIn since elem is not yet a final match
										temp.push(matcherIn[i] = elem);
									}
								}
								postFinder(null, matcherOut = [], temp, xml);
							}
	
							// Move matched elements from seed to results to keep them synchronized
							i = matcherOut.length;
							while (i--) {
								if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {
	
									seed[temp] = !(results[temp] = elem);
								}
							}
						}
	
						// Add elements to results, through postFinder if defined
					} else {
						matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
						if (postFinder) {
							postFinder(null, results, matcherOut, xml);
						} else {
							push.apply(results, matcherOut);
						}
					}
				});
			}
	
			function matcherFromTokens(tokens) {
				var checkContext,
				    matcher,
				    j,
				    len = tokens.length,
				    leadingRelative = Expr.relative[tokens[0].type],
				    implicitRelative = leadingRelative || Expr.relative[" "],
				    i = leadingRelative ? 1 : 0,
	
	
				// The foundational matcher ensures that elements are reachable from top-level context(s)
				matchContext = addCombinator(function (elem) {
					return elem === checkContext;
				}, implicitRelative, true),
				    matchAnyContext = addCombinator(function (elem) {
					return indexOf(checkContext, elem) > -1;
				}, implicitRelative, true),
				    matchers = [function (elem, context, xml) {
					var ret = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
					// Avoid hanging onto element (issue #299)
					checkContext = null;
					return ret;
				}];
	
				for (; i < len; i++) {
					if (matcher = Expr.relative[tokens[i].type]) {
						matchers = [addCombinator(elementMatcher(matchers), matcher)];
					} else {
						matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
	
						// Return special upon seeing a positional matcher
						if (matcher[expando]) {
							// Find the next relative operator (if any) for proper handling
							j = ++i;
							for (; j < len; j++) {
								if (Expr.relative[tokens[j].type]) {
									break;
								}
							}
							return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(
							// If the preceding token was a descendant combinator, insert an implicit any-element `*`
							tokens.slice(0, i - 1).concat({ value: tokens[i - 2].type === " " ? "*" : "" })).replace(rtrim, "$1"), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens));
						}
						matchers.push(matcher);
					}
				}
	
				return elementMatcher(matchers);
			}
	
			function matcherFromGroupMatchers(elementMatchers, setMatchers) {
				var bySet = setMatchers.length > 0,
				    byElement = elementMatchers.length > 0,
				    superMatcher = function superMatcher(seed, context, xml, results, outermost) {
					var elem,
					    j,
					    matcher,
					    matchedCount = 0,
					    i = "0",
					    unmatched = seed && [],
					    setMatched = [],
					    contextBackup = outermostContext,
	
					// We must always have either seed elements or outermost context
					elems = seed || byElement && Expr.find["TAG"]("*", outermost),
	
					// Use integer dirruns iff this is the outermost matcher
					dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1,
					    len = elems.length;
	
					if (outermost) {
						outermostContext = context === document || context || outermost;
					}
	
					// Add elements passing elementMatchers directly to results
					// Support: IE<9, Safari
					// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
					for (; i !== len && (elem = elems[i]) != null; i++) {
						if (byElement && elem) {
							j = 0;
							if (!context && elem.ownerDocument !== document) {
								setDocument(elem);
								xml = !documentIsHTML;
							}
							while (matcher = elementMatchers[j++]) {
								if (matcher(elem, context || document, xml)) {
									results.push(elem);
									break;
								}
							}
							if (outermost) {
								dirruns = dirrunsUnique;
							}
						}
	
						// Track unmatched elements for set filters
						if (bySet) {
							// They will have gone through all possible matchers
							if (elem = !matcher && elem) {
								matchedCount--;
							}
	
							// Lengthen the array for every element, matched or not
							if (seed) {
								unmatched.push(elem);
							}
						}
					}
	
					// `i` is now the count of elements visited above, and adding it to `matchedCount`
					// makes the latter nonnegative.
					matchedCount += i;
	
					// Apply set filters to unmatched elements
					// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
					// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
					// no element matchers and no seed.
					// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
					// case, which will result in a "00" `matchedCount` that differs from `i` but is also
					// numerically zero.
					if (bySet && i !== matchedCount) {
						j = 0;
						while (matcher = setMatchers[j++]) {
							matcher(unmatched, setMatched, context, xml);
						}
	
						if (seed) {
							// Reintegrate element matches to eliminate the need for sorting
							if (matchedCount > 0) {
								while (i--) {
									if (!(unmatched[i] || setMatched[i])) {
										setMatched[i] = pop.call(results);
									}
								}
							}
	
							// Discard index placeholder values to get only actual matches
							setMatched = condense(setMatched);
						}
	
						// Add matches to results
						push.apply(results, setMatched);
	
						// Seedless set matches succeeding multiple successful matchers stipulate sorting
						if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) {
	
							Sizzle.uniqueSort(results);
						}
					}
	
					// Override manipulation of globals by nested matchers
					if (outermost) {
						dirruns = dirrunsUnique;
						outermostContext = contextBackup;
					}
	
					return unmatched;
				};
	
				return bySet ? markFunction(superMatcher) : superMatcher;
			}
	
			compile = Sizzle.compile = function (selector, match /* Internal Use Only */) {
				var i,
				    setMatchers = [],
				    elementMatchers = [],
				    cached = compilerCache[selector + " "];
	
				if (!cached) {
					// Generate a function of recursive functions that can be used to check each element
					if (!match) {
						match = tokenize(selector);
					}
					i = match.length;
					while (i--) {
						cached = matcherFromTokens(match[i]);
						if (cached[expando]) {
							setMatchers.push(cached);
						} else {
							elementMatchers.push(cached);
						}
					}
	
					// Cache the compiled function
					cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
	
					// Save selector and tokenization
					cached.selector = selector;
				}
				return cached;
			};
	
			/**
	   * A low-level selection function that works with Sizzle's compiled
	   *  selector functions
	   * @param {String|Function} selector A selector or a pre-compiled
	   *  selector function built with Sizzle.compile
	   * @param {Element} context
	   * @param {Array} [results]
	   * @param {Array} [seed] A set of elements to match against
	   */
			select = Sizzle.select = function (selector, context, results, seed) {
				var i,
				    tokens,
				    token,
				    type,
				    find,
				    compiled = typeof selector === "function" && selector,
				    match = !seed && tokenize(selector = compiled.selector || selector);
	
				results = results || [];
	
				// Try to minimize operations if there is only one selector in the list and no seed
				// (the latter of which guarantees us context)
				if (match.length === 1) {
	
					// Reduce context if the leading compound selector is an ID
					tokens = match[0] = match[0].slice(0);
					if (tokens.length > 2 && (token = tokens[0]).type === "ID" && support.getById && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {
	
						context = (Expr.find["ID"](token.matches[0].replace(runescape, funescape), context) || [])[0];
						if (!context) {
							return results;
	
							// Precompiled matchers will still verify ancestry, so step up a level
						} else if (compiled) {
							context = context.parentNode;
						}
	
						selector = selector.slice(tokens.shift().value.length);
					}
	
					// Fetch a seed set for right-to-left matching
					i = matchExpr["needsContext"].test(selector) ? 0 : tokens.length;
					while (i--) {
						token = tokens[i];
	
						// Abort if we hit a combinator
						if (Expr.relative[type = token.type]) {
							break;
						}
						if (find = Expr.find[type]) {
							// Search, expanding context for leading sibling combinators
							if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) {
	
								// If seed is empty or no tokens remain, we can return early
								tokens.splice(i, 1);
								selector = seed.length && toSelector(tokens);
								if (!selector) {
									push.apply(results, seed);
									return results;
								}
	
								break;
							}
						}
					}
				}
	
				// Compile and execute a filtering function if one is not provided
				// Provide `match` to avoid retokenization if we modified the selector above
				(compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);
				return results;
			};
	
			// One-time assignments
	
			// Sort stability
			support.sortStable = expando.split("").sort(sortOrder).join("") === expando;
	
			// Support: Chrome 14-35+
			// Always assume duplicates if they aren't passed to the comparison function
			support.detectDuplicates = !!hasDuplicate;
	
			// Initialize against the default document
			setDocument();
	
			// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
			// Detached nodes confoundingly follow *each other*
			support.sortDetached = assert(function (div1) {
				// Should return 1, but returns 4 (following)
				return div1.compareDocumentPosition(document.createElement("div")) & 1;
			});
	
			// Support: IE<8
			// Prevent attribute/property "interpolation"
			// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
			if (!assert(function (div) {
				div.innerHTML = "<a href='#'></a>";
				return div.firstChild.getAttribute("href") === "#";
			})) {
				addHandle("type|href|height|width", function (elem, name, isXML) {
					if (!isXML) {
						return elem.getAttribute(name, name.toLowerCase() === "type" ? 1 : 2);
					}
				});
			}
	
			// Support: IE<9
			// Use defaultValue in place of getAttribute("value")
			if (!support.attributes || !assert(function (div) {
				div.innerHTML = "<input/>";
				div.firstChild.setAttribute("value", "");
				return div.firstChild.getAttribute("value") === "";
			})) {
				addHandle("value", function (elem, name, isXML) {
					if (!isXML && elem.nodeName.toLowerCase() === "input") {
						return elem.defaultValue;
					}
				});
			}
	
			// Support: IE<9
			// Use getAttributeNode to fetch booleans when getAttribute lies
			if (!assert(function (div) {
				return div.getAttribute("disabled") == null;
			})) {
				addHandle(booleans, function (elem, name, isXML) {
					var val;
					if (!isXML) {
						return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null;
					}
				});
			}
	
			return Sizzle;
		}(window);
	
		jQuery.find = Sizzle;
		jQuery.expr = Sizzle.selectors;
		jQuery.expr[":"] = jQuery.expr.pseudos;
		jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
		jQuery.text = Sizzle.getText;
		jQuery.isXMLDoc = Sizzle.isXML;
		jQuery.contains = Sizzle.contains;
	
		var dir = function dir(elem, _dir, until) {
			var matched = [],
			    truncate = until !== undefined;
	
			while ((elem = elem[_dir]) && elem.nodeType !== 9) {
				if (elem.nodeType === 1) {
					if (truncate && jQuery(elem).is(until)) {
						break;
					}
					matched.push(elem);
				}
			}
			return matched;
		};
	
		var _siblings = function _siblings(n, elem) {
			var matched = [];
	
			for (; n; n = n.nextSibling) {
				if (n.nodeType === 1 && n !== elem) {
					matched.push(n);
				}
			}
	
			return matched;
		};
	
		var rneedsContext = jQuery.expr.match.needsContext;
	
		var rsingleTag = /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/;
	
		var risSimple = /^.[^:#\[\.,]*$/;
	
		// Implement the identical functionality for filter and not
		function winnow(elements, qualifier, not) {
			if (jQuery.isFunction(qualifier)) {
				return jQuery.grep(elements, function (elem, i) {
					/* jshint -W018 */
					return !!qualifier.call(elem, i, elem) !== not;
				});
			}
	
			if (qualifier.nodeType) {
				return jQuery.grep(elements, function (elem) {
					return elem === qualifier !== not;
				});
			}
	
			if (typeof qualifier === "string") {
				if (risSimple.test(qualifier)) {
					return jQuery.filter(qualifier, elements, not);
				}
	
				qualifier = jQuery.filter(qualifier, elements);
			}
	
			return jQuery.grep(elements, function (elem) {
				return indexOf.call(qualifier, elem) > -1 !== not;
			});
		}
	
		jQuery.filter = function (expr, elems, not) {
			var elem = elems[0];
	
			if (not) {
				expr = ":not(" + expr + ")";
			}
	
			return elems.length === 1 && elem.nodeType === 1 ? jQuery.find.matchesSelector(elem, expr) ? [elem] : [] : jQuery.find.matches(expr, jQuery.grep(elems, function (elem) {
				return elem.nodeType === 1;
			}));
		};
	
		jQuery.fn.extend({
			find: function find(selector) {
				var i,
				    len = this.length,
				    ret = [],
				    self = this;
	
				if (typeof selector !== "string") {
					return this.pushStack(jQuery(selector).filter(function () {
						for (i = 0; i < len; i++) {
							if (jQuery.contains(self[i], this)) {
								return true;
							}
						}
					}));
				}
	
				for (i = 0; i < len; i++) {
					jQuery.find(selector, self[i], ret);
				}
	
				// Needed because $( selector, context ) becomes $( context ).find( selector )
				ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret);
				ret.selector = this.selector ? this.selector + " " + selector : selector;
				return ret;
			},
			filter: function filter(selector) {
				return this.pushStack(winnow(this, selector || [], false));
			},
			not: function not(selector) {
				return this.pushStack(winnow(this, selector || [], true));
			},
			is: function is(selector) {
				return !!winnow(this,
	
				// If this is a positional/relative selector, check membership in the returned set
				// so $("p:first").is("p:last") won't return true for a doc with two "p".
				typeof selector === "string" && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length;
			}
		});
	
		// Initialize a jQuery object
	
	
		// A central reference to the root jQuery(document)
		var rootjQuery,
	
	
		// A simple way to check for HTML strings
		// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
		// Strict HTML recognition (#11290: must start with <)
		rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
		    init = jQuery.fn.init = function (selector, context, root) {
			var match, elem;
	
			// HANDLE: $(""), $(null), $(undefined), $(false)
			if (!selector) {
				return this;
			}
	
			// Method init() accepts an alternate rootjQuery
			// so migrate can support jQuery.sub (gh-2101)
			root = root || rootjQuery;
	
			// Handle HTML strings
			if (typeof selector === "string") {
				if (selector[0] === "<" && selector[selector.length - 1] === ">" && selector.length >= 3) {
	
					// Assume that strings that start and end with <> are HTML and skip the regex check
					match = [null, selector, null];
				} else {
					match = rquickExpr.exec(selector);
				}
	
				// Match html or make sure no context is specified for #id
				if (match && (match[1] || !context)) {
	
					// HANDLE: $(html) -> $(array)
					if (match[1]) {
						context = context instanceof jQuery ? context[0] : context;
	
						// Option to run scripts is true for back-compat
						// Intentionally let the error be thrown if parseHTML is not present
						jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true));
	
						// HANDLE: $(html, props)
						if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
							for (match in context) {
	
								// Properties of context are called as methods if possible
								if (jQuery.isFunction(this[match])) {
									this[match](context[match]);
	
									// ...and otherwise set as attributes
								} else {
									this.attr(match, context[match]);
								}
							}
						}
	
						return this;
	
						// HANDLE: $(#id)
					} else {
						elem = document.getElementById(match[2]);
	
						// Support: Blackberry 4.6
						// gEBID returns nodes no longer in the document (#6963)
						if (elem && elem.parentNode) {
	
							// Inject the element directly into the jQuery object
							this.length = 1;
							this[0] = elem;
						}
	
						this.context = document;
						this.selector = selector;
						return this;
					}
	
					// HANDLE: $(expr, $(...))
				} else if (!context || context.jquery) {
					return (context || root).find(selector);
	
					// HANDLE: $(expr, context)
					// (which is just equivalent to: $(context).find(expr)
				} else {
					return this.constructor(context).find(selector);
				}
	
				// HANDLE: $(DOMElement)
			} else if (selector.nodeType) {
				this.context = this[0] = selector;
				this.length = 1;
				return this;
	
				// HANDLE: $(function)
				// Shortcut for document ready
			} else if (jQuery.isFunction(selector)) {
				return root.ready !== undefined ? root.ready(selector) :
	
				// Execute immediately if ready is not present
				selector(jQuery);
			}
	
			if (selector.selector !== undefined) {
				this.selector = selector.selector;
				this.context = selector.context;
			}
	
			return jQuery.makeArray(selector, this);
		};
	
		// Give the init function the jQuery prototype for later instantiation
		init.prototype = jQuery.fn;
	
		// Initialize central reference
		rootjQuery = jQuery(document);
	
		var rparentsprev = /^(?:parents|prev(?:Until|All))/,
	
	
		// Methods guaranteed to produce a unique set when starting from a unique set
		guaranteedUnique = {
			children: true,
			contents: true,
			next: true,
			prev: true
		};
	
		jQuery.fn.extend({
			has: function has(target) {
				var targets = jQuery(target, this),
				    l = targets.length;
	
				return this.filter(function () {
					var i = 0;
					for (; i < l; i++) {
						if (jQuery.contains(this, targets[i])) {
							return true;
						}
					}
				});
			},
	
			closest: function closest(selectors, context) {
				var cur,
				    i = 0,
				    l = this.length,
				    matched = [],
				    pos = rneedsContext.test(selectors) || typeof selectors !== "string" ? jQuery(selectors, context || this.context) : 0;
	
				for (; i < l; i++) {
					for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {
	
						// Always skip document fragments
						if (cur.nodeType < 11 && (pos ? pos.index(cur) > -1 :
	
						// Don't pass non-elements to Sizzle
						cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) {
	
							matched.push(cur);
							break;
						}
					}
				}
	
				return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched);
			},
	
			// Determine the position of an element within the set
			index: function index(elem) {
	
				// No argument, return index in parent
				if (!elem) {
					return this[0] && this[0].parentNode ? this.first().prevAll().length : -1;
				}
	
				// Index in selector
				if (typeof elem === "string") {
					return indexOf.call(jQuery(elem), this[0]);
				}
	
				// Locate the position of the desired element
				return indexOf.call(this,
	
				// If it receives a jQuery object, the first element is used
				elem.jquery ? elem[0] : elem);
			},
	
			add: function add(selector, context) {
				return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(selector, context))));
			},
	
			addBack: function addBack(selector) {
				return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector));
			}
		});
	
		function sibling(cur, dir) {
			while ((cur = cur[dir]) && cur.nodeType !== 1) {}
			return cur;
		}
	
		jQuery.each({
			parent: function parent(elem) {
				var parent = elem.parentNode;
				return parent && parent.nodeType !== 11 ? parent : null;
			},
			parents: function parents(elem) {
				return dir(elem, "parentNode");
			},
			parentsUntil: function parentsUntil(elem, i, until) {
				return dir(elem, "parentNode", until);
			},
			next: function next(elem) {
				return sibling(elem, "nextSibling");
			},
			prev: function prev(elem) {
				return sibling(elem, "previousSibling");
			},
			nextAll: function nextAll(elem) {
				return dir(elem, "nextSibling");
			},
			prevAll: function prevAll(elem) {
				return dir(elem, "previousSibling");
			},
			nextUntil: function nextUntil(elem, i, until) {
				return dir(elem, "nextSibling", until);
			},
			prevUntil: function prevUntil(elem, i, until) {
				return dir(elem, "previousSibling", until);
			},
			siblings: function siblings(elem) {
				return _siblings((elem.parentNode || {}).firstChild, elem);
			},
			children: function children(elem) {
				return _siblings(elem.firstChild);
			},
			contents: function contents(elem) {
				return elem.contentDocument || jQuery.merge([], elem.childNodes);
			}
		}, function (name, fn) {
			jQuery.fn[name] = function (until, selector) {
				var matched = jQuery.map(this, fn, until);
	
				if (name.slice(-5) !== "Until") {
					selector = until;
				}
	
				if (selector && typeof selector === "string") {
					matched = jQuery.filter(selector, matched);
				}
	
				if (this.length > 1) {
	
					// Remove duplicates
					if (!guaranteedUnique[name]) {
						jQuery.uniqueSort(matched);
					}
	
					// Reverse order for parents* and prev-derivatives
					if (rparentsprev.test(name)) {
						matched.reverse();
					}
				}
	
				return this.pushStack(matched);
			};
		});
		var rnotwhite = /\S+/g;
	
		// Convert String-formatted options into Object-formatted ones
		function createOptions(options) {
			var object = {};
			jQuery.each(options.match(rnotwhite) || [], function (_, flag) {
				object[flag] = true;
			});
			return object;
		}
	
		/*
	  * Create a callback list using the following parameters:
	  *
	  *	options: an optional list of space-separated options that will change how
	  *			the callback list behaves or a more traditional option object
	  *
	  * By default a callback list will act like an event callback list and can be
	  * "fired" multiple times.
	  *
	  * Possible options:
	  *
	  *	once:			will ensure the callback list can only be fired once (like a Deferred)
	  *
	  *	memory:			will keep track of previous values and will call any callback added
	  *					after the list has been fired right away with the latest "memorized"
	  *					values (like a Deferred)
	  *
	  *	unique:			will ensure a callback can only be added once (no duplicate in the list)
	  *
	  *	stopOnFalse:	interrupt callings when a callback returns false
	  *
	  */
		jQuery.Callbacks = function (options) {
	
			// Convert options from String-formatted to Object-formatted if needed
			// (we check in cache first)
			options = typeof options === "string" ? createOptions(options) : jQuery.extend({}, options);
	
			var // Flag to know if list is currently firing
			firing,
	
	
			// Last fire value for non-forgettable lists
			memory,
	
	
			// Flag to know if list was already fired
			_fired,
	
	
			// Flag to prevent firing
			_locked,
	
	
			// Actual callback list
			list = [],
	
	
			// Queue of execution data for repeatable lists
			queue = [],
	
	
			// Index of currently firing callback (modified by add/remove as needed)
			firingIndex = -1,
	
	
			// Fire callbacks
			fire = function fire() {
	
				// Enforce single-firing
				_locked = options.once;
	
				// Execute callbacks for all pending executions,
				// respecting firingIndex overrides and runtime changes
				_fired = firing = true;
				for (; queue.length; firingIndex = -1) {
					memory = queue.shift();
					while (++firingIndex < list.length) {
	
						// Run callback and check for early termination
						if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) {
	
							// Jump to end and forget the data so .add doesn't re-fire
							firingIndex = list.length;
							memory = false;
						}
					}
				}
	
				// Forget the data if we're done with it
				if (!options.memory) {
					memory = false;
				}
	
				firing = false;
	
				// Clean up if we're done firing for good
				if (_locked) {
	
					// Keep an empty list if we have data for future add calls
					if (memory) {
						list = [];
	
						// Otherwise, this object is spent
					} else {
						list = "";
					}
				}
			},
	
	
			// Actual Callbacks object
			self = {
	
				// Add a callback or a collection of callbacks to the list
				add: function add() {
					if (list) {
	
						// If we have memory from a past run, we should fire after adding
						if (memory && !firing) {
							firingIndex = list.length - 1;
							queue.push(memory);
						}
	
						(function add(args) {
							jQuery.each(args, function (_, arg) {
								if (jQuery.isFunction(arg)) {
									if (!options.unique || !self.has(arg)) {
										list.push(arg);
									}
								} else if (arg && arg.length && jQuery.type(arg) !== "string") {
	
									// Inspect recursively
									add(arg);
								}
							});
						})(arguments);
	
						if (memory && !firing) {
							fire();
						}
					}
					return this;
				},
	
				// Remove a callback from the list
				remove: function remove() {
					jQuery.each(arguments, function (_, arg) {
						var index;
						while ((index = jQuery.inArray(arg, list, index)) > -1) {
							list.splice(index, 1);
	
							// Handle firing indexes
							if (index <= firingIndex) {
								firingIndex--;
							}
						}
					});
					return this;
				},
	
				// Check if a given callback is in the list.
				// If no argument is given, return whether or not list has callbacks attached.
				has: function has(fn) {
					return fn ? jQuery.inArray(fn, list) > -1 : list.length > 0;
				},
	
				// Remove all callbacks from the list
				empty: function empty() {
					if (list) {
						list = [];
					}
					return this;
				},
	
				// Disable .fire and .add
				// Abort any current/pending executions
				// Clear all callbacks and values
				disable: function disable() {
					_locked = queue = [];
					list = memory = "";
					return this;
				},
				disabled: function disabled() {
					return !list;
				},
	
				// Disable .fire
				// Also disable .add unless we have memory (since it would have no effect)
				// Abort any pending executions
				lock: function lock() {
					_locked = queue = [];
					if (!memory) {
						list = memory = "";
					}
					return this;
				},
				locked: function locked() {
					return !!_locked;
				},
	
				// Call all callbacks with the given context and arguments
				fireWith: function fireWith(context, args) {
					if (!_locked) {
						args = args || [];
						args = [context, args.slice ? args.slice() : args];
						queue.push(args);
						if (!firing) {
							fire();
						}
					}
					return this;
				},
	
				// Call all the callbacks with the given arguments
				fire: function fire() {
					self.fireWith(this, arguments);
					return this;
				},
	
				// To know if the callbacks have already been called at least once
				fired: function fired() {
					return !!_fired;
				}
			};
	
			return self;
		};
	
		jQuery.extend({
	
			Deferred: function Deferred(func) {
				var tuples = [
	
				// action, add listener, listener list, final state
				["resolve", "done", jQuery.Callbacks("once memory"), "resolved"], ["reject", "fail", jQuery.Callbacks("once memory"), "rejected"], ["notify", "progress", jQuery.Callbacks("memory")]],
				    _state = "pending",
				    _promise = {
					state: function state() {
						return _state;
					},
					always: function always() {
						deferred.done(arguments).fail(arguments);
						return this;
					},
					then: function then() /* fnDone, fnFail, fnProgress */{
						var fns = arguments;
						return jQuery.Deferred(function (newDefer) {
							jQuery.each(tuples, function (i, tuple) {
								var fn = jQuery.isFunction(fns[i]) && fns[i];
	
								// deferred[ done | fail | progress ] for forwarding actions to newDefer
								deferred[tuple[1]](function () {
									var returned = fn && fn.apply(this, arguments);
									if (returned && jQuery.isFunction(returned.promise)) {
										returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject);
									} else {
										newDefer[tuple[0] + "With"](this === _promise ? newDefer.promise() : this, fn ? [returned] : arguments);
									}
								});
							});
							fns = null;
						}).promise();
					},
	
					// Get a promise for this deferred
					// If obj is provided, the promise aspect is added to the object
					promise: function promise(obj) {
						return obj != null ? jQuery.extend(obj, _promise) : _promise;
					}
				},
				    deferred = {};
	
				// Keep pipe for back-compat
				_promise.pipe = _promise.then;
	
				// Add list-specific methods
				jQuery.each(tuples, function (i, tuple) {
					var list = tuple[2],
					    stateString = tuple[3];
	
					// promise[ done | fail | progress ] = list.add
					_promise[tuple[1]] = list.add;
	
					// Handle state
					if (stateString) {
						list.add(function () {
	
							// state = [ resolved | rejected ]
							_state = stateString;
	
							// [ reject_list | resolve_list ].disable; progress_list.lock
						}, tuples[i ^ 1][2].disable, tuples[2][2].lock);
					}
	
					// deferred[ resolve | reject | notify ]
					deferred[tuple[0]] = function () {
						deferred[tuple[0] + "With"](this === deferred ? _promise : this, arguments);
						return this;
					};
					deferred[tuple[0] + "With"] = list.fireWith;
				});
	
				// Make the deferred a promise
				_promise.promise(deferred);
	
				// Call given func if any
				if (func) {
					func.call(deferred, deferred);
				}
	
				// All done!
				return deferred;
			},
	
			// Deferred helper
			when: function when(subordinate /* , ..., subordinateN */) {
				var i = 0,
				    resolveValues = _slice.call(arguments),
				    length = resolveValues.length,
	
	
				// the count of uncompleted subordinates
				remaining = length !== 1 || subordinate && jQuery.isFunction(subordinate.promise) ? length : 0,
	
	
				// the master Deferred.
				// If resolveValues consist of only a single Deferred, just use that.
				deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
	
	
				// Update function for both resolve and progress values
				updateFunc = function updateFunc(i, contexts, values) {
					return function (value) {
						contexts[i] = this;
						values[i] = arguments.length > 1 ? _slice.call(arguments) : value;
						if (values === progressValues) {
							deferred.notifyWith(contexts, values);
						} else if (! --remaining) {
							deferred.resolveWith(contexts, values);
						}
					};
				},
				    progressValues,
				    progressContexts,
				    resolveContexts;
	
				// Add listeners to Deferred subordinates; treat others as resolved
				if (length > 1) {
					progressValues = new Array(length);
					progressContexts = new Array(length);
					resolveContexts = new Array(length);
					for (; i < length; i++) {
						if (resolveValues[i] && jQuery.isFunction(resolveValues[i].promise)) {
							resolveValues[i].promise().progress(updateFunc(i, progressContexts, progressValues)).done(updateFunc(i, resolveContexts, resolveValues)).fail(deferred.reject);
						} else {
							--remaining;
						}
					}
				}
	
				// If we're not waiting on anything, resolve the master
				if (!remaining) {
					deferred.resolveWith(resolveContexts, resolveValues);
				}
	
				return deferred.promise();
			}
		});
	
		// The deferred used on DOM ready
		var readyList;
	
		jQuery.fn.ready = function (fn) {
	
			// Add the callback
			jQuery.ready.promise().done(fn);
	
			return this;
		};
	
		jQuery.extend({
	
			// Is the DOM ready to be used? Set to true once it occurs.
			isReady: false,
	
			// A counter to track how many items to wait for before
			// the ready event fires. See #6781
			readyWait: 1,
	
			// Hold (or release) the ready event
			holdReady: function holdReady(hold) {
				if (hold) {
					jQuery.readyWait++;
				} else {
					jQuery.ready(true);
				}
			},
	
			// Handle when the DOM is ready
			ready: function ready(wait) {
	
				// Abort if there are pending holds or we're already ready
				if (wait === true ? --jQuery.readyWait : jQuery.isReady) {
					return;
				}
	
				// Remember that the DOM is ready
				jQuery.isReady = true;
	
				// If a normal DOM Ready event fired, decrement, and wait if need be
				if (wait !== true && --jQuery.readyWait > 0) {
					return;
				}
	
				// If there are functions bound, to execute
				readyList.resolveWith(document, [jQuery]);
	
				// Trigger any bound ready events
				if (jQuery.fn.triggerHandler) {
					jQuery(document).triggerHandler("ready");
					jQuery(document).off("ready");
				}
			}
		});
	
		/**
	  * The ready event handler and self cleanup method
	  */
		function completed() {
			document.removeEventListener("DOMContentLoaded", completed);
			window.removeEventListener("load", completed);
			jQuery.ready();
		}
	
		jQuery.ready.promise = function (obj) {
			if (!readyList) {
	
				readyList = jQuery.Deferred();
	
				// Catch cases where $(document).ready() is called
				// after the browser event has already occurred.
				// Support: IE9-10 only
				// Older IE sometimes signals "interactive" too soon
				if (document.readyState === "complete" || document.readyState !== "loading" && !document.documentElement.doScroll) {
	
					// Handle it asynchronously to allow scripts the opportunity to delay ready
					window.setTimeout(jQuery.ready);
				} else {
	
					// Use the handy event callback
					document.addEventListener("DOMContentLoaded", completed);
	
					// A fallback to window.onload, that will always work
					window.addEventListener("load", completed);
				}
			}
			return readyList.promise(obj);
		};
	
		// Kick off the DOM ready check even if the user does not
		jQuery.ready.promise();
	
		// Multifunctional method to get and set values of a collection
		// The value/s can optionally be executed if it's a function
		var access = function access(elems, fn, key, value, chainable, emptyGet, raw) {
			var i = 0,
			    len = elems.length,
			    bulk = key == null;
	
			// Sets many values
			if (jQuery.type(key) === "object") {
				chainable = true;
				for (i in key) {
					access(elems, fn, i, key[i], true, emptyGet, raw);
				}
	
				// Sets one value
			} else if (value !== undefined) {
				chainable = true;
	
				if (!jQuery.isFunction(value)) {
					raw = true;
				}
	
				if (bulk) {
	
					// Bulk operations run against the entire set
					if (raw) {
						fn.call(elems, value);
						fn = null;
	
						// ...except when executing function values
					} else {
						bulk = fn;
						fn = function fn(elem, key, value) {
							return bulk.call(jQuery(elem), value);
						};
					}
				}
	
				if (fn) {
					for (; i < len; i++) {
						fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)));
					}
				}
			}
	
			return chainable ? elems :
	
			// Gets
			bulk ? fn.call(elems) : len ? fn(elems[0], key) : emptyGet;
		};
		var acceptData = function acceptData(owner) {
	
			// Accepts only:
			//  - Node
			//    - Node.ELEMENT_NODE
			//    - Node.DOCUMENT_NODE
			//  - Object
			//    - Any
			/* jshint -W018 */
			return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType;
		};
	
		function Data() {
			this.expando = jQuery.expando + Data.uid++;
		}
	
		Data.uid = 1;
	
		Data.prototype = {
	
			register: function register(owner, initial) {
				var value = initial || {};
	
				// If it is a node unlikely to be stringify-ed or looped over
				// use plain assignment
				if (owner.nodeType) {
					owner[this.expando] = value;
	
					// Otherwise secure it in a non-enumerable, non-writable property
					// configurability must be true to allow the property to be
					// deleted with the delete operator
				} else {
					Object.defineProperty(owner, this.expando, {
						value: value,
						writable: true,
						configurable: true
					});
				}
				return owner[this.expando];
			},
			cache: function cache(owner) {
	
				// We can accept data for non-element nodes in modern browsers,
				// but we should not, see #8335.
				// Always return an empty object.
				if (!acceptData(owner)) {
					return {};
				}
	
				// Check if the owner object already has a cache
				var value = owner[this.expando];
	
				// If not, create one
				if (!value) {
					value = {};
	
					// We can accept data for non-element nodes in modern browsers,
					// but we should not, see #8335.
					// Always return an empty object.
					if (acceptData(owner)) {
	
						// If it is a node unlikely to be stringify-ed or looped over
						// use plain assignment
						if (owner.nodeType) {
							owner[this.expando] = value;
	
							// Otherwise secure it in a non-enumerable property
							// configurable must be true to allow the property to be
							// deleted when data is removed
						} else {
							Object.defineProperty(owner, this.expando, {
								value: value,
								configurable: true
							});
						}
					}
				}
	
				return value;
			},
			set: function set(owner, data, value) {
				var prop,
				    cache = this.cache(owner);
	
				// Handle: [ owner, key, value ] args
				if (typeof data === "string") {
					cache[data] = value;
	
					// Handle: [ owner, { properties } ] args
				} else {
	
					// Copy the properties one-by-one to the cache object
					for (prop in data) {
						cache[prop] = data[prop];
					}
				}
				return cache;
			},
			get: function get(owner, key) {
				return key === undefined ? this.cache(owner) : owner[this.expando] && owner[this.expando][key];
			},
			access: function access(owner, key, value) {
				var stored;
	
				// In cases where either:
				//
				//   1. No key was specified
				//   2. A string key was specified, but no value provided
				//
				// Take the "read" path and allow the get method to determine
				// which value to return, respectively either:
				//
				//   1. The entire cache object
				//   2. The data stored at the key
				//
				if (key === undefined || key && typeof key === "string" && value === undefined) {
	
					stored = this.get(owner, key);
	
					return stored !== undefined ? stored : this.get(owner, jQuery.camelCase(key));
				}
	
				// When the key is not a string, or both a key and value
				// are specified, set or extend (existing objects) with either:
				//
				//   1. An object of properties
				//   2. A key and value
				//
				this.set(owner, key, value);
	
				// Since the "set" path can have two possible entry points
				// return the expected data based on which path was taken[*]
				return value !== undefined ? value : key;
			},
			remove: function remove(owner, key) {
				var i,
				    name,
				    camel,
				    cache = owner[this.expando];
	
				if (cache === undefined) {
					return;
				}
	
				if (key === undefined) {
					this.register(owner);
				} else {
	
					// Support array or space separated string of keys
					if (jQuery.isArray(key)) {
	
						// If "name" is an array of keys...
						// When data is initially created, via ("key", "val") signature,
						// keys will be converted to camelCase.
						// Since there is no way to tell _how_ a key was added, remove
						// both plain key and camelCase key. #12786
						// This will only penalize the array argument path.
						name = key.concat(key.map(jQuery.camelCase));
					} else {
						camel = jQuery.camelCase(key);
	
						// Try the string as a key before any manipulation
						if (key in cache) {
							name = [key, camel];
						} else {
	
							// If a key with the spaces exists, use it.
							// Otherwise, create an array by matching non-whitespace
							name = camel;
							name = name in cache ? [name] : name.match(rnotwhite) || [];
						}
					}
	
					i = name.length;
	
					while (i--) {
						delete cache[name[i]];
					}
				}
	
				// Remove the expando if there's no more data
				if (key === undefined || jQuery.isEmptyObject(cache)) {
	
					// Support: Chrome <= 35-45+
					// Webkit & Blink performance suffers when deleting properties
					// from DOM nodes, so set to undefined instead
					// https://code.google.com/p/chromium/issues/detail?id=378607
					if (owner.nodeType) {
						owner[this.expando] = undefined;
					} else {
						delete owner[this.expando];
					}
				}
			},
			hasData: function hasData(owner) {
				var cache = owner[this.expando];
				return cache !== undefined && !jQuery.isEmptyObject(cache);
			}
		};
		var dataPriv = new Data();
	
		var dataUser = new Data();
	
		//	Implementation Summary
		//
		//	1. Enforce API surface and semantic compatibility with 1.9.x branch
		//	2. Improve the module's maintainability by reducing the storage
		//		paths to a single mechanism.
		//	3. Use the same single mechanism to support "private" and "user" data.
		//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
		//	5. Avoid exposing implementation details on user objects (eg. expando properties)
		//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
	
		var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
		    rmultiDash = /[A-Z]/g;
	
		function dataAttr(elem, key, data) {
			var name;
	
			// If nothing was found internally, try to fetch any
			// data from the HTML5 data-* attribute
			if (data === undefined && elem.nodeType === 1) {
				name = "data-" + key.replace(rmultiDash, "-$&").toLowerCase();
				data = elem.getAttribute(name);
	
				if (typeof data === "string") {
					try {
						data = data === "true" ? true : data === "false" ? false : data === "null" ? null :
	
						// Only convert to a number if it doesn't change the string
						+data + "" === data ? +data : rbrace.test(data) ? jQuery.parseJSON(data) : data;
					} catch (e) {}
	
					// Make sure we set the data so it isn't changed later
					dataUser.set(elem, key, data);
				} else {
					data = undefined;
				}
			}
			return data;
		}
	
		jQuery.extend({
			hasData: function hasData(elem) {
				return dataUser.hasData(elem) || dataPriv.hasData(elem);
			},
	
			data: function data(elem, name, _data) {
				return dataUser.access(elem, name, _data);
			},
	
			removeData: function removeData(elem, name) {
				dataUser.remove(elem, name);
			},
	
			// TODO: Now that all calls to _data and _removeData have been replaced
			// with direct calls to dataPriv methods, these can be deprecated.
			_data: function _data(elem, name, data) {
				return dataPriv.access(elem, name, data);
			},
	
			_removeData: function _removeData(elem, name) {
				dataPriv.remove(elem, name);
			}
		});
	
		jQuery.fn.extend({
			data: function data(key, value) {
				var i,
				    name,
				    data,
				    elem = this[0],
				    attrs = elem && elem.attributes;
	
				// Gets all values
				if (key === undefined) {
					if (this.length) {
						data = dataUser.get(elem);
	
						if (elem.nodeType === 1 && !dataPriv.get(elem, "hasDataAttrs")) {
							i = attrs.length;
							while (i--) {
	
								// Support: IE11+
								// The attrs elements can be null (#14894)
								if (attrs[i]) {
									name = attrs[i].name;
									if (name.indexOf("data-") === 0) {
										name = jQuery.camelCase(name.slice(5));
										dataAttr(elem, name, data[name]);
									}
								}
							}
							dataPriv.set(elem, "hasDataAttrs", true);
						}
					}
	
					return data;
				}
	
				// Sets multiple values
				if ((typeof key === "undefined" ? "undefined" : _typeof(key)) === "object") {
					return this.each(function () {
						dataUser.set(this, key);
					});
				}
	
				return access(this, function (value) {
					var data, camelKey;
	
					// The calling jQuery object (element matches) is not empty
					// (and therefore has an element appears at this[ 0 ]) and the
					// `value` parameter was not undefined. An empty jQuery object
					// will result in `undefined` for elem = this[ 0 ] which will
					// throw an exception if an attempt to read a data cache is made.
					if (elem && value === undefined) {
	
						// Attempt to get data from the cache
						// with the key as-is
						data = dataUser.get(elem, key) ||
	
						// Try to find dashed key if it exists (gh-2779)
						// This is for 2.2.x only
						dataUser.get(elem, key.replace(rmultiDash, "-$&").toLowerCase());
	
						if (data !== undefined) {
							return data;
						}
	
						camelKey = jQuery.camelCase(key);
	
						// Attempt to get data from the cache
						// with the key camelized
						data = dataUser.get(elem, camelKey);
						if (data !== undefined) {
							return data;
						}
	
						// Attempt to "discover" the data in
						// HTML5 custom data-* attrs
						data = dataAttr(elem, camelKey, undefined);
						if (data !== undefined) {
							return data;
						}
	
						// We tried really hard, but the data doesn't exist.
						return;
					}
	
					// Set the data...
					camelKey = jQuery.camelCase(key);
					this.each(function () {
	
						// First, attempt to store a copy or reference of any
						// data that might've been store with a camelCased key.
						var data = dataUser.get(this, camelKey);
	
						// For HTML5 data-* attribute interop, we have to
						// store property names with dashes in a camelCase form.
						// This might not apply to all properties...*
						dataUser.set(this, camelKey, value);
	
						// *... In the case of properties that might _actually_
						// have dashes, we need to also store a copy of that
						// unchanged property.
						if (key.indexOf("-") > -1 && data !== undefined) {
							dataUser.set(this, key, value);
						}
					});
				}, null, value, arguments.length > 1, null, true);
			},
	
			removeData: function removeData(key) {
				return this.each(function () {
					dataUser.remove(this, key);
				});
			}
		});
	
		jQuery.extend({
			queue: function queue(elem, type, data) {
				var queue;
	
				if (elem) {
					type = (type || "fx") + "queue";
					queue = dataPriv.get(elem, type);
	
					// Speed up dequeue by getting out quickly if this is just a lookup
					if (data) {
						if (!queue || jQuery.isArray(data)) {
							queue = dataPriv.access(elem, type, jQuery.makeArray(data));
						} else {
							queue.push(data);
						}
					}
					return queue || [];
				}
			},
	
			dequeue: function dequeue(elem, type) {
				type = type || "fx";
	
				var queue = jQuery.queue(elem, type),
				    startLength = queue.length,
				    fn = queue.shift(),
				    hooks = jQuery._queueHooks(elem, type),
				    next = function next() {
					jQuery.dequeue(elem, type);
				};
	
				// If the fx queue is dequeued, always remove the progress sentinel
				if (fn === "inprogress") {
					fn = queue.shift();
					startLength--;
				}
	
				if (fn) {
	
					// Add a progress sentinel to prevent the fx queue from being
					// automatically dequeued
					if (type === "fx") {
						queue.unshift("inprogress");
					}
	
					// Clear up the last queue stop function
					delete hooks.stop;
					fn.call(elem, next, hooks);
				}
	
				if (!startLength && hooks) {
					hooks.empty.fire();
				}
			},
	
			// Not public - generate a queueHooks object, or return the current one
			_queueHooks: function _queueHooks(elem, type) {
				var key = type + "queueHooks";
				return dataPriv.get(elem, key) || dataPriv.access(elem, key, {
					empty: jQuery.Callbacks("once memory").add(function () {
						dataPriv.remove(elem, [type + "queue", key]);
					})
				});
			}
		});
	
		jQuery.fn.extend({
			queue: function queue(type, data) {
				var setter = 2;
	
				if (typeof type !== "string") {
					data = type;
					type = "fx";
					setter--;
				}
	
				if (arguments.length < setter) {
					return jQuery.queue(this[0], type);
				}
	
				return data === undefined ? this : this.each(function () {
					var queue = jQuery.queue(this, type, data);
	
					// Ensure a hooks for this queue
					jQuery._queueHooks(this, type);
	
					if (type === "fx" && queue[0] !== "inprogress") {
						jQuery.dequeue(this, type);
					}
				});
			},
			dequeue: function dequeue(type) {
				return this.each(function () {
					jQuery.dequeue(this, type);
				});
			},
			clearQueue: function clearQueue(type) {
				return this.queue(type || "fx", []);
			},
	
			// Get a promise resolved when queues of a certain type
			// are emptied (fx is the type by default)
			promise: function promise(type, obj) {
				var tmp,
				    count = 1,
				    defer = jQuery.Deferred(),
				    elements = this,
				    i = this.length,
				    resolve = function resolve() {
					if (! --count) {
						defer.resolveWith(elements, [elements]);
					}
				};
	
				if (typeof type !== "string") {
					obj = type;
					type = undefined;
				}
				type = type || "fx";
	
				while (i--) {
					tmp = dataPriv.get(elements[i], type + "queueHooks");
					if (tmp && tmp.empty) {
						count++;
						tmp.empty.add(resolve);
					}
				}
				resolve();
				return defer.promise(obj);
			}
		});
		var pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
	
		var rcssNum = new RegExp("^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i");
	
		var cssExpand = ["Top", "Right", "Bottom", "Left"];
	
		var isHidden = function isHidden(elem, el) {
	
			// isHidden might be called from jQuery#filter function;
			// in that case, element will be second argument
			elem = el || elem;
			return jQuery.css(elem, "display") === "none" || !jQuery.contains(elem.ownerDocument, elem);
		};
	
		function adjustCSS(elem, prop, valueParts, tween) {
			var adjusted,
			    scale = 1,
			    maxIterations = 20,
			    currentValue = tween ? function () {
				return tween.cur();
			} : function () {
				return jQuery.css(elem, prop, "");
			},
			    initial = currentValue(),
			    unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? "" : "px"),
	
	
			// Starting value computation is required for potential unit mismatches
			initialInUnit = (jQuery.cssNumber[prop] || unit !== "px" && +initial) && rcssNum.exec(jQuery.css(elem, prop));
	
			if (initialInUnit && initialInUnit[3] !== unit) {
	
				// Trust units reported by jQuery.css
				unit = unit || initialInUnit[3];
	
				// Make sure we update the tween properties later on
				valueParts = valueParts || [];
	
				// Iteratively approximate from a nonzero starting point
				initialInUnit = +initial || 1;
	
				do {
	
					// If previous iteration zeroed out, double until we get *something*.
					// Use string for doubling so we don't accidentally see scale as unchanged below
					scale = scale || ".5";
	
					// Adjust and apply
					initialInUnit = initialInUnit / scale;
					jQuery.style(elem, prop, initialInUnit + unit);
	
					// Update scale, tolerating zero or NaN from tween.cur()
					// Break the loop if scale is unchanged or perfect, or if we've just had enough.
				} while (scale !== (scale = currentValue() / initial) && scale !== 1 && --maxIterations);
			}
	
			if (valueParts) {
				initialInUnit = +initialInUnit || +initial || 0;
	
				// Apply relative offset (+=/-=) if specified
				adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2];
				if (tween) {
					tween.unit = unit;
					tween.start = initialInUnit;
					tween.end = adjusted;
				}
			}
			return adjusted;
		}
		var rcheckableType = /^(?:checkbox|radio)$/i;
	
		var rtagName = /<([\w:-]+)/;
	
		var rscriptType = /^$|\/(?:java|ecma)script/i;
	
		// We have to close these tags to support XHTML (#13200)
		var wrapMap = {
	
			// Support: IE9
			option: [1, "<select multiple='multiple'>", "</select>"],
	
			// XHTML parsers do not magically insert elements in the
			// same way that tag soup parsers do. So we cannot shorten
			// this by omitting <tbody> or other required elements.
			thead: [1, "<table>", "</table>"],
			col: [2, "<table><colgroup>", "</colgroup></table>"],
			tr: [2, "<table><tbody>", "</tbody></table>"],
			td: [3, "<table><tbody><tr>", "</tr></tbody></table>"],
	
			_default: [0, "", ""]
		};
	
		// Support: IE9
		wrapMap.optgroup = wrapMap.option;
	
		wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
		wrapMap.th = wrapMap.td;
	
		function getAll(context, tag) {
	
			// Support: IE9-11+
			// Use typeof to avoid zero-argument method invocation on host objects (#15151)
			var ret = typeof context.getElementsByTagName !== "undefined" ? context.getElementsByTagName(tag || "*") : typeof context.querySelectorAll !== "undefined" ? context.querySelectorAll(tag || "*") : [];
	
			return tag === undefined || tag && jQuery.nodeName(context, tag) ? jQuery.merge([context], ret) : ret;
		}
	
		// Mark scripts as having already been evaluated
		function setGlobalEval(elems, refElements) {
			var i = 0,
			    l = elems.length;
	
			for (; i < l; i++) {
				dataPriv.set(elems[i], "globalEval", !refElements || dataPriv.get(refElements[i], "globalEval"));
			}
		}
	
		var rhtml = /<|&#?\w+;/;
	
		function buildFragment(elems, context, scripts, selection, ignored) {
			var elem,
			    tmp,
			    tag,
			    wrap,
			    contains,
			    j,
			    fragment = context.createDocumentFragment(),
			    nodes = [],
			    i = 0,
			    l = elems.length;
	
			for (; i < l; i++) {
				elem = elems[i];
	
				if (elem || elem === 0) {
	
					// Add nodes directly
					if (jQuery.type(elem) === "object") {
	
						// Support: Android<4.1, PhantomJS<2
						// push.apply(_, arraylike) throws on ancient WebKit
						jQuery.merge(nodes, elem.nodeType ? [elem] : elem);
	
						// Convert non-html into a text node
					} else if (!rhtml.test(elem)) {
						nodes.push(context.createTextNode(elem));
	
						// Convert html into DOM nodes
					} else {
						tmp = tmp || fragment.appendChild(context.createElement("div"));
	
						// Deserialize a standard representation
						tag = (rtagName.exec(elem) || ["", ""])[1].toLowerCase();
						wrap = wrapMap[tag] || wrapMap._default;
						tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2];
	
						// Descend through wrappers to the right content
						j = wrap[0];
						while (j--) {
							tmp = tmp.lastChild;
						}
	
						// Support: Android<4.1, PhantomJS<2
						// push.apply(_, arraylike) throws on ancient WebKit
						jQuery.merge(nodes, tmp.childNodes);
	
						// Remember the top-level container
						tmp = fragment.firstChild;
	
						// Ensure the created nodes are orphaned (#12392)
						tmp.textContent = "";
					}
				}
			}
	
			// Remove wrapper from fragment
			fragment.textContent = "";
	
			i = 0;
			while (elem = nodes[i++]) {
	
				// Skip elements already in the context collection (trac-4087)
				if (selection && jQuery.inArray(elem, selection) > -1) {
					if (ignored) {
						ignored.push(elem);
					}
					continue;
				}
	
				contains = jQuery.contains(elem.ownerDocument, elem);
	
				// Append to fragment
				tmp = getAll(fragment.appendChild(elem), "script");
	
				// Preserve script evaluation history
				if (contains) {
					setGlobalEval(tmp);
				}
	
				// Capture executables
				if (scripts) {
					j = 0;
					while (elem = tmp[j++]) {
						if (rscriptType.test(elem.type || "")) {
							scripts.push(elem);
						}
					}
				}
			}
	
			return fragment;
		}
	
		(function () {
			var fragment = document.createDocumentFragment(),
			    div = fragment.appendChild(document.createElement("div")),
			    input = document.createElement("input");
	
			// Support: Android 4.0-4.3, Safari<=5.1
			// Check state lost if the name is set (#11217)
			// Support: Windows Web Apps (WWA)
			// `name` and `type` must use .setAttribute for WWA (#14901)
			input.setAttribute("type", "radio");
			input.setAttribute("checked", "checked");
			input.setAttribute("name", "t");
	
			div.appendChild(input);
	
			// Support: Safari<=5.1, Android<4.2
			// Older WebKit doesn't clone checked state correctly in fragments
			support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked;
	
			// Support: IE<=11+
			// Make sure textarea (and checkbox) defaultValue is properly cloned
			div.innerHTML = "<textarea>x</textarea>";
			support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue;
		})();
	
		var rkeyEvent = /^key/,
		    rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
		    rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
	
		function returnTrue() {
			return true;
		}
	
		function returnFalse() {
			return false;
		}
	
		// Support: IE9
		// See #13393 for more info
		function safeActiveElement() {
			try {
				return document.activeElement;
			} catch (err) {}
		}
	
		function _on(elem, types, selector, data, fn, one) {
			var origFn, type;
	
			// Types can be a map of types/handlers
			if ((typeof types === "undefined" ? "undefined" : _typeof(types)) === "object") {
	
				// ( types-Object, selector, data )
				if (typeof selector !== "string") {
	
					// ( types-Object, data )
					data = data || selector;
					selector = undefined;
				}
				for (type in types) {
					_on(elem, type, selector, data, types[type], one);
				}
				return elem;
			}
	
			if (data == null && fn == null) {
	
				// ( types, fn )
				fn = selector;
				data = selector = undefined;
			} else if (fn == null) {
				if (typeof selector === "string") {
	
					// ( types, selector, fn )
					fn = data;
					data = undefined;
				} else {
	
					// ( types, data, fn )
					fn = data;
					data = selector;
					selector = undefined;
				}
			}
			if (fn === false) {
				fn = returnFalse;
			} else if (!fn) {
				return elem;
			}
	
			if (one === 1) {
				origFn = fn;
				fn = function fn(event) {
	
					// Can use an empty set, since event contains the info
					jQuery().off(event);
					return origFn.apply(this, arguments);
				};
	
				// Use same guid so caller can remove using origFn
				fn.guid = origFn.guid || (origFn.guid = jQuery.guid++);
			}
			return elem.each(function () {
				jQuery.event.add(this, types, fn, data, selector);
			});
		}
	
		/*
	  * Helper functions for managing events -- not part of the public interface.
	  * Props to Dean Edwards' addEvent library for many of the ideas.
	  */
		jQuery.event = {
	
			global: {},
	
			add: function add(elem, types, handler, data, selector) {
	
				var handleObjIn,
				    eventHandle,
				    tmp,
				    events,
				    t,
				    handleObj,
				    special,
				    handlers,
				    type,
				    namespaces,
				    origType,
				    elemData = dataPriv.get(elem);
	
				// Don't attach events to noData or text/comment nodes (but allow plain objects)
				if (!elemData) {
					return;
				}
	
				// Caller can pass in an object of custom data in lieu of the handler
				if (handler.handler) {
					handleObjIn = handler;
					handler = handleObjIn.handler;
					selector = handleObjIn.selector;
				}
	
				// Make sure that the handler has a unique ID, used to find/remove it later
				if (!handler.guid) {
					handler.guid = jQuery.guid++;
				}
	
				// Init the element's event structure and main handler, if this is the first
				if (!(events = elemData.events)) {
					events = elemData.events = {};
				}
				if (!(eventHandle = elemData.handle)) {
					eventHandle = elemData.handle = function (e) {
	
						// Discard the second event of a jQuery.event.trigger() and
						// when an event is called after a page has unloaded
						return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(elem, arguments) : undefined;
					};
				}
	
				// Handle multiple events separated by a space
				types = (types || "").match(rnotwhite) || [""];
				t = types.length;
				while (t--) {
					tmp = rtypenamespace.exec(types[t]) || [];
					type = origType = tmp[1];
					namespaces = (tmp[2] || "").split(".").sort();
	
					// There *must* be a type, no attaching namespace-only handlers
					if (!type) {
						continue;
					}
	
					// If event changes its type, use the special event handlers for the changed type
					special = jQuery.event.special[type] || {};
	
					// If selector defined, determine special event api type, otherwise given type
					type = (selector ? special.delegateType : special.bindType) || type;
	
					// Update special based on newly reset type
					special = jQuery.event.special[type] || {};
	
					// handleObj is passed to all event handlers
					handleObj = jQuery.extend({
						type: type,
						origType: origType,
						data: data,
						handler: handler,
						guid: handler.guid,
						selector: selector,
						needsContext: selector && jQuery.expr.match.needsContext.test(selector),
						namespace: namespaces.join(".")
					}, handleObjIn);
	
					// Init the event handler queue if we're the first
					if (!(handlers = events[type])) {
						handlers = events[type] = [];
						handlers.delegateCount = 0;
	
						// Only use addEventListener if the special events handler returns false
						if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {
	
							if (elem.addEventListener) {
								elem.addEventListener(type, eventHandle);
							}
						}
					}
	
					if (special.add) {
						special.add.call(elem, handleObj);
	
						if (!handleObj.handler.guid) {
							handleObj.handler.guid = handler.guid;
						}
					}
	
					// Add to the element's handler list, delegates in front
					if (selector) {
						handlers.splice(handlers.delegateCount++, 0, handleObj);
					} else {
						handlers.push(handleObj);
					}
	
					// Keep track of which events have ever been used, for event optimization
					jQuery.event.global[type] = true;
				}
			},
	
			// Detach an event or set of events from an element
			remove: function remove(elem, types, handler, selector, mappedTypes) {
	
				var j,
				    origCount,
				    tmp,
				    events,
				    t,
				    handleObj,
				    special,
				    handlers,
				    type,
				    namespaces,
				    origType,
				    elemData = dataPriv.hasData(elem) && dataPriv.get(elem);
	
				if (!elemData || !(events = elemData.events)) {
					return;
				}
	
				// Once for each type.namespace in types; type may be omitted
				types = (types || "").match(rnotwhite) || [""];
				t = types.length;
				while (t--) {
					tmp = rtypenamespace.exec(types[t]) || [];
					type = origType = tmp[1];
					namespaces = (tmp[2] || "").split(".").sort();
	
					// Unbind all events (on this namespace, if provided) for the element
					if (!type) {
						for (type in events) {
							jQuery.event.remove(elem, type + types[t], handler, selector, true);
						}
						continue;
					}
	
					special = jQuery.event.special[type] || {};
					type = (selector ? special.delegateType : special.bindType) || type;
					handlers = events[type] || [];
					tmp = tmp[2] && new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)");
	
					// Remove matching events
					origCount = j = handlers.length;
					while (j--) {
						handleObj = handlers[j];
	
						if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === "**" && handleObj.selector)) {
							handlers.splice(j, 1);
	
							if (handleObj.selector) {
								handlers.delegateCount--;
							}
							if (special.remove) {
								special.remove.call(elem, handleObj);
							}
						}
					}
	
					// Remove generic event handler if we removed something and no more handlers exist
					// (avoids potential for endless recursion during removal of special event handlers)
					if (origCount && !handlers.length) {
						if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {
	
							jQuery.removeEvent(elem, type, elemData.handle);
						}
	
						delete events[type];
					}
				}
	
				// Remove data and the expando if it's no longer used
				if (jQuery.isEmptyObject(events)) {
					dataPriv.remove(elem, "handle events");
				}
			},
	
			dispatch: function dispatch(event) {
	
				// Make a writable jQuery.Event from the native event object
				event = jQuery.event.fix(event);
	
				var i,
				    j,
				    ret,
				    matched,
				    handleObj,
				    handlerQueue = [],
				    args = _slice.call(arguments),
				    handlers = (dataPriv.get(this, "events") || {})[event.type] || [],
				    special = jQuery.event.special[event.type] || {};
	
				// Use the fix-ed jQuery.Event rather than the (read-only) native event
				args[0] = event;
				event.delegateTarget = this;
	
				// Call the preDispatch hook for the mapped type, and let it bail if desired
				if (special.preDispatch && special.preDispatch.call(this, event) === false) {
					return;
				}
	
				// Determine handlers
				handlerQueue = jQuery.event.handlers.call(this, event, handlers);
	
				// Run delegates first; they may want to stop propagation beneath us
				i = 0;
				while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
					event.currentTarget = matched.elem;
	
					j = 0;
					while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {
	
						// Triggered event must either 1) have no namespace, or 2) have namespace(s)
						// a subset or equal to those in the bound event (both can have no namespace).
						if (!event.rnamespace || event.rnamespace.test(handleObj.namespace)) {
	
							event.handleObj = handleObj;
							event.data = handleObj.data;
	
							ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);
	
							if (ret !== undefined) {
								if ((event.result = ret) === false) {
									event.preventDefault();
									event.stopPropagation();
								}
							}
						}
					}
				}
	
				// Call the postDispatch hook for the mapped type
				if (special.postDispatch) {
					special.postDispatch.call(this, event);
				}
	
				return event.result;
			},
	
			handlers: function handlers(event, _handlers) {
				var i,
				    matches,
				    sel,
				    handleObj,
				    handlerQueue = [],
				    delegateCount = _handlers.delegateCount,
				    cur = event.target;
	
				// Support (at least): Chrome, IE9
				// Find delegate handlers
				// Black-hole SVG <use> instance trees (#13180)
				//
				// Support: Firefox<=42+
				// Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)
				if (delegateCount && cur.nodeType && (event.type !== "click" || isNaN(event.button) || event.button < 1)) {
	
					for (; cur !== this; cur = cur.parentNode || this) {
	
						// Don't check non-elements (#13208)
						// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
						if (cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click")) {
							matches = [];
							for (i = 0; i < delegateCount; i++) {
								handleObj = _handlers[i];
	
								// Don't conflict with Object.prototype properties (#13203)
								sel = handleObj.selector + " ";
	
								if (matches[sel] === undefined) {
									matches[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) > -1 : jQuery.find(sel, this, null, [cur]).length;
								}
								if (matches[sel]) {
									matches.push(handleObj);
								}
							}
							if (matches.length) {
								handlerQueue.push({ elem: cur, handlers: matches });
							}
						}
					}
				}
	
				// Add the remaining (directly-bound) handlers
				if (delegateCount < _handlers.length) {
					handlerQueue.push({ elem: this, handlers: _handlers.slice(delegateCount) });
				}
	
				return handlerQueue;
			},
	
			// Includes some event props shared by KeyEvent and MouseEvent
			props: ("altKey bubbles cancelable ctrlKey currentTarget detail eventPhase " + "metaKey relatedTarget shiftKey target timeStamp view which").split(" "),
	
			fixHooks: {},
	
			keyHooks: {
				props: "char charCode key keyCode".split(" "),
				filter: function filter(event, original) {
	
					// Add which for key events
					if (event.which == null) {
						event.which = original.charCode != null ? original.charCode : original.keyCode;
					}
	
					return event;
				}
			},
	
			mouseHooks: {
				props: ("button buttons clientX clientY offsetX offsetY pageX pageY " + "screenX screenY toElement").split(" "),
				filter: function filter(event, original) {
					var eventDoc,
					    doc,
					    body,
					    button = original.button;
	
					// Calculate pageX/Y if missing and clientX/Y available
					if (event.pageX == null && original.clientX != null) {
						eventDoc = event.target.ownerDocument || document;
						doc = eventDoc.documentElement;
						body = eventDoc.body;
	
						event.pageX = original.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
						event.pageY = original.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0);
					}
	
					// Add which for click: 1 === left; 2 === middle; 3 === right
					// Note: button is not normalized, so don't use it
					if (!event.which && button !== undefined) {
						event.which = button & 1 ? 1 : button & 2 ? 3 : button & 4 ? 2 : 0;
					}
	
					return event;
				}
			},
	
			fix: function fix(event) {
				if (event[jQuery.expando]) {
					return event;
				}
	
				// Create a writable copy of the event object and normalize some properties
				var i,
				    prop,
				    copy,
				    type = event.type,
				    originalEvent = event,
				    fixHook = this.fixHooks[type];
	
				if (!fixHook) {
					this.fixHooks[type] = fixHook = rmouseEvent.test(type) ? this.mouseHooks : rkeyEvent.test(type) ? this.keyHooks : {};
				}
				copy = fixHook.props ? this.props.concat(fixHook.props) : this.props;
	
				event = new jQuery.Event(originalEvent);
	
				i = copy.length;
				while (i--) {
					prop = copy[i];
					event[prop] = originalEvent[prop];
				}
	
				// Support: Cordova 2.5 (WebKit) (#13255)
				// All events should have a target; Cordova deviceready doesn't
				if (!event.target) {
					event.target = document;
				}
	
				// Support: Safari 6.0+, Chrome<28
				// Target should not be a text node (#504, #13143)
				if (event.target.nodeType === 3) {
					event.target = event.target.parentNode;
				}
	
				return fixHook.filter ? fixHook.filter(event, originalEvent) : event;
			},
	
			special: {
				load: {
	
					// Prevent triggered image.load events from bubbling to window.load
					noBubble: true
				},
				focus: {
	
					// Fire native event if possible so blur/focus sequence is correct
					trigger: function trigger() {
						if (this !== safeActiveElement() && this.focus) {
							this.focus();
							return false;
						}
					},
					delegateType: "focusin"
				},
				blur: {
					trigger: function trigger() {
						if (this === safeActiveElement() && this.blur) {
							this.blur();
							return false;
						}
					},
					delegateType: "focusout"
				},
				click: {
	
					// For checkbox, fire native event so checked state will be right
					trigger: function trigger() {
						if (this.type === "checkbox" && this.click && jQuery.nodeName(this, "input")) {
							this.click();
							return false;
						}
					},
	
					// For cross-browser consistency, don't fire native .click() on links
					_default: function _default(event) {
						return jQuery.nodeName(event.target, "a");
					}
				},
	
				beforeunload: {
					postDispatch: function postDispatch(event) {
	
						// Support: Firefox 20+
						// Firefox doesn't alert if the returnValue field is not set.
						if (event.result !== undefined && event.originalEvent) {
							event.originalEvent.returnValue = event.result;
						}
					}
				}
			}
		};
	
		jQuery.removeEvent = function (elem, type, handle) {
	
			// This "if" is needed for plain objects
			if (elem.removeEventListener) {
				elem.removeEventListener(type, handle);
			}
		};
	
		jQuery.Event = function (src, props) {
	
			// Allow instantiation without the 'new' keyword
			if (!(this instanceof jQuery.Event)) {
				return new jQuery.Event(src, props);
			}
	
			// Event object
			if (src && src.type) {
				this.originalEvent = src;
				this.type = src.type;
	
				// Events bubbling up the document may have been marked as prevented
				// by a handler lower down the tree; reflect the correct value.
				this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined &&
	
				// Support: Android<4.0
				src.returnValue === false ? returnTrue : returnFalse;
	
				// Event type
			} else {
				this.type = src;
			}
	
			// Put explicitly provided properties onto the event object
			if (props) {
				jQuery.extend(this, props);
			}
	
			// Create a timestamp if incoming event doesn't have one
			this.timeStamp = src && src.timeStamp || jQuery.now();
	
			// Mark it as fixed
			this[jQuery.expando] = true;
		};
	
		// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
		// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
		jQuery.Event.prototype = {
			constructor: jQuery.Event,
			isDefaultPrevented: returnFalse,
			isPropagationStopped: returnFalse,
			isImmediatePropagationStopped: returnFalse,
			isSimulated: false,
	
			preventDefault: function preventDefault() {
				var e = this.originalEvent;
	
				this.isDefaultPrevented = returnTrue;
	
				if (e && !this.isSimulated) {
					e.preventDefault();
				}
			},
			stopPropagation: function stopPropagation() {
				var e = this.originalEvent;
	
				this.isPropagationStopped = returnTrue;
	
				if (e && !this.isSimulated) {
					e.stopPropagation();
				}
			},
			stopImmediatePropagation: function stopImmediatePropagation() {
				var e = this.originalEvent;
	
				this.isImmediatePropagationStopped = returnTrue;
	
				if (e && !this.isSimulated) {
					e.stopImmediatePropagation();
				}
	
				this.stopPropagation();
			}
		};
	
		// Create mouseenter/leave events using mouseover/out and event-time checks
		// so that event delegation works in jQuery.
		// Do the same for pointerenter/pointerleave and pointerover/pointerout
		//
		// Support: Safari 7 only
		// Safari sends mouseenter too often; see:
		// https://code.google.com/p/chromium/issues/detail?id=470258
		// for the description of the bug (it existed in older Chrome versions as well).
		jQuery.each({
			mouseenter: "mouseover",
			mouseleave: "mouseout",
			pointerenter: "pointerover",
			pointerleave: "pointerout"
		}, function (orig, fix) {
			jQuery.event.special[orig] = {
				delegateType: fix,
				bindType: fix,
	
				handle: function handle(event) {
					var ret,
					    target = this,
					    related = event.relatedTarget,
					    handleObj = event.handleObj;
	
					// For mouseenter/leave call the handler if related is outside the target.
					// NB: No relatedTarget if the mouse left/entered the browser window
					if (!related || related !== target && !jQuery.contains(target, related)) {
						event.type = handleObj.origType;
						ret = handleObj.handler.apply(this, arguments);
						event.type = fix;
					}
					return ret;
				}
			};
		});
	
		jQuery.fn.extend({
			on: function on(types, selector, data, fn) {
				return _on(this, types, selector, data, fn);
			},
			one: function one(types, selector, data, fn) {
				return _on(this, types, selector, data, fn, 1);
			},
			off: function off(types, selector, fn) {
				var handleObj, type;
				if (types && types.preventDefault && types.handleObj) {
	
					// ( event )  dispatched jQuery.Event
					handleObj = types.handleObj;
					jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler);
					return this;
				}
				if ((typeof types === "undefined" ? "undefined" : _typeof(types)) === "object") {
	
					// ( types-object [, selector] )
					for (type in types) {
						this.off(type, selector, types[type]);
					}
					return this;
				}
				if (selector === false || typeof selector === "function") {
	
					// ( types [, fn] )
					fn = selector;
					selector = undefined;
				}
				if (fn === false) {
					fn = returnFalse;
				}
				return this.each(function () {
					jQuery.event.remove(this, types, fn, selector);
				});
			}
		});
	
		var rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,
	
	
		// Support: IE 10-11, Edge 10240+
		// In IE/Edge using regex groups here causes severe slowdowns.
		// See https://connect.microsoft.com/IE/feedback/details/1736512/
		rnoInnerhtml = /<script|<style|<link/i,
	
	
		// checked="checked" or checked
		rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
		    rscriptTypeMasked = /^true\/(.*)/,
		    rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
	
		// Manipulating tables requires a tbody
		function manipulationTarget(elem, content) {
			return jQuery.nodeName(elem, "table") && jQuery.nodeName(content.nodeType !== 11 ? content : content.firstChild, "tr") ? elem.getElementsByTagName("tbody")[0] || elem.appendChild(elem.ownerDocument.createElement("tbody")) : elem;
		}
	
		// Replace/restore the type attribute of script elements for safe DOM manipulation
		function disableScript(elem) {
			elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
			return elem;
		}
		function restoreScript(elem) {
			var match = rscriptTypeMasked.exec(elem.type);
	
			if (match) {
				elem.type = match[1];
			} else {
				elem.removeAttribute("type");
			}
	
			return elem;
		}
	
		function cloneCopyEvent(src, dest) {
			var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
	
			if (dest.nodeType !== 1) {
				return;
			}
	
			// 1. Copy private data: events, handlers, etc.
			if (dataPriv.hasData(src)) {
				pdataOld = dataPriv.access(src);
				pdataCur = dataPriv.set(dest, pdataOld);
				events = pdataOld.events;
	
				if (events) {
					delete pdataCur.handle;
					pdataCur.events = {};
	
					for (type in events) {
						for (i = 0, l = events[type].length; i < l; i++) {
							jQuery.event.add(dest, type, events[type][i]);
						}
					}
				}
			}
	
			// 2. Copy user data
			if (dataUser.hasData(src)) {
				udataOld = dataUser.access(src);
				udataCur = jQuery.extend({}, udataOld);
	
				dataUser.set(dest, udataCur);
			}
		}
	
		// Fix IE bugs, see support tests
		function fixInput(src, dest) {
			var nodeName = dest.nodeName.toLowerCase();
	
			// Fails to persist the checked state of a cloned checkbox or radio button.
			if (nodeName === "input" && rcheckableType.test(src.type)) {
				dest.checked = src.checked;
	
				// Fails to return the selected option to the default selected state when cloning options
			} else if (nodeName === "input" || nodeName === "textarea") {
				dest.defaultValue = src.defaultValue;
			}
		}
	
		function domManip(collection, args, callback, ignored) {
	
			// Flatten any nested arrays
			args = concat.apply([], args);
	
			var fragment,
			    first,
			    scripts,
			    hasScripts,
			    node,
			    doc,
			    i = 0,
			    l = collection.length,
			    iNoClone = l - 1,
			    value = args[0],
			    isFunction = jQuery.isFunction(value);
	
			// We can't cloneNode fragments that contain checked, in WebKit
			if (isFunction || l > 1 && typeof value === "string" && !support.checkClone && rchecked.test(value)) {
				return collection.each(function (index) {
					var self = collection.eq(index);
					if (isFunction) {
						args[0] = value.call(this, index, self.html());
					}
					domManip(self, args, callback, ignored);
				});
			}
	
			if (l) {
				fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);
				first = fragment.firstChild;
	
				if (fragment.childNodes.length === 1) {
					fragment = first;
				}
	
				// Require either new content or an interest in ignored elements to invoke the callback
				if (first || ignored) {
					scripts = jQuery.map(getAll(fragment, "script"), disableScript);
					hasScripts = scripts.length;
	
					// Use the original fragment for the last item
					// instead of the first because it can end up
					// being emptied incorrectly in certain situations (#8070).
					for (; i < l; i++) {
						node = fragment;
	
						if (i !== iNoClone) {
							node = jQuery.clone(node, true, true);
	
							// Keep references to cloned scripts for later restoration
							if (hasScripts) {
	
								// Support: Android<4.1, PhantomJS<2
								// push.apply(_, arraylike) throws on ancient WebKit
								jQuery.merge(scripts, getAll(node, "script"));
							}
						}
	
						callback.call(collection[i], node, i);
					}
	
					if (hasScripts) {
						doc = scripts[scripts.length - 1].ownerDocument;
	
						// Reenable scripts
						jQuery.map(scripts, restoreScript);
	
						// Evaluate executable scripts on first document insertion
						for (i = 0; i < hasScripts; i++) {
							node = scripts[i];
							if (rscriptType.test(node.type || "") && !dataPriv.access(node, "globalEval") && jQuery.contains(doc, node)) {
	
								if (node.src) {
	
									// Optional AJAX dependency, but won't run scripts if not present
									if (jQuery._evalUrl) {
										jQuery._evalUrl(node.src);
									}
								} else {
									jQuery.globalEval(node.textContent.replace(rcleanScript, ""));
								}
							}
						}
					}
				}
			}
	
			return collection;
		}
	
		function _remove(elem, selector, keepData) {
			var node,
			    nodes = selector ? jQuery.filter(selector, elem) : elem,
			    i = 0;
	
			for (; (node = nodes[i]) != null; i++) {
				if (!keepData && node.nodeType === 1) {
					jQuery.cleanData(getAll(node));
				}
	
				if (node.parentNode) {
					if (keepData && jQuery.contains(node.ownerDocument, node)) {
						setGlobalEval(getAll(node, "script"));
					}
					node.parentNode.removeChild(node);
				}
			}
	
			return elem;
		}
	
		jQuery.extend({
			htmlPrefilter: function htmlPrefilter(html) {
				return html.replace(rxhtmlTag, "<$1></$2>");
			},
	
			clone: function clone(elem, dataAndEvents, deepDataAndEvents) {
				var i,
				    l,
				    srcElements,
				    destElements,
				    clone = elem.cloneNode(true),
				    inPage = jQuery.contains(elem.ownerDocument, elem);
	
				// Fix IE cloning issues
				if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {
	
					// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
					destElements = getAll(clone);
					srcElements = getAll(elem);
	
					for (i = 0, l = srcElements.length; i < l; i++) {
						fixInput(srcElements[i], destElements[i]);
					}
				}
	
				// Copy the events from the original to the clone
				if (dataAndEvents) {
					if (deepDataAndEvents) {
						srcElements = srcElements || getAll(elem);
						destElements = destElements || getAll(clone);
	
						for (i = 0, l = srcElements.length; i < l; i++) {
							cloneCopyEvent(srcElements[i], destElements[i]);
						}
					} else {
						cloneCopyEvent(elem, clone);
					}
				}
	
				// Preserve script evaluation history
				destElements = getAll(clone, "script");
				if (destElements.length > 0) {
					setGlobalEval(destElements, !inPage && getAll(elem, "script"));
				}
	
				// Return the cloned set
				return clone;
			},
	
			cleanData: function cleanData(elems) {
				var data,
				    elem,
				    type,
				    special = jQuery.event.special,
				    i = 0;
	
				for (; (elem = elems[i]) !== undefined; i++) {
					if (acceptData(elem)) {
						if (data = elem[dataPriv.expando]) {
							if (data.events) {
								for (type in data.events) {
									if (special[type]) {
										jQuery.event.remove(elem, type);
	
										// This is a shortcut to avoid jQuery.event.remove's overhead
									} else {
										jQuery.removeEvent(elem, type, data.handle);
									}
								}
							}
	
							// Support: Chrome <= 35-45+
							// Assign undefined instead of using delete, see Data#remove
							elem[dataPriv.expando] = undefined;
						}
						if (elem[dataUser.expando]) {
	
							// Support: Chrome <= 35-45+
							// Assign undefined instead of using delete, see Data#remove
							elem[dataUser.expando] = undefined;
						}
					}
				}
			}
		});
	
		jQuery.fn.extend({
	
			// Keep domManip exposed until 3.0 (gh-2225)
			domManip: domManip,
	
			detach: function detach(selector) {
				return _remove(this, selector, true);
			},
	
			remove: function remove(selector) {
				return _remove(this, selector);
			},
	
			text: function text(value) {
				return access(this, function (value) {
					return value === undefined ? jQuery.text(this) : this.empty().each(function () {
						if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
							this.textContent = value;
						}
					});
				}, null, value, arguments.length);
			},
	
			append: function append() {
				return domManip(this, arguments, function (elem) {
					if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
						var target = manipulationTarget(this, elem);
						target.appendChild(elem);
					}
				});
			},
	
			prepend: function prepend() {
				return domManip(this, arguments, function (elem) {
					if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
						var target = manipulationTarget(this, elem);
						target.insertBefore(elem, target.firstChild);
					}
				});
			},
	
			before: function before() {
				return domManip(this, arguments, function (elem) {
					if (this.parentNode) {
						this.parentNode.insertBefore(elem, this);
					}
				});
			},
	
			after: function after() {
				return domManip(this, arguments, function (elem) {
					if (this.parentNode) {
						this.parentNode.insertBefore(elem, this.nextSibling);
					}
				});
			},
	
			empty: function empty() {
				var elem,
				    i = 0;
	
				for (; (elem = this[i]) != null; i++) {
					if (elem.nodeType === 1) {
	
						// Prevent memory leaks
						jQuery.cleanData(getAll(elem, false));
	
						// Remove any remaining nodes
						elem.textContent = "";
					}
				}
	
				return this;
			},
	
			clone: function clone(dataAndEvents, deepDataAndEvents) {
				dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
				deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
	
				return this.map(function () {
					return jQuery.clone(this, dataAndEvents, deepDataAndEvents);
				});
			},
	
			html: function html(value) {
				return access(this, function (value) {
					var elem = this[0] || {},
					    i = 0,
					    l = this.length;
	
					if (value === undefined && elem.nodeType === 1) {
						return elem.innerHTML;
					}
	
					// See if we can take a shortcut and just use innerHTML
					if (typeof value === "string" && !rnoInnerhtml.test(value) && !wrapMap[(rtagName.exec(value) || ["", ""])[1].toLowerCase()]) {
	
						value = jQuery.htmlPrefilter(value);
	
						try {
							for (; i < l; i++) {
								elem = this[i] || {};
	
								// Remove element nodes and prevent memory leaks
								if (elem.nodeType === 1) {
									jQuery.cleanData(getAll(elem, false));
									elem.innerHTML = value;
								}
							}
	
							elem = 0;
	
							// If using innerHTML throws an exception, use the fallback method
						} catch (e) {}
					}
	
					if (elem) {
						this.empty().append(value);
					}
				}, null, value, arguments.length);
			},
	
			replaceWith: function replaceWith() {
				var ignored = [];
	
				// Make the changes, replacing each non-ignored context element with the new content
				return domManip(this, arguments, function (elem) {
					var parent = this.parentNode;
	
					if (jQuery.inArray(this, ignored) < 0) {
						jQuery.cleanData(getAll(this));
						if (parent) {
							parent.replaceChild(elem, this);
						}
					}
	
					// Force callback invocation
				}, ignored);
			}
		});
	
		jQuery.each({
			appendTo: "append",
			prependTo: "prepend",
			insertBefore: "before",
			insertAfter: "after",
			replaceAll: "replaceWith"
		}, function (name, original) {
			jQuery.fn[name] = function (selector) {
				var elems,
				    ret = [],
				    insert = jQuery(selector),
				    last = insert.length - 1,
				    i = 0;
	
				for (; i <= last; i++) {
					elems = i === last ? this : this.clone(true);
					jQuery(insert[i])[original](elems);
	
					// Support: QtWebKit
					// .get() because push.apply(_, arraylike) throws
					push.apply(ret, elems.get());
				}
	
				return this.pushStack(ret);
			};
		});
	
		var iframe,
		    elemdisplay = {
	
			// Support: Firefox
			// We have to pre-define these values for FF (#10227)
			HTML: "block",
			BODY: "block"
		};
	
		/**
	  * Retrieve the actual display of a element
	  * @param {String} name nodeName of the element
	  * @param {Object} doc Document object
	  */
	
		// Called only from within defaultDisplay
		function actualDisplay(name, doc) {
			var elem = jQuery(doc.createElement(name)).appendTo(doc.body),
			    display = jQuery.css(elem[0], "display");
	
			// We don't have any data stored on the element,
			// so use "detach" method as fast way to get rid of the element
			elem.detach();
	
			return display;
		}
	
		/**
	  * Try to determine the default display value of an element
	  * @param {String} nodeName
	  */
		function defaultDisplay(nodeName) {
			var doc = document,
			    display = elemdisplay[nodeName];
	
			if (!display) {
				display = actualDisplay(nodeName, doc);
	
				// If the simple way fails, read from inside an iframe
				if (display === "none" || !display) {
	
					// Use the already-created iframe if possible
					iframe = (iframe || jQuery("<iframe frameborder='0' width='0' height='0'/>")).appendTo(doc.documentElement);
	
					// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
					doc = iframe[0].contentDocument;
	
					// Support: IE
					doc.write();
					doc.close();
	
					display = actualDisplay(nodeName, doc);
					iframe.detach();
				}
	
				// Store the correct default display
				elemdisplay[nodeName] = display;
			}
	
			return display;
		}
		var rmargin = /^margin/;
	
		var rnumnonpx = new RegExp("^(" + pnum + ")(?!px)[a-z%]+$", "i");
	
		var getStyles = function getStyles(elem) {
	
			// Support: IE<=11+, Firefox<=30+ (#15098, #14150)
			// IE throws on elements created in popups
			// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
			var view = elem.ownerDocument.defaultView;
	
			if (!view || !view.opener) {
				view = window;
			}
	
			return view.getComputedStyle(elem);
		};
	
		var swap = function swap(elem, options, callback, args) {
			var ret,
			    name,
			    old = {};
	
			// Remember the old values, and insert the new ones
			for (name in options) {
				old[name] = elem.style[name];
				elem.style[name] = options[name];
			}
	
			ret = callback.apply(elem, args || []);
	
			// Revert the old values
			for (name in options) {
				elem.style[name] = old[name];
			}
	
			return ret;
		};
	
		var documentElement = document.documentElement;
	
		(function () {
			var pixelPositionVal,
			    boxSizingReliableVal,
			    pixelMarginRightVal,
			    reliableMarginLeftVal,
			    container = document.createElement("div"),
			    div = document.createElement("div");
	
			// Finish early in limited (non-browser) environments
			if (!div.style) {
				return;
			}
	
			// Support: IE9-11+
			// Style of cloned element affects source element cloned (#8908)
			div.style.backgroundClip = "content-box";
			div.cloneNode(true).style.backgroundClip = "";
			support.clearCloneStyle = div.style.backgroundClip === "content-box";
	
			container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" + "padding:0;margin-top:1px;position:absolute";
			container.appendChild(div);
	
			// Executing both pixelPosition & boxSizingReliable tests require only one layout
			// so they're executed at the same time to save the second computation.
			function computeStyleTests() {
				div.style.cssText =
	
				// Support: Firefox<29, Android 2.3
				// Vendor-prefix box-sizing
				"-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;" + "position:relative;display:block;" + "margin:auto;border:1px;padding:1px;" + "top:1%;width:50%";
				div.innerHTML = "";
				documentElement.appendChild(container);
	
				var divStyle = window.getComputedStyle(div);
				pixelPositionVal = divStyle.top !== "1%";
				reliableMarginLeftVal = divStyle.marginLeft === "2px";
				boxSizingReliableVal = divStyle.width === "4px";
	
				// Support: Android 4.0 - 4.3 only
				// Some styles come back with percentage values, even though they shouldn't
				div.style.marginRight = "50%";
				pixelMarginRightVal = divStyle.marginRight === "4px";
	
				documentElement.removeChild(container);
			}
	
			jQuery.extend(support, {
				pixelPosition: function pixelPosition() {
	
					// This test is executed only once but we still do memoizing
					// since we can use the boxSizingReliable pre-computing.
					// No need to check if the test was already performed, though.
					computeStyleTests();
					return pixelPositionVal;
				},
				boxSizingReliable: function boxSizingReliable() {
					if (boxSizingReliableVal == null) {
						computeStyleTests();
					}
					return boxSizingReliableVal;
				},
				pixelMarginRight: function pixelMarginRight() {
	
					// Support: Android 4.0-4.3
					// We're checking for boxSizingReliableVal here instead of pixelMarginRightVal
					// since that compresses better and they're computed together anyway.
					if (boxSizingReliableVal == null) {
						computeStyleTests();
					}
					return pixelMarginRightVal;
				},
				reliableMarginLeft: function reliableMarginLeft() {
	
					// Support: IE <=8 only, Android 4.0 - 4.3 only, Firefox <=3 - 37
					if (boxSizingReliableVal == null) {
						computeStyleTests();
					}
					return reliableMarginLeftVal;
				},
				reliableMarginRight: function reliableMarginRight() {
	
					// Support: Android 2.3
					// Check if div with explicit width and no margin-right incorrectly
					// gets computed margin-right based on width of container. (#3333)
					// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
					// This support function is only executed once so no memoizing is needed.
					var ret,
					    marginDiv = div.appendChild(document.createElement("div"));
	
					// Reset CSS: box-sizing; display; margin; border; padding
					marginDiv.style.cssText = div.style.cssText =
	
					// Support: Android 2.3
					// Vendor-prefix box-sizing
					"-webkit-box-sizing:content-box;box-sizing:content-box;" + "display:block;margin:0;border:0;padding:0";
					marginDiv.style.marginRight = marginDiv.style.width = "0";
					div.style.width = "1px";
					documentElement.appendChild(container);
	
					ret = !parseFloat(window.getComputedStyle(marginDiv).marginRight);
	
					documentElement.removeChild(container);
					div.removeChild(marginDiv);
	
					return ret;
				}
			});
		})();
	
		function curCSS(elem, name, computed) {
			var width,
			    minWidth,
			    maxWidth,
			    ret,
			    style = elem.style;
	
			computed = computed || getStyles(elem);
			ret = computed ? computed.getPropertyValue(name) || computed[name] : undefined;
	
			// Support: Opera 12.1x only
			// Fall back to style even without computed
			// computed is undefined for elems on document fragments
			if ((ret === "" || ret === undefined) && !jQuery.contains(elem.ownerDocument, elem)) {
				ret = jQuery.style(elem, name);
			}
	
			// Support: IE9
			// getPropertyValue is only needed for .css('filter') (#12537)
			if (computed) {
	
				// A tribute to the "awesome hack by Dean Edwards"
				// Android Browser returns percentage for some values,
				// but width seems to be reliably pixels.
				// This is against the CSSOM draft spec:
				// http://dev.w3.org/csswg/cssom/#resolved-values
				if (!support.pixelMarginRight() && rnumnonpx.test(ret) && rmargin.test(name)) {
	
					// Remember the original values
					width = style.width;
					minWidth = style.minWidth;
					maxWidth = style.maxWidth;
	
					// Put in the new values to get a computed value out
					style.minWidth = style.maxWidth = style.width = ret;
					ret = computed.width;
	
					// Revert the changed values
					style.width = width;
					style.minWidth = minWidth;
					style.maxWidth = maxWidth;
				}
			}
	
			return ret !== undefined ?
	
			// Support: IE9-11+
			// IE returns zIndex value as an integer.
			ret + "" : ret;
		}
	
		function addGetHookIf(conditionFn, hookFn) {
	
			// Define the hook, we'll check on the first run if it's really needed.
			return {
				get: function get() {
					if (conditionFn()) {
	
						// Hook not needed (or it's not possible to use it due
						// to missing dependency), remove it.
						delete this.get;
						return;
					}
	
					// Hook needed; redefine it so that the support test is not executed again.
					return (this.get = hookFn).apply(this, arguments);
				}
			};
		}
	
		var
	
		// Swappable if display is none or starts with table
		// except "table", "table-cell", or "table-caption"
		// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
		rdisplayswap = /^(none|table(?!-c[ea]).+)/,
		    cssShow = { position: "absolute", visibility: "hidden", display: "block" },
		    cssNormalTransform = {
			letterSpacing: "0",
			fontWeight: "400"
		},
		    cssPrefixes = ["Webkit", "O", "Moz", "ms"],
		    emptyStyle = document.createElement("div").style;
	
		// Return a css property mapped to a potentially vendor prefixed property
		function vendorPropName(name) {
	
			// Shortcut for names that are not vendor prefixed
			if (name in emptyStyle) {
				return name;
			}
	
			// Check for vendor prefixed names
			var capName = name[0].toUpperCase() + name.slice(1),
			    i = cssPrefixes.length;
	
			while (i--) {
				name = cssPrefixes[i] + capName;
				if (name in emptyStyle) {
					return name;
				}
			}
		}
	
		function setPositiveNumber(elem, value, subtract) {
	
			// Any relative (+/-) values have already been
			// normalized at this point
			var matches = rcssNum.exec(value);
			return matches ?
	
			// Guard against undefined "subtract", e.g., when used as in cssHooks
			Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || "px") : value;
		}
	
		function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) {
			var i = extra === (isBorderBox ? "border" : "content") ?
	
			// If we already have the right measurement, avoid augmentation
			4 :
	
			// Otherwise initialize for horizontal or vertical properties
			name === "width" ? 1 : 0,
			    val = 0;
	
			for (; i < 4; i += 2) {
	
				// Both box models exclude margin, so add it if we want it
				if (extra === "margin") {
					val += jQuery.css(elem, extra + cssExpand[i], true, styles);
				}
	
				if (isBorderBox) {
	
					// border-box includes padding, so remove it if we want content
					if (extra === "content") {
						val -= jQuery.css(elem, "padding" + cssExpand[i], true, styles);
					}
	
					// At this point, extra isn't border nor margin, so remove border
					if (extra !== "margin") {
						val -= jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
					}
				} else {
	
					// At this point, extra isn't content, so add padding
					val += jQuery.css(elem, "padding" + cssExpand[i], true, styles);
	
					// At this point, extra isn't content nor padding, so add border
					if (extra !== "padding") {
						val += jQuery.css(elem, "border" + cssExpand[i] + "Width", true, styles);
					}
				}
			}
	
			return val;
		}
	
		function getWidthOrHeight(elem, name, extra) {
	
			// Start with offset property, which is equivalent to the border-box value
			var valueIsBorderBox = true,
			    val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
			    styles = getStyles(elem),
			    isBorderBox = jQuery.css(elem, "boxSizing", false, styles) === "border-box";
	
			// Some non-html elements return undefined for offsetWidth, so check for null/undefined
			// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
			// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
			if (val <= 0 || val == null) {
	
				// Fall back to computed then uncomputed css if necessary
				val = curCSS(elem, name, styles);
				if (val < 0 || val == null) {
					val = elem.style[name];
				}
	
				// Computed unit is not pixels. Stop here and return.
				if (rnumnonpx.test(val)) {
					return val;
				}
	
				// Check for style in case a browser which returns unreliable values
				// for getComputedStyle silently falls back to the reliable elem.style
				valueIsBorderBox = isBorderBox && (support.boxSizingReliable() || val === elem.style[name]);
	
				// Normalize "", auto, and prepare for extra
				val = parseFloat(val) || 0;
			}
	
			// Use the active box-sizing model to add/subtract irrelevant styles
			return val + augmentWidthOrHeight(elem, name, extra || (isBorderBox ? "border" : "content"), valueIsBorderBox, styles) + "px";
		}
	
		function showHide(elements, show) {
			var display,
			    elem,
			    hidden,
			    values = [],
			    index = 0,
			    length = elements.length;
	
			for (; index < length; index++) {
				elem = elements[index];
				if (!elem.style) {
					continue;
				}
	
				values[index] = dataPriv.get(elem, "olddisplay");
				display = elem.style.display;
				if (show) {
	
					// Reset the inline display of this element to learn if it is
					// being hidden by cascaded rules or not
					if (!values[index] && display === "none") {
						elem.style.display = "";
					}
	
					// Set elements which have been overridden with display: none
					// in a stylesheet to whatever the default browser style is
					// for such an element
					if (elem.style.display === "" && isHidden(elem)) {
						values[index] = dataPriv.access(elem, "olddisplay", defaultDisplay(elem.nodeName));
					}
				} else {
					hidden = isHidden(elem);
	
					if (display !== "none" || !hidden) {
						dataPriv.set(elem, "olddisplay", hidden ? display : jQuery.css(elem, "display"));
					}
				}
			}
	
			// Set the display of most of the elements in a second loop
			// to avoid the constant reflow
			for (index = 0; index < length; index++) {
				elem = elements[index];
				if (!elem.style) {
					continue;
				}
				if (!show || elem.style.display === "none" || elem.style.display === "") {
					elem.style.display = show ? values[index] || "" : "none";
				}
			}
	
			return elements;
		}
	
		jQuery.extend({
	
			// Add in style property hooks for overriding the default
			// behavior of getting and setting a style property
			cssHooks: {
				opacity: {
					get: function get(elem, computed) {
						if (computed) {
	
							// We should always get a number back from opacity
							var ret = curCSS(elem, "opacity");
							return ret === "" ? "1" : ret;
						}
					}
				}
			},
	
			// Don't automatically add "px" to these possibly-unitless properties
			cssNumber: {
				"animationIterationCount": true,
				"columnCount": true,
				"fillOpacity": true,
				"flexGrow": true,
				"flexShrink": true,
				"fontWeight": true,
				"lineHeight": true,
				"opacity": true,
				"order": true,
				"orphans": true,
				"widows": true,
				"zIndex": true,
				"zoom": true
			},
	
			// Add in properties whose names you wish to fix before
			// setting or getting the value
			cssProps: {
				"float": "cssFloat"
			},
	
			// Get and set the style property on a DOM Node
			style: function style(elem, name, value, extra) {
	
				// Don't set styles on text and comment nodes
				if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
					return;
				}
	
				// Make sure that we're working with the right name
				var ret,
				    type,
				    hooks,
				    origName = jQuery.camelCase(name),
				    style = elem.style;
	
				name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(origName) || origName);
	
				// Gets hook for the prefixed version, then unprefixed version
				hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
	
				// Check if we're setting a value
				if (value !== undefined) {
					type = typeof value === "undefined" ? "undefined" : _typeof(value);
	
					// Convert "+=" or "-=" to relative numbers (#7345)
					if (type === "string" && (ret = rcssNum.exec(value)) && ret[1]) {
						value = adjustCSS(elem, name, ret);
	
						// Fixes bug #9237
						type = "number";
					}
	
					// Make sure that null and NaN values aren't set (#7116)
					if (value == null || value !== value) {
						return;
					}
	
					// If a number was passed in, add the unit (except for certain CSS properties)
					if (type === "number") {
						value += ret && ret[3] || (jQuery.cssNumber[origName] ? "" : "px");
					}
	
					// Support: IE9-11+
					// background-* props affect original clone's values
					if (!support.clearCloneStyle && value === "" && name.indexOf("background") === 0) {
						style[name] = "inherit";
					}
	
					// If a hook was provided, use that value, otherwise just set the specified value
					if (!hooks || !("set" in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {
	
						style[name] = value;
					}
				} else {
	
					// If a hook was provided get the non-computed value from there
					if (hooks && "get" in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {
	
						return ret;
					}
	
					// Otherwise just get the value from the style object
					return style[name];
				}
			},
	
			css: function css(elem, name, extra, styles) {
				var val,
				    num,
				    hooks,
				    origName = jQuery.camelCase(name);
	
				// Make sure that we're working with the right name
				name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(origName) || origName);
	
				// Try prefixed name followed by the unprefixed name
				hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
	
				// If a hook was provided get the computed value from there
				if (hooks && "get" in hooks) {
					val = hooks.get(elem, true, extra);
				}
	
				// Otherwise, if a way to get the computed value exists, use that
				if (val === undefined) {
					val = curCSS(elem, name, styles);
				}
	
				// Convert "normal" to computed value
				if (val === "normal" && name in cssNormalTransform) {
					val = cssNormalTransform[name];
				}
	
				// Make numeric if forced or a qualifier was provided and val looks numeric
				if (extra === "" || extra) {
					num = parseFloat(val);
					return extra === true || isFinite(num) ? num || 0 : val;
				}
				return val;
			}
		});
	
		jQuery.each(["height", "width"], function (i, name) {
			jQuery.cssHooks[name] = {
				get: function get(elem, computed, extra) {
					if (computed) {
	
						// Certain elements can have dimension info if we invisibly show them
						// but it must have a current display style that would benefit
						return rdisplayswap.test(jQuery.css(elem, "display")) && elem.offsetWidth === 0 ? swap(elem, cssShow, function () {
							return getWidthOrHeight(elem, name, extra);
						}) : getWidthOrHeight(elem, name, extra);
					}
				},
	
				set: function set(elem, value, extra) {
					var matches,
					    styles = extra && getStyles(elem),
					    subtract = extra && augmentWidthOrHeight(elem, name, extra, jQuery.css(elem, "boxSizing", false, styles) === "border-box", styles);
	
					// Convert to pixels if value adjustment is needed
					if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || "px") !== "px") {
	
						elem.style[name] = value;
						value = jQuery.css(elem, name);
					}
	
					return setPositiveNumber(elem, value, subtract);
				}
			};
		});
	
		jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function (elem, computed) {
			if (computed) {
				return (parseFloat(curCSS(elem, "marginLeft")) || elem.getBoundingClientRect().left - swap(elem, { marginLeft: 0 }, function () {
					return elem.getBoundingClientRect().left;
				})) + "px";
			}
		});
	
		// Support: Android 2.3
		jQuery.cssHooks.marginRight = addGetHookIf(support.reliableMarginRight, function (elem, computed) {
			if (computed) {
				return swap(elem, { "display": "inline-block" }, curCSS, [elem, "marginRight"]);
			}
		});
	
		// These hooks are used by animate to expand properties
		jQuery.each({
			margin: "",
			padding: "",
			border: "Width"
		}, function (prefix, suffix) {
			jQuery.cssHooks[prefix + suffix] = {
				expand: function expand(value) {
					var i = 0,
					    expanded = {},
	
	
					// Assumes a single number if not a string
					parts = typeof value === "string" ? value.split(" ") : [value];
	
					for (; i < 4; i++) {
						expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0];
					}
	
					return expanded;
				}
			};
	
			if (!rmargin.test(prefix)) {
				jQuery.cssHooks[prefix + suffix].set = setPositiveNumber;
			}
		});
	
		jQuery.fn.extend({
			css: function css(name, value) {
				return access(this, function (elem, name, value) {
					var styles,
					    len,
					    map = {},
					    i = 0;
	
					if (jQuery.isArray(name)) {
						styles = getStyles(elem);
						len = name.length;
	
						for (; i < len; i++) {
							map[name[i]] = jQuery.css(elem, name[i], false, styles);
						}
	
						return map;
					}
	
					return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name);
				}, name, value, arguments.length > 1);
			},
			show: function show() {
				return showHide(this, true);
			},
			hide: function hide() {
				return showHide(this);
			},
			toggle: function toggle(state) {
				if (typeof state === "boolean") {
					return state ? this.show() : this.hide();
				}
	
				return this.each(function () {
					if (isHidden(this)) {
						jQuery(this).show();
					} else {
						jQuery(this).hide();
					}
				});
			}
		});
	
		function Tween(elem, options, prop, end, easing) {
			return new Tween.prototype.init(elem, options, prop, end, easing);
		}
		jQuery.Tween = Tween;
	
		Tween.prototype = {
			constructor: Tween,
			init: function init(elem, options, prop, end, easing, unit) {
				this.elem = elem;
				this.prop = prop;
				this.easing = easing || jQuery.easing._default;
				this.options = options;
				this.start = this.now = this.cur();
				this.end = end;
				this.unit = unit || (jQuery.cssNumber[prop] ? "" : "px");
			},
			cur: function cur() {
				var hooks = Tween.propHooks[this.prop];
	
				return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this);
			},
			run: function run(percent) {
				var eased,
				    hooks = Tween.propHooks[this.prop];
	
				if (this.options.duration) {
					this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration);
				} else {
					this.pos = eased = percent;
				}
				this.now = (this.end - this.start) * eased + this.start;
	
				if (this.options.step) {
					this.options.step.call(this.elem, this.now, this);
				}
	
				if (hooks && hooks.set) {
					hooks.set(this);
				} else {
					Tween.propHooks._default.set(this);
				}
				return this;
			}
		};
	
		Tween.prototype.init.prototype = Tween.prototype;
	
		Tween.propHooks = {
			_default: {
				get: function get(tween) {
					var result;
	
					// Use a property on the element directly when it is not a DOM element,
					// or when there is no matching style property that exists.
					if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) {
						return tween.elem[tween.prop];
					}
	
					// Passing an empty string as a 3rd parameter to .css will automatically
					// attempt a parseFloat and fallback to a string if the parse fails.
					// Simple values such as "10px" are parsed to Float;
					// complex values such as "rotate(1rad)" are returned as-is.
					result = jQuery.css(tween.elem, tween.prop, "");
	
					// Empty strings, null, undefined and "auto" are converted to 0.
					return !result || result === "auto" ? 0 : result;
				},
				set: function set(tween) {
	
					// Use step hook for back compat.
					// Use cssHook if its there.
					// Use .style if available and use plain properties where available.
					if (jQuery.fx.step[tween.prop]) {
						jQuery.fx.step[tween.prop](tween);
					} else if (tween.elem.nodeType === 1 && (tween.elem.style[jQuery.cssProps[tween.prop]] != null || jQuery.cssHooks[tween.prop])) {
						jQuery.style(tween.elem, tween.prop, tween.now + tween.unit);
					} else {
						tween.elem[tween.prop] = tween.now;
					}
				}
			}
		};
	
		// Support: IE9
		// Panic based approach to setting things on disconnected nodes
		Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
			set: function set(tween) {
				if (tween.elem.nodeType && tween.elem.parentNode) {
					tween.elem[tween.prop] = tween.now;
				}
			}
		};
	
		jQuery.easing = {
			linear: function linear(p) {
				return p;
			},
			swing: function swing(p) {
				return 0.5 - Math.cos(p * Math.PI) / 2;
			},
			_default: "swing"
		};
	
		jQuery.fx = Tween.prototype.init;
	
		// Back Compat <1.8 extension point
		jQuery.fx.step = {};
	
		var fxNow,
		    timerId,
		    rfxtypes = /^(?:toggle|show|hide)$/,
		    rrun = /queueHooks$/;
	
		// Animations created synchronously will run synchronously
		function createFxNow() {
			window.setTimeout(function () {
				fxNow = undefined;
			});
			return fxNow = jQuery.now();
		}
	
		// Generate parameters to create a standard animation
		function genFx(type, includeWidth) {
			var which,
			    i = 0,
			    attrs = { height: type };
	
			// If we include width, step value is 1 to do all cssExpand values,
			// otherwise step value is 2 to skip over Left and Right
			includeWidth = includeWidth ? 1 : 0;
			for (; i < 4; i += 2 - includeWidth) {
				which = cssExpand[i];
				attrs["margin" + which] = attrs["padding" + which] = type;
			}
	
			if (includeWidth) {
				attrs.opacity = attrs.width = type;
			}
	
			return attrs;
		}
	
		function createTween(value, prop, animation) {
			var tween,
			    collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners["*"]),
			    index = 0,
			    length = collection.length;
			for (; index < length; index++) {
				if (tween = collection[index].call(animation, prop, value)) {
	
					// We're done with this property
					return tween;
				}
			}
		}
	
		function defaultPrefilter(elem, props, opts) {
			/* jshint validthis: true */
			var prop,
			    value,
			    toggle,
			    tween,
			    hooks,
			    oldfire,
			    display,
			    checkDisplay,
			    anim = this,
			    orig = {},
			    style = elem.style,
			    hidden = elem.nodeType && isHidden(elem),
			    dataShow = dataPriv.get(elem, "fxshow");
	
			// Handle queue: false promises
			if (!opts.queue) {
				hooks = jQuery._queueHooks(elem, "fx");
				if (hooks.unqueued == null) {
					hooks.unqueued = 0;
					oldfire = hooks.empty.fire;
					hooks.empty.fire = function () {
						if (!hooks.unqueued) {
							oldfire();
						}
					};
				}
				hooks.unqueued++;
	
				anim.always(function () {
	
					// Ensure the complete handler is called before this completes
					anim.always(function () {
						hooks.unqueued--;
						if (!jQuery.queue(elem, "fx").length) {
							hooks.empty.fire();
						}
					});
				});
			}
	
			// Height/width overflow pass
			if (elem.nodeType === 1 && ("height" in props || "width" in props)) {
	
				// Make sure that nothing sneaks out
				// Record all 3 overflow attributes because IE9-10 do not
				// change the overflow attribute when overflowX and
				// overflowY are set to the same value
				opts.overflow = [style.overflow, style.overflowX, style.overflowY];
	
				// Set display property to inline-block for height/width
				// animations on inline elements that are having width/height animated
				display = jQuery.css(elem, "display");
	
				// Test default display if display is currently "none"
				checkDisplay = display === "none" ? dataPriv.get(elem, "olddisplay") || defaultDisplay(elem.nodeName) : display;
	
				if (checkDisplay === "inline" && jQuery.css(elem, "float") === "none") {
					style.display = "inline-block";
				}
			}
	
			if (opts.overflow) {
				style.overflow = "hidden";
				anim.always(function () {
					style.overflow = opts.overflow[0];
					style.overflowX = opts.overflow[1];
					style.overflowY = opts.overflow[2];
				});
			}
	
			// show/hide pass
			for (prop in props) {
				value = props[prop];
				if (rfxtypes.exec(value)) {
					delete props[prop];
					toggle = toggle || value === "toggle";
					if (value === (hidden ? "hide" : "show")) {
	
						// If there is dataShow left over from a stopped hide or show
						// and we are going to proceed with show, we should pretend to be hidden
						if (value === "show" && dataShow && dataShow[prop] !== undefined) {
							hidden = true;
						} else {
							continue;
						}
					}
					orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop);
	
					// Any non-fx value stops us from restoring the original display value
				} else {
					display = undefined;
				}
			}
	
			if (!jQuery.isEmptyObject(orig)) {
				if (dataShow) {
					if ("hidden" in dataShow) {
						hidden = dataShow.hidden;
					}
				} else {
					dataShow = dataPriv.access(elem, "fxshow", {});
				}
	
				// Store state if its toggle - enables .stop().toggle() to "reverse"
				if (toggle) {
					dataShow.hidden = !hidden;
				}
				if (hidden) {
					jQuery(elem).show();
				} else {
					anim.done(function () {
						jQuery(elem).hide();
					});
				}
				anim.done(function () {
					var prop;
	
					dataPriv.remove(elem, "fxshow");
					for (prop in orig) {
						jQuery.style(elem, prop, orig[prop]);
					}
				});
				for (prop in orig) {
					tween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
	
					if (!(prop in dataShow)) {
						dataShow[prop] = tween.start;
						if (hidden) {
							tween.end = tween.start;
							tween.start = prop === "width" || prop === "height" ? 1 : 0;
						}
					}
				}
	
				// If this is a noop like .hide().hide(), restore an overwritten display value
			} else if ((display === "none" ? defaultDisplay(elem.nodeName) : display) === "inline") {
				style.display = display;
			}
		}
	
		function propFilter(props, specialEasing) {
			var index, name, easing, value, hooks;
	
			// camelCase, specialEasing and expand cssHook pass
			for (index in props) {
				name = jQuery.camelCase(index);
				easing = specialEasing[name];
				value = props[index];
				if (jQuery.isArray(value)) {
					easing = value[1];
					value = props[index] = value[0];
				}
	
				if (index !== name) {
					props[name] = value;
					delete props[index];
				}
	
				hooks = jQuery.cssHooks[name];
				if (hooks && "expand" in hooks) {
					value = hooks.expand(value);
					delete props[name];
	
					// Not quite $.extend, this won't overwrite existing keys.
					// Reusing 'index' because we have the correct "name"
					for (index in value) {
						if (!(index in props)) {
							props[index] = value[index];
							specialEasing[index] = easing;
						}
					}
				} else {
					specialEasing[name] = easing;
				}
			}
		}
	
		function Animation(elem, properties, options) {
			var result,
			    stopped,
			    index = 0,
			    length = Animation.prefilters.length,
			    deferred = jQuery.Deferred().always(function () {
	
				// Don't match elem in the :animated selector
				delete tick.elem;
			}),
			    tick = function tick() {
				if (stopped) {
					return false;
				}
				var currentTime = fxNow || createFxNow(),
				    remaining = Math.max(0, animation.startTime + animation.duration - currentTime),
	
	
				// Support: Android 2.3
				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
				temp = remaining / animation.duration || 0,
				    percent = 1 - temp,
				    index = 0,
				    length = animation.tweens.length;
	
				for (; index < length; index++) {
					animation.tweens[index].run(percent);
				}
	
				deferred.notifyWith(elem, [animation, percent, remaining]);
	
				if (percent < 1 && length) {
					return remaining;
				} else {
					deferred.resolveWith(elem, [animation]);
					return false;
				}
			},
			    animation = deferred.promise({
				elem: elem,
				props: jQuery.extend({}, properties),
				opts: jQuery.extend(true, {
					specialEasing: {},
					easing: jQuery.easing._default
				}, options),
				originalProperties: properties,
				originalOptions: options,
				startTime: fxNow || createFxNow(),
				duration: options.duration,
				tweens: [],
				createTween: function createTween(prop, end) {
					var tween = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);
					animation.tweens.push(tween);
					return tween;
				},
				stop: function stop(gotoEnd) {
					var index = 0,
	
	
					// If we are going to the end, we want to run all the tweens
					// otherwise we skip this part
					length = gotoEnd ? animation.tweens.length : 0;
					if (stopped) {
						return this;
					}
					stopped = true;
					for (; index < length; index++) {
						animation.tweens[index].run(1);
					}
	
					// Resolve when we played the last frame; otherwise, reject
					if (gotoEnd) {
						deferred.notifyWith(elem, [animation, 1, 0]);
						deferred.resolveWith(elem, [animation, gotoEnd]);
					} else {
						deferred.rejectWith(elem, [animation, gotoEnd]);
					}
					return this;
				}
			}),
			    props = animation.props;
	
			propFilter(props, animation.opts.specialEasing);
	
			for (; index < length; index++) {
				result = Animation.prefilters[index].call(animation, elem, props, animation.opts);
				if (result) {
					if (jQuery.isFunction(result.stop)) {
						jQuery._queueHooks(animation.elem, animation.opts.queue).stop = jQuery.proxy(result.stop, result);
					}
					return result;
				}
			}
	
			jQuery.map(props, createTween, animation);
	
			if (jQuery.isFunction(animation.opts.start)) {
				animation.opts.start.call(elem, animation);
			}
	
			jQuery.fx.timer(jQuery.extend(tick, {
				elem: elem,
				anim: animation,
				queue: animation.opts.queue
			}));
	
			// attach callbacks from options
			return animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always);
		}
	
		jQuery.Animation = jQuery.extend(Animation, {
			tweeners: {
				"*": [function (prop, value) {
					var tween = this.createTween(prop, value);
					adjustCSS(tween.elem, prop, rcssNum.exec(value), tween);
					return tween;
				}]
			},
	
			tweener: function tweener(props, callback) {
				if (jQuery.isFunction(props)) {
					callback = props;
					props = ["*"];
				} else {
					props = props.match(rnotwhite);
				}
	
				var prop,
				    index = 0,
				    length = props.length;
	
				for (; index < length; index++) {
					prop = props[index];
					Animation.tweeners[prop] = Animation.tweeners[prop] || [];
					Animation.tweeners[prop].unshift(callback);
				}
			},
	
			prefilters: [defaultPrefilter],
	
			prefilter: function prefilter(callback, prepend) {
				if (prepend) {
					Animation.prefilters.unshift(callback);
				} else {
					Animation.prefilters.push(callback);
				}
			}
		});
	
		jQuery.speed = function (speed, easing, fn) {
			var opt = speed && (typeof speed === "undefined" ? "undefined" : _typeof(speed)) === "object" ? jQuery.extend({}, speed) : {
				complete: fn || !fn && easing || jQuery.isFunction(speed) && speed,
				duration: speed,
				easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
			};
	
			opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration : opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
	
			// Normalize opt.queue - true/undefined/null -> "fx"
			if (opt.queue == null || opt.queue === true) {
				opt.queue = "fx";
			}
	
			// Queueing
			opt.old = opt.complete;
	
			opt.complete = function () {
				if (jQuery.isFunction(opt.old)) {
					opt.old.call(this);
				}
	
				if (opt.queue) {
					jQuery.dequeue(this, opt.queue);
				}
			};
	
			return opt;
		};
	
		jQuery.fn.extend({
			fadeTo: function fadeTo(speed, to, easing, callback) {
	
				// Show any hidden elements after setting opacity to 0
				return this.filter(isHidden).css("opacity", 0).show()
	
				// Animate to the value specified
				.end().animate({ opacity: to }, speed, easing, callback);
			},
			animate: function animate(prop, speed, easing, callback) {
				var empty = jQuery.isEmptyObject(prop),
				    optall = jQuery.speed(speed, easing, callback),
				    doAnimation = function doAnimation() {
	
					// Operate on a copy of prop so per-property easing won't be lost
					var anim = Animation(this, jQuery.extend({}, prop), optall);
	
					// Empty animations, or finishing resolves immediately
					if (empty || dataPriv.get(this, "finish")) {
						anim.stop(true);
					}
				};
				doAnimation.finish = doAnimation;
	
				return empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation);
			},
			stop: function stop(type, clearQueue, gotoEnd) {
				var stopQueue = function stopQueue(hooks) {
					var stop = hooks.stop;
					delete hooks.stop;
					stop(gotoEnd);
				};
	
				if (typeof type !== "string") {
					gotoEnd = clearQueue;
					clearQueue = type;
					type = undefined;
				}
				if (clearQueue && type !== false) {
					this.queue(type || "fx", []);
				}
	
				return this.each(function () {
					var dequeue = true,
					    index = type != null && type + "queueHooks",
					    timers = jQuery.timers,
					    data = dataPriv.get(this);
	
					if (index) {
						if (data[index] && data[index].stop) {
							stopQueue(data[index]);
						}
					} else {
						for (index in data) {
							if (data[index] && data[index].stop && rrun.test(index)) {
								stopQueue(data[index]);
							}
						}
					}
	
					for (index = timers.length; index--;) {
						if (timers[index].elem === this && (type == null || timers[index].queue === type)) {
	
							timers[index].anim.stop(gotoEnd);
							dequeue = false;
							timers.splice(index, 1);
						}
					}
	
					// Start the next in the queue if the last step wasn't forced.
					// Timers currently will call their complete callbacks, which
					// will dequeue but only if they were gotoEnd.
					if (dequeue || !gotoEnd) {
						jQuery.dequeue(this, type);
					}
				});
			},
			finish: function finish(type) {
				if (type !== false) {
					type = type || "fx";
				}
				return this.each(function () {
					var index,
					    data = dataPriv.get(this),
					    queue = data[type + "queue"],
					    hooks = data[type + "queueHooks"],
					    timers = jQuery.timers,
					    length = queue ? queue.length : 0;
	
					// Enable finishing flag on private data
					data.finish = true;
	
					// Empty the queue first
					jQuery.queue(this, type, []);
	
					if (hooks && hooks.stop) {
						hooks.stop.call(this, true);
					}
	
					// Look for any active animations, and finish them
					for (index = timers.length; index--;) {
						if (timers[index].elem === this && timers[index].queue === type) {
							timers[index].anim.stop(true);
							timers.splice(index, 1);
						}
					}
	
					// Look for any animations in the old queue and finish them
					for (index = 0; index < length; index++) {
						if (queue[index] && queue[index].finish) {
							queue[index].finish.call(this);
						}
					}
	
					// Turn off finishing flag
					delete data.finish;
				});
			}
		});
	
		jQuery.each(["toggle", "show", "hide"], function (i, name) {
			var cssFn = jQuery.fn[name];
			jQuery.fn[name] = function (speed, easing, callback) {
				return speed == null || typeof speed === "boolean" ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), speed, easing, callback);
			};
		});
	
		// Generate shortcuts for custom animations
		jQuery.each({
			slideDown: genFx("show"),
			slideUp: genFx("hide"),
			slideToggle: genFx("toggle"),
			fadeIn: { opacity: "show" },
			fadeOut: { opacity: "hide" },
			fadeToggle: { opacity: "toggle" }
		}, function (name, props) {
			jQuery.fn[name] = function (speed, easing, callback) {
				return this.animate(props, speed, easing, callback);
			};
		});
	
		jQuery.timers = [];
		jQuery.fx.tick = function () {
			var timer,
			    i = 0,
			    timers = jQuery.timers;
	
			fxNow = jQuery.now();
	
			for (; i < timers.length; i++) {
				timer = timers[i];
	
				// Checks the timer has not already been removed
				if (!timer() && timers[i] === timer) {
					timers.splice(i--, 1);
				}
			}
	
			if (!timers.length) {
				jQuery.fx.stop();
			}
			fxNow = undefined;
		};
	
		jQuery.fx.timer = function (timer) {
			jQuery.timers.push(timer);
			if (timer()) {
				jQuery.fx.start();
			} else {
				jQuery.timers.pop();
			}
		};
	
		jQuery.fx.interval = 13;
		jQuery.fx.start = function () {
			if (!timerId) {
				timerId = window.setInterval(jQuery.fx.tick, jQuery.fx.interval);
			}
		};
	
		jQuery.fx.stop = function () {
			window.clearInterval(timerId);
	
			timerId = null;
		};
	
		jQuery.fx.speeds = {
			slow: 600,
			fast: 200,
	
			// Default speed
			_default: 400
		};
	
		// Based off of the plugin by Clint Helfers, with permission.
		// http://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
		jQuery.fn.delay = function (time, type) {
			time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
			type = type || "fx";
	
			return this.queue(type, function (next, hooks) {
				var timeout = window.setTimeout(next, time);
				hooks.stop = function () {
					window.clearTimeout(timeout);
				};
			});
		};
	
		(function () {
			var input = document.createElement("input"),
			    select = document.createElement("select"),
			    opt = select.appendChild(document.createElement("option"));
	
			input.type = "checkbox";
	
			// Support: iOS<=5.1, Android<=4.2+
			// Default value for a checkbox should be "on"
			support.checkOn = input.value !== "";
	
			// Support: IE<=11+
			// Must access selectedIndex to make default options select
			support.optSelected = opt.selected;
	
			// Support: Android<=2.3
			// Options inside disabled selects are incorrectly marked as disabled
			select.disabled = true;
			support.optDisabled = !opt.disabled;
	
			// Support: IE<=11+
			// An input loses its value after becoming a radio
			input = document.createElement("input");
			input.value = "t";
			input.type = "radio";
			support.radioValue = input.value === "t";
		})();
	
		var boolHook,
		    attrHandle = jQuery.expr.attrHandle;
	
		jQuery.fn.extend({
			attr: function attr(name, value) {
				return access(this, jQuery.attr, name, value, arguments.length > 1);
			},
	
			removeAttr: function removeAttr(name) {
				return this.each(function () {
					jQuery.removeAttr(this, name);
				});
			}
		});
	
		jQuery.extend({
			attr: function attr(elem, name, value) {
				var ret,
				    hooks,
				    nType = elem.nodeType;
	
				// Don't get/set attributes on text, comment and attribute nodes
				if (nType === 3 || nType === 8 || nType === 2) {
					return;
				}
	
				// Fallback to prop when attributes are not supported
				if (typeof elem.getAttribute === "undefined") {
					return jQuery.prop(elem, name, value);
				}
	
				// All attributes are lowercase
				// Grab necessary hook if one is defined
				if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
					name = name.toLowerCase();
					hooks = jQuery.attrHooks[name] || (jQuery.expr.match.bool.test(name) ? boolHook : undefined);
				}
	
				if (value !== undefined) {
					if (value === null) {
						jQuery.removeAttr(elem, name);
						return;
					}
	
					if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
						return ret;
					}
	
					elem.setAttribute(name, value + "");
					return value;
				}
	
				if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
					return ret;
				}
	
				ret = jQuery.find.attr(elem, name);
	
				// Non-existent attributes return null, we normalize to undefined
				return ret == null ? undefined : ret;
			},
	
			attrHooks: {
				type: {
					set: function set(elem, value) {
						if (!support.radioValue && value === "radio" && jQuery.nodeName(elem, "input")) {
							var val = elem.value;
							elem.setAttribute("type", value);
							if (val) {
								elem.value = val;
							}
							return value;
						}
					}
				}
			},
	
			removeAttr: function removeAttr(elem, value) {
				var name,
				    propName,
				    i = 0,
				    attrNames = value && value.match(rnotwhite);
	
				if (attrNames && elem.nodeType === 1) {
					while (name = attrNames[i++]) {
						propName = jQuery.propFix[name] || name;
	
						// Boolean attributes get special treatment (#10870)
						if (jQuery.expr.match.bool.test(name)) {
	
							// Set corresponding property to false
							elem[propName] = false;
						}
	
						elem.removeAttribute(name);
					}
				}
			}
		});
	
		// Hooks for boolean attributes
		boolHook = {
			set: function set(elem, value, name) {
				if (value === false) {
	
					// Remove boolean attributes when set to false
					jQuery.removeAttr(elem, name);
				} else {
					elem.setAttribute(name, name);
				}
				return name;
			}
		};
		jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function (i, name) {
			var getter = attrHandle[name] || jQuery.find.attr;
	
			attrHandle[name] = function (elem, name, isXML) {
				var ret, handle;
				if (!isXML) {
	
					// Avoid an infinite loop by temporarily removing this function from the getter
					handle = attrHandle[name];
					attrHandle[name] = ret;
					ret = getter(elem, name, isXML) != null ? name.toLowerCase() : null;
					attrHandle[name] = handle;
				}
				return ret;
			};
		});
	
		var rfocusable = /^(?:input|select|textarea|button)$/i,
		    rclickable = /^(?:a|area)$/i;
	
		jQuery.fn.extend({
			prop: function prop(name, value) {
				return access(this, jQuery.prop, name, value, arguments.length > 1);
			},
	
			removeProp: function removeProp(name) {
				return this.each(function () {
					delete this[jQuery.propFix[name] || name];
				});
			}
		});
	
		jQuery.extend({
			prop: function prop(elem, name, value) {
				var ret,
				    hooks,
				    nType = elem.nodeType;
	
				// Don't get/set properties on text, comment and attribute nodes
				if (nType === 3 || nType === 8 || nType === 2) {
					return;
				}
	
				if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
	
					// Fix name and attach hooks
					name = jQuery.propFix[name] || name;
					hooks = jQuery.propHooks[name];
				}
	
				if (value !== undefined) {
					if (hooks && "set" in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
						return ret;
					}
	
					return elem[name] = value;
				}
	
				if (hooks && "get" in hooks && (ret = hooks.get(elem, name)) !== null) {
					return ret;
				}
	
				return elem[name];
			},
	
			propHooks: {
				tabIndex: {
					get: function get(elem) {
	
						// elem.tabIndex doesn't always return the
						// correct value when it hasn't been explicitly set
						// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
						// Use proper attribute retrieval(#12072)
						var tabindex = jQuery.find.attr(elem, "tabindex");
	
						return tabindex ? parseInt(tabindex, 10) : rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href ? 0 : -1;
					}
				}
			},
	
			propFix: {
				"for": "htmlFor",
				"class": "className"
			}
		});
	
		// Support: IE <=11 only
		// Accessing the selectedIndex property
		// forces the browser to respect setting selected
		// on the option
		// The getter ensures a default option is selected
		// when in an optgroup
		if (!support.optSelected) {
			jQuery.propHooks.selected = {
				get: function get(elem) {
					var parent = elem.parentNode;
					if (parent && parent.parentNode) {
						parent.parentNode.selectedIndex;
					}
					return null;
				},
				set: function set(elem) {
					var parent = elem.parentNode;
					if (parent) {
						parent.selectedIndex;
	
						if (parent.parentNode) {
							parent.parentNode.selectedIndex;
						}
					}
				}
			};
		}
	
		jQuery.each(["tabIndex", "readOnly", "maxLength", "cellSpacing", "cellPadding", "rowSpan", "colSpan", "useMap", "frameBorder", "contentEditable"], function () {
			jQuery.propFix[this.toLowerCase()] = this;
		});
	
		var rclass = /[\t\r\n\f]/g;
	
		function getClass(elem) {
			return elem.getAttribute && elem.getAttribute("class") || "";
		}
	
		jQuery.fn.extend({
			addClass: function addClass(value) {
				var classes,
				    elem,
				    cur,
				    curValue,
				    clazz,
				    j,
				    finalValue,
				    i = 0;
	
				if (jQuery.isFunction(value)) {
					return this.each(function (j) {
						jQuery(this).addClass(value.call(this, j, getClass(this)));
					});
				}
	
				if (typeof value === "string" && value) {
					classes = value.match(rnotwhite) || [];
	
					while (elem = this[i++]) {
						curValue = getClass(elem);
						cur = elem.nodeType === 1 && (" " + curValue + " ").replace(rclass, " ");
	
						if (cur) {
							j = 0;
							while (clazz = classes[j++]) {
								if (cur.indexOf(" " + clazz + " ") < 0) {
									cur += clazz + " ";
								}
							}
	
							// Only assign if different to avoid unneeded rendering.
							finalValue = jQuery.trim(cur);
							if (curValue !== finalValue) {
								elem.setAttribute("class", finalValue);
							}
						}
					}
				}
	
				return this;
			},
	
			removeClass: function removeClass(value) {
				var classes,
				    elem,
				    cur,
				    curValue,
				    clazz,
				    j,
				    finalValue,
				    i = 0;
	
				if (jQuery.isFunction(value)) {
					return this.each(function (j) {
						jQuery(this).removeClass(value.call(this, j, getClass(this)));
					});
				}
	
				if (!arguments.length) {
					return this.attr("class", "");
				}
	
				if (typeof value === "string" && value) {
					classes = value.match(rnotwhite) || [];
	
					while (elem = this[i++]) {
						curValue = getClass(elem);
	
						// This expression is here for better compressibility (see addClass)
						cur = elem.nodeType === 1 && (" " + curValue + " ").replace(rclass, " ");
	
						if (cur) {
							j = 0;
							while (clazz = classes[j++]) {
	
								// Remove *all* instances
								while (cur.indexOf(" " + clazz + " ") > -1) {
									cur = cur.replace(" " + clazz + " ", " ");
								}
							}
	
							// Only assign if different to avoid unneeded rendering.
							finalValue = jQuery.trim(cur);
							if (curValue !== finalValue) {
								elem.setAttribute("class", finalValue);
							}
						}
					}
				}
	
				return this;
			},
	
			toggleClass: function toggleClass(value, stateVal) {
				var type = typeof value === "undefined" ? "undefined" : _typeof(value);
	
				if (typeof stateVal === "boolean" && type === "string") {
					return stateVal ? this.addClass(value) : this.removeClass(value);
				}
	
				if (jQuery.isFunction(value)) {
					return this.each(function (i) {
						jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal);
					});
				}
	
				return this.each(function () {
					var className, i, self, classNames;
	
					if (type === "string") {
	
						// Toggle individual class names
						i = 0;
						self = jQuery(this);
						classNames = value.match(rnotwhite) || [];
	
						while (className = classNames[i++]) {
	
							// Check each className given, space separated list
							if (self.hasClass(className)) {
								self.removeClass(className);
							} else {
								self.addClass(className);
							}
						}
	
						// Toggle whole class name
					} else if (value === undefined || type === "boolean") {
						className = getClass(this);
						if (className) {
	
							// Store className if set
							dataPriv.set(this, "__className__", className);
						}
	
						// If the element has a class name or if we're passed `false`,
						// then remove the whole classname (if there was one, the above saved it).
						// Otherwise bring back whatever was previously saved (if anything),
						// falling back to the empty string if nothing was stored.
						if (this.setAttribute) {
							this.setAttribute("class", className || value === false ? "" : dataPriv.get(this, "__className__") || "");
						}
					}
				});
			},
	
			hasClass: function hasClass(selector) {
				var className,
				    elem,
				    i = 0;
	
				className = " " + selector + " ";
				while (elem = this[i++]) {
					if (elem.nodeType === 1 && (" " + getClass(elem) + " ").replace(rclass, " ").indexOf(className) > -1) {
						return true;
					}
				}
	
				return false;
			}
		});
	
		var rreturn = /\r/g,
		    rspaces = /[\x20\t\r\n\f]+/g;
	
		jQuery.fn.extend({
			val: function val(value) {
				var hooks,
				    ret,
				    isFunction,
				    elem = this[0];
	
				if (!arguments.length) {
					if (elem) {
						hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];
	
						if (hooks && "get" in hooks && (ret = hooks.get(elem, "value")) !== undefined) {
							return ret;
						}
	
						ret = elem.value;
	
						return typeof ret === "string" ?
	
						// Handle most common string cases
						ret.replace(rreturn, "") :
	
						// Handle cases where value is null/undef or number
						ret == null ? "" : ret;
					}
	
					return;
				}
	
				isFunction = jQuery.isFunction(value);
	
				return this.each(function (i) {
					var val;
	
					if (this.nodeType !== 1) {
						return;
					}
	
					if (isFunction) {
						val = value.call(this, i, jQuery(this).val());
					} else {
						val = value;
					}
	
					// Treat null/undefined as ""; convert numbers to string
					if (val == null) {
						val = "";
					} else if (typeof val === "number") {
						val += "";
					} else if (jQuery.isArray(val)) {
						val = jQuery.map(val, function (value) {
							return value == null ? "" : value + "";
						});
					}
	
					hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];
	
					// If set returns undefined, fall back to normal setting
					if (!hooks || !("set" in hooks) || hooks.set(this, val, "value") === undefined) {
						this.value = val;
					}
				});
			}
		});
	
		jQuery.extend({
			valHooks: {
				option: {
					get: function get(elem) {
	
						var val = jQuery.find.attr(elem, "value");
						return val != null ? val :
	
						// Support: IE10-11+
						// option.text throws exceptions (#14686, #14858)
						// Strip and collapse whitespace
						// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
						jQuery.trim(jQuery.text(elem)).replace(rspaces, " ");
					}
				},
				select: {
					get: function get(elem) {
						var value,
						    option,
						    options = elem.options,
						    index = elem.selectedIndex,
						    one = elem.type === "select-one" || index < 0,
						    values = one ? null : [],
						    max = one ? index + 1 : options.length,
						    i = index < 0 ? max : one ? index : 0;
	
						// Loop through all the selected options
						for (; i < max; i++) {
							option = options[i];
	
							// IE8-9 doesn't update selected after form reset (#2551)
							if ((option.selected || i === index) && (
	
							// Don't return options that are disabled or in a disabled optgroup
							support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) && (!option.parentNode.disabled || !jQuery.nodeName(option.parentNode, "optgroup"))) {
	
								// Get the specific value for the option
								value = jQuery(option).val();
	
								// We don't need an array for one selects
								if (one) {
									return value;
								}
	
								// Multi-Selects return an array
								values.push(value);
							}
						}
	
						return values;
					},
	
					set: function set(elem, value) {
						var optionSet,
						    option,
						    options = elem.options,
						    values = jQuery.makeArray(value),
						    i = options.length;
	
						while (i--) {
							option = options[i];
							if (option.selected = jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1) {
								optionSet = true;
							}
						}
	
						// Force browsers to behave consistently when non-matching value is set
						if (!optionSet) {
							elem.selectedIndex = -1;
						}
						return values;
					}
				}
			}
		});
	
		// Radios and checkboxes getter/setter
		jQuery.each(["radio", "checkbox"], function () {
			jQuery.valHooks[this] = {
				set: function set(elem, value) {
					if (jQuery.isArray(value)) {
						return elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1;
					}
				}
			};
			if (!support.checkOn) {
				jQuery.valHooks[this].get = function (elem) {
					return elem.getAttribute("value") === null ? "on" : elem.value;
				};
			}
		});
	
		// Return jQuery for attributes-only inclusion
	
	
		var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
	
		jQuery.extend(jQuery.event, {
	
			trigger: function trigger(event, data, elem, onlyHandlers) {
	
				var i,
				    cur,
				    tmp,
				    bubbleType,
				    ontype,
				    handle,
				    special,
				    eventPath = [elem || document],
				    type = hasOwn.call(event, "type") ? event.type : event,
				    namespaces = hasOwn.call(event, "namespace") ? event.namespace.split(".") : [];
	
				cur = tmp = elem = elem || document;
	
				// Don't do events on text and comment nodes
				if (elem.nodeType === 3 || elem.nodeType === 8) {
					return;
				}
	
				// focus/blur morphs to focusin/out; ensure we're not firing them right now
				if (rfocusMorph.test(type + jQuery.event.triggered)) {
					return;
				}
	
				if (type.indexOf(".") > -1) {
	
					// Namespaced trigger; create a regexp to match event type in handle()
					namespaces = type.split(".");
					type = namespaces.shift();
					namespaces.sort();
				}
				ontype = type.indexOf(":") < 0 && "on" + type;
	
				// Caller can pass in a jQuery.Event object, Object, or just an event type string
				event = event[jQuery.expando] ? event : new jQuery.Event(type, (typeof event === "undefined" ? "undefined" : _typeof(event)) === "object" && event);
	
				// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
				event.isTrigger = onlyHandlers ? 2 : 3;
				event.namespace = namespaces.join(".");
				event.rnamespace = event.namespace ? new RegExp("(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)") : null;
	
				// Clean up the event in case it is being reused
				event.result = undefined;
				if (!event.target) {
					event.target = elem;
				}
	
				// Clone any incoming data and prepend the event, creating the handler arg list
				data = data == null ? [event] : jQuery.makeArray(data, [event]);
	
				// Allow special events to draw outside the lines
				special = jQuery.event.special[type] || {};
				if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
					return;
				}
	
				// Determine event propagation path in advance, per W3C events spec (#9951)
				// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
				if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {
	
					bubbleType = special.delegateType || type;
					if (!rfocusMorph.test(bubbleType + type)) {
						cur = cur.parentNode;
					}
					for (; cur; cur = cur.parentNode) {
						eventPath.push(cur);
						tmp = cur;
					}
	
					// Only add window if we got to document (e.g., not plain obj or detached DOM)
					if (tmp === (elem.ownerDocument || document)) {
						eventPath.push(tmp.defaultView || tmp.parentWindow || window);
					}
				}
	
				// Fire handlers on the event path
				i = 0;
				while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {
	
					event.type = i > 1 ? bubbleType : special.bindType || type;
	
					// jQuery handler
					handle = (dataPriv.get(cur, "events") || {})[event.type] && dataPriv.get(cur, "handle");
					if (handle) {
						handle.apply(cur, data);
					}
	
					// Native handler
					handle = ontype && cur[ontype];
					if (handle && handle.apply && acceptData(cur)) {
						event.result = handle.apply(cur, data);
						if (event.result === false) {
							event.preventDefault();
						}
					}
				}
				event.type = type;
	
				// If nobody prevented the default action, do it now
				if (!onlyHandlers && !event.isDefaultPrevented()) {
	
					if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) {
	
						// Call a native DOM method on the target with the same name name as the event.
						// Don't do default actions on window, that's where global variables be (#6170)
						if (ontype && jQuery.isFunction(elem[type]) && !jQuery.isWindow(elem)) {
	
							// Don't re-trigger an onFOO event when we call its FOO() method
							tmp = elem[ontype];
	
							if (tmp) {
								elem[ontype] = null;
							}
	
							// Prevent re-triggering of the same event, since we already bubbled it above
							jQuery.event.triggered = type;
							elem[type]();
							jQuery.event.triggered = undefined;
	
							if (tmp) {
								elem[ontype] = tmp;
							}
						}
					}
				}
	
				return event.result;
			},
	
			// Piggyback on a donor event to simulate a different one
			// Used only for `focus(in | out)` events
			simulate: function simulate(type, elem, event) {
				var e = jQuery.extend(new jQuery.Event(), event, {
					type: type,
					isSimulated: true
				});
	
				jQuery.event.trigger(e, null, elem);
			}
	
		});
	
		jQuery.fn.extend({
	
			trigger: function trigger(type, data) {
				return this.each(function () {
					jQuery.event.trigger(type, data, this);
				});
			},
			triggerHandler: function triggerHandler(type, data) {
				var elem = this[0];
				if (elem) {
					return jQuery.event.trigger(type, data, elem, true);
				}
			}
		});
	
		jQuery.each(("blur focus focusin focusout load resize scroll unload click dblclick " + "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + "change select submit keydown keypress keyup error contextmenu").split(" "), function (i, name) {
	
			// Handle event binding
			jQuery.fn[name] = function (data, fn) {
				return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name);
			};
		});
	
		jQuery.fn.extend({
			hover: function hover(fnOver, fnOut) {
				return this.mouseenter(fnOver).mouseleave(fnOut || fnOver);
			}
		});
	
		support.focusin = "onfocusin" in window;
	
		// Support: Firefox
		// Firefox doesn't have focus(in | out) events
		// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
		//
		// Support: Chrome, Safari
		// focus(in | out) events fire after focus & blur events,
		// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
		// Related ticket - https://code.google.com/p/chromium/issues/detail?id=449857
		if (!support.focusin) {
			jQuery.each({ focus: "focusin", blur: "focusout" }, function (orig, fix) {
	
				// Attach a single capturing handler on the document while someone wants focusin/focusout
				var handler = function handler(event) {
					jQuery.event.simulate(fix, event.target, jQuery.event.fix(event));
				};
	
				jQuery.event.special[fix] = {
					setup: function setup() {
						var doc = this.ownerDocument || this,
						    attaches = dataPriv.access(doc, fix);
	
						if (!attaches) {
							doc.addEventListener(orig, handler, true);
						}
						dataPriv.access(doc, fix, (attaches || 0) + 1);
					},
					teardown: function teardown() {
						var doc = this.ownerDocument || this,
						    attaches = dataPriv.access(doc, fix) - 1;
	
						if (!attaches) {
							doc.removeEventListener(orig, handler, true);
							dataPriv.remove(doc, fix);
						} else {
							dataPriv.access(doc, fix, attaches);
						}
					}
				};
			});
		}
		var location = window.location;
	
		var nonce = jQuery.now();
	
		var rquery = /\?/;
	
		// Support: Android 2.3
		// Workaround failure to string-cast null input
		jQuery.parseJSON = function (data) {
			return JSON.parse(data + "");
		};
	
		// Cross-browser xml parsing
		jQuery.parseXML = function (data) {
			var xml;
			if (!data || typeof data !== "string") {
				return null;
			}
	
			// Support: IE9
			try {
				xml = new window.DOMParser().parseFromString(data, "text/xml");
			} catch (e) {
				xml = undefined;
			}
	
			if (!xml || xml.getElementsByTagName("parsererror").length) {
				jQuery.error("Invalid XML: " + data);
			}
			return xml;
		};
	
		var rhash = /#.*$/,
		    rts = /([?&])_=[^&]*/,
		    rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
	
	
		// #7653, #8125, #8152: local protocol detection
		rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
		    rnoContent = /^(?:GET|HEAD)$/,
		    rprotocol = /^\/\//,
	
	
		/* Prefilters
	  * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
	  * 2) These are called:
	  *    - BEFORE asking for a transport
	  *    - AFTER param serialization (s.data is a string if s.processData is true)
	  * 3) key is the dataType
	  * 4) the catchall symbol "*" can be used
	  * 5) execution will start with transport dataType and THEN continue down to "*" if needed
	  */
		prefilters = {},
	
	
		/* Transports bindings
	  * 1) key is the dataType
	  * 2) the catchall symbol "*" can be used
	  * 3) selection will start with transport dataType and THEN go to "*" if needed
	  */
		transports = {},
	
	
		// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
		allTypes = "*/".concat("*"),
	
	
		// Anchor tag for parsing the document origin
		originAnchor = document.createElement("a");
		originAnchor.href = location.href;
	
		// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
		function addToPrefiltersOrTransports(structure) {
	
			// dataTypeExpression is optional and defaults to "*"
			return function (dataTypeExpression, func) {
	
				if (typeof dataTypeExpression !== "string") {
					func = dataTypeExpression;
					dataTypeExpression = "*";
				}
	
				var dataType,
				    i = 0,
				    dataTypes = dataTypeExpression.toLowerCase().match(rnotwhite) || [];
	
				if (jQuery.isFunction(func)) {
	
					// For each dataType in the dataTypeExpression
					while (dataType = dataTypes[i++]) {
	
						// Prepend if requested
						if (dataType[0] === "+") {
							dataType = dataType.slice(1) || "*";
							(structure[dataType] = structure[dataType] || []).unshift(func);
	
							// Otherwise append
						} else {
							(structure[dataType] = structure[dataType] || []).push(func);
						}
					}
				}
			};
		}
	
		// Base inspection function for prefilters and transports
		function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
	
			var inspected = {},
			    seekingTransport = structure === transports;
	
			function inspect(dataType) {
				var selected;
				inspected[dataType] = true;
				jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) {
					var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
					if (typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[dataTypeOrTransport]) {
	
						options.dataTypes.unshift(dataTypeOrTransport);
						inspect(dataTypeOrTransport);
						return false;
					} else if (seekingTransport) {
						return !(selected = dataTypeOrTransport);
					}
				});
				return selected;
			}
	
			return inspect(options.dataTypes[0]) || !inspected["*"] && inspect("*");
		}
	
		// A special extend for ajax options
		// that takes "flat" options (not to be deep extended)
		// Fixes #9887
		function ajaxExtend(target, src) {
			var key,
			    deep,
			    flatOptions = jQuery.ajaxSettings.flatOptions || {};
	
			for (key in src) {
				if (src[key] !== undefined) {
					(flatOptions[key] ? target : deep || (deep = {}))[key] = src[key];
				}
			}
			if (deep) {
				jQuery.extend(true, target, deep);
			}
	
			return target;
		}
	
		/* Handles responses to an ajax request:
	  * - finds the right dataType (mediates between content-type and expected dataType)
	  * - returns the corresponding response
	  */
		function ajaxHandleResponses(s, jqXHR, responses) {
	
			var ct,
			    type,
			    finalDataType,
			    firstDataType,
			    contents = s.contents,
			    dataTypes = s.dataTypes;
	
			// Remove auto dataType and get content-type in the process
			while (dataTypes[0] === "*") {
				dataTypes.shift();
				if (ct === undefined) {
					ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
				}
			}
	
			// Check if we're dealing with a known content-type
			if (ct) {
				for (type in contents) {
					if (contents[type] && contents[type].test(ct)) {
						dataTypes.unshift(type);
						break;
					}
				}
			}
	
			// Check to see if we have a response for the expected dataType
			if (dataTypes[0] in responses) {
				finalDataType = dataTypes[0];
			} else {
	
				// Try convertible dataTypes
				for (type in responses) {
					if (!dataTypes[0] || s.converters[type + " " + dataTypes[0]]) {
						finalDataType = type;
						break;
					}
					if (!firstDataType) {
						firstDataType = type;
					}
				}
	
				// Or just use first one
				finalDataType = finalDataType || firstDataType;
			}
	
			// If we found a dataType
			// We add the dataType to the list if needed
			// and return the corresponding response
			if (finalDataType) {
				if (finalDataType !== dataTypes[0]) {
					dataTypes.unshift(finalDataType);
				}
				return responses[finalDataType];
			}
		}
	
		/* Chain conversions given the request and the original response
	  * Also sets the responseXXX fields on the jqXHR instance
	  */
		function ajaxConvert(s, response, jqXHR, isSuccess) {
			var conv2,
			    current,
			    conv,
			    tmp,
			    prev,
			    converters = {},
	
	
			// Work with a copy of dataTypes in case we need to modify it for conversion
			dataTypes = s.dataTypes.slice();
	
			// Create converters map with lowercased keys
			if (dataTypes[1]) {
				for (conv in s.converters) {
					converters[conv.toLowerCase()] = s.converters[conv];
				}
			}
	
			current = dataTypes.shift();
	
			// Convert to each sequential dataType
			while (current) {
	
				if (s.responseFields[current]) {
					jqXHR[s.responseFields[current]] = response;
				}
	
				// Apply the dataFilter if provided
				if (!prev && isSuccess && s.dataFilter) {
					response = s.dataFilter(response, s.dataType);
				}
	
				prev = current;
				current = dataTypes.shift();
	
				if (current) {
	
					// There's only work to do if current dataType is non-auto
					if (current === "*") {
	
						current = prev;
	
						// Convert response if prev dataType is non-auto and differs from current
					} else if (prev !== "*" && prev !== current) {
	
						// Seek a direct converter
						conv = converters[prev + " " + current] || converters["* " + current];
	
						// If none found, seek a pair
						if (!conv) {
							for (conv2 in converters) {
	
								// If conv2 outputs current
								tmp = conv2.split(" ");
								if (tmp[1] === current) {
	
									// If prev can be converted to accepted input
									conv = converters[prev + " " + tmp[0]] || converters["* " + tmp[0]];
									if (conv) {
	
										// Condense equivalence converters
										if (conv === true) {
											conv = converters[conv2];
	
											// Otherwise, insert the intermediate dataType
										} else if (converters[conv2] !== true) {
											current = tmp[0];
											dataTypes.unshift(tmp[1]);
										}
										break;
									}
								}
							}
						}
	
						// Apply converter (if not an equivalence)
						if (conv !== true) {
	
							// Unless errors are allowed to bubble, catch and return them
							if (conv && s.throws) {
								response = conv(response);
							} else {
								try {
									response = conv(response);
								} catch (e) {
									return {
										state: "parsererror",
										error: conv ? e : "No conversion from " + prev + " to " + current
									};
								}
							}
						}
					}
				}
			}
	
			return { state: "success", data: response };
		}
	
		jQuery.extend({
	
			// Counter for holding the number of active queries
			active: 0,
	
			// Last-Modified header cache for next request
			lastModified: {},
			etag: {},
	
			ajaxSettings: {
				url: location.href,
				type: "GET",
				isLocal: rlocalProtocol.test(location.protocol),
				global: true,
				processData: true,
				async: true,
				contentType: "application/x-www-form-urlencoded; charset=UTF-8",
				/*
	   timeout: 0,
	   data: null,
	   dataType: null,
	   username: null,
	   password: null,
	   cache: null,
	   throws: false,
	   traditional: false,
	   headers: {},
	   */
	
				accepts: {
					"*": allTypes,
					text: "text/plain",
					html: "text/html",
					xml: "application/xml, text/xml",
					json: "application/json, text/javascript"
				},
	
				contents: {
					xml: /\bxml\b/,
					html: /\bhtml/,
					json: /\bjson\b/
				},
	
				responseFields: {
					xml: "responseXML",
					text: "responseText",
					json: "responseJSON"
				},
	
				// Data converters
				// Keys separate source (or catchall "*") and destination types with a single space
				converters: {
	
					// Convert anything to text
					"* text": String,
	
					// Text to html (true = no transformation)
					"text html": true,
	
					// Evaluate text as a json expression
					"text json": jQuery.parseJSON,
	
					// Parse text as xml
					"text xml": jQuery.parseXML
				},
	
				// For options that shouldn't be deep extended:
				// you can add your own custom options here if
				// and when you create one that shouldn't be
				// deep extended (see ajaxExtend)
				flatOptions: {
					url: true,
					context: true
				}
			},
	
			// Creates a full fledged settings object into target
			// with both ajaxSettings and settings fields.
			// If target is omitted, writes into ajaxSettings.
			ajaxSetup: function ajaxSetup(target, settings) {
				return settings ?
	
				// Building a settings object
				ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) :
	
				// Extending ajaxSettings
				ajaxExtend(jQuery.ajaxSettings, target);
			},
	
			ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
			ajaxTransport: addToPrefiltersOrTransports(transports),
	
			// Main method
			ajax: function ajax(url, options) {
	
				// If url is an object, simulate pre-1.5 signature
				if ((typeof url === "undefined" ? "undefined" : _typeof(url)) === "object") {
					options = url;
					url = undefined;
				}
	
				// Force options to be an object
				options = options || {};
	
				var transport,
	
	
				// URL without anti-cache param
				cacheURL,
	
	
				// Response headers
				responseHeadersString,
				    responseHeaders,
	
	
				// timeout handle
				timeoutTimer,
	
	
				// Url cleanup var
				urlAnchor,
	
	
				// To know if global events are to be dispatched
				fireGlobals,
	
	
				// Loop variable
				i,
	
	
				// Create the final options object
				s = jQuery.ajaxSetup({}, options),
	
	
				// Callbacks context
				callbackContext = s.context || s,
	
	
				// Context for global events is callbackContext if it is a DOM node or jQuery collection
				globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) : jQuery.event,
	
	
				// Deferreds
				deferred = jQuery.Deferred(),
				    completeDeferred = jQuery.Callbacks("once memory"),
	
	
				// Status-dependent callbacks
				_statusCode = s.statusCode || {},
	
	
				// Headers (they are sent all at once)
				requestHeaders = {},
				    requestHeadersNames = {},
	
	
				// The jqXHR state
				state = 0,
	
	
				// Default abort message
				strAbort = "canceled",
	
	
				// Fake xhr
				jqXHR = {
					readyState: 0,
	
					// Builds headers hashtable if needed
					getResponseHeader: function getResponseHeader(key) {
						var match;
						if (state === 2) {
							if (!responseHeaders) {
								responseHeaders = {};
								while (match = rheaders.exec(responseHeadersString)) {
									responseHeaders[match[1].toLowerCase()] = match[2];
								}
							}
							match = responseHeaders[key.toLowerCase()];
						}
						return match == null ? null : match;
					},
	
					// Raw string
					getAllResponseHeaders: function getAllResponseHeaders() {
						return state === 2 ? responseHeadersString : null;
					},
	
					// Caches the header
					setRequestHeader: function setRequestHeader(name, value) {
						var lname = name.toLowerCase();
						if (!state) {
							name = requestHeadersNames[lname] = requestHeadersNames[lname] || name;
							requestHeaders[name] = value;
						}
						return this;
					},
	
					// Overrides response content-type header
					overrideMimeType: function overrideMimeType(type) {
						if (!state) {
							s.mimeType = type;
						}
						return this;
					},
	
					// Status-dependent callbacks
					statusCode: function statusCode(map) {
						var code;
						if (map) {
							if (state < 2) {
								for (code in map) {
	
									// Lazy-add the new callback in a way that preserves old ones
									_statusCode[code] = [_statusCode[code], map[code]];
								}
							} else {
	
								// Execute the appropriate callbacks
								jqXHR.always(map[jqXHR.status]);
							}
						}
						return this;
					},
	
					// Cancel the request
					abort: function abort(statusText) {
						var finalText = statusText || strAbort;
						if (transport) {
							transport.abort(finalText);
						}
						done(0, finalText);
						return this;
					}
				};
	
				// Attach deferreds
				deferred.promise(jqXHR).complete = completeDeferred.add;
				jqXHR.success = jqXHR.done;
				jqXHR.error = jqXHR.fail;
	
				// Remove hash character (#7531: and string promotion)
				// Add protocol if not provided (prefilters might expect it)
				// Handle falsy url in the settings object (#10093: consistency with old signature)
				// We also use the url parameter if available
				s.url = ((url || s.url || location.href) + "").replace(rhash, "").replace(rprotocol, location.protocol + "//");
	
				// Alias method option to type as per ticket #12004
				s.type = options.method || options.type || s.method || s.type;
	
				// Extract dataTypes list
				s.dataTypes = jQuery.trim(s.dataType || "*").toLowerCase().match(rnotwhite) || [""];
	
				// A cross-domain request is in order when the origin doesn't match the current origin.
				if (s.crossDomain == null) {
					urlAnchor = document.createElement("a");
	
					// Support: IE8-11+
					// IE throws exception if url is malformed, e.g. http://example.com:80x/
					try {
						urlAnchor.href = s.url;
	
						// Support: IE8-11+
						// Anchor's host property isn't correctly set when s.url is relative
						urlAnchor.href = urlAnchor.href;
						s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== urlAnchor.protocol + "//" + urlAnchor.host;
					} catch (e) {
	
						// If there is an error parsing the URL, assume it is crossDomain,
						// it can be rejected by the transport if it is invalid
						s.crossDomain = true;
					}
				}
	
				// Convert data if not already a string
				if (s.data && s.processData && typeof s.data !== "string") {
					s.data = jQuery.param(s.data, s.traditional);
				}
	
				// Apply prefilters
				inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);
	
				// If request was aborted inside a prefilter, stop there
				if (state === 2) {
					return jqXHR;
				}
	
				// We can fire global events as of now if asked to
				// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
				fireGlobals = jQuery.event && s.global;
	
				// Watch for a new set of requests
				if (fireGlobals && jQuery.active++ === 0) {
					jQuery.event.trigger("ajaxStart");
				}
	
				// Uppercase the type
				s.type = s.type.toUpperCase();
	
				// Determine if request has content
				s.hasContent = !rnoContent.test(s.type);
	
				// Save the URL in case we're toying with the If-Modified-Since
				// and/or If-None-Match header later on
				cacheURL = s.url;
	
				// More options handling for requests with no content
				if (!s.hasContent) {
	
					// If data is available, append data to url
					if (s.data) {
						cacheURL = s.url += (rquery.test(cacheURL) ? "&" : "?") + s.data;
	
						// #9682: remove data so that it's not used in an eventual retry
						delete s.data;
					}
	
					// Add anti-cache in url if needed
					if (s.cache === false) {
						s.url = rts.test(cacheURL) ?
	
						// If there is already a '_' parameter, set its value
						cacheURL.replace(rts, "$1_=" + nonce++) :
	
						// Otherwise add one to the end
						cacheURL + (rquery.test(cacheURL) ? "&" : "?") + "_=" + nonce++;
					}
				}
	
				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
				if (s.ifModified) {
					if (jQuery.lastModified[cacheURL]) {
						jqXHR.setRequestHeader("If-Modified-Since", jQuery.lastModified[cacheURL]);
					}
					if (jQuery.etag[cacheURL]) {
						jqXHR.setRequestHeader("If-None-Match", jQuery.etag[cacheURL]);
					}
				}
	
				// Set the correct header, if data is being sent
				if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
					jqXHR.setRequestHeader("Content-Type", s.contentType);
				}
	
				// Set the Accepts header for the server, depending on the dataType
				jqXHR.setRequestHeader("Accept", s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== "*" ? ", " + allTypes + "; q=0.01" : "") : s.accepts["*"]);
	
				// Check for headers option
				for (i in s.headers) {
					jqXHR.setRequestHeader(i, s.headers[i]);
				}
	
				// Allow custom headers/mimetypes and early abort
				if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || state === 2)) {
	
					// Abort if not done already and return
					return jqXHR.abort();
				}
	
				// Aborting is no longer a cancellation
				strAbort = "abort";
	
				// Install callbacks on deferreds
				for (i in { success: 1, error: 1, complete: 1 }) {
					jqXHR[i](s[i]);
				}
	
				// Get transport
				transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);
	
				// If no transport, we auto-abort
				if (!transport) {
					done(-1, "No Transport");
				} else {
					jqXHR.readyState = 1;
	
					// Send global event
					if (fireGlobals) {
						globalEventContext.trigger("ajaxSend", [jqXHR, s]);
					}
	
					// If request was aborted inside ajaxSend, stop there
					if (state === 2) {
						return jqXHR;
					}
	
					// Timeout
					if (s.async && s.timeout > 0) {
						timeoutTimer = window.setTimeout(function () {
							jqXHR.abort("timeout");
						}, s.timeout);
					}
	
					try {
						state = 1;
						transport.send(requestHeaders, done);
					} catch (e) {
	
						// Propagate exception as error if not done
						if (state < 2) {
							done(-1, e);
	
							// Simply rethrow otherwise
						} else {
							throw e;
						}
					}
				}
	
				// Callback for when everything is done
				function done(status, nativeStatusText, responses, headers) {
					var isSuccess,
					    success,
					    error,
					    response,
					    modified,
					    statusText = nativeStatusText;
	
					// Called once
					if (state === 2) {
						return;
					}
	
					// State is "done" now
					state = 2;
	
					// Clear timeout if it exists
					if (timeoutTimer) {
						window.clearTimeout(timeoutTimer);
					}
	
					// Dereference transport for early garbage collection
					// (no matter how long the jqXHR object will be used)
					transport = undefined;
	
					// Cache response headers
					responseHeadersString = headers || "";
	
					// Set readyState
					jqXHR.readyState = status > 0 ? 4 : 0;
	
					// Determine if successful
					isSuccess = status >= 200 && status < 300 || status === 304;
	
					// Get response data
					if (responses) {
						response = ajaxHandleResponses(s, jqXHR, responses);
					}
	
					// Convert no matter what (that way responseXXX fields are always set)
					response = ajaxConvert(s, response, jqXHR, isSuccess);
	
					// If successful, handle type chaining
					if (isSuccess) {
	
						// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
						if (s.ifModified) {
							modified = jqXHR.getResponseHeader("Last-Modified");
							if (modified) {
								jQuery.lastModified[cacheURL] = modified;
							}
							modified = jqXHR.getResponseHeader("etag");
							if (modified) {
								jQuery.etag[cacheURL] = modified;
							}
						}
	
						// if no content
						if (status === 204 || s.type === "HEAD") {
							statusText = "nocontent";
	
							// if not modified
						} else if (status === 304) {
							statusText = "notmodified";
	
							// If we have data, let's convert it
						} else {
							statusText = response.state;
							success = response.data;
							error = response.error;
							isSuccess = !error;
						}
					} else {
	
						// Extract error from statusText and normalize for non-aborts
						error = statusText;
						if (status || !statusText) {
							statusText = "error";
							if (status < 0) {
								status = 0;
							}
						}
					}
	
					// Set data for the fake xhr object
					jqXHR.status = status;
					jqXHR.statusText = (nativeStatusText || statusText) + "";
	
					// Success/Error
					if (isSuccess) {
						deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
					} else {
						deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
					}
	
					// Status-dependent callbacks
					jqXHR.statusCode(_statusCode);
					_statusCode = undefined;
	
					if (fireGlobals) {
						globalEventContext.trigger(isSuccess ? "ajaxSuccess" : "ajaxError", [jqXHR, s, isSuccess ? success : error]);
					}
	
					// Complete
					completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);
	
					if (fireGlobals) {
						globalEventContext.trigger("ajaxComplete", [jqXHR, s]);
	
						// Handle the global AJAX counter
						if (! --jQuery.active) {
							jQuery.event.trigger("ajaxStop");
						}
					}
				}
	
				return jqXHR;
			},
	
			getJSON: function getJSON(url, data, callback) {
				return jQuery.get(url, data, callback, "json");
			},
	
			getScript: function getScript(url, callback) {
				return jQuery.get(url, undefined, callback, "script");
			}
		});
	
		jQuery.each(["get", "post"], function (i, method) {
			jQuery[method] = function (url, data, callback, type) {
	
				// Shift arguments if data argument was omitted
				if (jQuery.isFunction(data)) {
					type = type || callback;
					callback = data;
					data = undefined;
				}
	
				// The url can be an options object (which then must have .url)
				return jQuery.ajax(jQuery.extend({
					url: url,
					type: method,
					dataType: type,
					data: data,
					success: callback
				}, jQuery.isPlainObject(url) && url));
			};
		});
	
		jQuery._evalUrl = function (url) {
			return jQuery.ajax({
				url: url,
	
				// Make this explicit, since user can override this through ajaxSetup (#11264)
				type: "GET",
				dataType: "script",
				async: false,
				global: false,
				"throws": true
			});
		};
	
		jQuery.fn.extend({
			wrapAll: function wrapAll(html) {
				var wrap;
	
				if (jQuery.isFunction(html)) {
					return this.each(function (i) {
						jQuery(this).wrapAll(html.call(this, i));
					});
				}
	
				if (this[0]) {
	
					// The elements to wrap the target around
					wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);
	
					if (this[0].parentNode) {
						wrap.insertBefore(this[0]);
					}
	
					wrap.map(function () {
						var elem = this;
	
						while (elem.firstElementChild) {
							elem = elem.firstElementChild;
						}
	
						return elem;
					}).append(this);
				}
	
				return this;
			},
	
			wrapInner: function wrapInner(html) {
				if (jQuery.isFunction(html)) {
					return this.each(function (i) {
						jQuery(this).wrapInner(html.call(this, i));
					});
				}
	
				return this.each(function () {
					var self = jQuery(this),
					    contents = self.contents();
	
					if (contents.length) {
						contents.wrapAll(html);
					} else {
						self.append(html);
					}
				});
			},
	
			wrap: function wrap(html) {
				var isFunction = jQuery.isFunction(html);
	
				return this.each(function (i) {
					jQuery(this).wrapAll(isFunction ? html.call(this, i) : html);
				});
			},
	
			unwrap: function unwrap() {
				return this.parent().each(function () {
					if (!jQuery.nodeName(this, "body")) {
						jQuery(this).replaceWith(this.childNodes);
					}
				}).end();
			}
		});
	
		jQuery.expr.filters.hidden = function (elem) {
			return !jQuery.expr.filters.visible(elem);
		};
		jQuery.expr.filters.visible = function (elem) {
	
			// Support: Opera <= 12.12
			// Opera reports offsetWidths and offsetHeights less than zero on some elements
			// Use OR instead of AND as the element is not visible if either is true
			// See tickets #10406 and #13132
			return elem.offsetWidth > 0 || elem.offsetHeight > 0 || elem.getClientRects().length > 0;
		};
	
		var r20 = /%20/g,
		    rbracket = /\[\]$/,
		    rCRLF = /\r?\n/g,
		    rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
		    rsubmittable = /^(?:input|select|textarea|keygen)/i;
	
		function buildParams(prefix, obj, traditional, add) {
			var name;
	
			if (jQuery.isArray(obj)) {
	
				// Serialize array item.
				jQuery.each(obj, function (i, v) {
					if (traditional || rbracket.test(prefix)) {
	
						// Treat each array item as a scalar.
						add(prefix, v);
					} else {
	
						// Item is non-scalar (array or object), encode its numeric index.
						buildParams(prefix + "[" + ((typeof v === "undefined" ? "undefined" : _typeof(v)) === "object" && v != null ? i : "") + "]", v, traditional, add);
					}
				});
			} else if (!traditional && jQuery.type(obj) === "object") {
	
				// Serialize object item.
				for (name in obj) {
					buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
				}
			} else {
	
				// Serialize scalar item.
				add(prefix, obj);
			}
		}
	
		// Serialize an array of form elements or a set of
		// key/values into a query string
		jQuery.param = function (a, traditional) {
			var prefix,
			    s = [],
			    add = function add(key, value) {
	
				// If value is a function, invoke it and return its value
				value = jQuery.isFunction(value) ? value() : value == null ? "" : value;
				s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
			};
	
			// Set traditional to true for jQuery <= 1.3.2 behavior.
			if (traditional === undefined) {
				traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
			}
	
			// If an array was passed in, assume that it is an array of form elements.
			if (jQuery.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {
	
				// Serialize the form elements
				jQuery.each(a, function () {
					add(this.name, this.value);
				});
			} else {
	
				// If traditional, encode the "old" way (the way 1.3.2 or older
				// did it), otherwise encode params recursively.
				for (prefix in a) {
					buildParams(prefix, a[prefix], traditional, add);
				}
			}
	
			// Return the resulting serialization
			return s.join("&").replace(r20, "+");
		};
	
		jQuery.fn.extend({
			serialize: function serialize() {
				return jQuery.param(this.serializeArray());
			},
			serializeArray: function serializeArray() {
				return this.map(function () {
	
					// Can add propHook for "elements" to filter or add form elements
					var elements = jQuery.prop(this, "elements");
					return elements ? jQuery.makeArray(elements) : this;
				}).filter(function () {
					var type = this.type;
	
					// Use .is( ":disabled" ) so that fieldset[disabled] works
					return this.name && !jQuery(this).is(":disabled") && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type));
				}).map(function (i, elem) {
					var val = jQuery(this).val();
	
					return val == null ? null : jQuery.isArray(val) ? jQuery.map(val, function (val) {
						return { name: elem.name, value: val.replace(rCRLF, "\r\n") };
					}) : { name: elem.name, value: val.replace(rCRLF, "\r\n") };
				}).get();
			}
		});
	
		jQuery.ajaxSettings.xhr = function () {
			try {
				return new window.XMLHttpRequest();
			} catch (e) {}
		};
	
		var xhrSuccessStatus = {
	
			// File protocol always yields status code 0, assume 200
			0: 200,
	
			// Support: IE9
			// #1450: sometimes IE returns 1223 when it should be 204
			1223: 204
		},
		    xhrSupported = jQuery.ajaxSettings.xhr();
	
		support.cors = !!xhrSupported && "withCredentials" in xhrSupported;
		support.ajax = xhrSupported = !!xhrSupported;
	
		jQuery.ajaxTransport(function (options) {
			var _callback, errorCallback;
	
			// Cross domain only allowed if supported through XMLHttpRequest
			if (support.cors || xhrSupported && !options.crossDomain) {
				return {
					send: function send(headers, complete) {
						var i,
						    xhr = options.xhr();
	
						xhr.open(options.type, options.url, options.async, options.username, options.password);
	
						// Apply custom fields if provided
						if (options.xhrFields) {
							for (i in options.xhrFields) {
								xhr[i] = options.xhrFields[i];
							}
						}
	
						// Override mime type if needed
						if (options.mimeType && xhr.overrideMimeType) {
							xhr.overrideMimeType(options.mimeType);
						}
	
						// X-Requested-With header
						// For cross-domain requests, seeing as conditions for a preflight are
						// akin to a jigsaw puzzle, we simply never set it to be sure.
						// (it can always be set on a per-request basis or even using ajaxSetup)
						// For same-domain requests, won't change header if already provided.
						if (!options.crossDomain && !headers["X-Requested-With"]) {
							headers["X-Requested-With"] = "XMLHttpRequest";
						}
	
						// Set headers
						for (i in headers) {
							xhr.setRequestHeader(i, headers[i]);
						}
	
						// Callback
						_callback = function callback(type) {
							return function () {
								if (_callback) {
									_callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;
	
									if (type === "abort") {
										xhr.abort();
									} else if (type === "error") {
	
										// Support: IE9
										// On a manual native abort, IE9 throws
										// errors on any property access that is not readyState
										if (typeof xhr.status !== "number") {
											complete(0, "error");
										} else {
											complete(
	
											// File: protocol always yields status 0; see #8605, #14207
											xhr.status, xhr.statusText);
										}
									} else {
										complete(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText,
	
										// Support: IE9 only
										// IE9 has no XHR2 but throws on binary (trac-11426)
										// For XHR2 non-text, let the caller handle it (gh-2498)
										(xhr.responseType || "text") !== "text" || typeof xhr.responseText !== "string" ? { binary: xhr.response } : { text: xhr.responseText }, xhr.getAllResponseHeaders());
									}
								}
							};
						};
	
						// Listen to events
						xhr.onload = _callback();
						errorCallback = xhr.onerror = _callback("error");
	
						// Support: IE9
						// Use onreadystatechange to replace onabort
						// to handle uncaught aborts
						if (xhr.onabort !== undefined) {
							xhr.onabort = errorCallback;
						} else {
							xhr.onreadystatechange = function () {
	
								// Check readyState before timeout as it changes
								if (xhr.readyState === 4) {
	
									// Allow onerror to be called first,
									// but that will not handle a native abort
									// Also, save errorCallback to a variable
									// as xhr.onerror cannot be accessed
									window.setTimeout(function () {
										if (_callback) {
											errorCallback();
										}
									});
								}
							};
						}
	
						// Create the abort callback
						_callback = _callback("abort");
	
						try {
	
							// Do send the request (this may raise an exception)
							xhr.send(options.hasContent && options.data || null);
						} catch (e) {
	
							// #14683: Only rethrow if this hasn't been notified as an error yet
							if (_callback) {
								throw e;
							}
						}
					},
	
					abort: function abort() {
						if (_callback) {
							_callback();
						}
					}
				};
			}
		});
	
		// Install script dataType
		jQuery.ajaxSetup({
			accepts: {
				script: "text/javascript, application/javascript, " + "application/ecmascript, application/x-ecmascript"
			},
			contents: {
				script: /\b(?:java|ecma)script\b/
			},
			converters: {
				"text script": function textScript(text) {
					jQuery.globalEval(text);
					return text;
				}
			}
		});
	
		// Handle cache's special case and crossDomain
		jQuery.ajaxPrefilter("script", function (s) {
			if (s.cache === undefined) {
				s.cache = false;
			}
			if (s.crossDomain) {
				s.type = "GET";
			}
		});
	
		// Bind script tag hack transport
		jQuery.ajaxTransport("script", function (s) {
	
			// This transport only deals with cross domain requests
			if (s.crossDomain) {
				var script, _callback2;
				return {
					send: function send(_, complete) {
						script = jQuery("<script>").prop({
							charset: s.scriptCharset,
							src: s.url
						}).on("load error", _callback2 = function callback(evt) {
							script.remove();
							_callback2 = null;
							if (evt) {
								complete(evt.type === "error" ? 404 : 200, evt.type);
							}
						});
	
						// Use native DOM manipulation to avoid our domManip AJAX trickery
						document.head.appendChild(script[0]);
					},
					abort: function abort() {
						if (_callback2) {
							_callback2();
						}
					}
				};
			}
		});
	
		var oldCallbacks = [],
		    rjsonp = /(=)\?(?=&|$)|\?\?/;
	
		// Default jsonp settings
		jQuery.ajaxSetup({
			jsonp: "callback",
			jsonpCallback: function jsonpCallback() {
				var callback = oldCallbacks.pop() || jQuery.expando + "_" + nonce++;
				this[callback] = true;
				return callback;
			}
		});
	
		// Detect, normalize options and install callbacks for jsonp requests
		jQuery.ajaxPrefilter("json jsonp", function (s, originalSettings, jqXHR) {
	
			var callbackName,
			    overwritten,
			    responseContainer,
			    jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ? "url" : typeof s.data === "string" && (s.contentType || "").indexOf("application/x-www-form-urlencoded") === 0 && rjsonp.test(s.data) && "data");
	
			// Handle iff the expected data type is "jsonp" or we have a parameter to set
			if (jsonProp || s.dataTypes[0] === "jsonp") {
	
				// Get callback name, remembering preexisting value associated with it
				callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback;
	
				// Insert callback into url or form data
				if (jsonProp) {
					s[jsonProp] = s[jsonProp].replace(rjsonp, "$1" + callbackName);
				} else if (s.jsonp !== false) {
					s.url += (rquery.test(s.url) ? "&" : "?") + s.jsonp + "=" + callbackName;
				}
	
				// Use data converter to retrieve json after script execution
				s.converters["script json"] = function () {
					if (!responseContainer) {
						jQuery.error(callbackName + " was not called");
					}
					return responseContainer[0];
				};
	
				// Force json dataType
				s.dataTypes[0] = "json";
	
				// Install callback
				overwritten = window[callbackName];
				window[callbackName] = function () {
					responseContainer = arguments;
				};
	
				// Clean-up function (fires after converters)
				jqXHR.always(function () {
	
					// If previous value didn't exist - remove it
					if (overwritten === undefined) {
						jQuery(window).removeProp(callbackName);
	
						// Otherwise restore preexisting value
					} else {
						window[callbackName] = overwritten;
					}
	
					// Save back as free
					if (s[callbackName]) {
	
						// Make sure that re-using the options doesn't screw things around
						s.jsonpCallback = originalSettings.jsonpCallback;
	
						// Save the callback name for future use
						oldCallbacks.push(callbackName);
					}
	
					// Call if it was a function and we have a response
					if (responseContainer && jQuery.isFunction(overwritten)) {
						overwritten(responseContainer[0]);
					}
	
					responseContainer = overwritten = undefined;
				});
	
				// Delegate to script
				return "script";
			}
		});
	
		// Argument "data" should be string of html
		// context (optional): If specified, the fragment will be created in this context,
		// defaults to document
		// keepScripts (optional): If true, will include scripts passed in the html string
		jQuery.parseHTML = function (data, context, keepScripts) {
			if (!data || typeof data !== "string") {
				return null;
			}
			if (typeof context === "boolean") {
				keepScripts = context;
				context = false;
			}
			context = context || document;
	
			var parsed = rsingleTag.exec(data),
			    scripts = !keepScripts && [];
	
			// Single tag
			if (parsed) {
				return [context.createElement(parsed[1])];
			}
	
			parsed = buildFragment([data], context, scripts);
	
			if (scripts && scripts.length) {
				jQuery(scripts).remove();
			}
	
			return jQuery.merge([], parsed.childNodes);
		};
	
		// Keep a copy of the old load method
		var _load = jQuery.fn.load;
	
		/**
	  * Load a url into a page
	  */
		jQuery.fn.load = function (url, params, callback) {
			if (typeof url !== "string" && _load) {
				return _load.apply(this, arguments);
			}
	
			var selector,
			    type,
			    response,
			    self = this,
			    off = url.indexOf(" ");
	
			if (off > -1) {
				selector = jQuery.trim(url.slice(off));
				url = url.slice(0, off);
			}
	
			// If it's a function
			if (jQuery.isFunction(params)) {
	
				// We assume that it's the callback
				callback = params;
				params = undefined;
	
				// Otherwise, build a param string
			} else if (params && (typeof params === "undefined" ? "undefined" : _typeof(params)) === "object") {
				type = "POST";
			}
	
			// If we have elements to modify, make the request
			if (self.length > 0) {
				jQuery.ajax({
					url: url,
	
					// If "type" variable is undefined, then "GET" method will be used.
					// Make value of this field explicit since
					// user can override it through ajaxSetup method
					type: type || "GET",
					dataType: "html",
					data: params
				}).done(function (responseText) {
	
					// Save response for use in complete callback
					response = arguments;
	
					self.html(selector ?
	
					// If a selector was specified, locate the right elements in a dummy div
					// Exclude scripts to avoid IE 'Permission Denied' errors
					jQuery("<div>").append(jQuery.parseHTML(responseText)).find(selector) :
	
					// Otherwise use the full result
					responseText);
	
					// If the request succeeds, this function gets "data", "status", "jqXHR"
					// but they are ignored because response was set above.
					// If it fails, this function gets "jqXHR", "status", "error"
				}).always(callback && function (jqXHR, status) {
					self.each(function () {
						callback.apply(this, response || [jqXHR.responseText, status, jqXHR]);
					});
				});
			}
	
			return this;
		};
	
		// Attach a bunch of functions for handling common AJAX events
		jQuery.each(["ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend"], function (i, type) {
			jQuery.fn[type] = function (fn) {
				return this.on(type, fn);
			};
		});
	
		jQuery.expr.filters.animated = function (elem) {
			return jQuery.grep(jQuery.timers, function (fn) {
				return elem === fn.elem;
			}).length;
		};
	
		/**
	  * Gets a window from an element
	  */
		function getWindow(elem) {
			return jQuery.isWindow(elem) ? elem : elem.nodeType === 9 && elem.defaultView;
		}
	
		jQuery.offset = {
			setOffset: function setOffset(elem, options, i) {
				var curPosition,
				    curLeft,
				    curCSSTop,
				    curTop,
				    curOffset,
				    curCSSLeft,
				    calculatePosition,
				    position = jQuery.css(elem, "position"),
				    curElem = jQuery(elem),
				    props = {};
	
				// Set position first, in-case top/left are set even on static elem
				if (position === "static") {
					elem.style.position = "relative";
				}
	
				curOffset = curElem.offset();
				curCSSTop = jQuery.css(elem, "top");
				curCSSLeft = jQuery.css(elem, "left");
				calculatePosition = (position === "absolute" || position === "fixed") && (curCSSTop + curCSSLeft).indexOf("auto") > -1;
	
				// Need to be able to calculate position if either
				// top or left is auto and position is either absolute or fixed
				if (calculatePosition) {
					curPosition = curElem.position();
					curTop = curPosition.top;
					curLeft = curPosition.left;
				} else {
					curTop = parseFloat(curCSSTop) || 0;
					curLeft = parseFloat(curCSSLeft) || 0;
				}
	
				if (jQuery.isFunction(options)) {
	
					// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
					options = options.call(elem, i, jQuery.extend({}, curOffset));
				}
	
				if (options.top != null) {
					props.top = options.top - curOffset.top + curTop;
				}
				if (options.left != null) {
					props.left = options.left - curOffset.left + curLeft;
				}
	
				if ("using" in options) {
					options.using.call(elem, props);
				} else {
					curElem.css(props);
				}
			}
		};
	
		jQuery.fn.extend({
			offset: function offset(options) {
				if (arguments.length) {
					return options === undefined ? this : this.each(function (i) {
						jQuery.offset.setOffset(this, options, i);
					});
				}
	
				var docElem,
				    win,
				    elem = this[0],
				    box = { top: 0, left: 0 },
				    doc = elem && elem.ownerDocument;
	
				if (!doc) {
					return;
				}
	
				docElem = doc.documentElement;
	
				// Make sure it's not a disconnected DOM node
				if (!jQuery.contains(docElem, elem)) {
					return box;
				}
	
				box = elem.getBoundingClientRect();
				win = getWindow(doc);
				return {
					top: box.top + win.pageYOffset - docElem.clientTop,
					left: box.left + win.pageXOffset - docElem.clientLeft
				};
			},
	
			position: function position() {
				if (!this[0]) {
					return;
				}
	
				var offsetParent,
				    offset,
				    elem = this[0],
				    parentOffset = { top: 0, left: 0 };
	
				// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
				// because it is its only offset parent
				if (jQuery.css(elem, "position") === "fixed") {
	
					// Assume getBoundingClientRect is there when computed position is fixed
					offset = elem.getBoundingClientRect();
				} else {
	
					// Get *real* offsetParent
					offsetParent = this.offsetParent();
	
					// Get correct offsets
					offset = this.offset();
					if (!jQuery.nodeName(offsetParent[0], "html")) {
						parentOffset = offsetParent.offset();
					}
	
					// Add offsetParent borders
					parentOffset.top += jQuery.css(offsetParent[0], "borderTopWidth", true);
					parentOffset.left += jQuery.css(offsetParent[0], "borderLeftWidth", true);
				}
	
				// Subtract parent offsets and element margins
				return {
					top: offset.top - parentOffset.top - jQuery.css(elem, "marginTop", true),
					left: offset.left - parentOffset.left - jQuery.css(elem, "marginLeft", true)
				};
			},
	
			// This method will return documentElement in the following cases:
			// 1) For the element inside the iframe without offsetParent, this method will return
			//    documentElement of the parent window
			// 2) For the hidden or detached element
			// 3) For body or html element, i.e. in case of the html node - it will return itself
			//
			// but those exceptions were never presented as a real life use-cases
			// and might be considered as more preferable results.
			//
			// This logic, however, is not guaranteed and can change at any point in the future
			offsetParent: function offsetParent() {
				return this.map(function () {
					var offsetParent = this.offsetParent;
	
					while (offsetParent && jQuery.css(offsetParent, "position") === "static") {
						offsetParent = offsetParent.offsetParent;
					}
	
					return offsetParent || documentElement;
				});
			}
		});
	
		// Create scrollLeft and scrollTop methods
		jQuery.each({ scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function (method, prop) {
			var top = "pageYOffset" === prop;
	
			jQuery.fn[method] = function (val) {
				return access(this, function (elem, method, val) {
					var win = getWindow(elem);
	
					if (val === undefined) {
						return win ? win[prop] : elem[method];
					}
	
					if (win) {
						win.scrollTo(!top ? val : win.pageXOffset, top ? val : win.pageYOffset);
					} else {
						elem[method] = val;
					}
				}, method, val, arguments.length);
			};
		});
	
		// Support: Safari<7-8+, Chrome<37-44+
		// Add the top/left cssHooks using jQuery.fn.position
		// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
		// Blink bug: https://code.google.com/p/chromium/issues/detail?id=229280
		// getComputedStyle returns percent when specified for top/left/bottom/right;
		// rather than make the css module depend on the offset module, just check for it here
		jQuery.each(["top", "left"], function (i, prop) {
			jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function (elem, computed) {
				if (computed) {
					computed = curCSS(elem, prop);
	
					// If curCSS returns percentage, fallback to offset
					return rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + "px" : computed;
				}
			});
		});
	
		// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
		jQuery.each({ Height: "height", Width: "width" }, function (name, type) {
			jQuery.each({ padding: "inner" + name, content: type, "": "outer" + name }, function (defaultExtra, funcName) {
	
				// Margin is only for outerHeight, outerWidth
				jQuery.fn[funcName] = function (margin, value) {
					var chainable = arguments.length && (defaultExtra || typeof margin !== "boolean"),
					    extra = defaultExtra || (margin === true || value === true ? "margin" : "border");
	
					return access(this, function (elem, type, value) {
						var doc;
	
						if (jQuery.isWindow(elem)) {
	
							// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
							// isn't a whole lot we can do. See pull request at this URL for discussion:
							// https://github.com/jquery/jquery/pull/764
							return elem.document.documentElement["client" + name];
						}
	
						// Get document width or height
						if (elem.nodeType === 9) {
							doc = elem.documentElement;
	
							// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
							// whichever is greatest
							return Math.max(elem.body["scroll" + name], doc["scroll" + name], elem.body["offset" + name], doc["offset" + name], doc["client" + name]);
						}
	
						return value === undefined ?
	
						// Get width or height on the element, requesting but not forcing parseFloat
						jQuery.css(elem, type, extra) :
	
						// Set width or height on the element
						jQuery.style(elem, type, value, extra);
					}, type, chainable ? margin : undefined, chainable, null);
				};
			});
		});
	
		jQuery.fn.extend({
	
			bind: function bind(types, data, fn) {
				return this.on(types, null, data, fn);
			},
			unbind: function unbind(types, fn) {
				return this.off(types, null, fn);
			},
	
			delegate: function delegate(selector, types, data, fn) {
				return this.on(types, selector, data, fn);
			},
			undelegate: function undelegate(selector, types, fn) {
	
				// ( namespace ) or ( selector, types [, fn] )
				return arguments.length === 1 ? this.off(selector, "**") : this.off(types, selector || "**", fn);
			},
			size: function size() {
				return this.length;
			}
		});
	
		jQuery.fn.andSelf = jQuery.fn.addBack;
	
		// Register as a named AMD module, since jQuery can be concatenated with other
		// files that may use define, but not via a proper concatenation script that
		// understands anonymous AMD modules. A named AMD is safest and most robust
		// way to register. Lowercase jquery is used because AMD module names are
		// derived from file names, and jQuery is normally delivered in a lowercase
		// file name. Do this after creating the global so that if an AMD module wants
		// to call noConflict to hide this version of jQuery, it will work.
	
		// Note that for maximum portability, libraries that are not jQuery should
		// declare themselves as anonymous modules, and avoid setting a global if an
		// AMD loader is present. jQuery is a special case. For more information, see
		// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
	
		if (true) {
			!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function () {
				return jQuery;
			}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
		}
	
		var
	
		// Map over jQuery in case of overwrite
		_jQuery = window.jQuery,
	
	
		// Map over the $ in case of overwrite
		_$ = window.$;
	
		jQuery.noConflict = function (deep) {
			if (window.$ === jQuery) {
				window.$ = _$;
			}
	
			if (deep && window.jQuery === jQuery) {
				window.jQuery = _jQuery;
			}
	
			return jQuery;
		};
	
		// Expose jQuery and $ identifiers, even in AMD
		// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
		// and CommonJS for browser emulators (#13566)
		if (!noGlobal) {
			window.jQuery = window.$ = jQuery;
		}
	
		return jQuery;
	});
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(619)(module)))

/***/ },
/* 492 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 */
	var PhotosMimeType = {
	  isImage: function isImage(mimeString) {
	    return getParts(mimeString)[0] === 'image';
	  },
	  isJpeg: function isJpeg(mimeString) {
	    var parts = getParts(mimeString);
	    return PhotosMimeType.isImage(mimeString) && (
	    // see http://fburl.com/10972194
	    parts[1] === 'jpeg' || parts[1] === 'pjpeg');
	  }
	};
	
	function getParts(mimeString) {
	  return mimeString.split('/');
	}
	
	module.exports = PhotosMimeType;

/***/ },
/* 493 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var invariant = __webpack_require__(432);
	
	/**
	 * Convert array-like objects to arrays.
	 *
	 * This API assumes the caller knows the contents of the data type. For less
	 * well defined inputs use createArrayFromMixed.
	 *
	 * @param {object|function|filelist} obj
	 * @return {array}
	 */
	function toArray(obj) {
	  var length = obj.length;
	
	  // Some browsers builtin objects can report typeof 'function' (e.g. NodeList
	  // in old versions of Safari).
	  !(!Array.isArray(obj) && (typeof obj === 'object' || typeof obj === 'function')) ? true ? invariant(false, 'toArray: Array-like object expected') : invariant(false) : void 0;
	
	  !(typeof length === 'number') ? true ? invariant(false, 'toArray: Object needs a length property') : invariant(false) : void 0;
	
	  !(length === 0 || length - 1 in obj) ? true ? invariant(false, 'toArray: Object should have keys for indices') : invariant(false) : void 0;
	
	  !(typeof obj.callee !== 'function') ? true ? invariant(false, 'toArray: Object can\'t be `arguments`. Use rest params ' + '(function(...args) {}) or Array.from() instead.') : invariant(false) : void 0;
	
	  // Old IE doesn't give collections access to hasOwnProperty. Assume inputs
	  // without method will throw during the slice call and skip straight to the
	  // fallback.
	  if (obj.hasOwnProperty) {
	    try {
	      return Array.prototype.slice.call(obj);
	    } catch (e) {
	      // IE < 9 does not support Array#slice on collections objects
	    }
	  }
	
	  // Fall back to copying key by key. This assumes all keys have a value,
	  // so will not preserve sparsely populated inputs.
	  var ret = Array(length);
	  for (var ii = 0; ii < length; ii++) {
	    ret[ii] = obj[ii];
	  }
	  return ret;
	}
	
	/**
	 * Perform a heuristic test to determine if an object is "array-like".
	 *
	 *   A monk asked Joshu, a Zen master, "Has a dog Buddha nature?"
	 *   Joshu replied: "Mu."
	 *
	 * This function determines if its argument has "array nature": it returns
	 * true if the argument is an actual array, an `arguments' object, or an
	 * HTMLCollection (e.g. node.childNodes or node.getElementsByTagName()).
	 *
	 * It will return false for other array-like objects like Filelist.
	 *
	 * @param {*} obj
	 * @return {boolean}
	 */
	function hasArrayNature(obj) {
	  return (
	    // not null/false
	    !!obj && (
	    // arrays are objects, NodeLists are functions in Safari
	    typeof obj == 'object' || typeof obj == 'function') &&
	    // quacks like an array
	    'length' in obj &&
	    // not window
	    !('setInterval' in obj) &&
	    // no DOM node should be considered an array-like
	    // a 'select' element has 'length' and 'item' properties on IE8
	    typeof obj.nodeType != 'number' && (
	    // a real array
	    Array.isArray(obj) ||
	    // arguments
	    'callee' in obj ||
	    // HTMLCollection/NodeList
	    'item' in obj)
	  );
	}
	
	/**
	 * Ensure that the argument is an array by wrapping it in an array if it is not.
	 * Creates a copy of the argument if it is already an array.
	 *
	 * This is mostly useful idiomatically:
	 *
	 *   var createArrayFromMixed = require('createArrayFromMixed');
	 *
	 *   function takesOneOrMoreThings(things) {
	 *     things = createArrayFromMixed(things);
	 *     ...
	 *   }
	 *
	 * This allows you to treat `things' as an array, but accept scalars in the API.
	 *
	 * If you need to convert an array-like object, like `arguments`, into an array
	 * use toArray instead.
	 *
	 * @param {*} obj
	 * @return {array}
	 */
	function createArrayFromMixed(obj) {
	  if (!hasArrayNature(obj)) {
	    return [obj];
	  } else if (Array.isArray(obj)) {
	    return obj.slice();
	  } else {
	    return toArray(obj);
	  }
	}
	
	module.exports = createArrayFromMixed;

/***/ },
/* 494 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getSelectionOffsetKeyForNode
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	/**
	 * Get offset key from a node.
	 */
	function getSelectionOffsetKeyForNode(node) {
	  return node instanceof Element ? node.getAttribute('data-offset-key') : null;
	}
	
	module.exports = getSelectionOffsetKeyForNode;

/***/ },
/* 495 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getFragmentFromSelection
	 * 
	 */
	
	'use strict';
	
	var getContentStateFragment = __webpack_require__(380);
	
	function getFragmentFromSelection(editorState) {
	  var selectionState = editorState.getSelection();
	  if (!selectionState.isCollapsed()) {
	    return getContentStateFragment(editorState.getCurrentContent(), selectionState);
	  }
	}
	
	module.exports = getFragmentFromSelection;

/***/ },
/* 496 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule SecondaryClipboard
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(329);
	var EditorState = __webpack_require__(332);
	
	var getContentStateFragment = __webpack_require__(380);
	var nullthrows = __webpack_require__(442);
	
	var clipboard = null;
	
	/**
	 * Some systems offer a "secondary" clipboard to allow quick internal cut
	 * and paste behavior. For instance, Ctrl+K (cut) and Ctrl+Y (paste).
	 */
	var SecondaryClipboard = {
	  cut: function cut(editorState) {
	    var content = editorState.getCurrentContent();
	    var selection = editorState.getSelection();
	    var targetRange = null;
	
	    if (selection.isCollapsed()) {
	      var anchorKey = selection.getAnchorKey();
	      var blockEnd = content.getBlockForKey(anchorKey).getLength();
	
	      if (blockEnd === selection.getAnchorOffset()) {
	        return editorState;
	      }
	
	      targetRange = selection.set('focusOffset', blockEnd);
	    } else {
	      targetRange = selection;
	    }
	
	    targetRange = nullthrows(targetRange);
	    clipboard = getContentStateFragment(content, targetRange);
	
	    var afterRemoval = DraftModifier.removeRange(content, targetRange, 'forward');
	
	    if (afterRemoval === content) {
	      return editorState;
	    }
	
	    return EditorState.push(editorState, afterRemoval, 'remove-range');
	  },
	
	  paste: function paste(editorState) {
	    if (!clipboard) {
	      return editorState;
	    }
	
	    var newContent = DraftModifier.replaceWithFragment(editorState.getCurrentContent(), editorState.getSelection(), clipboard);
	
	    return EditorState.push(editorState, newContent, 'insert-fragment');
	  }
	};
	
	module.exports = SecondaryClipboard;

/***/ },
/* 497 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandBackspaceToStartOfLine
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(332);
	
	var expandRangeToStartOfLine = __webpack_require__(531);
	var getDraftEditorSelectionWithNodes = __webpack_require__(532);
	var moveSelectionBackward = __webpack_require__(533);
	var removeTextWithStrategy = __webpack_require__(534);
	
	function keyCommandBackspaceToStartOfLine(editorState) {
	  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {
	    var selection = strategyState.getSelection();
	    if (selection.isCollapsed() && selection.getAnchorOffset() === 0) {
	      return moveSelectionBackward(strategyState, 1);
	    }
	
	    var domSelection = global.getSelection();
	    var range = domSelection.getRangeAt(0);
	    range = expandRangeToStartOfLine(range);
	
	    return getDraftEditorSelectionWithNodes(strategyState, null, range.endContainer, range.endOffset, range.startContainer, range.startOffset).selectionState;
	  }, 'backward');
	
	  if (afterRemoval === editorState.getCurrentContent()) {
	    return editorState;
	  }
	
	  return EditorState.push(editorState, afterRemoval, 'remove-range');
	}
	
	module.exports = keyCommandBackspaceToStartOfLine;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 498 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandBackspaceWord
	 * 
	 */
	
	'use strict';
	
	var DraftRemovableWord = __webpack_require__(535);
	var EditorState = __webpack_require__(332);
	
	var moveSelectionBackward = __webpack_require__(533);
	var removeTextWithStrategy = __webpack_require__(534);
	
	/**
	 * Delete the word that is left of the cursor, as well as any spaces or
	 * punctuation after the word.
	 */
	function keyCommandBackspaceWord(editorState) {
	  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {
	    var selection = strategyState.getSelection();
	    var offset = selection.getStartOffset();
	    // If there are no words before the cursor, remove the preceding newline.
	    if (offset === 0) {
	      return moveSelectionBackward(strategyState, 1);
	    }
	    var key = selection.getStartKey();
	    var content = strategyState.getCurrentContent();
	    var text = content.getBlockForKey(key).getText().slice(0, offset);
	    var toRemove = DraftRemovableWord.getBackward(text);
	    return moveSelectionBackward(strategyState, toRemove.length || 1);
	  }, 'backward');
	
	  if (afterRemoval === editorState.getCurrentContent()) {
	    return editorState;
	  }
	
	  return EditorState.push(editorState, afterRemoval, 'remove-range');
	}
	
	module.exports = keyCommandBackspaceWord;

/***/ },
/* 499 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandDeleteWord
	 * 
	 */
	
	'use strict';
	
	var DraftRemovableWord = __webpack_require__(535);
	var EditorState = __webpack_require__(332);
	
	var moveSelectionForward = __webpack_require__(536);
	var removeTextWithStrategy = __webpack_require__(534);
	
	/**
	 * Delete the word that is right of the cursor, as well as any spaces or
	 * punctuation before the word.
	 */
	function keyCommandDeleteWord(editorState) {
	  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {
	    var selection = strategyState.getSelection();
	    var offset = selection.getStartOffset();
	    var key = selection.getStartKey();
	    var content = strategyState.getCurrentContent();
	    var text = content.getBlockForKey(key).getText().slice(offset);
	    var toRemove = DraftRemovableWord.getForward(text);
	
	    // If there are no words in front of the cursor, remove the newline.
	    return moveSelectionForward(strategyState, toRemove.length || 1);
	  }, 'forward');
	
	  if (afterRemoval === editorState.getCurrentContent()) {
	    return editorState;
	  }
	
	  return EditorState.push(editorState, afterRemoval, 'remove-range');
	}
	
	module.exports = keyCommandDeleteWord;

/***/ },
/* 500 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandInsertNewline
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(329);
	var EditorState = __webpack_require__(332);
	
	function keyCommandInsertNewline(editorState) {
	  var contentState = DraftModifier.splitBlock(editorState.getCurrentContent(), editorState.getSelection());
	  return EditorState.push(editorState, contentState, 'split-block');
	}
	
	module.exports = keyCommandInsertNewline;

/***/ },
/* 501 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandPlainBackspace
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(332);
	var UnicodeUtils = __webpack_require__(445);
	
	var moveSelectionBackward = __webpack_require__(533);
	var removeTextWithStrategy = __webpack_require__(534);
	
	/**
	 * Remove the selected range. If the cursor is collapsed, remove the preceding
	 * character. This operation is Unicode-aware, so removing a single character
	 * will remove a surrogate pair properly as well.
	 */
	function keyCommandPlainBackspace(editorState) {
	  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {
	    var selection = strategyState.getSelection();
	    var content = strategyState.getCurrentContent();
	    var key = selection.getAnchorKey();
	    var offset = selection.getAnchorOffset();
	    var charBehind = content.getBlockForKey(key).getText()[offset - 1];
	    return moveSelectionBackward(strategyState, charBehind ? UnicodeUtils.getUTF16Length(charBehind, 0) : 1);
	  }, 'backward');
	
	  if (afterRemoval === editorState.getCurrentContent()) {
	    return editorState;
	  }
	
	  var selection = editorState.getSelection();
	  return EditorState.push(editorState, afterRemoval.set('selectionBefore', selection), selection.isCollapsed() ? 'backspace-character' : 'remove-range');
	}
	
	module.exports = keyCommandPlainBackspace;

/***/ },
/* 502 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandPlainDelete
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(332);
	var UnicodeUtils = __webpack_require__(445);
	
	var moveSelectionForward = __webpack_require__(536);
	var removeTextWithStrategy = __webpack_require__(534);
	
	/**
	 * Remove the selected range. If the cursor is collapsed, remove the following
	 * character. This operation is Unicode-aware, so removing a single character
	 * will remove a surrogate pair properly as well.
	 */
	function keyCommandPlainDelete(editorState) {
	  var afterRemoval = removeTextWithStrategy(editorState, function (strategyState) {
	    var selection = strategyState.getSelection();
	    var content = strategyState.getCurrentContent();
	    var key = selection.getAnchorKey();
	    var offset = selection.getAnchorOffset();
	    var charAhead = content.getBlockForKey(key).getText()[offset];
	    return moveSelectionForward(strategyState, charAhead ? UnicodeUtils.getUTF16Length(charAhead, 0) : 1);
	  }, 'forward');
	
	  if (afterRemoval === editorState.getCurrentContent()) {
	    return editorState;
	  }
	
	  var selection = editorState.getSelection();
	
	  return EditorState.push(editorState, afterRemoval.set('selectionBefore', selection), selection.isCollapsed() ? 'delete-character' : 'remove-range');
	}
	
	module.exports = keyCommandPlainDelete;

/***/ },
/* 503 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandMoveSelectionToEndOfBlock
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(332);
	
	/**
	 * See comment for `moveSelectionToStartOfBlock`.
	 */
	function keyCommandMoveSelectionToEndOfBlock(editorState) {
	  var selection = editorState.getSelection();
	  var endKey = selection.getEndKey();
	  var content = editorState.getCurrentContent();
	  var textLength = content.getBlockForKey(endKey).getLength();
	  return EditorState.set(editorState, {
	    selection: selection.merge({
	      anchorKey: endKey,
	      anchorOffset: textLength,
	      focusKey: endKey,
	      focusOffset: textLength,
	      isBackward: false
	    }),
	    forceSelection: true
	  });
	}
	
	module.exports = keyCommandMoveSelectionToEndOfBlock;

/***/ },
/* 504 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandMoveSelectionToStartOfBlock
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(332);
	
	/**
	 * Collapse selection at the start of the first selected block. This is used
	 * for Firefox versions that attempt to navigate forward/backward instead of
	 * moving the cursor. Other browsers are able to move the cursor natively.
	 */
	function keyCommandMoveSelectionToStartOfBlock(editorState) {
	  var selection = editorState.getSelection();
	  var startKey = selection.getStartKey();
	  return EditorState.set(editorState, {
	    selection: selection.merge({
	      anchorKey: startKey,
	      anchorOffset: 0,
	      focusKey: startKey,
	      focusOffset: 0,
	      isBackward: false
	    }),
	    forceSelection: true
	  });
	}
	
	module.exports = keyCommandMoveSelectionToStartOfBlock;

/***/ },
/* 505 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandTransposeCharacters
	 * 
	 */
	
	'use strict';
	
	var DraftModifier = __webpack_require__(329);
	var EditorState = __webpack_require__(332);
	
	var getContentStateFragment = __webpack_require__(380);
	
	/**
	 * Transpose the characters on either side of a collapsed cursor, or
	 * if the cursor is at the end of the block, transpose the last two
	 * characters.
	 */
	function keyCommandTransposeCharacters(editorState) {
	  var selection = editorState.getSelection();
	  if (!selection.isCollapsed()) {
	    return editorState;
	  }
	
	  var offset = selection.getAnchorOffset();
	  if (offset === 0) {
	    return editorState;
	  }
	
	  var blockKey = selection.getAnchorKey();
	  var content = editorState.getCurrentContent();
	  var block = content.getBlockForKey(blockKey);
	  var length = block.getLength();
	
	  // Nothing to transpose if there aren't two characters.
	  if (length <= 1) {
	    return editorState;
	  }
	
	  var removalRange;
	  var finalSelection;
	
	  if (offset === length) {
	    // The cursor is at the end of the block. Swap the last two characters.
	    removalRange = selection.set('anchorOffset', offset - 1);
	    finalSelection = selection;
	  } else {
	    removalRange = selection.set('focusOffset', offset + 1);
	    finalSelection = removalRange.set('anchorOffset', offset + 1);
	  }
	
	  // Extract the character to move as a fragment. This preserves its
	  // styling and entity, if any.
	  var movedFragment = getContentStateFragment(content, removalRange);
	  var afterRemoval = DraftModifier.removeRange(content, removalRange, 'backward');
	
	  // After the removal, the insertion target is one character back.
	  var selectionAfter = afterRemoval.getSelectionAfter();
	  var targetOffset = selectionAfter.getAnchorOffset() - 1;
	  var targetRange = selectionAfter.merge({
	    anchorOffset: targetOffset,
	    focusOffset: targetOffset
	  });
	
	  var afterInsert = DraftModifier.replaceWithFragment(afterRemoval, targetRange, movedFragment);
	
	  var newEditorState = EditorState.push(editorState, afterInsert, 'insert-fragment');
	
	  return EditorState.acceptSelection(newEditorState, finalSelection);
	}
	
	module.exports = keyCommandTransposeCharacters;

/***/ },
/* 506 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule keyCommandUndo
	 * 
	 */
	
	'use strict';
	
	var EditorState = __webpack_require__(332);
	
	function keyCommandUndo(e, editorState, updateFn) {
	  var undoneState = EditorState.undo(editorState);
	
	  // If the last change to occur was a spellcheck change, allow the undo
	  // event to fall through to the browser. This allows the browser to record
	  // the unwanted change, which should soon lead it to learn not to suggest
	  // the correction again.
	  if (editorState.getLastChangeType() === 'spellcheck-change') {
	    var nativelyRenderedContent = undoneState.getCurrentContent();
	    updateFn(EditorState.set(undoneState, { nativelyRenderedContent: nativelyRenderedContent }));
	    return;
	  }
	
	  // Otheriwse, manage the undo behavior manually.
	  e.preventDefault();
	  if (!editorState.getNativelyRenderedContent()) {
	    updateFn(undoneState);
	    return;
	  }
	
	  // Trigger a re-render with the current content state to ensure that the
	  // component tree has up-to-date props for comparison.
	  updateFn(EditorState.set(editorState, { nativelyRenderedContent: null }));
	
	  // Wait to ensure that the re-render has occurred before performing
	  // the undo action.
	  setTimeout(function () {
	    updateFn(undoneState);
	  }, 0);
	}
	
	module.exports = keyCommandUndo;

/***/ },
/* 507 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftPasteProcessor
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var CharacterMetadata = __webpack_require__(321);
	var ContentBlock = __webpack_require__(323);
	var Immutable = __webpack_require__(346);
	
	var convertFromHTMLtoContentBlocks = __webpack_require__(337);
	var generateRandomKey = __webpack_require__(339);
	var getSafeBodyFromHTML = __webpack_require__(401);
	var sanitizeDraftText = __webpack_require__(375);
	
	var List = Immutable.List;
	var Repeat = Immutable.Repeat;
	
	var DraftPasteProcessor = {
	  processHTML: function processHTML(html, blockRenderMap) {
	    return convertFromHTMLtoContentBlocks(html, getSafeBodyFromHTML, blockRenderMap);
	  },
	
	  processText: function processText(textBlocks, character) {
	    return textBlocks.map(function (textLine) {
	      textLine = sanitizeDraftText(textLine);
	      return new ContentBlock({
	        key: generateRandomKey(),
	        type: 'unstyled',
	        text: textLine,
	        characterList: List(Repeat(character, textLine.length))
	      });
	    });
	  }
	};
	
	module.exports = DraftPasteProcessor;

/***/ },
/* 508 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule splitTextIntoTextBlocks
	 * 
	 */
	
	'use strict';
	
	var NEWLINE_REGEX = /\r\n?|\n/g;
	
	function splitTextIntoTextBlocks(text) {
	  return text.split(NEWLINE_REGEX);
	}
	
	module.exports = splitTextIntoTextBlocks;

/***/ },
/* 509 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getDraftEditorSelection
	 * @typechecks
	 * 
	 */
	
	/**
	 * Convert the current selection range to an anchor/focus pair of offset keys
	 * and values that can be interpreted by components.
	 */
	'use strict';
	
	var getDraftEditorSelectionWithNodes = __webpack_require__(532);
	
	function getDraftEditorSelection(editorState, root) {
	  var selection = global.getSelection();
	
	  // No active selection.
	  if (selection.rangeCount === 0) {
	    return {
	      selectionState: editorState.getSelection().set('hasFocus', false),
	      needsRecovery: false
	    };
	  }
	
	  return getDraftEditorSelectionWithNodes(editorState, root, selection.anchorNode, selection.anchorOffset, selection.focusNode, selection.focusOffset);
	}
	
	module.exports = getDraftEditorSelection;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 510 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _propTypes = __webpack_require__(523);
	
	var _propTypes2 = _interopRequireDefault(_propTypes);
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { "default": obj };
	}
	
	exports["default"] = _propTypes2["default"].shape({
	  subscribe: _propTypes2["default"].func.isRequired,
	  dispatch: _propTypes2["default"].func.isRequired,
	  getState: _propTypes2["default"].func.isRequired
	});

/***/ },
/* 511 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports["default"] = warning;
	/**
	 * Prints a warning in the console if it exists.
	 *
	 * @param {String} message The warning message.
	 * @returns {void}
	 */
	function warning(message) {
	  /* eslint-disable no-console */
	  if (typeof console !== 'undefined' && typeof console.error === 'function') {
	    console.error(message);
	  }
	  /* eslint-enable no-console */
	  try {
	    // This error was thrown as a convenience so that if you enable
	    // "break on all exceptions" in your console,
	    // it would pause the execution at this line.
	    throw new Error(message);
	    /* eslint-disable no-empty */
	  } catch (e) {}
	  /* eslint-enable no-empty */
	}

/***/ },
/* 512 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	exports.__esModule = true;
	exports["default"] = shallowEqual;
	function shallowEqual(objA, objB) {
	  if (objA === objB) {
	    return true;
	  }
	
	  var keysA = Object.keys(objA);
	  var keysB = Object.keys(objB);
	
	  if (keysA.length !== keysB.length) {
	    return false;
	  }
	
	  // Test for A's keys different from B.
	  var hasOwn = Object.prototype.hasOwnProperty;
	  for (var i = 0; i < keysA.length; i++) {
	    if (!hasOwn.call(objB, keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) {
	      return false;
	    }
	  }
	
	  return true;
	}

/***/ },
/* 513 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports["default"] = wrapActionCreators;
	
	var _redux = __webpack_require__(470);
	
	function wrapActionCreators(actionCreators) {
	  return function (dispatch) {
	    return (0, _redux.bindActionCreators)(actionCreators, dispatch);
	  };
	}

/***/ },
/* 514 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	exports.__esModule = true;
	exports.ActionTypes = undefined;
	exports['default'] = createStore;
	
	var _isPlainObject = __webpack_require__(537);
	
	var _isPlainObject2 = _interopRequireDefault(_isPlainObject);
	
	var _symbolObservable = __webpack_require__(554);
	
	var _symbolObservable2 = _interopRequireDefault(_symbolObservable);
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	/**
	 * These are private action types reserved by Redux.
	 * For any unknown actions, you must return the current state.
	 * If the current state is undefined, you must return the initial state.
	 * Do not reference these action types directly in your code.
	 */
	var ActionTypes = exports.ActionTypes = {
	  INIT: '@@redux/INIT'
	
	  /**
	   * Creates a Redux store that holds the state tree.
	   * The only way to change the data in the store is to call `dispatch()` on it.
	   *
	   * There should only be a single store in your app. To specify how different
	   * parts of the state tree respond to actions, you may combine several reducers
	   * into a single reducer function by using `combineReducers`.
	   *
	   * @param {Function} reducer A function that returns the next state tree, given
	   * the current state tree and the action to handle.
	   *
	   * @param {any} [preloadedState] The initial state. You may optionally specify it
	   * to hydrate the state from the server in universal apps, or to restore a
	   * previously serialized user session.
	   * If you use `combineReducers` to produce the root reducer function, this must be
	   * an object with the same shape as `combineReducers` keys.
	   *
	   * @param {Function} [enhancer] The store enhancer. You may optionally specify it
	   * to enhance the store with third-party capabilities such as middleware,
	   * time travel, persistence, etc. The only store enhancer that ships with Redux
	   * is `applyMiddleware()`.
	   *
	   * @returns {Store} A Redux store that lets you read the state, dispatch actions
	   * and subscribe to changes.
	   */
	};function createStore(reducer, preloadedState, enhancer) {
	  var _ref2;
	
	  if (typeof preloadedState === 'function' && typeof enhancer === 'undefined') {
	    enhancer = preloadedState;
	    preloadedState = undefined;
	  }
	
	  if (typeof enhancer !== 'undefined') {
	    if (typeof enhancer !== 'function') {
	      throw new Error('Expected the enhancer to be a function.');
	    }
	
	    return enhancer(createStore)(reducer, preloadedState);
	  }
	
	  if (typeof reducer !== 'function') {
	    throw new Error('Expected the reducer to be a function.');
	  }
	
	  var currentReducer = reducer;
	  var currentState = preloadedState;
	  var currentListeners = [];
	  var nextListeners = currentListeners;
	  var isDispatching = false;
	
	  function ensureCanMutateNextListeners() {
	    if (nextListeners === currentListeners) {
	      nextListeners = currentListeners.slice();
	    }
	  }
	
	  /**
	   * Reads the state tree managed by the store.
	   *
	   * @returns {any} The current state tree of your application.
	   */
	  function getState() {
	    return currentState;
	  }
	
	  /**
	   * Adds a change listener. It will be called any time an action is dispatched,
	   * and some part of the state tree may potentially have changed. You may then
	   * call `getState()` to read the current state tree inside the callback.
	   *
	   * You may call `dispatch()` from a change listener, with the following
	   * caveats:
	   *
	   * 1. The subscriptions are snapshotted just before every `dispatch()` call.
	   * If you subscribe or unsubscribe while the listeners are being invoked, this
	   * will not have any effect on the `dispatch()` that is currently in progress.
	   * However, the next `dispatch()` call, whether nested or not, will use a more
	   * recent snapshot of the subscription list.
	   *
	   * 2. The listener should not expect to see all state changes, as the state
	   * might have been updated multiple times during a nested `dispatch()` before
	   * the listener is called. It is, however, guaranteed that all subscribers
	   * registered before the `dispatch()` started will be called with the latest
	   * state by the time it exits.
	   *
	   * @param {Function} listener A callback to be invoked on every dispatch.
	   * @returns {Function} A function to remove this change listener.
	   */
	  function subscribe(listener) {
	    if (typeof listener !== 'function') {
	      throw new Error('Expected listener to be a function.');
	    }
	
	    var isSubscribed = true;
	
	    ensureCanMutateNextListeners();
	    nextListeners.push(listener);
	
	    return function unsubscribe() {
	      if (!isSubscribed) {
	        return;
	      }
	
	      isSubscribed = false;
	
	      ensureCanMutateNextListeners();
	      var index = nextListeners.indexOf(listener);
	      nextListeners.splice(index, 1);
	    };
	  }
	
	  /**
	   * Dispatches an action. It is the only way to trigger a state change.
	   *
	   * The `reducer` function, used to create the store, will be called with the
	   * current state tree and the given `action`. Its return value will
	   * be considered the **next** state of the tree, and the change listeners
	   * will be notified.
	   *
	   * The base implementation only supports plain object actions. If you want to
	   * dispatch a Promise, an Observable, a thunk, or something else, you need to
	   * wrap your store creating function into the corresponding middleware. For
	   * example, see the documentation for the `redux-thunk` package. Even the
	   * middleware will eventually dispatch plain object actions using this method.
	   *
	   * @param {Object} action A plain object representing “what changed”. It is
	   * a good idea to keep actions serializable so you can record and replay user
	   * sessions, or use the time travelling `redux-devtools`. An action must have
	   * a `type` property which may not be `undefined`. It is a good idea to use
	   * string constants for action types.
	   *
	   * @returns {Object} For convenience, the same action object you dispatched.
	   *
	   * Note that, if you use a custom middleware, it may wrap `dispatch()` to
	   * return something else (for example, a Promise you can await).
	   */
	  function dispatch(action) {
	    if (!(0, _isPlainObject2['default'])(action)) {
	      throw new Error('Actions must be plain objects. ' + 'Use custom middleware for async actions.');
	    }
	
	    if (typeof action.type === 'undefined') {
	      throw new Error('Actions may not have an undefined "type" property. ' + 'Have you misspelled a constant?');
	    }
	
	    if (isDispatching) {
	      throw new Error('Reducers may not dispatch actions.');
	    }
	
	    try {
	      isDispatching = true;
	      currentState = currentReducer(currentState, action);
	    } finally {
	      isDispatching = false;
	    }
	
	    var listeners = currentListeners = nextListeners;
	    for (var i = 0; i < listeners.length; i++) {
	      var listener = listeners[i];
	      listener();
	    }
	
	    return action;
	  }
	
	  /**
	   * Replaces the reducer currently used by the store to calculate the state.
	   *
	   * You might need this if your app implements code splitting and you want to
	   * load some of the reducers dynamically. You might also need this if you
	   * implement a hot reloading mechanism for Redux.
	   *
	   * @param {Function} nextReducer The reducer for the store to use instead.
	   * @returns {void}
	   */
	  function replaceReducer(nextReducer) {
	    if (typeof nextReducer !== 'function') {
	      throw new Error('Expected the nextReducer to be a function.');
	    }
	
	    currentReducer = nextReducer;
	    dispatch({ type: ActionTypes.INIT });
	  }
	
	  /**
	   * Interoperability point for observable/reactive libraries.
	   * @returns {observable} A minimal observable of state changes.
	   * For more information, see the observable proposal:
	   * https://github.com/tc39/proposal-observable
	   */
	  function observable() {
	    var _ref;
	
	    var outerSubscribe = subscribe;
	    return _ref = {
	      /**
	       * The minimal observable subscription method.
	       * @param {Object} observer Any object that can be used as an observer.
	       * The observer object should have a `next` method.
	       * @returns {subscription} An object with an `unsubscribe` method that can
	       * be used to unsubscribe the observable from the store, and prevent further
	       * emission of values from the observable.
	       */
	      subscribe: function subscribe(observer) {
	        if ((typeof observer === 'undefined' ? 'undefined' : _typeof(observer)) !== 'object') {
	          throw new TypeError('Expected the observer to be an object.');
	        }
	
	        function observeState() {
	          if (observer.next) {
	            observer.next(getState());
	          }
	        }
	
	        observeState();
	        var unsubscribe = outerSubscribe(observeState);
	        return { unsubscribe: unsubscribe };
	      }
	    }, _ref[_symbolObservable2['default']] = function () {
	      return this;
	    }, _ref;
	  }
	
	  // When a store is created, an "INIT" action is dispatched so that every
	  // reducer returns their initial state. This effectively populates
	  // the initial state tree.
	  dispatch({ type: ActionTypes.INIT });
	
	  return _ref2 = {
	    dispatch: dispatch,
	    subscribe: subscribe,
	    getState: getState,
	    replaceReducer: replaceReducer
	  }, _ref2[_symbolObservable2['default']] = observable, _ref2;
	}

/***/ },
/* 515 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports['default'] = combineReducers;
	
	var _createStore = __webpack_require__(514);
	
	var _isPlainObject = __webpack_require__(537);
	
	var _isPlainObject2 = _interopRequireDefault(_isPlainObject);
	
	var _warning = __webpack_require__(521);
	
	var _warning2 = _interopRequireDefault(_warning);
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	function getUndefinedStateErrorMessage(key, action) {
	  var actionType = action && action.type;
	  var actionName = actionType && '"' + actionType.toString() + '"' || 'an action';
	
	  return 'Given action ' + actionName + ', reducer "' + key + '" returned undefined. ' + 'To ignore an action, you must explicitly return the previous state. ' + 'If you want this reducer to hold no value, you can return null instead of undefined.';
	}
	
	function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
	  var reducerKeys = Object.keys(reducers);
	  var argumentName = action && action.type === _createStore.ActionTypes.INIT ? 'preloadedState argument passed to createStore' : 'previous state received by the reducer';
	
	  if (reducerKeys.length === 0) {
	    return 'Store does not have a valid reducer. Make sure the argument passed ' + 'to combineReducers is an object whose values are reducers.';
	  }
	
	  if (!(0, _isPlainObject2['default'])(inputState)) {
	    return 'The ' + argumentName + ' has unexpected type of "' + {}.toString.call(inputState).match(/\s([a-z|A-Z]+)/)[1] + '". Expected argument to be an object with the following ' + ('keys: "' + reducerKeys.join('", "') + '"');
	  }
	
	  var unexpectedKeys = Object.keys(inputState).filter(function (key) {
	    return !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key];
	  });
	
	  unexpectedKeys.forEach(function (key) {
	    unexpectedKeyCache[key] = true;
	  });
	
	  if (unexpectedKeys.length > 0) {
	    return 'Unexpected ' + (unexpectedKeys.length > 1 ? 'keys' : 'key') + ' ' + ('"' + unexpectedKeys.join('", "') + '" found in ' + argumentName + '. ') + 'Expected to find one of the known reducer keys instead: ' + ('"' + reducerKeys.join('", "') + '". Unexpected keys will be ignored.');
	  }
	}
	
	function assertReducerShape(reducers) {
	  Object.keys(reducers).forEach(function (key) {
	    var reducer = reducers[key];
	    var initialState = reducer(undefined, { type: _createStore.ActionTypes.INIT });
	
	    if (typeof initialState === 'undefined') {
	      throw new Error('Reducer "' + key + '" returned undefined during initialization. ' + 'If the state passed to the reducer is undefined, you must ' + 'explicitly return the initial state. The initial state may ' + 'not be undefined. If you don\'t want to set a value for this reducer, ' + 'you can use null instead of undefined.');
	    }
	
	    var type = '@@redux/PROBE_UNKNOWN_ACTION_' + Math.random().toString(36).substring(7).split('').join('.');
	    if (typeof reducer(undefined, { type: type }) === 'undefined') {
	      throw new Error('Reducer "' + key + '" returned undefined when probed with a random type. ' + ('Don\'t try to handle ' + _createStore.ActionTypes.INIT + ' or other actions in "redux/*" ') + 'namespace. They are considered private. Instead, you must return the ' + 'current state for any unknown actions, unless it is undefined, ' + 'in which case you must return the initial state, regardless of the ' + 'action type. The initial state may not be undefined, but can be null.');
	    }
	  });
	}
	
	/**
	 * Turns an object whose values are different reducer functions, into a single
	 * reducer function. It will call every child reducer, and gather their results
	 * into a single state object, whose keys correspond to the keys of the passed
	 * reducer functions.
	 *
	 * @param {Object} reducers An object whose values correspond to different
	 * reducer functions that need to be combined into one. One handy way to obtain
	 * it is to use ES6 `import * as reducers` syntax. The reducers may never return
	 * undefined for any action. Instead, they should return their initial state
	 * if the state passed to them was undefined, and the current state for any
	 * unrecognized action.
	 *
	 * @returns {Function} A reducer function that invokes every reducer inside the
	 * passed object, and builds a state object with the same shape.
	 */
	function combineReducers(reducers) {
	  var reducerKeys = Object.keys(reducers);
	  var finalReducers = {};
	  for (var i = 0; i < reducerKeys.length; i++) {
	    var key = reducerKeys[i];
	
	    if (true) {
	      if (typeof reducers[key] === 'undefined') {
	        (0, _warning2['default'])('No reducer provided for key "' + key + '"');
	      }
	    }
	
	    if (typeof reducers[key] === 'function') {
	      finalReducers[key] = reducers[key];
	    }
	  }
	  var finalReducerKeys = Object.keys(finalReducers);
	
	  var unexpectedKeyCache = void 0;
	  if (true) {
	    unexpectedKeyCache = {};
	  }
	
	  var shapeAssertionError = void 0;
	  try {
	    assertReducerShape(finalReducers);
	  } catch (e) {
	    shapeAssertionError = e;
	  }
	
	  return function combination() {
	    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
	    var action = arguments[1];
	
	    if (shapeAssertionError) {
	      throw shapeAssertionError;
	    }
	
	    if (true) {
	      var warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);
	      if (warningMessage) {
	        (0, _warning2['default'])(warningMessage);
	      }
	    }
	
	    var hasChanged = false;
	    var nextState = {};
	    for (var _i = 0; _i < finalReducerKeys.length; _i++) {
	      var _key = finalReducerKeys[_i];
	      var reducer = finalReducers[_key];
	      var previousStateForKey = state[_key];
	      var nextStateForKey = reducer(previousStateForKey, action);
	      if (typeof nextStateForKey === 'undefined') {
	        var errorMessage = getUndefinedStateErrorMessage(_key, action);
	        throw new Error(errorMessage);
	      }
	      nextState[_key] = nextStateForKey;
	      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
	    }
	    return hasChanged ? nextState : state;
	  };
	}

/***/ },
/* 516 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	exports.__esModule = true;
	exports['default'] = bindActionCreators;
	function bindActionCreator(actionCreator, dispatch) {
	  return function () {
	    return dispatch(actionCreator.apply(undefined, arguments));
	  };
	}
	
	/**
	 * Turns an object whose values are action creators, into an object with the
	 * same keys, but with every function wrapped into a `dispatch` call so they
	 * may be invoked directly. This is just a convenience method, as you can call
	 * `store.dispatch(MyActionCreators.doSomething())` yourself just fine.
	 *
	 * For convenience, you can also pass a single function as the first argument,
	 * and get a function in return.
	 *
	 * @param {Function|Object} actionCreators An object whose values are action
	 * creator functions. One handy way to obtain it is to use ES6 `import * as`
	 * syntax. You may also pass a single function.
	 *
	 * @param {Function} dispatch The `dispatch` function available on your Redux
	 * store.
	 *
	 * @returns {Function|Object} The object mimicking the original object, but with
	 * every action creator wrapped into the `dispatch` call. If you passed a
	 * function as `actionCreators`, the return value will also be a single
	 * function.
	 */
	function bindActionCreators(actionCreators, dispatch) {
	  if (typeof actionCreators === 'function') {
	    return bindActionCreator(actionCreators, dispatch);
	  }
	
	  if ((typeof actionCreators === 'undefined' ? 'undefined' : _typeof(actionCreators)) !== 'object' || actionCreators === null) {
	    throw new Error('bindActionCreators expected an object or a function, instead received ' + (actionCreators === null ? 'null' : typeof actionCreators === 'undefined' ? 'undefined' : _typeof(actionCreators)) + '. ' + 'Did you write "import ActionCreators from" instead of "import * as ActionCreators from"?');
	  }
	
	  var keys = Object.keys(actionCreators);
	  var boundActionCreators = {};
	  for (var i = 0; i < keys.length; i++) {
	    var key = keys[i];
	    var actionCreator = actionCreators[key];
	    if (typeof actionCreator === 'function') {
	      boundActionCreators[key] = bindActionCreator(actionCreator, dispatch);
	    }
	  }
	  return boundActionCreators;
	}

/***/ },
/* 517 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	
	var _extends = Object.assign || function (target) {
	  for (var i = 1; i < arguments.length; i++) {
	    var source = arguments[i];for (var key in source) {
	      if (Object.prototype.hasOwnProperty.call(source, key)) {
	        target[key] = source[key];
	      }
	    }
	  }return target;
	};
	
	exports['default'] = applyMiddleware;
	
	var _compose = __webpack_require__(518);
	
	var _compose2 = _interopRequireDefault(_compose);
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	/**
	 * Creates a store enhancer that applies middleware to the dispatch method
	 * of the Redux store. This is handy for a variety of tasks, such as expressing
	 * asynchronous actions in a concise manner, or logging every action payload.
	 *
	 * See `redux-thunk` package as an example of the Redux middleware.
	 *
	 * Because middleware is potentially asynchronous, this should be the first
	 * store enhancer in the composition chain.
	 *
	 * Note that each middleware will be given the `dispatch` and `getState` functions
	 * as named arguments.
	 *
	 * @param {...Function} middlewares The middleware chain to be applied.
	 * @returns {Function} A store enhancer applying the middleware.
	 */
	function applyMiddleware() {
	  for (var _len = arguments.length, middlewares = Array(_len), _key = 0; _key < _len; _key++) {
	    middlewares[_key] = arguments[_key];
	  }
	
	  return function (createStore) {
	    return function (reducer, preloadedState, enhancer) {
	      var store = createStore(reducer, preloadedState, enhancer);
	      var _dispatch = store.dispatch;
	      var chain = [];
	
	      var middlewareAPI = {
	        getState: store.getState,
	        dispatch: function dispatch(action) {
	          return _dispatch(action);
	        }
	      };
	      chain = middlewares.map(function (middleware) {
	        return middleware(middlewareAPI);
	      });
	      _dispatch = _compose2['default'].apply(undefined, chain)(store.dispatch);
	
	      return _extends({}, store, {
	        dispatch: _dispatch
	      });
	    };
	  };
	}

/***/ },
/* 518 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	exports.__esModule = true;
	exports["default"] = compose;
	/**
	 * Composes single-argument functions from right to left. The rightmost
	 * function can take multiple arguments as it provides the signature for
	 * the resulting composite function.
	 *
	 * @param {...Function} funcs The functions to compose.
	 * @returns {Function} A function obtained by composing the argument functions
	 * from right to left. For example, compose(f, g, h) is identical to doing
	 * (...args) => f(g(h(...args))).
	 */
	
	function compose() {
	  for (var _len = arguments.length, funcs = Array(_len), _key = 0; _key < _len; _key++) {
	    funcs[_key] = arguments[_key];
	  }
	
	  if (funcs.length === 0) {
	    return function (arg) {
	      return arg;
	    };
	  }
	
	  if (funcs.length === 1) {
	    return funcs[0];
	  }
	
	  return funcs.reduce(function (a, b) {
	    return function () {
	      return a(b.apply(undefined, arguments));
	    };
	  });
	}

/***/ },
/* 519 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(process) {// Generated by CoffeeScript 1.7.1
	(function () {
	  var getNanoSeconds, hrtime, loadTime;
	
	  if (typeof performance !== "undefined" && performance !== null && performance.now) {
	    module.exports = function () {
	      return performance.now();
	    };
	  } else if (typeof process !== "undefined" && process !== null && process.hrtime) {
	    module.exports = function () {
	      return (getNanoSeconds() - loadTime) / 1e6;
	    };
	    hrtime = process.hrtime;
	    getNanoSeconds = function getNanoSeconds() {
	      var hr;
	      hr = hrtime();
	      return hr[0] * 1e9 + hr[1];
	    };
	    loadTime = getNanoSeconds();
	  } else if (Date.now) {
	    module.exports = function () {
	      return Date.now() - loadTime;
	    };
	    loadTime = Date.now();
	  } else {
	    module.exports = function () {
	      return new Date().getTime() - loadTime;
	    };
	    loadTime = new Date().getTime();
	  }
	}).call(this);
	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(546)))

/***/ },
/* 520 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	Object.defineProperty(exports, '__esModule', {
	    value: true
	});
	
	var _slicedToArray = function () {
	    function sliceIterator(arr, i) {
	        var _arr = [];var _n = true;var _d = false;var _e = undefined;try {
	            for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
	                _arr.push(_s.value);if (i && _arr.length === i) break;
	            }
	        } catch (err) {
	            _d = true;_e = err;
	        } finally {
	            try {
	                if (!_n && _i['return']) _i['return']();
	            } finally {
	                if (_d) throw _e;
	            }
	        }return _arr;
	    }return function (arr, i) {
	        if (Array.isArray(arr)) {
	            return arr;
	        } else if (Symbol.iterator in Object(arr)) {
	            return sliceIterator(arr, i);
	        } else {
	            throw new TypeError('Invalid attempt to destructure non-iterable instance');
	        }
	    };
	}();
	
	function _interopRequireDefault(obj) {
	    return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	var _inlineStylePrefixAll = __webpack_require__(552);
	
	var _inlineStylePrefixAll2 = _interopRequireDefault(_inlineStylePrefixAll);
	
	var _util = __webpack_require__(471);
	
	var generateCSS = function generateCSS(selector, styleTypes, stringHandlers, useImportant) {
	    var merged = styleTypes.reduce(_util.recursiveMerge);
	
	    var declarations = {};
	    var mediaQueries = {};
	    var pseudoStyles = {};
	
	    Object.keys(merged).forEach(function (key) {
	        if (key[0] === ':') {
	            pseudoStyles[key] = merged[key];
	        } else if (key[0] === '@') {
	            mediaQueries[key] = merged[key];
	        } else {
	            declarations[key] = merged[key];
	        }
	    });
	
	    return generateCSSRuleset(selector, declarations, stringHandlers, useImportant) + Object.keys(pseudoStyles).map(function (pseudoSelector) {
	        return generateCSSRuleset(selector + pseudoSelector, pseudoStyles[pseudoSelector], stringHandlers, useImportant);
	    }).join("") + Object.keys(mediaQueries).map(function (mediaQuery) {
	        var ruleset = generateCSS(selector, [mediaQueries[mediaQuery]], stringHandlers, useImportant);
	        return mediaQuery + '{' + ruleset + '}';
	    }).join("");
	};
	
	exports.generateCSS = generateCSS;
	var runStringHandlers = function runStringHandlers(declarations, stringHandlers) {
	    var result = {};
	
	    Object.keys(declarations).forEach(function (key) {
	        // If a handler exists for this particular key, let it interpret
	        // that value first before continuing
	        if (stringHandlers && stringHandlers.hasOwnProperty(key)) {
	            result[key] = stringHandlers[key](declarations[key]);
	        } else {
	            result[key] = declarations[key];
	        }
	    });
	
	    return result;
	};
	
	var generateCSSRuleset = function generateCSSRuleset(selector, declarations, stringHandlers, useImportant) {
	    var handledDeclarations = runStringHandlers(declarations, stringHandlers);
	
	    var prefixedDeclarations = (0, _inlineStylePrefixAll2['default'])(handledDeclarations);
	
	    var prefixedRules = (0, _util.flatten)((0, _util.objectToPairs)(prefixedDeclarations).map(function (_ref) {
	        var _ref2 = _slicedToArray(_ref, 2);
	
	        var key = _ref2[0];
	        var value = _ref2[1];
	
	        if (Array.isArray(value)) {
	            var _ret = function () {
	                // inline-style-prefix-all returns an array when there should be
	                // multiple rules, we will flatten to single rules
	
	                var prefixedValues = [];
	                var unprefixedValues = [];
	
	                value.forEach(function (v) {
	                    if (v.indexOf('-') === 0) {
	                        prefixedValues.push(v);
	                    } else {
	                        unprefixedValues.push(v);
	                    }
	                });
	
	                prefixedValues.sort();
	                unprefixedValues.sort();
	
	                return {
	                    v: prefixedValues.concat(unprefixedValues).map(function (v) {
	                        return [key, v];
	                    })
	                };
	            }();
	
	            if ((typeof _ret === 'undefined' ? 'undefined' : _typeof(_ret)) === 'object') return _ret.v;
	        }
	        return [[key, value]];
	    }));
	
	    var rules = prefixedRules.map(function (_ref3) {
	        var _ref32 = _slicedToArray(_ref3, 2);
	
	        var key = _ref32[0];
	        var value = _ref32[1];
	
	        var stringValue = (0, _util.stringifyValue)(key, value);
	        var ret = (0, _util.kebabifyStyleName)(key) + ':' + stringValue + ';';
	        return useImportant === false ? ret : (0, _util.importantify)(ret);
	    }).join("");
	
	    if (rules) {
	        return selector + '{' + rules + '}';
	    } else {
	        return "";
	    }
	};
	exports.generateCSSRuleset = generateCSSRuleset;

/***/ },
/* 521 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	exports.__esModule = true;
	exports['default'] = warning;
	/**
	 * Prints a warning in the console if it exists.
	 *
	 * @param {String} message The warning message.
	 * @returns {void}
	 */
	function warning(message) {
	  /* eslint-disable no-console */
	  if (typeof console !== 'undefined' && typeof console.error === 'function') {
	    console.error(message);
	  }
	  /* eslint-enable no-console */
	  try {
	    // This error was thrown as a convenience so that if you enable
	    // "break on all exceptions" in your console,
	    // it would pause the execution at this line.
	    throw new Error(message);
	    /* eslint-disable no-empty */
	  } catch (e) {}
	  /* eslint-enable no-empty */
	}

/***/ },
/* 522 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A popover that renders a set of keys floating above the page.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet;
	
	var _require2 = __webpack_require__(357),
	    View = _require2.View;
	
	var _require3 = __webpack_require__(295),
	    keyConfigPropType = _require3.keyConfigPropType;
	
	var _require4 = __webpack_require__(283),
	    BorderStyles = _require4.BorderStyles;
	
	var zIndexes = __webpack_require__(363);
	
	var MultiSymbolPopover = function (_React$Component) {
	    _inherits(MultiSymbolPopover, _React$Component);
	
	    function MultiSymbolPopover() {
	        _classCallCheck(this, MultiSymbolPopover);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    MultiSymbolPopover.prototype.render = function render() {
	        var keys = this.props.keys;
	
	        // TODO(charlie): We have to require this lazily because of a cyclic
	        // dependence in our components.
	
	        var TouchableKeypadButton = __webpack_require__(418);
	        return React.createElement(
	            View,
	            { style: styles.container },
	            keys.map(function (key) {
	                return React.createElement(TouchableKeypadButton, {
	                    key: key.id,
	                    keyConfig: key,
	                    borders: BorderStyles.NONE
	                });
	            })
	        );
	    };
	
	    return MultiSymbolPopover;
	}(React.Component);
	
	MultiSymbolPopover.propTypes = {
	    keys: React.PropTypes.arrayOf(keyConfigPropType)
	};
	
	
	var styles = StyleSheet.create({
	    container: {
	        flexDirection: 'column-reverse',
	        position: 'relative',
	        width: '100%',
	        borderRadius: 2,
	        boxShadow: '0 2px 6px rgba(0, 0, 0, 0.3)',
	        zIndex: zIndexes.popover
	    },
	
	    popoverButton: {
	        backgroundColor: '#FFF',
	        borderWidth: 0
	    }
	});
	
	module.exports = MultiSymbolPopover;

/***/ },
/* 523 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */
	
	if (true) {
	  var ReactIs = __webpack_require__(553);
	
	  // By explicitly using `prop-types` you are opting into new development behavior.
	  // http://fb.me/prop-types-in-prod
	  var throwOnDirectAccess = true;
	  module.exports = __webpack_require__(541)(ReactIs.isElement, throwOnDirectAccess);
	} else {
	  // By explicitly using `prop-types` you are opting into new production behavior.
	  // http://fb.me/prop-types-in-prod
	  module.exports = require('./factoryWithThrowingShims')();
	}

/***/ },
/* 524 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A component that renders an icon for a symbol with the given name.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet;
	
	var MathIcon = __webpack_require__(542);
	var SvgIcon = __webpack_require__(543);
	var TextIcon = __webpack_require__(544);
	
	var _require2 = __webpack_require__(283),
	    IconTypes = _require2.IconTypes;
	
	var _require3 = __webpack_require__(295),
	    iconPropType = _require3.iconPropType;
	
	var _require4 = __webpack_require__(355),
	    gray25 = _require4.gray25;
	
	var focusedColor = '#FFF';
	var unfocusedColor = gray25;
	
	var Icon = function (_React$PureComponent) {
	    _inherits(Icon, _React$PureComponent);
	
	    function Icon() {
	        _classCallCheck(this, Icon);
	
	        return _possibleConstructorReturn(this, _React$PureComponent.apply(this, arguments));
	    }
	
	    Icon.prototype.render = function render() {
	        var _props = this.props,
	            focused = _props.focused,
	            icon = _props.icon,
	            style = _props.style;
	
	
	        var styleWithFocus = [focused ? styles.focused : styles.unfocused].concat(Array.isArray(style) ? style : [style]);
	
	        switch (icon.type) {
	            case IconTypes.MATH:
	                return React.createElement(MathIcon, {
	                    math: icon.data,
	                    style: styleWithFocus
	                });
	
	            case IconTypes.SVG:
	                // TODO(charlie): Support passing style objects to `SvgIcon`.
	                // This will require migrating the individual icons to use
	                // `currentColor` and accept a `className` prop, rather than
	                // relying on an explicit color prop.
	                return React.createElement(SvgIcon, {
	                    name: icon.data,
	                    color: focused ? focusedColor : unfocusedColor
	                });
	
	            case IconTypes.TEXT:
	                return React.createElement(TextIcon, {
	                    character: icon.data,
	                    style: styleWithFocus
	                });
	        }
	
	        throw new Error("No icon or symbol provided");
	    };
	
	    return Icon;
	}(React.PureComponent);
	
	Icon.propTypes = {
	    focused: React.PropTypes.bool,
	    icon: iconPropType.isRequired,
	    // An Aphrodite style object, or an array of Aphrodite style objects.
	    // Note that custom styles will only be applied to text and math icons
	    // (and not SVG icons).
	    style: React.PropTypes.any
	};
	
	
	var styles = StyleSheet.create({
	    unfocused: {
	        color: unfocusedColor
	    },
	
	    focused: {
	        color: focusedColor
	    }
	});
	
	module.exports = Icon;

/***/ },
/* 525 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A grid of symbols, rendered as text and positioned based on the number of
	 * symbols provided. Up to four symbols will be shown.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet;
	
	var _require2 = __webpack_require__(357),
	    View = _require2.View;
	
	var Icon = __webpack_require__(524);
	
	var _require3 = __webpack_require__(283),
	    IconTypes = _require3.IconTypes;
	
	var _require4 = __webpack_require__(295),
	    iconPropType = _require4.iconPropType;
	
	var _require5 = __webpack_require__(364),
	    row = _require5.row,
	    column = _require5.column,
	    centered = _require5.centered,
	    fullWidth = _require5.fullWidth;
	
	var _require6 = __webpack_require__(355),
	    iconSizeHeightPx = _require6.iconSizeHeightPx,
	    iconSizeWidthPx = _require6.iconSizeWidthPx;
	
	var MultiSymbolGrid = function (_React$Component) {
	    _inherits(MultiSymbolGrid, _React$Component);
	
	    function MultiSymbolGrid() {
	        _classCallCheck(this, MultiSymbolGrid);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    MultiSymbolGrid.prototype.render = function render() {
	        var _props = this.props,
	            focused = _props.focused,
	            icons = _props.icons;
	
	        // Validate that we only received math-based icons. Right now, this
	        // component only supports math icons (and it should only be passed
	        // variables and Greek letters, which are always rendered as math).
	        // Supporting other types of icons is possible but would require
	        // some styles coercion and doesn't seem worthwhile right now.
	
	        icons.forEach(function (icon) {
	            if (icon.type !== IconTypes.MATH) {
	                throw new Error('Received invalid icon: type=' + icon.type + ', ' + ('data=' + icon.data));
	            }
	        });
	
	        if (icons.length === 1) {
	            return React.createElement(Icon, { icon: icons[0], focused: focused });
	        } else {
	            var primaryIconStyle = styles.base;
	            var secondaryIconStyle = [styles.base, styles.secondary];
	
	            if (icons.length === 2) {
	                return React.createElement(
	                    View,
	                    { style: [row, styles.size] },
	                    React.createElement(
	                        View,
	                        { style: [column, centered, fullWidth, styles.middleLeft]
	                        },
	                        React.createElement(Icon, {
	                            style: primaryIconStyle,
	                            icon: icons[0],
	                            focused: focused
	                        })
	                    ),
	                    React.createElement(
	                        View,
	                        { style: [column, centered, fullWidth, styles.middleRight]
	                        },
	                        React.createElement(Icon, {
	                            style: secondaryIconStyle,
	                            icon: icons[1],
	                            focused: focused
	                        })
	                    )
	                );
	            } else if (icons.length >= 3) {
	                return React.createElement(
	                    View,
	                    { style: [column, styles.size] },
	                    React.createElement(
	                        View,
	                        { style: row },
	                        React.createElement(
	                            View,
	                            { style: [centered, fullWidth, styles.topLeft] },
	                            React.createElement(Icon, {
	                                style: primaryIconStyle,
	                                icon: icons[0],
	                                focused: focused
	                            })
	                        ),
	                        React.createElement(
	                            View,
	                            { style: [centered, fullWidth, styles.topRight] },
	                            React.createElement(Icon, {
	                                style: secondaryIconStyle,
	                                icon: icons[1],
	                                focused: focused
	                            })
	                        )
	                    ),
	                    React.createElement(
	                        View,
	                        { style: row },
	                        React.createElement(
	                            View,
	                            { style: [centered, fullWidth, styles.bottomLeft] },
	                            React.createElement(Icon, {
	                                style: secondaryIconStyle,
	                                icon: icons[2],
	                                focused: focused
	                            })
	                        ),
	                        React.createElement(
	                            View,
	                            { style: [centered, fullWidth, styles.bottomRight] },
	                            icons[3] && React.createElement(Icon, {
	                                style: secondaryIconStyle,
	                                icon: icons[3],
	                                focused: focused
	                            })
	                        )
	                    )
	                );
	            }
	        }
	
	        throw new Error("Invalid number of icons:", icons.length);
	    };
	
	    return MultiSymbolGrid;
	}(React.Component);
	
	MultiSymbolGrid.propTypes = {
	    focused: React.PropTypes.bool,
	    icons: React.PropTypes.arrayOf(iconPropType).isRequired
	};
	
	
	var verticalInsetPx = 2;
	var horizontalInsetPx = 4;
	
	var styles = StyleSheet.create({
	    size: {
	        height: iconSizeHeightPx,
	        width: iconSizeWidthPx
	    },
	
	    // For the three- and four-icon layouts.
	    bottomLeft: {
	        marginBottom: verticalInsetPx,
	        marginLeft: horizontalInsetPx
	    },
	    topLeft: {
	        marginTop: verticalInsetPx,
	        marginLeft: horizontalInsetPx
	    },
	    topRight: {
	        marginTop: verticalInsetPx,
	        marginRight: horizontalInsetPx
	    },
	    bottomRight: {
	        marginBottom: verticalInsetPx,
	        marginRight: horizontalInsetPx
	    },
	
	    // For the two-icon layout.
	    middleLeft: {
	        marginLeft: horizontalInsetPx
	    },
	    middleRight: {
	        marginRight: horizontalInsetPx
	    },
	
	    base: {
	        fontSize: 18
	    },
	
	    secondary: {
	        opacity: 0.3
	    }
	});
	
	module.exports = MultiSymbolGrid;

/***/ },
/* 526 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A small triangular decal to sit in the corner of a parent component.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet;
	
	var _require2 = __webpack_require__(357),
	    View = _require2.View;
	
	var _require3 = __webpack_require__(355),
	    gray25 = _require3.gray25;
	
	var CornerDecal = function (_React$Component) {
	    _inherits(CornerDecal, _React$Component);
	
	    function CornerDecal() {
	        _classCallCheck(this, CornerDecal);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    CornerDecal.prototype.render = function render() {
	        var style = this.props.style;
	
	
	        var containerStyle = [styles.container].concat(Array.isArray(style) ? style : [style]);
	
	        return React.createElement(
	            View,
	            { style: containerStyle },
	            React.createElement(
	                'svg',
	                {
	                    width: triangleSizePx,
	                    height: triangleSizePx,
	                    viewBox: '4 4 8 8'
	                },
	                React.createElement('path', {
	                    fill: gray25,
	                    opacity: '0.3',
	                    d: 'M5.29289322,5.70710678 L10.2928932,10.7071068 C10.9228581,11.3370716 12,10.8909049 12,10 L12,5 C12,4.44771525 11.5522847,4 11,4 L6,4 C5.10909515,4 4.66292836,5.07714192 5.29289322,5.70710678 Z' // @Nolint
	                })
	            )
	        );
	    };
	
	    return CornerDecal;
	}(React.Component);
	
	CornerDecal.propTypes = {
	    style: React.PropTypes.any
	};
	
	
	var triangleSizePx = 7;
	
	var styles = StyleSheet.create({
	    container: {
	        position: "absolute",
	        top: 0,
	        right: 0,
	        width: triangleSizePx,
	        height: triangleSizePx
	    }
	});
	
	module.exports = CornerDecal;

/***/ },
/* 527 */
/***/ function(module, exports, __webpack_require__) {

	/* NOTE: This mimics what we do in webapp and links to our custom version of
	React -- this was not added with npm */
	module.exports = __webpack_require__(43).__internalAddons.CSSTransitionGroup;


/***/ },
/* 528 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var isNode = __webpack_require__(545);
	
	/**
	 * @param {*} object The object to check.
	 * @return {boolean} Whether or not the object is a DOM text node.
	 */
	function isTextNode(object) {
	  return isNode(object) && object.nodeType == 3;
	}
	
	module.exports = isTextNode;

/***/ },
/* 529 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var _hyphenPattern = /-(.)/g;
	
	/**
	 * Camelcases a hyphenated string, for example:
	 *
	 *   > camelize('background-color')
	 *   < "backgroundColor"
	 *
	 * @param {string} string
	 * @return {string}
	 */
	function camelize(string) {
	  return string.replace(_hyphenPattern, function (_, character) {
	    return character.toUpperCase();
	  });
	}
	
	module.exports = camelize;

/***/ },
/* 530 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	var _uppercasePattern = /([A-Z])/g;
	
	/**
	 * Hyphenates a camelcased string, for example:
	 *
	 *   > hyphenate('backgroundColor')
	 *   < "background-color"
	 *
	 * For CSS style names, use `hyphenateStyleName` instead which works properly
	 * with all vendor prefixes, including `ms`.
	 *
	 * @param {string} string
	 * @return {string}
	 */
	function hyphenate(string) {
	  return string.replace(_uppercasePattern, '-$1').toLowerCase();
	}
	
	module.exports = hyphenate;

/***/ },
/* 531 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule expandRangeToStartOfLine
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var UnicodeUtils = __webpack_require__(445);
	
	var getRangeClientRects = __webpack_require__(426);
	var invariant = __webpack_require__(432);
	
	/**
	 * Return the computed line height, in pixels, for the provided element.
	 */
	function getLineHeightPx(element) {
	  var computed = getComputedStyle(element);
	  var div = document.createElement('div');
	  div.style.fontFamily = computed.fontFamily;
	  div.style.fontSize = computed.fontSize;
	  div.style.fontStyle = computed.fontStyle;
	  div.style.fontWeight = computed.fontWeight;
	  div.style.lineHeight = computed.lineHeight;
	  div.style.position = 'absolute';
	  div.textContent = 'M';
	
	  // forced layout here
	  document.body.appendChild(div);
	  var rect = div.getBoundingClientRect();
	  document.body.removeChild(div);
	
	  return rect.height;
	}
	
	/**
	 * Return whether every ClientRect in the provided list lies on the same line.
	 *
	 * We assume that the rects on the same line all contain the baseline, so the
	 * lowest top line needs to be above the highest bottom line (i.e., if you were
	 * to project the rects onto the y-axis, their intersection would be nonempty).
	 *
	 * In addition, we require that no two boxes are lineHeight (or more) apart at
	 * either top or bottom, which helps protect against false positives for fonts
	 * with extremely large glyph heights (e.g., with a font size of 17px, Zapfino
	 * produces rects of height 58px!).
	 */
	function areRectsOnOneLine(rects, lineHeight) {
	  var minTop = Infinity;
	  var minBottom = Infinity;
	  var maxTop = -Infinity;
	  var maxBottom = -Infinity;
	
	  for (var ii = 0; ii < rects.length; ii++) {
	    var rect = rects[ii];
	    if (rect.width === 0 || rect.width === 1) {
	      // When a range starts or ends a soft wrap, many browsers (Chrome, IE,
	      // Safari) include an empty rect on the previous or next line. When the
	      // text lies in a container whose position is not integral (e.g., from
	      // margin: auto), Safari makes these empty rects have width 1 (instead of
	      // 0). Having one-pixel-wide characters seems unlikely (and most browsers
	      // report widths in subpixel precision anyway) so it's relatively safe to
	      // skip over them.
	      continue;
	    }
	    minTop = Math.min(minTop, rect.top);
	    minBottom = Math.min(minBottom, rect.bottom);
	    maxTop = Math.max(maxTop, rect.top);
	    maxBottom = Math.max(maxBottom, rect.bottom);
	  }
	
	  return maxTop <= minBottom && maxTop - minTop < lineHeight && maxBottom - minBottom < lineHeight;
	}
	
	/**
	 * Return the length of a node, as used by Range offsets.
	 */
	function getNodeLength(node) {
	  // http://www.w3.org/TR/dom/#concept-node-length
	  switch (node.nodeType) {
	    case Node.DOCUMENT_TYPE_NODE:
	      return 0;
	    case Node.TEXT_NODE:
	    case Node.PROCESSING_INSTRUCTION_NODE:
	    case Node.COMMENT_NODE:
	      return node.length;
	    default:
	      return node.childNodes.length;
	  }
	}
	
	/**
	 * Given a collapsed range, move the start position backwards as far as
	 * possible while the range still spans only a single line.
	 */
	function expandRangeToStartOfLine(range) {
	  !range.collapsed ? true ? invariant(false, 'expandRangeToStartOfLine: Provided range is not collapsed.') : invariant(false) : undefined;
	  range = range.cloneRange();
	
	  var containingElement = range.startContainer;
	  if (containingElement.nodeType !== 1) {
	    containingElement = containingElement.parentNode;
	  }
	  var lineHeight = getLineHeightPx(containingElement);
	
	  // Imagine our text looks like:
	  //   <div><span>once upon a time, there was a <em>boy
	  //   who lived</em> </span><q><strong>under^ the
	  //   stairs</strong> in a small closet.</q></div>
	  // where the caret represents the cursor. First, we crawl up the tree until
	  // the range spans multiple lines (setting the start point to before
	  // "<strong>", then before "<div>"), then at each level we do a search to
	  // find the latest point which is still on a previous line. We'll find that
	  // the break point is inside the span, then inside the <em>, then in its text
	  // node child, the actual break point before "who".
	
	  var bestContainer = range.endContainer;
	  var bestOffset = range.endOffset;
	  range.setStart(range.startContainer, 0);
	
	  while (areRectsOnOneLine(getRangeClientRects(range), lineHeight)) {
	    bestContainer = range.startContainer;
	    bestOffset = range.startOffset;
	    !bestContainer.parentNode ? true ? invariant(false, 'Found unexpected detached subtree when traversing.') : invariant(false) : undefined;
	    range.setStartBefore(bestContainer);
	    if (bestContainer.nodeType === 1 && getComputedStyle(bestContainer).display !== 'inline') {
	      // The start of the line is never in a different block-level container.
	      break;
	    }
	  }
	
	  // In the above example, range now spans from "<div>" to "under",
	  // bestContainer is <div>, and bestOffset is 1 (index of <q> inside <div>)].
	  // Picking out which child to recurse into here is a special case since we
	  // don't want to check past <q> -- once we find that the final range starts
	  // in <span>, we can look at all of its children (and all of their children)
	  // to find the break point.
	
	  // At all times, (bestContainer, bestOffset) is the latest single-line start
	  // point that we know of.
	  var currentContainer = bestContainer;
	  var maxIndexToConsider = bestOffset - 1;
	
	  do {
	    var nodeValue = currentContainer.nodeValue;
	
	    for (var ii = maxIndexToConsider; ii >= 0; ii--) {
	      if (nodeValue != null && ii > 0 && UnicodeUtils.isSurrogatePair(nodeValue, ii - 1)) {
	        // We're in the middle of a surrogate pair -- skip over so we never
	        // return a range with an endpoint in the middle of a code point.
	        continue;
	      }
	
	      range.setStart(currentContainer, ii);
	      if (areRectsOnOneLine(getRangeClientRects(range), lineHeight)) {
	        bestContainer = currentContainer;
	        bestOffset = ii;
	      } else {
	        break;
	      }
	    }
	
	    if (ii === -1 || currentContainer.childNodes.length === 0) {
	      // If ii === -1, then (bestContainer, bestOffset), which is equal to
	      // (currentContainer, 0), was a single-line start point but a start
	      // point before currentContainer wasn't, so the line break seems to
	      // have occurred immediately after currentContainer's start tag
	      //
	      // If currentContainer.childNodes.length === 0, we're already at a
	      // terminal node (e.g., text node) and should return our current best.
	      break;
	    }
	
	    currentContainer = currentContainer.childNodes[ii];
	    maxIndexToConsider = getNodeLength(currentContainer);
	  } while (true);
	
	  range.setStart(bestContainer, bestOffset);
	  return range;
	}
	
	module.exports = expandRangeToStartOfLine;

/***/ },
/* 532 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule getDraftEditorSelectionWithNodes
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var findAncestorOffsetKey = __webpack_require__(454);
	var getSelectionOffsetKeyForNode = __webpack_require__(494);
	var getUpdatedSelectionState = __webpack_require__(456);
	var invariant = __webpack_require__(432);
	var nullthrows = __webpack_require__(442);
	
	/**
	 * Convert the current selection range to an anchor/focus pair of offset keys
	 * and values that can be interpreted by components.
	 */
	function getDraftEditorSelectionWithNodes(editorState, root, anchorNode, anchorOffset, focusNode, focusOffset) {
	  var anchorIsTextNode = anchorNode.nodeType === Node.TEXT_NODE;
	  var focusIsTextNode = focusNode.nodeType === Node.TEXT_NODE;
	
	  // If the selection range lies only on text nodes, the task is simple.
	  // Find the nearest offset-aware elements and use the
	  // offset values supplied by the selection range.
	  if (anchorIsTextNode && focusIsTextNode) {
	    return {
	      selectionState: getUpdatedSelectionState(editorState, nullthrows(findAncestorOffsetKey(anchorNode)), anchorOffset, nullthrows(findAncestorOffsetKey(focusNode)), focusOffset),
	      needsRecovery: false
	    };
	  }
	
	  var anchorPoint = null;
	  var focusPoint = null;
	  var needsRecovery = true;
	
	  // An element is selected. Convert this selection range into leaf offset
	  // keys and offset values for consumption at the component level. This
	  // is common in Firefox, where select-all and triple click behavior leads
	  // to entire elements being selected.
	  //
	  // Note that we use the `needsRecovery` parameter in the callback here. This
	  // is because when certain elements are selected, the behavior for subsequent
	  // cursor movement (e.g. via arrow keys) is uncertain and may not match
	  // expectations at the component level. For example, if an entire <div> is
	  // selected and the user presses the right arrow, Firefox keeps the selection
	  // on the <div>. If we allow subsequent keypresses to insert characters
	  // natively, they will be inserted into a browser-created text node to the
	  // right of that <div>. This is obviously undesirable.
	  //
	  // With the `needsRecovery` flag, we inform the caller that it is responsible
	  // for manually setting the selection state on the rendered document to
	  // ensure proper selection state maintenance.
	
	  if (anchorIsTextNode) {
	    anchorPoint = {
	      key: nullthrows(findAncestorOffsetKey(anchorNode)),
	      offset: anchorOffset
	    };
	    focusPoint = getPointForNonTextNode(root, focusNode, focusOffset);
	  } else if (focusIsTextNode) {
	    focusPoint = {
	      key: nullthrows(findAncestorOffsetKey(focusNode)),
	      offset: focusOffset
	    };
	    anchorPoint = getPointForNonTextNode(root, anchorNode, anchorOffset);
	  } else {
	    anchorPoint = getPointForNonTextNode(root, anchorNode, anchorOffset);
	    focusPoint = getPointForNonTextNode(root, focusNode, focusOffset);
	
	    // If the selection is collapsed on an empty block, don't force recovery.
	    // This way, on arrow key selection changes, the browser can move the
	    // cursor from a non-zero offset on one block, through empty blocks,
	    // to a matching non-zero offset on other text blocks.
	    if (anchorNode === focusNode && anchorOffset === focusOffset) {
	      needsRecovery = anchorNode.firstChild.nodeName !== 'BR';
	    }
	  }
	
	  return {
	    selectionState: getUpdatedSelectionState(editorState, anchorPoint.key, anchorPoint.offset, focusPoint.key, focusPoint.offset),
	    needsRecovery: needsRecovery
	  };
	}
	
	/**
	 * Identify the first leaf descendant for the given node.
	 */
	function getFirstLeaf(node) {
	  while (node.firstChild && getSelectionOffsetKeyForNode(node.firstChild)) {
	    node = node.firstChild;
	  }
	  return node;
	}
	
	/**
	 * Identify the last leaf descendant for the given node.
	 */
	function getLastLeaf(node) {
	  while (node.lastChild && getSelectionOffsetKeyForNode(node.lastChild)) {
	    node = node.lastChild;
	  }
	  return node;
	}
	
	function getPointForNonTextNode(editorRoot, node, childOffset) {
	  var offsetKey = findAncestorOffsetKey(node);
	
	  !(offsetKey != null || editorRoot && (editorRoot === node || editorRoot.firstChild === node)) ? true ? invariant(false, 'Unknown node in selection range.') : invariant(false) : undefined;
	
	  // If the editorRoot is the selection, step downward into the content
	  // wrapper.
	  if (editorRoot === node) {
	    node = node.firstChild;
	    !(node instanceof Element && node.getAttribute('data-contents') === 'true') ? true ? invariant(false, 'Invalid DraftEditorContents structure.') : invariant(false) : undefined;
	    if (childOffset > 0) {
	      childOffset = node.childNodes.length;
	    }
	  }
	
	  // If the child offset is zero and we have an offset key, we're done.
	  // If there's no offset key because the entire editor is selected,
	  // find the leftmost ("first") leaf in the tree and use that as the offset
	  // key.
	  if (childOffset === 0) {
	    var key = null;
	    if (offsetKey != null) {
	      key = offsetKey;
	    } else {
	      var firstLeaf = getFirstLeaf(node);
	      key = nullthrows(getSelectionOffsetKeyForNode(firstLeaf));
	    }
	    return { key: key, offset: 0 };
	  }
	
	  var nodeBeforeCursor = node.childNodes[childOffset - 1];
	  var leafKey = null;
	  var textLength = null;
	
	  if (!getSelectionOffsetKeyForNode(nodeBeforeCursor)) {
	    // Our target node may be a leaf or a text node, in which case we're
	    // already where we want to be and can just use the child's length as
	    // our offset.
	    leafKey = nullthrows(offsetKey);
	    textLength = getTextContentLength(nodeBeforeCursor);
	  } else {
	    // Otherwise, we'll look at the child to the left of the cursor and find
	    // the last leaf node in its subtree.
	    var lastLeaf = getLastLeaf(nodeBeforeCursor);
	    leafKey = nullthrows(getSelectionOffsetKeyForNode(lastLeaf));
	    textLength = getTextContentLength(lastLeaf);
	  }
	
	  return {
	    key: leafKey,
	    offset: textLength
	  };
	}
	
	/**
	 * Return the length of a node's textContent, regarding single newline
	 * characters as zero-length. This allows us to avoid problems with identifying
	 * the correct selection offset for empty blocks in IE, in which we
	 * render newlines instead of break tags.
	 */
	function getTextContentLength(node) {
	  var textContent = node.textContent;
	  return textContent === '\n' ? 0 : textContent.length;
	}
	
	module.exports = getDraftEditorSelectionWithNodes;

/***/ },
/* 533 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule moveSelectionBackward
	 * 
	 */
	
	/**
	 * Given a collapsed selection, move the focus `maxDistance` backward within
	 * the selected block. If the selection will go beyond the start of the block,
	 * move focus to the end of the previous block, but no further.
	 *
	 * This function is not Unicode-aware, so surrogate pairs will be treated
	 * as having length 2.
	 */
	'use strict';
	
	function moveSelectionBackward(editorState, maxDistance) {
	  var selection = editorState.getSelection();
	  var content = editorState.getCurrentContent();
	  var key = selection.getStartKey();
	  var offset = selection.getStartOffset();
	
	  var focusKey = key;
	  var focusOffset = 0;
	
	  if (maxDistance > offset) {
	    var keyBefore = content.getKeyBefore(key);
	    if (keyBefore == null) {
	      focusKey = key;
	    } else {
	      focusKey = keyBefore;
	      var blockBefore = content.getBlockForKey(keyBefore);
	      focusOffset = blockBefore.getText().length;
	    }
	  } else {
	    focusOffset = offset - maxDistance;
	  }
	
	  return selection.merge({
	    focusKey: focusKey,
	    focusOffset: focusOffset,
	    isBackward: true
	  });
	}
	
	module.exports = moveSelectionBackward;

/***/ },
/* 534 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule removeTextWithStrategy
	 * 
	 */
	
	/**
	 * For a collapsed selection state, remove text based on the specified strategy.
	 * If the selection state is not collapsed, remove the entire selected range.
	 */
	'use strict';
	
	var DraftModifier = __webpack_require__(329);
	
	function removeTextWithStrategy(editorState, strategy, direction) {
	  var selection = editorState.getSelection();
	  var content = editorState.getCurrentContent();
	  var target = selection;
	  if (selection.isCollapsed()) {
	    if (direction === 'forward') {
	      if (editorState.isSelectionAtEndOfContent()) {
	        return content;
	      }
	    } else if (editorState.isSelectionAtStartOfContent()) {
	      return content;
	    }
	
	    target = strategy(editorState);
	    if (target === selection) {
	      return content;
	    }
	  }
	  return DraftModifier.removeRange(content, target, direction);
	}
	
	module.exports = removeTextWithStrategy;

/***/ },
/* 535 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule DraftRemovableWord
	 * @typechecks
	 * 
	 */
	
	'use strict';
	
	var TokenizeUtil = __webpack_require__(547);
	
	var punctuation = TokenizeUtil.getPunctuation();
	
	// The apostrophe and curly single quotes behave in a curious way: when
	// surrounded on both sides by word characters, they behave as word chars; when
	// either neighbor is punctuation or an end of the string, they behave as
	// punctuation.
	var CHAMELEON_CHARS = '[\'‘’]';
	
	// Remove the underscore, which should count as part of the removable word. The
	// "chameleon chars" also count as punctuation in this regex.
	var WHITESPACE_AND_PUNCTUATION = '\\s|(?![_])' + punctuation;
	
	var DELETE_STRING = '^' + '(?:' + WHITESPACE_AND_PUNCTUATION + ')*' + '(?:' + CHAMELEON_CHARS + '|(?!' + WHITESPACE_AND_PUNCTUATION + ').)*' + '(?:(?!' + WHITESPACE_AND_PUNCTUATION + ').)';
	var DELETE_REGEX = new RegExp(DELETE_STRING);
	
	var BACKSPACE_STRING = '(?:(?!' + WHITESPACE_AND_PUNCTUATION + ').)' + '(?:' + CHAMELEON_CHARS + '|(?!' + WHITESPACE_AND_PUNCTUATION + ').)*' + '(?:' + WHITESPACE_AND_PUNCTUATION + ')*' + '$';
	var BACKSPACE_REGEX = new RegExp(BACKSPACE_STRING);
	
	function getRemovableWord(text, isBackward) {
	  var matches = isBackward ? BACKSPACE_REGEX.exec(text) : DELETE_REGEX.exec(text);
	  return matches ? matches[0] : text;
	}
	
	var DraftRemovableWord = {
	  getBackward: function getBackward(text) {
	    return getRemovableWord(text, true);
	  },
	
	  getForward: function getForward(text) {
	    return getRemovableWord(text, false);
	  }
	};
	
	module.exports = DraftRemovableWord;

/***/ },
/* 536 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 * All rights reserved.
	 *
	 * This source code is licensed under the BSD-style license found in the
	 * LICENSE file in the root directory of this source tree. An additional grant
	 * of patent rights can be found in the PATENTS file in the same directory.
	 *
	 * @providesModule moveSelectionForward
	 * 
	 */
	
	/**
	 * Given a collapsed selection, move the focus `maxDistance` forward within
	 * the selected block. If the selection will go beyond the end of the block,
	 * move focus to the start of the next block, but no further.
	 *
	 * This function is not Unicode-aware, so surrogate pairs will be treated
	 * as having length 2.
	 */
	'use strict';
	
	function moveSelectionForward(editorState, maxDistance) {
	  var selection = editorState.getSelection();
	  var key = selection.getStartKey();
	  var offset = selection.getStartOffset();
	  var content = editorState.getCurrentContent();
	
	  var focusKey = key;
	  var focusOffset;
	
	  var block = content.getBlockForKey(key);
	
	  if (maxDistance > block.getText().length - offset) {
	    focusKey = content.getKeyAfter(key);
	    focusOffset = 0;
	  } else {
	    focusOffset = offset + maxDistance;
	  }
	
	  return selection.merge({ focusKey: focusKey, focusOffset: focusOffset });
	}
	
	module.exports = moveSelectionForward;

/***/ },
/* 537 */
/***/ function(module, exports, __webpack_require__) {

	var baseGetTag = __webpack_require__(548),
	    getPrototype = __webpack_require__(549),
	    isObjectLike = __webpack_require__(550);
	
	/** `Object#toString` result references. */
	var objectTag = '[object Object]';
	
	/** Used for built-in method references. */
	var funcProto = Function.prototype,
	    objectProto = Object.prototype;
	
	/** Used to resolve the decompiled source of functions. */
	var funcToString = funcProto.toString;
	
	/** Used to check objects for own properties. */
	var hasOwnProperty = objectProto.hasOwnProperty;
	
	/** Used to infer the `Object` constructor. */
	var objectCtorString = funcToString.call(Object);
	
	/**
	 * Checks if `value` is a plain object, that is, an object created by the
	 * `Object` constructor or one with a `[[Prototype]]` of `null`.
	 *
	 * @static
	 * @memberOf _
	 * @since 0.8.0
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
	 * @example
	 *
	 * function Foo() {
	 *   this.a = 1;
	 * }
	 *
	 * _.isPlainObject(new Foo);
	 * // => false
	 *
	 * _.isPlainObject([1, 2, 3]);
	 * // => false
	 *
	 * _.isPlainObject({ 'x': 0, 'y': 0 });
	 * // => true
	 *
	 * _.isPlainObject(Object.create(null));
	 * // => true
	 */
	function isPlainObject(value) {
	  if (!isObjectLike(value) || baseGetTag(value) != objectTag) {
	    return false;
	  }
	  var proto = getPrototype(value);
	  if (proto === null) {
	    return true;
	  }
	  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
	  return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
	}
	
	module.exports = isPlainObject;

/***/ },
/* 538 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */
	
	'use strict';
	
	/**
	 * Use invariant() to assert state which your program assumes to be true.
	 *
	 * Provide sprintf-style format (only %s is supported) and arguments
	 * to provide information about what broke and what you were
	 * expecting.
	 *
	 * The invariant message will be stripped in production, but the invariant
	 * will remain to ensure logic does not differ in production.
	 */
	
	var invariant = function invariant(condition, format, a, b, c, d, e, f) {
	  if (true) {
	    if (format === undefined) {
	      throw new Error('invariant requires an error message argument');
	    }
	  }
	
	  if (!condition) {
	    var error;
	    if (format === undefined) {
	      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];
	      var argIndex = 0;
	      error = new Error(format.replace(/%s/g, function () {
	        return args[argIndex++];
	      }));
	      error.name = 'Invariant Violation';
	    }
	
	    error.framesToPop = 1; // we don't care about invariant's own frame
	    throw error;
	  }
	};
	
	module.exports = invariant;

/***/ },
/* 539 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var reactIs = __webpack_require__(553);
	
	/**
	 * Copyright 2015, Yahoo! Inc.
	 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
	 */
	var REACT_STATICS = {
	  childContextTypes: true,
	  contextType: true,
	  contextTypes: true,
	  defaultProps: true,
	  displayName: true,
	  getDefaultProps: true,
	  getDerivedStateFromError: true,
	  getDerivedStateFromProps: true,
	  mixins: true,
	  propTypes: true,
	  type: true
	};
	var KNOWN_STATICS = {
	  name: true,
	  length: true,
	  prototype: true,
	  caller: true,
	  callee: true,
	  arguments: true,
	  arity: true
	};
	var FORWARD_REF_STATICS = {
	  '$$typeof': true,
	  render: true,
	  defaultProps: true,
	  displayName: true,
	  propTypes: true
	};
	var MEMO_STATICS = {
	  '$$typeof': true,
	  compare: true,
	  defaultProps: true,
	  displayName: true,
	  propTypes: true,
	  type: true
	};
	var TYPE_STATICS = {};
	TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
	TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
	
	function getStatics(component) {
	  // React v16.11 and below
	  if (reactIs.isMemo(component)) {
	    return MEMO_STATICS;
	  } // React v16.12 and above
	
	
	  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
	}
	
	var defineProperty = Object.defineProperty;
	var getOwnPropertyNames = Object.getOwnPropertyNames;
	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
	var getPrototypeOf = Object.getPrototypeOf;
	var objectPrototype = Object.prototype;
	function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
	  if (typeof sourceComponent !== 'string') {
	    // don't hoist over string (html) components
	    if (objectPrototype) {
	      var inheritedComponent = getPrototypeOf(sourceComponent);
	
	      if (inheritedComponent && inheritedComponent !== objectPrototype) {
	        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
	      }
	    }
	
	    var keys = getOwnPropertyNames(sourceComponent);
	
	    if (getOwnPropertySymbols) {
	      keys = keys.concat(getOwnPropertySymbols(sourceComponent));
	    }
	
	    var targetStatics = getStatics(targetComponent);
	    var sourceStatics = getStatics(sourceComponent);
	
	    for (var i = 0; i < keys.length; ++i) {
	      var key = keys[i];
	
	      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
	        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
	
	        try {
	          // Avoid failures from read-only properties
	          defineProperty(targetComponent, key, descriptor);
	        } catch (e) {}
	      }
	    }
	  }
	
	  return targetComponent;
	}
	
	module.exports = hoistNonReactStatics;

/***/ },
/* 540 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	// rawAsap provides everything we need except exception management.
	
	var rawAsap = __webpack_require__(555);
	// RawTasks are recycled to reduce GC churn.
	var freeTasks = [];
	// We queue errors to ensure they are thrown in right order (FIFO).
	// Array-as-queue is good enough here, since we are just dealing with exceptions.
	var pendingErrors = [];
	var requestErrorThrow = rawAsap.makeRequestCallFromTimer(throwFirstError);
	
	function throwFirstError() {
	    if (pendingErrors.length) {
	        throw pendingErrors.shift();
	    }
	}
	
	/**
	 * Calls a task as soon as possible after returning, in its own event, with priority
	 * over other events like animation, reflow, and repaint. An error thrown from an
	 * event will not interrupt, nor even substantially slow down the processing of
	 * other events, but will be rather postponed to a lower priority event.
	 * @param {{call}} task A callable object, typically a function that takes no
	 * arguments.
	 */
	module.exports = asap;
	function asap(task) {
	    var rawTask;
	    if (freeTasks.length) {
	        rawTask = freeTasks.pop();
	    } else {
	        rawTask = new RawTask();
	    }
	    rawTask.task = task;
	    rawAsap(rawTask);
	}
	
	// We wrap tasks with recyclable task objects.  A task object implements
	// `call`, just like a function.
	function RawTask() {
	    this.task = null;
	}
	
	// The sole purpose of wrapping the task is to catch the exception and recycle
	// the task object after its single use.
	RawTask.prototype.call = function () {
	    try {
	        this.task.call();
	    } catch (error) {
	        if (asap.onerror) {
	            // This hook exists purely for testing purposes.
	            // Its name will be periodically randomized to break any code that
	            // depends on its existence.
	            asap.onerror(error);
	        } else {
	            // In a web browser, exceptions are not fatal. However, to avoid
	            // slowing down the queue of pending tasks, we rethrow the error in a
	            // lower priority turn.
	            pendingErrors.push(error);
	            requestErrorThrow();
	        }
	    } finally {
	        this.task = null;
	        freeTasks[freeTasks.length] = this;
	    }
	};

/***/ },
/* 541 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */
	
	'use strict';
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	var ReactIs = __webpack_require__(553);
	var assign = __webpack_require__(576);
	
	var ReactPropTypesSecret = __webpack_require__(562);
	var checkPropTypes = __webpack_require__(557);
	
	var has = Function.call.bind(Object.prototype.hasOwnProperty);
	var printWarning = function printWarning() {};
	
	if (true) {
	  printWarning = function printWarning(text) {
	    var message = 'Warning: ' + text;
	    if (typeof console !== 'undefined') {
	      console.error(message);
	    }
	    try {
	      // --- Welcome to debugging React ---
	      // This error was thrown as a convenience so that you can use this stack
	      // to find the callsite that caused this warning to fire.
	      throw new Error(message);
	    } catch (x) {}
	  };
	}
	
	function emptyFunctionThatReturnsNull() {
	  return null;
	}
	
	module.exports = function (isValidElement, throwOnDirectAccess) {
	  /* global Symbol */
	  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
	  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.
	
	  /**
	   * Returns the iterator method function contained on the iterable object.
	   *
	   * Be sure to invoke the function with the iterable as context:
	   *
	   *     var iteratorFn = getIteratorFn(myIterable);
	   *     if (iteratorFn) {
	   *       var iterator = iteratorFn.call(myIterable);
	   *       ...
	   *     }
	   *
	   * @param {?object} maybeIterable
	   * @return {?function}
	   */
	  function getIteratorFn(maybeIterable) {
	    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
	    if (typeof iteratorFn === 'function') {
	      return iteratorFn;
	    }
	  }
	
	  /**
	   * Collection of methods that allow declaration and validation of props that are
	   * supplied to React components. Example usage:
	   *
	   *   var Props = require('ReactPropTypes');
	   *   var MyArticle = React.createClass({
	   *     propTypes: {
	   *       // An optional string prop named "description".
	   *       description: Props.string,
	   *
	   *       // A required enum prop named "category".
	   *       category: Props.oneOf(['News','Photos']).isRequired,
	   *
	   *       // A prop named "dialog" that requires an instance of Dialog.
	   *       dialog: Props.instanceOf(Dialog).isRequired
	   *     },
	   *     render: function() { ... }
	   *   });
	   *
	   * A more formal specification of how these methods are used:
	   *
	   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
	   *   decl := ReactPropTypes.{type}(.isRequired)?
	   *
	   * Each and every declaration produces a function with the same signature. This
	   * allows the creation of custom validation functions. For example:
	   *
	   *  var MyLink = React.createClass({
	   *    propTypes: {
	   *      // An optional string or URI prop named "href".
	   *      href: function(props, propName, componentName) {
	   *        var propValue = props[propName];
	   *        if (propValue != null && typeof propValue !== 'string' &&
	   *            !(propValue instanceof URI)) {
	   *          return new Error(
	   *            'Expected a string or an URI for ' + propName + ' in ' +
	   *            componentName
	   *          );
	   *        }
	   *      }
	   *    },
	   *    render: function() {...}
	   *  });
	   *
	   * @internal
	   */
	
	  var ANONYMOUS = '<<anonymous>>';
	
	  // Important!
	  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
	  var 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(),
	    elementType: createElementTypeTypeChecker(),
	    instanceOf: createInstanceTypeChecker,
	    node: createNodeChecker(),
	    objectOf: createObjectOfTypeChecker,
	    oneOf: createEnumTypeChecker,
	    oneOfType: createUnionTypeChecker,
	    shape: createShapeTypeChecker,
	    exact: createStrictShapeTypeChecker
	  };
	
	  /**
	   * inlined Object.is polyfill to avoid requiring consumers ship their own
	   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
	   */
	  /*eslint-disable no-self-compare*/
	  function is(x, y) {
	    // SameValue algorithm
	    if (x === y) {
	      // Steps 1-5, 7-10
	      // Steps 6.b-6.e: +0 != -0
	      return x !== 0 || 1 / x === 1 / y;
	    } else {
	      // Step 6.a: NaN == NaN
	      return x !== x && y !== y;
	    }
	  }
	  /*eslint-enable no-self-compare*/
	
	  /**
	   * We use an Error-like object for backward compatibility as people may call
	   * PropTypes directly and inspect their output. However, we don't use real
	   * Errors anymore. We don't inspect their stack anyway, and creating them
	   * is prohibitively expensive if they are created too often, such as what
	   * happens in oneOfType() for any type before the one that matched.
	   */
	  function PropTypeError(message) {
	    this.message = message;
	    this.stack = '';
	  }
	  // Make `instanceof Error` still work for returned errors.
	  PropTypeError.prototype = Error.prototype;
	
	  function createChainableTypeChecker(validate) {
	    if (true) {
	      var manualPropTypeCallCache = {};
	      var manualPropTypeWarningCount = 0;
	    }
	    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
	      componentName = componentName || ANONYMOUS;
	      propFullName = propFullName || propName;
	
	      if (secret !== ReactPropTypesSecret) {
	        if (throwOnDirectAccess) {
	          // New behavior only for users of `prop-types` package
	          var err = new Error('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');
	          err.name = 'Invariant Violation';
	          throw err;
	        } else if (("undefined") !== 'production' && typeof console !== 'undefined') {
	          // Old behavior for people using React.PropTypes
	          var cacheKey = componentName + ':' + propName;
	          if (!manualPropTypeCallCache[cacheKey] &&
	          // Avoid spamming the console because they are often not actionable except for lib authors
	          manualPropTypeWarningCount < 3) {
	            printWarning('You are manually calling a React.PropTypes validation ' + 'function for the `' + propFullName + '` prop on `' + componentName + '`. 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.');
	            manualPropTypeCallCache[cacheKey] = true;
	            manualPropTypeWarningCount++;
	          }
	        }
	      }
	      if (props[propName] == null) {
	        if (isRequired) {
	          if (props[propName] === null) {
	            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
	          }
	          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
	        }
	        return null;
	      } else {
	        return validate(props, propName, componentName, location, propFullName);
	      }
	    }
	
	    var chainedCheckType = checkType.bind(null, false);
	    chainedCheckType.isRequired = checkType.bind(null, true);
	
	    return chainedCheckType;
	  }
	
	  function createPrimitiveTypeChecker(expectedType) {
	    function validate(props, propName, componentName, location, propFullName, secret) {
	      var propValue = props[propName];
	      var propType = getPropType(propValue);
	      if (propType !== expectedType) {
	        // `propValue` being instance of, say, date/regexp, pass the 'object'
	        // check, but we can offer a more precise error message here rather than
	        // 'of type `object`'.
	        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(emptyFunctionThatReturnsNull);
	  }
	
	  function createArrayOfTypeChecker(typeChecker) {
	    function validate(props, propName, componentName, location, propFullName) {
	      if (typeof typeChecker !== 'function') {
	        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 createElementTypeTypeChecker() {
	    function validate(props, propName, componentName, location, propFullName) {
	      var propValue = props[propName];
	      if (!ReactIs.isValidElementType(propValue)) {
	        var propType = getPropType(propValue);
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
	      }
	      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;
	        var 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) {
	    if (!Array.isArray(expectedValues)) {
	      if (true) {
	        if (arguments.length > 1) {
	          printWarning('Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' + 'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).');
	        } else {
	          printWarning('Invalid argument supplied to oneOf, expected an array.');
	        }
	      }
	      return emptyFunctionThatReturnsNull;
	    }
	
	    function validate(props, propName, componentName, location, propFullName) {
	      var propValue = props[propName];
	      for (var i = 0; i < expectedValues.length; i++) {
	        if (is(propValue, expectedValues[i])) {
	          return null;
	        }
	      }
	
	      var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
	        var type = getPreciseType(value);
	        if (type === 'symbol') {
	          return String(value);
	        }
	        return value;
	      });
	      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
	    }
	    return createChainableTypeChecker(validate);
	  }
	
	  function createObjectOfTypeChecker(typeChecker) {
	    function validate(props, propName, componentName, location, propFullName) {
	      if (typeof typeChecker !== 'function') {
	        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
	      }
	      var propValue = props[propName];
	      var propType = getPropType(propValue);
	      if (propType !== 'object') {
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
	      }
	      for (var key in propValue) {
	        if (has(propValue, 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) {
	    if (!Array.isArray(arrayOfTypeCheckers)) {
	      true ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : void 0;
	      return emptyFunctionThatReturnsNull;
	    }
	
	    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
	      var checker = arrayOfTypeCheckers[i];
	      if (typeof checker !== 'function') {
	        printWarning('Invalid argument supplied to oneOfType. Expected an array of check functions, but ' + 'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.');
	        return emptyFunctionThatReturnsNull;
	      }
	    }
	
	    function validate(props, propName, componentName, location, propFullName) {
	      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
	        var checker = arrayOfTypeCheckers[i];
	        if (checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret) == null) {
	          return null;
	        }
	      }
	
	      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.'));
	    }
	    return createChainableTypeChecker(validate);
	  }
	
	  function createNodeChecker() {
	    function validate(props, propName, componentName, location, propFullName) {
	      if (!isNode(props[propName])) {
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }
	
	  function createShapeTypeChecker(shapeTypes) {
	    function validate(props, propName, componentName, location, propFullName) {
	      var propValue = props[propName];
	      var propType = getPropType(propValue);
	      if (propType !== 'object') {
	        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) {
	          continue;
	        }
	        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
	        if (error) {
	          return error;
	        }
	      }
	      return null;
	    }
	    return createChainableTypeChecker(validate);
	  }
	
	  function createStrictShapeTypeChecker(shapeTypes) {
	    function validate(props, propName, componentName, location, propFullName) {
	      var propValue = props[propName];
	      var propType = getPropType(propValue);
	      if (propType !== 'object') {
	        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
	      }
	      // We need to check all keys in case some are required but missing from
	      // props.
	      var allKeys = assign({}, props[propName], shapeTypes);
	      for (var key in allKeys) {
	        var checker = shapeTypes[key];
	        if (!checker) {
	          return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' + '\nBad object: ' + JSON.stringify(props[propName], null, '  ') + '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  '));
	        }
	        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 === 'undefined' ? 'undefined' : _typeof(propValue)) {
	      case 'number':
	      case 'string':
	      case 'undefined':
	        return true;
	      case 'boolean':
	        return !propValue;
	      case 'object':
	        if (Array.isArray(propValue)) {
	          return propValue.every(isNode);
	        }
	        if (propValue === null || isValidElement(propValue)) {
	          return true;
	        }
	
	        var iteratorFn = getIteratorFn(propValue);
	        if (iteratorFn) {
	          var iterator = iteratorFn.call(propValue);
	          var step;
	          if (iteratorFn !== propValue.entries) {
	            while (!(step = iterator.next()).done) {
	              if (!isNode(step.value)) {
	                return false;
	              }
	            }
	          } else {
	            // Iterator will provide entry [k,v] tuples rather than values.
	            while (!(step = iterator.next()).done) {
	              var entry = step.value;
	              if (entry) {
	                if (!isNode(entry[1])) {
	                  return false;
	                }
	              }
	            }
	          }
	        } else {
	          return false;
	        }
	
	        return true;
	      default:
	        return false;
	    }
	  }
	
	  function isSymbol(propType, propValue) {
	    // Native Symbol.
	    if (propType === 'symbol') {
	      return true;
	    }
	
	    // falsy value can't be a Symbol
	    if (!propValue) {
	      return false;
	    }
	
	    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
	    if (propValue['@@toStringTag'] === 'Symbol') {
	      return true;
	    }
	
	    // Fallback for non-spec compliant Symbols which are polyfilled.
	    if (typeof Symbol === 'function' && propValue instanceof Symbol) {
	      return true;
	    }
	
	    return false;
	  }
	
	  // Equivalent of `typeof` but with special handling for array and regexp.
	  function getPropType(propValue) {
	    var propType = typeof propValue === 'undefined' ? 'undefined' : _typeof(propValue);
	    if (Array.isArray(propValue)) {
	      return 'array';
	    }
	    if (propValue instanceof RegExp) {
	      // Old webkits (at least until Android 4.0) return 'function' rather than
	      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
	      // passes PropTypes.object.
	      return 'object';
	    }
	    if (isSymbol(propType, propValue)) {
	      return 'symbol';
	    }
	    return propType;
	  }
	
	  // This handles more types than `getPropType`. Only used for error messages.
	  // See `createPrimitiveTypeChecker`.
	  function getPreciseType(propValue) {
	    if (typeof propValue === 'undefined' || propValue === null) {
	      return '' + propValue;
	    }
	    var propType = getPropType(propValue);
	    if (propType === 'object') {
	      if (propValue instanceof Date) {
	        return 'date';
	      } else if (propValue instanceof RegExp) {
	        return 'regexp';
	      }
	    }
	    return propType;
	  }
	
	  // Returns a string that is postfixed to a warning about an invalid type.
	  // For example, "undefined" or "of type array"
	  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;
	    }
	  }
	
	  // Returns class name of the object, if any.
	  function getClassName(propValue) {
	    if (!propValue.constructor || !propValue.constructor.name) {
	      return ANONYMOUS;
	    }
	    return propValue.constructor.name;
	  }
	
	  ReactPropTypes.checkPropTypes = checkPropTypes;
	  ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
	  ReactPropTypes.PropTypes = ReactPropTypes;
	
	  return ReactPropTypes;
	};

/***/ },
/* 542 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A component that renders an icon with math (via KaTeX).
	 */
	
	var React = __webpack_require__(43);
	var ReactDOM = __webpack_require__(44);
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet;
	
	var _require2 = __webpack_require__(357),
	    View = _require2.View;
	
	var _require3 = __webpack_require__(364),
	    row = _require3.row,
	    centered = _require3.centered;
	
	var _require4 = __webpack_require__(355),
	    iconSizeHeightPx = _require4.iconSizeHeightPx,
	    iconSizeWidthPx = _require4.iconSizeWidthPx;
	
	var MathIcon = function (_React$Component) {
	    _inherits(MathIcon, _React$Component);
	
	    function MathIcon() {
	        var _temp, _this, _ret;
	
	        _classCallCheck(this, MathIcon);
	
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        return _ret = (_temp = (_this = _possibleConstructorReturn(this, _React$Component.call.apply(_React$Component, [this].concat(args))), _this), _this._renderMath = function () {
	            var math = _this.props.math;
	
	            window.katex.render(math, ReactDOM.findDOMNode(_this));
	        }, _temp), _possibleConstructorReturn(_this, _ret);
	    }
	
	    MathIcon.prototype.componentDidMount = function componentDidMount() {
	        this._renderMath();
	    };
	
	    MathIcon.prototype.componentDidUpdate = function componentDidUpdate(prevProps) {
	        if (prevProps.math !== this.props.math) {
	            this._renderMath();
	        }
	    };
	
	    MathIcon.prototype.render = function render() {
	        var style = this.props.style;
	
	
	        var containerStyle = [row, centered, styles.size, styles.base].concat(Array.isArray(style) ? style : [style]);
	
	        return React.createElement(View, { style: containerStyle });
	    };
	
	    return MathIcon;
	}(React.Component);
	
	MathIcon.propTypes = {
	    math: React.PropTypes.string.isRequired,
	    style: React.PropTypes.any
	};
	
	
	var styles = StyleSheet.create({
	    size: {
	        height: iconSizeHeightPx,
	        width: iconSizeWidthPx
	    },
	
	    base: {
	        fontSize: 25
	    }
	});
	
	module.exports = MathIcon;

/***/ },
/* 543 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A component that renders a single SVG icon.
	 */
	
	var React = __webpack_require__(43);
	
	var Iconography = __webpack_require__(556);
	
	var SvgIcon = function (_React$Component) {
	    _inherits(SvgIcon, _React$Component);
	
	    function SvgIcon() {
	        _classCallCheck(this, SvgIcon);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    SvgIcon.prototype.render = function render() {
	        var _props = this.props,
	            color = _props.color,
	            name = _props.name;
	
	
	        var SvgForName = Iconography[name];
	        return React.createElement(SvgForName, { color: color });
	    };
	
	    return SvgIcon;
	}(React.Component);
	
	SvgIcon.propTypes = {
	    color: React.PropTypes.string.isRequired,
	    name: React.PropTypes.string.isRequired
	};
	
	
	module.exports = SvgIcon;

/***/ },
/* 544 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * A component that renders a text-based icon.
	 */
	
	var React = __webpack_require__(43);
	
	var _require = __webpack_require__(414),
	    StyleSheet = _require.StyleSheet;
	
	var _require2 = __webpack_require__(357),
	    View = _require2.View,
	    Text = _require2.Text;
	
	var _require3 = __webpack_require__(364),
	    row = _require3.row,
	    centered = _require3.centered;
	
	var _require4 = __webpack_require__(355),
	    iconSizeHeightPx = _require4.iconSizeHeightPx,
	    iconSizeWidthPx = _require4.iconSizeWidthPx;
	
	var TextIcon = function (_React$Component) {
	    _inherits(TextIcon, _React$Component);
	
	    function TextIcon() {
	        _classCallCheck(this, TextIcon);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    TextIcon.prototype.render = function render() {
	        var _props = this.props,
	            character = _props.character,
	            style = _props.style;
	
	
	        var containerStyle = [row, centered, styles.size, styles.base].concat(Array.isArray(style) ? style : [style]);
	        return React.createElement(
	            View,
	            { style: containerStyle },
	            React.createElement(
	                Text,
	                null,
	                character
	            )
	        );
	    };
	
	    return TextIcon;
	}(React.Component);
	
	TextIcon.propTypes = {
	    character: React.PropTypes.string.isRequired,
	    style: React.PropTypes.any
	};
	
	
	var styles = StyleSheet.create({
	    size: {
	        height: iconSizeHeightPx,
	        width: iconSizeWidthPx
	    },
	
	    base: {
	        fontFamily: 'Proxima Nova',
	        fontSize: 25
	    }
	});
	
	module.exports = TextIcon;

/***/ },
/* 545 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 */
	
	/**
	 * @param {*} object The object to check.
	 * @return {boolean} Whether or not the object is a DOM node.
	 */
	function isNode(object) {
	  var doc = object ? object.ownerDocument || object : document;
	  var defaultView = doc.defaultView || window;
	  return !!(object && (typeof defaultView.Node === 'function' ? object instanceof defaultView.Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string'));
	}
	
	module.exports = isNode;

/***/ },
/* 546 */
/***/ function(module, exports, __webpack_require__) {

	// shim for using process in browser
	
	var process = module.exports = {};
	var queue = [];
	var draining = false;
	
	function drainQueue() {
	    if (draining) {
	        return;
	    }
	    draining = true;
	    var currentQueue;
	    var len = queue.length;
	    while(len) {
	        currentQueue = queue;
	        queue = [];
	        var i = -1;
	        while (++i < len) {
	            currentQueue[i]();
	        }
	        len = queue.length;
	    }
	    draining = false;
	}
	process.nextTick = function (fun) {
	    queue.push(fun);
	    if (!draining) {
	        setTimeout(drainQueue, 0);
	    }
	};
	
	process.title = 'browser';
	process.browser = true;
	process.env = {};
	process.argv = [];
	process.version = ''; // empty string to avoid regexp issues
	process.versions = {};
	
	function noop() {}
	
	process.on = noop;
	process.addListener = noop;
	process.once = noop;
	process.off = noop;
	process.removeListener = noop;
	process.removeAllListeners = noop;
	process.emit = noop;
	
	process.binding = function (name) {
	    throw new Error('process.binding is not supported');
	};
	
	// TODO(shtylman)
	process.cwd = function () { return '/' };
	process.chdir = function (dir) {
	    throw new Error('process.chdir is not supported');
	};
	process.umask = function() { return 0; };


/***/ },
/* 547 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 *
	 * @typechecks
	 * @stub
	 * 
	 */
	
	'use strict';
	
	// \u00a1-\u00b1\u00b4-\u00b8\u00ba\u00bb\u00bf
	//             is latin supplement punctuation except fractions and superscript
	//             numbers
	// \u2010-\u2027\u2030-\u205e
	//             is punctuation from the general punctuation block:
	//             weird quotes, commas, bullets, dashes, etc.
	// \u30fb\u3001\u3002\u3008-\u3011\u3014-\u301f
	//             is CJK punctuation
	// \uff1a-\uff1f\uff01-\uff0f\uff3b-\uff40\uff5b-\uff65
	//             is some full-width/half-width punctuation
	// \u2E2E\u061f\u066a-\u066c\u061b\u060c\u060d\uFD3e\uFD3F
	//             is some Arabic punctuation marks
	// \u1801\u0964\u104a\u104b
	//             is misc. other language punctuation marks
	
	var PUNCTUATION = '[.,+*?$|#{}()\'\\^\\-\\[\\]\\\\\\/!@%"~=<>_:;' + '\u30FB\u3001\u3002\u3008-\u3011\u3014-\u301F\uFF1A-\uFF1F\uFF01-\uFF0F' + '\uFF3B-\uFF40\uFF5B-\uFF65\u2E2E\u061F\u066A-\u066C\u061B\u060C\u060D' + '\uFD3E\uFD3F\u1801\u0964\u104A\u104B\u2010-\u2027\u2030-\u205E' + '\xA1-\xB1\xB4-\xB8\xBA\xBB\xBF]';
	
	module.exports = {
	  getPunctuation: function getPunctuation() {
	    return PUNCTUATION;
	  }
	};

/***/ },
/* 548 */
/***/ function(module, exports, __webpack_require__) {

	var _Symbol = __webpack_require__(558),
	    getRawTag = __webpack_require__(559),
	    objectToString = __webpack_require__(560);
	
	/** `Object#toString` result references. */
	var nullTag = '[object Null]',
	    undefinedTag = '[object Undefined]';
	
	/** Built-in value references. */
	var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
	
	/**
	 * The base implementation of `getTag` without fallbacks for buggy environments.
	 *
	 * @private
	 * @param {*} value The value to query.
	 * @returns {string} Returns the `toStringTag`.
	 */
	function baseGetTag(value) {
	    if (value == null) {
	        return value === undefined ? undefinedTag : nullTag;
	    }
	    return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
	}
	
	module.exports = baseGetTag;

/***/ },
/* 549 */
/***/ function(module, exports, __webpack_require__) {

	var overArg = __webpack_require__(561);
	
	/** Built-in value references. */
	var getPrototype = overArg(Object.getPrototypeOf, Object);
	
	module.exports = getPrototype;

/***/ },
/* 550 */
/***/ function(module, exports, __webpack_require__) {

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	/**
	 * Checks if `value` is object-like. A value is object-like if it's not `null`
	 * and has a `typeof` result of "object".
	 *
	 * @static
	 * @memberOf _
	 * @since 4.0.0
	 * @category Lang
	 * @param {*} value The value to check.
	 * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
	 * @example
	 *
	 * _.isObjectLike({});
	 * // => true
	 *
	 * _.isObjectLike([1, 2, 3]);
	 * // => true
	 *
	 * _.isObjectLike(_.noop);
	 * // => false
	 *
	 * _.isObjectLike(null);
	 * // => false
	 */
	function isObjectLike(value) {
	  return value != null && (typeof value === 'undefined' ? 'undefined' : _typeof(value)) == 'object';
	}
	
	module.exports = isObjectLike;

/***/ },
/* 551 */
/***/ function(module, exports, __webpack_require__) {

	var __WEBPACK_AMD_DEFINE_RESULT__;/*!@license
	 * UAParser.js v0.7.28
	 * Lightweight JavaScript-based User-Agent string parser
	 * https://github.com/faisalman/ua-parser-js
	 *
	 * Copyright © 2012-2021 Faisal Salman <f@faisalman.com>
	 * Licensed under MIT License
	 */
	
	(function (window, undefined) {
	
	    'use strict';
	
	    //////////////
	    // Constants
	    /////////////
	
	
	    var LIBVERSION  = '0.7.28',
	        EMPTY       = '',
	        UNKNOWN     = '?',
	        FUNC_TYPE   = 'function',
	        UNDEF_TYPE  = 'undefined',
	        OBJ_TYPE    = 'object',
	        STR_TYPE    = 'string',
	        MAJOR       = 'major', // deprecated
	        MODEL       = 'model',
	        NAME        = 'name',
	        TYPE        = 'type',
	        VENDOR      = 'vendor',
	        VERSION     = 'version',
	        ARCHITECTURE= 'architecture',
	        CONSOLE     = 'console',
	        MOBILE      = 'mobile',
	        TABLET      = 'tablet',
	        SMARTTV     = 'smarttv',
	        WEARABLE    = 'wearable',
	        EMBEDDED    = 'embedded',
	        UA_MAX_LENGTH = 255;
	
	
	    ///////////
	    // Helper
	    //////////
	
	
	    var util = {
	        extend : function (regexes, extensions) {
	            var mergedRegexes = {};
	            for (var i in regexes) {
	                if (extensions[i] && extensions[i].length % 2 === 0) {
	                    mergedRegexes[i] = extensions[i].concat(regexes[i]);
	                } else {
	                    mergedRegexes[i] = regexes[i];
	                }
	            }
	            return mergedRegexes;
	        },
	        has : function (str1, str2) {
	            return typeof str1 === STR_TYPE ? str2.toLowerCase().indexOf(str1.toLowerCase()) !== -1 : false;
	        },
	        lowerize : function (str) {
	            return str.toLowerCase();
	        },
	        major : function (version) {
	            return typeof(version) === STR_TYPE ? version.replace(/[^\d\.]/g,'').split(".")[0] : undefined;
	        },
	        trim : function (str, len) {
	            str = str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
	            return typeof(len) === UNDEF_TYPE ? str : str.substring(0, UA_MAX_LENGTH);
	        }
	    };
	
	
	    ///////////////
	    // Map helper
	    //////////////
	
	
	    var mapper = {
	
	        rgx : function (ua, arrays) {
	
	            var i = 0, j, k, p, q, matches, match;
	
	            // loop through all regexes maps
	            while (i < arrays.length && !matches) {
	
	                var regex = arrays[i],       // even sequence (0,2,4,..)
	                    props = arrays[i + 1];   // odd sequence (1,3,5,..)
	                j = k = 0;
	
	                // try matching uastring with regexes
	                while (j < regex.length && !matches) {
	
	                    matches = regex[j++].exec(ua);
	
	                    if (!!matches) {
	                        for (p = 0; p < props.length; p++) {
	                            match = matches[++k];
	                            q = props[p];
	                            // check if given property is actually array
	                            if (typeof q === OBJ_TYPE && q.length > 0) {
	                                if (q.length == 2) {
	                                    if (typeof q[1] == FUNC_TYPE) {
	                                        // assign modified match
	                                        this[q[0]] = q[1].call(this, match);
	                                    } else {
	                                        // assign given value, ignore regex match
	                                        this[q[0]] = q[1];
	                                    }
	                                } else if (q.length == 3) {
	                                    // check whether function or regex
	                                    if (typeof q[1] === FUNC_TYPE && !(q[1].exec && q[1].test)) {
	                                        // call function (usually string mapper)
	                                        this[q[0]] = match ? q[1].call(this, match, q[2]) : undefined;
	                                    } else {
	                                        // sanitize match using given regex
	                                        this[q[0]] = match ? match.replace(q[1], q[2]) : undefined;
	                                    }
	                                } else if (q.length == 4) {
	                                        this[q[0]] = match ? q[3].call(this, match.replace(q[1], q[2])) : undefined;
	                                }
	                            } else {
	                                this[q] = match ? match : undefined;
	                            }
	                        }
	                    }
	                }
	                i += 2;
	            }
	        },
	
	        str : function (str, map) {
	
	            for (var i in map) {
	                // check if array
	                if (typeof map[i] === OBJ_TYPE && map[i].length > 0) {
	                    for (var j = 0; j < map[i].length; j++) {
	                        if (util.has(map[i][j], str)) {
	                            return (i === UNKNOWN) ? undefined : i;
	                        }
	                    }
	                } else if (util.has(map[i], str)) {
	                    return (i === UNKNOWN) ? undefined : i;
	                }
	            }
	            return str;
	        }
	    };
	
	
	    ///////////////
	    // String map
	    //////////////
	
	
	    var maps = {
	
	        browser : {
	            // Safari < 3.0
	            oldSafari : {
	                version : {
	                    '1.0'   : '/8',
	                    '1.2'   : '/1',
	                    '1.3'   : '/3',
	                    '2.0'   : '/412',
	                    '2.0.2' : '/416',
	                    '2.0.3' : '/417',
	                    '2.0.4' : '/419',
	                    '?'     : '/'
	                }
	            },
	            oldEdge : {
	                version : {
	                    '0.1'   : '12.',
	                    '21'    : '13.',
	                    '31'    : '14.',
	                    '39'    : '15.',
	                    '41'    : '16.',
	                    '42'    : '17.',
	                    '44'    : '18.'
	                }
	            }
	        },
	
	        os : {
	            windows : {
	                version : {
	                    'ME'        : '4.90',
	                    'NT 3.11'   : 'NT3.51',
	                    'NT 4.0'    : 'NT4.0',
	                    '2000'      : 'NT 5.0',
	                    'XP'        : ['NT 5.1', 'NT 5.2'],
	                    'Vista'     : 'NT 6.0',
	                    '7'         : 'NT 6.1',
	                    '8'         : 'NT 6.2',
	                    '8.1'       : 'NT 6.3',
	                    '10'        : ['NT 6.4', 'NT 10.0'],
	                    'RT'        : 'ARM'
	                }
	            }
	        }
	    };
	
	
	    //////////////
	    // Regex map
	    /////////////
	
	
	    var regexes = {
	
	        browser : [[
	
	            /\b(?:crmo|crios)\/([\w\.]+)/i                                      // Chrome for Android/iOS
	            ], [VERSION, [NAME, 'Chrome']], [
	            /edg(?:e|ios|a)?\/([\w\.]+)/i                                       // Microsoft Edge
	            ], [VERSION, [NAME, 'Edge']], [
	            // breaking change (reserved for next major release):
	            ///edge\/([\w\.]+)/i                                                  // Old Edge (Trident)
	            //], [[VERSION, mapper.str, maps.browser.oldEdge.version], [NAME, 'Edge']], [
	
	            // Presto based
	            /(opera\smini)\/([\w\.-]+)/i,                                       // Opera Mini
	            /(opera\s[mobiletab]{3,6})\b.+version\/([\w\.-]+)/i,                // Opera Mobi/Tablet
	            /(opera)(?:.+version\/|[\/\s]+)([\w\.]+)/i,                         // Opera
	            ], [NAME, VERSION], [
	            /opios[\/\s]+([\w\.]+)/i                                            // Opera mini on iphone >= 8.0
	            ], [VERSION, [NAME, 'Opera Mini']], [
	            /\sopr\/([\w\.]+)/i                                                 // Opera Webkit
	            ], [VERSION, [NAME, 'Opera']], [
	
	            // Mixed
	            /(kindle)\/([\w\.]+)/i,                                             // Kindle
	            /(lunascape|maxthon|netfront|jasmine|blazer)[\/\s]?([\w\.]*)/i,     // Lunascape/Maxthon/Netfront/Jasmine/Blazer
	            // Trident based
	            /(avant\s|iemobile|slim)(?:browser)?[\/\s]?([\w\.]*)/i,             // Avant/IEMobile/SlimBrowser
	            /(ba?idubrowser)[\/\s]?([\w\.]+)/i,                                 // Baidu Browser
	            /(?:ms|\()(ie)\s([\w\.]+)/i,                                        // Internet Explorer
	
	            // Webkit/KHTML based
	            /(flock|rockmelt|midori|epiphany|silk|skyfire|ovibrowser|bolt|iron|vivaldi|iridium|phantomjs|bowser|quark|qupzilla|falkon)\/([\w\.-]+)/i,
	                                                                                // Flock/RockMelt/Midori/Epiphany/Silk/Skyfire/Bolt/Iron/Iridium/PhantomJS/Bowser/QupZilla/Falkon
	            /(rekonq|puffin|brave|whale|qqbrowserlite|qq)\/([\w\.]+)/i,         // Rekonq/Puffin/Brave/Whale/QQBrowserLite/QQ, aka ShouQ
	            /(weibo)__([\d\.]+)/i                                               // Weibo
	            ], [NAME, VERSION], [
	            /(?:[\s\/]uc?\s?browser|(?:juc.+)ucweb)[\/\s]?([\w\.]+)/i           // UCBrowser
	            ], [VERSION, [NAME, 'UCBrowser']], [
	            /(?:windowswechat)?\sqbcore\/([\w\.]+)\b.*(?:windowswechat)?/i      // WeChat Desktop for Windows Built-in Browser
	            ], [VERSION, [NAME, 'WeChat(Win) Desktop']], [
	            /micromessenger\/([\w\.]+)/i                                        // WeChat
	            ], [VERSION, [NAME, 'WeChat']], [
	            /konqueror\/([\w\.]+)/i                                             // Konqueror
	            ], [VERSION, [NAME, 'Konqueror']], [
	            /trident.+rv[:\s]([\w\.]{1,9})\b.+like\sgecko/i                     // IE11
	            ], [VERSION, [NAME, 'IE']], [
	            /yabrowser\/([\w\.]+)/i                                             // Yandex
	            ], [VERSION, [NAME, 'Yandex']], [
	            /(avast|avg)\/([\w\.]+)/i                                           // Avast/AVG Secure Browser
	            ], [[NAME, /(.+)/, '$1 Secure Browser'], VERSION], [
	            /focus\/([\w\.]+)/i                                                 // Firefox Focus
	            ], [VERSION, [NAME, 'Firefox Focus']], [
	            /opt\/([\w\.]+)/i                                                   // Opera Touch
	            ], [VERSION, [NAME, 'Opera Touch']], [
	            /coc_coc_browser\/([\w\.]+)/i                                       // Coc Coc Browser
	            ], [VERSION, [NAME, 'Coc Coc']], [
	            /dolfin\/([\w\.]+)/i                                                // Dolphin
	            ], [VERSION, [NAME, 'Dolphin']], [
	            /coast\/([\w\.]+)/i                                                 // Opera Coast
	            ], [VERSION, [NAME, 'Opera Coast']],
	            [/xiaomi\/miuibrowser\/([\w\.]+)/i                                  // MIUI Browser
	            ], [VERSION, [NAME, 'MIUI Browser']], [
	            /fxios\/([\w\.-]+)/i                                                // Firefox for iOS
	            ], [VERSION, [NAME, 'Firefox']], [
	            /(qihu|qhbrowser|qihoobrowser|360browser)/i                         // 360
	            ], [[NAME, '360 Browser']], [
	            /(oculus|samsung|sailfish)browser\/([\w\.]+)/i
	            ], [[NAME, /(.+)/, '$1 Browser'], VERSION], [                       // Oculus/Samsung/Sailfish Browser
	            /(comodo_dragon)\/([\w\.]+)/i                                       // Comodo Dragon
	            ], [[NAME, /_/g, ' '], VERSION], [
	            /\s(electron)\/([\w\.]+)\ssafari/i,                                 // Electron-based App
	            /(tesla)(?:\sqtcarbrowser|\/(20[12]\d\.[\w\.-]+))/i,                // Tesla
	            /m?(qqbrowser|baiduboxapp|2345Explorer)[\/\s]?([\w\.]+)/i           // QQBrowser/Baidu App/2345 Browser
	            ], [NAME, VERSION], [
	            /(MetaSr)[\/\s]?([\w\.]+)/i,                                        // SouGouBrowser
	            /(LBBROWSER)/i                                                      // LieBao Browser
	            ], [NAME], [
	
	            // WebView
	            /;fbav\/([\w\.]+);/i                                                // Facebook App for iOS & Android with version
	            ], [VERSION, [NAME, 'Facebook']], [
	            /FBAN\/FBIOS|FB_IAB\/FB4A/i                                         // Facebook App for iOS & Android without version
	            ], [[NAME, 'Facebook']], [
	            /safari\s(line)\/([\w\.]+)/i,                                       // Line App for iOS
	            /\b(line)\/([\w\.]+)\/iab/i,                                        // Line App for Android
	            /(chromium|instagram)[\/\s]([\w\.-]+)/i                             // Chromium/Instagram
	            ], [NAME, VERSION], [
	            /\bgsa\/([\w\.]+)\s.*safari\//i                                     // Google Search Appliance on iOS
	            ], [VERSION, [NAME, 'GSA']], [
	
	            /headlesschrome(?:\/([\w\.]+)|\s)/i                                 // Chrome Headless
	            ], [VERSION, [NAME, 'Chrome Headless']], [
	
	            /\swv\).+(chrome)\/([\w\.]+)/i                                      // Chrome WebView
	            ], [[NAME, 'Chrome WebView'], VERSION], [
	
	            /droid.+\sversion\/([\w\.]+)\b.+(?:mobile\ssafari|safari)/i         // Android Browser
	            ], [VERSION, [NAME, 'Android Browser']], [
	
	            /(chrome|omniweb|arora|[tizenoka]{5}\s?browser)\/v?([\w\.]+)/i      // Chrome/OmniWeb/Arora/Tizen/Nokia
	            ], [NAME, VERSION], [
	
	            /version\/([\w\.]+)\s.*mobile\/\w+\s(safari)/i                      // Mobile Safari
	            ], [VERSION, [NAME, 'Mobile Safari']], [
	            /version\/([\w\.]+)\s.*(mobile\s?safari|safari)/i                   // Safari & Safari Mobile
	            ], [VERSION, NAME], [
	            /webkit.+?(mobile\s?safari|safari)(\/[\w\.]+)/i                     // Safari < 3.0
	            ], [NAME, [VERSION, mapper.str, maps.browser.oldSafari.version]], [
	
	            /(webkit|khtml)\/([\w\.]+)/i
	            ], [NAME, VERSION], [
	
	            // Gecko based
	            /(navigator|netscape)\/([\w\.-]+)/i                                 // Netscape
	            ], [[NAME, 'Netscape'], VERSION], [
	            /ile\svr;\srv:([\w\.]+)\).+firefox/i                                // Firefox Reality
	            ], [VERSION, [NAME, 'Firefox Reality']], [
	            /ekiohf.+(flow)\/([\w\.]+)/i,                                       // Flow
	            /(swiftfox)/i,                                                      // Swiftfox
	            /(icedragon|iceweasel|camino|chimera|fennec|maemo\sbrowser|minimo|conkeror)[\/\s]?([\w\.\+]+)/i,
	                                                                                // IceDragon/Iceweasel/Camino/Chimera/Fennec/Maemo/Minimo/Conkeror
	            /(firefox|seamonkey|k-meleon|icecat|iceape|firebird|phoenix|palemoon|basilisk|waterfox)\/([\w\.-]+)$/i,
	                                                                                // Firefox/SeaMonkey/K-Meleon/IceCat/IceApe/Firebird/Phoenix
	            /(firefox)\/([\w\.]+)\s[\w\s\-]+\/[\w\.]+$/i,                       // Other Firefox-based
	            /(mozilla)\/([\w\.]+)\s.+rv\:.+gecko\/\d+/i,                        // Mozilla
	
	            // Other
	            /(polaris|lynx|dillo|icab|doris|amaya|w3m|netsurf|sleipnir)[\/\s]?([\w\.]+)/i,
	                                                                                // Polaris/Lynx/Dillo/iCab/Doris/Amaya/w3m/NetSurf/Sleipnir
	            /(links)\s\(([\w\.]+)/i,                                            // Links
	            /(gobrowser)\/?([\w\.]*)/i,                                         // GoBrowser
	            /(ice\s?browser)\/v?([\w\._]+)/i,                                   // ICE Browser
	            /(mosaic)[\/\s]([\w\.]+)/i                                          // Mosaic
	            ], [NAME, VERSION]
	        ],
	
	        cpu : [[
	
	            /(?:(amd|x(?:(?:86|64)[_-])?|wow|win)64)[;\)]/i                     // AMD64 (x64)
	            ], [[ARCHITECTURE, 'amd64']], [
	
	            /(ia32(?=;))/i                                                      // IA32 (quicktime)
	            ], [[ARCHITECTURE, util.lowerize]], [
	
	            /((?:i[346]|x)86)[;\)]/i                                            // IA32 (x86)
	            ], [[ARCHITECTURE, 'ia32']], [
	
	            /\b(aarch64|armv?8e?l?)\b/i                                         // ARM64
	            ], [[ARCHITECTURE, 'arm64']], [
	
	            /\b(arm(?:v[67])?ht?n?[fl]p?)\b/i                                   // ARMHF
	            ], [[ARCHITECTURE, 'armhf']], [
	
	            // PocketPC mistakenly identified as PowerPC
	            /windows\s(ce|mobile);\sppc;/i
	            ], [[ARCHITECTURE, 'arm']], [
	
	            /((?:ppc|powerpc)(?:64)?)(?:\smac|;|\))/i                           // PowerPC
	            ], [[ARCHITECTURE, /ower/, '', util.lowerize]], [
	
	            /(sun4\w)[;\)]/i                                                    // SPARC
	            ], [[ARCHITECTURE, 'sparc']], [
	
	            /((?:avr32|ia64(?=;))|68k(?=\))|\barm(?:64|(?=v(?:[1-7]|[5-7]1)l?|;|eabi))|(?=atmel\s)avr|(?:irix|mips|sparc)(?:64)?\b|pa-risc)/i
	                                                                                // IA64, 68K, ARM/64, AVR/32, IRIX/64, MIPS/64, SPARC/64, PA-RISC
	            ], [[ARCHITECTURE, util.lowerize]]
	        ],
	
	        device : [[
	
	            //////////////////////////
	            // MOBILES & TABLETS
	            // Ordered by popularity
	            /////////////////////////
	
	            // Samsung
	            /\b(sch-i[89]0\d|shw-m380s|sm-[pt]\w{2,4}|gt-[pn]\d{2,4}|sgh-t8[56]9|nexus\s10)/i
	            ], [MODEL, [VENDOR, 'Samsung'], [TYPE, TABLET]], [
	            /\b((?:s[cgp]h|gt|sm)-\w+|galaxy\snexus)/i,
	            /\ssamsung[\s-]([\w-]+)/i,
	            /sec-(sgh\w+)/i
	            ], [MODEL, [VENDOR, 'Samsung'], [TYPE, MOBILE]], [
	
	            // Apple
	            /\((ip(?:hone|od)[\s\w]*);/i                                        // iPod/iPhone
	            ], [MODEL, [VENDOR, 'Apple'], [TYPE, MOBILE]], [
	            /\((ipad);[\w\s\),;-]+apple/i,                                      // iPad
	            /applecoremedia\/[\w\.]+\s\((ipad)/i,
	            /\b(ipad)\d\d?,\d\d?[;\]].+ios/i
	            ], [MODEL, [VENDOR, 'Apple'], [TYPE, TABLET]], [
	
	            // Huawei
	            /\b((?:agr|ags[23]|bah2?|sht?)-a?[lw]\d{2})/i,
	            ], [MODEL, [VENDOR, 'Huawei'], [TYPE, TABLET]], [
	            /d\/huawei([\w\s-]+)[;\)]/i,
	            /\b(nexus\s6p|vog-[at]?l\d\d|ane-[at]?l[x\d]\d|eml-a?l\d\da?|lya-[at]?l\d[\dc]|clt-a?l\d\di?|ele-l\d\d)/i,
	            /\b(\w{2,4}-[atu][ln][01259][019])[;\)\s]/i
	            ], [MODEL, [VENDOR, 'Huawei'], [TYPE, MOBILE]], [
	
	            // Xiaomi
	            /\b(poco[\s\w]+)(?:\sbuild|\))/i,                                   // Xiaomi POCO
	            /\b;\s(\w+)\sbuild\/hm\1/i,                                         // Xiaomi Hongmi 'numeric' models
	            /\b(hm[\s\-_]?note?[\s_]?(?:\d\w)?)\sbuild/i,                       // Xiaomi Hongmi
	            /\b(redmi[\s\-_]?(?:note|k)?[\w\s_]+)(?:\sbuild|\))/i,              // Xiaomi Redmi
	            /\b(mi[\s\-_]?(?:a\d|one|one[\s_]plus|note lte)?[\s_]?(?:\d?\w?)[\s_]?(?:plus)?)\sbuild/i  // Xiaomi Mi
	            ], [[MODEL, /_/g, ' '], [VENDOR, 'Xiaomi'], [TYPE, MOBILE]], [
	            /\b(mi[\s\-_]?(?:pad)(?:[\w\s_]+))(?:\sbuild|\))/i                  // Mi Pad tablets
	            ],[[MODEL, /_/g, ' '], [VENDOR, 'Xiaomi'], [TYPE, TABLET]], [
	
	            // OPPO
	            /;\s(\w+)\sbuild.+\soppo/i,
	            /\s(cph[12]\d{3}|p(?:af|c[al]|d\w|e[ar])[mt]\d0|x9007)\b/i
	            ], [MODEL, [VENDOR, 'OPPO'], [TYPE, MOBILE]], [
	
	            // Vivo
	            /\svivo\s(\w+)(?:\sbuild|\))/i,
	            /\s(v[12]\d{3}\w?[at])(?:\sbuild|;)/i
	            ], [MODEL, [VENDOR, 'Vivo'], [TYPE, MOBILE]], [
	
	            // Realme
	            /\s(rmx[12]\d{3})(?:\sbuild|;)/i
	            ], [MODEL, [VENDOR, 'Realme'], [TYPE, MOBILE]], [
	
	            // Motorola
	            /\s(milestone|droid(?:[2-4x]|\s(?:bionic|x2|pro|razr))?:?(\s4g)?)\b[\w\s]+build\//i,
	            /\smot(?:orola)?[\s-](\w*)/i,
	            /((?:moto[\s\w\(\)]+|xt\d{3,4}|nexus\s6)(?=\sbuild|\)))/i
	            ], [MODEL, [VENDOR, 'Motorola'], [TYPE, MOBILE]], [
	            /\s(mz60\d|xoom[\s2]{0,2})\sbuild\//i
	            ], [MODEL, [VENDOR, 'Motorola'], [TYPE, TABLET]], [
	
	            // LG
	            /((?=lg)?[vl]k\-?\d{3})\sbuild|\s3\.[\s\w;-]{10}lg?-([06cv9]{3,4})/i
	            ], [MODEL, [VENDOR, 'LG'], [TYPE, TABLET]], [
	            /(lm-?f100[nv]?|nexus\s[45])/i,
	            /lg[e;\s\/-]+((?!browser|netcast)\w+)/i,
	            /\blg(\-?[\d\w]+)\sbuild/i
	            ], [MODEL, [VENDOR, 'LG'], [TYPE, MOBILE]], [
	
	            // Lenovo
	            /(ideatab[\w\-\s]+)/i,
	            /lenovo\s?(s(?:5000|6000)(?:[\w-]+)|tab(?:[\s\w]+)|yt[\d\w-]{6}|tb[\d\w-]{6})/i        // Lenovo tablets
	            ], [MODEL, [VENDOR, 'Lenovo'], [TYPE, TABLET]], [
	
	            // Nokia
	            /(?:maemo|nokia).*(n900|lumia\s\d+)/i,
	            /nokia[\s_-]?([\w\.-]*)/i
	            ], [[MODEL, /_/g, ' '], [VENDOR, 'Nokia'], [TYPE, MOBILE]], [
	
	            // Google
	            /droid.+;\s(pixel\sc)[\s)]/i                                        // Google Pixel C
	            ], [MODEL, [VENDOR, 'Google'], [TYPE, TABLET]], [
	            /droid.+;\s(pixel[\s\daxl]{0,6})(?:\sbuild|\))/i                    // Google Pixel
	            ], [MODEL, [VENDOR, 'Google'], [TYPE, MOBILE]], [
	
	            // Sony
	            /droid.+\s([c-g]\d{4}|so[-l]\w+|xq-a\w[4-7][12])(?=\sbuild\/|\).+chrome\/(?![1-6]{0,1}\d\.))/i
	            ], [MODEL, [VENDOR, 'Sony'], [TYPE, MOBILE]], [
	            /sony\stablet\s[ps]\sbuild\//i,
	            /(?:sony)?sgp\w+(?:\sbuild\/|\))/i
	            ], [[MODEL, 'Xperia Tablet'], [VENDOR, 'Sony'], [TYPE, TABLET]], [
	
	            // OnePlus
	            /\s(kb2005|in20[12]5|be20[12][59])\b/i,
	            /\ba000(1)\sbuild/i,                                                // OnePlus
	            /\boneplus\s(a\d{4})[\s)]/i
	            ], [MODEL, [VENDOR, 'OnePlus'], [TYPE, MOBILE]], [
	
	            // Amazon
	            /(alexa)webm/i,
	            /(kf[a-z]{2}wi)(\sbuild\/|\))/i,                                    // Kindle Fire without Silk
	            /(kf[a-z]+)(\sbuild\/|\)).+silk\//i                                 // Kindle Fire HD
	            ], [MODEL, [VENDOR, 'Amazon'], [TYPE, TABLET]], [
	            /(sd|kf)[0349hijorstuw]+(\sbuild\/|\)).+silk\//i                    // Fire Phone
	            ], [[MODEL, 'Fire Phone'], [VENDOR, 'Amazon'], [TYPE, MOBILE]], [
	
	            // BlackBerry
	            /\((playbook);[\w\s\),;-]+(rim)/i                                   // BlackBerry PlayBook
	            ], [MODEL, VENDOR, [TYPE, TABLET]], [
	            /((?:bb[a-f]|st[hv])100-\d)/i,
	            /\(bb10;\s(\w+)/i                                                   // BlackBerry 10
	            ], [MODEL, [VENDOR, 'BlackBerry'], [TYPE, MOBILE]], [
	
	            // Asus
	            /(?:\b|asus_)(transfo[prime\s]{4,10}\s\w+|eeepc|slider\s\w+|nexus\s7|padfone|p00[cj])/i
	            ], [MODEL, [VENDOR, 'ASUS'], [TYPE, TABLET]], [
	            /\s(z[es]6[027][01][km][ls]|zenfone\s\d\w?)\b/i
	            ], [MODEL, [VENDOR, 'ASUS'], [TYPE, MOBILE]], [
	
	            // HTC
	            /(nexus\s9)/i                                                       // HTC Nexus 9
	            ], [MODEL, [VENDOR, 'HTC'], [TYPE, TABLET]], [
	            /(htc)[;_\s-]{1,2}([\w\s]+(?=\)|\sbuild)|\w+)/i,                    // HTC
	
	            // ZTE
	            /(zte)-(\w*)/i,
	            /(alcatel|geeksphone|nexian|panasonic|(?=;\s)sony)[_\s-]?([\w-]*)/i // Alcatel/GeeksPhone/Nexian/Panasonic/Sony
	            ], [VENDOR, [MODEL, /_/g, ' '], [TYPE, MOBILE]], [
	
	            // Acer
	            /droid[x\d\.\s;]+\s([ab][1-7]\-?[0178a]\d\d?)/i
	            ], [MODEL, [VENDOR, 'Acer'], [TYPE, TABLET]], [
	
	            // Meizu
	            /droid.+;\s(m[1-5]\snote)\sbuild/i,
	            /\bmz-([\w-]{2,})/i
	            ], [MODEL, [VENDOR, 'Meizu'], [TYPE, MOBILE]], [
	
	            // MIXED
	            /(blackberry|benq|palm(?=\-)|sonyericsson|acer|asus|dell|meizu|motorola|polytron)[\s_-]?([\w-]*)/i,
	                                                                                // BlackBerry/BenQ/Palm/Sony-Ericsson/Acer/Asus/Dell/Meizu/Motorola/Polytron
	            /(hp)\s([\w\s]+\w)/i,                                               // HP iPAQ
	            /(asus)-?(\w+)/i,                                                   // Asus
	            /(microsoft);\s(lumia[\s\w]+)/i,                                    // Microsoft Lumia
	            /(lenovo)[_\s-]?([\w-]+)/i,                                         // Lenovo
	            /linux;.+(jolla);/i,                                                // Jolla
	            /droid.+;\s(oppo)\s?([\w\s]+)\sbuild/i                              // OPPO
	            ], [VENDOR, MODEL, [TYPE, MOBILE]], [
	
	            /(archos)\s(gamepad2?)/i,                                           // Archos
	            /(hp).+(touchpad(?!.+tablet)|tablet)/i,                             // HP TouchPad
	            /(kindle)\/([\w\.]+)/i,                                             // Kindle
	            /\s(nook)[\w\s]+build\/(\w+)/i,                                     // Nook
	            /(dell)\s(strea[kpr\s\d]*[\dko])/i,                                 // Dell Streak
	            /[;\/]\s?(le[\s\-]+pan)[\s\-]+(\w{1,9})\sbuild/i,                   // Le Pan Tablets
	            /[;\/]\s?(trinity)[\-\s]*(t\d{3})\sbuild/i,                         // Trinity Tablets
	            /\b(gigaset)[\s\-]+(q\w{1,9})\sbuild/i,                             // Gigaset Tablets
	            /\b(vodafone)\s([\w\s]+)(?:\)|\sbuild)/i                            // Vodafone
	            ], [VENDOR, MODEL, [TYPE, TABLET]], [
	
	            /\s(surface\sduo)\s/i                                               // Surface Duo
	            ], [MODEL, [VENDOR, 'Microsoft'], [TYPE, TABLET]], [
	            /droid\s[\d\.]+;\s(fp\du?)\sbuild/i
	            ], [MODEL, [VENDOR, 'Fairphone'], [TYPE, MOBILE]], [
	            /\s(u304aa)\sbuild/i                                                // AT&T
	            ], [MODEL, [VENDOR, 'AT&T'], [TYPE, MOBILE]], [
	            /sie-(\w*)/i                                                        // Siemens
	            ], [MODEL, [VENDOR, 'Siemens'], [TYPE, MOBILE]], [
	            /[;\/]\s?(rct\w+)\sbuild/i                                          // RCA Tablets
	            ], [MODEL, [VENDOR, 'RCA'], [TYPE, TABLET]], [
	            /[;\/\s](venue[\d\s]{2,7})\sbuild/i                                 // Dell Venue Tablets
	            ], [MODEL, [VENDOR, 'Dell'], [TYPE, TABLET]], [
	            /[;\/]\s?(q(?:mv|ta)\w+)\sbuild/i                                   // Verizon Tablet
	            ], [MODEL, [VENDOR, 'Verizon'], [TYPE, TABLET]], [
	            /[;\/]\s(?:barnes[&\s]+noble\s|bn[rt])([\w\s\+]*)\sbuild/i          // Barnes & Noble Tablet
	            ], [MODEL, [VENDOR, 'Barnes & Noble'], [TYPE, TABLET]], [
	            /[;\/]\s(tm\d{3}\w+)\sbuild/i
	            ], [MODEL, [VENDOR, 'NuVision'], [TYPE, TABLET]], [
	            /;\s(k88)\sbuild/i                                                  // ZTE K Series Tablet
	            ], [MODEL, [VENDOR, 'ZTE'], [TYPE, TABLET]], [
	            /;\s(nx\d{3}j)\sbuild/i                                             // ZTE Nubia
	            ], [MODEL, [VENDOR, 'ZTE'], [TYPE, MOBILE]], [
	            /[;\/]\s?(gen\d{3})\sbuild.*49h/i                                   // Swiss GEN Mobile
	            ], [MODEL, [VENDOR, 'Swiss'], [TYPE, MOBILE]], [
	            /[;\/]\s?(zur\d{3})\sbuild/i                                        // Swiss ZUR Tablet
	            ], [MODEL, [VENDOR, 'Swiss'], [TYPE, TABLET]], [
	            /[;\/]\s?((zeki)?tb.*\b)\sbuild/i                                   // Zeki Tablets
	            ], [MODEL, [VENDOR, 'Zeki'], [TYPE, TABLET]], [
	            /[;\/]\s([yr]\d{2})\sbuild/i,
	            /[;\/]\s(dragon[\-\s]+touch\s|dt)(\w{5})\sbuild/i                   // Dragon Touch Tablet
	            ], [[VENDOR, 'Dragon Touch'], MODEL, [TYPE, TABLET]], [
	            /[;\/]\s?(ns-?\w{0,9})\sbuild/i                                     // Insignia Tablets
	            ], [MODEL, [VENDOR, 'Insignia'], [TYPE, TABLET]], [
	            /[;\/]\s?((nxa|Next)-?\w{0,9})\sbuild/i                             // NextBook Tablets
	            ], [MODEL, [VENDOR, 'NextBook'], [TYPE, TABLET]], [
	            /[;\/]\s?(xtreme\_)?(v(1[045]|2[015]|[3469]0|7[05]))\sbuild/i
	            ], [[VENDOR, 'Voice'], MODEL, [TYPE, MOBILE]], [                    // Voice Xtreme Phones
	            /[;\/]\s?(lvtel\-)?(v1[12])\sbuild/i                                // LvTel Phones
	            ], [[VENDOR, 'LvTel'], MODEL, [TYPE, MOBILE]], [
	            /;\s(ph-1)\s/i
	            ], [MODEL, [VENDOR, 'Essential'], [TYPE, MOBILE]], [                // Essential PH-1
	            /[;\/]\s?(v(100md|700na|7011|917g).*\b)\sbuild/i                    // Envizen Tablets
	            ], [MODEL, [VENDOR, 'Envizen'], [TYPE, TABLET]], [
	            /[;\/]\s?(trio[\s\w\-\.]+)\sbuild/i                                 // MachSpeed Tablets
	            ], [MODEL, [VENDOR, 'MachSpeed'], [TYPE, TABLET]], [
	            /[;\/]\s?tu_(1491)\sbuild/i                                         // Rotor Tablets
	            ], [MODEL, [VENDOR, 'Rotor'], [TYPE, TABLET]], [
	            /(shield[\w\s]+)\sbuild/i                                           // Nvidia Shield Tablets
	            ], [MODEL, [VENDOR, 'Nvidia'], [TYPE, TABLET]], [
	            /(sprint)\s(\w+)/i                                                  // Sprint Phones
	            ], [VENDOR, MODEL, [TYPE, MOBILE]], [
	            /(kin\.[onetw]{3})/i                                                // Microsoft Kin
	            ], [[MODEL, /\./g, ' '], [VENDOR, 'Microsoft'], [TYPE, MOBILE]], [
	            /droid\s[\d\.]+;\s(cc6666?|et5[16]|mc[239][23]x?|vc8[03]x?)\)/i     // Zebra
	            ], [MODEL, [VENDOR, 'Zebra'], [TYPE, TABLET]], [
	            /droid\s[\d\.]+;\s(ec30|ps20|tc[2-8]\d[kx])\)/i
	            ], [MODEL, [VENDOR, 'Zebra'], [TYPE, MOBILE]], [
	
	            ///////////////////
	            // CONSOLES
	            ///////////////////
	
	            /\s(ouya)\s/i,                                                      // Ouya
	            /(nintendo)\s([wids3utch]+)/i                                       // Nintendo
	            ], [VENDOR, MODEL, [TYPE, CONSOLE]], [
	            /droid.+;\s(shield)\sbuild/i                                        // Nvidia
	            ], [MODEL, [VENDOR, 'Nvidia'], [TYPE, CONSOLE]], [
	            /(playstation\s[345portablevi]+)/i                                  // Playstation
	            ], [MODEL, [VENDOR, 'Sony'], [TYPE, CONSOLE]], [
	            /[\s\(;](xbox(?:\sone)?(?!;\sxbox))[\s\);]/i                        // Microsoft Xbox
	            ], [MODEL, [VENDOR, 'Microsoft'], [TYPE, CONSOLE]], [
	
	            ///////////////////
	            // SMARTTVS
	            ///////////////////
	
	            /smart-tv.+(samsung)/i                                              // Samsung
	            ], [VENDOR, [TYPE, SMARTTV]], [
	            /hbbtv.+maple;(\d+)/i
	            ], [[MODEL, /^/, 'SmartTV'], [VENDOR, 'Samsung'], [TYPE, SMARTTV]], [
	            /(?:linux;\snetcast.+smarttv|lg\snetcast\.tv-201\d)/i,              // LG SmartTV
	            ], [[VENDOR, 'LG'], [TYPE, SMARTTV]], [
	            /(apple)\s?tv/i                                                     // Apple TV
	            ], [VENDOR, [MODEL, 'Apple TV'], [TYPE, SMARTTV]], [
	            /crkey/i                                                            // Google Chromecast
	            ], [[MODEL, 'Chromecast'], [VENDOR, 'Google'], [TYPE, SMARTTV]], [
	            /droid.+aft([\w])(\sbuild\/|\))/i                                   // Fire TV
	            ], [MODEL, [VENDOR, 'Amazon'], [TYPE, SMARTTV]], [
	            /\(dtv[\);].+(aquos)/i                                              // Sharp
	            ], [MODEL, [VENDOR, 'Sharp'], [TYPE, SMARTTV]], [
	            /hbbtv\/\d+\.\d+\.\d+\s+\([\w\s]*;\s*(\w[^;]*);([^;]*)/i            // HbbTV devices
	            ], [[VENDOR, util.trim], [MODEL, util.trim], [TYPE, SMARTTV]], [
	            /[\s\/\(](android\s|smart[-\s]?|opera\s)tv[;\)\s]/i                 // SmartTV from Unidentified Vendors
	            ], [[TYPE, SMARTTV]], [
	
	            ///////////////////
	            // WEARABLES
	            ///////////////////
	
	            /((pebble))app\/[\d\.]+\s/i                                         // Pebble
	            ], [VENDOR, MODEL, [TYPE, WEARABLE]], [
	            /droid.+;\s(glass)\s\d/i                                            // Google Glass
	            ], [MODEL, [VENDOR, 'Google'], [TYPE, WEARABLE]], [
	            /droid\s[\d\.]+;\s(wt63?0{2,3})\)/i
	            ], [MODEL, [VENDOR, 'Zebra'], [TYPE, WEARABLE]], [
	
	            ///////////////////
	            // EMBEDDED
	            ///////////////////
	
	            /(tesla)(?:\sqtcarbrowser|\/20[12]\d\.[\w\.-]+)/i                   // Tesla
	            ], [VENDOR, [TYPE, EMBEDDED]], [
	
	            ////////////////////
	            // MIXED (GENERIC)
	            ///////////////////
	
	            /droid .+?; ([^;]+?)(?: build|\) applewebkit).+? mobile safari/i    // Android Phones from Unidentified Vendors
	            ], [MODEL, [TYPE, MOBILE]], [
	            /droid .+?;\s([^;]+?)(?: build|\) applewebkit).+?(?! mobile) safari/i  // Android Tablets from Unidentified Vendors
	            ], [MODEL, [TYPE, TABLET]], [
	            /\s(tablet|tab)[;\/]/i,                                             // Unidentifiable Tablet
	            /\s(mobile)(?:[;\/]|\ssafari)/i                                     // Unidentifiable Mobile
	            ], [[TYPE, util.lowerize]], [
	            /(android[\w\.\s\-]{0,9});.+build/i                                 // Generic Android Device
	            ], [MODEL, [VENDOR, 'Generic']], [
	            /(phone)/i
	            ], [[TYPE, MOBILE]]
	        ],
	
	        engine : [[
	
	            /windows.+\sedge\/([\w\.]+)/i                                       // EdgeHTML
	            ], [VERSION, [NAME, 'EdgeHTML']], [
	
	            /webkit\/537\.36.+chrome\/(?!27)([\w\.]+)/i                         // Blink
	            ], [VERSION, [NAME, 'Blink']], [
	
	            /(presto)\/([\w\.]+)/i,                                             // Presto
	            /(webkit|trident|netfront|netsurf|amaya|lynx|w3m|goanna)\/([\w\.]+)/i, // WebKit/Trident/NetFront/NetSurf/Amaya/Lynx/w3m/Goanna
	            /ekioh(flow)\/([\w\.]+)/i,                                          // Flow
	            /(khtml|tasman|links)[\/\s]\(?([\w\.]+)/i,                          // KHTML/Tasman/Links
	            /(icab)[\/\s]([23]\.[\d\.]+)/i                                      // iCab
	            ], [NAME, VERSION], [
	
	            /rv\:([\w\.]{1,9})\b.+(gecko)/i                                     // Gecko
	            ], [VERSION, NAME]
	        ],
	
	        os : [[
	
	            // Windows
	            /microsoft\s(windows)\s(vista|xp)/i                                 // Windows (iTunes)
	            ], [NAME, VERSION], [
	            /(windows)\snt\s6\.2;\s(arm)/i,                                     // Windows RT
	            /(windows\sphone(?:\sos)*)[\s\/]?([\d\.\s\w]*)/i,                   // Windows Phone
	            /(windows\smobile|windows)[\s\/]?([ntce\d\.\s]+\w)(?!.+xbox)/i
	            ], [NAME, [VERSION, mapper.str, maps.os.windows.version]], [
	            /(win(?=3|9|n)|win\s9x\s)([nt\d\.]+)/i
	            ], [[NAME, 'Windows'], [VERSION, mapper.str, maps.os.windows.version]], [
	
	            // iOS/macOS
	            /ip[honead]{2,4}\b(?:.*os\s([\w]+)\slike\smac|;\sopera)/i,          // iOS
	            /cfnetwork\/.+darwin/i
	            ], [[VERSION, /_/g, '.'], [NAME, 'iOS']], [
	            /(mac\sos\sx)\s?([\w\s\.]*)/i,
	            /(macintosh|mac(?=_powerpc)\s)(?!.+haiku)/i                         // Mac OS
	            ], [[NAME, 'Mac OS'], [VERSION, /_/g, '.']], [
	
	            // Mobile OSes                                                      // Android/WebOS/Palm/QNX/Bada/RIM/MeeGo/Contiki/Sailfish OS
	            /(android|webos|palm\sos|qnx|bada|rim\stablet\sos|meego|sailfish|contiki)[\/\s-]?([\w\.]*)/i,
	            /(blackberry)\w*\/([\w\.]*)/i,                                      // Blackberry
	            /(tizen|kaios)[\/\s]([\w\.]+)/i,                                    // Tizen/KaiOS
	            /\((series40);/i                                                    // Series 40
	            ], [NAME, VERSION], [
	            /\(bb(10);/i                                                        // BlackBerry 10
	            ], [VERSION, [NAME, 'BlackBerry']], [
	            /(?:symbian\s?os|symbos|s60(?=;)|series60)[\/\s-]?([\w\.]*)/i       // Symbian
	            ], [VERSION, [NAME, 'Symbian']], [
	            /mozilla.+\(mobile;.+gecko.+firefox/i                               // Firefox OS
	            ], [[NAME, 'Firefox OS']], [
	            /web0s;.+rt(tv)/i,
	            /\b(?:hp)?wos(?:browser)?\/([\w\.]+)/i                              // WebOS
	            ], [VERSION, [NAME, 'webOS']], [
	
	            // Google Chromecast
	            /crkey\/([\d\.]+)/i                                                 // Google Chromecast
	            ], [VERSION, [NAME, 'Chromecast']], [
	            /(cros)\s[\w]+\s([\w\.]+\w)/i                                       // Chromium OS
	            ], [[NAME, 'Chromium OS'], VERSION],[
	
	            // Console
	            /(nintendo|playstation)\s([wids345portablevuch]+)/i,                // Nintendo/Playstation
	            /(xbox);\s+xbox\s([^\);]+)/i,                                       // Microsoft Xbox (360, One, X, S, Series X, Series S)
	
	            // GNU/Linux based
	            /(mint)[\/\s\(\)]?(\w*)/i,                                          // Mint
	            /(mageia|vectorlinux)[;\s]/i,                                       // Mageia/VectorLinux
	            /(joli|[kxln]?ubuntu|debian|suse|opensuse|gentoo|arch(?=\slinux)|slackware|fedora|mandriva|centos|pclinuxos|redhat|zenwalk|linpus|raspbian)(?:\sgnu\/linux)?(?:\slinux)?[\/\s-]?(?!chrom|package)([\w\.-]*)/i,
	                                                                                // Joli/Ubuntu/Debian/SUSE/Gentoo/Arch/Slackware
	                                                                                // Fedora/Mandriva/CentOS/PCLinuxOS/RedHat/Zenwalk/Linpus
	            /(hurd|linux)\s?([\w\.]*)/i,                                        // Hurd/Linux
	            /(gnu)\s?([\w\.]*)/i,                                               // GNU
	
	            // BSD based
	            /\s([frentopc-]{0,4}bsd|dragonfly)\s?(?!amd|[ix346]{1,2}86)([\w\.]*)/i,  // FreeBSD/NetBSD/OpenBSD/PC-BSD/DragonFly
	            /(haiku)\s(\w+)/i                                                   // Haiku
	            ], [NAME, VERSION], [
	
	            // Other
	            /(sunos)\s?([\w\.\d]*)/i                                            // Solaris
	            ], [[NAME, 'Solaris'], VERSION], [
	            /((?:open)?solaris)[\/\s-]?([\w\.]*)/i,                             // Solaris
	            /(aix)\s((\d)(?=\.|\)|\s)[\w\.])*/i,                                // AIX
	            /(plan\s9|minix|beos|os\/2|amigaos|morphos|risc\sos|openvms|fuchsia)/i,  // Plan9/Minix/BeOS/OS2/AmigaOS/MorphOS/RISCOS/OpenVMS/Fuchsia
	            /(unix)\s?([\w\.]*)/i                                               // UNIX
	            ], [NAME, VERSION]
	        ]
	    };
	
	
	    /////////////////
	    // Constructor
	    ////////////////
	    var UAParser = function (ua, extensions) {
	
	        if (typeof ua === 'object') {
	            extensions = ua;
	            ua = undefined;
	        }
	
	        if (!(this instanceof UAParser)) {
	            return new UAParser(ua, extensions).getResult();
	        }
	
	        var _ua = ua || ((typeof window !== 'undefined' && window.navigator && window.navigator.userAgent) ? window.navigator.userAgent : EMPTY);
	        var _rgxmap = extensions ? util.extend(regexes, extensions) : regexes;
	
	        this.getBrowser = function () {
	            var _browser = { name: undefined, version: undefined };
	            mapper.rgx.call(_browser, _ua, _rgxmap.browser);
	            _browser.major = util.major(_browser.version); // deprecated
	            return _browser;
	        };
	        this.getCPU = function () {
	            var _cpu = { architecture: undefined };
	            mapper.rgx.call(_cpu, _ua, _rgxmap.cpu);
	            return _cpu;
	        };
	        this.getDevice = function () {
	            var _device = { vendor: undefined, model: undefined, type: undefined };
	            mapper.rgx.call(_device, _ua, _rgxmap.device);
	            return _device;
	        };
	        this.getEngine = function () {
	            var _engine = { name: undefined, version: undefined };
	            mapper.rgx.call(_engine, _ua, _rgxmap.engine);
	            return _engine;
	        };
	        this.getOS = function () {
	            var _os = { name: undefined, version: undefined };
	            mapper.rgx.call(_os, _ua, _rgxmap.os);
	            return _os;
	        };
	        this.getResult = function () {
	            return {
	                ua      : this.getUA(),
	                browser : this.getBrowser(),
	                engine  : this.getEngine(),
	                os      : this.getOS(),
	                device  : this.getDevice(),
	                cpu     : this.getCPU()
	            };
	        };
	        this.getUA = function () {
	            return _ua;
	        };
	        this.setUA = function (ua) {
	            _ua = (typeof ua === STR_TYPE && ua.length > UA_MAX_LENGTH) ? util.trim(ua, UA_MAX_LENGTH) : ua;
	            return this;
	        };
	        this.setUA(_ua);
	        return this;
	    };
	
	    UAParser.VERSION = LIBVERSION;
	    UAParser.BROWSER = {
	        NAME    : NAME,
	        MAJOR   : MAJOR, // deprecated
	        VERSION : VERSION
	    };
	    UAParser.CPU = {
	        ARCHITECTURE : ARCHITECTURE
	    };
	    UAParser.DEVICE = {
	        MODEL   : MODEL,
	        VENDOR  : VENDOR,
	        TYPE    : TYPE,
	        CONSOLE : CONSOLE,
	        MOBILE  : MOBILE,
	        SMARTTV : SMARTTV,
	        TABLET  : TABLET,
	        WEARABLE: WEARABLE,
	        EMBEDDED: EMBEDDED
	    };
	    UAParser.ENGINE = {
	        NAME    : NAME,
	        VERSION : VERSION
	    };
	    UAParser.OS = {
	        NAME    : NAME,
	        VERSION : VERSION
	    };
	
	    ///////////
	    // Export
	    //////////
	
	
	    // check js environment
	    if (typeof(exports) !== UNDEF_TYPE) {
	        // nodejs env
	        if (typeof module !== UNDEF_TYPE && module.exports) {
	            exports = module.exports = UAParser;
	        }
	        exports.UAParser = UAParser;
	    } else {
	        // requirejs env (optional)
	        if (true) {
	            !(__WEBPACK_AMD_DEFINE_RESULT__ = function () {
	                return UAParser;
	            }.call(exports, __webpack_require__, exports, module), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
	        } else if (typeof window !== 'undefined') {
	            // browser env
	            window.UAParser = UAParser;
	        }
	    }
	
	    // jQuery/Zepto specific (optional)
	    // Note:
	    //   In AMD env the global scope should be kept clean, but jQuery is an exception.
	    //   jQuery always exports to global scope, unless jQuery.noConflict(true) is used,
	    //   and we should catch that.
	    var $ = typeof window !== 'undefined' && (window.jQuery || window.Zepto);
	    if ($ && !$.ua) {
	        var parser = new UAParser();
	        $.ua = parser.getResult();
	        $.ua.get = function () {
	            return parser.getUA();
	        };
	        $.ua.set = function (uastring) {
	            parser.setUA(uastring);
	            var result = parser.getResult();
	            for (var prop in result) {
	                $.ua[prop] = result[prop];
	            }
	        };
	    }
	
	})(typeof window === 'object' ? window : this);


/***/ },
/* 552 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = prefixAll;
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	var _prefixProps = __webpack_require__(563);
	
	var _prefixProps2 = _interopRequireDefault(_prefixProps);
	
	var _utilsCapitalizeString = __webpack_require__(565);
	
	var _utilsCapitalizeString2 = _interopRequireDefault(_utilsCapitalizeString);
	
	var _utilsAssign = __webpack_require__(566);
	
	var _utilsAssign2 = _interopRequireDefault(_utilsAssign);
	
	var _pluginsCalc = __webpack_require__(567);
	
	var _pluginsCalc2 = _interopRequireDefault(_pluginsCalc);
	
	var _pluginsCursor = __webpack_require__(568);
	
	var _pluginsCursor2 = _interopRequireDefault(_pluginsCursor);
	
	var _pluginsFlex = __webpack_require__(569);
	
	var _pluginsFlex2 = _interopRequireDefault(_pluginsFlex);
	
	var _pluginsSizing = __webpack_require__(570);
	
	var _pluginsSizing2 = _interopRequireDefault(_pluginsSizing);
	
	var _pluginsGradient = __webpack_require__(571);
	
	var _pluginsGradient2 = _interopRequireDefault(_pluginsGradient);
	
	var _pluginsTransition = __webpack_require__(572);
	
	var _pluginsTransition2 = _interopRequireDefault(_pluginsTransition);
	
	// special flexbox specifications
	
	var _pluginsFlexboxIE = __webpack_require__(573);
	
	var _pluginsFlexboxIE2 = _interopRequireDefault(_pluginsFlexboxIE);
	
	var _pluginsFlexboxOld = __webpack_require__(574);
	
	var _pluginsFlexboxOld2 = _interopRequireDefault(_pluginsFlexboxOld);
	
	var plugins = [_pluginsCalc2['default'], _pluginsCursor2['default'], _pluginsSizing2['default'], _pluginsGradient2['default'], _pluginsTransition2['default'], _pluginsFlexboxIE2['default'], _pluginsFlexboxOld2['default'], _pluginsFlex2['default']];
	
	/**
	 * Returns a prefixed version of the style object using all vendor prefixes
	 * @param {Object} styles - Style object that gets prefixed properties added
	 * @returns {Object} - Style object with prefixed properties and values
	 */
	
	function prefixAll(styles) {
	  return Object.keys(styles).reduce(function (prefixedStyles, property) {
	    var value = styles[property];
	    if (value instanceof Object && !Array.isArray(value)) {
	      // recurse through nested style objects
	      prefixedStyles[property] = prefixAll(value);
	    } else {
	      Object.keys(_prefixProps2['default']).forEach(function (prefix) {
	        var properties = _prefixProps2['default'][prefix];
	        // add prefixes if needed
	        if (properties[property]) {
	          prefixedStyles[prefix + (0, _utilsCapitalizeString2['default'])(property)] = value;
	        }
	      });
	
	      // resolve every special plugins
	      plugins.forEach(function (plugin) {
	        return (0, _utilsAssign2['default'])(prefixedStyles, plugin(property, value));
	      });
	    }
	
	    return prefixedStyles;
	  }, styles);
	}
	
	module.exports = exports['default'];

/***/ },
/* 553 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	if (false) {
	  module.exports = require('./cjs/react-is.production.min.js');
	} else {
	  module.exports = __webpack_require__(575);
	}

/***/ },
/* 554 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global, module) {'use strict';
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	var _ponyfill = __webpack_require__(564);
	
	var _ponyfill2 = _interopRequireDefault(_ponyfill);
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	var root; /* global window */
	
	if (typeof self !== 'undefined') {
	  root = self;
	} else if (typeof window !== 'undefined') {
	  root = window;
	} else if (typeof global !== 'undefined') {
	  root = global;
	} else if (true) {
	  root = module;
	} else {
	  root = Function('return this')();
	}
	
	var result = (0, _ponyfill2['default'])(root);
	exports['default'] = result;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(619)(module)))

/***/ },
/* 555 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {"use strict";
	
	// Use the fastest means possible to execute a task in its own turn, with
	// priority over other events including IO, animation, reflow, and redraw
	// events in browsers.
	//
	// An exception thrown by a task will permanently interrupt the processing of
	// subsequent tasks. The higher level `asap` function ensures that if an
	// exception is thrown by a task, that the task queue will continue flushing as
	// soon as possible, but if you use `rawAsap` directly, you are responsible to
	// either ensure that no exceptions are thrown from your task, or to manually
	// call `rawAsap.requestFlush` if an exception is thrown.
	
	module.exports = rawAsap;
	function rawAsap(task) {
	    if (!queue.length) {
	        requestFlush();
	        flushing = true;
	    }
	    // Equivalent to push, but avoids a function call.
	    queue[queue.length] = task;
	}
	
	var queue = [];
	// Once a flush has been requested, no further calls to `requestFlush` are
	// necessary until the next `flush` completes.
	var flushing = false;
	// `requestFlush` is an implementation-specific method that attempts to kick
	// off a `flush` event as quickly as possible. `flush` will attempt to exhaust
	// the event queue before yielding to the browser's own event loop.
	var requestFlush;
	// The position of the next task to execute in the task queue. This is
	// preserved between calls to `flush` so that it can be resumed if
	// a task throws an exception.
	var index = 0;
	// If a task schedules additional tasks recursively, the task queue can grow
	// unbounded. To prevent memory exhaustion, the task queue will periodically
	// truncate already-completed tasks.
	var capacity = 1024;
	
	// The flush function processes all tasks that have been scheduled with
	// `rawAsap` unless and until one of those tasks throws an exception.
	// If a task throws an exception, `flush` ensures that its state will remain
	// consistent and will resume where it left off when called again.
	// However, `flush` does not make any arrangements to be called again if an
	// exception is thrown.
	function flush() {
	    while (index < queue.length) {
	        var currentIndex = index;
	        // Advance the index before calling the task. This ensures that we will
	        // begin flushing on the next task the task throws an error.
	        index = index + 1;
	        queue[currentIndex].call();
	        // Prevent leaking memory for long chains of recursive calls to `asap`.
	        // If we call `asap` within tasks scheduled by `asap`, the queue will
	        // grow, but to avoid an O(n) walk for every task we execute, we don't
	        // shift tasks off the queue after they have been executed.
	        // Instead, we periodically shift 1024 tasks off the queue.
	        if (index > capacity) {
	            // Manually shift all values starting at the index back to the
	            // beginning of the queue.
	            for (var scan = 0, newLength = queue.length - index; scan < newLength; scan++) {
	                queue[scan] = queue[scan + index];
	            }
	            queue.length -= index;
	            index = 0;
	        }
	    }
	    queue.length = 0;
	    index = 0;
	    flushing = false;
	}
	
	// `requestFlush` is implemented using a strategy based on data collected from
	// every available SauceLabs Selenium web driver worker at time of writing.
	// https://docs.google.com/spreadsheets/d/1mG-5UYGup5qxGdEMWkhP6BWCz053NUb2E1QoUTU16uA/edit#gid=783724593
	
	// Safari 6 and 6.1 for desktop, iPad, and iPhone are the only browsers that
	// have WebKitMutationObserver but not un-prefixed MutationObserver.
	// Must use `global` or `self` instead of `window` to work in both frames and web
	// workers. `global` is a provision of Browserify, Mr, Mrs, or Mop.
	
	/* globals self */
	var scope = typeof global !== "undefined" ? global : self;
	var BrowserMutationObserver = scope.MutationObserver || scope.WebKitMutationObserver;
	
	// MutationObservers are desirable because they have high priority and work
	// reliably everywhere they are implemented.
	// They are implemented in all modern browsers.
	//
	// - Android 4-4.3
	// - Chrome 26-34
	// - Firefox 14-29
	// - Internet Explorer 11
	// - iPad Safari 6-7.1
	// - iPhone Safari 7-7.1
	// - Safari 6-7
	if (typeof BrowserMutationObserver === "function") {
	    requestFlush = makeRequestCallFromMutationObserver(flush);
	
	    // MessageChannels are desirable because they give direct access to the HTML
	    // task queue, are implemented in Internet Explorer 10, Safari 5.0-1, and Opera
	    // 11-12, and in web workers in many engines.
	    // Although message channels yield to any queued rendering and IO tasks, they
	    // would be better than imposing the 4ms delay of timers.
	    // However, they do not work reliably in Internet Explorer or Safari.
	
	    // Internet Explorer 10 is the only browser that has setImmediate but does
	    // not have MutationObservers.
	    // Although setImmediate yields to the browser's renderer, it would be
	    // preferrable to falling back to setTimeout since it does not have
	    // the minimum 4ms penalty.
	    // Unfortunately there appears to be a bug in Internet Explorer 10 Mobile (and
	    // Desktop to a lesser extent) that renders both setImmediate and
	    // MessageChannel useless for the purposes of ASAP.
	    // https://github.com/kriskowal/q/issues/396
	
	    // Timers are implemented universally.
	    // We fall back to timers in workers in most engines, and in foreground
	    // contexts in the following browsers.
	    // However, note that even this simple case requires nuances to operate in a
	    // broad spectrum of browsers.
	    //
	    // - Firefox 3-13
	    // - Internet Explorer 6-9
	    // - iPad Safari 4.3
	    // - Lynx 2.8.7
	} else {
	    requestFlush = makeRequestCallFromTimer(flush);
	}
	
	// `requestFlush` requests that the high priority event queue be flushed as
	// soon as possible.
	// This is useful to prevent an error thrown in a task from stalling the event
	// queue if the exception handled by Node.js’s
	// `process.on("uncaughtException")` or by a domain.
	rawAsap.requestFlush = requestFlush;
	
	// To request a high priority event, we induce a mutation observer by toggling
	// the text of a text node between "1" and "-1".
	function makeRequestCallFromMutationObserver(callback) {
	    var toggle = 1;
	    var observer = new BrowserMutationObserver(callback);
	    var node = document.createTextNode("");
	    observer.observe(node, { characterData: true });
	    return function requestCall() {
	        toggle = -toggle;
	        node.data = toggle;
	    };
	}
	
	// The message channel technique was discovered by Malte Ubl and was the
	// original foundation for this library.
	// http://www.nonblocking.io/2011/06/windownexttick.html
	
	// Safari 6.0.5 (at least) intermittently fails to create message ports on a
	// page's first load. Thankfully, this version of Safari supports
	// MutationObservers, so we don't need to fall back in that case.
	
	// function makeRequestCallFromMessageChannel(callback) {
	//     var channel = new MessageChannel();
	//     channel.port1.onmessage = callback;
	//     return function requestCall() {
	//         channel.port2.postMessage(0);
	//     };
	// }
	
	// For reasons explained above, we are also unable to use `setImmediate`
	// under any circumstances.
	// Even if we were, there is another bug in Internet Explorer 10.
	// It is not sufficient to assign `setImmediate` to `requestFlush` because
	// `setImmediate` must be called *by name* and therefore must be wrapped in a
	// closure.
	// Never forget.
	
	// function makeRequestCallFromSetImmediate(callback) {
	//     return function requestCall() {
	//         setImmediate(callback);
	//     };
	// }
	
	// Safari 6.0 has a problem where timers will get lost while the user is
	// scrolling. This problem does not impact ASAP because Safari 6.0 supports
	// mutation observers, so that implementation is used instead.
	// However, if we ever elect to use timers in Safari, the prevalent work-around
	// is to add a scroll event listener that calls for a flush.
	
	// `setTimeout` does not call the passed callback if the delay is less than
	// approximately 7 in web workers in Firefox 8 through 18, and sometimes not
	// even then.
	
	function makeRequestCallFromTimer(callback) {
	    return function requestCall() {
	        // We dispatch a timeout with a specified delay of 0 for engines that
	        // can reliably accommodate that request. This will usually be snapped
	        // to a 4 milisecond delay, but once we're flushing, there's no delay
	        // between events.
	        var timeoutHandle = setTimeout(handleTimer, 0);
	        // However, since this timer gets frequently dropped in Firefox
	        // workers, we enlist an interval handle that will try to fire
	        // an event 20 times per second until it succeeds.
	        var intervalHandle = setInterval(handleTimer, 50);
	
	        function handleTimer() {
	            // Whichever timer succeeds will cancel both timers and
	            // execute the callback.
	            clearTimeout(timeoutHandle);
	            clearInterval(intervalHandle);
	            callback();
	        }
	    };
	}
	
	// This is for `asap.js` only.
	// Its name will be periodically randomized to break any code that depends on
	// its existence.
	rawAsap.makeRequestCallFromTimer = makeRequestCallFromTimer;
	
	// ASAP was originally a nextTick shim included in Q. This was factored out
	// into this ASAP package. It was later adapted to RSVP which made further
	// amendments. These decisions, particularly to marginalize MessageChannel and
	// to capture the MutationObserver implementation in a closure, were integrated
	// back into ASAP proper.
	// https://github.com/tildeio/rsvp.js/blob/cddf7232546a9cf858524b75cde6f9edf72620a7/lib/rsvp/asap.js
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ },
/* 556 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A directory of autogenerated icon components.
	 */
	
	module.exports = {
	    COS: __webpack_require__(577),
	    LOG: __webpack_require__(578),
	    EQUAL: __webpack_require__(579),
	    BACKSPACE: __webpack_require__(580),
	    SQRT: __webpack_require__(581),
	    EXP: __webpack_require__(582),
	    NEQ: __webpack_require__(583),
	    GEQ: __webpack_require__(584),
	    LN: __webpack_require__(585),
	    DISMISS: __webpack_require__(586),
	    SIN: __webpack_require__(587),
	    LT: __webpack_require__(588),
	    CUBE_ROOT: __webpack_require__(589),
	    PLUS: __webpack_require__(590),
	    TAN: __webpack_require__(591),
	    LEFT: __webpack_require__(592),
	    UP: __webpack_require__(593),
	    DOWN: __webpack_require__(594),
	    LEFT_PAREN: __webpack_require__(595),
	    RIGHT_PAREN: __webpack_require__(596),
	    GT: __webpack_require__(597),
	    DIVIDE: __webpack_require__(598),
	    PERIOD: __webpack_require__(599),
	    PERCENT: __webpack_require__(600),
	    TIMES: __webpack_require__(601),
	    EXP_3: __webpack_require__(602),
	    EXP_2: __webpack_require__(603),
	    RIGHT: __webpack_require__(604),
	    CDOT: __webpack_require__(605),
	    LOG_N: __webpack_require__(606),
	    LEQ: __webpack_require__(607),
	    MINUS: __webpack_require__(608),
	    NEGATIVE: __webpack_require__(608),
	    RADICAL: __webpack_require__(609),
	    FRAC_INCLUSIVE: __webpack_require__(610),
	    FRAC_EXCLUSIVE: __webpack_require__(611),
	    JUMP_OUT_PARENTHESES: __webpack_require__(612),
	    JUMP_OUT_EXPONENT: __webpack_require__(613),
	    JUMP_OUT_BASE: __webpack_require__(614),
	    JUMP_INTO_NUMERATOR: __webpack_require__(615),
	    JUMP_OUT_NUMERATOR: __webpack_require__(616),
	    JUMP_OUT_DENOMINATOR: __webpack_require__(617)
	};

/***/ },
/* 557 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */
	
	'use strict';
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	var printWarning = function printWarning() {};
	
	if (true) {
	  var ReactPropTypesSecret = __webpack_require__(562);
	  var loggedTypeFailures = {};
	  var has = Function.call.bind(Object.prototype.hasOwnProperty);
	
	  printWarning = function printWarning(text) {
	    var message = 'Warning: ' + text;
	    if (typeof console !== 'undefined') {
	      console.error(message);
	    }
	    try {
	      // --- Welcome to debugging React ---
	      // This error was thrown as a convenience so that you can use this stack
	      // to find the callsite that caused this warning to fire.
	      throw new Error(message);
	    } catch (x) {}
	  };
	}
	
	/**
	 * Assert that the values match with the type specs.
	 * Error messages are memorized and will only be shown once.
	 *
	 * @param {object} typeSpecs Map of name to a ReactPropType
	 * @param {object} values Runtime values that need to be type-checked
	 * @param {string} location e.g. "prop", "context", "child context"
	 * @param {string} componentName Name of the component for error messages.
	 * @param {?Function} getStack Returns the component stack.
	 * @private
	 */
	function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
	  if (true) {
	    for (var typeSpecName in typeSpecs) {
	      if (has(typeSpecs, typeSpecName)) {
	        var error;
	        // Prop type validation may throw. In case they do, we don't want to
	        // fail the render phase where it didn't fail before. So we log it.
	        // After these have been cleaned up, we'll let them throw.
	        try {
	          // This is intentionally an invariant that gets caught. It's the same
	          // behavior as without this statement except with a better message.
	          if (typeof typeSpecs[typeSpecName] !== 'function') {
	            var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + _typeof(typeSpecs[typeSpecName]) + '`.');
	            err.name = 'Invariant Violation';
	            throw err;
	          }
	          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
	        } catch (ex) {
	          error = ex;
	        }
	        if (error && !(error instanceof Error)) {
	          printWarning((componentName || 'React class') + ': type specification of ' + location + ' `' + typeSpecName + '` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a ' + (typeof error === 'undefined' ? 'undefined' : _typeof(error)) + '. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).');
	        }
	        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
	          // Only monitor this failure once because there tends to be a lot of the
	          // same error.
	          loggedTypeFailures[error.message] = true;
	
	          var stack = getStack ? getStack() : '';
	
	          printWarning('Failed ' + location + ' type: ' + error.message + (stack != null ? stack : ''));
	        }
	      }
	    }
	  }
	}
	
	/**
	 * Resets warning cache when testing.
	 *
	 * @private
	 */
	checkPropTypes.resetWarningCache = function () {
	  if (true) {
	    loggedTypeFailures = {};
	  }
	};
	
	module.exports = checkPropTypes;

/***/ },
/* 558 */
/***/ function(module, exports, __webpack_require__) {

	var root = __webpack_require__(618);
	
	/** Built-in value references. */
	var _Symbol = root.Symbol;
	
	module.exports = _Symbol;

/***/ },
/* 559 */
/***/ function(module, exports, __webpack_require__) {

	var _Symbol = __webpack_require__(558);
	
	/** Used for built-in method references. */
	var objectProto = Object.prototype;
	
	/** Used to check objects for own properties. */
	var hasOwnProperty = objectProto.hasOwnProperty;
	
	/**
	 * Used to resolve the
	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
	 * of values.
	 */
	var nativeObjectToString = objectProto.toString;
	
	/** Built-in value references. */
	var symToStringTag = _Symbol ? _Symbol.toStringTag : undefined;
	
	/**
	 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
	 *
	 * @private
	 * @param {*} value The value to query.
	 * @returns {string} Returns the raw `toStringTag`.
	 */
	function getRawTag(value) {
	  var isOwn = hasOwnProperty.call(value, symToStringTag),
	      tag = value[symToStringTag];
	
	  try {
	    value[symToStringTag] = undefined;
	    var unmasked = true;
	  } catch (e) {}
	
	  var result = nativeObjectToString.call(value);
	  if (unmasked) {
	    if (isOwn) {
	      value[symToStringTag] = tag;
	    } else {
	      delete value[symToStringTag];
	    }
	  }
	  return result;
	}
	
	module.exports = getRawTag;

/***/ },
/* 560 */
/***/ function(module, exports, __webpack_require__) {

	/** Used for built-in method references. */
	var objectProto = Object.prototype;
	
	/**
	 * Used to resolve the
	 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
	 * of values.
	 */
	var nativeObjectToString = objectProto.toString;
	
	/**
	 * Converts `value` to a string using `Object.prototype.toString`.
	 *
	 * @private
	 * @param {*} value The value to convert.
	 * @returns {string} Returns the converted string.
	 */
	function objectToString(value) {
	  return nativeObjectToString.call(value);
	}
	
	module.exports = objectToString;

/***/ },
/* 561 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Creates a unary function that invokes `func` with its argument transformed.
	 *
	 * @private
	 * @param {Function} func The function to wrap.
	 * @param {Function} transform The argument transform.
	 * @returns {Function} Returns the new function.
	 */
	function overArg(func, transform) {
	  return function (arg) {
	    return func(transform(arg));
	  };
	}
	
	module.exports = overArg;

/***/ },
/* 562 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Copyright (c) 2013-present, Facebook, Inc.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */
	
	'use strict';
	
	var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
	
	module.exports = ReactPropTypesSecret;

/***/ },
/* 563 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	exports["default"] = { "Webkit": { "transform": true, "transformOrigin": true, "transformOriginX": true, "transformOriginY": true, "backfaceVisibility": true, "perspective": true, "perspectiveOrigin": true, "transformStyle": true, "transformOriginZ": true, "animation": true, "animationDelay": true, "animationDirection": true, "animationFillMode": true, "animationDuration": true, "animationIterationCount": true, "animationName": true, "animationPlayState": true, "animationTimingFunction": true, "appearance": true, "userSelect": true, "fontKerning": true, "textEmphasisPosition": true, "textEmphasis": true, "textEmphasisStyle": true, "textEmphasisColor": true, "boxDecorationBreak": true, "clipPath": true, "maskImage": true, "maskMode": true, "maskRepeat": true, "maskPosition": true, "maskClip": true, "maskOrigin": true, "maskSize": true, "maskComposite": true, "mask": true, "maskBorderSource": true, "maskBorderMode": true, "maskBorderSlice": true, "maskBorderWidth": true, "maskBorderOutset": true, "maskBorderRepeat": true, "maskBorder": true, "maskType": true, "textDecorationStyle": true, "textDecorationSkip": true, "textDecorationLine": true, "textDecorationColor": true, "filter": true, "fontFeatureSettings": true, "breakAfter": true, "breakBefore": true, "breakInside": true, "columnCount": true, "columnFill": true, "columnGap": true, "columnRule": true, "columnRuleColor": true, "columnRuleStyle": true, "columnRuleWidth": true, "columns": true, "columnSpan": true, "columnWidth": true, "flex": true, "flexBasis": true, "flexDirection": true, "flexGrow": true, "flexFlow": true, "flexShrink": true, "flexWrap": true, "alignContent": true, "alignItems": true, "alignSelf": true, "justifyContent": true, "order": true, "transition": true, "transitionDelay": true, "transitionDuration": true, "transitionProperty": true, "transitionTimingFunction": true, "backdropFilter": true, "scrollSnapType": true, "scrollSnapPointsX": true, "scrollSnapPointsY": true, "scrollSnapDestination": true, "scrollSnapCoordinate": true, "shapeImageThreshold": true, "shapeImageMargin": true, "shapeImageOutside": true, "hyphens": true, "flowInto": true, "flowFrom": true, "regionFragment": true, "textSizeAdjust": true, "borderImage": true, "borderImageOutset": true, "borderImageRepeat": true, "borderImageSlice": true, "borderImageSource": true, "borderImageWidth": true, "tabSize": true, "objectFit": true, "objectPosition": true }, "Moz": { "appearance": true, "userSelect": true, "boxSizing": true, "textAlignLast": true, "textDecorationStyle": true, "textDecorationSkip": true, "textDecorationLine": true, "textDecorationColor": true, "tabSize": true, "hyphens": true, "fontFeatureSettings": true, "breakAfter": true, "breakBefore": true, "breakInside": true, "columnCount": true, "columnFill": true, "columnGap": true, "columnRule": true, "columnRuleColor": true, "columnRuleStyle": true, "columnRuleWidth": true, "columns": true, "columnSpan": true, "columnWidth": true }, "ms": { "flex": true, "flexBasis": false, "flexDirection": true, "flexGrow": false, "flexFlow": true, "flexShrink": false, "flexWrap": true, "alignContent": false, "alignItems": false, "alignSelf": false, "justifyContent": false, "order": false, "transform": true, "transformOrigin": true, "transformOriginX": true, "transformOriginY": true, "userSelect": true, "wrapFlow": true, "wrapThrough": true, "wrapMargin": true, "scrollSnapType": true, "scrollSnapPointsX": true, "scrollSnapPointsY": true, "scrollSnapDestination": true, "scrollSnapCoordinate": true, "touchAction": true, "hyphens": true, "flowInto": true, "flowFrom": true, "breakBefore": true, "breakAfter": true, "breakInside": true, "regionFragment": true, "gridTemplateColumns": true, "gridTemplateRows": true, "gridTemplateAreas": true, "gridTemplate": true, "gridAutoColumns": true, "gridAutoRows": true, "gridAutoFlow": true, "grid": true, "gridRowStart": true, "gridColumnStart": true, "gridRowEnd": true, "gridRow": true, "gridColumn": true, "gridColumnEnd": true, "gridColumnGap": true, "gridRowGap": true, "gridArea": true, "gridGap": true, "textSizeAdjust": true } };
	module.exports = exports["default"];

/***/ },
/* 564 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, "__esModule", {
		value: true
	});
	exports['default'] = symbolObservablePonyfill;
	function symbolObservablePonyfill(root) {
		var result;
		var _Symbol = root.Symbol;
	
		if (typeof _Symbol === 'function') {
			if (_Symbol.observable) {
				result = _Symbol.observable;
			} else {
				result = _Symbol('observable');
				_Symbol.observable = result;
			}
		} else {
			result = '@@observable';
		}
	
		return result;
	};

/***/ },
/* 565 */
/***/ function(module, exports, __webpack_require__) {

	// helper to capitalize strings
	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports["default"] = function (str) {
	  return str.charAt(0).toUpperCase() + str.slice(1);
	};
	
	module.exports = exports["default"];

/***/ },
/* 566 */
/***/ function(module, exports, __webpack_require__) {

	// leight polyfill for Object.assign
	"use strict";
	
	Object.defineProperty(exports, "__esModule", {
	  value: true
	});
	
	exports["default"] = function (base) {
	  var extend = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
	  return Object.keys(extend).reduce(function (out, key) {
	    base[key] = extend[key];
	    return out;
	  }, {});
	};
	
	module.exports = exports["default"];

/***/ },
/* 567 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = calc;
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	var _utilsJoinPrefixedRules = __webpack_require__(620);
	
	var _utilsJoinPrefixedRules2 = _interopRequireDefault(_utilsJoinPrefixedRules);
	
	var _utilsIsPrefixedValue = __webpack_require__(621);
	
	var _utilsIsPrefixedValue2 = _interopRequireDefault(_utilsIsPrefixedValue);
	
	function calc(property, value) {
	  if (typeof value === 'string' && value.indexOf('calc(') > -1) {
	    if ((0, _utilsIsPrefixedValue2['default'])(value)) return;
	
	    return (0, _utilsJoinPrefixedRules2['default'])(property, value, function (prefix, value) {
	      return value.replace(/calc\(/g, prefix + 'calc(');
	    });
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 568 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = cursor;
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	var _utilsJoinPrefixedRules = __webpack_require__(620);
	
	var _utilsJoinPrefixedRules2 = _interopRequireDefault(_utilsJoinPrefixedRules);
	
	var values = {
	  'zoom-in': true,
	  'zoom-out': true,
	  'grab': true,
	  'grabbing': true
	};
	
	function cursor(property, value) {
	  if (property === 'cursor' && values[value]) {
	    return (0, _utilsJoinPrefixedRules2['default'])(property, value);
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 569 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = flex;
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	var _utilsCamelToDashCase = __webpack_require__(622);
	
	var _utilsCamelToDashCase2 = _interopRequireDefault(_utilsCamelToDashCase);
	
	var values = { flex: true, 'inline-flex': true };
	
	function flex(property, value) {
	  if (property === 'display' && values[value]) {
	    return {
	      display: ['-webkit-box', '-moz-box', '-ms-' + value + 'box', '-webkit-' + value, value]
	    };
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 570 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = sizing;
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	var _utilsJoinPrefixedRules = __webpack_require__(620);
	
	var _utilsJoinPrefixedRules2 = _interopRequireDefault(_utilsJoinPrefixedRules);
	
	var properties = {
	  maxHeight: true,
	  maxWidth: true,
	  width: true,
	  height: true,
	  columnWidth: true,
	  minWidth: true,
	  minHeight: true
	};
	var values = {
	  'min-content': true,
	  'max-content': true,
	  'fill-available': true,
	  'fit-content': true,
	  'contain-floats': true
	};
	
	function sizing(property, value) {
	  if (properties[property] && values[value]) {
	    return (0, _utilsJoinPrefixedRules2['default'])(property, value);
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 571 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = gradient;
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	var _utilsJoinPrefixedRules = __webpack_require__(620);
	
	var _utilsJoinPrefixedRules2 = _interopRequireDefault(_utilsJoinPrefixedRules);
	
	var _utilsIsPrefixedValue = __webpack_require__(621);
	
	var _utilsIsPrefixedValue2 = _interopRequireDefault(_utilsIsPrefixedValue);
	
	var values = /linear-gradient|radial-gradient|repeating-linear-gradient|repeating-radial-gradient/;
	
	function gradient(property, value) {
	  if (typeof value === 'string' && value.match(values) !== null) {
	    if ((0, _utilsIsPrefixedValue2['default'])(value)) return;
	
	    return (0, _utilsJoinPrefixedRules2['default'])(property, value);
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 572 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = transition;
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	function _defineProperty(obj, key, value) {
	  if (key in obj) {
	    Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true });
	  } else {
	    obj[key] = value;
	  }return obj;
	}
	
	var _utilsCamelToDashCase = __webpack_require__(622);
	
	var _utilsCamelToDashCase2 = _interopRequireDefault(_utilsCamelToDashCase);
	
	var _utilsCapitalizeString = __webpack_require__(565);
	
	var _utilsCapitalizeString2 = _interopRequireDefault(_utilsCapitalizeString);
	
	var _utilsIsPrefixedValue = __webpack_require__(621);
	
	var _utilsIsPrefixedValue2 = _interopRequireDefault(_utilsIsPrefixedValue);
	
	var _prefixProps = __webpack_require__(563);
	
	var _prefixProps2 = _interopRequireDefault(_prefixProps);
	
	var properties = {
	  transition: true,
	  transitionProperty: true,
	  WebkitTransition: true,
	  WebkitTransitionProperty: true
	};
	
	function transition(property, value) {
	  // also check for already prefixed transitions
	  if (typeof value === 'string' && properties[property]) {
	    var _ref2;
	
	    var outputValue = prefixValue(value);
	    var webkitOutput = outputValue.split(',').filter(function (value) {
	      return value.match(/-moz-|-ms-/) === null;
	    }).join(',');
	
	    // if the property is already prefixed
	    if (property.indexOf('Webkit') > -1) {
	      return _defineProperty({}, property, webkitOutput);
	    }
	
	    return _ref2 = {}, _defineProperty(_ref2, 'Webkit' + (0, _utilsCapitalizeString2['default'])(property), webkitOutput), _defineProperty(_ref2, property, outputValue), _ref2;
	  }
	}
	
	function prefixValue(value) {
	  if ((0, _utilsIsPrefixedValue2['default'])(value)) {
	    return value;
	  }
	
	  // only split multi values, not cubic beziers
	  var multipleValues = value.split(/,(?![^()]*(?:\([^()]*\))?\))/g);
	
	  // iterate each single value and check for transitioned properties
	  // that need to be prefixed as well
	  multipleValues.forEach(function (val, index) {
	    multipleValues[index] = Object.keys(_prefixProps2['default']).reduce(function (out, prefix) {
	      var dashCasePrefix = '-' + prefix.toLowerCase() + '-';
	
	      Object.keys(_prefixProps2['default'][prefix]).forEach(function (prop) {
	        var dashCaseProperty = (0, _utilsCamelToDashCase2['default'])(prop);
	
	        if (val.indexOf(dashCaseProperty) > -1) {
	          // join all prefixes and create a new value
	          out = val.replace(dashCaseProperty, dashCasePrefix + dashCaseProperty) + ',' + out;
	        }
	      });
	      return out;
	    }, val);
	  });
	
	  return multipleValues.join(',');
	}
	module.exports = exports['default'];

/***/ },
/* 573 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = flexboxIE;
	
	function _defineProperty(obj, key, value) {
	  if (key in obj) {
	    Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true });
	  } else {
	    obj[key] = value;
	  }return obj;
	}
	
	var alternativeValues = {
	  'space-around': 'distribute',
	  'space-between': 'justify',
	  'flex-start': 'start',
	  'flex-end': 'end'
	};
	var alternativeProps = {
	  alignContent: 'msFlexLinePack',
	  alignSelf: 'msFlexItemAlign',
	  alignItems: 'msFlexAlign',
	  justifyContent: 'msFlexPack',
	  order: 'msFlexOrder',
	  flexGrow: 'msFlexPositive',
	  flexShrink: 'msFlexNegative',
	  flexBasis: 'msPreferredSize'
	};
	
	function flexboxIE(property, value) {
	  if (alternativeProps[property]) {
	    return _defineProperty({}, alternativeProps[property], alternativeValues[value] || value);
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 574 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	exports['default'] = flexboxOld;
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	function _defineProperty(obj, key, value) {
	  if (key in obj) {
	    Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true });
	  } else {
	    obj[key] = value;
	  }return obj;
	}
	
	var _utilsCamelToDashCase = __webpack_require__(622);
	
	var _utilsCamelToDashCase2 = _interopRequireDefault(_utilsCamelToDashCase);
	
	var alternativeValues = {
	  'space-around': 'justify',
	  'space-between': 'justify',
	  'flex-start': 'start',
	  'flex-end': 'end',
	  'wrap-reverse': 'multiple',
	  wrap: 'multiple'
	};
	
	var alternativeProps = {
	  alignItems: 'WebkitBoxAlign',
	  justifyContent: 'WebkitBoxPack',
	  flexWrap: 'WebkitBoxLines'
	};
	
	function flexboxOld(property, value) {
	  if (property === 'flexDirection') {
	    return {
	      WebkitBoxOrient: value.indexOf('column') > -1 ? 'vertical' : 'horizontal',
	      WebkitBoxDirection: value.indexOf('reverse') > -1 ? 'reverse' : 'normal'
	    };
	  }
	  if (alternativeProps[property]) {
	    return _defineProperty({}, alternativeProps[property], alternativeValues[value] || value);
	  }
	}
	
	module.exports = exports['default'];

/***/ },
/* 575 */
/***/ function(module, exports, __webpack_require__) {

	/** @license React v16.13.1
	 * react-is.development.js
	 *
	 * Copyright (c) Facebook, Inc. and its affiliates.
	 *
	 * This source code is licensed under the MIT license found in the
	 * LICENSE file in the root directory of this source tree.
	 */
	
	'use strict';
	
	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	if (true) {
	  (function () {
	    'use strict';
	
	    // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
	    // nor polyfill, then a plain number is used for performance.
	
	    var hasSymbol = typeof Symbol === 'function' && Symbol.for;
	    var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
	    var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
	    var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
	    var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
	    var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
	    var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
	    var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
	    // (unstable) APIs that have been removed. Can we remove the symbols?
	
	    var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
	    var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
	    var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
	    var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
	    var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
	    var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
	    var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
	    var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
	    var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
	    var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
	    var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;
	
	    function isValidElementType(type) {
	      return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
	      type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || (typeof type === 'undefined' ? 'undefined' : _typeof(type)) === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
	    }
	
	    function typeOf(object) {
	      if ((typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && object !== null) {
	        var $$typeof = object.$$typeof;
	
	        switch ($$typeof) {
	          case REACT_ELEMENT_TYPE:
	            var type = object.type;
	
	            switch (type) {
	              case REACT_ASYNC_MODE_TYPE:
	              case REACT_CONCURRENT_MODE_TYPE:
	              case REACT_FRAGMENT_TYPE:
	              case REACT_PROFILER_TYPE:
	              case REACT_STRICT_MODE_TYPE:
	              case REACT_SUSPENSE_TYPE:
	                return type;
	
	              default:
	                var $$typeofType = type && type.$$typeof;
	
	                switch ($$typeofType) {
	                  case REACT_CONTEXT_TYPE:
	                  case REACT_FORWARD_REF_TYPE:
	                  case REACT_LAZY_TYPE:
	                  case REACT_MEMO_TYPE:
	                  case REACT_PROVIDER_TYPE:
	                    return $$typeofType;
	
	                  default:
	                    return $$typeof;
	                }
	
	            }
	
	          case REACT_PORTAL_TYPE:
	            return $$typeof;
	        }
	      }
	
	      return undefined;
	    } // AsyncMode is deprecated along with isAsyncMode
	
	    var AsyncMode = REACT_ASYNC_MODE_TYPE;
	    var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
	    var ContextConsumer = REACT_CONTEXT_TYPE;
	    var ContextProvider = REACT_PROVIDER_TYPE;
	    var Element = REACT_ELEMENT_TYPE;
	    var ForwardRef = REACT_FORWARD_REF_TYPE;
	    var Fragment = REACT_FRAGMENT_TYPE;
	    var Lazy = REACT_LAZY_TYPE;
	    var Memo = REACT_MEMO_TYPE;
	    var Portal = REACT_PORTAL_TYPE;
	    var Profiler = REACT_PROFILER_TYPE;
	    var StrictMode = REACT_STRICT_MODE_TYPE;
	    var Suspense = REACT_SUSPENSE_TYPE;
	    var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated
	
	    function isAsyncMode(object) {
	      {
	        if (!hasWarnedAboutDeprecatedIsAsyncMode) {
	          hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
	
	          console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
	        }
	      }
	
	      return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
	    }
	    function isConcurrentMode(object) {
	      return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
	    }
	    function isContextConsumer(object) {
	      return typeOf(object) === REACT_CONTEXT_TYPE;
	    }
	    function isContextProvider(object) {
	      return typeOf(object) === REACT_PROVIDER_TYPE;
	    }
	    function isElement(object) {
	      return (typeof object === 'undefined' ? 'undefined' : _typeof(object)) === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
	    }
	    function isForwardRef(object) {
	      return typeOf(object) === REACT_FORWARD_REF_TYPE;
	    }
	    function isFragment(object) {
	      return typeOf(object) === REACT_FRAGMENT_TYPE;
	    }
	    function isLazy(object) {
	      return typeOf(object) === REACT_LAZY_TYPE;
	    }
	    function isMemo(object) {
	      return typeOf(object) === REACT_MEMO_TYPE;
	    }
	    function isPortal(object) {
	      return typeOf(object) === REACT_PORTAL_TYPE;
	    }
	    function isProfiler(object) {
	      return typeOf(object) === REACT_PROFILER_TYPE;
	    }
	    function isStrictMode(object) {
	      return typeOf(object) === REACT_STRICT_MODE_TYPE;
	    }
	    function isSuspense(object) {
	      return typeOf(object) === REACT_SUSPENSE_TYPE;
	    }
	
	    exports.AsyncMode = AsyncMode;
	    exports.ConcurrentMode = ConcurrentMode;
	    exports.ContextConsumer = ContextConsumer;
	    exports.ContextProvider = ContextProvider;
	    exports.Element = Element;
	    exports.ForwardRef = ForwardRef;
	    exports.Fragment = Fragment;
	    exports.Lazy = Lazy;
	    exports.Memo = Memo;
	    exports.Portal = Portal;
	    exports.Profiler = Profiler;
	    exports.StrictMode = StrictMode;
	    exports.Suspense = Suspense;
	    exports.isAsyncMode = isAsyncMode;
	    exports.isConcurrentMode = isConcurrentMode;
	    exports.isContextConsumer = isContextConsumer;
	    exports.isContextProvider = isContextProvider;
	    exports.isElement = isElement;
	    exports.isForwardRef = isForwardRef;
	    exports.isFragment = isFragment;
	    exports.isLazy = isLazy;
	    exports.isMemo = isMemo;
	    exports.isPortal = isPortal;
	    exports.isProfiler = isProfiler;
	    exports.isStrictMode = isStrictMode;
	    exports.isSuspense = isSuspense;
	    exports.isValidElementType = isValidElementType;
	    exports.typeOf = typeOf;
	  })();
	}

/***/ },
/* 576 */
/***/ function(module, exports, __webpack_require__) {

	/*
	object-assign
	(c) Sindre Sorhus
	@license MIT
	*/
	
	'use strict';
	/* eslint-disable no-unused-vars */
	
	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
	var hasOwnProperty = Object.prototype.hasOwnProperty;
	var propIsEnumerable = Object.prototype.propertyIsEnumerable;
	
	function toObject(val) {
		if (val === null || val === undefined) {
			throw new TypeError('Object.assign cannot be called with null or undefined');
		}
	
		return Object(val);
	}
	
	function shouldUseNative() {
		try {
			if (!Object.assign) {
				return false;
			}
	
			// Detect buggy property enumeration order in older V8 versions.
	
			// https://bugs.chromium.org/p/v8/issues/detail?id=4118
			var test1 = new String('abc'); // eslint-disable-line no-new-wrappers
			test1[5] = 'de';
			if (Object.getOwnPropertyNames(test1)[0] === '5') {
				return false;
			}
	
			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
			var test2 = {};
			for (var i = 0; i < 10; i++) {
				test2['_' + String.fromCharCode(i)] = i;
			}
			var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
				return test2[n];
			});
			if (order2.join('') !== '0123456789') {
				return false;
			}
	
			// https://bugs.chromium.org/p/v8/issues/detail?id=3056
			var test3 = {};
			'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
				test3[letter] = letter;
			});
			if (Object.keys(Object.assign({}, test3)).join('') !== 'abcdefghijklmnopqrst') {
				return false;
			}
	
			return true;
		} catch (err) {
			// We don't expect any of the above to throw, but better to be safe.
			return false;
		}
	}
	
	module.exports = shouldUseNative() ? Object.assign : function (target, source) {
		var from;
		var to = toObject(target);
		var symbols;
	
		for (var s = 1; s < arguments.length; s++) {
			from = Object(arguments[s]);
	
			for (var key in from) {
				if (hasOwnProperty.call(from, key)) {
					to[key] = from[key];
				}
			}
	
			if (getOwnPropertySymbols) {
				symbols = getOwnPropertySymbols(from);
				for (var i = 0; i < symbols.length; i++) {
					if (propIsEnumerable.call(from, symbols[i])) {
						to[symbols[i]] = from[symbols[i]];
					}
				}
			}
		}
	
		return to;
	};

/***/ },
/* 577 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the COS iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Cos = function (_React$Component) {
	    _inherits(Cos, _React$Component);
	
	    function Cos() {
	        _classCallCheck(this, Cos);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Cos.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M13 12h24v24H13z" }),
	                React.createElement("path", { d: "M18.182 29.168c1.386 0 2.226-.602 2.674-1.232l-1.162-1.078a1.707 1.707 0 0 1-1.428.728c-1.078 0-1.834-.798-1.834-1.974s.756-1.96 1.834-1.96c.616 0 1.106.252 1.428.728l1.162-1.092c-.448-.616-1.288-1.218-2.674-1.218-2.086 0-3.584 1.47-3.584 3.542 0 2.086 1.498 3.556 3.584 3.556zm6.972 0c2.24 0 3.584-1.624 3.584-3.556 0-1.918-1.344-3.542-3.584-3.542-2.226 0-3.57 1.624-3.57 3.542 0 1.932 1.344 3.556 3.57 3.556zm0-1.582c-1.106 0-1.722-.91-1.722-1.974 0-1.05.616-1.96 1.722-1.96 1.106 0 1.736.91 1.736 1.96 0 1.064-.63 1.974-1.736 1.974zm7.336 1.582c1.876 0 2.926-.938 2.926-2.17 0-2.73-4.004-1.89-4.004-2.898 0-.378.42-.672 1.064-.672.826 0 1.596.35 2.002.784l.714-1.218c-.672-.532-1.582-.924-2.73-.924-1.778 0-2.772.994-2.772 2.128 0 2.66 4.018 1.75 4.018 2.87 0 .42-.364.728-1.134.728-.84 0-1.848-.462-2.338-.924l-.77 1.246c.714.658 1.848 1.05 3.024 1.05z", fill: this.props.color })
	            )
	        );
	    };
	
	    return Cos;
	}(React.Component);
	
	Cos.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Cos;

/***/ },
/* 578 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the LOG iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Log = function (_React$Component) {
	    _inherits(Log, _React$Component);
	
	    function Log() {
	        _classCallCheck(this, Log);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Log.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { d: "M16.776 29v-9.338h-1.778V29h1.778zm4.9.168c2.24 0 3.584-1.624 3.584-3.556 0-1.918-1.344-3.542-3.584-3.542-2.226 0-3.57 1.624-3.57 3.542 0 1.932 1.344 3.556 3.57 3.556zm0-1.582c-1.106 0-1.722-.91-1.722-1.974 0-1.05.616-1.96 1.722-1.96 1.106 0 1.736.91 1.736 1.96 0 1.064-.63 1.974-1.736 1.974zm7.672 4.158c1.666 0 3.654-.63 3.654-3.206v-6.3H31.21v.868c-.546-.686-1.274-1.036-2.086-1.036-1.708 0-2.982 1.232-2.982 3.444 0 2.254 1.288 3.444 2.982 3.444.826 0 1.554-.392 2.086-1.064v.686c0 1.33-1.008 1.708-1.862 1.708-.854 0-1.568-.238-2.114-.84l-.798 1.288c.854.742 1.75 1.008 2.912 1.008zm.336-4.368c-1.008 0-1.708-.7-1.708-1.862 0-1.162.7-1.862 1.708-1.862.588 0 1.232.322 1.526.77v2.184c-.294.434-.938.77-1.526.77z", fill: this.props.color })
	            )
	        );
	    };
	
	    return Log;
	}(React.Component);
	
	Log.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Log;

/***/ },
/* 579 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the EQUAL iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Equal = function (_React$Component) {
	    _inherits(Equal, _React$Component);
	
	    function Equal() {
	        _classCallCheck(this, Equal);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Equal.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	                React.createElement("path", { d: "M16 21h17M16 27h17", stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
	            )
	        );
	    };
	
	    return Equal;
	}(React.Component);
	
	Equal.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Equal;

/***/ },
/* 580 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * An autogenerated component that renders the BACKSPACE iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Backspace = function Backspace() {
	  return React.createElement(
	    "svg",
	    { width: "48", height: "48", viewBox: "0 0 48 48" },
	    React.createElement(
	      "g",
	      { fill: "none", fillRule: "evenodd" },
	      React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	      React.createElement("path", { d: "M13 24l6 6h14V18H19l-6 6zm-1.414-1.414l6-6A2 2 0 0 1 19 16h14a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2H19a2 2 0 0 1-1.414-.586l-6-6a2 2 0 0 1 0-2.828z", fill: "#888D93" }),
	      React.createElement("path", { d: "M23 21l6 6M29 21l-6 6", stroke: "#888D93", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
	    )
	  );
	};
	
	module.exports = Backspace;

/***/ },
/* 581 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the SQRT iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Sqrt = function (_React$Component) {
	    _inherits(Sqrt, _React$Component);
	
	    function Sqrt() {
	        _classCallCheck(this, Sqrt);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Sqrt.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", d: "M14 29l4 6 9-14h7" })
	            )
	        );
	    };
	
	    return Sqrt;
	}(React.Component);
	
	Sqrt.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Sqrt;

/***/ },
/* 582 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the EXP iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Exp = function (_React$Component) {
	    _inherits(Exp, _React$Component);
	
	    function Exp() {
	        _classCallCheck(this, Exp);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Exp.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { d: "M28 16.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM30 18h4v4h-4v-4zM14 21c0-.552.456-1 1.002-1h9.996A1 1 0 0 1 26 21v14c0 .552-.456 1-1.002 1h-9.996A1 1 0 0 1 14 35V21zm2 1h8v12h-8V22z", fill: this.props.color })
	            )
	        );
	    };
	
	    return Exp;
	}(React.Component);
	
	Exp.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Exp;

/***/ },
/* 583 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the NEQ iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Neq = function (_React$Component) {
	    _inherits(Neq, _React$Component);
	
	    function Neq() {
	        _classCallCheck(this, Neq);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Neq.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	                React.createElement("path", { d: "M19 33l10-18M16 21h17M16 27h17", stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
	            )
	        );
	    };
	
	    return Neq;
	}(React.Component);
	
	Neq.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Neq;

/***/ },
/* 584 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the GEQ iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Geq = function (_React$Component) {
	    _inherits(Geq, _React$Component);
	
	    function Geq() {
	        _classCallCheck(this, Geq);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Geq.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	                React.createElement("path", { d: "M16 33h16M16 30l16-6-16-6", stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
	            )
	        );
	    };
	
	    return Geq;
	}(React.Component);
	
	Geq.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Geq;

/***/ },
/* 585 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the LN iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Ln = function (_React$Component) {
	    _inherits(Ln, _React$Component);
	
	    function Ln() {
	        _classCallCheck(this, Ln);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Ln.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { d: "M20.836 29v-9.338h-1.778V29h1.778zm8.106 0v-4.774c0-1.316-.714-2.156-2.198-2.156-1.106 0-1.932.532-2.366 1.05v-.882H22.6V29h1.778v-4.55c.294-.406.84-.798 1.54-.798.756 0 1.246.322 1.246 1.26V29h1.778z", fill: this.props.color })
	            )
	        );
	    };
	
	    return Ln;
	}(React.Component);
	
	Ln.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Ln;

/***/ },
/* 586 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * An autogenerated component that renders the DISMISS iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Dismiss = function Dismiss() {
	  return React.createElement(
	    "svg",
	    { width: "48", height: "48", viewBox: "0 0 48 48" },
	    React.createElement(
	      "g",
	      { fill: "none", fillRule: "evenodd" },
	      React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	      React.createElement("path", { d: "M18 21l6 6 6-6", strokeLinecap: "round", strokeWidth: "2", stroke: "#71B307", strokeLinejoin: "round" })
	    )
	  );
	};
	
	module.exports = Dismiss;

/***/ },
/* 587 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the SIN iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Sin = function (_React$Component) {
	    _inherits(Sin, _React$Component);
	
	    function Sin() {
	        _classCallCheck(this, Sin);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Sin.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	                React.createElement("path", { d: "M18.655 29.168c1.876 0 2.926-.938 2.926-2.17 0-2.73-4.004-1.89-4.004-2.898 0-.378.42-.672 1.064-.672.826 0 1.596.35 2.002.784l.714-1.218c-.672-.532-1.582-.924-2.73-.924-1.778 0-2.772.994-2.772 2.128 0 2.66 4.018 1.75 4.018 2.87 0 .42-.364.728-1.134.728-.84 0-1.848-.462-2.338-.924l-.77 1.246c.714.658 1.848 1.05 3.024 1.05zm5.124-7.658c.588 0 1.064-.476 1.064-1.064 0-.588-.476-1.05-1.064-1.05a1.06 1.06 0 0 0-1.064 1.05c0 .588.49 1.064 1.064 1.064zm.896 7.49v-6.762h-1.778V29h1.778zm8.106 0v-4.774c0-1.316-.714-2.156-2.198-2.156-1.106 0-1.932.532-2.366 1.05v-.882h-1.778V29h1.778v-4.55c.294-.406.84-.798 1.54-.798.756 0 1.246.322 1.246 1.26V29h1.778z", fill: this.props.color })
	            )
	        );
	    };
	
	    return Sin;
	}(React.Component);
	
	Sin.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Sin;

/***/ },
/* 588 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the LT iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Lt = function (_React$Component) {
	    _inherits(Lt, _React$Component);
	
	    function Lt() {
	        _classCallCheck(this, Lt);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Lt.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	                React.createElement("path", { stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", d: "M32 30l-16-6 16-6" })
	            )
	        );
	    };
	
	    return Lt;
	}(React.Component);
	
	Lt.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Lt;

/***/ },
/* 589 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the CUBE_ROOT iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var CubeRoot = function (_React$Component) {
	    _inherits(CubeRoot, _React$Component);
	
	    function CubeRoot() {
	        _classCallCheck(this, CubeRoot);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    CubeRoot.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { d: "M17.91 23.12c1.66 0 2.76-.81 2.76-1.98 0-.96-.86-1.51-1.57-1.58.79-.13 1.46-.72 1.46-1.5 0-1.1-.95-1.83-2.65-1.83-1.23 0-2.11.45-2.67 1.08l.83 1.08c.47-.42 1.05-.64 1.66-.64.64 0 1.12.19 1.12.61 0 .35-.39.52-1.08.52-.25 0-.77 0-.9-.01v1.53c.1-.01.61-.01.9-.01.91 0 1.19.18 1.19.56 0 .37-.38.65-1.12.65-.58 0-1.34-.23-1.82-.7l-.87 1.17c.52.6 1.48 1.05 2.76 1.05z", fill: this.props.color }),
	                React.createElement("path", { stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", d: "M14 29l4 6 9-14h7" })
	            )
	        );
	    };
	
	    return CubeRoot;
	}(React.Component);
	
	CubeRoot.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = CubeRoot;

/***/ },
/* 590 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the PLUS iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Plus = function (_React$Component) {
	    _inherits(Plus, _React$Component);
	
	    function Plus() {
	        _classCallCheck(this, Plus);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Plus.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { d: "M19 24h10M24 29V19", stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
	            )
	        );
	    };
	
	    return Plus;
	}(React.Component);
	
	Plus.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Plus;

/***/ },
/* 591 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the TAN iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Tan = function (_React$Component) {
	    _inherits(Tan, _React$Component);
	
	    function Tan() {
	        _classCallCheck(this, Tan);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Tan.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	                React.createElement("path", { d: "M16.93 29.168c.742 0 1.218-.196 1.484-.434l-.378-1.344c-.098.098-.35.196-.616.196-.392 0-.616-.322-.616-.742v-3.052h1.372v-1.554h-1.372V20.39h-1.792v1.848h-1.12v1.554h1.12v3.528c0 1.204.672 1.848 1.918 1.848zM25.232 29v-4.368c0-1.946-1.414-2.562-2.954-2.562-1.064 0-2.128.336-2.954 1.064l.672 1.19c.574-.532 1.246-.798 1.974-.798.896 0 1.484.448 1.484 1.134v.91c-.448-.532-1.246-.826-2.142-.826-1.078 0-2.352.602-2.352 2.184 0 1.512 1.274 2.24 2.352 2.24.882 0 1.68-.322 2.142-.868v.7h1.778zm-3.206-1.036c-.7 0-1.274-.364-1.274-.994 0-.658.574-1.022 1.274-1.022.574 0 1.134.196 1.428.588v.84c-.294.392-.854.588-1.428.588zM33.338 29v-4.774c0-1.316-.714-2.156-2.198-2.156-1.106 0-1.932.532-2.366 1.05v-.882h-1.778V29h1.778v-4.55c.294-.406.84-.798 1.54-.798.756 0 1.246.322 1.246 1.26V29h1.778z", fill: this.props.color })
	            )
	        );
	    };
	
	    return Tan;
	}(React.Component);
	
	Tan.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Tan;

/***/ },
/* 592 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * An component that renders the LEFT iconograpy in SVG.
	 */
	var React = __webpack_require__(43);
	
	var Arrow = __webpack_require__(623);
	
	var Left = function Left() {
	  return React.createElement(
	    'svg',
	    { width: '48', height: '48', viewBox: '0 0 48 48' },
	    React.createElement(Arrow, null)
	  );
	};
	
	module.exports = Left;

/***/ },
/* 593 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A component that renders the UP iconograpy in SVG.
	 */
	var React = __webpack_require__(43);
	
	var Arrow = __webpack_require__(623);
	
	var Up = function Up() {
	    return React.createElement(
	        'svg',
	        { width: '48', height: '48', viewBox: '0 0 48 48' },
	        React.createElement(Arrow, { transform: 'rotate(90 24 24)' })
	    );
	};
	
	module.exports = Up;

/***/ },
/* 594 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A component that renders the DOWN iconograpy in SVG.
	 */
	var React = __webpack_require__(43);
	
	var Arrow = __webpack_require__(623);
	
	var Down = function Down() {
	    return React.createElement(
	        'svg',
	        { width: '48', height: '48', viewBox: '0 0 48 48' },
	        React.createElement(Arrow, { transform: 'rotate(270 24 24)' })
	    );
	};
	
	module.exports = Down;

/***/ },
/* 595 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the LEFT_PAREN iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var LeftParen = function (_React$Component) {
	    _inherits(LeftParen, _React$Component);
	
	    function LeftParen() {
	        _classCallCheck(this, LeftParen);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    LeftParen.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	                React.createElement("path", { d: "M26 14c-4 6-4 14 0 20", stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
	            )
	        );
	    };
	
	    return LeftParen;
	}(React.Component);
	
	LeftParen.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = LeftParen;

/***/ },
/* 596 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the RIGHT_PAREN iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var RightParen = function (_React$Component) {
	    _inherits(RightParen, _React$Component);
	
	    function RightParen() {
	        _classCallCheck(this, RightParen);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    RightParen.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	                React.createElement("path", { d: "M23 14c4 6 4 14 0 20", stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
	            )
	        );
	    };
	
	    return RightParen;
	}(React.Component);
	
	RightParen.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = RightParen;

/***/ },
/* 597 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the GT iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Gt = function (_React$Component) {
	    _inherits(Gt, _React$Component);
	
	    function Gt() {
	        _classCallCheck(this, Gt);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Gt.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	                React.createElement("path", { stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", d: "M16 30l16-6-16-6" })
	            )
	        );
	    };
	
	    return Gt;
	}(React.Component);
	
	Gt.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Gt;

/***/ },
/* 598 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the DIVIDE iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Divide = function (_React$Component) {
	    _inherits(Divide, _React$Component);
	
	    function Divide() {
	        _classCallCheck(this, Divide);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Divide.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { d: "M19 24h10", stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
	                React.createElement("circle", { fill: this.props.color, cx: "24", cy: "19.5", r: "1.5" }),
	                React.createElement("circle", { fill: this.props.color, cx: "24", cy: "28.5", r: "1.5" })
	            )
	        );
	    };
	
	    return Divide;
	}(React.Component);
	
	Divide.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Divide;

/***/ },
/* 599 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the PERIOD iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Period = function (_React$Component) {
	    _inherits(Period, _React$Component);
	
	    function Period() {
	        _classCallCheck(this, Period);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Period.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("circle", { fill: this.props.color, cx: "24", cy: "30", r: "2" })
	            )
	        );
	    };
	
	    return Period;
	}(React.Component);
	
	Period.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Period;

/***/ },
/* 600 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the PERCENT iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Percent = function (_React$Component) {
	    _inherits(Percent, _React$Component);
	
	    function Percent() {
	        _classCallCheck(this, Percent);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Percent.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement(
	                    "g",
	                    { transform: "translate(12 12)" },
	                    React.createElement("path", { fill: "none", d: "M0 0h24v24H0z" }),
	                    React.createElement("path", { d: "M16 4L8 20", stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
	                    React.createElement("circle", { stroke: this.props.color, strokeWidth: "2", cx: "7", cy: "7", r: "3" }),
	                    React.createElement("circle", { stroke: this.props.color, strokeWidth: "2", cx: "17", cy: "17", r: "3" })
	                )
	            )
	        );
	    };
	
	    return Percent;
	}(React.Component);
	
	Percent.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Percent;

/***/ },
/* 601 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the TIMES iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Times = function (_React$Component) {
	    _inherits(Times, _React$Component);
	
	    function Times() {
	        _classCallCheck(this, Times);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Times.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	                React.createElement("path", { d: "M20 20l8 8M28 20l-8 8", stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
	            )
	        );
	    };
	
	    return Times;
	}(React.Component);
	
	Times.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Times;

/***/ },
/* 602 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the EXP_3 iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Exp3 = function (_React$Component) {
	    _inherits(Exp3, _React$Component);
	
	    function Exp3() {
	        _classCallCheck(this, Exp3);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Exp3.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { d: "M14 21c0-.552.456-1 1.002-1h9.996A1 1 0 0 1 26 21v14c0 .552-.456 1-1.002 1h-9.996A1 1 0 0 1 14 35V21zm2 1h8v12h-8V22zM30.92 23.12c1.66 0 2.76-.81 2.76-1.98 0-.96-.86-1.51-1.57-1.58.79-.13 1.46-.72 1.46-1.5 0-1.1-.95-1.83-2.65-1.83-1.23 0-2.11.45-2.67 1.08l.83 1.08c.47-.42 1.05-.64 1.66-.64.64 0 1.12.19 1.12.61 0 .35-.39.52-1.08.52-.25 0-.77 0-.9-.01v1.53c.1-.01.61-.01.9-.01.91 0 1.19.18 1.19.56 0 .37-.38.65-1.12.65-.58 0-1.34-.23-1.82-.7l-.87 1.17c.52.6 1.48 1.05 2.76 1.05z", fill: this.props.color })
	            )
	        );
	    };
	
	    return Exp3;
	}(React.Component);
	
	Exp3.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Exp3;

/***/ },
/* 603 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the EXP_2 iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Exp2 = function (_React$Component) {
	    _inherits(Exp2, _React$Component);
	
	    function Exp2() {
	        _classCallCheck(this, Exp2);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Exp2.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { d: "M14 21c0-.552.456-1 1.002-1h9.996A1 1 0 0 1 26 21v14c0 .552-.456 1-1.002 1h-9.996A1 1 0 0 1 14 35V21zm2 1h8v12h-8V22zM33.67 23v-1.5h-2.44c1.66-1.16 2.39-2.03 2.39-3.05 0-1.34-1.13-2.22-2.7-2.22-.93 0-1.99.33-2.7 1.11l.95 1.14c.48-.45 1.04-.73 1.78-.73.49 0 .92.24.92.7 0 .66-.54 1.12-3.43 3.21V23h5.23z", fill: this.props.color })
	            )
	        );
	    };
	
	    return Exp2;
	}(React.Component);
	
	Exp2.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Exp2;

/***/ },
/* 604 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * A component that renders the RIGHT iconograpy in SVG.
	 */
	var React = __webpack_require__(43);
	
	var Arrow = __webpack_require__(623);
	
	var Right = function Right() {
	    return React.createElement(
	        'svg',
	        { width: '48', height: '48', viewBox: '0 0 48 48' },
	        React.createElement(Arrow, { transform: 'rotate(180 24 24)' })
	    );
	};
	
	module.exports = Right;

/***/ },
/* 605 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the CDOT iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Cdot = function (_React$Component) {
	    _inherits(Cdot, _React$Component);
	
	    function Cdot() {
	        _classCallCheck(this, Cdot);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Cdot.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement(
	                    "g",
	                    { transform: "translate(12 12)" },
	                    React.createElement("path", { fill: "none", d: "M0 0h24v24H0z" }),
	                    React.createElement("circle", { fill: this.props.color, cx: "12", cy: "12", r: "3" })
	                )
	            )
	        );
	    };
	
	    return Cdot;
	}(React.Component);
	
	Cdot.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Cdot;

/***/ },
/* 606 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the LOG_N iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var LogN = function (_React$Component) {
	    _inherits(LogN, _React$Component);
	
	    function LogN() {
	        _classCallCheck(this, LogN);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    LogN.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { d: "M30 28.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM32 30h4v4h-4v-4zM12.776 29v-9.338h-1.778V29h1.778zm4.9.168c2.24 0 3.584-1.624 3.584-3.556 0-1.918-1.344-3.542-3.584-3.542-2.226 0-3.57 1.624-3.57 3.542 0 1.932 1.344 3.556 3.57 3.556zm0-1.582c-1.106 0-1.722-.91-1.722-1.974 0-1.05.616-1.96 1.722-1.96 1.106 0 1.736.91 1.736 1.96 0 1.064-.63 1.974-1.736 1.974zm7.672 4.158c1.666 0 3.654-.63 3.654-3.206v-6.3H27.21v.868c-.546-.686-1.274-1.036-2.086-1.036-1.708 0-2.982 1.232-2.982 3.444 0 2.254 1.288 3.444 2.982 3.444.826 0 1.554-.392 2.086-1.064v.686c0 1.33-1.008 1.708-1.862 1.708-.854 0-1.568-.238-2.114-.84l-.798 1.288c.854.742 1.75 1.008 2.912 1.008zm.336-4.368c-1.008 0-1.708-.7-1.708-1.862 0-1.162.7-1.862 1.708-1.862.588 0 1.232.322 1.526.77v2.184c-.294.434-.938.77-1.526.77z", fill: this.props.color })
	            )
	        );
	    };
	
	    return LogN;
	}(React.Component);
	
	LogN.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = LogN;

/***/ },
/* 607 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the LEQ iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Leq = function (_React$Component) {
	    _inherits(Leq, _React$Component);
	
	    function Leq() {
	        _classCallCheck(this, Leq);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Leq.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	                React.createElement("path", { d: "M16 33h16M32 30l-16-6 16-6", stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
	            )
	        );
	    };
	
	    return Leq;
	}(React.Component);
	
	Leq.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Leq;

/***/ },
/* 608 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the MINUS iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Minus = function (_React$Component) {
	    _inherits(Minus, _React$Component);
	
	    function Minus() {
	        _classCallCheck(this, Minus);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Minus.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { d: "M19 24h10", stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
	            )
	        );
	    };
	
	    return Minus;
	}(React.Component);
	
	Minus.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Minus;

/***/ },
/* 609 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the RADICAL iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var Radical = function (_React$Component) {
	    _inherits(Radical, _React$Component);
	
	    function Radical() {
	        _classCallCheck(this, Radical);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    Radical.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement("path", { d: "M13 16.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM15 18h4v4h-4v-4z", fill: this.props.color }),
	                React.createElement("path", { stroke: this.props.color, strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", d: "M14 29l4 6 9-14h7" })
	            )
	        );
	    };
	
	    return Radical;
	}(React.Component);
	
	Radical.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = Radical;

/***/ },
/* 610 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the FRAC_INCLUSIVE iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var FracInclusive = function (_React$Component) {
	    _inherits(FracInclusive, _React$Component);
	
	    function FracInclusive() {
	        _classCallCheck(this, FracInclusive);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    FracInclusive.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement(
	                    "g",
	                    { transform: "translate(12 12)" },
	                    React.createElement("path", { fill: "none", d: "M0 0h24v24H0z" }),
	                    React.createElement("path", { d: "M8 16.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997H8.997c-.55 0-.997-.453-.997-.997v-6.006zM10 18h4v4h-4v-4z", fill: this.props.color }),
	                    React.createElement("rect", { fill: this.props.color, x: "2", y: "11", width: "20", height: "2", rx: "1" }),
	                    React.createElement("path", { d: "M8 .997C8 .447 8.453 0 8.997 0h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997H8.997C8.447 8 8 7.547 8 7.003V.997zM10 2h4v4h-4V2z", fill: this.props.color })
	                )
	            )
	        );
	    };
	
	    return FracInclusive;
	}(React.Component);
	
	FracInclusive.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = FracInclusive;

/***/ },
/* 611 */
/***/ function(module, exports, __webpack_require__) {

	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	/**
	 * An autogenerated component that renders the FRAC_EXCLUSIVE iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var FracExclusive = function (_React$Component) {
	    _inherits(FracExclusive, _React$Component);
	
	    function FracExclusive() {
	        _classCallCheck(this, FracExclusive);
	
	        return _possibleConstructorReturn(this, _React$Component.apply(this, arguments));
	    }
	
	    FracExclusive.prototype.render = function render() {
	        return React.createElement(
	            "svg",
	            { width: "48", height: "48", viewBox: "0 0 48 48" },
	            React.createElement(
	                "g",
	                { fill: "none", fillRule: "evenodd" },
	                React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	                React.createElement(
	                    "g",
	                    { transform: "translate(12 12)" },
	                    React.createElement("path", { fill: "none", d: "M0 0h24v24H0z" }),
	                    React.createElement("path", { d: "M13 16.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM15 18h4v4h-4v-4z", fill: this.props.color }),
	                    React.createElement("rect", { fill: this.props.color, x: "10", y: "11", width: "14", height: "2", rx: "1" }),
	                    React.createElement("path", { d: "M13 .997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997V.997zM15 2h4v4h-4V2zM0 8.997C0 8.447.453 8 .997 8h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997H.997C.447 16 0 15.547 0 15.003V8.997zM2 10h4v4H2v-4z", fill: this.props.color })
	                )
	            )
	        );
	    };
	
	    return FracExclusive;
	}(React.Component);
	
	FracExclusive.propTypes = {
	    color: React.PropTypes.string.isRequired
	};
	
	
	module.exports = FracExclusive;

/***/ },
/* 612 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * An autogenerated component that renders the JUMP_OUT_PARENTHESES iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var JumpOutParentheses = function JumpOutParentheses() {
	  return React.createElement(
	    "svg",
	    { width: "48", height: "48", viewBox: "0 0 48 48" },
	    React.createElement(
	      "g",
	      { fill: "none", fillRule: "evenodd" },
	      React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	      React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	      React.createElement("path", { d: "M24 18c3 3 3 9 0 12M18 18c-3 3-3 9 0 12", stroke: "#888D93", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
	      React.createElement("path", { stroke: "#78C008", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", d: "M32 27l3-3-3-3M22 24h12" })
	    )
	  );
	};
	
	module.exports = JumpOutParentheses;

/***/ },
/* 613 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * An autogenerated component that renders the JUMP_OUT_EXPONENT iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var JumpOutExponent = function JumpOutExponent() {
	  return React.createElement(
	    "svg",
	    { width: "48", height: "48", viewBox: "0 0 48 48" },
	    React.createElement(
	      "g",
	      { fill: "none", fillRule: "evenodd" },
	      React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	      React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	      React.createElement("path", { d: "M35 19v16M23 19l8 8M31 23v4h-4", stroke: "#78C008", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
	      React.createElement("path", { d: "M12 12.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM14 14h4v4h-4v-4z", fill: "#888D93" })
	    )
	  );
	};
	
	module.exports = JumpOutExponent;

/***/ },
/* 614 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * An autogenerated component that renders the JUMP_OUT_BASE iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var JumpOutBase = function JumpOutBase() {
	  return React.createElement(
	    "svg",
	    { width: "48", height: "48", viewBox: "0 0 48 48" },
	    React.createElement(
	      "g",
	      { fill: "none", fillRule: "evenodd" },
	      React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	      React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	      React.createElement("path", { d: "M12 28.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM14 30h4v4h-4v-4z", fill: "#888D93" }),
	      React.createElement("path", { d: "M35 13v16M23 29l8-8M27 21h4v4", stroke: "#78C008", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
	    )
	  );
	};
	
	module.exports = JumpOutBase;

/***/ },
/* 615 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * An autogenerated component that renders the JUMP_INTO_NUMERATOR iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var JumpIntoNumerator = function JumpIntoNumerator() {
	  return React.createElement(
	    "svg",
	    { width: "48", height: "48", viewBox: "0 0 48 48" },
	    React.createElement(
	      "g",
	      { fill: "none", fillRule: "evenodd" },
	      React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	      React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	      React.createElement("path", { d: "M13 16v16M17 22l6-6M23 20v-4h-4", stroke: "#78C008", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
	      React.createElement("path", { d: "M26 27.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM28 29h4v4h-4v-4z", fill: "#888D93" }),
	      React.createElement("path", { d: "M35 24H25", stroke: "#888D93", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
	      React.createElement("path", { d: "M26 13.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM28 15h4v4h-4v-4z", fill: "#78C008" })
	    )
	  );
	};
	
	module.exports = JumpIntoNumerator;

/***/ },
/* 616 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * An autogenerated component that renders the JUMP_OUT_NUMERATOR iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var JumpOutNumerator = function JumpOutNumerator() {
	  return React.createElement(
	    "svg",
	    { width: "48", height: "48", viewBox: "0 0 48 48" },
	    React.createElement(
	      "g",
	      { fill: "none", fillRule: "evenodd" },
	      React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	      React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	      React.createElement("path", { stroke: "#78C008", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", d: "M33 29l-3 3-3-3M30 18v14" }),
	      React.createElement("path", { d: "M16 27.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM18 29h4v4h-4v-4z", fill: "#78C008" }),
	      React.createElement("path", { d: "M25 24H15", stroke: "#888D93", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
	      React.createElement("path", { d: "M16 13.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM18 15h4v4h-4v-4z", fill: "#888D93" })
	    )
	  );
	};
	
	module.exports = JumpOutNumerator;

/***/ },
/* 617 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * An autogenerated component that renders the JUMP_OUT_DENOMINATOR iconograpy in SVG.
	 *
	 * Generated with: https://gist.github.com/crm416/3c7abc88e520eaed72347af240b32590.
	 */
	var React = __webpack_require__(43);
	
	var JumpOutDenominator = function JumpOutDenominator() {
	  return React.createElement(
	    "svg",
	    { width: "48", height: "48", viewBox: "0 0 48 48" },
	    React.createElement(
	      "g",
	      { fill: "none", fillRule: "evenodd" },
	      React.createElement("path", { d: "M0 0h48v48H0z" }),
	      React.createElement("path", { d: "M12 12h24v24H12z" }),
	      React.createElement("path", { d: "M35 16v16m-4-4v-4h-4m-2 6l6-6", stroke: "#78C008", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
	      React.createElement("path", { d: "M14 27.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM16 29h4v4h-4v-4z", fill: "#888D93" }),
	      React.createElement("path", { d: "M23 24H13", stroke: "#888D93", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }),
	      React.createElement("path", { d: "M14 13.997c0-.55.453-.997.997-.997h6.006c.55 0 .997.453.997.997v6.006c0 .55-.453.997-.997.997h-6.006c-.55 0-.997-.453-.997-.997v-6.006zM16 15h4v4h-4v-4z", fill: "#888D93" })
	    )
	  );
	};
	
	module.exports = JumpOutDenominator;

/***/ },
/* 618 */
/***/ function(module, exports, __webpack_require__) {

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	var freeGlobal = __webpack_require__(624);
	
	/** Detect free variable `self`. */
	var freeSelf = (typeof self === 'undefined' ? 'undefined' : _typeof(self)) == 'object' && self && self.Object === Object && self;
	
	/** Used as a reference to the global object. */
	var root = freeGlobal || freeSelf || Function('return this')();
	
	module.exports = root;

/***/ },
/* 619 */
/***/ function(module, exports, __webpack_require__) {

	module.exports = function(module) {
		if(!module.webpackPolyfill) {
			module.deprecate = function() {};
			module.paths = [];
			// module.parent = undefined by default
			module.children = [];
			module.webpackPolyfill = 1;
		}
		return module;
	}


/***/ },
/* 620 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	
	function _interopRequireDefault(obj) {
	  return obj && obj.__esModule ? obj : { 'default': obj };
	}
	
	function _defineProperty(obj, key, value) {
	  if (key in obj) {
	    Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true });
	  } else {
	    obj[key] = value;
	  }return obj;
	}
	
	var _camelToDashCase = __webpack_require__(622);
	
	var _camelToDashCase2 = _interopRequireDefault(_camelToDashCase);
	
	// returns a style object with a single concated prefixed value string
	
	exports['default'] = function (property, value) {
	  var replacer = arguments.length <= 2 || arguments[2] === undefined ? function (prefix, value) {
	    return prefix + value;
	  } : arguments[2];
	  return function () {
	    return _defineProperty({}, property, ['-webkit-', '-moz-', ''].map(function (prefix) {
	      return replacer(prefix, value);
	    }));
	  }();
	};
	
	module.exports = exports['default'];

/***/ },
/* 621 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	
	exports['default'] = function (value) {
	  if (Array.isArray(value)) value = value.join(',');
	
	  return value.match(/-webkit-|-moz-|-ms-/) !== null;
	};
	
	module.exports = exports['default'];

/***/ },
/* 622 */
/***/ function(module, exports, __webpack_require__) {

	/**
	 * Converts a camel-case string to a dash-case string
	 * @param {string} str - str that gets converted to dash-case
	 */
	'use strict';
	
	Object.defineProperty(exports, '__esModule', {
	  value: true
	});
	
	exports['default'] = function (str) {
	  return str.replace(/([a-z]|^)([A-Z])/g, function (match, p1, p2) {
	    return p1 + '-' + p2.toLowerCase();
	  }).replace('ms-', '-ms-');
	};
	
	module.exports = exports['default'];

/***/ },
/* 623 */
/***/ function(module, exports, __webpack_require__) {

	var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
	
	/**
	 * An arrow icon, used by the other navigational keys.
	 */
	var React = __webpack_require__(43);
	
	var Arrow = function Arrow(props) {
	  return React.createElement(
	    "g",
	    _extends({ fill: "none", fillRule: "evenodd" }, props),
	    React.createElement("path", { fill: "none", d: "M0 0h48v48H0z" }),
	    React.createElement("path", { fill: "none", d: "M12 12h24v24H12z" }),
	    React.createElement("path", { stroke: "#888D93", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", d: "M22 18l-6 6 6 6M16 24h16" })
	  );
	};
	
	module.exports = Arrow;

/***/ },
/* 624 */
/***/ function(module, exports, __webpack_require__) {

	/* WEBPACK VAR INJECTION */(function(global) {var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
	
	/** Detect free variable `global` from Node.js. */
	var freeGlobal = (typeof global === 'undefined' ? 'undefined' : _typeof(global)) == 'object' && global && global.Object === Object && global;
	
	module.exports = freeGlobal;
	/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))

/***/ }
/******/ ])
//# sourceMappingURL=frame-perseus.js.map