@khanacademy/perseus 41.3.0 → 41.5.0

package/dist/index.js

@@ -1588,7 +1588,7 @@ 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
@@ -1631,7 +1631,6 @@ const MAXERROR_EPSILON = Math.pow(2, -42);
  * TODO(alpert): Think of a less-absurd name for createValidatorFunctional.
  *
  */
-
 const KhanAnswerTypes = {
   /*
    * predicate answer type
@@ -2103,9 +2102,7 @@ const KhanAnswerTypes = {
       })];
     },
     createValidatorFunctional: function (correctAnswer, options, strings) {
-      return KhanAnswerTypes.predicate.createValidatorFunctional(
-      // @ts-expect-error - TS2556 - A spread argument must either have a tuple type or be passed to a rest parameter.
-      ...KhanAnswerTypes.number.convertToPredicate(correctAnswer, options), strings);
+      return KhanAnswerTypes.predicate.createValidatorFunctional(...KhanAnswerTypes.number.convertToPredicate(correctAnswer, options), strings);
     }
   },
   /*
@@ -2715,7 +2712,7 @@ const keypadConfigurationForProps = widgetOptions => {
     times: widgetOptions.times
   };
 };
-const propUpgrades$2 = {
+const propUpgrades$3 = {
   /* c8 ignore next */
   "1": v0props => ({
     times: v0props.times,
@@ -2775,7 +2772,7 @@ var Expression$1 = {
     major: 1,
     minor: 0
   },
-  propUpgrades: propUpgrades$2,
+  propUpgrades: propUpgrades$3,
   // For use by the editor
   isLintable: true,
   scorer: scoreExpression,
@@ -18927,6 +18924,9 @@ const replaceDeprecatedWidgets = () => {
   replaceWidget("sequence", "deprecated-standin");
   replaceWidget("simulator", "deprecated-standin");
   replaceWidget("unit-input", "deprecated-standin");
+
+  // Input-Number is a special case as it is being replaced by Numeric-Input
+  replaceWidget("input-number", "numeric-input");
 };
 const registerEditors = editorsToRegister => {
   editorsToRegister.forEach(editor => {
@@ -18961,6 +18961,11 @@ const replaceDeprecatedEditors = () => {
   replaceEditor("sequence", "deprecated-standin");
   replaceEditor("simulator", "deprecated-standin");
   replaceEditor("unit-input", "deprecated-standin");
+
+  // We're replacing the input-number editor with the numeric-input editor here,
+  // but we're also modifying the JSON content to convert input-number into the
+  // numeric-input format over in editor-page.tsx on line 92.
+  replaceEditor("input-number", "numeric-input");
 };
 const getWidget = name => {
   // TODO(alex): Consider referring to these as renderers to avoid
@@ -19007,10 +19012,8 @@ const getVersionVector = () => {
 const getPublicWidgets = () => {
   // TODO(alex): Update underscore.js so that _.pick can take a function.
   // @ts-expect-error - TS2740 - Type 'Pick<{ [key: string]: Readonly<{ name: string; displayName: string; getWidget?: (() => ComponentType<any>) | undefined; accessible?: boolean | ((props: any) => boolean) | undefined; hidden?: boolean | undefined; ... 10 more ...; widget: ComponentType<...>; }>; }, string>' is missing the following properties from type 'readonly Readonly<{ name: string; displayName: string; getWidget?: (() => ComponentType<any>) | undefined; accessible?: boolean | ((props: any) => boolean) | undefined; hidden?: boolean | undefined; ... 10 more ...; widget: ComponentType<...>; }>[]': length, concat, join, slice, and 18 more.
-  return ___default["default"].pick(widgets,
-  // @ts-expect-error - TS2345 - Argument of type '(name: string) => boolean | undefined' is not assignable to parameter of type 'Iteratee<string[], boolean, string>'.
-  ___default["default"].reject(___default["default"].keys(widgets), function (name) {
-    return widgets[name].hidden;
+  return ___default["default"].pick(widgets, ___default["default"].reject(___default["default"].keys(widgets), function (name) {
+    return widgets[name].hidden || name === "input-number";
   }));
 };
 const isAccessible = widgetInfo => {
@@ -22380,7 +22383,7 @@ class NumericInput extends React__namespace.Component {
         height: "auto"
       }
     });
-    return /*#__PURE__*/React__namespace.createElement("div", null, /*#__PURE__*/React__namespace.createElement(InputWithExamples, {
+    return /*#__PURE__*/React__namespace.createElement(InputWithExamples, {
       ref: ref => this.inputRef = ref,
       value: this.props.currentValue,
       onChange: this.handleChange,
@@ -22392,7 +22395,7 @@ class NumericInput extends React__namespace.Component {
       id: this.props.widgetId,
       disabled: this.props.apiOptions.readOnly,
       style: styles.input
-    }));
+    });
   }
 }
 
@@ -22450,13 +22453,65 @@ const propsTransform = function (widgetOptions) {
   });
   return rendererProps;
 };
+
+// This function is being used to replace the input-number widget
+// with the numeric-input widget
+const propUpgrades$2 = {
+  /* c8 ignore next */
+  "1": initialProps => {
+    // If the initialProps has a value, it means we're upgrading from
+    // input-number to numeric-input. In this case, we need to upgrade
+    // the widget options accordingly.
+    if (initialProps.value) {
+      const provideAnswerForm = initialProps.answerType !== "number";
+
+      // We need to determine the mathFormat for the numeric-input widget
+      const mathFormat = initialProps.answerType === "rational" ? "proper" // input-number uses "rational" for proper fractions
+      : initialProps.answerType; // Otherwise, we can use the answerType directly
+
+      // If adjusting this logic, also adjust the logic in the convertInputNumberWidgetOptions
+      // function in input-number.ts in the Perseus Editor package's util folder
+      const answers = [{
+        value: initialProps.value,
+        simplify: initialProps.simplify,
+        answerForms: provideAnswerForm ? [mathFormat] : undefined,
+        strict: initialProps.inexact,
+        // We only want to set maxError if the inexact prop is true
+        maxError: initialProps.inexact ? initialProps.maxError : 0,
+        status: "correct",
+        // Input-number only allows correct answers
+        message: ""
+      }];
+      return {
+        answers,
+        size: initialProps.size,
+        coefficient: false,
+        // input-number doesn't have a coefficient prop
+        labelText: "",
+        // input-number doesn't have a labelText prop
+        static: false,
+        // static is always false for numeric-input
+        rightAlign: initialProps.rightAlign || false
+      };
+    } else {
+      // Otherwise simply return the initialProps as there's no differences
+      // between v0 and v1 for numeric-input
+      return initialProps;
+    }
+  }
+};
 var NumericInput$1 = {
   name: "numeric-input",
   displayName: "Numeric input",
   defaultAlignment: "inline-block",
   accessible: true,
   widget: NumericInput,
+  version: {
+    major: 1,
+    minor: 0
+  },
   transform: propsTransform,
+  propUpgrades: propUpgrades$2,
   isLintable: true,
   scorer: scoreNumericInput,
   getOneCorrectAnswerFromRubric(rubric) {
@@ -32262,17 +32317,12 @@ const ItemExtras = [
 // prettier-ignore
 
 // prettier-ignore
-
+// While this widget is deprecated, we still need the type for conversion purposes
 // 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
@@ -32367,6 +32417,9 @@ function replaceOutsideTeX(mathString) {
 // Condense adjacent text nodes into a single text node
 function condenseTextNodes(nodes) {
   const result = [];
+  if (!nodes) {
+    return result;
+  }
   let currentText = "";
   for (const node of nodes) {
     if (node.type === "math") {
@@ -44512,17 +44565,23 @@ var Sorter$1 = {
   scorer: scoreSorter
 };
 
-function scoreTable(state, rubric, strings) {
-  const filterNonEmpty = function (table) {
-    return ___default["default"].filter(table, function (row) {
-      // Check if row has a cell that is nonempty
-      return ___default["default"].some(row, ___default["default"].identity);
-    });
-  };
-  const solution = filterNonEmpty(rubric.answers);
-  const supplied = filterNonEmpty(state);
-  const hasEmptyCell = ___default["default"].some(supplied, function (row) {
-    return ___default["default"].some(row, function (cell) {
+/**
+ * Filters the given table (modelled as a 2D array) to remove any rows that are
+ * completely empty.
+ *
+ * @returns A new table with only non-empty rows.
+ */
+const filterNonEmpty = function (table) {
+  return table.filter(function (row) {
+    // Return only rows that are non-empty.
+    return row.some(cell => cell);
+  });
+};
+
+function validateTable(userInput) {
+  const supplied = filterNonEmpty(userInput);
+  const hasEmptyCell = supplied.some(function (row) {
+    return row.some(function (cell) {
       return cell === "";
     });
   });
@@ -44532,6 +44591,16 @@ function scoreTable(state, rubric, strings) {
       message: null
     };
   }
+  return null;
+}
+
+function scoreTable(userInput, rubric, strings) {
+  const validationResult = validateTable(userInput);
+  if (validationResult != null) {
+    return validationResult;
+  }
+  const supplied = filterNonEmpty(userInput);
+  const solution = filterNonEmpty(rubric.answers);
   if (supplied.length !== solution.length) {
     return {
       type: "points",
@@ -44542,17 +44611,16 @@ function scoreTable(state, rubric, strings) {
   }
   const createValidator = KhanAnswerTypes.number.createValidatorFunctional;
   let message = null;
-  const allCorrect = ___default["default"].every(solution, function (rowSolution) {
+  const allCorrect = solution.every(function (rowSolution) {
     for (let i = 0; i < supplied.length; i++) {
       const rowSupplied = supplied[i];
-      const correct = ___default["default"].every(rowSupplied, function (cellSupplied, i) {
+      const correct = rowSupplied.every(function (cellSupplied, i) {
         const cellSolution = rowSolution[i];
         const validator = createValidator(cellSolution, {
           simplify: true
         }, strings);
         const result = validator(cellSupplied);
         if (result.message) {
-          // @ts-expect-error - TS2322 - Type 'string' is not assignable to type 'null'.
           message = result.message;
         }
         return result.correct;
@@ -44568,7 +44636,7 @@ function scoreTable(state, rubric, strings) {
     type: "points",
     earned: allCorrect ? 1 : 0,
     total: 1,
-    message: message
+    message
   };
 }
 
@@ -44971,7 +45039,7 @@ const init = function () {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus";
-const libVersion = "41.3.0";
+const libVersion = "41.5.0";
 perseusCore.addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {
@@ -45664,7 +45732,7 @@ class ServerItemRenderer extends React__namespace.Component {
 
   /**
    * Accepts a question area widgetId, or an answer area widgetId of
-   * the form "answer-input-number 1", or the string "answer-area"
+   * the form "answer-numeric-input 1", or the string "answer-area"
    * for the whole answer area (if the answer area is a single widget).
    */
   _setWidgetProps(widgetId, newProps, callback) {
@@ -48648,6 +48716,118 @@ const parseExpressionWidget = parseWidget(constant("expression"), object({
   buttonsVisible: optional(enumeration("always", "never", "focused"))
 }));
 
+const parsePerseusRenderer = object({
+  content: 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: (rawVal, ctx) => parseWidgetsMap(rawVal, ctx),
+  metadata: optional(array(string)),
+  images: record(string, object({
+    width: number,
+    height: number
+  }))
+});
+
+const parseGradedGroupWidgetOptions = object({
+  title: string,
+  hasHint: optional(nullable(boolean)),
+  // This module has an import cycle with parsePerseusRenderer.
+  // The anonymous function below ensures that we don't try to access
+  // parsePerseusRenderer before it's defined.
+  hint: optional(nullable((rawVal, ctx) => parsePerseusRenderer(rawVal, ctx))),
+  content: string,
+  // This module has an import cycle with parseWidgetsMap.
+  // The anonymous function below ensures that we don't try to access
+  // parseWidgetsMap before it's defined.
+  widgets: (rawVal, ctx) => parseWidgetsMap(rawVal, ctx),
+  widgetEnabled: optional(nullable(boolean)),
+  immutableWidgets: optional(nullable(boolean)),
+  images: record(string, object({
+    width: number,
+    height: number
+  }))
+});
+const parseGradedGroupWidget = parseWidget(constant("graded-group"), parseGradedGroupWidgetOptions);
+
+const parseGradedGroupSetWidget = parseWidget(constant("graded-group-set"), object({
+  gradedGroups: array(parseGradedGroupWidgetOptions)
+}));
+
+const pairOfNumbers$3 = pair(number, number);
+const pairOfPoints = pair(pairOfNumbers$3, pairOfNumbers$3);
+const parseGrapherWidget = parseWidget(constant("grapher"), object({
+  availableTypes: array(enumeration("absolute_value", "exponential", "linear", "logarithm", "quadratic", "sinusoid", "tangent")),
+  correct: union(object({
+    type: constant("absolute_value"),
+    coords: pairOfPoints
+  })).or(object({
+    type: constant("exponential"),
+    asymptote: pairOfPoints,
+    coords: pairOfPoints
+  })).or(object({
+    type: constant("linear"),
+    coords: pairOfPoints
+  })).or(object({
+    type: constant("logarithm"),
+    asymptote: pairOfPoints,
+    coords: pairOfPoints
+  })).or(object({
+    type: constant("quadratic"),
+    coords: pairOfPoints
+  })).or(object({
+    type: constant("sinusoid"),
+    coords: pairOfPoints
+  })).or(object({
+    type: constant("tangent"),
+    coords: pairOfPoints
+  })).parser,
+  graph: object({
+    backgroundImage: object({
+      bottom: optional(number),
+      height: optional(number),
+      left: optional(number),
+      scale: optional(number),
+      url: optional(nullable(string)),
+      width: optional(number)
+    }),
+    box: optional(pairOfNumbers$3),
+    editableSettings: optional(array(enumeration("graph", "snap", "image", "measure"))),
+    gridStep: optional(pairOfNumbers$3),
+    labels: pair(string, string),
+    markings: enumeration("graph", "none", "grid"),
+    range: pair(pairOfNumbers$3, pairOfNumbers$3),
+    rulerLabel: constant(""),
+    rulerTicks: number,
+    showProtractor: optional(boolean),
+    showRuler: optional(boolean),
+    showTooltips: optional(boolean),
+    snapStep: optional(pairOfNumbers$3),
+    step: pairOfNumbers$3,
+    valid: optional(union(boolean).or(string).parser)
+  })
+}));
+
+const parseGroupWidget = parseWidget(constant("group"),
+// This module has an import cycle with parsePerseusRenderer.
+// The anonymous function below ensures that we don't try to access
+// parsePerseusRenderer before it's defined.
+(rawVal, ctx) => parsePerseusRenderer(rawVal, ctx));
+
+const parseIframeWidget = parseWidget(constant("iframe"), object({
+  url: string,
+  settings: array(object({
+    name: string,
+    value: string
+  })),
+  width: union(number).or(string).parser,
+  height: union(number).or(string).parser,
+  allowFullScreen: boolean,
+  allowTopNavigation: optional(boolean),
+  static: boolean
+}));
+
 const parsePerseusImageBackground = object({
   url: optional(nullable(string)),
   width: optional(number),
@@ -48659,6 +48839,160 @@ const parsePerseusImageBackground = object({
   scale: optional(union(number).or(string).parser)
 });
 
+const pairOfNumbers$2 = pair(number, number);
+const parseImageWidget = parseWidget(constant("image"), object({
+  title: optional(string),
+  caption: optional(string),
+  alt: optional(string),
+  backgroundImage: parsePerseusImageBackground,
+  static: optional(boolean),
+  labels: optional(array(object({
+    content: string,
+    alignment: string,
+    coordinates: array(number)
+  }))),
+  range: optional(pair(pairOfNumbers$2, pairOfNumbers$2)),
+  box: optional(pairOfNumbers$2)
+}));
+
+const parseInputNumberWidget = parseWidget(constant("input-number"), object({
+  answerType: optional(enumeration("number", "decimal", "integer", "rational", "improper", "mixed", "percent", "pi")),
+  inexact: optional(boolean),
+  maxError: optional(union(number).or(string).parser),
+  rightAlign: optional(boolean),
+  simplify: enumeration("required", "optional", "enforced"),
+  size: enumeration("normal", "small"),
+  value: union(number).or(string).parser,
+  customKeypad: optional(boolean)
+}));
+
+const pairOfNumbers$1 = pair(number, number);
+const parseFunctionElement = object({
+  type: constant("function"),
+  key: string,
+  options: object({
+    value: string,
+    funcName: string,
+    rangeMin: string,
+    rangeMax: string,
+    color: string,
+    strokeDasharray: string,
+    strokeWidth: number
+  })
+});
+const parseLabelElement = object({
+  type: constant("label"),
+  key: string,
+  options: object({
+    label: string,
+    color: string,
+    coordX: string,
+    coordY: string
+  })
+});
+const parseLineElement = object({
+  type: constant("line"),
+  key: string,
+  options: object({
+    color: string,
+    startX: string,
+    startY: string,
+    endX: string,
+    endY: string,
+    strokeDasharray: string,
+    strokeWidth: number,
+    arrows: string
+  })
+});
+const parseMovableLineElement = object({
+  type: constant("movable-line"),
+  key: string,
+  options: object({
+    startX: string,
+    startY: string,
+    startSubscript: number,
+    endX: string,
+    endY: string,
+    endSubscript: number,
+    constraint: string,
+    snap: number,
+    constraintFn: string,
+    constraintXMin: string,
+    constraintXMax: string,
+    constraintYMin: string,
+    constraintYMax: string
+  })
+});
+const parseMovablePointElement = object({
+  type: constant("movable-point"),
+  key: string,
+  options: object({
+    startX: string,
+    startY: string,
+    varSubscript: number,
+    constraint: string,
+    snap: number,
+    constraintFn: string,
+    constraintXMin: string,
+    constraintXMax: string,
+    constraintYMin: string,
+    constraintYMax: string
+  })
+});
+const parseParametricElement = object({
+  type: constant("parametric"),
+  key: string,
+  options: object({
+    x: string,
+    y: string,
+    rangeMin: string,
+    rangeMax: string,
+    color: string,
+    strokeDasharray: string,
+    strokeWidth: number
+  })
+});
+const parsePointElement = object({
+  type: constant("point"),
+  key: string,
+  options: object({
+    color: string,
+    coordX: string,
+    coordY: string
+  })
+});
+const parseRectangleElement = object({
+  type: constant("rectangle"),
+  key: string,
+  options: object({
+    color: string,
+    coordX: string,
+    coordY: string,
+    width: string,
+    height: string
+  })
+});
+const parseInteractionWidget = parseWidget(constant("interaction"), object({
+  static: boolean,
+  graph: object({
+    editableSettings: optional(array(enumeration("canvas", "graph"))),
+    box: pairOfNumbers$1,
+    labels: array(string),
+    range: pair(pairOfNumbers$1, pairOfNumbers$1),
+    gridStep: pairOfNumbers$1,
+    markings: enumeration("graph", "grid", "none"),
+    snapStep: optional(pairOfNumbers$1),
+    valid: optional(union(boolean).or(string).parser),
+    backgroundImage: optional(parsePerseusImageBackground),
+    showProtractor: optional(boolean),
+    showRuler: optional(boolean),
+    rulerLabel: optional(string),
+    rulerTicks: optional(number),
+    tickStep: pairOfNumbers$1
+  }),
+  elements: array(union(parseFunctionElement).or(parseLabelElement).or(parseLineElement).or(parseMovableLineElement).or(parseMovablePointElement).or(parseParametricElement).or(parsePointElement).or(parseRectangleElement).parser)
+}));
+
 // Used to represent 2-D points and ranges
 const pairOfNumbers = pair(number, number);
 const parsePerseusGraphTypeAngle = object({
@@ -48845,6 +49179,195 @@ const parseInteractiveGraphWidget = parseWidget(constant("interactive-graph"), o
   fullGraphAriaDescription: optional(string)
 }));
 
+const parseLabelImageWidget = parseWidget(constant("label-image"), object({
+  choices: array(string),
+  imageUrl: string,
+  imageAlt: string,
+  imageHeight: number,
+  imageWidth: number,
+  markers: array(object({
+    answers: array(string),
+    label: string,
+    x: number,
+    y: number
+  })),
+  hideChoicesFromInstructions: boolean,
+  multipleAnswers: boolean,
+  static: boolean
+}));
+
+const parseMatcherWidget = parseWidget(constant("matcher"), object({
+  labels: array(string),
+  left: array(string),
+  right: array(string),
+  orderMatters: boolean,
+  padding: boolean
+}));
+
+const parseMatrixWidget = parseWidget(constant("matrix"), object({
+  prefix: string,
+  suffix: string,
+  answers: array(array(number)),
+  cursorPosition: array(number),
+  matrixBoardSize: array(number),
+  static: boolean
+}));
+
+const parseMeasurerWidget = parseWidget(constant("measurer"), object({
+  image: parsePerseusImageBackground,
+  showProtractor: boolean,
+  showRuler: boolean,
+  rulerLabel: string,
+  rulerTicks: number,
+  rulerPixels: number,
+  rulerLength: number,
+  box: pair(number, number),
+  static: boolean
+}));
+
+const parseMoleculeRendererWidget = parseWidget(constant("molecule-renderer"), object({
+  widgetId: string,
+  rotationAngle: optional(number),
+  smiles: optional(string)
+}));
+
+const parseNumberLineWidget = parseWidget(constant("number-line"), object({
+  range: array(number),
+  labelRange: array(nullable(number)),
+  labelStyle: string,
+  labelTicks: boolean,
+  isTickCtrl: optional(nullable(boolean)),
+  divisionRange: array(number),
+  numDivisions: optional(nullable(number)),
+  snapDivisions: number,
+  tickStep: optional(nullable(number)),
+  correctRel: optional(nullable(string)),
+  correctX: number,
+  initialX: optional(nullable(number)),
+  showTooltip: optional(boolean),
+  static: boolean
+}));
+
+const parseMathFormat = enumeration("integer", "mixed", "improper", "proper", "decimal", "percent", "pi");
+const parseNumericInputWidget = parseWidget(constant("numeric-input"), object({
+  answers: array(object({
+    message: string,
+    value: number,
+    status: string,
+    answerForms: optional(array(parseMathFormat)),
+    strict: boolean,
+    maxError: optional(nullable(number)),
+    simplify: optional(nullable(string))
+  })),
+  labelText: string,
+  size: string,
+  coefficient: boolean,
+  rightAlign: optional(boolean),
+  static: boolean,
+  answerForms: optional(array(object({
+    name: parseMathFormat,
+    simplify: optional(nullable(enumeration("required", "correct", "enforced", "optional")))
+  })))
+}));
+
+// There is an import cycle between orderer-widget.ts and perseus-renderer.ts.
+// This wrapper ensures that we don't refer to parsePerseusRenderer before
+// it's defined.
+function parseRenderer(rawValue, ctx) {
+  return parsePerseusRenderer(rawValue, ctx);
+}
+const parseOrdererWidget = parseWidget(constant("orderer"), object({
+  options: array(parseRenderer),
+  correctOptions: array(parseRenderer),
+  otherOptions: array(parseRenderer),
+  height: string,
+  layout: string
+}));
+
+const parsePassageRefWidget = parseWidget(constant("passage-ref"), object({
+  passageNumber: number,
+  referenceNumber: number,
+  summaryText: string
+}));
+
+const parsePassageWidget = parseWidget(constant("passage"), object({
+  footnotes: string,
+  passageText: string,
+  passageTitle: string,
+  showLineNumbers: boolean,
+  static: boolean
+}));
+
+const parsePhetSimulationWidget = parseWidget(constant("phet-simulation"), object({
+  url: string,
+  description: string
+}));
+
+const parsePlotterWidget = parseWidget(constant("plotter"), object({
+  labels: array(string),
+  categories: array(string),
+  type: enumeration(...plotterPlotTypes),
+  maxY: number,
+  scaleY: number,
+  labelInterval: optional(nullable(number)),
+  snapsPerLine: number,
+  starting: array(number),
+  correct: array(number),
+  picUrl: optional(nullable(string)),
+  picSize: optional(nullable(number)),
+  picBoxHeight: optional(nullable(number)),
+  plotDimensions: array(number)
+}));
+
+const parsePythonProgramWidget = parseWidget(constant("python-program"), object({
+  programID: string,
+  height: number
+}));
+
+const parseRadioWidget = parseWidget(constant("radio"), object({
+  choices: array(object({
+    content: string,
+    clue: optional(string),
+    correct: optional(boolean),
+    isNoneOfTheAbove: optional(boolean),
+    // deprecated
+    // There is an import cycle between radio-widget.ts and
+    // widgets-map.ts. The anonymous function below ensures that we
+    // don't refer to parseWidgetsMap before it's defined.
+    widgets: optional((rawVal, ctx) => parseWidgetsMap(rawVal, ctx))
+  })),
+  hasNoneOfTheAbove: optional(boolean),
+  countChoices: optional(boolean),
+  randomize: optional(boolean),
+  multipleSelect: optional(boolean),
+  deselectEnabled: optional(boolean),
+  // deprecated
+  onePerLine: optional(boolean),
+  // deprecated
+  displayCount: optional(any),
+  // v0 props
+  // `noneOfTheAbove` is still in use (but only set to `false`).
+  noneOfTheAbove: constant(false)
+}));
+
+const parseSorterWidget = parseWidget(constant("sorter"), object({
+  correct: array(string),
+  padding: boolean,
+  layout: enumeration("horizontal", "vertical")
+}));
+
+const parseTableWidget = parseWidget(constant("table"), object({
+  headers: array(string),
+  rows: number,
+  columns: number,
+  answers: array(array(string))
+}));
+
+const parseVideoWidget = parseWidget(constant("video"), object({
+  location: string,
+  static: optional(boolean)
+}));
+
 const parseWidgetsMap = (rawValue, ctx) => {
   if (!isObject(rawValue)) {
     return ctx.failure("PerseusWidgetsMap", rawValue);
@@ -48890,86 +49413,67 @@ const parseWidgetsMapEntry = (_ref, widgetMap, ctx) => {
     case "expression":
       return parseAndAssign(`expression ${id}`, parseExpressionWidget);
     case "grapher":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`grapher ${id}`, any);
+      return parseAndAssign(`grapher ${id}`, parseGrapherWidget);
     case "group":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`group ${id}`, any);
+      return parseAndAssign(`group ${id}`, parseGroupWidget);
     case "graded-group":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`graded-group ${id}`, any);
+      return parseAndAssign(`graded-group ${id}`, parseGradedGroupWidget);
     case "graded-group-set":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`graded-group-set ${id}`, any);
+      return parseAndAssign(`graded-group-set ${id}`, parseGradedGroupSetWidget);
     case "iframe":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`iframe ${id}`, any);
+      return parseAndAssign(`iframe ${id}`, parseIframeWidget);
     case "image":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`image ${id}`, any);
+      return parseAndAssign(`image ${id}`, parseImageWidget);
     case "input-number":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`input-number ${id}`, any);
+      return parseAndAssign(`input-number ${id}`, parseInputNumberWidget);
     case "interaction":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`interaction ${id}`, any);
+      return parseAndAssign(`interaction ${id}`, parseInteractionWidget);
     case "interactive-graph":
       return parseAndAssign(`interactive-graph ${id}`, parseInteractiveGraphWidget);
     case "label-image":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`label-image ${id}`, any);
+      return parseAndAssign(`label-image ${id}`, parseLabelImageWidget);
     case "matcher":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`matcher ${id}`, any);
+      return parseAndAssign(`matcher ${id}`, parseMatcherWidget);
     case "matrix":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`matrix ${id}`, any);
+      return parseAndAssign(`matrix ${id}`, parseMatrixWidget);
     case "measurer":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`measurer ${id}`, any);
+      return parseAndAssign(`measurer ${id}`, parseMeasurerWidget);
     case "molecule-renderer":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`molecule-renderer ${id}`, any);
+      return parseAndAssign(`molecule-renderer ${id}`, parseMoleculeRendererWidget);
     case "number-line":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`number-line ${id}`, any);
+      return parseAndAssign(`number-line ${id}`, parseNumberLineWidget);
     case "numeric-input":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`numeric-input ${id}`, any);
+      return parseAndAssign(`numeric-input ${id}`, parseNumericInputWidget);
     case "orderer":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`orderer ${id}`, any);
+      return parseAndAssign(`orderer ${id}`, parseOrdererWidget);
     case "passage":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`passage ${id}`, any);
+      return parseAndAssign(`passage ${id}`, parsePassageWidget);
     case "passage-ref":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`passage-ref ${id}`, any);
+      return parseAndAssign(`passage-ref ${id}`, parsePassageRefWidget);
     case "passage-ref-target":
-      // TODO(LEMS-2585): implement a real parser for this widget
+      // 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);
     case "phet-simulation":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`phet-simulation ${id}`, any);
+      return parseAndAssign(`phet-simulation ${id}`, parsePhetSimulationWidget);
     case "plotter":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`plotter ${id}`, any);
+      return parseAndAssign(`plotter ${id}`, parsePlotterWidget);
     case "python-program":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`python-program ${id}`, any);
+      return parseAndAssign(`python-program ${id}`, parsePythonProgramWidget);
     case "radio":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`radio ${id}`, any);
+      return parseAndAssign(`radio ${id}`, parseRadioWidget);
     case "sorter":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`sorter ${id}`, any);
+      return parseAndAssign(`sorter ${id}`, parseSorterWidget);
     case "table":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`table ${id}`, any);
+      return parseAndAssign(`table ${id}`, parseTableWidget);
     case "video":
-      // TODO(LEMS-2585): implement a real parser for this widget
-      return parseAndAssign(`video ${id}`, any);
+      return parseAndAssign(`video ${id}`, parseVideoWidget);
     default:
+      if (getWidget(type)) {
+        // @ts-expect-error - 'type' is not a valid widget type
+        return parseAndAssign(`${type} ${id}`, any);
+      }
       return ctx.failure("a valid widget type", type);
   }
 };
@@ -48992,16 +49496,6 @@ const parseHint = object({
   }))
 });
 
-const parsePerseusRenderer = object({
-  content: string,
-  widgets: parseWidgetsMap,
-  metadata: optional(array(string)),
-  images: record(string, object({
-    width: number,
-    height: number
-  }))
-});
-
 object({
   question: parsePerseusRenderer,
   hints: array(parseHint),