@khanacademy/perseus 41.5.0 → 42.0.1

package/dist/index.js

@@ -371,10 +371,11 @@ const mockStrings = {
   graphKeyboardPrompt: "Press Shift + Enter to interact with the graph",
   srPointAtCoordinates: _ref27 => {
     let {
+      num,
       x,
       y
     } = _ref27;
-    return `Point at ${x} comma ${y}`;
+    return `Point ${num} at ${x} comma ${y}`;
   },
   srInteractiveElements: _ref28 => {
     let {
@@ -18874,6 +18875,326 @@ class QuestionParagraph extends React__namespace.Component {
   }
 }
 
+// Methods to convert input-number widgets to numeric-input widgets
+
+const inputNumberToNumericInput = json => {
+  // First we need to create a map of the old input-number keys to the new numeric-input keys
+  // so that we can ensure we update the content and widgets accordingly
+  const renameMap = getInputNumberRenameMap(json);
+
+  // Then we can use this to update the JSON
+  return convertInputNumberJson(json, renameMap);
+};
+
+// We need to be able to run this code recursively in order to convert nested input-number widgets
+const convertInputNumberJson = (json, renameMap) => {
+  const updatedContent = convertDeprecatedWidgetsInContent(json, renameMap);
+  const updatedWidgets = convertInputNumberWidgetOptions(json, renameMap);
+  const modernizedJson = {
+    ...json,
+    content: updatedContent,
+    widgets: updatedWidgets
+  };
+  return modernizedJson;
+};
+
+// Convert the input-number json in the widgets of a PerseusRenderer object
+const convertInputNumberWidgetOptions = (json, renameMap) => {
+  const widgets = {
+    ...json.widgets
+  };
+  // The question.widgets is a dictionary map of widgets, so we need to loop through in order to convert input-number to numeric-input
+  // which can exist as both the key or as a value on widget.type.
+  for (const key of Object.keys(widgets)) {
+    // Loop through the keys of the widgets dictionary
+    if (widgets[key].options.widgets) {
+      widgets[key].options = {
+        ...inputNumberToNumericInput(widgets[key].options)
+      };
+    }
+    // Check if the widget is an input-number
+    if (widgets[key].type === "input-number") {
+      // If the answerType is not number or percent, we need to provide
+      // the answer form for the numeric-input widget
+      const provideAnswerForm = widgets[key].options.answerType !== "number" && widgets[key].options.answerType !== "percent";
+      // We need to determine the mathFormat for the numeric-input widget
+      const mathFormat = widgets[key].options.answerType === "rational" ? "proper" // input-number uses "rational" for proper fractions
+      : widgets[key].options.answerType; // Otherwise, we can use the answerType directly
+
+      // We need to update the answers prop to match the numeric-input widget format
+      const answers = [{
+        value: widgets[key].options.value,
+        simplify: widgets[key].options.simplify,
+        // Input Number doesn't have a strict prop, so we default to false
+        strict: false,
+        // We only want to set maxError if the inexact prop is true
+        maxError: widgets[key].options.inexact ? widgets[key].options.maxError : 0,
+        status: "correct",
+        // Input-number only allows correct answers
+        message: ""
+      }];
+
+      // Add the required answerForms if provided/applicable
+      if (provideAnswerForm) {
+        answers[0].answerForms = [mathFormat];
+      }
+
+      // Update the options prop to match the numeric-input widget format
+      const upgradedWidgetOptions = {
+        answers,
+        size: widgets[key].options.size,
+        coefficient: false,
+        // input-number doesn't have a coefficient prop
+        labelText: "",
+        // input-number doesn't have a labelText prop
+        static: false,
+        // static is always false for numeric-input
+        rightAlign: widgets[key].options.rightAlign || false
+      };
+      const upgradedWidget = {
+        options: upgradedWidgetOptions,
+        type: "numeric-input"
+      };
+      const newWidgetName = renameMap[key];
+      // Create the new key entry
+      widgets[newWidgetName] = upgradedWidget;
+
+      // We need to delete the old widget key
+      delete widgets[key];
+    }
+  }
+  return widgets;
+};
+
+// Convert the deprecated widget refs in the content string
+// of a PerseusRenderer object to their renamed equivalents
+const convertDeprecatedWidgetsInContent = (json, renameMap) => {
+  return Object.keys(renameMap).reduce((newContent, oldKey) => {
+    const newKey = renameMap[oldKey];
+    return newKey ? newContent.replace(oldKey, newKey) : newContent;
+  }, json.content);
+};
+
+// Create a map of the old input-number keys to the new numeric-input keys
+const getInputNumberRenameMap = json => {
+  const numericRegex = /(?<=\[\[\u2603 )(numeric-input \d+)(?=\]\])/g;
+  const inputNumberRegex = /(?<=\[\[\u2603 )(input-number \d+)(?=\]\])/g;
+
+  // Get all the content strings within the json, which might be nested within widgets
+  const allContentStrings = json.content;
+
+  // Loop through the content strings to get all the input-number widgets
+  const renameMap = {};
+  const inputNumberMatches = [...(allContentStrings.match(inputNumberRegex) || [])];
+
+  // We want to count any pre-existing numeric-input widgets
+  // so that we can start the new ids at the next number
+  const numericMatches = [...(allContentStrings.match(numericRegex) || [])];
+  let currentNumericCount = numericMatches.reduce((count, match) => {
+    const id = parseInt(match.split(" ")[1], 10);
+    return id >= count ? id + 1 : count; // We want to start at the next highest number
+  }, 1);
+
+  // Now that we have all the necessary information, we can create the renameMap
+  for (const match of inputNumberMatches) {
+    const oldKey = match;
+    const newKey = `numeric-input ${currentNumericCount}`;
+    renameMap[oldKey] = newKey;
+    currentNumericCount++;
+  }
+  return renameMap;
+};
+
+// Convert the user input data keys from input-number to numeric-input
+const convertUserInputNumberData = userInputMap => {
+  const updatedUserInputMap = {
+    ...userInputMap
+  };
+  for (const key of Object.keys(userInputMap)) {
+    if (key.includes("input-number")) {
+      const updatedKey = key.replace("input-number", "numeric-input");
+      updatedUserInputMap[updatedKey] = userInputMap[key];
+      delete updatedUserInputMap[key];
+    }
+  }
+  return updatedUserInputMap;
+};
+
+const widgetRegExes = [/input-number \d+/]; // We can add more regexes here in the future
+
+// This utils in this file are used to modernize our Perseus JSON structure,
+// so that we can convert deprecated widgets to their modern equivalents when
+// content creators use the Editor Page to update content containing these widgets.
+// Currently, we're only converting input-number to numeric-input,
+// but we can add more conversions here in the future.
+// Modernize the json content of a PerseusRenderer object
+// by converting deprecated widgets to their modern equivalents
+const convertDeprecatedWidgets = json => {
+  // Currently we're only converting input-number to numeric-input,
+  // But we can add more conversions here in the future
+  return inputNumberToNumericInput(json);
+};
+const conversionRequired = json => {
+  // If there's no content, then there's no conversion required
+  if (!json.content) {
+    return false;
+  }
+  // Check the content string for any top-level input-number widgets
+  if (widgetRegExes.some(regex => regex.test(json.content))) {
+    return true;
+  }
+
+  // If there's no deprecated widget in the top-level, then check for any nested widgets
+  for (const key of Object.keys(json.widgets)) {
+    if (json.widgets[key].options.widgets) {
+      const nestedJson = json.widgets[key].options;
+      if (conversionRequired(nestedJson)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+// Convert the user input data keys for deprecated widgets to their modern equivalents
+const convertUserInputData = userInputMap => {
+  // Currently we're only converting input-number to numeric-input,
+  // But we can add more conversions here in the future
+  return convertUserInputNumberData(userInputMap);
+};
+
+// 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.
+ * Useful for multi-items that needs to split
+ * one PerseusItem into several
+ *
+ * @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"];
@@ -19334,6 +19655,27 @@ widgetIds, userInputMap, strings, locale) {
     }
   });
 }
+
+// TODO: combine scorePerseusItem with scoreWidgetsFunctional
+// once scorePerseusItem is the only one calling scoreWidgetsFunctional
+function scorePerseusItem(perseusRenderData, userInputMap,
+// TODO(LEMS-2461,LEMS-2391): these probably
+// need to be removed before we move this to the server
+strings, locale) {
+  // Check if the PerseusRenderer object contains any deprecated widgets that need to be converted
+  const mustConvertData = conversionRequired(perseusRenderData);
+  const convertedRenderData = mustConvertData ? convertDeprecatedWidgets(perseusRenderData) // Convert deprecated widgets to their modern equivalents
+  : perseusRenderData;
+  const convertedUserInputMap = mustConvertData ? convertUserInputData(userInputMap) // Convert deprecated user input data keys to their modern equivalents
+  : userInputMap;
+
+  // 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(convertedRenderData.content);
+  const scores = scoreWidgetsFunctional(convertedRenderData.widgets, usedWidgetIds, convertedUserInputMap, strings, locale);
+  return Util.flattenScores(scores);
+}
 function scoreWidgetsFunctional(widgets,
 // This is a port of old code, I'm not sure why
 // we need widgetIds vs the keys of the widgets object
@@ -19354,7 +19696,7 @@ widgetIds, userInputMap, strings, locale) {
     const userInput = userInputMap[id];
     const scorer = getWidgetScorer(widget.type);
     if (widget.type === "group") {
-      const scores = scoreWidgetsFunctional(widget.options.widgets, Object.keys(widget.options.widgets), userInputMap[id], strings, locale);
+      const scores = scoreWidgetsFunctional(widget.options.widgets, getWidgetIdsFromContent(widget.options.content), userInputMap[id], strings, locale);
       widgetScores[id] = Util.flattenScores(scores);
     } else if (scorer) {
       widgetScores[id] = scorer(userInput, widget.options, strings, locale);
@@ -20403,7 +20745,7 @@ class Renderer extends React__namespace.Component {
       // Instead, we center them with css magic in styles.less
       // /cry(aria)
       this._foundTextNodes = true;
-      if (___default["default"].contains(this.widgetIds, node.id)) {
+      if (this.widgetIds.includes(node.id)) {
         // We don't want to render a duplicate widget key/ref,
         // as this causes problems with react (for obvious
         // reasons). Instead we just notify the
@@ -20728,7 +21070,7 @@ class Renderer extends React__namespace.Component {
   };
   getInputPaths = () => {
     const inputPaths = [];
-    ___default["default"].each(this.widgetIds, widgetId => {
+    this.widgetIds.forEach(widgetId => {
       const widget = this.getWidgetInstance(widgetId);
       if (widget && widget.getInputPaths) {
         // Grab all input paths and add widgetID to the front
@@ -20736,7 +21078,7 @@ class Renderer extends React__namespace.Component {
         // Prefix paths with their widgetID and add to collective
         // list of paths.
         // @ts-expect-error - TS2345 - Argument of type '(inputPath: string) => void' is not assignable to parameter of type 'CollectionIterator<FocusPath, void, readonly FocusPath[]>'.
-        ___default["default"].each(widgetInputPaths, inputPath => {
+        widgetInputPaths.forEach(inputPath => {
           const relativeInputPath = [widgetId].concat(inputPath);
           inputPaths.push(relativeInputPath);
         });
@@ -20929,33 +21271,30 @@ class Renderer extends React__namespace.Component {
   }
 
   /**
-   * Returns an object mapping from widget ID to perseus-style score.
-   * The keys of this object are the values of the array returned
-   * from `getWidgetIds`.
-   */
-  scoreWidgets() {
-    return scoreWidgetsFunctional(this.state.widgetInfo, this.widgetIds, this.getUserInputMap(), this.props.strings, this.context.locale);
-  }
-
-  /**
-   * Grades the content.
+   * Scores the content.
+   *
+   * @deprecated use scorePerseusItem
    */
   score() {
-    const scores = this.scoreWidgets();
+    const scores = scoreWidgetsFunctional(this.state.widgetInfo, this.widgetIds, this.getUserInputMap(), this.props.strings, this.context.locale);
     const combinedScore = Util.flattenScores(scores);
     return combinedScore;
   }
-  guessAndScore() {
+
+  /**
+   * @deprecated use scorePerseusItem
+   */
+  guessAndScore = () => {
     const totalGuess = this.getUserInput();
     const totalScore = this.score();
     return [totalGuess, totalScore];
-  }
+  };
   examples = () => {
     const widgetIds = this.widgetIds;
-    const examples = ___default["default"].compact(___default["default"].map(widgetIds, widgetId => {
+    const examples = widgetIds.map(widgetId => {
       const widget = this.getWidgetInstance(widgetId);
       return widget != null && widget.examples ? widget.examples() : null;
-    }));
+    }).filter(Boolean);
 
     // no widgets with examples
     if (!examples.length) {
@@ -22463,7 +22802,9 @@ const propUpgrades$2 = {
     // input-number to numeric-input. In this case, we need to upgrade
     // the widget options accordingly.
     if (initialProps.value) {
-      const provideAnswerForm = initialProps.answerType !== "number";
+      // If the answerType is not number or percent, we need to provide
+      // the answer form for the numeric-input widget
+      const provideAnswerForm = initialProps.answerType !== "number" && initialProps.answerType !== "percent";
 
       // We need to determine the mathFormat for the numeric-input widget
       const mathFormat = initialProps.answerType === "rational" ? "proper" // input-number uses "rational" for proper fractions
@@ -29528,6 +29869,9 @@ class Group extends React__namespace.Component {
         this.change("widgets", this.rendererRef.props.widgets);
       }
     };
+
+    // TODO(LEMS-2391): replace this when there's a separate check
+    // for valid/invalid state
     const score = this.rendererRef?.score();
     const isValid = score && score.type !== "invalid";
     const isInvalid = score && score.type === "invalid";
@@ -31371,6 +31715,108 @@ function AxisArrows() {
   })));
 }
 
+/**
+ * 44 is touch best practice and AAA compliant for WCAG
+ * https://www.w3.org/WAI/WCAG21/Understanding/target-size.html
+ */
+const TARGET_SIZE = 44;
+const REMOVE_BUTTON_ID = "perseus_mafs_remove_button";
+
+// same as pointsFromNormalized in interactive-graph.tsx
+const normalizePoints = (range, step, coordsList, noSnap) => coordsList.map(coords =>
+// maps over [x, y]
+coords.map((coord, i) => {
+  const axisRange = range[i];
+  if (noSnap) {
+    return axisRange[MIN] + size(axisRange) * coord;
+  }
+  const axisStep = step[i];
+  const nSteps = Math.floor(size(axisRange) / axisStep);
+  const tick = Math.round(coord * nSteps);
+  return axisRange[MIN] + axisStep * tick;
+}));
+
+// same as normalizeCoords in interactive-graph.tsx
+const normalizeCoords = (coordsList, ranges) => coordsList.map(coords => coords.map((coord, i) => {
+  return (coord + ranges[i][1]) / size(ranges[i]);
+}));
+
+// Returns the closest point to the given `point` that is within the graph
+// bounds given in `state`.
+function bound$1(_ref) {
+  let {
+    snapStep,
+    range,
+    point
+  } = _ref;
+  const boundingBox = inset(snapStep, range);
+  return clampToBox(boundingBox, point);
+}
+function isUnlimitedGraphState(state) {
+  return state.type === "point" && state.numPoints === "unlimited" || state.type === "polygon" && state.numSides === "unlimited";
+}
+
+/**
+ * Replace all text outside of the $ TeX blocks with `\\text{...}`
+ * This way, the entire resulting string can be rendered within <TeX>
+ * and the text outside of the $ blocks will be non-TeX text.
+ */
+function replaceOutsideTeX(mathString) {
+  // All the information we need is in the first section,
+  // whether it's typed as "blockmath" or "paragraph"
+  const firstSection = SimpleMarkdown__namespace.parse(mathString)[0];
+
+  // If it's blockMath, the outer level has the full math content.
+  if (firstSection.type === "blockMath") {
+    return firstSection.content;
+  }
+
+  // If it's a paragraph, we need to iterate through the sections
+  // to look for individual math blocks.
+  const condensedNodes = condenseTextNodes(firstSection.content);
+  let result = "";
+  for (const piece of condensedNodes) {
+    piece.type === "math" ? result += piece.content : result += `\\text{${escapeSpecialChars(piece.content)}}`;
+  }
+  return result;
+}
+// Helper function for replaceOutsideTeX()
+// Condense adjacent text nodes into a single text node
+function condenseTextNodes(nodes) {
+  const result = [];
+  if (!nodes) {
+    return result;
+  }
+  let currentText = "";
+  for (const node of nodes) {
+    if (node.type === "math") {
+      if (currentText) {
+        result.push({
+          type: "text",
+          content: currentText
+        });
+        currentText = "";
+      }
+      result.push(node);
+    } else {
+      currentText += node.content;
+    }
+  }
+  if (currentText) {
+    result.push({
+      type: "text",
+      content: currentText
+    });
+  }
+  return result;
+}
+
+// Helper function for replaceOutsideTeX()
+function escapeSpecialChars(str) {
+  // Escape $, \, {, and } characters
+  return str.replace(/([$\\{}])/g, "\\$1");
+}
+
 function AxisLabels() {
   const {
     range,
@@ -31402,7 +31848,7 @@ function AxisLabels() {
       fontSize: "14px",
       transform: "translate(7px, -50%)"
     }
-  }, /*#__PURE__*/React__default["default"].createElement(TeX, null, xAxisLabelText)), /*#__PURE__*/React__default["default"].createElement("span", {
+  }, /*#__PURE__*/React__default["default"].createElement(TeX, null, replaceOutsideTeX(xAxisLabelText))), /*#__PURE__*/React__default["default"].createElement("span", {
     style: {
       position: "absolute",
       left: x2,
@@ -31410,7 +31856,7 @@ function AxisLabels() {
       fontSize: "14px",
       transform: "translate(-50%, 0px)"
     }
-  }, /*#__PURE__*/React__default["default"].createElement(TeX, null, yAxisLabelText)));
+  }, /*#__PURE__*/React__default["default"].createElement(TeX, null, replaceOutsideTeX(yAxisLabelText))));
 }
 
 // The size of the ticks and labels in pixels
@@ -32348,108 +32794,6 @@ const lockedFigureFillStyles = {
 
 const plotterPlotTypes = ["bar", "line", "pic", "histogram", "dotplot"];
 
-/**
- * 44 is touch best practice and AAA compliant for WCAG
- * https://www.w3.org/WAI/WCAG21/Understanding/target-size.html
- */
-const TARGET_SIZE = 44;
-const REMOVE_BUTTON_ID = "perseus_mafs_remove_button";
-
-// same as pointsFromNormalized in interactive-graph.tsx
-const normalizePoints = (range, step, coordsList, noSnap) => coordsList.map(coords =>
-// maps over [x, y]
-coords.map((coord, i) => {
-  const axisRange = range[i];
-  if (noSnap) {
-    return axisRange[MIN] + size(axisRange) * coord;
-  }
-  const axisStep = step[i];
-  const nSteps = Math.floor(size(axisRange) / axisStep);
-  const tick = Math.round(coord * nSteps);
-  return axisRange[MIN] + axisStep * tick;
-}));
-
-// same as normalizeCoords in interactive-graph.tsx
-const normalizeCoords = (coordsList, ranges) => coordsList.map(coords => coords.map((coord, i) => {
-  return (coord + ranges[i][1]) / size(ranges[i]);
-}));
-
-// Returns the closest point to the given `point` that is within the graph
-// bounds given in `state`.
-function bound$1(_ref) {
-  let {
-    snapStep,
-    range,
-    point
-  } = _ref;
-  const boundingBox = inset(snapStep, range);
-  return clampToBox(boundingBox, point);
-}
-function isUnlimitedGraphState(state) {
-  return state.type === "point" && state.numPoints === "unlimited" || state.type === "polygon" && state.numSides === "unlimited";
-}
-
-/**
- * Replace all text outside of the $ TeX blocks with `\\text{...}`
- * This way, the entire resulting string can be rendered within <TeX>
- * and the text outside of the $ blocks will be non-TeX text.
- */
-function replaceOutsideTeX(mathString) {
-  // All the information we need is in the first section,
-  // whether it's typed as "blockmath" or "paragraph"
-  const firstSection = SimpleMarkdown__namespace.parse(mathString)[0];
-
-  // If it's blockMath, the outer level has the full math content.
-  if (firstSection.type === "blockMath") {
-    return firstSection.content;
-  }
-
-  // If it's a paragraph, we need to iterate through the sections
-  // to look for individual math blocks.
-  const condensedNodes = condenseTextNodes(firstSection.content);
-  let result = "";
-  for (const piece of condensedNodes) {
-    piece.type === "math" ? result += piece.content : result += `\\text{${escapeSpecialChars(piece.content)}}`;
-  }
-  return result;
-}
-// Helper function for replaceOutsideTeX()
-// Condense adjacent text nodes into a single text node
-function condenseTextNodes(nodes) {
-  const result = [];
-  if (!nodes) {
-    return result;
-  }
-  let currentText = "";
-  for (const node of nodes) {
-    if (node.type === "math") {
-      if (currentText) {
-        result.push({
-          type: "text",
-          content: currentText
-        });
-        currentText = "";
-      }
-      result.push(node);
-    } else {
-      currentText += node.content;
-    }
-  }
-  if (currentText) {
-    result.push({
-      type: "text",
-      content: currentText
-    });
-  }
-  return result;
-}
-
-// Helper function for replaceOutsideTeX()
-function escapeSpecialChars(str) {
-  // Escape $, \, {, and } characters
-  return str.replace(/([$\\{}])/g, "\\$1");
-}
-
 function LockedLabel(props) {
   const {
     coord,
@@ -33678,6 +34022,7 @@ function useControlPoint(params) {
   } = useGraphConfig();
   const {
     point,
+    sequenceNumber,
     color,
     cursor,
     constrain = p => snap(snapStep, p),
@@ -33718,6 +34063,7 @@ function useControlPoint(params) {
     ref: focusableHandleRef,
     role: "button",
     "aria-label": strings.srPointAtCoordinates({
+      num: sequenceNumber,
       x: srFormatNumber(point[X], locale),
       y: srFormatNumber(point[Y], locale)
     })
@@ -33795,6 +34141,7 @@ const MovableLine = props => {
     focusableHandle: focusableHandle1
   } = useControlPoint({
     point: start,
+    sequenceNumber: 1,
     color,
     onMove: p => onMovePoint(0, p)
   });
@@ -33803,6 +34150,7 @@ const MovableLine = props => {
     focusableHandle: focusableHandle2
   } = useControlPoint({
     point: end,
+    sequenceNumber: 2,
     color,
     onMove: p => onMovePoint(1, p)
   });
@@ -33984,14 +34332,17 @@ function AngleGraph(props) {
   // Render the lines, angle, and then movable points
   return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, svgLines, /*#__PURE__*/React__namespace.createElement(Angle, angleParams), /*#__PURE__*/React__namespace.createElement(MovablePoint$1, {
     point: coords[1],
+    sequenceNumber: 1,
     constrain: p => p,
     onMove: destination => dispatch(actions.angle.movePoint(1, destination))
   }), /*#__PURE__*/React__namespace.createElement(MovablePoint$1, {
     point: coords[0],
+    sequenceNumber: 2,
     constrain: getAngleSideConstraint(coords[0], coords[1], snapDegrees || 1),
     onMove: destination => dispatch(actions.angle.movePoint(0, destination))
   }), /*#__PURE__*/React__namespace.createElement(MovablePoint$1, {
     point: coords[2],
+    sequenceNumber: 3,
     constrain: getAngleSideConstraint(coords[2], coords[1], snapDegrees || 1),
     onMove: destination => dispatch(actions.angle.movePoint(2, destination))
   }));
@@ -34156,6 +34507,7 @@ function CircleGraph(props) {
     onMove: c => dispatch(actions.circle.moveCenter(c))
   }), /*#__PURE__*/React__namespace.createElement(MovablePoint$1, {
     point: radiusPoint,
+    sequenceNumber: 1,
     cursor: "ew-resize",
     onMove: newRadiusPoint => {
       dispatch(actions.circle.moveRadiusPoint(newRadiusPoint));
@@ -34331,6 +34683,7 @@ function LimitedPointGraph(props) {
   return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, props.graphState.coords.map((point, i) => /*#__PURE__*/React__namespace.createElement(MovablePoint$1, {
     key: i,
     point: point,
+    sequenceNumber: i + 1,
     onMove: destination => dispatch(actions.pointGraph.movePoint(i, destination))
   })));
 }
@@ -34372,6 +34725,7 @@ function UnlimitedPointGraph(props) {
   }), props.graphState.coords.map((point, i) => /*#__PURE__*/React__namespace.createElement(MovablePoint$1, {
     key: i,
     point: point,
+    sequenceNumber: i + 1,
     onMove: destination => dispatch(actions.pointGraph.movePoint(i, destination)),
     ref: ref => {
       itemsRef.current[i] = ref;
@@ -34403,9 +34757,10 @@ function describePointGraph(state, i18n) {
   if (state.coords.length === 0) {
     return strings.srNoInteractiveElements;
   }
-  const pointDescriptions = state.coords.map(_ref2 => {
+  const pointDescriptions = state.coords.map((_ref2, index) => {
     let [x, y] = _ref2;
     return strings.srPointAtCoordinates({
+      num: index + 1,
       x: srFormatNumber(x, locale),
       y: srFormatNumber(y, locale)
     });
@@ -34525,6 +34880,7 @@ const LimitedPolygonGraph = props => {
     key: "point-" + i,
     constrain: constrain,
     point: point,
+    sequenceNumber: i + 1,
     onMove: destination => {
       const now = Date.now();
       const targetFPS = 40;
@@ -34671,6 +35027,7 @@ const UnlimitedPolygonGraph = props => {
   }), props.graphState.coords.map((point, i) => /*#__PURE__*/React__namespace.createElement(MovablePoint$1, {
     key: i,
     point: point,
+    sequenceNumber: i + 1,
     onMove: destination => dispatch(actions.pointGraph.movePoint(i, destination)),
     ref: ref => {
       pointRef.current[i] = ref;
@@ -34743,6 +35100,7 @@ function QuadraticGraph(props) {
   }), 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))
   })));
 }
@@ -34871,6 +35229,7 @@ function SinusoidGraph(props) {
   }), coords.map((coord, i) => /*#__PURE__*/React__namespace.createElement(MovablePoint$1, {
     key: "point-" + i,
     point: coord,
+    sequenceNumber: i + 1,
     onMove: destination => dispatch(actions.sinusoid.movePoint(i, destination))
   })));
 }
@@ -45039,7 +45398,7 @@ const init = function () {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus";
-const libVersion = "41.5.0";
+const libVersion = "42.0.1";
 perseusCore.addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {
@@ -45644,6 +46003,13 @@ class ServerItemRenderer extends React__namespace.Component {
         this.props.onRendered(true);
       }
     }
+    if (this.props.score && this.props.score !== prevProps.score) {
+      const emptyQuestionAreaWidgets = this.questionRenderer.emptyWidgets();
+      this.setState({
+        questionCompleted: this.props.score.correct,
+        questionHighlightedWidgets: emptyQuestionAreaWidgets
+      });
+    }
   }
   componentWillUnmount() {
     if (this.blurTimeoutID != null) {
@@ -45779,18 +46145,37 @@ class ServerItemRenderer extends React__namespace.Component {
     return this.questionRenderer.getPromptJSON();
   }
 
+  /**
+   * Returns an array of the widget `.getUserInput()` results
+   *
+   * TODO: can we remove this? Seems to be just for backwards
+   * compatibility with old Perseus Chrome logging
+   * @deprecated use getUserInput
+   */
+  getUserInputLegacy() {
+    return this.questionRenderer.getUserInput();
+  }
+
+  /**
+   * Returns an object of the widget `.getUserInput()` results
+   */
+  getUserInput() {
+    return this.questionRenderer.getUserInputMap();
+  }
+
   /**
    * Grades the item.
+   *
+   * @deprecated use scorePerseusItem
    */
   scoreInput() {
-    const guessAndScore = this.questionRenderer.guessAndScore();
-    const guess = guessAndScore[0];
-    const score = guessAndScore[1];
+    const guess = this.getUserInput();
+    const score = scorePerseusItem(this.props.item.question, guess, this.context.strings, this.context.locale);
 
     // Continue to include an empty guess for the now defunct answer area.
     // TODO(alex): Check whether we rely on the format here for
     //             analyzing ProblemLogs. If not, remove this layer.
-    const maxCompatGuess = [guess, []];
+    const maxCompatGuess = [this.questionRenderer.getUserInput(), []];
     const keScore = Util.keScoreFromPerseusScore(score, maxCompatGuess, this.questionRenderer.getSerializedState());
     const emptyQuestionAreaWidgets = this.questionRenderer.emptyWidgets();
     this.setState({
@@ -47652,138 +48037,6 @@ const registerAllWidgetsForTesting = () => {
   replaceDeprecatedWidgets();
 };
 
-// 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.
- * Useful for multi-items that needs to split
- * one PerseusItem into several
- *
- * @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.
  *
@@ -49785,6 +50038,8 @@ exports.buildMapper = buildMapper;
 exports.components = components;
 exports.containerSizeClass = containerSizeClass;
 exports.contentHasWidgetType = contentHasWidgetType;
+exports.conversionRequired = conversionRequired;
+exports.convertDeprecatedWidgets = convertDeprecatedWidgets;
 exports.convertWidgetNameToEnum = convertWidgetNameToEnum;
 exports.displaySigFigs = displaySigFigs;
 exports.generateTestCategorizerWidget = generateTestCategorizerWidget;
@@ -49836,6 +50091,7 @@ exports.parsePerseusItem = parsePerseusItem;
 exports.plotterPlotTypes = plotterPlotTypes;
 exports.preprocessTex = preprocessTex;
 exports.registerAllWidgetsForTesting = registerAllWidgetsForTesting;
+exports.scorePerseusItem = scorePerseusItem;
 exports.shapes = shapes;
 exports.shouldHaveIndividualAnswer = shouldHaveIndividualAnswer;
 exports.traverse = traverse;