@khanacademy/perseus 51.0.0 → 52.0.0

package/dist/index.js

@@ -283,14 +283,36 @@ const strings = {
   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",
+  srSingleSegmentGraphAriaLabel: "A line segment on a coordinate plane.",
+  srMultipleSegmentGraphAriaLabel: "%(countOfSegments)s line segments on a coordinate plane.",
+  srMultipleSegmentIndividualLabel: "Segment %(indexOfSegment)s: Endpoint 1 at %(point1X)s comma %(point1Y)s. Endpoint 2 %(point2X)s comma %(point2Y)s.",
+  srSingleSegmentLabel: "Endpoint 1 at %(point1X)s comma %(point1Y)s. Endpoint 2 %(point2X)s comma %(point2Y)s.",
+  srSegmentLength: "Segment length %(length)s units.",
+  srSingleSegmentGraphEndpointAriaLabel: "Endpoint %(endpointNumber)s at %(x)s comma %(y)s.",
+  srMultipleSegmentGraphEndpointAriaLabel: "Endpoint %(endpointNumber)s on segment %(indexOfSegment)s at %(x)s comma %(y)s.",
+  srSegmentGrabHandle: "Segment from %(point1X)s comma %(point1Y)s to %(point2X)s comma %(point2Y)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 %(point1X)s comma %(point1Y)s.",
-  srRayTerminalPoint: "Through point at %(point2X)s comma %(point2Y)s."
+  srRayEndpoint: "Endpoint at %(x)s comma %(y)s.",
+  srRayTerminalPoint: "Through point at %(x)s comma %(y)s.",
+  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: "Vertex is in quadrant %(quadrant)s.",
+  srQuadraticTwoXIntercepts: "The X-intercepts are at %(intercept1)s comma 0 and %(intercept2)s comma 0.",
+  srQuadraticOneXIntercept: "The X-intercept is at %(intercept)s comma 0.",
+  srQuadraticYIntercept: "The Y-intercept is at 0 comma %(intercept)s.",
+  srQuadraticPointOrigin: "Point %(pointNumber)s on parabola at the origin.",
+  srQuadraticPointAxis: "Point %(pointNumber)s on parabola at %(x)s comma %(y)s.",
+  srQuadraticPointQuadrant: "Point %(pointNumber)s on parabola in quadrant %(quadrant)s at %(x)s comma %(y)s.",
+  srQuadraticInteractiveElements: "Parabola with points at %(point1X)s comma %(point1Y)s, %(point2X)s comma %(point2Y)s, and %(point3X)s comma %(point3Y)s."
   // The above strings are used for interactive graph SR descriptions.
 };
 
@@ -680,58 +702,181 @@ 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.
 };
@@ -2006,23 +2151,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 +2190,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 +17709,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 +17794,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 +17942,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 +18043,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 +18358,7 @@ var widgets$1 = /*#__PURE__*/Object.freeze({
   replaceDeprecatedEditors: replaceDeprecatedEditors,
   getWidget: getWidget,
   getWidgetExport: getWidgetExport,
+  getWidgetValidator: getWidgetValidator,
   getWidgetScorer: getWidgetScorer,
   getPublicWidgetOptionsFunction: getPublicWidgetOptionsFunction,
   getEditor: getEditor,
@@ -18378,7 +18381,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 +18398,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 +18437,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 +18460,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 +19074,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 +23034,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 +23044,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 +23599,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 +25285,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 +25409,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 +25416,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 +25443,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 +25625,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 +26067,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 => {
@@ -27604,11 +27588,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 +27756,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 +30680,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 +32607,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 +32628,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 +32666,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 +32674,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 +33282,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 +33299,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 +33322,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 +33384,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 +33564,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 +33636,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 +33966,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 +33986,8 @@ const MafsGraph = props => {
     interactiveElementsDescription
   } = renderGraphElements({
     state,
-    dispatch
+    dispatch,
+    i18n
   });
   return /*#__PURE__*/React__namespace.createElement(GraphConfigContext.Provider, {
     value: {
@@ -34027,7 +34364,8 @@ const calculateNestedSVGCoords = (range, width, height) => {
 const renderGraphElements = props => {
   const {
     state,
-    dispatch
+    dispatch,
+    i18n
   } = props;
   const {
     type
@@ -34050,7 +34388,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 +38008,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 +38030,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 +38138,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 +38180,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 +39725,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 +39837,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 +40418,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 +40482,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 +40547,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 +40586,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 +40611,7 @@ function parse$2(smiles, ctx) {
   return parseParenthesizedExpression(smiles, ctx);
 }
 var SmilesParser = {
-  parse: parse$2,
+  parse: parse$1,
   ParseError: ParseError$1
 };
 
@@ -40296,7 +40619,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 +40646,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 +41311,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 +41868,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 +41921,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 +42944,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 +43110,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 +43332,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 +43520,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.0";
+const libVersion = "52.0.0";
 perseusCore.addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {
@@ -44631,6 +44966,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 +45552,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 +45773,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 +45818,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 +45826,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 +45856,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 +45864,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 +45873,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;