@khanacademy/perseus 50.0.0 → 51.0.0

package/dist/index.js

@@ -4,7 +4,9 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var KAS = require('@khanacademy/kas');
 var mathInput = require('@khanacademy/math-input');
+var perseusCore = require('@khanacademy/perseus-core');
 var PerseusLinter = require('@khanacademy/perseus-linter');
+var perseusScore = require('@khanacademy/perseus-score');
 var wonderBlocksCore = require('@khanacademy/wonder-blocks-core');
 var Tooltip$1 = require('@khanacademy/wonder-blocks-tooltip');
 var wonderBlocksTypography = require('@khanacademy/wonder-blocks-typography');
@@ -13,13 +15,11 @@ var classNames$1 = require('classnames');
 var React = require('react');
 var ReactDOM = require('react-dom');
 var _ = require('underscore');
-var perseusScore = require('@khanacademy/perseus-score');
 var Clickable = require('@khanacademy/wonder-blocks-clickable');
 var wonderBlocksPopover = require('@khanacademy/wonder-blocks-popover');
 var wonderBlocksTokens = require('@khanacademy/wonder-blocks-tokens');
 var $ = require('jquery');
 var uuid = require('uuid');
-var perseusCore = require('@khanacademy/perseus-core');
 var PropTypes = require('prop-types');
 var wonderStuffCore = require('@khanacademy/wonder-stuff-core');
 var wonderBlocksProgressSpinner = require('@khanacademy/wonder-blocks-progress-spinner');
@@ -282,7 +282,15 @@ const strings = {
   srAngleSideAtCoordinates: "Point %(point)s, %(side)s at %(x)s comma %(y)s",
   srAngleVertexAtCoordinatesWithAngleMeasure: "Point 2, vertex at %(x)s comma %(y)s. Angle %(angleMeasure)s degrees",
   srAngleGraphAriaLabel: "An angle on a coordinate plane.",
-  srAngleGraphAriaDescription: "The angle measure is %(angleMeasure)s degrees with a vertex at %(vertexX)s comma %(vertexY)s, a point on the starting side at %(startingSideX)s comma %(startingSideY)s and a point on the ending side at %(endingSideX)s comma %(endingSideY)s"
+  srAngleGraphAriaDescription: "The angle measure is %(angleMeasure)s degrees with a vertex at %(vertexX)s comma %(vertexY)s, a point on the starting side at %(startingSideX)s comma %(startingSideY)s and a point on the ending side at %(endingSideX)s comma %(endingSideY)s",
+  srLinearSystemGraph: "Two lines on a coordinate plane.",
+  srLinearSystemPoints: "Line %(lineNumber)s has two points, point 1 at %(point1X)s comma %(point1Y)s and point 2 at %(point2X)s comma %(point2Y)s.",
+  srLinearSystemPoint: "Point %(pointSequence)s on line %(lineNumber)s at %(x)s comma %(y)s.",
+  srRayGraph: "A ray on a coordinate plane.",
+  srRayPoints: "The endpoint is at %(point1X)s comma %(point1Y)s and the ray goes through point %(point2X)s comma %(point2Y)s.",
+  srRayGrabHandle: "Ray with endpoint %(point1X)s comma %(point1Y)s going through point %(point2X)s comma %(point2Y)s.",
+  srRayEndpoint: "Endpoint at %(point1X)s comma %(point1Y)s.",
+  srRayTerminalPoint: "Through point at %(point2X)s comma %(point2Y)s."
   // The above strings are used for interactive graph SR descriptions.
 };
 
@@ -671,19 +679,84 @@ const mockStrings = {
       endingSideY
     } = _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}.`;
+  },
+  srLinearSystemGraph: "Two lines on a coordinate plane.",
+  srLinearSystemPoints: _ref41 => {
+    let {
+      lineNumber,
+      point1X,
+      point1Y,
+      point2X,
+      point2Y
+    } = _ref41;
+    return `Line ${lineNumber} has two points, point 1 at ${point1X} comma ${point1Y} and point 2 at ${point2X} comma ${point2Y}.`;
+  },
+  srLinearSystemPoint: _ref42 => {
+    let {
+      lineNumber,
+      pointSequence,
+      x,
+      y
+    } = _ref42;
+    return `Point ${pointSequence} on line ${lineNumber} at ${x} comma ${y}.`;
+  },
+  srRayGraph: "A ray on a coordinate plane.",
+  srRayPoints: _ref43 => {
+    let {
+      point1X,
+      point1Y,
+      point2X,
+      point2Y
+    } = _ref43;
+    return `The endpoint is at ${point1X} comma ${point1Y} and the ray goes through point ${point2X} comma ${point2Y}.`;
+  },
+  srRayGrabHandle: _ref44 => {
+    let {
+      point1X,
+      point1Y,
+      point2X,
+      point2Y
+    } = _ref44;
+    return `Ray with endpoint ${point1X} comma ${point1Y} going through point ${point2X} comma ${point2Y}.`;
+  },
+  srRayEndpoint: _ref45 => {
+    let {
+      x,
+      y
+    } = _ref45;
+    return `Endpoint at ${x} comma ${y}.`;
+  },
+  srRayTerminalPoint: _ref46 => {
+    let {
+      x,
+      y
+    } = _ref46;
+    return `Through point at ${x} comma ${y}.`;
   }
   // The above strings are used for interactive graph SR descriptions.
 };
 
-({
-  [perseusScore.ErrorCodes.MISSING_PERCENT_ERROR]: strings.MISSING_PERCENT_ERROR,
-  [perseusScore.ErrorCodes.NEEDS_TO_BE_SIMPLIFIED_ERROR]: strings.NEEDS_TO_BE_SIMPLFIED_ERROR,
-  [perseusScore.ErrorCodes.APPROXIMATED_PI_ERROR]: strings.APPROXIMATED_PI_ERROR,
-  [perseusScore.ErrorCodes.EXTRA_SYMBOLS_ERROR]: strings.EXTRA_SYMBOLS_ERROR,
-  [perseusScore.ErrorCodes.WRONG_CASE_ERROR]: strings.WRONG_CASE_ERROR,
-  [perseusScore.ErrorCodes.WRONG_LETTER_ERROR]: strings.WRONG_LETTER_ERROR,
-  [perseusScore.ErrorCodes.MULTIPLICATION_SIGN_ERROR]: strings.MULTIPLICATION_SIGN_ERROR
-});
+// This type helps us make sure all error codes are mapped to strings
+
+const errorToString = {
+  MISSING_PERCENT_ERROR: strings.MISSING_PERCENT_ERROR,
+  NEEDS_TO_BE_SIMPLIFIED_ERROR: strings.NEEDS_TO_BE_SIMPLFIED_ERROR,
+  APPROXIMATED_PI_ERROR: strings.APPROXIMATED_PI_ERROR,
+  EXTRA_SYMBOLS_ERROR: strings.EXTRA_SYMBOLS_ERROR,
+  WRONG_CASE_ERROR: strings.WRONG_CASE_ERROR,
+  WRONG_LETTER_ERROR: strings.WRONG_LETTER_ERROR,
+  MULTIPLICATION_SIGN_ERROR: strings.MULTIPLICATION_SIGN_ERROR,
+  INVALID_SELECTION_ERROR: strings.invalidSelection,
+  CHOOSE_CORRECT_NUM_ERROR: strings.chooseCorrectNum,
+  NOT_NONE_ABOVE_ERROR: strings.notNoneOfTheAbove,
+  FILL_ALL_CELLS_ERROR: strings.fillAllCells
+};
+function mapErrorToString(err) {
+  if (!err) {
+    return err;
+  }
+  return errorToString[err] || err;
+}
 
 /**
  * PerseusI18nContext provides a way to set the strings and locale that are
@@ -1610,204 +1683,6 @@ const getPromptJSON$t = (renderProps, userInput) => {
   };
 };
 
-/**
- *  Get the character used for separating decimals.
- */
-const getDecimalSeparator = locale => {
-  switch (locale) {
-    // TODO(somewhatabstract): Remove this when Chrome supports the `ka`
-    // locale properly.
-    // https://github.com/formatjs/formatjs/issues/1526#issuecomment-559891201
-    //
-    // Supported locales in Chrome:
-    // https://source.chromium.org/chromium/chromium/src/+/master:third_party/icu/scripts/chrome_ui_languages.list
-    case "ka":
-      return ",";
-    default:
-      const numberWithDecimalSeparator = 1.1;
-      // TODO(FEI-3647): Update to use .formatToParts() once we no longer have to
-      // support Safari 12.
-      const match = new Intl.NumberFormat(locale).format(numberWithDecimalSeparator)
-      // 0x661 is ARABIC-INDIC DIGIT ONE
-      // 0x6F1 is EXTENDED ARABIC-INDIC DIGIT ONE
-      .match(/[^\d\u0661\u06F1]/);
-      return match?.[0] ?? ".";
-  }
-};
-
-// TODO(LP-11481): Change the primary API we use for logging in Perseus to use
-// getDependencies() internally... simplify usage to just using a "singleton"
-// which get's the injected logger.
-/**
- * Provides logging infrastructure for Perseus
- */
-const Log = {
-  // Logs a message
-  log: (message, extra) => {
-    getDependencies().Log.log(message, extra);
-  },
-  // Logs an error with a message
-  error: (message, kind, extra) => {
-    getDependencies().Log.error(message, kind, extra);
-  }
-};
-
-/**
- * Checks user input from the expression widget to see if it is scorable.
- *
- * Note: Most of the expression widget's validation requires the Rubric because
- * of its use of KhanAnswerTypes as a core part of scoring.
- *
- * @see `scoreExpression()` for more details.
- */
-function validateExpression(userInput) {
-  if (userInput === "") {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
-
-/* Content creators input a list of answers which are matched from top to
- * bottom. The intent is that they can include spcific solutions which should
- * be graded as correct or incorrect (or ungraded!) first, then get more
- * general.
- *
- * We iterate through each answer, trying to match it with the user's input
- * using the following angorithm:
- * - Try to parse the user's input. If it doesn't parse then return "not
- *   graded".
- * - For each answer:
- *   ~ Try to validate the user's input against the answer. The answer is
- *     expected to parse.
- *   ~ If the user's input validates (the validator judges it "correct"), we've
- *     matched and can stop considering answers.
- * - If there were no matches or the matching answer is considered "ungraded",
- *   show the user an error. TODO(joel) - what error?
- * - Otherwise, pass through the resulting points and message.
- */
-function scoreExpression(userInput, rubric, strings, locale) {
-  const validationError = validateExpression(userInput);
-  if (validationError) {
-    return validationError;
-  }
-  const options = ___default["default"].clone(rubric);
-  ___default["default"].extend(options, {
-    decimal_separator: getDecimalSeparator(locale)
-  });
-  const createValidator = answer => {
-    // We give options to KAS.parse here because it is parsing the
-    // solution answer, not the student answer, and we don't want a
-    // solution to work if the student is using a different language
-    // (different from the content creation language, ie. English).
-    const expression = KAS__namespace.parse(answer.value, rubric);
-    // An answer may not be parsed if the expression was defined
-    // incorrectly. For example if the answer is using a symbol defined
-    // in the function variables list for the expression.
-    if (!expression.parsed) {
-      /* c8 ignore next */
-      Log.error("Unable to parse solution answer for expression", perseusCore.Errors.InvalidInput, {
-        loggedMetadata: {
-          rubric: JSON.stringify(rubric)
-        }
-      });
-      return null;
-    }
-    return perseusScore.KhanAnswerTypes.expression.createValidatorFunctional(expression.expr, ___default["default"]({}).extend(options, {
-      simplify: answer.simplify,
-      form: answer.form
-    }));
-  };
-
-  // Find the first answer form that matches the user's input and that
-  // is considered correct. Also, track whether the input is
-  // considered "empty" for all answer forms, and keep the validation
-  // result for the first answer form for which the user's input was
-  // considered "ungraded".
-  // (Terminology reminder: the answer forms are provided by the
-  // assessment items; they are not the user's input. Each one might
-  // represent a correct answer, an incorrect one (if the exercise
-  // creator has predicted certain common wrong answers and wants to
-  // provide guidance via a message), or an ungraded one (same idea,
-  // but without giving the user an incorrect mark for the question).
-  let matchingAnswerForm;
-  let matchMessage;
-  let allEmpty = true;
-  let firstUngradedResult;
-  for (const answerForm of rubric.answerForms || []) {
-    const validator = createValidator(answerForm);
-    if (!validator) {
-      continue;
-    }
-    const result = validator(userInput);
-
-    // Short-circuit as soon as the user's input matches some answer
-    // (independently of whether the answer is correct)
-    if (result.correct) {
-      matchingAnswerForm = answerForm;
-      matchMessage = result.message || "";
-      break;
-    }
-    allEmpty = allEmpty && result.empty;
-    // If this answer form is correct and the user's input is considered
-    // "ungraded" for it, we'll want to keep the evaluation result for
-    // later. If the user's input doesn't match any answer forms, we'll
-    // show the message from this validation.
-    if (answerForm.considered === "correct" && result.ungraded && !firstUngradedResult) {
-      firstUngradedResult = result;
-    }
-  }
-
-  // Now check to see if we matched any answer form at all, and if
-  // we did, whether it's considered correct, incorrect, or ungraded
-  if (!matchingAnswerForm) {
-    if (firstUngradedResult) {
-      // While we didn't directly match with any answer form, we
-      // did at some point get an "ungraded" validation result,
-      // which might indicate e.g. a mismatch in variable casing.
-      // We'll return "invalid", which will let the user try again
-      // with no penalty, and the hopefully helpful validation
-      // message.
-      return {
-        type: "invalid",
-        message: firstUngradedResult.message,
-        suppressAlmostThere: firstUngradedResult.suppressAlmostThere
-      };
-    }
-    if (allEmpty) {
-      // If everything graded as empty, it's invalid.
-      return {
-        type: "invalid",
-        message: null
-      };
-    }
-    // We fell through all the possibilities and we're not empty,
-    // so the answer is considered incorrect.
-    return {
-      type: "points",
-      earned: 0,
-      total: 1
-    };
-  }
-  if (matchingAnswerForm.considered === "ungraded") {
-    return {
-      type: "invalid",
-      message: matchMessage
-    };
-  }
-  // We matched a graded answer form, so we can now tell the user
-  // whether their input was correct or incorrect, and hand out
-  // points accordingly
-  return {
-    type: "points",
-    earned: matchingAnswerForm.considered === "correct" ? 1 : 0,
-    total: 1,
-    message: matchMessage
-  };
-}
-
 // Map of international operator names to their English equivalents
 const englishOperators = {
   arctg: "arctan",
@@ -1918,7 +1793,7 @@ class Expression extends React__namespace.Component {
     // make it so that solution answers with ','s or '.'s work
     const options = ___default["default"].pick(props || this.props, "functions");
     ___default["default"].extend(options, {
-      decimal_separator: getDecimalSeparator(this.context.locale)
+      decimal_separator: perseusCore.getDecimalSeparator(this.context.locale)
     });
     return KAS__namespace.parse(normalizeTex(value), options);
   };
@@ -2196,7 +2071,7 @@ var Expression$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusExpressionUserInput'.
-  scorer: scoreExpression,
+  scorer: perseusScore.scoreExpression,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'Rubric' is not assignable to type 'PerseusExpressionRubric'.
   getOneCorrectAnswerFromRubric(rubric) {
@@ -2566,56 +2441,6 @@ function constrainedTickStepsFromTickSteps(tickSteps, ranges) {
   return [constrainTickStep(tickSteps[0], ranges[0]), constrainTickStep(tickSteps[1], ranges[1])];
 }
 
-/**
- * Approximate equality on numbers and primitives.
- */
-function eq$4(x, y) {
-  if (typeof x === "number" && typeof y === "number") {
-    return Math.abs(x - y) < 1e-9;
-  }
-  return x === y;
-}
-
-/**
- * Deep approximate equality on primitives, numbers, arrays, and objects.
- * Recursive.
- */
-function deepEq$7(x, y) {
-  if (Array.isArray(x) && Array.isArray(y)) {
-    if (x.length !== y.length) {
-      return false;
-    }
-    for (let i = 0; i < x.length; i++) {
-      if (!deepEq$7(x[i], y[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (Array.isArray(x) || Array.isArray(y)) {
-    return false;
-  }
-  if (typeof x === "function" && typeof y === "function") {
-    return eq$4(x, y);
-  }
-  if (typeof x === "function" || typeof y === "function") {
-    return false;
-  }
-  if (typeof x === "object" && typeof y === "object" && !!x && !!y) {
-    return x === y || ___default["default"].all(x, function (v, k) {
-      // @ts-expect-error - TS2536 - Type 'CollectionKey<T>' cannot be used to index type 'T'.
-      return deepEq$7(y[k], v);
-    }) && ___default["default"].all(y, function (v, k) {
-      // @ts-expect-error - TS2536 - Type 'CollectionKey<T>' cannot be used to index type 'T'.
-      return deepEq$7(x[k], v);
-    });
-  }
-  if (typeof x === "object" && !!x || typeof y === "object" && !!y) {
-    return false;
-  }
-  return eq$4(x, y);
-}
-
 /**
  * Query String Parser
  *
@@ -2830,15 +2655,6 @@ const textarea = {
  */
 const unescapeMathMode$1 = label => label.startsWith("$") && label.endsWith("$") ? label.slice(1, -1) : label;
 const random$1 = seededRNG$1(new Date().getTime() & 0xffffffff);
-
-// TODO(benchristel): in the future, we may want to make deepClone work for
-// Record<string, Cloneable> as well. Currently, it only does arrays.
-function deepClone(obj) {
-  if (Array.isArray(obj)) {
-    return obj.map(deepClone);
-  }
-  return obj;
-}
 const Util = {
   inputPathsEqual,
   nestedMap: nestedMap$2,
@@ -2859,8 +2675,6 @@ const Util = {
   gridStepFromTickStep,
   tickStepFromNumTicks,
   constrainedTickStepsFromTickSteps,
-  eq: eq$4,
-  deepEq: deepEq$7,
   parseQueryString,
   updateQueryString: updateQueryString$2,
   strongEncodeURIComponent,
@@ -2878,8 +2692,24 @@ const Util = {
   getDataUrl: getDataUrl,
   textarea,
   unescapeMathMode: unescapeMathMode$1,
-  random: random$1,
-  deepClone
+  random: random$1
+};
+
+// TODO(LP-11481): Change the primary API we use for logging in Perseus to use
+// getDependencies() internally... simplify usage to just using a "singleton"
+// which get's the injected logger.
+/**
+ * Provides logging infrastructure for Perseus
+ */
+const Log = {
+  // Logs a message
+  log: (message, extra) => {
+    getDependencies().Log.log(message, extra);
+  },
+  // Logs an error with a message
+  error: (message, kind, extra) => {
+    getDependencies().Log.error(message, kind, extra);
+  }
 };
 
 // For offline exercises in the mobile app, we download the graphie data
@@ -8428,7 +8258,7 @@ var Tex$1 = {
 const {
   processMath: processMath$1
 } = Tex$1;
-function polar$1(r, th) {
+function polar$2(r, th) {
   if (typeof r === "number") {
     r = [r, r];
   }
@@ -8767,8 +8597,8 @@ class Graphie$1 {
       endAngle = (endAngle % 360 + 360) % 360;
       const cent = this.scalePoint(center);
       const radii = this.scaleVector(radius);
-      const startVector = polar$1(radius, startAngle);
-      const endVector = polar$1(radius, endAngle);
+      const startVector = polar$2(radius, startAngle);
+      const endVector = polar$2(radius, endAngle);
 
       // We round the coordinates to make testing easier, because trig
       // operations return unround numbers.
@@ -10312,261 +10142,11 @@ class WrappedLine extends WrappedDrawing {
   }
 }
 
-/**
- * A collection of geomtry-related utility functions
- */
-const {
-  eq: eq$3,
-  deepEq: deepEq$6
-} = Util;
-
-// This should really be a readonly tuple of [number, number]
-
-// a, b, c
-
-// Given a number, return whether it is positive (1), negative (-1), or zero (0)
-function sign(val) {
-  if (eq$3(val, 0)) {
-    return 0;
-  }
-  return val > 0 ? 1 : -1;
-}
-
-// Determine whether three points are collinear (0), for a clockwise turn (negative),
-// or counterclockwise turn (positive)
-function ccw(a, b, c) {
-  return (b[0] - a[0]) * (c[1] - a[1]) - (c[0] - a[0]) * (b[1] - a[1]);
-}
-function collinear(a, b, c) {
-  return eq$3(ccw(a, b, c), 0);
-}
-
-// Given rect bounding points A and B, whether point C is inside the rect
-function pointInRect(a, b, c) {
-  return c[0] <= Math.max(a[0], b[0]) && c[0] >= Math.min(a[0], b[0]) && c[1] <= Math.max(a[1], b[1]) && c[1] >= Math.min(a[1], b[1]);
-}
-
-// Whether line segment AB intersects line segment CD
-// http://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/
-function intersects(ab, cd) {
-  const triplets = [[ab[0], ab[1], cd[0]], [ab[0], ab[1], cd[1]], [cd[0], cd[1], ab[0]], [cd[0], cd[1], ab[1]]];
-  const orientations = ___default["default"].map(triplets, function (triplet) {
-    return sign(ccw(...triplet));
-  });
-  if (orientations[0] !== orientations[1] && orientations[2] !== orientations[3]) {
-    return true;
-  }
-  for (let i = 0; i < 4; i++) {
-    if (orientations[i] === 0 && pointInRect(...triplets[i])) {
-      return true;
-    }
-  }
-  return false;
-}
-
-// Whether any two sides of a polygon intersect each other
-function polygonSidesIntersect(vertices) {
-  for (let i = 0; i < vertices.length; i++) {
-    for (let k = i + 1; k < vertices.length; k++) {
-      // If any two vertices are the same point, sides overlap
-      if (kmath.point.equal(vertices[i], vertices[k])) {
-        return true;
-      }
-
-      // Find the other end of the sides starting at vertices i and k
-      const iNext = (i + 1) % vertices.length;
-      const kNext = (k + 1) % vertices.length;
-
-      // Adjacent sides always intersect (at the vertex); skip those
-      if (iNext === k || kNext === i) {
-        continue;
-      }
-      const side1 = [vertices[i], vertices[iNext]];
-      const side2 = [vertices[k], vertices[kNext]];
-      if (intersects(side1, side2)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function vector(a, b) {
-  return ___default["default"].map(___default["default"].zip(a, b), function (pair) {
-    return pair[0] - pair[1];
-  });
-}
-function reverseVector(vector) {
-  return [-vector[0], -vector[1]];
-}
-
-// Returns whether connecting the given sequence of `points` forms a clockwise
-// path (assuming a closed loop, where the last point connects back to the
-// first).
-function clockwise$1(points) {
-  const segments = ___default["default"].zip(points, points.slice(1).concat(points.slice(0, 1)));
-  const areas = ___default["default"].map(segments, function (segment) {
-    const p1 = segment[0];
-    const p2 = segment[1];
-    return (p2[0] - p1[0]) * (p2[1] + p1[1]);
-  });
-  return kmath.sum(areas) > 0;
-}
-function magnitude(v) {
-  return Math.sqrt(___default["default"].reduce(v, function (memo, el) {
-    // @ts-expect-error - TS2345 - Argument of type 'Coord' is not assignable to parameter of type 'number'.
-    return memo + Math.pow(el, 2);
-  }, 0));
-}
-function dotProduct(a, b) {
-  return ___default["default"].reduce(___default["default"].zip(a, b), function (memo, pair) {
-    return memo + pair[0] * pair[1];
-  }, 0);
-}
-function sideLengths(coords) {
-  const segments = ___default["default"].zip(coords, rotate(coords));
-  return segments.map(function (segment) {
-    // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'readonly Coord[]'. | TS2556 - A spread argument must either have a tuple type or be passed to a rest parameter.
-    return magnitude(vector(...segment));
-  });
-}
-
-// Based on http://math.stackexchange.com/a/151149
-function angleMeasures(coords) {
-  const triplets = ___default["default"].zip(rotate(coords, -1), coords, rotate(coords, 1));
-  const offsets = ___default["default"].map(triplets, function (triplet) {
-    const p = vector(triplet[1], triplet[0]);
-    const q = vector(triplet[2], triplet[1]);
-    // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'Coord'. | TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'readonly Coord[]'. | TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'readonly Coord[]'.
-    const raw = Math.acos(dotProduct(p, q) / (magnitude(p) * magnitude(q)));
-    // @ts-expect-error - TS2556 - A spread argument must either have a tuple type or be passed to a rest parameter.
-    return sign(ccw(...triplet)) > 0 ? raw : -raw;
-  });
-  const sum = ___default["default"].reduce(offsets, function (memo, arg) {
-    return memo + arg;
-  }, 0);
-  return ___default["default"].map(offsets, function (offset) {
-    return sum > 0 ? Math.PI - offset : Math.PI + offset;
-  });
-}
-
-// Whether two polygons are similar (or if specified, congruent)
-function similar(coords1, coords2, tolerance) {
-  if (coords1.length !== coords2.length) {
-    return false;
-  }
-  const n = coords1.length;
-  const angles1 = angleMeasures(coords1);
-  const angles2 = angleMeasures(coords2);
-  const sides1 = sideLengths(coords1);
-  const sides2 = sideLengths(coords2);
-  for (let i = 0; i < 2 * n; i++) {
-    let angles = angles2.slice();
-    let sides = sides2.slice();
-
-    // Reverse angles and sides to allow matching reflected polygons
-    if (i >= n) {
-      angles.reverse();
-      sides.reverse();
-      // Since sides are calculated from two coordinates,
-      // simply reversing results in an off by one error
-      // @ts-expect-error - TS4104 - The type 'readonly number[]' is 'readonly' and cannot be assigned to the mutable type 'number[]'.
-      sides = rotate(sides, 1);
-    }
-
-    // @ts-expect-error - TS4104 - The type 'readonly number[]' is 'readonly' and cannot be assigned to the mutable type 'number[]'.
-    angles = rotate(angles, i);
-    // @ts-expect-error - TS4104 - The type 'readonly number[]' is 'readonly' and cannot be assigned to the mutable type 'number[]'.
-    sides = rotate(sides, i);
-    if (deepEq$6(angles1, angles)) {
-      const sidePairs = ___default["default"].zip(sides1, sides);
-      const factors = ___default["default"].map(sidePairs, function (pair) {
-        return pair[0] / pair[1];
-      });
-      const same = ___default["default"].all(factors, function (factor) {
-        return eq$3(factors[0], factor);
-      });
-      const congruentEnough = ___default["default"].all(sidePairs, function (pair) {
-        return kmath.number.equal(pair[0], pair[1], tolerance);
-      });
-      if (same && congruentEnough) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-// Given triangle with sides ABC return angle opposite side C in degrees
-function lawOfCosines(a, b, c) {
-  return Math.acos((a * a + b * b - c * c) / (2 * a * b)) * 180 / Math.PI;
-}
-function canonicalSineCoefficients$1(_ref) {
-  let [amplitude, angularFrequency, phase, verticalOffset] = _ref;
-  // For a curve of the form f(x) = a * Sin(b * x - c) + d,
-  // this function ensures that a, b > 0, and c is its
-  // smallest possible positive value.
-
-  // Guarantee a > 0
-  if (amplitude < 0) {
-    amplitude *= -1;
-    angularFrequency *= -1;
-    phase *= -1;
-  }
-  const period = 2 * Math.PI;
-  // Guarantee b > 0
-  if (angularFrequency < 0) {
-    angularFrequency *= -1;
-    phase *= -1;
-    phase += period / 2;
-  }
-
-  // Guarantee c is smallest possible positive value
-  while (phase > 0) {
-    phase -= period;
-  }
-  while (phase < 0) {
-    phase += period;
-  }
-  return [amplitude, angularFrequency, phase, verticalOffset];
-}
-
-// e.g. rotate([1, 2, 3]) -> [2, 3, 1]
-function rotate(array, n) {
-  n = typeof n === "undefined" ? 1 : n % array.length;
-  return array.slice(n).concat(array.slice(0, n));
-}
-function getLineEquation(first, second) {
-  if (eq$3(first[0], second[0])) {
-    return "x = " + first[0].toFixed(3);
-  }
-  const m = (second[1] - first[1]) / (second[0] - first[0]);
-  const b = first[1] - m * first[0];
-  return "y = " + m.toFixed(3) + "x + " + b.toFixed(3);
-}
-
-// Stolen from the wikipedia article
-// http://en.wikipedia.org/wiki/Line-line_intersection
-function getLineIntersection(
-// TODO(LP-10725): update these to be 2-tuples
-firstPoints, secondPoints) {
-  const x1 = firstPoints[0][0];
-  const y1 = firstPoints[0][1];
-  const x2 = firstPoints[1][0];
-  const y2 = firstPoints[1][1];
-  const x3 = secondPoints[0][0];
-  const y3 = secondPoints[0][1];
-  const x4 = secondPoints[1][0];
-  const y4 = secondPoints[1][1];
-  const determinant = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4);
-  if (Math.abs(determinant) < 1e-9) {
-    return "Lines are parallel";
-  }
-  const x = ((x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4)) / determinant;
-  const y = ((x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4)) / determinant;
-  return "Intersection: (" + x.toFixed(3) + ", " + y.toFixed(3) + ")";
-}
-
 /* eslint-disable @babel/no-invalid-this */
+const {
+  clockwise: clockwise$3,
+  reverseVector: reverseVector$1
+} = kmath.geometry;
 function scaledDistanceFromAngle(angle) {
   const a = 3.51470560176242 * 20;
   const b = 0.5687298702748785 * 20;
@@ -10710,7 +10290,7 @@ ___default["default"].extend(GraphUtils.Graphie.prototype, {
         const sOffset = sSpacing * (i - (n - 1) / 2);
         const sOffsetVector = scaledPolarRad(sOffset, parallelAngle);
         const sHeightVector = scaledPolarRad(sHeight, perpendicularAngle);
-        const sPath = [kmath.vector.add(sMidpoint, sOffsetVector, sHeightVector), kmath.vector.add(sMidpoint, sOffsetVector, reverseVector(sHeightVector))];
+        const sPath = [kmath.vector.add(sMidpoint, sOffsetVector, sHeightVector), kmath.vector.add(sMidpoint, sOffsetVector, reverseVector$1(sHeightVector))];
 
         // @ts-expect-error - TS2345 - Argument of type 'any' is not assignable to parameter of type 'never'.
         temp.push(graphie.scaledPath(sPath, style));
@@ -10735,7 +10315,7 @@ ___default["default"].extend(GraphUtils.Graphie.prototype, {
         const sOffset = sCumulativeOffset + sSpacing * i;
         let sOffsetVector = scaledPolarRad(sOffset, parallelAngle);
         if (start !== p1) {
-          sOffsetVector = reverseVector(sOffsetVector);
+          sOffsetVector = reverseVector$1(sOffsetVector);
         }
         const sEnd = kmath.vector.add(sMidpoint, sOffsetVector);
 
@@ -11802,7 +11382,7 @@ ___default["default"].extend(GraphUtils.Graphie.prototype, {
       // Temporary objects
       ___default["default"].invoke(polygon.temp, "remove");
       polygon.temp = [];
-      const isClockwise = clockwise$1(polygon.coords);
+      const isClockwise = clockwise$3(polygon.coords);
 
       // Update angle labels
       if (polygon.angleLabels.length || polygon.showRightAngleMarkers.length) {
@@ -13223,7 +12803,7 @@ ___default["default"].extend(MovableAngle.prototype, {
     points[1].onMove = function (x, y) {
       const oldVertex = points[1].coord;
       const newVertex = [x, y];
-      const delta = kmath.vector.add(newVertex, reverseVector(oldVertex));
+      const delta = kmath.vector.add(newVertex, reverseVector$1(oldVertex));
       let valid = true;
       const newPoints = {};
       ___default["default"].each([0, 2], function (i) {
@@ -13265,7 +12845,7 @@ ___default["default"].extend(MovableAngle.prototype, {
           let angle = GraphUtils.findAngleDeprecated(newPoint, vertex);
           angle = Math.round((angle - snapOffset) / snap) * snap + snapOffset;
           const distance = GraphUtils.getDistance(newPoint, vertex);
-          return kmath.vector.add(vertex, polar$1(distance, angle));
+          return kmath.vector.add(vertex, polar$2(distance, angle));
         }
         return true;
       };
@@ -13416,7 +12996,6 @@ ___default["default"].extend(MovableAngle.prototype, {
 
 /* eslint-disable @babel/no-invalid-this */
 const nestedMap$1 = Util.nestedMap;
-const deepEq$5 = Util.deepEq;
 
 /**
  * A base class for all Graphie Movables
@@ -13513,7 +13092,7 @@ const createSimpleClass = function (addFunction) {
       this._prevProps = this.props;
     },
     modify: function (graphie) {
-      if (!deepEq$5(this.props, this._prevProps)) {
+      if (!perseusCore.approximateDeepEqual(this.props, this._prevProps)) {
         this.remove();
         this.add(graphie);
         this._prevProps = this.props;
@@ -15236,7 +14815,7 @@ function sum(array) {
     return memo + arg;
   }, 0);
 }
-function clockwise(points) {
+function clockwise$2(points) {
   const segments = ___default["default"].zip(points, points.slice(1).concat(points.slice(0, 1)));
   const areas = ___default["default"].map(segments, function (segment) {
     const p1 = segment[0];
@@ -15302,7 +14881,7 @@ const draw$1 = {
     const graphie = this.graphie;
     const self = this;
     const coords = ___default["default"].invoke(state.points, "coord");
-    const isClockwise = clockwise(coords);
+    const isClockwise = clockwise$2(coords);
     const n = coords.length;
 
     // graphie.labelAngle and similar methods attempt to re-use the label
@@ -16012,7 +15591,7 @@ const Parabola = GraphieClasses.createClass({
     this.parabola.toFront();
   }
 });
-const Sinusoid$1 = GraphieClasses.createClass({
+const Sinusoid = GraphieClasses.createClass({
   displayName: "Sinusoid",
   movableProps: ["children"],
   add: function (graphie) {
@@ -16034,7 +15613,7 @@ const Sinusoid$1 = GraphieClasses.createClass({
     this.sinusoid.toFront();
   }
 });
-const Plot$2 = GraphieClasses.createSimpleClass((graphie, props) => {
+const Plot$1 = GraphieClasses.createSimpleClass((graphie, props) => {
   return graphie.plot(props.fn, props.range, props.style);
 });
 const PlotParametric$1 = GraphieClasses.createSimpleClass((graphie, props) => {
@@ -16092,17 +15671,16 @@ var Movables = {
   MovablePoint: MovablePoint$4,
   Parabola: Parabola,
   Path: Path,
-  Plot: Plot$2,
+  Plot: Plot$1,
   PlotParametric: PlotParametric$1,
   Point: Point$1,
-  Sinusoid: Sinusoid$1,
+  Sinusoid: Sinusoid,
   Rect: Rect$1
 };
 
 const GraphieMovable = GraphieClasses.GraphieMovable;
 const createGraphie = GraphUtils.createGraphie;
 const {
-  deepEq: deepEq$4,
   nestedMap
 } = Util;
 const {
@@ -16140,7 +15718,7 @@ class Graphie extends React__namespace.Component {
     if (this.props.setup !== prevProps.setup) {
       Log.error("<Graphie> was given a new setup function. " + "This is a bad idea; please refactor your code to give " + "the same setup function reference to <Graphie> on " + "every render.", perseusCore.Errors.Internal);
     }
-    if (!deepEq$4(this.props.options, prevProps.options) || !deepEq$4(this.props.box, prevProps.box) || !deepEq$4(this.props.range, prevProps.range)) {
+    if (!perseusCore.approximateDeepEqual(this.props.options, prevProps.options) || !perseusCore.approximateDeepEqual(this.props.box, prevProps.box) || !perseusCore.approximateDeepEqual(this.props.range, prevProps.range)) {
       this._setupGraphie();
     }
     this._updateMovables();
@@ -18469,6 +18047,9 @@ const getWidgetExport = name => {
 const getWidgetScorer = name => {
   return widgets[name]?.scorer ?? null;
 };
+const getPublicWidgetOptionsFunction = name => {
+  return widgets[name]?.getPublicWidgetOptions ?? (i => i);
+};
 const getEditor = name => {
   return ___default["default"].has(editors, name) ? editors[name] : null;
 };
@@ -18776,6 +18357,7 @@ var widgets$1 = /*#__PURE__*/Object.freeze({
   getWidget: getWidget,
   getWidgetExport: getWidgetExport,
   getWidgetScorer: getWidgetScorer,
+  getPublicWidgetOptionsFunction: getPublicWidgetOptionsFunction,
   getEditor: getEditor,
   getTransform: getTransform,
   getVersion: getVersion,
@@ -21147,230 +20729,6 @@ const getPromptJSON$s = (renderProps, userInput) => {
   };
 };
 
-/*
- * In this file, an `expression` is some portion of valid TeX enclosed in
- * curly brackets.
- */
-
-/*
- * Find the index at which an expression ends, i.e., has an unmatched
- * closing curly bracket. This method assumes that we start with a non-open
- * bracket character and end when we've seen more left than right brackets
- * (rather than assuming that we start with a bracket character and wait for
- * bracket equality).
- */
-function findEndpoint(tex, currentIndex) {
-  let bracketDepth = 0;
-  for (let i = currentIndex, len = tex.length; i < len; i++) {
-    const c = tex[i];
-    if (c === "{") {
-      bracketDepth++;
-    } else if (c === "}") {
-      bracketDepth--;
-    }
-    if (bracketDepth < 0) {
-      return i;
-    }
-  }
-  // If we never see unbalanced curly brackets, default to the
-  // entire string
-  return tex.length;
-}
-
-/*
- * Parses an individual set of curly brackets into TeX.
- */
-function parseNextExpression(tex, currentIndex, handler) {
-  // Find the first '{' and grab subsequent TeX
-  // Ex) tex: '{3}{7}', and we want the '3'
-  const openBracketIndex = tex.indexOf("{", currentIndex);
-  const nextExpIndex = openBracketIndex + 1;
-
-  // Truncate to only contain remaining TeX
-  const endpoint = findEndpoint(tex, nextExpIndex);
-  const expressionTeX = tex.substring(nextExpIndex, endpoint);
-  const parsedExp = walkTex(expressionTeX, handler);
-  return {
-    endpoint: endpoint,
-    expression: parsedExp
-  };
-}
-function getNextFracIndex(tex, currentIndex) {
-  const dfrac = "\\dfrac";
-  const frac = "\\frac";
-  const nextFrac = tex.indexOf(frac, currentIndex);
-  const nextDFrac = tex.indexOf(dfrac, currentIndex);
-  if (nextFrac > -1 && nextDFrac > -1) {
-    return Math.min(nextFrac, nextDFrac);
-  }
-  if (nextFrac > -1) {
-    return nextFrac;
-  }
-  if (nextDFrac > -1) {
-    return nextDFrac;
-  }
-  return -1;
-}
-function walkTex(tex, handler) {
-  if (!tex) {
-    return "";
-  }
-
-  // Ex) tex: '2 \dfrac {3}{7}'
-  let parsedString = "";
-  let currentIndex = 0;
-  let nextFrac = getNextFracIndex(tex, currentIndex);
-
-  // For each \dfrac, find the two expressions (wrapped in {}) and recur
-  while (nextFrac > -1) {
-    // Gather first fragment, preceding \dfrac
-    // Ex) parsedString: '2 '
-    parsedString += tex.substring(currentIndex, nextFrac);
-
-    // Remove everything preceding \dfrac, which has been parsed
-    currentIndex = nextFrac;
-
-    // Parse first expression and move index past it
-    // Ex) firstParsedExpression.expression: '3'
-    const firstParsedExpression = parseNextExpression(tex, currentIndex, handler);
-    currentIndex = firstParsedExpression.endpoint + 1;
-
-    // Parse second expression
-    // Ex) secondParsedExpression.expression: '7'
-    const secondParsedExpression = parseNextExpression(tex, currentIndex, handler);
-    currentIndex = secondParsedExpression.endpoint + 1;
-
-    // Add expressions to running total of parsed expressions
-    if (parsedString.length) {
-      parsedString += " ";
-    }
-
-    // Apply a custom handler based on the parsed subexpressions
-    parsedString += handler(firstParsedExpression.expression, secondParsedExpression.expression);
-
-    // Find next DFrac, relative to currentIndex
-    nextFrac = getNextFracIndex(tex, currentIndex);
-  }
-
-  // Add remaining TeX, which is \dfrac-free
-  parsedString += tex.slice(currentIndex);
-  return parsedString;
-}
-
-/*
- * Modify a TeX expression, returning another TeX expression. The resulting
- * expression will have its innermost fractions stubbed out with \fracs
- * (as opposed to \dfracs). All other content will remain untouched.
- */
-function modifyTex(tex) {
-  function isNestedFraction(tex) {
-    return tex.indexOf("\\frac") > -1 || tex.indexOf("\\dfrac") > -1;
-  }
-  const handler = function (exp1, exp2) {
-    let prefix;
-    if (isNestedFraction(exp1) || isNestedFraction(exp2)) {
-      prefix = "\\dfrac";
-    } else {
-      prefix = "\\frac";
-    }
-    return prefix + " {" + exp1 + "}{" + exp2 + "}";
-  };
-  return walkTex(tex, handler);
-}
-
-/*
- * Parse a TeX expression into something interpretable by input-number.
- * The process is concerned with: (1) parsing fractions, i.e., \dfracs; and
- * (2) removing backslash-escaping from certain characters (right now, only
- * percent signs).
- *
- * The basic algorithm for handling \dfracs splits on \dfracs and then recurs
- * on the subsequent "expressions", i.e., the {} pairs that follow \dfrac. The
- * recursion is to allow for nested \dfrac elements.
- *
- * Backslash-escapes are removed with a simple search-and-replace.
- */
-function parseTex(tex) {
-  const handler = function (exp1, exp2) {
-    return exp1 + "/" + exp2;
-  };
-  const texWithoutFracs = walkTex(tex, handler);
-  return texWithoutFracs.replace("\\%", "%");
-}
-var TexWrangler = {
-  parseTex,
-  modifyTex
-};
-
-const ParseTex$1 = TexWrangler.parseTex;
-const answerTypes = {
-  number: {
-    name: "Numbers",
-    forms: "integer, decimal, proper, improper, mixed"
-  },
-  decimal: {
-    name: "Decimals",
-    forms: "decimal"
-  },
-  integer: {
-    name: "Integers",
-    forms: "integer"
-  },
-  rational: {
-    name: "Fractions and mixed numbers",
-    forms: "integer, proper, improper, mixed"
-  },
-  improper: {
-    name: "Improper numbers (no mixed)",
-    forms: "integer, proper, improper"
-  },
-  mixed: {
-    name: "Mixed numbers (no improper)",
-    forms: "integer, proper, mixed"
-  },
-  percent: {
-    name: "Numbers or percents",
-    forms: "integer, decimal, proper, improper, mixed, percent"
-  },
-  pi: {
-    name: "Numbers with pi",
-    forms: "pi"
-  }
-};
-function scoreInputNumber(userInput, rubric, strings) {
-  if (rubric.answerType == null) {
-    rubric.answerType = "number";
-  }
-
-  // note(matthewc): this will get immediately parsed again by
-  // `KhanAnswerTypes.number.convertToPredicate`, but a string is
-  // expected here
-  const stringValue = `${rubric.value}`;
-  const val = perseusScore.KhanAnswerTypes.number.createValidatorFunctional(stringValue, {
-    simplify: rubric.simplify,
-    inexact: rubric.inexact || undefined,
-    maxError: rubric.maxError,
-    forms: answerTypes[rubric.answerType].forms
-  });
-
-  // We may have received TeX; try to parse it before grading.
-  // If `currentValue` is not TeX, this should be a no-op.
-  const currentValue = ParseTex$1(userInput.currentValue);
-  const result = val(currentValue);
-  if (result.empty) {
-    return {
-      type: "invalid",
-      message: result.message
-    };
-  }
-  return {
-    type: "points",
-    earned: result.correct ? 1 : 0,
-    total: 1,
-    message: result.message
-  };
-}
-
 const formExamples$1 = {
   integer: function (options, strings) {
     return strings.integerExample;
@@ -21482,7 +20840,7 @@ class InputNumber extends React__namespace.Component {
       strings
     } = this.context;
     const type = this.props.answerType;
-    const forms = answerTypes[type].forms.split(/\s*,\s*/);
+    const forms = perseusScore.inputNumberAnswerTypes[type].forms.split(/\s*,\s*/);
     const examples = ___default["default"].map(forms, form => formExamples$1[form](this.props, strings));
     return [strings.yourAnswer].concat(examples);
   }
@@ -21578,7 +20936,7 @@ var InputNumber$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusInputNumberUserInput'.
-  scorer: scoreInputNumber,
+  scorer: perseusScore.scoreInputNumber,
   getOneCorrectAnswerFromRubric(rubric) {
     if (rubric.value == null) {
       return;
@@ -21601,139 +20959,6 @@ const getPromptJSON$r = (renderProps, userInput) => {
   };
 };
 
-const ParseTex = TexWrangler.parseTex;
-const answerFormButtons = [{
-  title: "Integers",
-  value: "integer",
-  content: "6"
-}, {
-  title: "Decimals",
-  value: "decimal",
-  content: "0.75"
-}, {
-  title: "Proper fractions",
-  value: "proper",
-  content: "\u2157"
-}, {
-  title: "Improper fractions",
-  value: "improper",
-  content: "\u2077\u2044\u2084"
-}, {
-  title: "Mixed numbers",
-  value: "mixed",
-  content: "1\u00BE"
-}, {
-  title: "Numbers with \u03C0",
-  value: "pi",
-  content: "\u03C0"
-}];
-
-// This function checks if the user inputted a percent value, parsing
-// it as a number (and maybe scaling) so that it can be graded.
-// NOTE(michaelpolyak): Unlike `KhanAnswerTypes.number.percent()` which
-// can accept several input forms with or without "%", the decision
-// to parse based on the presence of "%" in the input, is so that we
-// don't accidently scale the user typed value before grading, CP-930.
-function maybeParsePercentInput(inputValue, normalizedAnswerExpected) {
-  // If the input value is not a string ending with "%", then there's
-  // nothing more to do. The value will be graded as inputted by user.
-  if (!(typeof inputValue === "string" && inputValue.endsWith("%"))) {
-    return inputValue;
-  }
-  const value = parseFloat(inputValue.slice(0, -1));
-  // If the input value stripped of the "%" cannot be parsed as a
-  // number (the slice is not really necessary for parseFloat to work
-  // if the string starts with a number) then return the original
-  // input for grading.
-  if (isNaN(value)) {
-    return inputValue;
-  }
-
-  // Next, if all correct answers are in the range of |0,1| then we
-  // scale the user typed value. We assume this is the correct thing
-  // to do since the input value ends with "%".
-  if (normalizedAnswerExpected) {
-    return value / 100;
-  }
-
-  // Otherwise, we return input value (number) stripped of the "%".
-  return value;
-}
-function scoreNumericInput(userInput, rubric, strings) {
-  const defaultAnswerForms = answerFormButtons.map(e => e["value"])
-  // Don't default to validating the answer as a pi answer
-  // if answerForm isn't set on the answer
-  // https://khanacademy.atlassian.net/browse/LC-691
-  .filter(e => e !== "pi");
-  const createValidator = answer => {
-    const stringAnswer = `${answer.value}`;
-
-    // Always validate against the provided answer forms (pi, decimal, etc.)
-    const validatorForms = [...(answer.answerForms ?? [])];
-
-    // When an answer is set to strict, we validate using ONLY
-    // the provided answerForms. If strict is false, or if there
-    // were no provided answer forms, we will include all
-    // of the default answer forms in our validator.
-    if (!answer.strict || validatorForms.length === 0) {
-      validatorForms.push(...defaultAnswerForms);
-    }
-    return perseusScore.KhanAnswerTypes.number.createValidatorFunctional(stringAnswer, {
-      message: answer.message,
-      simplify: answer.status === "correct" ? answer.simplify : "optional",
-      inexact: true,
-      // TODO(merlob) backfill / delete
-      maxError: answer.maxError,
-      forms: validatorForms
-    });
-  };
-
-  // We may have received TeX; try to parse it before grading.
-  // If `currentValue` is not TeX, this should be a no-op.
-  const currentValue = ParseTex(userInput.currentValue);
-  const normalizedAnswerExpected = rubric.answers.filter(answer => answer.status === "correct").every(answer => answer.value != null && Math.abs(answer.value) <= 1);
-
-  // The coefficient is an attribute of the widget
-  let localValue = currentValue;
-  if (rubric.coefficient) {
-    if (!localValue) {
-      localValue = 1;
-    } else if (localValue === "-") {
-      localValue = -1;
-    }
-  }
-  const matchedAnswer = rubric.answers.map(answer => {
-    const validateFn = createValidator(answer);
-    const score = validateFn(maybeParsePercentInput(localValue, normalizedAnswerExpected));
-    return {
-      ...answer,
-      score
-    };
-  }).find(answer => {
-    // NOTE: "answer.score.correct" indicates a match via the validate function.
-    //       It does NOT indicate that the answer itself is correct.
-    return answer.score.correct || answer.status === "correct" && answer.score.empty;
-  });
-  const result = matchedAnswer?.status === "correct" ? matchedAnswer.score : {
-    empty: matchedAnswer?.status === "ungraded",
-    correct: matchedAnswer?.status === "correct",
-    message: matchedAnswer?.message ?? null,
-    guess: localValue
-  };
-  if (result.empty) {
-    return {
-      type: "invalid",
-      message: result.message
-    };
-  }
-  return {
-    type: "points",
-    earned: result.correct ? 1 : 0,
-    total: 1,
-    message: result.message
-  };
-}
-
 const formExamples = {
   integer: (form, strings) => strings.integerExample,
   proper: (form, strings) => form.simplify === "optional" ? strings.properExample : strings.simplifiedProperExample,
@@ -21970,7 +21195,7 @@ var NumericInput$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusNumericInputUserInput'.
-  scorer: scoreNumericInput,
+  scorer: perseusScore.scoreNumericInput,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'Rubric' is not assignable to type 'PerseusNumericInputRubric'
   getOneCorrectAnswerFromRubric(rubric) {
@@ -25733,72 +24958,6 @@ const styles$o = aphrodite.StyleSheet.create({
   }
 });
 
-/**
- * Checks if the user has selected at least one option. Additional validation
- * is done in scoreRadio to check if the number of selected options is correct
- * and if the user has selected both a correct option and the "none of the above"
- * option.
- * @param userInput
- * @see `scoreRadio` for the additional validation logic and the scoring logic.
- */
-function validateRadio(userInput) {
-  const numSelected = userInput.choicesSelected.reduce((sum, selected) => {
-    return sum + (selected ? 1 : 0);
-  }, 0);
-  if (numSelected === 0) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
-
-function scoreRadio(userInput, rubric, strings) {
-  const validationError = validateRadio(userInput);
-  if (validationError) {
-    return validationError;
-  }
-  const numSelected = userInput.choicesSelected.reduce((sum, selected) => {
-    return sum + (selected ? 1 : 0);
-  }, 0);
-  const numCorrect = rubric.choices.reduce((sum, currentChoice) => {
-    return currentChoice.correct ? sum + 1 : sum;
-  }, 0);
-  if (numCorrect > 1 && numSelected !== numCorrect) {
-    return {
-      type: "invalid",
-      message: strings.chooseCorrectNum
-    };
-    // If NOTA and some other answer are checked, ...
-  }
-
-  const noneOfTheAboveSelected = rubric.choices.some((choice, index) => choice.isNoneOfTheAbove && userInput.choicesSelected[index]);
-  if (noneOfTheAboveSelected && numSelected > 1) {
-    return {
-      type: "invalid",
-      message: strings.notNoneOfTheAbove
-    };
-  }
-  const correct = userInput.choicesSelected.every((selected, i) => {
-    let isCorrect;
-    if (rubric.choices[i].isNoneOfTheAbove) {
-      isCorrect = rubric.choices.every((choice, j) => {
-        return i === j || !choice.correct;
-      });
-    } else {
-      isCorrect = !!rubric.choices[i].correct;
-    }
-    return isCorrect === selected;
-  });
-  return {
-    type: "points",
-    earned: correct ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 // RenderProps is the return type for radio.jsx#transform
 
 class Radio$1 extends React__namespace.Component {
@@ -25986,7 +25145,7 @@ class Radio$1 extends React__namespace.Component {
       choiceStates
     } = this.props;
     if (choiceStates) {
-      const score = scoreRadio(this.getUserInput(), rubric, this.context.strings);
+      const score = perseusScore.scoreRadio(this.getUserInput(), rubric);
       const widgetCorrect = score.type === "points" && score.total === score.earned;
       const newStates = choiceStates.map(state => ({
         ...state,
@@ -26269,7 +25428,7 @@ var Radio = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type UserInput is not assignable to type PerseusRadioUserInput
-  scorer: scoreRadio
+  scorer: perseusScore.scoreRadio
 };
 
 /* eslint-disable import/no-named-as-default */
@@ -26289,40 +25448,20 @@ const getPromptJSON$n = (renderProps, userInput) => {
 };
 
 /**
- * Checks userInput from the categorizer widget to see if the user has selected
- * a category for each item.
- * @param userInput - The user's input corresponding to an array of indices that
- * represent the selected category for each row/item.
- * @param validationData - An array of strings corresponding to each row/item
- * @param strings - Used to provide a validation message
+ * For details on the individual options, see the
+ * PerseusCategorizerWidgetOptions type
  */
-function validateCategorizer(userInput, validationData, strings) {
-  const incomplete = validationData.items.some((_, i) => userInput.values[i] == null);
-  if (incomplete) {
-    return {
-      type: "invalid",
-      message: strings.invalidSelection
-    };
-  }
-  return null;
-}
 
-function scoreCategorizer(userInput, scoringData, strings) {
-  const validationError = validateCategorizer(userInput, scoringData, strings);
-  if (validationError) {
-    return validationError;
-  }
-  let allCorrect = true;
-  scoringData.values.forEach((value, i) => {
-    if (userInput.values[i] !== value) {
-      allCorrect = false;
-    }
-  });
+/**
+ * Given a PerseusCategorizerWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getCategorizerPublicWidgetOptions(options) {
   return {
-    type: "points",
-    earned: allCorrect ? 1 : 0,
-    total: 1,
-    message: null
+    items: options.items,
+    categories: options.categories,
+    randomizeItems: options.randomizeItems,
+    static: options.static
   };
 }
 
@@ -26507,7 +25646,8 @@ var Categorizer$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusCSProgramUserInput'.
-  scorer: scoreCategorizer
+  scorer: perseusScore.scoreCategorizer,
+  getPublicWidgetOptions: getCategorizerPublicWidgetOptions
 };
 
 /**
@@ -26570,31 +25710,6 @@ const getPromptJSON$m = () => {
   return getUnsupportedPromptJSON("cs-program");
 };
 
-function scoreCSProgram(state) {
-  // The iframe can tell us whether it's correct or incorrect,
-  //  and pass an optional message
-  if (state.status === "correct") {
-    return {
-      type: "points",
-      earned: 1,
-      total: 1,
-      message: state.message || null
-    };
-  }
-  if (state.status === "incorrect") {
-    return {
-      type: "points",
-      earned: 0,
-      total: 1,
-      message: state.message || null
-    };
-  }
-  return {
-    type: "invalid",
-    message: "Keep going, you're not there yet!"
-  };
-}
-
 /**
  * This widget is for embedding Khan Academy CS programs.
  */
@@ -26746,7 +25861,7 @@ var CSProgram$1 = {
   hidden: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusCSProgramUserInput'.
-  scorer: scoreCSProgram
+  scorer: perseusScore.scoreCSProgram
 };
 
 const getPromptJSON$l = renderProps => {
@@ -26871,34 +25986,6 @@ const getPromptJSON$k = (renderProps, userInput) => {
   };
 };
 
-/**
- * Checks if the user has selected an item from the dropdown before scoring.
- * This is shown with a userInput value / index other than 0.
- */
-function validateDropdown(userInput) {
-  if (userInput.value === 0) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
-
-function scoreDropdown(userInput, rubric) {
-  const validationError = validateDropdown(userInput);
-  if (validationError) {
-    return validationError;
-  }
-  const correct = rubric.choices[userInput.value - 1].correct;
-  return {
-    type: "points",
-    earned: correct ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 class Dropdown extends React__namespace.Component {
   static contextType = PerseusI18nContext;
   static defaultProps = {
@@ -26999,7 +26086,7 @@ var Dropdown$1 = {
   transform: optionsTransform,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusDropdownUserInput'.
-  scorer: scoreDropdown
+  scorer: perseusScore.scoreDropdown
 };
 
 const getPromptJSON$j = renderProps => {
@@ -27371,7 +26458,7 @@ class GradedGroup extends React__namespace.Component {
       DEFAULT_INVALID_MESSAGE_2
     } = this.context.strings;
     const status = score.type === "points" ? score.total === score.earned ? GRADING_STATUSES.correct : GRADING_STATUSES.incorrect : GRADING_STATUSES.invalid;
-    const message = score.type === "points" ? score.message || "" : score.message ? `${INVALID_MESSAGE_PREFIX} ${score.message}` : `${INVALID_MESSAGE_PREFIX} ${DEFAULT_INVALID_MESSAGE_1}${DEFAULT_INVALID_MESSAGE_2}`;
+    const message = score.type === "points" ? score.message || "" : score.message ? `${INVALID_MESSAGE_PREFIX} ${mapErrorToString(score.message)}` : `${INVALID_MESSAGE_PREFIX} ${DEFAULT_INVALID_MESSAGE_1}${DEFAULT_INVALID_MESSAGE_2}`;
     this.setState({
       status: status,
       message: message,
@@ -27970,408 +27057,21 @@ const getPromptJSON$g = (renderProps, userInput) => {
   };
 };
 
-// @ts-expect-error - TS2339 - Property 'Plot' does not exist on type 'typeof Graphie'.
-const Plot$1 = Graphie.Plot;
+const movableTypeToComponent = {
+  // @ts-expect-error - TS2339 - Property 'Plot' does not exist on type 'typeof Graphie'.
+  PLOT: Graphie.Plot,
+  // @ts-expect-error - TS2339 - Property 'Parabola' does not exist on type 'typeof Graphie'.
+  PARABOLA: Graphie.Parabola,
+  // @ts-expect-error - TS2339 - Property 'Sinusoid' does not exist on type 'typeof Graphie'.
+  SINUSOID: Graphie.Sinusoid
+};
 const DEFAULT_BACKGROUND_IMAGE = {
   url: null
 };
-
-// TODO(charlie): These really need to go into a utility file as they're being
-// used by both interactive-graph and now grapher.
-function canonicalSineCoefficients(coeffs) {
-  // For a curve of the form f(x) = a * Sin(b * x - c) + d,
-  // this function ensures that a, b > 0, and c is its
-  // smallest possible positive value.
-  let amplitude = coeffs[0];
-  let angularFrequency = coeffs[1];
-  let phase = coeffs[2];
-  const verticalOffset = coeffs[3];
-
-  // Guarantee a > 0
-  if (amplitude < 0) {
-    amplitude *= -1;
-    angularFrequency *= -1;
-    phase *= -1;
-  }
-  const period = 2 * Math.PI;
-  // Guarantee b > 0
-  if (angularFrequency < 0) {
-    angularFrequency *= -1;
-    phase *= -1;
-    phase += period / 2;
-  }
-
-  // Guarantee c is smallest possible positive value
-  while (phase > 0) {
-    phase -= period;
-  }
-  while (phase < 0) {
-    phase += period;
-  }
-  return [amplitude, angularFrequency, phase, verticalOffset];
-}
-function canonicalTangentCoefficients(coeffs) {
-  // For a curve of the form f(x) = a * Tan(b * x - c) + d,
-  // this function ensures that a, b > 0, and c is its
-  // smallest possible positive value.
-  let amplitude = coeffs[0];
-  let angularFrequency = coeffs[1];
-  let phase = coeffs[2];
-  const verticalOffset = coeffs[3];
-
-  // Guarantee a > 0
-  if (amplitude < 0) {
-    amplitude *= -1;
-    angularFrequency *= -1;
-    phase *= -1;
-  }
-  const period = Math.PI;
-  // Guarantee b > 0
-  if (angularFrequency < 0) {
-    angularFrequency *= -1;
-    phase *= -1;
-    phase += period / 2;
-  }
-
-  // Guarantee c is smallest possible positive value
-  while (phase > 0) {
-    phase -= period;
-  }
-  while (phase < 0) {
-    phase += period;
-  }
-  return [amplitude, angularFrequency, phase, verticalOffset];
-}
-const PlotDefaults = {
-  areEqual: function (coeffs1, coeffs2) {
-    return Util.deepEq(coeffs1, coeffs2);
-  },
-  Movable: Plot$1,
-  getPropsForCoeffs: function (coeffs) {
-    return {
-      // @ts-expect-error - TS2339 - Property 'getFunctionForCoeffs' does not exist on type '{ readonly areEqual: (coeffs1: any, coeffs2: any) => boolean; readonly Movable: any; readonly getPropsForCoeffs: (coeffs: any) => any; }'.
-      fn: ___default["default"].partial(this.getFunctionForCoeffs, coeffs)
-    };
-  }
-};
-const Linear = ___default["default"].extend({}, PlotDefaults, {
-  url: "https://ka-perseus-graphie.s3.amazonaws.com/67aaf581e6d9ef9038c10558a1f70ac21c11c9f8.png",
-  defaultCoords: [[0.25, 0.75], [0.75, 0.75]],
-  getCoefficients: function (coords) {
-    const p1 = coords[0];
-    const p2 = coords[1];
-    const denom = p2[0] - p1[0];
-    const num = p2[1] - p1[1];
-    if (denom === 0) {
-      return;
-    }
-    const m = num / denom;
-    const b = p2[1] - m * p2[0];
-    return [m, b];
-  },
-  getFunctionForCoeffs: function (coeffs, x) {
-    const m = coeffs[0];
-    const b = coeffs[1];
-    return m * x + b;
-  },
-  getEquationString: function (coords) {
-    const coeffs = this.getCoefficients(coords);
-    const m = coeffs[0];
-    const b = coeffs[1];
-    return "y = " + m.toFixed(3) + "x + " + b.toFixed(3);
-  }
-});
-const Quadratic = ___default["default"].extend({}, PlotDefaults, {
-  url: "https://ka-perseus-graphie.s3.amazonaws.com/e23d36e6fc29ee37174e92c9daba2a66677128ab.png",
-  defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
-  // @ts-expect-error - TS2339 - Property 'Parabola' does not exist on type 'typeof Graphie'.
-  Movable: Graphie.Parabola,
-  getCoefficients: function (coords) {
-    const p1 = coords[0];
-    const p2 = coords[1];
-
-    // Parabola with vertex (h, k) has form: y = a * (h - k)^2 + k
-    const h = p1[0];
-    const k = p1[1];
-
-    // Use these to calculate familiar a, b, c
-    const a = (p2[1] - k) / ((p2[0] - h) * (p2[0] - h));
-    const b = -2 * h * a;
-    const c = a * h * h + k;
-    return [a, b, c];
-  },
-  getFunctionForCoeffs: function (coeffs, x) {
-    const a = coeffs[0];
-    const b = coeffs[1];
-    const c = coeffs[2];
-    return (a * x + b) * x + c;
-  },
-  getPropsForCoeffs: function (coeffs) {
-    return {
-      a: coeffs[0],
-      b: coeffs[1],
-      c: coeffs[2]
-    };
-  },
-  getEquationString: function (coords) {
-    const coeffs = this.getCoefficients(coords);
-    const a = coeffs[0];
-    const b = coeffs[1];
-    const c = coeffs[2];
-    return "y = " + a.toFixed(3) + "x^2 + " + b.toFixed(3) + "x + " + c.toFixed(3);
-  }
-});
-const Sinusoid = ___default["default"].extend({}, PlotDefaults, {
-  url: "https://ka-perseus-graphie.s3.amazonaws.com/3d68e7718498475f53b206c2ab285626baf8857e.png",
-  defaultCoords: [[0.5, 0.5], [0.6, 0.6]],
-  // @ts-expect-error - TS2339 - Property 'Sinusoid' does not exist on type 'typeof Graphie'.
-  Movable: Graphie.Sinusoid,
-  getCoefficients: function (coords) {
-    const p1 = coords[0];
-    const p2 = coords[1];
-    const a = p2[1] - p1[1];
-    const b = Math.PI / (2 * (p2[0] - p1[0]));
-    const c = p1[0] * b;
-    const d = p1[1];
-    return [a, b, c, d];
-  },
-  getFunctionForCoeffs: function (coeffs, x) {
-    const a = coeffs[0];
-    const b = coeffs[1];
-    const c = coeffs[2];
-    const d = coeffs[3];
-    return a * Math.sin(b * x - c) + d;
-  },
-  getPropsForCoeffs: function (coeffs) {
-    return {
-      a: coeffs[0],
-      b: coeffs[1],
-      c: coeffs[2],
-      d: coeffs[3]
-    };
-  },
-  getEquationString: function (coords) {
-    const coeffs = this.getCoefficients(coords);
-    const a = coeffs[0];
-    const b = coeffs[1];
-    const c = coeffs[2];
-    const d = coeffs[3];
-    return "y = " + a.toFixed(3) + " sin(" + b.toFixed(3) + "x - " + c.toFixed(3) + ") + " + d.toFixed(3);
-  },
-  areEqual: function (coeffs1, coeffs2) {
-    return Util.deepEq(canonicalSineCoefficients(coeffs1), canonicalSineCoefficients(coeffs2));
-  }
-});
-const Tangent = ___default["default"].extend({}, PlotDefaults, {
-  url: "https://ka-perseus-graphie.s3.amazonaws.com/7db80d23c35214f98659fe1cf0765811c1bbfbba.png",
-  defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
-  getCoefficients: function (coords) {
-    const p1 = coords[0];
-    const p2 = coords[1];
-    const a = p2[1] - p1[1];
-    const b = Math.PI / (4 * (p2[0] - p1[0]));
-    const c = p1[0] * b;
-    const d = p1[1];
-    return [a, b, c, d];
-  },
-  getFunctionForCoeffs: function (coeffs, x) {
-    const a = coeffs[0];
-    const b = coeffs[1];
-    const c = coeffs[2];
-    const d = coeffs[3];
-    return a * Math.tan(b * x - c) + d;
-  },
-  getEquationString: function (coords) {
-    const coeffs = this.getCoefficients(coords);
-    const a = coeffs[0];
-    const b = coeffs[1];
-    const c = coeffs[2];
-    const d = coeffs[3];
-    return "y = " + a.toFixed(3) + " sin(" + b.toFixed(3) + "x - " + c.toFixed(3) + ") + " + d.toFixed(3);
-  },
-  areEqual: function (coeffs1, coeffs2) {
-    return Util.deepEq(canonicalTangentCoefficients(coeffs1), canonicalTangentCoefficients(coeffs2));
-  }
-});
-const Exponential = ___default["default"].extend({}, PlotDefaults, {
-  url: "https://ka-perseus-graphie.s3.amazonaws.com/9cbfad55525e3ce755a31a631b074670a5dad611.png",
-  defaultCoords: [[0.5, 0.55], [0.75, 0.75]],
-  defaultAsymptote: [[0, 0.5], [1.0, 0.5]],
-  /**
-   * Add extra constraints for movement of the points or asymptote (below):
-   *   newCoord: [x, y]
-   *     The end position of the point or asymptote endpoint
-   *   oldCoord: [x, y]
-   *     The old position of the point or asymptote endpoint
-   *   coords:
-   *     An array of coordinates representing the proposed end configuration
-   *     of the plot coordinates.
-   *   asymptote:
-   *     An array of coordinates representing the proposed end configuration
-   *     of the asymptote.
-   *
-   * Return: either a coordinate (to be used as the resulting coordinate of
-   * the move) or a boolean, where `true` uses newCoord as the resulting
-   * coordinate, and `false` uses oldCoord as the resulting coordinate.
-   */
-  extraCoordConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
-    const y = asymptote[0][1];
-    return ___default["default"].all(coords, coord => coord[1] !== y);
-  },
-  extraAsymptoteConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
-    const y = newCoord[1];
-    const isValid = ___default["default"].all(coords, coord => coord[1] > y) || ___default["default"].all(coords, coord => coord[1] < y);
-    if (isValid) {
-      return [oldCoord[0], y];
-    }
-    // Snap the asymptote as close as possible, i.e., if the user moves
-    // the mouse really quickly into an invalid region
-    const oldY = oldCoord[1];
-    const wasBelow = ___default["default"].all(coords, coord => coord[1] > oldY);
-    if (wasBelow) {
-      const bottomMost = ___default["default"].min(___default["default"].map(coords, coord => coord[1]));
-      return [oldCoord[0], bottomMost - graph.snapStep[1]];
-    }
-    const topMost = ___default["default"].max(___default["default"].map(coords, coord => coord[1]));
-    return [oldCoord[0], topMost + graph.snapStep[1]];
-  },
-  allowReflectOverAsymptote: true,
-  getCoefficients: function (coords, asymptote) {
-    const p1 = coords[0];
-    const p2 = coords[1];
-    const c = asymptote[0][1];
-    const b = Math.log((p1[1] - c) / (p2[1] - c)) / (p1[0] - p2[0]);
-    const a = (p1[1] - c) / Math.exp(b * p1[0]);
-    return [a, b, c];
-  },
-  getFunctionForCoeffs: function (coeffs, x) {
-    const a = coeffs[0];
-    const b = coeffs[1];
-    const c = coeffs[2];
-    return a * Math.exp(b * x) + c;
-  },
-  getEquationString: function (coords, asymptote) {
-    if (!asymptote) {
-      return null;
-    }
-    const coeffs = this.getCoefficients(coords, asymptote);
-    const a = coeffs[0];
-    const b = coeffs[1];
-    const c = coeffs[2];
-    return "y = " + a.toFixed(3) + "e^(" + b.toFixed(3) + "x) + " + c.toFixed(3);
-  }
-});
-const Logarithm = ___default["default"].extend({}, PlotDefaults, {
-  url: "https://ka-perseus-graphie.s3.amazonaws.com/f6491e99d34af34d924bfe0231728ad912068dc3.png",
-  defaultCoords: [[0.55, 0.5], [0.75, 0.75]],
-  defaultAsymptote: [[0.5, 0], [0.5, 1.0]],
-  extraCoordConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
-    const x = asymptote[0][0];
-    return ___default["default"].all(coords, coord => coord[0] !== x) && coords[0][1] !== coords[1][1];
-  },
-  extraAsymptoteConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
-    const x = newCoord[0];
-    const isValid = ___default["default"].all(coords, coord => coord[0] > x) || ___default["default"].all(coords, coord => coord[0] < x);
-    if (isValid) {
-      return [x, oldCoord[1]];
-    }
-    // Snap the asymptote as close as possible, i.e., if the user moves
-    // the mouse really quickly into an invalid region
-    const oldX = oldCoord[0];
-    const wasLeft = ___default["default"].all(coords, coord => coord[0] > oldX);
-    if (wasLeft) {
-      const leftMost = ___default["default"].min(___default["default"].map(coords, coord => coord[0]));
-      return [leftMost - graph.snapStep[0], oldCoord[1]];
-    }
-    const rightMost = ___default["default"].max(___default["default"].map(coords, coord => coord[0]));
-    return [rightMost + graph.snapStep[0], oldCoord[1]];
-  },
-  allowReflectOverAsymptote: true,
-  getCoefficients: function (coords, asymptote) {
-    // It's easiest to calculate the logarithm's coefficients by thinking
-    // about it as the inverse of the exponential, so we flip x and y and
-    // perform some algebra on the coefficients. This also unifies the
-    // logic between the two 'models'.
-    const flip = coord => [coord[1], coord[0]];
-    const inverseCoeffs = Exponential.getCoefficients(___default["default"].map(coords, flip), ___default["default"].map(asymptote, flip));
-    if (inverseCoeffs) {
-      const c = -inverseCoeffs[2] / inverseCoeffs[0];
-      const b = 1 / inverseCoeffs[0];
-      const a = 1 / inverseCoeffs[1];
-      return [a, b, c];
-    }
-  },
-  getFunctionForCoeffs: function (coeffs, x, asymptote) {
-    const a = coeffs[0];
-    const b = coeffs[1];
-    const c = coeffs[2];
-    return a * Math.log(b * x + c);
-  },
-  getEquationString: function (coords, asymptote) {
-    if (!asymptote) {
-      return null;
-    }
-    const coeffs = this.getCoefficients(coords, asymptote);
-    const a = coeffs[0];
-    const b = coeffs[1];
-    const c = coeffs[2];
-    return "y = ln(" + a.toFixed(3) + "x + " + b.toFixed(3) + ") + " + c.toFixed(3);
-  }
-});
-const AbsoluteValue = ___default["default"].extend({}, PlotDefaults, {
-  url: "https://ka-perseus-graphie.s3.amazonaws.com/8256a630175a0cb1d11de223d6de0266daf98721.png",
-  defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
-  getCoefficients: function (coords) {
-    const p1 = coords[0];
-    const p2 = coords[1];
-    const denom = p2[0] - p1[0];
-    const num = p2[1] - p1[1];
-    if (denom === 0) {
-      return;
-    }
-    let m = Math.abs(num / denom);
-    if (p2[1] < p1[1]) {
-      m *= -1;
-    }
-    const horizontalOffset = p1[0];
-    const verticalOffset = p1[1];
-    return [m, horizontalOffset, verticalOffset];
-  },
-  getFunctionForCoeffs: function (coeffs, x) {
-    const m = coeffs[0];
-    const horizontalOffset = coeffs[1];
-    const verticalOffset = coeffs[2];
-    return m * Math.abs(x - horizontalOffset) + verticalOffset;
-  },
-  getEquationString: function (coords) {
-    const coeffs = this.getCoefficients(coords);
-    const m = coeffs[0];
-    const horizontalOffset = coeffs[1];
-    const verticalOffset = coeffs[2];
-    return "y = " + m.toFixed(3) + "| x - " + horizontalOffset.toFixed(3) + "| + " + verticalOffset.toFixed(3);
-  }
-});
-
-/* Utility functions for dealing with graphing interfaces. */
-const functionTypeMapping = {
-  linear: Linear,
-  quadratic: Quadratic,
-  sinusoid: Sinusoid,
-  tangent: Tangent,
-  exponential: Exponential,
-  logarithm: Logarithm,
-  absolute_value: AbsoluteValue
-};
-const allTypes = ___default["default"].keys(functionTypeMapping);
-function functionForType(type) {
-  // @ts-expect-error: TypeScript doesn't know how to use deal with generics
-  // and conditional types in this way.
-  return functionTypeMapping[type];
-}
 const getEquationString = props => {
   const plot = props.plot;
   if (plot.type && plot.coords) {
-    const handler = functionForType(plot.type);
+    const handler = perseusCore.GrapherUtil.functionForType(plot.type);
     const result = handler.getEquationString(plot.coords, plot.asymptote);
     return result || "";
   }
@@ -28429,7 +27129,7 @@ const defaultPlotProps = (type, graph) => {
   // extra information. It would be valid to always submit the default
   // widget before even reading the question; you can't lose, but you
   // might get a free win.
-  const model = functionForType(type);
+  const model = perseusCore.GrapherUtil.functionForType(type);
   const defaultAsymptote = "defaultAsymptote" in model ? model.defaultAsymptote : null;
   const gridStep = [1, 1];
   // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type '[number, number]'.
@@ -28475,70 +27175,12 @@ const typeToButton = type => {
     value: type,
     title: capitalized,
     content: /*#__PURE__*/React__namespace.createElement("img", {
-      src: staticUrl(functionForType(type).url),
+      src: staticUrl(perseusCore.GrapherUtil.functionForType(type).url),
       alt: capitalized
     })
   };
 };
 
-function getCoefficientsByType(data) {
-  if (data.coords == null) {
-    return undefined;
-  }
-  if (data.type === "exponential" || data.type === "logarithm") {
-    const grader = functionForType(data.type);
-    return grader.getCoefficients(data.coords, data.asymptote);
-  } else if (data.type === "linear" || data.type === "quadratic" || data.type === "absolute_value" || data.type === "sinusoid" || data.type === "tangent") {
-    const grader = functionForType(data.type);
-    return grader.getCoefficients(data.coords);
-  } else {
-    throw new perseusCore.PerseusError("Invalid grapher type", perseusCore.Errors.InvalidInput);
-  }
-}
-function scoreGrapher(userInput, rubric) {
-  if (userInput.type !== rubric.correct.type) {
-    return {
-      type: "points",
-      earned: 0,
-      total: 1,
-      message: null
-    };
-  }
-
-  // We haven't moved the coords
-  if (userInput.coords == null) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-
-  // Get new function handler for grading
-  const grader = functionForType(userInput.type);
-  const guessCoeffs = getCoefficientsByType(userInput);
-  const correctCoeffs = getCoefficientsByType(rubric.correct);
-  if (guessCoeffs == null || correctCoeffs == null) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  if (grader.areEqual(guessCoeffs, correctCoeffs)) {
-    return {
-      type: "points",
-      earned: 1,
-      total: 1,
-      message: null
-    };
-  }
-  return {
-    type: "points",
-    earned: 0,
-    total: 1,
-    message: null
-  };
-}
-
 // @ts-expect-error - TS2339 - Property 'MovablePoint' does not exist on type 'typeof Graphie'.
 const MovablePoint$3 = Graphie.MovablePoint;
 // @ts-expect-error - TS2339 - Property 'MovableLine' does not exist on type 'typeof Graphie'.
@@ -28600,7 +27242,8 @@ class FunctionGrapher extends React__namespace.Component {
       return;
     }
     const functionProps = model.getPropsForCoeffs(coeffs, xRange);
-    return /*#__PURE__*/React__namespace.createElement(model.Movable, _extends({}, functionProps, {
+    const Movable = movableTypeToComponent[model.movable];
+    return /*#__PURE__*/React__namespace.createElement(Movable, _extends({}, functionProps, {
       key: this.props.model.url,
       range: xRange,
       style: style
@@ -28893,7 +27536,7 @@ class Grapher extends React__namespace.Component {
         setup: this._setupGraphie
       },
       onChange: this.handlePlotChanges,
-      model: type && functionForType(type),
+      model: type && perseusCore.GrapherUtil.functionForType(type),
       coords: coords,
       asymptote: asymptote,
       static: this.props.static,
@@ -28942,7 +27585,7 @@ var Grapher$1 = {
   staticTransform: staticTransform$4,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusGrapherUserInput'.
-  scorer: scoreGrapher
+  scorer: perseusScore.scoreGrapher
 };
 
 const getPromptJSON$f = rendererJSON => {
@@ -29128,31 +27771,6 @@ const getPromptJSON$e = () => {
   return getUnsupportedPromptJSON("iframe");
 };
 
-function scoreIframe(userInput) {
-  // The iframe can tell us whether it's correct or incorrect,
-  //  and pass an optional message
-  if (userInput.status === "correct") {
-    return {
-      type: "points",
-      earned: 1,
-      total: 1,
-      message: userInput.message || null
-    };
-  }
-  if (userInput.status === "incorrect") {
-    return {
-      type: "points",
-      earned: 0,
-      total: 1,
-      message: userInput.message || null
-    };
-  }
-  return {
-    type: "invalid",
-    message: "Keep going, you're not there yet!"
-  };
-}
-
 /**
  * This is an iframe widget. It is used for rendering an iframe that
  *  then communicates its state via window.postMessage
@@ -29287,7 +27905,7 @@ var Iframe$1 = {
   hidden: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusIframeUserInput'.
-  scorer: scoreIframe
+  scorer: perseusScore.scoreIframe
 };
 
 const getPromptJSON$d = renderProps => {
@@ -30734,63 +29352,6 @@ function findIntersectionOfRays(_ref3, _ref4) {
   }
 }
 
-// This file contains helper functions for working with angles.
-
-function convertDegreesToRadians(degrees) {
-  return degrees / 180 * Math.PI;
-}
-
-// Returns a value between -180 and 180, inclusive. The angle is measured
-// between the positive x-axis and the given vector.
-function calculateAngleInDegrees(_ref) {
-  let [x, y] = _ref;
-  return Math.atan2(y, x) * 180 / Math.PI;
-}
-
-// Converts polar coordinates to cartesian. The th(eta) parameter is in degrees.
-function polar(r, th) {
-  if (typeof r === "number") {
-    r = [r, r];
-  }
-  th = th * Math.PI / 180;
-  return [r[0] * Math.cos(th), r[1] * Math.sin(th)];
-}
-// This function calculates the angle between two points and an optional vertex.
-// If the vertex is not provided, the angle is measured between the two points.
-// This does not account for reflex angles or clockwise position.
-const getAngleFromVertex = (point, vertex) => {
-  const x = point[0] - vertex[0];
-  const y = point[1] - vertex[1];
-  if (!x && !y) {
-    return 0;
-  }
-  return (180 + Math.atan2(-y, -x) * 180 / Math.PI + 360) % 360;
-};
-
-// This function calculates the clockwise angle between three points,
-// and is used to generate the labels and equation strings of the
-// current angle for the interactive graph.
-const getClockwiseAngle = function (coords) {
-  let allowReflexAngles = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-  const coordsCopy = [...coords];
-  // The coords are saved as [point1, vertex, point2] in the interactive graph
-  const areClockwise = clockwise$1([coordsCopy[0], coordsCopy[2], coordsCopy[1]]);
-
-  // We may need to reverse the coordinates if we allow
-  // reflex angles and the points are not in clockwise order.
-  const shouldReverseCoords = !areClockwise || allowReflexAngles;
-
-  // Reverse the coordinates accordingly to ensure the angle is calculated correctly
-  const clockwiseCoords = shouldReverseCoords ? coordsCopy.reverse() : coordsCopy;
-
-  // Calculate the angles between the two points and get the difference
-  // between the two angles to get the clockwise angle.
-  const startAngle = getAngleFromVertex(clockwiseCoords[0], clockwiseCoords[1]);
-  const endAngle = getAngleFromVertex(clockwiseCoords[2], clockwiseCoords[1]);
-  const angle = (startAngle + 360 - endAngle) % 360;
-  return angle;
-};
-
 const defaultGraphConfig = {
   range: [[0, 1], [0, 1]],
   tickStep: [1, 1],
@@ -31923,7 +30484,8 @@ const LockedEllipse = props => {
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: "locked-ellipse",
     "aria-label": hasAria ? ariaLabel : undefined,
-    "aria-hidden": !hasAria
+    "aria-hidden": !hasAria,
+    role: "img"
   }, /*#__PURE__*/React__namespace.createElement(mafs.Ellipse, {
     center: center,
     radius: radius,
@@ -31968,7 +30530,8 @@ const LockedFunction = props => {
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: "locked-function",
     "aria-label": hasAria ? props.ariaLabel : undefined,
-    "aria-hidden": !hasAria
+    "aria-hidden": !hasAria,
+    role: "img"
   }, directionalAxis === "x" && /*#__PURE__*/React__namespace.createElement(mafs.Plot.OfX, _extends({
     y: x => equation.eval({
       x
@@ -31999,6 +30562,9 @@ function SVGLine(props) {
   });
 }
 
+const {
+  calculateAngleInDegrees: calculateAngleInDegrees$3
+} = kmath.angles;
 function Vector(props) {
   const {
     tail,
@@ -32008,7 +30574,7 @@ function Vector(props) {
   } = props;
   const [tailPx, tipPx] = useTransformVectorsToPixels(tail, tip);
   const direction = mafs.vec.sub(tipPx, tailPx);
-  const angle = calculateAngleInDegrees(direction);
+  const angle = calculateAngleInDegrees$3(direction);
   return /*#__PURE__*/React__namespace.createElement("g", {
     style: {
       stroke: color,
@@ -32025,6 +30591,14 @@ function Vector(props) {
   }));
 }
 
+function srFormatNumber(a, locale) {
+  // adding zero here converts negative zero to positive zero.
+  return (0 + a).toLocaleString(locale, {
+    maximumFractionDigits: 3,
+    useGrouping: false // no thousands separators
+  });
+}
+
 /**
  * Given a ray and a rectangular box, find the point where the ray intersects
  * the edge of the box. Assumes the `initialPoint` is inside the box.
@@ -32073,7 +30647,45 @@ function getArrayWithoutDuplicates(array) {
   }
   return returnArray;
 }
+function getSlopeStringForLine(line, strings) {
+  const slope = (line[1][1] - line[0][1]) / (line[1][0] - line[0][0]);
+  if (!Number.isFinite(slope)) {
+    return strings.srLinearGraphSlopeVertical;
+  }
+  if (slope === 0) {
+    return strings.srLinearGraphSlopeHorizontal;
+  }
+  return slope > 0 ? strings.srLinearGraphSlopeIncreasing : strings.srLinearGraphSlopeDecreasing;
+}
+function getInterceptStringForLine(line, strings, locale) {
+  const slope = (line[1][1] - line[0][1]) / (line[1][0] - line[0][0]);
+  const xIntercept = (0 - line[0][1]) / slope + line[0][0];
+  const yIntercept = line[0][1] - slope * line[0][0];
+
+  // Check if the line fully overlaps with an axis.
+  const overlapsXAxis = line[0][1] === 0 && line[1][1] === 0;
+  const overlapsYAxis = line[0][0] === 0 && line[1][0] === 0;
+  const hasXIntercept = Number.isFinite(xIntercept) && !overlapsXAxis;
+  const hasYIntercept = Number.isFinite(yIntercept) && !overlapsYAxis;
+  if (hasXIntercept && hasYIntercept) {
+    // Describe both intercepts in the same sentence.
+    return xIntercept === 0 && yIntercept === 0 ? strings.srLinearGraphOriginIntercept : strings.srLinearGraphBothIntercepts({
+      xIntercept: srFormatNumber(xIntercept, locale),
+      yIntercept: srFormatNumber(yIntercept, locale)
+    });
+  }
+
+  // Describe only one intercept.
+  return hasXIntercept ? strings.srLinearGraphXOnlyIntercept({
+    xIntercept: srFormatNumber(xIntercept, locale)
+  }) : strings.srLinearGraphYOnlyIntercept({
+    yIntercept: srFormatNumber(yIntercept, locale)
+  });
+}
 
+const {
+  calculateAngleInDegrees: calculateAngleInDegrees$2
+} = kmath.angles;
 const LockedLine = props => {
   const {
     color,
@@ -32105,7 +30717,7 @@ const LockedLine = props => {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     const [tailPx, tipPx] = useTransformVectorsToPixels(point2.coord, point1.coord);
     const direction = mafs.vec.sub(tailPx, tipPx);
-    let angle = calculateAngleInDegrees(direction);
+    let angle = calculateAngleInDegrees$2(direction);
     const startArrowHead = kind !== "segment" && /*#__PURE__*/React__namespace.createElement(Arrowhead, {
       angle: angle,
       tip: arrowTip,
@@ -32128,7 +30740,8 @@ const LockedLine = props => {
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: kind === "ray" ? "locked-ray" : "locked-line",
     "aria-label": hasAria ? ariaLabel : undefined,
-    "aria-hidden": !hasAria
+    "aria-hidden": !hasAria,
+    role: "img"
   }, line, showPoint1 && /*#__PURE__*/React__namespace.createElement(mafs.Point, {
     x: point1.coord[X],
     y: point1.coord[Y],
@@ -32164,7 +30777,8 @@ const LockedPoint = props => {
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: "locked-point",
     "aria-label": hasAria ? ariaLabel : undefined,
-    "aria-hidden": !hasAria
+    "aria-hidden": !hasAria,
+    role: "img"
   }, /*#__PURE__*/React__namespace.createElement(mafs.Point, {
     x: x,
     y: y,
@@ -32190,7 +30804,8 @@ const LockedPolygon = props => {
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: "locked-polygon",
     "aria-label": hasAria ? props.ariaLabel : undefined,
-    "aria-hidden": !hasAria
+    "aria-hidden": !hasAria,
+    role: "img"
   }, /*#__PURE__*/React__namespace.createElement(mafs.Polygon, {
     points: [...points],
     fillOpacity: perseusCore.lockedFigureFillStyles[fillStyle],
@@ -32224,7 +30839,8 @@ const LockedVector = props => {
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: "locked-vector",
     "aria-label": hasAria ? ariaLabel : undefined,
-    "aria-hidden": !hasAria
+    "aria-hidden": !hasAria,
+    role: "img"
   }, /*#__PURE__*/React__namespace.createElement(Vector, {
     tail: tail,
     tip: tip,
@@ -32513,6 +31129,12 @@ const SvgDefs = () => /*#__PURE__*/React__default["default"].createElement("defs
   in: "SourceGraphic"
 })));
 
+const {
+  clockwise: clockwise$1
+} = kmath.geometry;
+const {
+  getAngleFromVertex: getAngleFromVertex$1
+} = kmath.angles;
 const PolygonAngle = _ref => {
   let {
     centerPoint,
@@ -32603,8 +31225,8 @@ const Angle = _ref2 => {
   const clockwiseCoords = shouldReverseCoords ? coords : coords.reverse();
 
   // Calculate the angles between the two points
-  const startAngle = getAngleFromVertex(clockwiseCoords[0], vertex);
-  const endAngle = getAngleFromVertex(clockwiseCoords[1], vertex);
+  const startAngle = getAngleFromVertex$1(clockwiseCoords[0], vertex);
+  const endAngle = getAngleFromVertex$1(clockwiseCoords[1], vertex);
   const angle = (startAngle + 360 - endAngle) % 360;
 
   // Check if the angle is reflexive
@@ -32965,14 +31587,6 @@ function range(min, max) {
   return result;
 }
 
-function srFormatNumber(a, locale) {
-  // adding zero here converts negative zero to positive zero.
-  return (0 + a).toLocaleString(locale, {
-    maximumFractionDigits: 3,
-    useGrouping: false // no thousands separators
-  });
-}
-
 // The hitbox size of 48px by 48px is preserved from the legacy interactive
 // graph.
 const hitboxSizePx = 48;
@@ -33365,6 +31979,11 @@ const MovablePoint$1 = /*#__PURE__*/React__namespace.forwardRef((props, pointRef
   return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, focusableHandle, visiblePoint);
 });
 
+const {
+  calculateAngleInDegrees: calculateAngleInDegrees$1,
+  getClockwiseAngle: getClockwiseAngle$2,
+  polar: polar$1
+} = kmath.angles;
 function renderAngleGraph(state, dispatch) {
   return {
     graph: /*#__PURE__*/React__namespace.createElement(AngleGraph, {
@@ -33435,7 +32054,7 @@ function AngleGraph(props) {
     strings,
     locale
   } = usePerseusI18n();
-  const angleMeasure = srFormatNumber(getClockwiseAngle([endPoints[0], centerPoint, endPoints[1]], allowReflexAngles), locale);
+  const angleMeasure = srFormatNumber(getClockwiseAngle$2([endPoints[0], centerPoint, endPoints[1]], allowReflexAngles), locale);
   const wholeAngleAriaLabel = strings.srAngleGraphAriaLabel;
   const wholeAngleDescription = strings.srAngleGraphAriaDescription({
     angleMeasure,
@@ -33503,9 +32122,7 @@ function AngleGraph(props) {
     ariaLabel: initialSideAriaLabel
   }), /*#__PURE__*/React__namespace.createElement("g", {
     id: "angle-description",
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, wholeAngleDescription));
 }
 const positiveX = [1, 0];
@@ -33513,7 +32130,7 @@ const negativeX = [-1, 0];
 const positiveY = [0, 1];
 const negativeY = [0, -1];
 function getAngleSideConstraint(sidePoint, vertex, snapDegrees) {
-  const currentAngle = calculateAngleInDegrees(mafs.vec.sub(sidePoint, vertex));
+  const currentAngle = calculateAngleInDegrees$1(mafs.vec.sub(sidePoint, vertex));
 
   // Find the rays that start at the current point and point up, down, left
   // and right.
@@ -33530,8 +32147,8 @@ function getAngleSideConstraint(sidePoint, vertex, snapDegrees) {
 
   // find the rays that start from the vertex and point in the direction of
   // the angles we just computed.
-  const counterClockwiseRay = [vertex, mafs.vec.add(vertex, polar(1, oneStepCounterClockwise))];
-  const clockwiseRay = [vertex, mafs.vec.add(vertex, polar(1, oneStepClockwise))];
+  const counterClockwiseRay = [vertex, mafs.vec.add(vertex, polar$1(1, oneStepCounterClockwise))];
+  const clockwiseRay = [vertex, mafs.vec.add(vertex, polar$1(1, oneStepClockwise))];
 
   // find the intersections of those rays with the horizontal and vertical
   // rays extending from the sidePoint. These intersections are the points to
@@ -33548,6 +32165,9 @@ function getAngleSideConstraint(sidePoint, vertex, snapDegrees) {
   };
 }
 
+const {
+  clockwise
+} = kmath.geometry;
 function getGradableGraph(state, initialGraph) {
   if (!state.hasBeenInteractedWith) {
     return {
@@ -33629,7 +32249,7 @@ function getGradableGraph(state, initialGraph) {
     // by the order of the points in the coords array, and we want to maintain
     // the same angle scoring with the legacy graph (which had a bug).
     // (LEMS-2190): When we remove the legacy graph, move this logic to the scoring function.
-    const areClockwise = clockwise$1([state.coords[0], state.coords[2], state.coords[1]]);
+    const areClockwise = clockwise([state.coords[0], state.coords[2], state.coords[1]]);
     const shouldReverseCoords = areClockwise && !state.allowReflexAngles;
     const coords = shouldReverseCoords ? state.coords.slice().reverse() : state.coords;
     return {
@@ -33742,14 +32362,10 @@ function CircleGraph(props) {
     }
   }), /*#__PURE__*/React__namespace.createElement("g", {
     id: radiusId,
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, srCircleRadius), /*#__PURE__*/React__namespace.createElement("g", {
     id: outerPointsId,
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, srCircleOuterPoints));
 }
 function MovableCircle(props) {
@@ -33935,49 +32551,16 @@ const LinearGraph = (props, key) => {
     point2X: srFormatNumber(line[1][0], locale),
     point2Y: srFormatNumber(line[1][1], locale)
   });
-
-  // Slope description
-  const slope = (line[1][1] - line[0][1]) / (line[1][0] - line[0][0]);
-  let slopeString = "";
-  if (slope === Infinity || slope === -Infinity) {
-    slopeString = strings.srLinearGraphSlopeVertical;
-  } else if (slope === 0) {
-    slopeString = strings.srLinearGraphSlopeHorizontal;
-  } else {
-    slopeString = slope > 0 ? strings.srLinearGraphSlopeIncreasing : strings.srLinearGraphSlopeDecreasing;
-  }
-
-  // Intersection description
-  const xIntercept = (0 - line[0][1]) / slope + line[0][0];
-  const yIntercept = line[0][1] - slope * line[0][0];
-  const hasXIntercept = xIntercept !== Infinity && xIntercept !== -Infinity;
-  const hasYIntercept = yIntercept !== Infinity && yIntercept !== -Infinity;
-  let interceptString;
-  if (hasXIntercept && hasYIntercept) {
-    // Describe both intercepts in the same sentence.
-    interceptString = xIntercept === 0 && yIntercept === 0 ? strings.srLinearGraphOriginIntercept : strings.srLinearGraphBothIntercepts({
-      xIntercept: srFormatNumber(xIntercept, locale),
-      yIntercept: srFormatNumber(yIntercept, locale)
-    });
-  } else {
-    // Describe only one intercept.
-    interceptString = hasXIntercept ? strings.srLinearGraphXOnlyIntercept({
-      xIntercept: srFormatNumber(xIntercept, locale)
-    }) : strings.srLinearGraphYOnlyIntercept({
-      yIntercept: srFormatNumber(yIntercept, 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", {
-    className: "linear-graph-container"
     // Outer line minimal description
-    ,
     "aria-label": strings.srLinearGraph,
-    "aria-describedby": `${pointsDescriptionId} ${interceptDescriptionId} ${slopeDescriptionId}`,
-    role: "figure"
+    "aria-describedby": `${pointsDescriptionId} ${interceptDescriptionId} ${slopeDescriptionId}`
   }, /*#__PURE__*/React__namespace.createElement(MovableLine, {
     key: 0,
     ariaLabels: {
@@ -33996,19 +32579,13 @@ const LinearGraph = (props, key) => {
     color: "var(--movable-line-stroke-color)"
   }), /*#__PURE__*/React__namespace.createElement("g", {
     id: pointsDescriptionId,
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, linearGraphPointsDescription), /*#__PURE__*/React__namespace.createElement("g", {
     id: interceptDescriptionId,
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, interceptString), /*#__PURE__*/React__namespace.createElement("g", {
     id: slopeDescriptionId,
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, slopeString));
 };
 
@@ -34018,7 +32595,9 @@ function renderLinearSystemGraph(state, dispatch) {
       graphState: state,
       dispatch: dispatch
     }),
-    interactiveElementsDescription: null
+    interactiveElementsDescription: /*#__PURE__*/React__namespace.createElement(LinearSystemGraphDescription, {
+      state: state
+    })
   };
 }
 const LinearSystemGraph = props => {
@@ -34028,9 +32607,56 @@ const LinearSystemGraph = props => {
   const {
     coords: lines
   } = props.graphState;
-  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, lines?.map((line, i) => /*#__PURE__*/React__namespace.createElement(MovableLine, {
+  const {
+    strings,
+    locale
+  } = usePerseusI18n();
+  const id = React__namespace.useId();
+  const linesAriaInfo = lines.map((line, i) => {
+    return {
+      pointsDescriptionId: `${id}-line${i + 1}-points`,
+      interceptDescriptionId: `${id}-line${i + 1}-intercept`,
+      slopeDescriptionId: `${id}-line${i + 1}-slope`,
+      pointsDescription: strings.srLinearSystemPoints({
+        lineNumber: i + 1,
+        point1X: srFormatNumber(line[0][0], locale),
+        point1Y: srFormatNumber(line[0][1], locale),
+        point2X: srFormatNumber(line[1][0], locale),
+        point2Y: srFormatNumber(line[1][1], locale)
+      }),
+      interceptDescription: getInterceptStringForLine(line, strings, locale),
+      slopeDescription: getSlopeStringForLine(line, strings)
+    };
+  });
+  return /*#__PURE__*/React__namespace.createElement("g", {
+    "aria-label": strings.srLinearSystemGraph,
+    "aria-describedby": linesAriaInfo.map(_ref => {
+      let {
+        pointsDescriptionId,
+        interceptDescriptionId,
+        slopeDescriptionId
+      } = _ref;
+      return `${pointsDescriptionId} ${interceptDescriptionId} ${slopeDescriptionId}`;
+    }).join(" ")
+  }, lines?.map((line, i) => /*#__PURE__*/React__namespace.createElement(MovableLine, {
     key: i,
     points: line,
+    ariaLabels: {
+      point1AriaLabel: strings.srLinearSystemPoint({
+        lineNumber: i + 1,
+        pointSequence: 1,
+        x: srFormatNumber(line[0][0], locale),
+        y: srFormatNumber(line[0][1], locale)
+      }),
+      point2AriaLabel: strings.srLinearSystemPoint({
+        lineNumber: i + 1,
+        pointSequence: 2,
+        x: srFormatNumber(line[1][0], locale),
+        y: srFormatNumber(line[1][1], locale)
+      }),
+      grabHandleAriaLabel: `${linesAriaInfo[i].interceptDescription} ${linesAriaInfo[i].slopeDescription}`
+    },
+    ariaDescribedBy: `${linesAriaInfo[i].interceptDescriptionId} ${linesAriaInfo[i].slopeDescriptionId}`,
     onMoveLine: delta => {
       dispatch(actions.linearSystem.moveLine(i, delta));
     },
@@ -34040,8 +32666,67 @@ const LinearSystemGraph = props => {
     },
     onMovePoint: (endpointIndex, destination) => dispatch(actions.linearSystem.movePointInFigure(i, endpointIndex, destination)),
     color: "var(--movable-line-stroke-color)"
-  })), ";");
+  })), linesAriaInfo.map(_ref2 => {
+    let {
+      pointsDescriptionId,
+      interceptDescriptionId,
+      slopeDescriptionId,
+      pointsDescription,
+      interceptDescription,
+      slopeDescription
+    } = _ref2;
+    return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement("g", {
+      key: pointsDescriptionId,
+      id: pointsDescriptionId,
+      style: a11y.srOnly
+    }, pointsDescription), /*#__PURE__*/React__namespace.createElement("g", {
+      key: interceptDescriptionId,
+      id: interceptDescriptionId,
+      style: a11y.srOnly
+    }, interceptDescription), /*#__PURE__*/React__namespace.createElement("g", {
+      key: slopeDescriptionId,
+      id: slopeDescriptionId,
+      style: a11y.srOnly
+    }, slopeDescription));
+  }));
 };
+function LinearSystemGraphDescription(_ref3) {
+  let {
+    state
+  } = _ref3;
+  // The reason that LinearSystemGraphDescription is a component (rather
+  // than a function that returns a string) is because it needs to use a
+  // hook: `usePerseusI18n`.
+  const i18n = usePerseusI18n();
+  return describeLinearSystemGraph(state, i18n);
+}
+
+// Exported for testing
+function describeLinearSystemGraph(state, i18n) {
+  const {
+    strings,
+    locale
+  } = i18n;
+  const {
+    coords: lines
+  } = state;
+  const graphDescription = strings.srLinearSystemGraph;
+  const lineDescriptions = lines.map((line, i) => {
+    const point1 = line[0];
+    const point2 = line[1];
+    return strings.srLinearSystemPoints({
+      lineNumber: i + 1,
+      point1X: srFormatNumber(point1[0], locale),
+      point1Y: srFormatNumber(point1[1], locale),
+      point2X: srFormatNumber(point2[0], locale),
+      point2Y: srFormatNumber(point2[1], locale)
+    });
+  });
+  const allDescriptions = [graphDescription, ...lineDescriptions];
+  return strings.srInteractiveElements({
+    elements: allDescriptions.join(" ")
+  });
+}
 
 function renderPointGraph(state, dispatch) {
   return {
@@ -34483,7 +33168,7 @@ function QuadraticGraph(props) {
   // to content creators the currently selected "correct answer". ex: y = 0.200x^2 + 0.000x + 0.000
   // While we should technically never have invalid coordinates, we want to ensure that we have a fallback
   const coeffRef = React__namespace.useRef([0, 0, 0]);
-  const coeffs = getQuadraticCoefficients$1(coords);
+  const coeffs = getQuadraticCoefficients$2(coords);
   if (coeffs !== undefined) {
     coeffRef.current = coeffs;
   }
@@ -34508,7 +33193,7 @@ function QuadraticGraph(props) {
 // These equations were originally set up in 2013 and may require some
 // additional comments to help clarify the quadratic formula manipulations
 // Origin: https://phabricator.khanacademy.org/D2413
-const getQuadraticCoefficients$1 = coords => {
+const getQuadraticCoefficients$2 = coords => {
   const p1 = coords[0];
   const p2 = coords[1];
   const p3 = coords[2];
@@ -34531,7 +33216,9 @@ function renderRayGraph(state, dispatch) {
       graphState: state,
       dispatch: dispatch
     }),
-    interactiveElementsDescription: null
+    interactiveElementsDescription: /*#__PURE__*/React__namespace.createElement(RayGraphDescription, {
+      state: state
+    })
   };
 }
 const RayGraph = props => {
@@ -34543,18 +33230,104 @@ const RayGraph = props => {
   } = props.graphState;
   const handleMoveLine = delta => dispatch(actions.ray.moveRay(delta));
   const handleMovePoint = (pointIndex, newPoint) => dispatch(actions.ray.movePoint(pointIndex, newPoint));
+  const {
+    strings,
+    locale
+  } = usePerseusI18n();
+  const id = React__namespace.useId();
+  const pointsDescriptionId = id + "-points";
+
+  // Aria label strings
+  const {
+    srRayGraph,
+    srRayPoints,
+    srRayEndpoint,
+    srRayTerminalPoint,
+    srRayGrabHandle
+  } = describeRayGraph(props.graphState, {
+    strings,
+    locale
+  });
 
   // Ray graphs only have one line
-  return /*#__PURE__*/React__namespace.createElement(MovableLine, {
+  return /*#__PURE__*/React__namespace.createElement("g", {
+    // Outer line minimal description
+    "aria-label": srRayGraph,
+    "aria-describedby": pointsDescriptionId
+  }, /*#__PURE__*/React__namespace.createElement(MovableLine, {
     points: line,
+    ariaLabels: {
+      point1AriaLabel: srRayEndpoint,
+      point2AriaLabel: srRayTerminalPoint,
+      grabHandleAriaLabel: srRayGrabHandle
+    },
     onMoveLine: handleMoveLine,
     onMovePoint: handleMovePoint,
     extend: {
       start: false,
       end: true
     }
-  });
+  }), /*#__PURE__*/React__namespace.createElement("g", {
+    id: pointsDescriptionId,
+    style: a11y.srOnly
+  }, srRayPoints));
 };
+function RayGraphDescription(_ref) {
+  let {
+    state
+  } = _ref;
+  // The reason that RayGraphDescription 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 = describeRayGraph(state, i18n);
+  return strings.srRayInteractiveElement;
+}
+
+// Exported for testing
+function describeRayGraph(state, i18n) {
+  const {
+    coords: line
+  } = state;
+  const {
+    strings,
+    locale
+  } = i18n;
+
+  // Aria label strings
+  const srRayGraph = strings.srRayGraph;
+  const srRayPoints = strings.srRayPoints({
+    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 srRayEndpoint = strings.srRayEndpoint({
+    x: srFormatNumber(line[0][0], locale),
+    y: srFormatNumber(line[0][1], locale)
+  });
+  const srRayTerminalPoint = strings.srRayTerminalPoint({
+    x: srFormatNumber(line[1][0], locale),
+    y: srFormatNumber(line[1][1], locale)
+  });
+  const srRayGrabHandle = strings.srRayGrabHandle({
+    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 srRayInteractiveElement = strings.srInteractiveElements({
+    elements: [srRayGraph, srRayPoints].join(" ")
+  });
+  return {
+    srRayGraph,
+    srRayPoints,
+    srRayEndpoint,
+    srRayTerminalPoint,
+    srRayGrabHandle,
+    srRayInteractiveElement
+  };
+}
 
 function renderSegmentGraph(state, dispatch) {
   return {
@@ -34669,6 +33442,10 @@ const getSinusoidCoefficients$1 = coords => {
   };
 };
 
+const {
+  calculateAngleInDegrees,
+  convertDegreesToRadians
+} = kmath.angles;
 const protractorImage = "https://ka-perseus-graphie.s3.amazonaws.com/e9d032f2ab8b95979f674fbfa67056442ba1ff6a.png";
 
 // The vector from the center of the protractor to the top left corner of the
@@ -35384,6 +34161,10 @@ function mafsStateToInteractiveGraph(state, originalGraph) {
   }
 }
 
+const {
+  magnitude: magnitude$2,
+  vector: vector$2
+} = kmath.geometry;
 function initializeGraphState(params) {
   const {
     graph,
@@ -35671,7 +34452,7 @@ const getAngleCoords = params => {
   defaultCoords = normalizePoints(range, step, defaultCoords, true);
 
   // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'readonly Coord[]'. | TS2556 - A spread argument must either have a tuple type or be passed to a rest parameter.
-  const radius = magnitude(vector(...defaultCoords));
+  const radius = magnitude$2(vector$2(...defaultCoords));
 
   // We're adding a placeholder for the third point to appease ts and so that we
   // can calculate it after we've adjusted the first point by the angleOffsetDeg
@@ -35685,6 +34466,24 @@ const getAngleCoords = params => {
   return coords;
 };
 
+const {
+  getAngleFromVertex,
+  getClockwiseAngle: getClockwiseAngle$1,
+  polar
+} = kmath.angles;
+const {
+  angleMeasures: angleMeasures$1,
+  ccw: ccw$1,
+  lawOfCosines: lawOfCosines$1,
+  magnitude: magnitude$1,
+  polygonSidesIntersect,
+  reverseVector,
+  sign: sign$1,
+  vector: vector$1
+} = kmath.geometry;
+const {
+  getQuadraticCoefficients: getQuadraticCoefficients$1
+} = kmath.coefficients;
 const minDistanceBetweenAngleVertexAndSidePoint = 2;
 function interactiveGraphReducer(state, action) {
   switch (action.type) {
@@ -36229,11 +35028,9 @@ const getChange = (coords, delta, constraintOpts) => {
   const [dx, dy] = getDeltaVertex(maxMoves, minMoves, delta);
   return [dx, dy];
 };
-const eq$2 = Util.eq;
-
 // Less than or approximately equal
 function leq$1(a, b) {
-  return a < b || eq$2(a, b);
+  return a < b || perseusCore.approximateEqual(a, b);
 }
 function boundAndSnapToGrid(point, _ref) {
   let {
@@ -36383,7 +35180,7 @@ function boundAndSnapToPolygonAngle(destinationPoint, _ref6, index) {
   });
 
   // Gets the radian angles between the coords and maps them to degrees
-  const angles = angleMeasures(coordsCopy).map(angle => angle * 180 / Math.PI);
+  const angles = angleMeasures$1(coordsCopy).map(angle => angle * 180 / Math.PI);
 
   // Gets the relative index of a point
   const rel = j => {
@@ -36395,7 +35192,7 @@ function boundAndSnapToPolygonAngle(destinationPoint, _ref6, index) {
     angles[rel(j)] = Math.round(angles[rel(j)]);
   });
   const getAngle = function (a, vertex, b) {
-    const angle = getClockwiseAngle([coordsCopy[rel(a)], coordsCopy[rel(vertex)], coordsCopy[rel(b)]]);
+    const angle = getClockwiseAngle$1([coordsCopy[rel(a)], coordsCopy[rel(vertex)], coordsCopy[rel(b)]]);
     return angle;
   };
   const innerAngles = [angles[rel(-1)] - getAngle(-2, -1, 1), angles[rel(1)] - getAngle(-1, 1, 2)];
@@ -36407,9 +35204,9 @@ function boundAndSnapToPolygonAngle(destinationPoint, _ref6, index) {
   })) {
     return startingPoint;
   }
-  const knownSide = magnitude(
+  const knownSide = magnitude$1(
   // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'readonly Coord[]'.
-  vector(coordsCopy[rel(-1)], coordsCopy[rel(1)]));
+  vector$1(coordsCopy[rel(-1)], coordsCopy[rel(1)]));
 
   // Returns true if the points form a counter-clockwise turn;
   // a.k.a if the point is on the left or right of the polygon.
@@ -36417,7 +35214,7 @@ function boundAndSnapToPolygonAngle(destinationPoint, _ref6, index) {
   // we want to add the inner angle to the outer angle, and if it's on the right,
   // we want to subtract the inner angle from the outer angle. The angle solved
   // for is then used in the polar function to determine the new point.
-  const onLeft = sign(ccw(coordsCopy[rel(-1)], coordsCopy[rel(1)], coordsCopy[index])) === 1;
+  const onLeft = sign$1(ccw$1(coordsCopy[rel(-1)], coordsCopy[rel(1)], coordsCopy[index])) === 1;
 
   // Solve for side by using the law of sines
   const side = Math.sin(innerAngles[1] * Math.PI / 180) / Math.sin(innerAngles[2] * Math.PI / 180) * knownSide;
@@ -36456,7 +35253,7 @@ function boundAndSnapToSides(destinationPoint, _ref7, index) {
   };
   const sides = ___default["default"].map([[coordsCopy[rel(-1)], coordsCopy[index]], [coordsCopy[index], coordsCopy[rel(1)]], [coordsCopy[rel(-1)], coordsCopy[rel(1)]]], function (coordsCopy) {
     // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'readonly Coord[]'. | TS2556 - A spread argument must either have a tuple type or be passed to a rest parameter.
-    return magnitude(vector(...coordsCopy));
+    return magnitude$1(vector$1(...coordsCopy));
   });
 
   // Round the sides to left and right of the current point
@@ -36471,7 +35268,7 @@ function boundAndSnapToSides(destinationPoint, _ref7, index) {
 
   // Solve for angle by using the law of cosines
   // Angle at the first vertex of the polygon
-  const innerAngle = lawOfCosines(sides[0], sides[2], sides[1]);
+  const innerAngle = lawOfCosines$1(sides[0], sides[2], sides[1]);
 
   // Angle at the second vertex of the polygon
   const outerAngle = getAngleFromVertex(coordsCopy[rel(1)], coordsCopy[rel(-1)]);
@@ -36482,7 +35279,7 @@ function boundAndSnapToSides(destinationPoint, _ref7, index) {
   // we want to add the inner angle to the outer angle, and if it's on the right,
   // we want to subtract the inner angle from the outer angle. The angle solved
   // for is then used in the polar function to determine the new point.
-  const onLeft = sign(ccw(coordsCopy[rel(-1)], coordsCopy[rel(1)], coordsCopy[index])) === 1;
+  const onLeft = sign$1(ccw$1(coordsCopy[rel(-1)], coordsCopy[rel(1)], coordsCopy[index])) === 1;
 
   // Uses the length of the first side of the polygon (radial coordinate)
   // and the angle between the first and second sides of the
@@ -36616,216 +35413,26 @@ const StatefulMafsGraph = /*#__PURE__*/React__namespace.forwardRef((props, ref)
   }));
 });
 
-const eq$1 = Util.eq;
-const deepEq$3 = Util.deepEq;
-function scoreInteractiveGraph(userInput, rubric) {
-  // None-type graphs are not graded
-  if (userInput.type === "none" && rubric.correct.type === "none") {
-    return {
-      type: "points",
-      earned: 0,
-      total: 0,
-      message: null
-    };
-  }
-
-  // When nothing has moved, there will neither be coords nor the
-  // circle's center/radius fields. When those fields are absent, skip
-  // all these checks; just go mark the answer as empty.
-  const hasValue = Boolean(
-  // @ts-expect-error - TS2339 - Property 'coords' does not exist on type 'PerseusGraphType'.
-  userInput.coords ||
-  // @ts-expect-error - TS2339 - Property 'center' does not exist on type 'PerseusGraphType'. | TS2339 - Property 'radius' does not exist on type 'PerseusGraphType'.
-  userInput.center && userInput.radius);
-  if (userInput.type === rubric.correct.type && hasValue) {
-    if (userInput.type === "linear" && rubric.correct.type === "linear" && userInput.coords != null) {
-      const guess = userInput.coords;
-      const correct = rubric.correct.coords;
-
-      // If both of the guess points are on the correct line, it's
-      // correct.
-      if (collinear(correct[0], correct[1], guess[0]) && collinear(correct[0], correct[1], guess[1])) {
-        return {
-          type: "points",
-          earned: 1,
-          total: 1,
-          message: null
-        };
-      }
-    } else if (userInput.type === "linear-system" && rubric.correct.type === "linear-system" && userInput.coords != null) {
-      const guess = userInput.coords;
-      const correct = rubric.correct.coords;
-      if (collinear(correct[0][0], correct[0][1], guess[0][0]) && collinear(correct[0][0], correct[0][1], guess[0][1]) && collinear(correct[1][0], correct[1][1], guess[1][0]) && collinear(correct[1][0], correct[1][1], guess[1][1]) || collinear(correct[0][0], correct[0][1], guess[1][0]) && collinear(correct[0][0], correct[0][1], guess[1][1]) && collinear(correct[1][0], correct[1][1], guess[0][0]) && collinear(correct[1][0], correct[1][1], guess[0][1])) {
-        return {
-          type: "points",
-          earned: 1,
-          total: 1,
-          message: null
-        };
-      }
-    } else if (userInput.type === "quadratic" && rubric.correct.type === "quadratic" && userInput.coords != null) {
-      // If the parabola coefficients match, it's correct.
-      const guessCoeffs = getQuadraticCoefficients(userInput.coords);
-      const correctCoeffs = getQuadraticCoefficients(rubric.correct.coords);
-      if (deepEq$3(guessCoeffs, correctCoeffs)) {
-        return {
-          type: "points",
-          earned: 1,
-          total: 1,
-          message: null
-        };
-      }
-    } else if (userInput.type === "sinusoid" && rubric.correct.type === "sinusoid" && userInput.coords != null) {
-      const guessCoeffs = getSinusoidCoefficients(userInput.coords);
-      const correctCoeffs = getSinusoidCoefficients(rubric.correct.coords);
-      const canonicalGuessCoeffs = canonicalSineCoefficients$1(guessCoeffs);
-      const canonicalCorrectCoeffs = canonicalSineCoefficients$1(correctCoeffs);
-      // If the canonical coefficients match, it's correct.
-      if (deepEq$3(canonicalGuessCoeffs, canonicalCorrectCoeffs)) {
-        return {
-          type: "points",
-          earned: 1,
-          total: 1,
-          message: null
-        };
-      }
-    } else if (userInput.type === "circle" && rubric.correct.type === "circle") {
-      if (deepEq$3(userInput.center, rubric.correct.center) && eq$1(userInput.radius, rubric.correct.radius)) {
-        return {
-          type: "points",
-          earned: 1,
-          total: 1,
-          message: null
-        };
-      }
-    } else if (userInput.type === "point" && rubric.correct.type === "point" && userInput.coords != null) {
-      let correct = rubric.correct.coords;
-      if (correct == null) {
-        throw new Error("Point graph rubric has null coords");
-      }
-      const guess = userInput.coords.slice();
-      correct = correct.slice();
-      // Everything's already rounded so we shouldn't need to do an
-      // eq() comparison but _.isEqual(0, -0) is false, so we'll use
-      // eq() anyway. The sort should be fine because it'll stringify
-      // it and -0 converted to a string is "0"
-      guess?.sort();
-      // @ts-expect-error - TS2339 - Property 'sort' does not exist on type 'readonly Coord[]'.
-      correct.sort();
-      if (deepEq$3(guess, correct)) {
-        return {
-          type: "points",
-          earned: 1,
-          total: 1,
-          message: null
-        };
-      }
-    } else if (userInput.type === "polygon" && rubric.correct.type === "polygon" && userInput.coords != null) {
-      const guess = userInput.coords.slice();
-      const correct = rubric.correct.coords.slice();
-      let match;
-      if (rubric.correct.match === "similar") {
-        match = similar(guess, correct, Number.POSITIVE_INFINITY);
-      } else if (rubric.correct.match === "congruent") {
-        match = similar(guess, correct, kmath.number.DEFAULT_TOLERANCE);
-      } else if (rubric.correct.match === "approx") {
-        match = similar(guess, correct, 0.1);
-      } else {
-        /* exact */
-        guess.sort();
-        correct.sort();
-        match = deepEq$3(guess, correct);
-      }
-      if (match) {
-        return {
-          type: "points",
-          earned: 1,
-          total: 1,
-          message: null
-        };
-      }
-    } else if (userInput.type === "segment" && rubric.correct.type === "segment" && userInput.coords != null) {
-      let guess = Util.deepClone(userInput.coords);
-      let correct = Util.deepClone(rubric.correct.coords);
-      guess = ___default["default"].invoke(guess, "sort").sort();
-      correct = ___default["default"].invoke(correct, "sort").sort();
-      if (deepEq$3(guess, correct)) {
-        return {
-          type: "points",
-          earned: 1,
-          total: 1,
-          message: null
-        };
-      }
-    } else if (userInput.type === "ray" && rubric.correct.type === "ray" && userInput.coords != null) {
-      const guess = userInput.coords;
-      const correct = rubric.correct.coords;
-      if (deepEq$3(guess[0], correct[0]) && collinear(correct[0], correct[1], guess[1])) {
-        return {
-          type: "points",
-          earned: 1,
-          total: 1,
-          message: null
-        };
-      }
-    } else if (userInput.type === "angle" && rubric.correct.type === "angle") {
-      const guess = userInput.coords;
-      const correct = rubric.correct.coords;
-      const allowReflexAngles = rubric.correct.allowReflexAngles;
-      let match;
-      if (rubric.correct.match === "congruent") {
-        const angles = ___default["default"].map([guess, correct], function (coords) {
-          if (!coords) {
-            return false;
-          }
-          const angle = getClockwiseAngle(coords, allowReflexAngles);
-          return angle;
-        });
-        // @ts-expect-error - TS2556 - A spread argument must either have a tuple type or be passed to a rest parameter.
-        match = eq$1(...angles);
-      } else {
-        /* exact */
-        match =
-        // @ts-expect-error - TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'.
-        deepEq$3(guess[1], correct[1]) &&
-        // @ts-expect-error - TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'.
-        collinear(correct[1], correct[0], guess[0]) &&
-        // @ts-expect-error - TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'.
-        collinear(correct[1], correct[2], guess[2]);
-      }
-      if (match) {
-        return {
-          type: "points",
-          earned: 1,
-          total: 1,
-          message: null
-        };
-      }
-    }
-  }
-
-  // The input wasn't correct, so check if it's a blank input or if it's
-  // actually just wrong
-  if (!hasValue || ___default["default"].isEqual(userInput, rubric.graph)) {
-    // We're where we started.
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return {
-    type: "points",
-    earned: 0,
-    total: 1,
-    message: null
-  };
-}
-
+const {
+  getClockwiseAngle
+} = kmath.angles;
+const {
+  angleMeasures,
+  ccw,
+  collinear,
+  getLineEquation,
+  getLineIntersection,
+  intersects,
+  lawOfCosines,
+  magnitude,
+  rotate,
+  sign,
+  vector
+} = kmath.geometry;
 const TRASH_ICON_URI = "https://ka-perseus-graphie.s3.amazonaws.com/b1452c0d79fd0f7ff4c3af9488474a0a0decb361.png";
 const defaultBackgroundImage = {
   url: null
 };
-const eq = Util.eq;
 const UNLIMITED = "unlimited";
 
 // Sample background image:
@@ -36838,7 +35445,7 @@ function defaultVal(actual, defaultValue) {
 
 // Less than or approximately equal
 function leq(a, b) {
-  return a < b || eq(a, b);
+  return a < b || perseusCore.approximateEqual(a, b);
 }
 function capitalize(str) {
   return str.replace(/(?:^|-)(.)/g, function (match, letter) {
@@ -37700,7 +36307,7 @@ class LegacyInteractiveGraph extends React__namespace.Component {
         // Solve for side by using the law of sines
         const side = Math.sin(innerAngles[1] * Math.PI / 180) / Math.sin(innerAngles[2] * Math.PI / 180) * knownSide;
         const outerAngle = GraphUtils.findAngleDeprecated(coords[rel(1)], coords[rel(-1)]);
-        const offset = polar$1(side, outerAngle + (onLeft ? 1 : -1) * innerAngles[0]);
+        const offset = polar$2(side, outerAngle + (onLeft ? 1 : -1) * innerAngles[0]);
         return this.graphie?.addPoints(coords[rel(-1)], offset);
       }
       // @ts-expect-error - TS2339 - Property 'snapTo' does not exist on type 'PerseusGraphType'.
@@ -37724,7 +36331,7 @@ class LegacyInteractiveGraph extends React__namespace.Component {
         const innerAngle = lawOfCosines(sides[0], sides[2], sides[1]);
         const outerAngle = GraphUtils.findAngleDeprecated(coords[rel(1)], coords[rel(-1)]);
         const onLeft = sign(ccw(coords[rel(-1)], coords[rel(1)], coords[i])) === 1;
-        const offset = polar$1(sides[0], outerAngle + (onLeft ? 1 : -1) * innerAngle);
+        const offset = polar$2(sides[0], outerAngle + (onLeft ? 1 : -1) * innerAngle);
         return this.graphie?.addPoints(coords[rel(-1)], offset);
       }
       // Snap to grid (already done)
@@ -38336,12 +36943,12 @@ class InteractiveGraph extends React__namespace.Component {
   }
   static getLinearEquationString(props) {
     const coords = InteractiveGraph.getLineCoords(props.graph, props);
-    if (eq(coords[0][0], coords[1][0])) {
+    if (perseusCore.approximateEqual(coords[0][0], coords[1][0])) {
       return "x = " + coords[0][0].toFixed(3);
     }
     const m = (coords[1][1] - coords[0][1]) / (coords[1][0] - coords[0][0]);
     const b = coords[0][1] - m * coords[0][0];
-    if (eq(m, 0)) {
+    if (perseusCore.approximateEqual(m, 0)) {
       return "y = " + b.toFixed(3);
     }
     return "y = " + m.toFixed(3) + "x + " + b.toFixed(3);
@@ -38483,7 +37090,7 @@ var InteractiveGraph$1 = {
   staticTransform: staticTransform$3,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusInteractiveGraphUserInput'.
-  scorer: scoreInteractiveGraph
+  scorer: perseusScore.scoreInteractiveGraph
 };
 
 // TODO: can we use WB typography?
@@ -38860,59 +37467,6 @@ const styles$a = aphrodite.StyleSheet.create({
   }
 });
 
-// Question state for marker as result of user selected answers.
-
-function scoreMarker(marker) {
-  const score = {
-    hasAnswers: false,
-    isCorrect: false
-  };
-  if (marker.selected && marker.selected.length > 0) {
-    score.hasAnswers = true;
-  }
-  if (marker.answers.length > 0) {
-    if (marker.selected && marker.selected.length === marker.answers.length) {
-      // All correct answers are selected by the user.
-      score.isCorrect = marker.selected.every(choice => marker.answers.includes(choice));
-    }
-  } else if (!marker.selected || marker.selected.length === 0) {
-    // Correct as no answers should be selected by the user.
-    score.isCorrect = true;
-  }
-  return score;
-}
-
-// TODO(LEMS-2440): May need to pull answers out of PerseusLabelImageWidgetOptions[markers] for the rubric
-function scoreLabelImage(userInput, rubric) {
-  let numAnswered = 0;
-  let numCorrect = 0;
-  for (const marker of userInput.markers) {
-    const score = scoreMarker(marker);
-    if (score.hasAnswers) {
-      numAnswered++;
-    }
-    if (score.isCorrect) {
-      numCorrect++;
-    }
-  }
-
-  // We expect all question markers to be answered before grading.
-  if (numAnswered !== userInput.markers.length) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return {
-    type: "points",
-    // Markers with no expected answers are graded as correct if user
-    // makes no answer selection.
-    earned: numCorrect === userInput.markers.length ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 /**
  * Represents a direction vector.
  * No diagonals allowed.
@@ -39136,7 +37690,7 @@ class LabelImage extends React__namespace.Component {
       onChange
     } = this.props;
     const updatedMarkers = markers.map(marker => {
-      const score = scoreMarker(marker);
+      const score = perseusScore.scoreLabelImageMarker(marker);
       return {
         ...marker,
         // Reveal correctness state for markers with answers.
@@ -39285,7 +37839,7 @@ class LabelImage extends React__namespace.Component {
           bottom: "top"
         }[markerPosition];
       }
-      const score = scoreMarker(marker);
+      const score = perseusScore.scoreLabelImageMarker(marker);
       // Once the question is answered, show markers
       // with correct answers, otherwise passthrough
       // the correctness state.
@@ -39493,7 +38047,7 @@ var LabelImage$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusLabelImageUserInput'.
-  scorer: scoreLabelImage
+  scorer: perseusScore.scoreLabelImage
 };
 
 /* eslint-disable @khanacademy/ts-no-error-suppressions */
@@ -40219,16 +38773,6 @@ const getPromptJSON$9 = (renderProps, userInput) => {
   };
 };
 
-function scoreMatcher(state, rubric) {
-  const correct = ___default["default"].isEqual(state.left, rubric.left) && ___default["default"].isEqual(state.right, rubric.right);
-  return {
-    type: "points",
-    earned: correct ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 const {
   shuffle: shuffle$1,
   seededRNG
@@ -40434,7 +38978,7 @@ var Matcher$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusMatcherUserInput'.
-  scorer: scoreMatcher
+  scorer: perseusScore.scoreMatcher
 };
 
 const getPromptJSON$8 = (renderProps, userInput) => {
@@ -40450,78 +38994,6 @@ const getPromptJSON$8 = (renderProps, userInput) => {
   };
 };
 
-/**
- * Checks user input from the matrix widget to see if it is scorable.
- *
- * Note: The matrix widget cannot do much validation without the Scoring
- * Data because of its use of KhanAnswerTypes as a core part of scoring.
- *
- * @see `scoreMatrix()` for more details.
- */
-function validateMatrix(userInput, validationData, strings) {
-  const supplied = userInput.answers;
-  const suppliedSize = getMatrixSize(supplied);
-  for (let row = 0; row < suppliedSize[0]; row++) {
-    for (let col = 0; col < suppliedSize[1]; col++) {
-      if (supplied[row][col] == null || supplied[row][col].toString().length === 0) {
-        return {
-          type: "invalid",
-          message: strings.fillAllCells
-        };
-      }
-    }
-  }
-  return null;
-}
-
-function scoreMatrix(userInput, rubric, strings) {
-  const validationResult = validateMatrix(userInput, rubric, strings);
-  if (validationResult != null) {
-    return validationResult;
-  }
-  const solution = rubric.answers;
-  const supplied = userInput.answers;
-  const solutionSize = getMatrixSize(solution);
-  const suppliedSize = getMatrixSize(supplied);
-  const incorrectSize = solutionSize[0] !== suppliedSize[0] || solutionSize[1] !== suppliedSize[1];
-  const createValidator = perseusScore.KhanAnswerTypes.number.createValidatorFunctional;
-  let message = null;
-  let incorrect = false;
-  ___default["default"](suppliedSize[0]).times(row => {
-    ___default["default"](suppliedSize[1]).times(col => {
-      if (!incorrectSize) {
-        const validator = createValidator(
-        // @ts-expect-error - TS2345 - Argument of type 'number' is not assignable to parameter of type 'string'.
-        solution[row][col], {
-          simplify: true
-        });
-        const result = validator(supplied[row][col]);
-        if (result.message) {
-          // @ts-expect-error - TS2322 - Type 'string' is not assignable to type 'null'.
-          message = result.message;
-        }
-        if (!result.correct) {
-          incorrect = true;
-        }
-      }
-    });
-  });
-  if (incorrectSize) {
-    return {
-      type: "points",
-      earned: 0,
-      total: 1,
-      message: null
-    };
-  }
-  return {
-    type: "points",
-    earned: incorrect ? 0 : 1,
-    total: 1,
-    message: message
-  };
-}
-
 const {
   assert: assert$2
 } = InteractiveUtil;
@@ -40570,29 +39042,6 @@ const getRefForPath$1 = function (path) {
   const column = getColumnFromPath$1(path);
   return "answer" + row + "," + column;
 };
-function getMatrixSize(matrix) {
-  const matrixSize = [1, 1];
-
-  // We need to find the widest row and tallest column to get the correct
-  // matrix size.
-  ___default["default"](matrix).each((matrixRow, row) => {
-    let rowWidth = 0;
-    ___default["default"](matrixRow).each((matrixCol, col) => {
-      if (matrixCol != null && matrixCol.toString().length) {
-        rowWidth = col + 1;
-      }
-    });
-
-    // Matrix width:
-    matrixSize[1] = Math.max(matrixSize[1], rowWidth);
-
-    // Matrix height:
-    if (rowWidth > 0) {
-      matrixSize[0] = Math.max(matrixSize[0], row + 1);
-    }
-  });
-  return matrixSize;
-}
 class Matrix extends React__namespace.Component {
   static contextType = PerseusI18nContext;
   // @ts-expect-error - TS2564 - Property 'cursorPosition' has no initializer and is not definitely assigned in the constructor.
@@ -40763,7 +39212,7 @@ class Matrix extends React__namespace.Component {
       INPUT_HEIGHT,
       INPUT_WIDTH
     } = dimensions;
-    const matrixSize = getMatrixSize(this.props.answers);
+    const matrixSize = perseusCore.getMatrixSize(this.props.answers);
     const maxRows = this.props.matrixBoardSize[0];
     const maxCols = this.props.matrixBoardSize[1];
     const cursorRow = this.props.cursorPosition[0];
@@ -40935,7 +39384,7 @@ var Matrix$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusMatrixUserInput'.
-  scorer: scoreMatrix
+  scorer: perseusScore.scoreMatrix
 };
 
 const getPromptJSON$7 = () => {
@@ -41980,59 +40429,6 @@ const getPromptJSON$6 = (renderProps, userInput) => {
   };
 };
 
-/**
- * Checks user input is within the allowed range and not the same as the initial
- * state.
- * @param userInput
- * @see 'scoreNumberLine' for the scoring logic.
- */
-function validateNumberLine(userInput) {
-  const divisionRange = userInput.divisionRange;
-  const outsideAllowedRange = userInput.numDivisions > divisionRange[1] || userInput.numDivisions < divisionRange[0];
-
-  // TODO: I don't think isTickCrtl is a thing anymore
-  if (userInput.isTickCrtl && outsideAllowedRange) {
-    return {
-      type: "invalid",
-      message: "Number of divisions is outside the allowed range."
-    };
-  }
-  return null;
-}
-
-function scoreNumberLine(userInput, scoringData) {
-  const validationError = validateNumberLine(userInput);
-  if (validationError) {
-    return validationError;
-  }
-  const range = scoringData.range;
-  const start = scoringData.initialX != null ? scoringData.initialX : range[0];
-  const startRel = scoringData.isInequality ? "ge" : "eq";
-  const correctRel = scoringData.correctRel || "eq";
-  const correctPos = kmath.number.equal(userInput.numLinePosition, scoringData.correctX || 0);
-  if (correctPos && correctRel === userInput.rel) {
-    return {
-      type: "points",
-      earned: 1,
-      total: 1,
-      message: null
-    };
-  }
-  if (userInput.numLinePosition === start && userInput.rel === startRel) {
-    // We're where we started.
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return {
-    type: "points",
-    earned: 0,
-    total: 1,
-    message: null
-  };
-}
-
 // @ts-expect-error - TS2339 - Property 'MovablePoint' does not exist on type 'typeof Graphie'.
 const MovablePoint = Graphie.MovablePoint;
 // @ts-expect-error - TS2339 - Property 'Line' does not exist on type 'typeof Graphie'.
@@ -42592,7 +40988,7 @@ var NumberLine$1 = {
   staticTransform: staticTransform$1,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type 'UserInput' is not assignable to type 'PerseusNumberLineUserInput'.
-  scorer: scoreNumberLine
+  scorer: perseusScore.scoreNumberLine
 };
 
 const getPromptJSON$5 = (renderProps, userInput) => {
@@ -42607,36 +41003,6 @@ const getPromptJSON$5 = (renderProps, userInput) => {
   };
 };
 
-/**
- * Checks user input from the orderer widget to see if the user has started
- * ordering the options, making the widget scorable.
- * @param userInput
- * @see `scoreOrderer` for more details.
- */
-function validateOrderer(userInput) {
-  if (userInput.current.length === 0) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
-
-function scoreOrderer(userInput, rubric) {
-  const validateError = validateOrderer(userInput);
-  if (validateError) {
-    return validateError;
-  }
-  const correct = ___default["default"].isEqual(userInput.current, rubric.correctOptions.map(option => option.content));
-  return {
-    type: "points",
-    earned: correct ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 class PlaceholderCard extends React__namespace.Component {
   render() {
     return /*#__PURE__*/React__namespace.createElement("div", {
@@ -43176,7 +41542,7 @@ var Orderer$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type UserInput is not assignable to type PerseusOrdererUserInput
-  scorer: scoreOrderer
+  scorer: perseusScore.scoreOrderer
 };
 
 /* eslint-disable @khanacademy/ts-no-error-suppressions */
@@ -43448,42 +41814,6 @@ const getPromptJSON$3 = () => {
   return getUnsupportedPromptJSON("plotter");
 };
 
-const {
-  deepEq: deepEq$2
-} = Util;
-
-/**
- * Checks user input to confirm it is not the same as the starting values for the graph.
- * This means the user has modified the graph, and the question can be scored.
- *
- * @see 'scorePlotter' for more details on scoring.
- */
-function validatePlotter(userInput, validationData) {
-  if (deepEq$2(userInput, validationData.starting)) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
-
-const {
-  deepEq: deepEq$1
-} = Util;
-function scorePlotter(userInput, scoringData) {
-  const validationError = validatePlotter(userInput, scoringData);
-  if (validationError) {
-    return validationError;
-  }
-  return {
-    type: "points",
-    earned: deepEq$1(userInput, scoringData.correct) ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 /* eslint-disable react/no-unsafe */
 class Plotter extends React__namespace.Component {
   static contextType = PerseusI18nContext;
@@ -44288,7 +42618,7 @@ var Plotter$1 = {
   staticTransform: staticTransform,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type UserInput is not assignable to type PerseusPlotterUserInput
-  scorer: scorePlotter
+  scorer: perseusScore.scorePlotter
 };
 
 const getPromptJSON$2 = () => {
@@ -44365,43 +42695,6 @@ const getPromptJSON$1 = userInput => {
   };
 };
 
-/**
- * Checks user input for the sorter widget to ensure that the user has made
- * changes before attempting to score the widget.
- * @param userInput
- * @see 'scoreSorter' in 'packages/perseus/src/widgets/sorter/score-sorter.ts'
- * for more details on how the sorter widget is scored.
- */
-function validateSorter(userInput) {
-  // If the sorter widget hasn't been changed yet, we treat it as "empty" which
-  // prevents the "Check" button from becoming active. We want the user
-  // to make a change before trying to move forward. This makes an
-  // assumption that the initial order isn't the correct order! However,
-  // this should be rare if it happens, and interacting with the list
-  // will enable the button, so they won't be locked out of progressing.
-  if (!userInput.changed) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
-
-function scoreSorter(userInput, rubric) {
-  const validationError = validateSorter(userInput);
-  if (validationError) {
-    return validationError;
-  }
-  const correct = Util.deepEq(userInput.options, rubric.correct);
-  return {
-    type: "points",
-    earned: correct ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 const {
   shuffle
 } = Util;
@@ -44488,84 +42781,9 @@ var Sorter$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type UserInput is not assignable to type PerseusSorterUserInput
-  scorer: scoreSorter
-};
-
-/**
- * Filters the given table (modelled as a 2D array) to remove any rows that are
- * completely empty.
- *
- * @returns A new table with only non-empty rows.
- */
-const filterNonEmpty = function (table) {
-  return table.filter(function (row) {
-    // Return only rows that are non-empty.
-    return row.some(cell => cell);
-  });
+  scorer: perseusScore.scoreSorter
 };
 
-function validateTable(userInput) {
-  const supplied = filterNonEmpty(userInput);
-  const hasEmptyCell = supplied.some(function (row) {
-    return row.some(function (cell) {
-      return cell === "";
-    });
-  });
-  if (hasEmptyCell || !supplied.length) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
-
-function scoreTable(userInput, rubric, strings) {
-  const validationResult = validateTable(userInput);
-  if (validationResult != null) {
-    return validationResult;
-  }
-  const supplied = filterNonEmpty(userInput);
-  const solution = filterNonEmpty(rubric.answers);
-  if (supplied.length !== solution.length) {
-    return {
-      type: "points",
-      earned: 0,
-      total: 1,
-      message: null
-    };
-  }
-  const createValidator = perseusScore.KhanAnswerTypes.number.createValidatorFunctional;
-  let message = null;
-  const allCorrect = solution.every(function (rowSolution) {
-    for (let i = 0; i < supplied.length; i++) {
-      const rowSupplied = supplied[i];
-      const correct = rowSupplied.every(function (cellSupplied, i) {
-        const cellSolution = rowSolution[i];
-        const validator = createValidator(cellSolution, {
-          simplify: true
-        });
-        const result = validator(cellSupplied);
-        if (result.message) {
-          message = result.message;
-        }
-        return result.correct;
-      });
-      if (correct) {
-        supplied.splice(i, 1);
-        return true;
-      }
-    }
-    return false;
-  });
-  return {
-    type: "points",
-    earned: allCorrect ? 1 : 0,
-    total: 1,
-    message
-  };
-}
-
 const {
   assert
 } = InteractiveUtil;
@@ -44782,7 +43000,7 @@ var Table$1 = {
   isLintable: true,
   // TODO(LEMS-2656): remove TS suppression
   // @ts-expect-error: Type UserInput is not assignable to type PerseusTableUserInput
-  scorer: scoreTable
+  scorer: perseusScore.scoreTable
 };
 
 const getPromptJSON = () => {
@@ -44967,7 +43185,7 @@ const init = function () {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus";
-const libVersion = "50.0.0";
+const libVersion = "51.0.0";
 perseusCore.addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {
@@ -46936,7 +45154,6 @@ const getValidWidgetIds = perseusItem => {
   return wonderStuffCore.keys(widgets).filter(id => isWidgetIdInContent(perseusItem, id));
 };
 
-const deepEq = Util.deepEq;
 function isRealJSONParse(jsonParse) {
   const randomPhrase = buildRandomPhrase();
   const randomHintPhrase = buildRandomPhrase();
@@ -46993,7 +45210,7 @@ function isRealJSONParse(jsonParse) {
   const testJSON = buildTestData(testingObject.replace(/"/g, '\\"'));
   const parsedTestJSON = jsonParse(testJSON);
   const parsedTestItemData = parsedTestJSON.data.assessmentItem.item.itemData;
-  return deepEq(parsedTestItemData, testingObject);
+  return perseusCore.approximateDeepEqual(parsedTestItemData, testingObject);
 }
 function buildRandomString() {
   let capitalize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
@@ -47200,7 +45417,9 @@ function object(schema) {
     for (const [prop, propParser] of Object.entries(schema)) {
       const result = propParser(rawValue[prop], ctx.forSubtree(prop));
       if (isSuccess(result)) {
-        ret[prop] = result.value;
+        if (result.value !== undefined || prop in rawValue) {
+          ret[prop] = result.value;
+        }
       } else {
         mismatches.push(...result.detail);
       }
@@ -48819,7 +47038,6 @@ const EditorJsonify = {
  * Main entry point
  */
 const GrapherUtil = {
-  allTypes,
   DEFAULT_GRAPHER_PROPS,
   chooseType,
   defaultPlotProps,
@@ -48887,7 +47105,6 @@ exports.getAngleCoords = getAngleCoords;
 exports.getAnswerFromUserInput = getAnswerFromUserInput;
 exports.getAnswersFromWidgets = getAnswersFromWidgets;
 exports.getCircleCoords = getCircleCoords;
-exports.getClockwiseAngle = getClockwiseAngle;
 exports.getCorrectAnswerForWidgetId = getCorrectAnswerForWidgetId;
 exports.getImagesWithoutAltData = getImagesWithoutAltData;
 exports.getInteractiveBoxFromSizeClass = getInteractiveBoxFromSizeClass;