@khanacademy/perseus 49.2.2 → 50.0.0

package/dist/index.js

@@ -13,6 +13,7 @@ var classNames$1 = require('classnames');
 var React = require('react');
 var ReactDOM = require('react-dom');
 var _ = require('underscore');
+var perseusScore = require('@khanacademy/perseus-score');
 var Clickable = require('@khanacademy/wonder-blocks-clickable');
 var wonderBlocksPopover = require('@khanacademy/wonder-blocks-popover');
 var wonderBlocksTokens = require('@khanacademy/wonder-blocks-tokens');
@@ -20,9 +21,9 @@ var $ = require('jquery');
 var uuid = require('uuid');
 var perseusCore = require('@khanacademy/perseus-core');
 var PropTypes = require('prop-types');
-var kmath = require('@khanacademy/kmath');
 var wonderStuffCore = require('@khanacademy/wonder-stuff-core');
 var wonderBlocksProgressSpinner = require('@khanacademy/wonder-blocks-progress-spinner');
+var kmath = require('@khanacademy/kmath');
 var SimpleMarkdown = require('@khanacademy/simple-markdown');
 var pureMarkdown = require('@khanacademy/pure-markdown');
 var wonderBlocksForm = require('@khanacademy/wonder-blocks-form');
@@ -108,6 +109,183 @@ function _extends() {
  * The translated strings that are used to render Perseus.
  */
 
+/**
+ * Untranslated strings used in Perseus. To be used by an external
+ * translator to produce translated strings, passed in as `PerseusStrings`.
+ * !! Note: Ensure that all escape sequences are double-escaped. (e.g. `\\text` -> `\\\\text`)
+ */
+const strings = {
+  closeKeypad: "close math keypad",
+  openKeypad: "open math keypad",
+  mathInputBox: "Math input box",
+  removeHighlight: "Remove highlight",
+  addHighlight: "Add highlight",
+  hintPos: "Hint #%(pos)s",
+  errorRendering: "Error rendering: %(error)s",
+  APPROXIMATED_PI_ERROR: "Your answer is close, but you may " + "have approximated pi. Enter your " + "answer as a multiple of pi, like " + "12 pi or " + "2/3 pi",
+  EXTRA_SYMBOLS_ERROR: "We could not understand your " + "answer. Please check your answer for extra " + "text or symbols.",
+  NEEDS_TO_BE_SIMPLFIED_ERROR: "Your answer is almost correct, " + "but it needs to be simplified.",
+  MISSING_PERCENT_ERROR: "Your answer is almost correct, " + "but it is missing a " + "<code>\\\\%</code> at the end.",
+  MULTIPLICATION_SIGN_ERROR: "I'm a computer. I only understand " + "multiplication if you use an asterisk " + "(*) as the multiplication sign.",
+  WRONG_CASE_ERROR: "Your answer includes use of a variable with the wrong case.",
+  WRONG_LETTER_ERROR: "Your answer includes a wrong variable letter.",
+  invalidSelection: "Make sure you select something for every row.",
+  ERROR_TITLE: "Oops!",
+  ERROR_MESSAGE: "Sorry, I don't understand that!",
+  hints: "Hints",
+  getAnotherHint: "Get another hint",
+  deprecatedStandin: "Sorry, this part of the question is no longer available. 😅 Don't worry, you won't be graded on this part. Keep going!",
+  keepTrying: "Keep trying",
+  tryAgain: "Try again",
+  check: "Check",
+  correctExcited: "Correct!",
+  nextQuestion: "Next question",
+  skipToTitle: "Skip to %(title)s",
+  current: "Current",
+  correct: "Correct",
+  correctSelected: "Correct (selected)",
+  correctCrossedOut: "Correct (but you crossed it out)",
+  incorrect: "Incorrect",
+  incorrectSelected: "Incorrect (selected)",
+  hideExplanation: "Hide explanation",
+  explain: "Explain",
+  INVALID_MESSAGE_PREFIX: "We couldn't grade your answer.",
+  DEFAULT_INVALID_MESSAGE_1: "It looks like you left something blank or ",
+  DEFAULT_INVALID_MESSAGE_2: "entered in an invalid answer.",
+  integerExample: "an integer, like $6$",
+  properExample: "a *proper* fraction, like $1/2$ or $6/10$",
+  simplifiedProperExample: "a *simplified proper* fraction, like $3/5$",
+  improperExample: "an *improper* fraction, like $10/7$ or $14/8$",
+  simplifiedImproperExample: "a *simplified improper* fraction, like $7/4$",
+  mixedExample: "a mixed number, like $1\\\\ 3/4$",
+  decimalExample: "an *exact* decimal, like $0.75$",
+  percentExample: "a percent, like $12.34\\\\%$",
+  piExample: "a multiple of pi, like $12$ pi or $2/3$ pi",
+  yourAnswer: "**Your answer should be** ",
+  yourAnswerLabel: "Your answer:",
+  addPoints: "Click to add points",
+  addVertices: "Click to add vertices",
+  tapMultiple: "Tap each dot on the image to select all answers that apply.",
+  tapSingle: "Tap each dot on the image to select an answer.",
+  clickMultiple: "Click each dot on the image to select all answers that apply.",
+  clickSingle: "Click each dot on the image to select an answer.",
+  choices: "Choices:",
+  answers: {
+    one: "%(num)s answer",
+    other: "%(num)s answers"
+  },
+  hideAnswersToggleLabel: "Hide answer choices",
+  moves: {
+    one: "Moves: %(num)s",
+    other: "Moves: %(num)s"
+  },
+  clickTiles: "Click on the tiles to change the lights.",
+  turnOffLights: "You must turn on all of the lights to continue.",
+  fillAllCells: "Make sure you fill in all cells in the matrix.",
+  molecularDrawing: "A molecular structure drawing. SMILES notation: %(content)s",
+  switchDirection: "Switch direction",
+  circleOpen: "Make circle open",
+  circleFilled: "Make circle filled",
+  numDivisions: "Number of divisions:",
+  divisions: "Please make sure the number of divisions is in the range %(divRangeString)s.",
+  lineRange: "lines %(lineRange)s",
+  lineNumber: "line %(lineNumber)s",
+  symbolPassage: "The symbol %(questionSymbol)s indicates that question %(questionNumber)s references this portion of the passage.",
+  symbolQuestion: " The symbol %(sentenceSymbol)s indicates that the following sentence is referenced in a question.",
+  lineLabel: {
+    context: "a label next to a reading passage to denote the line number",
+    message: "Line"
+  },
+  beginningPassage: "Beginning of reading passage.",
+  beginningFootnotes: "Beginning of reading passage footnotes.",
+  endPassage: "End of reading passage.",
+  questionMarker: "[Marker for question %(number)s]",
+  circleMarker: "[Circle marker %(number)s]",
+  sentenceMarker: "[Sentence %(number)s]",
+  dragHandles: "Drag handles to make graph",
+  tapAddPoints: "Tap to add points",
+  false: "False",
+  true: "True",
+  no: "No",
+  yes: "Yes",
+  chooseCorrectNum: "Please choose the correct number of answers.",
+  notNoneOfTheAbove: "'None of the above' may not be selected when other answers are selected.",
+  noneOfTheAbove: "None of the above",
+  chooseNumAnswers: "Choose %(numCorrect)s answers:",
+  chooseAllAnswers: "Choose all answers that apply:",
+  chooseOneAnswer: "Choose 1 answer:",
+  choiceCheckedCorrect: "(Choice %(letter)s, Checked, Correct)",
+  choiceCrossedOutCorrect: "(Choice %(letter)s, Crossed out, Correct)",
+  choiceCorrect: "(Choice %(letter)s, Correct)",
+  choiceCheckedIncorrect: "(Choice %(letter)s, Checked, Incorrect)",
+  choiceCrossedOutIncorrect: "(Choice %(letter)s, Crossed out, Incorrect)",
+  choiceIncorrect: "(Choice %(letter)s, Incorrect)",
+  choiceChecked: "(Choice %(letter)s, Checked)",
+  choiceCrossedOut: "(Choice %(letter)s, Crossed out)",
+  choice: "(Choice %(letter)s)",
+  crossOut: "Cross out",
+  crossOutOption: "Cross out option",
+  crossOutChoice: "Cross out Choice %(letter)s",
+  bringBack: "Bring back",
+  openMenuForChoice: "Open menu for Choice %(letter)s",
+  letters: {
+    context: "This is a list of single-character labels that will appear in front of multiple-choice options. For instance, a multiple-choice question with three options would display (A) first option (B) second option (C) third option. There must be spaces between each of the different characters. The characters will show up next to options in the order that they are listed here. Most multiple choice questions have 5 or fewer options.",
+    message: "A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
+  },
+  rightArrow: "Reaction arrow pointing to the right.",
+  dontUnderstandUnits: "I couldn't understand those units.",
+  checkSigFigs: "Check your significant figures.",
+  answerNumericallyIncorrect: "That answer is numerically incorrect.",
+  checkUnits: "Check your units.",
+  dontUnderstand: "I don't understand that",
+  loading: "Loading...",
+  videoTranscript: "See video transcript",
+  somethingWrong: "Something went wrong.",
+  videoWrapper: "Khan Academy video wrapper",
+  mathInputTitle: "mathematics keyboard",
+  mathInputDescription: "Use keyboard/mouse to interact with math-based input fields",
+  sin: "sin",
+  cos: "cos",
+  tan: "tan",
+  simulationLoadFail: "Sorry, this simulation cannot load.",
+  simulationLocaleWarning: "Sorry, this simulation isn't available in your language.",
+  selectAnAnswer: "Select an answer",
+  // The following strings are used for interactive graph SR descriptions.
+  addPoint: "Add Point",
+  removePoint: "Remove Point",
+  graphKeyboardPrompt: "Press Shift + Enter to interact with the graph",
+  closePolygon: "Close shape",
+  openPolygon: "Re-open shape",
+  srInteractiveElements: "Interactive elements: %(elements)s",
+  srNoInteractiveElements: "No interactive elements",
+  // TODO(LEMS-2660): The following strings are ones that will need
+  // translation tickets after all interactive graph SR strings have
+  // been finalized. Remove this comment after the tickets have been
+  // created.
+  srPointAtCoordinates: "Point %(num)s at %(x)s comma %(y)s",
+  srCircleGraph: "A circle on a coordinate plane.",
+  srCircleShape: "Circle. The center point is at %(centerX)s comma %(centerY)s.",
+  srCircleRadiusPoint: "Radius point at %(radiusPointX)s comma %(radiusPointY)s.",
+  srCircleRadius: "Circle radius is %(radius)s.",
+  srCircleOuterPoints: "Points on the circle at %(point1X)s comma %(point1Y)s, %(point2X)s comma %(point2Y)s, %(point3X)s comma %(point3Y)s, %(point4X)s comma %(point4Y)s.",
+  srLinearGraph: "A line on a coordinate plane.",
+  srLinearGraphPoints: "The line has two points, point 1 at %(point1X)s comma %(point1Y)s and point 2 at %(point2X)s comma %(point2Y)s.",
+  srLinearGraphSlopeIncreasing: "Its slope increases from left to right.",
+  srLinearGraphSlopeDecreasing: "Its slope decreases from left to right.",
+  srLinearGraphSlopeHorizontal: "Its slope is zero.",
+  srLinearGraphSlopeVertical: "Its slope is undefined.",
+  srLinearGraphXOnlyIntercept: "The line crosses the X-axis at %(xIntercept)s comma 0.",
+  srLinearGraphYOnlyIntercept: "The line crosses the Y-axis at 0 comma %(yIntercept)s.",
+  srLinearGraphBothIntercepts: "The line crosses the X-axis at %(xIntercept)s comma 0 and the Y-axis at 0 comma %(yIntercept)s.",
+  srLinearGraphOriginIntercept: "The line crosses the x and y axes at the graph's origin.",
+  srLinearGrabHandle: "Line from %(point1X)s comma %(point1Y)s to %(point2X)s comma %(point2Y)s.",
+  srAngleSideAtCoordinates: "Point %(point)s, %(side)s at %(x)s comma %(y)s",
+  srAngleVertexAtCoordinatesWithAngleMeasure: "Point 2, vertex at %(x)s comma %(y)s. Angle %(angleMeasure)s degrees",
+  srAngleGraphAriaLabel: "An angle on a coordinate plane.",
+  srAngleGraphAriaDescription: "The angle measure is %(angleMeasure)s degrees with a vertex at %(vertexX)s comma %(vertexY)s, a point on the starting side at %(startingSideX)s comma %(startingSideY)s and a point on the ending side at %(endingSideX)s comma %(endingSideY)s"
+  // The above strings are used for interactive graph SR descriptions.
+};
+
 /**
  * Mock strings for the Perseus package, to be used for tests and Storybook.
  */
@@ -497,6 +675,16 @@ const mockStrings = {
   // The above strings are used for interactive graph SR descriptions.
 };
 
+({
+  [perseusScore.ErrorCodes.MISSING_PERCENT_ERROR]: strings.MISSING_PERCENT_ERROR,
+  [perseusScore.ErrorCodes.NEEDS_TO_BE_SIMPLIFIED_ERROR]: strings.NEEDS_TO_BE_SIMPLFIED_ERROR,
+  [perseusScore.ErrorCodes.APPROXIMATED_PI_ERROR]: strings.APPROXIMATED_PI_ERROR,
+  [perseusScore.ErrorCodes.EXTRA_SYMBOLS_ERROR]: strings.EXTRA_SYMBOLS_ERROR,
+  [perseusScore.ErrorCodes.WRONG_CASE_ERROR]: strings.WRONG_CASE_ERROR,
+  [perseusScore.ErrorCodes.WRONG_LETTER_ERROR]: strings.WRONG_LETTER_ERROR,
+  [perseusScore.ErrorCodes.MULTIPLICATION_SIGN_ERROR]: strings.MULTIPLICATION_SIGN_ERROR
+});
+
 /**
  * PerseusI18nContext provides a way to set the strings and locale that are
  * used inside the Perseus package.
@@ -1464,918 +1652,6 @@ const Log = {
   }
 };
 
-const KhanMath = {
-  // Simplify formulas before display
-  cleanMath: function (expr) {
-    return typeof expr === "string" ? expr.replace(/\+\s*-/g, "- ").replace(/-\s*-/g, "+ ").replace(/\^1/g, "") : expr;
-  },
-  // Bound a number by 1e-6 and 1e20 to avoid exponents after toString
-  bound: function (num) {
-    if (num === 0) {
-      return num;
-    }
-    if (num < 0) {
-      return -KhanMath.bound(-num);
-    }
-    return Math.max(1e-6, Math.min(num, 1e20));
-  },
-  factorial: function (x) {
-    if (x <= 1) {
-      return x;
-    }
-    return x * KhanMath.factorial(x - 1);
-  },
-  getGCD: function (a, b) {
-    if (arguments.length > 2) {
-      // TODO(kevinb): rewrite using rest args instead of arguments
-      // eslint-disable-next-line prefer-rest-params
-      const rest = [].slice.call(arguments, 1);
-      // @ts-expect-error - TS2556 - A spread argument must either have a tuple type or be passed to a rest parameter.
-      return KhanMath.getGCD(a, KhanMath.getGCD(...rest));
-    }
-    let mod;
-    a = Math.abs(a);
-    b = Math.abs(b);
-    while (b) {
-      mod = a % b;
-      a = b;
-      b = mod;
-    }
-    return a;
-  },
-  getLCM: function (a, b) {
-    if (arguments.length > 2) {
-      // TODO(kevinb): rewrite using rest args instead of arguments
-      // eslint-disable-next-line prefer-rest-params
-      const rest = [].slice.call(arguments, 1);
-      // @ts-expect-error - TS2556 - A spread argument must either have a tuple type or be passed to a rest parameter.
-      return KhanMath.getLCM(a, KhanMath.getLCM(...rest));
-    }
-    return Math.abs(a * b) / KhanMath.getGCD(a, b);
-  },
-  primes: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97],
-  isPrime: function (n) {
-    if (n <= 1) {
-      return false;
-    }
-    if (n < 101) {
-      return !!$__default["default"].grep(KhanMath.primes, function (p, i) {
-        return Math.abs(p - n) <= 0.5;
-      }).length;
-    }
-    if (n <= 1 || n > 2 && n % 2 === 0) {
-      return false;
-    }
-    for (let i = 3, sqrt = Math.sqrt(n); i <= sqrt; i += 2) {
-      if (n % i === 0) {
-        return false;
-      }
-    }
-    return true;
-  },
-  // @ts-expect-error - TS2366 - Function lacks ending return statement and return type does not include 'undefined'.
-  getPrimeFactorization: function (number) {
-    if (number === 1) {
-      return [];
-    }
-    if (KhanMath.isPrime(number)) {
-      return [number];
-    }
-    const maxf = Math.sqrt(number);
-    for (let f = 2; f <= maxf; f++) {
-      if (number % f === 0) {
-        return $__default["default"].merge(KhanMath.getPrimeFactorization(f), KhanMath.getPrimeFactorization(number / f));
-      }
-    }
-  },
-  // Round a number to the nearest increment
-  // E.g., if increment = 30 and num = 40, return 30. if increment = 30 and
-  //     num = 45, return 60.
-  roundToNearest: function (increment, num) {
-    return Math.round(num / increment) * increment;
-  },
-  // Round a number to a certain number of decimal places
-  roundTo: function (precision, num) {
-    const factor = Math.pow(10, precision).toFixed(5);
-    // @ts-expect-error - TS2345 - Argument of type 'string' is not assignable to parameter of type 'number'. | TS2363 - The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. | TS2363 - The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type.
-    return Math.round((num * factor).toFixed(5)) / factor;
-  },
-  /**
-   * Return a string of num rounded to a fixed precision decimal places,
-   * with an approx symbol if num had to be rounded, and trailing 0s
-   */
-  toFixedApprox: function (num, precision) {
-    // TODO(aria): Make this locale-dependent
-    const fixedStr = num.toFixed(precision);
-    if (kmath.number.equal(+fixedStr, num)) {
-      return fixedStr;
-    }
-    return "\\approx " + fixedStr;
-  },
-  /**
-   * Return a string of num rounded to precision decimal places, with an
-   * approx symbol if num had to be rounded, but no trailing 0s if it was
-   * not rounded.
-   */
-  roundToApprox: function (num, precision) {
-    const fixed = KhanMath.roundTo(precision, num);
-    if (kmath.number.equal(fixed, num)) {
-      return String(fixed);
-    }
-    return KhanMath.toFixedApprox(num, precision);
-  },
-  // toFraction(4/8) => [1, 2]
-  // toFraction(0.666) => [333, 500]
-  // toFraction(0.666, 0.001) => [2, 3]
-  //
-  // tolerance can't be bigger than 1, sorry
-  toFraction: function (decimal, tolerance) {
-    if (tolerance == null) {
-      tolerance = Math.pow(2, -46);
-    }
-    if (decimal < 0 || decimal > 1) {
-      let fract = decimal % 1;
-      fract += fract < 0 ? 1 : 0;
-      const nd = KhanMath.toFraction(fract, tolerance);
-      nd[0] += Math.round(decimal - fract) * nd[1];
-      return nd;
-    }
-    if (Math.abs(Math.round(Number(decimal)) - decimal) <= tolerance) {
-      return [Math.round(decimal), 1];
-    }
-    let loN = 0;
-    let loD = 1;
-    let hiN = 1;
-    let hiD = 1;
-    let midN = 1;
-    let midD = 2;
-
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-      if (Math.abs(Number(midN / midD) - decimal) <= tolerance) {
-        return [midN, midD];
-      }
-      if (midN / midD < decimal) {
-        loN = midN;
-        loD = midD;
-      } else {
-        hiN = midN;
-        hiD = midD;
-      }
-      midN = loN + hiN;
-      midD = loD + hiD;
-    }
-  },
-  // Returns the format (string) of a given numeric string
-  // Note: purposively more inclusive than answer-types' predicate.forms
-  // That is, it is not necessarily true that interpreted input are numeric
-  getNumericFormat: function (text) {
-    text = $__default["default"].trim(text);
-    text = text.replace(/\u2212/, "-").replace(/([+-])\s+/g, "$1");
-    if (text.match(/^[+-]?\d+$/)) {
-      return "integer";
-    }
-    if (text.match(/^[+-]?\d+\s+\d+\s*\/\s*\d+$/)) {
-      return "mixed";
-    }
-    const fraction = text.match(/^[+-]?(\d+)\s*\/\s*(\d+)$/);
-    if (fraction) {
-      return parseFloat(fraction[1]) > parseFloat(fraction[2]) ? "improper" : "proper";
-    }
-    if (text.replace(/[,. ]/g, "").match(/^\d+$/)) {
-      return "decimal";
-    }
-    if (text.match(/(pi?|\u03c0|t(?:au)?|\u03c4|pau)/)) {
-      return "pi";
-    }
-    return null;
-  },
-  // Returns a string of the number in a specified format
-  toNumericString: function (number, format) {
-    if (number == null) {
-      return "";
-    }
-    if (number === 0) {
-      return "0"; // otherwise it might end up as 0% or 0pi
-    }
-
-    if (format === "percent") {
-      return number * 100 + "%";
-    }
-    if (format === "pi") {
-      const fraction = kmath.number.toFraction(number / Math.PI);
-      const numerator = Math.abs(fraction[0]);
-      const denominator = fraction[1];
-      if (kmath.number.isInteger(numerator)) {
-        const sign = number < 0 ? "-" : "";
-        const pi = "\u03C0";
-        return sign + (numerator === 1 ? "" : numerator) + pi + (denominator === 1 ? "" : "/" + denominator);
-      }
-    }
-    if (___default["default"](["proper", "improper", "mixed", "fraction"]).contains(format)) {
-      const fraction = kmath.number.toFraction(number);
-      const numerator = Math.abs(fraction[0]);
-      const denominator = fraction[1];
-      const sign = number < 0 ? "-" : "";
-      if (denominator === 1) {
-        return sign + numerator; // for integers, irrational, d > 1000
-      }
-
-      if (format === "mixed") {
-        const modulus = numerator % denominator;
-        const integer = (numerator - modulus) / denominator;
-        return sign + (integer ? integer + " " : "") + modulus + "/" + denominator;
-      } // otherwise proper, improper, or fraction
-      return sign + numerator + "/" + denominator;
-    }
-
-    // otherwise (decimal, float, long long)
-    return String(number);
-  }
-};
-function sum$1(array) {
-  return array.reduce(add$3, 0);
-}
-function add$3(a, b) {
-  return a + b;
-}
-
-/* eslint-disable no-useless-escape */
-const MAXERROR_EPSILON = Math.pow(2, -42);
-
-// TOOD(kevinb): Figure out how this relates to KEScore in
-// perseus-all-package/types.js and see if there's a way to
-// unify these types.
-/**
- * Answer types
- *
- * Utility for creating answerable questions displayed in exercises
- *
- * Different answer types produce different kinds of input displays, and do
- * different kinds of checking on the solutions.
- *
- * Each of the objects contain two functions, setup and createValidator.
- *
- * The setup function takes a solutionarea and solution, and performs setup
- * within the solutionarea, and then returns an object which contains:
- *
- * answer: a function which, when called, will retrieve the current answer from
- *         the solutionarea, which can then be validated using the validator
- *         function
- * validator: a function returned from the createValidator function (defined
- *            below)
- * solution: the correct answer to the problem
- * showGuess: a function which, when given a guess, shows the guess within the
- *            provided solutionarea
- * showGuessCustom: a function which displays parts of a guess that are not
- *                  within the solutionarea; currently only used for custom
- *                  answers
- *
- * The createValidator function only takes a solution, and it returns a
- * function which can be used to validate an answer.
- *
- * The resulting validator function returns:
- * - true: if the answer is fully correct
- * - false: if the answer is incorrect
- * - "" (the empty string): if no answer has been provided (e.g. the answer box
- *   is left unfilled)
- * - a string: if there is some slight error
- *
- * In most cases, setup and createValidator don't really need the solution DOM
- * element so we have setupFunctional and createValidatorFunctional for them
- * which take only $solution.text() and $solution.data(). This makes it easier
- * to reuse specific answer types.
- *
- * TODO(alpert): Think of a less-absurd name for createValidatorFunctional.
- *
- */
-const KhanAnswerTypes = {
-  /*
-   * predicate answer type
-   *
-   * performs simple predicate-based checking of a numeric solution, with
-   * different kinds of number formats
-   *
-   * Uses the data-forms option on the solution to choose which number formats
-   * are acceptable. Available data-forms:
-   *
-   * - integer:  3
-   * - proper:   3/5
-   * - improper: 5/3
-   * - pi:       3 pi
-   * - log:      log(5)
-   * - percent:  15%
-   * - mixed:    1 1/3
-   * - decimal:  1.7
-   *
-   * The solution should be a predicate of the form:
-   *
-   * function(guess, maxError) {
-   *     return abs(guess - 3) < maxError;
-   * }
-   *
-   */
-  predicate: {
-    defaultForms: "integer, proper, improper, mixed, decimal",
-    createValidatorFunctional: function (predicate, options, strings) {
-      // Extract the options from the given solution object
-      options = ___default["default"].extend({
-        simplify: "required",
-        ratio: false,
-        forms: KhanAnswerTypes.predicate.defaultForms
-      }, options);
-      let acceptableForms;
-      // this is maintaining backwards compatibility
-      // TODO(merlob) fix all places that depend on this, then delete
-      if (!___default["default"].isArray(options.forms)) {
-        acceptableForms = options.forms.split(/\s*,\s*/);
-      } else {
-        acceptableForms = options.forms;
-      }
-
-      // TODO(jack): remove options.inexact in favor of options.maxError
-      if (options.inexact === undefined) {
-        // If we aren't allowing inexact, ensure that we don't have a
-        // large maxError as well.
-        options.maxError = 0;
-      }
-      // Allow a small tolerance on maxError, to avoid numerical
-      // representation issues (2.3 should be correct for a solution of
-      // 2.45 with maxError=0.15).
-      options.maxError = +options.maxError + MAXERROR_EPSILON;
-
-      // If percent is an acceptable form, make sure it's the last one
-      // in the list so we don't prematurely complain about not having
-      // a percent sign when the user entered the correct answer in a
-      // different form (such as a decimal or fraction)
-      if (___default["default"].contains(acceptableForms, "percent")) {
-        acceptableForms = ___default["default"].without(acceptableForms, "percent");
-        acceptableForms.push("percent");
-      }
-
-      // Take text looking like a fraction, and turn it into a number
-      const fractionTransformer = function (text) {
-        text = text
-        // Replace unicode minus sign with hyphen
-        .replace(/\u2212/, "-")
-        // Remove space after +, -
-        .replace(/([+-])\s+/g, "$1")
-        // Remove leading/trailing whitespace
-        .replace(/(^\s*)|(\s*$)/gi, "");
-
-        // Extract numerator and denominator
-        const match = text.match(/^([+-]?\d+)\s*\/\s*([+-]?\d+)$/);
-        // Fractions are represented as "-\frac{numerator}{denominator}"
-        // in Mobile device input instead of "numerator/denominator" as
-        // in web-browser.
-        const mobileDeviceMatch = text.match(/^([+-]?)\\frac\{([+-]?\d+)\}\{([+-]?\d+)\}$/);
-        const parsedInt = parseInt(text, 10);
-        if (match || mobileDeviceMatch) {
-          let num;
-          let denom;
-          let simplified = true;
-          if (match) {
-            num = parseFloat(match[1]);
-            denom = parseFloat(match[2]);
-          } else {
-            num = parseFloat(mobileDeviceMatch[2]);
-            if (mobileDeviceMatch[1] === "-") {
-              if (num < 0) {
-                simplified = false;
-              }
-              num = -num;
-            }
-            denom = parseFloat(mobileDeviceMatch[3]);
-          }
-          simplified = simplified && denom > 0 && (options.ratio || denom !== 1) && KhanMath.getGCD(num, denom) === 1;
-          return [{
-            value: num / denom,
-            exact: simplified
-          }];
-        }
-        if (!isNaN(parsedInt) && "" + parsedInt === text) {
-          return [{
-            value: parsedInt,
-            exact: true
-          }];
-        }
-        return [];
-      };
-
-      /*
-       * Different forms of numbers
-       *
-       * Each function returns a list of objects of the form:
-       *
-       * {
-       *    value: numerical value,
-       *    exact: true/false
-       * }
-       */
-      const forms = {
-        // integer, which is encompassed by decimal
-        integer: function (text) {
-          // Compare the decimal form to the decimal form rounded to
-          // an integer. Only accept if the user actually entered an
-          // integer.
-          const decimal = forms.decimal(text);
-          const rounded = forms.decimal(text, 1);
-          if (decimal[0].value != null && decimal[0].value === rounded[0].value || decimal[1].value != null && decimal[1].value === rounded[1].value) {
-            return decimal;
-          }
-          return [];
-        },
-        // A proper fraction
-        proper: function (text) {
-          return $__default["default"].map(fractionTransformer(text), function (o) {
-            // All fractions that are less than 1
-            if (Math.abs(o.value) < 1) {
-              return [o];
-            }
-            return [];
-          });
-        },
-        // an improper fraction
-        improper: function (text) {
-          return $__default["default"].map(fractionTransformer(text), function (o) {
-            // All fractions that are greater than 1
-            if (Math.abs(o.value) >= 1) {
-              return [o];
-            }
-            return [];
-          });
-        },
-        // pi-like numbers
-        pi: function (text) {
-          let match;
-          let possibilities = [];
-
-          // Replace unicode minus sign with hyphen
-          text = text.replace(/\u2212/, "-");
-
-          // - pi
-          // (Note: we also support \pi (for TeX), p, tau (and \tau,
-          // and t), pau.)
-          if (match = text.match(/^([+-]?)\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i)) {
-            possibilities = [{
-              value: parseFloat(match[1] + "1"),
-              exact: true
-            }];
-
-            // 5 / 6 pi
-          } else if (match = text.match(/^([+-]?\s*\d+\s*(?:\/\s*[+-]?\s*\d+)?)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i)) {
-            possibilities = fractionTransformer(match[1]);
-
-            // 4 5 / 6 pi
-          } else if (match = text.match(/^([+-]?)\s*(\d+)\s*([+-]?\d+)\s*\/\s*([+-]?\d+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i)) {
-            const sign = parseFloat(match[1] + "1");
-            const integ = parseFloat(match[2]);
-            const num = parseFloat(match[3]);
-            const denom = parseFloat(match[4]);
-            const simplified = num < denom && KhanMath.getGCD(num, denom) === 1;
-            possibilities = [{
-              value: sign * (integ + num / denom),
-              exact: simplified
-            }];
-
-            // 5 pi / 6
-          } else if (match = text.match(/^([+-]?\s*\d+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)\s*(?:\/\s*([+-]?\s*\d+))?$/i)) {
-            possibilities = fractionTransformer(match[1] + "/" + match[3]);
-
-            // - pi / 4
-          } else if (match = text.match(/^([+-]?)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)\s*(?:\/\s*([+-]?\d+))?$/i)) {
-            possibilities = fractionTransformer(match[1] + "1/" + match[3]);
-
-            // 0
-          } else if (text === "0") {
-            possibilities = [{
-              value: 0,
-              exact: true
-            }];
-
-            // 0.5 pi (fallback)
-          } else if (match = text.match(/^(.+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i)) {
-            possibilities = forms.decimal(match[1]);
-          } else {
-            possibilities = ___default["default"].reduce(KhanAnswerTypes.predicate.defaultForms.split(/\s*,\s*/), function (memo, form) {
-              return memo.concat(forms[form](text));
-            }, []);
-
-            // If the answer is a floating point number that's
-            // near a multiple of pi, mark is as being possibly
-            // an approximation of pi.  We actually check if
-            // it's a plausible approximation of pi/12, since
-            // sometimes the correct answer is like pi/3 or pi/4.
-            // We also say it's a pi-approximation if it involves
-            // x/7 (since 22/7 is an approximation of pi.)
-            // Never mark an integer as being an approximation
-            // of pi.
-            let approximatesPi = false;
-            const number = parseFloat(text);
-            if (!isNaN(number) && number !== parseInt(text)) {
-              const piMult = Math.PI / 12;
-              const roundedNumber = piMult * Math.round(number / piMult);
-              if (Math.abs(number - roundedNumber) < 0.01) {
-                approximatesPi = true;
-              }
-            } else if (text.match(/\/\s*7/)) {
-              approximatesPi = true;
-            }
-            if (approximatesPi) {
-              ___default["default"].each(possibilities, function (possibility) {
-                possibility.piApprox = true;
-              });
-            }
-            return possibilities;
-          }
-          let multiplier = Math.PI;
-          if (text.match(/\\?tau|t|\u03c4/)) {
-            multiplier = Math.PI * 2;
-          }
-
-          // We're taking an early stand along side xkcd in the
-          // inevitable ti vs. pau debate... http://xkcd.com/1292
-          if (text.match(/pau/)) {
-            multiplier = Math.PI * 1.5;
-          }
-          $__default["default"].each(possibilities, function (ix, possibility) {
-            possibility.value *= multiplier;
-          });
-          return possibilities;
-        },
-        // Converts '' to 1 and '-' to -1 so you can write "[___] x"
-        // and accept sane things
-        coefficient: function (text) {
-          let possibilities = [];
-
-          // Replace unicode minus sign with hyphen
-          text = text.replace(/\u2212/, "-");
-          if (text === "") {
-            possibilities = [{
-              value: 1,
-              exact: true
-            }];
-          } else if (text === "-") {
-            possibilities = [{
-              value: -1,
-              exact: true
-            }];
-          }
-          return possibilities;
-        },
-        // simple log(c) form
-        log: function (text) {
-          let match;
-          let possibilities = [];
-
-          // Replace unicode minus sign with hyphen
-          text = text.replace(/\u2212/, "-");
-          text = text.replace(/[ \(\)]/g, "");
-          if (match = text.match(/^log\s*(\S+)\s*$/i)) {
-            // @ts-expect-error - TS2322 - Type '{ value: number | undefined; exact: boolean; }[]' is not assignable to type 'never[]'.
-            possibilities = forms.decimal(match[1]);
-          } else if (text === "0") {
-            // @ts-expect-error - TS2322 - Type 'number' is not assignable to type 'never'. | TS2322 - Type 'boolean' is not assignable to type 'never'.
-            possibilities = [{
-              value: 0,
-              exact: true
-            }];
-          }
-          return possibilities;
-        },
-        // Numbers with percent signs
-        percent: function (text) {
-          text = $__default["default"].trim(text);
-          // store whether or not there is a percent sign
-          let hasPercentSign = false;
-          if (text.indexOf("%") === text.length - 1) {
-            text = $__default["default"].trim(text.substring(0, text.length - 1));
-            hasPercentSign = true;
-          }
-          const transformed = forms.decimal(text);
-          $__default["default"].each(transformed, function (ix, t) {
-            t.exact = hasPercentSign;
-            // @ts-expect-error - TS2532 - Object is possibly 'undefined'.
-            t.value = t.value / 100;
-          });
-          return transformed;
-        },
-        // Mixed numbers, like 1 3/4
-        mixed: function (text) {
-          const match = text
-          // Replace unicode minus sign with hyphen
-          .replace(/\u2212/, "-")
-          // Remove space after +, -
-          .replace(/([+-])\s+/g, "$1")
-          // Extract integer, numerator and denominator
-          .match(/^([+-]?)(\d+)\s+(\d+)\s*\/\s*(\d+)$/);
-          if (match) {
-            const sign = parseFloat(match[1] + "1");
-            const integ = parseFloat(match[2]);
-            const num = parseFloat(match[3]);
-            const denom = parseFloat(match[4]);
-            const simplified = num < denom && KhanMath.getGCD(num, denom) === 1;
-            return [{
-              value: sign * (integ + num / denom),
-              exact: simplified
-            }];
-          }
-          return [];
-        },
-        // Decimal numbers -- compare entered text rounded to
-        // 'precision' Reciprical of the precision against the correct
-        // answer. We round to 1/1e10 by default, which is healthily
-        // less than machine epsilon but should be more than any real
-        // decimal answer would use. (The 'integer' answer type uses
-        // precision == 1.)
-        decimal: function (text) {
-          let precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1e10;
-          const normal = function (text) {
-            text = $__default["default"].trim(text);
-            const match = text
-            // Replace unicode minus sign with hyphen
-            .replace(/\u2212/, "-")
-            // Remove space after +, -
-            .replace(/([+-])\s+/g, "$1")
-            // Extract integer, numerator and denominator. If
-            // commas or spaces are used, they must be in the
-            // "correct" places
-            .match(/^([+-]?(?:\d{1,3}(?:[, ]?\d{3})*\.?|\d{0,3}(?:[, ]?\d{3})*\.(?:\d{3}[, ]?)*\d{1,3}))$/);
-
-            // You can't start a number with `0,`, to prevent us
-            // interpeting '0.342' as correct for '342'
-            const badLeadingZero = text.match(/^0[0,]*,/);
-            if (match && !badLeadingZero) {
-              let x = parseFloat(match[1].replace(/[, ]/g, ""));
-              if (options.inexact === undefined) {
-                x = Math.round(x * precision) / precision;
-              }
-              return x;
-            }
-          };
-          const commas = function (text) {
-            text = text.replace(/([\.,])/g, function (_, c) {
-              return c === "." ? "," : ".";
-            });
-            return normal(text);
-          };
-          return [{
-            value: normal(text),
-            exact: true
-          }, {
-            value: commas(text),
-            exact: true
-          }];
-        }
-      };
-
-      // validator function
-      return function (guess) {
-        // The fallback variable is used in place of the answer, if no
-        // answer is provided (i.e. the field is left blank)
-        const fallback = options.fallback != null ? "" + options.fallback : "";
-        guess = $__default["default"].trim(guess) || fallback;
-        const score = {
-          empty: guess === "",
-          correct: false,
-          message: null,
-          guess: guess
-        };
-
-        // iterate over all the acceptable forms, and if one of the
-        // answers is correct, return true
-        $__default["default"].each(acceptableForms, function (i, form) {
-          const transformed = forms[form](guess);
-          for (let j = 0, l = transformed.length; j < l; j++) {
-            const val = transformed[j].value;
-            const exact = transformed[j].exact;
-            const piApprox = transformed[j].piApprox;
-            // If a string was returned, and it exactly matches,
-            // return true
-            if (predicate(val, options.maxError)) {
-              // If the exact correct number was returned,
-              // return true
-              if (exact || options.simplify === "optional") {
-                score.correct = true;
-                score.message = options.message || null;
-                // If the answer is correct, don't say it's
-                // empty. This happens, for example, with the
-                // coefficient type where guess === "" but is
-                // interpreted as "1" which is correct.
-                score.empty = false;
-              } else if (form === "percent") {
-                // Otherwise, an error was returned
-                score.empty = true;
-                score.message = strings.MISSING_PERCENT_ERROR;
-              } else {
-                if (options.simplify !== "enforced") {
-                  score.empty = true;
-                }
-                score.message = strings.NEEDS_TO_BE_SIMPLFIED_ERROR;
-              }
-              // The return false below stops the looping of the
-              // callback since predicate check  succeeded.
-              // No more forms to look to verify the user guess.
-              return false;
-            }
-            if (piApprox && predicate(val, Math.abs(val * 0.001))) {
-              score.empty = true;
-              score.message = strings.APPROXIMATED_PI_ERROR;
-            }
-          }
-        });
-        if (score.correct === false) {
-          let interpretedGuess = false;
-          ___default["default"].each(forms, function (form) {
-            const anyAreNaN = ___default["default"].any(form(guess), function (t) {
-              return t.value != null && !___default["default"].isNaN(t.value);
-            });
-            if (anyAreNaN) {
-              interpretedGuess = true;
-            }
-          });
-          if (!interpretedGuess) {
-            score.empty = true;
-            score.message = strings.EXTRA_SYMBOLS_ERROR;
-            return score;
-          }
-        }
-        return score;
-      };
-    }
-  },
-  /*
-   * number answer type
-   *
-   * wraps the predicate answer type to performs simple number-based checking
-   * of a solution
-   */
-  number: {
-    convertToPredicate: function (correctAnswer, options) {
-      const correctFloat = parseFloat(correctAnswer);
-      return [function (guess, maxError) {
-        return Math.abs(guess - correctFloat) < maxError;
-      }, $__default["default"].extend({}, options, {
-        type: "predicate"
-      })];
-    },
-    createValidatorFunctional: function (correctAnswer, options, strings) {
-      return KhanAnswerTypes.predicate.createValidatorFunctional(...KhanAnswerTypes.number.convertToPredicate(correctAnswer, options), strings);
-    }
-  },
-  /*
-   * The expression answer type parses a given expression or equation
-   * and semantically compares it to the solution. In addition, instant
-   * feedback is provided by rendering the last answer that fully parsed.
-   *
-   * Parsing options:
-   * functions (e.g. data-functions="f g h")
-   *     A space or comma separated list of single-letter variables that
-   *     should be interpreted as functions. Case sensitive. "e" and "i"
-   *     are reserved.
-   *
-   *     no functions specified: f(x+y) == fx + fy
-   *     with "f" as a function: f(x+y) != fx + fy
-   *
-   * Comparison options:
-   * same-form (e.g. data-same-form)
-   *     If present, the answer must match the solution's structure in
-   *     addition to evaluating the same. Commutativity and excess negation
-   *     are ignored, but all other changes will trigger a rejection. Useful
-   *     for requiring a particular form of an equation, or if the answer
-   *     must be factored.
-   *
-   *     example question:    Factor x^2 + x - 2
-   *     example solution:    (x-1)(x+2)
-   *     accepted answers:    (x-1)(x+2), (x+2)(x-1), ---(-x-2)(-1+x), etc.
-   *     rejected answers:    x^2+x-2, x*x+x-2, x(x+1)-2, (x-1)(x+2)^1, etc.
-   *     rejection message:   Your answer is not in the correct form
-   *
-   * simplify (e.g. data-simplify)
-   *     If present, the answer must be fully expanded and simplified. Use
-   *     carefully - simplification is hard and there may be bugs, or you
-   *     might not agree on the definition of "simplified" used. You will
-   *     get an error if the provided solution is not itself fully expanded
-   *     and simplified.
-   *
-   *     example question:    Simplify ((n*x^5)^5) / (n^(-2)*x^2)^-3
-   *     example solution:    x^31 / n
-   *     accepted answers:    x^31 / n, x^31 / n^1, x^31 * n^(-1), etc.
-   *     rejected answers:    (x^25 * n^5) / (x^(-6) * n^6), etc.
-   *     rejection message:   Your answer is not fully expanded and simplified
-   *
-   * Rendering options:
-   * times (e.g. data-times)
-   *     If present, explicit multiplication (such as between numbers) will
-   *     be rendered with a cross/x symbol (TeX: \times) instead of the usual
-   *     center dot (TeX: \cdot).
-   *
-   *     normal rendering:    2 * 3^x -> 2 \cdot 3^{x}
-   *     but with "times":    2 * 3^x -> 2 \times 3^{x}
-   */
-  expression: {
-    parseSolution: function (solutionString, options) {
-      let solution = KAS__namespace.parse(solutionString, options);
-      if (!solution.parsed) {
-        throw new perseusCore.PerseusError("The provided solution (" + solutionString + ") didn't parse.", perseusCore.Errors.InvalidInput);
-      } else if (options.simplified && !solution.expr.isSimplified()) {
-        throw new perseusCore.PerseusError("The provided solution (" + solutionString + ") isn't fully expanded and simplified.", perseusCore.Errors.InvalidInput);
-      } else {
-        solution = solution.expr;
-      }
-      return solution;
-    },
-    createValidatorFunctional: function (solution, options, strings) {
-      return function (guess) {
-        const score = {
-          empty: false,
-          correct: false,
-          message: null,
-          guess: guess,
-          // Setting `ungraded` to true indicates that if the
-          // guess doesn't match any of the solutions, the guess
-          // shouldn't be marked as incorrect; instead, `message`
-          // should be shown to the user. This is different from
-          // setting `empty` to true, since the behavior of `empty`
-          // is that `message` only will be shown if the guess is
-          // graded as empty for every solution.
-          ungraded: false
-        };
-
-        // Don't bother parsing an empty input
-        if (!guess) {
-          // @ts-expect-error - TS2540 - Cannot assign to 'empty' because it is a read-only property.
-          score.empty = true;
-          return score;
-        }
-        const answer = KAS__namespace.parse(guess, options);
-
-        // An unsuccessful parse doesn't count as wrong
-        if (!answer.parsed) {
-          // @ts-expect-error - TS2540 - Cannot assign to 'empty' because it is a read-only property.
-          score.empty = true;
-          return score;
-        }
-
-        // Solution will need to be parsed again if we're creating
-        // this from a multiple question type
-        if (typeof solution === "string") {
-          solution = KhanAnswerTypes.expression.parseSolution(solution, options);
-        }
-        const result = KAS__namespace.compare(answer.expr, solution, options);
-        if (result.equal) {
-          // Correct answer
-          // @ts-expect-error - TS2540 - Cannot assign to 'correct' because it is a read-only property.
-          score.correct = true;
-        } else if (result.wrongVariableNames || result.wrongVariableCase) {
-          // We don't want to give people an error for getting the
-          // variable names or the variable case wrong.
-          // TODO(aasmund): This should ideally have been handled
-          // under the `result.message` condition, but the
-          // KAS messages currently aren't translatable.
-          // @ts-expect-error - TS2540 - Cannot assign to 'ungraded' because it is a read-only property.
-          score.ungraded = true;
-          // @ts-expect-error - TS2540 - Cannot assign to 'message' because it is a read-only property.
-          score.message = result.wrongVariableCase ? strings.WRONG_CASE_ERROR : strings.WRONG_LETTER_ERROR;
-          // Don't tell the use they're "almost there" in this case, that may not be true and isn't helpful.
-          // @ts-expect-error - TS2339 - Property 'suppressAlmostThere' does not exist on type '{ readonly empty: false; readonly correct: false; readonly message: string | null | undefined; readonly guess: any; readonly ungraded: false; }'.
-          score.suppressAlmostThere = true;
-        } else if (result.message) {
-          // Nearly correct answer
-          // TODO(aasmund): This message also isn't translatable;
-          // need to fix that in KAS
-          // @ts-expect-error - TS2540 - Cannot assign to 'message' because it is a read-only property.
-          score.message = result.message;
-        } else {
-          // Replace x with * and see if it would have been correct
-          // TODO(aasmund): I think this branch is effectively dead,
-          // because the replacement will only work in situations
-          // where the variables are wrong (except if the variable
-          // is x, in which case the replacement won't work either),
-          // which is handled by another branch. When we implement a
-          // more sophisticated variable check, revive this or
-          // remove it completely if it will never come into play.
-          const answerX = KAS__namespace.parse(guess.replace(/[xX]/g, "*"), options);
-          if (answerX.parsed) {
-            const resultX = KAS__namespace.compare(answerX.expr, solution, options);
-            if (resultX.equal) {
-              // @ts-expect-error - TS2540 - Cannot assign to 'ungraded' because it is a read-only property.
-              score.ungraded = true;
-              // @ts-expect-error - TS2540 - Cannot assign to 'message' because it is a read-only property.
-              score.message = strings.MULTIPLICATION_SIGN_ERROR;
-            } else if (resultX.message) {
-              // TODO(aasmund): I18nize `score.message`
-              // @ts-expect-error - TS2540 - Cannot assign to 'message' because it is a read-only property.
-              score.message = resultX.message + " Also, I'm a computer. I only understand " + "multiplication if you use an " + "asterisk (*) as the multiplication " + "sign.";
-            }
-          }
-        }
-        return score;
-      };
-    }
-  }
-};
-
 /**
  * Checks user input from the expression widget to see if it is scorable.
  *
@@ -2439,10 +1715,10 @@ function scoreExpression(userInput, rubric, strings, locale) {
       });
       return null;
     }
-    return KhanAnswerTypes.expression.createValidatorFunctional(expression.expr, ___default["default"]({}).extend(options, {
+    return perseusScore.KhanAnswerTypes.expression.createValidatorFunctional(expression.expr, ___default["default"]({}).extend(options, {
       simplify: answer.simplify,
       form: answer.form
-    }), strings);
+    }));
   };
 
   // Find the first answer form that matches the user's input and that
@@ -3108,14 +2384,14 @@ const split = "x".split(/(.)/g).length ? function (str, r) {
 function firstNumericalParse$1(text, strings) {
   // TODO(alpert): This is sort of hacky...
   let first;
-  const val = KhanAnswerTypes.predicate.createValidatorFunctional(function (ans) {
+  const val = perseusScore.KhanAnswerTypes.predicate.createValidatorFunctional(function (ans) {
     first = ans;
     return true; /* break */
   }, {
     simplify: "optional",
     inexact: true,
     forms: "integer, proper, improper, pi, log, mixed, decimal"
-  }, strings);
+  });
   val(text);
   return first;
 }
@@ -9128,7 +8404,7 @@ var Tex$1 = {
       text = text != null ? text + "" : "";
 
       // Attempt to clean up some of the math
-      text = KhanMath.cleanMath(text);
+      text = kmath.KhanMath.cleanMath(text);
 
       // Store the formula that we're using
       $elem.attr("data-math-formula", text);
@@ -9815,7 +9091,7 @@ class Graphie$1 {
         return "z";
       }
       const scaled = alreadyScaled ? point : this.scalePoint(point);
-      return (i === 0 ? "M" : "L") + KhanMath.bound(scaled[0]) + " " + KhanMath.bound(scaled[1]);
+      return (i === 0 ? "M" : "L") + kmath.KhanMath.bound(scaled[0]) + " " + kmath.KhanMath.bound(scaled[1]);
     }).join("");
   };
   svgParabolaPath = (a, b, c) => {
@@ -9851,7 +9127,7 @@ class Graphie$1 {
 
     // Scale and bound
     const points = [left, control, right].map(this.scalePoint);
-    const values = points.flat().map(KhanMath.bound);
+    const values = points.flat().map(kmath.KhanMath.bound);
     return "M" + values[0] + "," + values[1] + " Q" + values[2] + "," + values[3] + " " + values[4] + "," + values[5];
   };
   svgSinusoidPath = (a, b, c, d) => {
@@ -10901,7 +10177,7 @@ class Arrowhead$1 extends WrappedPath {
   }
   toCoordAtAngle(coord, angle) {
     const clipPoint = this.graphie.scalePoint(getClipPoint(this.graphie, coord, angle));
-    this.transform("translateX(" + (clipPoint[0] + Arrowhead$1.scale * this.center[0]) + "px) " + "translateY(" + (clipPoint[1] + Arrowhead$1.scale * this.center[1]) + "px) " + "translateZ(0) " + "rotate(" + (360 - KhanMath.bound(angle)) + "deg)");
+    this.transform("translateX(" + (clipPoint[0] + Arrowhead$1.scale * this.center[0]) + "px) " + "translateY(" + (clipPoint[1] + Arrowhead$1.scale * this.center[1]) + "px) " + "translateZ(0) " + "rotate(" + (360 - kmath.KhanMath.bound(angle)) + "deg)");
   }
 }
 
@@ -11025,9 +10301,9 @@ class WrappedLine extends WrappedDrawing {
     // Compute transformation parameters
     const polarDiff = kmath.vector.polarDegFromCart(kmath.vector.subtract(scaledEnd, scaledStart));
     const lineLength = polarDiff[0];
-    const angle = KhanMath.bound(polarDiff[1]);
+    const angle = kmath.KhanMath.bound(polarDiff[1]);
     const delta = kmath.vector.subtract(scaledStart, this.initialPoint);
-    const scale = KhanMath.bound(lineLength / this.initialLength);
+    const scale = kmath.KhanMath.bound(lineLength / this.initialLength);
 
     // Construct and apply transformation string
     const do3dTransform = InteractiveUtil.getCanUse3dTransform();
@@ -11133,7 +10409,7 @@ function clockwise$1(points) {
     const p2 = segment[1];
     return (p2[0] - p1[0]) * (p2[1] + p1[1]);
   });
-  return sum$1(areas) > 0;
+  return kmath.sum(areas) > 0;
 }
 function magnitude(v) {
   return Math.sqrt(___default["default"].reduce(v, function (memo, el) {
@@ -11380,7 +10656,7 @@ ___default["default"].extend(GraphUtils.Graphie.prototype, {
       const match = text.match(/\$deg(\d)?/);
       if (match) {
         const precision = match[1] || 1;
-        text = text.replace(match[0], KhanMath.toFixedApprox(angle, precision) + "^{\\circ}");
+        text = text.replace(match[0], kmath.KhanMath.toFixedApprox(angle, precision) + "^{\\circ}");
       }
       const sOffset = scaledPolarDeg(sRadius + 15, halfAngle);
       const sPosition = kmath.vector.add(sVertex, sOffset);
@@ -11473,7 +10749,7 @@ ___default["default"].extend(GraphUtils.Graphie.prototype, {
       if (match) {
         const distance = GraphUtils.getDistance(p1, p2);
         const precision = match[1] || 1;
-        text = text.replace(match[0], KhanMath.toFixedApprox(distance, precision));
+        text = text.replace(match[0], kmath.KhanMath.toFixedApprox(distance, precision));
       }
       const sOffset = 20;
       const sOffsetVector = scaledPolarRad(sOffset, perpendicularAngle);
@@ -11696,8 +10972,8 @@ ___default["default"].extend(GraphUtils.Graphie.prototype, {
         // convert back to coordinates relative to graphie canvas
         mouseX = mouseXrel + centerX;
         mouseY = -mouseYrel + centerY;
-        coordX = KhanMath.roundTo(5, mouseX / graph.scale[0] + graph.range[0][0]);
-        coordY = KhanMath.roundTo(5, graph.range[1][1] - mouseY / graph.scale[1]);
+        coordX = kmath.KhanMath.roundTo(5, mouseX / graph.scale[0] + graph.range[0][0]);
+        coordY = kmath.KhanMath.roundTo(5, graph.range[1][1] - mouseY / graph.scale[1]);
       }
       const result = movablePoint.applyConstraint([coordX, coordY]);
       return result;
@@ -14869,54 +14145,6 @@ var MovableLineOptions = {
   }
 };
 
-/**
- * A work-in-progress of _ methods for objects.
- * That is, they take an object as a parameter,
- * and return an object instead of an array.
- *
- * TODO(aria): Move this out of interactive2
- */
-
-/**
- * Does a pluck on keys inside objects in an object
- *
- * Ex:
- * tools = {
- *     translation: {
- *         enabled: true
- *     },
- *     rotation: {
- *         enabled: false
- *     }
- * };
- * pluckObject(tools, "enabled") returns {
- *     translation: true
- *     rotation: false
- * }
- */
-const pluck = function (table, subKey) {
-  return ___default["default"].object(___default["default"].map(table, function (value, key) {
-    return [key, value[subKey]];
-  }));
-};
-
-/**
- * Maps an object to an object
- *
- * > mapObject({a: '1', b: '2'}, (value, key) => {
- *       return value + 1;
- *   });
- * {a: 2, b: 3}
- */
-const mapObject = function (obj, lambda) {
-  const result = {};
-  Object.keys(obj).forEach(key => {
-    // @ts-expect-error - TS2345 - Argument of type 'string' is not assignable to parameter of type 'K'.
-    result[key] = lambda(obj[key], key);
-  });
-  return result;
-};
-
 /**
  * MovableLine
  */
@@ -14981,7 +14209,7 @@ ___default["default"].extend(MovableLine$4.prototype, {
     //    - are objects, not primitives (and need a deeper copy)
     //    - they don't need getters created for them
     // TODO(jack): Consider "default" once we es3ify perseus
-    pluck(MovableLineOptions, "standard")), DEFAULT_PROPS$2);
+    perseusCore.pluck(MovableLineOptions, "standard")), DEFAULT_PROPS$2);
   },
   /**
    * Resets the object to its state as if it were constructed with
@@ -15488,7 +14716,7 @@ class MovablePoint$5 {
       //    - are objects, not primitives (and need a deeper copy)
       //    - they don't need getters created for them
       // TODO(jack): Consider "default" once we es3ify perseus
-      pluck(MovablePointOptions, "standard")
+      perseusCore.pluck(MovablePointOptions, "standard")
       // We only update props here, because we want things on state to
       // be persistent, and updated appropriately in modify()
       ),
@@ -16389,7 +15617,7 @@ ___default["default"].extend(MovablePolygon.prototype, {
     //    - are objects, not primitives (and need a deeper copy)
     //    - they don't need getters created for them
     // TODO(jack): Consider "default" once we es3ify perseus
-    pluck(MovablePolygonOptions, "standard")
+    perseusCore.pluck(MovablePolygonOptions, "standard")
 
     // We only update props here, because we want things on state to
     // be persistent, and updated appropriately in modify()
@@ -18774,7 +18002,7 @@ const inlineNodeTypes = {
 
 // @ts-expect-error - TS2345 - Argument of type '{ readonly columns: { readonly react: (node: any, output: any, state: any) => Element; readonly order: -2; readonly match: any; readonly parse: (capture: any, parse: any, state: any) => any; }; ... 35 more ...; readonly text: TextInOutRule; }' is not assignable to parameter of type 'ParserRules'.
 const builtParser$1 = SimpleMarkdown__default["default"].parserFor(rules$1);
-const parse$3 = (source, state) => {
+const parse$4 = (source, state) => {
   const paragraphedSource = source + "\n\n";
   return builtParser$1(paragraphedSource, {
     ...state,
@@ -18859,14 +18087,14 @@ const getContent = ast => {
  */
 const characterCount = source => {
   // @ts-expect-error - TS2554 - Expected 2 arguments, but got 1.
-  const ast = parse$3(source);
+  const ast = parse$4(source);
   const content = getContent(ast).join("");
   return content.length;
 };
 var PerseusMarkdown = {
   characterCount: characterCount,
   traverseContent: traverseContent,
-  parse: parse$3,
+  parse: parse$4,
   parseInline: inlineParser,
   reactFor: SimpleMarkdown__default["default"].reactFor,
   ruleOutput: SimpleMarkdown__default["default"].ruleOutput(rules$1, "react"),
@@ -19569,7 +18797,7 @@ var widgets$1 = /*#__PURE__*/Object.freeze({
 
 function getUpgradedWidgetOptions(oldWidgetOptions) {
   // @ts-expect-error - TS2322 - Type '(props: Props) => Partial<Record<string, CategorizerWidget | CSProgramWidget | DefinitionWidget | DropdownWidget | ... 35 more ... | VideoWidget>>' is not assignable to type '(props: Props) => { [key: string]: PerseusWidget; }'.
-  return mapObject(oldWidgetOptions, (widgetInfo, widgetId) => {
+  return perseusCore.mapObject(oldWidgetOptions, (widgetInfo, widgetId) => {
     if (!widgetInfo.type || !widgetInfo.alignment) {
       const newValues = {};
       if (!widgetInfo.type) {
@@ -20295,7 +19523,7 @@ class Renderer extends React__namespace.Component {
    * state from that instead of the current widget props.
    */
   getSerializedState = widgetProps => {
-    return mapObject(widgetProps || this.state.widgetProps, (props, widgetId) => {
+    return perseusCore.mapObject(widgetProps || this.state.widgetProps, (props, widgetId) => {
       const widget = this.getWidgetInstance(widgetId);
       if (widget && widget.getSerializedState) {
         return widget.getSerializedState();
@@ -20331,7 +19559,7 @@ class Renderer extends React__namespace.Component {
       }
     };
     this.setState({
-      widgetProps: mapObject(serializedState, (props, widgetId) => {
+      widgetProps: perseusCore.mapObject(serializedState, (props, widgetId) => {
         const widget = this.getWidgetInstance(widgetId);
         if (widget && widget.restoreSerializedState) {
           // Note that we probably can't call
@@ -22118,12 +21346,12 @@ function scoreInputNumber(userInput, rubric, strings) {
   // `KhanAnswerTypes.number.convertToPredicate`, but a string is
   // expected here
   const stringValue = `${rubric.value}`;
-  const val = KhanAnswerTypes.number.createValidatorFunctional(stringValue, {
+  const val = perseusScore.KhanAnswerTypes.number.createValidatorFunctional(stringValue, {
     simplify: rubric.simplify,
     inexact: rubric.inexact || undefined,
     maxError: rubric.maxError,
     forms: answerTypes[rubric.answerType].forms
-  }, strings);
+  });
 
   // We may have received TeX; try to parse it before grading.
   // If `currentValue` is not TeX, this should be a no-op.
@@ -22450,14 +21678,14 @@ function scoreNumericInput(userInput, rubric, strings) {
     if (!answer.strict || validatorForms.length === 0) {
       validatorForms.push(...defaultAnswerForms);
     }
-    return KhanAnswerTypes.number.createValidatorFunctional(stringAnswer, {
+    return perseusScore.KhanAnswerTypes.number.createValidatorFunctional(stringAnswer, {
       message: answer.message,
       simplify: answer.status === "correct" ? answer.simplify : "optional",
       inexact: true,
       // TODO(merlob) backfill / delete
       maxError: answer.maxError,
       forms: validatorForms
-    }, strings);
+    });
   };
 
   // We may have received TeX; try to parse it before grading.
@@ -22760,11 +21988,11 @@ var NumericInput$1 = {
       }
 
       // @ts-expect-error - TS2345 - Argument of type 'string' is not assignable to parameter of type 'MathFormat | undefined'.
-      let answerString = KhanMath.toNumericString(answer.value, format);
+      let answerString = kmath.KhanMath.toNumericString(answer.value, format);
       if (answer.maxError) {
         answerString += " \u00B1 " +
         // @ts-expect-error - TS2345 - Argument of type 'string' is not assignable to parameter of type 'MathFormat | undefined'.
-        KhanMath.toNumericString(answer.maxError, format);
+        kmath.KhanMath.toNumericString(answer.maxError, format);
       }
       return answerString;
     });
@@ -24567,7 +23795,7 @@ const CIRCLE_LABEL_STYLE = {
 // TODO(LEMS-2656): remove TS suppression
 // @ts-expect-error: State is not assignable to ParseState
 const builtParser = SimpleMarkdown__default["default"].parserFor(rules);
-const parse$2 = (source, state) => {
+const parse$3 = (source, state) => {
   // @ts-expect-error - TS2322 - Type 'ParseState | {}' is not assignable to type 'ParseState | null | undefined'.
   state = state || {};
   const paragraphedSource = source + "\n\n";
@@ -24577,7 +23805,7 @@ const parse$2 = (source, state) => {
 // @ts-expect-error - TS2322 - Type 'ReactOutput' is not assignable to type '(arg1: SingleASTNode[]) => ReactElement<any, string | JSXElementConstructor<any>>'.
 const output = SimpleMarkdown__default["default"].reactFor(SimpleMarkdown__default["default"].ruleOutput(rules, "react"));
 var PassageMarkdown = {
-  parse: parse$2,
+  parse: parse$3,
   output,
   START_REF_PREFIX,
   END_REF_PREFIX,
@@ -29254,6 +28482,9 @@ const typeToButton = type => {
 };
 
 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);
@@ -32043,9 +31274,10 @@ const AxisTicks = () => {
  * @param {number} axisIndex which axis we're getting options for
  */
 const axisOptions = (props, axisIndex) => {
+  const lines = props.markings === "axes" ? false : props.gridStep[axisIndex];
   return {
-    axis: props.markings === "graph",
-    lines: props.gridStep[axisIndex],
+    axis: props.markings === "graph" || props.markings === "axes",
+    lines: lines,
     labels: false
   };
 };
@@ -32332,8 +31564,8 @@ const {
   firstNumericalParse,
   captureScratchpadTouchStart
 } = Util;
-const toNumericString = KhanMath.toNumericString;
-const getNumericFormat = KhanMath.getNumericFormat;
+const toNumericString = kmath.KhanMath.toNumericString;
+const getNumericFormat = kmath.KhanMath.getNumericFormat;
 
 /**
  * An input box that accepts only numeric strings
@@ -32628,231 +31860,6 @@ const LegacyGrid = _ref => {
   return null;
 };
 
-/**
- * The Perseus "data schema" file.
- *
- * This file, and the types in it, represents the "data schema" that Perseus
- * uses. The @khanacademy/perseus-editor package edits and produces objects
- * that conform to the types in this file. Similarly, the top-level renderers
- * in @khanacademy/perseus, consume objects that conform to these types.
- *
- * WARNING: This file should not import any types from elsewhere so that it is
- * easy to reason about changes that alter the Perseus schema. This helps
- * ensure that it is not changed accidentally when upgrading a dependant
- * package or other part of Perseus code. Note that TypeScript does type
- * checking via something called "structural typing". This means that as long
- * as the shape of a type matches, the name it goes by doesn't matter. As a
- * result, a `Coord` type that looks like this `[x: number, y: number]` is
- * _identical_, in TypeScript's eyes, to this `Vector2` type `[x: number, y:
- * number]`. Also, with tuples, the labels for each entry is ignored, so `[x:
- * number, y: number]` is compatible with `[min: number, max: number]`. The
- * labels are for humans, not TypeScript. :)
- *
- * If you make changes to types in this file, be very sure that:
- *
- *   a) the changes are backwards compatible. If they are not, old data from
- *      previous versions of the "schema" could become unrenderable, or worse,
- *      introduce hard-to-diagnose bugs.
- *   b) the parsing code (`util/parse-perseus-json/`) is updated to handle
- *      the new format _as well as_ the old format.
- */
-
-// TODO(FEI-4010): Remove `Perseus` prefix for all types here
-
-// Same name as Mafs
-
-/**
- * Our core set of Perseus widgets.
- *
- * This interface is the basis for "registering" all Perseus widget types.
- * There should be one key/value pair for each supported widget. If you create
- * a new widget, an entry should be added to this interface. Note that this
- * only registers the widget options type, you'll also need to register the
- * widget so that it's available at runtime (@see
- * {@link file://./widgets.ts#registerWidget}).
- *
- * Importantly, the key should be the name that is used in widget IDs. For most
- * widgets that is the same as the widget option's `type` field. In cases where
- * a widget has been deprecated and replaced with the deprecated-standin
- * widget, it should be the original widget type!
- *
- * If you define the widget outside of this package, you can still add the new
- * widget to this interface by writing the following in that package that
- * contains the widget. TypeScript will merge that definition of the
- * `PerseusWidgets` with the one defined below.
- *
- * ```typescript
- * declare module "@khanacademy/perseus" {
- *     interface PerseusWidgetTypes {
- *         // A new widget
- *         "new-awesomeness": MyAwesomeNewWidget;
- *
- *         // A deprecated widget
- *         "super-old-widget": DeprecatedStandinWidget;
- *     }
- * }
- *
- * // The new widget's options definition
- * type MyAwesomeNewWidget = WidgetOptions<'new-awesomeness', MyAwesomeNewWidgetOptions>;
- *
- * // The deprecated widget's options definition
- * type SuperOldWidget = WidgetOptions<'super-old-widget', object>;
- * ```
- *
- * This interface can be extended through the magic of TypeScript "Declaration
- * merging". Specifically, we augment this module and extend this interface.
- *
- * @see {@link https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation}
- */
-
-/**
- * A map of widget IDs to widget options. This is most often used as the type
- * for a set of widgets defined in a `PerseusItem` but can also be useful to
- * represent a function parameter where only `widgets` from a `PerseusItem` are
- * needed. Today Widget IDs are made up of the widget type and an incrementing
- * integer (eg. `interactive-graph 1` or `radio 3`). It is suggested to avoid
- * reading/parsing the widget id to derive any information from it, except in
- * the case of this map.
- *
- * @see {@link PerseusWidgetTypes} additional widgets can be added to this map type
- * by augmenting the PerseusWidgetTypes with new widget types!
- */
-
-/**
- * A "PerseusItem" is a classic Perseus item. It is rendered by the
- * `ServerItemRenderer` and the layout is pre-set.
- *
- * To render more complex Perseus items, see the `Item` type in the multi item
- * area.
- */
-
-/**
- * A "PerseusArticle" is an item that is meant to be rendered as an article.
- * This item is never scored and is rendered by the `ArticleRenderer`.
- */
-
-const ItemExtras = [
-// The user might benefit from using a Scientific Calculator.  Provided on Khan Academy when true
-"calculator",
-// The user might benefit from using a statistics Chi Squared Table like https://people.richland.edu/james/lecture/m170/tbl-chi.html
-"chi2Table",
-// The user might benefit from a monthly payments calculator.  Provided on Khan Academy when true
-"financialCalculatorMonthlyPayment",
-// The user might benefit from a total amount calculator.  Provided on Khan Academy when true
-"financialCalculatorTotalAmount",
-// The user might benefit from a time to pay off calculator.  Provided on Khan Academy when true
-"financialCalculatorTimeToPayOff",
-// The user might benefit from using a Periodic Table of Elements.  Provided on Khan Academy when true
-"periodicTable",
-// The user might benefit from using a Periodic Table of Elements with key.  Provided on Khan Academy when true
-"periodicTableWithKey",
-// The user might benefit from using a statistics T Table like https://www.statisticshowto.com/tables/t-distribution-table/
-"tTable",
-// The user might benefit from using a statistics Z Table like https://www.ztable.net/
-"zTable"];
-
-/**
- * The type representing the common structure of all widget's options. The
- * `Options` generic type represents the widget-specific option data.
- */
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-//prettier-ignore
-
-/**
- * A background image applied to various widgets.
- */
-
-const PerseusExpressionAnswerFormConsidered = ["correct", "wrong", "ungraded"];
-
-// 2D range: xMin, xMax, yMin, yMax
-
-const lockedFigureColorNames = ["blue", "green", "grayH", "purple", "pink", "orange", "red"];
-const lockedFigureColors = {
-  blue: "#3D7586",
-  green: "#447A53",
-  grayH: "#3B3D45",
-  purple: "#594094",
-  pink: "#B25071",
-  red: "#D92916",
-  orange: "#946700"
-};
-const lockedFigureFillStyles = {
-  none: 0,
-  white: 1,
-  translucent: 0.4,
-  solid: 1
-};
-
-// Not associated with a specific figure
-
-const plotterPlotTypes = ["bar", "line", "pic", "histogram", "dotplot"];
-
 function LockedLabel(props) {
   const {
     coord,
@@ -32872,7 +31879,7 @@ function LockedLabel(props) {
       position: "absolute",
       left: x,
       top: y,
-      color: lockedFigureColors[color],
+      color: perseusCore.lockedFigureColors[color],
       fontSize: wonderBlocksTokens.font.size[size],
       backgroundColor: "rgba(255, 255, 255, 0.8)"
     },
@@ -32921,16 +31928,16 @@ const LockedEllipse = props => {
     center: center,
     radius: radius,
     angle: angle,
-    fillOpacity: lockedFigureFillStyles[fillStyle],
+    fillOpacity: perseusCore.lockedFigureFillStyles[fillStyle],
     strokeStyle: strokeStyle,
-    color: lockedFigureColors[color]
+    color: perseusCore.lockedFigureColors[color]
     // We need to override the svg props if we want to have a
     // different fill color than the stroke color (specifically,
     // in the case where the fillStyle is "white").
     ,
     svgEllipseProps: {
       style: {
-        fill: fillStyle === "white" ? wonderBlocksTokens.color.white : lockedFigureColors[color]
+        fill: fillStyle === "white" ? wonderBlocksTokens.color.white : perseusCore.lockedFigureColors[color]
       }
     }
   }));
@@ -32945,7 +31952,7 @@ const LockedFunction = props => {
     domain
   } = props;
   const plotProps = {
-    color: lockedFigureColors[color],
+    color: perseusCore.lockedFigureColors[color],
     style: strokeStyle,
     domain
   };
@@ -33087,7 +32094,7 @@ const LockedLine = props => {
     line = /*#__PURE__*/React__namespace.createElement(Vector, {
       tail: point1.coord,
       tip: extendedPoint,
-      color: lockedFigureColors[color],
+      color: perseusCore.lockedFigureColors[color],
       style: {
         strokeDasharray: lineStyle === "dashed" ? "var(--mafs-line-stroke-dash-style)" : undefined
       }
@@ -33102,19 +32109,19 @@ const LockedLine = props => {
     const startArrowHead = kind !== "segment" && /*#__PURE__*/React__namespace.createElement(Arrowhead, {
       angle: angle,
       tip: arrowTip,
-      color: lockedFigureColors[color]
+      color: perseusCore.lockedFigureColors[color]
     });
     arrowTip = kind === "segment" ? point1.coord : getIntersectionOfRayWithBox(point2.coord, point1.coord, range);
     angle = angle > 180 ? angle - 180 : angle + 180;
     const endArrowHead = kind !== "segment" && /*#__PURE__*/React__namespace.createElement(Arrowhead, {
       angle: angle,
       tip: arrowTip,
-      color: lockedFigureColors[color]
+      color: perseusCore.lockedFigureColors[color]
     });
     line = /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, startArrowHead, /*#__PURE__*/React__namespace.createElement(LineType, {
       point1: point1.coord,
       point2: point2.coord,
-      color: lockedFigureColors[color],
+      color: perseusCore.lockedFigureColors[color],
       style: lineStyle
     }), endArrowHead);
   }
@@ -33127,8 +32134,8 @@ const LockedLine = props => {
     y: point1.coord[Y],
     svgCircleProps: {
       style: {
-        fill: point1.filled ? lockedFigureColors[point1.color] : wonderBlocksTokens.color.white,
-        stroke: lockedFigureColors[point1.color],
+        fill: point1.filled ? perseusCore.lockedFigureColors[point1.color] : wonderBlocksTokens.color.white,
+        stroke: perseusCore.lockedFigureColors[point1.color],
         strokeWidth: wonderBlocksTokens.spacing.xxxxSmall_2
       }
     }
@@ -33137,8 +32144,8 @@ const LockedLine = props => {
     y: point2.coord[Y],
     svgCircleProps: {
       style: {
-        fill: point2.filled ? lockedFigureColors[point2.color] : wonderBlocksTokens.color.white,
-        stroke: lockedFigureColors[point2.color],
+        fill: point2.filled ? perseusCore.lockedFigureColors[point2.color] : wonderBlocksTokens.color.white,
+        stroke: perseusCore.lockedFigureColors[point2.color],
         strokeWidth: wonderBlocksTokens.spacing.xxxxSmall_2
       }
     }
@@ -33163,8 +32170,8 @@ const LockedPoint = props => {
     y: y,
     svgCircleProps: {
       style: {
-        fill: filled ? lockedFigureColors[color] : wonderBlocksTokens.color.white,
-        stroke: lockedFigureColors[color],
+        fill: filled ? perseusCore.lockedFigureColors[color] : wonderBlocksTokens.color.white,
+        stroke: perseusCore.lockedFigureColors[color],
         strokeWidth: wonderBlocksTokens.spacing.xxxxSmall_2
       }
     }
@@ -33186,23 +32193,23 @@ const LockedPolygon = props => {
     "aria-hidden": !hasAria
   }, /*#__PURE__*/React__namespace.createElement(mafs.Polygon, {
     points: [...points],
-    fillOpacity: lockedFigureFillStyles[fillStyle],
+    fillOpacity: perseusCore.lockedFigureFillStyles[fillStyle],
     strokeStyle: strokeStyle,
-    color: lockedFigureColors[color]
+    color: perseusCore.lockedFigureColors[color]
     // We need to override the svg props if we want to have a
     // different fill color than the stroke color (specifically,
     // in the case where the fillStyle is "white").
     ,
     svgPolygonProps: {
       style: {
-        fill: fillStyle === "white" ? wonderBlocksTokens.color.white : lockedFigureColors[color]
+        fill: fillStyle === "white" ? wonderBlocksTokens.color.white : perseusCore.lockedFigureColors[color]
       }
     }
   }), showVertices && points.map((point, index) => /*#__PURE__*/React__namespace.createElement(mafs.Point, {
     key: `locked-polygon-point-${index}`,
     x: point[X],
     y: point[Y],
-    color: lockedFigureColors[color]
+    color: perseusCore.lockedFigureColors[color]
   })));
 };
 
@@ -33221,7 +32228,7 @@ const LockedVector = props => {
   }, /*#__PURE__*/React__namespace.createElement(Vector, {
     tail: tail,
     tip: tip,
-    color: lockedFigureColors[color]
+    color: perseusCore.lockedFigureColors[color]
   }));
 };
 
@@ -34657,7 +33664,9 @@ function renderCircleGraph(state, dispatch) {
       graphState: state,
       dispatch: dispatch
     }),
-    interactiveElementsDescription: null
+    interactiveElementsDescription: /*#__PURE__*/React__namespace.createElement(CircleGraphDescription, {
+      state: state
+    })
   };
 }
 function CircleGraph(props) {
@@ -34681,38 +33690,26 @@ function CircleGraph(props) {
   const outerPointsId = id + "-outer-points";
 
   // Aria label strings
-  const circleGraphAriaLabel = strings.srCircleGraph;
-  const circleShapeAriaLabel = strings.srCircleShape({
-    centerX: srFormatNumber(center[0], locale),
-    centerY: srFormatNumber(center[1], locale)
-  });
-  const circleRadiusPointAriaLabel = strings.srCircleRadiusPoint({
-    radiusPointX: srFormatNumber(radiusPoint[0], locale),
-    radiusPointY: srFormatNumber(radiusPoint[1], locale)
-  });
-  const circleRadiusDescription = strings.srCircleRadius({
-    radius
-  });
-  const circleOuterPointsDescription = strings.srCircleOuterPoints({
-    point1X: srFormatNumber(center[0] + radius, locale),
-    point1Y: srFormatNumber(center[1], locale),
-    point2X: srFormatNumber(center[0], locale),
-    point2Y: srFormatNumber(center[1] + radius, locale),
-    point3X: srFormatNumber(center[0] - radius, locale),
-    point3Y: srFormatNumber(center[1], locale),
-    point4X: srFormatNumber(center[0], locale),
-    point4Y: srFormatNumber(center[1] - radius, locale)
+  const {
+    srCircleGraph,
+    srCircleShape,
+    srCircleRadiusPoint,
+    srCircleRadius,
+    srCircleOuterPoints
+  } = describeCircleGraph(graphState, {
+    strings,
+    locale
   });
   return /*#__PURE__*/React__namespace.createElement("g", {
     // Outer circle minimal description
-    "aria-label": circleGraphAriaLabel,
+    "aria-label": srCircleGraph,
     "aria-describedby": `${circleId} ${radiusId} ${outerPointsId}`
   }, /*#__PURE__*/React__namespace.createElement(MovableCircle, {
     id: circleId
     // Focusable circle aria label reads with every update
     // because of the aria-live property in the circle <g>.
     ,
-    ariaLabel: circleShapeAriaLabel
+    ariaLabel: srCircleShape
     // Aria-describedby describes additional info on focus.
     ,
     ariaDescribedBy: `${radiusId} ${outerPointsId}`,
@@ -34725,7 +33722,7 @@ function CircleGraph(props) {
   }), /*#__PURE__*/React__namespace.createElement(MovablePoint$1
   // Radius point aria label reads with every update.
   , {
-    ariaLabel: `${circleRadiusPointAriaLabel} ${circleRadiusDescription}`
+    ariaLabel: `${srCircleRadiusPoint} ${srCircleRadius}`
     // Aria-describedby describes additional info on focus.
     ,
     ariaDescribedBy: `${outerPointsId}`
@@ -34748,12 +33745,12 @@ function CircleGraph(props) {
     style: {
       display: "hidden"
     }
-  }, circleRadiusDescription), /*#__PURE__*/React__namespace.createElement("g", {
+  }, srCircleRadius), /*#__PURE__*/React__namespace.createElement("g", {
     id: outerPointsId,
     style: {
       display: "hidden"
     }
-  }, circleOuterPointsDescription));
+  }, srCircleOuterPoints));
 }
 function MovableCircle(props) {
   const {
@@ -34840,6 +33837,65 @@ function crossProduct(as, bs) {
   }
   return result;
 }
+function CircleGraphDescription(_ref) {
+  let {
+    state
+  } = _ref;
+  // The reason that CircleGraphDescription 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 = describeCircleGraph(state, i18n);
+  return strings.srCircleInteractiveElement;
+}
+
+// Exported for testing
+function describeCircleGraph(state, i18n) {
+  const {
+    strings,
+    locale
+  } = i18n;
+  const {
+    center,
+    radiusPoint
+  } = state;
+  const radius = getRadius(state);
+
+  // Aria label strings
+  const srCircleGraph = strings.srCircleGraph;
+  const srCircleShape = strings.srCircleShape({
+    centerX: srFormatNumber(center[0], locale),
+    centerY: srFormatNumber(center[1], locale)
+  });
+  const srCircleRadiusPoint = strings.srCircleRadiusPoint({
+    radiusPointX: srFormatNumber(radiusPoint[0], locale),
+    radiusPointY: srFormatNumber(radiusPoint[1], locale)
+  });
+  const srCircleRadius = strings.srCircleRadius({
+    radius
+  });
+  const srCircleOuterPoints = strings.srCircleOuterPoints({
+    point1X: srFormatNumber(center[0] + radius, locale),
+    point1Y: srFormatNumber(center[1], locale),
+    point2X: srFormatNumber(center[0], locale),
+    point2Y: srFormatNumber(center[1] + radius, locale),
+    point3X: srFormatNumber(center[0] - radius, locale),
+    point3Y: srFormatNumber(center[1], locale),
+    point4X: srFormatNumber(center[0], locale),
+    point4Y: srFormatNumber(center[1] - radius, locale)
+  });
+  const srCircleInteractiveElement = strings.srInteractiveElements({
+    elements: [srCircleShape, srCircleRadius].join(" ")
+  });
+  return {
+    srCircleGraph,
+    srCircleShape,
+    srCircleRadiusPoint,
+    srCircleRadius,
+    srCircleOuterPoints,
+    srCircleInteractiveElement
+  };
+}
 
 function renderLinearGraph(state, dispatch) {
   return {
@@ -35833,7 +34889,9 @@ const MafsGraph = props => {
       labels,
       disableKeyboardInteraction: readOnly || !!props.static
     }
-  }, /*#__PURE__*/React__namespace.createElement(wonderBlocksCore.View, null, /*#__PURE__*/React__namespace.createElement(wonderBlocksCore.View, {
+  }, /*#__PURE__*/React__namespace.createElement(wonderBlocksCore.View, {
+    className: "mafs-graph-container"
+  }, /*#__PURE__*/React__namespace.createElement(wonderBlocksCore.View, {
     className: "mafs-graph",
     style: {
       position: "relative",
@@ -35876,7 +34934,7 @@ const MafsGraph = props => {
       bottom: 0,
       left: 0
     }
-  }, props.markings === "graph" && /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(AxisLabels, null)), /*#__PURE__*/React__namespace.createElement(mafs.Mafs, {
+  }, (props.markings === "graph" || props.markings === "axes") && /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(AxisLabels, null)), /*#__PURE__*/React__namespace.createElement(mafs.Mafs, {
     preserveAspectRatio: false,
     viewBox: {
       x: state.range[X],
@@ -35896,7 +34954,7 @@ const MafsGraph = props => {
     height: height
   })),
   // Only render the axis ticks and arrows if the markings are set to a full "graph"
-  props.markings === "graph" && /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(AxisTicks, null), /*#__PURE__*/React__namespace.createElement(AxisArrows, null)), /*#__PURE__*/React__namespace.createElement("svg", nestedSVGAttributes, props.lockedFigures && /*#__PURE__*/React__namespace.createElement(GraphLockedLayer, {
+  (props.markings === "graph" || props.markings === "axes") && /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(AxisTicks, null), /*#__PURE__*/React__namespace.createElement(AxisArrows, null)), /*#__PURE__*/React__namespace.createElement("svg", nestedSVGAttributes, props.lockedFigures && /*#__PURE__*/React__namespace.createElement(GraphLockedLayer, {
     lockedFigures: props.lockedFigures,
     range: state.range
   }))), props.lockedFigures && /*#__PURE__*/React__namespace.createElement(GraphLockedLabelsLayer, {
@@ -41426,7 +40484,7 @@ function scoreMatrix(userInput, rubric, strings) {
   const solutionSize = getMatrixSize(solution);
   const suppliedSize = getMatrixSize(supplied);
   const incorrectSize = solutionSize[0] !== suppliedSize[0] || solutionSize[1] !== suppliedSize[1];
-  const createValidator = KhanAnswerTypes.number.createValidatorFunctional;
+  const createValidator = perseusScore.KhanAnswerTypes.number.createValidatorFunctional;
   let message = null;
   let incorrect = false;
   ___default["default"](suppliedSize[0]).times(row => {
@@ -41436,7 +40494,7 @@ function scoreMatrix(userInput, rubric, strings) {
         // @ts-expect-error - TS2345 - Argument of type 'number' is not assignable to parameter of type 'string'.
         solution[row][col], {
           simplify: true
-        }, strings);
+        });
         const result = validator(supplied[row][col]);
         if (result.message) {
           // @ts-expect-error - TS2322 - Type 'string' is not assignable to type 'null'.
@@ -42588,10 +41646,10 @@ function parseBondModifier(smiles, ctx) {
   const firstChar = smiles[0];
   const rest = smiles.slice(1);
   if (firstChar === "=") {
-    return parse$1(rest, _mset(ctx, ["bond", "bondType"], "double"));
+    return parse$2(rest, _mset(ctx, ["bond", "bondType"], "double"));
   }
   if (firstChar === "#") {
-    return parse$1(rest, _mset(ctx, ["bond", "bondType"], "triple"));
+    return parse$2(rest, _mset(ctx, ["bond", "bondType"], "triple"));
   }
   throw new ParseError$1("Invalid character: " + firstChar);
 }
@@ -42652,8 +41710,8 @@ function parseParenthesizedExpression(smiles, ctx) {
       idx: newCtx.idx.concat([[inBranchIdx, 0]]),
       parens: newCtx.parens.concat("(")
     };
-    const parenExpr = parse$1(rest, parenCtx);
-    const remainder = parse$1(sliceFromMatchingCloseParen(rest, ["("]), newCtx);
+    const parenExpr = parse$2(rest, parenCtx);
+    const remainder = parse$2(sliceFromMatchingCloseParen(rest, ["("]), newCtx);
     return [parenExpr].concat(remainder);
   }
   if (firstChar === ")") {
@@ -42717,7 +41775,7 @@ function parseAtom(smiles, ctx) {
 
   // increment the atom counter and reset the branch counter
   const newCtx = _mset(ctx, ["idx", ctx.idx.length - 1], [1 + ctx.idx[ctx.idx.length - 1][0], 0]);
-  let restOfMolecule = parse$1(rest, _mset(newCtx, ["bond", "bondType"], "single"));
+  let restOfMolecule = parse$2(rest, _mset(newCtx, ["bond", "bondType"], "single"));
   if (!Array.isArray(restOfMolecule) && !!restOfMolecule) {
     //TODO(colin): fix this awkwardness.
     restOfMolecule = [restOfMolecule];
@@ -42756,7 +41814,7 @@ function isModifierChar(s) {
  *     ParseError: if the input is not valid SMILES or contains features not
  *         yet implemented.
  */
-function parse$1(smiles, ctx) {
+function parse$2(smiles, ctx) {
   if (!validate(smiles)) {
     throw new ParseError$1("Invalid input.");
   }
@@ -42781,7 +41839,7 @@ function parse$1(smiles, ctx) {
   return parseParenthesizedExpression(smiles, ctx);
 }
 var SmilesParser = {
-  parse: parse$1,
+  parse: parse$2,
   ParseError: ParseError$1
 };
 
@@ -42789,7 +41847,7 @@ var SmilesParser = {
 const {
   layout
 } = MoleculeLayout;
-const parse = SmilesParser.parse;
+const parse$1 = SmilesParser.parse;
 const ParseError = SmilesParser.ParseError;
 const borderSize = 30;
 class Molecule extends React__namespace.Component {
@@ -42816,7 +41874,7 @@ class Molecule extends React__namespace.Component {
     try {
       this.setState({
         // @ts-expect-error - TS2554 - Expected 2 arguments, but got 1.
-        parsedSmiles: parse(smiles),
+        parsedSmiles: parse$1(smiles),
         error: null
       });
     } catch (e) {
@@ -43029,15 +42087,15 @@ const _label = (graphie, labelStyle, pos, value, base) => {
     return graphie.label([pos, -0.53], Math.round(value * 100) / 100, "center");
   }
   if (labelStyle === "improper") {
-    const frac = KhanMath.toFraction(value);
+    const frac = kmath.KhanMath.toFraction(value);
     return graphie.label([pos, -0.17], formatImproper(frac[0], frac[1]), "below");
   }
   if (labelStyle === "mixed") {
-    const frac = KhanMath.toFraction(value);
+    const frac = kmath.KhanMath.toFraction(value);
     return graphie.label([pos, -0.17], formatMixed(frac[0], frac[1]), "below");
   }
   if (labelStyle === "non-reduced") {
-    const frac = KhanMath.toFraction(value);
+    const frac = kmath.KhanMath.toFraction(value);
     return graphie.label([pos, -0.17], formatNonReduced(frac[0], frac[1], base), "below");
   }
 };
@@ -43073,7 +42131,7 @@ const TickMarks = Graphie.createSimpleClass((graphie, props) => {
     }
     const getDenom = x => kmath.number.toFraction(x)[1];
     const denoms = ___default["default"].map(fractions, getDenom);
-    base = ___default["default"].reduce(denoms, (x, y) => KhanMath.getLCM(x, y));
+    base = ___default["default"].reduce(denoms, (x, y) => kmath.KhanMath.getLCM(x, y));
   } else {
     base = undefined;
   }
@@ -44609,7 +43667,7 @@ class Plotter extends React__namespace.Component {
       // If we have isMobile, we skip the 0 label.
       const initialY = isMobile ? c.scaleY : 0;
       for (let y = initialY; y <= c.dimY; y += c.scaleY) {
-        graphie.label([0, y], KhanMath.roundToApprox(y, 2), "left", /* isTeX */true /* for the \approx symbol */);
+        graphie.label([0, y], kmath.KhanMath.roundToApprox(y, 2), "left", /* isTeX */true /* for the \approx symbol */);
 
         graphie.style({
           stroke: isMobile ? "#e9ebec" : "#000",
@@ -45477,7 +44535,7 @@ function scoreTable(userInput, rubric, strings) {
       message: null
     };
   }
-  const createValidator = KhanAnswerTypes.number.createValidatorFunctional;
+  const createValidator = perseusScore.KhanAnswerTypes.number.createValidatorFunctional;
   let message = null;
   const allCorrect = solution.every(function (rowSolution) {
     for (let i = 0; i < supplied.length; i++) {
@@ -45486,7 +44544,7 @@ function scoreTable(userInput, rubric, strings) {
         const cellSolution = rowSolution[i];
         const validator = createValidator(cellSolution, {
           simplify: true
-        }, strings);
+        });
         const result = validator(cellSupplied);
         if (result.message) {
           message = result.message;
@@ -45909,7 +44967,7 @@ const init = function () {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus";
-const libVersion = "49.2.2";
+const libVersion = "50.0.0";
 perseusCore.addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {
@@ -46849,7 +45907,7 @@ const traverseRenderer$1 = function (rendererOptions, contentCallback, deepWidge
       newContent = modifiedContent;
     }
   }
-  const newWidgets = mapObject(rendererOptions.widgets || {}, function (widgetInfo, widgetId) {
+  const newWidgets = perseusCore.mapObject(rendererOptions.widgets || {}, function (widgetInfo, widgetId) {
     // Widgets without info or a type are empty widgets, and
     // should always be renderable. It's also annoying to write
     // checks for this everywhere, so we just filter them out once and
@@ -48000,6 +47058,69 @@ function all(results) {
   return success(values);
 }
 
+class ErrorTrackingParseContext {
+  constructor(path) {
+    this.path = path;
+  }
+  failure(expected, badValue) {
+    return failure([{
+      expected: wrapInArray(expected),
+      badValue,
+      path: this.path
+    }]);
+  }
+  forSubtree(key) {
+    return new ErrorTrackingParseContext([...this.path, key]);
+  }
+  success(value) {
+    return success(value);
+  }
+}
+function wrapInArray(a) {
+  return Array.isArray(a) ? a : [a];
+}
+
+function formatPath(path) {
+  return "(root)" + path.map(formatPathSegment).join("");
+}
+function formatPathSegment(segment) {
+  if (typeof segment === "string") {
+    return validIdentifier.test(segment) ? "." + segment : `[${JSON.stringify(segment)}]`;
+  }
+  return `[${segment.toString()}]`;
+}
+const validIdentifier = /^[A-Za-z$_][A-Za-z$_0-9]*$/;
+
+function message(failure) {
+  const expected = conjoin(failure.expected);
+  const path = formatPath(failure.path);
+  const badValue = JSON.stringify(failure.badValue);
+  return `At ${path} -- expected ${expected}, but got ${badValue}`;
+}
+function conjoin(items) {
+  switch (items.length) {
+    // TODO(benchristel): handle 0 if this is reused elsewhere.
+    case 1:
+      return items[0];
+    case 2:
+      return items.join(" or ");
+    default:
+      {
+        const allButLast = items.slice(0, items.length - 1);
+        const last = items[items.length - 1];
+        return allButLast.join(", ") + ", or " + last;
+      }
+  }
+}
+
+function parse(value, parser) {
+  const result = parser(value, new ErrorTrackingParseContext([]));
+  if (isFailure(result)) {
+    return failure(result.detail.map(message).join("; "));
+  }
+  return result;
+}
+
 const any = (rawValue, ctx) => ctx.success(rawValue);
 
 function array(elementParser) {
@@ -48285,7 +47406,6 @@ const parseCSProgramWidget = parseWidget(constant("cs-program"), object({
   })),
   showEditor: boolean,
   showButtons: boolean,
-  width: number,
   height: number,
   static: defaulted(boolean, () => false)
 }));
@@ -48474,25 +47594,6 @@ function migrateV0ToV1(widget) {
 }
 const parseExpressionWidget = versionedWidgetOptions(1, parseExpressionWidgetV1).withMigrationFrom(0, parseExpressionWidgetV0, migrateV0ToV1).parser;
 
-const parsePerseusRenderer = defaulted(object({
-  // TODO(benchristel): content is also defaulted to empty string in
-  // renderer.tsx. See if we can remove one default or the other.
-  content: defaulted(string, () => ""),
-  // This module has an import cycle with parseWidgetsMap, because the
-  // `group` widget can contain another renderer.
-  // The anonymous function below ensures that we don't try to access
-  // parseWidgetsMap before it's defined.
-  widgets: defaulted((rawVal, ctx) => parseWidgetsMap(rawVal, ctx), () => ({})),
-  metadata: optional(array(string)),
-  images: parseImages
-}),
-// Default value
-() => ({
-  content: "",
-  widgets: {},
-  images: {}
-}));
-
 const falseToNull = pipeParsers(constant(false)).then(convert(() => null)).parser;
 const parseGradedGroupWidgetOptions = object({
   title: defaulted(string, () => ""),
@@ -48563,27 +47664,27 @@ const parseGrapherWidget = parseWidget(constant("grapher"), object({
   availableTypes: array(enumeration("absolute_value", "exponential", "linear", "logarithm", "quadratic", "sinusoid", "tangent")),
   correct: discriminatedUnionOn("type").withBranch("absolute_value", object({
     type: constant("absolute_value"),
-    coords: pairOfPoints
+    coords: nullable(pairOfPoints)
   })).withBranch("exponential", object({
     type: constant("exponential"),
     asymptote: pairOfPoints,
-    coords: pairOfPoints
+    coords: nullable(pairOfPoints)
   })).withBranch("linear", object({
     type: constant("linear"),
-    coords: defaulted(pairOfPoints, () => [[-5, 5], [5, 5]])
+    coords: nullable(pairOfPoints)
   })).withBranch("logarithm", object({
     type: constant("logarithm"),
     asymptote: pairOfPoints,
-    coords: pairOfPoints
+    coords: nullable(pairOfPoints)
   })).withBranch("quadratic", object({
     type: constant("quadratic"),
-    coords: pairOfPoints
+    coords: nullable(pairOfPoints)
   })).withBranch("sinusoid", object({
     type: constant("sinusoid"),
-    coords: pairOfPoints
+    coords: nullable(pairOfPoints)
   })).withBranch("tangent", object({
     type: constant("tangent"),
-    coords: pairOfPoints
+    coords: nullable(pairOfPoints)
   })).parser,
   graph: object({
     backgroundImage: object({
@@ -48619,13 +47720,13 @@ const parseGroupWidget = parseWidget(constant("group"),
 
 const parseIframeWidget = parseWidget(constant("iframe"), object({
   url: string,
-  settings: array(object({
+  settings: optional(array(object({
     name: string,
     value: string
-  })),
+  }))),
   width: union(number).or(string).parser,
   height: union(number).or(string).parser,
-  allowFullScreen: boolean,
+  allowFullScreen: defaulted(boolean, () => false),
   allowTopNavigation: optional(boolean),
   static: defaulted(boolean, () => false)
 }));
@@ -48698,10 +47799,10 @@ const parseInputNumberWidget = parseWidget(constant("input-number"), object({
 
 const pairOfNumbers$1 = pair(number, number);
 const stringOrEmpty = defaulted(string, () => "");
-const parseFunctionType = constant("function");
+const parseKey = pipeParsers(optional(string)).then(convert(String)).parser;
 const parseFunctionElement = object({
-  type: parseFunctionType,
-  key: string,
+  type: constant("function"),
+  key: parseKey,
   options: object({
     value: string,
     funcName: string,
@@ -48712,10 +47813,9 @@ const parseFunctionElement = object({
     strokeWidth: number
   })
 });
-const parseLabelType = constant("label");
 const parseLabelElement = object({
-  type: parseLabelType,
-  key: string,
+  type: constant("label"),
+  key: parseKey,
   options: object({
     label: string,
     color: string,
@@ -48723,10 +47823,9 @@ const parseLabelElement = object({
     coordY: string
   })
 });
-const parseLineType = constant("line");
 const parseLineElement = object({
-  type: parseLineType,
-  key: string,
+  type: constant("line"),
+  key: parseKey,
   options: object({
     color: string,
     startX: string,
@@ -48738,10 +47837,9 @@ const parseLineElement = object({
     arrows: string
   })
 });
-const parseMovableLineType = constant("movable-line");
 const parseMovableLineElement = object({
-  type: parseMovableLineType,
-  key: string,
+  type: constant("movable-line"),
+  key: parseKey,
   options: object({
     startX: string,
     startY: string,
@@ -48758,10 +47856,9 @@ const parseMovableLineElement = object({
     constraintYMax: string
   })
 });
-const parseMovablePointType = constant("movable-point");
 const parseMovablePointElement = object({
-  type: parseMovablePointType,
-  key: string,
+  type: constant("movable-point"),
+  key: parseKey,
   options: object({
     startX: string,
     startY: string,
@@ -48775,10 +47872,9 @@ const parseMovablePointElement = object({
     constraintYMax: stringOrEmpty
   })
 });
-const parseParametricType = constant("parametric");
 const parseParametricElement = object({
-  type: parseParametricType,
-  key: string,
+  type: constant("parametric"),
+  key: parseKey,
   options: object({
     x: string,
     y: string,
@@ -48789,20 +47885,18 @@ const parseParametricElement = object({
     strokeWidth: number
   })
 });
-const parsePointType = constant("point");
 const parsePointElement = object({
-  type: parsePointType,
-  key: string,
+  type: constant("point"),
+  key: parseKey,
   options: object({
     color: string,
     coordX: string,
     coordY: string
   })
 });
-const parseRectangleType = constant("rectangle");
 const parseRectangleElement = object({
-  type: parseRectangleType,
-  key: string,
+  type: constant("rectangle"),
+  key: parseKey,
   options: object({
     color: string,
     coordX: string,
@@ -48923,7 +48017,7 @@ const parsePerseusGraphTypeSinusoid = object({
   coord: optional(pairOfNumbers)
 });
 const parsePerseusGraphType = discriminatedUnionOn("type").withBranch("angle", parsePerseusGraphTypeAngle).withBranch("circle", parsePerseusGraphTypeCircle).withBranch("linear", parsePerseusGraphTypeLinear).withBranch("linear-system", parsePerseusGraphTypeLinearSystem).withBranch("none", parsePerseusGraphTypeNone).withBranch("point", parsePerseusGraphTypePoint).withBranch("polygon", parsePerseusGraphTypePolygon).withBranch("quadratic", parsePerseusGraphTypeQuadratic).withBranch("ray", parsePerseusGraphTypeRay).withBranch("segment", parsePerseusGraphTypeSegment).withBranch("sinusoid", parsePerseusGraphTypeSinusoid).parser;
-const parseLockedFigureColor = enumeration(...lockedFigureColorNames);
+const parseLockedFigureColor = enumeration(...perseusCore.lockedFigureColorNames);
 const parseLockedFigureFillType = enumeration("none", "white", "translucent", "solid");
 const parseLockedLineStyle = enumeration("solid", "dashed");
 const parseLockedLabelType = object({
@@ -48948,8 +48042,8 @@ const parseLockedLineType = object({
   points: pair(parseLockedPointType, parseLockedPointType),
   color: parseLockedFigureColor,
   lineStyle: parseLockedLineStyle,
-  showPoint1: boolean,
-  showPoint2: boolean,
+  showPoint1: defaulted(boolean, () => false),
+  showPoint2: defaulted(boolean, () => false),
   // TODO(benchristel): default labels to empty array?
   labels: optional(array(parseLockedLabelType)),
   ariaLabel: optional(string)
@@ -48996,7 +48090,7 @@ const parseLockedFunctionType = object({
   labels: optional(array(parseLockedLabelType)),
   ariaLabel: optional(string)
 });
-const parseLockedFigure = union(parseLockedPointType).or(parseLockedLineType).or(parseLockedVectorType).or(parseLockedEllipseType).or(parseLockedPolygonType).or(parseLockedFunctionType).or(parseLockedLabelType).parser;
+const parseLockedFigure = discriminatedUnionOn("type").withBranch("point", parseLockedPointType).withBranch("line", parseLockedLineType).withBranch("vector", parseLockedVectorType).withBranch("ellipse", parseLockedEllipseType).withBranch("polygon", parseLockedPolygonType).withBranch("function", parseLockedFunctionType).withBranch("label", parseLockedLabelType).parser;
 const parseInteractiveGraphWidget = parseWidget(constant("interactive-graph"), object({
   step: pairOfNumbers,
   // TODO(benchristel): rather than making gridStep and snapStep
@@ -49064,7 +48158,14 @@ const parseMatrixWidget = parseWidget(defaulted(constant("matrix"), () => "matri
 }));
 
 const parseMeasurerWidget = parseWidget(constant("measurer"), object({
-  image: parsePerseusImageBackground,
+  // The default value for image comes from measurer.tsx.
+  // See parse-perseus-json/README.md for why we want to duplicate the
+  // defaults here.
+  image: defaulted(parsePerseusImageBackground, () => ({
+    url: null,
+    top: 0,
+    left: 0
+  })),
   showProtractor: boolean,
   showRuler: boolean,
   rulerLabel: string,
@@ -49173,11 +48274,17 @@ const parsePhetSimulationWidget = parseWidget(constant("phet-simulation"), objec
 const parsePlotterWidget = parseWidget(constant("plotter"), object({
   labels: array(string),
   categories: array(string),
-  type: enumeration(...plotterPlotTypes),
+  type: enumeration(...perseusCore.plotterPlotTypes),
   maxY: number,
-  scaleY: number,
+  // The default value for scaleY comes from plotter.tsx.
+  // See parse-perseus-json/README.md for why we want to duplicate the
+  // defaults here.
+  scaleY: defaulted(number, () => 1),
   labelInterval: optional(nullable(number)),
-  snapsPerLine: number,
+  // The default value for snapsPerLine comes from plotter.tsx.
+  // See parse-perseus-json/README.md for why we want to duplicate the
+  // defaults here.
+  snapsPerLine: defaulted(number, () => 2),
   starting: array(number),
   correct: array(number),
   picUrl: optional(nullable(string)),
@@ -49255,12 +48362,12 @@ const parseWidgetsMap = (rawValue, ctx) => {
   return ctx.success(widgetsMap);
 };
 const parseWidgetsMapEntry = (_ref, widgetMap, ctx) => {
-  let [key, widget] = _ref;
-  const keyComponentsResult = parseWidgetMapKeyComponents(key.split(" "), ctx);
-  if (isFailure(keyComponentsResult)) {
-    return keyComponentsResult;
+  let [id, widget] = _ref;
+  const idComponentsResult = parseWidgetIdComponents(id.split(" "), ctx.forSubtree("(widget ID)"));
+  if (isFailure(idComponentsResult)) {
+    return idComponentsResult;
   }
-  const [type, id] = keyComponentsResult.value;
+  const [type, n] = idComponentsResult.value;
   function parseAndAssign(key, parse) {
     const widgetResult = parse(widget, ctx);
     if (isFailure(widgetResult)) {
@@ -49271,88 +48378,88 @@ const parseWidgetsMapEntry = (_ref, widgetMap, ctx) => {
   }
   switch (type) {
     case "categorizer":
-      return parseAndAssign(`categorizer ${id}`, parseCategorizerWidget);
+      return parseAndAssign(`categorizer ${n}`, parseCategorizerWidget);
     case "cs-program":
-      return parseAndAssign(`cs-program ${id}`, parseCSProgramWidget);
+      return parseAndAssign(`cs-program ${n}`, parseCSProgramWidget);
     case "definition":
-      return parseAndAssign(`definition ${id}`, parseDefinitionWidget);
+      return parseAndAssign(`definition ${n}`, parseDefinitionWidget);
     case "dropdown":
-      return parseAndAssign(`dropdown ${id}`, parseDropdownWidget);
+      return parseAndAssign(`dropdown ${n}`, parseDropdownWidget);
     case "explanation":
-      return parseAndAssign(`explanation ${id}`, parseExplanationWidget);
+      return parseAndAssign(`explanation ${n}`, parseExplanationWidget);
     case "expression":
-      return parseAndAssign(`expression ${id}`, parseExpressionWidget);
+      return parseAndAssign(`expression ${n}`, parseExpressionWidget);
     case "grapher":
-      return parseAndAssign(`grapher ${id}`, parseGrapherWidget);
+      return parseAndAssign(`grapher ${n}`, parseGrapherWidget);
     case "group":
-      return parseAndAssign(`group ${id}`, parseGroupWidget);
+      return parseAndAssign(`group ${n}`, parseGroupWidget);
     case "graded-group":
-      return parseAndAssign(`graded-group ${id}`, parseGradedGroupWidget);
+      return parseAndAssign(`graded-group ${n}`, parseGradedGroupWidget);
     case "graded-group-set":
-      return parseAndAssign(`graded-group-set ${id}`, parseGradedGroupSetWidget);
+      return parseAndAssign(`graded-group-set ${n}`, parseGradedGroupSetWidget);
     case "iframe":
-      return parseAndAssign(`iframe ${id}`, parseIframeWidget);
+      return parseAndAssign(`iframe ${n}`, parseIframeWidget);
     case "image":
-      return parseAndAssign(`image ${id}`, parseImageWidget);
+      return parseAndAssign(`image ${n}`, parseImageWidget);
     case "input-number":
-      return parseAndAssign(`input-number ${id}`, parseInputNumberWidget);
+      return parseAndAssign(`input-number ${n}`, parseInputNumberWidget);
     case "interaction":
-      return parseAndAssign(`interaction ${id}`, parseInteractionWidget);
+      return parseAndAssign(`interaction ${n}`, parseInteractionWidget);
     case "interactive-graph":
-      return parseAndAssign(`interactive-graph ${id}`, parseInteractiveGraphWidget);
+      return parseAndAssign(`interactive-graph ${n}`, parseInteractiveGraphWidget);
     case "label-image":
-      return parseAndAssign(`label-image ${id}`, parseLabelImageWidget);
+      return parseAndAssign(`label-image ${n}`, parseLabelImageWidget);
     case "matcher":
-      return parseAndAssign(`matcher ${id}`, parseMatcherWidget);
+      return parseAndAssign(`matcher ${n}`, parseMatcherWidget);
     case "matrix":
-      return parseAndAssign(`matrix ${id}`, parseMatrixWidget);
+      return parseAndAssign(`matrix ${n}`, parseMatrixWidget);
     case "measurer":
-      return parseAndAssign(`measurer ${id}`, parseMeasurerWidget);
+      return parseAndAssign(`measurer ${n}`, parseMeasurerWidget);
     case "molecule-renderer":
-      return parseAndAssign(`molecule-renderer ${id}`, parseMoleculeRendererWidget);
+      return parseAndAssign(`molecule-renderer ${n}`, parseMoleculeRendererWidget);
     case "number-line":
-      return parseAndAssign(`number-line ${id}`, parseNumberLineWidget);
+      return parseAndAssign(`number-line ${n}`, parseNumberLineWidget);
     case "numeric-input":
-      return parseAndAssign(`numeric-input ${id}`, parseNumericInputWidget);
+      return parseAndAssign(`numeric-input ${n}`, parseNumericInputWidget);
     case "orderer":
-      return parseAndAssign(`orderer ${id}`, parseOrdererWidget);
+      return parseAndAssign(`orderer ${n}`, parseOrdererWidget);
     case "passage":
-      return parseAndAssign(`passage ${id}`, parsePassageWidget);
+      return parseAndAssign(`passage ${n}`, parsePassageWidget);
     case "passage-ref":
-      return parseAndAssign(`passage-ref ${id}`, parsePassageRefWidget);
+      return parseAndAssign(`passage-ref ${n}`, parsePassageRefWidget);
     case "passage-ref-target":
       // NOTE(benchristel): as of 2024-11-12, passage-ref-target is only
       // used in test content. See:
       // https://www.khanacademy.org/devadmin/content/search?query=widget:passage-ref-target
-      return parseAndAssign(`passage-ref-target ${id}`, any);
+      return parseAndAssign(`passage-ref-target ${n}`, any);
     case "phet-simulation":
-      return parseAndAssign(`phet-simulation ${id}`, parsePhetSimulationWidget);
+      return parseAndAssign(`phet-simulation ${n}`, parsePhetSimulationWidget);
     case "plotter":
-      return parseAndAssign(`plotter ${id}`, parsePlotterWidget);
+      return parseAndAssign(`plotter ${n}`, parsePlotterWidget);
     case "python-program":
-      return parseAndAssign(`python-program ${id}`, parsePythonProgramWidget);
+      return parseAndAssign(`python-program ${n}`, parsePythonProgramWidget);
     case "radio":
-      return parseAndAssign(`radio ${id}`, parseRadioWidget);
+      return parseAndAssign(`radio ${n}`, parseRadioWidget);
     case "sorter":
-      return parseAndAssign(`sorter ${id}`, parseSorterWidget);
+      return parseAndAssign(`sorter ${n}`, parseSorterWidget);
     case "table":
-      return parseAndAssign(`table ${id}`, parseTableWidget);
+      return parseAndAssign(`table ${n}`, parseTableWidget);
     case "video":
-      return parseAndAssign(`video ${id}`, parseVideoWidget);
+      return parseAndAssign(`video ${n}`, parseVideoWidget);
     case "sequence":
       // sequence is a deprecated widget type, and the corresponding
       // widget component no longer exists.
-      return parseAndAssign(`sequence ${id}`, parseDeprecatedWidget);
+      return parseAndAssign(`sequence ${n}`, parseDeprecatedWidget);
     case "lights-puzzle":
-      return parseAndAssign(`lights-puzzle ${id}`, parseDeprecatedWidget);
+      return parseAndAssign(`lights-puzzle ${n}`, parseDeprecatedWidget);
     case "simulator":
-      return parseAndAssign(`simulator ${id}`, parseDeprecatedWidget);
+      return parseAndAssign(`simulator ${n}`, parseDeprecatedWidget);
     case "transformer":
-      return parseAndAssign(`transformer ${id}`, parseDeprecatedWidget);
+      return parseAndAssign(`transformer ${n}`, parseDeprecatedWidget);
     default:
       if (getWidget(type)) {
         // @ts-expect-error - 'type' is not a valid widget type
-        return parseAndAssign(`${type} ${id}`, any);
+        return parseAndAssign(`${type} ${n}`, any);
       }
       return ctx.failure("a valid widget type", type);
   }
@@ -49364,11 +48471,32 @@ const parseDeprecatedWidget = parseWidget(
 object({}));
 const parseStringToPositiveInt = (rawValue, ctx) => {
   if (typeof rawValue !== "string" || !/^[1-9][0-9]*$/.test(rawValue)) {
-    return ctx.failure("numeric string", rawValue);
+    return ctx.failure("a string representing a positive integer", rawValue);
   }
   return ctx.success(+rawValue);
 };
-const parseWidgetMapKeyComponents = pair(string, parseStringToPositiveInt);
+const parseWidgetIdComponents = pair(string, parseStringToPositiveInt);
+
+const parsePerseusRenderer = defaulted(object({
+  // TODO(benchristel): content is also defaulted to empty string in
+  // renderer.tsx. See if we can remove one default or the other.
+  content: defaulted(string, () => ""),
+  // This module has an import cycle with parseWidgetsMap, because the
+  // `group` widget can contain another renderer.
+  // The anonymous function below ensures that we don't try to access
+  // parseWidgetsMap before it's defined.
+  widgets: defaulted((rawVal, ctx) => parseWidgetsMap(rawVal, ctx), () => ({})),
+  metadata: optional(array(string)),
+  images: parseImages
+}),
+// Default value
+() => ({
+  content: "",
+  widgets: {},
+  images: {}
+}));
+
+const parsePerseusArticle = union(parsePerseusRenderer).or(array(parsePerseusRenderer)).parser;
 
 const parseHint = object({
   replace: optional(boolean),
@@ -49378,10 +48506,10 @@ const parseHint = object({
   images: parseImages
 });
 
-object({
+const parsePerseusItem$1 = object({
   question: parsePerseusRenderer,
   hints: defaulted(array(parseHint), () => []),
-  answerArea: pipeParsers(defaulted(object({}), () => ({}))).then(migrateAnswerArea).then(record(enumeration(...ItemExtras), boolean)).parser,
+  answerArea: pipeParsers(defaulted(object({}), () => ({}))).then(migrateAnswerArea).then(record(enumeration(...perseusCore.ItemExtras), boolean)).parser,
   itemDataVersion: optional(object({
     major: number,
     minor: number
@@ -49417,6 +48545,7 @@ function migrateAnswerArea(rawValue, ctx) {
  * Why not just use JSON.parse? We want:
  * - To make sure types are correct
  * - To give us a central place to validate/transform output if needed
+ * @deprecated - use parseAndMigratePerseusItem instead
  * @param {string} json - the stringified PerseusItem JSON
  * @returns {PerseusItem} the parsed PerseusItem object
  */
@@ -49428,6 +48557,60 @@ function parsePerseusItem(json) {
   }
   throw new Error("Something went wrong.");
 }
+/**
+ * Parses a PerseusItem from a JSON string, migrates old formats to the latest
+ * schema, and runtime-typechecks the result. Use this to parse assessmentItem
+ * data.
+ *
+ * @returns a {@link Result} of the parsed PerseusItem. If the result is a
+ * failure, it will contain an error message describing where in the tree
+ * parsing failed.
+ * @throws SyntaxError if the argument is not well-formed JSON.
+ */
+function parseAndMigratePerseusItem(json) {
+  throwErrorIfCheatingDetected();
+  const object = JSON.parse(json);
+  const result = parse(object, parsePerseusItem$1);
+  if (isFailure(result)) {
+    return failure({
+      message: result.detail,
+      invalidObject: object
+    });
+  }
+  return result;
+}
+
+/**
+ * Parses a PerseusArticle from a JSON string, migrates old formats to the
+ * latest schema, and runtime-typechecks the result.
+ *
+ * @returns a {@link Result} of the parsed PerseusArticle. If the result is a
+ * failure, it will contain an error message describing where in the tree
+ * parsing failed.
+ * @throws SyntaxError if the argument is not well-formed JSON.
+ */
+function parseAndMigratePerseusArticle(json) {
+  throwErrorIfCheatingDetected();
+  const object = JSON.parse(json);
+  const result = parse(object, parsePerseusArticle);
+  if (isFailure(result)) {
+    return failure({
+      message: result.detail,
+      invalidObject: object
+    });
+  }
+  return result;
+}
+
+/**
+ * Tries to block a cheating vector that relies on monkey-patching JSON.parse.
+ */
+// TODO(LEMS-2331): delete this function once server-side scoring is done.
+function throwErrorIfCheatingDetected() {
+  if (!isRealJSONParse(JSON.parse)) {
+    throw new Error("Something went wrong.");
+  }
+}
 
 const genericPerseusItemData = {
   question: {
@@ -49666,15 +48849,12 @@ exports.HintRenderer = HintRenderer;
 exports.HintsRenderer = HintsRenderer;
 exports.InputNumber = InputNumber$1;
 exports.InteractiveGraphWidget = InteractiveGraph$1;
-exports.ItemExtras = ItemExtras;
 exports.JiptParagraphs = JiptParagraphs;
 exports.KhanColors = KhanColors;
-exports.KhanMath = KhanMath;
 exports.LoadingContext = context;
 exports.Log = Log;
 exports.MatrixWidget = Matrix$1;
 exports.NumericInput = NumericInput$1;
-exports.PerseusExpressionAnswerFormConsidered = PerseusExpressionAnswerFormConsidered;
 exports.PerseusI18nContext = PerseusI18nContext;
 exports.PerseusI18nContextProvider = PerseusI18nContextProvider;
 exports.PerseusMarkdown = PerseusMarkdown;
@@ -49730,20 +48910,21 @@ exports.iconTrash = iconTrash;
 exports.init = init;
 exports.injectWidgets = injectWidgets;
 exports.interactiveSizes = interactiveSizes$1;
+exports.isFailure = isFailure;
 exports.isItemRenderableByVersion = isItemRenderableByVersion;
+exports.isSuccess = isSuccess;
 exports.isWidgetIdInContent = isWidgetIdInContent;
 exports.isWrongAnswerSupported = isWrongAnswerSupported;
 exports.itemDataVersion = itemDataVersion;
 exports.itemVersion = ItemVersion;
 exports.libVersion = libVersion;
-exports.lockedFigureColors = lockedFigureColors;
-exports.lockedFigureFillStyles = lockedFigureFillStyles;
 exports.makeSafeUrl = makeSafeUrl;
 exports.mathOnlyParser = mathOnlyParser;
 exports.mediaQueries = mediaQueries;
+exports.parseAndMigratePerseusArticle = parseAndMigratePerseusArticle;
+exports.parseAndMigratePerseusItem = parseAndMigratePerseusItem;
 exports.parseDataFromJSONP = parseDataFromJSONP;
 exports.parsePerseusItem = parsePerseusItem;
-exports.plotterPlotTypes = plotterPlotTypes;
 exports.preprocessTex = preprocessTex;
 exports.registerAllWidgetsForTesting = registerAllWidgetsForTesting;
 exports.scorePerseusItem = scorePerseusItem;