@khanacademy/perseus 51.0.1 → 52.0.1

package/dist/index.js

@@ -109,191 +109,6 @@ function _extends() {
  * The translated strings that are used to render Perseus.
  */
 
-/**
- * Untranslated strings used in Perseus. To be used by an external
- * translator to produce translated strings, passed in as `PerseusStrings`.
- * !! Note: Ensure that all escape sequences are double-escaped. (e.g. `\\text` -> `\\\\text`)
- */
-const strings = {
-  closeKeypad: "close math keypad",
-  openKeypad: "open math keypad",
-  mathInputBox: "Math input box",
-  removeHighlight: "Remove highlight",
-  addHighlight: "Add highlight",
-  hintPos: "Hint #%(pos)s",
-  errorRendering: "Error rendering: %(error)s",
-  APPROXIMATED_PI_ERROR: "Your answer is close, but you may " + "have approximated pi. Enter your " + "answer as a multiple of pi, like " + "12 pi or " + "2/3 pi",
-  EXTRA_SYMBOLS_ERROR: "We could not understand your " + "answer. Please check your answer for extra " + "text or symbols.",
-  NEEDS_TO_BE_SIMPLFIED_ERROR: "Your answer is almost correct, " + "but it needs to be simplified.",
-  MISSING_PERCENT_ERROR: "Your answer is almost correct, " + "but it is missing a " + "<code>\\\\%</code> at the end.",
-  MULTIPLICATION_SIGN_ERROR: "I'm a computer. I only understand " + "multiplication if you use an asterisk " + "(*) as the multiplication sign.",
-  WRONG_CASE_ERROR: "Your answer includes use of a variable with the wrong case.",
-  WRONG_LETTER_ERROR: "Your answer includes a wrong variable letter.",
-  invalidSelection: "Make sure you select something for every row.",
-  ERROR_TITLE: "Oops!",
-  ERROR_MESSAGE: "Sorry, I don't understand that!",
-  hints: "Hints",
-  getAnotherHint: "Get another hint",
-  deprecatedStandin: "Sorry, this part of the question is no longer available. 😅 Don't worry, you won't be graded on this part. Keep going!",
-  keepTrying: "Keep trying",
-  tryAgain: "Try again",
-  check: "Check",
-  correctExcited: "Correct!",
-  nextQuestion: "Next question",
-  skipToTitle: "Skip to %(title)s",
-  current: "Current",
-  correct: "Correct",
-  correctSelected: "Correct (selected)",
-  correctCrossedOut: "Correct (but you crossed it out)",
-  incorrect: "Incorrect",
-  incorrectSelected: "Incorrect (selected)",
-  hideExplanation: "Hide explanation",
-  explain: "Explain",
-  INVALID_MESSAGE_PREFIX: "We couldn't grade your answer.",
-  DEFAULT_INVALID_MESSAGE_1: "It looks like you left something blank or ",
-  DEFAULT_INVALID_MESSAGE_2: "entered in an invalid answer.",
-  integerExample: "an integer, like $6$",
-  properExample: "a *proper* fraction, like $1/2$ or $6/10$",
-  simplifiedProperExample: "a *simplified proper* fraction, like $3/5$",
-  improperExample: "an *improper* fraction, like $10/7$ or $14/8$",
-  simplifiedImproperExample: "a *simplified improper* fraction, like $7/4$",
-  mixedExample: "a mixed number, like $1\\\\ 3/4$",
-  decimalExample: "an *exact* decimal, like $0.75$",
-  percentExample: "a percent, like $12.34\\\\%$",
-  piExample: "a multiple of pi, like $12$ pi or $2/3$ pi",
-  yourAnswer: "**Your answer should be** ",
-  yourAnswerLabel: "Your answer:",
-  addPoints: "Click to add points",
-  addVertices: "Click to add vertices",
-  tapMultiple: "Tap each dot on the image to select all answers that apply.",
-  tapSingle: "Tap each dot on the image to select an answer.",
-  clickMultiple: "Click each dot on the image to select all answers that apply.",
-  clickSingle: "Click each dot on the image to select an answer.",
-  choices: "Choices:",
-  answers: {
-    one: "%(num)s answer",
-    other: "%(num)s answers"
-  },
-  hideAnswersToggleLabel: "Hide answer choices",
-  moves: {
-    one: "Moves: %(num)s",
-    other: "Moves: %(num)s"
-  },
-  clickTiles: "Click on the tiles to change the lights.",
-  turnOffLights: "You must turn on all of the lights to continue.",
-  fillAllCells: "Make sure you fill in all cells in the matrix.",
-  molecularDrawing: "A molecular structure drawing. SMILES notation: %(content)s",
-  switchDirection: "Switch direction",
-  circleOpen: "Make circle open",
-  circleFilled: "Make circle filled",
-  numDivisions: "Number of divisions:",
-  divisions: "Please make sure the number of divisions is in the range %(divRangeString)s.",
-  lineRange: "lines %(lineRange)s",
-  lineNumber: "line %(lineNumber)s",
-  symbolPassage: "The symbol %(questionSymbol)s indicates that question %(questionNumber)s references this portion of the passage.",
-  symbolQuestion: " The symbol %(sentenceSymbol)s indicates that the following sentence is referenced in a question.",
-  lineLabel: {
-    context: "a label next to a reading passage to denote the line number",
-    message: "Line"
-  },
-  beginningPassage: "Beginning of reading passage.",
-  beginningFootnotes: "Beginning of reading passage footnotes.",
-  endPassage: "End of reading passage.",
-  questionMarker: "[Marker for question %(number)s]",
-  circleMarker: "[Circle marker %(number)s]",
-  sentenceMarker: "[Sentence %(number)s]",
-  dragHandles: "Drag handles to make graph",
-  tapAddPoints: "Tap to add points",
-  false: "False",
-  true: "True",
-  no: "No",
-  yes: "Yes",
-  chooseCorrectNum: "Please choose the correct number of answers.",
-  notNoneOfTheAbove: "'None of the above' may not be selected when other answers are selected.",
-  noneOfTheAbove: "None of the above",
-  chooseNumAnswers: "Choose %(numCorrect)s answers:",
-  chooseAllAnswers: "Choose all answers that apply:",
-  chooseOneAnswer: "Choose 1 answer:",
-  choiceCheckedCorrect: "(Choice %(letter)s, Checked, Correct)",
-  choiceCrossedOutCorrect: "(Choice %(letter)s, Crossed out, Correct)",
-  choiceCorrect: "(Choice %(letter)s, Correct)",
-  choiceCheckedIncorrect: "(Choice %(letter)s, Checked, Incorrect)",
-  choiceCrossedOutIncorrect: "(Choice %(letter)s, Crossed out, Incorrect)",
-  choiceIncorrect: "(Choice %(letter)s, Incorrect)",
-  choiceChecked: "(Choice %(letter)s, Checked)",
-  choiceCrossedOut: "(Choice %(letter)s, Crossed out)",
-  choice: "(Choice %(letter)s)",
-  crossOut: "Cross out",
-  crossOutOption: "Cross out option",
-  crossOutChoice: "Cross out Choice %(letter)s",
-  bringBack: "Bring back",
-  openMenuForChoice: "Open menu for Choice %(letter)s",
-  letters: {
-    context: "This is a list of single-character labels that will appear in front of multiple-choice options. For instance, a multiple-choice question with three options would display (A) first option (B) second option (C) third option. There must be spaces between each of the different characters. The characters will show up next to options in the order that they are listed here. Most multiple choice questions have 5 or fewer options.",
-    message: "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
-  },
-  rightArrow: "Reaction arrow pointing to the right.",
-  dontUnderstandUnits: "I couldn't understand those units.",
-  checkSigFigs: "Check your significant figures.",
-  answerNumericallyIncorrect: "That answer is numerically incorrect.",
-  checkUnits: "Check your units.",
-  dontUnderstand: "I don't understand that",
-  loading: "Loading...",
-  videoTranscript: "See video transcript",
-  somethingWrong: "Something went wrong.",
-  videoWrapper: "Khan Academy video wrapper",
-  mathInputTitle: "mathematics keyboard",
-  mathInputDescription: "Use keyboard/mouse to interact with math-based input fields",
-  sin: "sin",
-  cos: "cos",
-  tan: "tan",
-  simulationLoadFail: "Sorry, this simulation cannot load.",
-  simulationLocaleWarning: "Sorry, this simulation isn't available in your language.",
-  selectAnAnswer: "Select an answer",
-  // The following strings are used for interactive graph SR descriptions.
-  addPoint: "Add Point",
-  removePoint: "Remove Point",
-  graphKeyboardPrompt: "Press Shift + Enter to interact with the graph",
-  closePolygon: "Close shape",
-  openPolygon: "Re-open shape",
-  srInteractiveElements: "Interactive elements: %(elements)s",
-  srNoInteractiveElements: "No interactive elements",
-  // TODO(LEMS-2660): The following strings are ones that will need
-  // translation tickets after all interactive graph SR strings have
-  // been finalized. Remove this comment after the tickets have been
-  // created.
-  srPointAtCoordinates: "Point %(num)s at %(x)s comma %(y)s",
-  srCircleGraph: "A circle on a coordinate plane.",
-  srCircleShape: "Circle. The center point is at %(centerX)s comma %(centerY)s.",
-  srCircleRadiusPoint: "Radius point at %(radiusPointX)s comma %(radiusPointY)s.",
-  srCircleRadius: "Circle radius is %(radius)s.",
-  srCircleOuterPoints: "Points on the circle at %(point1X)s comma %(point1Y)s, %(point2X)s comma %(point2Y)s, %(point3X)s comma %(point3Y)s, %(point4X)s comma %(point4Y)s.",
-  srLinearGraph: "A line on a coordinate plane.",
-  srLinearGraphPoints: "The line has two points, point 1 at %(point1X)s comma %(point1Y)s and point 2 at %(point2X)s comma %(point2Y)s.",
-  srLinearGraphSlopeIncreasing: "Its slope increases from left to right.",
-  srLinearGraphSlopeDecreasing: "Its slope decreases from left to right.",
-  srLinearGraphSlopeHorizontal: "Its slope is zero.",
-  srLinearGraphSlopeVertical: "Its slope is undefined.",
-  srLinearGraphXOnlyIntercept: "The line crosses the X-axis at %(xIntercept)s comma 0.",
-  srLinearGraphYOnlyIntercept: "The line crosses the Y-axis at 0 comma %(yIntercept)s.",
-  srLinearGraphBothIntercepts: "The line crosses the X-axis at %(xIntercept)s comma 0 and the Y-axis at 0 comma %(yIntercept)s.",
-  srLinearGraphOriginIntercept: "The line crosses the x and y axes at the graph's origin.",
-  srLinearGrabHandle: "Line from %(point1X)s comma %(point1Y)s to %(point2X)s comma %(point2Y)s.",
-  srAngleSideAtCoordinates: "Point %(point)s, %(side)s at %(x)s comma %(y)s",
-  srAngleVertexAtCoordinatesWithAngleMeasure: "Point 2, vertex at %(x)s comma %(y)s. Angle %(angleMeasure)s degrees",
-  srAngleGraphAriaLabel: "An angle on a coordinate plane.",
-  srAngleGraphAriaDescription: "The angle measure is %(angleMeasure)s degrees with a vertex at %(vertexX)s comma %(vertexY)s, a point on the starting side at %(startingSideX)s comma %(startingSideY)s and a point on the ending side at %(endingSideX)s comma %(endingSideY)s",
-  srLinearSystemGraph: "Two lines on a coordinate plane.",
-  srLinearSystemPoints: "Line %(lineNumber)s has two points, point 1 at %(point1X)s comma %(point1Y)s and point 2 at %(point2X)s comma %(point2Y)s.",
-  srLinearSystemPoint: "Point %(pointSequence)s on line %(lineNumber)s at %(x)s comma %(y)s.",
-  srRayGraph: "A ray on a coordinate plane.",
-  srRayPoints: "The endpoint is at %(point1X)s comma %(point1Y)s and the ray goes through point %(point2X)s comma %(point2Y)s.",
-  srRayGrabHandle: "Ray with endpoint %(point1X)s comma %(point1Y)s going through point %(point2X)s comma %(point2Y)s.",
-  srRayEndpoint: "Endpoint at %(x)s comma %(y)s.",
-  srRayTerminalPoint: "Through point at %(x)s comma %(y)s."
-  // The above strings are used for interactive graph SR descriptions.
-};
-
 /**
  * Mock strings for the Perseus package, to be used for tests and Storybook.
  */
@@ -680,82 +495,213 @@ const mockStrings = {
     } = _ref40;
     return `The angle measure is ${angleMeasure} degrees with a vertex at ${vertexX} comma ${vertexY}, a point on the starting side at ${startingSideX} comma ${startingSideY} and a point on the ending side at ${endingSideX} comma ${endingSideY}.`;
   },
+  srSingleSegmentGraphAriaLabel: "A line segment on a coordinate plane.",
+  srMultipleSegmentGraphAriaLabel: _ref41 => {
+    let {
+      countOfSegments
+    } = _ref41;
+    return `${countOfSegments} segments on a coordinate plane.`;
+  },
+  srMultipleSegmentIndividualLabel: _ref42 => {
+    let {
+      point1X,
+      point1Y,
+      point2X,
+      point2Y,
+      indexOfSegment
+    } = _ref42;
+    return `Segment ${indexOfSegment}: Endpoint 1 at ${point1X} comma ${point1Y}. Endpoint 2 at ${point2X} comma ${point2Y}.`;
+  },
+  srSingleSegmentLabel: _ref43 => {
+    let {
+      point1X,
+      point1Y,
+      point2X,
+      point2Y
+    } = _ref43;
+    return `Endpoint 1 at ${point1X} comma ${point1Y}. Endpoint 2 at ${point2X} comma ${point2Y}.`;
+  },
+  srSegmentLength: _ref44 => {
+    let {
+      length
+    } = _ref44;
+    return `Segment length ${length} units.`;
+  },
+  srSingleSegmentGraphEndpointAriaLabel: _ref45 => {
+    let {
+      endpointNumber,
+      x,
+      y
+    } = _ref45;
+    return `Endpoint ${endpointNumber} at ${x} comma ${y}.`;
+  },
+  srMultipleSegmentGraphEndpointAriaLabel: _ref46 => {
+    let {
+      endpointNumber,
+      x,
+      y,
+      indexOfSegment
+    } = _ref46;
+    return `Endpoint ${endpointNumber} on segment ${indexOfSegment} at ${x} comma ${y}.`;
+  },
+  srSegmentGrabHandle: _ref47 => {
+    let {
+      point1X,
+      point1Y,
+      point2X,
+      point2Y
+    } = _ref47;
+    return `Segment from ${point1X} comma ${point1Y} to ${point2X} comma ${point2Y}.`;
+  },
   srLinearSystemGraph: "Two lines on a coordinate plane.",
-  srLinearSystemPoints: _ref41 => {
+  srLinearSystemPoints: _ref48 => {
     let {
       lineNumber,
       point1X,
       point1Y,
       point2X,
       point2Y
-    } = _ref41;
+    } = _ref48;
     return `Line ${lineNumber} has two points, point 1 at ${point1X} comma ${point1Y} and point 2 at ${point2X} comma ${point2Y}.`;
   },
-  srLinearSystemPoint: _ref42 => {
+  srLinearSystemPoint: _ref49 => {
     let {
       lineNumber,
       pointSequence,
       x,
       y
-    } = _ref42;
+    } = _ref49;
     return `Point ${pointSequence} on line ${lineNumber} at ${x} comma ${y}.`;
   },
   srRayGraph: "A ray on a coordinate plane.",
-  srRayPoints: _ref43 => {
+  srRayPoints: _ref50 => {
     let {
       point1X,
       point1Y,
       point2X,
       point2Y
-    } = _ref43;
+    } = _ref50;
     return `The endpoint is at ${point1X} comma ${point1Y} and the ray goes through point ${point2X} comma ${point2Y}.`;
   },
-  srRayGrabHandle: _ref44 => {
+  srRayGrabHandle: _ref51 => {
     let {
       point1X,
       point1Y,
       point2X,
       point2Y
-    } = _ref44;
+    } = _ref51;
     return `Ray with endpoint ${point1X} comma ${point1Y} going through point ${point2X} comma ${point2Y}.`;
   },
-  srRayEndpoint: _ref45 => {
+  srRayEndpoint: _ref52 => {
     let {
       x,
       y
-    } = _ref45;
+    } = _ref52;
     return `Endpoint at ${x} comma ${y}.`;
   },
-  srRayTerminalPoint: _ref46 => {
+  srRayTerminalPoint: _ref53 => {
     let {
       x,
       y
-    } = _ref46;
+    } = _ref53;
     return `Through point at ${x} comma ${y}.`;
+  },
+  srQuadraticGraph: "A parabola on a 4-quadrant coordinate plane.",
+  srQuadraticFaceUp: "The parabola opens upward.",
+  srQuadraticFaceDown: "The parabola opens downward.",
+  srQuadraticGraphVertexOrigin: "Vertex is at the origin.",
+  srQuadraticGraphVertexXAxis: "Vertex is on the X-axis.",
+  srQuadraticGraphVertexYAxis: "Vertex is on the Y-axis.",
+  srQuadraticGraphVertexQuadrant: _ref54 => {
+    let {
+      quadrant
+    } = _ref54;
+    return `Vertex is in quadrant ${quadrant}.`;
+  },
+  srQuadraticTwoXIntercepts: _ref55 => {
+    let {
+      intercept1,
+      intercept2
+    } = _ref55;
+    return `The X-intercepts are at ${intercept1} comma 0 and ${intercept2} comma 0.`;
+  },
+  srQuadraticOneXIntercept: _ref56 => {
+    let {
+      intercept
+    } = _ref56;
+    return `The X-intercept is at ${intercept} comma 0.`;
+  },
+  srQuadraticYIntercept: _ref57 => {
+    let {
+      intercept
+    } = _ref57;
+    return `The Y-intercept is at 0 comma ${intercept}.`;
+  },
+  srQuadraticPointOrigin: _ref58 => {
+    let {
+      pointNumber
+    } = _ref58;
+    return `Point ${pointNumber} on parabola at the origin.`;
+  },
+  srQuadraticPointAxis: _ref59 => {
+    let {
+      pointNumber,
+      x,
+      y
+    } = _ref59;
+    return `Point ${pointNumber} on parabola at ${x} comma ${y}.`;
+  },
+  srQuadraticPointQuadrant: _ref60 => {
+    let {
+      pointNumber,
+      x,
+      y,
+      quadrant
+    } = _ref60;
+    return `Point ${pointNumber} on parabola in quadrant ${quadrant} at ${x} comma ${y}.`;
+  },
+  srQuadraticInteractiveElements: _ref61 => {
+    let {
+      point1X,
+      point1Y,
+      point2X,
+      point2Y,
+      point3X,
+      point3Y
+    } = _ref61;
+    return `Parabola with points at ${point1X} comma ${point1Y}, ${point2X} comma ${point2Y}, and ${point3X} comma ${point3Y}.`;
   }
   // The above strings are used for interactive graph SR descriptions.
 };
 
 // This type helps us make sure all error codes are mapped to strings
 
+/**
+ * Map an error string to a PerseusStrings key
+ * that we can use to get the translated error message
+ */
 const errorToString = {
-  MISSING_PERCENT_ERROR: strings.MISSING_PERCENT_ERROR,
-  NEEDS_TO_BE_SIMPLIFIED_ERROR: strings.NEEDS_TO_BE_SIMPLFIED_ERROR,
-  APPROXIMATED_PI_ERROR: strings.APPROXIMATED_PI_ERROR,
-  EXTRA_SYMBOLS_ERROR: strings.EXTRA_SYMBOLS_ERROR,
-  WRONG_CASE_ERROR: strings.WRONG_CASE_ERROR,
-  WRONG_LETTER_ERROR: strings.WRONG_LETTER_ERROR,
-  MULTIPLICATION_SIGN_ERROR: strings.MULTIPLICATION_SIGN_ERROR,
-  INVALID_SELECTION_ERROR: strings.invalidSelection,
-  CHOOSE_CORRECT_NUM_ERROR: strings.chooseCorrectNum,
-  NOT_NONE_ABOVE_ERROR: strings.notNoneOfTheAbove,
-  FILL_ALL_CELLS_ERROR: strings.fillAllCells
-};
-function mapErrorToString(err) {
+  MISSING_PERCENT_ERROR: "MISSING_PERCENT_ERROR",
+  NEEDS_TO_BE_SIMPLIFIED_ERROR: "NEEDS_TO_BE_SIMPLFIED_ERROR",
+  APPROXIMATED_PI_ERROR: "APPROXIMATED_PI_ERROR",
+  EXTRA_SYMBOLS_ERROR: "EXTRA_SYMBOLS_ERROR",
+  WRONG_CASE_ERROR: "WRONG_CASE_ERROR",
+  WRONG_LETTER_ERROR: "WRONG_LETTER_ERROR",
+  MULTIPLICATION_SIGN_ERROR: "MULTIPLICATION_SIGN_ERROR",
+  INVALID_SELECTION_ERROR: "invalidSelection",
+  CHOOSE_CORRECT_NUM_ERROR: "chooseCorrectNum",
+  NOT_NONE_ABOVE_ERROR: "notNoneOfTheAbove",
+  FILL_ALL_CELLS_ERROR: "fillAllCells"
+};
+function mapErrorToString(
+// the string representing an error code
+err,
+// the translated Perseus strings
+translatedStrings) {
   if (!err) {
     return err;
   }
-  return errorToString[err] || err;
+  return translatedStrings[errorToString[err]] || err;
 }
 
 /**
@@ -2006,23 +1952,6 @@ const keypadConfigurationForProps = widgetOptions => {
     times: widgetOptions.times
   };
 };
-const propUpgrades$2 = {
-  /* c8 ignore next */
-  "1": v0props => ({
-    times: v0props.times,
-    buttonSets: v0props.buttonSets,
-    functions: v0props.functions,
-    buttonsVisible: v0props.buttonsVisible,
-    visibleLabel: v0props.visibleLabel,
-    ariaLabel: v0props.ariaLabel,
-    answerForms: [{
-      considered: "correct",
-      form: v0props.form,
-      simplify: v0props.simplify,
-      value: v0props.value
-    }]
-  })
-};
 const ExpressionWithDependencies = /*#__PURE__*/React__namespace.forwardRef((props, ref) => {
   const deps = useDependencies();
   return /*#__PURE__*/React__namespace.createElement(Expression, _extends({
@@ -2062,17 +1991,18 @@ var Expression$1 = {
       ariaLabel
     };
   },
-  version: {
-    major: 1,
-    minor: 0
-  },
-  propUpgrades: propUpgrades$2,
+  version: perseusCore.expressionLogic.version,
+  propUpgrades: perseusCore.expressionLogic.widgetOptionsUpgrades,
   // For use by the editor
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusExpressionUserInput'.
   scorer: perseusScore.scoreExpression,
   // TODO(LEMS-2656): remove TS suppression
+  // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusExpressionUserInput'.
+  validator: perseusScore.validateExpression,
+  getPublicWidgetOptions: perseusCore.getExpressionPublicWidgetOptions,
+  // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'Rubric' is not assignable to type 'PerseusExpressionRubric'.
   getOneCorrectAnswerFromRubric(rubric) {
     const correctAnswers = (rubric.answerForms || []).filter(answerForm => answerForm.considered === "correct");
@@ -17580,7 +17510,7 @@ const inlineNodeTypes = {
 
 // @ts-expect-error - TS2345 - Argument of type '{ readonly columns: { readonly react: (node: any, output: any, state: any) => Element; readonly order: -2; readonly match: any; readonly parse: (capture: any, parse: any, state: any) => any; }; ... 35 more ...; readonly text: TextInOutRule; }' is not assignable to parameter of type 'ParserRules'.
 const builtParser$1 = SimpleMarkdown__default["default"].parserFor(rules$1);
-const parse$4 = (source, state) => {
+const parse$3 = (source, state) => {
   const paragraphedSource = source + "\n\n";
   return builtParser$1(paragraphedSource, {
     ...state,
@@ -17665,14 +17595,14 @@ const getContent = ast => {
  */
 const characterCount = source => {
   // @ts-expect-error - TS2554 - Expected 2 arguments, but got 1.
-  const ast = parse$4(source);
+  const ast = parse$3(source);
   const content = getContent(ast).join("");
   return content.length;
 };
 var PerseusMarkdown = {
   characterCount: characterCount,
   traverseContent: traverseContent,
-  parse: parse$4,
+  parse: parse$3,
   parseInline: inlineParser,
   reactFor: SimpleMarkdown__default["default"].reactFor,
   ruleOutput: SimpleMarkdown__default["default"].ruleOutput(rules$1, "react"),
@@ -17813,136 +17743,6 @@ guess, state) {
   });
 }
 
-// These are all the current widgets that require user-input and are supported for automatic scoring
-const QUESTION_WIDGETS = ["numeric-input", "input-number", "radio", "interactive-graph", "interactive-number-line", "categorizer", "plotter", "orderer", "protractor", "matcher", "sorter"];
-
-/**
- * Regex for widget placeholders in a string.
- *
- * First capture group is the widget ID (ex. 'radio 1')
- * Second capture group is the widget type (ex. "radio)
- * exec return will look like: ['[[☃ radio 1]]', 'radio 1', 'radio']
- */
-function getWidgetRegex() {
-  return /\[\[☃ ([A-Za-z0-9- ]+)\]\]/g;
-}
-
-/**
- * Add a widget placeholder using the widget ID.
- * ex. addWidget("radio 1") => "[[☃ radio 1]]"
- *
- * @param {string} id
- * @returns {string}
- */
-function addWidget(id) {
-  return `[[☃ ${id}]]`;
-}
-
-/**
- * Get a widget type by a widget's ID
- * (please don't derive type from ID)
- *
- * @param {string} widgetId the ID of the widget
- * @param {PerseusWidgetsMap} widgetMap widget ID to widget map
- * @returns {string} the widget type (ie "radio")
- */
-function getWidgetTypeByWidgetId(WidgetId, widgetMap) {
-  const widget = widgetMap[WidgetId];
-  return widget?.type ?? null;
-}
-
-/**
- * Does the content have a specific type of widget?
- *
- * @param {string} type the type of the widget in question (ie "radio")
- * @param {string} content the string to search through
- * @param {PerseusWidgetsMap} widgetMap widget ID to widget map
- * @returns {boolean} if the content includes the widget type
- */
-function contentHasWidgetType(type, content, widgetMap) {
-  return getWidgetIdsFromContentByType(type, content, widgetMap).length > 0;
-}
-
-/**
- * Extract all widget IDs, which includes the widget type and instance number.
- * example output: ['radio 1', 'categorizer 1', 'categorizor 2']
- *
- * Content should contain Perseus widget placeholders,
- * which look like: '[[☃ radio 1]]'.
- *
- * @param {string} content
- * @returns {ReadonlyArray<string>} widgetIds
- */
-function getWidgetIdsFromContent(content) {
-  const widgets = [];
-  const localWidgetRegex = getWidgetRegex();
-  let match = localWidgetRegex.exec(content);
-  while (match !== null) {
-    widgets.push(match[1]);
-    match = localWidgetRegex.exec(content);
-  }
-  return widgets;
-}
-
-/**
- * Get a list of widget IDs from content,
- * but only for specific widget types
- *
- * @param {string} type the type of widget (ie "radio")
- * @param {string} content the string to parse
- * @param {PerseusWidgetsMap} widgetMap widget ID to widget map
- * @returns {ReadonlyArray<string>} the widget type (ie "radio")
- */
-function getWidgetIdsFromContentByType(type, content, widgetMap) {
-  const rv = [];
-  const widgetIdsInContent = getWidgetIdsFromContent(content);
-  widgetIdsInContent.forEach(widgetId => {
-    const widget = widgetMap[widgetId];
-    if (widget?.type === type) {
-      rv.push(widgetId);
-    }
-  });
-  return rv;
-}
-
-/**
- * Pull the widget map out of ItemData
- *
- * @param {PerseusItem} PerseusItem containing a widgetMap
- * @returns {WidgetMap} the widget map in the PerseusItem
- */
-function getWidgetsMapFromItemData(itemData) {
-  return itemData.question.widgets;
-}
-
-/**
- * Get the widget information from a WidgetMap
- *
- * @param {string} widgetId the ID of the widget
- * @returns {PerseusWidget | null} the widget data if it exists, otherwise null
- */
-function getWidgetFromWidgetMap(widgetId, widgetMap) {
-  return widgetMap[widgetId] ?? null;
-}
-
-/**
- * Get select widgets from a widget map.
- *
- * @param {ReadonlyArray<string>} widgetIds to extract
- * @param {PerseusWidgetsMap} widgetMap to extract from
- * @return {PerseusWidgetsMap} a new widget map with requested widgets
- */
-function getWidgetsFromWidgetMap(widgetIds, widgetMap) {
-  const widgets = {};
-  widgetIds.forEach(widgetId => {
-    const widget = getWidgetFromWidgetMap(widgetId, widgetMap);
-    if (widget) {
-      widgets[widgetId] = widget;
-    }
-  });
-  return widgets;
-}
-
 const DEFAULT_ALIGNMENT$1 = "block";
 // NOTE(kevinb): "default" is not one in `validAlignments`.
 const DEFAULT_SUPPORTED_ALIGNMENTS = ["default"];
@@ -18044,6 +17844,9 @@ const getWidget = name => {
 const getWidgetExport = name => {
   return widgets[name] ?? null;
 };
+const getWidgetValidator = name => {
+  return widgets[name]?.validator ?? null;
+};
 const getWidgetScorer = name => {
   return widgets[name]?.scorer ?? null;
 };
@@ -18356,6 +18159,7 @@ var widgets$1 = /*#__PURE__*/Object.freeze({
   replaceDeprecatedEditors: replaceDeprecatedEditors,
   getWidget: getWidget,
   getWidgetExport: getWidgetExport,
+  getWidgetValidator: getWidgetValidator,
   getWidgetScorer: getWidgetScorer,
   getPublicWidgetOptionsFunction: getPublicWidgetOptionsFunction,
   getEditor: getEditor,
@@ -18378,7 +18182,6 @@ var widgets$1 = /*#__PURE__*/Object.freeze({
 });
 
 function getUpgradedWidgetOptions(oldWidgetOptions) {
-  // @ts-expect-error - TS2322 - Type '(props: Props) => Partial<Record<string, CategorizerWidget | CSProgramWidget | DefinitionWidget | DropdownWidget | ... 35 more ... | VideoWidget>>' is not assignable to type '(props: Props) => { [key: string]: PerseusWidget; }'.
   return perseusCore.mapObject(oldWidgetOptions, (widgetInfo, widgetId) => {
     if (!widgetInfo.type || !widgetInfo.alignment) {
       const newValues = {};
@@ -18396,22 +18199,30 @@ function getUpgradedWidgetOptions(oldWidgetOptions) {
         ...newValues
       };
     }
+    // TODO(LEMS-2656): remove TS suppression
     return upgradeWidgetInfoToLatestVersion(widgetInfo);
   });
 }
+
+/**
+ * Checks the given user input to see if any answerable widgets have not been
+ * "filled in" (ie. if they're empty). Another way to think about this
+ * function is that its a check to see if we can score the provided input.
+ */
 function emptyWidgetsFunctional(widgets,
 // This is a port of old code, I'm not sure why
 // we need widgetIds vs the keys of the widgets object
 widgetIds, userInputMap, strings, locale) {
-  const upgradedWidgets = getUpgradedWidgetOptions(widgets);
   return widgetIds.filter(id => {
-    const widget = upgradedWidgets[id];
-    if (!widget || widget.static) {
+    const widget = widgets[id];
+    if (!widget || widget.static === true) {
       // Static widgets shouldn't count as empty
       return false;
     }
-    const scorer = getWidgetScorer(widget.type);
-    const score = scorer?.(userInputMap[id], widget.options, strings, locale);
+    const validator = getWidgetValidator(widget.type);
+    const userInput = userInputMap[id];
+    const validationData = widget.options;
+    const score = validator?.(userInput, validationData, strings, locale);
     if (score) {
       return scoreIsEmpty(score);
     }
@@ -18427,7 +18238,7 @@ strings, locale) {
   // There seems to be a chance that PerseusRenderer.widgets might include
   // widget data for widgets that are not in PerseusRenderer.content,
   // so this checks that the widgets are being used before scoring them
-  const usedWidgetIds = getWidgetIdsFromContent(perseusRenderData.content);
+  const usedWidgetIds = perseusCore.getWidgetIdsFromContent(perseusRenderData.content);
   const scores = scoreWidgetsFunctional(perseusRenderData.widgets, usedWidgetIds, userInputMap, strings, locale);
   return flattenScores(scores);
 }
@@ -18450,8 +18261,12 @@ widgetIds, userInputMap, strings, locale) {
       return;
     }
     const userInput = userInputMap[id];
+    const validator = getWidgetValidator(widget.type);
     const scorer = getWidgetScorer(widget.type);
-    const score = scorer?.(userInput, widget.options, strings, locale);
+
+    // We do validation (empty checks) first and then scoring. If
+    // validation fails, it's result is itself a PerseusScore.
+    const score = validator?.(userInput, widget.options, strings, locale) ?? scorer?.(userInput, widget.options, strings, locale);
     if (score != null) {
       widgetScores[id] = score;
     }
@@ -19060,7 +18875,7 @@ class Renderer extends React__namespace.Component {
     const apiOptions = this.getApiOptions();
     const widgetProps = this.state.widgetProps[widgetId] || {};
 
-    // The widget needs access to its "rubric" at all times when in review
+    // The widget needs access to its "scoring data" at all times when in review
     // mode (which is really just part of its widget info).
     const widgetInfo = this.state.widgetInfo[widgetId];
     const reviewModeRubric = this.props.reviewMode && widgetInfo ? widgetInfo.options : null;
@@ -23020,7 +22835,7 @@ const CIRCLE_LABEL_STYLE = {
 // TODO(LEMS-2656): remove TS suppression
 // @ts-expect-error: State is not assignable to ParseState
 const builtParser = SimpleMarkdown__default["default"].parserFor(rules);
-const parse$3 = (source, state) => {
+const parse$2 = (source, state) => {
   // @ts-expect-error - TS2322 - Type 'ParseState | {}' is not assignable to type 'ParseState | null | undefined'.
   state = state || {};
   const paragraphedSource = source + "\n\n";
@@ -23030,7 +22845,7 @@ const parse$3 = (source, state) => {
 // @ts-expect-error - TS2322 - Type 'ReactOutput' is not assignable to type '(arg1: SingleASTNode[]) => ReactElement<any, string | JSXElementConstructor<any>>'.
 const output = SimpleMarkdown__default["default"].reactFor(SimpleMarkdown__default["default"].ruleOutput(rules, "react"));
 var PassageMarkdown = {
-  parse: parse$3,
+  parse: parse$2,
   output,
   START_REF_PREFIX,
   END_REF_PREFIX,
@@ -23585,10 +23400,7 @@ var PassageRef$1 = {
     referenceNumber: widgetOptions.referenceNumber,
     summaryText: widgetOptions.summaryText
   }),
-  version: {
-    major: 0,
-    minor: 1
-  },
+  version: perseusCore.passageRefLogic.version,
   // TODO: things that aren't interactive shouldn't need scoring functions
   scorer: () => scoreNoop()
 };
@@ -25274,7 +25086,7 @@ class Radio$1 extends React__namespace.Component {
         // Current versions of the radio widget always pass in the
         // "correct" value through the choices. Old serialized state
         // for radio widgets doesn't have this though, so we have to
-        // pull the correctness out of the review mode rubric. This
+        // pull the correctness out of the review mode scoring data. This
         // only works because all of the places we use
         // `restoreSerializedState()` also turn on reviewMode, but is
         // fine for now.
@@ -25398,21 +25210,6 @@ const transform = (widgetOptions, strings, problemNum) => {
     selectedChoices: ___default["default"].pluck(choices, "correct")
   };
 };
-const propUpgrades$1 = {
-  "1": v0props => {
-    const {
-      noneOfTheAbove,
-      ...rest
-    } = v0props;
-    if (noneOfTheAbove) {
-      throw new Error("radio widget v0 no longer supports auto noneOfTheAbove");
-    }
-    return {
-      ...rest,
-      hasNoneOfTheAbove: false
-    };
-  }
-};
 var Radio = {
   name: "radio",
   displayName: "Radio / Multiple choice",
@@ -25420,15 +25217,15 @@ var Radio = {
   widget: Radio$1,
   transform: transform,
   staticTransform: transform,
-  version: {
-    major: 1,
-    minor: 0
-  },
-  propUpgrades: propUpgrades$1,
+  version: perseusCore.radioLogic.version,
+  propUpgrades: perseusCore.radioLogic.widgetOptionsUpgrades,
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type UserInput is not assignable to type PerseusRadioUserInput
-  scorer: perseusScore.scoreRadio
+  scorer: perseusScore.scoreRadio,
+  // TODO(LEMS-2656): remove TS suppression
+  // @ts-expect-error: Type UserInput is not assignable to type PerseusRadioUserInput
+  validator: perseusScore.validateRadio
 };
 
 /* eslint-disable import/no-named-as-default */
@@ -25447,24 +25244,6 @@ const getPromptJSON$n = (renderProps, userInput) => {
   };
 };
 
-/**
- * For details on the individual options, see the
- * PerseusCategorizerWidgetOptions type
- */
-
-/**
- * Given a PerseusCategorizerWidgetOptions object, return a new object with only
- * the public options that should be exposed to the client.
- */
-function getCategorizerPublicWidgetOptions(options) {
-  return {
-    items: options.items,
-    categories: options.categories,
-    randomizeItems: options.randomizeItems,
-    static: options.static
-  };
-}
-
 /* eslint-disable @khanacademy/ts-no-error-suppressions */
 class Categorizer extends React__namespace.Component {
   static contextType = PerseusI18nContext;
@@ -25647,7 +25426,10 @@ var Categorizer$1 = {
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusCSProgramUserInput'.
   scorer: perseusScore.scoreCategorizer,
-  getPublicWidgetOptions: getCategorizerPublicWidgetOptions
+  // TODO(LEMS-2656): remove TS suppression
+  // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusCSProgramUserInput'.
+  validator: perseusScore.validateCategorizer,
+  getPublicWidgetOptions: perseusCore.getCategorizerPublicWidgetOptions
 };
 
 /**
@@ -26086,7 +25868,10 @@ var Dropdown$1 = {
   transform: optionsTransform,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusDropdownUserInput'.
-  scorer: perseusScore.scoreDropdown
+  scorer: perseusScore.scoreDropdown,
+  // TODO(LEMS-2656): remove TS suppression
+  // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusDropdownUserInput'.
+  validator: perseusScore.validateDropdown
 };
 
 const getPromptJSON$j = renderProps => {
@@ -26458,7 +26243,7 @@ class GradedGroup extends React__namespace.Component {
       DEFAULT_INVALID_MESSAGE_2
     } = this.context.strings;
     const status = score.type === "points" ? score.total === score.earned ? GRADING_STATUSES.correct : GRADING_STATUSES.incorrect : GRADING_STATUSES.invalid;
-    const message = score.type === "points" ? score.message || "" : score.message ? `${INVALID_MESSAGE_PREFIX} ${mapErrorToString(score.message)}` : `${INVALID_MESSAGE_PREFIX} ${DEFAULT_INVALID_MESSAGE_1}${DEFAULT_INVALID_MESSAGE_2}`;
+    const message = score.type === "points" ? score.message || "" : score.message ? `${INVALID_MESSAGE_PREFIX} ${mapErrorToString(score.message, this.context.strings)}` : `${INVALID_MESSAGE_PREFIX} ${DEFAULT_INVALID_MESSAGE_1}${DEFAULT_INVALID_MESSAGE_2}`;
     this.setState({
       status: status,
       message: message,
@@ -27604,11 +27389,22 @@ const getPromptJSON$f = rendererJSON => {
 
 // The `group` widget is basically a widget hosting a full Perseus system in
 // it. As such, scoring a group means scoring all widgets it contains.
-function scoreGroup(userInput, options, strings, locale) {
-  const scores = scoreWidgetsFunctional(options.widgets, Object.keys(options.widgets), userInput, strings, locale);
+function scoreGroup(userInput, rubric, strings, locale) {
+  const scores = scoreWidgetsFunctional(rubric.widgets, Object.keys(rubric.widgets), userInput, strings, locale);
   return flattenScores(scores);
 }
 
+function validateGroup(userInput, validationData, strings, locale) {
+  const emptyWidgets = emptyWidgetsFunctional(validationData.widgets, Object.keys(validationData.widgets), userInput, strings, locale);
+  if (emptyWidgets.length === 0) {
+    return null;
+  }
+  return {
+    type: "invalid",
+    message: null
+  };
+}
+
 // exports has no 'transform'
 
 class Group extends React__namespace.Component {
@@ -27761,8 +27557,11 @@ var Group$1 = {
   widget: Group,
   traverseChildWidgets: traverseChildWidgets,
   // TODO(LEMS-2656): remove TS suppression
-  // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusCSProgramUserInput'.
+  // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusGroupUserInput'.
   scorer: scoreGroup,
+  // TODO(LEMS-2656): remove TS suppression
+  // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusGroupUserInput'.
+  validator: validateGroup,
   hidden: true,
   isLintable: true
 };
@@ -30682,6 +30481,96 @@ function getInterceptStringForLine(line, strings, locale) {
     yIntercept: srFormatNumber(yIntercept, locale)
   });
 }
+function getCoordQuadrant(coord) {
+  const [unroundedX, unroundedY] = coord;
+  const x = Number(unroundedX.toFixed(3));
+  const y = Number(unroundedY.toFixed(3));
+  if (x === 0 && y === 0) {
+    return "origin";
+  }
+  if (y === 0) {
+    return "x-axis";
+  }
+  if (x === 0) {
+    return "y-axis";
+  }
+  if (x > 0 && y > 0) {
+    return 1;
+  }
+  if (x < 0 && y > 0) {
+    return 2;
+  }
+  if (x < 0 && y < 0) {
+    return 3;
+  }
+  return 4;
+}
+function getQuadraticVertexString(vertex, strings) {
+  const location = getCoordQuadrant(vertex);
+  switch (location) {
+    case "origin":
+      return strings.srQuadraticGraphVertexOrigin;
+    case "x-axis":
+      return strings.srQuadraticGraphVertexXAxis;
+    case "y-axis":
+      return strings.srQuadraticGraphVertexYAxis;
+    default:
+      return strings.srQuadraticGraphVertexQuadrant({
+        quadrant: location
+      });
+  }
+}
+function getQuadraticPointString(pointNumber, coord, strings, locale) {
+  const location = getCoordQuadrant(coord);
+  const [x, y] = coord;
+  switch (location) {
+    case "origin":
+      return strings.srQuadraticPointOrigin({
+        pointNumber: pointNumber
+      });
+    case "x-axis":
+    case "y-axis":
+      return strings.srQuadraticPointAxis({
+        pointNumber: pointNumber,
+        x: srFormatNumber(x, locale),
+        y: srFormatNumber(y, locale)
+      });
+    default:
+      // return `Point ${pointNumber} on parabola in quadrant ${location} at ${srFormatNumber(x, locale)} comma ${srFormatNumber(y, locale)}.`;
+      return strings.srQuadraticPointQuadrant({
+        pointNumber: pointNumber,
+        quadrant: location,
+        x: srFormatNumber(x, locale),
+        y: srFormatNumber(y, locale)
+      });
+  }
+}
+function getQuadraticXIntercepts(
+// Coefficients of the quadratic equation
+a, b, c) {
+  // If a is 0, the equation is a line and has maybe only one x-intercept.
+  if (a === 0) {
+    // If b is 0, the equation a horizontal line and has no x-intercepts.
+    if (b === 0) {
+      return [];
+    }
+    return [-c / b];
+  }
+
+  // Find the x-intercepts by plugging in y = 0 into the quadratic equation.
+  // 0 = ax^2 + bx + c
+  // x = (-b ± sqrt(b^2 - 4ac)) / 2a
+  const discriminant = b * b - 4 * a * c;
+  if (discriminant < 0) {
+    return [];
+  }
+  const x1 = (-b + Math.sqrt(discriminant)) / (2 * a);
+  const x2 = (-b - Math.sqrt(discriminant)) / (2 * a);
+  if (x1 === x2) {
+    return [x1];
+  }
+  return [x1, x2];
+}
 
 const {
   calculateAngleInDegrees: calculateAngleInDegrees$2
@@ -32519,7 +32408,9 @@ function renderLinearGraph(state, dispatch) {
       graphState: state,
       dispatch: dispatch
     }),
-    interactiveElementsDescription: null
+    interactiveElementsDescription: /*#__PURE__*/React__namespace.createElement(LinearGraphDescription, {
+      state: state
+    })
   };
 }
 const LinearGraph = (props, key) => {
@@ -32538,33 +32429,29 @@ const LinearGraph = (props, key) => {
   const interceptDescriptionId = id + "-intercept";
   const slopeDescriptionId = id + "-slope";
 
-  // Aria label strings
-  const linearGraphPointsDescription = strings.srLinearGraphPoints({
-    point1X: srFormatNumber(line[0][0], locale),
-    point1Y: srFormatNumber(line[0][1], locale),
-    point2X: srFormatNumber(line[1][0], locale),
-    point2Y: srFormatNumber(line[1][1], locale)
-  });
-  const grabHandleAriaLabel = strings.srLinearGrabHandle({
-    point1X: srFormatNumber(line[0][0], locale),
-    point1Y: srFormatNumber(line[0][1], locale),
-    point2X: srFormatNumber(line[1][0], locale),
-    point2Y: srFormatNumber(line[1][1], locale)
+  // Aria strings
+  const {
+    srLinearGraph,
+    srLinearGraphPoints,
+    srLinearGrabHandle,
+    slopeString,
+    interceptString
+  } = describeLinearGraph(props.graphState, {
+    strings,
+    locale
   });
-  const slopeString = getSlopeStringForLine(line, strings);
-  const interceptString = getInterceptStringForLine(line, strings, locale);
 
   // Linear graphs only have one line
   // (LEMS-2050): Update the reducer so that we have a separate action for moving one line
   // and another action for moving multiple lines
   return /*#__PURE__*/React__namespace.createElement("g", {
     // Outer line minimal description
-    "aria-label": strings.srLinearGraph,
+    "aria-label": srLinearGraph,
     "aria-describedby": `${pointsDescriptionId} ${interceptDescriptionId} ${slopeDescriptionId}`
   }, /*#__PURE__*/React__namespace.createElement(MovableLine, {
     key: 0,
     ariaLabels: {
-      grabHandleAriaLabel: grabHandleAriaLabel
+      grabHandleAriaLabel: srLinearGrabHandle
     },
     ariaDescribedBy: `${interceptDescriptionId} ${slopeDescriptionId}`,
     points: line,
@@ -32580,7 +32467,7 @@ const LinearGraph = (props, key) => {
   }), /*#__PURE__*/React__namespace.createElement("g", {
     id: pointsDescriptionId,
     style: a11y.srOnly
-  }, linearGraphPointsDescription), /*#__PURE__*/React__namespace.createElement("g", {
+  }, srLinearGraphPoints), /*#__PURE__*/React__namespace.createElement("g", {
     id: interceptDescriptionId,
     style: a11y.srOnly
   }, interceptString), /*#__PURE__*/React__namespace.createElement("g", {
@@ -32588,6 +32475,56 @@ const LinearGraph = (props, key) => {
     style: a11y.srOnly
   }, slopeString));
 };
+function LinearGraphDescription(_ref) {
+  let {
+    state
+  } = _ref;
+  // The reason that LinearGraphDescription is a component (rather than a
+  // function that returns a string) is because it needs to use a
+  // hook: `usePerseusI18n`.
+  const i18n = usePerseusI18n();
+  const strings = describeLinearGraph(state, i18n);
+  return strings.srLinearInteractiveElement;
+}
+
+// Exported for testing
+function describeLinearGraph(state, i18n) {
+  const {
+    coords: line
+  } = state;
+  const {
+    strings,
+    locale
+  } = i18n;
+
+  // Aria label strings
+  const srLinearGraph = strings.srLinearGraph;
+  const srLinearGraphPoints = strings.srLinearGraphPoints({
+    point1X: srFormatNumber(line[0][0], locale),
+    point1Y: srFormatNumber(line[0][1], locale),
+    point2X: srFormatNumber(line[1][0], locale),
+    point2Y: srFormatNumber(line[1][1], locale)
+  });
+  const srLinearGrabHandle = strings.srLinearGrabHandle({
+    point1X: srFormatNumber(line[0][0], locale),
+    point1Y: srFormatNumber(line[0][1], locale),
+    point2X: srFormatNumber(line[1][0], locale),
+    point2Y: srFormatNumber(line[1][1], locale)
+  });
+  const slopeString = getSlopeStringForLine(line, strings);
+  const interceptString = getInterceptStringForLine(line, strings, locale);
+  const srLinearInteractiveElement = strings.srInteractiveElements({
+    elements: [srLinearGraph, srLinearGraphPoints].join(" ")
+  });
+  return {
+    srLinearGraph,
+    srLinearGraphPoints,
+    srLinearGrabHandle,
+    slopeString,
+    interceptString,
+    srLinearInteractiveElement
+  };
+}
 
 function renderLinearSystemGraph(state, dispatch) {
   return {
@@ -33146,13 +33083,13 @@ const hasFocusVisible = element => {
   }
 };
 
-function renderQuadraticGraph(state, dispatch) {
+function renderQuadraticGraph(state, dispatch, i18n) {
   return {
     graph: /*#__PURE__*/React__namespace.createElement(QuadraticGraph, {
       graphState: state,
       dispatch: dispatch
     }),
-    interactiveElementsDescription: null
+    interactiveElementsDescription: getQuadraticGraphDescription(state, i18n)
   };
 }
 function QuadraticGraph(props) {
@@ -33163,6 +33100,14 @@ function QuadraticGraph(props) {
   const {
     coords
   } = graphState;
+  const {
+    strings,
+    locale
+  } = usePerseusI18n();
+  const id = React__namespace.useId();
+  const quadraticDirectionId = id + "-direction";
+  const quadraticVertexId = id + "-vertex";
+  const quadraticInterceptsId = id + "-intercepts";
 
   // The coefficients are used to calculate the quadratic equation, plot the graph, and to indicate
   // to content creators the currently selected "correct answer". ex: y = 0.200x^2 + 0.000x + 0.000
@@ -33178,15 +33123,46 @@ function QuadraticGraph(props) {
 
   // Calculate the y value based on the current x value
   const y = x => (a * x + b) * x + c;
-  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(mafs.Plot.OfX, {
+
+  // Aria strings
+  const {
+    srQuadraticGraph,
+    srQuadraticDirection,
+    srQuadraticVertex,
+    srQuadraticXIntercepts,
+    srQuadraticYIntercept
+  } = describeQuadraticGraph(graphState, {
+    strings,
+    locale
+  });
+  return /*#__PURE__*/React__namespace.createElement("g", {
+    // Outer graph minimal description
+    "aria-label": srQuadraticGraph,
+    "aria-describedby": `${quadraticDirectionId} ${quadraticVertexId} ${quadraticInterceptsId}`
+  }, /*#__PURE__*/React__namespace.createElement(mafs.Plot.OfX, {
     y: y,
     color: wonderBlocksTokens.color.blue
-  }), coords.map((coord, i) => /*#__PURE__*/React__namespace.createElement(MovablePoint$1, {
-    key: "point-" + i,
-    point: coord,
-    sequenceNumber: i + 1,
-    onMove: destination => dispatch(actions.quadratic.movePoint(i, destination))
-  })));
+  }), coords.map((coord, i) => {
+    const srQuadraticPoint = getQuadraticPointString(i + 1, coord, strings, locale);
+    // Vertex might not exist if the quadratic graph is a line
+    const srVertex = srQuadraticVertex ? ` ${srQuadraticVertex}` : "";
+    return /*#__PURE__*/React__namespace.createElement(MovablePoint$1, {
+      key: "point-" + i,
+      ariaLabel: `${srQuadraticPoint}${srVertex}`,
+      point: coord,
+      sequenceNumber: i + 1,
+      onMove: destination => dispatch(actions.quadratic.movePoint(i, destination))
+    });
+  }), srQuadraticDirection && /*#__PURE__*/React__namespace.createElement("g", {
+    id: quadraticDirectionId,
+    style: a11y.srOnly
+  }, srQuadraticDirection), srQuadraticVertex && /*#__PURE__*/React__namespace.createElement("g", {
+    id: quadraticVertexId,
+    style: a11y.srOnly
+  }, srQuadraticVertex), /*#__PURE__*/React__namespace.createElement("g", {
+    id: quadraticInterceptsId,
+    style: a11y.srOnly
+  }, srQuadraticXIntercepts ? `${srQuadraticXIntercepts} ${srQuadraticYIntercept}` : `${srQuadraticYIntercept}`));
 }
 
 // Get the quadratic coefficients from the 3 control points
@@ -33209,6 +33185,60 @@ const getQuadraticCoefficients$2 = coords => {
   const c = (p2[0] * p3[0] * (p2[0] - p3[0]) * p1[1] + p3[0] * p1[0] * (p3[0] - p1[0]) * p2[1] + p1[0] * p2[0] * (p1[0] - p2[0]) * p3[1]) / denom;
   return [a, b, c];
 };
+function getQuadraticGraphDescription(state, i18n) {
+  const strings = describeQuadraticGraph(state, i18n);
+  return strings.srQuadraticInteractiveElements;
+}
+// Exported for testing
+function describeQuadraticGraph(state, i18n) {
+  const {
+    strings,
+    locale
+  } = i18n;
+  const coeffs = getQuadraticCoefficients$2(state.coords);
+  const [a, b, c] = coeffs ?? [0, 0, 0];
+  const vertex = [-b / (2 * a), c - b * b / (4 * a)];
+  const xIntercepts = getQuadraticXIntercepts(a, b, c);
+
+  // Aria label strings
+  const srQuadraticGraph = strings.srQuadraticGraph;
+  const srQuadraticFaceUp = strings.srQuadraticFaceUp;
+  const srQuadraticFaceDown = strings.srQuadraticFaceDown;
+  // The graph only has a direction if it is not a line.
+  const srQuadraticDirection = a === 0 ? undefined : a > 0 ? srQuadraticFaceUp : srQuadraticFaceDown;
+  // Only describe vertex if the quadratic graph is not a line.
+  // (Undefined means the quadratic graph is a line and has no vertex.)
+  const srQuadraticVertex = a !== 0 ? getQuadraticVertexString(vertex, strings) : undefined;
+  // Undefined means the quadratic graph has no x-intercepts,
+  // such as when the graph is a horizontal line.
+  const srQuadraticXIntercepts = xIntercepts.length === 2 ? strings.srQuadraticTwoXIntercepts({
+    intercept1: srFormatNumber(xIntercepts[0], locale),
+    intercept2: srFormatNumber(xIntercepts[1], locale)
+  }) : xIntercepts.length === 1 ? strings.srQuadraticOneXIntercept({
+    intercept: srFormatNumber(xIntercepts[0], locale)
+  }) : undefined;
+  const srQuadraticYIntercept = strings.srQuadraticYIntercept({
+    intercept: srFormatNumber(c, locale)
+  });
+  const srQuadraticInteractiveElements = strings.srInteractiveElements({
+    elements: strings.srQuadraticInteractiveElements({
+      point1X: srFormatNumber(state.coords[0][0], locale),
+      point1Y: srFormatNumber(state.coords[0][1], locale),
+      point2X: srFormatNumber(state.coords[1][0], locale),
+      point2Y: srFormatNumber(state.coords[1][1], locale),
+      point3X: srFormatNumber(state.coords[2][0], locale),
+      point3Y: srFormatNumber(state.coords[2][1], locale)
+    })
+  });
+  return {
+    srQuadraticGraph,
+    srQuadraticDirection,
+    srQuadraticVertex,
+    srQuadraticXIntercepts,
+    srQuadraticYIntercept,
+    srQuadraticInteractiveElements
+  };
+}
 
 function renderRayGraph(state, dispatch) {
   return {
@@ -33335,17 +33365,71 @@ function renderSegmentGraph(state, dispatch) {
       graphState: state,
       dispatch: dispatch
     }),
-    interactiveElementsDescription: null
+    interactiveElementsDescription: /*#__PURE__*/React__namespace.createElement(SegmentGraphDescription, {
+      state: state
+    })
   };
 }
-const SegmentGraph = props => {
-  const {
-    dispatch
-  } = props;
+const SegmentGraph = _ref => {
+  let {
+    dispatch,
+    graphState
+  } = _ref;
   const {
     coords: segments
-  } = props.graphState;
-  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, segments?.map((segment, i) => /*#__PURE__*/React__namespace.createElement(MovableLine, {
+  } = graphState;
+  const {
+    strings,
+    locale
+  } = usePerseusI18n();
+  const segmentUniqueId = React__namespace.useId();
+  const lengthDescriptionId = segmentUniqueId + "-length";
+  const wholeGraphDescriptionId = segmentUniqueId + "-whole-graph";
+  function getWholeSegmentGraphAriaLabel() {
+    return segments?.length > 1 ? strings.srMultipleSegmentGraphAriaLabel({
+      countOfSegments: segments.length
+    }) : strings.srSingleSegmentGraphAriaLabel;
+  }
+  const wholeSegmentGraphAriaLabel = getWholeSegmentGraphAriaLabel();
+  function getIndividualSegmentAriaLabel(segment, index) {
+    if (segments.length === 1) {
+      return strings.srSingleSegmentLabel({
+        point1X: srFormatNumber(segments[0][0][X], locale),
+        point1Y: srFormatNumber(segments[0][0][Y], locale),
+        point2X: srFormatNumber(segments[0][1][X], locale),
+        point2Y: srFormatNumber(segments[0][1][Y], locale)
+      });
+    }
+    return strings.srMultipleSegmentIndividualLabel({
+      point1X: srFormatNumber(segment[0][X], locale),
+      point1Y: srFormatNumber(segment[0][Y], locale),
+      point2X: srFormatNumber(segment[1][X], locale),
+      point2Y: srFormatNumber(segment[1][Y], locale),
+      indexOfSegment: index + 1
+    });
+  }
+  function getWholeSegmentGraphAriaDescription() {
+    return segments.map((segment, index) => getIndividualSegmentAriaLabel(segment, index)).join(" ");
+  }
+  function formatSegment(endpointNumber, x, y, index) {
+    const segObj = {
+      endpointNumber: endpointNumber,
+      x: srFormatNumber(x, locale),
+      y: srFormatNumber(y, locale)
+    };
+    return segments.length > 1 ? strings.srMultipleSegmentGraphEndpointAriaLabel({
+      ...segObj,
+      indexOfSegment: index
+    }) : strings.srSingleSegmentGraphEndpointAriaLabel(segObj);
+  }
+  return /*#__PURE__*/React__namespace.createElement("g", {
+    "aria-label": wholeSegmentGraphAriaLabel,
+    "aria-describedby": wholeGraphDescriptionId
+  }, segments?.map((segment, i) => /*#__PURE__*/React__namespace.createElement("g", {
+    "aria-label": getIndividualSegmentAriaLabel(segment, i),
+    "aria-describedby": lengthDescriptionId,
+    key: `${segmentUniqueId}-${i}`
+  }, /*#__PURE__*/React__namespace.createElement(MovableLine, {
     key: i,
     points: segment,
     onMoveLine: delta => {
@@ -33353,9 +33437,61 @@ const SegmentGraph = props => {
     },
     onMovePoint: (endpointIndex, destination) => {
       dispatch(actions.segment.movePointInFigure(i, endpointIndex, destination));
+    },
+    ariaLabels: {
+      point1AriaLabel: formatSegment(1, segment[0][X], segment[0][Y], i + 1),
+      point2AriaLabel: formatSegment(2, segment[1][X], segment[1][Y], i + 1),
+      grabHandleAriaLabel: strings.srSegmentGrabHandle({
+        point1X: srFormatNumber(segment[0][X], locale),
+        point1Y: srFormatNumber(segment[0][Y], locale),
+        point2X: srFormatNumber(segment[1][X], locale),
+        point2Y: srFormatNumber(segment[1][Y], locale)
+      })
     }
-  })));
+  }), /*#__PURE__*/React__namespace.createElement("g", {
+    id: lengthDescriptionId,
+    style: a11y.srOnly
+  }, strings.srSegmentLength({
+    length: srFormatNumber(getLengthOfSegment(segment), locale)
+  })))), /*#__PURE__*/React__namespace.createElement("g", {
+    style: a11y.srOnly,
+    id: wholeGraphDescriptionId
+  }, getWholeSegmentGraphAriaDescription()));
 };
+function getLengthOfSegment(segment) {
+  return kmath.point.distanceToPoint(...segment);
+}
+function SegmentGraphDescription(_ref2) {
+  let {
+    state
+  } = _ref2;
+  // The reason that SegmentGraphDescription is a component (rather than a
+  // function that returns a string) is because it needs to use a
+  // hook: `usePerseusI18n`.
+  const i18n = usePerseusI18n();
+  return describeSegmentGraph(state, i18n);
+}
+
+// Exported for testing
+function describeSegmentGraph(state, i18n) {
+  const {
+    strings,
+    locale
+  } = i18n;
+  const segmentDescriptions = state.coords.map((_ref3, index) => {
+    let [point1, point2] = _ref3;
+    return strings.srMultipleSegmentIndividualLabel({
+      point1X: srFormatNumber(point1[X], locale),
+      point1Y: srFormatNumber(point1[Y], locale),
+      point2X: srFormatNumber(point2[X], locale),
+      point2Y: srFormatNumber(point2[Y], locale),
+      indexOfSegment: index + 1
+    });
+  });
+  return strings.srInteractiveElements({
+    elements: segmentDescriptions.join(" ")
+  });
+}
 
 function renderSinusoidGraph(state, dispatch) {
   return {
@@ -33631,9 +33767,10 @@ const MafsGraph = props => {
     x: viewboxX,
     y: viewboxY
   };
+  const i18n = usePerseusI18n();
   const {
     strings
-  } = usePerseusI18n();
+  } = i18n;
   const interactionPrompt = isUnlimitedGraphState(state) && state.showKeyboardInteractionInvitation;
   wonderBlocksCore.useOnMountEffect(() => {
     analytics.onAnalyticsEvent({
@@ -33650,7 +33787,8 @@ const MafsGraph = props => {
     interactiveElementsDescription
   } = renderGraphElements({
     state,
-    dispatch
+    dispatch,
+    i18n
   });
   return /*#__PURE__*/React__namespace.createElement(GraphConfigContext.Provider, {
     value: {
@@ -34027,7 +34165,8 @@ const calculateNestedSVGCoords = (range, width, height) => {
 const renderGraphElements = props => {
   const {
     state,
-    dispatch
+    dispatch,
+    i18n
   } = props;
   const {
     type
@@ -34050,7 +34189,7 @@ const renderGraphElements = props => {
     case "circle":
       return renderCircleGraph(state, dispatch);
     case "quadratic":
-      return renderQuadraticGraph(state, dispatch);
+      return renderQuadraticGraph(state, dispatch, i18n);
     case "sinusoid":
       return renderSinusoidGraph(state, dispatch);
     case "none":
@@ -37670,19 +37809,21 @@ class LabelImage extends React__namespace.Component {
     this._mounted = false;
   }
   getUserInput() {
-    const {
-      markers
-    } = this.props;
     return {
-      markers
+      markers: this.props.markers.map(marker => ({
+        selected: marker.selected,
+        label: marker.label
+      }))
     };
   }
   getPromptJSON() {
     return getPromptJSON$a(this.props, this.getUserInput());
   }
 
-  // TODO(LEMS-2544): Investigate impact on scoring; possibly pull out &/or remove rubric parameter.
-  showRationalesForCurrentlySelectedChoices(rubric) {
+  // TODO(LEMS-2544): Investigate impact on scoring
+  // Also consider how scoreMarker is being called as it seems to require the marker.answers property.
+  // Removed rubric parameter, but it gets a full widget options object from the renderer
+  showRationalesForCurrentlySelectedChoices() {
     const {
       markers
     } = this.props;
@@ -37690,7 +37831,7 @@ class LabelImage extends React__namespace.Component {
       onChange
     } = this.props;
     const updatedMarkers = markers.map(marker => {
-      const score = perseusScore.scoreLabelImageMarker(marker);
+      const score = perseusScore.scoreLabelImageMarker(marker.selected, marker.answers);
       return {
         ...marker,
         // Reveal correctness state for markers with answers.
@@ -37798,6 +37939,7 @@ class LabelImage extends React__namespace.Component {
       selected: selected.length ? selected : undefined
     });
   }
+  // TODO(LEMS-2723): Investigate if possible to change this to not require answers
   renderMarkers() {
     const {
       markers,
@@ -37839,7 +37981,7 @@ class LabelImage extends React__namespace.Component {
           bottom: "top"
         }[markerPosition];
       }
-      const score = perseusScore.scoreLabelImageMarker(marker);
+      const score = perseusScore.scoreLabelImageMarker(marker.selected, marker.answers);
       // Once the question is answered, show markers
       // with correct answers, otherwise passthrough
       // the correctness state.
@@ -39384,7 +39526,10 @@ var Matrix$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusMatrixUserInput'.
-  scorer: perseusScore.scoreMatrix
+  scorer: perseusScore.scoreMatrix,
+  // TODO(LEMS-2656): remove TS suppression
+  // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusMatrixUserInput'.
+  validator: perseusScore.validateMatrix
 };
 
 const getPromptJSON$7 = () => {
@@ -39493,34 +39638,13 @@ class Measurer extends React__namespace.Component {
     }));
   }
 }
-const propUpgrades = {
-  "1": v0props => {
-    const {
-      imageUrl,
-      imageTop,
-      imageLeft,
-      ...rest
-    } = v0props;
-    return {
-      ...rest,
-      image: {
-        url: imageUrl,
-        top: imageTop,
-        left: imageLeft
-      }
-    };
-  }
-};
 var Measurer$1 = {
   name: "measurer",
   displayName: "Measurer",
   hidden: true,
   widget: Measurer,
-  version: {
-    major: 1,
-    minor: 0
-  },
-  propUpgrades: propUpgrades,
+  version: perseusCore.measurerLogic.version,
+  propUpgrades: perseusCore.measurerLogic.widgetOptionsUpgrades,
   // TODO: things that aren't interactive shouldn't need scoring functions
   scorer: () => scoreNoop(1)
 };
@@ -40095,10 +40219,10 @@ function parseBondModifier(smiles, ctx) {
   const firstChar = smiles[0];
   const rest = smiles.slice(1);
   if (firstChar === "=") {
-    return parse$2(rest, _mset(ctx, ["bond", "bondType"], "double"));
+    return parse$1(rest, _mset(ctx, ["bond", "bondType"], "double"));
   }
   if (firstChar === "#") {
-    return parse$2(rest, _mset(ctx, ["bond", "bondType"], "triple"));
+    return parse$1(rest, _mset(ctx, ["bond", "bondType"], "triple"));
   }
   throw new ParseError$1("Invalid character: " + firstChar);
 }
@@ -40159,8 +40283,8 @@ function parseParenthesizedExpression(smiles, ctx) {
       idx: newCtx.idx.concat([[inBranchIdx, 0]]),
       parens: newCtx.parens.concat("(")
     };
-    const parenExpr = parse$2(rest, parenCtx);
-    const remainder = parse$2(sliceFromMatchingCloseParen(rest, ["("]), newCtx);
+    const parenExpr = parse$1(rest, parenCtx);
+    const remainder = parse$1(sliceFromMatchingCloseParen(rest, ["("]), newCtx);
     return [parenExpr].concat(remainder);
   }
   if (firstChar === ")") {
@@ -40224,7 +40348,7 @@ function parseAtom(smiles, ctx) {
 
   // increment the atom counter and reset the branch counter
   const newCtx = _mset(ctx, ["idx", ctx.idx.length - 1], [1 + ctx.idx[ctx.idx.length - 1][0], 0]);
-  let restOfMolecule = parse$2(rest, _mset(newCtx, ["bond", "bondType"], "single"));
+  let restOfMolecule = parse$1(rest, _mset(newCtx, ["bond", "bondType"], "single"));
   if (!Array.isArray(restOfMolecule) && !!restOfMolecule) {
     //TODO(colin): fix this awkwardness.
     restOfMolecule = [restOfMolecule];
@@ -40263,7 +40387,7 @@ function isModifierChar(s) {
  *     ParseError: if the input is not valid SMILES or contains features not
  *         yet implemented.
  */
-function parse$2(smiles, ctx) {
+function parse$1(smiles, ctx) {
   if (!validate(smiles)) {
     throw new ParseError$1("Invalid input.");
   }
@@ -40288,7 +40412,7 @@ function parse$2(smiles, ctx) {
   return parseParenthesizedExpression(smiles, ctx);
 }
 var SmilesParser = {
-  parse: parse$2,
+  parse: parse$1,
   ParseError: ParseError$1
 };
 
@@ -40296,7 +40420,7 @@ var SmilesParser = {
 const {
   layout
 } = MoleculeLayout;
-const parse$1 = SmilesParser.parse;
+const parse = SmilesParser.parse;
 const ParseError = SmilesParser.ParseError;
 const borderSize = 30;
 class Molecule extends React__namespace.Component {
@@ -40323,7 +40447,7 @@ class Molecule extends React__namespace.Component {
     try {
       this.setState({
         // @ts-expect-error - TS2554 - Expected 2 arguments, but got 1.
-        parsedSmiles: parse$1(smiles),
+        parsedSmiles: parse(smiles),
         error: null
       });
     } catch (e) {
@@ -40988,7 +41112,10 @@ var NumberLine$1 = {
   staticTransform: staticTransform$1,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusNumberLineUserInput'.
-  scorer: perseusScore.scoreNumberLine
+  scorer: perseusScore.scoreNumberLine,
+  // TODO(LEMS-2656): remove TS suppression
+  // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusNumberLineUserInput'.
+  validator: perseusScore.validateNumberLine
 };
 
 const getPromptJSON$5 = (renderProps, userInput) => {
@@ -41542,7 +41669,11 @@ var Orderer$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type UserInput is not assignable to type PerseusOrdererUserInput
-  scorer: perseusScore.scoreOrderer
+  scorer: perseusScore.scoreOrderer,
+  // TODO(LEMS-2656): remove TS suppression
+  // @ts-expect-error: Type UserInput is not assignable to type PerseusOrdererUserInput
+  validator: perseusScore.validateOrderer,
+  getPublicWidgetOptions: perseusCore.getOrdererPublicWidgetOptions
 };
 
 /* eslint-disable @khanacademy/ts-no-error-suppressions */
@@ -41591,10 +41722,6 @@ var PassageRefTarget$1 = {
   transform: editorProps => {
     return ___default["default"].pick(editorProps, "content");
   },
-  version: {
-    major: 0,
-    minor: 0
-  },
   isLintable: true,
   // TODO: things that aren't interactive shouldn't need scoring functions
   scorer: () => scoreNoop()
@@ -42618,7 +42745,10 @@ var Plotter$1 = {
   staticTransform: staticTransform,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type UserInput is not assignable to type PerseusPlotterUserInput
-  scorer: perseusScore.scorePlotter
+  scorer: perseusScore.scorePlotter,
+  // TODO(LEMS-2656): remove TS suppression
+  // @ts-expect-error: Type UserInput is not assignable to type PerseusPlotterUserInput
+  validator: perseusScore.validatePlotter
 };
 
 const getPromptJSON$2 = () => {
@@ -42781,7 +42911,10 @@ var Sorter$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type UserInput is not assignable to type PerseusSorterUserInput
-  scorer: perseusScore.scoreSorter
+  scorer: perseusScore.scoreSorter,
+  // TODO(LEMS-2656): remove TS suppression
+  // @ts-expect-error: Type UserInput is not assignable to type PerseusSorterUserInput
+  validator: perseusScore.validateSorter
 };
 
 const {
@@ -43000,7 +43133,10 @@ var Table$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type UserInput is not assignable to type PerseusTableUserInput
-  scorer: perseusScore.scoreTable
+  scorer: perseusScore.scoreTable,
+  // TODO(LEMS-2656): remove TS suppression
+  // @ts-expect-error: Type UserInput is not assignable to type PerseusTableUserInput
+  validator: perseusScore.validateTable
 };
 
 const getPromptJSON = () => {
@@ -43185,7 +43321,7 @@ const init = function () {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus";
-const libVersion = "51.0.1";
+const libVersion = "52.0.1";
 perseusCore.addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {
@@ -44631,6 +44767,69 @@ const registerAllWidgetsForTesting = () => {
   replaceDeprecatedWidgets();
 };
 
+/**
+ * Get a widget type by a widget's ID
+ * (please don't derive type from ID)
+ *
+ * @param {string} widgetId the ID of the widget
+ * @param {PerseusWidgetsMap} widgetMap widget ID to widget map
+ * @returns {string} the widget type (ie "radio")
+ */
+function getWidgetTypeByWidgetId(WidgetId, widgetMap) {
+  const widget = widgetMap[WidgetId];
+  return widget?.type ?? null;
+}
+
+/**
+ * Does the content have a specific type of widget?
+ *
+ * @param {string} type the type of the widget in question (ie "radio")
+ * @param {string} content the string to search through
+ * @param {PerseusWidgetsMap} widgetMap widget ID to widget map
+ * @returns {boolean} if the content includes the widget type
+ */
+function contentHasWidgetType(type, content, widgetMap) {
+  return perseusCore.getWidgetIdsFromContentByType(type, content, widgetMap).length > 0;
+}
+
+/**
+ * Pull the widget map out of ItemData
+ *
+ * @param {PerseusItem} PerseusItem containing a widgetMap
+ * @returns {WidgetMap} the widget map in the PerseusItem
+ */
+function getWidgetsMapFromItemData(itemData) {
+  return itemData.question.widgets;
+}
+
+/**
+ * Get the widget information from a WidgetMap
+ *
+ * @param {string} widgetId the ID of the widget
+ * @returns {PerseusWidget | null} the widget data if it exists, otherwise null
+ */
+function getWidgetFromWidgetMap(widgetId, widgetMap) {
+  return widgetMap[widgetId] ?? null;
+}
+
+/**
+ * Get select widgets from a widget map.
+ *
+ * @param {ReadonlyArray<string>} widgetIds to extract
+ * @param {PerseusWidgetsMap} widgetMap to extract from
+ * @return {PerseusWidgetsMap} a new widget map with requested widgets
+ */
+function getWidgetsFromWidgetMap(widgetIds, widgetMap) {
+  const widgets = {};
+  widgetIds.forEach(widgetId => {
+    const widget = getWidgetFromWidgetMap(widgetId, widgetMap);
+    if (widget) {
+      widgets[widgetId] = widget;
+    }
+  });
+  return widgets;
+}
+
 /**
  * This function extracts the answers from the widgets.
  *
@@ -45154,1683 +45353,6 @@ const getValidWidgetIds = perseusItem => {
   return wonderStuffCore.keys(widgets).filter(id => isWidgetIdInContent(perseusItem, id));
 };
 
-function isRealJSONParse(jsonParse) {
-  const randomPhrase = buildRandomPhrase();
-  const randomHintPhrase = buildRandomPhrase();
-  const randomString = buildRandomString();
-  const testingObject = JSON.stringify({
-    answerArea: {
-      calculator: false,
-      chi2Table: false,
-      financialCalculatorMonthlyPayment: false,
-      financialCalculatorTimeToPayOff: false,
-      financialCalculatorTotalAmount: false,
-      periodicTable: false,
-      periodicTableWithKey: false,
-      tTable: false,
-      zTable: false
-    },
-    hints: [randomHintPhrase, `=${Math.floor(Math.random() * 50) + 1}`],
-    itemDataVersion: {
-      major: 0,
-      minor: 1
-    },
-    question: {
-      content: `${randomPhrase}`,
-      images: {},
-      widgets: {
-        expression1: {
-          alignment: "default",
-          graded: false,
-          options: {
-            answerForms: [{
-              considered: "wrong",
-              form: false,
-              key: 0,
-              simplify: false,
-              value: `${randomString}`
-            }],
-            ariaLabel: "Answer",
-            buttonSets: ["basic"],
-            functions: ["f", "g", "h"],
-            static: true,
-            times: false,
-            visibleLabel: "Answer"
-          },
-          static: true,
-          type: "expression",
-          version: {
-            major: 1,
-            minor: 0
-          }
-        }
-      }
-    }
-  });
-  const testJSON = buildTestData(testingObject.replace(/"/g, '\\"'));
-  const parsedTestJSON = jsonParse(testJSON);
-  const parsedTestItemData = parsedTestJSON.data.assessmentItem.item.itemData;
-  return perseusCore.approximateDeepEqual(parsedTestItemData, testingObject);
-}
-function buildRandomString() {
-  let capitalize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-  let randomString = "";
-  const randomLength = Math.floor(Math.random() * 8) + 3;
-  for (let i = 0; i < randomLength; i++) {
-    const randomLetter = String.fromCharCode(97 + Math.floor(Math.random() * 26));
-    randomString += capitalize && i === 0 ? randomLetter.toUpperCase() : randomLetter;
-  }
-  return randomString;
-}
-function buildRandomPhrase() {
-  const phrases = [];
-  const randomLength = Math.floor(Math.random() * 10) + 5;
-  for (let i = 0; i < randomLength; i++) {
-    phrases.push(buildRandomString(i === 0));
-  }
-  const modifierStart = ["**", "$"];
-  const modifierEnd = ["**", "$"];
-  const modifierIndex = Math.floor(Math.random() * modifierStart.length);
-  return `${modifierStart[modifierIndex]}${phrases.join(" ")}${modifierEnd[modifierIndex]}`;
-}
-function buildTestData(testObject) {
-  return `{"data":{"assessmentItem":{"__typename":"AssessmentItemOrError","error":null,"item":{"__typename":"AssessmentItem","id":"x890b3c70f3e8f4a6","itemData":"${testObject}","problemType":"Type 1","sha":"c7284a3ad65214b4e62bccce236d92f7f5d35941"}}}}`;
-}
-
-function success(value) {
-  return {
-    type: "success",
-    value
-  };
-}
-function failure(detail) {
-  return {
-    type: "failure",
-    detail
-  };
-}
-function isFailure(result) {
-  return result.type === "failure";
-}
-function isSuccess(result) {
-  return result.type === "success";
-}
-
-// Result's `all` function is similar to Promise.all: given an array of
-// results, it returns success if all succeeded, and failure if any failed.
-function all(results) {
-  let combineFailureDetails = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : a => a;
-  const values = [];
-  const failureDetails = [];
-  for (const result of results) {
-    if (result.type === "success") {
-      values.push(result.value);
-    } else {
-      failureDetails.push(result.detail);
-    }
-  }
-  if (failureDetails.length > 0) {
-    return failure(failureDetails.reduce(combineFailureDetails));
-  }
-  return success(values);
-}
-
-class ErrorTrackingParseContext {
-  constructor(path) {
-    this.path = path;
-  }
-  failure(expected, badValue) {
-    return failure([{
-      expected: wrapInArray(expected),
-      badValue,
-      path: this.path
-    }]);
-  }
-  forSubtree(key) {
-    return new ErrorTrackingParseContext([...this.path, key]);
-  }
-  success(value) {
-    return success(value);
-  }
-}
-function wrapInArray(a) {
-  return Array.isArray(a) ? a : [a];
-}
-
-function formatPath(path) {
-  return "(root)" + path.map(formatPathSegment).join("");
-}
-function formatPathSegment(segment) {
-  if (typeof segment === "string") {
-    return validIdentifier.test(segment) ? "." + segment : `[${JSON.stringify(segment)}]`;
-  }
-  return `[${segment.toString()}]`;
-}
-const validIdentifier = /^[A-Za-z$_][A-Za-z$_0-9]*$/;
-
-function message(failure) {
-  const expected = conjoin(failure.expected);
-  const path = formatPath(failure.path);
-  const badValue = JSON.stringify(failure.badValue);
-  return `At ${path} -- expected ${expected}, but got ${badValue}`;
-}
-function conjoin(items) {
-  switch (items.length) {
-    // TODO(benchristel): handle 0 if this is reused elsewhere.
-    case 1:
-      return items[0];
-    case 2:
-      return items.join(" or ");
-    default:
-      {
-        const allButLast = items.slice(0, items.length - 1);
-        const last = items[items.length - 1];
-        return allButLast.join(", ") + ", or " + last;
-      }
-  }
-}
-
-function parse(value, parser) {
-  const result = parser(value, new ErrorTrackingParseContext([]));
-  if (isFailure(result)) {
-    return failure(result.detail.map(message).join("; "));
-  }
-  return result;
-}
-
-const any = (rawValue, ctx) => ctx.success(rawValue);
-
-function array(elementParser) {
-  return (rawValue, ctx) => {
-    if (!Array.isArray(rawValue)) {
-      return ctx.failure("array", rawValue);
-    }
-    const elementResults = rawValue.map((elem, i) => elementParser(elem, ctx.forSubtree(i)));
-    return all(elementResults, concat);
-  };
-}
-function concat(a, b) {
-  return [...a, ...b];
-}
-
-function boolean(rawValue, ctx) {
-  if (typeof rawValue === "boolean") {
-    return ctx.success(rawValue);
-  }
-  return ctx.failure("boolean", rawValue);
-}
-
-function constant(acceptedValue) {
-  return (rawValue, ctx) => {
-    if (rawValue !== acceptedValue) {
-      return ctx.failure(String(JSON.stringify(acceptedValue)), rawValue);
-    }
-    return ctx.success(acceptedValue);
-  };
-}
-
-function enumeration() {
-  for (var _len = arguments.length, acceptedValues = new Array(_len), _key = 0; _key < _len; _key++) {
-    acceptedValues[_key] = arguments[_key];
-  }
-  return (rawValue, ctx) => {
-    if (typeof rawValue === "string") {
-      const index = acceptedValues.indexOf(rawValue);
-      if (index > -1) {
-        return ctx.success(acceptedValues[index]);
-      }
-    }
-    const expected = acceptedValues.map(v => JSON.stringify(v));
-    return ctx.failure(expected, rawValue);
-  };
-}
-
-function isObject(x) {
-  return x != null && Object.getPrototypeOf(x) === Object.prototype;
-}
-
-function nullable(parseValue) {
-  return (rawValue, ctx) => {
-    if (rawValue === null) {
-      return ctx.success(rawValue);
-    }
-    return parseValue(rawValue, ctx);
-  };
-}
-
-const number = (rawValue, ctx) => {
-  if (typeof rawValue === "number") {
-    return ctx.success(rawValue);
-  }
-  return ctx.failure("number", rawValue);
-};
-
-function object(schema) {
-  return (rawValue, ctx) => {
-    if (!isObject(rawValue)) {
-      return ctx.failure("object", rawValue);
-    }
-    const ret = {
-      ...rawValue
-    };
-    const mismatches = [];
-    for (const [prop, propParser] of Object.entries(schema)) {
-      const result = propParser(rawValue[prop], ctx.forSubtree(prop));
-      if (isSuccess(result)) {
-        if (result.value !== undefined || prop in rawValue) {
-          ret[prop] = result.value;
-        }
-      } else {
-        mismatches.push(...result.detail);
-      }
-    }
-    if (mismatches.length > 0) {
-      return failure(mismatches);
-    }
-    return ctx.success(ret);
-  };
-}
-
-function optional(parseValue) {
-  return (rawValue, ctx) => {
-    if (rawValue === undefined) {
-      return ctx.success(rawValue);
-    }
-    return parseValue(rawValue, ctx);
-  };
-}
-
-function pair(parseA, parseB) {
-  return (rawValue, ctx) => {
-    if (!Array.isArray(rawValue)) {
-      return ctx.failure("array", rawValue);
-    }
-    if (rawValue.length !== 2) {
-      return ctx.failure("array of length 2", rawValue);
-    }
-    const [rawA, rawB] = rawValue;
-    const resultA = parseA(rawA, ctx.forSubtree(0));
-    if (isFailure(resultA)) {
-      return resultA;
-    }
-    const resultB = parseB(rawB, ctx.forSubtree(1));
-    if (isFailure(resultB)) {
-      return resultB;
-    }
-    return ctx.success([resultA.value, resultB.value]);
-  };
-}
-
-function pipeParsers(p) {
-  return new ParserPipeline(p);
-}
-class ParserPipeline {
-  constructor(parser) {
-    this.parser = parser;
-  }
-  then(nextParser) {
-    return new ParserPipeline(composeParsers(this.parser, nextParser));
-  }
-}
-function composeParsers(parserA, parserB) {
-  return (rawValue, ctx) => {
-    const partialResult = parserA(rawValue, ctx);
-    if (isFailure(partialResult)) {
-      return partialResult;
-    }
-    return parserB(partialResult.value, ctx);
-  };
-}
-
-function record(parseKey, parseValue) {
-  return (rawValue, ctx) => {
-    if (!isObject(rawValue)) {
-      return ctx.failure("object", rawValue);
-    }
-    const result = {};
-    const mismatches = [];
-    for (const [key, value] of Object.entries(rawValue)) {
-      const entryCtx = ctx.forSubtree(key);
-      const keyResult = parseKey(key, entryCtx);
-      if (isFailure(keyResult)) {
-        mismatches.push(...keyResult.detail);
-      }
-      const valueResult = parseValue(value, entryCtx);
-      if (isFailure(valueResult)) {
-        mismatches.push(...valueResult.detail);
-      }
-      if (isSuccess(keyResult) && isSuccess(valueResult)) {
-        result[keyResult.value] = valueResult.value;
-      }
-    }
-    if (mismatches.length > 0) {
-      return failure(mismatches);
-    }
-    return ctx.success(result);
-  };
-}
-
-const string = (rawValue, ctx) => {
-  if (typeof rawValue === "string") {
-    return ctx.success(rawValue);
-  }
-  return ctx.failure("string", rawValue);
-};
-
-function trio(parseA, parseB, parseC) {
-  return (rawValue, ctx) => {
-    if (!Array.isArray(rawValue)) {
-      return ctx.failure("array", rawValue);
-    }
-    if (rawValue.length !== 3) {
-      return ctx.failure("array of length 3", rawValue);
-    }
-    const resultA = parseA(rawValue[0], ctx.forSubtree(0));
-    if (isFailure(resultA)) {
-      return resultA;
-    }
-    const resultB = parseB(rawValue[1], ctx.forSubtree(1));
-    if (isFailure(resultB)) {
-      return resultB;
-    }
-    const resultC = parseC(rawValue[2], ctx.forSubtree(2));
-    if (isFailure(resultC)) {
-      return resultC;
-    }
-    return ctx.success([resultA.value, resultB.value, resultC.value]);
-  };
-}
-
-function union(parseBranch) {
-  return new UnionBuilder(parseBranch);
-}
-class UnionBuilder {
-  constructor(parser) {
-    this.parser = parser;
-  }
-  or(newBranch) {
-    return new UnionBuilder(either(this.parser, newBranch));
-  }
-}
-function either(parseA, parseB) {
-  return (rawValue, ctx) => {
-    const resultA = parseA(rawValue, ctx);
-    if (isSuccess(resultA)) {
-      return resultA;
-    }
-    return parseB(rawValue, ctx);
-  };
-}
-
-function defaulted(parser, fallback) {
-  return (rawValue, ctx) => {
-    if (rawValue == null) {
-      return success(fallback(rawValue));
-    }
-    return parser(rawValue, ctx);
-  };
-}
-
-const parseImages = defaulted(record(string, object({
-  width: number,
-  height: number
-})), () => ({}));
-
-function parseWidget(parseType, parseOptions) {
-  return object({
-    type: parseType,
-    static: optional(boolean),
-    graded: optional(boolean),
-    alignment: optional(string),
-    options: parseOptions,
-    key: optional(number),
-    version: optional(object({
-      major: number,
-      minor: number
-    }))
-  });
-}
-function parseWidgetWithVersion(parseVersion, parseType, parseOptions) {
-  return object({
-    type: parseType,
-    static: optional(boolean),
-    graded: optional(boolean),
-    alignment: optional(string),
-    options: parseOptions,
-    key: optional(number),
-    version: parseVersion
-  });
-}
-
-const parseCategorizerWidget = parseWidget(constant("categorizer"), object({
-  items: array(string),
-  categories: array(string),
-  randomizeItems: defaulted(boolean, () => false),
-  static: defaulted(boolean, () => false),
-  values: array(defaulted(number, () => 0)),
-  highlightLint: optional(boolean),
-  linterContext: optional(object({
-    contentType: string,
-    paths: array(string),
-    stack: array(string)
-  }))
-}));
-
-const parseCSProgramWidget = parseWidget(constant("cs-program"), object({
-  programID: string,
-  programType: any,
-  settings: array(object({
-    name: string,
-    value: string
-  })),
-  showEditor: boolean,
-  showButtons: boolean,
-  height: number,
-  static: defaulted(boolean, () => false)
-}));
-
-const parseDefinitionWidget = parseWidget(constant("definition"), object({
-  togglePrompt: string,
-  definition: string,
-  static: defaulted(boolean, () => false)
-}));
-
-const parseDropdownWidget = parseWidget(constant("dropdown"), object({
-  placeholder: defaulted(string, () => ""),
-  ariaLabel: optional(string),
-  visibleLabel: optional(string),
-  static: defaulted(boolean, () => false),
-  choices: array(object({
-    content: string,
-    correct: boolean
-  }))
-}));
-
-const parseExplanationWidget = parseWidget(constant("explanation"), object({
-  showPrompt: string,
-  hidePrompt: string,
-  explanation: string,
-  // We wrap parseWidgetsMap in a function here to make sure it is not
-  // referenced before it is defined. There is an import cycle between
-  // this file and widgets-map.ts that could cause it to be undefined.
-  widgets: defaulted((rawVal, ctx) => parseWidgetsMap(rawVal, ctx), () => ({})),
-  static: defaulted(boolean, () => false)
-}));
-
-// Given a function, creates a PartialParser that converts one type to another
-// using that function. The returned parser never fails.
-function convert(f) {
-  return (rawValue, ctx) => ctx.success(f(rawValue));
-}
-
-/**
- * Creates a parser for a widget options type with multiple major versions. Old
- * versions are migrated to the latest version. The parse fails if the input
- * data does not match any of the versions.
- *
- * @example
- * const parseOptions = versionedWidgetOptions(3, parseOptionsV3)
- *     .withMigrationFrom(2, parseOptionsV2, migrateV2ToV3)
- *     .withMigrationFrom(1, parseOptionsV1, migrateV1ToV2)
- *     .withMigrationFrom(0, parseOptionsV0, migrateV0ToV1)
- *     .parser;
- *
- * @param latestMajorVersion the latest major version of the widget options.
- * @param parseLatest a {@link Parser} for the latest version of the widget
- * options.
- * @returns a builder object, to which migrations from earlier versions can be
- * added. Migrations must be added in "reverse chronological" order as in the
- * example above.
- */
-function versionedWidgetOptions(latestMajorVersion, parseLatest) {
-  return new VersionedWidgetOptionsParserBuilder(latestMajorVersion, parseLatest, latest => latest, (raw, ctx) => ctx.failure("widget options with a known version number", raw));
-}
-class VersionedWidgetOptionsParserBuilder {
-  parser;
-  constructor(majorVersion, parseThisVersion, migrateToLatest, parseOtherVersions) {
-    this.migrateToLatest = migrateToLatest;
-    this.parseOtherVersions = parseOtherVersions;
-    const parseThisVersionAndMigrateToLatest = pipeParsers(parseThisVersion).then(convert(this.migrateToLatest)).parser;
-    this.parser = (raw, ctx) => {
-      if (!isObject(raw)) {
-        return ctx.failure("object", raw);
-      }
-      const versionParseResult = parseVersionedObject(raw, ctx);
-      if (isFailure(versionParseResult)) {
-        return versionParseResult;
-      }
-      if (versionParseResult.value.version.major !== majorVersion) {
-        return this.parseOtherVersions(raw, ctx);
-      }
-      return parseThisVersionAndMigrateToLatest(raw, ctx);
-    };
-  }
-
-  /**
-   * Add a migration from an old version of the widget options.
-   */
-  withMigrationFrom(majorVersion, parseOldVersion, migrateToNextVersion) {
-    const parseOtherVersions = this.parser;
-    const migrateToLatest = old => this.migrateToLatest(migrateToNextVersion(old));
-    return new VersionedWidgetOptionsParserBuilder(majorVersion, parseOldVersion, migrateToLatest, parseOtherVersions);
-  }
-}
-const parseVersionedObject = object({
-  version: defaulted(object({
-    major: number,
-    minor: number
-  }), () => ({
-    major: 0,
-    minor: 0
-  }))
-});
-
-const stringOrNumberOrNullOrUndefined = union(string).or(number).or(constant(null)).or(constant(undefined)).parser;
-const parsePossiblyInvalidAnswerForm = object({
-  // `value` is the possibly invalid part of this. It should always be a
-  // string, but some answer forms don't have it. The Expression widget
-  // ignores invalid values, so we can safely filter them out during parsing.
-  value: optional(string),
-  form: defaulted(boolean, () => false),
-  simplify: defaulted(boolean, () => false),
-  considered: enumeration("correct", "wrong", "ungraded"),
-  key: pipeParsers(stringOrNumberOrNullOrUndefined).then(convert(String)).parser
-});
-function removeInvalidAnswerForms(possiblyInvalid) {
-  const valid = [];
-  for (const answerForm of possiblyInvalid) {
-    const {
-      value
-    } = answerForm;
-    if (value != null) {
-      // Copying the object seems to be needed to make TypeScript happy
-      valid.push({
-        ...answerForm,
-        value
-      });
-    }
-  }
-  return valid;
-}
-
-// NOTE(benchristel): I copied the default buttonSets from
-// expression.tsx. See the parse-perseus-json/README.md for
-// an explanation of why we want to duplicate the default here.
-const parseButtonSets = defaulted(array(enumeration("basic", "basic+div", "trig", "prealgebra", "logarithms", "basic relations", "advanced relations")), () => ["basic", "trig", "prealgebra", "logarithms"]);
-const version1 = object({
-  major: constant(1),
-  minor: number
-});
-const parseExpressionWidgetV1 = parseWidgetWithVersion(version1, constant("expression"), object({
-  answerForms: pipeParsers(array(parsePossiblyInvalidAnswerForm)).then(convert(removeInvalidAnswerForms)).parser,
-  functions: array(string),
-  times: boolean,
-  visibleLabel: optional(string),
-  ariaLabel: optional(string),
-  buttonSets: parseButtonSets,
-  buttonsVisible: optional(enumeration("always", "never", "focused"))
-}));
-const version0 = optional(object({
-  major: constant(0),
-  minor: number
-}));
-const parseExpressionWidgetV0 = parseWidgetWithVersion(version0, constant("expression"), object({
-  functions: array(string),
-  times: boolean,
-  visibleLabel: optional(string),
-  ariaLabel: optional(string),
-  form: boolean,
-  simplify: boolean,
-  value: string,
-  buttonSets: parseButtonSets,
-  buttonsVisible: optional(enumeration("always", "never", "focused"))
-}));
-function migrateV0ToV1(widget) {
-  const {
-    options
-  } = widget;
-  return {
-    ...widget,
-    version: {
-      major: 1,
-      minor: 0
-    },
-    options: {
-      times: options.times,
-      buttonSets: options.buttonSets,
-      functions: options.functions,
-      buttonsVisible: options.buttonsVisible,
-      visibleLabel: options.visibleLabel,
-      ariaLabel: options.ariaLabel,
-      answerForms: [{
-        considered: "correct",
-        form: options.form,
-        simplify: options.simplify,
-        value: options.value
-      }]
-    }
-  };
-}
-const parseExpressionWidget = versionedWidgetOptions(1, parseExpressionWidgetV1).withMigrationFrom(0, parseExpressionWidgetV0, migrateV0ToV1).parser;
-
-const falseToNull = pipeParsers(constant(false)).then(convert(() => null)).parser;
-const parseGradedGroupWidgetOptions = object({
-  title: defaulted(string, () => ""),
-  hasHint: optional(nullable(boolean)),
-  // This module has an import cycle with parsePerseusRenderer.
-  // The anonymous function below ensures that we don't try to access
-  // parsePerseusRenderer before it's defined.
-  hint: union(falseToNull).or(constant(null)).or(constant(undefined)).or((rawVal, ctx) => parsePerseusRenderer(rawVal, ctx)).parser,
-  content: string,
-  // This module has an import cycle with parseWidgetsMap.
-  // The anonymous function below ensures that we don't try to access
-  // parseWidgetsMap before it's defined.
-  widgets: (rawVal, ctx) => parseWidgetsMap(rawVal, ctx),
-  widgetEnabled: optional(nullable(boolean)),
-  immutableWidgets: optional(nullable(boolean)),
-  images: record(string, object({
-    width: number,
-    height: number
-  }))
-});
-const parseGradedGroupWidget = parseWidget(constant("graded-group"), parseGradedGroupWidgetOptions);
-
-const parseGradedGroupSetWidget = parseWidget(constant("graded-group-set"), object({
-  gradedGroups: array(parseGradedGroupWidgetOptions)
-}));
-
-/**
- * discriminatedUnion() should be preferred over union() when parsing a
- * discriminated union type, because discriminatedUnion() produces more
- * understandable failure messages. It takes the discriminant as the source of
- * truth for which variant is to be parsed, and expects the other data to match
- * that variant.
- */
-function discriminatedUnionOn(discriminantKey) {
-  const noMoreBranches = (raw, ctx) => {
-    if (!isObject(raw)) {
-      return ctx.failure("object", raw);
-    }
-    return ctx.forSubtree(discriminantKey).failure("a valid value", raw[discriminantKey]);
-  };
-  return new DiscriminatedUnionBuilder(discriminantKey, noMoreBranches);
-}
-class DiscriminatedUnionBuilder {
-  constructor(discriminantKey, parser) {
-    this.discriminantKey = discriminantKey;
-    this.parser = parser;
-  }
-  withBranch(discriminantValue, parseNewVariant) {
-    const parseNewBranch = discriminatedUnionBranch(this.discriminantKey, discriminantValue, parseNewVariant, this.parser);
-    return new DiscriminatedUnionBuilder(this.discriminantKey, parseNewBranch);
-  }
-}
-function discriminatedUnionBranch(discriminantKey, discriminantValue, parseVariant, parseOtherBranches) {
-  return (raw, ctx) => {
-    if (!isObject(raw)) {
-      return ctx.failure("object", raw);
-    }
-    if (raw[discriminantKey] === discriminantValue) {
-      return parseVariant(raw, ctx);
-    }
-    return parseOtherBranches(raw, ctx);
-  };
-}
-
-const pairOfNumbers$3 = pair(number, number);
-const pairOfPoints = pair(pairOfNumbers$3, pairOfNumbers$3);
-const parseGrapherWidget = parseWidget(constant("grapher"), object({
-  availableTypes: array(enumeration("absolute_value", "exponential", "linear", "logarithm", "quadratic", "sinusoid", "tangent")),
-  correct: discriminatedUnionOn("type").withBranch("absolute_value", object({
-    type: constant("absolute_value"),
-    coords: nullable(pairOfPoints)
-  })).withBranch("exponential", object({
-    type: constant("exponential"),
-    asymptote: pairOfPoints,
-    coords: nullable(pairOfPoints)
-  })).withBranch("linear", object({
-    type: constant("linear"),
-    coords: nullable(pairOfPoints)
-  })).withBranch("logarithm", object({
-    type: constant("logarithm"),
-    asymptote: pairOfPoints,
-    coords: nullable(pairOfPoints)
-  })).withBranch("quadratic", object({
-    type: constant("quadratic"),
-    coords: nullable(pairOfPoints)
-  })).withBranch("sinusoid", object({
-    type: constant("sinusoid"),
-    coords: nullable(pairOfPoints)
-  })).withBranch("tangent", object({
-    type: constant("tangent"),
-    coords: nullable(pairOfPoints)
-  })).parser,
-  graph: object({
-    backgroundImage: object({
-      bottom: optional(number),
-      height: optional(number),
-      left: optional(number),
-      scale: optional(number),
-      url: optional(nullable(string)),
-      width: optional(number)
-    }),
-    box: optional(pairOfNumbers$3),
-    editableSettings: optional(array(enumeration("graph", "snap", "image", "measure"))),
-    gridStep: optional(pairOfNumbers$3),
-    labels: pair(string, string),
-    markings: enumeration("graph", "none", "grid"),
-    range: pair(pairOfNumbers$3, pairOfNumbers$3),
-    rulerLabel: constant(""),
-    rulerTicks: number,
-    showProtractor: optional(boolean),
-    showRuler: optional(boolean),
-    showTooltips: optional(boolean),
-    snapStep: optional(pairOfNumbers$3),
-    step: pairOfNumbers$3,
-    valid: optional(union(boolean).or(string).parser)
-  })
-}));
-
-const parseGroupWidget = parseWidget(constant("group"),
-// This module has an import cycle with parsePerseusRenderer.
-// The anonymous function below ensures that we don't try to access
-// parsePerseusRenderer before it's defined.
-(rawVal, ctx) => parsePerseusRenderer(rawVal, ctx));
-
-const parseIframeWidget = parseWidget(constant("iframe"), object({
-  url: string,
-  settings: optional(array(object({
-    name: string,
-    value: string
-  }))),
-  width: union(number).or(string).parser,
-  height: union(number).or(string).parser,
-  allowFullScreen: defaulted(boolean, () => false),
-  allowTopNavigation: optional(boolean),
-  static: defaulted(boolean, () => false)
-}));
-
-const stringToNumber = (rawValue, ctx) => {
-  if (typeof rawValue === "number") {
-    return ctx.success(rawValue);
-  }
-  const parsedNumber = +rawValue;
-  if (rawValue === "" || isNaN(parsedNumber)) {
-    return ctx.failure("a number or numeric string", rawValue);
-  }
-  return ctx.success(parsedNumber);
-};
-
-function emptyToZero(x) {
-  return x === "" ? 0 : x;
-}
-const imageDimensionToNumber = pipeParsers(union(number).or(string).parser)
-// In this specific case, empty string is equivalent to zero. An empty
-// string parses to either NaN (using parseInt) or 0 (using unary +) and
-// CSS will treat NaN as invalid and default to 0 instead.
-.then(convert(emptyToZero)).then(stringToNumber).parser;
-const parsePerseusImageBackground = object({
-  url: optional(nullable(string)),
-  width: optional(imageDimensionToNumber),
-  height: optional(imageDimensionToNumber),
-  top: optional(imageDimensionToNumber),
-  left: optional(imageDimensionToNumber),
-  bottom: optional(imageDimensionToNumber),
-  scale: optional(imageDimensionToNumber)
-});
-
-const pairOfNumbers$2 = pair(number, number);
-const parseImageWidget = parseWidget(constant("image"), object({
-  title: optional(string),
-  caption: optional(string),
-  alt: optional(string),
-  backgroundImage: parsePerseusImageBackground,
-  static: optional(boolean),
-  labels: optional(array(object({
-    content: string,
-    alignment: string,
-    coordinates: array(number)
-  }))),
-  range: optional(pair(pairOfNumbers$2, pairOfNumbers$2)),
-  box: optional(pairOfNumbers$2)
-}));
-
-const booleanToString = (rawValue, ctx) => {
-  if (typeof rawValue === "boolean") {
-    return ctx.success(String(rawValue));
-  }
-  return ctx.failure("boolean", rawValue);
-};
-const parseInputNumberWidget = parseWidget(constant("input-number"), object({
-  answerType: optional(enumeration("number", "decimal", "integer", "rational", "improper", "mixed", "percent", "pi")),
-  inexact: optional(boolean),
-  maxError: optional(union(number).or(string).parser),
-  rightAlign: optional(boolean),
-  simplify: enumeration("required", "optional", "enforced"),
-  size: enumeration("normal", "small"),
-  // TODO(benchristel): there are some content items where value is a
-  // boolean, even though that makes no sense. We should figure out if
-  // those content items are actually published anywhere, and consider
-  // updating them.
-  value: union(number).or(string).or(booleanToString).parser,
-  customKeypad: optional(boolean)
-}));
-
-const pairOfNumbers$1 = pair(number, number);
-const stringOrEmpty = defaulted(string, () => "");
-const parseKey = pipeParsers(optional(string)).then(convert(String)).parser;
-const parseFunctionElement = object({
-  type: constant("function"),
-  key: parseKey,
-  options: object({
-    value: string,
-    funcName: string,
-    rangeMin: string,
-    rangeMax: string,
-    color: string,
-    strokeDasharray: string,
-    strokeWidth: number
-  })
-});
-const parseLabelElement = object({
-  type: constant("label"),
-  key: parseKey,
-  options: object({
-    label: string,
-    color: string,
-    coordX: string,
-    coordY: string
-  })
-});
-const parseLineElement = object({
-  type: constant("line"),
-  key: parseKey,
-  options: object({
-    color: string,
-    startX: string,
-    startY: string,
-    endX: string,
-    endY: string,
-    strokeDasharray: string,
-    strokeWidth: number,
-    arrows: string
-  })
-});
-const parseMovableLineElement = object({
-  type: constant("movable-line"),
-  key: parseKey,
-  options: object({
-    startX: string,
-    startY: string,
-    startSubscript: number,
-    endX: string,
-    endY: string,
-    endSubscript: number,
-    constraint: string,
-    snap: number,
-    constraintFn: string,
-    constraintXMin: string,
-    constraintXMax: string,
-    constraintYMin: string,
-    constraintYMax: string
-  })
-});
-const parseMovablePointElement = object({
-  type: constant("movable-point"),
-  key: parseKey,
-  options: object({
-    startX: string,
-    startY: string,
-    varSubscript: number,
-    constraint: string,
-    snap: number,
-    constraintFn: string,
-    constraintXMin: stringOrEmpty,
-    constraintXMax: stringOrEmpty,
-    constraintYMin: stringOrEmpty,
-    constraintYMax: stringOrEmpty
-  })
-});
-const parseParametricElement = object({
-  type: constant("parametric"),
-  key: parseKey,
-  options: object({
-    x: string,
-    y: string,
-    rangeMin: string,
-    rangeMax: string,
-    color: string,
-    strokeDasharray: string,
-    strokeWidth: number
-  })
-});
-const parsePointElement = object({
-  type: constant("point"),
-  key: parseKey,
-  options: object({
-    color: string,
-    coordX: string,
-    coordY: string
-  })
-});
-const parseRectangleElement = object({
-  type: constant("rectangle"),
-  key: parseKey,
-  options: object({
-    color: string,
-    coordX: string,
-    coordY: string,
-    width: string,
-    height: string
-  })
-});
-const parseInteractionWidget = parseWidget(constant("interaction"), object({
-  static: defaulted(boolean, () => false),
-  graph: object({
-    editableSettings: optional(array(enumeration("canvas", "graph"))),
-    box: pairOfNumbers$1,
-    labels: array(string),
-    range: pair(pairOfNumbers$1, pairOfNumbers$1),
-    gridStep: pairOfNumbers$1,
-    markings: enumeration("graph", "grid", "none"),
-    snapStep: optional(pairOfNumbers$1),
-    valid: optional(union(boolean).or(string).parser),
-    backgroundImage: optional(parsePerseusImageBackground),
-    showProtractor: optional(boolean),
-    showRuler: optional(boolean),
-    rulerLabel: optional(string),
-    rulerTicks: optional(number),
-    tickStep: pairOfNumbers$1
-  }),
-  elements: array(discriminatedUnionOn("type").withBranch("function", parseFunctionElement).withBranch("label", parseLabelElement).withBranch("line", parseLineElement).withBranch("movable-line", parseMovableLineElement).withBranch("movable-point", parseMovablePointElement).withBranch("parametric", parseParametricElement).withBranch("point", parsePointElement).withBranch("rectangle", parseRectangleElement).parser)
-}));
-
-// Used to represent 2-D points and ranges
-const pairOfNumbers = pair(number, number);
-const parsePerseusGraphTypeAngle = object({
-  type: constant("angle"),
-  showAngles: optional(boolean),
-  allowReflexAngles: optional(boolean),
-  angleOffsetDeg: optional(number),
-  snapDegrees: optional(number),
-  match: optional(constant("congruent")),
-  coords: optional(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers)),
-  startCoords: optional(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers))
-});
-const parsePerseusGraphTypeCircle = object({
-  type: constant("circle"),
-  center: optional(pairOfNumbers),
-  radius: optional(number),
-  startCoords: optional(object({
-    center: pairOfNumbers,
-    radius: number
-  })),
-  // TODO: remove coord? it's legacy.
-  coord: optional(pairOfNumbers)
-});
-const parsePerseusGraphTypeLinear = object({
-  type: constant("linear"),
-  coords: optional(nullable(pair(pairOfNumbers, pairOfNumbers))),
-  startCoords: optional(pair(pairOfNumbers, pairOfNumbers)),
-  // TODO: remove coord? it's legacy.
-  coord: optional(pairOfNumbers)
-});
-const parsePerseusGraphTypeLinearSystem = object({
-  type: constant("linear-system"),
-  // TODO(benchristel): default coords to empty array?
-  coords: optional(nullable(array(pair(pairOfNumbers, pairOfNumbers)))),
-  startCoords: optional(array(pair(pairOfNumbers, pairOfNumbers))),
-  // TODO: remove coord? it's legacy.
-  coord: optional(pairOfNumbers)
-});
-const parsePerseusGraphTypeNone = object({
-  type: constant("none")
-});
-const parsePerseusGraphTypePoint = object({
-  type: constant("point"),
-  numPoints: optional(union(number).or(constant("unlimited")).parser),
-  coords: optional(nullable(array(pairOfNumbers))),
-  startCoords: optional(array(pairOfNumbers)),
-  // TODO: remove coord? it's legacy.
-  coord: optional(pairOfNumbers)
-});
-const parsePerseusGraphTypePolygon = object({
-  type: constant("polygon"),
-  numSides: optional(union(number).or(constant("unlimited")).parser),
-  showAngles: optional(boolean),
-  showSides: optional(boolean),
-  snapTo: optional(enumeration("grid", "angles", "sides")),
-  match: optional(enumeration("similar", "congruent", "approx", "exact")),
-  startCoords: optional(array(pairOfNumbers)),
-  // TODO: remove coord? it's legacy.
-  coord: optional(pairOfNumbers)
-});
-const parsePerseusGraphTypeQuadratic = object({
-  type: constant("quadratic"),
-  coords: optional(nullable(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers))),
-  startCoords: optional(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers)),
-  // TODO: remove coord? it's legacy.
-  coord: optional(pairOfNumbers)
-});
-const parsePerseusGraphTypeRay = object({
-  type: constant("ray"),
-  coords: optional(nullable(pair(pairOfNumbers, pairOfNumbers))),
-  startCoords: optional(pair(pairOfNumbers, pairOfNumbers)),
-  // TODO: remove coord? it's legacy.
-  coord: optional(pairOfNumbers)
-});
-const parsePerseusGraphTypeSegment = object({
-  type: constant("segment"),
-  // TODO(benchristel): default numSegments?
-  numSegments: optional(number),
-  coords: optional(nullable(array(pair(pairOfNumbers, pairOfNumbers)))),
-  startCoords: optional(array(pair(pairOfNumbers, pairOfNumbers))),
-  // TODO: remove coord? it's legacy.
-  coord: optional(pairOfNumbers)
-});
-const parsePerseusGraphTypeSinusoid = object({
-  type: constant("sinusoid"),
-  coords: optional(nullable(array(pairOfNumbers))),
-  startCoords: optional(array(pairOfNumbers)),
-  // TODO: remove coord? it's legacy.
-  coord: optional(pairOfNumbers)
-});
-const parsePerseusGraphType = discriminatedUnionOn("type").withBranch("angle", parsePerseusGraphTypeAngle).withBranch("circle", parsePerseusGraphTypeCircle).withBranch("linear", parsePerseusGraphTypeLinear).withBranch("linear-system", parsePerseusGraphTypeLinearSystem).withBranch("none", parsePerseusGraphTypeNone).withBranch("point", parsePerseusGraphTypePoint).withBranch("polygon", parsePerseusGraphTypePolygon).withBranch("quadratic", parsePerseusGraphTypeQuadratic).withBranch("ray", parsePerseusGraphTypeRay).withBranch("segment", parsePerseusGraphTypeSegment).withBranch("sinusoid", parsePerseusGraphTypeSinusoid).parser;
-const parseLockedFigureColor = enumeration(...perseusCore.lockedFigureColorNames);
-const parseLockedFigureFillType = enumeration("none", "white", "translucent", "solid");
-const parseLockedLineStyle = enumeration("solid", "dashed");
-const parseLockedLabelType = object({
-  type: constant("label"),
-  coord: pairOfNumbers,
-  text: string,
-  color: parseLockedFigureColor,
-  size: enumeration("small", "medium", "large")
-});
-const parseLockedPointType = object({
-  type: constant("point"),
-  coord: pairOfNumbers,
-  color: parseLockedFigureColor,
-  filled: boolean,
-  // TODO(benchristel): default labels to empty array?
-  labels: optional(array(parseLockedLabelType)),
-  ariaLabel: optional(string)
-});
-const parseLockedLineType = object({
-  type: constant("line"),
-  kind: enumeration("line", "ray", "segment"),
-  points: pair(parseLockedPointType, parseLockedPointType),
-  color: parseLockedFigureColor,
-  lineStyle: parseLockedLineStyle,
-  showPoint1: defaulted(boolean, () => false),
-  showPoint2: defaulted(boolean, () => false),
-  // TODO(benchristel): default labels to empty array?
-  labels: optional(array(parseLockedLabelType)),
-  ariaLabel: optional(string)
-});
-const parseLockedVectorType = object({
-  type: constant("vector"),
-  points: pair(pairOfNumbers, pairOfNumbers),
-  color: parseLockedFigureColor,
-  // TODO(benchristel): default labels to empty array?
-  labels: optional(array(parseLockedLabelType)),
-  ariaLabel: optional(string)
-});
-const parseLockedEllipseType = object({
-  type: constant("ellipse"),
-  center: pairOfNumbers,
-  radius: pairOfNumbers,
-  angle: number,
-  color: parseLockedFigureColor,
-  fillStyle: parseLockedFigureFillType,
-  strokeStyle: parseLockedLineStyle,
-  // TODO(benchristel): default labels to empty array?
-  labels: optional(array(parseLockedLabelType)),
-  ariaLabel: optional(string)
-});
-const parseLockedPolygonType = object({
-  type: constant("polygon"),
-  points: array(pairOfNumbers),
-  color: parseLockedFigureColor,
-  showVertices: boolean,
-  fillStyle: parseLockedFigureFillType,
-  strokeStyle: parseLockedLineStyle,
-  // TODO(benchristel): default labels to empty array?
-  labels: optional(array(parseLockedLabelType)),
-  ariaLabel: optional(string)
-});
-const parseLockedFunctionType = object({
-  type: constant("function"),
-  color: parseLockedFigureColor,
-  strokeStyle: parseLockedLineStyle,
-  equation: string,
-  directionalAxis: enumeration("x", "y"),
-  domain: optional(pairOfNumbers),
-  // TODO(benchristel): default labels to empty array?
-  labels: optional(array(parseLockedLabelType)),
-  ariaLabel: optional(string)
-});
-const parseLockedFigure = discriminatedUnionOn("type").withBranch("point", parseLockedPointType).withBranch("line", parseLockedLineType).withBranch("vector", parseLockedVectorType).withBranch("ellipse", parseLockedEllipseType).withBranch("polygon", parseLockedPolygonType).withBranch("function", parseLockedFunctionType).withBranch("label", parseLockedLabelType).parser;
-const parseInteractiveGraphWidget = parseWidget(constant("interactive-graph"), object({
-  step: pairOfNumbers,
-  // TODO(benchristel): rather than making gridStep and snapStep
-  // optional, we should duplicate the defaulting logic from the
-  // InteractiveGraph component. See parse-perseus-json/README.md for
-  // why.
-  gridStep: optional(pairOfNumbers),
-  snapStep: optional(pairOfNumbers),
-  backgroundImage: optional(parsePerseusImageBackground),
-  markings: enumeration("graph", "grid", "none"),
-  labels: optional(array(string)),
-  showProtractor: boolean,
-  showRuler: optional(boolean),
-  showTooltips: optional(boolean),
-  rulerLabel: optional(string),
-  rulerTicks: optional(number),
-  range: pair(pairOfNumbers, pairOfNumbers),
-  // NOTE(benchristel): I copied the default graph from
-  // interactive-graph.tsx. See the parse-perseus-json/README.md for
-  // an explanation of why we want to duplicate the default here.
-  graph: defaulted(parsePerseusGraphType, () => ({
-    type: "linear"
-  })),
-  correct: parsePerseusGraphType,
-  // TODO(benchristel): default lockedFigures to empty array
-  lockedFigures: optional(array(parseLockedFigure)),
-  fullGraphLabel: optional(string),
-  fullGraphAriaDescription: optional(string)
-}));
-
-const parseLabelImageWidget = parseWidget(constant("label-image"), object({
-  choices: array(string),
-  imageUrl: string,
-  imageAlt: string,
-  imageHeight: number,
-  imageWidth: number,
-  markers: array(object({
-    answers: array(string),
-    label: string,
-    x: number,
-    y: number
-  })),
-  hideChoicesFromInstructions: boolean,
-  multipleAnswers: boolean,
-  static: defaulted(boolean, () => false)
-}));
-
-const parseMatcherWidget = parseWidget(constant("matcher"), object({
-  labels: array(string),
-  left: array(string),
-  right: array(string),
-  orderMatters: boolean,
-  padding: boolean
-}));
-
-const numberOrString = union(number).or(string).parser;
-const numeric = pipeParsers(defaulted(numberOrString, () => NaN)).then(stringToNumber).parser;
-const parseMatrixWidget = parseWidget(defaulted(constant("matrix"), () => "matrix"), object({
-  prefix: optional(string),
-  suffix: optional(string),
-  answers: array(array(numeric)),
-  cursorPosition: optional(array(number)),
-  matrixBoardSize: array(number),
-  static: optional(boolean)
-}));
-
-const parseMeasurerWidget = parseWidget(constant("measurer"), object({
-  // The default value for image comes from measurer.tsx.
-  // See parse-perseus-json/README.md for why we want to duplicate the
-  // defaults here.
-  image: defaulted(parsePerseusImageBackground, () => ({
-    url: null,
-    top: 0,
-    left: 0
-  })),
-  showProtractor: boolean,
-  showRuler: boolean,
-  rulerLabel: string,
-  rulerTicks: number,
-  rulerPixels: number,
-  rulerLength: number,
-  box: pair(number, number),
-  // TODO(benchristel): static is not used. Remove it?
-  static: defaulted(boolean, () => false)
-}));
-
-const parseMoleculeRendererWidget = parseWidget(constant("molecule-renderer"), object({
-  widgetId: string,
-  rotationAngle: optional(number),
-  smiles: optional(string)
-}));
-
-const emptyStringToNull = pipeParsers(constant("")).then(convert(() => null)).parser;
-const parseNumberLineWidget = parseWidget(constant("number-line"), object({
-  range: array(number),
-  labelRange: array(nullable(union(number).or(emptyStringToNull).parser)),
-  labelStyle: string,
-  labelTicks: boolean,
-  isTickCtrl: optional(nullable(boolean)),
-  divisionRange: array(number),
-  numDivisions: optional(nullable(number)),
-  // NOTE(benchristel): I copied the default snapDivisions from
-  // number-line.tsx. See the parse-perseus-json/README.md for
-  // an explanation of why we want to duplicate the default here.
-  snapDivisions: defaulted(number, () => 2),
-  tickStep: optional(nullable(number)),
-  correctRel: optional(nullable(string)),
-  correctX: nullable(number),
-  initialX: optional(nullable(number)),
-  showTooltip: optional(boolean),
-  static: defaulted(boolean, () => false)
-}));
-
-const parseMathFormat = enumeration("integer", "mixed", "improper", "proper", "decimal", "percent", "pi");
-const parseNumericInputWidget = parseWidget(constant("numeric-input"), object({
-  answers: array(object({
-    message: string,
-    // TODO(benchristel): value should never be null or undefined,
-    // but we have some content where it is anyway. If we backfill
-    // the data, simplify this.
-    value: optional(nullable(number)),
-    status: string,
-    answerForms: optional(array(parseMathFormat)),
-    strict: boolean,
-    maxError: optional(nullable(number)),
-    // TODO(benchristel): simplify should never be a boolean, but we
-    // have some content where it is anyway. If we ever backfill
-    // the data, we should simplify `simplify`.
-    simplify: optional(nullable(union(string).or(pipeParsers(boolean).then(convert(String)).parser).parser))
-  })),
-  labelText: optional(string),
-  size: string,
-  coefficient: defaulted(boolean, () => false),
-  rightAlign: optional(boolean),
-  static: defaulted(boolean, () => false),
-  answerForms: optional(array(object({
-    name: parseMathFormat,
-    simplify: optional(nullable(enumeration("required", "correct", "enforced", "optional")))
-  })))
-}));
-
-// There is an import cycle between orderer-widget.ts and perseus-renderer.ts.
-// This wrapper ensures that we don't refer to parsePerseusRenderer before
-// it's defined.
-function parseRenderer(rawValue, ctx) {
-  return parsePerseusRenderer(rawValue, ctx);
-}
-const largeToAuto = (height, ctx) => {
-  if (height === "large") {
-    return ctx.success("auto");
-  }
-  return ctx.success(height);
-};
-const parseOrdererWidget = parseWidget(constant("orderer"), object({
-  options: defaulted(array(parseRenderer), () => []),
-  correctOptions: array(parseRenderer),
-  otherOptions: array(parseRenderer),
-  height: pipeParsers(enumeration("normal", "auto", "large")).then(largeToAuto).parser,
-  layout: defaulted(enumeration("horizontal", "vertical"), () => "horizontal")
-}));
-
-const parsePassageRefWidget = parseWidget(constant("passage-ref"), object({
-  passageNumber: number,
-  referenceNumber: number,
-  summaryText: optional(string)
-}));
-
-const parsePassageWidget = parseWidget(constant("passage"), object({
-  footnotes: defaulted(string, () => ""),
-  passageText: string,
-  passageTitle: defaulted(string, () => ""),
-  showLineNumbers: boolean,
-  static: defaulted(boolean, () => false)
-}));
-
-const parsePhetSimulationWidget = parseWidget(constant("phet-simulation"), object({
-  url: string,
-  description: string
-}));
-
-const parsePlotterWidget = parseWidget(constant("plotter"), object({
-  labels: array(string),
-  categories: array(string),
-  type: enumeration(...perseusCore.plotterPlotTypes),
-  maxY: number,
-  // The default value for scaleY comes from plotter.tsx.
-  // See parse-perseus-json/README.md for why we want to duplicate the
-  // defaults here.
-  scaleY: defaulted(number, () => 1),
-  labelInterval: optional(nullable(number)),
-  // The default value for snapsPerLine comes from plotter.tsx.
-  // See parse-perseus-json/README.md for why we want to duplicate the
-  // defaults here.
-  snapsPerLine: defaulted(number, () => 2),
-  starting: array(number),
-  correct: array(number),
-  picUrl: optional(nullable(string)),
-  picSize: optional(nullable(number)),
-  picBoxHeight: optional(nullable(number)),
-  // NOTE(benchristel): I copied the default plotDimensions from
-  // plotter.tsx. See the parse-perseus-json/README.md for an explanation
-  // of why we want to duplicate the defaults here.
-  plotDimensions: defaulted(array(number), () => [380, 300])
-}));
-
-const parsePythonProgramWidget = parseWidget(constant("python-program"), object({
-  programID: string,
-  height: number
-}));
-
-const parseRadioWidget = parseWidget(constant("radio"), object({
-  choices: array(object({
-    content: defaulted(string, () => ""),
-    clue: optional(string),
-    correct: optional(boolean),
-    isNoneOfTheAbove: optional(boolean),
-    // deprecated
-    // There is an import cycle between radio-widget.ts and
-    // widgets-map.ts. The anonymous function below ensures that we
-    // don't refer to parseWidgetsMap before it's defined.
-    widgets: optional((rawVal, ctx) => parseWidgetsMap(rawVal, ctx))
-  })),
-  hasNoneOfTheAbove: optional(boolean),
-  countChoices: optional(boolean),
-  randomize: optional(boolean),
-  multipleSelect: optional(boolean),
-  deselectEnabled: optional(boolean),
-  // deprecated
-  onePerLine: optional(boolean),
-  // deprecated
-  displayCount: optional(any),
-  // v0 props
-  // `noneOfTheAbove` is still in use (but only set to `false`).
-  noneOfTheAbove: optional(constant(false))
-}));
-
-const parseSorterWidget = parseWidget(constant("sorter"), object({
-  correct: array(string),
-  padding: boolean,
-  layout: enumeration("horizontal", "vertical")
-}));
-
-const parseTableWidget = parseWidget(constant("table"), object({
-  headers: array(string),
-  rows: number,
-  columns: number,
-  answers: array(array(string))
-}));
-
-const parseVideoWidget = parseWidget(constant("video"), object({
-  location: string,
-  static: optional(boolean)
-}));
-
-const parseWidgetsMap = (rawValue, ctx) => {
-  if (!isObject(rawValue)) {
-    return ctx.failure("PerseusWidgetsMap", rawValue);
-  }
-  const widgetsMap = {};
-  for (const key of Object.keys(rawValue)) {
-    // parseWidgetsMapEntry modifies the widgetsMap. This is kind of gross,
-    // but it's the only way I could find to make TypeScript check the key
-    // against the widget type.
-    const entryResult = parseWidgetsMapEntry([key, rawValue[key]], widgetsMap, ctx.forSubtree(key));
-    if (isFailure(entryResult)) {
-      return entryResult;
-    }
-  }
-  return ctx.success(widgetsMap);
-};
-const parseWidgetsMapEntry = (_ref, widgetMap, ctx) => {
-  let [id, widget] = _ref;
-  const idComponentsResult = parseWidgetIdComponents(id.split(" "), ctx.forSubtree("(widget ID)"));
-  if (isFailure(idComponentsResult)) {
-    return idComponentsResult;
-  }
-  const [type, n] = idComponentsResult.value;
-  function parseAndAssign(key, parse) {
-    const widgetResult = parse(widget, ctx);
-    if (isFailure(widgetResult)) {
-      return widgetResult;
-    }
-    widgetMap[key] = widgetResult.value;
-    return ctx.success(undefined);
-  }
-  switch (type) {
-    case "categorizer":
-      return parseAndAssign(`categorizer ${n}`, parseCategorizerWidget);
-    case "cs-program":
-      return parseAndAssign(`cs-program ${n}`, parseCSProgramWidget);
-    case "definition":
-      return parseAndAssign(`definition ${n}`, parseDefinitionWidget);
-    case "dropdown":
-      return parseAndAssign(`dropdown ${n}`, parseDropdownWidget);
-    case "explanation":
-      return parseAndAssign(`explanation ${n}`, parseExplanationWidget);
-    case "expression":
-      return parseAndAssign(`expression ${n}`, parseExpressionWidget);
-    case "grapher":
-      return parseAndAssign(`grapher ${n}`, parseGrapherWidget);
-    case "group":
-      return parseAndAssign(`group ${n}`, parseGroupWidget);
-    case "graded-group":
-      return parseAndAssign(`graded-group ${n}`, parseGradedGroupWidget);
-    case "graded-group-set":
-      return parseAndAssign(`graded-group-set ${n}`, parseGradedGroupSetWidget);
-    case "iframe":
-      return parseAndAssign(`iframe ${n}`, parseIframeWidget);
-    case "image":
-      return parseAndAssign(`image ${n}`, parseImageWidget);
-    case "input-number":
-      return parseAndAssign(`input-number ${n}`, parseInputNumberWidget);
-    case "interaction":
-      return parseAndAssign(`interaction ${n}`, parseInteractionWidget);
-    case "interactive-graph":
-      return parseAndAssign(`interactive-graph ${n}`, parseInteractiveGraphWidget);
-    case "label-image":
-      return parseAndAssign(`label-image ${n}`, parseLabelImageWidget);
-    case "matcher":
-      return parseAndAssign(`matcher ${n}`, parseMatcherWidget);
-    case "matrix":
-      return parseAndAssign(`matrix ${n}`, parseMatrixWidget);
-    case "measurer":
-      return parseAndAssign(`measurer ${n}`, parseMeasurerWidget);
-    case "molecule-renderer":
-      return parseAndAssign(`molecule-renderer ${n}`, parseMoleculeRendererWidget);
-    case "number-line":
-      return parseAndAssign(`number-line ${n}`, parseNumberLineWidget);
-    case "numeric-input":
-      return parseAndAssign(`numeric-input ${n}`, parseNumericInputWidget);
-    case "orderer":
-      return parseAndAssign(`orderer ${n}`, parseOrdererWidget);
-    case "passage":
-      return parseAndAssign(`passage ${n}`, parsePassageWidget);
-    case "passage-ref":
-      return parseAndAssign(`passage-ref ${n}`, parsePassageRefWidget);
-    case "passage-ref-target":
-      // NOTE(benchristel): as of 2024-11-12, passage-ref-target is only
-      // used in test content. See:
-      // https://www.khanacademy.org/devadmin/content/search?query=widget:passage-ref-target
-      return parseAndAssign(`passage-ref-target ${n}`, any);
-    case "phet-simulation":
-      return parseAndAssign(`phet-simulation ${n}`, parsePhetSimulationWidget);
-    case "plotter":
-      return parseAndAssign(`plotter ${n}`, parsePlotterWidget);
-    case "python-program":
-      return parseAndAssign(`python-program ${n}`, parsePythonProgramWidget);
-    case "radio":
-      return parseAndAssign(`radio ${n}`, parseRadioWidget);
-    case "sorter":
-      return parseAndAssign(`sorter ${n}`, parseSorterWidget);
-    case "table":
-      return parseAndAssign(`table ${n}`, parseTableWidget);
-    case "video":
-      return parseAndAssign(`video ${n}`, parseVideoWidget);
-    case "sequence":
-      // sequence is a deprecated widget type, and the corresponding
-      // widget component no longer exists.
-      return parseAndAssign(`sequence ${n}`, parseDeprecatedWidget);
-    case "lights-puzzle":
-      return parseAndAssign(`lights-puzzle ${n}`, parseDeprecatedWidget);
-    case "simulator":
-      return parseAndAssign(`simulator ${n}`, parseDeprecatedWidget);
-    case "transformer":
-      return parseAndAssign(`transformer ${n}`, parseDeprecatedWidget);
-    default:
-      if (getWidget(type)) {
-        // @ts-expect-error - 'type' is not a valid widget type
-        return parseAndAssign(`${type} ${n}`, any);
-      }
-      return ctx.failure("a valid widget type", type);
-  }
-};
-const parseDeprecatedWidget = parseWidget(
-// Ignore the incoming widget type and hardcode "deprecated-standin"
-(_, ctx) => ctx.success("deprecated-standin"),
-// Allow any widget options
-object({}));
-const parseStringToPositiveInt = (rawValue, ctx) => {
-  if (typeof rawValue !== "string" || !/^[1-9][0-9]*$/.test(rawValue)) {
-    return ctx.failure("a string representing a positive integer", rawValue);
-  }
-  return ctx.success(+rawValue);
-};
-const parseWidgetIdComponents = pair(string, parseStringToPositiveInt);
-
-const parsePerseusRenderer = defaulted(object({
-  // TODO(benchristel): content is also defaulted to empty string in
-  // renderer.tsx. See if we can remove one default or the other.
-  content: defaulted(string, () => ""),
-  // This module has an import cycle with parseWidgetsMap, because the
-  // `group` widget can contain another renderer.
-  // The anonymous function below ensures that we don't try to access
-  // parseWidgetsMap before it's defined.
-  widgets: defaulted((rawVal, ctx) => parseWidgetsMap(rawVal, ctx), () => ({})),
-  metadata: optional(array(string)),
-  images: parseImages
-}),
-// Default value
-() => ({
-  content: "",
-  widgets: {},
-  images: {}
-}));
-
-const parsePerseusArticle = union(parsePerseusRenderer).or(array(parsePerseusRenderer)).parser;
-
-const parseHint = object({
-  replace: optional(boolean),
-  content: string,
-  widgets: defaulted(parseWidgetsMap, () => ({})),
-  metadata: optional(array(string)),
-  images: parseImages
-});
-
-const parsePerseusItem$1 = object({
-  question: parsePerseusRenderer,
-  hints: defaulted(array(parseHint), () => []),
-  answerArea: pipeParsers(defaulted(object({}), () => ({}))).then(migrateAnswerArea).then(record(enumeration(...perseusCore.ItemExtras), boolean)).parser,
-  itemDataVersion: optional(object({
-    major: number,
-    minor: number
-  })),
-  // Deprecated field
-  answer: any
-});
-
-// Some answerAreas have extra fields, like:
-//
-//   "answerArea": {
-//     "type": "multiple",
-//     "options": {
-//       "content": "",
-//       "images": {},
-//       "widgets": {}
-//     }
-//   }
-//
-// The "type" and "options" fields don't seem to be used anywhere. This
-// migration function removes them.
-function migrateAnswerArea(rawValue, ctx) {
-  const {
-    type: _,
-    options: __,
-    ...rest
-  } = rawValue;
-  return ctx.success(rest);
-}
-
-/**
- * Helper to parse PerseusItem JSON
- * Why not just use JSON.parse? We want:
- * - To make sure types are correct
- * - To give us a central place to validate/transform output if needed
- * @deprecated - use parseAndMigratePerseusItem instead
- * @param {string} json - the stringified PerseusItem JSON
- * @returns {PerseusItem} the parsed PerseusItem object
- */
-function parsePerseusItem(json) {
-  // Try to block a cheating vector which relies on monkey-patching
-  // JSON.parse
-  if (isRealJSONParse(JSON.parse)) {
-    return JSON.parse(json);
-  }
-  throw new Error("Something went wrong.");
-}
-/**
- * Parses a PerseusItem from a JSON string, migrates old formats to the latest
- * schema, and runtime-typechecks the result. Use this to parse assessmentItem
- * data.
- *
- * @returns a {@link Result} of the parsed PerseusItem. If the result is a
- * failure, it will contain an error message describing where in the tree
- * parsing failed.
- * @throws SyntaxError if the argument is not well-formed JSON.
- */
-function parseAndMigratePerseusItem(json) {
-  throwErrorIfCheatingDetected();
-  const object = JSON.parse(json);
-  const result = parse(object, parsePerseusItem$1);
-  if (isFailure(result)) {
-    return failure({
-      message: result.detail,
-      invalidObject: object
-    });
-  }
-  return result;
-}
-
-/**
- * Parses a PerseusArticle from a JSON string, migrates old formats to the
- * latest schema, and runtime-typechecks the result.
- *
- * @returns a {@link Result} of the parsed PerseusArticle. If the result is a
- * failure, it will contain an error message describing where in the tree
- * parsing failed.
- * @throws SyntaxError if the argument is not well-formed JSON.
- */
-function parseAndMigratePerseusArticle(json) {
-  throwErrorIfCheatingDetected();
-  const object = JSON.parse(json);
-  const result = parse(object, parsePerseusArticle);
-  if (isFailure(result)) {
-    return failure({
-      message: result.detail,
-      invalidObject: object
-    });
-  }
-  return result;
-}
-
-/**
- * Tries to block a cheating vector that relies on monkey-patching JSON.parse.
- */
-// TODO(LEMS-2331): delete this function once server-side scoring is done.
-function throwErrorIfCheatingDetected() {
-  if (!isRealJSONParse(JSON.parse)) {
-    throw new Error("Something went wrong.");
-  }
-}
-
 const genericPerseusItemData = {
   question: {
     content: "",
@@ -47052,6 +45574,26 @@ const ScoringUtil = {
  * Types
  */
 
+Object.defineProperty(exports, 'isFailure', {
+  enumerable: true,
+  get: function () { return perseusCore.isFailure; }
+});
+Object.defineProperty(exports, 'isSuccess', {
+  enumerable: true,
+  get: function () { return perseusCore.isSuccess; }
+});
+Object.defineProperty(exports, 'parseAndMigratePerseusArticle', {
+  enumerable: true,
+  get: function () { return perseusCore.parseAndMigratePerseusArticle; }
+});
+Object.defineProperty(exports, 'parseAndMigratePerseusItem', {
+  enumerable: true,
+  get: function () { return perseusCore.parseAndMigratePerseusItem; }
+});
+Object.defineProperty(exports, 'parsePerseusItem', {
+  enumerable: true,
+  get: function () { return perseusCore.parsePerseusItem; }
+});
 exports.ApiOptions = ApiOptions;
 exports.ArticleRenderer = ArticleRenderer;
 exports.BaseRadio = BaseRadio;
@@ -47077,7 +45619,6 @@ exports.PerseusI18nContext = PerseusI18nContext;
 exports.PerseusI18nContextProvider = PerseusI18nContextProvider;
 exports.PerseusMarkdown = PerseusMarkdown;
 exports.PlotterWidget = Plotter$1;
-exports.QUESTION_WIDGETS = QUESTION_WIDGETS;
 exports.Radio = Radio;
 exports.Renderer = Renderer;
 exports.ScoringUtil = ScoringUtil;
@@ -47086,7 +45627,6 @@ exports.TableWidget = Table$1;
 exports.Util = Util;
 exports.WIDGET_PROP_DENYLIST = denylist;
 exports.Widgets = widgets$1;
-exports.addWidget = addWidget;
 exports.apiVersion = apiVersion;
 exports.bodyXsmallBold = bodyXsmallBold;
 exports.components = components;
@@ -47117,8 +45657,6 @@ exports.getSegmentCoords = getSegmentCoords;
 exports.getSinusoidCoords = getSinusoidCoords;
 exports.getValidWidgetIds = getValidWidgetIds;
 exports.getWidgetFromWidgetMap = getWidgetFromWidgetMap;
-exports.getWidgetIdsFromContent = getWidgetIdsFromContent;
-exports.getWidgetIdsFromContentByType = getWidgetIdsFromContentByType;
 exports.getWidgetTypeByWidgetId = getWidgetTypeByWidgetId;
 exports.getWidgetsFromWidgetMap = getWidgetsFromWidgetMap;
 exports.getWidgetsMapFromItemData = getWidgetsMapFromItemData;
@@ -47127,9 +45665,7 @@ exports.iconTrash = iconTrash;
 exports.init = init;
 exports.injectWidgets = injectWidgets;
 exports.interactiveSizes = interactiveSizes$1;
-exports.isFailure = isFailure;
 exports.isItemRenderableByVersion = isItemRenderableByVersion;
-exports.isSuccess = isSuccess;
 exports.isWidgetIdInContent = isWidgetIdInContent;
 exports.isWrongAnswerSupported = isWrongAnswerSupported;
 exports.itemDataVersion = itemDataVersion;
@@ -47138,10 +45674,7 @@ exports.libVersion = libVersion;
 exports.makeSafeUrl = makeSafeUrl;
 exports.mathOnlyParser = mathOnlyParser;
 exports.mediaQueries = mediaQueries;
-exports.parseAndMigratePerseusArticle = parseAndMigratePerseusArticle;
-exports.parseAndMigratePerseusItem = parseAndMigratePerseusItem;
 exports.parseDataFromJSONP = parseDataFromJSONP;
-exports.parsePerseusItem = parsePerseusItem;
 exports.preprocessTex = preprocessTex;
 exports.registerAllWidgetsForTesting = registerAllWidgetsForTesting;
 exports.scorePerseusItem = scorePerseusItem;