@khanacademy/perseus 50.1.0 → 51.0.0

package/dist/es/index.js

@@ -1,7 +1,9 @@
 import * as KAS from '@khanacademy/kas';
 import { MathInputI18nContext, CursorContext, getKeyTranslator, createMathField, getCursorContext, DesktopKeypad, convertDotToTimesByLocale, mathQuillInstance, KeypadInput, KeypadType, KeyArray, keypadElementPropType } from '@khanacademy/math-input';
+import { PerseusError, Errors, getDecimalSeparator, approximateDeepEqual, pluck, mapObject, GrapherUtil as GrapherUtil$1, lockedFigureColors, lockedFigureFillStyles, approximateEqual, getMatrixSize, addLibraryVersionToPerseusDebug, lockedFigureColorNames, plotterPlotTypes, ItemExtras } from '@khanacademy/perseus-core';
 import * as PerseusLinter from '@khanacademy/perseus-linter';
 import { linterContextDefault, Rule } from '@khanacademy/perseus-linter';
+import { scoreExpression, KhanAnswerTypes, scoreInputNumber, inputNumberAnswerTypes, scoreNumericInput, scoreRadio, scoreCategorizer, scoreCSProgram, scoreDropdown, scoreGrapher, scoreIframe, scoreInteractiveGraph, scoreLabelImage, scoreLabelImageMarker, scoreMatcher, scoreMatrix, scoreNumberLine, scoreOrderer, scorePlotter, scoreSorter, scoreTable } from '@khanacademy/perseus-score';
 import { View, RenderStateRoot, Id, useOnMountEffect, useLatestRef, Text as Text$2 } from '@khanacademy/wonder-blocks-core';
 import Tooltip$1 from '@khanacademy/wonder-blocks-tooltip';
 import { HeadingMedium, LabelSmall, LabelLarge, Body, LabelMedium } from '@khanacademy/wonder-blocks-typography';
@@ -12,17 +14,15 @@ import React__default, { useContext, useState, useEffect, useRef, createContext,
 import * as ReactDOM from 'react-dom';
 import ReactDOM__default from 'react-dom';
 import _, { debounce as debounce$1 } from 'underscore';
-import { ErrorCodes, KhanAnswerTypes } from '@khanacademy/perseus-score';
 import Clickable from '@khanacademy/wonder-blocks-clickable';
 import { Popover, PopoverContentCore, PopoverContent } from '@khanacademy/wonder-blocks-popover';
 import { color, spacing, font } from '@khanacademy/wonder-blocks-tokens';
 import $ from 'jquery';
 import { v4 } from 'uuid';
-import { PerseusError, Errors, pluck, mapObject, lockedFigureColors, lockedFigureFillStyles, addLibraryVersionToPerseusDebug, lockedFigureColorNames, plotterPlotTypes, ItemExtras } from '@khanacademy/perseus-core';
 import PropTypes from 'prop-types';
 import { entries, UnreachableCaseError, keys } from '@khanacademy/wonder-stuff-core';
 import { CircularSpinner } from '@khanacademy/wonder-blocks-progress-spinner';
-import { point, KhanMath, number as number$1, vector as vector$1, sum as sum$1, line } from '@khanacademy/kmath';
+import { point, KhanMath, number as number$1, vector as vector$3, line, geometry, angles, coefficients } from '@khanacademy/kmath';
 import SimpleMarkdown from '@khanacademy/simple-markdown';
 import { pureMarkdownRules } from '@khanacademy/pure-markdown';
 import { TextField } from '@khanacademy/wonder-blocks-form';
@@ -33,7 +33,7 @@ import { OptionItem, SingleSelect, MultiSelect } from '@khanacademy/wonder-block
 import caretDown from '@phosphor-icons/core/regular/caret-down.svg';
 import caretUp from '@phosphor-icons/core/regular/caret-up.svg';
 import debounce$2 from 'lodash.debounce';
-import { vec, Coordinates, Ellipse, Plot as Plot$3, Line as Line$4, Point as Point$2, Polygon, Text as Text$1, useTransformContext, Polyline, Mafs } from 'mafs';
+import { vec, Coordinates, Ellipse, Plot as Plot$2, Line as Line$4, Point as Point$2, Polygon, Text as Text$1, useTransformContext, Polyline, Mafs } from 'mafs';
 import { PhosphorIcon } from '@khanacademy/wonder-blocks-icon';
 import questionIcon from '@phosphor-icons/core/regular/question.svg';
 import { useDrag } from '@use-gesture/react';
@@ -231,7 +231,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.
 };
 
@@ -500,18 +508,59 @@ const mockStrings = {
     startingSideY,
     endingSideX,
     endingSideY
-  }) => `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}.`
+  }) => `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: ({
+    lineNumber,
+    point1X,
+    point1Y,
+    point2X,
+    point2Y
+  }) => `Line ${lineNumber} has two points, point 1 at ${point1X} comma ${point1Y} and point 2 at ${point2X} comma ${point2Y}.`,
+  srLinearSystemPoint: ({
+    lineNumber,
+    pointSequence,
+    x,
+    y
+  }) => `Point ${pointSequence} on line ${lineNumber} at ${x} comma ${y}.`,
+  srRayGraph: "A ray on a coordinate plane.",
+  srRayPoints: ({
+    point1X,
+    point1Y,
+    point2X,
+    point2Y
+  }) => `The endpoint is at ${point1X} comma ${point1Y} and the ray goes through point ${point2X} comma ${point2Y}.`,
+  srRayGrabHandle: ({
+    point1X,
+    point1Y,
+    point2X,
+    point2Y
+  }) => `Ray with endpoint ${point1X} comma ${point1Y} going through point ${point2X} comma ${point2Y}.`,
+  srRayEndpoint: ({
+    x,
+    y
+  }) => `Endpoint at ${x} comma ${y}.`,
+  srRayTerminalPoint: ({
+    x,
+    y
+  }) => `Through point at ${x} comma ${y}.`
   // The above strings are used for interactive graph SR descriptions.
 };
 
+// This type helps us make sure all error codes are mapped to strings
+
 const errorToString = {
-  [ErrorCodes.MISSING_PERCENT_ERROR]: strings.MISSING_PERCENT_ERROR,
-  [ErrorCodes.NEEDS_TO_BE_SIMPLIFIED_ERROR]: strings.NEEDS_TO_BE_SIMPLFIED_ERROR,
-  [ErrorCodes.APPROXIMATED_PI_ERROR]: strings.APPROXIMATED_PI_ERROR,
-  [ErrorCodes.EXTRA_SYMBOLS_ERROR]: strings.EXTRA_SYMBOLS_ERROR,
-  [ErrorCodes.WRONG_CASE_ERROR]: strings.WRONG_CASE_ERROR,
-  [ErrorCodes.WRONG_LETTER_ERROR]: strings.WRONG_LETTER_ERROR,
-  [ErrorCodes.MULTIPLICATION_SIGN_ERROR]: strings.MULTIPLICATION_SIGN_ERROR
+  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) {
@@ -1455,205 +1504,6 @@ const getPromptJSON$t = (renderProps, userInput) => {
   };
 };
 
-/**
- *  Get the character used for separating decimals.
- */
-const getDecimalSeparator = locale => {
-  var _match$;
-  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$ = match == null ? void 0 : match[0]) != null ? _match$ : ".";
-  }
-};
-
-// 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 = _.clone(rubric);
-  _.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.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", Errors.InvalidInput, {
-        loggedMetadata: {
-          rubric: JSON.stringify(rubric)
-        }
-      });
-      return null;
-    }
-    return KhanAnswerTypes.expression.createValidatorFunctional(expression.expr, _({}).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",
@@ -2414,56 +2264,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 || _.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);
-    }) && _.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
  *
@@ -2680,15 +2480,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,
@@ -2709,8 +2500,6 @@ const Util = {
   gridStepFromTickStep,
   tickStepFromNumTicks,
   constrainedTickStepsFromTickSteps,
-  eq: eq$4,
-  deepEq: deepEq$7,
   parseQueryString,
   updateQueryString: updateQueryString$2,
   strongEncodeURIComponent,
@@ -2728,8 +2517,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
@@ -8277,7 +8082,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];
   }
@@ -8436,7 +8241,7 @@ class Graphie$1 {
         // See: http://stackoverflow.com/questions/13932704/how-to-draw-sine-waves-with-svg-js
         const xCoords = [x0, x0 * 2 / 3 + x1 * 1 / 3, x0 * 1 / 3 + x1 * 2 / 3, x1];
         const yCoords = [computeSine(x0), computeSine(x0) + computeDerivative(x0) * (x1 - x0) / 3, computeSine(x1) - computeDerivative(x1) * (x1 - x0) / 3, computeSine(x1)];
-        const points = vector$1.zip(xCoords, yCoords);
+        const points = vector$3.zip(xCoords, yCoords);
         return points.map(this.scalePoint);
       };
 
@@ -8769,8 +8574,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.
@@ -8875,7 +8680,7 @@ class Graphie$1 {
     // Apply padding and offset to points to convert from
     // canvas coordinates to pixel coordinates relative to bounding box
     points = points.map(function (point) {
-      return vector$1.add(vector$1.subtract(point, topLeftOfBoundingBox), vector$1.scale(padding, 0.5));
+      return vector$3.add(vector$3.subtract(point, topLeftOfBoundingBox), vector$3.scale(padding, 0.5));
     });
 
     // Calculate <div> dimensions
@@ -8939,8 +8744,8 @@ class Graphie$1 {
     const extraOffset = [Math.min(start[0], end[0]), Math.min(start[1], end[1])];
 
     // Apply padding and offset to start, end points
-    start = vector$1.add(vector$1.subtract(start, extraOffset), vector$1.scale(padding, 0.5));
-    end = vector$1.add(vector$1.subtract(end, extraOffset), vector$1.scale(padding, 0.5));
+    start = vector$3.add(vector$3.subtract(start, extraOffset), vector$3.scale(padding, 0.5));
+    end = vector$3.add(vector$3.subtract(end, extraOffset), vector$3.scale(padding, 0.5));
 
     // Calculate <div> dimensions
     const left = extraOffset[0] - padding[0] / 2;
@@ -9896,10 +9701,10 @@ const getClipPoint = function getClipPoint(graph, coord, angle) {
   // shoot a point off into the distance ...
   const distance = xExtent + yExtent;
   // we need to scale the point according to the scale of the axes
-  const angleVec = graph.unscaleVector(vector$1.cartFromPolarDeg(1, angle));
-  const distVec = vector$1.scale(vector$1.normalize(angleVec), distance);
-  const farCoord = vector$1.add(coord, distVec);
-  const scaledAngle = vector$1.polarDegFromCart(angleVec)[1];
+  const angleVec = graph.unscaleVector(vector$3.cartFromPolarDeg(1, angle));
+  const distVec = vector$3.scale(vector$3.normalize(angleVec), distance);
+  const farCoord = vector$3.add(coord, distVec);
+  const scaledAngle = vector$3.polarDegFromCart(angleVec)[1];
   // ... and then bring it back
   const clipPoint = graph.constrainToBoundsOnAngle(farCoord, 4, scaledAngle * Math.PI / 180);
   return clipPoint;
@@ -9950,7 +9755,7 @@ class WrappedDrawing {
     return this.visibleShape[0];
   }
   moveTo(point) {
-    const delta = vector$1.subtract(this.graphie.scalePoint(point), this.graphie.scalePoint(this.initialPoint));
+    const delta = vector$3.subtract(this.graphie.scalePoint(point), this.graphie.scalePoint(this.initialPoint));
     const do3dTransform = InteractiveUtil.getCanUse3dTransform();
     const transformation = "translateX(" + delta[0] + "px) " + "translateY(" + delta[1] + "px)" + (do3dTransform ? " translateZ(0)" : "");
     this.transform(transformation);
@@ -10005,9 +9810,9 @@ class Arrowhead$1 extends WrappedPath {
     const center = [0.75, 0];
     const points = [[-3, 4], [-2.75, 2.5], [0, 0.25], center, [0, -0.25], [-2.75, -2.5], [-3, -4]].map(point => {
       // Scale points by `Arrowhead.scale` around `center`
-      const pv = vector$1.subtract(point, center);
-      const pvScaled = vector$1.scale(pv, Arrowhead$1.scale);
-      return vector$1.add(center, pvScaled);
+      const pv = vector$3.subtract(point, center);
+      const pvScaled = vector$3.scale(pv, Arrowhead$1.scale);
+      return vector$3.add(center, pvScaled);
     });
     const unscaledPoints = points.map(graphie.unscalePoint);
     super(graphie, unscaledPoints, {
@@ -10078,7 +9883,7 @@ class WrappedEllipse extends WrappedDrawing {
       const wrapper = this.wrapper;
       wrapper.style.filter = filter;
       this.moveTo = function (point) {
-        const delta = vector$1.subtract(this.graphie.scalePoint(point), this.graphie.scalePoint(this.initialPoint));
+        const delta = vector$3.subtract(this.graphie.scalePoint(point), this.graphie.scalePoint(this.initialPoint));
         const do3dTransform = InteractiveUtil.getCanUse3dTransform();
         const transform = "translateX(" + Math.round(delta[0]) + "px) " + "translateY(" + Math.round(delta[1]) + "px)" + (do3dTransform ? " translateZ(0)" : "");
         this.transform(transform);
@@ -10147,10 +9952,10 @@ class WrappedLine extends WrappedDrawing {
     const scaledEnd = this.graphie.scalePoint(end);
 
     // Compute transformation parameters
-    const polarDiff = vector$1.polarDegFromCart(vector$1.subtract(scaledEnd, scaledStart));
+    const polarDiff = vector$3.polarDegFromCart(vector$3.subtract(scaledEnd, scaledStart));
     const lineLength = polarDiff[0];
     const angle = KhanMath.bound(polarDiff[1]);
-    const delta = vector$1.subtract(scaledStart, this.initialPoint);
+    const delta = vector$3.subtract(scaledStart, this.initialPoint);
     const scale = KhanMath.bound(lineLength / this.initialLength);
 
     // Construct and apply transformation string
@@ -10160,260 +9965,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 = _.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 (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 _.map(_.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 = _.zip(points, points.slice(1).concat(points.slice(0, 1)));
-  const areas = _.map(segments, function (segment) {
-    const p1 = segment[0];
-    const p2 = segment[1];
-    return (p2[0] - p1[0]) * (p2[1] + p1[1]);
-  });
-  return sum$1(areas) > 0;
-}
-function magnitude(v) {
-  return Math.sqrt(_.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 _.reduce(_.zip(a, b), function (memo, pair) {
-    return memo + pair[0] * pair[1];
-  }, 0);
-}
-function sideLengths(coords) {
-  const segments = _.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 = _.zip(rotate(coords, -1), coords, rotate(coords, 1));
-  const offsets = _.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 = _.reduce(offsets, function (memo, arg) {
-    return memo + arg;
-  }, 0);
-  return _.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 = _.zip(sides1, sides);
-      const factors = _.map(sidePairs, function (pair) {
-        return pair[0] / pair[1];
-      });
-      const same = _.all(factors, function (factor) {
-        return eq$3(factors[0], factor);
-      });
-      const congruentEnough = _.all(sidePairs, function (pair) {
-        return number$1.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([amplitude, angularFrequency, phase, verticalOffset]) {
-  // 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
+} = geometry;
 function scaledDistanceFromAngle(angle) {
   const a = 3.51470560176242 * 20;
   const b = 0.5687298702748785 * 20;
@@ -10482,10 +10038,10 @@ _.extend(GraphUtils.Graphie.prototype, {
     let sRadius = sPadding + scaledDistanceFromAngle(angle);
     const temp = [];
     if (Math.abs(angle - 90) < 1e-9 && options.showRightAngleMarker) {
-      const v1 = vector$1.add(sVertex, scaledPolarDeg(sRadius, startAngle));
-      const v2 = vector$1.add(sVertex, scaledPolarDeg(sRadius, endAngle));
+      const v1 = vector$3.add(sVertex, scaledPolarDeg(sRadius, startAngle));
+      const v2 = vector$3.add(sVertex, scaledPolarDeg(sRadius, endAngle));
       sRadius *= Math.SQRT2;
-      const v3 = vector$1.add(sVertex, scaledPolarDeg(sRadius, halfAngle));
+      const v3 = vector$3.add(sVertex, scaledPolarDeg(sRadius, halfAngle));
       _.each([v1, v2], function (v) {
         // @ts-expect-error - TS2345 - Argument of type 'any' is not assignable to parameter of type 'never'.
         temp.push(graphie.scaledPath([v, v3], options.style));
@@ -10506,7 +10062,7 @@ _.extend(GraphUtils.Graphie.prototype, {
         text = text.replace(match[0], KhanMath.toFixedApprox(angle, precision) + "^{\\circ}");
       }
       const sOffset = scaledPolarDeg(sRadius + 15, halfAngle);
-      const sPosition = vector$1.add(sVertex, sOffset);
+      const sPosition = vector$3.add(sVertex, sOffset);
       const position = graphie.unscalePoint(sPosition);
 
       // Reuse label if possible
@@ -10557,7 +10113,7 @@ _.extend(GraphUtils.Graphie.prototype, {
         const sOffset = sSpacing * (i - (n - 1) / 2);
         const sOffsetVector = scaledPolarRad(sOffset, parallelAngle);
         const sHeightVector = scaledPolarRad(sHeight, perpendicularAngle);
-        const sPath = [vector$1.add(sMidpoint, sOffsetVector, sHeightVector), vector$1.add(sMidpoint, sOffsetVector, reverseVector(sHeightVector))];
+        const sPath = [vector$3.add(sMidpoint, sOffsetVector, sHeightVector), vector$3.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));
@@ -10582,9 +10138,9 @@ _.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 = vector$1.add(sMidpoint, sOffsetVector);
+        const sEnd = vector$3.add(sMidpoint, sOffsetVector);
 
         // @ts-expect-error - TS2345 - Argument of type 'any' is not assignable to parameter of type 'never'.
         temp.push(graphie.scaledPath([sStart, sEnd], style));
@@ -10600,7 +10156,7 @@ _.extend(GraphUtils.Graphie.prototype, {
       }
       const sOffset = 20;
       const sOffsetVector = scaledPolarRad(sOffset, perpendicularAngle);
-      const sPosition = vector$1.add(sMidpoint, sOffsetVector);
+      const sPosition = vector$3.add(sMidpoint, sOffsetVector);
       const position = graphie.unscalePoint(sPosition);
 
       // Reuse label if possible
@@ -10658,7 +10214,7 @@ _.extend(GraphUtils.Graphie.prototype, {
     }
     const sRadius = 10 + scaledDistanceFromAngle(360 - angle);
     const sOffsetVector = scaledPolarDeg(sRadius, halfAngle);
-    const sPosition = vector$1.add(sVertex, sOffsetVector);
+    const sPosition = vector$3.add(sVertex, sOffsetVector);
     const position = graphie.unscalePoint(sPosition);
 
     // Reuse label if possible
@@ -10934,7 +10490,7 @@ _.extend(GraphUtils.Graphie.prototype, {
 
         // Adjust the target coordinate by accounting for the gesture's
         // offset.
-        let coord = vector$1.add(graph.getMouseCoord(event), offset);
+        let coord = vector$3.add(graph.getMouseCoord(event), offset);
         coord = applySnapAndConstraints(coord);
         let coordX = coord[0];
         let coordY = coord[1];
@@ -11045,7 +10601,7 @@ _.extend(GraphUtils.Graphie.prototype, {
           const startCoord = movablePoint.coord;
           const startMouseCoord = graph.getMouseCoord(event);
           const isMouse = !("ontouchstart" in window);
-          const touchOffset = isMouse ? [0, 0] : vector$1.subtract(startCoord, startMouseCoord);
+          const touchOffset = isMouse ? [0, 0] : vector$3.subtract(startCoord, startMouseCoord);
           movablePoint.grab(touchOffset);
         }
       });
@@ -11265,17 +10821,17 @@ _.extend(GraphUtils.Graphie.prototype, {
       const getScaledAngle = function getScaledAngle(line) {
         const scaledA = line.graph.scalePoint(line.coordA);
         const scaledZ = line.graph.scalePoint(line.coordZ);
-        return vector$1.polarDegFromCart(vector$1.subtract(scaledZ, scaledA))[1];
+        return vector$3.polarDegFromCart(vector$3.subtract(scaledZ, scaledA))[1];
       };
       const getClipPoint = function getClipPoint(graph, coord, angle) {
         graph = lineSegment.graph;
         const xExtent = graph.range[0][1] - graph.range[0][0];
         const yExtent = graph.range[1][1] - graph.range[1][0];
         const distance = xExtent + yExtent;
-        const angleVec = graph.unscaleVector(vector$1.cartFromPolarDeg(1, angle));
-        const distVec = vector$1.scale(vector$1.normalize(angleVec), distance);
-        const farCoord = vector$1.add(coord, distVec);
-        const scaledAngle = vector$1.polarDegFromCart(angleVec)[1];
+        const angleVec = graph.unscaleVector(vector$3.cartFromPolarDeg(1, angle));
+        const distVec = vector$3.scale(vector$3.normalize(angleVec), distance);
+        const farCoord = vector$3.add(coord, distVec);
+        const scaledAngle = vector$3.polarDegFromCart(angleVec)[1];
         const clipPoint = graph.constrainToBoundsOnAngle(farCoord, 4, scaledAngle * Math.PI / 180);
         return clipPoint;
       };
@@ -11649,7 +11205,7 @@ _.extend(GraphUtils.Graphie.prototype, {
       // Temporary objects
       _.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) {
@@ -12177,8 +11733,8 @@ _.extend(GraphUtils.Graphie.prototype, {
     const drawRotateHandle = function drawRotateHandle(graphie, center, radius, halfWidth, lengthAngle, angle, interacting) {
       const getRotateHandlePoint = function getRotateHandlePoint(offset, distanceFromArrowMidline) {
         const distFromRotationCenter = radius + distanceFromArrowMidline;
-        const vec = vector$1.cartFromPolarDeg(distFromRotationCenter, angle + offset);
-        const absolute = vector$1.add(center, vec);
+        const vec = vector$3.cartFromPolarDeg(distFromRotationCenter, angle + offset);
+        const absolute = vector$3.add(center, vec);
         const pixels = graphie.scalePoint(absolute);
         return pixels[0] + "," + pixels[1];
       };
@@ -12218,7 +11774,7 @@ _.extend(GraphUtils.Graphie.prototype, {
         };
       }
       const rotateHandle = graph.addMovablePoint({
-        coord: point.addVector(rotatePoint.coord, vector$1.cartFromPolarDeg(radius, options.angleDeg || 0)),
+        coord: point.addVector(rotatePoint.coord, vector$3.cartFromPolarDeg(radius, options.angleDeg || 0)),
         constraints: {
           fixedDistance: {
             dist: radius,
@@ -12243,8 +11799,8 @@ _.extend(GraphUtils.Graphie.prototype, {
           return; // Don't draw anything!
         }
 
-        const handleVec = vector$1.subtract(handleCoord, rotatePoint.coord);
-        const handlePolar = vector$1.polarDegFromCart(handleVec);
+        const handleVec = vector$3.subtract(handleCoord, rotatePoint.coord);
+        const handlePolar = vector$3.polarDegFromCart(handleVec);
         const angle = handlePolar[1];
         if (drawnRotateHandle) {
           drawnRotateHandle.remove();
@@ -12256,8 +11812,8 @@ _.extend(GraphUtils.Graphie.prototype, {
       // the rotationHandle as well, or it will end up out
       // of sync
       $(rotatePoint).on("move." + id, function () {
-        const delta = vector$1.subtract(rotatePoint.coord, rotatePointPrevCoord);
-        rotateHandle.setCoord(vector$1.add(rotateHandle.coord, delta));
+        const delta = vector$3.subtract(rotatePoint.coord, rotatePointPrevCoord);
+        rotateHandle.setCoord(vector$3.add(rotateHandle.coord, delta));
         redrawRotateHandle(rotateHandle.coord);
         rotatePointPrevCoord = rotatePoint.coord;
         rotateHandle.constraints.fixedDistance.point = rotatePoint;
@@ -12272,8 +11828,8 @@ _.extend(GraphUtils.Graphie.prototype, {
         }
         let coord = [x, y];
         if (options.onMove) {
-          const oldPolar = vector$1.polarDegFromCart(vector$1.subtract(rotateHandlePrevCoord, rotatePoint.coord));
-          const newPolar = vector$1.polarDegFromCart(vector$1.subtract(coord, rotatePoint.coord));
+          const oldPolar = vector$3.polarDegFromCart(vector$3.subtract(rotateHandlePrevCoord, rotatePoint.coord));
+          const newPolar = vector$3.polarDegFromCart(vector$3.subtract(coord, rotatePoint.coord));
           const oldAngle = oldPolar[1];
           const newAngle = newPolar[1];
           let result = options.onMove(newAngle, oldAngle);
@@ -12281,7 +11837,7 @@ _.extend(GraphUtils.Graphie.prototype, {
             if (result === false) {
               result = oldAngle;
             }
-            coord = vector$1.add(rotatePoint.coord, vector$1.cartFromPolarDeg(oldPolar[0], result));
+            coord = vector$3.add(rotatePoint.coord, vector$3.cartFromPolarDeg(oldPolar[0], result));
           }
         }
         redrawRotateHandle(coord);
@@ -12292,8 +11848,8 @@ _.extend(GraphUtils.Graphie.prototype, {
         isRotating = false;
         redrawRotateHandle(rotateHandle.coord);
         if (options.onMoveEnd) {
-          const oldPolar = vector$1.polarDegFromCart(vector$1.subtract(rotateHandleStartCoord, rotatePoint.coord));
-          const newPolar = vector$1.polarDegFromCart(vector$1.subtract(rotateHandle.coord, rotatePoint.coord));
+          const oldPolar = vector$3.polarDegFromCart(vector$3.subtract(rotateHandleStartCoord, rotatePoint.coord));
+          const newPolar = vector$3.polarDegFromCart(vector$3.subtract(rotateHandle.coord, rotatePoint.coord));
           options.onMoveEnd(newPolar[1], oldPolar[1]);
         }
       };
@@ -12338,14 +11894,14 @@ _.extend(GraphUtils.Graphie.prototype, {
       if (point.equal(lineCoords[0], lineCoords[1])) {
         lineCoords = [lineCoords[0], point.addVector(lineCoords[0], [1, 1])];
       }
-      const lineDirection = vector$1.normalize(vector$1.subtract(lineCoords[1], lineCoords[0]));
-      const lineVec = vector$1.scale(lineDirection, size / 2);
-      const centerVec = vector$1.scale(lineDirection, distanceFromCenter);
-      const leftCenterVec = vector$1.rotateDeg(centerVec, 90);
-      const rightCenterVec = vector$1.rotateDeg(centerVec, -90);
-      const negLineVec = vector$1.negate(lineVec);
-      const leftVec = vector$1.rotateDeg(lineVec, 90);
-      const rightVec = vector$1.rotateDeg(lineVec, -90);
+      const lineDirection = vector$3.normalize(vector$3.subtract(lineCoords[1], lineCoords[0]));
+      const lineVec = vector$3.scale(lineDirection, size / 2);
+      const centerVec = vector$3.scale(lineDirection, distanceFromCenter);
+      const leftCenterVec = vector$3.rotateDeg(centerVec, 90);
+      const rightCenterVec = vector$3.rotateDeg(centerVec, -90);
+      const negLineVec = vector$3.negate(lineVec);
+      const leftVec = vector$3.rotateDeg(lineVec, 90);
+      const rightVec = vector$3.rotateDeg(lineVec, -90);
       const leftCenter = point.addVectors(buttonCoord, leftCenterVec);
       const rightCenter = point.addVectors(buttonCoord, rightCenterVec);
       const leftCoord1 = point.addVectors(buttonCoord, leftCenterVec, lineVec, leftVec);
@@ -12472,7 +12028,7 @@ _.extend(GraphUtils.Graphie.prototype, {
     // @ts-expect-error - TS2350 - Only a void function can be called with the 'new' keyword.
     return new Ruler(this, options || {});
   },
-  addPoints: vector$1.add
+  addPoints: vector$3.add
 });
 function Protractor$1(graph, center) {
   // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
@@ -12746,10 +12302,10 @@ function Ruler(graphie, options) {
   });
   const width = options.units * options.pixelsPerUnit;
   const height = 50;
-  const leftBottom = graphie.unscalePoint(vector$1.subtract(graphie.scalePoint(options.center), vector$1.scale([width, -height], 0.5)));
+  const leftBottom = graphie.unscalePoint(vector$3.subtract(graphie.scalePoint(options.center), vector$3.scale([width, -height], 0.5)));
   const graphieUnitsPerUnit = options.pixelsPerUnit / graphie.scale[0];
   const graphieUnitsHeight = height / graphie.scale[0];
-  const rightTop = vector$1.add(leftBottom, [options.units * graphieUnitsPerUnit, graphieUnitsHeight]);
+  const rightTop = vector$3.add(leftBottom, [options.units * graphieUnitsPerUnit, graphieUnitsHeight]);
   const tickHeight = 1.0;
   let tickHeightMap;
   if (options.ticksPerUnit === 10) {
@@ -12896,11 +12452,11 @@ function Ruler(graphie, options) {
       const dy = rightBottomHandle.coord[1] - y;
       const dx = rightBottomHandle.coord[0] - x;
       const angle = Math.atan2(dy, dx) * 180 / Math.PI;
-      const center = vector$1.scale(vector$1.add([x, y], rightBottomHandle.coord), 0.5);
+      const center = vector$3.scale(vector$3.add([x, y], rightBottomHandle.coord), 0.5);
       const scaledCenter = graphie.scalePoint(center);
-      const oldCenter = vector$1.scale(vector$1.add(leftBottomHandle.coord, rightBottomHandle.coord), 0.5);
+      const oldCenter = vector$3.scale(vector$3.add(leftBottomHandle.coord, rightBottomHandle.coord), 0.5);
       const scaledOldCenter = graphie.scalePoint(oldCenter);
-      const diff = vector$1.subtract(scaledCenter, scaledOldCenter);
+      const diff = vector$3.subtract(scaledCenter, scaledOldCenter);
       set.rotate(-angle, scaledOldCenter[0], scaledOldCenter[1]);
       set.translate(diff[0], diff[1]);
     }
@@ -12923,11 +12479,11 @@ function Ruler(graphie, options) {
       const dy = y - leftBottomHandle.coord[1];
       const dx = x - leftBottomHandle.coord[0];
       const angle = Math.atan2(dy, dx) * 180 / Math.PI;
-      const center = vector$1.scale(vector$1.add([x, y], leftBottomHandle.coord), 0.5);
+      const center = vector$3.scale(vector$3.add([x, y], leftBottomHandle.coord), 0.5);
       const scaledCenter = graphie.scalePoint(center);
-      const oldCenter = vector$1.scale(vector$1.add(leftBottomHandle.coord, rightBottomHandle.coord), 0.5);
+      const oldCenter = vector$3.scale(vector$3.add(leftBottomHandle.coord, rightBottomHandle.coord), 0.5);
       const scaledOldCenter = graphie.scalePoint(oldCenter);
-      const diff = vector$1.subtract(scaledCenter, scaledOldCenter);
+      const diff = vector$3.subtract(scaledCenter, scaledOldCenter);
       set.rotate(-angle, scaledOldCenter[0], scaledOldCenter[1]);
       set.translate(diff[0], diff[1]);
     }
@@ -13070,12 +12626,12 @@ _.extend(MovableAngle.prototype, {
     points[1].onMove = function (x, y) {
       const oldVertex = points[1].coord;
       const newVertex = [x, y];
-      const delta = vector$1.add(newVertex, reverseVector(oldVertex));
+      const delta = vector$3.add(newVertex, reverseVector$1(oldVertex));
       let valid = true;
       const newPoints = {};
       _.each([0, 2], function (i) {
         const oldPoint = points[i].coord;
-        let newPoint = vector$1.add(oldPoint, delta);
+        let newPoint = vector$3.add(oldPoint, delta);
         let angle = GraphUtils.findAngleDeprecated(newVertex, newPoint);
         angle *= Math.PI / 180;
         newPoint = graphie.constrainToBoundsOnAngle(newPoint, 10, angle);
@@ -13112,7 +12668,7 @@ _.extend(MovableAngle.prototype, {
           let angle = GraphUtils.findAngleDeprecated(newPoint, vertex);
           angle = Math.round((angle - snapOffset) / snap) * snap + snapOffset;
           const distance = GraphUtils.getDistance(newPoint, vertex);
-          return vector$1.add(vertex, polar$1(distance, angle));
+          return vector$3.add(vertex, polar$2(distance, angle));
         }
         return true;
       };
@@ -13263,7 +12819,6 @@ _.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
@@ -13360,7 +12915,7 @@ const createSimpleClass = function createSimpleClass(addFunction) {
       this._prevProps = this.props;
     },
     modify: function (graphie) {
-      if (!deepEq$5(this.props, this._prevProps)) {
+      if (!approximateDeepEqual(this.props, this._prevProps)) {
         this.remove();
         this.add(graphie);
         this._prevProps = this.props;
@@ -13721,7 +13276,7 @@ function getEventName$1(key) {
 const getScaledAngle = function getScaledAngle(line) {
   const scaledA = line.graphie.scalePoint(line.coord(0));
   const scaledZ = line.graphie.scalePoint(line.coord(1));
-  return vector$1.polarDegFromCart(vector$1.subtract(scaledZ, scaledA))[1];
+  return vector$3.polarDegFromCart(vector$3.subtract(scaledZ, scaledA))[1];
 };
 
 /**
@@ -13880,11 +13435,11 @@ const constraints$2 = {
       if (snap === null) {
         return true;
       }
-      let delta = vector$1.subtract(coord, prevCoord);
+      let delta = vector$3.subtract(coord, prevCoord);
       // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
       snap = snap || this.graphie.snap;
       delta = point.roundTo(delta, snap);
-      return vector$1.add(prevCoord, delta);
+      return vector$3.add(prevCoord, delta);
     };
   },
   bound: function (range, snap, paddingPx) {
@@ -13898,7 +13453,7 @@ const constraints$2 = {
     return function (coord, prevCoord) {
       // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
       const graphie = this.graphie;
-      const delta = vector$1.subtract(coord, prevCoord);
+      const delta = vector$3.subtract(coord, prevCoord);
       range = range || graphie.range;
       // A null snap means no snap; an undefined snap means
       // default to graphie's
@@ -13918,8 +13473,8 @@ const constraints$2 = {
       const deltaBounds = _.map(
       // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
       this.coords(), function (coord, i) {
-        const max = vector$1.subtract(absoluteUpper, coord);
-        const min = vector$1.subtract(absoluteLower, coord);
+        const max = vector$3.subtract(absoluteUpper, coord);
+        const min = vector$3.subtract(absoluteLower, coord);
         return [min, max];
       });
 
@@ -13933,7 +13488,7 @@ const constraints$2 = {
         const deltaY = Math.max(lower[1], Math.min(upper[1], delta[1]));
         return [deltaX, deltaY];
       }, delta);
-      return vector$1.add(prevCoord, boundedDelta);
+      return vector$3.add(prevCoord, boundedDelta);
     };
   }
 };
@@ -13942,10 +13497,10 @@ const constraints$2 = {
 constraints$2.standard = null;
 const onMove$1 = {
   updatePoints: function (coord, prevCoord) {
-    const actualDelta = vector$1.subtract(coord, prevCoord);
+    const actualDelta = vector$3.subtract(coord, prevCoord);
     // @ts-expect-error - TS2339 - Property 'state' does not exist on type '{ readonly updatePoints: (coord: Coord, prevCoord: Coord) => void; }'.
     _.each(this.state.points, function (point) {
-      point.setCoord(vector$1.add(point.coord(), actualDelta));
+      point.setCoord(vector$3.add(point.coord(), actualDelta));
     });
   }
 };
@@ -14107,9 +13662,9 @@ _.extend(MovableLine$4.prototype, {
         self._fireEvent(self.state.onMoveStart, self.coord(0), self.coord(0));
       },
       onMove: function (mouseCoord, prevMouseCoord) {
-        const delta = vector$1.subtract(mouseCoord, prevMouseCoord);
-        self._totalDelta = vector$1.add(self._totalDelta, delta);
-        let refCoord = vector$1.add(self._initialRefCoord, self._totalDelta);
+        const delta = vector$3.subtract(mouseCoord, prevMouseCoord);
+        self._totalDelta = vector$3.add(self._totalDelta, delta);
+        let refCoord = vector$3.add(self._initialRefCoord, self._totalDelta);
         refCoord = self._applyConstraints(refCoord, self._prevRefCoord);
         if (refCoord === false) {
           return;
@@ -14621,7 +14176,7 @@ class MovablePoint$5 {
         // touch-based interaction.
         if (state.touchOffset == null) {
           const isMouse = !("ontouchstart" in window);
-          state.touchOffset = isMouse ? [0, 0] : vector$1.subtract(startCoord, startMouseCoord);
+          state.touchOffset = isMouse ? [0, 0] : vector$3.subtract(startCoord, startMouseCoord);
         }
         const svgElem = state.visibleShape.wrapper;
         if (state.shadow) {
@@ -14648,7 +14203,7 @@ class MovablePoint$5 {
         self.draw();
       },
       onMove: (mouseCoord, prevMouseCoord) => {
-        const transformedCoord = vector$1.add(mouseCoord, state.touchOffset);
+        const transformedCoord = vector$3.add(mouseCoord, state.touchOffset);
         self.moveTo(transformedCoord);
         if (state.showHairlines) {
           if (!this.state.outOfBounds) {
@@ -15041,7 +14596,7 @@ function sum(array) {
     return memo + arg;
   }, 0);
 }
-function clockwise(points) {
+function clockwise$2(points) {
   const segments = _.zip(points, points.slice(1).concat(points.slice(0, 1)));
   const areas = _.map(segments, function (segment) {
     const p1 = segment[0];
@@ -15107,7 +14662,7 @@ const draw$1 = {
     const graphie = this.graphie;
     const self = this;
     const coords = _.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
@@ -15278,7 +14833,7 @@ const constraints = {
     return function (coord, prevCoord) {
       // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
       const graphie = this.graphie;
-      const delta = vector$1.subtract(coord, prevCoord);
+      const delta = vector$3.subtract(coord, prevCoord);
       range = range || graphie.range;
       // A null snap means no snap; an undefined snap means
       // default to graphie's
@@ -15297,8 +14852,8 @@ const constraints = {
       // Calculate the bounds for the delta.
       // @ts-expect-error - TS2683 - 'this' implicitly has type 'any' because it does not have a type annotation.
       const deltaBounds = _.map(this.coords(), function (coord, i) {
-        const max = vector$1.subtract(absoluteUpper, coord);
-        const min = vector$1.subtract(absoluteLower, coord);
+        const max = vector$3.subtract(absoluteUpper, coord);
+        const min = vector$3.subtract(absoluteLower, coord);
         return [min, max];
       });
 
@@ -15312,7 +14867,7 @@ const constraints = {
         const deltaY = Math.max(lower[1], Math.min(upper[1], delta[1]));
         return [deltaX, deltaY];
       }, delta);
-      return vector$1.add(prevCoord, boundedDelta);
+      return vector$3.add(prevCoord, boundedDelta);
     };
   }
 };
@@ -15321,10 +14876,10 @@ const constraints = {
 constraints.standard = null;
 const onMove = {
   updatePoints: function (coord, prevCoord) {
-    const actualDelta = vector$1.subtract(coord, prevCoord);
+    const actualDelta = vector$3.subtract(coord, prevCoord);
     // @ts-expect-error - TS2339 - Property 'state' does not exist on type '{ readonly updatePoints: (coord: Coord, prevCoord: Coord) => undefined; }'.
     _.each(this.state.points, function (point) {
-      point.setCoord(vector$1.add(point.coord(), actualDelta));
+      point.setCoord(vector$3.add(point.coord(), actualDelta));
     });
   }
 };
@@ -15498,9 +15053,9 @@ _.extend(MovablePolygon.prototype, {
         self._fireEvent(self.state.onMoveStart, self.coord(0), self.coord(0));
       },
       onMove: function (mouseCoord, prevMouseCoord) {
-        const delta = vector$1.subtract(mouseCoord, prevMouseCoord);
-        self._totalDelta = vector$1.add(self._totalDelta, delta);
-        let refCoord = vector$1.add(self._initialRefCoord, self._totalDelta);
+        const delta = vector$3.subtract(mouseCoord, prevMouseCoord);
+        self._totalDelta = vector$3.add(self._totalDelta, delta);
+        let refCoord = vector$3.add(self._initialRefCoord, self._totalDelta);
         refCoord = self._applyConstraints(refCoord, self._prevRefCoord);
         if (refCoord === false) {
           return;
@@ -15815,7 +15370,7 @@ const Parabola = GraphieClasses.createClass({
     this.parabola.toFront();
   }
 });
-const Sinusoid$1 = GraphieClasses.createClass({
+const Sinusoid = GraphieClasses.createClass({
   displayName: "Sinusoid",
   movableProps: ["children"],
   add: function (graphie) {
@@ -15837,7 +15392,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) => {
@@ -15895,17 +15450,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 {
@@ -16147,7 +15701,7 @@ class Graphie extends React.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.", 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 (!approximateDeepEqual(this.props.options, prevProps.options) || !approximateDeepEqual(this.props.box, prevProps.box) || !approximateDeepEqual(this.props.range, prevProps.range)) {
       this._setupGraphie();
     }
     this._updateMovables();
@@ -20902,230 +20456,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 handler(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 handler(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 = 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;
@@ -21228,7 +20558,7 @@ class InputNumber extends React.Component {
       strings
     } = this.context;
     const type = this.props.answerType;
-    const forms = answerTypes[type].forms.split(/\s*,\s*/);
+    const forms = inputNumberAnswerTypes[type].forms.split(/\s*,\s*/);
     const examples = _.map(forms, form => formExamples$1[form](this.props, strings));
     return [strings.yourAnswer].concat(examples);
   }
@@ -21358,140 +20688,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) {
-  var _matchedAnswer$messag;
-  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 => {
-    var _answer$answerForms;
-    const stringAnswer = `${answer.value}`;
-
-    // Always validate against the provided answer forms (pi, decimal, etc.)
-    const validatorForms = [...((_answer$answerForms = answer.answerForms) != null ? _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 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 _extends({}, 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 == null ? void 0 : matchedAnswer.status) === "correct" ? matchedAnswer.score : {
-    empty: (matchedAnswer == null ? void 0 : matchedAnswer.status) === "ungraded",
-    correct: (matchedAnswer == null ? void 0 : matchedAnswer.status) === "correct",
-    message: (_matchedAnswer$messag = matchedAnswer == null ? void 0 : matchedAnswer.message) != null ? _matchedAnswer$messag : 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,
@@ -25479,72 +24675,6 @@ const styles$o = 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.Component {
@@ -25650,7 +24780,7 @@ class Radio$1 extends React.Component {
         choiceStates
       } = this.props;
       if (choiceStates) {
-        const score = scoreRadio(this.getUserInput(), rubric, this.context.strings);
+        const score = scoreRadio(this.getUserInput(), rubric);
         const widgetCorrect = score.type === "points" && score.total === score.earned;
         const newStates = choiceStates.map(state => _extends({}, state, {
           highlighted: state.selected,
@@ -26037,44 +25167,6 @@ function getCategorizerPublicWidgetOptions(options) {
   };
 }
 
-/**
- * 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
- */
-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;
-    }
-  });
-  return {
-    type: "points",
-    earned: allCorrect ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 /* eslint-disable @khanacademy/ts-no-error-suppressions */
 class Categorizer extends React.Component {
   constructor(..._args) {
@@ -26316,31 +25408,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.
  */
@@ -26613,34 +25680,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.Component {
   constructor(...args) {
     super(...args);
@@ -27703,408 +26742,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: _.partial(this.getFunctionForCoeffs, coeffs)
-    };
-  }
-};
-const Linear = _.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 = _.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 = _.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 = _.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 = _.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 _.all(coords, coord => coord[1] !== y);
-  },
-  extraAsymptoteConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
-    const y = newCoord[1];
-    const isValid = _.all(coords, coord => coord[1] > y) || _.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 = _.all(coords, coord => coord[1] > oldY);
-    if (wasBelow) {
-      const bottomMost = _.min(_.map(coords, coord => coord[1]));
-      return [oldCoord[0], bottomMost - graph.snapStep[1]];
-    }
-    const topMost = _.max(_.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 = _.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 _.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 = _.all(coords, coord => coord[0] > x) || _.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 = _.all(coords, coord => coord[0] > oldX);
-    if (wasLeft) {
-      const leftMost = _.min(_.map(coords, coord => coord[0]));
-      return [leftMost - graph.snapStep[0], oldCoord[1]];
-    }
-    const rightMost = _.max(_.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(_.map(coords, flip), _.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 = _.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 = _.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 = GrapherUtil$1.functionForType(plot.type);
     const result = handler.getEquationString(plot.coords, plot.asymptote);
     return result || "";
   }
@@ -28162,7 +26814,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 = GrapherUtil$1.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]'.
@@ -28208,70 +26860,12 @@ const typeToButton = type => {
     value: type,
     title: capitalized,
     content: /*#__PURE__*/React.createElement("img", {
-      src: staticUrl(functionForType(type).url),
+      src: staticUrl(GrapherUtil$1.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 PerseusError("Invalid grapher type", 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'.
@@ -28319,7 +26913,8 @@ class FunctionGrapher extends React.Component {
         return;
       }
       const functionProps = model.getPropsForCoeffs(coeffs, xRange);
-      return /*#__PURE__*/React.createElement(model.Movable, _extends({}, functionProps, {
+      const Movable = movableTypeToComponent[model.movable];
+      return /*#__PURE__*/React.createElement(Movable, _extends({}, functionProps, {
         key: this.props.model.url,
         range: xRange,
         style: style
@@ -28335,8 +26930,8 @@ class FunctionGrapher extends React.Component {
       return asymptote && /*#__PURE__*/React.createElement(MovableLine$2, {
         onMove: (newCoord, oldCoord) => {
           // Calculate and apply displacement
-          const delta = vector$1.subtract(newCoord, oldCoord);
-          const newAsymptote = _.map(this._asymptote(), coord => vector$1.add(coord, delta));
+          const delta = vector$3.subtract(newCoord, oldCoord);
+          const newAsymptote = _.map(this._asymptote(), coord => vector$3.add(coord, delta));
           this.props.onChange({
             asymptote: newAsymptote
           });
@@ -28347,8 +26942,8 @@ class FunctionGrapher extends React.Component {
         // @ts-expect-error - TS2339 - Property 'constraints' does not exist on type '(graphie: any, movable: any, options: any) => void'.
         Interactive2.MovableLine.constraints.snap(), (newCoord, oldCoord) => {
           // Calculate and apply proposed displacement
-          const delta = vector$1.subtract(newCoord, oldCoord);
-          const proposedAsymptote = _.map(this._asymptote(), coord => vector$1.add(coord, delta));
+          const delta = vector$3.subtract(newCoord, oldCoord);
+          const proposedAsymptote = _.map(this._asymptote(), coord => vector$3.add(coord, delta));
           // Verify that resulting asymptote is valid for graph
           if (model.extraAsymptoteConstraint) {
             return model.extraAsymptoteConstraint(newCoord, oldCoord, this._coords(), proposedAsymptote, graph);
@@ -28620,7 +27215,7 @@ class Grapher extends React.Component {
         setup: this._setupGraphie
       },
       onChange: this.handlePlotChanges,
-      model: type && functionForType(type),
+      model: type && GrapherUtil$1.functionForType(type),
       coords: coords,
       asymptote: asymptote,
       static: this.props.static,
@@ -28857,31 +27452,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
@@ -29315,7 +27885,7 @@ class Interaction extends React.Component {
       const xDiff = this._eval("(" + options.endX + ")-(" + options.startX + ")");
       // @ts-expect-error - TS2554 - Expected 2 arguments, but got 1.
       const yDiff = this._eval("(" + options.endY + ")-(" + options.startY + ")");
-      const endCoord = vector$1.add(startCoord, [xDiff, yDiff]);
+      const endCoord = vector$3.add(startCoord, [xDiff, yDiff]);
       const variables = _.clone(this.state.variables);
       variables["x_" + options.startSubscript] = startCoord[0];
       variables["y_" + options.startSubscript] = startCoord[1];
@@ -29903,15 +28473,15 @@ class Graph extends React.Component {
       if (this.props.markings === "graph") {
         graphie.graphInit({
           range: range,
-          scale: vector$1.map(gridConfig, g => g.scale),
+          scale: vector$3.map(gridConfig, g => g.scale),
           axisArrows: "<->",
           labelFormat: function (s) {
             return "\\small{" + s + "}";
           },
           gridStep: this.props.gridStep,
-          tickStep: vector$1.map(gridConfig, g => g.tickStep),
+          tickStep: vector$3.map(gridConfig, g => g.tickStep),
           labelStep: 1,
-          unityLabels: vector$1.map(gridConfig, g => g.unityLabel),
+          unityLabels: vector$3.map(gridConfig, g => g.unityLabel),
           isMobile: this.props.isMobile
         });
         graphie.label([0, range[1][1]], labels[1], this.props.isMobile ? "below right" : "above");
@@ -29919,7 +28489,7 @@ class Graph extends React.Component {
       } else if (this.props.markings === "grid") {
         graphie.graphInit({
           range: range,
-          scale: vector$1.map(gridConfig, g => g.scale),
+          scale: vector$3.map(gridConfig, g => g.scale),
           gridStep: this.props.gridStep,
           axes: false,
           ticks: false,
@@ -29929,7 +28499,7 @@ class Graph extends React.Component {
       } else if (this.props.markings === "none") {
         graphie.init({
           range: range,
-          scale: vector$1.map(gridConfig, g => g.scale),
+          scale: vector$3.map(gridConfig, g => g.scale),
           isMobile: this.props.isMobile
         });
       }
@@ -30002,7 +28572,7 @@ class Graph extends React.Component {
       }
     };
     this._getGridConfig = () => {
-      return vector$1.map(this.props.step, (step, i) => Util.gridDimensionConfig(step, this.props.range[i], this.props.box[i], this.props.gridStep[i]));
+      return vector$3.map(this.props.step, (step, i) => Util.gridDimensionConfig(step, this.props.range[i], this.props.box[i], this.props.gridStep[i]));
     };
     this._updateProtractor = () => {
       if (this.protractor) {
@@ -30444,61 +29014,6 @@ function findIntersectionOfRays([[a, b], [c, d]], [[p, q], [r, s]]) {
   }
 }
 
-// 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([x, y]) {
-  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 = (coords, allowReflexAngles = 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],
@@ -31669,11 +30184,11 @@ const LockedFunction = props => {
     "aria-label": hasAria ? props.ariaLabel : undefined,
     "aria-hidden": !hasAria,
     role: "img"
-  }, directionalAxis === "x" && /*#__PURE__*/React.createElement(Plot$3.OfX, _extends({
+  }, directionalAxis === "x" && /*#__PURE__*/React.createElement(Plot$2.OfX, _extends({
     y: x => equation.eval({
       x
     })
-  }, plotProps)), directionalAxis === "y" && /*#__PURE__*/React.createElement(Plot$3.OfY, _extends({
+  }, plotProps)), directionalAxis === "y" && /*#__PURE__*/React.createElement(Plot$2.OfY, _extends({
     x: y => equation.eval({
       y
     })
@@ -31699,6 +30214,9 @@ function SVGLine(props) {
   });
 }
 
+const {
+  calculateAngleInDegrees: calculateAngleInDegrees$3
+} = angles;
 function Vector(props) {
   const {
     tail,
@@ -31708,7 +30226,7 @@ function Vector(props) {
   } = props;
   const [tailPx, tipPx] = useTransformVectorsToPixels(tail, tip);
   const direction = vec.sub(tipPx, tailPx);
-  const angle = calculateAngleInDegrees(direction);
+  const angle = calculateAngleInDegrees$3(direction);
   return /*#__PURE__*/React.createElement("g", {
     style: {
       stroke: color,
@@ -31725,6 +30243,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.
@@ -31770,7 +30296,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
+} = angles;
 const LockedLine = props => {
   const {
     color: color$1,
@@ -31802,7 +30366,7 @@ const LockedLine = props => {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     const [tailPx, tipPx] = useTransformVectorsToPixels(point2.coord, point1.coord);
     const direction = vec.sub(tailPx, tipPx);
-    let angle = calculateAngleInDegrees(direction);
+    let angle = calculateAngleInDegrees$2(direction);
     const startArrowHead = kind !== "segment" && /*#__PURE__*/React.createElement(Arrowhead, {
       angle: angle,
       tip: arrowTip,
@@ -32212,6 +30776,12 @@ const SvgDefs = () => /*#__PURE__*/React__default.createElement("defs", null, /*
   in: "SourceGraphic"
 })));
 
+const {
+  clockwise: clockwise$1
+} = geometry;
+const {
+  getAngleFromVertex: getAngleFromVertex$1
+} = angles;
 const PolygonAngle = ({
   centerPoint,
   endPoints,
@@ -32300,8 +30870,8 @@ const Angle = ({
   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
@@ -32657,14 +31227,6 @@ function range(min, max, step = 1) {
   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;
@@ -33052,6 +31614,11 @@ const MovablePoint$1 = /*#__PURE__*/React.forwardRef((props, pointRef) => {
   return /*#__PURE__*/React.createElement(React.Fragment, null, focusableHandle, visiblePoint);
 });
 
+const {
+  calculateAngleInDegrees: calculateAngleInDegrees$1,
+  getClockwiseAngle: getClockwiseAngle$2,
+  polar: polar$1
+} = angles;
 function renderAngleGraph(state, dispatch) {
   return {
     graph: /*#__PURE__*/React.createElement(AngleGraph, {
@@ -33121,7 +31688,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,
@@ -33185,9 +31752,7 @@ function AngleGraph(props) {
     ariaLabel: initialSideAriaLabel
   }), /*#__PURE__*/React.createElement("g", {
     id: "angle-description",
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, wholeAngleDescription));
 }
 const positiveX = [1, 0];
@@ -33196,7 +31761,7 @@ const positiveY = [0, 1];
 const negativeY = [0, -1];
 function getAngleSideConstraint(sidePoint, vertex, snapDegrees) {
   var _findIntersectionOfRa, _findIntersectionOfRa2, _findIntersectionOfRa3, _findIntersectionOfRa4;
-  const currentAngle = calculateAngleInDegrees(vec.sub(sidePoint, vertex));
+  const currentAngle = calculateAngleInDegrees$1(vec.sub(sidePoint, vertex));
 
   // Find the rays that start at the current point and point up, down, left
   // and right.
@@ -33213,8 +31778,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, vec.add(vertex, polar(1, oneStepCounterClockwise))];
-  const clockwiseRay = [vertex, vec.add(vertex, polar(1, oneStepClockwise))];
+  const counterClockwiseRay = [vertex, vec.add(vertex, polar$1(1, oneStepCounterClockwise))];
+  const clockwiseRay = [vertex, 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
@@ -33231,6 +31796,9 @@ function getAngleSideConstraint(sidePoint, vertex, snapDegrees) {
   };
 }
 
+const {
+  clockwise
+} = geometry;
 function getGradableGraph(state, initialGraph) {
   if (!state.hasBeenInteractedWith) {
     return _extends({}, initialGraph);
@@ -33299,7 +31867,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 _extends({}, initialGraph, {
@@ -33411,14 +31979,10 @@ function CircleGraph(props) {
     }
   }), /*#__PURE__*/React.createElement("g", {
     id: radiusId,
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, srCircleRadius), /*#__PURE__*/React.createElement("g", {
     id: outerPointsId,
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, srCircleOuterPoints));
 }
 function MovableCircle(props) {
@@ -33603,49 +32167,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.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.createElement(MovableLine, {
     key: 0,
     ariaLabels: {
@@ -33664,19 +32195,13 @@ const LinearGraph = (props, key) => {
     color: "var(--movable-line-stroke-color)"
   }), /*#__PURE__*/React.createElement("g", {
     id: pointsDescriptionId,
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, linearGraphPointsDescription), /*#__PURE__*/React.createElement("g", {
     id: interceptDescriptionId,
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, interceptString), /*#__PURE__*/React.createElement("g", {
     id: slopeDescriptionId,
-    style: {
-      display: "hidden"
-    }
+    style: a11y.srOnly
   }, slopeString));
 };
 
@@ -33686,7 +32211,9 @@ function renderLinearSystemGraph(state, dispatch) {
       graphState: state,
       dispatch: dispatch
     }),
-    interactiveElementsDescription: null
+    interactiveElementsDescription: /*#__PURE__*/React.createElement(LinearSystemGraphDescription, {
+      state: state
+    })
   };
 }
 const LinearSystemGraph = props => {
@@ -33696,9 +32223,53 @@ const LinearSystemGraph = props => {
   const {
     coords: lines
   } = props.graphState;
-  return /*#__PURE__*/React.createElement(React.Fragment, null, lines == null ? void 0 : lines.map((line, i) => /*#__PURE__*/React.createElement(MovableLine, {
+  const {
+    strings,
+    locale
+  } = usePerseusI18n();
+  const id = React.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.createElement("g", {
+    "aria-label": strings.srLinearSystemGraph,
+    "aria-describedby": linesAriaInfo.map(({
+      pointsDescriptionId,
+      interceptDescriptionId,
+      slopeDescriptionId
+    }) => `${pointsDescriptionId} ${interceptDescriptionId} ${slopeDescriptionId}`).join(" ")
+  }, lines == null ? void 0 : lines.map((line, i) => /*#__PURE__*/React.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));
     },
@@ -33708,8 +32279,63 @@ const LinearSystemGraph = props => {
     },
     onMovePoint: (endpointIndex, destination) => dispatch(actions.linearSystem.movePointInFigure(i, endpointIndex, destination)),
     color: "var(--movable-line-stroke-color)"
-  })), ";");
+  })), linesAriaInfo.map(({
+    pointsDescriptionId,
+    interceptDescriptionId,
+    slopeDescriptionId,
+    pointsDescription,
+    interceptDescription,
+    slopeDescription
+  }) => /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("g", {
+    key: pointsDescriptionId,
+    id: pointsDescriptionId,
+    style: a11y.srOnly
+  }, pointsDescription), /*#__PURE__*/React.createElement("g", {
+    key: interceptDescriptionId,
+    id: interceptDescriptionId,
+    style: a11y.srOnly
+  }, interceptDescription), /*#__PURE__*/React.createElement("g", {
+    key: slopeDescriptionId,
+    id: slopeDescriptionId,
+    style: a11y.srOnly
+  }, slopeDescription))));
 };
+function LinearSystemGraphDescription({
+  state
+}) {
+  // 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 {
@@ -34148,7 +32774,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.useRef([0, 0, 0]);
-  const coeffs = getQuadraticCoefficients$1(coords);
+  const coeffs = getQuadraticCoefficients$2(coords);
   if (coeffs !== undefined) {
     coeffRef.current = coeffs;
   }
@@ -34158,7 +32784,7 @@ function QuadraticGraph(props) {
 
   // Calculate the y value based on the current x value
   const y = x => (a * x + b) * x + c;
-  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Plot$3.OfX, {
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Plot$2.OfX, {
     y: y,
     color: color.blue
   }), coords.map((coord, i) => /*#__PURE__*/React.createElement(MovablePoint$1, {
@@ -34173,7 +32799,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];
@@ -34196,7 +32822,9 @@ function renderRayGraph(state, dispatch) {
       graphState: state,
       dispatch: dispatch
     }),
-    interactiveElementsDescription: null
+    interactiveElementsDescription: /*#__PURE__*/React.createElement(RayGraphDescription, {
+      state: state
+    })
   };
 }
 const RayGraph = props => {
@@ -34208,18 +32836,103 @@ 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.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.createElement(MovableLine, {
+  return /*#__PURE__*/React.createElement("g", {
+    // Outer line minimal description
+    "aria-label": srRayGraph,
+    "aria-describedby": pointsDescriptionId
+  }, /*#__PURE__*/React.createElement(MovableLine, {
     points: line,
+    ariaLabels: {
+      point1AriaLabel: srRayEndpoint,
+      point2AriaLabel: srRayTerminalPoint,
+      grabHandleAriaLabel: srRayGrabHandle
+    },
     onMoveLine: handleMoveLine,
     onMovePoint: handleMovePoint,
     extend: {
       start: false,
       end: true
     }
-  });
+  }), /*#__PURE__*/React.createElement("g", {
+    id: pointsDescriptionId,
+    style: a11y.srOnly
+  }, srRayPoints));
 };
+function RayGraphDescription({
+  state
+}) {
+  // 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 {
@@ -34287,7 +33000,7 @@ function SinusoidGraph(props) {
   if (coeffs !== undefined) {
     coeffRef.current = coeffs;
   }
-  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Plot$3.OfX, {
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Plot$2.OfX, {
     y: x => computeSine(x, coeffRef.current),
     color: color.blue
   }), coords.map((coord, i) => /*#__PURE__*/React.createElement(MovablePoint$1, {
@@ -34334,6 +33047,10 @@ const getSinusoidCoefficients$1 = coords => {
   };
 };
 
+const {
+  calculateAngleInDegrees,
+  convertDegreesToRadians
+} = 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
@@ -35035,6 +33752,10 @@ function mafsStateToInteractiveGraph(state, originalGraph) {
   }
 }
 
+const {
+  magnitude: magnitude$2,
+  vector: vector$2
+} = geometry;
 function initializeGraphState(params) {
   var _graph$snapTo;
   const {
@@ -35314,7 +34035,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
@@ -35328,6 +34049,24 @@ const getAngleCoords = params => {
   return coords;
 };
 
+const {
+  getAngleFromVertex,
+  getClockwiseAngle: getClockwiseAngle$1,
+  polar
+} = angles;
+const {
+  angleMeasures: angleMeasures$1,
+  ccw: ccw$1,
+  lawOfCosines: lawOfCosines$1,
+  magnitude: magnitude$1,
+  polygonSidesIntersect,
+  reverseVector,
+  sign: sign$1,
+  vector: vector$1
+} = geometry;
+const {
+  getQuadraticCoefficients: getQuadraticCoefficients$1
+} = coefficients;
 const minDistanceBetweenAngleVertexAndSidePoint = 2;
 function interactiveGraphReducer(state, action) {
   switch (action.type) {
@@ -35846,11 +34585,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 || approximateEqual(a, b);
 }
 function boundAndSnapToGrid(point, {
   snapStep,
@@ -35994,7 +34731,7 @@ function boundAndSnapToPolygonAngle(destinationPoint, {
   });
 
   // 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 => {
@@ -36006,7 +34743,7 @@ function boundAndSnapToPolygonAngle(destinationPoint, {
     angles[rel(j)] = Math.round(angles[rel(j)]);
   });
   const getAngle = function getAngle(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)];
@@ -36018,9 +34755,9 @@ function boundAndSnapToPolygonAngle(destinationPoint, {
   })) {
     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.
@@ -36028,7 +34765,7 @@ function boundAndSnapToPolygonAngle(destinationPoint, {
   // 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;
@@ -36040,7 +34777,7 @@ function boundAndSnapToPolygonAngle(destinationPoint, {
   // and the angle between the first and second sides of the
   // polygon (angular coordinate) to determine how to adjust the point
   const offset = polar(side, outerAngle + (onLeft ? 1 : -1) * innerAngles[0]);
-  return vector$1.add(coordsCopy[rel(-1)], offset);
+  return vector$3.add(coordsCopy[rel(-1)], offset);
 }
 function boundAndSnapToSides(destinationPoint, {
   range,
@@ -36066,7 +34803,7 @@ function boundAndSnapToSides(destinationPoint, {
   };
   const sides = _.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
@@ -36081,7 +34818,7 @@ function boundAndSnapToSides(destinationPoint, {
 
   // 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)]);
@@ -36092,13 +34829,13 @@ function boundAndSnapToSides(destinationPoint, {
   // 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
   // polygon (angular coordinate) to determine how to adjust the point
   const offset = polar(sides[0], outerAngle + (onLeft ? 1 : -1) * innerAngle);
-  return vector$1.add(coordsCopy[rel(-1)], offset);
+  return vector$3.add(coordsCopy[rel(-1)], offset);
 }
 
 // Returns the vector from the given point to the top-right corner of the graph when snapped to the grid
@@ -36128,7 +34865,7 @@ function minMove({
   });
   return vec.sub(bottomLeft, point);
 }
-const coordsOverlap = coords => coords.some((coord, i) => coords.some((c, j) => i !== j && vector$1.equal(coord, c)));
+const coordsOverlap = coords => coords.some((coord, i) => coords.some((c, j) => i !== j && vector$3.equal(coord, c)));
 function updateAtIndex(args) {
   const {
     array,
@@ -36223,216 +34960,26 @@ const StatefulMafsGraph = /*#__PURE__*/React.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 == null || 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, number$1.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 = _.invoke(guess, "sort").sort();
-      correct = _.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 = _.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 || _.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
+} = angles;
+const {
+  angleMeasures,
+  ccw,
+  collinear,
+  getLineEquation,
+  getLineIntersection,
+  intersects,
+  lawOfCosines,
+  magnitude,
+  rotate,
+  sign,
+  vector
+} = 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:
@@ -36445,7 +34992,7 @@ function defaultVal(actual, defaultValue) {
 
 // Less than or approximately equal
 function leq(a, b) {
-  return a < b || eq(a, b);
+  return a < b || approximateEqual(a, b);
 }
 function capitalize(str) {
   return str.replace(/(?:^|-)(.)/g, function (match, letter) {
@@ -37272,7 +35819,7 @@ class LegacyInteractiveGraph extends React.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$graphie5 = this.graphie) == null ? void 0 : _this$graphie5.addPoints(coords[rel(-1)], offset);
         }
         // @ts-expect-error - TS2339 - Property 'snapTo' does not exist on type 'PerseusGraphType'.
@@ -37297,7 +35844,7 @@ class LegacyInteractiveGraph extends React.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$graphie6 = this.graphie) == null ? void 0 : _this$graphie6.addPoints(coords[rel(-1)], offset);
         }
         // Snap to grid (already done)
@@ -37959,12 +36506,12 @@ class InteractiveGraph extends React.Component {
   }
   static getLinearEquationString(props) {
     const coords = InteractiveGraph.getLineCoords(props.graph, props);
-    if (eq(coords[0][0], coords[1][0])) {
+    if (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 (approximateEqual(m, 0)) {
       return "y = " + b.toFixed(3);
     }
     return "y = " + m.toFixed(3) + "x + " + b.toFixed(3);
@@ -38490,59 +37037,6 @@ const styles$a = 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.
@@ -38764,7 +37258,7 @@ class LabelImage extends React.Component {
       onChange
     } = this.props;
     const updatedMarkers = markers.map(marker => {
-      const score = scoreMarker(marker);
+      const score = scoreLabelImageMarker(marker);
       return _extends({}, marker, {
         // Reveal correctness state for markers with answers.
         showCorrectness: score.hasAnswers ? score.isCorrect ? "correct" : "incorrect" : undefined
@@ -38911,7 +37405,7 @@ class LabelImage extends React.Component {
           bottom: "top"
         }[markerPosition];
       }
-      const score = scoreMarker(marker);
+      const score = scoreLabelImageMarker(marker);
       // Once the question is answered, show markers
       // with correct answers, otherwise passthrough
       // the correctness state.
@@ -39843,16 +38337,6 @@ const getPromptJSON$9 = (renderProps, userInput) => {
   };
 };
 
-function scoreMatcher(state, rubric) {
-  const correct = _.isEqual(state.left, rubric.left) && _.isEqual(state.right, rubric.right);
-  return {
-    type: "points",
-    earned: correct ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 const {
   shuffle: shuffle$1,
   seededRNG
@@ -40075,78 +38559,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 = KhanAnswerTypes.number.createValidatorFunctional;
-  let message = null;
-  let incorrect = false;
-  _(suppliedSize[0]).times(row => {
-    _(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;
@@ -40195,29 +38607,6 @@ const getRefForPath$1 = function getRefForPath(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.
-  _(matrix).each((matrixRow, row) => {
-    let rowWidth = 0;
-    _(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.Component {
   constructor(...args) {
     super(...args);
@@ -41608,59 +39997,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 = number$1.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'.
@@ -42229,36 +40565,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 = _.isEqual(userInput.current, rubric.correctOptions.map(option => option.content));
-  return {
-    type: "points",
-    earned: correct ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
-
 class PlaceholderCard extends React.Component {
   render() {
     return /*#__PURE__*/React.createElement("div", {
@@ -43074,42 +41380,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.Component {
   constructor(..._args) {
@@ -43989,43 +42259,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;
@@ -44118,81 +42351,6 @@ var Sorter$1 = {
   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 filterNonEmpty(table) {
-  return table.filter(function (row) {
-    // Return only rows that are non-empty.
-    return row.some(cell => cell);
-  });
-};
-
-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 = 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;
@@ -44595,7 +42753,7 @@ const init = function init() {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus";
-const libVersion = "50.1.0";
+const libVersion = "51.0.0";
 addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {
@@ -46556,7 +44714,6 @@ const getValidWidgetIds = perseusItem => {
   return keys(widgets).filter(id => isWidgetIdInContent(perseusItem, id));
 };
 
-const deepEq = Util.deepEq;
 function isRealJSONParse(jsonParse) {
   const randomPhrase = buildRandomPhrase();
   const randomHintPhrase = buildRandomPhrase();
@@ -46613,7 +44770,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 approximateDeepEqual(parsedTestItemData, testingObject);
 }
 function buildRandomString(capitalize = false) {
   let randomString = "";
@@ -46813,7 +44970,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);
       }
@@ -48422,7 +46581,6 @@ const EditorJsonify = {
  * Main entry point
  */
 const GrapherUtil = {
-  allTypes,
   DEFAULT_GRAPHER_PROPS,
   chooseType,
   defaultPlotProps,
@@ -48437,5 +46595,5 @@ const ScoringUtil = {
  * Types
  */
 
-export { ApiOptions, ArticleRenderer, BaseRadio, Categorizer$1 as Categorizer, changeable as Changeable, ClassNames, dependencies as Dependencies, EditorJsonify, Expression, GrapherUtil, Grapher$1 as GrapherWidget, HintRenderer, HintsRenderer, InputNumber$1 as InputNumber, InteractiveGraph$1 as InteractiveGraphWidget, JiptParagraphs, KhanColors, context as LoadingContext, Log, Matrix$1 as MatrixWidget, NumericInput$1 as NumericInput, PerseusI18nContext, PerseusI18nContextProvider, PerseusMarkdown, Plotter$1 as PlotterWidget, QUESTION_WIDGETS, Radio, Renderer, ScoringUtil, ref as ServerItemRenderer, Table$1 as TableWidget, Util, denylist as WIDGET_PROP_DENYLIST, widgets$1 as Widgets, addWidget, apiVersion, bodyXsmallBold, components, containerSizeClass, contentHasWidgetType, convertWidgetNameToEnum, displaySigFigs, generateTestCategorizerWidget, generateTestExpressionWidget, generateTestInteractiveGraphWidget, generateTestNumericInputWidget, generateTestPerseusItem, generateTestRadioWidget, genericPerseusItemData, getAngleCoords, getAnswerFromUserInput, getAnswersFromWidgets, getCircleCoords, getClockwiseAngle, getCorrectAnswerForWidgetId, getImagesWithoutAltData, getInteractiveBoxFromSizeClass, getLineCoords, getLinearSystemCoords, getPointCoords, getPolygonCoords, getQuadraticCoords, getSegmentCoords, getSinusoidCoords, getValidWidgetIds, getWidgetFromWidgetMap, getWidgetIdsFromContent, getWidgetIdsFromContentByType, getWidgetTypeByWidgetId, getWidgetsFromWidgetMap, getWidgetsMapFromItemData, iconChevronDown, iconTrash, init, injectWidgets, interactiveSizes$1 as interactiveSizes, isFailure, isItemRenderableByVersion, isSuccess, isWidgetIdInContent, isWrongAnswerSupported, itemDataVersion, ItemVersion as itemVersion, libVersion, makeSafeUrl, mathOnlyParser, mediaQueries, parseAndMigratePerseusArticle, parseAndMigratePerseusItem, parseDataFromJSONP, parsePerseusItem, preprocessTex, registerAllWidgetsForTesting, scorePerseusItem, shouldHaveIndividualAnswer, traverse, usePerseusI18n, violatingWidgets, allWidgets as widgets };
+export { ApiOptions, ArticleRenderer, BaseRadio, Categorizer$1 as Categorizer, changeable as Changeable, ClassNames, dependencies as Dependencies, EditorJsonify, Expression, GrapherUtil, Grapher$1 as GrapherWidget, HintRenderer, HintsRenderer, InputNumber$1 as InputNumber, InteractiveGraph$1 as InteractiveGraphWidget, JiptParagraphs, KhanColors, context as LoadingContext, Log, Matrix$1 as MatrixWidget, NumericInput$1 as NumericInput, PerseusI18nContext, PerseusI18nContextProvider, PerseusMarkdown, Plotter$1 as PlotterWidget, QUESTION_WIDGETS, Radio, Renderer, ScoringUtil, ref as ServerItemRenderer, Table$1 as TableWidget, Util, denylist as WIDGET_PROP_DENYLIST, widgets$1 as Widgets, addWidget, apiVersion, bodyXsmallBold, components, containerSizeClass, contentHasWidgetType, convertWidgetNameToEnum, displaySigFigs, generateTestCategorizerWidget, generateTestExpressionWidget, generateTestInteractiveGraphWidget, generateTestNumericInputWidget, generateTestPerseusItem, generateTestRadioWidget, genericPerseusItemData, getAngleCoords, getAnswerFromUserInput, getAnswersFromWidgets, getCircleCoords, getCorrectAnswerForWidgetId, getImagesWithoutAltData, getInteractiveBoxFromSizeClass, getLineCoords, getLinearSystemCoords, getPointCoords, getPolygonCoords, getQuadraticCoords, getSegmentCoords, getSinusoidCoords, getValidWidgetIds, getWidgetFromWidgetMap, getWidgetIdsFromContent, getWidgetIdsFromContentByType, getWidgetTypeByWidgetId, getWidgetsFromWidgetMap, getWidgetsMapFromItemData, iconChevronDown, iconTrash, init, injectWidgets, interactiveSizes$1 as interactiveSizes, isFailure, isItemRenderableByVersion, isSuccess, isWidgetIdInContent, isWrongAnswerSupported, itemDataVersion, ItemVersion as itemVersion, libVersion, makeSafeUrl, mathOnlyParser, mediaQueries, parseAndMigratePerseusArticle, parseAndMigratePerseusItem, parseDataFromJSONP, parsePerseusItem, preprocessTex, registerAllWidgetsForTesting, scorePerseusItem, shouldHaveIndividualAnswer, traverse, usePerseusI18n, violatingWidgets, allWidgets as widgets };
 //# sourceMappingURL=index.js.map