@pie-element/ebsr 10.7.3-next.9 → 12.0.1-esmbeta.0

package/configure/node_modules/@pie-element/multiple-choice/esm/element.js

@@ -0,0 +1,3287 @@
+import React from 'react';
+import PropTypes$2 from 'prop-types';
+import { withStyles, createMuiTheme, MuiThemeProvider } from '@material-ui/core/styles';
+import { color, PreviewPrompt, Feedback, Collapsible, PreviewLayout, EnableAudioAutoplayImage } from '@pie-lib/render-ui';
+import CorrectAnswerToggle from '@pie-lib/correct-answer-toggle';
+import classNames from 'classnames';
+import Translator from '@pie-lib/translator';
+import FormControlLabel from '@material-ui/core/FormControlLabel';
+import Checkbox from '@material-ui/core/Checkbox';
+import Radio from '@material-ui/core/Radio';
+import require$$2$1 from 'react-dom';
+import debounce from 'lodash/debounce';
+import debug from 'debug';
+import { SessionChangedEvent, ModelSetEvent } from '@pie-framework/pie-player-events';
+import { renderMath } from '@pie-lib/math-rendering';
+
+function _extends() {
+  _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;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+function getAugmentedNamespace(n) {
+	if (n.__esModule) return n;
+	var a = Object.defineProperty({}, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var CSSTransition = {exports: {}};
+
+var addClass = {exports: {}};
+
+var interopRequireDefault = {exports: {}};
+
+(function (module) {
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {
+    "default": obj
+  };
+}
+
+module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}(interopRequireDefault));
+
+var hasClass = {exports: {}};
+
+(function (module, exports) {
+
+exports.__esModule = true;
+exports.default = hasClass;
+
+function hasClass(element, className) {
+  if (element.classList) return !!className && element.classList.contains(className);else return (" " + (element.className.baseVal || element.className) + " ").indexOf(" " + className + " ") !== -1;
+}
+
+module.exports = exports["default"];
+}(hasClass, hasClass.exports));
+
+(function (module, exports) {
+
+var _interopRequireDefault = interopRequireDefault.exports;
+
+exports.__esModule = true;
+exports.default = addClass;
+
+var _hasClass = _interopRequireDefault(hasClass.exports);
+
+function addClass(element, className) {
+  if (element.classList) element.classList.add(className);else if (!(0, _hasClass.default)(element, className)) if (typeof element.className === 'string') element.className = element.className + ' ' + className;else element.setAttribute('class', (element.className && element.className.baseVal || '') + ' ' + className);
+}
+
+module.exports = exports["default"];
+}(addClass, addClass.exports));
+
+function replaceClassName(origClass, classToRemove) {
+  return origClass.replace(new RegExp('(^|\\s)' + classToRemove + '(?:\\s|$)', 'g'), '$1').replace(/\s+/g, ' ').replace(/^\s*|\s*$/g, '');
+}
+
+var removeClass = function removeClass(element, className) {
+  if (element.classList) element.classList.remove(className);else if (typeof element.className === 'string') element.className = replaceClassName(element.className, className);else element.setAttribute('class', replaceClassName(element.className && element.className.baseVal || '', className));
+};
+
+var Transition$1 = {};
+
+/**
+ * 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 componentWillMount() {
+  // Call this.constructor.gDSFP to support sub-classes.
+  var state = this.constructor.getDerivedStateFromProps(this.props, this.state);
+  if (state !== null && state !== undefined) {
+    this.setState(state);
+  }
+}
+
+function componentWillReceiveProps(nextProps) {
+  // Call this.constructor.gDSFP to support sub-classes.
+  // Use the setState() updater to ensure state isn't stale in certain edge cases.
+  function updater(prevState) {
+    var state = this.constructor.getDerivedStateFromProps(nextProps, prevState);
+    return state !== null && state !== undefined ? state : null;
+  }
+  // Binding "this" is important for shallow renderer support.
+  this.setState(updater.bind(this));
+}
+
+function componentWillUpdate(nextProps, nextState) {
+  try {
+    var prevProps = this.props;
+    var prevState = this.state;
+    this.props = nextProps;
+    this.state = nextState;
+    this.__reactInternalSnapshotFlag = true;
+    this.__reactInternalSnapshot = this.getSnapshotBeforeUpdate(
+      prevProps,
+      prevState
+    );
+  } finally {
+    this.props = prevProps;
+    this.state = prevState;
+  }
+}
+
+// React may warn about cWM/cWRP/cWU methods being deprecated.
+// Add a flag to suppress these warnings for this special case.
+componentWillMount.__suppressDeprecationWarning = true;
+componentWillReceiveProps.__suppressDeprecationWarning = true;
+componentWillUpdate.__suppressDeprecationWarning = true;
+
+function polyfill(Component) {
+  var prototype = Component.prototype;
+
+  if (!prototype || !prototype.isReactComponent) {
+    throw new Error('Can only polyfill class components');
+  }
+
+  if (
+    typeof Component.getDerivedStateFromProps !== 'function' &&
+    typeof prototype.getSnapshotBeforeUpdate !== 'function'
+  ) {
+    return Component;
+  }
+
+  // If new component APIs are defined, "unsafe" lifecycles won't be called.
+  // Error if any of these lifecycles are present,
+  // Because they would work differently between older and newer (16.3+) versions of React.
+  var foundWillMountName = null;
+  var foundWillReceivePropsName = null;
+  var foundWillUpdateName = null;
+  if (typeof prototype.componentWillMount === 'function') {
+    foundWillMountName = 'componentWillMount';
+  } else if (typeof prototype.UNSAFE_componentWillMount === 'function') {
+    foundWillMountName = 'UNSAFE_componentWillMount';
+  }
+  if (typeof prototype.componentWillReceiveProps === 'function') {
+    foundWillReceivePropsName = 'componentWillReceiveProps';
+  } else if (typeof prototype.UNSAFE_componentWillReceiveProps === 'function') {
+    foundWillReceivePropsName = 'UNSAFE_componentWillReceiveProps';
+  }
+  if (typeof prototype.componentWillUpdate === 'function') {
+    foundWillUpdateName = 'componentWillUpdate';
+  } else if (typeof prototype.UNSAFE_componentWillUpdate === 'function') {
+    foundWillUpdateName = 'UNSAFE_componentWillUpdate';
+  }
+  if (
+    foundWillMountName !== null ||
+    foundWillReceivePropsName !== null ||
+    foundWillUpdateName !== null
+  ) {
+    var componentName = Component.displayName || Component.name;
+    var newApiName =
+      typeof Component.getDerivedStateFromProps === 'function'
+        ? 'getDerivedStateFromProps()'
+        : 'getSnapshotBeforeUpdate()';
+
+    throw Error(
+      'Unsafe legacy lifecycles will not be called for components using new component APIs.\n\n' +
+        componentName +
+        ' uses ' +
+        newApiName +
+        ' but also contains the following legacy lifecycles:' +
+        (foundWillMountName !== null ? '\n  ' + foundWillMountName : '') +
+        (foundWillReceivePropsName !== null
+          ? '\n  ' + foundWillReceivePropsName
+          : '') +
+        (foundWillUpdateName !== null ? '\n  ' + foundWillUpdateName : '') +
+        '\n\nThe above lifecycles should be removed. Learn more about this warning here:\n' +
+        'https://fb.me/react-async-component-lifecycle-hooks'
+    );
+  }
+
+  // React <= 16.2 does not support static getDerivedStateFromProps.
+  // As a workaround, use cWM and cWRP to invoke the new static lifecycle.
+  // Newer versions of React will ignore these lifecycles if gDSFP exists.
+  if (typeof Component.getDerivedStateFromProps === 'function') {
+    prototype.componentWillMount = componentWillMount;
+    prototype.componentWillReceiveProps = componentWillReceiveProps;
+  }
+
+  // React <= 16.2 does not support getSnapshotBeforeUpdate.
+  // As a workaround, use cWU to invoke the new lifecycle.
+  // Newer versions of React will ignore that lifecycle if gSBU exists.
+  if (typeof prototype.getSnapshotBeforeUpdate === 'function') {
+    if (typeof prototype.componentDidUpdate !== 'function') {
+      throw new Error(
+        'Cannot polyfill getSnapshotBeforeUpdate() for components that do not define componentDidUpdate() on the prototype'
+      );
+    }
+
+    prototype.componentWillUpdate = componentWillUpdate;
+
+    var componentDidUpdate = prototype.componentDidUpdate;
+
+    prototype.componentDidUpdate = function componentDidUpdatePolyfill(
+      prevProps,
+      prevState,
+      maybeSnapshot
+    ) {
+      // 16.3+ will not execute our will-update method;
+      // It will pass a snapshot value to did-update though.
+      // Older versions will require our polyfilled will-update value.
+      // We need to handle both cases, but can't just check for the presence of "maybeSnapshot",
+      // Because for <= 15.x versions this might be a "prevContext" object.
+      // We also can't just check "__reactInternalSnapshot",
+      // Because get-snapshot might return a falsy value.
+      // So check for the explicit __reactInternalSnapshotFlag flag to determine behavior.
+      var snapshot = this.__reactInternalSnapshotFlag
+        ? this.__reactInternalSnapshot
+        : maybeSnapshot;
+
+      componentDidUpdate.call(this, prevProps, prevState, snapshot);
+    };
+  }
+
+  return Component;
+}
+
+var reactLifecyclesCompat_es = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  polyfill: polyfill
+});
+
+var require$$2 = /*@__PURE__*/getAugmentedNamespace(reactLifecyclesCompat_es);
+
+var PropTypes$1 = {};
+
+PropTypes$1.__esModule = true;
+PropTypes$1.classNamesShape = PropTypes$1.timeoutsShape = void 0;
+
+var _propTypes = _interopRequireDefault$2(PropTypes$2);
+
+function _interopRequireDefault$2(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var timeoutsShape = process.env.NODE_ENV !== 'production' ? _propTypes.default.oneOfType([_propTypes.default.number, _propTypes.default.shape({
+  enter: _propTypes.default.number,
+  exit: _propTypes.default.number,
+  appear: _propTypes.default.number
+}).isRequired]) : null;
+PropTypes$1.timeoutsShape = timeoutsShape;
+var classNamesShape = process.env.NODE_ENV !== 'production' ? _propTypes.default.oneOfType([_propTypes.default.string, _propTypes.default.shape({
+  enter: _propTypes.default.string,
+  exit: _propTypes.default.string,
+  active: _propTypes.default.string
+}), _propTypes.default.shape({
+  enter: _propTypes.default.string,
+  enterDone: _propTypes.default.string,
+  enterActive: _propTypes.default.string,
+  exit: _propTypes.default.string,
+  exitDone: _propTypes.default.string,
+  exitActive: _propTypes.default.string
+})]) : null;
+PropTypes$1.classNamesShape = classNamesShape;
+
+Transition$1.__esModule = true;
+Transition$1.default = Transition$1.EXITING = Transition$1.ENTERED = Transition$1.ENTERING = Transition$1.EXITED = Transition$1.UNMOUNTED = void 0;
+
+var PropTypes = _interopRequireWildcard(PropTypes$2);
+
+var _react$1 = _interopRequireDefault$1(React);
+
+var _reactDom = _interopRequireDefault$1(require$$2$1);
+
+var _reactLifecyclesCompat = require$$2;
+
+var _PropTypes = PropTypes$1;
+
+function _interopRequireDefault$1(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+var UNMOUNTED = 'unmounted';
+Transition$1.UNMOUNTED = UNMOUNTED;
+var EXITED = 'exited';
+Transition$1.EXITED = EXITED;
+var ENTERING = 'entering';
+Transition$1.ENTERING = ENTERING;
+var ENTERED = 'entered';
+Transition$1.ENTERED = ENTERED;
+var EXITING = 'exiting';
+/**
+ * The Transition component lets you describe a transition from one component
+ * state to another _over time_ with a simple declarative API. Most commonly
+ * it's used to animate the mounting and unmounting of a component, but can also
+ * be used to describe in-place transition states as well.
+ *
+ * ---
+ *
+ * **Note**: `Transition` is a platform-agnostic base component. If you're using
+ * transitions in CSS, you'll probably want to use
+ * [`CSSTransition`](https://reactcommunity.org/react-transition-group/css-transition)
+ * instead. It inherits all the features of `Transition`, but contains
+ * additional features necessary to play nice with CSS transitions (hence the
+ * name of the component).
+ *
+ * ---
+ *
+ * By default the `Transition` component does not alter the behavior of the
+ * component it renders, it only tracks "enter" and "exit" states for the
+ * components. It's up to you to give meaning and effect to those states. For
+ * example we can add styles to a component when it enters or exits:
+ *
+ * ```jsx
+ * import { Transition } from 'react-transition-group';
+ *
+ * const duration = 300;
+ *
+ * const defaultStyle = {
+ *   transition: `opacity ${duration}ms ease-in-out`,
+ *   opacity: 0,
+ * }
+ *
+ * const transitionStyles = {
+ *   entering: { opacity: 0 },
+ *   entered:  { opacity: 1 },
+ * };
+ *
+ * const Fade = ({ in: inProp }) => (
+ *   <Transition in={inProp} timeout={duration}>
+ *     {state => (
+ *       <div style={{
+ *         ...defaultStyle,
+ *         ...transitionStyles[state]
+ *       }}>
+ *         I'm a fade Transition!
+ *       </div>
+ *     )}
+ *   </Transition>
+ * );
+ * ```
+ *
+ * There are 4 main states a Transition can be in:
+ *  - `'entering'`
+ *  - `'entered'`
+ *  - `'exiting'`
+ *  - `'exited'`
+ *
+ * Transition state is toggled via the `in` prop. When `true` the component
+ * begins the "Enter" stage. During this stage, the component will shift from
+ * its current transition state, to `'entering'` for the duration of the
+ * transition and then to the `'entered'` stage once it's complete. Let's take
+ * the following example (we'll use the
+ * [useState](https://reactjs.org/docs/hooks-reference.html#usestate) hook):
+ *
+ * ```jsx
+ * function App() {
+ *   const [inProp, setInProp] = useState(false);
+ *   return (
+ *     <div>
+ *       <Transition in={inProp} timeout={500}>
+ *         {state => (
+ *           // ...
+ *         )}
+ *       </Transition>
+ *       <button onClick={() => setInProp(true)}>
+ *         Click to Enter
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * When the button is clicked the component will shift to the `'entering'` state
+ * and stay there for 500ms (the value of `timeout`) before it finally switches
+ * to `'entered'`.
+ *
+ * When `in` is `false` the same thing happens except the state moves from
+ * `'exiting'` to `'exited'`.
+ */
+
+Transition$1.EXITING = EXITING;
+
+var Transition =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(Transition, _React$Component);
+
+  function Transition(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+    var parentGroup = context.transitionGroup; // In the context of a TransitionGroup all enters are really appears
+
+    var appear = parentGroup && !parentGroup.isMounting ? props.enter : props.appear;
+    var initialStatus;
+    _this.appearStatus = null;
+
+    if (props.in) {
+      if (appear) {
+        initialStatus = EXITED;
+        _this.appearStatus = ENTERING;
+      } else {
+        initialStatus = ENTERED;
+      }
+    } else {
+      if (props.unmountOnExit || props.mountOnEnter) {
+        initialStatus = UNMOUNTED;
+      } else {
+        initialStatus = EXITED;
+      }
+    }
+
+    _this.state = {
+      status: initialStatus
+    };
+    _this.nextCallback = null;
+    return _this;
+  }
+
+  var _proto = Transition.prototype;
+
+  _proto.getChildContext = function getChildContext() {
+    return {
+      transitionGroup: null // allows for nested Transitions
+
+    };
+  };
+
+  Transition.getDerivedStateFromProps = function getDerivedStateFromProps(_ref, prevState) {
+    var nextIn = _ref.in;
+
+    if (nextIn && prevState.status === UNMOUNTED) {
+      return {
+        status: EXITED
+      };
+    }
+
+    return null;
+  }; // getSnapshotBeforeUpdate(prevProps) {
+  //   let nextStatus = null
+  //   if (prevProps !== this.props) {
+  //     const { status } = this.state
+  //     if (this.props.in) {
+  //       if (status !== ENTERING && status !== ENTERED) {
+  //         nextStatus = ENTERING
+  //       }
+  //     } else {
+  //       if (status === ENTERING || status === ENTERED) {
+  //         nextStatus = EXITING
+  //       }
+  //     }
+  //   }
+  //   return { nextStatus }
+  // }
+
+
+  _proto.componentDidMount = function componentDidMount() {
+    this.updateStatus(true, this.appearStatus);
+  };
+
+  _proto.componentDidUpdate = function componentDidUpdate(prevProps) {
+    var nextStatus = null;
+
+    if (prevProps !== this.props) {
+      var status = this.state.status;
+
+      if (this.props.in) {
+        if (status !== ENTERING && status !== ENTERED) {
+          nextStatus = ENTERING;
+        }
+      } else {
+        if (status === ENTERING || status === ENTERED) {
+          nextStatus = EXITING;
+        }
+      }
+    }
+
+    this.updateStatus(false, nextStatus);
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.cancelNextCallback();
+  };
+
+  _proto.getTimeouts = function getTimeouts() {
+    var timeout = this.props.timeout;
+    var exit, enter, appear;
+    exit = enter = appear = timeout;
+
+    if (timeout != null && typeof timeout !== 'number') {
+      exit = timeout.exit;
+      enter = timeout.enter; // TODO: remove fallback for next major
+
+      appear = timeout.appear !== undefined ? timeout.appear : enter;
+    }
+
+    return {
+      exit: exit,
+      enter: enter,
+      appear: appear
+    };
+  };
+
+  _proto.updateStatus = function updateStatus(mounting, nextStatus) {
+    if (mounting === void 0) {
+      mounting = false;
+    }
+
+    if (nextStatus !== null) {
+      // nextStatus will always be ENTERING or EXITING.
+      this.cancelNextCallback();
+
+      var node = _reactDom.default.findDOMNode(this);
+
+      if (nextStatus === ENTERING) {
+        this.performEnter(node, mounting);
+      } else {
+        this.performExit(node);
+      }
+    } else if (this.props.unmountOnExit && this.state.status === EXITED) {
+      this.setState({
+        status: UNMOUNTED
+      });
+    }
+  };
+
+  _proto.performEnter = function performEnter(node, mounting) {
+    var _this2 = this;
+
+    var enter = this.props.enter;
+    var appearing = this.context.transitionGroup ? this.context.transitionGroup.isMounting : mounting;
+    var timeouts = this.getTimeouts();
+    var enterTimeout = appearing ? timeouts.appear : timeouts.enter; // no enter animation skip right to ENTERED
+    // if we are mounting and running this it means appear _must_ be set
+
+    if (!mounting && !enter) {
+      this.safeSetState({
+        status: ENTERED
+      }, function () {
+        _this2.props.onEntered(node);
+      });
+      return;
+    }
+
+    this.props.onEnter(node, appearing);
+    this.safeSetState({
+      status: ENTERING
+    }, function () {
+      _this2.props.onEntering(node, appearing);
+
+      _this2.onTransitionEnd(node, enterTimeout, function () {
+        _this2.safeSetState({
+          status: ENTERED
+        }, function () {
+          _this2.props.onEntered(node, appearing);
+        });
+      });
+    });
+  };
+
+  _proto.performExit = function performExit(node) {
+    var _this3 = this;
+
+    var exit = this.props.exit;
+    var timeouts = this.getTimeouts(); // no exit animation skip right to EXITED
+
+    if (!exit) {
+      this.safeSetState({
+        status: EXITED
+      }, function () {
+        _this3.props.onExited(node);
+      });
+      return;
+    }
+
+    this.props.onExit(node);
+    this.safeSetState({
+      status: EXITING
+    }, function () {
+      _this3.props.onExiting(node);
+
+      _this3.onTransitionEnd(node, timeouts.exit, function () {
+        _this3.safeSetState({
+          status: EXITED
+        }, function () {
+          _this3.props.onExited(node);
+        });
+      });
+    });
+  };
+
+  _proto.cancelNextCallback = function cancelNextCallback() {
+    if (this.nextCallback !== null) {
+      this.nextCallback.cancel();
+      this.nextCallback = null;
+    }
+  };
+
+  _proto.safeSetState = function safeSetState(nextState, callback) {
+    // This shouldn't be necessary, but there are weird race conditions with
+    // setState callbacks and unmounting in testing, so always make sure that
+    // we can cancel any pending setState callbacks after we unmount.
+    callback = this.setNextCallback(callback);
+    this.setState(nextState, callback);
+  };
+
+  _proto.setNextCallback = function setNextCallback(callback) {
+    var _this4 = this;
+
+    var active = true;
+
+    this.nextCallback = function (event) {
+      if (active) {
+        active = false;
+        _this4.nextCallback = null;
+        callback(event);
+      }
+    };
+
+    this.nextCallback.cancel = function () {
+      active = false;
+    };
+
+    return this.nextCallback;
+  };
+
+  _proto.onTransitionEnd = function onTransitionEnd(node, timeout, handler) {
+    this.setNextCallback(handler);
+    var doesNotHaveTimeoutOrListener = timeout == null && !this.props.addEndListener;
+
+    if (!node || doesNotHaveTimeoutOrListener) {
+      setTimeout(this.nextCallback, 0);
+      return;
+    }
+
+    if (this.props.addEndListener) {
+      this.props.addEndListener(node, this.nextCallback);
+    }
+
+    if (timeout != null) {
+      setTimeout(this.nextCallback, timeout);
+    }
+  };
+
+  _proto.render = function render() {
+    var status = this.state.status;
+
+    if (status === UNMOUNTED) {
+      return null;
+    }
+
+    var _this$props = this.props,
+        children = _this$props.children,
+        childProps = _objectWithoutPropertiesLoose(_this$props, ["children"]); // filter props for Transtition
+
+
+    delete childProps.in;
+    delete childProps.mountOnEnter;
+    delete childProps.unmountOnExit;
+    delete childProps.appear;
+    delete childProps.enter;
+    delete childProps.exit;
+    delete childProps.timeout;
+    delete childProps.addEndListener;
+    delete childProps.onEnter;
+    delete childProps.onEntering;
+    delete childProps.onEntered;
+    delete childProps.onExit;
+    delete childProps.onExiting;
+    delete childProps.onExited;
+
+    if (typeof children === 'function') {
+      return children(status, childProps);
+    }
+
+    var child = _react$1.default.Children.only(children);
+
+    return _react$1.default.cloneElement(child, childProps);
+  };
+
+  return Transition;
+}(_react$1.default.Component);
+
+Transition.contextTypes = {
+  transitionGroup: PropTypes.object
+};
+Transition.childContextTypes = {
+  transitionGroup: function transitionGroup() {}
+};
+Transition.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * A `function` child can be used instead of a React element. This function is
+   * called with the current transition status (`'entering'`, `'entered'`,
+   * `'exiting'`, `'exited'`, `'unmounted'`), which can be used to apply context
+   * specific props to a component.
+   *
+   * ```jsx
+   * <Transition in={this.state.in} timeout={150}>
+   *   {state => (
+   *     <MyComponent className={`fade fade-${state}`} />
+   *   )}
+   * </Transition>
+   * ```
+   */
+  children: PropTypes.oneOfType([PropTypes.func.isRequired, PropTypes.element.isRequired]).isRequired,
+
+  /**
+   * Show the component; triggers the enter or exit states
+   */
+  in: PropTypes.bool,
+
+  /**
+   * By default the child component is mounted immediately along with
+   * the parent `Transition` component. If you want to "lazy mount" the component on the
+   * first `in={true}` you can set `mountOnEnter`. After the first enter transition the component will stay
+   * mounted, even on "exited", unless you also specify `unmountOnExit`.
+   */
+  mountOnEnter: PropTypes.bool,
+
+  /**
+   * By default the child component stays mounted after it reaches the `'exited'` state.
+   * Set `unmountOnExit` if you'd prefer to unmount the component after it finishes exiting.
+   */
+  unmountOnExit: PropTypes.bool,
+
+  /**
+   * Normally a component is not transitioned if it is shown when the `<Transition>` component mounts.
+   * If you want to transition on the first mount set `appear` to `true`, and the
+   * component will transition in as soon as the `<Transition>` mounts.
+   *
+   * > Note: there are no specific "appear" states. `appear` only adds an additional `enter` transition.
+   */
+  appear: PropTypes.bool,
+
+  /**
+   * Enable or disable enter transitions.
+   */
+  enter: PropTypes.bool,
+
+  /**
+   * Enable or disable exit transitions.
+   */
+  exit: PropTypes.bool,
+
+  /**
+   * The duration of the transition, in milliseconds.
+   * Required unless `addEndListener` is provided.
+   *
+   * You may specify a single timeout for all transitions:
+   *
+   * ```jsx
+   * timeout={500}
+   * ```
+   *
+   * or individually:
+   *
+   * ```jsx
+   * timeout={{
+   *  appear: 500,
+   *  enter: 300,
+   *  exit: 500,
+   * }}
+   * ```
+   *
+   * - `appear` defaults to the value of `enter`
+   * - `enter` defaults to `0`
+   * - `exit` defaults to `0`
+   *
+   * @type {number | { enter?: number, exit?: number, appear?: number }}
+   */
+  timeout: function timeout(props) {
+    var pt = _PropTypes.timeoutsShape;
+    if (!props.addEndListener) pt = pt.isRequired;
+
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    return pt.apply(void 0, [props].concat(args));
+  },
+
+  /**
+   * Add a custom transition end trigger. Called with the transitioning
+   * DOM node and a `done` callback. Allows for more fine grained transition end
+   * logic. **Note:** Timeouts are still used as a fallback if provided.
+   *
+   * ```jsx
+   * addEndListener={(node, done) => {
+   *   // use the css transitionend event to mark the finish of a transition
+   *   node.addEventListener('transitionend', done, false);
+   * }}
+   * ```
+   */
+  addEndListener: PropTypes.func,
+
+  /**
+   * Callback fired before the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEnter: PropTypes.func,
+
+  /**
+   * Callback fired after the "entering" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: PropTypes.func,
+
+  /**
+   * Callback fired after the "entered" status is applied. An extra parameter
+   * `isAppearing` is supplied to indicate if the enter stage is occurring on the initial mount
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool) -> void
+   */
+  onEntered: PropTypes.func,
+
+  /**
+   * Callback fired before the "exiting" status is applied.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExit: PropTypes.func,
+
+  /**
+   * Callback fired after the "exiting" status is applied.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExiting: PropTypes.func,
+
+  /**
+   * Callback fired after the "exited" status is applied.
+   *
+   * @type Function(node: HtmlElement) -> void
+   */
+  onExited: PropTypes.func // Name the function so it is clearer in the documentation
+
+} : {};
+
+function noop() {}
+
+Transition.defaultProps = {
+  in: false,
+  mountOnEnter: false,
+  unmountOnExit: false,
+  appear: false,
+  enter: true,
+  exit: true,
+  onEnter: noop,
+  onEntering: noop,
+  onEntered: noop,
+  onExit: noop,
+  onExiting: noop,
+  onExited: noop
+};
+Transition.UNMOUNTED = 0;
+Transition.EXITED = 1;
+Transition.ENTERING = 2;
+Transition.ENTERED = 3;
+Transition.EXITING = 4;
+
+var _default = (0, _reactLifecyclesCompat.polyfill)(Transition);
+
+Transition$1.default = _default;
+
+(function (module, exports) {
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var PropTypes = _interopRequireWildcard(PropTypes$2);
+
+var _addClass = _interopRequireDefault(addClass.exports);
+
+var _removeClass = _interopRequireDefault(removeClass);
+
+var _react = _interopRequireDefault(React);
+
+var _Transition = _interopRequireDefault(Transition$1);
+
+var _PropTypes = PropTypes$1;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }
+
+function _extends() { _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; }; return _extends.apply(this, arguments); }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+var addClass$1 = function addClass(node, classes) {
+  return node && classes && classes.split(' ').forEach(function (c) {
+    return (0, _addClass.default)(node, c);
+  });
+};
+
+var removeClass$1 = function removeClass(node, classes) {
+  return node && classes && classes.split(' ').forEach(function (c) {
+    return (0, _removeClass.default)(node, c);
+  });
+};
+/**
+ * A transition component inspired by the excellent
+ * [ng-animate](http://www.nganimate.org/) library, you should use it if you're
+ * using CSS transitions or animations. It's built upon the
+ * [`Transition`](https://reactcommunity.org/react-transition-group/transition)
+ * component, so it inherits all of its props.
+ *
+ * `CSSTransition` applies a pair of class names during the `appear`, `enter`,
+ * and `exit` states of the transition. The first class is applied and then a
+ * second `*-active` class in order to activate the CSSS transition. After the
+ * transition, matching `*-done` class names are applied to persist the
+ * transition state.
+ *
+ * ```jsx
+ * function App() {
+ *   const [inProp, setInProp] = useState(false);
+ *   return (
+ *     <div>
+ *       <CSSTransition in={inProp} timeout={200} classNames="my-node">
+ *         <div>
+ *           {"I'll receive my-node-* classes"}
+ *         </div>
+ *       </CSSTransition>
+ *       <button type="button" onClick={() => setInProp(true)}>
+ *         Click to Enter
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * When the `in` prop is set to `true`, the child component will first receive
+ * the class `example-enter`, then the `example-enter-active` will be added in
+ * the next tick. `CSSTransition` [forces a
+ * reflow](https://github.com/reactjs/react-transition-group/blob/5007303e729a74be66a21c3e2205e4916821524b/src/CSSTransition.js#L208-L215)
+ * between before adding the `example-enter-active`. This is an important trick
+ * because it allows us to transition between `example-enter` and
+ * `example-enter-active` even though they were added immediately one after
+ * another. Most notably, this is what makes it possible for us to animate
+ * _appearance_.
+ *
+ * ```css
+ * .my-node-enter {
+ *   opacity: 0;
+ * }
+ * .my-node-enter-active {
+ *   opacity: 1;
+ *   transition: opacity 200ms;
+ * }
+ * .my-node-exit {
+ *   opacity: 1;
+ * }
+ * .my-node-exit-active {
+ *   opacity: 0;
+ *   transition: opacity: 200ms;
+ * }
+ * ```
+ *
+ * `*-active` classes represent which styles you want to animate **to**.
+ */
+
+
+var CSSTransition =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(CSSTransition, _React$Component);
+
+  function CSSTransition() {
+    var _this;
+
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(args)) || this;
+
+    _this.onEnter = function (node, appearing) {
+      var _this$getClassNames = _this.getClassNames(appearing ? 'appear' : 'enter'),
+          className = _this$getClassNames.className;
+
+      _this.removeClasses(node, 'exit');
+
+      addClass$1(node, className);
+
+      if (_this.props.onEnter) {
+        _this.props.onEnter(node, appearing);
+      }
+    };
+
+    _this.onEntering = function (node, appearing) {
+      var _this$getClassNames2 = _this.getClassNames(appearing ? 'appear' : 'enter'),
+          activeClassName = _this$getClassNames2.activeClassName;
+
+      _this.reflowAndAddClass(node, activeClassName);
+
+      if (_this.props.onEntering) {
+        _this.props.onEntering(node, appearing);
+      }
+    };
+
+    _this.onEntered = function (node, appearing) {
+      var appearClassName = _this.getClassNames('appear').doneClassName;
+
+      var enterClassName = _this.getClassNames('enter').doneClassName;
+
+      var doneClassName = appearing ? appearClassName + " " + enterClassName : enterClassName;
+
+      _this.removeClasses(node, appearing ? 'appear' : 'enter');
+
+      addClass$1(node, doneClassName);
+
+      if (_this.props.onEntered) {
+        _this.props.onEntered(node, appearing);
+      }
+    };
+
+    _this.onExit = function (node) {
+      var _this$getClassNames3 = _this.getClassNames('exit'),
+          className = _this$getClassNames3.className;
+
+      _this.removeClasses(node, 'appear');
+
+      _this.removeClasses(node, 'enter');
+
+      addClass$1(node, className);
+
+      if (_this.props.onExit) {
+        _this.props.onExit(node);
+      }
+    };
+
+    _this.onExiting = function (node) {
+      var _this$getClassNames4 = _this.getClassNames('exit'),
+          activeClassName = _this$getClassNames4.activeClassName;
+
+      _this.reflowAndAddClass(node, activeClassName);
+
+      if (_this.props.onExiting) {
+        _this.props.onExiting(node);
+      }
+    };
+
+    _this.onExited = function (node) {
+      var _this$getClassNames5 = _this.getClassNames('exit'),
+          doneClassName = _this$getClassNames5.doneClassName;
+
+      _this.removeClasses(node, 'exit');
+
+      addClass$1(node, doneClassName);
+
+      if (_this.props.onExited) {
+        _this.props.onExited(node);
+      }
+    };
+
+    _this.getClassNames = function (type) {
+      var classNames = _this.props.classNames;
+      var isStringClassNames = typeof classNames === 'string';
+      var prefix = isStringClassNames && classNames ? classNames + '-' : '';
+      var className = isStringClassNames ? prefix + type : classNames[type];
+      var activeClassName = isStringClassNames ? className + '-active' : classNames[type + 'Active'];
+      var doneClassName = isStringClassNames ? className + '-done' : classNames[type + 'Done'];
+      return {
+        className: className,
+        activeClassName: activeClassName,
+        doneClassName: doneClassName
+      };
+    };
+
+    return _this;
+  }
+
+  var _proto = CSSTransition.prototype;
+
+  _proto.removeClasses = function removeClasses(node, type) {
+    var _this$getClassNames6 = this.getClassNames(type),
+        className = _this$getClassNames6.className,
+        activeClassName = _this$getClassNames6.activeClassName,
+        doneClassName = _this$getClassNames6.doneClassName;
+
+    className && removeClass$1(node, className);
+    activeClassName && removeClass$1(node, activeClassName);
+    doneClassName && removeClass$1(node, doneClassName);
+  };
+
+  _proto.reflowAndAddClass = function reflowAndAddClass(node, className) {
+    // This is for to force a repaint,
+    // which is necessary in order to transition styles when adding a class name.
+    if (className) {
+      /* eslint-disable no-unused-expressions */
+      node && node.scrollTop;
+      /* eslint-enable no-unused-expressions */
+
+      addClass$1(node, className);
+    }
+  };
+
+  _proto.render = function render() {
+    var props = _extends({}, this.props);
+
+    delete props.classNames;
+    return _react.default.createElement(_Transition.default, _extends({}, props, {
+      onEnter: this.onEnter,
+      onEntered: this.onEntered,
+      onEntering: this.onEntering,
+      onExit: this.onExit,
+      onExiting: this.onExiting,
+      onExited: this.onExited
+    }));
+  };
+
+  return CSSTransition;
+}(_react.default.Component);
+
+CSSTransition.defaultProps = {
+  classNames: ''
+};
+CSSTransition.propTypes = process.env.NODE_ENV !== "production" ? _extends({}, _Transition.default.propTypes, {
+  /**
+   * The animation classNames applied to the component as it enters, exits or
+   * has finished the transition. A single name can be provided and it will be
+   * suffixed for each stage: e.g.
+   *
+   * `classNames="fade"` applies `fade-enter`, `fade-enter-active`,
+   * `fade-enter-done`, `fade-exit`, `fade-exit-active`, `fade-exit-done`,
+   * `fade-appear`, `fade-appear-active`, and `fade-appear-done`.
+   *
+   * **Note**: `fade-appear-done` and `fade-enter-done` will _both_ be applied.
+   * This allows you to define different behavior for when appearing is done and
+   * when regular entering is done, using selectors like
+   * `.fade-enter-done:not(.fade-appear-done)`. For example, you could apply an
+   * epic entrance animation when element first appears in the DOM using
+   * [Animate.css](https://daneden.github.io/animate.css/). Otherwise you can
+   * simply use `fade-enter-done` for defining both cases.
+   *
+   * Each individual classNames can also be specified independently like:
+   *
+   * ```js
+   * classNames={{
+   *  appear: 'my-appear',
+   *  appearActive: 'my-active-appear',
+   *  appearDone: 'my-done-appear',
+   *  enter: 'my-enter',
+   *  enterActive: 'my-active-enter',
+   *  enterDone: 'my-done-enter',
+   *  exit: 'my-exit',
+   *  exitActive: 'my-active-exit',
+   *  exitDone: 'my-done-exit',
+   * }}
+   * ```
+   *
+   * If you want to set these classes using CSS Modules:
+   *
+   * ```js
+   * import styles from './styles.css';
+   * ```
+   *
+   * you might want to use camelCase in your CSS file, that way could simply
+   * spread them instead of listing them one by one:
+   *
+   * ```js
+   * classNames={{ ...styles }}
+   * ```
+   *
+   * @type {string | {
+   *  appear?: string,
+   *  appearActive?: string,
+   *  appearDone?: string,
+   *  enter?: string,
+   *  enterActive?: string,
+   *  enterDone?: string,
+   *  exit?: string,
+   *  exitActive?: string,
+   *  exitDone?: string,
+   * }}
+   */
+  classNames: _PropTypes.classNamesShape,
+
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter' or 'appear' class is
+   * applied.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEnter: PropTypes.func,
+
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter-active' or
+   * 'appear-active' class is applied.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntering: PropTypes.func,
+
+  /**
+   * A `<Transition>` callback fired immediately after the 'enter' or
+   * 'appear' classes are **removed** and the `done` class is added to the DOM node.
+   *
+   * @type Function(node: HtmlElement, isAppearing: bool)
+   */
+  onEntered: PropTypes.func,
+
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit' class is
+   * applied.
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExit: PropTypes.func,
+
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit-active' is applied.
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExiting: PropTypes.func,
+
+  /**
+   * A `<Transition>` callback fired immediately after the 'exit' classes
+   * are **removed** and the `exit-done` class is added to the DOM node.
+   *
+   * @type Function(node: HtmlElement)
+   */
+  onExited: PropTypes.func
+}) : {};
+var _default = CSSTransition;
+exports.default = _default;
+module.exports = exports["default"];
+}(CSSTransition, CSSTransition.exports));
+
+var ReplaceTransition = {exports: {}};
+
+var TransitionGroup = {exports: {}};
+
+var ChildMapping = {};
+
+ChildMapping.__esModule = true;
+ChildMapping.getChildMapping = getChildMapping;
+ChildMapping.mergeChildMappings = mergeChildMappings;
+ChildMapping.getInitialChildMapping = getInitialChildMapping;
+ChildMapping.getNextChildMapping = getNextChildMapping;
+
+var _react = React;
+
+/**
+ * Given `this.props.children`, return an object mapping key to child.
+ *
+ * @param {*} children `this.props.children`
+ * @return {object} Mapping of key to child
+ */
+function getChildMapping(children, mapFn) {
+  var mapper = function mapper(child) {
+    return mapFn && (0, _react.isValidElement)(child) ? mapFn(child) : child;
+  };
+
+  var result = Object.create(null);
+  if (children) _react.Children.map(children, function (c) {
+    return c;
+  }).forEach(function (child) {
+    // run the map function here instead so that the key is the computed one
+    result[child.key] = mapper(child);
+  });
+  return result;
+}
+/**
+ * When you're adding or removing children some may be added or removed in the
+ * same render pass. We want to show *both* since we want to simultaneously
+ * animate elements in and out. This function takes a previous set of keys
+ * and a new set of keys and merges them with its best guess of the correct
+ * ordering. In the future we may expose some of the utilities in
+ * ReactMultiChild to make this easy, but for now React itself does not
+ * directly have this concept of the union of prevChildren and nextChildren
+ * so we implement it here.
+ *
+ * @param {object} prev prev children as returned from
+ * `ReactTransitionChildMapping.getChildMapping()`.
+ * @param {object} next next children as returned from
+ * `ReactTransitionChildMapping.getChildMapping()`.
+ * @return {object} a key set that contains all keys in `prev` and all keys
+ * in `next` in a reasonable order.
+ */
+
+
+function mergeChildMappings(prev, next) {
+  prev = prev || {};
+  next = next || {};
+
+  function getValueForKey(key) {
+    return key in next ? next[key] : prev[key];
+  } // For each key of `next`, the list of keys to insert before that key in
+  // the combined list
+
+
+  var nextKeysPending = Object.create(null);
+  var pendingKeys = [];
+
+  for (var prevKey in prev) {
+    if (prevKey in next) {
+      if (pendingKeys.length) {
+        nextKeysPending[prevKey] = pendingKeys;
+        pendingKeys = [];
+      }
+    } else {
+      pendingKeys.push(prevKey);
+    }
+  }
+
+  var i;
+  var childMapping = {};
+
+  for (var nextKey in next) {
+    if (nextKeysPending[nextKey]) {
+      for (i = 0; i < nextKeysPending[nextKey].length; i++) {
+        var pendingNextKey = nextKeysPending[nextKey][i];
+        childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey);
+      }
+    }
+
+    childMapping[nextKey] = getValueForKey(nextKey);
+  } // Finally, add the keys which didn't appear before any key in `next`
+
+
+  for (i = 0; i < pendingKeys.length; i++) {
+    childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]);
+  }
+
+  return childMapping;
+}
+
+function getProp(child, prop, props) {
+  return props[prop] != null ? props[prop] : child.props[prop];
+}
+
+function getInitialChildMapping(props, onExited) {
+  return getChildMapping(props.children, function (child) {
+    return (0, _react.cloneElement)(child, {
+      onExited: onExited.bind(null, child),
+      in: true,
+      appear: getProp(child, 'appear', props),
+      enter: getProp(child, 'enter', props),
+      exit: getProp(child, 'exit', props)
+    });
+  });
+}
+
+function getNextChildMapping(nextProps, prevChildMapping, onExited) {
+  var nextChildMapping = getChildMapping(nextProps.children);
+  var children = mergeChildMappings(prevChildMapping, nextChildMapping);
+  Object.keys(children).forEach(function (key) {
+    var child = children[key];
+    if (!(0, _react.isValidElement)(child)) return;
+    var hasPrev = key in prevChildMapping;
+    var hasNext = key in nextChildMapping;
+    var prevChild = prevChildMapping[key];
+    var isLeaving = (0, _react.isValidElement)(prevChild) && !prevChild.props.in; // item is new (entering)
+
+    if (hasNext && (!hasPrev || isLeaving)) {
+      // console.log('entering', key)
+      children[key] = (0, _react.cloneElement)(child, {
+        onExited: onExited.bind(null, child),
+        in: true,
+        exit: getProp(child, 'exit', nextProps),
+        enter: getProp(child, 'enter', nextProps)
+      });
+    } else if (!hasNext && hasPrev && !isLeaving) {
+      // item is old (exiting)
+      // console.log('leaving', key)
+      children[key] = (0, _react.cloneElement)(child, {
+        in: false
+      });
+    } else if (hasNext && hasPrev && (0, _react.isValidElement)(prevChild)) {
+      // item hasn't changed transition states
+      // copy over the last transition props;
+      // console.log('unchanged', key)
+      children[key] = (0, _react.cloneElement)(child, {
+        onExited: onExited.bind(null, child),
+        in: prevChild.props.in,
+        exit: getProp(child, 'exit', nextProps),
+        enter: getProp(child, 'enter', nextProps)
+      });
+    }
+  });
+  return children;
+}
+
+(function (module, exports) {
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _propTypes = _interopRequireDefault(PropTypes$2);
+
+var _react = _interopRequireDefault(React);
+
+var _reactLifecyclesCompat = require$$2;
+
+var _ChildMapping = ChildMapping;
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _extends() { _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; }; return _extends.apply(this, arguments); }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+var values = Object.values || function (obj) {
+  return Object.keys(obj).map(function (k) {
+    return obj[k];
+  });
+};
+
+var defaultProps = {
+  component: 'div',
+  childFactory: function childFactory(child) {
+    return child;
+  }
+  /**
+   * The `<TransitionGroup>` component manages a set of transition components
+   * (`<Transition>` and `<CSSTransition>`) in a list. Like with the transition
+   * components, `<TransitionGroup>` is a state machine for managing the mounting
+   * and unmounting of components over time.
+   *
+   * Consider the example below. As items are removed or added to the TodoList the
+   * `in` prop is toggled automatically by the `<TransitionGroup>`.
+   *
+   * Note that `<TransitionGroup>`  does not define any animation behavior!
+   * Exactly _how_ a list item animates is up to the individual transition
+   * component. This means you can mix and match animations across different list
+   * items.
+   */
+
+};
+
+var TransitionGroup =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(TransitionGroup, _React$Component);
+
+  function TransitionGroup(props, context) {
+    var _this;
+
+    _this = _React$Component.call(this, props, context) || this;
+
+    var handleExited = _this.handleExited.bind(_assertThisInitialized(_assertThisInitialized(_this))); // Initial children should all be entering, dependent on appear
+
+
+    _this.state = {
+      handleExited: handleExited,
+      firstRender: true
+    };
+    return _this;
+  }
+
+  var _proto = TransitionGroup.prototype;
+
+  _proto.getChildContext = function getChildContext() {
+    return {
+      transitionGroup: {
+        isMounting: !this.appeared
+      }
+    };
+  };
+
+  _proto.componentDidMount = function componentDidMount() {
+    this.appeared = true;
+    this.mounted = true;
+  };
+
+  _proto.componentWillUnmount = function componentWillUnmount() {
+    this.mounted = false;
+  };
+
+  TransitionGroup.getDerivedStateFromProps = function getDerivedStateFromProps(nextProps, _ref) {
+    var prevChildMapping = _ref.children,
+        handleExited = _ref.handleExited,
+        firstRender = _ref.firstRender;
+    return {
+      children: firstRender ? (0, _ChildMapping.getInitialChildMapping)(nextProps, handleExited) : (0, _ChildMapping.getNextChildMapping)(nextProps, prevChildMapping, handleExited),
+      firstRender: false
+    };
+  };
+
+  _proto.handleExited = function handleExited(child, node) {
+    var currentChildMapping = (0, _ChildMapping.getChildMapping)(this.props.children);
+    if (child.key in currentChildMapping) return;
+
+    if (child.props.onExited) {
+      child.props.onExited(node);
+    }
+
+    if (this.mounted) {
+      this.setState(function (state) {
+        var children = _extends({}, state.children);
+
+        delete children[child.key];
+        return {
+          children: children
+        };
+      });
+    }
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        Component = _this$props.component,
+        childFactory = _this$props.childFactory,
+        props = _objectWithoutPropertiesLoose(_this$props, ["component", "childFactory"]);
+
+    var children = values(this.state.children).map(childFactory);
+    delete props.appear;
+    delete props.enter;
+    delete props.exit;
+
+    if (Component === null) {
+      return children;
+    }
+
+    return _react.default.createElement(Component, props, children);
+  };
+
+  return TransitionGroup;
+}(_react.default.Component);
+
+TransitionGroup.childContextTypes = {
+  transitionGroup: _propTypes.default.object.isRequired
+};
+TransitionGroup.propTypes = process.env.NODE_ENV !== "production" ? {
+  /**
+   * `<TransitionGroup>` renders a `<div>` by default. You can change this
+   * behavior by providing a `component` prop.
+   * If you use React v16+ and would like to avoid a wrapping `<div>` element
+   * you can pass in `component={null}`. This is useful if the wrapping div
+   * borks your css styles.
+   */
+  component: _propTypes.default.any,
+
+  /**
+   * A set of `<Transition>` components, that are toggled `in` and out as they
+   * leave. the `<TransitionGroup>` will inject specific transition props, so
+   * remember to spread them through if you are wrapping the `<Transition>` as
+   * with our `<Fade>` example.
+   *
+   * While this component is meant for multiple `Transition` or `CSSTransition`
+   * children, sometimes you may want to have a single transition child with
+   * content that you want to be transitioned out and in when you change it
+   * (e.g. routes, images etc.) In that case you can change the `key` prop of
+   * the transition child as you change its content, this will cause
+   * `TransitionGroup` to transition the child out and back in.
+   */
+  children: _propTypes.default.node,
+
+  /**
+   * A convenience prop that enables or disables appear animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  appear: _propTypes.default.bool,
+
+  /**
+   * A convenience prop that enables or disables enter animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  enter: _propTypes.default.bool,
+
+  /**
+   * A convenience prop that enables or disables exit animations
+   * for all children. Note that specifying this will override any defaults set
+   * on individual children Transitions.
+   */
+  exit: _propTypes.default.bool,
+
+  /**
+   * You may need to apply reactive updates to a child as it is exiting.
+   * This is generally done by using `cloneElement` however in the case of an exiting
+   * child the element has already been removed and not accessible to the consumer.
+   *
+   * If you do need to update a child as it leaves you can provide a `childFactory`
+   * to wrap every child, even the ones that are leaving.
+   *
+   * @type Function(child: ReactElement) -> ReactElement
+   */
+  childFactory: _propTypes.default.func
+} : {};
+TransitionGroup.defaultProps = defaultProps;
+
+var _default = (0, _reactLifecyclesCompat.polyfill)(TransitionGroup);
+
+exports.default = _default;
+module.exports = exports["default"];
+}(TransitionGroup, TransitionGroup.exports));
+
+(function (module, exports) {
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _propTypes = _interopRequireDefault(PropTypes$2);
+
+var _react = _interopRequireDefault(React);
+
+var _reactDom = require$$2$1;
+
+var _TransitionGroup = _interopRequireDefault(TransitionGroup.exports);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _inheritsLoose(subClass, superClass) { subClass.prototype = Object.create(superClass.prototype); subClass.prototype.constructor = subClass; subClass.__proto__ = superClass; }
+
+/**
+ * The `<ReplaceTransition>` component is a specialized `Transition` component
+ * that animates between two children.
+ *
+ * ```jsx
+ * <ReplaceTransition in>
+ *   <Fade><div>I appear first</div></Fade>
+ *   <Fade><div>I replace the above</div></Fade>
+ * </ReplaceTransition>
+ * ```
+ */
+var ReplaceTransition =
+/*#__PURE__*/
+function (_React$Component) {
+  _inheritsLoose(ReplaceTransition, _React$Component);
+
+  function ReplaceTransition() {
+    var _this;
+
+    for (var _len = arguments.length, _args = new Array(_len), _key = 0; _key < _len; _key++) {
+      _args[_key] = arguments[_key];
+    }
+
+    _this = _React$Component.call.apply(_React$Component, [this].concat(_args)) || this;
+
+    _this.handleEnter = function () {
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+
+      return _this.handleLifecycle('onEnter', 0, args);
+    };
+
+    _this.handleEntering = function () {
+      for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        args[_key3] = arguments[_key3];
+      }
+
+      return _this.handleLifecycle('onEntering', 0, args);
+    };
+
+    _this.handleEntered = function () {
+      for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+        args[_key4] = arguments[_key4];
+      }
+
+      return _this.handleLifecycle('onEntered', 0, args);
+    };
+
+    _this.handleExit = function () {
+      for (var _len5 = arguments.length, args = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+        args[_key5] = arguments[_key5];
+      }
+
+      return _this.handleLifecycle('onExit', 1, args);
+    };
+
+    _this.handleExiting = function () {
+      for (var _len6 = arguments.length, args = new Array(_len6), _key6 = 0; _key6 < _len6; _key6++) {
+        args[_key6] = arguments[_key6];
+      }
+
+      return _this.handleLifecycle('onExiting', 1, args);
+    };
+
+    _this.handleExited = function () {
+      for (var _len7 = arguments.length, args = new Array(_len7), _key7 = 0; _key7 < _len7; _key7++) {
+        args[_key7] = arguments[_key7];
+      }
+
+      return _this.handleLifecycle('onExited', 1, args);
+    };
+
+    return _this;
+  }
+
+  var _proto = ReplaceTransition.prototype;
+
+  _proto.handleLifecycle = function handleLifecycle(handler, idx, originalArgs) {
+    var _child$props;
+
+    var children = this.props.children;
+
+    var child = _react.default.Children.toArray(children)[idx];
+
+    if (child.props[handler]) (_child$props = child.props)[handler].apply(_child$props, originalArgs);
+    if (this.props[handler]) this.props[handler]((0, _reactDom.findDOMNode)(this));
+  };
+
+  _proto.render = function render() {
+    var _this$props = this.props,
+        children = _this$props.children,
+        inProp = _this$props.in,
+        props = _objectWithoutPropertiesLoose(_this$props, ["children", "in"]);
+
+    var _React$Children$toArr = _react.default.Children.toArray(children),
+        first = _React$Children$toArr[0],
+        second = _React$Children$toArr[1];
+
+    delete props.onEnter;
+    delete props.onEntering;
+    delete props.onEntered;
+    delete props.onExit;
+    delete props.onExiting;
+    delete props.onExited;
+    return _react.default.createElement(_TransitionGroup.default, props, inProp ? _react.default.cloneElement(first, {
+      key: 'first',
+      onEnter: this.handleEnter,
+      onEntering: this.handleEntering,
+      onEntered: this.handleEntered
+    }) : _react.default.cloneElement(second, {
+      key: 'second',
+      onEnter: this.handleExit,
+      onEntering: this.handleExiting,
+      onEntered: this.handleExited
+    }));
+  };
+
+  return ReplaceTransition;
+}(_react.default.Component);
+
+ReplaceTransition.propTypes = process.env.NODE_ENV !== "production" ? {
+  in: _propTypes.default.bool.isRequired,
+  children: function children(props, propName) {
+    if (_react.default.Children.count(props[propName]) !== 2) return new Error("\"" + propName + "\" must be exactly two transition components.");
+    return null;
+  }
+} : {};
+var _default = ReplaceTransition;
+exports.default = _default;
+module.exports = exports["default"];
+}(ReplaceTransition, ReplaceTransition.exports));
+
+var _CSSTransition = _interopRequireDefault(CSSTransition.exports);
+
+var _ReplaceTransition = _interopRequireDefault(ReplaceTransition.exports);
+
+var _TransitionGroup = _interopRequireDefault(TransitionGroup.exports);
+
+var _Transition = _interopRequireDefault(Transition$1);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+var reactTransitionGroup = {
+  Transition: _Transition.default,
+  TransitionGroup: _TransitionGroup.default,
+  ReplaceTransition: _ReplaceTransition.default,
+  CSSTransition: _CSSTransition.default
+};
+
+const stylesheet = {
+  incorrect: {
+    fill: `var(--feedback-incorrect-bg-color, ${color.incorrect()})`
+  },
+  correct: {
+    fill: `var(--feedback-correct-bg-color, ${color.correct()})`
+  },
+  feedbackTick: {
+    width: '33px',
+    height: '33px',
+    '& svg': {
+      position: 'absolute',
+      display: 'inline-block',
+      width: '33px',
+      height: '33px',
+      verticalAlign: 'middle',
+      '& hide': {
+        display: 'none'
+      }
+    }
+  },
+  feedbackTickEnter: {
+    opacity: '0',
+    left: '-50px'
+  },
+  feedbackTickEnterActive: {
+    opacity: '1',
+    left: '0px',
+    transition: 'left 500ms ease-in 200ms, opacity 500ms linear 200ms'
+  },
+  feedbackTickLeave: {
+    opacity: '1',
+    left: '0px'
+  },
+  feedbackTickLeaveActive: {
+    opacity: '0',
+    left: '-50px',
+    transition: 'left 300ms ease-in, opacity 300ms'
+  }
+};
+
+class FeedbackTick extends React.Component {
+  constructor(props) {
+    super(props);
+    this.incorrectIcon = /*#__PURE__*/React.createElement("svg", {
+      key: "1",
+      preserveAspectRatio: "xMinYMin meet",
+      x: "0px",
+      y: "0px",
+      viewBox: "0 0 44 40",
+      style: {
+        enableBackground: 'new 0 0 44 40'
+      }
+    }, /*#__PURE__*/React.createElement("g", null, /*#__PURE__*/React.createElement("rect", {
+      x: "11",
+      y: "17.3",
+      transform: "matrix(0.7071 -0.7071 0.7071 0.7071 -7.852 19.2507)",
+      className: this.props.classes.incorrect,
+      width: "16.6",
+      height: "3.7"
+    }), /*#__PURE__*/React.createElement("rect", {
+      x: "17.4",
+      y: "10.7",
+      transform: "matrix(0.7071 -0.7071 0.7071 0.7071 -7.8175 19.209)",
+      className: this.props.classes.incorrect,
+      width: "3.7",
+      height: "16.6"
+    })));
+    this.correctIcon = /*#__PURE__*/React.createElement("svg", {
+      key: "2",
+      preserveAspectRatio: "xMinYMin meet",
+      version: "1.1",
+      x: "0px",
+      y: "0px",
+      viewBox: "0 0 44 40",
+      style: {
+        enableBackground: 'new 0 0 44 40'
+      }
+    }, /*#__PURE__*/React.createElement("polygon", {
+      className: this.props.classes.correct,
+      points: "19.1,28.6 11.8,22.3 14.4,19.2 17.9,22.1 23.9,11.4 27.5,13.4"
+    }));
+  }
+
+  render() {
+    const {
+      correctness,
+      classes
+    } = this.props;
+
+    const icon = (() => {
+      if (correctness === 'incorrect') {
+        return this.incorrectIcon;
+      } else if (correctness === 'correct') {
+        return this.correctIcon;
+      }
+    })();
+
+    return /*#__PURE__*/React.createElement("div", {
+      className: classes.feedbackTick
+    }, /*#__PURE__*/React.createElement(reactTransitionGroup.TransitionGroup, null, correctness && /*#__PURE__*/React.createElement(reactTransitionGroup.CSSTransition, {
+      classNames: {
+        enter: classes.feedbackTickEnter,
+        enterActive: classes.feedbackTickEnterActive,
+        exit: classes.feedbackTickLeave,
+        exitActive: classes.feedbackTickLeaveActive
+      },
+      timeout: {
+        enter: 700,
+        exit: 300
+      }
+    }, icon)));
+  }
+
+}
+
+FeedbackTick.propTypes = {
+  classes: PropTypes$2.object.isRequired,
+  correctness: PropTypes$2.string
+};
+var FeedbackTick$1 = withStyles(stylesheet, {
+  name: 'FeedbackTick'
+})(FeedbackTick);
+
+const CLASS_NAME = 'multiple-choice-component';
+
+const styleSheet = theme => ({
+  row: {
+    display: 'flex',
+    alignItems: 'center',
+    backgroundColor: color.background()
+  },
+  checkboxHolder: {
+    display: 'flex',
+    alignItems: 'center',
+    backgroundColor: color.background(),
+    flex: 1,
+    '& label': {
+      color: color.text(),
+      '& > span': {
+        fontSize: 'inherit'
+      }
+    }
+  },
+  horizontalLayout: {
+    [`& .${CLASS_NAME}`]: {
+      // visually reduce right padding, but maintain accessibility padding for checkbox indicators to be circles
+      // add margin to the top, left and bottom of the checkbox to keep the same spacing as before
+      padding: theme.spacing.unit,
+      margin: `${theme.spacing.unit / 2}px 0 ${theme.spacing.unit / 2}px ${theme.spacing.unit / 2}px`
+    }
+  },
+  belowLayout: {
+    '& > label': {
+      alignItems: 'flex-start'
+    }
+  },
+  belowLayoutCenter: {
+    justifyContent: 'center',
+    '& > label': {
+      alignItems: 'center'
+    }
+  },
+  belowSelectionComponent: {
+    display: 'flex',
+    alignItems: 'center',
+    '& > span': {
+      // visually reduce right padding, but maintain accessibility padding for checkbox indicators to be circles
+      marginLeft: `-${theme.spacing.unit}px`
+    }
+  },
+  srOnly: {
+    position: 'absolute',
+    left: '-10000px',
+    top: 'auto',
+    width: '1px',
+    height: '1px',
+    overflow: 'hidden'
+  }
+});
+
+const formStyleSheet = {
+  label: {
+    color: `${color.text()} !important`,
+    //'var(--choice-input-color, black)'
+    backgroundColor: color.background(),
+    letterSpacing: 'normal'
+  },
+  disabled: {
+    // apply to all children
+    '& *': {
+      cursor: 'not-allowed !important'
+    }
+  }
+};
+const StyledFormControlLabel = withStyles(formStyleSheet, {
+  name: 'FormControlLabel'
+})(props => /*#__PURE__*/React.createElement(FormControlLabel, _extends({}, props, {
+  classes: {
+    label: props.classes.label,
+    disabled: props.classes.disabled
+  }
+})));
+
+const colorStyle = (varName, fallback) => ({
+  [`&.${CLASS_NAME}`]: {
+    color: `var(--choice-input-${varName}, ${fallback}) !important`
+  }
+});
+
+const inputStyles = {
+  'correct-root': colorStyle('correct-color', color.text()),
+  'correct-checked': colorStyle('correct-selected-color', color.correct()),
+  //green[500]),
+  'correct-disabled': colorStyle('correct-disabled-color', color.disabled()),
+  //'grey'),
+  'incorrect-root': colorStyle('incorrect-color', color.incorrect()),
+  'incorrect-checked': colorStyle('incorrect-checked', color.incorrect()),
+  //orange[500]),
+  'incorrect-disabled': colorStyle('incorrect-disabled-color', color.disabled()),
+  root: _extends({}, colorStyle('color', color.text()), {
+    '&:hover': {
+      color: `${color.primaryLight()} !important`
+    }
+  }),
+  checked: colorStyle('selected-color', color.primary()),
+  disabled: _extends({}, colorStyle('disabled-color', color.text()), {
+    opacity: 0.6,
+    cursor: 'not-allowed !important',
+    pointerEvents: 'initial !important'
+  }),
+  focusVisibleUnchecked: {
+    outline: `2px solid ${color.focusUncheckedBorder()}`,
+    backgroundColor: color.focusUnchecked()
+  },
+  focusVisibleChecked: {
+    outline: `2px solid ${color.focusCheckedBorder()}`,
+    backgroundColor: color.focusChecked()
+  }
+};
+const StyledCheckbox = withStyles(inputStyles)(props => {
+  const {
+    correctness,
+    classes,
+    checked,
+    onChange,
+    disabled,
+    value,
+    id,
+    onKeyDown,
+    inputRef
+  } = props;
+
+  const key = k => correctness ? `${correctness}-${k}` : k;
+
+  const resolved = {
+    root: classes[key('root')],
+    checked: classes[key('checked')],
+    disabled: classes[key('disabled')]
+  };
+  const miniProps = {
+    checked,
+    onChange,
+    disabled,
+    value
+  };
+  return /*#__PURE__*/React.createElement(Checkbox, _extends({
+    id: id,
+    inputRef: inputRef,
+    "aria-checked": checked,
+    onKeyDown: onKeyDown,
+    focusVisibleClassName: checked ? classes.focusVisibleChecked : classes.focusVisibleUnchecked,
+    disableRipple: true
+  }, miniProps, {
+    className: CLASS_NAME,
+    classes: {
+      root: resolved.root,
+      checked: resolved.checked,
+      disabled: `${correctness ? '' : resolved.disabled}`
+    }
+  }));
+});
+const StyledRadio = withStyles(inputStyles)(props => {
+  const {
+    correctness,
+    classes,
+    checked,
+    onChange,
+    disabled,
+    value,
+    id,
+    tagName,
+    inputRef
+  } = props;
+
+  const key = k => correctness ? `${correctness}-${k}` : k;
+
+  const resolved = {
+    root: classes[key('root')],
+    checked: classes[key('checked')],
+    disabled: classes[key('disabled')]
+  };
+  const miniProps = {
+    checked,
+    onChange,
+    disabled,
+    value
+  };
+  return /*#__PURE__*/React.createElement(Radio, _extends({
+    id: id,
+    inputRef: inputRef,
+    "aria-checked": checked,
+    focusVisibleClassName: checked ? classes.focusVisibleChecked : classes.focusVisibleUnchecked,
+    disableRipple: true
+  }, miniProps, {
+    className: CLASS_NAME,
+    name: tagName,
+    classes: {
+      root: resolved.root,
+      checked: resolved.checked,
+      disabled: `${correctness ? '' : resolved.disabled}`
+    }
+  }));
+});
+class ChoiceInput extends React.Component {
+  constructor(props) {
+    super(props);
+
+    this.handleKeyDown = event => {
+      const {
+        choiceMode
+      } = this.props;
+      if (choiceMode !== 'checkbox') return;
+      const isArrowDown = event.key === 'ArrowDown';
+      const isArrowUp = event.key === 'ArrowUp';
+      if (!isArrowDown && !isArrowUp) return;
+      event.preventDefault();
+      const currentEl = document.getElementById(this.choiceId);
+      if (!currentEl) return;
+      const fieldset = currentEl.closest('fieldset');
+      if (!fieldset) return;
+      const groupCheckboxes = Array.from(fieldset.querySelectorAll('input[type="checkbox"]'));
+      const currentIndex = groupCheckboxes.findIndex(el => el === currentEl);
+      if (currentIndex === -1) return;
+      const nextIndex = isArrowDown ? currentIndex + 1 : currentIndex - 1;
+      const nextEl = groupCheckboxes[nextIndex];
+
+      if (nextEl) {
+        nextEl.focus();
+      }
+    };
+
+    this.onToggleChoice = this.onToggleChoice.bind(this);
+    this.choiceId = this.generateChoiceId();
+    this.descId = `${this.choiceId}-desc`;
+  }
+
+  onToggleChoice(event) {
+    this.props.onChange(event);
+  }
+
+  generateChoiceId() {
+    return 'choice-' + (Math.random() * 10000).toFixed();
+  }
+
+  render() {
+    const {
+      choiceMode,
+      disabled,
+      displayKey,
+      feedback,
+      label,
+      correctness,
+      classes,
+      className,
+      rationale,
+      hideTick,
+      isEvaluateMode,
+      choicesLayout,
+      value,
+      checked,
+      tagName,
+      isSelectionButtonBelow
+    } = this.props;
+    const Tag = choiceMode === 'checkbox' ? StyledCheckbox : StyledRadio;
+    const classSuffix = choiceMode === 'checkbox' ? 'checkbox' : 'radio-button';
+    const holderClassNames = classNames(classes.checkboxHolder, {
+      [classes.horizontalLayout]: choicesLayout === 'horizontal',
+      [classes.belowLayout]: isSelectionButtonBelow && choicesLayout !== 'grid',
+      [classes.belowLayoutCenter]: isSelectionButtonBelow && choicesLayout === 'grid'
+    });
+    const choicelabel = /*#__PURE__*/React.createElement(React.Fragment, null, displayKey && !isSelectionButtonBelow ? /*#__PURE__*/React.createElement("span", {
+      className: classes.row
+    }, displayKey, ".", '\u00A0', /*#__PURE__*/React.createElement(PreviewPrompt, {
+      className: "label",
+      prompt: label,
+      tagName: "span"
+    })) : /*#__PURE__*/React.createElement(PreviewPrompt, {
+      className: "label",
+      prompt: label,
+      tagName: "span"
+    }));
+    const screenReaderLabel = /*#__PURE__*/React.createElement("span", {
+      id: this.descId,
+      className: classes.srOnly
+    }, choiceMode === 'checkbox' ? 'Checkbox to select the answer below' : 'Radio button to select the answer below');
+    const tagProps = {
+      disabled,
+      checked,
+      correctness,
+      tagName,
+      value,
+      id: this.choiceId,
+      onChange: this.onToggleChoice,
+      onKeyDown: this.handleKeyDown,
+      'aria-describedby': this.descId
+    };
+    const hasMathOrImage = typeof label === 'string' && (label.includes('<math') || label.includes('\\(') || label.includes('\\[') || label.includes('<img') || label.includes('data-latex') || label.includes('data-raw') || label.includes('<mjx-container'));
+    const control = isSelectionButtonBelow ? /*#__PURE__*/React.createElement("span", {
+      className: classes.belowSelectionComponent
+    }, hasMathOrImage && screenReaderLabel, /*#__PURE__*/React.createElement(Tag, _extends({}, tagProps, {
+      style: {
+        padding: 0
+      }
+    })), displayKey ? `${displayKey}.` : '') : /*#__PURE__*/React.createElement(React.Fragment, null, hasMathOrImage && screenReaderLabel, /*#__PURE__*/React.createElement(Tag, _extends({}, tagProps, {
+      inputRef: this.props.autoFocusRef
+    })));
+    return /*#__PURE__*/React.createElement("div", {
+      className: classNames(className, 'corespring-' + classSuffix, 'choice-input')
+    }, /*#__PURE__*/React.createElement("div", {
+      className: classes.row
+    }, !hideTick && isEvaluateMode && /*#__PURE__*/React.createElement(FeedbackTick$1, {
+      correctness: correctness
+    }), /*#__PURE__*/React.createElement("div", {
+      className: classNames(holderClassNames, 'checkbox-holder')
+    }, /*#__PURE__*/React.createElement(StyledFormControlLabel, {
+      label: choicelabel,
+      value: value,
+      htmlFor: this.choiceId,
+      labelPlacement: isSelectionButtonBelow ? 'top' : undefined,
+      control: control
+    }))), rationale && /*#__PURE__*/React.createElement(PreviewPrompt, {
+      className: "rationale",
+      defaultClassName: "rationale",
+      prompt: rationale
+    }), /*#__PURE__*/React.createElement(Feedback, {
+      feedback: feedback,
+      correctness: correctness
+    }));
+  }
+
+}
+ChoiceInput.propTypes = {
+  choiceMode: PropTypes$2.oneOf(['radio', 'checkbox']),
+  displayKey: PropTypes$2.string,
+  checked: PropTypes$2.bool.isRequired,
+  correctness: PropTypes$2.string,
+  disabled: PropTypes$2.bool.isRequired,
+  feedback: PropTypes$2.string,
+  label: PropTypes$2.string.isRequired,
+  rationale: PropTypes$2.string,
+  onChange: PropTypes$2.func.isRequired,
+  value: PropTypes$2.string.isRequired,
+  classes: PropTypes$2.object,
+  className: PropTypes$2.string,
+  tagName: PropTypes$2.string,
+  hideTick: PropTypes$2.bool,
+  isEvaluateMode: PropTypes$2.bool,
+  choicesLayout: PropTypes$2.oneOf(['vertical', 'grid', 'horizontal']),
+  isSelectionButtonBelow: PropTypes$2.bool
+};
+ChoiceInput.defaultProps = {
+  rationale: null,
+  checked: false,
+  isEvaluateMode: false
+};
+var ChoiceInput$1 = withStyles(styleSheet)(ChoiceInput);
+
+class Choice extends React.Component {
+  constructor(...args) {
+    super(...args);
+    this.state = {
+      isHovered: false
+    };
+
+    this.handleMouseEnter = () => {
+      const {
+        disabled,
+        checked
+      } = this.props;
+
+      if (!disabled && !checked) {
+        this.setState({
+          isHovered: true
+        });
+      }
+    };
+
+    this.handleMouseLeave = () => {
+      this.setState({
+        isHovered: false
+      });
+    };
+
+    this.onChange = choice => {
+      const {
+        disabled,
+        onChoiceChanged
+      } = this.props;
+
+      if (!disabled) {
+        onChoiceChanged(choice);
+      }
+    };
+  }
+
+  render() {
+    const {
+      choice,
+      index,
+      choicesLength,
+      showCorrect,
+      isEvaluateMode,
+      choiceMode,
+      disabled,
+      checked,
+      correctness,
+      displayKey,
+      classes,
+      choicesLayout,
+      gridColumns,
+      isSelectionButtonBelow,
+      selectedAnswerBackgroundColor,
+      selectedAnswerStrokeColor,
+      selectedAnswerStrokeWidth,
+      hoverAnswerBackgroundColor,
+      hoverAnswerStrokeColor,
+      hoverAnswerStrokeWidth,
+      autoFocusRef,
+      tagName
+    } = this.props;
+    const {
+      isHovered
+    } = this.state;
+    const choiceClass = 'choice' + (index === choicesLength - 1 ? ' last' : '');
+    const feedback = !isEvaluateMode || showCorrect ? '' : choice.feedback;
+
+    const choiceProps = _extends({}, choice, {
+      checked,
+      choiceMode,
+      disabled,
+      feedback,
+      correctness,
+      displayKey,
+      index,
+      choicesLayout,
+      gridColumns,
+      onChange: this.onChange,
+      isEvaluateMode,
+      isSelectionButtonBelow,
+      selectedAnswerStrokeColor,
+      selectedAnswerStrokeWidth,
+      tagName
+    });
+
+    const normalizeStrokeWidth = width => {
+      if (!width) return '2px'; // default
+
+      const trimmed = String(width).trim(); // add 'px' if the value is a number
+
+      if (/^\d+(\.\d+)?$/.test(trimmed)) {
+        return `${trimmed}px`;
+      }
+
+      return trimmed;
+    };
+
+    const hasSelectedStroke = selectedAnswerStrokeColor && selectedAnswerStrokeColor !== 'initial';
+    const hasHoverStroke = hoverAnswerStrokeColor && hoverAnswerStrokeColor !== 'initial';
+    let currentStrokeColor = 'transparent';
+    let currentStrokeWidth = '2px';
+    let currentBackgroundColor = 'initial';
+
+    if (hasSelectedStroke || hasHoverStroke) {
+      if (checked && hasSelectedStroke) {
+        // selected state takes priority when selected stroke is configured
+        currentStrokeColor = selectedAnswerStrokeColor;
+        currentStrokeWidth = selectedAnswerStrokeWidth;
+      } else if (isHovered && !disabled && hasHoverStroke) {
+        // hover state when not selected and not disabled, and hover stroke is configured
+        currentStrokeColor = hoverAnswerStrokeColor;
+        currentStrokeWidth = hoverAnswerStrokeWidth;
+      }
+    }
+
+    if (checked && selectedAnswerBackgroundColor && selectedAnswerBackgroundColor !== 'initial') {
+      currentBackgroundColor = selectedAnswerBackgroundColor;
+    } else if (isHovered && !disabled && hoverAnswerBackgroundColor && hoverAnswerBackgroundColor !== 'initial') {
+      currentBackgroundColor = hoverAnswerBackgroundColor;
+    }
+
+    const strokeStyle = hasSelectedStroke || hasHoverStroke ? {
+      border: `${normalizeStrokeWidth(currentStrokeWidth)} solid ${currentStrokeColor}`,
+      borderRadius: '8px'
+    } : {};
+    const names = classNames(classes.choice, {
+      [classes.noBorder]: index === choicesLength - 1 || choicesLayout !== 'vertical' || strokeStyle,
+      [classes.horizontalLayout]: choicesLayout === 'horizontal'
+    });
+    const choiceBackground = currentBackgroundColor !== 'initial' ? currentBackgroundColor : 'initial';
+    return /*#__PURE__*/React.createElement("div", {
+      className: choiceClass,
+      key: index,
+      style: _extends({
+        backgroundColor: choiceBackground
+      }, strokeStyle),
+      onMouseEnter: this.handleMouseEnter,
+      onMouseLeave: this.handleMouseLeave
+    }, /*#__PURE__*/React.createElement(ChoiceInput$1, _extends({}, choiceProps, {
+      className: names,
+      autoFocusRef: autoFocusRef
+    })));
+  }
+
+}
+Choice.propTypes = {};
+Choice.propTypes = {
+  choiceMode: PropTypes$2.oneOf(['radio', 'checkbox']),
+  choice: PropTypes$2.object,
+  disabled: PropTypes$2.bool.isRequired,
+  onChoiceChanged: PropTypes$2.func,
+  classes: PropTypes$2.object.isRequired,
+  index: PropTypes$2.number,
+  choicesLength: PropTypes$2.number,
+  showCorrect: PropTypes$2.bool,
+  isEvaluateMode: PropTypes$2.bool,
+  checked: PropTypes$2.bool,
+  correctness: PropTypes$2.string,
+  displayKey: PropTypes$2.string,
+  choicesLayout: PropTypes$2.oneOf(['vertical', 'grid', 'horizontal']),
+  gridColumns: PropTypes$2.string,
+  selectedAnswerBackgroundColor: PropTypes$2.string,
+  selectedAnswerStrokeColor: PropTypes$2.string,
+  selectedAnswerStrokeWidth: PropTypes$2.string,
+  hoverAnswerBackgroundColor: PropTypes$2.string,
+  hoverAnswerStrokeColor: PropTypes$2.string,
+  hoverAnswerStrokeWidth: PropTypes$2.string,
+  tagName: PropTypes$2.string,
+  isSelectionButtonBelow: PropTypes$2.bool,
+  autoFocusRef: PropTypes$2.object
+};
+var StyledChoice = withStyles(theme => ({
+  choice: {
+    paddingTop: theme.spacing.unit * 2.5,
+    paddingBottom: theme.spacing.unit + 2,
+    paddingLeft: theme.spacing.unit + 2,
+    paddingRight: theme.spacing.unit + 2,
+    borderBottom: `1px solid ${theme.palette.grey[300]}`
+  },
+  noBorder: {
+    borderBottom: 'none'
+  },
+  horizontalLayout: {
+    paddingRight: theme.spacing.unit * 2.5,
+    '& label': {
+      marginRight: theme.spacing.unit // '& span:first-child': {
+      //   paddingRight: 0
+      // }
+
+    }
+  }
+}))(Choice);
+
+const {
+  translator
+} = Translator;
+
+const styles$1 = theme => ({
+  main: {
+    color: color.text(),
+    backgroundColor: color.background(),
+    '& *': {
+      '-webkit-font-smoothing': 'antialiased'
+    },
+    position: 'relative',
+    // remove border from legend tags inside main to override the OT default styles
+    '& legend': {
+      border: 'none !important'
+    }
+  },
+  partLabel: {
+    display: 'block',
+    fontSize: 'inherit',
+    margin: '0',
+    fontWeight: 'normal',
+    paddingBottom: theme.spacing.unit * 2
+  },
+  teacherInstructions: {
+    marginBottom: theme.spacing.unit * 2
+  },
+  horizontalLayout: {
+    display: 'flex',
+    flexDirection: 'row',
+    flexWrap: 'wrap'
+  },
+  gridLayout: {
+    display: 'grid'
+  },
+  fieldset: {
+    border: '0px',
+    padding: '0.01em 0 0 0',
+    margin: '0px',
+    minWidth: '0px',
+    '&:focus': {
+      outline: 'none'
+    }
+  },
+  srOnly: {
+    position: 'absolute',
+    left: '-10000px',
+    top: 'auto',
+    width: '1px',
+    height: '1px',
+    overflow: 'hidden'
+  },
+  errorText: {
+    fontSize: theme.typography.fontSize - 2,
+    color: theme.palette.error.main,
+    paddingTop: theme.spacing.unit
+  }
+});
+
+class MultipleChoice$1 extends React.Component {
+  constructor(props) {
+    super(props);
+
+    this.handleChange = event => {
+      const {
+        value,
+        checked
+      } = event.target;
+      const {
+        maxSelections,
+        onChoiceChanged,
+        session
+      } = this.props;
+
+      if (session.value && session.value.length >= maxSelections) {
+        // show/hide max selections error when user select/deselect an answer
+        this.setState({
+          maxSelectionsErrorState: checked
+        });
+
+        if (checked) {
+          // prevent selecting more answers
+          return;
+        }
+      }
+
+      onChoiceChanged({
+        value,
+        selected: checked,
+        selector: 'Mouse'
+      });
+    };
+
+    this.onToggle = () => {
+      if (this.props.mode === 'evaluate') {
+        this.setState({
+          showCorrect: !this.state.showCorrect
+        }, () => {
+          if (this.props.onShowCorrectToggle) {
+            this.props.onShowCorrectToggle();
+          }
+        });
+      }
+    };
+
+    this.getCorrectness = (choice = {}) => {
+      const isCorrect = choice.correct;
+      const isChecked = this.isSelected(choice.value);
+
+      if (this.state.showCorrect) {
+        return isCorrect ? 'correct' : undefined;
+      }
+
+      if (isCorrect) {
+        if (isChecked) {
+          // A correct answer is selected: marked with a green checkmark
+          return 'correct';
+        } else {
+          // A correct answer is NOT selected: marked with an orange X
+          return 'incorrect';
+        }
+      } else {
+        if (isChecked) {
+          // An incorrect answer is selected: marked with an orange X
+          return 'incorrect';
+        } else {
+          // An incorrect answer is NOT selected: not marked
+          return undefined;
+        }
+      }
+    };
+
+    this.handleGroupFocus = e => {
+      const fieldset = e.currentTarget;
+      const activeEl = document.activeElement;
+
+      if (fieldset.contains(activeEl) && activeEl !== fieldset) {
+        return;
+      } // Only focus the first input if user is tabbing forward
+
+
+      if (!e.relatedTarget || fieldset.compareDocumentPosition(e.relatedTarget) & Node.DOCUMENT_POSITION_PRECEDING) {
+        var _this$firstInputRef;
+
+        if ((_this$firstInputRef = this.firstInputRef) != null && _this$firstInputRef.current) {
+          this.firstInputRef.current.focus();
+        }
+      }
+    };
+
+    this.state = {
+      showCorrect: this.props.alwaysShowCorrect || false,
+      maxSelectionsErrorState: false
+    };
+    this.onToggle = this.onToggle.bind(this);
+    this.firstInputRef = /*#__PURE__*/React.createRef();
+  }
+
+  isSelected(value) {
+    const sessionValue = this.props.session && this.props.session.value;
+    return sessionValue && sessionValue.indexOf && sessionValue.indexOf(value) >= 0;
+  } // handleChange was added for accessibility. Please see comments and videos from PD-2441.
+
+
+  UNSAFE_componentWillReceiveProps(nextProps) {
+    if (!nextProps.correctResponse && this.state.showCorrect !== false) {
+      this.setState({
+        showCorrect: false
+      }, () => {
+        if (this.props.onShowCorrectToggle) {
+          this.props.onShowCorrectToggle();
+        }
+      });
+    }
+
+    if (nextProps.alwaysShowCorrect && this.state.showCorrect !== true) {
+      this.setState({
+        showCorrect: true
+      }, () => {
+        if (this.props.onShowCorrectToggle) {
+          this.props.onShowCorrectToggle();
+        }
+      });
+    }
+  }
+
+  indexToSymbol(index) {
+    if (this.props.keyMode === 'numbers') {
+      return `${index + 1}`;
+    }
+
+    if (this.props.keyMode === 'letters') {
+      return String.fromCharCode(97 + index).toUpperCase();
+    }
+
+    return '';
+  }
+
+  getChecked(choice) {
+    // to determine if we are in evaluate mode or print mode
+    // since both modes have showCorrect but it interferes with "browse mode" in IBX if the print props are set
+    const isEvaluateMode = this.state.showCorrect && this.props.mode === 'evaluate';
+    const isPrintMode = this.props.alwaysShowCorrect && (!this.props.session || !this.props.session.value || this.props.session.value.length === 0);
+
+    if (isEvaluateMode || isPrintMode) {
+      return choice.correct || false;
+    }
+
+    return this.isSelected(choice.value);
+  } // renderHeading function was added for accessibility.
+
+
+  renderHeading() {
+    const {
+      mode,
+      choiceMode,
+      classes
+    } = this.props;
+
+    if (mode !== 'gather') {
+      return null;
+    }
+
+    return choiceMode === 'radio' ? /*#__PURE__*/React.createElement("h3", {
+      className: classes.srOnly
+    }, "Multiple Choice Question") : /*#__PURE__*/React.createElement("h3", {
+      className: classes.srOnly
+    }, "Multiple Select Question");
+  }
+
+  render() {
+    const {
+      mode,
+      disabled,
+      className,
+      choices = [],
+      choiceMode,
+      gridColumns,
+      partLabel,
+      prompt,
+      responseCorrect,
+      teacherInstructions,
+      classes,
+      alwaysShowCorrect,
+      animationsDisabled,
+      language,
+      isSelectionButtonBelow,
+      minSelections,
+      maxSelections,
+      autoplayAudioEnabled,
+      session,
+      customAudioButton
+    } = this.props;
+    const {
+      showCorrect,
+      maxSelectionsErrorState
+    } = this.state;
+    const isEvaluateMode = mode === 'evaluate';
+    const showCorrectAnswerToggle = isEvaluateMode && !responseCorrect;
+    const columnsStyle = gridColumns > 1 ? {
+      gridTemplateColumns: `repeat(${gridColumns}, 1fr)`
+    } : undefined;
+    const selections = session.value && session.value.length || 0;
+    const teacherInstructionsDiv = /*#__PURE__*/React.createElement(PreviewPrompt, {
+      tagName: "div",
+      className: "prompt",
+      defaultClassName: "teacher-instructions",
+      prompt: teacherInstructions
+    });
+
+    const getMultipleChoiceMinSelectionErrorMessage = () => {
+      if (minSelections && maxSelections) {
+        return minSelections === maxSelections ? translator.t('translation:multipleChoice:minmaxSelections_equal', {
+          lng: language,
+          minSelections
+        }) : translator.t('translation:multipleChoice:minmaxSelections_range', {
+          lng: language,
+          minSelections,
+          maxSelections
+        });
+      }
+
+      if (minSelections) {
+        return translator.t('translation:multipleChoice:minSelections', {
+          lng: language,
+          minSelections
+        });
+      }
+
+      return '';
+    };
+
+    return /*#__PURE__*/React.createElement("div", {
+      id: 'main-container',
+      className: classNames(classes.main, className, 'multiple-choice')
+    }, partLabel && /*#__PURE__*/React.createElement("h2", {
+      className: classes.partLabel
+    }, partLabel), this.renderHeading(), teacherInstructions && /*#__PURE__*/React.createElement("div", {
+      className: classes.teacherInstructions
+    }, !animationsDisabled ? /*#__PURE__*/React.createElement(Collapsible, {
+      labels: {
+        hidden: 'Show Teacher Instructions',
+        visible: 'Hide Teacher Instructions'
+      }
+    }, teacherInstructionsDiv) : teacherInstructionsDiv), /*#__PURE__*/React.createElement("fieldset", {
+      tabIndex: 0,
+      className: classes.fieldset,
+      onFocus: this.handleGroupFocus,
+      role: choiceMode === 'radio' ? 'radiogroup' : 'group'
+    }, /*#__PURE__*/React.createElement(PreviewPrompt, {
+      className: "prompt",
+      defaultClassName: "prompt",
+      prompt: prompt,
+      tagName: 'legend',
+      autoplayAudioEnabled: autoplayAudioEnabled,
+      customAudioButton: customAudioButton
+    }), !alwaysShowCorrect && /*#__PURE__*/React.createElement(CorrectAnswerToggle, {
+      show: showCorrectAnswerToggle,
+      toggled: showCorrect,
+      onToggle: this.onToggle.bind(this),
+      language: language
+    }), /*#__PURE__*/React.createElement("div", {
+      className: classNames({
+        [classes.gridLayout]: this.props.choicesLayout === 'grid',
+        [classes.horizontalLayout]: this.props.choicesLayout === 'horizontal'
+      }),
+      style: columnsStyle
+    }, choices.map((choice, index) => /*#__PURE__*/React.createElement(StyledChoice, {
+      autoFocusRef: index === 0 ? this.firstInputRef : null,
+      choicesLayout: this.props.choicesLayout,
+      selectedAnswerBackgroundColor: this.props.selectedAnswerBackgroundColor,
+      selectedAnswerStrokeColor: this.props.selectedAnswerStrokeColor,
+      selectedAnswerStrokeWidth: this.props.selectedAnswerStrokeWidth,
+      hoverAnswerBackgroundColor: this.props.hoverAnswerBackgroundColor,
+      hoverAnswerStrokeColor: this.props.hoverAnswerStrokeColor,
+      hoverAnswerStrokeWidth: this.props.hoverAnswerStrokeWidth,
+      gridColumns: gridColumns,
+      key: `choice-${index}`,
+      choice: choice,
+      index: index,
+      choicesLength: choices.length,
+      showCorrect: showCorrect,
+      isEvaluateMode: isEvaluateMode,
+      choiceMode: choiceMode,
+      disabled: disabled,
+      tagName: partLabel ? `group-${partLabel}` : 'group',
+      onChoiceChanged: this.handleChange,
+      hideTick: choice.hideTick,
+      checked: this.getChecked(choice),
+      correctness: isEvaluateMode ? this.getCorrectness(choice) : undefined,
+      displayKey: this.indexToSymbol(index),
+      isSelectionButtonBelow: isSelectionButtonBelow
+    })))), choiceMode === 'checkbox' && selections < minSelections && /*#__PURE__*/React.createElement("div", {
+      className: classes.errorText
+    }, getMultipleChoiceMinSelectionErrorMessage()), choiceMode === 'checkbox' && maxSelectionsErrorState && /*#__PURE__*/React.createElement("div", {
+      className: classes.errorText
+    }, translator.t(`translation:multipleChoice:maxSelections_${maxSelections === 1 ? 'one' : 'other'}`, {
+      lng: language,
+      maxSelections
+    })));
+  }
+
+}
+MultipleChoice$1.propTypes = {
+  className: PropTypes$2.string,
+  mode: PropTypes$2.oneOf(['gather', 'view', 'evaluate']),
+  choiceMode: PropTypes$2.oneOf(['radio', 'checkbox']),
+  keyMode: PropTypes$2.oneOf(['numbers', 'letters', 'none']),
+  choices: PropTypes$2.array,
+  partLabel: PropTypes$2.string,
+  prompt: PropTypes$2.string,
+  teacherInstructions: PropTypes$2.string,
+  session: PropTypes$2.object,
+  disabled: PropTypes$2.bool,
+  onChoiceChanged: PropTypes$2.func,
+  responseCorrect: PropTypes$2.bool,
+  classes: PropTypes$2.object.isRequired,
+  correctResponse: PropTypes$2.array,
+  choicesLayout: PropTypes$2.oneOf(['vertical', 'grid', 'horizontal']),
+  gridColumns: PropTypes$2.string,
+  alwaysShowCorrect: PropTypes$2.bool,
+  animationsDisabled: PropTypes$2.bool,
+  language: PropTypes$2.string,
+  selectedAnswerBackgroundColor: PropTypes$2.string,
+  selectedAnswerStrokeColor: PropTypes$2.string,
+  selectedAnswerStrokeWidth: PropTypes$2.string,
+  hoverAnswerBackgroundColor: PropTypes$2.string,
+  hoverAnswerStrokeColor: PropTypes$2.string,
+  hoverAnswerStrokeWidth: PropTypes$2.string,
+  onShowCorrectToggle: PropTypes$2.func,
+  isSelectionButtonBelow: PropTypes$2.bool,
+  minSelections: PropTypes$2.number,
+  maxSelections: PropTypes$2.number,
+  autoplayAudioEnabled: PropTypes$2.bool,
+  customAudioButton: {
+    playImage: PropTypes$2.string,
+    pauseImage: PropTypes$2.string
+  }
+};
+MultipleChoice$1.defaultProps = {
+  session: {
+    value: []
+  }
+};
+var MultipleChoice$2 = withStyles(styles$1)(MultipleChoice$1);
+
+const styles = () => ({});
+
+class Main extends React.Component {
+  constructor(props) {
+    super(props);
+  }
+
+  render() {
+    const {
+      model,
+      onChoiceChanged,
+      session,
+      onShowCorrectToggle
+    } = this.props;
+    const {
+      extraCSSRules,
+      fontSizeFactor
+    } = model; // model.partLabel is a property used for ebsr
+
+    return /*#__PURE__*/React.createElement(PreviewLayout, {
+      extraCSSRules: extraCSSRules,
+      fontSizeFactor: fontSizeFactor
+    }, /*#__PURE__*/React.createElement(MultipleChoice$2, _extends({}, model, {
+      session: session,
+      onChoiceChanged: onChoiceChanged,
+      onShowCorrectToggle: onShowCorrectToggle
+    })));
+  }
+
+}
+
+Main.propTypes = {
+  model: PropTypes$2.object,
+  session: PropTypes$2.object,
+  onChoiceChanged: PropTypes$2.func,
+  classes: PropTypes$2.object.isRequired,
+  onShowCorrectToggle: PropTypes$2.func,
+  extraCSSRules: PropTypes$2.shape({
+    names: PropTypes$2.arrayOf(PropTypes$2.string),
+    rules: PropTypes$2.string
+  })
+};
+Main.defaultProps = {
+  model: {},
+  session: {}
+};
+const Styled = withStyles(styles, {
+  name: 'Main'
+})(Main);
+const theme = createMuiTheme({
+  typography: {
+    useNextVariants: true
+  }
+});
+
+const Root = props => /*#__PURE__*/React.createElement(MuiThemeProvider, {
+  theme: theme
+}, /*#__PURE__*/React.createElement(Styled, props));
+
+function updateSessionValue(session, choiceMode, data) {
+  session.value = session.value || [];
+
+  if (choiceMode === 'checkbox') {
+    if (data.selected) {
+      session.value = Array.from(new Set([...session.value, data.value]));
+    } else {
+      session.value = session.value.filter(v => v !== data.value);
+    }
+  }
+
+  if (choiceMode === 'radio') {
+    if (data.selected) {
+      session.value = [data.value];
+    } else {
+      session.value = [];
+    }
+  } //update session value metadata
+
+
+  session.selector = data.selector; //the input method used to select the choice (e.g. mouse, keyboard)
+}
+function updateSessionMetadata(session, metadata) {
+  session.audioStartTime = session.audioStartTime || metadata.audioStartTime; //timestamp when auto-played audio started playing
+
+  session.audioEndTime = session.audioEndTime || metadata.audioEndTime; //timestamp when auto-played audio completed playing
+
+  if (!session.waitTime && session.audioStartTime && session.audioEndTime) {
+    // waitTime is elapsed time the user waited for auto-played audio to finish
+    session.waitTime = session.audioEndTime - session.audioStartTime;
+  }
+}
+
+const log = debug('pie-ui:multiple-choice');
+const isComplete = (session, model, audioComplete, elementContext) => {
+  const {
+    autoplayAudioEnabled,
+    completeAudioEnabled
+  } = model || {}; // check audio completion if audio settings are enabled and audio actually exists
+
+  if (autoplayAudioEnabled && completeAudioEnabled && !audioComplete) {
+    if (elementContext) {
+      const audio = elementContext.querySelector('audio');
+      const isInsidePrompt = audio && audio.closest('#preview-prompt'); // only require audio completion if audio exists and is inside the prompt
+
+      if (audio && isInsidePrompt) {
+        return false;
+      }
+    }
+  }
+
+  if (!session || !session.value) {
+    return false;
+  }
+
+  const {
+    choiceMode,
+    minSelections = 1,
+    maxSelections
+  } = model || {};
+  const selections = session.value.length || 0;
+
+  if (choiceMode === 'radio') {
+    return !!selections;
+  }
+
+  if (selections < minSelections || selections > maxSelections) {
+    return false;
+  }
+
+  return true;
+};
+class MultipleChoice extends HTMLElement {
+  constructor() {
+    super();
+    this._model = null;
+    this._session = null;
+    this.audioComplete = false;
+    this._boundHandleKeyDown = this.handleKeyDown.bind(this);
+    this._keyboardEventsEnabled = false;
+    this._audioInitialized = false;
+    this._rerender = debounce(() => {
+      if (this._model && this._session) {
+        var element = /*#__PURE__*/React.createElement(Root, {
+          model: this._model,
+          session: this._session,
+          onChoiceChanged: this._onChange.bind(this),
+          onShowCorrectToggle: this.onShowCorrectToggle.bind(this)
+        }); //TODO: aria-label is set in the _rerender because we need to change it when the model.choiceMode is updated. Consider revisiting the placement of the aria-label setting in the _rerender
+
+        this.setAttribute('aria-label', this._model.choiceMode === 'radio' ? 'Multiple Choice Question' : 'Multiple Correct Answer Question');
+        this.setAttribute('role', 'region');
+        this.setLangAttribute();
+        require$$2$1.render(element, this, () => {
+          log('render complete - render math');
+          renderMath(this);
+        });
+
+        if (this._model.keyboardEventsEnabled === true && !this._keyboardEventsEnabled) {
+          this.enableKeyboardEvents();
+        }
+      } else {
+        log('skip');
+      }
+    }, 50, {
+      leading: false,
+      trailing: true
+    });
+    this._dispatchResponseChanged = debounce(() => {
+      this.dispatchEvent(new SessionChangedEvent(this.tagName.toLowerCase(), isComplete(this._session, this._model, this.audioComplete, this)));
+    });
+    this._dispatchModelSet = debounce(() => {
+      this.dispatchEvent(new ModelSetEvent(this.tagName.toLowerCase(), isComplete(this._session, this._model, this.audioComplete, this), this._model !== undefined));
+    }, 50, {
+      leading: false,
+      trailing: true
+    });
+  }
+
+  onShowCorrectToggle() {
+    renderMath(this);
+  }
+
+  setLangAttribute() {
+    const language = this._model && typeof this._model.language ? this._model.language : '';
+    const lang = language ? language.slice(0, 2) : 'en';
+    this.setAttribute('lang', lang);
+  }
+
+  set model(s) {
+    this._model = s;
+
+    this._rerender(); // reset the audioInitialized to false since the model changed, and we might need to reinitialize the audio
+
+
+    this._audioInitialized = false;
+
+    this._dispatchModelSet();
+  }
+
+  get session() {
+    return this._session;
+  }
+
+  set session(s) {
+    this._session = s;
+
+    this._rerender(); //TODO: remove this session-changed should only be emit on user change
+
+
+    this._dispatchResponseChanged();
+  }
+
+  _onChange(data) {
+    updateSessionValue(this._session, this._model.choiceMode, data);
+
+    this._dispatchResponseChanged();
+
+    this._rerender();
+  }
+
+  _createAudioInfoToast() {
+    const info = document.createElement('div');
+    info.id = 'play-audio-info';
+    Object.assign(info.style, {
+      position: 'absolute',
+      top: 0,
+      width: '100%',
+      height: '100%',
+      display: 'flex',
+      justifyContent: 'center',
+      alignItems: 'center',
+      background: 'white',
+      zIndex: '1000',
+      cursor: 'pointer'
+    });
+    const img = document.createElement('img');
+    img.src = EnableAudioAutoplayImage;
+    img.alt = 'Click anywhere to enable audio autoplay';
+    img.width = 500;
+    img.height = 300;
+    info.appendChild(img);
+    return info;
+  }
+
+  connectedCallback() {
+    this._rerender(); // Observation:  audio in Chrome will have the autoplay attribute,
+    // while other browsers will not have the autoplay attribute and will need a user interaction to play the audio
+    // This workaround fixes the issue of audio being cached and played on any user interaction in Safari and Firefox
+
+
+    const observer = new MutationObserver((mutationsList, observer) => {
+      mutationsList.forEach(mutation => {
+        if (mutation.type === 'childList') {
+          if (this._audioInitialized) return;
+          const audio = this.querySelector('audio');
+          const isInsidePrompt = audio && audio.closest('#preview-prompt');
+          if (!this._model) return;
+          if (!this._model.autoplayAudioEnabled) return;
+          if (audio && !isInsidePrompt) return;
+          if (!audio) return;
+
+          const info = this._createAudioInfoToast();
+
+          const container = this.querySelector('#main-container');
+
+          const enableAudio = () => {
+            if (this.querySelector('#play-audio-info')) {
+              audio.play();
+              container.removeChild(info);
+            }
+
+            document.removeEventListener('click', enableAudio);
+          }; // if the audio is paused, it means the user has not interacted with the page yet and the audio will not play
+          // FIX FOR SAFARI: play with a slight delay to check if autoplay was blocked
+
+
+          setTimeout(() => {
+            if (audio.paused && !this.querySelector('#play-audio-info')) {
+              // add info message as a toast to enable audio playback
+              container.appendChild(info);
+              document.addEventListener('click', enableAudio);
+            } else {
+              document.removeEventListener('click', enableAudio);
+            }
+          }, 500); // we need to listen for the playing event to remove the toast in case the audio plays because of re-rendering
+
+          const handlePlaying = () => {
+            updateSessionMetadata(this._session, {
+              audioStartTime: new Date().getTime()
+            });
+            const info = this.querySelector('#play-audio-info');
+
+            if (info) {
+              container.removeChild(info);
+            }
+
+            audio.removeEventListener('playing', handlePlaying);
+          };
+
+          audio.addEventListener('playing', handlePlaying); // we need to listen for the ended event to update the isComplete state
+
+          const handleEnded = () => {
+            updateSessionMetadata(this._session, {
+              audioEndTime: new Date().getTime()
+            });
+            this.audioComplete = true;
+
+            this._dispatchResponseChanged();
+
+            audio.removeEventListener('ended', handleEnded);
+          };
+
+          audio.addEventListener('ended', handleEnded); // store references to remove later
+
+          this._audio = audio;
+          this._handlePlaying = handlePlaying;
+          this._handleEnded = handleEnded;
+          this._enableAudio = enableAudio; // set to true to prevent multiple initializations
+
+          this._audioInitialized = true;
+          observer.disconnect();
+        }
+      });
+    });
+    observer.observe(this, {
+      childList: true,
+      subtree: true
+    });
+  }
+
+  enableKeyboardEvents() {
+    if (!this._keyboardEventsEnabled) {
+      window.addEventListener('keydown', this._boundHandleKeyDown);
+      this._keyboardEventsEnabled = true;
+    }
+  }
+
+  disconnectedCallback() {
+    if (this._keyboardEventsEnabled) {
+      window.removeEventListener('keydown', this._boundHandleKeyDown);
+      this._keyboardEventsEnabled = false;
+    }
+
+    document.removeEventListener('click', this._enableAudio);
+
+    if (this._audio) {
+      this._audio.removeEventListener('playing', this._handlePlaying);
+
+      this._audio.removeEventListener('ended', this._handleEnded);
+
+      this._audio = null;
+    }
+  }
+  /**
+   * Handles global keyboard events for selecting or toggling multiple-choice answers.
+   * Maps keys (1-9, 0, a-j, A-J) to choices and updates the session state accordingly.
+   * Ensures valid key presses toggle or select the appropriate choice based on the model.
+   */
+
+
+  handleKeyDown(event) {
+    var _this$_model$choices;
+
+    if (!this._model || !this._session) {
+      return;
+    }
+
+    const {
+      mode
+    } = this._model;
+
+    if (mode !== 'gather') {
+      return;
+    }
+
+    const keyToIndex = key => {
+      const numOffset = key >= '1' && key <= '9' ? key - '1' : key === '0' ? 9 : -1;
+      const letterOffset = /^[a-jA-J]$/.test(key) ? key.toLowerCase().charCodeAt(0) - 'a'.charCodeAt(0) : -1;
+      return numOffset >= 0 ? numOffset : letterOffset;
+    };
+
+    const choiceIndex = keyToIndex(event.key);
+
+    if (choiceIndex === undefined || choiceIndex <= -1 || choiceIndex >= ((_this$_model$choices = this._model.choices) == null ? void 0 : _this$_model$choices.length)) {
+      return;
+    }
+
+    const currentValue = this._session.value || [];
+    const choiceId = this._model.choices[choiceIndex].value;
+    const newValue = {
+      value: choiceId,
+      selected: !currentValue.includes(choiceId),
+      selector: 'Keyboard'
+    };
+
+    this._onChange(newValue);
+  }
+
+}
+
+export { MultipleChoice as default, isComplete };
+//# sourceMappingURL=element.js.map