@khanacademy/perseus-core 6.0.0 → 7.0.0

package/dist/es/index.js

@@ -0,0 +1,4090 @@
+import _ from 'underscore';
+import _extends from '@babel/runtime/helpers/extends';
+import * as KAS from '@khanacademy/kas';
+import _objectWithoutPropertiesLoose from '@babel/runtime/helpers/objectWithoutPropertiesLoose';
+import { addLibraryVersionToPerseusDebug } from '@khanacademy/perseus-utils';
+
+function getMatrixSize(matrix) {
+  const matrixSize = [1, 1];
+
+  // We need to find the widest row and tallest column to get the correct
+  // matrix size.
+  _(matrix).each((matrixRow, row) => {
+    let rowWidth = 0;
+    _(matrixRow).each((matrixCol, col) => {
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+      if (matrixCol != null && matrixCol.toString().length) {
+        rowWidth = col + 1;
+      }
+    });
+
+    // Matrix width:
+    matrixSize[1] = Math.max(matrixSize[1], rowWidth);
+
+    // Matrix height:
+    if (rowWidth > 0) {
+      matrixSize[0] = Math.max(matrixSize[0], row + 1);
+    }
+  });
+  return matrixSize;
+}
+
+/**
+ *  Get the character used for separating decimals.
+ */
+const getDecimalSeparator = locale => {
+  var _match$;
+  switch (locale) {
+    // TODO(somewhatabstract): Remove this when Chrome supports the `ka`
+    // locale properly.
+    // https://github.com/formatjs/formatjs/issues/1526#issuecomment-559891201
+    //
+    // Supported locales in Chrome:
+    // https://source.chromium.org/chromium/chromium/src/+/master:third_party/icu/scripts/chrome_ui_languages.list
+    case "ka":
+      return ",";
+    default:
+      const numberWithDecimalSeparator = 1.1;
+      // TODO(FEI-3647): Update to use .formatToParts() once we no longer have to
+      // support Safari 12.
+      const match = new Intl.NumberFormat(locale).format(numberWithDecimalSeparator)
+      // 0x661 is ARABIC-INDIC DIGIT ONE
+      // 0x6F1 is EXTENDED ARABIC-INDIC DIGIT ONE
+      // 0x967 is DEVANAGARI DIGIT ONE
+      // 0x9e7 is BENGALI/BANGLA DIGIT ONE
+      .match(/[^\d\u0661\u06F1\u0967\u09e7]/);
+      return (_match$ = match == null ? void 0 : match[0]) != null ? _match$ : ".";
+  }
+};
+
+/**
+ * APPROXIMATE equality on numbers and primitives.
+ */
+function approximateEqual(x, y) {
+  if (typeof x === "number" && typeof y === "number") {
+    return Math.abs(x - y) < 1e-9;
+  }
+  return x === y;
+}
+
+/**
+ * Deep APPROXIMATE equality on primitives, numbers, arrays, and objects.
+ * Recursive.
+ */
+function approximateDeepEqual(x, y) {
+  if (Array.isArray(x) && Array.isArray(y)) {
+    if (x.length !== y.length) {
+      return false;
+    }
+    for (let i = 0; i < x.length; i++) {
+      if (!approximateDeepEqual(x[i], y[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (Array.isArray(x) || Array.isArray(y)) {
+    return false;
+  }
+  if (typeof x === "function" && typeof y === "function") {
+    return approximateEqual(x, y);
+  }
+  if (typeof x === "function" || typeof y === "function") {
+    return false;
+  }
+  if (typeof x === "object" && typeof y === "object" && !!x && !!y) {
+    return x === y || _.all(x, function (v, k) {
+      // @ts-expect-error - TS2536 - Type 'CollectionKey<T>' cannot be used to index type 'T'.
+      return approximateDeepEqual(y[k], v);
+    }) && _.all(y, function (v, k) {
+      // @ts-expect-error - TS2536 - Type 'CollectionKey<T>' cannot be used to index type 'T'.
+      return approximateDeepEqual(x[k], v);
+    });
+  }
+  if (typeof x === "object" && !!x || typeof y === "object" && !!y) {
+    return false;
+  }
+  return approximateEqual(x, y);
+}
+
+/**
+ * Add a widget placeholder using the widget ID.
+ * ex. addWidget("radio 1") => "[[☃ radio 1]]"
+ *
+ * @param {string} id
+ * @returns {string}
+ */
+function addWidget(id) {
+  return `[[☃ ${id}]]`;
+}
+
+/**
+ * Regex for widget placeholders in a string.
+ *
+ * First capture group is the widget ID (ex. 'radio 1')
+ * Second capture group is the widget type (ex. "radio)
+ * exec return will look like: ['[[☃ radio 1]]', 'radio 1', 'radio']
+ */
+function getWidgetRegex() {
+  return /\[\[☃ ([A-Za-z0-9- ]+)\]\]/g;
+}
+
+/**
+ * Extract all widget IDs, which includes the widget type and instance number.
+ * example output: ['radio 1', 'categorizer 1', 'categorizor 2']
+ *
+ * Content should contain Perseus widget placeholders,
+ * which look like: '[[☃ radio 1]]'.
+ *
+ * @param {string} content
+ * @returns {ReadonlyArray<string>} widgetIds
+ */
+function getWidgetIdsFromContent(content) {
+  const widgets = [];
+  const localWidgetRegex = getWidgetRegex();
+  let match = localWidgetRegex.exec(content);
+  while (match !== null) {
+    widgets.push(match[1]);
+    match = localWidgetRegex.exec(content);
+  }
+  return widgets;
+}
+
+/**
+ * Get a list of widget IDs from content,
+ * but only for specific widget types
+ *
+ * @param {string} type the type of widget (ie "radio")
+ * @param {string} content the string to parse
+ * @param {PerseusWidgetsMap} widgetMap widget ID to widget map
+ * @returns {ReadonlyArray<string>} the widget type (ie "radio")
+ */
+function getWidgetIdsFromContentByType(type, content, widgetMap) {
+  const rv = [];
+  const widgetIdsInContent = getWidgetIdsFromContent(content);
+  widgetIdsInContent.forEach(widgetId => {
+    const widget = widgetMap[widgetId];
+    if ((widget == null ? void 0 : widget.type) === type) {
+      rv.push(widgetId);
+    }
+  });
+  return rv;
+}
+
+// TODO(benchristel): in the future, we may want to make deepClone work for
+// Record<string, Cloneable> as well. Currently, it only does arrays.
+
+function deepClone(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(deepClone);
+  }
+  return obj;
+}
+
+const MOVABLES = {
+  PLOT: "PLOT",
+  PARABOLA: "PARABOLA",
+  SINUSOID: "SINUSOID"
+};
+
+// TODO(charlie): These really need to go into a utility file as they're being
+// used by both interactive-graph and now grapher.
+function canonicalSineCoefficients(coeffs) {
+  // For a curve of the form f(x) = a * Sin(b * x - c) + d,
+  // this function ensures that a, b > 0, and c is its
+  // smallest possible positive value.
+  let amplitude = coeffs[0];
+  let angularFrequency = coeffs[1];
+  let phase = coeffs[2];
+  const verticalOffset = coeffs[3];
+
+  // Guarantee a > 0
+  if (amplitude < 0) {
+    amplitude *= -1;
+    angularFrequency *= -1;
+    phase *= -1;
+  }
+  const period = 2 * Math.PI;
+  // Guarantee b > 0
+  if (angularFrequency < 0) {
+    angularFrequency *= -1;
+    phase *= -1;
+    phase += period / 2;
+  }
+
+  // Guarantee c is smallest possible positive value
+  while (phase > 0) {
+    phase -= period;
+  }
+  while (phase < 0) {
+    phase += period;
+  }
+  return [amplitude, angularFrequency, phase, verticalOffset];
+}
+function canonicalTangentCoefficients(coeffs) {
+  // For a curve of the form f(x) = a * Tan(b * x - c) + d,
+  // this function ensures that a, b > 0, and c is its
+  // smallest possible positive value.
+  let amplitude = coeffs[0];
+  let angularFrequency = coeffs[1];
+  let phase = coeffs[2];
+  const verticalOffset = coeffs[3];
+
+  // Guarantee a > 0
+  if (amplitude < 0) {
+    amplitude *= -1;
+    angularFrequency *= -1;
+    phase *= -1;
+  }
+  const period = Math.PI;
+  // Guarantee b > 0
+  if (angularFrequency < 0) {
+    angularFrequency *= -1;
+    phase *= -1;
+    phase += period / 2;
+  }
+
+  // Guarantee c is smallest possible positive value
+  while (phase > 0) {
+    phase -= period;
+  }
+  while (phase < 0) {
+    phase += period;
+  }
+  return [amplitude, angularFrequency, phase, verticalOffset];
+}
+const PlotDefaults = {
+  areEqual: function (coeffs1, coeffs2) {
+    return approximateDeepEqual(coeffs1, coeffs2);
+  },
+  movable: MOVABLES.PLOT,
+  getPropsForCoeffs: function (coeffs) {
+    return {
+      // @ts-expect-error - TS2339 - Property 'getFunctionForCoeffs' does not exist on type '{ readonly areEqual: (coeffs1: any, coeffs2: any) => boolean; readonly Movable: any; readonly getPropsForCoeffs: (coeffs: any) => any; }'.
+      fn: _.partial(this.getFunctionForCoeffs, coeffs)
+    };
+  }
+};
+const Linear = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/67aaf581e6d9ef9038c10558a1f70ac21c11c9f8.png",
+  defaultCoords: [[0.25, 0.75], [0.75, 0.75]],
+  getCoefficients: function (coords) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+    const denom = p2[0] - p1[0];
+    const num = p2[1] - p1[1];
+    if (denom === 0) {
+      return;
+    }
+    const m = num / denom;
+    const b = p2[1] - m * p2[0];
+    return [m, b];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const m = coeffs[0];
+    const b = coeffs[1];
+    return m * x + b;
+  },
+  getEquationString: function (coords) {
+    const coeffs = this.getCoefficients(coords);
+    const m = coeffs[0];
+    const b = coeffs[1];
+    return "y = " + m.toFixed(3) + "x + " + b.toFixed(3);
+  }
+});
+const Quadratic = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/e23d36e6fc29ee37174e92c9daba2a66677128ab.png",
+  defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
+  movable: MOVABLES.PARABOLA,
+  getCoefficients: function (coords) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+
+    // Parabola with vertex (h, k) has form: y = a * (h - k)^2 + k
+    const h = p1[0];
+    const k = p1[1];
+
+    // Use these to calculate familiar a, b, c
+    const a = (p2[1] - k) / ((p2[0] - h) * (p2[0] - h));
+    const b = -2 * h * a;
+    const c = a * h * h + k;
+    return [a, b, c];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return (a * x + b) * x + c;
+  },
+  getPropsForCoeffs: function (coeffs) {
+    return {
+      a: coeffs[0],
+      b: coeffs[1],
+      c: coeffs[2]
+    };
+  },
+  getEquationString: function (coords) {
+    const coeffs = this.getCoefficients(coords);
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return "y = " + a.toFixed(3) + "x^2 + " + b.toFixed(3) + "x + " + c.toFixed(3);
+  }
+});
+const Sinusoid = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/3d68e7718498475f53b206c2ab285626baf8857e.png",
+  defaultCoords: [[0.5, 0.5], [0.6, 0.6]],
+  movable: MOVABLES.SINUSOID,
+  getCoefficients: function (coords) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+    const a = p2[1] - p1[1];
+    const b = Math.PI / (2 * (p2[0] - p1[0]));
+    const c = p1[0] * b;
+    const d = p1[1];
+    return [a, b, c, d];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    const d = coeffs[3];
+    return a * Math.sin(b * x - c) + d;
+  },
+  getPropsForCoeffs: function (coeffs) {
+    return {
+      a: coeffs[0],
+      b: coeffs[1],
+      c: coeffs[2],
+      d: coeffs[3]
+    };
+  },
+  getEquationString: function (coords) {
+    const coeffs = this.getCoefficients(coords);
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    const d = coeffs[3];
+    return "y = " + a.toFixed(3) + " sin(" + b.toFixed(3) + "x - " + c.toFixed(3) + ") + " + d.toFixed(3);
+  },
+  areEqual: function (coeffs1, coeffs2) {
+    return approximateDeepEqual(canonicalSineCoefficients(coeffs1), canonicalSineCoefficients(coeffs2));
+  }
+});
+const Tangent = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/7db80d23c35214f98659fe1cf0765811c1bbfbba.png",
+  defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
+  getCoefficients: function (coords) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+    const a = p2[1] - p1[1];
+    const b = Math.PI / (4 * (p2[0] - p1[0]));
+    const c = p1[0] * b;
+    const d = p1[1];
+    return [a, b, c, d];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    const d = coeffs[3];
+    return a * Math.tan(b * x - c) + d;
+  },
+  getEquationString: function (coords) {
+    const coeffs = this.getCoefficients(coords);
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    const d = coeffs[3];
+    return "y = " + a.toFixed(3) + " sin(" + b.toFixed(3) + "x - " + c.toFixed(3) + ") + " + d.toFixed(3);
+  },
+  areEqual: function (coeffs1, coeffs2) {
+    return approximateDeepEqual(canonicalTangentCoefficients(coeffs1), canonicalTangentCoefficients(coeffs2));
+  }
+});
+const Exponential = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/9cbfad55525e3ce755a31a631b074670a5dad611.png",
+  defaultCoords: [[0.5, 0.55], [0.75, 0.75]],
+  defaultAsymptote: [[0, 0.5], [1.0, 0.5]],
+  /**
+   * Add extra constraints for movement of the points or asymptote (below):
+   *   newCoord: [x, y]
+   *     The end position of the point or asymptote endpoint
+   *   oldCoord: [x, y]
+   *     The old position of the point or asymptote endpoint
+   *   coords:
+   *     An array of coordinates representing the proposed end configuration
+   *     of the plot coordinates.
+   *   asymptote:
+   *     An array of coordinates representing the proposed end configuration
+   *     of the asymptote.
+   *
+   * Return: either a coordinate (to be used as the resulting coordinate of
+   * the move) or a boolean, where `true` uses newCoord as the resulting
+   * coordinate, and `false` uses oldCoord as the resulting coordinate.
+   */
+  extraCoordConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
+    const y = asymptote[0][1];
+    return _.all(coords, coord => coord[1] !== y);
+  },
+  extraAsymptoteConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
+    const y = newCoord[1];
+    const isValid = _.all(coords, coord => coord[1] > y) || _.all(coords, coord => coord[1] < y);
+    if (isValid) {
+      return [oldCoord[0], y];
+    }
+    // Snap the asymptote as close as possible, i.e., if the user moves
+    // the mouse really quickly into an invalid region
+    const oldY = oldCoord[1];
+    const wasBelow = _.all(coords, coord => coord[1] > oldY);
+    if (wasBelow) {
+      const bottomMost = _.min(_.map(coords, coord => coord[1]));
+      return [oldCoord[0], bottomMost - graph.snapStep[1]];
+    }
+    const topMost = _.max(_.map(coords, coord => coord[1]));
+    return [oldCoord[0], topMost + graph.snapStep[1]];
+  },
+  allowReflectOverAsymptote: true,
+  getCoefficients: function (coords, asymptote) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+    const c = asymptote[0][1];
+    const b = Math.log((p1[1] - c) / (p2[1] - c)) / (p1[0] - p2[0]);
+    const a = (p1[1] - c) / Math.exp(b * p1[0]);
+    return [a, b, c];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return a * Math.exp(b * x) + c;
+  },
+  getEquationString: function (coords, asymptote) {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (!asymptote) {
+      return null;
+    }
+    const coeffs = this.getCoefficients(coords, asymptote);
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return "y = " + a.toFixed(3) + "e^(" + b.toFixed(3) + "x) + " + c.toFixed(3);
+  }
+});
+const Logarithm = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/f6491e99d34af34d924bfe0231728ad912068dc3.png",
+  defaultCoords: [[0.55, 0.5], [0.75, 0.75]],
+  defaultAsymptote: [[0.5, 0], [0.5, 1.0]],
+  extraCoordConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
+    const x = asymptote[0][0];
+    return _.all(coords, coord => coord[0] !== x) && coords[0][1] !== coords[1][1];
+  },
+  extraAsymptoteConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
+    const x = newCoord[0];
+    const isValid = _.all(coords, coord => coord[0] > x) || _.all(coords, coord => coord[0] < x);
+    if (isValid) {
+      return [x, oldCoord[1]];
+    }
+    // Snap the asymptote as close as possible, i.e., if the user moves
+    // the mouse really quickly into an invalid region
+    const oldX = oldCoord[0];
+    const wasLeft = _.all(coords, coord => coord[0] > oldX);
+    if (wasLeft) {
+      const leftMost = _.min(_.map(coords, coord => coord[0]));
+      return [leftMost - graph.snapStep[0], oldCoord[1]];
+    }
+    const rightMost = _.max(_.map(coords, coord => coord[0]));
+    return [rightMost + graph.snapStep[0], oldCoord[1]];
+  },
+  allowReflectOverAsymptote: true,
+  getCoefficients: function (coords, asymptote) {
+    // It's easiest to calculate the logarithm's coefficients by thinking
+    // about it as the inverse of the exponential, so we flip x and y and
+    // perform some algebra on the coefficients. This also unifies the
+    // logic between the two 'models'.
+    const flip = coord => [coord[1], coord[0]];
+    const inverseCoeffs = Exponential.getCoefficients(_.map(coords, flip), _.map(asymptote, flip));
+    if (inverseCoeffs) {
+      const c = -inverseCoeffs[2] / inverseCoeffs[0];
+      const b = 1 / inverseCoeffs[0];
+      const a = 1 / inverseCoeffs[1];
+      return [a, b, c];
+    }
+  },
+  getFunctionForCoeffs: function (coeffs, x, asymptote) {
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return a * Math.log(b * x + c);
+  },
+  getEquationString: function (coords, asymptote) {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    if (!asymptote) {
+      return null;
+    }
+    const coeffs = this.getCoefficients(coords, asymptote);
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return "y = ln(" + a.toFixed(3) + "x + " + b.toFixed(3) + ") + " + c.toFixed(3);
+  }
+});
+const AbsoluteValue = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/8256a630175a0cb1d11de223d6de0266daf98721.png",
+  defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
+  getCoefficients: function (coords) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+    const denom = p2[0] - p1[0];
+    const num = p2[1] - p1[1];
+    if (denom === 0) {
+      return;
+    }
+    let m = Math.abs(num / denom);
+    if (p2[1] < p1[1]) {
+      m *= -1;
+    }
+    const horizontalOffset = p1[0];
+    const verticalOffset = p1[1];
+    return [m, horizontalOffset, verticalOffset];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const m = coeffs[0];
+    const horizontalOffset = coeffs[1];
+    const verticalOffset = coeffs[2];
+    return m * Math.abs(x - horizontalOffset) + verticalOffset;
+  },
+  getEquationString: function (coords) {
+    const coeffs = this.getCoefficients(coords);
+    const m = coeffs[0];
+    const horizontalOffset = coeffs[1];
+    const verticalOffset = coeffs[2];
+    return "y = " + m.toFixed(3) + "| x - " + horizontalOffset.toFixed(3) + "| + " + verticalOffset.toFixed(3);
+  }
+});
+
+/* Utility functions for dealing with graphing interfaces. */
+const functionTypeMapping = {
+  linear: Linear,
+  quadratic: Quadratic,
+  sinusoid: Sinusoid,
+  tangent: Tangent,
+  exponential: Exponential,
+  logarithm: Logarithm,
+  absolute_value: AbsoluteValue
+};
+const allTypes = _.keys(functionTypeMapping);
+function functionForType(type) {
+  // @ts-expect-error: TypeScript doesn't know how to use deal with generics
+  // and conditional types in this way.
+  return functionTypeMapping[type];
+}
+
+var grapherUtil = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MOVABLES: MOVABLES,
+    allTypes: allTypes,
+    functionForType: functionForType
+});
+
+function isRealJSONParse(jsonParse) {
+  const randomPhrase = buildRandomPhrase();
+  const randomHintPhrase = buildRandomPhrase();
+  const randomString = buildRandomString();
+  const testingObject = JSON.stringify({
+    answerArea: {
+      calculator: false,
+      chi2Table: false,
+      financialCalculatorMonthlyPayment: false,
+      financialCalculatorTimeToPayOff: false,
+      financialCalculatorTotalAmount: false,
+      periodicTable: false,
+      periodicTableWithKey: false,
+      tTable: false,
+      zTable: false
+    },
+    hints: [randomHintPhrase, `=${Math.floor(Math.random() * 50) + 1}`],
+    itemDataVersion: {
+      major: 0,
+      minor: 1
+    },
+    question: {
+      content: `${randomPhrase}`,
+      images: {},
+      widgets: {
+        expression1: {
+          alignment: "default",
+          graded: false,
+          options: {
+            answerForms: [{
+              considered: "wrong",
+              form: false,
+              key: 0,
+              simplify: false,
+              value: `${randomString}`
+            }],
+            ariaLabel: "Answer",
+            buttonSets: ["basic"],
+            functions: ["f", "g", "h"],
+            static: true,
+            times: false,
+            visibleLabel: "Answer"
+          },
+          static: true,
+          type: "expression",
+          version: {
+            major: 1,
+            minor: 0
+          }
+        }
+      }
+    }
+  });
+  const testJSON = buildTestData(testingObject.replace(/"/g, '\\"'));
+  const parsedTestJSON = jsonParse(testJSON);
+  const parsedTestItemData = parsedTestJSON.data.assessmentItem.item.itemData;
+  return approximateDeepEqual(parsedTestItemData, testingObject);
+}
+function buildRandomString(capitalize = false) {
+  let randomString = "";
+  const randomLength = Math.floor(Math.random() * 8) + 3;
+  for (let i = 0; i < randomLength; i++) {
+    const randomLetter = String.fromCharCode(97 + Math.floor(Math.random() * 26));
+    randomString += capitalize && i === 0 ? randomLetter.toUpperCase() : randomLetter;
+  }
+  return randomString;
+}
+function buildRandomPhrase() {
+  const phrases = [];
+  const randomLength = Math.floor(Math.random() * 10) + 5;
+  for (let i = 0; i < randomLength; i++) {
+    phrases.push(buildRandomString(i === 0));
+  }
+  const modifierStart = ["**", "$"];
+  const modifierEnd = ["**", "$"];
+  const modifierIndex = Math.floor(Math.random() * modifierStart.length);
+  return `${modifierStart[modifierIndex]}${phrases.join(" ")}${modifierEnd[modifierIndex]}`;
+}
+function buildTestData(testObject) {
+  return `{"data":{"assessmentItem":{"__typename":"AssessmentItemOrError","error":null,"item":{"__typename":"AssessmentItem","id":"x890b3c70f3e8f4a6","itemData":"${testObject}","problemType":"Type 1","sha":"c7284a3ad65214b4e62bccce236d92f7f5d35941"}}}}`;
+}
+
+function success(value) {
+  return {
+    type: "success",
+    value
+  };
+}
+function failure(detail) {
+  return {
+    type: "failure",
+    detail
+  };
+}
+function isFailure(result) {
+  return result.type === "failure";
+}
+function isSuccess(result) {
+  return result.type === "success";
+}
+
+// Result's `all` function is similar to Promise.all: given an array of
+// results, it returns success if all succeeded, and failure if any failed.
+function all(results, combineFailureDetails = a => a) {
+  const values = [];
+  const failureDetails = [];
+  for (const result of results) {
+    if (result.type === "success") {
+      values.push(result.value);
+    } else {
+      failureDetails.push(result.detail);
+    }
+  }
+  if (failureDetails.length > 0) {
+    return failure(failureDetails.reduce(combineFailureDetails));
+  }
+  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) {
+  return (rawValue, ctx) => {
+    if (!Array.isArray(rawValue)) {
+      return ctx.failure("array", rawValue);
+    }
+    const elementResults = rawValue.map((elem, i) => elementParser(elem, ctx.forSubtree(i)));
+    return all(elementResults, concat);
+  };
+}
+function concat(a, b) {
+  return [...a, ...b];
+}
+
+function boolean(rawValue, ctx) {
+  if (typeof rawValue === "boolean") {
+    return ctx.success(rawValue);
+  }
+  return ctx.failure("boolean", rawValue);
+}
+
+function constant(acceptedValue) {
+  return (rawValue, ctx) => {
+    if (rawValue !== acceptedValue) {
+      return ctx.failure(String(JSON.stringify(acceptedValue)), rawValue);
+    }
+    return ctx.success(acceptedValue);
+  };
+}
+
+function enumeration(...acceptedValues) {
+  return (rawValue, ctx) => {
+    if (typeof rawValue === "string") {
+      const index = acceptedValues.indexOf(rawValue);
+      if (index > -1) {
+        return ctx.success(acceptedValues[index]);
+      }
+    }
+    const expected = acceptedValues.map(v => JSON.stringify(v));
+    return ctx.failure(expected, rawValue);
+  };
+}
+
+function isObject(x) {
+  return x != null && Object.getPrototypeOf(x) === Object.prototype;
+}
+
+function nullable(parseValue) {
+  return (rawValue, ctx) => {
+    if (rawValue === null) {
+      return ctx.success(rawValue);
+    }
+    return parseValue(rawValue, ctx);
+  };
+}
+
+const number = (rawValue, ctx) => {
+  if (typeof rawValue === "number") {
+    return ctx.success(rawValue);
+  }
+  return ctx.failure("number", rawValue);
+};
+
+function object(schema) {
+  return (rawValue, ctx) => {
+    if (!isObject(rawValue)) {
+      return ctx.failure("object", rawValue);
+    }
+    const ret = _extends({}, rawValue);
+    const mismatches = [];
+    for (const [prop, propParser] of Object.entries(schema)) {
+      const result = propParser(rawValue[prop], ctx.forSubtree(prop));
+      if (isSuccess(result)) {
+        if (result.value !== undefined || prop in rawValue) {
+          ret[prop] = result.value;
+        }
+      } else {
+        mismatches.push(...result.detail);
+      }
+    }
+    if (mismatches.length > 0) {
+      return failure(mismatches);
+    }
+    return ctx.success(ret);
+  };
+}
+
+function optional(parseValue) {
+  return (rawValue, ctx) => {
+    if (rawValue === undefined) {
+      return ctx.success(rawValue);
+    }
+    return parseValue(rawValue, ctx);
+  };
+}
+
+function pair(parseA, parseB) {
+  return (rawValue, ctx) => {
+    if (!Array.isArray(rawValue)) {
+      return ctx.failure("array", rawValue);
+    }
+    if (rawValue.length !== 2) {
+      return ctx.failure("array of length 2", rawValue);
+    }
+    const [rawA, rawB] = rawValue;
+    const resultA = parseA(rawA, ctx.forSubtree(0));
+    if (isFailure(resultA)) {
+      return resultA;
+    }
+    const resultB = parseB(rawB, ctx.forSubtree(1));
+    if (isFailure(resultB)) {
+      return resultB;
+    }
+    return ctx.success([resultA.value, resultB.value]);
+  };
+}
+
+function pipeParsers(p) {
+  return new ParserPipeline(p);
+}
+class ParserPipeline {
+  constructor(parser) {
+    this.parser = parser;
+  }
+  then(nextParser) {
+    return new ParserPipeline(composeParsers(this.parser, nextParser));
+  }
+}
+function composeParsers(parserA, parserB) {
+  return (rawValue, ctx) => {
+    const partialResult = parserA(rawValue, ctx);
+    if (isFailure(partialResult)) {
+      return partialResult;
+    }
+    return parserB(partialResult.value, ctx);
+  };
+}
+
+function record(parseKey, parseValue) {
+  return (rawValue, ctx) => {
+    if (!isObject(rawValue)) {
+      return ctx.failure("object", rawValue);
+    }
+    const result = {};
+    const mismatches = [];
+    for (const [key, value] of Object.entries(rawValue)) {
+      const entryCtx = ctx.forSubtree(key);
+      const keyResult = parseKey(key, entryCtx);
+      if (isFailure(keyResult)) {
+        mismatches.push(...keyResult.detail);
+      }
+      const valueResult = parseValue(value, entryCtx);
+      if (isFailure(valueResult)) {
+        mismatches.push(...valueResult.detail);
+      }
+      if (isSuccess(keyResult) && isSuccess(valueResult)) {
+        result[keyResult.value] = valueResult.value;
+      }
+    }
+    if (mismatches.length > 0) {
+      return failure(mismatches);
+    }
+    return ctx.success(result);
+  };
+}
+
+const string = (rawValue, ctx) => {
+  if (typeof rawValue === "string") {
+    return ctx.success(rawValue);
+  }
+  return ctx.failure("string", rawValue);
+};
+
+function trio(parseA, parseB, parseC) {
+  return (rawValue, ctx) => {
+    if (!Array.isArray(rawValue)) {
+      return ctx.failure("array", rawValue);
+    }
+    if (rawValue.length !== 3) {
+      return ctx.failure("array of length 3", rawValue);
+    }
+    const resultA = parseA(rawValue[0], ctx.forSubtree(0));
+    if (isFailure(resultA)) {
+      return resultA;
+    }
+    const resultB = parseB(rawValue[1], ctx.forSubtree(1));
+    if (isFailure(resultB)) {
+      return resultB;
+    }
+    const resultC = parseC(rawValue[2], ctx.forSubtree(2));
+    if (isFailure(resultC)) {
+      return resultC;
+    }
+    return ctx.success([resultA.value, resultB.value, resultC.value]);
+  };
+}
+
+function union(parseBranch) {
+  return new UnionBuilder(parseBranch);
+}
+class UnionBuilder {
+  constructor(parser) {
+    this.parser = parser;
+  }
+  or(newBranch) {
+    return new UnionBuilder(either(this.parser, newBranch));
+  }
+}
+function either(parseA, parseB) {
+  return (rawValue, ctx) => {
+    const resultA = parseA(rawValue, ctx);
+    if (isSuccess(resultA)) {
+      return resultA;
+    }
+    return parseB(rawValue, ctx);
+  };
+}
+
+function defaulted(parser, fallback) {
+  return (rawValue, ctx) => {
+    if (rawValue == null) {
+      return success(fallback(rawValue));
+    }
+    return parser(rawValue, ctx);
+  };
+}
+
+const parseImages = defaulted(record(string, object({
+  width: number,
+  height: number
+})), () => ({}));
+
+function parseWidget(parseType, parseOptions) {
+  return object({
+    type: parseType,
+    static: optional(boolean),
+    graded: optional(boolean),
+    alignment: optional(string),
+    options: parseOptions,
+    key: optional(nullable(number)),
+    version: optional(object({
+      major: number,
+      minor: number
+    }))
+  });
+}
+function parseWidgetWithVersion(parseVersion, parseType, parseOptions) {
+  return object({
+    type: parseType,
+    static: optional(boolean),
+    graded: optional(boolean),
+    alignment: optional(string),
+    options: parseOptions,
+    key: optional(nullable(number)),
+    version: parseVersion
+  });
+}
+
+const parseCategorizerWidget = parseWidget(constant("categorizer"), object({
+  items: array(string),
+  categories: array(string),
+  randomizeItems: defaulted(boolean, () => false),
+  static: defaulted(boolean, () => false),
+  values: array(defaulted(number, () => 0)),
+  highlightLint: optional(boolean),
+  linterContext: optional(object({
+    contentType: string,
+    paths: array(string),
+    stack: array(string)
+  }))
+}));
+
+const parseCSProgramWidget = parseWidget(constant("cs-program"), object({
+  programID: string,
+  programType: any,
+  settings: array(object({
+    name: string,
+    value: string
+  })),
+  showEditor: boolean,
+  showButtons: boolean,
+  height: number,
+  static: defaulted(boolean, () => false)
+}));
+
+const parseDefinitionWidget = parseWidget(constant("definition"), object({
+  togglePrompt: string,
+  definition: string,
+  static: defaulted(boolean, () => false)
+}));
+
+const parseDropdownWidget = parseWidget(constant("dropdown"), object({
+  placeholder: defaulted(string, () => ""),
+  ariaLabel: optional(string),
+  visibleLabel: optional(string),
+  static: defaulted(boolean, () => false),
+  choices: array(object({
+    content: string,
+    correct: boolean
+  }))
+}));
+
+const parseExplanationWidget = parseWidget(constant("explanation"), object({
+  showPrompt: string,
+  hidePrompt: string,
+  explanation: string,
+  // We wrap parseWidgetsMap in a function here to make sure it is not
+  // referenced before it is defined. There is an import cycle between
+  // this file and widgets-map.ts that could cause it to be undefined.
+  widgets: defaulted((rawVal, ctx) => parseWidgetsMap(rawVal, ctx), () => ({})),
+  static: defaulted(boolean, () => false)
+}));
+
+const KeypadKeys = ["PLUS", "MINUS", "NEGATIVE", "TIMES", "DIVIDE", "DECIMAL", "PERIOD", "PERCENT", "CDOT", "EQUAL", "NEQ", "GT", "LT", "GEQ", "LEQ",
+// mobile native only
+"FRAC_INCLUSIVE",
+// mobile native only
+"FRAC_EXCLUSIVE",
+// mobile native only
+"FRAC", "EXP", "EXP_2", "EXP_3", "SQRT", "CUBE_ROOT", "RADICAL", "LEFT_PAREN", "RIGHT_PAREN", "LN", "LOG", "LOG_N", "SIN", "COS",
+// TODO(charlie): Add in additional Greek letters.,
+"TAN", "PI", "THETA", "UP", "RIGHT", "DOWN", "LEFT", "BACKSPACE", "DISMISS", "JUMP_OUT_PARENTHESES", "JUMP_OUT_EXPONENT", "JUMP_OUT_BASE", "JUMP_INTO_NUMERATOR", "JUMP_OUT_NUMERATOR", "JUMP_OUT_DENOMINATOR",
+// Multi-functional keys.
+"NUM_0", "NUM_1", "NUM_2", "NUM_3", "NUM_4", "NUM_5", "NUM_6", "NUM_7", "NUM_8", "NUM_9", "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", "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"];
+
+// Used by KeypadContext to pass around a renderer reference
+
+/**
+ * Scrape the answer forms for any variables or contants (like Pi)
+ * that need to be included as keys on the keypad.
+ */
+function deriveExtraKeys(widgetOptions) {
+  if (widgetOptions.extraKeys) {
+    return widgetOptions.extraKeys;
+  }
+
+  // If there are no extra symbols available, we include Pi anyway, so
+  // that the "extra symbols" button doesn't appear empty.
+  const defaultKeys = ["PI"];
+  if (widgetOptions.answerForms == null) {
+    return defaultKeys;
+  }
+
+  // Extract any and all variables and constants from the answer forms.
+  const uniqueExtraVariables = {};
+  const uniqueExtraConstants = {};
+  for (const answerForm of widgetOptions.answerForms) {
+    const maybeExpr = KAS.parse(answerForm.value, widgetOptions);
+    if (maybeExpr.parsed) {
+      const expr = maybeExpr.expr;
+
+      // The keypad expects Greek letters to be capitalized (e.g., it
+      // requires `PI` instead of `pi`). Right now, it only supports Pi
+      // and Theta, so we special-case.
+      const isGreek = symbol => symbol === "pi" || symbol === "theta";
+      const toKey = symbol => isGreek(symbol) ? symbol.toUpperCase() : symbol;
+      const isKey = key => KeypadKeys.includes(key);
+      for (const variable of expr.getVars()) {
+        const maybeKey = toKey(variable);
+        if (isKey(maybeKey)) {
+          uniqueExtraVariables[maybeKey] = true;
+        }
+      }
+      for (const constant of expr.getConsts()) {
+        const maybeKey = toKey(constant);
+        if (isKey(maybeKey)) {
+          uniqueExtraConstants[maybeKey] = true;
+        }
+      }
+    }
+  }
+
+  // TODO(charlie): Alert the keypad as to which of these symbols should be
+  // treated as functions.
+  const extraVariables = Object.keys(uniqueExtraVariables).sort();
+  const extraConstants = Object.keys(uniqueExtraConstants).sort();
+  const extraKeys = [...extraVariables, ...extraConstants];
+  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+  if (!extraKeys.length) {
+    return defaultKeys;
+  }
+  return extraKeys;
+}
+
+// Given a function, creates a PartialParser that converts one type to another
+// using that function. The returned parser never fails.
+function convert(f) {
+  return (rawValue, ctx) => ctx.success(f(rawValue));
+}
+
+const parseLegacyButtonSet = enumeration("basic", "basic+div", "trig", "prealgebra", "logarithms", "basic relations", "advanced relations", "scientific");
+const parseLegacyButtonSets = defaulted(array(parseLegacyButtonSet),
+// NOTE(benchristel): I copied the default buttonSets from
+// expression.tsx. See the parse-perseus-json/README.md for
+// an explanation of why we want to duplicate the default here.
+() => ["basic", "trig", "prealgebra", "logarithms"]);
+
+/**
+ * Creates a parser for a widget options type with multiple major versions. Old
+ * versions are migrated to the latest version. The parse fails if the input
+ * data does not match any of the versions.
+ *
+ * @example
+ * const parseOptions = versionedWidgetOptions(3, parseOptionsV3)
+ *     .withMigrationFrom(2, parseOptionsV2, migrateV2ToV3)
+ *     .withMigrationFrom(1, parseOptionsV1, migrateV1ToV2)
+ *     .withMigrationFrom(0, parseOptionsV0, migrateV0ToV1)
+ *     .parser;
+ *
+ * @param latestMajorVersion the latest major version of the widget options.
+ * @param parseLatest a {@link Parser} for the latest version of the widget
+ * options.
+ * @returns a builder object, to which migrations from earlier versions can be
+ * added. Migrations must be added in "reverse chronological" order as in the
+ * example above.
+ */
+function versionedWidgetOptions(latestMajorVersion, parseLatest) {
+  return new VersionedWidgetOptionsParserBuilder(latestMajorVersion, parseLatest, latest => latest, (raw, ctx) => ctx.failure("widget options with a known version number", raw));
+}
+class VersionedWidgetOptionsParserBuilder {
+  constructor(majorVersion, parseThisVersion, migrateToLatest, parseOtherVersions) {
+    this.parser = void 0;
+    this.migrateToLatest = migrateToLatest;
+    this.parseOtherVersions = parseOtherVersions;
+    const parseThisVersionAndMigrateToLatest = pipeParsers(parseThisVersion).then(convert(this.migrateToLatest)).parser;
+    this.parser = (raw, ctx) => {
+      if (!isObject(raw)) {
+        return ctx.failure("object", raw);
+      }
+      const versionParseResult = parseVersionedObject(raw, ctx);
+      if (isFailure(versionParseResult)) {
+        return versionParseResult;
+      }
+      if (versionParseResult.value.version.major !== majorVersion) {
+        return this.parseOtherVersions(raw, ctx);
+      }
+      return parseThisVersionAndMigrateToLatest(raw, ctx);
+    };
+  }
+
+  /**
+   * Add a migration from an old version of the widget options.
+   */
+  withMigrationFrom(majorVersion, parseOldVersion, migrateToNextVersion) {
+    const parseOtherVersions = this.parser;
+    const migrateToLatest = old => this.migrateToLatest(migrateToNextVersion(old));
+    return new VersionedWidgetOptionsParserBuilder(majorVersion, parseOldVersion, migrateToLatest, parseOtherVersions);
+  }
+}
+const parseVersionedObject = object({
+  version: defaulted(object({
+    major: number,
+    minor: number
+  }), () => ({
+    major: 0,
+    minor: 0
+  }))
+});
+
+const stringOrNumberOrNullOrUndefined = union(string).or(number).or(constant(null)).or(constant(undefined)).parser;
+const parsePossiblyInvalidAnswerForm = object({
+  // `value` is the possibly invalid part of this. It should always be a
+  // string, but some answer forms don't have it. The Expression widget
+  // ignores invalid values, so we can safely filter them out during parsing.
+  value: optional(string),
+  form: defaulted(boolean, () => false),
+  simplify: defaulted(boolean, () => false),
+  considered: enumeration("correct", "wrong", "ungraded"),
+  key: pipeParsers(stringOrNumberOrNullOrUndefined).then(convert(String)).parser
+});
+function removeInvalidAnswerForms(possiblyInvalid) {
+  const valid = [];
+  for (const answerForm of possiblyInvalid) {
+    const {
+      value
+    } = answerForm;
+    if (value != null) {
+      // Copying the object seems to be needed to make TypeScript happy
+      valid.push(_extends({}, answerForm, {
+        value
+      }));
+    }
+  }
+  return valid;
+}
+const version2$1 = object({
+  major: constant(2),
+  minor: number
+});
+const parseExpressionWidgetV2 = parseWidgetWithVersion(version2$1, constant("expression"), object({
+  answerForms: pipeParsers(array(parsePossiblyInvalidAnswerForm)).then(convert(removeInvalidAnswerForms)).parser,
+  functions: array(string),
+  times: boolean,
+  visibleLabel: optional(string),
+  ariaLabel: optional(string),
+  buttonSets: parseLegacyButtonSets,
+  buttonsVisible: optional(enumeration("always", "never", "focused")),
+  extraKeys: array(enumeration(...KeypadKeys))
+}));
+const version1$1 = object({
+  major: constant(1),
+  minor: number
+});
+const parseExpressionWidgetV1 = parseWidgetWithVersion(version1$1, constant("expression"), object({
+  answerForms: pipeParsers(array(parsePossiblyInvalidAnswerForm)).then(convert(removeInvalidAnswerForms)).parser,
+  functions: array(string),
+  times: boolean,
+  visibleLabel: optional(string),
+  ariaLabel: optional(string),
+  buttonSets: parseLegacyButtonSets,
+  buttonsVisible: optional(enumeration("always", "never", "focused"))
+}));
+function migrateV1ToV2$1(widget) {
+  const {
+    options
+  } = widget;
+  return _extends({}, widget, {
+    version: {
+      major: 2,
+      minor: 0
+    },
+    options: {
+      times: options.times,
+      buttonSets: options.buttonSets,
+      functions: options.functions,
+      buttonsVisible: options.buttonsVisible,
+      visibleLabel: options.visibleLabel,
+      ariaLabel: options.ariaLabel,
+      answerForms: options.answerForms,
+      extraKeys: deriveExtraKeys(options)
+    }
+  });
+}
+const version0$1 = optional(object({
+  major: constant(0),
+  minor: number
+}));
+const parseExpressionWidgetV0 = parseWidgetWithVersion(version0$1, constant("expression"), object({
+  functions: array(string),
+  times: boolean,
+  visibleLabel: optional(string),
+  ariaLabel: optional(string),
+  form: boolean,
+  simplify: boolean,
+  value: string,
+  buttonSets: parseLegacyButtonSets,
+  buttonsVisible: optional(enumeration("always", "never", "focused"))
+}));
+function migrateV0ToV1$1(widget) {
+  const {
+    options
+  } = widget;
+  return _extends({}, widget, {
+    version: {
+      major: 1,
+      minor: 0
+    },
+    options: {
+      times: options.times,
+      buttonSets: options.buttonSets,
+      functions: options.functions,
+      buttonsVisible: options.buttonsVisible,
+      visibleLabel: options.visibleLabel,
+      ariaLabel: options.ariaLabel,
+      answerForms: [{
+        considered: "correct",
+        form: options.form,
+        simplify: options.simplify,
+        value: options.value
+      }]
+    }
+  });
+}
+const parseExpressionWidget = versionedWidgetOptions(2, parseExpressionWidgetV2).withMigrationFrom(1, parseExpressionWidgetV1, migrateV1ToV2$1).withMigrationFrom(0, parseExpressionWidgetV0, migrateV0ToV1$1).parser;
+
+const falseToNull = pipeParsers(constant(false)).then(convert(() => null)).parser;
+const parseGradedGroupWidgetOptions = object({
+  title: defaulted(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: union(falseToNull).or(constant(null)).or(constant(undefined)).or((rawVal, ctx) => parsePerseusRenderer(rawVal, ctx)).parser,
+  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)
+}));
+
+/**
+ * discriminatedUnion() should be preferred over union() when parsing a
+ * discriminated union type, because discriminatedUnion() produces more
+ * understandable failure messages. It takes the discriminant as the source of
+ * truth for which variant is to be parsed, and expects the other data to match
+ * that variant.
+ */
+function discriminatedUnionOn(discriminantKey) {
+  const noMoreBranches = (raw, ctx) => {
+    if (!isObject(raw)) {
+      return ctx.failure("object", raw);
+    }
+    return ctx.forSubtree(discriminantKey).failure("a valid value", raw[discriminantKey]);
+  };
+  return new DiscriminatedUnionBuilder(discriminantKey, noMoreBranches);
+}
+class DiscriminatedUnionBuilder {
+  constructor(discriminantKey, parser) {
+    this.discriminantKey = discriminantKey;
+    this.parser = parser;
+  }
+  withBranch(discriminantValue, parseNewVariant) {
+    const parseNewBranch = discriminatedUnionBranch(this.discriminantKey, discriminantValue, parseNewVariant, this.parser);
+    return new DiscriminatedUnionBuilder(this.discriminantKey, parseNewBranch);
+  }
+}
+function discriminatedUnionBranch(discriminantKey, discriminantValue, parseVariant, parseOtherBranches) {
+  return (raw, ctx) => {
+    if (!isObject(raw)) {
+      return ctx.failure("object", raw);
+    }
+    if (raw[discriminantKey] === discriminantValue) {
+      return parseVariant(raw, ctx);
+    }
+    return parseOtherBranches(raw, ctx);
+  };
+}
+
+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: discriminatedUnionOn("type").withBranch("absolute_value", object({
+    type: constant("absolute_value"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("exponential", object({
+    type: constant("exponential"),
+    asymptote: pairOfPoints,
+    coords: nullable(pairOfPoints)
+  })).withBranch("linear", object({
+    type: constant("linear"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("logarithm", object({
+    type: constant("logarithm"),
+    asymptote: pairOfPoints,
+    coords: nullable(pairOfPoints)
+  })).withBranch("quadratic", object({
+    type: constant("quadratic"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("sinusoid", object({
+    type: constant("sinusoid"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("tangent", object({
+    type: constant("tangent"),
+    coords: nullable(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: optional(array(object({
+    name: string,
+    value: string
+  }))),
+  width: union(number).or(string).parser,
+  height: union(number).or(string).parser,
+  allowFullScreen: defaulted(boolean, () => false),
+  allowTopNavigation: optional(boolean),
+  static: defaulted(boolean, () => false)
+}));
+
+const stringToNumber = (rawValue, ctx) => {
+  if (typeof rawValue === "number") {
+    return ctx.success(rawValue);
+  }
+  const parsedNumber = +rawValue;
+  if (rawValue === "" || isNaN(parsedNumber)) {
+    return ctx.failure("a number or numeric string", rawValue);
+  }
+  return ctx.success(parsedNumber);
+};
+
+function emptyToZero(x) {
+  return x === "" ? 0 : x;
+}
+const imageDimensionToNumber = pipeParsers(union(number).or(string).parser)
+// In this specific case, empty string is equivalent to zero. An empty
+// string parses to either NaN (using parseInt) or 0 (using unary +) and
+// CSS will treat NaN as invalid and default to 0 instead.
+.then(convert(emptyToZero)).then(stringToNumber).parser;
+const dimensionOrUndefined = defaulted(imageDimensionToNumber, () => undefined);
+const parsePerseusImageBackground = object({
+  url: optional(nullable(string)),
+  width: dimensionOrUndefined,
+  height: dimensionOrUndefined,
+  top: dimensionOrUndefined,
+  left: dimensionOrUndefined,
+  bottom: dimensionOrUndefined,
+  scale: dimensionOrUndefined
+});
+
+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 booleanToString = (rawValue, ctx) => {
+  if (typeof rawValue === "boolean") {
+    return ctx.success(String(rawValue));
+  }
+  return ctx.failure("boolean", rawValue);
+};
+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"),
+  // TODO(benchristel): there are some content items where value is a
+  // boolean, even though that makes no sense. We should figure out if
+  // those content items are actually published anywhere, and consider
+  // updating them.
+  value: union(number).or(string).or(booleanToString).parser,
+  customKeypad: optional(boolean)
+}));
+
+const pairOfNumbers$1 = pair(number, number);
+const stringOrEmpty = defaulted(string, () => "");
+const parseKey = pipeParsers(optional(string)).then(convert(String)).parser;
+const parseFunctionElement = object({
+  type: constant("function"),
+  key: parseKey,
+  options: object({
+    value: string,
+    funcName: string,
+    rangeMin: string,
+    rangeMax: string,
+    color: string,
+    strokeDasharray: string,
+    strokeWidth: number
+  })
+});
+const parseLabelElement = object({
+  type: constant("label"),
+  key: parseKey,
+  options: object({
+    label: string,
+    color: string,
+    coordX: string,
+    coordY: string
+  })
+});
+const parseLineElement = object({
+  type: constant("line"),
+  key: parseKey,
+  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: parseKey,
+  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: parseKey,
+  options: object({
+    startX: string,
+    startY: string,
+    varSubscript: number,
+    constraint: string,
+    snap: number,
+    constraintFn: string,
+    constraintXMin: stringOrEmpty,
+    constraintXMax: stringOrEmpty,
+    constraintYMin: stringOrEmpty,
+    constraintYMax: stringOrEmpty
+  })
+});
+const parseParametricElement = object({
+  type: constant("parametric"),
+  key: parseKey,
+  options: object({
+    x: string,
+    y: string,
+    rangeMin: string,
+    rangeMax: string,
+    color: string,
+    strokeDasharray: string,
+    strokeWidth: number
+  })
+});
+const parsePointElement = object({
+  type: constant("point"),
+  key: parseKey,
+  options: object({
+    color: string,
+    coordX: string,
+    coordY: string
+  })
+});
+const parseRectangleElement = object({
+  type: constant("rectangle"),
+  key: parseKey,
+  options: object({
+    color: string,
+    coordX: string,
+    coordY: string,
+    width: string,
+    height: string
+  })
+});
+const parseInteractionWidget = parseWidget(constant("interaction"), object({
+  static: defaulted(boolean, () => false),
+  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(discriminatedUnionOn("type").withBranch("function", parseFunctionElement).withBranch("label", parseLabelElement).withBranch("line", parseLineElement).withBranch("movable-line", parseMovableLineElement).withBranch("movable-point", parseMovablePointElement).withBranch("parametric", parseParametricElement).withBranch("point", parsePointElement).withBranch("rectangle", parseRectangleElement).parser)
+}));
+
+/**
+ * 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
+
+/**
+ * A utility type that constructs a widget map from a "registry interface".
+ * The keys of the registry should be the widget type (aka, "categorizer" or
+ * "radio", etc) and the value should be the option type stored in the value
+ * of the map.
+ *
+ * You can think of this as a type that generates another type. We use
+ * "registry interfaces" as a way to keep a set of widget types to their data
+ * type in several places in Perseus. This type then allows us to generate a
+ * map type that maps a widget id to its data type and keep strong typing by
+ * widget id.
+ *
+ * For example, given a fictitious registry such as this:
+ *
+ * ```
+ * interface DummyRegistry {
+ *     categorizer: { categories: ReadonlyArray<string> };
+ *     dropdown: { choices: ReadonlyArray<string> }:
+ * }
+ * ```
+ *
+ * If we create a DummyMap using this helper:
+ *
+ * ```
+ * type DummyMap = MakeWidgetMap<DummyRegistry>;
+ * ```
+ *
+ * We'll get a map that looks like this:
+ *
+ * ```
+ * type DummyMap = {
+ *     `categorizer ${number}`: { categories: ReadonlyArray<string> };
+ *     `dropdown ${number}`: { choices: ReadonlyArray<string> };
+ * }
+ * ```
+ *
+ * We use interfaces for the registries so that they can be extended in cases
+ * where the consuming app brings along their own widgets. Interfaces in
+ * TypeScript are always open (ie. you can extend them) whereas types aren't.
+ */
+
+/**
+ * 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-core" {
+ *     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!
+ */
+
+/**
+ * PerseusWidget is a union of all the different types of widget options that
+ * Perseus knows about.
+ *
+ * Thanks to it being based on PerseusWidgetTypes interface, this union is
+ * automatically extended to include widgets used in tests without those widget
+ * option types seeping into our production types.
+ *
+ * @see MockWidget for an example
+ */
+
+/**
+ * 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.
+ */
+
+/**
+ * The type of markings to display on the graph.
+ * - axes: shows the axes without the gride lines
+ * - graph: shows the axes and the grid lines
+ * - grid: shows only the grid lines
+ * - none: shows no markings
+ */
+
+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
+
+/**
+ * Determines how unsimplified fractions are scored.
+ *
+ * - "required" means unsimplified fractions are considered invalid input, and
+ *   the learner can try again.
+ * - "enforced" means unsimplified fractions are marked incorrect.
+ * - "optional" means unsimplified fractions are accepted.
+ */
+
+const plotterPlotTypes = ["bar", "line", "pic", "histogram", "dotplot"];
+
+// Used to represent 2-D points and ranges
+const pairOfNumbers = pair(number, number);
+const parsePerseusGraphTypeAngle = object({
+  type: constant("angle"),
+  showAngles: optional(boolean),
+  allowReflexAngles: optional(boolean),
+  angleOffsetDeg: optional(number),
+  snapDegrees: optional(number),
+  match: optional(constant("congruent")),
+  coords: optional(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers)),
+  startCoords: optional(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers))
+});
+const parsePerseusGraphTypeCircle = object({
+  type: constant("circle"),
+  center: optional(pairOfNumbers),
+  radius: optional(number),
+  startCoords: optional(object({
+    center: pairOfNumbers,
+    radius: number
+  })),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeLinear = object({
+  type: constant("linear"),
+  coords: optional(nullable(pair(pairOfNumbers, pairOfNumbers))),
+  startCoords: optional(pair(pairOfNumbers, pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeLinearSystem = object({
+  type: constant("linear-system"),
+  // TODO(benchristel): default coords to empty array?
+  coords: optional(nullable(array(pair(pairOfNumbers, pairOfNumbers)))),
+  startCoords: optional(array(pair(pairOfNumbers, pairOfNumbers))),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeNone = object({
+  type: constant("none")
+});
+const parsePerseusGraphTypePoint = object({
+  type: constant("point"),
+  numPoints: optional(union(number).or(constant("unlimited")).parser),
+  coords: optional(nullable(array(pairOfNumbers))),
+  startCoords: optional(array(pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypePolygon = object({
+  type: constant("polygon"),
+  numSides: optional(union(number).or(constant("unlimited")).parser),
+  showAngles: optional(boolean),
+  showSides: optional(boolean),
+  snapTo: optional(enumeration("grid", "angles", "sides")),
+  match: optional(enumeration("similar", "congruent", "approx", "exact")),
+  startCoords: optional(array(pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeQuadratic = object({
+  type: constant("quadratic"),
+  coords: optional(nullable(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers))),
+  startCoords: optional(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeRay = object({
+  type: constant("ray"),
+  coords: optional(nullable(pair(pairOfNumbers, pairOfNumbers))),
+  startCoords: optional(pair(pairOfNumbers, pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeSegment = object({
+  type: constant("segment"),
+  // TODO(benchristel): default numSegments?
+  numSegments: optional(number),
+  coords: optional(nullable(array(pair(pairOfNumbers, pairOfNumbers)))),
+  startCoords: optional(array(pair(pairOfNumbers, pairOfNumbers))),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeSinusoid = object({
+  type: constant("sinusoid"),
+  coords: optional(nullable(array(pairOfNumbers))),
+  startCoords: optional(array(pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  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 parseLockedFigureFillType = enumeration("none", "white", "translucent", "solid");
+const parseLockedLineStyle = enumeration("solid", "dashed");
+const parseLockedLabelType = object({
+  type: constant("label"),
+  coord: pairOfNumbers,
+  text: string,
+  color: parseLockedFigureColor,
+  size: enumeration("small", "medium", "large")
+});
+const parseLockedPointType = object({
+  type: constant("point"),
+  coord: pairOfNumbers,
+  color: parseLockedFigureColor,
+  filled: boolean,
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+const parseLockedLineType = object({
+  type: constant("line"),
+  kind: enumeration("line", "ray", "segment"),
+  points: pair(parseLockedPointType, parseLockedPointType),
+  color: parseLockedFigureColor,
+  lineStyle: parseLockedLineStyle,
+  showPoint1: defaulted(boolean, () => false),
+  showPoint2: defaulted(boolean, () => false),
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+const parseLockedVectorType = object({
+  type: constant("vector"),
+  points: pair(pairOfNumbers, pairOfNumbers),
+  color: parseLockedFigureColor,
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+const parseLockedEllipseType = object({
+  type: constant("ellipse"),
+  center: pairOfNumbers,
+  radius: pairOfNumbers,
+  angle: number,
+  color: parseLockedFigureColor,
+  fillStyle: parseLockedFigureFillType,
+  strokeStyle: parseLockedLineStyle,
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+const parseLockedPolygonType = object({
+  type: constant("polygon"),
+  points: array(pairOfNumbers),
+  color: parseLockedFigureColor,
+  showVertices: boolean,
+  fillStyle: parseLockedFigureFillType,
+  strokeStyle: parseLockedLineStyle,
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+
+// Exported for testing.
+const parseLockedFunctionDomain = defaulted(pair(defaulted(number, () => -Infinity), defaulted(number, () => Infinity)), () => [-Infinity, Infinity]);
+const parseLockedFunctionType = object({
+  type: constant("function"),
+  color: parseLockedFigureColor,
+  strokeStyle: parseLockedLineStyle,
+  equation: string,
+  directionalAxis: enumeration("x", "y"),
+  domain: parseLockedFunctionDomain,
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+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
+  // optional, we should duplicate the defaulting logic from the
+  // InteractiveGraph component. See parse-perseus-json/README.md for
+  // why.
+  gridStep: optional(pairOfNumbers),
+  snapStep: optional(pairOfNumbers),
+  backgroundImage: optional(parsePerseusImageBackground),
+  markings: enumeration("graph", "grid", "none"),
+  labels: optional(array(string)),
+  showProtractor: boolean,
+  showRuler: optional(boolean),
+  showTooltips: optional(boolean),
+  rulerLabel: optional(string),
+  rulerTicks: optional(number),
+  range: pair(pairOfNumbers, pairOfNumbers),
+  // NOTE(benchristel): I copied the default graph from
+  // interactive-graph.tsx. See the parse-perseus-json/README.md for
+  // an explanation of why we want to duplicate the default here.
+  graph: defaulted(parsePerseusGraphType, () => ({
+    type: "linear"
+  })),
+  correct: parsePerseusGraphType,
+  // TODO(benchristel): default lockedFigures to empty array
+  lockedFigures: optional(array(parseLockedFigure)),
+  fullGraphLabel: optional(string),
+  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: defaulted(boolean, () => false)
+}));
+
+const parseMatcherWidget = parseWidget(constant("matcher"), object({
+  labels: array(string),
+  left: array(string),
+  right: array(string),
+  orderMatters: boolean,
+  padding: boolean
+}));
+
+const numberOrString = union(number).or(string).parser;
+const numeric = pipeParsers(defaulted(numberOrString, () => NaN)).then(stringToNumber).parser;
+const parseMatrixWidget = parseWidget(defaulted(constant("matrix"), () => "matrix"), object({
+  prefix: optional(string),
+  suffix: optional(string),
+  answers: array(array(numeric)),
+  cursorPosition: optional(array(number)),
+  matrixBoardSize: array(number),
+  static: optional(boolean)
+}));
+
+const parseMeasurerWidget = parseWidget(constant("measurer"), object({
+  // 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,
+  rulerTicks: number,
+  rulerPixels: number,
+  rulerLength: number,
+  box: pair(number, number),
+  // TODO(benchristel): static is not used. Remove it?
+  static: defaulted(boolean, () => false)
+}));
+
+const parseMoleculeRendererWidget = parseWidget(constant("molecule-renderer"), object({
+  widgetId: string,
+  rotationAngle: optional(number),
+  smiles: optional(string)
+}));
+
+const emptyStringToNull = pipeParsers(constant("")).then(convert(() => null)).parser;
+const parseNumberLineWidget = parseWidget(constant("number-line"), object({
+  range: array(number),
+  labelRange: array(nullable(union(number).or(emptyStringToNull).parser)),
+  labelStyle: string,
+  labelTicks: boolean,
+  isTickCtrl: optional(nullable(boolean)),
+  divisionRange: array(number),
+  numDivisions: optional(nullable(number)),
+  // NOTE(benchristel): I copied the default snapDivisions from
+  // number-line.tsx. See the parse-perseus-json/README.md for
+  // an explanation of why we want to duplicate the default here.
+  snapDivisions: defaulted(number, () => 2),
+  tickStep: optional(nullable(number)),
+  correctRel: optional(nullable(string)),
+  correctX: nullable(number),
+  initialX: optional(nullable(number)),
+  showTooltips: optional(boolean),
+  static: defaulted(boolean, () => false)
+}));
+
+const parseMathFormat = enumeration("integer", "mixed", "improper", "proper", "decimal", "percent", "pi");
+const parseSimplify = pipeParsers(union(constant(null)).or(constant(undefined)).or(boolean).or(constant("required")).or(constant("correct")).or(constant("enforced")).or(constant("optional")).or(constant("accepted")).parser).then(convert(deprecatedSimplifyValuesToRequired)).parser;
+function deprecatedSimplifyValuesToRequired(simplify) {
+  switch (simplify) {
+    case "enforced":
+    case "required":
+    case "optional":
+      return simplify;
+    // NOTE(benchristel): "accepted", "correct", true, false, undefined, and
+    // null are all treated the same as "required" during scoring, so we
+    // convert them to "required" here to preserve behavior. See the tests
+    // in score-numeric-input.test.ts
+    default:
+      return "required";
+  }
+}
+const parseNumericInputWidget = parseWidget(constant("numeric-input"), object({
+  answers: array(object({
+    message: string,
+    // TODO(benchristel): value should never be null or undefined,
+    // but we have some content where it is anyway. If we backfill
+    // the data, simplify this.
+    value: optional(nullable(number)),
+    status: string,
+    answerForms: defaulted(array(parseMathFormat), () => undefined),
+    strict: boolean,
+    maxError: optional(nullable(number)),
+    // TODO(benchristel): simplify should never be a boolean, but we
+    // have some content where it is anyway. If we ever backfill
+    // the data, we should simplify `simplify`.
+    simplify: parseSimplify
+  })),
+  labelText: optional(string),
+  size: string,
+  coefficient: defaulted(boolean, () => false),
+  rightAlign: optional(boolean),
+  static: defaulted(boolean, () => false),
+  answerForms: optional(array(object({
+    name: parseMathFormat,
+    simplify: parseSimplify
+  })))
+}));
+
+// 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 largeToAuto = (height, ctx) => {
+  if (height === "large") {
+    return ctx.success("auto");
+  }
+  return ctx.success(height);
+};
+const parseOrdererWidget = parseWidget(constant("orderer"), object({
+  options: defaulted(array(parseRenderer), () => []),
+  correctOptions: array(parseRenderer),
+  otherOptions: array(parseRenderer),
+  height: pipeParsers(enumeration("normal", "auto", "large")).then(largeToAuto).parser,
+  layout: defaulted(enumeration("horizontal", "vertical"), () => "horizontal")
+}));
+
+const parsePassageRefWidget = parseWidget(constant("passage-ref"), object({
+  passageNumber: number,
+  referenceNumber: number,
+  summaryText: optional(string)
+}));
+
+const parsePassageWidget = parseWidget(constant("passage"), object({
+  footnotes: defaulted(string, () => ""),
+  passageText: string,
+  passageTitle: defaulted(string, () => ""),
+  showLineNumbers: boolean,
+  static: defaulted(boolean, () => false)
+}));
+
+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,
+  // 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)),
+  // 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)),
+  picSize: optional(nullable(number)),
+  picBoxHeight: optional(nullable(number)),
+  // NOTE(benchristel): I copied the default plotDimensions from
+  // plotter.tsx. See the parse-perseus-json/README.md for an explanation
+  // of why we want to duplicate the defaults here.
+  plotDimensions: defaulted(array(number), () => [380, 300])
+}));
+
+const parsePythonProgramWidget = parseWidget(constant("python-program"), object({
+  programID: string,
+  height: number
+}));
+
+const _excluded$a = ["noneOfTheAbove"];
+const currentVersion$3 = {
+  major: 2,
+  minor: 0
+};
+function deriveNumCorrect(options) {
+  const {
+    choices,
+    numCorrect
+  } = options;
+  return numCorrect != null ? numCorrect : choices.filter(c => c.correct).length;
+}
+const widgetOptionsUpgrades$2 = {
+  "2": v1props => {
+    const upgraded = _extends({}, v1props, {
+      numCorrect: deriveNumCorrect(v1props)
+    });
+    return upgraded;
+  },
+  "1": v0props => {
+    const {
+        noneOfTheAbove
+      } = v0props,
+      rest = _objectWithoutPropertiesLoose(v0props, _excluded$a);
+    if (noneOfTheAbove) {
+      throw new Error("radio widget v0 no longer supports auto noneOfTheAbove");
+    }
+    return _extends({}, rest, {
+      hasNoneOfTheAbove: false
+    });
+  }
+};
+const defaultWidgetOptions$v = {
+  choices: [{}, {}, {}, {}],
+  displayCount: null,
+  randomize: false,
+  hasNoneOfTheAbove: false,
+  multipleSelect: false,
+  countChoices: false,
+  deselectEnabled: false
+};
+
+const _excluded$9 = ["noneOfTheAbove"];
+const version2 = optional(object({
+  major: constant(2),
+  minor: number
+}));
+const parseRadioWidgetV2 = parseWidgetWithVersion(version2, constant("radio"), object({
+  numCorrect: optional(number),
+  choices: array(object({
+    content: defaulted(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: optional(constant(false))
+}));
+const version1 = optional(object({
+  major: constant(1),
+  minor: number
+}));
+const parseRadioWidgetV1 = parseWidgetWithVersion(version1, constant("radio"), object({
+  choices: array(object({
+    content: defaulted(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: defaulted((rawVal, ctx) => parseWidgetsMap(rawVal, ctx), () => undefined)
+  })),
+  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: optional(constant(false))
+}));
+function migrateV1ToV2(widget) {
+  const {
+    options
+  } = widget;
+  return _extends({}, widget, {
+    version: {
+      major: 2,
+      minor: 0
+    },
+    options: _extends({}, options, {
+      numCorrect: deriveNumCorrect(options)
+    })
+  });
+}
+const version0 = optional(object({
+  major: constant(0),
+  minor: number
+}));
+const parseRadioWidgetV0 = parseWidgetWithVersion(version0, constant("radio"), object({
+  choices: array(object({
+    content: defaulted(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: optional(constant(false))
+}));
+function migrateV0ToV1(widget) {
+  const {
+    options
+  } = widget;
+  const rest = _objectWithoutPropertiesLoose(options, _excluded$9);
+  return _extends({}, widget, {
+    version: {
+      major: 1,
+      minor: 0
+    },
+    options: _extends({}, rest, {
+      hasNoneOfTheAbove: false
+    })
+  });
+}
+const parseRadioWidget = versionedWidgetOptions(2, parseRadioWidgetV2).withMigrationFrom(1, parseRadioWidgetV1, migrateV1ToV2).withMigrationFrom(0, parseRadioWidgetV0, migrateV0ToV1).parser;
+
+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);
+  }
+  const widgetsMap = {};
+  for (const key of Object.keys(rawValue)) {
+    // parseWidgetsMapEntry modifies the widgetsMap. This is kind of gross,
+    // but it's the only way I could find to make TypeScript check the key
+    // against the widget type.
+    const entryResult = parseWidgetsMapEntry([key, rawValue[key]], widgetsMap, ctx.forSubtree(key));
+    if (isFailure(entryResult)) {
+      return entryResult;
+    }
+  }
+  return ctx.success(widgetsMap);
+};
+const parseWidgetsMapEntry = ([id, widget], widgetMap, ctx) => {
+  const idComponentsResult = parseWidgetIdComponents(id.split(" "), ctx.forSubtree("(widget ID)"));
+  if (isFailure(idComponentsResult)) {
+    return idComponentsResult;
+  }
+  const [type, n] = idComponentsResult.value;
+  function parseAndAssign(key, parse) {
+    const widgetResult = parse(widget, ctx);
+    if (isFailure(widgetResult)) {
+      return widgetResult;
+    }
+    widgetMap[key] = widgetResult.value;
+    return ctx.success(undefined);
+  }
+  switch (type) {
+    case "categorizer":
+      return parseAndAssign(`categorizer ${n}`, parseCategorizerWidget);
+    case "cs-program":
+      return parseAndAssign(`cs-program ${n}`, parseCSProgramWidget);
+    case "definition":
+      return parseAndAssign(`definition ${n}`, parseDefinitionWidget);
+    case "dropdown":
+      return parseAndAssign(`dropdown ${n}`, parseDropdownWidget);
+    case "explanation":
+      return parseAndAssign(`explanation ${n}`, parseExplanationWidget);
+    case "expression":
+      return parseAndAssign(`expression ${n}`, parseExpressionWidget);
+    case "grapher":
+      return parseAndAssign(`grapher ${n}`, parseGrapherWidget);
+    case "group":
+      return parseAndAssign(`group ${n}`, parseGroupWidget);
+    case "graded-group":
+      return parseAndAssign(`graded-group ${n}`, parseGradedGroupWidget);
+    case "graded-group-set":
+      return parseAndAssign(`graded-group-set ${n}`, parseGradedGroupSetWidget);
+    case "iframe":
+      return parseAndAssign(`iframe ${n}`, parseIframeWidget);
+    case "image":
+      return parseAndAssign(`image ${n}`, parseImageWidget);
+    case "input-number":
+      return parseAndAssign(`input-number ${n}`, parseInputNumberWidget);
+    case "interaction":
+      return parseAndAssign(`interaction ${n}`, parseInteractionWidget);
+    case "interactive-graph":
+      return parseAndAssign(`interactive-graph ${n}`, parseInteractiveGraphWidget);
+    case "label-image":
+      return parseAndAssign(`label-image ${n}`, parseLabelImageWidget);
+    case "matcher":
+      return parseAndAssign(`matcher ${n}`, parseMatcherWidget);
+    case "matrix":
+      return parseAndAssign(`matrix ${n}`, parseMatrixWidget);
+    case "measurer":
+      return parseAndAssign(`measurer ${n}`, parseMeasurerWidget);
+    case "molecule-renderer":
+      return parseAndAssign(`molecule-renderer ${n}`, parseMoleculeRendererWidget);
+    case "number-line":
+      return parseAndAssign(`number-line ${n}`, parseNumberLineWidget);
+    case "numeric-input":
+      return parseAndAssign(`numeric-input ${n}`, parseNumericInputWidget);
+    case "orderer":
+      return parseAndAssign(`orderer ${n}`, parseOrdererWidget);
+    case "passage":
+      return parseAndAssign(`passage ${n}`, parsePassageWidget);
+    case "passage-ref":
+      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 ${n}`, any);
+    case "phet-simulation":
+      return parseAndAssign(`phet-simulation ${n}`, parsePhetSimulationWidget);
+    case "plotter":
+      return parseAndAssign(`plotter ${n}`, parsePlotterWidget);
+    case "python-program":
+      return parseAndAssign(`python-program ${n}`, parsePythonProgramWidget);
+    case "radio":
+      return parseAndAssign(`radio ${n}`, parseRadioWidget);
+    case "sorter":
+      return parseAndAssign(`sorter ${n}`, parseSorterWidget);
+    case "table":
+      return parseAndAssign(`table ${n}`, parseTableWidget);
+    case "video":
+      return parseAndAssign(`video ${n}`, parseVideoWidget);
+    case "sequence":
+      // sequence is a deprecated widget type, and the corresponding
+      // widget component no longer exists.
+      return parseAndAssign(`sequence ${n}`, parseDeprecatedWidget);
+    case "lights-puzzle":
+      return parseAndAssign(`lights-puzzle ${n}`, parseDeprecatedWidget);
+    case "simulator":
+      return parseAndAssign(`simulator ${n}`, parseDeprecatedWidget);
+    case "transformer":
+      return parseAndAssign(`transformer ${n}`, parseDeprecatedWidget);
+    default:
+      return parseAndAssign(`${type} ${n}`, parseWidget(constant(type), any));
+  }
+};
+const parseDeprecatedWidget = parseWidget(
+// Ignore the incoming widget type and hardcode "deprecated-standin"
+(_, ctx) => ctx.success("deprecated-standin"),
+// Allow any widget options
+object({}));
+const parseStringToNonNegativeInt = (rawValue, ctx) => {
+  // The article renderer seems to allow the numeric part of a widget ID to
+  // be 0, at least for image widgets. However, if widget IDs in an exercise
+  // contain 0, the exercise renderer will blow up. We allow 0 here for
+  // compatibility with articles.
+  if (typeof rawValue !== "string" || !/^(0|[1-9][0-9]*)$/.test(rawValue)) {
+    return ctx.failure("a string representing a non-negative integer", rawValue);
+  }
+  return ctx.success(+rawValue);
+};
+const parseWidgetIdComponents = pair(string, parseStringToNonNegativeInt);
+
+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), () => ({})),
+  images: parseImages,
+  // deprecated
+  metadata: any
+}),
+// Default value
+() => ({
+  content: "",
+  widgets: {},
+  images: {}
+}));
+
+const parsePerseusArticle = union(parsePerseusRenderer).or(array(parsePerseusRenderer)).parser;
+
+const parseHint = object({
+  replace: defaulted(boolean, () => undefined),
+  content: string,
+  widgets: defaulted(parseWidgetsMap, () => ({})),
+  images: parseImages,
+  // deprecated
+  metadata: any
+});
+
+const parsePerseusAnswerArea = pipeParsers(defaulted(object({}), () => ({}))).then(convert(toAnswerArea)).parser;
+
+// Some answerAreas have extra, bogus fields, like:
+//
+//   "answerArea": {
+//     "type": "multiple",
+//     "options": {},
+//     "version": null,
+//     "static": false,
+//     "graded": false,
+//     "alignment": "",
+//   }
+//
+// This function filters the fields of an answerArea object, keeping only the
+// known ones, and converts `undefined` and `null` values to `false`.
+function toAnswerArea(raw) {
+  return {
+    zTable: !!raw.zTable,
+    calculator: !!raw.calculator,
+    chi2Table: !!raw.chi2Table,
+    financialCalculatorMonthlyPayment: !!raw.financialCalculatorMonthlyPayment,
+    financialCalculatorTotalAmount: !!raw.financialCalculatorTotalAmount,
+    financialCalculatorTimeToPayOff: !!raw.financialCalculatorTimeToPayOff,
+    periodicTable: !!raw.periodicTable,
+    periodicTableWithKey: !!raw.periodicTableWithKey,
+    tTable: !!raw.tTable
+  };
+}
+
+const parsePerseusItem$1 = object({
+  question: parsePerseusRenderer,
+  hints: defaulted(array(parseHint), () => []),
+  answerArea: parsePerseusAnswerArea,
+  itemDataVersion: optional(nullable(object({
+    major: number,
+    minor: number
+  }))),
+  // Deprecated field
+  answer: any
+});
+
+/**
+ * Helper to parse PerseusItem JSON
+ * 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
+ */
+function parsePerseusItem(json) {
+  // Try to block a cheating vector which relies on monkey-patching
+  // JSON.parse
+  if (isRealJSONParse(JSON.parse)) {
+    return JSON.parse(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.");
+  }
+}
+
+// This file is processed by a Rollup plugin (replace) to inject the production
+// version number during the release build.
+// In dev, you'll never see the version number.
+
+const libName = "@khanacademy/perseus-core";
+const libVersion = "7.0.0";
+addLibraryVersionToPerseusDebug(libName, libVersion);
+
+/**
+ * @typedef {Object} Errors utility for referencing the Perseus error taxonomy.
+ */
+const Errors = Object.freeze({
+  /**
+   * @property {ErrorKind} Unknown The kind of error is not known.
+   */
+  Unknown: "Unknown",
+  /**
+   * @property {ErrorKind} Internal The error is internal to the executing code.
+   */
+  Internal: "Internal",
+  /**
+   * @property {ErrorKind} InvalidInput There was a problem with the provided
+   * input, such as the wrong format or a null value.
+   */
+  InvalidInput: "InvalidInput",
+  /**
+   * @property {ErrorKind} NotAllowed There was a problem due to the state of
+   * the system not matching the requested operation or input. For example,
+   * trying to create a username that is valid, but is already taken by
+   * another user. Use {@link InvalidInput} instead when the input isn't
+   * valid regardless of the state of the system. Use {@link NotFound} when
+   * the failure is due to not being able to find a resource.
+   */
+  NotAllowed: "NotAllowed",
+  /**
+   * @property {ErrorKind} TransientService There was a problem when making a
+   * request to a service.
+   */
+  TransientService: "TransientService",
+  /**
+   * @property {ErrorKind} Service There was a non-transient problem when
+   * making a request to service.
+   */
+  Service: "Service"
+});
+
+/**
+ * @type {ErrorKind} The kind of error being reported
+ */
+
+class PerseusError extends Error {
+  constructor(message, kind, options) {
+    super(message);
+    this.kind = void 0;
+    this.metadata = void 0;
+    this.kind = kind;
+    this.metadata = options == null ? void 0 : options.metadata;
+  }
+}
+
+/**
+ * _ utilities for objects
+ */
+
+
+/**
+ * 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 pluck(table, subKey) {
+  return _.object(_.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 mapObject(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;
+};
+
+/**
+ * For details on the individual options, see the
+ * PerseusCategorizerWidgetOptions type
+ */
+
+/**
+ * Given a PerseusCategorizerWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getCategorizerPublicWidgetOptions(options) {
+  return {
+    items: options.items,
+    categories: options.categories,
+    randomizeItems: options.randomizeItems,
+    static: options.static
+  };
+}
+
+const defaultWidgetOptions$u = {
+  items: [],
+  categories: [],
+  values: [],
+  randomizeItems: false
+};
+const categorizerWidgetLogic = {
+  name: "categorizer",
+  defaultWidgetOptions: defaultWidgetOptions$u,
+  getPublicWidgetOptions: getCategorizerPublicWidgetOptions
+};
+
+function getCSProgramPublicWidgetOptions(options) {
+  return options;
+}
+
+const DEFAULT_HEIGHT = 400;
+const defaultWidgetOptions$t = {
+  programID: "",
+  programType: null,
+  settings: [{
+    name: "",
+    value: ""
+  }],
+  showEditor: false,
+  showButtons: false,
+  height: DEFAULT_HEIGHT
+};
+const csProgramWidgetLogic = {
+  name: "cs-program",
+  defaultWidgetOptions: defaultWidgetOptions$t,
+  supportedAlignments: ["block", "full-width"],
+  getPublicWidgetOptions: getCSProgramPublicWidgetOptions
+};
+
+const defaultWidgetOptions$s = {
+  togglePrompt: "",
+  definition: ""
+};
+const definitionWidgetLogic = {
+  name: "definition",
+  defaultWidgetOptions: defaultWidgetOptions$s,
+  defaultAlignment: "inline"
+};
+
+/**
+ * For details on the individual options, see the
+ * PerseusDropdownWidgetOptions type
+ */
+
+/**
+ * Given a PerseusDropdownWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getDropdownPublicWidgetOptions(options) {
+  return {
+    choices: options.choices.map(choice => ({
+      content: choice.content
+    })),
+    placeholder: options.placeholder,
+    static: options.static,
+    visibleLabel: options.visibleLabel,
+    ariaLabel: options.ariaLabel
+  };
+}
+
+const defaultWidgetOptions$r = {
+  placeholder: "",
+  choices: [{
+    content: "",
+    correct: false
+  }]
+};
+const dropdownWidgetLogic = {
+  name: "definition",
+  defaultWidgetOptions: defaultWidgetOptions$r,
+  defaultAlignment: "inline-block",
+  getPublicWidgetOptions: getDropdownPublicWidgetOptions
+};
+
+const defaultWidgetOptions$q = {
+  showPrompt: "Explain",
+  hidePrompt: "Hide explanation",
+  explanation: "explanation goes here\n\nmore explanation",
+  widgets: {}
+};
+const explanationWidgetLogic = {
+  name: "explanation",
+  defaultWidgetOptions: defaultWidgetOptions$q,
+  defaultAlignment: "inline"
+};
+
+const currentVersion$2 = {
+  major: 2,
+  minor: 0
+};
+const widgetOptionsUpgrades$1 = {
+  "2": v1options => {
+    return {
+      times: v1options.times,
+      buttonSets: v1options.buttonSets,
+      functions: v1options.functions,
+      buttonsVisible: v1options.buttonsVisible,
+      visibleLabel: v1options.visibleLabel,
+      ariaLabel: v1options.ariaLabel,
+      answerForms: v1options.answerForms,
+      extraKeys: v1options.extraKeys || deriveExtraKeys(v1options)
+    };
+  },
+  "1": v0options => {
+    return {
+      times: v0options.times,
+      buttonSets: v0options.buttonSets,
+      functions: v0options.functions,
+      buttonsVisible: v0options.buttonsVisible,
+      visibleLabel: v0options.visibleLabel,
+      ariaLabel: v0options.ariaLabel,
+      extraKeys: v0options.extraKeys,
+      answerForms: [{
+        considered: "correct",
+        form: v0options.form,
+        simplify: v0options.simplify,
+        value: v0options.value
+      }]
+    };
+  }
+};
+const defaultWidgetOptions$p = {
+  answerForms: [],
+  times: false,
+  buttonSets: ["basic"],
+  functions: ["f", "g", "h"]
+};
+
+/**
+ * For details on the individual options, see the
+ * PerseusExpressionWidgetOptions type
+ */
+
+/**
+ * Given a PerseusExpressionWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getExpressionPublicWidgetOptions(options) {
+  return {
+    buttonSets: options.buttonSets,
+    functions: options.functions,
+    times: options.times,
+    visibleLabel: options.visibleLabel,
+    ariaLabel: options.ariaLabel,
+    buttonsVisible: options.buttonsVisible,
+    extraKeys: options.extraKeys
+  };
+}
+
+const expressionWidgetLogic = {
+  name: "expression",
+  version: currentVersion$2,
+  widgetOptionsUpgrades: widgetOptionsUpgrades$1,
+  defaultWidgetOptions: defaultWidgetOptions$p,
+  defaultAlignment: "inline-block",
+  getPublicWidgetOptions: getExpressionPublicWidgetOptions
+};
+
+const defaultWidgetOptions$o = {
+  title: "",
+  content: "",
+  widgets: {},
+  images: {},
+  hint: null
+};
+const gradedGroupWidgetLogic = {
+  name: "graded-group",
+  defaultWidgetOptions: defaultWidgetOptions$o
+};
+
+const defaultWidgetOptions$n = {
+  gradedGroups: []
+};
+const gradedGroupSetWidgetLogic = {
+  name: "graded-group-set",
+  defaultWidgetOptions: defaultWidgetOptions$n
+};
+
+const _excluded$8 = ["correct"];
+function getGrapherPublicWidgetOptions(options) {
+  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded$8);
+  return publicOptions;
+}
+
+const defaultWidgetOptions$m = {
+  graph: {
+    labels: ["x", "y"],
+    range: [[-10, 10], [-10, 10]],
+    step: [1, 1],
+    backgroundImage: {
+      url: null
+    },
+    markings: "graph",
+    rulerLabel: "",
+    rulerTicks: 10,
+    valid: true,
+    showTooltips: false
+  },
+  correct: {
+    type: "linear",
+    coords: null
+  },
+  availableTypes: ["linear"]
+};
+const grapherWidgetLogic = {
+  name: "grapher",
+  defaultWidgetOptions: defaultWidgetOptions$m,
+  getPublicWidgetOptions: getGrapherPublicWidgetOptions
+};
+
+const defaultWidgetOptions$l = {
+  content: "",
+  widgets: {},
+  images: {}
+};
+const groupWidgetLogic = {
+  name: "group",
+  defaultWidgetOptions: defaultWidgetOptions$l
+};
+
+function getIFramePublicWidgetOptions(options) {
+  return options;
+}
+
+const defaultWidgetOptions$k = {
+  url: "",
+  settings: [{
+    name: "",
+    value: ""
+  }],
+  width: "400",
+  height: "400",
+  allowFullScreen: false,
+  allowTopNavigation: false
+};
+const iframeWidgetLogic = {
+  name: "iframe",
+  defaultWidgetOptions: defaultWidgetOptions$k,
+  getPublicWidgetOptions: getIFramePublicWidgetOptions
+};
+
+const defaultWidgetOptions$j = {
+  title: "",
+  range: [[0, 10], [0, 10]],
+  box: [400, 400],
+  backgroundImage: {
+    url: null,
+    width: 0,
+    height: 0
+  },
+  labels: [],
+  alt: "",
+  caption: ""
+};
+const imageWidgetLogic = {
+  name: "image",
+  defaultWidgetOptions: defaultWidgetOptions$j,
+  supportedAlignments: ["block", "full-width"],
+  defaultAlignment: "block"
+};
+
+const defaultWidgetOptions$i = {
+  value: 0,
+  simplify: "required",
+  size: "normal",
+  inexact: false,
+  maxError: 0.1,
+  answerType: "number",
+  rightAlign: false
+};
+const inputNumberWidgetLogic = {
+  name: "input-number",
+  defaultWidgetOptions: defaultWidgetOptions$i,
+  defaultAlignment: "inline-block"
+};
+
+const defaultWidgetOptions$h = {
+  graph: {
+    box: [400, 400],
+    labels: ["x", "y"],
+    range: [[-10, 10], [-10, 10]],
+    tickStep: [1, 1],
+    gridStep: [1, 1],
+    markings: "graph"
+  },
+  elements: []
+};
+const interactionWidgetLogic = {
+  name: "interaction",
+  defaultWidgetOptions: defaultWidgetOptions$h
+};
+
+const _excluded$7 = ["correct"];
+function getInteractiveGraphPublicWidgetOptions(options) {
+  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded$7);
+  return publicOptions;
+}
+
+const defaultWidgetOptions$g = {
+  labels: ["x", "y"],
+  range: [[-10, 10], [-10, 10]],
+  step: [1, 1],
+  backgroundImage: {
+    url: null
+  },
+  markings: "graph",
+  showTooltips: false,
+  showProtractor: false,
+  graph: {
+    type: "linear"
+  },
+  correct: {
+    type: "linear",
+    coords: null
+  }
+};
+const interactiveGraphWidgetLogic = {
+  name: "interactive-graph",
+  defaultWidgetOptions: defaultWidgetOptions$g,
+  getPublicWidgetOptions: getInteractiveGraphPublicWidgetOptions
+};
+
+const _excluded$6 = ["answers"];
+/**
+ * For details on the individual options, see the
+ * PerseusLabelImageWidgetOptions type
+ */
+
+function getLabelImagePublicWidgetOptions(options) {
+  return _extends({}, options, {
+    markers: options.markers.map(getLabelImageMarkerPublicData)
+  });
+}
+function getLabelImageMarkerPublicData(marker) {
+  const publicData = _objectWithoutPropertiesLoose(marker, _excluded$6);
+  return publicData;
+}
+
+const defaultWidgetOptions$f = {
+  choices: [],
+  imageAlt: "",
+  imageUrl: "",
+  imageWidth: 0,
+  imageHeight: 0,
+  markers: [],
+  multipleAnswers: false,
+  hideChoicesFromInstructions: false
+};
+const labelImageWidgetLogic = {
+  name: "label-image",
+  defaultWidgetOptions: defaultWidgetOptions$f,
+  getPublicWidgetOptions: getLabelImagePublicWidgetOptions
+};
+
+/* Note(tamara): Brought over from the perseus package packages/perseus/src/util.ts file.
+    May be useful to bring other perseus package utilities here. Contains utility functions
+    and types used across multiple widgets for randomization and shuffling. */
+
+const seededRNG = function seededRNG(seed) {
+  let randomSeed = seed;
+  return function () {
+    // Robert Jenkins' 32 bit integer hash function.
+    let seed = randomSeed;
+    seed = seed + 0x7ed55d16 + (seed << 12) & 0xffffffff;
+    seed = (seed ^ 0xc761c23c ^ seed >>> 19) & 0xffffffff;
+    seed = seed + 0x165667b1 + (seed << 5) & 0xffffffff;
+    seed = (seed + 0xd3a2646c ^ seed << 9) & 0xffffffff;
+    seed = seed + 0xfd7046c5 + (seed << 3) & 0xffffffff;
+    seed = (seed ^ 0xb55a4f09 ^ seed >>> 16) & 0xffffffff;
+    return (randomSeed = seed & 0xfffffff) / 0x10000000;
+  };
+};
+
+// Shuffle an array using a given random seed or function.
+// If `ensurePermuted` is true, the input and output are guaranteed to be
+// distinct permutations.
+function shuffle(array, randomSeed, ensurePermuted = false) {
+  // Always return a copy of the input array
+  const shuffled = _.clone(array);
+
+  // Handle edge cases (input array is empty or uniform)
+  if (
+  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+  !shuffled.length || _.all(shuffled, function (value) {
+    return _.isEqual(value, shuffled[0]);
+  })) {
+    return shuffled;
+  }
+  let random;
+  if (typeof randomSeed === "function") {
+    random = randomSeed;
+  } else {
+    random = seededRNG(randomSeed);
+  }
+  do {
+    // Fischer-Yates shuffle
+    for (let top = shuffled.length; top > 0; top--) {
+      const newEnd = Math.floor(random() * top);
+      const temp = shuffled[newEnd];
+
+      // @ts-expect-error - TS2542 - Index signature in type 'readonly T[]' only permits reading.
+      shuffled[newEnd] = shuffled[top - 1];
+      // @ts-expect-error - TS2542 - Index signature in type 'readonly T[]' only permits reading.
+      shuffled[top - 1] = temp;
+    }
+  } while (ensurePermuted && _.isEqual(array, shuffled));
+  return shuffled;
+}
+const random = seededRNG(new Date().getTime() & 0xffffffff);
+
+// TODO(LEMS-2841): Should be able to remove once getPublicWidgetOptions is hooked up
+
+// TODO(LEMS-2841): Should be able to remove once getPublicWidgetOptions is hooked up
+const shuffleMatcher = props => {
+  // Use the same random() function to shuffle both columns sequentially
+  const rng = seededRNG(props.problemNum);
+  let left;
+  if (!props.orderMatters) {
+    // If the order doesn't matter, don't shuffle the left column
+    left = props.left;
+  } else {
+    left = shuffle(props.left, rng, /* ensurePermuted */true);
+  }
+  const right = shuffle(props.right, rng, /* ensurePermuted */true);
+  return {
+    left,
+    right
+  };
+};
+
+// TODO(LEMS-2841): Can shorten to shuffleMatcher after above function removed
+function shuffleMatcherWithRandom(data) {
+  // Use the same random() function to shuffle both columns sequentially
+  let left;
+  if (!data.orderMatters) {
+    // If the order doesn't matter, don't shuffle the left column
+    left = data.left;
+  } else {
+    left = shuffle(data.left, Math.random, /* ensurePermuted */true);
+  }
+  const right = shuffle(data.right, Math.random, /* ensurePermuted */true);
+  return {
+    left,
+    right
+  };
+}
+
+/**
+ * For details on the individual options, see the
+ * PerseusMatcherWidgetOptions type
+ */
+
+/**
+ * Given a PerseusMatcherWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getMatcherPublicWidgetOptions(options) {
+  const {
+    left,
+    right
+  } = shuffleMatcherWithRandom(options);
+  return _extends({}, options, {
+    left: left,
+    right: right
+  });
+}
+
+const defaultWidgetOptions$e = {
+  left: ["$x$", "$y$", "$z$"],
+  right: ["$1$", "$2$", "$3$"],
+  labels: ["test", "label"],
+  orderMatters: false,
+  padding: true
+};
+const matcherWidgetLogic = {
+  name: "matcher",
+  defaultWidgetOptions: defaultWidgetOptions$e,
+  getPublicWidgetOptions: getMatcherPublicWidgetOptions
+};
+
+const _excluded$5 = ["answers"];
+function getMatrixPublicWidgetOptions(options) {
+  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded$5);
+  return publicOptions;
+}
+
+const defaultWidgetOptions$d = {
+  matrixBoardSize: [3, 3],
+  answers: [[]],
+  prefix: "",
+  suffix: "",
+  cursorPosition: [0, 0]
+};
+const matrixWidgetLogic = {
+  name: "matrix",
+  defaultWidgetOptions: defaultWidgetOptions$d,
+  getPublicWidgetOptions: getMatrixPublicWidgetOptions
+};
+
+const _excluded$4 = ["imageUrl", "imageTop", "imageLeft"];
+const currentVersion$1 = {
+  major: 1,
+  minor: 0
+};
+const widgetOptionsUpgrades = {
+  "1": v0options => {
+    const {
+        imageUrl,
+        imageTop,
+        imageLeft
+      } = v0options,
+      rest = _objectWithoutPropertiesLoose(v0options, _excluded$4);
+    return _extends({}, rest, {
+      image: {
+        url: imageUrl,
+        top: imageTop,
+        left: imageLeft
+      }
+    });
+  }
+};
+const defaultWidgetOptions$c = {
+  box: [480, 480],
+  image: {},
+  showProtractor: true,
+  showRuler: false,
+  rulerLabel: "",
+  rulerTicks: 10,
+  rulerPixels: 40,
+  rulerLength: 10
+};
+
+const measurerWidgetLogic = {
+  name: "measurer",
+  version: currentVersion$1,
+  widgetOptionsUpgrades: widgetOptionsUpgrades,
+  defaultWidgetOptions: defaultWidgetOptions$c
+};
+
+const _excluded$3 = ["correctX", "correctRel"];
+function getNumberLinePublicWidgetOptions(options) {
+  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded$3);
+  return publicOptions;
+}
+
+const defaultWidgetOptions$b = {
+  range: [0, 10],
+  labelRange: [null, null],
+  labelStyle: "decimal",
+  labelTicks: true,
+  divisionRange: [1, 12],
+  numDivisions: 5,
+  snapDivisions: 2,
+  tickStep: null,
+  correctRel: "eq",
+  correctX: null,
+  initialX: null,
+  showTooltips: false
+};
+const numberLineWidgetLogic = {
+  name: "number-line",
+  defaultWidgetOptions: defaultWidgetOptions$b,
+  getPublicWidgetOptions: getNumberLinePublicWidgetOptions
+};
+
+const _excluded$2 = ["answers"];
+/**
+ * For details on the individual options, see the
+ * PerseusNumericInputWidgetOptions type
+ */
+
+/**
+ * This data from `answers` is used pre-scoring to give hints
+ * to the learner regarding the format of accepted answers
+ */
+function getNumericInputAnswerPublicData(answer) {
+  const {
+    answerForms,
+    simplify,
+    status
+  } = answer;
+  return {
+    answerForms,
+    simplify,
+    status
+  };
+}
+
+/**
+ * Given a PerseusNumericInputWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getNumericInputPublicWidgetOptions(options) {
+  const {
+      answers
+    } = options,
+    publicWidgetOptions = _objectWithoutPropertiesLoose(options, _excluded$2);
+  return _extends({}, publicWidgetOptions, {
+    answers: answers.map(getNumericInputAnswerPublicData)
+  });
+}
+
+const defaultWidgetOptions$a = {
+  answers: [{
+    value: null,
+    status: "correct",
+    message: "",
+    simplify: "required",
+    answerForms: [],
+    strict: false,
+    maxError: null
+  }],
+  size: "normal",
+  coefficient: false,
+  labelText: "",
+  rightAlign: false
+};
+const numericInputWidgetLogic = {
+  name: "numeric-input",
+  defaultWidgetOptions: defaultWidgetOptions$a,
+  defaultAlignment: "inline-block",
+  getPublicWidgetOptions: getNumericInputPublicWidgetOptions
+};
+
+/**
+ * For details on the individual options, see the
+ * PerseusOrdererWidgetOptions type
+ */
+
+/**
+ * Given a PerseusOrdererWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getOrdererPublicWidgetOptions(options) {
+  return {
+    options: options.options,
+    height: options.height,
+    layout: options.layout
+  };
+}
+
+const defaultWidgetOptions$9 = {
+  correctOptions: [{
+    content: "$x$"
+  }],
+  otherOptions: [{
+    content: "$y$"
+  }],
+  height: "normal",
+  layout: "horizontal"
+};
+const ordererWidgetLogic = {
+  name: "orderer",
+  defaultWidgetOptions: defaultWidgetOptions$9,
+  getPublicWidgetOptions: getOrdererPublicWidgetOptions
+};
+
+const defaultWidgetOptions$8 = {
+  passageTitle: "",
+  passageText: "",
+  footnotes: "",
+  showLineNumbers: true
+};
+const passageWidgetLogic = {
+  name: "passage",
+  defaultWidgetOptions: defaultWidgetOptions$8
+};
+
+const currentVersion = {
+  major: 0,
+  minor: 1
+};
+const defaultWidgetOptions$7 = {
+  passageNumber: 1,
+  referenceNumber: 1,
+  summaryText: ""
+};
+
+const passageRefWidgetLogic = {
+  name: "passageRef",
+  version: currentVersion,
+  defaultWidgetOptions: defaultWidgetOptions$7,
+  defaultAlignment: "inline"
+};
+
+const defaultWidgetOptions$6 = {
+  content: ""
+};
+const passageRefTargetWidgetLogic = {
+  name: "passageRefTarget",
+  defaultWidgetOptions: defaultWidgetOptions$6,
+  defaultAlignment: "inline"
+};
+
+const defaultWidgetOptions$5 = {
+  url: "",
+  description: ""
+};
+const phetSimulationWidgetLogic = {
+  name: "phet-simulation",
+  defaultWidgetOptions: defaultWidgetOptions$5
+};
+
+const _excluded$1 = ["correct"];
+/**
+ * For details on the individual options, see the
+ * PerseusPlotterWidgetOptions type
+ */
+
+/**
+ * Given a PerseusPlotterWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getPlotterPublicWidgetOptions(options) {
+  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded$1);
+  return publicOptions;
+}
+
+const defaultWidgetOptions$4 = {
+  scaleY: 1,
+  maxY: 10,
+  snapsPerLine: 2,
+  correct: [1],
+  starting: [1],
+  type: "bar",
+  labels: ["", ""],
+  categories: [""],
+  picSize: 30,
+  picBoxHeight: 36,
+  plotDimensions: [275, 200],
+  labelInterval: 1,
+  picUrl: null
+};
+const plotterWidgetLogic = {
+  name: "plotter",
+  defaultWidgetOptions: defaultWidgetOptions$4,
+  getPublicWidgetOptions: getPlotterPublicWidgetOptions
+};
+
+const defaultWidgetOptions$3 = {
+  programID: "",
+  height: 400
+};
+const pythonProgramWidgetLogic = {
+  name: "python-program",
+  defaultWidgetOptions: defaultWidgetOptions$3
+};
+
+/**
+ * For details on the individual options, see the
+ * PerseusRadioWidgetOptions type
+ */
+
+/**
+ * Only the options from each Radio choice that should be exposed to the client.
+ */
+
+/**
+ * Given a PerseusRadioChoice object, return a new object with only the public
+ * data that should be included in the Radio public widget options.
+ */
+function getRadioChoicePublicData(choice) {
+  const {
+    content,
+    isNoneOfTheAbove,
+    widgets
+  } = choice;
+  return {
+    content,
+    isNoneOfTheAbove,
+    widgets
+  };
+}
+
+/**
+ * Shared functionality to determine if numCorrect is used, because:
+ *
+ * 1. numCorrect is conditionally used for rendering pre-scoring
+ * 2. numCorrect also exposes information about answers
+ *
+ * So only include/use numCorrect when we know it's useful.
+ */
+function usesNumCorrect(multipleSelect, countChoices, numCorrect) {
+  return multipleSelect && countChoices && numCorrect;
+}
+
+/**
+ * Given a PerseusRadioWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getRadioPublicWidgetOptions(options) {
+  const {
+    numCorrect,
+    choices,
+    multipleSelect,
+    countChoices
+  } = options;
+  return _extends({}, options, {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    numCorrect: usesNumCorrect(multipleSelect, countChoices, numCorrect) ? numCorrect : undefined,
+    choices: choices.map(getRadioChoicePublicData)
+  });
+}
+
+const radioWidgetLogic = {
+  name: "radio",
+  version: currentVersion$3,
+  widgetOptionsUpgrades: widgetOptionsUpgrades$2,
+  defaultWidgetOptions: defaultWidgetOptions$v,
+  getPublicWidgetOptions: getRadioPublicWidgetOptions
+};
+
+/**
+ * For details on the individual options, see the
+ * PerseusSorterWidgetOptions type
+ */
+
+/**
+ * Given a PerseusSorterWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getSorterPublicWidgetOptions(options) {
+  const shuffledCorrect = shuffle(options.correct, Math.random, /* ensurePermuted */true);
+  return _extends({}, options, {
+    // Note(Tamara): This does not provide correct answer information any longer.
+    // To maintain compatibility with the original widget options, we are
+    // keeping the key the same. Represents initial state of the cards here.
+    correct: shuffledCorrect,
+    // Note(Tamara): This new key is only added here with "true". There isn't
+    // a place where it is set to false. It indicates that the correct field
+    // has been shuffled and no longer contains correct answer info.
+    isCorrectShuffled: true
+  });
+}
+
+const defaultWidgetOptions$2 = {
+  correct: ["$x$", "$y$", "$z$"],
+  layout: "horizontal",
+  padding: true
+};
+const sorterWidgetLogic = {
+  name: "sorter",
+  defaultWidgetOptions: defaultWidgetOptions$2,
+  getPublicWidgetOptions: getSorterPublicWidgetOptions
+};
+
+const _excluded = ["answers"];
+function getTablePublicWidgetOptions(options) {
+  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded);
+  return publicOptions;
+}
+
+const defaultRows = 4;
+const defaultColumns = 1;
+
+// initialize a 2D array
+// (defaultRows x defaultColumns) of empty strings
+const answers = new Array(defaultRows).fill(0).map(() => new Array(defaultColumns).fill(""));
+const defaultWidgetOptions$1 = {
+  headers: [""],
+  rows: defaultRows,
+  columns: defaultColumns,
+  answers: answers
+};
+const tableWidgetLogic = {
+  name: "table",
+  defaultWidgetOptions: defaultWidgetOptions$1,
+  getPublicWidgetOptions: getTablePublicWidgetOptions
+};
+
+const defaultWidgetOptions = {
+  location: ""
+};
+const videoWidgetLogic = {
+  name: "video",
+  defaultWidgetOptions,
+  supportedAlignments: ["block", "float-left", "float-right", "full-width"],
+  defaultAlignment: "block"
+};
+
+const widgets = {};
+function registerWidget(type, logic) {
+  widgets[type] = logic;
+}
+function isWidgetRegistered(type) {
+  const widgetLogic = widgets[type];
+  return !!widgetLogic;
+}
+function getCurrentVersion(type) {
+  const widgetLogic = widgets[type];
+  return (widgetLogic == null ? void 0 : widgetLogic.version) || {
+    major: 0,
+    minor: 0
+  };
+}
+
+// TODO(LEMS-2870): getPublicWidgetOptionsFunction/PublicWidgetOptionsFunction
+// need better types
+const getPublicWidgetOptionsFunction = name => {
+  var _widgets$name$getPubl, _widgets$name;
+  return (_widgets$name$getPubl = (_widgets$name = widgets[name]) == null ? void 0 : _widgets$name.getPublicWidgetOptions) != null ? _widgets$name$getPubl : i => i;
+};
+function getWidgetOptionsUpgrades(type) {
+  const widgetLogic = widgets[type];
+  return (widgetLogic == null ? void 0 : widgetLogic.widgetOptionsUpgrades) || {};
+}
+function getDefaultWidgetOptions(type) {
+  const widgetLogic = widgets[type];
+  return (widgetLogic == null ? void 0 : widgetLogic.defaultWidgetOptions) || {};
+}
+
+/**
+ * Handling for the optional alignments for widgets
+ * See widget-container.jsx for details on how alignments are implemented.
+ */
+
+/**
+ * Returns the list of supported alignments for the given (string) widget
+ * type. This is used primarily at editing time to display the choices
+ * for the user.
+ *
+ * Supported alignments are given as an array of strings in the exports of
+ * a widget's module.
+ */
+const getSupportedAlignments = type => {
+  var _widgetLogic$supporte;
+  const widgetLogic = widgets[type];
+  if (!(widgetLogic != null && (_widgetLogic$supporte = widgetLogic.supportedAlignments) != null && _widgetLogic$supporte[0])) {
+    // default alignments
+    return ["default"];
+  }
+  return widgetLogic == null ? void 0 : widgetLogic.supportedAlignments;
+};
+
+/**
+ * For the given (string) widget type, determine the default alignment for
+ * the widget. This is used at rendering time to go from "default" alignment
+ * to the actual alignment displayed on the screen.
+ *
+ * The default alignment is given either as a string (called
+ * `defaultAlignment`) or a function (called `getDefaultAlignment`) on
+ * the exports of a widget's module.
+ */
+const getDefaultAlignment = type => {
+  const widgetLogic = widgets[type];
+  if (!(widgetLogic != null && widgetLogic.defaultAlignment)) {
+    return "block";
+  }
+  return widgetLogic.defaultAlignment;
+};
+registerWidget("categorizer", categorizerWidgetLogic);
+registerWidget("cs-program", csProgramWidgetLogic);
+registerWidget("definition", definitionWidgetLogic);
+registerWidget("dropdown", dropdownWidgetLogic);
+registerWidget("explanation", explanationWidgetLogic);
+registerWidget("expression", expressionWidgetLogic);
+registerWidget("graded-group", gradedGroupWidgetLogic);
+registerWidget("graded-group-set", gradedGroupSetWidgetLogic);
+registerWidget("grapher", grapherWidgetLogic);
+registerWidget("group", groupWidgetLogic);
+registerWidget("iframe", iframeWidgetLogic);
+registerWidget("image", imageWidgetLogic);
+registerWidget("input-number", inputNumberWidgetLogic);
+registerWidget("interaction", interactionWidgetLogic);
+registerWidget("interactive-graph", interactiveGraphWidgetLogic);
+registerWidget("label-image", labelImageWidgetLogic);
+registerWidget("matcher", matcherWidgetLogic);
+registerWidget("matrix", matrixWidgetLogic);
+registerWidget("measurer", measurerWidgetLogic);
+registerWidget("number-line", numberLineWidgetLogic);
+registerWidget("numeric-input", numericInputWidgetLogic);
+registerWidget("orderer", ordererWidgetLogic);
+registerWidget("passage", passageWidgetLogic);
+registerWidget("passage-ref", passageRefWidgetLogic);
+registerWidget("passage-ref-target", passageRefTargetWidgetLogic);
+registerWidget("phet-simulation", phetSimulationWidgetLogic);
+registerWidget("plotter", plotterWidgetLogic);
+registerWidget("python-program", pythonProgramWidgetLogic);
+registerWidget("radio", radioWidgetLogic);
+registerWidget("sorter", sorterWidgetLogic);
+registerWidget("table", tableWidgetLogic);
+registerWidget("video", videoWidgetLogic);
+
+var coreWidgetRegistry = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getCurrentVersion: getCurrentVersion,
+    getDefaultAlignment: getDefaultAlignment,
+    getDefaultWidgetOptions: getDefaultWidgetOptions,
+    getPublicWidgetOptionsFunction: getPublicWidgetOptionsFunction,
+    getSupportedAlignments: getSupportedAlignments,
+    getWidgetOptionsUpgrades: getWidgetOptionsUpgrades,
+    isWidgetRegistered: isWidgetRegistered
+});
+
+const DEFAULT_STATIC = false;
+const upgradeWidgetInfoToLatestVersion = oldWidgetInfo => {
+  const type = oldWidgetInfo.type;
+  // NOTE(jeremy): This looks like it could be replaced by fixing types so
+  // that `type` is non-optional. But we're seeing this in Sentry today so I
+  // suspect we have legacy data (potentially unpublished) and we should
+  // figure that out before depending solely on types.
+  if (!_.isString(type)) {
+    throw new PerseusError("widget type must be a string, but was: " + type, Errors.Internal);
+  }
+  if (!isWidgetRegistered(type)) {
+    // If we have a widget that isn't registered, we can't upgrade it
+    // TODO(aria): Figure out what the best thing to do here would be
+    return oldWidgetInfo;
+  }
+
+  // Unversioned widgets (pre-July 2014) are all implicitly 0.0
+  const initialVersion = oldWidgetInfo.version || {
+    major: 0,
+    minor: 0
+  };
+  const latestVersion = getCurrentVersion(type);
+
+  // If the widget version is later than what we understand (major
+  // version is higher than latest, or major versions are equal and minor
+  // version is higher than latest), don't perform any upgrades.
+  if (initialVersion.major > latestVersion.major || initialVersion.major === latestVersion.major && initialVersion.minor > latestVersion.minor) {
+    return oldWidgetInfo;
+  }
+
+  // We do a clone here so that it's safe to mutate the input parameter
+  // in propUpgrades functions (which I will probably accidentally do at
+  // some point, and we would like to not break when that happens).
+  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+  let newEditorOptions = _.clone(oldWidgetInfo.options) || {};
+  const upgradePropsMap = getWidgetOptionsUpgrades(type);
+
+  // Empty props usually mean a newly created widget by the editor,
+  // and are always considerered up-to-date.
+  // Mostly, we'd rather not run upgrade functions on props that are
+  // not complete.
+  if (_.keys(newEditorOptions).length !== 0) {
+    // We loop through all the versions after the current version of
+    // the loaded widget, up to and including the latest version of the
+    // loaded widget, and run the upgrade function to bring our loaded
+    // widget's props up to that version.
+    // There is a little subtlety here in that we call
+    // upgradePropsMap[1] to upgrade *to* version 1,
+    // (not from version 1).
+    for (let nextVersion = initialVersion.major + 1; nextVersion <= latestVersion.major; nextVersion++) {
+      if (upgradePropsMap[String(nextVersion)]) {
+        newEditorOptions = upgradePropsMap[String(nextVersion)](newEditorOptions);
+      } else {
+        throw new PerseusError("No upgrade found for widget. Cannot render.", Errors.Internal, {
+          metadata: {
+            type,
+            fromMajorVersion: nextVersion - 1,
+            toMajorVersion: nextVersion,
+            oldWidgetInfo: JSON.stringify(oldWidgetInfo)
+          }
+        });
+      }
+    }
+  }
+
+  // Minor version upgrades (eg. new optional props) don't have
+  // transform functions. Instead, we fill in the new props with their
+  // defaults.
+  const defaultOptions = getDefaultWidgetOptions(type);
+  newEditorOptions = _extends({}, defaultOptions, newEditorOptions);
+  let alignment = oldWidgetInfo.alignment;
+
+  // Widgets that support multiple alignments will "lock in" the
+  // alignment to the alignment that would be listed first in the
+  // select box. If the widget only supports one alignment, the
+  // alignment value will likely just end up as "default".
+  if (alignment == null || alignment === "default") {
+    var _getSupportedAlignmen;
+    alignment = (_getSupportedAlignmen = getSupportedAlignments(type)) == null ? void 0 : _getSupportedAlignmen[0];
+    if (!alignment) {
+      throw new PerseusError("No default alignment found when upgrading widget", Errors.Internal, {
+        metadata: {
+          widgetType: type
+        }
+      });
+    }
+  }
+  let widgetStatic = oldWidgetInfo.static;
+  if (widgetStatic == null) {
+    widgetStatic = DEFAULT_STATIC;
+  }
+  return _extends({}, oldWidgetInfo, {
+    // maintain other info, like type
+    // After upgrading we guarantee that the version is up-to-date
+    version: latestVersion,
+    // Default graded to true (so null/undefined becomes true):
+    graded: oldWidgetInfo.graded != null ? oldWidgetInfo.graded : true,
+    alignment: alignment,
+    static: widgetStatic,
+    options: newEditorOptions
+  });
+};
+function getUpgradedWidgetOptions(oldWidgetOptions) {
+  return mapObject(oldWidgetOptions, (widgetInfo, widgetId) => {
+    if (!widgetInfo.type || !widgetInfo.alignment) {
+      const newValues = {};
+      if (!widgetInfo.type) {
+        // TODO: why does widget have no type?
+        // We don't want to derive type from widget ID
+        // see: LEMS-1845
+        newValues.type = widgetId.split(" ")[0];
+      }
+      if (!widgetInfo.alignment) {
+        newValues.alignment = "default";
+      }
+      widgetInfo = _extends({}, widgetInfo, newValues);
+    }
+    return upgradeWidgetInfoToLatestVersion(widgetInfo);
+  });
+}
+
+/**
+ * Return a copy of a Perseus item with rubric data removed (ie answers)
+ *
+ * @param originalItem - the original, full Perseus item (which includes the rubric - aka answer data)
+ */
+function splitPerseusItem(originalItem) {
+  var _item$widgets;
+  const item = _.clone(originalItem);
+  const originalWidgets = (_item$widgets = item.widgets) != null ? _item$widgets : {};
+  const upgradedWidgets = getUpgradedWidgetOptions(originalWidgets);
+  const splitWidgets = {};
+  for (const [id, widget] of Object.entries(upgradedWidgets)) {
+    const publicWidgetOptionsFun = getPublicWidgetOptionsFunction(widget.type);
+    splitWidgets[id] = _extends({}, widget, {
+      options: publicWidgetOptionsFun(widget.options)
+    });
+  }
+  return _extends({}, item, {
+    widgets: splitWidgets
+  });
+}
+
+export { coreWidgetRegistry as CoreWidgetRegistry, Errors, grapherUtil as GrapherUtil, ItemExtras, PerseusError, PerseusExpressionAnswerFormConsidered, addWidget, approximateDeepEqual, approximateEqual, categorizerWidgetLogic as categorizerLogic, csProgramWidgetLogic as csProgramLogic, deepClone, definitionWidgetLogic as definitionLogic, deriveExtraKeys, deriveNumCorrect, dropdownWidgetLogic as dropdownLogic, explanationWidgetLogic as explanationLogic, expressionWidgetLogic as expressionLogic, getCSProgramPublicWidgetOptions, getCategorizerPublicWidgetOptions, getDecimalSeparator, getDropdownPublicWidgetOptions, getExpressionPublicWidgetOptions, getGrapherPublicWidgetOptions, getIFramePublicWidgetOptions, getInteractiveGraphPublicWidgetOptions, getLabelImagePublicWidgetOptions, getMatcherPublicWidgetOptions, getMatrixPublicWidgetOptions, getMatrixSize, getNumberLinePublicWidgetOptions, getNumericInputPublicWidgetOptions, getOrdererPublicWidgetOptions, getPlotterPublicWidgetOptions, getRadioPublicWidgetOptions, getSorterPublicWidgetOptions, getTablePublicWidgetOptions, getUpgradedWidgetOptions, getWidgetIdsFromContent, getWidgetIdsFromContentByType, gradedGroupWidgetLogic as gradedGroupLogic, gradedGroupSetWidgetLogic as gradedGroupSetLogic, grapherWidgetLogic as grapherLogic, groupWidgetLogic as groupLogic, iframeWidgetLogic as iframeLogic, imageWidgetLogic as imageLogic, inputNumberWidgetLogic as inputNumberLogic, interactionWidgetLogic as interactionLogic, interactiveGraphWidgetLogic as interactiveGraphLogic, isFailure, isSuccess, labelImageWidgetLogic as labelImageLogic, libVersion, lockedFigureColorNames, lockedFigureColors, lockedFigureFillStyles, mapObject, matcherWidgetLogic as matcherLogic, matrixWidgetLogic as matrixLogic, measurerWidgetLogic as measurerLogic, numberLineWidgetLogic as numberLineLogic, numericInputWidgetLogic as numericInputLogic, ordererWidgetLogic as ordererLogic, parseAndMigratePerseusArticle, parseAndMigratePerseusItem, parsePerseusItem, passageWidgetLogic as passageLogic, passageRefWidgetLogic as passageRefLogic, passageRefTargetWidgetLogic as passageRefTargetLogic, phetSimulationWidgetLogic as phetSimulationLogic, plotterWidgetLogic as plotterLogic, plotterPlotTypes, pluck, pythonProgramWidgetLogic as pythonProgramLogic, radioWidgetLogic as radioLogic, random, seededRNG, shuffle, shuffleMatcher, sorterWidgetLogic as sorterLogic, splitPerseusItem, tableWidgetLogic as tableLogic, upgradeWidgetInfoToLatestVersion, usesNumCorrect, videoWidgetLogic as videoLogic };
+//# sourceMappingURL=index.js.map