@khanacademy/perseus-core 6.0.0 → 7.0.0

package/dist/index.js

@@ -1,19 +1,52 @@
-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';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _ = require('underscore');
+var KAS = require('@khanacademy/kas');
+var perseusUtils = require('@khanacademy/perseus-utils');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var ___default = /*#__PURE__*/_interopDefaultCompat(_);
+var KAS__namespace = /*#__PURE__*/_interopNamespaceCompat(KAS);
 
 function getMatrixSize(matrix) {
   const matrixSize = [1, 1];
-  _(matrix).each((matrixRow, row) => {
+
+  // We need to find the widest row and tallest column to get the correct
+  // matrix size.
+  ___default.default(matrix).each((matrixRow, row) => {
     let rowWidth = 0;
-    _(matrixRow).each((matrixCol, col) => {
+    ___default.default(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);
     }
@@ -21,24 +54,47 @@ function getMatrixSize(matrix) {
   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;
-      const match = new Intl.NumberFormat(locale).format(numberWithDecimalSeparator).match(/[^\d\u0661\u06F1\u0967\u09e7]/);
-      return (_match$ = match == null ? void 0 : match[0]) != null ? _match$ : ".";
+      // 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?.[0] ?? ".";
   }
 };
 
+/**
+ * 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) {
@@ -61,9 +117,11 @@ function approximateDeepEqual(x, y) {
     return false;
   }
   if (typeof x === "object" && typeof y === "object" && !!x && !!y) {
-    return x === y || _.all(x, function (v, k) {
+    return x === y || ___default.default.all(x, function (v, k) {
+      // @ts-expect-error - TS2536 - Type 'CollectionKey<T>' cannot be used to index type 'T'.
       return approximateDeepEqual(y[k], v);
-    }) && _.all(y, function (v, k) {
+    }) && ___default.default.all(y, function (v, k) {
+      // @ts-expect-error - TS2536 - Type 'CollectionKey<T>' cannot be used to index type 'T'.
       return approximateDeepEqual(x[k], v);
     });
   }
@@ -73,12 +131,38 @@ function approximateDeepEqual(x, y) {
   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();
@@ -89,18 +173,31 @@ function getWidgetIdsFromContent(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) {
+    if (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);
@@ -113,22 +210,33 @@ const MOVABLES = {
   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;
   }
@@ -138,21 +246,29 @@ function canonicalSineCoefficients(coeffs) {
   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;
   }
@@ -168,11 +284,12 @@ const PlotDefaults = {
   movable: MOVABLES.PLOT,
   getPropsForCoeffs: function (coeffs) {
     return {
-      fn: _.partial(this.getFunctionForCoeffs, coeffs)
+      // @ts-expect-error - TS2339 - Property 'getFunctionForCoeffs' does not exist on type '{ readonly areEqual: (coeffs1: any, coeffs2: any) => boolean; readonly Movable: any; readonly getPropsForCoeffs: (coeffs: any) => any; }'.
+      fn: ___default.default.partial(this.getFunctionForCoeffs, coeffs)
     };
   }
 };
-const Linear = _.extend({}, PlotDefaults, {
+const Linear = ___default.default.extend({}, PlotDefaults, {
   url: "https://ka-perseus-graphie.s3.amazonaws.com/67aaf581e6d9ef9038c10558a1f70ac21c11c9f8.png",
   defaultCoords: [[0.25, 0.75], [0.75, 0.75]],
   getCoefficients: function (coords) {
@@ -199,15 +316,19 @@ const Linear = _.extend({}, PlotDefaults, {
     return "y = " + m.toFixed(3) + "x + " + b.toFixed(3);
   }
 });
-const Quadratic = _.extend({}, PlotDefaults, {
+const Quadratic = ___default.default.extend({}, PlotDefaults, {
   url: "https://ka-perseus-graphie.s3.amazonaws.com/e23d36e6fc29ee37174e92c9daba2a66677128ab.png",
   defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
   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;
@@ -234,7 +355,7 @@ const Quadratic = _.extend({}, PlotDefaults, {
     return "y = " + a.toFixed(3) + "x^2 + " + b.toFixed(3) + "x + " + c.toFixed(3);
   }
 });
-const Sinusoid = _.extend({}, PlotDefaults, {
+const Sinusoid = ___default.default.extend({}, PlotDefaults, {
   url: "https://ka-perseus-graphie.s3.amazonaws.com/3d68e7718498475f53b206c2ab285626baf8857e.png",
   defaultCoords: [[0.5, 0.5], [0.6, 0.6]],
   movable: MOVABLES.SINUSOID,
@@ -274,7 +395,7 @@ const Sinusoid = _.extend({}, PlotDefaults, {
     return approximateDeepEqual(canonicalSineCoefficients(coeffs1), canonicalSineCoefficients(coeffs2));
   }
 });
-const Tangent = _.extend({}, PlotDefaults, {
+const Tangent = ___default.default.extend({}, PlotDefaults, {
   url: "https://ka-perseus-graphie.s3.amazonaws.com/7db80d23c35214f98659fe1cf0765811c1bbfbba.png",
   defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
   getCoefficients: function (coords) {
@@ -305,27 +426,46 @@ const Tangent = _.extend({}, PlotDefaults, {
     return approximateDeepEqual(canonicalTangentCoefficients(coeffs1), canonicalTangentCoefficients(coeffs2));
   }
 });
-const Exponential = _.extend({}, PlotDefaults, {
+const Exponential = ___default.default.extend({}, PlotDefaults, {
   url: "https://ka-perseus-graphie.s3.amazonaws.com/9cbfad55525e3ce755a31a631b074670a5dad611.png",
   defaultCoords: [[0.5, 0.55], [0.75, 0.75]],
   defaultAsymptote: [[0, 0.5], [1.0, 0.5]],
+  /**
+   * Add extra constraints for movement of the points or asymptote (below):
+   *   newCoord: [x, y]
+   *     The end position of the point or asymptote endpoint
+   *   oldCoord: [x, y]
+   *     The old position of the point or asymptote endpoint
+   *   coords:
+   *     An array of coordinates representing the proposed end configuration
+   *     of the plot coordinates.
+   *   asymptote:
+   *     An array of coordinates representing the proposed end configuration
+   *     of the asymptote.
+   *
+   * Return: either a coordinate (to be used as the resulting coordinate of
+   * the move) or a boolean, where `true` uses newCoord as the resulting
+   * coordinate, and `false` uses oldCoord as the resulting coordinate.
+   */
   extraCoordConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
     const y = asymptote[0][1];
-    return _.all(coords, coord => coord[1] !== y);
+    return ___default.default.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);
+    const isValid = ___default.default.all(coords, coord => coord[1] > y) || ___default.default.all(coords, coord => coord[1] < y);
     if (isValid) {
       return [oldCoord[0], y];
     }
+    // Snap the asymptote as close as possible, i.e., if the user moves
+    // the mouse really quickly into an invalid region
     const oldY = oldCoord[1];
-    const wasBelow = _.all(coords, coord => coord[1] > oldY);
+    const wasBelow = ___default.default.all(coords, coord => coord[1] > oldY);
     if (wasBelow) {
-      const bottomMost = _.min(_.map(coords, coord => coord[1]));
+      const bottomMost = ___default.default.min(___default.default.map(coords, coord => coord[1]));
       return [oldCoord[0], bottomMost - graph.snapStep[1]];
     }
-    const topMost = _.max(_.map(coords, coord => coord[1]));
+    const topMost = ___default.default.max(___default.default.map(coords, coord => coord[1]));
     return [oldCoord[0], topMost + graph.snapStep[1]];
   },
   allowReflectOverAsymptote: true,
@@ -344,6 +484,7 @@ const Exponential = _.extend({}, PlotDefaults, {
     return a * Math.exp(b * x) + c;
   },
   getEquationString: function (coords, asymptote) {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (!asymptote) {
       return null;
     }
@@ -354,33 +495,39 @@ const Exponential = _.extend({}, PlotDefaults, {
     return "y = " + a.toFixed(3) + "e^(" + b.toFixed(3) + "x) + " + c.toFixed(3);
   }
 });
-const Logarithm = _.extend({}, PlotDefaults, {
+const Logarithm = ___default.default.extend({}, PlotDefaults, {
   url: "https://ka-perseus-graphie.s3.amazonaws.com/f6491e99d34af34d924bfe0231728ad912068dc3.png",
   defaultCoords: [[0.55, 0.5], [0.75, 0.75]],
   defaultAsymptote: [[0.5, 0], [0.5, 1.0]],
   extraCoordConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
     const x = asymptote[0][0];
-    return _.all(coords, coord => coord[0] !== x) && coords[0][1] !== coords[1][1];
+    return ___default.default.all(coords, coord => coord[0] !== x) && coords[0][1] !== coords[1][1];
   },
   extraAsymptoteConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
     const x = newCoord[0];
-    const isValid = _.all(coords, coord => coord[0] > x) || _.all(coords, coord => coord[0] < x);
+    const isValid = ___default.default.all(coords, coord => coord[0] > x) || ___default.default.all(coords, coord => coord[0] < x);
     if (isValid) {
       return [x, oldCoord[1]];
     }
+    // Snap the asymptote as close as possible, i.e., if the user moves
+    // the mouse really quickly into an invalid region
     const oldX = oldCoord[0];
-    const wasLeft = _.all(coords, coord => coord[0] > oldX);
+    const wasLeft = ___default.default.all(coords, coord => coord[0] > oldX);
     if (wasLeft) {
-      const leftMost = _.min(_.map(coords, coord => coord[0]));
+      const leftMost = ___default.default.min(___default.default.map(coords, coord => coord[0]));
       return [leftMost - graph.snapStep[0], oldCoord[1]];
     }
-    const rightMost = _.max(_.map(coords, coord => coord[0]));
+    const rightMost = ___default.default.max(___default.default.map(coords, coord => coord[0]));
     return [rightMost + graph.snapStep[0], oldCoord[1]];
   },
   allowReflectOverAsymptote: true,
   getCoefficients: function (coords, asymptote) {
+    // It's easiest to calculate the logarithm's coefficients by thinking
+    // about it as the inverse of the exponential, so we flip x and y and
+    // perform some algebra on the coefficients. This also unifies the
+    // logic between the two 'models'.
     const flip = coord => [coord[1], coord[0]];
-    const inverseCoeffs = Exponential.getCoefficients(_.map(coords, flip), _.map(asymptote, flip));
+    const inverseCoeffs = Exponential.getCoefficients(___default.default.map(coords, flip), ___default.default.map(asymptote, flip));
     if (inverseCoeffs) {
       const c = -inverseCoeffs[2] / inverseCoeffs[0];
       const b = 1 / inverseCoeffs[0];
@@ -395,6 +542,7 @@ const Logarithm = _.extend({}, PlotDefaults, {
     return a * Math.log(b * x + c);
   },
   getEquationString: function (coords, asymptote) {
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (!asymptote) {
       return null;
     }
@@ -405,7 +553,7 @@ const Logarithm = _.extend({}, PlotDefaults, {
     return "y = ln(" + a.toFixed(3) + "x + " + b.toFixed(3) + ") + " + c.toFixed(3);
   }
 });
-const AbsoluteValue = _.extend({}, PlotDefaults, {
+const AbsoluteValue = ___default.default.extend({}, PlotDefaults, {
   url: "https://ka-perseus-graphie.s3.amazonaws.com/8256a630175a0cb1d11de223d6de0266daf98721.png",
   defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
   getCoefficients: function (coords) {
@@ -438,6 +586,8 @@ const AbsoluteValue = _.extend({}, PlotDefaults, {
     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,
@@ -447,8 +597,10 @@ const functionTypeMapping = {
   logarithm: Logarithm,
   absolute_value: AbsoluteValue
 };
-const allTypes = _.keys(functionTypeMapping);
+const allTypes = ___default.default.keys(functionTypeMapping);
 function functionForType(type) {
+  // @ts-expect-error: TypeScript doesn't know how to use deal with generics
+  // and conditional types in this way.
   return functionTypeMapping[type];
 }
 
@@ -517,7 +669,8 @@ function isRealJSONParse(jsonParse) {
   const parsedTestItemData = parsedTestJSON.data.assessmentItem.item.itemData;
   return approximateDeepEqual(parsedTestItemData, testingObject);
 }
-function buildRandomString(capitalize = false) {
+function buildRandomString() {
+  let capitalize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
   let randomString = "";
   const randomLength = Math.floor(Math.random() * 8) + 3;
   for (let i = 0; i < randomLength; i++) {
@@ -559,7 +712,11 @@ function isFailure(result) {
 function isSuccess(result) {
   return result.type === "success";
 }
-function all(results, combineFailureDetails = a => a) {
+
+// 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) {
+  let combineFailureDetails = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : a => a;
   const values = [];
   const failureDetails = [];
   for (const result of results) {
@@ -616,6 +773,7 @@ function message(failure) {
 }
 function conjoin(items) {
   switch (items.length) {
+    // TODO(benchristel): handle 0 if this is reused elsewhere.
     case 1:
       return items[0];
     case 2:
@@ -668,7 +826,10 @@ function constant(acceptedValue) {
   };
 }
 
-function enumeration(...acceptedValues) {
+function enumeration() {
+  for (var _len = arguments.length, acceptedValues = new Array(_len), _key = 0; _key < _len; _key++) {
+    acceptedValues[_key] = arguments[_key];
+  }
   return (rawValue, ctx) => {
     if (typeof rawValue === "string") {
       const index = acceptedValues.indexOf(rawValue);
@@ -706,7 +867,9 @@ function object(schema) {
     if (!isObject(rawValue)) {
       return ctx.failure("object", rawValue);
     }
-    const ret = _extends({}, rawValue);
+    const ret = {
+      ...rawValue
+    };
     const mismatches = [];
     for (const [prop, propParser] of Object.entries(schema)) {
       const result = propParser(rawValue[prop], ctx.forSubtree(prop));
@@ -944,26 +1107,54 @@ 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", "FRAC_INCLUSIVE", "FRAC_EXCLUSIVE", "FRAC", "EXP", "EXP_2", "EXP_3", "SQRT", "CUBE_ROOT", "RADICAL", "LEFT_PAREN", "RIGHT_PAREN", "LN", "LOG", "LOG_N", "SIN", "COS", "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", "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"];
-
+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);
+    const maybeExpr = KAS__namespace.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);
@@ -981,28 +1172,57 @@ function deriveExtraKeys(widgetOptions) {
       }
     }
   }
+
+  // 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), () => ["basic", "trig", "prealgebra", "logarithms"]);
-
+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 {
+  parser;
   constructor(majorVersion, parseThisVersion, migrateToLatest, parseOtherVersions) {
-    this.parser = void 0;
     this.migrateToLatest = migrateToLatest;
     this.parseOtherVersions = parseOtherVersions;
     const parseThisVersionAndMigrateToLatest = pipeParsers(parseThisVersion).then(convert(this.migrateToLatest)).parser;
@@ -1020,6 +1240,10 @@ class VersionedWidgetOptionsParserBuilder {
       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));
@@ -1038,6 +1262,9 @@ const parseVersionedObject = object({
 
 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),
@@ -1051,9 +1278,11 @@ function removeInvalidAnswerForms(possiblyInvalid) {
       value
     } = answerForm;
     if (value != null) {
-      valid.push(_extends({}, answerForm, {
+      // Copying the object seems to be needed to make TypeScript happy
+      valid.push({
+        ...answerForm,
         value
-      }));
+      });
     }
   }
   return valid;
@@ -1089,7 +1318,8 @@ function migrateV1ToV2$1(widget) {
   const {
     options
   } = widget;
-  return _extends({}, widget, {
+  return {
+    ...widget,
     version: {
       major: 2,
       minor: 0
@@ -1104,7 +1334,7 @@ function migrateV1ToV2$1(widget) {
       answerForms: options.answerForms,
       extraKeys: deriveExtraKeys(options)
     }
-  });
+  };
 }
 const version0$1 = optional(object({
   major: constant(0),
@@ -1125,7 +1355,8 @@ function migrateV0ToV1$1(widget) {
   const {
     options
   } = widget;
-  return _extends({}, widget, {
+  return {
+    ...widget,
     version: {
       major: 1,
       minor: 0
@@ -1144,7 +1375,7 @@ function migrateV0ToV1$1(widget) {
         value: options.value
       }]
     }
-  });
+  };
 }
 const parseExpressionWidget = versionedWidgetOptions(2, parseExpressionWidgetV2).withMigrationFrom(1, parseExpressionWidgetV1, migrateV1ToV2$1).withMigrationFrom(0, parseExpressionWidgetV0, migrateV0ToV1$1).parser;
 
@@ -1152,8 +1383,14 @@ const falseToNull = pipeParsers(constant(false)).then(convert(() => null)).parse
 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)),
@@ -1168,6 +1405,13 @@ const parseGradedGroupSetWidget = parseWidget(constant("graded-group-set"), obje
   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)) {
@@ -1253,7 +1497,11 @@ const parseGrapherWidget = parseWidget(constant("grapher"), object({
   })
 }));
 
-const parseGroupWidget = parseWidget(constant("group"), (rawVal, ctx) => parsePerseusRenderer(rawVal, ctx));
+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,
@@ -1282,7 +1530,11 @@ const stringToNumber = (rawValue, ctx) => {
 function emptyToZero(x) {
   return x === "" ? 0 : x;
 }
-const imageDimensionToNumber = pipeParsers(union(number).or(string).parser).then(convert(emptyToZero)).then(stringToNumber).parser;
+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)),
@@ -1323,6 +1575,10 @@ const parseInputNumberWidget = parseWidget(constant("input-number"), object({
   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)
 }));
@@ -1456,8 +1712,270 @@ const parseInteractionWidget = parseWidget(constant("interaction"), object({
   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)
 }));
 
-const ItemExtras = ["calculator", "chi2Table", "financialCalculatorMonthlyPayment", "financialCalculatorTotalAmount", "financialCalculatorTimeToPayOff", "periodicTable", "periodicTableWithKey", "tTable", "zTable"];
+/**
+ * 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",
@@ -1474,8 +1992,21 @@ const lockedFigureFillStyles = {
   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"),
@@ -1495,18 +2026,22 @@ const parsePerseusGraphTypeCircle = 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({
@@ -1517,6 +2052,7 @@ const parsePerseusGraphTypePoint = object({
   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({
@@ -1527,31 +2063,37 @@ const parsePerseusGraphTypePolygon = object({
   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;
@@ -1570,6 +2112,7 @@ const parseLockedPointType = object({
   coord: pairOfNumbers,
   color: parseLockedFigureColor,
   filled: boolean,
+  // TODO(benchristel): default labels to empty array?
   labels: optional(array(parseLockedLabelType)),
   ariaLabel: optional(string)
 });
@@ -1581,6 +2124,7 @@ const parseLockedLineType = object({
   lineStyle: parseLockedLineStyle,
   showPoint1: defaulted(boolean, () => false),
   showPoint2: defaulted(boolean, () => false),
+  // TODO(benchristel): default labels to empty array?
   labels: optional(array(parseLockedLabelType)),
   ariaLabel: optional(string)
 });
@@ -1588,6 +2132,7 @@ 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)
 });
@@ -1599,6 +2144,7 @@ const parseLockedEllipseType = object({
   color: parseLockedFigureColor,
   fillStyle: parseLockedFigureFillType,
   strokeStyle: parseLockedLineStyle,
+  // TODO(benchristel): default labels to empty array?
   labels: optional(array(parseLockedLabelType)),
   ariaLabel: optional(string)
 });
@@ -1609,9 +2155,12 @@ const parseLockedPolygonType = object({
   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"),
@@ -1620,12 +2169,17 @@ const parseLockedFunctionType = object({
   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),
@@ -1637,10 +2191,14 @@ const parseInteractiveGraphWidget = parseWidget(constant("interactive-graph"), o
   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)
@@ -1683,6 +2241,9 @@ const parseMatrixWidget = parseWidget(defaulted(constant("matrix"), () => "matri
 }));
 
 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,
@@ -1695,6 +2256,7 @@ const parseMeasurerWidget = parseWidget(constant("measurer"), object({
   rulerPixels: number,
   rulerLength: number,
   box: pair(number, number),
+  // TODO(benchristel): static is not used. Remove it?
   static: defaulted(boolean, () => false)
 }));
 
@@ -1713,6 +2275,9 @@ const parseNumberLineWidget = parseWidget(constant("number-line"), object({
   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)),
@@ -1730,6 +2295,10 @@ function deprecatedSimplifyValuesToRequired(simplify) {
     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";
   }
@@ -1737,11 +2306,17 @@ function deprecatedSimplifyValuesToRequired(simplify) {
 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),
@@ -1755,6 +2330,9 @@ const parseNumericInputWidget = parseWidget(constant("numeric-input"), object({
   })))
 }));
 
+// 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);
 }
@@ -1796,14 +2374,23 @@ const parsePlotterWidget = parseWidget(constant("plotter"), object({
   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])
 }));
 
@@ -1812,7 +2399,6 @@ const parsePythonProgramWidget = parseWidget(constant("python-program"), object(
   height: number
 }));
 
-const _excluded$a = ["noneOfTheAbove"];
 const currentVersion$3 = {
   major: 2,
   minor: 0
@@ -1822,26 +2408,28 @@ function deriveNumCorrect(options) {
     choices,
     numCorrect
   } = options;
-  return numCorrect != null ? numCorrect : choices.filter(c => c.correct).length;
+  return numCorrect ?? choices.filter(c => c.correct).length;
 }
 const widgetOptionsUpgrades$2 = {
   "2": v1props => {
-    const upgraded = _extends({}, v1props, {
+    const upgraded = {
+      ...v1props,
       numCorrect: deriveNumCorrect(v1props)
-    });
+    };
     return upgraded;
   },
   "1": v0props => {
     const {
-        noneOfTheAbove
-      } = v0props,
-      rest = _objectWithoutPropertiesLoose(v0props, _excluded$a);
+      noneOfTheAbove,
+      ...rest
+    } = v0props;
     if (noneOfTheAbove) {
       throw new Error("radio widget v0 no longer supports auto noneOfTheAbove");
     }
-    return _extends({}, rest, {
+    return {
+      ...rest,
       hasNoneOfTheAbove: false
-    });
+    };
   }
 };
 const defaultWidgetOptions$v = {
@@ -1854,7 +2442,6 @@ const defaultWidgetOptions$v = {
   deselectEnabled: false
 };
 
-const _excluded$9 = ["noneOfTheAbove"];
 const version2 = optional(object({
   major: constant(2),
   minor: number
@@ -1866,6 +2453,10 @@ const parseRadioWidgetV2 = parseWidgetWithVersion(version2, constant("radio"), o
     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),
@@ -1873,8 +2464,12 @@ const parseRadioWidgetV2 = parseWidgetWithVersion(version2, constant("radio"), o
   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({
@@ -1887,6 +2482,10 @@ const parseRadioWidgetV1 = parseWidgetWithVersion(version1, constant("radio"), o
     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),
@@ -1894,23 +2493,29 @@ const parseRadioWidgetV1 = parseWidgetWithVersion(version1, constant("radio"), o
   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, {
+  return {
+    ...widget,
     version: {
       major: 2,
       minor: 0
     },
-    options: _extends({}, options, {
+    options: {
+      ...options,
       numCorrect: deriveNumCorrect(options)
-    })
-  });
+    }
+  };
 }
 const version0 = optional(object({
   major: constant(0),
@@ -1922,6 +2527,10 @@ const parseRadioWidgetV0 = parseWidgetWithVersion(version0, constant("radio"), o
     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),
@@ -1929,24 +2538,33 @@ const parseRadioWidgetV0 = parseWidgetWithVersion(version0, constant("radio"), o
   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, {
+  const {
+    noneOfTheAbove: _,
+    ...rest
+  } = options;
+  return {
+    ...widget,
     version: {
       major: 1,
       minor: 0
     },
-    options: _extends({}, rest, {
+    options: {
+      ...rest,
       hasNoneOfTheAbove: false
-    })
-  });
+    }
+  };
 }
 const parseRadioWidget = versionedWidgetOptions(2, parseRadioWidgetV2).withMigrationFrom(1, parseRadioWidgetV1, migrateV1ToV2).withMigrationFrom(0, parseRadioWidgetV0, migrateV0ToV1).parser;
 
@@ -1974,6 +2592,9 @@ const parseWidgetsMap = (rawValue, ctx) => {
   }
   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;
@@ -1981,7 +2602,8 @@ const parseWidgetsMap = (rawValue, ctx) => {
   }
   return ctx.success(widgetsMap);
 };
-const parseWidgetsMapEntry = ([id, widget], widgetMap, ctx) => {
+const parseWidgetsMapEntry = (_ref, widgetMap, ctx) => {
+  let [id, widget] = _ref;
   const idComponentsResult = parseWidgetIdComponents(id.split(" "), ctx.forSubtree("(widget ID)"));
   if (isFailure(idComponentsResult)) {
     return idComponentsResult;
@@ -2047,6 +2669,9 @@ const parseWidgetsMapEntry = ([id, widget], widgetMap, ctx) => {
     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);
@@ -2063,6 +2688,8 @@ const parseWidgetsMapEntry = ([id, widget], widgetMap, ctx) => {
     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);
@@ -2074,8 +2701,16 @@ const parseWidgetsMapEntry = ([id, widget], widgetMap, ctx) => {
       return parseAndAssign(`${type} ${n}`, parseWidget(constant(type), any));
   }
 };
-const parseDeprecatedWidget = parseWidget((_, ctx) => ctx.success("deprecated-standin"), object({}));
+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);
   }
@@ -2084,11 +2719,20 @@ const parseStringToNonNegativeInt = (rawValue, ctx) => {
 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: {}
@@ -2101,10 +2745,25 @@ const parseHint = object({
   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,
@@ -2127,15 +2786,37 @@ const parsePerseusItem$1 = 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);
@@ -2148,6 +2829,16 @@ function parseAndMigratePerseusItem(json) {
   }
   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);
@@ -2160,48 +2851,131 @@ function parseAndMigratePerseusArticle(json) {
   }
   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 = "6.0.0";
-addLibraryVersionToPerseusDebug(libName, libVersion);
+const libVersion = "7.0.0";
+perseusUtils.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 {
+  kind;
+  metadata;
   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;
+    this.metadata = options?.metadata;
   }
 }
 
-const pluck = function pluck(table, subKey) {
-  return _.object(_.map(table, function (value, key) {
+/**
+ * _ 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 (table, subKey) {
+  return ___default.default.object(___default.default.map(table, function (value, key) {
     return [key, value[subKey]];
   }));
 };
-const mapObject = function mapObject(obj, lambda) {
+
+/**
+ * Maps an object to an object
+ *
+ * > mapObject({a: '1', b: '2'}, (value, key) => {
+ *       return value + 1;
+ *   });
+ * {a: 2, b: 3}
+ */
+const mapObject = function (obj, lambda) {
   const result = {};
   Object.keys(obj).forEach(key => {
+    // @ts-expect-error - TS2345 - Argument of type 'string' is not assignable to parameter of type 'K'.
     result[key] = lambda(obj[key], key);
   });
   return result;
 };
 
+/**
+ * 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,
@@ -2256,6 +3030,15 @@ const definitionWidgetLogic = {
   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 => ({
@@ -2336,6 +3119,15 @@ const defaultWidgetOptions$p = {
   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,
@@ -2377,9 +3169,11 @@ const gradedGroupSetWidgetLogic = {
   defaultWidgetOptions: defaultWidgetOptions$n
 };
 
-const _excluded$8 = ["correct"];
 function getGrapherPublicWidgetOptions(options) {
-  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded$8);
+  const {
+    correct: _,
+    ...publicOptions
+  } = options;
   return publicOptions;
 }
 
@@ -2491,9 +3285,11 @@ const interactionWidgetLogic = {
   defaultWidgetOptions: defaultWidgetOptions$h
 };
 
-const _excluded$7 = ["correct"];
 function getInteractiveGraphPublicWidgetOptions(options) {
-  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded$7);
+  const {
+    correct: _,
+    ...publicOptions
+  } = options;
   return publicOptions;
 }
 
@@ -2521,14 +3317,22 @@ const interactiveGraphWidgetLogic = {
   getPublicWidgetOptions: getInteractiveGraphPublicWidgetOptions
 };
 
-const _excluded$6 = ["answers"];
+/**
+ * For details on the individual options, see the
+ * PerseusLabelImageWidgetOptions type
+ */
+
 function getLabelImagePublicWidgetOptions(options) {
-  return _extends({}, options, {
+  return {
+    ...options,
     markers: options.markers.map(getLabelImageMarkerPublicData)
-  });
+  };
 }
 function getLabelImageMarkerPublicData(marker) {
-  const publicData = _objectWithoutPropertiesLoose(marker, _excluded$6);
+  const {
+    answers: _,
+    ...publicData
+  } = marker;
   return publicData;
 }
 
@@ -2548,9 +3352,14 @@ const labelImageWidgetLogic = {
   getPublicWidgetOptions: getLabelImagePublicWidgetOptions
 };
 
-const seededRNG = function seededRNG(seed) {
+/* 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 (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;
@@ -2561,10 +3370,20 @@ const seededRNG = function seededRNG(seed) {
     return (randomSeed = seed & 0xfffffff) / 0x10000000;
   };
 };
-function shuffle(array, randomSeed, ensurePermuted = false) {
-  const shuffled = _.clone(array);
-  if (!shuffled.length || _.all(shuffled, function (value) {
-    return _.isEqual(value, shuffled[0]);
+
+// 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) {
+  let ensurePermuted = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  // Always return a copy of the input array
+  const shuffled = ___default.default.clone(array);
+
+  // Handle edge cases (input array is empty or uniform)
+  if (
+  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+  !shuffled.length || ___default.default.all(shuffled, function (value) {
+    return ___default.default.isEqual(value, shuffled[0]);
   })) {
     return shuffled;
   }
@@ -2575,53 +3394,77 @@ function shuffle(array, randomSeed, ensurePermuted = false) {
     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));
+  } while (ensurePermuted && ___default.default.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, true);
+    left = shuffle(props.left, rng, /* ensurePermuted */true);
   }
-  const right = shuffle(props.right, rng, 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, true);
+    left = shuffle(data.left, Math.random, /* ensurePermuted */true);
   }
-  const right = shuffle(data.right, Math.random, 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, {
+  return {
+    ...options,
     left: left,
     right: right
-  });
+  };
 }
 
 const defaultWidgetOptions$e = {
@@ -2637,9 +3480,11 @@ const matcherWidgetLogic = {
   getPublicWidgetOptions: getMatcherPublicWidgetOptions
 };
 
-const _excluded$5 = ["answers"];
 function getMatrixPublicWidgetOptions(options) {
-  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded$5);
+  const {
+    answers: _,
+    ...publicOptions
+  } = options;
   return publicOptions;
 }
 
@@ -2656,7 +3501,6 @@ const matrixWidgetLogic = {
   getPublicWidgetOptions: getMatrixPublicWidgetOptions
 };
 
-const _excluded$4 = ["imageUrl", "imageTop", "imageLeft"];
 const currentVersion$1 = {
   major: 1,
   minor: 0
@@ -2664,18 +3508,19 @@ const currentVersion$1 = {
 const widgetOptionsUpgrades = {
   "1": v0options => {
     const {
-        imageUrl,
-        imageTop,
-        imageLeft
-      } = v0options,
-      rest = _objectWithoutPropertiesLoose(v0options, _excluded$4);
-    return _extends({}, rest, {
+      imageUrl,
+      imageTop,
+      imageLeft,
+      ...rest
+    } = v0options;
+    return {
+      ...rest,
       image: {
         url: imageUrl,
         top: imageTop,
         left: imageLeft
       }
-    });
+    };
   }
 };
 const defaultWidgetOptions$c = {
@@ -2696,9 +3541,12 @@ const measurerWidgetLogic = {
   defaultWidgetOptions: defaultWidgetOptions$c
 };
 
-const _excluded$3 = ["correctX", "correctRel"];
 function getNumberLinePublicWidgetOptions(options) {
-  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded$3);
+  const {
+    correctX: _,
+    correctRel: __,
+    ...publicOptions
+  } = options;
   return publicOptions;
 }
 
@@ -2722,7 +3570,15 @@ const numberLineWidgetLogic = {
   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,
@@ -2735,14 +3591,20 @@ function getNumericInputAnswerPublicData(answer) {
     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,
+    ...publicWidgetOptions
+  } = options;
+  return {
+    ...publicWidgetOptions,
     answers: answers.map(getNumericInputAnswerPublicData)
-  });
+  };
 }
 
 const defaultWidgetOptions$a = {
@@ -2767,6 +3629,15 @@ const numericInputWidgetLogic = {
   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,
@@ -2837,9 +3708,20 @@ const phetSimulationWidgetLogic = {
   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);
+  const {
+    correct: _,
+    ...publicOptions
+  } = options;
   return publicOptions;
 }
 
@@ -2873,6 +3755,19 @@ const pythonProgramWidgetLogic = {
   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,
@@ -2885,9 +3780,23 @@ function getRadioChoicePublicData(choice) {
     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,
@@ -2895,10 +3804,12 @@ function getRadioPublicWidgetOptions(options) {
     multipleSelect,
     countChoices
   } = options;
-  return _extends({}, options, {
+  return {
+    ...options,
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     numCorrect: usesNumCorrect(multipleSelect, countChoices, numCorrect) ? numCorrect : undefined,
     choices: choices.map(getRadioChoicePublicData)
-  });
+  };
 }
 
 const radioWidgetLogic = {
@@ -2909,12 +3820,28 @@ const radioWidgetLogic = {
   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, true);
-  return _extends({}, options, {
+  const shuffledCorrect = shuffle(options.correct, Math.random, /* ensurePermuted */true);
+  return {
+    ...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 = {
@@ -2928,14 +3855,19 @@ const sorterWidgetLogic = {
   getPublicWidgetOptions: getSorterPublicWidgetOptions
 };
 
-const _excluded = ["answers"];
 function getTablePublicWidgetOptions(options) {
-  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded);
+  const {
+    answers: _,
+    ...publicOptions
+  } = options;
   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: [""],
@@ -2969,34 +3901,60 @@ function isWidgetRegistered(type) {
 }
 function getCurrentVersion(type) {
   const widgetLogic = widgets[type];
-  return (widgetLogic == null ? void 0 : widgetLogic.version) || {
+  return 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;
+  return widgets[name]?.getPublicWidgetOptions ?? (i => i);
 };
 function getWidgetOptionsUpgrades(type) {
   const widgetLogic = widgets[type];
-  return (widgetLogic == null ? void 0 : widgetLogic.widgetOptionsUpgrades) || {};
+  return widgetLogic?.widgetOptionsUpgrades || {};
 }
 function getDefaultWidgetOptions(type) {
   const widgetLogic = widgets[type];
-  return (widgetLogic == null ? void 0 : widgetLogic.defaultWidgetOptions) || {};
+  return 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])) {
+  if (!widgetLogic?.supportedAlignments?.[0]) {
+    // default alignments
     return ["default"];
   }
-  return widgetLogic == null ? void 0 : widgetLogic.supportedAlignments;
+  return 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)) {
+  if (!widgetLogic?.defaultAlignment) {
     return "block";
   }
   return widgetLogic.defaultAlignment;
@@ -3048,23 +4006,52 @@ var coreWidgetRegistry = /*#__PURE__*/Object.freeze({
 const DEFAULT_STATIC = false;
 const upgradeWidgetInfoToLatestVersion = oldWidgetInfo => {
   const type = oldWidgetInfo.type;
-  if (!_.isString(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 (!___default.default.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;
   }
-  let newEditorOptions = _.clone(oldWidgetInfo.options) || {};
+
+  // 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 = ___default.default.clone(oldWidgetInfo.options) || {};
   const upgradePropsMap = getWidgetOptionsUpgrades(type);
-  if (_.keys(newEditorOptions).length !== 0) {
+
+  // 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 (___default.default.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);
@@ -3080,12 +4067,23 @@ const upgradeWidgetInfoToLatestVersion = 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);
+  newEditorOptions = {
+    ...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];
+    alignment = getSupportedAlignments(type)?.[0];
     if (!alignment) {
       throw new PerseusError("No default alignment found when upgrading widget", Errors.Internal, {
         metadata: {
@@ -3098,46 +4096,146 @@ const upgradeWidgetInfoToLatestVersion = oldWidgetInfo => {
   if (widgetStatic == null) {
     widgetStatic = DEFAULT_STATIC;
   }
-  return _extends({}, oldWidgetInfo, {
+  return {
+    ...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);
+      widgetInfo = {
+        ...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 item = ___default.default.clone(originalItem);
+  const originalWidgets = 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, {
+    splitWidgets[id] = {
+      ...widget,
       options: publicWidgetOptionsFun(widget.options)
-    });
+    };
   }
-  return _extends({}, item, {
+  return {
+    ...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 };
+exports.CoreWidgetRegistry = coreWidgetRegistry;
+exports.Errors = Errors;
+exports.GrapherUtil = grapherUtil;
+exports.ItemExtras = ItemExtras;
+exports.PerseusError = PerseusError;
+exports.PerseusExpressionAnswerFormConsidered = PerseusExpressionAnswerFormConsidered;
+exports.addWidget = addWidget;
+exports.approximateDeepEqual = approximateDeepEqual;
+exports.approximateEqual = approximateEqual;
+exports.categorizerLogic = categorizerWidgetLogic;
+exports.csProgramLogic = csProgramWidgetLogic;
+exports.deepClone = deepClone;
+exports.definitionLogic = definitionWidgetLogic;
+exports.deriveExtraKeys = deriveExtraKeys;
+exports.deriveNumCorrect = deriveNumCorrect;
+exports.dropdownLogic = dropdownWidgetLogic;
+exports.explanationLogic = explanationWidgetLogic;
+exports.expressionLogic = expressionWidgetLogic;
+exports.getCSProgramPublicWidgetOptions = getCSProgramPublicWidgetOptions;
+exports.getCategorizerPublicWidgetOptions = getCategorizerPublicWidgetOptions;
+exports.getDecimalSeparator = getDecimalSeparator;
+exports.getDropdownPublicWidgetOptions = getDropdownPublicWidgetOptions;
+exports.getExpressionPublicWidgetOptions = getExpressionPublicWidgetOptions;
+exports.getGrapherPublicWidgetOptions = getGrapherPublicWidgetOptions;
+exports.getIFramePublicWidgetOptions = getIFramePublicWidgetOptions;
+exports.getInteractiveGraphPublicWidgetOptions = getInteractiveGraphPublicWidgetOptions;
+exports.getLabelImagePublicWidgetOptions = getLabelImagePublicWidgetOptions;
+exports.getMatcherPublicWidgetOptions = getMatcherPublicWidgetOptions;
+exports.getMatrixPublicWidgetOptions = getMatrixPublicWidgetOptions;
+exports.getMatrixSize = getMatrixSize;
+exports.getNumberLinePublicWidgetOptions = getNumberLinePublicWidgetOptions;
+exports.getNumericInputPublicWidgetOptions = getNumericInputPublicWidgetOptions;
+exports.getOrdererPublicWidgetOptions = getOrdererPublicWidgetOptions;
+exports.getPlotterPublicWidgetOptions = getPlotterPublicWidgetOptions;
+exports.getRadioPublicWidgetOptions = getRadioPublicWidgetOptions;
+exports.getSorterPublicWidgetOptions = getSorterPublicWidgetOptions;
+exports.getTablePublicWidgetOptions = getTablePublicWidgetOptions;
+exports.getUpgradedWidgetOptions = getUpgradedWidgetOptions;
+exports.getWidgetIdsFromContent = getWidgetIdsFromContent;
+exports.getWidgetIdsFromContentByType = getWidgetIdsFromContentByType;
+exports.gradedGroupLogic = gradedGroupWidgetLogic;
+exports.gradedGroupSetLogic = gradedGroupSetWidgetLogic;
+exports.grapherLogic = grapherWidgetLogic;
+exports.groupLogic = groupWidgetLogic;
+exports.iframeLogic = iframeWidgetLogic;
+exports.imageLogic = imageWidgetLogic;
+exports.inputNumberLogic = inputNumberWidgetLogic;
+exports.interactionLogic = interactionWidgetLogic;
+exports.interactiveGraphLogic = interactiveGraphWidgetLogic;
+exports.isFailure = isFailure;
+exports.isSuccess = isSuccess;
+exports.labelImageLogic = labelImageWidgetLogic;
+exports.libVersion = libVersion;
+exports.lockedFigureColorNames = lockedFigureColorNames;
+exports.lockedFigureColors = lockedFigureColors;
+exports.lockedFigureFillStyles = lockedFigureFillStyles;
+exports.mapObject = mapObject;
+exports.matcherLogic = matcherWidgetLogic;
+exports.matrixLogic = matrixWidgetLogic;
+exports.measurerLogic = measurerWidgetLogic;
+exports.numberLineLogic = numberLineWidgetLogic;
+exports.numericInputLogic = numericInputWidgetLogic;
+exports.ordererLogic = ordererWidgetLogic;
+exports.parseAndMigratePerseusArticle = parseAndMigratePerseusArticle;
+exports.parseAndMigratePerseusItem = parseAndMigratePerseusItem;
+exports.parsePerseusItem = parsePerseusItem;
+exports.passageLogic = passageWidgetLogic;
+exports.passageRefLogic = passageRefWidgetLogic;
+exports.passageRefTargetLogic = passageRefTargetWidgetLogic;
+exports.phetSimulationLogic = phetSimulationWidgetLogic;
+exports.plotterLogic = plotterWidgetLogic;
+exports.plotterPlotTypes = plotterPlotTypes;
+exports.pluck = pluck;
+exports.pythonProgramLogic = pythonProgramWidgetLogic;
+exports.radioLogic = radioWidgetLogic;
+exports.random = random;
+exports.seededRNG = seededRNG;
+exports.shuffle = shuffle;
+exports.shuffleMatcher = shuffleMatcher;
+exports.sorterLogic = sorterWidgetLogic;
+exports.splitPerseusItem = splitPerseusItem;
+exports.tableLogic = tableWidgetLogic;
+exports.upgradeWidgetInfoToLatestVersion = upgradeWidgetInfoToLatestVersion;
+exports.usesNumCorrect = usesNumCorrect;
+exports.videoLogic = videoWidgetLogic;
 //# sourceMappingURL=index.js.map