@khanacademy/perseus 0.4.2 → 1.0.0

package/dist/index.js

@@ -73,7 +73,7 @@ var Link__default = /*#__PURE__*/_interopDefaultLegacy(Link);
 
 var version = {
   apiVersion: {
-    major: 11,
+    major: 12,
     minor: 0
   },
   itemDataVersion: {
@@ -438,38 +438,9 @@ const ApiOptions = {
     //     values. For now, though, you must either specify all fields
     //     of `styling`, or omit the `styling` option entirely.
     styling: PropTypes__default["default"].shape({
-      // Which version of radio widget styles to use in non-SAT
-      // contexts.
-      //
-      // "legacy" was the version of the widget display after XOM but
-      // before we started adding MCR styles. It doesn't have support
-      // for rationales. It has since been removed.
-      //
-      // "intermediate" is a design which adds several new additions
-      // to the "legacy" styles such as:
-      //  1. Using the XOM "desktop" styles (with a visible check icon
-      //     and lines in between choices) on mobile devices.
-      //  2. Designs for rationales
-      //  3. Using the single-select styles for multi-select styles
-      //
-      // "final" is a design which will build off of the
-      // "intermediate" designs and adds some improved designs as well
-      // as:
-      //  1. a/b/c/d/etc. letters inside of the prompt check box
-      //  2. New iconography and styles to indicate choice correctness
-      //
-      // The "legacy" and "intermediate" designs will be A/B tested
-      // against each other to ensure that its changes don't cause
-      // problems due to the new designs. Once the "intermediate"
-      // designs are finished, they will be A/B tested against the
-      // "final" designs.
-      //
-      // If no flag is provided, "legacy" styles will be shown.
-      //
-      // TODO(emily): Remove this by Aug 1, 2017, at which point all
-      //   callsites should have been switched to using the "final"
-      //   designs.
-      radioStyleVersion: PropTypes__default["default"].oneOf(["intermediate", "final"])
+      // TODO(Nicole): Remove this after landing wonderblock-ifying
+      // the radio widget
+      primaryProductColor: PropTypes__default["default"].string
     }),
     // The color used for the hint progress indicator (eg. 1 / 3)
     hintProgressColor: PropTypes__default["default"].string,
@@ -520,9 +491,7 @@ const ApiOptions = {
     },
     setDrawingAreaAvailable: function () {},
     useDraftEditor: false,
-    styling: {
-      radioStyleVersion: "final"
-    },
+    styling: {},
     canScrollPage: false,
     inModal: false,
     crossOutEnabled: false,
@@ -1643,16 +1612,10 @@ function inputPathsEqual(a, b) {
   return a.length === b.length && a.every((item, index) => {
     return b[index] === item;
   });
-} // Keep `rWidgetRule` in sync with `WIDGET_RE`
-// in content_internal/perseus_traversal.py
-// sync-start:widget-id-regex 1271666319 services/content-editing/perseus/translation/content_traversal.go
-// sync-start:widget-id-regex 680240484 services/static/javascript/perseus-merged-editor-package/editor.jsx
-// sync-start:widget-id-regex 1400368396 content_internal/perseus_traversal.py
-
+}
 
 const rWidgetRule = /^\[\[\u2603 (([a-z-]+) ([0-9]+))\]\]/;
-const rTypeFromWidgetId = /^([a-z-]+) ([0-9]+)$/; // sync-end:widget-id-regex
-
+const rTypeFromWidgetId = /^([a-z-]+) ([0-9]+)$/;
 const rWidgetParts = new RegExp(rWidgetRule.source + "$");
 const snowman = "\u2603";
 const noScore = {
@@ -3085,11 +3048,10 @@ const warningColor = "#f86700";
 const warningColorHover = "#df5c00";
 const warningColorActive = "#c75300";
 const publishBlockingErrorColor = "#be2612";
-const radioBorderColor$2 = "#BABEC2";
-const checkedColor$1 = "#71B307"; // sync-start:article-max-width 986452807 services/static/javascript/perseus-all-package/styles/variables.less
-
+const radioBorderColor$1 = "#BABEC2";
+const checkedColor$1 = "#71B307";
 const articleMaxWidthInPx = 688;
-const articleMaxWidthTableInPx = 512; // sync-end:article-max-width
+const articleMaxWidthTableInPx = 512;
 
 var constants$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -3154,7 +3116,7 @@ var constants$1 = /*#__PURE__*/Object.freeze({
     warningColorHover: warningColorHover,
     warningColorActive: warningColorActive,
     publishBlockingErrorColor: publishBlockingErrorColor,
-    radioBorderColor: radioBorderColor$2,
+    radioBorderColor: radioBorderColor$1,
     checkedColor: checkedColor$1,
     articleMaxWidthInPx: articleMaxWidthInPx,
     articleMaxWidthTableInPx: articleMaxWidthTableInPx
@@ -17888,17 +17850,17 @@ class Lint extends React__namespace.Component {
       let warningTextStyle;
 
       if (this.props.severity === 1) {
-        severityStyle = styles$w.indicatorError;
+        severityStyle = styles$A.indicatorError;
         warningText = "Error";
-        warningTextStyle = styles$w.publishBlockingError;
+        warningTextStyle = styles$A.publishBlockingError;
       } else if (this.props.severity === 2) {
-        severityStyle = styles$w.indicatorWarning;
+        severityStyle = styles$A.indicatorWarning;
         warningText = "Warning";
-        warningTextStyle = styles$w.warning;
+        warningTextStyle = styles$A.warning;
       } else {
-        severityStyle = styles$w.indicatorGuideline;
+        severityStyle = styles$A.indicatorGuideline;
         warningText = "Recommendation";
-        warningTextStyle = styles$w.warning;
+        warningTextStyle = styles$A.warning;
       }
 
       return /*#__PURE__*/React__namespace.createElement("a", {
@@ -17906,16 +17868,16 @@ class Lint extends React__namespace.Component {
         target: "lint-help-window",
         className: aphrodite.css(style)
       }, /*#__PURE__*/React__namespace.createElement("span", {
-        className: aphrodite.css(styles$w.indicator, severityStyle)
+        className: aphrodite.css(styles$A.indicator, severityStyle)
       }, this.props.severity === 1 && /*#__PURE__*/React__namespace.createElement(InlineIcon, exclamationIcon)), /*#__PURE__*/React__namespace.createElement("div", {
-        className: aphrodite.css(styles$w.tooltip, tooltipAbove && styles$w.tooltipAbove)
+        className: aphrodite.css(styles$A.tooltip, tooltipAbove && styles$A.tooltipAbove)
       }, this.props.message.split("\n\n").map((m, i) => /*#__PURE__*/React__namespace.createElement("p", {
         key: i,
-        className: aphrodite.css(styles$w.tooltipParagraph)
+        className: aphrodite.css(styles$A.tooltipParagraph)
       }, /*#__PURE__*/React__namespace.createElement("span", {
         className: aphrodite.css(warningTextStyle)
       }, warningText, ":", " "), m)), /*#__PURE__*/React__namespace.createElement("div", {
-        className: aphrodite.css(styles$w.tail, tooltipAbove && styles$w.tailAbove)
+        className: aphrodite.css(styles$A.tail, tooltipAbove && styles$A.tailAbove)
       })));
     });
   }
@@ -17963,19 +17925,19 @@ class Lint extends React__namespace.Component {
 
     if (blockHighlight) {
       return /*#__PURE__*/React__namespace.createElement("span", {
-        className: aphrodite.css(styles$w.lintContainer, styles$w.lintContainerBlock)
-      }, this.renderLink(styles$w.radioWidgetHoverTarget), /*#__PURE__*/React__namespace.createElement("span", null, children));
+        className: aphrodite.css(styles$A.lintContainer, styles$A.lintContainerBlock)
+      }, this.renderLink(styles$A.radioWidgetHoverTarget), /*#__PURE__*/React__namespace.createElement("span", null, children));
     }
 
     if (inline) {
       return /*#__PURE__*/React__namespace.createElement("span", {
-        className: aphrodite.css(styles$w.lintContainer)
-      }, this.renderLink(styles$w.inlineHoverTarget), /*#__PURE__*/React__namespace.createElement("span", null, children));
+        className: aphrodite.css(styles$A.lintContainer)
+      }, this.renderLink(styles$A.inlineHoverTarget), /*#__PURE__*/React__namespace.createElement("span", null, children));
     }
 
     return /*#__PURE__*/React__namespace.createElement("div", {
-      className: aphrodite.css(styles$w.lintContainer)
-    }, this.renderLink(styles$w.hoverTarget), /*#__PURE__*/React__namespace.createElement("div", null, children));
+      className: aphrodite.css(styles$A.lintContainer)
+    }, this.renderLink(styles$A.hoverTarget), /*#__PURE__*/React__namespace.createElement("div", null, children));
   }
 
 } // $FlowFixMe[prop-missing]
@@ -18000,7 +17962,7 @@ _defineProperty(Lint, "propTypes", {
   severity: PropTypes__default["default"].number
 });
 
-const styles$w = aphrodite.StyleSheet.create({
+const styles$A = aphrodite.StyleSheet.create({
   // This is the class of the outermost element.
   // We use relative positioning so that the lint indicator can be
   // positioned absolutely relative to the position of the linty container.
@@ -19893,7 +19855,7 @@ class Renderer extends React__namespace.Component {
             paddingRight: margin
           };
           const mobileInnerStyle = { ...innerStyle,
-            ...styles$v.mobileZoomableParentFix
+            ...styles$z.mobileZoomableParentFix
           };
           return /*#__PURE__*/React__namespace.createElement("div", {
             key: state.key,
@@ -20033,7 +19995,7 @@ class Renderer extends React__namespace.Component {
           paddingRight: 0
         };
         const mobileInnerStyle = { ...innerStyle,
-          ...styles$v.mobileZoomableParentFix
+          ...styles$z.mobileZoomableParentFix
         };
         const wrappedOutput = /*#__PURE__*/React__namespace.createElement("div", {
           style: { ...mobileInnerStyle,
@@ -20714,7 +20676,7 @@ _defineProperty(Renderer, "defaultProps", {
   linterContext: PerseusLinter__namespace.linterContextDefault
 });
 
-const styles$v = {
+const styles$z = {
   mobileZoomableParentFix: {
     // NOTE(abdul): There is an issue where transform animations will
     // cause the Zoomable component to disappear when running on the
@@ -24016,7 +23978,7 @@ var mediaQueries = {
 const {
   zIndexAboveScratchpad,
   zIndexInteractiveComponent,
-  radioBorderColor: radioBorderColor$1,
+  radioBorderColor,
   checkedColor,
   circleSize,
   radioMarginWidth
@@ -24071,7 +24033,7 @@ var sharedStyles = aphrodite.StyleSheet.create({
     },
     backgroundColor: "#fff",
     border: "2px solid #fff",
-    boxShadow: "0 0px 0px 1px ".concat(radioBorderColor$1),
+    boxShadow: "0 0px 0px 1px ".concat(radioBorderColor),
     outline: "none",
     boxSizing: "border-box",
     flexShrink: 0,
@@ -24323,36 +24285,6 @@ _defineProperty(Icon, "defaultProps", {
   color: "currentColor"
 });
 
-class FocusRing extends React__namespace.Component {
-  render() {
-    const borderColor = this.props.visible ? this.props.color : "transparent";
-    const style = {
-      borderColor: borderColor
-    };
-    return /*#__PURE__*/React__namespace.createElement("span", {
-      className: aphrodite.css(styles$u.ring),
-      style: style
-    }, this.props.children);
-  }
-
-}
-
-_defineProperty(FocusRing, "defaultProps", {
-  visible: true,
-  color: kaGreen$1
-});
-
-const styles$u = aphrodite.StyleSheet.create({
-  ring: {
-    margin: "auto",
-    display: "inline-block",
-    borderRadius: "50%",
-    borderWidth: 2,
-    padding: 2,
-    borderStyle: "solid"
-  }
-});
-
 /**
  * Given a choice's position in the radio widget, return the corresponding
  * "choice letter". (For example, in English, `getChoiceLetter(0)` is "A",
@@ -24383,179 +24315,57 @@ function getChoiceLetter(pos) {
   return " ";
 }
 
-const SAT_ICON_SIZE = 25;
-
-class SATChoiceIcon extends React__namespace.Component {
-  // TODO(amy): figure out a better scheme for specifying these
-  // styles that isn't such a pain to grok. See some neat ideas
-  // from MDR in https://phabricator.khanacademy.org/D35249.
-  constructStyles(reviewMode, correct, checked) {
-    let backgroundColor;
-    let borderColor = satBlue;
-    let color = satBlue;
-
-    if (reviewMode) {
-      if (correct) {
-        borderColor = satCorrectColor;
-        color = checked ? white$1 : satCorrectColor;
-        backgroundColor = checked ? satCorrectColor : white$1;
-      } else if (checked) {
-        borderColor = satIncorrectColor;
-        color = white$1;
-        backgroundColor = satIncorrectColor;
-      }
-    } else if (checked) {
-      color = white$1;
-      backgroundColor = satBlue;
-    }
-
-    return {
-      color,
-      backgroundColor,
-      borderColor
-    };
-  }
-
-  render() {
-    const {
-      letter,
-      a11yText,
-      reviewMode,
-      checked,
-      correct,
-      crossedOut
-    } = this.props;
-    const {
-      color,
-      backgroundColor,
-      borderColor
-    } = this.constructStyles(reviewMode, correct, checked);
-    return /*#__PURE__*/React__namespace.createElement("div", {
-      className: aphrodite.css(styles$t.iconWrapper)
-    }, /*#__PURE__*/React__namespace.createElement("div", {
-      className: aphrodite.css(styles$t.satCircle),
-      style: {
-        backgroundColor,
-        borderColor
-      }
-    }), /*#__PURE__*/React__namespace.createElement("div", {
-      style: {
-        color
-      },
-      className: aphrodite.css(styles$t.letter)
-    }, /*#__PURE__*/React__namespace.createElement("span", {
-      className: "perseus-sr-only"
-    }, a11yText), /*#__PURE__*/React__namespace.createElement("span", {
-      "aria-hidden": "true"
-    }, letter)), crossedOut && /*#__PURE__*/React__namespace.createElement(CrossOutLine, {
-      color: borderColor,
-      sat: true
-    }));
-  }
+/**
+ * Renders a circular selection ring around the child.
+ */
 
+function FocusRing(props) {
+  const {
+    visible,
+    color,
+    children,
+    multipleSelect
+  } = props;
+  const borderColor = visible ? color : "transparent";
+  const borderRadius = multipleSelect ? 5 : "50%";
+  const style = {
+    borderColor,
+    borderRadius
+  };
+  return /*#__PURE__*/React__namespace.createElement("span", {
+    "data-test-id": "focus-ring",
+    className: aphrodite.css(styles$y.ring),
+    style: style
+  }, children);
 }
 
-const LIBRARY_ICON_SIZE = 24;
-
-class LibraryChoiceIcon extends React__namespace.Component {
-  getChoiceInner() {
-    const {
-      letter,
-      showCorrectness,
-      correct
-    } = this.props;
-
-    if (!showCorrectness) {
-      return letter;
-    }
-
-    if (correct) {
-      return /*#__PURE__*/React__namespace.createElement(InlineIcon, _extends({}, iconCheck, {
-        style: {
-          position: "relative",
-          top: -1
-        }
-      }));
-    }
-
-    return /*#__PURE__*/React__namespace.createElement(InlineIcon, iconMinus);
-  } // Handle dynamic styling of the multiple choice icon. Most
-  // MC icon styles are constant, but we do allow the caller
-  // to specify the selected color, and thus must control styles
-  // related to the selected state dynamically.
-
-
-  getDynamicStyles() {
-    const {
-      checked,
-      showCorrectness,
-      pressed,
-      primaryProductColor,
-      correct,
-      transparentBackground
-    } = this.props;
-
-    if (!showCorrectness && pressed) {
-      return {
-        borderColor: primaryProductColor,
-        color: primaryProductColor,
-        backgroundColor: transparentBackground ? "transparent" : white$1
-      };
-    }
-
-    if (checked) {
-      // Note: kaGreen is not only the default product color,
-      // but also the "correctness" color
-      const bg = showCorrectness && correct ? Color__default["default"].green : primaryProductColor;
-      return {
-        color: white$1,
-        backgroundColor: bg,
-        borderColor: bg
-      };
-    }
-
-    return {
-      borderColor: Color__default["default"].offBlack64,
-      color: Color__default["default"].offBlack64
-    };
+FocusRing.defaultProps = {
+  visible: true,
+  color: kaGreen$1,
+  multipleSelect: false
+};
+const styles$y = aphrodite.StyleSheet.create({
+  ring: {
+    margin: "auto",
+    display: "inline-block",
+    borderWidth: 2,
+    padding: 2,
+    borderStyle: "solid"
   }
+});
 
-  render() {
-    const {
-      a11yText,
-      checked,
-      crossedOut,
-      showCorrectness,
-      correct,
-      focused,
-      primaryProductColor,
-      previouslyAnswered
-    } = this.props;
-    const dynamicStyles = this.getDynamicStyles();
-    return /*#__PURE__*/React__namespace.createElement("div", {
-      className: aphrodite.css(styles$t.iconWrapper)
-    }, /*#__PURE__*/React__namespace.createElement(FocusRing, {
-      color: primaryProductColor,
-      visible: focused
-    }, /*#__PURE__*/React__namespace.createElement("div", {
-      style: dynamicStyles,
-      className: aphrodite.css(styles$t.libraryCircle, showCorrectness && correct && styles$t.libraryCircleCorrect, showCorrectness && !correct && styles$t.libraryCircleIncorrect, showCorrectness && !correct && (checked || previouslyAnswered) && styles$t.libraryCircleIncorrectAnswered) // used in BaseRadio to check if we actually clicked on the
-      // radio icon
-      ,
-      "data-is-radio-icon": true
-    }, /*#__PURE__*/React__namespace.createElement("div", {
-      className: "perseus-sr-only"
-    }, a11yText), /*#__PURE__*/React__namespace.createElement("div", {
-      "aria-hidden": true
-    }, this.getChoiceInner()))), crossedOut && /*#__PURE__*/React__namespace.createElement(CrossOutLine, {
-      color: dynamicStyles.borderColor
-    }));
+const SAT_ICON_SIZE = 25;
+const LIBRARY_ICON_SIZE = 24;
+const styles$x = aphrodite.StyleSheet.create({
+  iconWrapper: {
+    display: "inline-block",
+    position: "relative"
   }
+});
 
-} // The "cross-out line" SVG is a bit bigger than the library icon, to provide
+/* Component for rendering a letter icon in radio choice */
 // extra space for the cute rounded line cap.
 
-
 const CROSS_OUT_LINE_PADDING = 2;
 const CROSS_OUT_LINE_SIZE = LIBRARY_ICON_SIZE + CROSS_OUT_LINE_PADDING * 2;
 const SAT_CROSS_OUT_LINE_SIZE = SAT_ICON_SIZE + CROSS_OUT_LINE_PADDING * 2;
@@ -24570,7 +24380,7 @@ function CrossOutLine(props) {
     width: crossOutLineSize,
     height: crossOutLineSize,
     viewBox: "0 0 ".concat(crossOutLineSize, " ").concat(crossOutLineSize),
-    className: aphrodite.css(styles$t.crossOutLine)
+    className: aphrodite.css(styles$w.crossOutLine)
   }, /*#__PURE__*/React__namespace.createElement("line", {
     // The line stretches from the bottom-left to top-right.
     // We don't quite go to the _very_ corner, because the cute
@@ -24585,151 +24395,129 @@ function CrossOutLine(props) {
   }));
 }
 
-class ChoiceIcon extends React__namespace.Component {
-  a11yText(letter) {
-    const {
-      checked,
-      correct,
-      crossedOut,
-      showCorrectness
-    } = this.props; // There are two pieces of metadata we want to add to each a11yText:
-    // whether the answer was checked/crossed-out/neither, and whether the
-    // answer is correct/incorrect/not-yet-revealed.
-    //
-    // Translation is tricky for cross-product situations like this, so
-    // we've just enumerated all 9 possibilities as separate strings.
-
-    if (showCorrectness && correct) {
-      if (checked) {
-        return i18n__namespace._("(Choice %(letter)s, Checked, Correct)", {
-          letter
-        });
-      }
-
-      if (crossedOut) {
-        return i18n__namespace._("(Choice %(letter)s, Crossed out, Correct)", {
-          letter
-        });
-      }
+const styles$w = aphrodite.StyleSheet.create({
+  crossOutLine: {
+    // Center the icon within the container.
+    position: "absolute",
+    top: "calc(50% - ".concat(CROSS_OUT_LINE_SIZE / 2, "px)"),
+    left: "calc(50% - ".concat(CROSS_OUT_LINE_SIZE / 2, "px)")
+  }
+});
 
-      return i18n__namespace._("(Choice %(letter)s, Correct)", {
-        letter
-      });
-    }
+function ChoiceInner(props) {
+  const {
+    letter,
+    showCorrectness,
+    correct
+  } = props;
 
-    if (showCorrectness && !correct) {
-      if (checked) {
-        return i18n__namespace._("(Choice %(letter)s, Checked, Incorrect)", {
-          letter
-        });
-      }
+  if (!showCorrectness) {
+    return letter;
+  }
 
-      if (crossedOut) {
-        return i18n__namespace._("(Choice %(letter)s, Crossed out, Incorrect)", {
-          letter
-        });
+  if (correct) {
+    return /*#__PURE__*/React__namespace.createElement(InlineIcon, _extends({}, iconCheck, {
+      style: {
+        position: "relative",
+        top: -1
       }
-
-      return i18n__namespace._("(Choice %(letter)s, Incorrect)", {
-        letter
-      });
-    }
-
-    if (checked) {
-      return i18n__namespace._("(Choice %(letter)s, Checked)", {
-        letter
-      });
-    }
-
-    if (crossedOut) {
-      return i18n__namespace._("(Choice %(letter)s, Crossed out)", {
-        letter
-      });
-    }
-
-    return i18n__namespace._("(Choice %(letter)s)", {
-      letter
-    });
+    }));
   }
 
-  render() {
-    const {
-      pos,
-      reviewMode,
-      checked,
-      crossedOut,
-      correct,
-      product,
-      showCorrectness,
-      pressed,
-      focused,
-      primaryProductColor,
-      previouslyAnswered,
-      transparentBackground
-    } = this.props;
-    const letter = getChoiceLetter(pos);
+  return /*#__PURE__*/React__namespace.createElement(InlineIcon, iconMinus);
+} // Handle dynamic styling of the multiple choice icon. Most
+// MC icon styles are constant, but we do allow the caller
+// to specify the selected color, and thus must control styles
+// related to the selected state dynamically.
+
+
+function getDynamicStyles(checked, showCorrectness, pressed, multipleSelect, primaryProductColor, correct, transparentBackground) {
+  let backgroundColor;
+  let borderColor;
+  let color;
+
+  if (!showCorrectness && pressed) {
+    borderColor = primaryProductColor;
+    color = primaryProductColor;
+    backgroundColor = transparentBackground ? "transparent" : white$1;
+  } else if (checked) {
+    // Note: kaGreen is not only the default product color,
+    // but also the "correctness" color
+    const bg = showCorrectness && correct ? Color__default["default"].green : primaryProductColor;
+    color = white$1;
+    backgroundColor = bg;
+    borderColor = bg;
+  } else {
+    borderColor = Color__default["default"].offBlack64;
+    color = Color__default["default"].offBlack64;
+  } // define shape
 
-    if (product === "sat") {
-      return /*#__PURE__*/React__namespace.createElement(SATChoiceIcon, {
-        letter: letter,
-        a11yText: this.a11yText(letter),
-        reviewMode: reviewMode,
-        checked: checked,
-        correct: correct,
-        crossedOut: crossedOut
-      });
-    }
 
-    return /*#__PURE__*/React__namespace.createElement(LibraryChoiceIcon, {
-      letter: letter,
-      a11yText: this.a11yText(letter),
-      reviewMode: reviewMode,
-      checked: checked,
-      crossedOut: crossedOut,
-      pressed: pressed,
-      focused: focused,
-      correct: correct,
-      showCorrectness: showCorrectness,
-      primaryProductColor: primaryProductColor,
-      previouslyAnswered: previouslyAnswered,
-      transparentBackground: transparentBackground
-    });
+  let borderRadius;
+
+  if (multipleSelect) {
+    borderRadius = 3;
+  } else {
+    borderRadius = LIBRARY_ICON_SIZE;
   }
 
+  return {
+    backgroundColor,
+    borderColor,
+    color,
+    borderRadius
+  };
 }
 
-_defineProperty(ChoiceIcon, "defaultProps", {
-  primaryProductColor: Color__default["default"].blue
-});
+function LibraryChoiceIcon(props) {
+  const {
+    a11yText,
+    checked,
+    crossedOut,
+    showCorrectness,
+    correct,
+    focused,
+    hovered,
+    multipleSelect,
+    primaryProductColor,
+    previouslyAnswered,
+    letter,
+    pressed,
+    transparentBackground
+  } = props;
+  const dynamicStyles = getDynamicStyles(checked, showCorrectness, pressed, multipleSelect, primaryProductColor, correct, transparentBackground);
+  return /*#__PURE__*/React__namespace.createElement("div", {
+    className: aphrodite.css(styles$x.iconWrapper)
+  }, /*#__PURE__*/React__namespace.createElement(FocusRing, {
+    color: primaryProductColor,
+    visible: focused || hovered,
+    multipleSelect: multipleSelect
+  }, /*#__PURE__*/React__namespace.createElement("div", {
+    style: dynamicStyles,
+    "data-test-id": "choice-icon__library-choice-icon",
+    className: aphrodite.css(styles$v.circle, showCorrectness && correct && styles$v.circleCorrect, showCorrectness && !correct && styles$v.circleIncorrect, showCorrectness && !correct && (checked || previouslyAnswered) && styles$v.circleIncorrectAnswered) // used in BaseRadio to check if we actually clicked on the
+    // radio icon
+    ,
+    "data-is-radio-icon": true
+  }, /*#__PURE__*/React__namespace.createElement("div", {
+    className: "perseus-sr-only"
+  }, a11yText), /*#__PURE__*/React__namespace.createElement("div", {
+    "aria-hidden": true
+  }, /*#__PURE__*/React__namespace.createElement(ChoiceInner, {
+    letter: letter,
+    showCorrectness: showCorrectness,
+    correct: correct
+  })))), crossedOut && /*#__PURE__*/React__namespace.createElement(CrossOutLine, {
+    color: dynamicStyles.borderColor
+  }));
+}
 
-const styles$t = aphrodite.StyleSheet.create({
-  satCircle: {
-    display: "block",
-    borderRadius: SAT_ICON_SIZE,
-    borderStyle: "solid",
-    borderWidth: 2,
-    content: "''",
-    height: SAT_ICON_SIZE,
-    width: SAT_ICON_SIZE,
-    top: 1,
-    left: 1
-  },
-  iconWrapper: {
-    display: "inline-block",
-    position: "relative"
-  },
-  crossOutLine: {
-    // Center the icon within the container.
-    position: "absolute",
-    top: "calc(50% - ".concat(CROSS_OUT_LINE_SIZE / 2, "px)"),
-    left: "calc(50% - ".concat(CROSS_OUT_LINE_SIZE / 2, "px)")
-  },
-  libraryCircle: {
+const styles$v = aphrodite.StyleSheet.create({
+  circle: {
     // Make the circle
     width: LIBRARY_ICON_SIZE,
     height: LIBRARY_ICON_SIZE,
     boxSizing: "border-box",
-    borderRadius: LIBRARY_ICON_SIZE,
     borderStyle: "solid",
     borderWidth: 2,
     // The default icons have letters in them. Style those letters.
@@ -24750,18 +24538,113 @@ const styles$t = aphrodite.StyleSheet.create({
     // pixel so it is much better centered.
     lineHeight: "1px"
   },
-  libraryCircleCorrect: {
+  circleCorrect: {
     fontSize: LIBRARY_ICON_SIZE
   },
-  libraryCircleIncorrect: {
+  circleIncorrect: {
     fontSize: LIBRARY_ICON_SIZE,
     borderColor: gray68,
     color: gray68
   },
-  libraryCircleIncorrectAnswered: {
+  circleIncorrectAnswered: {
     backgroundColor: Color__default["default"].red,
     borderColor: Color__default["default"].red,
     color: Color__default["default"].white
+  }
+});
+
+/* Component for rendering a letter icon in a SAT radio choice */
+
+// TODO(amy): figure out a better scheme for specifying these
+// styles that isn't such a pain to grok. See some neat ideas
+// from MDR in https://phabricator.khanacademy.org/D35249.
+function constructSATStyles(reviewMode, correct, checked, multipleSelect) {
+  let backgroundColor;
+  let borderColor = satBlue;
+  let color = satBlue;
+
+  if (reviewMode) {
+    if (correct) {
+      borderColor = satCorrectColor;
+      color = checked ? white$1 : satCorrectColor;
+      backgroundColor = checked ? satCorrectColor : white$1;
+    } else if (checked) {
+      borderColor = satIncorrectColor;
+      color = white$1;
+      backgroundColor = satIncorrectColor;
+    }
+  } else if (checked) {
+    color = white$1;
+    backgroundColor = satBlue;
+  }
+
+  let borderRadius;
+
+  if (multipleSelect) {
+    borderRadius = 3;
+  } else {
+    borderRadius = SAT_ICON_SIZE;
+  }
+
+  return {
+    color,
+    backgroundColor,
+    borderColor,
+    borderRadius
+  };
+}
+
+function SATChoiceIcon(props) {
+  const {
+    letter,
+    a11yText,
+    crossedOut,
+    reviewMode,
+    correct,
+    checked,
+    multipleSelect
+  } = props;
+  const {
+    color,
+    backgroundColor,
+    borderColor,
+    borderRadius
+  } = constructSATStyles(reviewMode, correct, checked, multipleSelect);
+  return /*#__PURE__*/React__namespace.createElement("div", {
+    className: aphrodite.css(styles$x.iconWrapper)
+  }, /*#__PURE__*/React__namespace.createElement("div", {
+    className: aphrodite.css(styles$u.satCircle),
+    "data-test-id": "choice-icon__sat-choice-icon",
+    style: {
+      backgroundColor,
+      borderColor,
+      borderRadius
+    }
+  }), /*#__PURE__*/React__namespace.createElement("div", {
+    style: {
+      color
+    },
+    className: aphrodite.css(styles$u.letter)
+  }, /*#__PURE__*/React__namespace.createElement("span", {
+    className: "perseus-sr-only"
+  }, a11yText), /*#__PURE__*/React__namespace.createElement("span", {
+    "aria-hidden": "true"
+  }, letter)), crossedOut && /*#__PURE__*/React__namespace.createElement(CrossOutLine, {
+    color: borderColor,
+    sat: true
+  }));
+}
+
+const styles$u = aphrodite.StyleSheet.create({
+  satCircle: {
+    display: "block",
+    borderStyle: "solid",
+    borderWidth: 2,
+    content: "''",
+    height: SAT_ICON_SIZE,
+    width: SAT_ICON_SIZE,
+    top: 1,
+    left: 1
   },
   letter: {
     // These properties make sure that this element has the exact
@@ -24781,6 +24664,118 @@ const styles$t = aphrodite.StyleSheet.create({
   }
 });
 
+/* Component for rendering a letter icon in radio choice */
+
+function getA11yText(letter, checked, correct, crossedOut, showCorrectness) {
+  // There are two pieces of metadata we want to add to each a11yText:
+  // whether the answer was checked/crossed-out/neither, and whether the
+  // answer is correct/incorrect/not-yet-revealed.
+  //
+  // Translation is tricky for cross-product situations like this, so
+  // we've just enumerated all 9 possibilities as separate strings.
+  if (showCorrectness && correct) {
+    if (checked) {
+      return i18n__namespace._("(Choice %(letter)s, Checked, Correct)", {
+        letter
+      });
+    }
+
+    if (crossedOut) {
+      return i18n__namespace._("(Choice %(letter)s, Crossed out, Correct)", {
+        letter
+      });
+    }
+
+    return i18n__namespace._("(Choice %(letter)s, Correct)", {
+      letter
+    });
+  }
+
+  if (showCorrectness && !correct) {
+    if (checked) {
+      return i18n__namespace._("(Choice %(letter)s, Checked, Incorrect)", {
+        letter
+      });
+    }
+
+    if (crossedOut) {
+      return i18n__namespace._("(Choice %(letter)s, Crossed out, Incorrect)", {
+        letter
+      });
+    }
+
+    return i18n__namespace._("(Choice %(letter)s, Incorrect)", {
+      letter
+    });
+  }
+
+  if (checked) {
+    return i18n__namespace._("(Choice %(letter)s, Checked)", {
+      letter
+    });
+  }
+
+  if (crossedOut) {
+    return i18n__namespace._("(Choice %(letter)s, Crossed out)", {
+      letter
+    });
+  }
+
+  return i18n__namespace._("(Choice %(letter)s)", {
+    letter
+  });
+}
+
+function ChoiceIcon(props) {
+  const {
+    pos,
+    reviewMode,
+    checked,
+    crossedOut,
+    correct,
+    product,
+    multipleSelect,
+    showCorrectness,
+    focused,
+    hovered,
+    pressed,
+    primaryProductColor = Color__default["default"].blue,
+    previouslyAnswered,
+    transparentBackground
+  } = props;
+  const letter = getChoiceLetter(pos);
+  const a11yText = getA11yText(letter, checked, correct, crossedOut, showCorrectness);
+
+  if (product === "sat") {
+    return /*#__PURE__*/React__namespace.createElement(SATChoiceIcon, {
+      letter: letter,
+      a11yText: a11yText,
+      reviewMode: reviewMode,
+      checked: checked,
+      correct: correct,
+      crossedOut: crossedOut,
+      multipleSelect: multipleSelect
+    });
+  }
+
+  return /*#__PURE__*/React__namespace.createElement(LibraryChoiceIcon, {
+    letter: letter,
+    a11yText: a11yText,
+    reviewMode: reviewMode,
+    checked: checked,
+    crossedOut: crossedOut,
+    focused: focused,
+    hovered: hovered,
+    pressed: pressed,
+    correct: correct,
+    showCorrectness: showCorrectness,
+    primaryProductColor: primaryProductColor,
+    previouslyAnswered: previouslyAnswered,
+    transparentBackground: transparentBackground,
+    multipleSelect: multipleSelect
+  });
+}
+
 /**
  * Renders text indicating whether the choice was correct or
  * not and whether the choice was selected or not.
@@ -24789,63 +24784,68 @@ const styles$t = aphrodite.StyleSheet.create({
  * between the states more immediately clear to users.
  */
 
-class OptionStatus extends React__namespace.Component {
-  _renderText() {
-    const {
-      checked,
-      correct,
-      crossedOut
-    } = this.props;
+function renderText(checked, correct, crossedOut) {
+  if (correct) {
+    // For correct answers, we surface checked _or_ crossedOut state,
+    // because any interaction with the correct answer is noteworthy!
+    if (checked) {
+      return i18n__namespace._("Correct (selected)");
+    }
 
-    if (correct) {
-      // For correct answers, we surface checked _or_ crossedOut state,
-      // because any interaction with the correct answer is noteworthy!
-      if (checked) {
-        return i18n__namespace._("Correct (selected)");
-      }
+    if (crossedOut) {
+      return i18n__namespace._("Correct (but you crossed it out)");
+    }
 
-      if (crossedOut) {
-        return i18n__namespace._("Correct (but you crossed it out)");
-      }
+    return i18n__namespace._("Correct");
+  } // But, for incorrect answers, we only surface checked state,
+  // because crossing out an incorrect answer is not noteworthy.
 
-      return i18n__namespace._("Correct");
-    } // But, for incorrect answers, we only surface checked state,
-    // because crossing out an incorrect answer is not noteworthy.
 
+  if (checked) {
+    return i18n__namespace._("Incorrect (selected)");
+  }
 
-    if (checked) {
-      return i18n__namespace._("Incorrect (selected)");
-    }
+  return i18n__namespace._("Incorrect");
+}
 
-    return i18n__namespace._("Incorrect");
+function OptionStatus(props) {
+  const {
+    checked,
+    correct,
+    crossedOut,
+    previouslyAnswered,
+    reviewMode,
+    satStyling
+  } = props; // Option status is exclued for SAT
+
+  if (satStyling) {
+    return null;
+  } // Option status is shown only in review mode, or for incorrectly
+  // answered items.
+
+
+  if (!reviewMode && !previouslyAnswered) {
+    return null;
   }
 
-  render() {
-    const {
-      checked,
-      correct,
-      previouslyAnswered
-    } = this.props;
-    let textStyle;
+  let textStyle;
 
-    if (correct) {
-      textStyle = styles$s.correct;
+  if (correct) {
+    textStyle = styles$t.correct;
+  } else {
+    if (checked || previouslyAnswered) {
+      textStyle = styles$t.incorrectAnswered;
     } else {
-      if (checked || previouslyAnswered) {
-        textStyle = styles$s.incorrectAnswered;
-      } else {
-        textStyle = styles$s.incorrect;
-      }
+      textStyle = styles$t.incorrect;
     }
-
-    return /*#__PURE__*/React__namespace.createElement("div", {
-      className: aphrodite.css(styles$s.text, textStyle)
-    }, this._renderText());
   }
 
+  return /*#__PURE__*/React__namespace.createElement("div", {
+    className: aphrodite.css(styles$t.text, textStyle)
+  }, renderText(checked, correct, crossedOut));
 }
 
-const styles$s = aphrodite.StyleSheet.create({
+const styles$t = aphrodite.StyleSheet.create({
   text: {
     alignItems: "center",
     display: "flex",
@@ -24872,316 +24872,206 @@ const ellipsisHorizontalIcon = {
   height: 27.284
 };
 
-class Choice extends React__namespace.Component {
-  constructor() {
-    super(...arguments);
-
-    _defineProperty(this, "justFinishedTouch", void 0);
-
-    _defineProperty(this, "justFinishedTimeoutID", void 0);
-
-    _defineProperty(this, "_input", void 0);
-
-    _defineProperty(this, "state", {
-      isInputFocused: false,
-      isInputActive: false
-    });
-
-    _defineProperty(this, "inputRef", ref => {
-      this._input = ref;
-    });
-
-    _defineProperty(this, "renderOptionStatus", () => {
-      const {
-        correct,
-        checked,
-        crossedOut,
-        reviewMode,
-        previouslyAnswered
-      } = this.props; // Option status is exclued for SAT
-
-      if (this.props.apiOptions.satStyling) {
-        return null;
-      } // Option status is shown only in review mode, or for incorrectly
-      // answered items.
-
-
-      if (!reviewMode && !previouslyAnswered) {
-        return null;
-      }
-
-      return /*#__PURE__*/React__namespace.createElement(OptionStatus, {
-        checked: checked,
-        correct: correct,
-        crossedOut: crossedOut,
-        previouslyAnswered: previouslyAnswered
-      });
-    });
-
-    _defineProperty(this, "renderChoiceIcon", _ref => {
-      let {
-        isFocused,
-        isPressed
-      } = _ref;
-      const {
-        radioStyleVersion,
-        primaryProductColor
-      } = this.props.apiOptions.styling;
-      const finalStyles = typeof radioStyleVersion === "undefined" ? false : radioStyleVersion === "final";
-
-      if (!finalStyles && !this.props.apiOptions.satStyling) {
-        return null;
-      }
-
-      return /*#__PURE__*/React__namespace.createElement(ChoiceIcon, {
-        pos: this.props.pos,
-        correct: this.props.correct,
-        crossedOut: this.props.crossedOut,
-        pressed: isPressed,
-        focused: isFocused,
-        checked: this.props.checked,
-        showCorrectness: this.props.showCorrectness,
-        reviewMode: this.props.reviewMode,
-        product: this.props.apiOptions.satStyling ? "sat" : "library",
-        primaryProductColor: primaryProductColor,
-        previouslyAnswered: this.props.previouslyAnswered
-      });
-    });
+function Choice(props) {
+  const {
+    disabled,
+    checked,
+    content,
+    crossedOut,
+    showCorrectness,
+    multipleSelect,
+    onChange,
+    reviewMode,
+    correct,
+    apiOptions,
+    previouslyAnswered,
+    pos,
+    showRationale,
+    rationale,
+    forwardedRef
+  } = props;
+  const [isInputFocused, setIsInputFocused] = React.useState(false);
+  React.useEffect(() => {
+    if (isInputFocused && disabled) {
+      setIsInputFocused(false);
+    }
+  }, [disabled, isInputFocused, setIsInputFocused]); // Call `this.props.onChange` with the given values. Any keys that are not
+  // specified will be filled in with the current value. (For example, if
+  // `checked` is specified but `crossedOut` is not, then `crossedOut` will
+  // be filled in with `this.props.crossedOut`.)
+  //
+  // This enables us to use shorthand inside this component, while
+  // maintaining a consistent API for the parent.
 
-    _defineProperty(this, "_sendChange", newValues => {
-      var _newValues$checked, _newValues$crossedOut;
+  function sendChange(newValues) {
+    var _newValues$checked, _newValues$crossedOut;
 
-      const checked = (_newValues$checked = newValues.checked) !== null && _newValues$checked !== void 0 ? _newValues$checked : this.props.checked;
-      const crossedOut = (_newValues$crossedOut = newValues.crossedOut) !== null && _newValues$crossedOut !== void 0 ? _newValues$crossedOut : this.props.crossedOut;
-      this.props.onChange({
-        checked,
-        crossedOut
-      });
+    const updatedChecked = (_newValues$checked = newValues.checked) !== null && _newValues$checked !== void 0 ? _newValues$checked : checked;
+    const updatedCrossedOut = (_newValues$crossedOut = newValues.crossedOut) !== null && _newValues$crossedOut !== void 0 ? _newValues$crossedOut : crossedOut;
+    onChange({
+      checked: updatedChecked,
+      crossedOut: updatedCrossedOut
     });
+  } // HACK: while most of the styling for rendering SAT items is handled
+  // via aphrodite, we also need to assign normal CSS classnames here to
+  // special-case the coloring of MathJax formulas (see .MathJax .math in
+  // stylesheets/task-package/tasks.less)
 
-    _defineProperty(this, "focusInput", () => {
-      var _this$_input;
 
-      (_this$_input = this._input) === null || _this$_input === void 0 ? void 0 : _this$_input.focus();
-    });
-  }
+  const satCorrectChoice = apiOptions.satStyling && reviewMode && correct;
+  const satIncorrectChecked = apiOptions.satStyling && reviewMode && !correct && checked;
+  const descriptionClassName = classNames__default["default"]("description", satCorrectChoice && "sat-correct", satIncorrectChecked && "sat-incorrect", aphrodite.css(!apiOptions.satStyling && styles$s.description, apiOptions.satStyling && styles$s.satDescription, satCorrectChoice && styles$s.satDescriptionCorrect, satCorrectChoice && checked && styles$s.satDescriptionCorrectChecked, satIncorrectChecked && styles$s.satDescriptionIncorrectChecked));
+  const rationaleClassName = classNames__default["default"]("perseus-radio-rationale-content", aphrodite.css(styles$s.rationale, !apiOptions.satStyling && styles$s.nonSatRationale, apiOptions.satStyling && styles$s.satReviewRationale)); // We want to show the choices as dimmed out when the choices are
+  // disabled. However, we don't want to do this in the SAT product and
+  // we also don't want to do this when we're in review mode in the
+  // content library.
 
-  UNSAFE_componentWillUpdate(nextProps) {
-    if (this.state.isInputFocused && nextProps.disabled) {
-      this.setState({
-        isInputFocused: false
-      });
+  const showDimmed = !apiOptions.satStyling && !reviewMode && apiOptions.readOnly || crossedOut;
+  return /*#__PURE__*/React__namespace.createElement("div", {
+    style: {
+      dispay: "flex",
+      flexDirection: "column"
     }
-  }
+  }, /*#__PURE__*/React__namespace.createElement("div", {
+    style: {
+      display: "flex",
+      flexDirection: "row",
+      width: "100%",
+      opacity: showDimmed ? 0.5 : 1.0
+    }
+  }, /*#__PURE__*/React__namespace.createElement(Clickable__default["default"], {
+    onClick: () => {
+      // If we're checking a crossed-out option, let's
+      // also uncross it.
+      sendChange({
+        checked: !checked,
+        crossedOut: false
+      });
+    },
+    className: descriptionClassName,
+    disabled: disabled || apiOptions.staticRender || apiOptions.readOnly,
+    "aria-label": "Select Choice ".concat(getChoiceLetter(pos)),
+    "aria-checked": checked ? "true" : "false",
+    role: "checkbox",
+    style: {
+      flex: 1
+    },
+    ref: forwardedRef
+  }, _ref => {
+    var _apiOptions$styling;
 
-  render() {
-    const sat = this.props.apiOptions.satStyling;
-    const {
-      reviewMode,
-      correct,
-      checked
-    } = this.props; // HACK: while most of the styling for rendering SAT items is handled
-    // via aphrodite, we also need to assign normal CSS classnames here to
-    // special-case the coloring of MathJax formulas (see .MathJax .math in
-    // stylesheets/task-package/tasks.less)
-
-    const satCorrectChoice = sat && reviewMode && correct;
-    const satIncorrectChecked = sat && reviewMode && !correct && checked;
-    const descriptionClassName = classNames__default["default"]("description", satCorrectChoice && "sat-correct", satIncorrectChecked && "sat-incorrect", aphrodite.css(!sat && styles$r.description, sat && styles$r.satDescription, satCorrectChoice && styles$r.satDescriptionCorrect, satCorrectChoice && checked && styles$r.satDescriptionCorrectChecked, satIncorrectChecked && styles$r.satDescriptionIncorrectChecked));
-    const rationaleClassName = classNames__default["default"]("perseus-radio-rationale-content", aphrodite.css(styles$r.rationale, !sat && styles$r.nonSatRationale, sat && styles$r.satReviewRationale)); // We want to show the choices as dimmed out when the choices are
-    // disabled. However, we don't want to do this in the SAT product and
-    // we also don't want to do this when we're in review mode in the
-    // content library.
-
-    const showDimmed = !sat && !reviewMode && this.props.apiOptions.readOnly || this.props.crossedOut;
+    let {
+      hovered,
+      focused,
+      pressed
+    } = _ref;
     return /*#__PURE__*/React__namespace.createElement("div", {
-      style: {
-        dispay: "flex",
-        flexDirection: "column"
-      }
-    }, /*#__PURE__*/React__namespace.createElement("div", {
       style: {
         display: "flex",
         flexDirection: "row",
-        width: "100%",
-        opacity: showDimmed ? 0.5 : 1.0
+        justifyContent: "center",
+        alignContent: "center",
+        paddingTop: Spacing__default["default"].xSmall_8,
+        paddingBottom: Spacing__default["default"].xSmall_8
       }
-    }, /*#__PURE__*/React__namespace.createElement(Clickable__default["default"], {
-      onClick: () => {
-        // If we're checking a crossed-out option, let's
-        // also uncross it.
-        this._sendChange({
-          checked: true,
-          crossedOut: false
-        });
-      },
-      className: descriptionClassName,
-      disabled: this.props.disabled || this.props.apiOptions.staticRender || this.props.apiOptions.readOnly,
-      "aria-label": "Select Choice ".concat(getChoiceLetter(this.props.pos)),
-      "aria-checked": this.props.checked,
-      role: "checkbox",
+    }, /*#__PURE__*/React__namespace.createElement(ChoiceIcon, {
+      pos: pos,
+      correct: correct,
+      crossedOut: crossedOut,
+      pressed: pressed,
+      focused: focused,
+      checked: checked,
+      hovered: hovered,
+      showCorrectness: showCorrectness,
+      multipleSelect: multipleSelect,
+      reviewMode: reviewMode,
+      product: apiOptions.satStyling ? "sat" : "library",
+      primaryProductColor: (_apiOptions$styling = apiOptions.styling) === null || _apiOptions$styling === void 0 ? void 0 : _apiOptions$styling.primaryProductColor,
+      previouslyAnswered: previouslyAnswered
+    }), /*#__PURE__*/React__namespace.createElement("span", {
       style: {
-        flex: 1
+        paddingLeft: Spacing__default["default"].small_12,
+        textAlign: "left",
+        flex: 1,
+        paddingTop: 4
       }
-    }, _ref2 => {
+    }, /*#__PURE__*/React__namespace.createElement("div", null, /*#__PURE__*/React__namespace.createElement(OptionStatus, {
+      checked: checked,
+      correct: correct,
+      crossedOut: crossedOut,
+      previouslyAnswered: previouslyAnswered,
+      reviewMode: reviewMode,
+      satStyling: apiOptions.satStyling
+    })), /*#__PURE__*/React__namespace.createElement("div", null, content)));
+  }), apiOptions.crossOutEnabled && !reviewMode && /*#__PURE__*/React__namespace.createElement(wonderBlocksPopover.Popover, {
+    dismissEnabled: true,
+    content: _ref2 => {
       let {
-        hovered,
-        focused,
-        pressed
+        close
       } = _ref2;
-      return /*#__PURE__*/React__namespace.createElement("div", {
-        style: {
-          display: "flex",
-          flexDirection: "row",
-          justifyContent: "center",
-          alignContent: "center",
-          paddingTop: Spacing__default["default"].xSmall_8,
-          paddingBottom: Spacing__default["default"].xSmall_8
-        }
-      }, /*#__PURE__*/React__namespace.createElement("span", null, this.renderChoiceIcon({
-        isFocused: focused,
-        isPressed: pressed
-      })), /*#__PURE__*/React__namespace.createElement("span", {
-        style: {
-          paddingLeft: Spacing__default["default"].small_12,
-          textAlign: "left",
-          flex: 1,
-          paddingTop: 4
-        }
-      }, /*#__PURE__*/React__namespace.createElement("div", null, this.renderOptionStatus()), /*#__PURE__*/React__namespace.createElement("div", null, this.props.content)));
-    }), this.props.apiOptions.crossOutEnabled && !reviewMode && /*#__PURE__*/React__namespace.createElement(wonderBlocksPopover.Popover, {
-      dismissEnabled: true,
-      content: _ref3 => {
-        let {
-          close
-        } = _ref3;
-        return /*#__PURE__*/React__namespace.createElement(wonderBlocksPopover.PopoverContent, {
-          title: "Cross out",
-          content: "Cross out option",
-          closeButtonVisible: true,
-          actions: /*#__PURE__*/React__namespace.createElement(wonderBlocksCore.View, null, /*#__PURE__*/React__namespace.createElement(wonderBlocksLayout.Strut, {
-            size: Spacing__default["default"].medium_16
-          }), /*#__PURE__*/React__namespace.createElement(Button__default["default"], {
-            kind: "primary",
-            "aria-label": "Cross out Choice ".concat(getChoiceLetter(this.props.pos)),
-            disabled: this.props.apiOptions.readOnly || reviewMode,
-            onClick: () => {
-              if (!this.props.crossedOut) {
-                // If we're crossing
-                // out a checked
-                // option, let's also
-                // uncheck it.
-                this._sendChange({
-                  checked: false,
-                  crossedOut: true
-                });
-              } else {
-                this._sendChange({
-                  crossedOut: false
-                });
-              }
-
-              close();
+      return /*#__PURE__*/React__namespace.createElement(wonderBlocksPopover.PopoverContent, {
+        title: "Cross out",
+        content: "Cross out option",
+        closeButtonVisible: true,
+        actions: /*#__PURE__*/React__namespace.createElement(wonderBlocksCore.View, null, /*#__PURE__*/React__namespace.createElement(wonderBlocksLayout.Strut, {
+          size: Spacing__default["default"].medium_16
+        }), /*#__PURE__*/React__namespace.createElement(Button__default["default"], {
+          kind: "primary",
+          "aria-label": "Cross out Choice ".concat(getChoiceLetter(pos)),
+          disabled: apiOptions.readOnly || reviewMode,
+          onClick: () => {
+            if (!crossedOut) {
+              // If we're crossing
+              // out a checked
+              // option, let's also
+              // uncheck it.
+              sendChange({
+                checked: false,
+                crossedOut: true
+              });
+            } else {
+              sendChange({
+                crossedOut: false
+              });
             }
-          }, this.props.crossedOut ? "Bring back" : "Cross out"))
-        });
-      }
+
+            close();
+          }
+        }, crossedOut ? "Bring back" : "Cross out"))
+      });
+    }
+  }, _ref3 => {
+    let {
+      open
+    } = _ref3;
+    return /*#__PURE__*/React__namespace.createElement(Clickable__default["default"], {
+      onClick: open,
+      "aria-label": "Open menu for Choice ".concat(getChoiceLetter(pos)),
+      disabled: apiOptions.staticRender
     }, _ref4 => {
-      let {
-        open
-      } = _ref4;
-      return /*#__PURE__*/React__namespace.createElement(Clickable__default["default"], {
-        onClick: open,
-        "aria-label": "Open menu for Choice ".concat(getChoiceLetter(this.props.pos)),
-        disabled: this.props.apiOptions.staticRender
-      }, _ref5 => {
-        return /*#__PURE__*/React__namespace.createElement(Icon, {
-          icon: ellipsisHorizontalIcon,
-          size: 3,
-          color: Color__default["default"].offBlack64
-        });
+      return /*#__PURE__*/React__namespace.createElement(Icon, {
+        icon: ellipsisHorizontalIcon,
+        size: 3,
+        color: Color__default["default"].offBlack64
       });
-    })), this.props.showRationale && /*#__PURE__*/React__namespace.createElement("div", {
-      className: rationaleClassName,
-      "data-test-id": "perseus-radio-rationale-content-".concat(this.props.pos)
-    }, this.props.rationale));
-  }
-
+    });
+  })), showRationale && /*#__PURE__*/React__namespace.createElement("div", {
+    className: rationaleClassName,
+    "data-test-id": "perseus-radio-rationale-content-".concat(pos)
+  }, rationale));
 }
 
-_defineProperty(Choice, "propTypes", {
-  // TODO(kevinb) use Options.propTypes from perseus-api.jsx
-  // This change will also require make sure that item-renderer.jsx and
-  // server-item-renderer.jsx have appropriate defaults for apiOptions
-  // because many of the properties on Options.propTypes are required.
-  apiOptions: PropTypes__default["default"].shape({
-    satStyling: PropTypes__default["default"].bool,
-    isMobile: PropTypes__default["default"].bool,
-    styling: PropTypes__default["default"].shape({
-      radioStyleVersion: PropTypes__default["default"].oneOf(["intermediate", "final"]),
-      primaryProductColor: PropTypes__default["default"].string
-    }),
-    readOnly: PropTypes__default["default"].bool
-  }),
-  checked: PropTypes__default["default"].bool,
-  className: PropTypes__default["default"].string,
-  rationale: PropTypes__default["default"].node,
-  content: PropTypes__default["default"].node,
-  correct: PropTypes__default["default"].bool,
-  deselectEnabled: PropTypes__default["default"].bool,
-  disabled: PropTypes__default["default"].bool,
-  editMode: PropTypes__default["default"].bool,
-  groupName: PropTypes__default["default"].string,
-  isLastChoice: PropTypes__default["default"].bool,
-  // Needed for border styling
-  // This indicates the position of the choice relative to others
-  // (so that we can display a nice little (A), (B), etc. next to it)
-  // Also used to generate an id for each input.
-  pos: PropTypes__default["default"].number,
-  reviewMode: PropTypes__default["default"].bool,
-  showRationale: PropTypes__default["default"].bool,
-  showCorrectness: PropTypes__default["default"].bool,
-  type: PropTypes__default["default"].string,
-  // Indicates whether the user has "crossed out" this choice, meaning
-  // that they don't think it's correct. This value does not affect
-  // scoring or other behavior; it's just a note for the user's
-  // reference.
-  crossedOut: PropTypes__default["default"].bool,
-  // Indicates that the user has previously selected this answer. These
-  // answers may be rendered orange in review, rather than grey if
-  // incorrect.
-  previouslyAnswered: PropTypes__default["default"].bool,
-  // A callback indicating that this choice has changed. Its argument is
-  // an object with two keys: `checked` and `crossedOut`. Each contains a
-  // boolean value specifying the new checked and crossed-out value of
-  // this choice.
-  onChange: PropTypes__default["default"].func,
-  // Callbacks for when the user presses the up arrow or down arrow
-  // (respectively) to navigate between choices. When called, the parent
-  // finds the prev/next choice, focuses the input, and checks the radio
-  // button if appropriate. (The reason we have custom behavior is that
-  // we actually _don't_ want to auto-select crossed-out choices!)
-  goToPrevChoice: PropTypes__default["default"].func.isRequired,
-  goToNextChoice: PropTypes__default["default"].func.isRequired
-});
-
-_defineProperty(Choice, "defaultProps", {
-  apiOptions: {
-    styling: {}
-  },
+Choice.defaultProps = {
+  disabled: false,
   checked: false,
-  classSet: {},
+  onChange: newValues => {},
   correct: false,
-  disabled: false,
-  editMode: false,
-  onChange: function () {},
-  showRationale: false,
-  type: "radio",
+  apiOptions: ApiOptions.defaults,
+  previouslyAnswered: false,
   pos: 0,
-  previouslyAnswered: false
-});
-
-const styles$r = aphrodite.StyleSheet.create({
+  showRationale: false
+};
+const styles$s = aphrodite.StyleSheet.create({
   description: {
     display: "inline-block",
     width: "100%"
@@ -25221,184 +25111,83 @@ const styles$r = aphrodite.StyleSheet.create({
     marginLeft: 45
   }
 });
+var Choice$1 = /*#__PURE__*/React__namespace.forwardRef((props, ref) => /*#__PURE__*/React__namespace.createElement(Choice, _extends({}, props, {
+  forwardedRef: ref
+})));
 
-class ChoiceNoneAbove extends React__namespace.Component {
-  constructor() {
-    super(...arguments);
-
-    _defineProperty(this, "_choice", void 0);
-
-    _defineProperty(this, "focusInput", () => {
-      this._choice.focusInput();
-    });
-  }
-
-  render() {
-    const choiceProps = { ...this.props,
-      className: classNames__default["default"](this.props.className, "none-of-above"),
-      content: this.props.showContent ? this.props.content :
-      /*#__PURE__*/
-      // We use a Renderer here because that is how
-      // `this.props.content` is wrapped otherwise.
-      // We pass in a key here so that we avoid a semi-spurious
-      // react warning when we render this in the same place
-      // as the previous choice content renderer.
-      // Note this destroys state, but since all we're doing
-      // is outputting "None of the above", that is okay.
-      React__namespace.createElement(Renderer, {
-        key: "noneOfTheAboveRenderer",
-        content: i18n__namespace._("None of the above")
-      }),
-      ref: el => this._choice = el
-    };
-    return /*#__PURE__*/React__namespace.createElement(Choice, choiceProps);
-  }
-
+function ChoiceNoneAbove(props) {
+  const {
+    showContent,
+    content,
+    forwardedRef,
+    ...rest
+  } = props;
+  const choiceProps = { ...rest,
+    content: showContent ? content :
+    /*#__PURE__*/
+    // We use a Renderer here because that is how
+    // `this.props.content` is wrapped otherwise.
+    // We pass in a key here so that we avoid a semi-spurious
+    // react warning when we render this in the same place
+    // as the previous choice content renderer.
+    // Note this destroys state, but since all we're doing
+    // is outputting "None of the above", that is okay.
+    //
+    // todo(matthewc): this seems like way overkill
+    // just to render a string
+    React__namespace.createElement(Renderer, {
+      key: "noneOfTheAboveRenderer",
+      content: i18n__namespace._("None of the above")
+    })
+  };
+  return /*#__PURE__*/React__namespace.createElement(Choice$1, _extends({}, choiceProps, {
+    ref: forwardedRef
+  }));
 }
 
-_defineProperty(ChoiceNoneAbove, "propTypes", {
-  className: PropTypes__default["default"].string,
-  content: PropTypes__default["default"].node,
-  showContent: PropTypes__default["default"].bool
-});
-
-_defineProperty(ChoiceNoneAbove, "defaultProps", {
+ChoiceNoneAbove.defaultProps = {
   showContent: true
-});
+};
+var ChoiceNoneAbove$1 = /*#__PURE__*/React__namespace.forwardRef((props, ref) => /*#__PURE__*/React__namespace.createElement(ChoiceNoneAbove, _extends({}, props, {
+  forwardedRef: ref
+})));
 
 const {
   captureScratchpadTouchStart: captureScratchpadTouchStart$2
-} = Util;
-const ChoicesType = PropTypes__default["default"].arrayOf(PropTypes__default["default"].shape({
-  // Indicates whether this choice is checked.
-  checked: PropTypes__default["default"].bool,
-  // Indicates whether the user has "crossed out" this choice, meaning
-  // that they don't think it's correct. This value does not affect
-  // scoring or other behavior; it's just a note for the user's
-  // reference.
-  crossedOut: PropTypes__default["default"].bool,
-  content: PropTypes__default["default"].node,
-  rationale: PropTypes__default["default"].node,
-  hasRationale: PropTypes__default["default"].bool,
-  showRationale: PropTypes__default["default"].bool,
-  showCorrectness: PropTypes__default["default"].bool,
-  correct: PropTypes__default["default"].bool,
-  originalIndex: PropTypes__default["default"].number,
-  isNoneOfTheAbove: PropTypes__default["default"].bool
-}));
-const radioBorderColor = radioBorderColor$2;
-
-class BaseRadio extends React__namespace.Component {
-  constructor() {
-    super(...arguments);
-
-    _defineProperty(this, "state", {
-      // TODO(mdr): This keeps the ID stable across re-renders on the
-      //     same machine, but, at time of writing, the server's state
-      //     isn't rehydrated to the client during SSR, so the server and
-      //     client will generate different IDs and cause a mismatch
-      //     during SSR :(
-      radioGroupName: ___default["default"].uniqueId("perseus_radio_")
-    });
-
-    _defineProperty(this, "updateChoice", (choiceIndex, newValues) => {
-      // Get the baseline `checked` values. If we're checking a new answer
-      // and multiple-select is not on, we should clear all choices to be
-      // unchecked. Otherwise, we should copy the old checked values.
-      let newCheckedList;
-
-      if (newValues.checked && !this.props.multipleSelect) {
-        newCheckedList = this.props.choices.map(_ => false);
-      } else {
-        newCheckedList = this.props.choices.map(c => c.checked);
-      } // Get the baseline `crossedOut` values.
+} = Util; // exported for tests
 
-
-      const newCrossedOutList = this.props.choices.map(c => c.crossedOut); // Update this choice's `checked` and `crossedOut` values.
-
-      newCheckedList[choiceIndex] = newValues.checked;
-      newCrossedOutList[choiceIndex] = newValues.crossedOut;
-      this.props.onChange({
-        checked: newCheckedList,
-        crossedOut: newCrossedOutList
+function getInstructionsText(multipleSelect, countChoices, numCorrect) {
+  if (multipleSelect) {
+    if (countChoices) {
+      return i18n__namespace._("Choose %(numCorrect)s answers:", {
+        numCorrect: numCorrect
       });
-    });
-
-    _defineProperty(this, "focus", i => {
-      // $FlowFixMe[incompatible-use]
-      // $FlowFixMe[prop-missing]
-      ReactDOM__default["default"].findDOMNode(this.refs["radio" + (i || 0)]).focus(); // eslint-disable-line react/no-string-refs
-
-      return true;
-    });
-
-    _defineProperty(this, "getInstructionsText", () => {
-      if (this.props.multipleSelect) {
-        if (this.props.countChoices) {
-          return i18n__namespace._("Choose %(numCorrect)s answers:", {
-            numCorrect: this.props.numCorrect
-          });
-        }
-
-        return i18n__namespace._("Choose all answers that apply:");
-      }
-
-      return i18n__namespace._("Choose 1 answer:");
-    });
-
-    _defineProperty(this, "deselectEnabled", () => {
-      // We want to force enable deselect on mobile.
-      return this.props.apiOptions.isMobile || this.props.deselectEnabled;
-    });
-
-    _defineProperty(this, "goToChoice", newChoiceIndex => {
-      const numChoices = this.props.choices.length; // Wrap the newChoiceIndex around the start/end, if necessary.
-
-      if (newChoiceIndex < 0) {
-        newChoiceIndex += numChoices;
-      }
-
-      if (newChoiceIndex >= numChoices) {
-        newChoiceIndex -= numChoices;
-      } // Focus the new choice's input element.
-      // eslint-disable-next-line react/no-string-refs
-
-
-      const choiceInstance = this.refs["radio".concat(newChoiceIndex)];
-
-      if (!choiceInstance) {
-        Log.error("found no choice at index ".concat(newChoiceIndex, ", even after ") + "wrapping it to be within bounds", Errors.Internal, {
-          loggedMetadata: {
-            choices: JSON.stringify(this.props.choices)
-          }
-        });
-        return;
-      }
-
-      choiceInstance.focusInput(); // We aren't going to change any choices' crossed-out state, but we
-      // _are_ going to deselect all choices.
-
-      const newCrossedOutList = this.props.choices.map(c => c.crossedOut);
-      const newCheckedList = this.props.choices.map(c => false); // And, if the new choice isn't crossed out, we'll select it.
-
-      if (!this.props.choices[newChoiceIndex].crossedOut) {
-        newCheckedList[newChoiceIndex] = true;
-      }
+    }
 
-      this.props.onChange({
-        checked: newCheckedList,
-        crossedOut: newCrossedOutList
-      });
-    });
+    return i18n__namespace._("Choose all answers that apply:");
   }
 
-  componentDidUpdate(prevProps) {
-    const {
-      apiOptions,
-      choices,
-      isLastUsedWidget,
-      reviewModeRubric
-    } = this.props; // Switching into review mode can sometimes cause the selected answer
+  return i18n__namespace._("Choose 1 answer:");
+}
+
+function BaseRadio(props) {
+  const {
+    apiOptions,
+    reviewModeRubric,
+    choices,
+    editMode,
+    multipleSelect,
+    labelWrap,
+    countChoices,
+    numCorrect,
+    isLastUsedWidget,
+    registerFocusFunction
+  } = props; // useEffect doesn't have previous props
+
+  const prevReviewModeRubric = React.useRef();
+  const choiceRefs = React.useRef([]);
+  React.useEffect(() => {
+    // Switching into review mode can sometimes cause the selected answer
     // to scroll out of view - for example, when we reveal all those tall
     // rationales. This can be disorienting for the user.
     //
@@ -25411,17 +25200,25 @@ class BaseRadio extends React__namespace.Component {
     // the most recently used widget (because, if the user has since
     // touched something else, they're probably not trying to keep their
     // eye on this widget anymore).
-
-    if (apiOptions.canScrollPage && isLastUsedWidget && reviewModeRubric && !prevProps.reviewModeRubric) {
+    if (apiOptions.canScrollPage && isLastUsedWidget && reviewModeRubric && !prevReviewModeRubric.current) {
       const checkedIndex = choices.findIndex(c => c.checked);
 
       if (checkedIndex >= 0) {
-        const checkedNode = ReactDOM__default["default"].findDOMNode( // eslint-disable-next-line react/no-string-refs
-        this.refs["radio" + checkedIndex]);
-        scrollElementIntoView(checkedNode);
+        const ref = choiceRefs.current[checkedIndex]; // note(matthew): we know this is only getting passed
+        // to a WB Clickable button, so we force it to be of
+        // type HTMLButtonElement
+
+        const anyNode = ReactDOM__default["default"].findDOMNode(ref.current);
+        const buttonNode = anyNode;
+
+        if (buttonNode) {
+          scrollElementIntoView(buttonNode);
+        }
       }
     }
-  } // When a particular choice's `onChange` handler is called, indicating a
+
+    prevReviewModeRubric.current = reviewModeRubric;
+  }, [apiOptions, choices, isLastUsedWidget, reviewModeRubric]); // When a particular choice's `onChange` handler is called, indicating a
   // change in a single choice's values, we need to call our `onChange`
   // handler in order to notify our parent. However, our API with our parent
   // is that we always provide *all* values for *all* choices, even if just
@@ -25430,181 +25227,196 @@ class BaseRadio extends React__namespace.Component {
   // will usually cause the old answer to become unchecked.)
   //
   // So, given the new values for a particular choice, compute the new values
-  // for all choices, and pass them to `this.props.onChange`.
+  // for all choices, and pass them to `onChange`.
   //
   // `newValues` is an object with two keys: `checked` and `crossedOut`. Each
   // contains a boolean value specifying the new checked and crossed-out
   // value of this choice.
 
+  function updateChoice(choiceIndex, newValues) {
+    const {
+      multipleSelect,
+      choices,
+      onChange
+    } = props; // Get the baseline `checked` values. If we're checking a new answer
+    // and multiple-select is not on, we should clear all choices to be
+    // unchecked. Otherwise, we should copy the old checked values.
 
-  render() {
-    const inputType = this.props.multipleSelect ? "checkbox" : "radio";
-    const rubric = this.props.reviewModeRubric;
-    const reviewMode = !!rubric;
-    const styles = BaseRadio.styles;
-    const sat = this.props.apiOptions.satStyling;
-    const isMobile = this.props.apiOptions.isMobile;
-    const choices = this.props.choices;
-    const firstChoiceHighlighted = choices[0].highlighted;
-    const lastChoiceHighlighted = choices[choices.length - 1].highlighted;
-    const className = classNames__default["default"]("perseus-widget-radio", !this.props.editMode && "perseus-rendered-radio", aphrodite.css(styles.radio, // SAT doesn't use the "responsive styling" as it conflicts
-    // with their custom theming.
-    !sat && styles.responsiveRadioContainer, !sat && firstChoiceHighlighted && isMobile && styles.radioContainerFirstHighlighted, !sat && lastChoiceHighlighted && isMobile && styles.radioContainerLastHighlighted, sat && styles.satRadio));
-    const instructionsClassName = classNames__default["default"]("instructions", aphrodite.css(styles.instructions, isMobile && styles.instructionsMobile));
-    const instructions = this.getInstructionsText();
-    const shouldShowInstructions = !sat;
-    const responsiveClassName = aphrodite.css(styles.responsiveFieldset);
-    const fieldset = /*#__PURE__*/React__namespace.createElement("fieldset", {
-      className: "perseus-widget-radio-fieldset ".concat(responsiveClassName)
-    }, /*#__PURE__*/React__namespace.createElement("legend", {
-      className: "perseus-sr-only"
-    }, instructions), shouldShowInstructions && /*#__PURE__*/React__namespace.createElement("div", {
-      className: instructionsClassName
-    }, instructions), /*#__PURE__*/React__namespace.createElement("ul", {
-      className: className,
-      style: {
-        listStyle: "none"
-      }
-    }, this.props.choices.map(function (choice, i) {
-      let Element = Choice;
-      const elementProps = {
-        ref: "radio".concat(i),
-        apiOptions: this.props.apiOptions,
-        checked: choice.checked,
-        crossedOut: choice.crossedOut,
-        previouslyAnswered: choice.previouslyAnswered,
-        reviewMode,
-        correct: choice.correct,
-        rationale: choice.rationale,
-        content: choice.content,
-        disabled: this.props.apiOptions.readOnly || choice.disabled,
-        editMode: this.props.editMode,
-        groupName: this.state.radioGroupName,
-        isLastChoice: i === this.props.choices.length - 1,
-        showCorrectness: reviewMode || !!choice.showCorrectness,
-        showRationale: choice.hasRationale && (reviewMode || choice.showRationale),
-        type: inputType,
-        pos: i,
-        deselectEnabled: this.deselectEnabled(),
-        onChange: newValues => {
-          this.updateChoice(i, newValues);
-        },
-        goToPrevChoice: () => this.goToChoice(i - 1),
-        goToNextChoice: () => this.goToChoice(i + 1)
-      };
+    let newCheckedList;
 
-      if (choice.isNoneOfTheAbove) {
-        Element = ChoiceNoneAbove;
+    if (newValues.checked && !multipleSelect) {
+      newCheckedList = choices.map(_ => false);
+    } else {
+      newCheckedList = choices.map(c => c.checked);
+    } // Get the baseline `crossedOut` values.
 
-        ___default["default"].extend(elementProps, {
-          showContent: choice.revealNoneOfTheAbove
-        });
-      }
 
-      const nextChoice = this.props.choices[i + 1];
-      const nextChoiceHighlighted = !!nextChoice && nextChoice.highlighted;
-
-      const aphroditeClassName = checked => {
-        // Whether or not to show correctness borders
-        // for this choice and the next choice.
-        const satShowCorrectness = sat && reviewMode && checked;
-        const satShowCorrectnessNext = sat && reviewMode && nextChoice && nextChoice.checked;
-        return aphrodite.css(sharedStyles.aboveScratchpad, styles.item, !sat && styles.responsiveItem, !sat && checked && styles.selectedItem, !sat && checked && choice.highlighted && styles.aboveBackdrop, !sat && checked && choice.highlighted && this.props.apiOptions.isMobile && styles.aboveBackdropMobile, !sat && nextChoiceHighlighted && this.props.apiOptions.isMobile && styles.nextHighlighted, sat && styles.satRadioOption, satShowCorrectness && !choice.correct && styles.satRadioOptionIncorrect, satShowCorrectness && choice.correct && styles.satRadioOptionCorrect, satShowCorrectnessNext && !nextChoice.correct && styles.satRadioOptionNextIncorrect, satShowCorrectnessNext && nextChoice.correct && styles.satRadioOptionNextCorrect, sat && rubric && styles.satReviewRadioOption);
-      }; // HACK(abdulrahman): Preloads the selection-state
-      // css because of a bug that causes iOS to lag
-      // when selecting the button for the first time.
-
-
-      aphroditeClassName(true);
-      const className = classNames__default["default"](aphroditeClassName(choice.checked), // TODO(aria): Make test case for these API
-      // classNames
-      ClassNames.RADIO.OPTION, choice.checked && ClassNames.RADIO.SELECTED, reviewMode && rubric.choices[i].correct && ClassNames.CORRECT, reviewMode && !rubric.choices[i].correct && ClassNames.INCORRECT); // In edit mode, the Choice renders a Div in order to
-      // allow for the contentEditable area to be selected
-      // (label forces any clicks inside to select the input
-      // element) We have to add some extra behavior to make
-      // sure that we can still check the choice.
-
-      let listElem = null;
-      let clickHandler = null;
-
-      if (this.props.editMode) {
-        clickHandler = e => {
-          // Traverse the parent nodes of the clicked
-          // element.
-          let elem = e.target;
-
-          while (elem && elem !== listElem) {
-            // If the clicked element is inside of the
-            // radio icon, then we want to trigger the
-            // check by flipping the choice of the icon.
-            if (elem.getAttribute("data-is-radio-icon")) {
-              this.updateChoice(i, {
-                checked: !choice.checked
-              });
-              return;
-            }
+    const newCrossedOutList = choices.map(c => c.crossedOut); // Update this choice's `checked` and `crossedOut` values.
+
+    newCheckedList[choiceIndex] = newValues.checked;
+    newCrossedOutList[choiceIndex] = newValues.crossedOut;
+    onChange({
+      checked: newCheckedList,
+      crossedOut: newCrossedOutList
+    });
+  } // register a callback with the parent that allows
+  // the parent to focus an individual choice
+
+
+  registerFocusFunction === null || registerFocusFunction === void 0 ? void 0 : registerFocusFunction(choiceIndex => {
+    const ref = choiceRefs.current[choiceIndex || 0]; // note(matthew): we know this is only getting passed
+    // to a WB Clickable button, so we force it to be of
+    // type HTMLButtonElement
+
+    const anyNode = ReactDOM__default["default"].findDOMNode(ref.current);
+    const buttonNode = anyNode;
+
+    if (buttonNode) {
+      buttonNode.focus();
+    } else {
+      return false;
+    }
+
+    return true;
+  }); // some commonly used shorthands
+
+  const reviewMode = !!reviewModeRubric;
+  const sat = apiOptions.satStyling;
+  const isMobile = apiOptions.isMobile;
+  const firstChoiceHighlighted = choices[0].highlighted;
+  const lastChoiceHighlighted = choices[choices.length - 1].highlighted;
+  const className = classNames__default["default"]("perseus-widget-radio", !editMode && "perseus-rendered-radio", aphrodite.css(styles$r.radio, // SAT doesn't use the "responsive styling" as it conflicts
+  // with their custom theming.
+  !sat && styles$r.responsiveRadioContainer, !sat && firstChoiceHighlighted && isMobile && styles$r.radioContainerFirstHighlighted, !sat && lastChoiceHighlighted && isMobile && styles$r.radioContainerLastHighlighted, sat && styles$r.satRadio));
+  const instructionsClassName = classNames__default["default"]("instructions", aphrodite.css(styles$r.instructions, isMobile && styles$r.instructionsMobile));
+  const instructions = getInstructionsText(multipleSelect, countChoices, numCorrect);
+  const shouldShowInstructions = !sat;
+  const responsiveClassName = aphrodite.css(styles$r.responsiveFieldset);
+  const fieldset = /*#__PURE__*/React__namespace.createElement("fieldset", {
+    className: "perseus-widget-radio-fieldset ".concat(responsiveClassName)
+  }, /*#__PURE__*/React__namespace.createElement("legend", {
+    className: "perseus-sr-only"
+  }, instructions), shouldShowInstructions && /*#__PURE__*/React__namespace.createElement("div", {
+    className: instructionsClassName
+  }, instructions), /*#__PURE__*/React__namespace.createElement("ul", {
+    className: className,
+    style: {
+      listStyle: "none"
+    }
+  }, choices.map(function (choice, i) {
+    let Element = Choice$1;
+    const ref = /*#__PURE__*/React__namespace.createRef();
+    choiceRefs.current[i] = ref;
+    const elementProps = {
+      apiOptions: apiOptions,
+      multipleSelect: multipleSelect,
+      checked: choice.checked,
+      crossedOut: choice.crossedOut,
+      previouslyAnswered: choice.previouslyAnswered,
+      reviewMode,
+      correct: choice.correct,
+      rationale: choice.rationale,
+      content: choice.content,
+      disabled: apiOptions.readOnly || choice.disabled,
+      showCorrectness: reviewMode || !!choice.showCorrectness,
+      showRationale: choice.hasRationale && (reviewMode || choice.showRationale),
+      pos: i,
+      onChange: newValues => {
+        updateChoice(i, newValues);
+      },
+      ref
+    };
 
-            elem = elem.parentNode;
+    if (choice.isNoneOfTheAbove) {
+      Element = ChoiceNoneAbove$1;
+
+      ___default["default"].extend(elementProps, {
+        showContent: choice.revealNoneOfTheAbove
+      });
+    }
+
+    const nextChoice = choices[i + 1];
+    const nextChoiceHighlighted = !!nextChoice && nextChoice.highlighted;
+
+    const aphroditeClassName = checked => {
+      // Whether or not to show correctness borders
+      // for this choice and the next choice.
+      const satShowCorrectness = sat && reviewMode && checked;
+      const satShowCorrectnessNext = sat && reviewMode && nextChoice && nextChoice.checked;
+      return aphrodite.css(sharedStyles.aboveScratchpad, styles$r.item, !sat && styles$r.responsiveItem, !sat && checked && styles$r.selectedItem, !sat && checked && choice.highlighted && styles$r.aboveBackdrop, !sat && checked && choice.highlighted && apiOptions.isMobile && styles$r.aboveBackdropMobile, !sat && nextChoiceHighlighted && apiOptions.isMobile && styles$r.nextHighlighted, sat && styles$r.satRadioOption, satShowCorrectness && !choice.correct && styles$r.satRadioOptionIncorrect, satShowCorrectness && choice.correct && styles$r.satRadioOptionCorrect, satShowCorrectnessNext && !nextChoice.correct && styles$r.satRadioOptionNextIncorrect, satShowCorrectnessNext && nextChoice.correct && styles$r.satRadioOptionNextCorrect, sat && reviewModeRubric && styles$r.satReviewRadioOption);
+    }; // HACK(abdulrahman): Preloads the selection-state
+    // css because of a bug that causes iOS to lag
+    // when selecting the button for the first time.
+
+
+    aphroditeClassName(true);
+    let correctnessClass; // reviewMode is only true if there's a rubric
+    // but Flow doesn't understand that
+
+    if (reviewMode && reviewModeRubric) {
+      correctnessClass = reviewModeRubric.choices[i].correct ? ClassNames.CORRECT : ClassNames.INCORRECT;
+    }
+
+    const className = classNames__default["default"](aphroditeClassName(choice.checked), // TODO(aria): Make test case for these API
+    // classNames
+    ClassNames.RADIO.OPTION, choice.checked && ClassNames.RADIO.SELECTED, correctnessClass); // In edit mode, the Choice renders a Div in order to
+    // allow for the contentEditable area to be selected
+    // (label forces any clicks inside to select the input
+    // element) We have to add some extra behavior to make
+    // sure that we can still check the choice.
+
+    let listElem = null;
+    let clickHandler = null;
+
+    if (editMode) {
+      clickHandler = e => {
+        // Traverse the parent nodes of the clicked
+        // element.
+        let elem = e.target;
+
+        while (elem && elem !== listElem) {
+          // If the clicked element is inside of the
+          // radio icon, then we want to trigger the
+          // check by flipping the choice of the icon.
+          if (elem.getAttribute("data-is-radio-icon")) {
+            this.updateChoice(i, {
+              checked: !choice.checked,
+              crossedOut: choice.crossedOut
+            });
+            return;
           }
-        };
-      } // TODO(mattdr): Index isn't a *good* choice of key
-      // here; is there a better one? Can we use choice
-      // content somehow? Would changing our choice of key
-      // somehow break something happening inside a choice's
-      // child Renderers, by changing when we mount/unmount?
 
+          elem = elem.parentNode;
+        }
+      };
+    } // TODO(mattdr): Index isn't a *good* choice of key
+    // here; is there a better one? Can we use choice
+    // content somehow? Would changing our choice of key
+    // somehow break something happening inside a choice's
+    // child Renderers, by changing when we mount/unmount?
 
-      return /*#__PURE__*/React__namespace.createElement("li", {
-        key: i,
-        ref: e => listElem = e,
-        className: className,
-        onClick: clickHandler,
-        onTouchStart: !this.props.labelWrap ? null : captureScratchpadTouchStart$2
-      }, /*#__PURE__*/React__namespace.createElement(Element, elementProps));
-    }, this))); // Allow for horizontal scrolling if content is too wide, which may be
-    // an issue especially on phones.
-    // This is disabled in SAT, since it conflicts with their theming.
 
-    return /*#__PURE__*/React__namespace.createElement("div", {
-      className: aphrodite.css(!sat && styles.responsiveContainer)
-    }, fieldset);
-  }
+    return /*#__PURE__*/React__namespace.createElement("li", {
+      key: i,
+      ref: e => listElem = e,
+      className: className,
+      onClick: clickHandler,
+      onTouchStart: !labelWrap ? null : captureScratchpadTouchStart$2
+    }, /*#__PURE__*/React__namespace.createElement(Element, elementProps));
+  }, this))); // Allow for horizontal scrolling if content is too wide, which may be
+  // an issue especially on phones.
+  // This is disabled in SAT, since it conflicts with their theming.
 
+  return /*#__PURE__*/React__namespace.createElement("div", {
+    className: aphrodite.css(!sat && styles$r.responsiveContainer)
+  }, fieldset);
 }
 
-_defineProperty(BaseRadio, "propTypes", {
-  apiOptions: PropTypes__default["default"].shape({
-    readOnly: PropTypes__default["default"].bool,
-    satStyling: PropTypes__default["default"].bool,
-    isMobile: PropTypes__default["default"].bool,
-    styling: PropTypes__default["default"].shape({
-      radioStyleVersion: PropTypes__default["default"].oneOf(["intermediate", "final"])
-    }),
-    canScrollPage: PropTypes__default["default"].bool
-  }),
-  choices: ChoicesType,
-  deselectEnabled: PropTypes__default["default"].bool,
-  editMode: PropTypes__default["default"].bool,
-  labelWrap: PropTypes__default["default"].bool,
-  countChoices: PropTypes__default["default"].bool,
-  numCorrect: PropTypes__default["default"].number,
-  multipleSelect: PropTypes__default["default"].bool,
-  reviewModeRubric: PropTypes__default["default"].shape({
-    choices: ChoicesType
-  }),
-  // A callback indicating that this choice has changed. Its argument is
-  // an object with two keys: `checked` and `crossedOut`. Each contains
-  // an array of boolean values, specifying the new checked and
-  // crossed-out value of each choice.
-  onChange: PropTypes__default["default"].func,
-  // Whether this widget was the most recently used widget in this
-  // Renderer. Determines whether we'll auto-scroll the page upon
-  // entering review mode.
-  isLastUsedWidget: PropTypes__default["default"].bool
-});
-
-_defineProperty(BaseRadio, "styles", aphrodite.StyleSheet.create({
-  // eslint-disable-next-line react-native/no-unused-styles
+BaseRadio.defaultProps = {
+  editMode: false,
+  multipleSelect: false
+};
+const styles$r = aphrodite.StyleSheet.create({
   instructions: {
     display: "block",
     color: gray17,
@@ -25614,7 +25426,6 @@ _defineProperty(BaseRadio, "styles", aphrodite.StyleSheet.create({
     fontWeight: "bold",
     marginBottom: 16
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   instructionsMobile: {
     fontSize: 18,
     [mediaQueries.smOrSmaller]: {
@@ -25628,36 +25439,30 @@ _defineProperty(BaseRadio, "styles", aphrodite.StyleSheet.create({
       fontSize: 20
     }
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   radio: {
     // Avoid centering
     width: "100%"
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   responsiveRadioContainer: {
-    borderBottom: "1px solid ".concat(radioBorderColor),
-    borderTop: "1px solid ".concat(radioBorderColor),
+    borderBottom: "1px solid ".concat(radioBorderColor$1),
+    borderTop: "1px solid ".concat(radioBorderColor$1),
     width: "auto",
     [mediaQueries.smOrSmaller]: {
       marginLeft: negativePhoneMargin,
       marginRight: negativePhoneMargin
     }
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   radioContainerFirstHighlighted: {
     borderTop: "1px solid rgba(0, 0, 0, 0)"
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   radioContainerLastHighlighted: {
     borderBottom: "1px solid rgba(0, 0, 0, 0)"
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   satRadio: {
     background: "none",
     marginLeft: 0,
     userSelect: "none"
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   satRadioOption: {
     margin: 0,
     padding: 0,
@@ -25666,57 +25471,40 @@ _defineProperty(BaseRadio, "styles", aphrodite.StyleSheet.create({
       borderTop: "1px solid #ccc"
     }
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   satRadioOptionCorrect: {
     borderBottomColor: satCorrectBorderColor,
     ":first-child": {
       borderTopColor: satCorrectBorderColor
     }
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   satRadioOptionIncorrect: {
     borderBottomColor: satIncorrectBorderColor,
     ":first-child": {
       borderTopColor: satIncorrectBorderColor
     }
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   satRadioOptionNextCorrect: {
     borderBottomColor: satCorrectBorderColor
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   satRadioOptionNextIncorrect: {
     borderBottomColor: satIncorrectBorderColor
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   satReviewRadioOption: {
     pointerEvents: "none"
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   item: {
     marginLeft: 20
   },
-  // eslint-disable-next-line react-native/no-unused-styles
-  inlineItem: {
-    display: "inline-block",
-    paddingLeft: 20,
-    verticalAlign: "middle" // See http://stackoverflow.com/q/8120466 for explanation of
-    // why vertical align property is needed
-
-  },
-  // eslint-disable-next-line react-native/no-unused-styles
   responsiveItem: {
     marginLeft: 0,
     padding: 0,
     ":not(:last-child)": {
-      borderBottom: "1px solid ".concat(radioBorderColor)
+      borderBottom: "1px solid ".concat(radioBorderColor$1)
     }
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   selectedItem: {
     background: "white"
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   aboveBackdrop: {
     position: "relative",
     // HACK(emily): We want selected choices to show up above our
@@ -25725,20 +25513,17 @@ _defineProperty(BaseRadio, "styles", aphrodite.StyleSheet.create({
     // coordinated between here and webapp. :(
     zIndex: 1062
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   aboveBackdropMobile: {
     boxShadow: "0 0 4px 0 rgba(0, 0, 0, 0.2)," + "0 0 2px 0 rgba(0, 0, 0, 0.1)",
     ":not(:last-child)": {
       borderBottom: "1px solid rgba(0, 0, 0, 0)"
     }
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   nextHighlighted: {
     ":not(:last-child)": {
       borderBottom: "1px solid rgba(0, 0, 0, 0)"
     }
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   responsiveContainer: {
     overflow: "auto",
     marginLeft: negativePhoneMargin,
@@ -25746,22 +25531,22 @@ _defineProperty(BaseRadio, "styles", aphrodite.StyleSheet.create({
     paddingLeft: phoneMargin // paddingRight is handled by responsiveFieldset
 
   },
-  // eslint-disable-next-line react-native/no-unused-styles
   responsiveFieldset: {
     paddingRight: phoneMargin
   }
-}));
-
-_defineProperty(BaseRadio, "defaultProps", {
-  editMode: false
 });
 
 class Radio$1 extends React__namespace.Component {
   constructor() {
+    var _this;
+
     super(...arguments);
+    _this = this;
+
+    _defineProperty(this, "focusFunction", void 0);
 
-    _defineProperty(this, "_renderRenderer", content => {
-      content = content || "";
+    _defineProperty(this, "_renderRenderer", function () {
+      let content = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
       let nextPassageRefId = 1;
       const widgets = {};
       const modContent = content.replace(/\{\{passage-ref (\d+) (\d+)(?: "([^"]*)")?\}\}/g, (match, passageNum, refNum, summaryText) => {
@@ -25793,19 +25578,14 @@ class Radio$1 extends React__namespace.Component {
         key: "choiceContentRenderer",
         content: modContent,
         widgets: widgets,
-        findExternalWidgets: this.props.findWidgets,
+        findExternalWidgets: _this.props.findWidgets,
         alwaysUpdate: true,
-        linterContext: { ...this.props.linterContext,
+        linterContext: { ..._this.props.linterContext,
           blockHighlight: true
         }
       });
     });
 
-    _defineProperty(this, "focus", i => {
-      // eslint-disable-next-line react/no-string-refs
-      return this.refs.baseRadio.focus(i);
-    });
-
     _defineProperty(this, "updateChoices", newValueLists => {
       const {
         choiceStates,
@@ -25816,25 +25596,18 @@ class Radio$1 extends React__namespace.Component {
       // should clone the old `choiceStates` objects, in preparation to
       // mutate them.
 
-      let newChoiceStates;
-
-      if (choiceStates) {
-        newChoiceStates = choiceStates.map(state => ({ ...state
-        }));
-      } else {
-        newChoiceStates = choices.map(() => ({
-          selected: false,
-          crossedOut: false,
-          highlighted: false,
-          rationaleShown: false,
-          correctnessShown: false,
-          previouslyAnswered: false,
-          readOnly: false
-        }));
-      } // Mutate the new `choiceState` objects, according to the new `checked`
+      const newChoiceStates = choiceStates ? choiceStates.map(state => ({ ...state
+      })) : choices.map(() => ({
+        selected: false,
+        crossedOut: false,
+        highlighted: false,
+        rationaleShown: false,
+        correctnessShown: false,
+        previouslyAnswered: false,
+        readOnly: false
+      })); // Mutate the new `choiceState` objects, according to the new `checked`
       // and `crossedOut` values provided in `newValueLists`.
 
-
       newChoiceStates.forEach((choiceState, i) => {
         choiceState.selected = newValueLists.checked[i];
         choiceState.crossedOut = newValueLists.crossedOut[i];
@@ -25898,14 +25671,47 @@ class Radio$1 extends React__namespace.Component {
     });
   }
 
+  // TODO(LP-10672): I think this might be unused right now. I can't find anywhere
+  // that we pass a value to `.focus()` and it seems to have been used for
+  // adding hints when editing.
+  // See: https://github.com/Khan/perseus/blame/e18582b4b69959270b90e237ef1813899711ddfa/src/widgets/radio.js#L169
+  focus(choiceIndex) {
+    if (this.focusFunction) {
+      return this.focusFunction(choiceIndex);
+    }
+
+    return false;
+  } // lets BaseRadio regiser a focus callback so widget
+  // can focus an individual choice
+
+
+  registerFocusFunction(fun) {
+    this.focusFunction = fun;
+  } // When `BaseRadio`'s `onChange` handler is called, indicating a change in
+  // our choices' state, we need to call our `onChange` handler in order to
+  // persist those changes in the item's Perseus state.
+  //
+  // So, given the new values for each choice, construct the new
+  // `choiceStates` objects, and pass them to `this.props.onChange`.
+  //
+  // `newValueLists` is an object with two keys: `checked` and `crossedOut`.
+  // Each contains an array of boolean values, specifying the new checked and
+  // crossed-out value of each choice.
+  //
+  // NOTE(mdr): This method expects to be auto-bound. If this component is
+  //     converted to an ES6 class, take care to auto-bind this method!
+
+
   render() {
-    let choices = this.props.choices;
+    const {
+      choices
+    } = this.props;
     let choiceStates;
 
     if (this.props.static) {
-      choiceStates = ___default["default"].map(choices, val => ({
-        selected: val.correct,
-        crossedOut: val.crossedOut,
+      choiceStates = choices.map(choice => ({
+        selected: !!choice.correct,
+        crossedOut: false,
         readOnly: true,
         highlighted: false,
         rationaleShown: true,
@@ -25913,12 +25719,12 @@ class Radio$1 extends React__namespace.Component {
         previouslyAnswered: false
       }));
     } else if (this.props.choiceStates) {
-      choiceStates = this.props.choiceStates; // $FlowFixMe[prop-missing]
+      choiceStates = this.props.choiceStates;
     } else if (this.props.values) {
       // Support legacy choiceStates implementation
 
       /* istanbul ignore next - props.values is deprecated */
-      choiceStates = ___default["default"].map(this.props.values, val => ({
+      choiceStates = this.props.values.map(val => ({
         selected: val,
         crossedOut: false,
         readOnly: false,
@@ -25928,7 +25734,7 @@ class Radio$1 extends React__namespace.Component {
         previouslyAnswered: false
       }));
     } else {
-      choiceStates = ___default["default"].map(choices, () => ({
+      choiceStates = choices.map(() => ({
         selected: false,
         crossedOut: false,
         readOnly: false,
@@ -25939,7 +25745,7 @@ class Radio$1 extends React__namespace.Component {
       }));
     }
 
-    choices = ___default["default"].map(choices, (choice, i) => {
+    const choicesProp = choices.map((choice, i) => {
       const content = choice.isNoneOfTheAbove && !choice.content ? // we use i18n._ instead of $_ here because the content
       // sent to a renderer needs to be a string, not a react
       // node (/renderable/fragment).
@@ -25967,37 +25773,36 @@ class Radio$1 extends React__namespace.Component {
         // TODO(emily): Come up with a more comprehensive way to solve
         // this sort of "serialized state breaks when internal
         // structure changes" problem.
-        correct: typeof choice.correct === "undefined" ? !!reviewChoice && reviewChoice.correct : choice.correct,
+        correct: choice.correct === undefined ? !!reviewChoice && !!reviewChoice.correct : choice.correct,
         disabled: readOnly,
         hasRationale: !!choice.clue,
         rationale: this._renderRenderer(choice.clue),
         showRationale: rationaleShown,
         showCorrectness: correctnessShown,
-        isNoneOfTheAbove: choice.isNoneOfTheAbove,
-        revealNoneOfTheAbove: this.props.questionCompleted && selected,
+        isNoneOfTheAbove: !!choice.isNoneOfTheAbove,
+        revealNoneOfTheAbove: !!(this.props.questionCompleted && selected),
         crossedOut,
         highlighted,
         previouslyAnswered: previouslyAnswered
       };
     });
-    return /*#__PURE__*/React__namespace.createElement(BaseRadio // eslint-disable-next-line react/no-string-refs
-    , {
-      ref: "baseRadio",
+    return /*#__PURE__*/React__namespace.createElement(BaseRadio, {
       labelWrap: true,
       multipleSelect: this.props.multipleSelect,
       countChoices: this.props.countChoices,
       numCorrect: this.props.numCorrect,
-      choices: choices,
+      choices: choicesProp,
       onChange: this.updateChoices,
       reviewModeRubric: this.props.reviewModeRubric,
       deselectEnabled: this.props.deselectEnabled,
       apiOptions: this.props.apiOptions,
-      isLastUsedWidget: this.props.isLastUsedWidget
+      isLastUsedWidget: this.props.isLastUsedWidget,
+      registerFocusFunction: i => this.registerFocusFunction(i)
     });
   }
 
   static validate(userInput, rubric) {
-    const numSelected = ___default["default"].reduce(userInput.choicesSelected, (sum, selected) => {
+    const numSelected = userInput.choicesSelected.reduce((sum, selected) => {
       return sum + (selected ? 1 : 0);
     }, 0);
 
@@ -26006,10 +25811,9 @@ class Radio$1 extends React__namespace.Component {
         type: "invalid",
         message: null
       };
-    } // $FlowFixMe[invalid-compare]
-
+    }
 
-    if (userInput.numCorrect > 1 && numSelected !== userInput.numCorrect) {
+    if (userInput.numCorrect && userInput.numCorrect > 1 && numSelected !== userInput.numCorrect) {
       return {
         type: "invalid",
         message: i18n__namespace._("Please choose the correct number of answers.")
@@ -26022,14 +25826,12 @@ class Radio$1 extends React__namespace.Component {
         message: i18n__namespace._("'None of the above' may not be selected " + "when other answers are selected.")
       };
     }
-    /* jshint -W018 */
-
 
-    const correct = ___default["default"].all(userInput.choicesSelected, (selected, i) => {
+    const correct = userInput.choicesSelected.every((selected, i) => {
       let isCorrect;
 
       if (userInput.noneOfTheAboveIndex === i) {
-        isCorrect = ___default["default"].all(rubric.choices, (choice, j) => {
+        isCorrect = rubric.choices.every((choice, j) => {
           return i === j || !choice.correct;
         });
       } else {
@@ -26038,9 +25840,6 @@ class Radio$1 extends React__namespace.Component {
 
       return isCorrect === selected;
     });
-    /* jshint +W018 */
-
-
     return {
       type: "points",
       earned: correct ? 1 : 0,
@@ -26062,9 +25861,7 @@ class Radio$1 extends React__namespace.Component {
       const numCorrect = props.numCorrect;
 
       for (let i = 0; i < choicesSelected.length; i++) {
-        // $FlowFixMe[prop-missing]
-        const index = props.choices[i].originalIndex; // $FlowFixMe[incompatible-use]
-
+        const index = props.choices[i].originalIndex;
         choicesSelected[index] = choiceStates[i].selected;
 
         if (props.choices[i].isNoneOfTheAbove) {
@@ -26085,31 +25882,35 @@ class Radio$1 extends React__namespace.Component {
       }; // Support legacy choiceState implementation
     }
     /* istanbul ignore if - props.values is deprecated */
-    // $FlowFixMe[prop-missing]
 
 
-    if (props.values) {
+    const {
+      values
+    } = props;
+
+    if (values) {
       let noneOfTheAboveIndex = null;
       let noneOfTheAboveSelected = false;
-      const values = props.values.slice();
+      const choicesSelected = [...values];
       const countChoices = props.countChoices;
       const numCorrect = props.numCorrect;
+      const valuesLength = values.length;
 
-      for (let i = 0; i < props.values.length; i++) {
+      for (let i = 0; i < valuesLength; i++) {
         const index = props.choices[i].originalIndex;
-        values[index] = props.values[i];
+        choicesSelected[index] = values[i];
 
         if (props.choices[i].isNoneOfTheAbove) {
           noneOfTheAboveIndex = index;
 
-          if (values[i]) {
+          if (choicesSelected[i]) {
             noneOfTheAboveSelected = true;
           }
         }
       }
 
       return {
-        choicesSelected: values,
+        choicesSelected,
         noneOfTheAboveIndex,
         noneOfTheAboveSelected,
         countChoices,
@@ -26119,15 +25920,14 @@ class Radio$1 extends React__namespace.Component {
 
 
     return {
-      choicesSelected: ___default["default"].map(props.choices, () => false)
+      choicesSelected: props.choices.map(() => false)
     };
   }
 
 }
 
 _defineProperty(Radio$1, "defaultProps", {
-  choices: [{}],
-  displayCount: null,
+  choices: [],
   multipleSelect: false,
   countChoices: false,
   deselectEnabled: false,
@@ -26158,14 +25958,14 @@ const _choiceTransform = (widgetOptions, problemNum) => {
 
   const _addNoneOfAbove = function (choices) {
     let noneOfTheAbove = null;
-
-    const newChoices = ___default["default"].reject(choices, function (choice, index) {
+    const newChoices = choices.filter((choice, index) => {
       if (choice.isNoneOfTheAbove) {
         noneOfTheAbove = choice;
-        return true;
+        return false;
       }
-    }); // Place the "None of the above" options last
 
+      return true;
+    }); // Place the "None of the above" options last
 
     if (noneOfTheAbove) {
       newChoices.push(noneOfTheAbove);
@@ -26185,12 +25985,11 @@ const _choiceTransform = (widgetOptions, problemNum) => {
   }; // Add meta-information to choices
 
 
-  let choices = widgetOptions.choices.slice();
-  choices = ___default["default"].map(choices, (choice, i) => {
-    return ___default["default"].extend({}, choice, {
+  const choices = widgetOptions.choices.map((choice, i) => {
+    return { ...choice,
       originalIndex: i,
       correct: Boolean(choice.correct)
-    });
+    };
   }); // Apply all the transforms. Note that the order we call these is
   // important!
   // 3) finally add "None of the above" to the bottom
@@ -40994,43 +40793,23 @@ const styles$9 = aphrodite.StyleSheet.create({
   }
 });
 
-const getLineHeightForNode = ($line1, $line2) => {
-  return $line2.offset().top - $line1.offset().top;
+const getLineHeightForNode = (line1, line2) => {
+  return $__default["default"](line2).offset().top - $__default["default"](line1).offset().top;
 };
 
-const START_REF_PREFIX = "start-ref-";
-const END_REF_PREFIX = "end-ref-";
-const REF_STYLE = {
-  display: "inline-block",
-  width: 0,
-  visibility: "hidden"
-};
-const LABEL_OUTER_STYLE = {
-  // for some reason we need these to keep the nbsp from wrapping when the
-  // inner circle/square is display: inline-block
-  display: "inline",
-  whiteSpace: "nowrap"
-};
-const SQUARE_LABEL_STYLE = {
-  display: "inline-block",
-  color: "rgb(255, 255, 255)",
-  backgroundColor: "rgb(90, 90, 90)",
-  paddingLeft: 10,
-  paddingRight: 10,
-  userSelect: "none",
-  WebkitUserSelect: "none"
-};
-const CIRCLE_LABEL_STYLE = {
-  display: "inline-block",
-  color: "rgb(255, 255, 255)",
-  backgroundColor: "rgb(90, 90, 90)",
-  userSelect: "none",
-  WebkitUserSelect: "none",
-  width: 22,
-  height: 22,
-  borderRadius: "50%",
-  textAlign: "center"
-};
+function getInitialParseState() {
+  return {
+    currentRef: [],
+    useRefs: true,
+    lastRef: 0,
+    firstSentenceRef: null,
+    firstQuestionRef: null,
+    lastFootnote: {
+      id: 0,
+      text: ""
+    }
+  };
+}
 
 class RefStart extends React__namespace.Component {
   constructor() {
@@ -41049,10 +40828,6 @@ class RefStart extends React__namespace.Component {
 
 }
 
-_defineProperty(RefStart, "propTypes", {
-  refContent: PropTypes__default["default"].node.isRequired
-});
-
 class RefEnd extends React__namespace.Component {
   render() {
     return /*#__PURE__*/React__namespace.createElement("span", {
@@ -41063,20 +40838,11 @@ class RefEnd extends React__namespace.Component {
 }
 
 const rules = {
-  // $FlowFixMe[prop-missing]
-  // $FlowFixMe[incompatible-use]
   newline: SimpleMarkdown__default["default"].defaultRules.newline,
-  // $FlowFixMe[prop-missing]
-  // $FlowFixMe[incompatible-use]
   paragraph: SimpleMarkdown__default["default"].defaultRules.paragraph,
-  // $FlowFixMe[prop-missing]
-  // $FlowFixMe[incompatible-use]
   escape: SimpleMarkdown__default["default"].defaultRules.escape,
   passageFootnote: {
-    // $FlowFixMe[prop-missing]
-    // $FlowFixMe[incompatible-use]
     order: SimpleMarkdown__default["default"].defaultRules.escape.order + 0.1,
-    // $FlowFixMe[prop-missing]
     match: SimpleMarkdown__default["default"].inlineRegex(/^\^/),
     parse: (capture, parse, state) => {
       // if no footnotes have been seen, we're id 1. otherwise,
@@ -41105,10 +40871,8 @@ const rules = {
     }
   },
   refStart: {
-    // $FlowFixMe[prop-missing]
-    // $FlowFixMe[incompatible-use]
     order: SimpleMarkdown__default["default"].defaultRules.escape.order + 0.2,
-    match: function (source, state) {
+    match: function (source) {
       const capture = /^\{\{/.exec(source);
 
       if (capture) {
@@ -41139,12 +40903,14 @@ const rules = {
           }
 
           closeIndex++;
-        }
-
-        const refText = source.slice(2, closeIndex); // A "magic" capture that matches the opening {{
+        } // A "magic" capture that matches the opening {{
         // but captures the full ref text internally :D
+        // unfortunately the "magic" makes Flow upset,
+        // so there's this questionable workaround
 
-        return [capture[0], refText];
+
+        capture[1] = source.slice(2, closeIndex);
+        return capture;
       }
 
       return null;
@@ -41167,33 +40933,34 @@ const rules = {
         // to make those refs into react refs on the
         // passage, for instance!
         useRefs: false
-      }, INITIAL_PARSE_STATE));
+      }, getInitialParseState()));
       return {
         ref: ref,
         refContent: refContent
       };
     },
     react: (node, output, state) => {
-      if (node.ref == null) {
+      const ref = node.ref;
+
+      if (ref == null) {
         return null;
       } // We don't pass state here because this is parsed
       // and output out-of-band. We don't want to affect
       // our state by the double-output here :).
 
 
-      const refContent = output(node.refContent, {});
+      const refContent = output(node.refContent, {}); // note(matthewc) the refs created here become the refs
+      // pulled from `this.refs` in passage.jsx
+
       return /*#__PURE__*/React__namespace.createElement(RefStart, {
-        ref: START_REF_PREFIX + node.ref,
-        key: START_REF_PREFIX + node.ref,
+        ref: START_REF_PREFIX + ref,
+        key: START_REF_PREFIX + ref,
         refContent: refContent
       });
     }
   },
   refEnd: {
-    // $FlowFixMe[prop-missing]
-    // $FlowFixMe[incompatible-use]
     order: SimpleMarkdown__default["default"].defaultRules.escape.order + 0.3,
-    // $FlowFixMe[prop-missing]
     match: SimpleMarkdown__default["default"].inlineRegex(/^\}\}/),
     parse: (capture, parse, state) => {
       if (!state.useRefs) {
@@ -41209,6 +40976,8 @@ const rules = {
     },
     react: (node, output, state) => {
       if (node.ref != null) {
+        // note(matthewc) the refs created here become the refs
+        // pulled from `this.refs` in passage.jsx
         return /*#__PURE__*/React__namespace.createElement(RefEnd, {
           ref: END_REF_PREFIX + node.ref,
           key: END_REF_PREFIX + node.ref
@@ -41222,10 +40991,7 @@ const rules = {
     }
   },
   squareLabel: {
-    // $FlowFixMe[prop-missing]
-    // $FlowFixMe[incompatible-use]
     order: SimpleMarkdown__default["default"].defaultRules.escape.order + 0.4,
-    // $FlowFixMe[prop-missing]
     match: SimpleMarkdown__default["default"].inlineRegex(/^\[\[(\w+)\]\]( *)/),
     parse: (capture, parse, state) => {
       if (!state.firstQuestionRef) {
@@ -41254,10 +41020,7 @@ const rules = {
     }
   },
   circleLabel: {
-    // $FlowFixMe[prop-missing]
-    // $FlowFixMe[incompatible-use]
     order: SimpleMarkdown__default["default"].defaultRules.escape.order + 0.5,
-    // $FlowFixMe[prop-missing]
     match: SimpleMarkdown__default["default"].inlineRegex(/^\(\((\w+)\)\)( *)/),
     parse: (capture, parse, state) => {
       return {
@@ -41282,10 +41045,7 @@ const rules = {
     }
   },
   squareBracketRef: {
-    // $FlowFixMe[prop-missing]
-    // $FlowFixMe[incompatible-use]
     order: SimpleMarkdown__default["default"].defaultRules.escape.order + 0.6,
-    // $FlowFixMe[prop-missing]
     match: SimpleMarkdown__default["default"].inlineRegex(/^\[(\d+)\]( *)/),
     parse: (capture, parse, state) => {
       if (!state.firstSentenceRef) {
@@ -41311,10 +41071,7 @@ const rules = {
     }
   },
   highlight: {
-    // $FlowFixMe[prop-missing]
-    // $FlowFixMe[incompatible-use]
     order: SimpleMarkdown__default["default"].defaultRules.escape.order + 0.7,
-    // $FlowFixMe[prop-missing]
     match: SimpleMarkdown__default["default"].inlineRegex(/^{highlighting.start}(.+?){highlighting.end}/),
     parse: (capture, parse, state) => {
       return {
@@ -41329,10 +41086,7 @@ const rules = {
     }
   },
   reviewHighlight: {
-    // $FlowFixMe[prop-missing]
-    // $FlowFixMe[incompatible-use]
     order: SimpleMarkdown__default["default"].defaultRules.escape.order + 0.7,
-    // $FlowFixMe[prop-missing]
     match: SimpleMarkdown__default["default"].inlineRegex(/^{review-highlighting.start}(.+?){review-highlighting.end}/),
     parse: (capture, parse, state) => {
       return {
@@ -41346,21 +41100,11 @@ const rules = {
       }, node.content)];
     }
   },
-  // $FlowFixMe[prop-missing]
-  // $FlowFixMe[incompatible-use]
   strong: SimpleMarkdown__default["default"].defaultRules.strong,
-  // $FlowFixMe[prop-missing]
-  // $FlowFixMe[incompatible-use]
   u: SimpleMarkdown__default["default"].defaultRules.u,
-  // $FlowFixMe[prop-missing]
-  // $FlowFixMe[incompatible-use]
   em: SimpleMarkdown__default["default"].defaultRules.em,
-  // $FlowFixMe[prop-missing]
-  // $FlowFixMe[incompatible-use]
   del: SimpleMarkdown__default["default"].defaultRules.del,
-  text: { // $FlowFixMe[prop-missing]
-    // $FlowFixMe[incompatible-use]
-    ...SimpleMarkdown__default["default"].defaultRules.text,
+  text: { ...SimpleMarkdown__default["default"].defaultRules.text,
 
     react(node, output, state) {
       return /*#__PURE__*/React__namespace.createElement("span", {
@@ -41370,32 +41114,54 @@ const rules = {
 
   }
 };
-const INITIAL_PARSE_STATE = {
-  currentRef: [],
-  useRefs: true,
-  lastRef: 0,
-  lastFootnote: {
-    id: 0,
-    text: ""
-  }
-}; // $FlowFixMe[prop-missing]
-
+const START_REF_PREFIX = "start-ref-";
+const END_REF_PREFIX = "end-ref-";
+const REF_STYLE = {
+  display: "inline-block",
+  width: 0,
+  visibility: "hidden"
+};
+const LABEL_OUTER_STYLE = {
+  // for some reason we need these to keep the nbsp from wrapping when the
+  // inner circle/square is display: inline-block
+  display: "inline",
+  whiteSpace: "nowrap"
+};
+const SQUARE_LABEL_STYLE = {
+  display: "inline-block",
+  color: "rgb(255, 255, 255)",
+  backgroundColor: "rgb(90, 90, 90)",
+  paddingLeft: 10,
+  paddingRight: 10,
+  userSelect: "none",
+  WebkitUserSelect: "none"
+};
+const CIRCLE_LABEL_STYLE = {
+  display: "inline-block",
+  color: "rgb(255, 255, 255)",
+  backgroundColor: "rgb(90, 90, 90)",
+  userSelect: "none",
+  WebkitUserSelect: "none",
+  width: 22,
+  height: 22,
+  borderRadius: "50%",
+  textAlign: "center"
+};
 const builtParser = SimpleMarkdown__default["default"].parserFor(rules);
 
 const parse = (source, state) => {
   state = state || {};
   const paragraphedSource = source + "\n\n";
-  return builtParser(paragraphedSource, ___default["default"].extend(state, INITIAL_PARSE_STATE));
+  return builtParser(paragraphedSource, ___default["default"].extend(state, getInitialParseState()));
 };
 
+const output = SimpleMarkdown__default["default"].reactFor(SimpleMarkdown__default["default"].ruleOutput(rules, "react"));
 var PassageMarkdown = {
-  parse: parse,
-  // $FlowFixMe[prop-missing]
-  output: SimpleMarkdown__default["default"].reactFor( // $FlowFixMe[prop-missing]
-  SimpleMarkdown__default["default"].ruleOutput(rules, "react")),
-  START_REF_PREFIX: START_REF_PREFIX,
-  END_REF_PREFIX: END_REF_PREFIX,
-  _rulesForTesting: rules
+  parse,
+  output,
+  START_REF_PREFIX,
+  END_REF_PREFIX,
+  getInitialParseState
 };
 
 // A fake paragraph to measure the line height of the passage. In CSS we always
@@ -41408,9 +41174,9 @@ class LineHeightMeasurer extends React__namespace.Component {
 
     _defineProperty(this, "_cachedLineHeight", void 0);
 
-    _defineProperty(this, "$body", void 0);
+    _defineProperty(this, "body", void 0);
 
-    _defineProperty(this, "$end", void 0);
+    _defineProperty(this, "end", void 0);
   }
 
   measureLineHeight() {
@@ -41422,23 +41188,30 @@ class LineHeightMeasurer extends React__namespace.Component {
   }
 
   forceMeasureLineHeight() {
-    // Add some text which magically fills an entire line.
-    this.$body.text(" \u0080"); // Now, the line height is the difference between the top of the
+    const body = this.body;
+    const end = this.end;
+
+    if (!body || !end) {
+      return;
+    } // Add some text which magically fills an entire line.
+
+
+    body.textContent = " \u0080"; // Now, the line height is the difference between the top of the
     // second line and the top of the first line.
 
-    this._cachedLineHeight = getLineHeightForNode(this.$body, this.$end); // Clear out the first line so it doesn't overlap the passage.
+    this._cachedLineHeight = getLineHeightForNode(body, end); // Clear out the first line so it doesn't overlap the passage.
 
-    this.$body.text("");
+    body.textContent = "";
   }
 
   render() {
     return /*#__PURE__*/React__namespace.createElement("div", {
       className: aphrodite.css(styles$8.measurer)
     }, /*#__PURE__*/React__namespace.createElement("div", null, /*#__PURE__*/React__namespace.createElement("div", {
-      ref: e => this.$body = $__default["default"](e),
+      ref: ref => this.body = ref,
       className: "paragraph"
     }), /*#__PURE__*/React__namespace.createElement("div", {
-      ref: e => this.$end = $__default["default"](e)
+      ref: ref => this.end = ref
     })));
   }
 
@@ -41457,9 +41230,11 @@ class Passage extends React__namespace.Component {
   constructor() {
     super(...arguments);
 
-    _defineProperty(this, "_onResize", void 0);
+    _defineProperty(this, "_contentRef", void 0);
 
-    _defineProperty(this, "_lineHeightMeasurer", void 0);
+    _defineProperty(this, "_lineHeightMeasurerRef", void 0);
+
+    _defineProperty(this, "_onResize", void 0);
 
     _defineProperty(this, "_stylesAppiedTimer", void 0);
 
@@ -41480,6 +41255,8 @@ class Passage extends React__namespace.Component {
     this._updateState();
 
     this._onResize = ___default["default"].throttle(() => {
+      var _this$_lineHeightMeas;
+
       // If we're rendering JIPT text, we won't have line numbers or a
       // line height measurer, so skip handling this resize.
       if (this.shouldRenderJipt()) {
@@ -41490,7 +41267,7 @@ class Passage extends React__namespace.Component {
       // listen for resize events.
 
 
-      this._lineHeightMeasurer.forceMeasureLineHeight();
+      (_this$_lineHeightMeas = this._lineHeightMeasurerRef) === null || _this$_lineHeightMeas === void 0 ? void 0 : _this$_lineHeightMeas.forceMeasureLineHeight();
 
       this._updateState();
     }, 500);
@@ -41553,9 +41330,8 @@ class Passage extends React__namespace.Component {
   }
 
   _measureLines() {
-    // eslint-disable-next-line react/no-string-refs
-    const $renderer = $__default["default"](ReactDOM__default["default"].findDOMNode(this.refs.content));
-    const contentsHeight = $renderer.height();
+    const renderer = ReactDOM__default["default"].findDOMNode(this._contentRef);
+    const contentsHeight = $__default["default"](renderer).height();
 
     const lineHeight = this._getLineHeight();
 
@@ -41582,7 +41358,9 @@ class Passage extends React__namespace.Component {
   }
 
   _getLineHeight() {
-    return this._lineHeightMeasurer.measureLineHeight();
+    var _this$_lineHeightMeas2;
+
+    return ((_this$_lineHeightMeas2 = this._lineHeightMeasurerRef) === null || _this$_lineHeightMeas2 === void 0 ? void 0 : _this$_lineHeightMeas2.measureLineHeight()) || 0;
   }
 
   getLineCount() {
@@ -41598,12 +41376,16 @@ class Passage extends React__namespace.Component {
    * These are functions to support the passage refs inter-widgets feature
    * where other widgets can fetch the line numbers of a reference inside of
    * a passage.
+   *
+   * todo(matthewc): The refs are created by PassageMarkdown's refStart and refEnd,
+   * somehow bubbling up to Passage's `this.refs`. This runs against
+   * current best practices for refs by using string refs, but also
+   * by breaking our expectation of explicit data flow.
    */
 
 
   _getStartRefLineNumber(referenceNumber) {
-    const refRef = PassageMarkdown.START_REF_PREFIX + referenceNumber; // eslint-disable-next-line react/no-string-refs
-
+    const refRef = PassageMarkdown.START_REF_PREFIX + referenceNumber;
     const ref = this.refs[refRef];
 
     if (!ref) {
@@ -41626,8 +41408,7 @@ class Passage extends React__namespace.Component {
   }
 
   _getEndRefLineNumber(referenceNumber) {
-    const refRef = PassageMarkdown.END_REF_PREFIX + referenceNumber; // eslint-disable-next-line react/no-string-refs
-
+    const refRef = PassageMarkdown.END_REF_PREFIX + referenceNumber;
     const ref = this.refs[refRef];
 
     if (!ref) {
@@ -41664,9 +41445,8 @@ class Passage extends React__namespace.Component {
   }
 
   _convertPosToLineNumber(absoluteVPos) {
-    // eslint-disable-next-line react/no-string-refs
-    const $content = $__default["default"](ReactDOM__default["default"].findDOMNode(this.refs.content));
-    const relativeVPos = absoluteVPos - $content.offset().top;
+    const content = ReactDOM__default["default"].findDOMNode(this._contentRef);
+    const relativeVPos = absoluteVPos - $__default["default"](content).offset().top;
 
     const lineHeight = this._getLineHeight();
 
@@ -41675,8 +41455,7 @@ class Passage extends React__namespace.Component {
   }
 
   _getRefContent(referenceNumber) {
-    const refRef = PassageMarkdown.START_REF_PREFIX + referenceNumber; // eslint-disable-next-line react/no-string-refs
-
+    const refRef = PassageMarkdown.START_REF_PREFIX + referenceNumber;
     const ref = this.refs[refRef];
 
     if (!ref) {
@@ -41782,12 +41561,9 @@ class Passage extends React__namespace.Component {
       onSerializedHighlightsUpdate: this._handleSerializedHighlightsUpdate,
       serializedHighlights: this.props.highlights
     }, /*#__PURE__*/React__namespace.createElement("div", {
-      ref: "content"
-    }, /*#__PURE__*/React__namespace.createElement(LineHeightMeasurer // TODO(mdr): We found a new Flow error when upgrading:
-    //     "e (null) This type is incompatible with this._lineHeightMeasurer (LineHeightMeasurer)"
-    // $FlowFixMe[incompatible-type](0.52.0->0.53.0)
-    , {
-      ref: e => this._lineHeightMeasurer = e
+      ref: ref => this._contentRef = ref
+    }, /*#__PURE__*/React__namespace.createElement(LineHeightMeasurer, {
+      ref: ref => this._lineHeightMeasurerRef = ref
     }), PassageMarkdown.output(parsed)));
   }
 
@@ -41830,10 +41606,7 @@ class Passage extends React__namespace.Component {
       });
     }
 
-    const parseState = {
-      firstSentenceRef: null,
-      firstQuestionRef: null
-    }; // Replace the vertical double quote characters quoting text with
+    const parseState = PassageMarkdown.getInitialParseState(); // Replace the vertical double quote characters quoting text with
     // an unicode left and right double quote characters. This would
     // avoid rendering right or left unicode double quotes on both
     // ends of a sentence wrapped by double quotes.