@khanacademy/perseus-core 3.1.0 → 3.3.0

package/dist/index.js

@@ -43,395 +43,103 @@ const addLibraryVersionToPerseusDebug = (libraryName, libraryVersion) => {
   }
 };
 
-// This file is processed by a Rollup plugin (replace) to inject the production
-const libName = "@khanacademy/perseus-core";
-const libVersion = "3.1.0";
-addLibraryVersionToPerseusDebug(libName, libVersion);
-
-/**
- * @typedef {Object} Errors utility for referencing the Perseus error taxonomy.
- */
-const Errors = Object.freeze({
-  /**
-   * @property {ErrorKind} Unknown The kind of error is not known.
-   */
-  Unknown: "Unknown",
-  /**
-   * @property {ErrorKind} Internal The error is internal to the executing code.
-   */
-  Internal: "Internal",
-  /**
-   * @property {ErrorKind} InvalidInput There was a problem with the provided
-   * input, such as the wrong format or a null value.
-   */
-  InvalidInput: "InvalidInput",
-  /**
-   * @property {ErrorKind} NotAllowed There was a problem due to the state of
-   * the system not matching the requested operation or input. For example,
-   * trying to create a username that is valid, but is already taken by
-   * another user. Use {@link InvalidInput} instead when the input isn't
-   * valid regardless of the state of the system. Use {@link NotFound} when
-   * the failure is due to not being able to find a resource.
-   */
-  NotAllowed: "NotAllowed",
-  /**
-   * @property {ErrorKind} TransientService There was a problem when making a
-   * request to a service.
-   */
-  TransientService: "TransientService",
-  /**
-   * @property {ErrorKind} Service There was a non-transient problem when
-   * making a request to service.
-   */
-  Service: "Service"
-});
+// Current version.
+var VERSION = '1.13.3';
 
-/**
- * @type {ErrorKind} The kind of error being reported
- */
+// Establish the root object, `window` (`self`) in the browser, `global`
+// on the server, or `this` in some virtual machines. We use `self`
+// instead of `window` for `WebWorker` support.
+var root = (typeof self == 'object' && self.self === self && self) ||
+          (typeof global == 'object' && global.global === global && global) ||
+          Function('return this')() ||
+          {};
 
-class PerseusError extends Error {
-  kind;
-  metadata;
-  constructor(message, kind, options) {
-    super(message);
-    this.kind = kind;
-    this.metadata = options?.metadata;
-  }
-}
+// Save bytes in the minified (but not gzipped) version:
+var ArrayProto = Array.prototype, ObjProto = Object.prototype;
+var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;
 
-/**
- * The Perseus "data schema" file.
- *
- * This file, and the types in it, represents the "data schema" that Perseus
- * uses. The @khanacademy/perseus-editor package edits and produces objects
- * that conform to the types in this file. Similarly, the top-level renderers
- * in @khanacademy/perseus, consume objects that conform to these types.
- *
- * WARNING: This file should not import any types from elsewhere so that it is
- * easy to reason about changes that alter the Perseus schema. This helps
- * ensure that it is not changed accidentally when upgrading a dependant
- * package or other part of Perseus code. Note that TypeScript does type
- * checking via something called "structural typing". This means that as long
- * as the shape of a type matches, the name it goes by doesn't matter. As a
- * result, a `Coord` type that looks like this `[x: number, y: number]` is
- * _identical_, in TypeScript's eyes, to this `Vector2` type `[x: number, y:
- * number]`. Also, with tuples, the labels for each entry is ignored, so `[x:
- * number, y: number]` is compatible with `[min: number, max: number]`. The
- * labels are for humans, not TypeScript. :)
- *
- * If you make changes to types in this file, be very sure that:
- *
- *   a) the changes are backwards compatible. If they are not, old data from
- *      previous versions of the "schema" could become unrenderable, or worse,
- *      introduce hard-to-diagnose bugs.
- *   b) the parsing code (`util/parse-perseus-json/`) is updated to handle
- *      the new format _as well as_ the old format.
- */
+// Create quick reference variables for speed access to core prototypes.
+var push = ArrayProto.push,
+    slice = ArrayProto.slice,
+    toString = ObjProto.toString,
+    hasOwnProperty = ObjProto.hasOwnProperty;
 
-// TODO(FEI-4010): Remove `Perseus` prefix for all types here
+// Modern feature detection.
+var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',
+    supportsDataView = typeof DataView !== 'undefined';
 
-// Same name as Mafs
+// All **ECMAScript 5+** native function implementations that we hope to use
+// are declared here.
+var nativeIsArray = Array.isArray,
+    nativeKeys = Object.keys,
+    nativeCreate = Object.create,
+    nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;
 
-/**
- * Our core set of Perseus widgets.
- *
- * This interface is the basis for "registering" all Perseus widget types.
- * There should be one key/value pair for each supported widget. If you create
- * a new widget, an entry should be added to this interface. Note that this
- * only registers the widget options type, you'll also need to register the
- * widget so that it's available at runtime (@see
- * {@link file://./widgets.ts#registerWidget}).
- *
- * Importantly, the key should be the name that is used in widget IDs. For most
- * widgets that is the same as the widget option's `type` field. In cases where
- * a widget has been deprecated and replaced with the deprecated-standin
- * widget, it should be the original widget type!
- *
- * If you define the widget outside of this package, you can still add the new
- * widget to this interface by writing the following in that package that
- * contains the widget. TypeScript will merge that definition of the
- * `PerseusWidgets` with the one defined below.
- *
- * ```typescript
- * declare module "@khanacademy/perseus" {
- *     interface PerseusWidgetTypes {
- *         // A new widget
- *         "new-awesomeness": MyAwesomeNewWidget;
- *
- *         // A deprecated widget
- *         "super-old-widget": DeprecatedStandinWidget;
- *     }
- * }
- *
- * // The new widget's options definition
- * type MyAwesomeNewWidget = WidgetOptions<'new-awesomeness', MyAwesomeNewWidgetOptions>;
- *
- * // The deprecated widget's options definition
- * type SuperOldWidget = WidgetOptions<'super-old-widget', object>;
- * ```
- *
- * This interface can be extended through the magic of TypeScript "Declaration
- * merging". Specifically, we augment this module and extend this interface.
- *
- * @see {@link https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation}
- */
+// Create references to these builtin functions because we override them.
+var _isNaN = isNaN,
+    _isFinite = isFinite;
 
-/**
- * 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!
- */
+// Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.
+var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');
+var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
+  'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];
 
-/**
- * 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.
- */
+// The largest integer that can be represented exactly.
+var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
 
-/**
- * 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`.
- */
+// Some functions take a variable number of arguments, or a few expected
+// arguments at the beginning and then a variable number of values to operate
+// on. This helper accumulates all remaining arguments past the function’s
+// argument length (or an explicit `startIndex`), into an array that becomes
+// the last argument. Similar to ES6’s "rest parameter".
+function restArguments(func, startIndex) {
+  startIndex = startIndex == null ? func.length - 1 : +startIndex;
+  return function() {
+    var length = Math.max(arguments.length - startIndex, 0),
+        rest = Array(length),
+        index = 0;
+    for (; index < length; index++) {
+      rest[index] = arguments[index + startIndex];
+    }
+    switch (startIndex) {
+      case 0: return func.call(this, rest);
+      case 1: return func.call(this, arguments[0], rest);
+      case 2: return func.call(this, arguments[0], arguments[1], rest);
+    }
+    var args = Array(startIndex + 1);
+    for (index = 0; index < startIndex; index++) {
+      args[index] = arguments[index];
+    }
+    args[startIndex] = rest;
+    return func.apply(this, args);
+  };
+}
 
-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"];
+// Is a given variable an object?
+function isObject$1(obj) {
+  var type = typeof obj;
+  return type === 'function' || (type === 'object' && !!obj);
+}
 
-/**
- * The type representing the common structure of all widget's options. The
- * `Options` generic type represents the widget-specific option data.
- */
+// Is a given value equal to null?
+function isNull(obj) {
+  return obj === null;
+}
 
-// prettier-ignore
+// Is a given variable undefined?
+function isUndefined(obj) {
+  return obj === void 0;
+}
 
-// prettier-ignore
+// Is a given value a boolean?
+function isBoolean(obj) {
+  return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
+}
 
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-// prettier-ignore
-
-//prettier-ignore
-
-/**
- * A background image applied to various widgets.
- */
-
-/**
- * The type of markings to display on the graph.
- * - axes: shows the axes without the gride lines
- * - graph: shows the axes and the grid lines
- * - grid: shows only the grid lines
- * - none: shows no markings
- */
-
-const PerseusExpressionAnswerFormConsidered = ["correct", "wrong", "ungraded"];
-
-// 2D range: xMin, xMax, yMin, yMax
-
-const lockedFigureColorNames = ["blue", "green", "grayH", "purple", "pink", "orange", "red"];
-const lockedFigureColors = {
-  blue: "#3D7586",
-  green: "#447A53",
-  grayH: "#3B3D45",
-  purple: "#594094",
-  pink: "#B25071",
-  red: "#D92916",
-  orange: "#946700"
-};
-const lockedFigureFillStyles = {
-  none: 0,
-  white: 1,
-  translucent: 0.4,
-  solid: 1
-};
-
-// Not associated with a specific figure
-
-const plotterPlotTypes = ["bar", "line", "pic", "histogram", "dotplot"];
-
-// Current version.
-var VERSION = '1.13.3';
-
-// Establish the root object, `window` (`self`) in the browser, `global`
-// on the server, or `this` in some virtual machines. We use `self`
-// instead of `window` for `WebWorker` support.
-var root = (typeof self == 'object' && self.self === self && self) ||
-          (typeof global == 'object' && global.global === global && global) ||
-          Function('return this')() ||
-          {};
-
-// Save bytes in the minified (but not gzipped) version:
-var ArrayProto = Array.prototype, ObjProto = Object.prototype;
-var SymbolProto = typeof Symbol !== 'undefined' ? Symbol.prototype : null;
-
-// Create quick reference variables for speed access to core prototypes.
-var push = ArrayProto.push,
-    slice = ArrayProto.slice,
-    toString = ObjProto.toString,
-    hasOwnProperty = ObjProto.hasOwnProperty;
-
-// Modern feature detection.
-var supportsArrayBuffer = typeof ArrayBuffer !== 'undefined',
-    supportsDataView = typeof DataView !== 'undefined';
-
-// All **ECMAScript 5+** native function implementations that we hope to use
-// are declared here.
-var nativeIsArray = Array.isArray,
-    nativeKeys = Object.keys,
-    nativeCreate = Object.create,
-    nativeIsView = supportsArrayBuffer && ArrayBuffer.isView;
-
-// Create references to these builtin functions because we override them.
-var _isNaN = isNaN,
-    _isFinite = isFinite;
-
-// Keys in IE < 9 that won't be iterated by `for key in ...` and thus missed.
-var hasEnumBug = !{toString: null}.propertyIsEnumerable('toString');
-var nonEnumerableProps = ['valueOf', 'isPrototypeOf', 'toString',
-  'propertyIsEnumerable', 'hasOwnProperty', 'toLocaleString'];
-
-// The largest integer that can be represented exactly.
-var MAX_ARRAY_INDEX = Math.pow(2, 53) - 1;
-
-// Some functions take a variable number of arguments, or a few expected
-// arguments at the beginning and then a variable number of values to operate
-// on. This helper accumulates all remaining arguments past the function’s
-// argument length (or an explicit `startIndex`), into an array that becomes
-// the last argument. Similar to ES6’s "rest parameter".
-function restArguments(func, startIndex) {
-  startIndex = startIndex == null ? func.length - 1 : +startIndex;
-  return function() {
-    var length = Math.max(arguments.length - startIndex, 0),
-        rest = Array(length),
-        index = 0;
-    for (; index < length; index++) {
-      rest[index] = arguments[index + startIndex];
-    }
-    switch (startIndex) {
-      case 0: return func.call(this, rest);
-      case 1: return func.call(this, arguments[0], rest);
-      case 2: return func.call(this, arguments[0], arguments[1], rest);
-    }
-    var args = Array(startIndex + 1);
-    for (index = 0; index < startIndex; index++) {
-      args[index] = arguments[index];
-    }
-    args[startIndex] = rest;
-    return func.apply(this, args);
-  };
-}
-
-// Is a given variable an object?
-function isObject(obj) {
-  var type = typeof obj;
-  return type === 'function' || (type === 'object' && !!obj);
-}
-
-// Is a given value equal to null?
-function isNull(obj) {
-  return obj === null;
-}
-
-// Is a given variable undefined?
-function isUndefined(obj) {
-  return obj === void 0;
-}
-
-// Is a given value a boolean?
-function isBoolean(obj) {
-  return obj === true || obj === false || toString.call(obj) === '[object Boolean]';
-}
-
-// Is a given value a DOM element?
-function isElement(obj) {
-  return !!(obj && obj.nodeType === 1);
-}
+// Is a given value a DOM element?
+function isElement(obj) {
+  return !!(obj && obj.nodeType === 1);
+}
 
 // Internal function for creating a `toString`-based type tester.
 function tagTester(name) {
@@ -522,7 +230,7 @@ function isNaN$1(obj) {
 }
 
 // Predicate-generating function. Often useful outside of Underscore.
-function constant(value) {
+function constant$1(value) {
   return function() {
     return value;
   };
@@ -559,7 +267,7 @@ function isTypedArray(obj) {
                 isBufferLike(obj) && typedArrayPattern.test(toString.call(obj));
 }
 
-var isTypedArray$1 = supportsArrayBuffer ? isTypedArray : constant(false);
+var isTypedArray$1 = supportsArrayBuffer ? isTypedArray : constant$1(false);
 
 // Internal helper to obtain the `length` property of an object.
 var getLength = shallowProperty('length');
@@ -604,7 +312,7 @@ function collectNonEnumProps(obj, keys) {
 // Retrieve the names of an object's own properties.
 // Delegates to **ECMAScript 5**'s native `Object.keys`.
 function keys(obj) {
-  if (!isObject(obj)) return [];
+  if (!isObject$1(obj)) return [];
   if (nativeKeys) return nativeKeys(obj);
   var keys = [];
   for (var key in obj) if (has$1(obj, key)) keys.push(key);
@@ -802,7 +510,7 @@ function isEqual(a, b) {
 
 // Retrieve all the enumerable property names of an object.
 function allKeys(obj) {
-  if (!isObject(obj)) return [];
+  if (!isObject$1(obj)) return [];
   var keys = [];
   for (var key in obj) keys.push(key);
   // Ahem, IE < 9.
@@ -931,7 +639,7 @@ function ctor() {
 
 // An internal function for creating a new object that inherits from another.
 function baseCreate(prototype) {
-  if (!isObject(prototype)) return {};
+  if (!isObject$1(prototype)) return {};
   if (nativeCreate) return nativeCreate(prototype);
   var Ctor = ctor();
   Ctor.prototype = prototype;
@@ -951,7 +659,7 @@ function create(prototype, props) {
 
 // Create a (shallow-cloned) duplicate of an object.
 function clone(obj) {
-  if (!isObject(obj)) return obj;
+  if (!isObject$1(obj)) return obj;
   return isArray(obj) ? obj.slice() : extend({}, obj);
 }
 
@@ -1060,7 +768,7 @@ function optimizeCb(func, context, argCount) {
 function baseIteratee(value, context, argCount) {
   if (value == null) return identity;
   if (isFunction$1(value)) return optimizeCb(value, context, argCount);
-  if (isObject(value) && !isArray(value)) return matcher(value);
+  if (isObject$1(value) && !isArray(value)) return matcher(value);
   return property(value);
 }
 
@@ -1309,7 +1017,7 @@ function executeBound(sourceFunc, boundFunc, context, callingContext, args) {
   if (!(callingContext instanceof boundFunc)) return sourceFunc.apply(context, args);
   var self = baseCreate(sourceFunc.prototype);
   var result = sourceFunc.apply(self, args);
-  if (isObject(result)) return result;
+  if (isObject$1(result)) return result;
   return self;
 }
 
@@ -2071,7 +1779,7 @@ function uniq(array, isSorted, iteratee, context) {
 
 // Produce an array that contains the union: each distinct element from all of
 // the passed-in arrays.
-var union = restArguments(function(arrays) {
+var union$1 = restArguments(function(arrays) {
   return uniq(flatten$1(arrays, true, true));
 });
 
@@ -2111,7 +1819,7 @@ var zip = restArguments(unzip);
 // Converts lists into objects. Pass either a single array of `[key, value]`
 // pairs, or two parallel arrays of the same length -- one of keys, and one of
 // the corresponding values. Passing by pairs is the reverse of `_.pairs`.
-function object(list, values) {
+function object$1(list, values) {
   var result = {};
   for (var i = 0, length = getLength(list); i < length; i++) {
     if (values) {
@@ -2206,7 +1914,7 @@ var allExports = /*#__PURE__*/Object.freeze({
     __proto__: null,
     VERSION: VERSION,
     restArguments: restArguments,
-    isObject: isObject,
+    isObject: isObject$1,
     isNull: isNull,
     isUndefined: isUndefined,
     isBoolean: isBoolean,
@@ -2250,7 +1958,7 @@ var allExports = /*#__PURE__*/Object.freeze({
     has: has,
     mapObject: mapObject$1,
     identity: identity,
-    constant: constant,
+    constant: constant$1,
     noop: noop,
     toPath: toPath$1,
     property: property,
@@ -2339,25 +2047,2619 @@ var allExports = /*#__PURE__*/Object.freeze({
     without: without,
     uniq: uniq,
     unique: uniq,
-    union: union,
+    union: union$1,
     intersection: intersection,
     difference: difference,
     unzip: unzip,
     transpose: unzip,
     zip: zip,
-    object: object,
+    object: object$1,
     range: range,
     chunk: chunk,
     mixin: mixin,
     'default': _$1
 });
 
-// Default Export
+// Default Export
+
+// Add all of the Underscore functions to the wrapper object.
+var _ = mixin(allExports);
+// Legacy Node.js API.
+_._ = _;
+
+function getMatrixSize(matrix) {
+  const matrixSize = [1, 1];
+
+  // We need to find the widest row and tallest column to get the correct
+  // matrix size.
+  _(matrix).each((matrixRow, row) => {
+    let rowWidth = 0;
+    _(matrixRow).each((matrixCol, col) => {
+      if (matrixCol != null && matrixCol.toString().length) {
+        rowWidth = col + 1;
+      }
+    });
+
+    // Matrix width:
+    matrixSize[1] = Math.max(matrixSize[1], rowWidth);
+
+    // Matrix height:
+    if (rowWidth > 0) {
+      matrixSize[0] = Math.max(matrixSize[0], row + 1);
+    }
+  });
+  return matrixSize;
+}
+
+/**
+ *  Get the character used for separating decimals.
+ */
+const getDecimalSeparator = locale => {
+  switch (locale) {
+    // TODO(somewhatabstract): Remove this when Chrome supports the `ka`
+    // locale properly.
+    // https://github.com/formatjs/formatjs/issues/1526#issuecomment-559891201
+    //
+    // Supported locales in Chrome:
+    // https://source.chromium.org/chromium/chromium/src/+/master:third_party/icu/scripts/chrome_ui_languages.list
+    case "ka":
+      return ",";
+    default:
+      const numberWithDecimalSeparator = 1.1;
+      // TODO(FEI-3647): Update to use .formatToParts() once we no longer have to
+      // support Safari 12.
+      const match = new Intl.NumberFormat(locale).format(numberWithDecimalSeparator)
+      // 0x661 is ARABIC-INDIC DIGIT ONE
+      // 0x6F1 is EXTENDED ARABIC-INDIC DIGIT ONE
+      .match(/[^\d\u0661\u06F1]/);
+      return match?.[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) {
+      return false;
+    }
+    for (let i = 0; i < x.length; i++) {
+      if (!approximateDeepEqual(x[i], y[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (Array.isArray(x) || Array.isArray(y)) {
+    return false;
+  }
+  if (typeof x === "function" && typeof y === "function") {
+    return approximateEqual(x, y);
+  }
+  if (typeof x === "function" || typeof y === "function") {
+    return false;
+  }
+  if (typeof x === "object" && typeof y === "object" && !!x && !!y) {
+    return x === y || _.all(x, function (v, k) {
+      // @ts-expect-error - TS2536 - Type 'CollectionKey<T>' cannot be used to index type 'T'.
+      return approximateDeepEqual(y[k], v);
+    }) && _.all(y, function (v, k) {
+      // @ts-expect-error - TS2536 - Type 'CollectionKey<T>' cannot be used to index type 'T'.
+      return approximateDeepEqual(x[k], v);
+    });
+  }
+  if (typeof x === "object" && !!x || typeof y === "object" && !!y) {
+    return false;
+  }
+  return approximateEqual(x, y);
+}
+
+/**
+ * Add a widget placeholder using the widget ID.
+ * ex. addWidget("radio 1") => "[[☃ radio 1]]"
+ *
+ * @param {string} id
+ * @returns {string}
+ */
+function addWidget(id) {
+  return `[[☃ ${id}]]`;
+}
+
+/**
+ * Regex for widget placeholders in a string.
+ *
+ * First capture group is the widget ID (ex. 'radio 1')
+ * Second capture group is the widget type (ex. "radio)
+ * exec return will look like: ['[[☃ radio 1]]', 'radio 1', 'radio']
+ */
+function getWidgetRegex() {
+  return /\[\[☃ ([A-Za-z0-9- ]+)\]\]/g;
+}
+
+/**
+ * Extract all widget IDs, which includes the widget type and instance number.
+ * example output: ['radio 1', 'categorizer 1', 'categorizor 2']
+ *
+ * Content should contain Perseus widget placeholders,
+ * which look like: '[[☃ radio 1]]'.
+ *
+ * @param {string} content
+ * @returns {ReadonlyArray<string>} widgetIds
+ */
+function getWidgetIdsFromContent(content) {
+  const widgets = [];
+  const localWidgetRegex = getWidgetRegex();
+  let match = localWidgetRegex.exec(content);
+  while (match !== null) {
+    widgets.push(match[1]);
+    match = localWidgetRegex.exec(content);
+  }
+  return widgets;
+}
+
+/**
+ * Get a list of widget IDs from content,
+ * but only for specific widget types
+ *
+ * @param {string} type the type of widget (ie "radio")
+ * @param {string} content the string to parse
+ * @param {PerseusWidgetsMap} widgetMap widget ID to widget map
+ * @returns {ReadonlyArray<string>} the widget type (ie "radio")
+ */
+function getWidgetIdsFromContentByType(type, content, widgetMap) {
+  const rv = [];
+  const widgetIdsInContent = getWidgetIdsFromContent(content);
+  widgetIdsInContent.forEach(widgetId => {
+    const widget = widgetMap[widgetId];
+    if (widget?.type === type) {
+      rv.push(widgetId);
+    }
+  });
+  return rv;
+}
+
+// TODO(benchristel): in the future, we may want to make deepClone work for
+// Record<string, Cloneable> as well. Currently, it only does arrays.
+
+function deepClone(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(deepClone);
+  }
+  return obj;
+}
+
+const MOVABLES = {
+  PLOT: "PLOT",
+  PARABOLA: "PARABOLA",
+  SINUSOID: "SINUSOID"
+};
+
+// TODO(charlie): These really need to go into a utility file as they're being
+// used by both interactive-graph and now grapher.
+function canonicalSineCoefficients(coeffs) {
+  // For a curve of the form f(x) = a * Sin(b * x - c) + d,
+  // this function ensures that a, b > 0, and c is its
+  // smallest possible positive value.
+  let amplitude = coeffs[0];
+  let angularFrequency = coeffs[1];
+  let phase = coeffs[2];
+  const verticalOffset = coeffs[3];
+
+  // Guarantee a > 0
+  if (amplitude < 0) {
+    amplitude *= -1;
+    angularFrequency *= -1;
+    phase *= -1;
+  }
+  const period = 2 * Math.PI;
+  // Guarantee b > 0
+  if (angularFrequency < 0) {
+    angularFrequency *= -1;
+    phase *= -1;
+    phase += period / 2;
+  }
+
+  // Guarantee c is smallest possible positive value
+  while (phase > 0) {
+    phase -= period;
+  }
+  while (phase < 0) {
+    phase += period;
+  }
+  return [amplitude, angularFrequency, phase, verticalOffset];
+}
+function canonicalTangentCoefficients(coeffs) {
+  // For a curve of the form f(x) = a * Tan(b * x - c) + d,
+  // this function ensures that a, b > 0, and c is its
+  // smallest possible positive value.
+  let amplitude = coeffs[0];
+  let angularFrequency = coeffs[1];
+  let phase = coeffs[2];
+  const verticalOffset = coeffs[3];
+
+  // Guarantee a > 0
+  if (amplitude < 0) {
+    amplitude *= -1;
+    angularFrequency *= -1;
+    phase *= -1;
+  }
+  const period = Math.PI;
+  // Guarantee b > 0
+  if (angularFrequency < 0) {
+    angularFrequency *= -1;
+    phase *= -1;
+    phase += period / 2;
+  }
+
+  // Guarantee c is smallest possible positive value
+  while (phase > 0) {
+    phase -= period;
+  }
+  while (phase < 0) {
+    phase += period;
+  }
+  return [amplitude, angularFrequency, phase, verticalOffset];
+}
+const PlotDefaults = {
+  areEqual: function (coeffs1, coeffs2) {
+    return approximateDeepEqual(coeffs1, coeffs2);
+  },
+  movable: MOVABLES.PLOT,
+  getPropsForCoeffs: function (coeffs) {
+    return {
+      // @ts-expect-error - TS2339 - Property 'getFunctionForCoeffs' does not exist on type '{ readonly areEqual: (coeffs1: any, coeffs2: any) => boolean; readonly Movable: any; readonly getPropsForCoeffs: (coeffs: any) => any; }'.
+      fn: _.partial(this.getFunctionForCoeffs, coeffs)
+    };
+  }
+};
+const Linear = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/67aaf581e6d9ef9038c10558a1f70ac21c11c9f8.png",
+  defaultCoords: [[0.25, 0.75], [0.75, 0.75]],
+  getCoefficients: function (coords) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+    const denom = p2[0] - p1[0];
+    const num = p2[1] - p1[1];
+    if (denom === 0) {
+      return;
+    }
+    const m = num / denom;
+    const b = p2[1] - m * p2[0];
+    return [m, b];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const m = coeffs[0];
+    const b = coeffs[1];
+    return m * x + b;
+  },
+  getEquationString: function (coords) {
+    const coeffs = this.getCoefficients(coords);
+    const m = coeffs[0];
+    const b = coeffs[1];
+    return "y = " + m.toFixed(3) + "x + " + b.toFixed(3);
+  }
+});
+const Quadratic = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/e23d36e6fc29ee37174e92c9daba2a66677128ab.png",
+  defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
+  movable: MOVABLES.PARABOLA,
+  getCoefficients: function (coords) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+
+    // Parabola with vertex (h, k) has form: y = a * (h - k)^2 + k
+    const h = p1[0];
+    const k = p1[1];
+
+    // Use these to calculate familiar a, b, c
+    const a = (p2[1] - k) / ((p2[0] - h) * (p2[0] - h));
+    const b = -2 * h * a;
+    const c = a * h * h + k;
+    return [a, b, c];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return (a * x + b) * x + c;
+  },
+  getPropsForCoeffs: function (coeffs) {
+    return {
+      a: coeffs[0],
+      b: coeffs[1],
+      c: coeffs[2]
+    };
+  },
+  getEquationString: function (coords) {
+    const coeffs = this.getCoefficients(coords);
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return "y = " + a.toFixed(3) + "x^2 + " + b.toFixed(3) + "x + " + c.toFixed(3);
+  }
+});
+const Sinusoid = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/3d68e7718498475f53b206c2ab285626baf8857e.png",
+  defaultCoords: [[0.5, 0.5], [0.6, 0.6]],
+  movable: MOVABLES.SINUSOID,
+  getCoefficients: function (coords) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+    const a = p2[1] - p1[1];
+    const b = Math.PI / (2 * (p2[0] - p1[0]));
+    const c = p1[0] * b;
+    const d = p1[1];
+    return [a, b, c, d];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    const d = coeffs[3];
+    return a * Math.sin(b * x - c) + d;
+  },
+  getPropsForCoeffs: function (coeffs) {
+    return {
+      a: coeffs[0],
+      b: coeffs[1],
+      c: coeffs[2],
+      d: coeffs[3]
+    };
+  },
+  getEquationString: function (coords) {
+    const coeffs = this.getCoefficients(coords);
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    const d = coeffs[3];
+    return "y = " + a.toFixed(3) + " sin(" + b.toFixed(3) + "x - " + c.toFixed(3) + ") + " + d.toFixed(3);
+  },
+  areEqual: function (coeffs1, coeffs2) {
+    return approximateDeepEqual(canonicalSineCoefficients(coeffs1), canonicalSineCoefficients(coeffs2));
+  }
+});
+const Tangent = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/7db80d23c35214f98659fe1cf0765811c1bbfbba.png",
+  defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
+  getCoefficients: function (coords) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+    const a = p2[1] - p1[1];
+    const b = Math.PI / (4 * (p2[0] - p1[0]));
+    const c = p1[0] * b;
+    const d = p1[1];
+    return [a, b, c, d];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    const d = coeffs[3];
+    return a * Math.tan(b * x - c) + d;
+  },
+  getEquationString: function (coords) {
+    const coeffs = this.getCoefficients(coords);
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    const d = coeffs[3];
+    return "y = " + a.toFixed(3) + " sin(" + b.toFixed(3) + "x - " + c.toFixed(3) + ") + " + d.toFixed(3);
+  },
+  areEqual: function (coeffs1, coeffs2) {
+    return approximateDeepEqual(canonicalTangentCoefficients(coeffs1), canonicalTangentCoefficients(coeffs2));
+  }
+});
+const Exponential = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/9cbfad55525e3ce755a31a631b074670a5dad611.png",
+  defaultCoords: [[0.5, 0.55], [0.75, 0.75]],
+  defaultAsymptote: [[0, 0.5], [1.0, 0.5]],
+  /**
+   * Add extra constraints for movement of the points or asymptote (below):
+   *   newCoord: [x, y]
+   *     The end position of the point or asymptote endpoint
+   *   oldCoord: [x, y]
+   *     The old position of the point or asymptote endpoint
+   *   coords:
+   *     An array of coordinates representing the proposed end configuration
+   *     of the plot coordinates.
+   *   asymptote:
+   *     An array of coordinates representing the proposed end configuration
+   *     of the asymptote.
+   *
+   * Return: either a coordinate (to be used as the resulting coordinate of
+   * the move) or a boolean, where `true` uses newCoord as the resulting
+   * coordinate, and `false` uses oldCoord as the resulting coordinate.
+   */
+  extraCoordConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
+    const y = asymptote[0][1];
+    return _.all(coords, coord => coord[1] !== y);
+  },
+  extraAsymptoteConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
+    const y = newCoord[1];
+    const isValid = _.all(coords, coord => coord[1] > y) || _.all(coords, coord => coord[1] < y);
+    if (isValid) {
+      return [oldCoord[0], y];
+    }
+    // Snap the asymptote as close as possible, i.e., if the user moves
+    // the mouse really quickly into an invalid region
+    const oldY = oldCoord[1];
+    const wasBelow = _.all(coords, coord => coord[1] > oldY);
+    if (wasBelow) {
+      const bottomMost = _.min(_.map(coords, coord => coord[1]));
+      return [oldCoord[0], bottomMost - graph.snapStep[1]];
+    }
+    const topMost = _.max(_.map(coords, coord => coord[1]));
+    return [oldCoord[0], topMost + graph.snapStep[1]];
+  },
+  allowReflectOverAsymptote: true,
+  getCoefficients: function (coords, asymptote) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+    const c = asymptote[0][1];
+    const b = Math.log((p1[1] - c) / (p2[1] - c)) / (p1[0] - p2[0]);
+    const a = (p1[1] - c) / Math.exp(b * p1[0]);
+    return [a, b, c];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return a * Math.exp(b * x) + c;
+  },
+  getEquationString: function (coords, asymptote) {
+    if (!asymptote) {
+      return null;
+    }
+    const coeffs = this.getCoefficients(coords, asymptote);
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return "y = " + a.toFixed(3) + "e^(" + b.toFixed(3) + "x) + " + c.toFixed(3);
+  }
+});
+const Logarithm = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/f6491e99d34af34d924bfe0231728ad912068dc3.png",
+  defaultCoords: [[0.55, 0.5], [0.75, 0.75]],
+  defaultAsymptote: [[0.5, 0], [0.5, 1.0]],
+  extraCoordConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
+    const x = asymptote[0][0];
+    return _.all(coords, coord => coord[0] !== x) && coords[0][1] !== coords[1][1];
+  },
+  extraAsymptoteConstraint: function (newCoord, oldCoord, coords, asymptote, graph) {
+    const x = newCoord[0];
+    const isValid = _.all(coords, coord => coord[0] > x) || _.all(coords, coord => coord[0] < x);
+    if (isValid) {
+      return [x, oldCoord[1]];
+    }
+    // Snap the asymptote as close as possible, i.e., if the user moves
+    // the mouse really quickly into an invalid region
+    const oldX = oldCoord[0];
+    const wasLeft = _.all(coords, coord => coord[0] > oldX);
+    if (wasLeft) {
+      const leftMost = _.min(_.map(coords, coord => coord[0]));
+      return [leftMost - graph.snapStep[0], oldCoord[1]];
+    }
+    const rightMost = _.max(_.map(coords, coord => coord[0]));
+    return [rightMost + graph.snapStep[0], oldCoord[1]];
+  },
+  allowReflectOverAsymptote: true,
+  getCoefficients: function (coords, asymptote) {
+    // It's easiest to calculate the logarithm's coefficients by thinking
+    // about it as the inverse of the exponential, so we flip x and y and
+    // perform some algebra on the coefficients. This also unifies the
+    // logic between the two 'models'.
+    const flip = coord => [coord[1], coord[0]];
+    const inverseCoeffs = Exponential.getCoefficients(_.map(coords, flip), _.map(asymptote, flip));
+    if (inverseCoeffs) {
+      const c = -inverseCoeffs[2] / inverseCoeffs[0];
+      const b = 1 / inverseCoeffs[0];
+      const a = 1 / inverseCoeffs[1];
+      return [a, b, c];
+    }
+  },
+  getFunctionForCoeffs: function (coeffs, x, asymptote) {
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return a * Math.log(b * x + c);
+  },
+  getEquationString: function (coords, asymptote) {
+    if (!asymptote) {
+      return null;
+    }
+    const coeffs = this.getCoefficients(coords, asymptote);
+    const a = coeffs[0];
+    const b = coeffs[1];
+    const c = coeffs[2];
+    return "y = ln(" + a.toFixed(3) + "x + " + b.toFixed(3) + ") + " + c.toFixed(3);
+  }
+});
+const AbsoluteValue = _.extend({}, PlotDefaults, {
+  url: "https://ka-perseus-graphie.s3.amazonaws.com/8256a630175a0cb1d11de223d6de0266daf98721.png",
+  defaultCoords: [[0.5, 0.5], [0.75, 0.75]],
+  getCoefficients: function (coords) {
+    const p1 = coords[0];
+    const p2 = coords[1];
+    const denom = p2[0] - p1[0];
+    const num = p2[1] - p1[1];
+    if (denom === 0) {
+      return;
+    }
+    let m = Math.abs(num / denom);
+    if (p2[1] < p1[1]) {
+      m *= -1;
+    }
+    const horizontalOffset = p1[0];
+    const verticalOffset = p1[1];
+    return [m, horizontalOffset, verticalOffset];
+  },
+  getFunctionForCoeffs: function (coeffs, x) {
+    const m = coeffs[0];
+    const horizontalOffset = coeffs[1];
+    const verticalOffset = coeffs[2];
+    return m * Math.abs(x - horizontalOffset) + verticalOffset;
+  },
+  getEquationString: function (coords) {
+    const coeffs = this.getCoefficients(coords);
+    const m = coeffs[0];
+    const horizontalOffset = coeffs[1];
+    const verticalOffset = coeffs[2];
+    return "y = " + m.toFixed(3) + "| x - " + horizontalOffset.toFixed(3) + "| + " + verticalOffset.toFixed(3);
+  }
+});
+
+/* Utility functions for dealing with graphing interfaces. */
+const functionTypeMapping = {
+  linear: Linear,
+  quadratic: Quadratic,
+  sinusoid: Sinusoid,
+  tangent: Tangent,
+  exponential: Exponential,
+  logarithm: Logarithm,
+  absolute_value: AbsoluteValue
+};
+const allTypes = _.keys(functionTypeMapping);
+function functionForType(type) {
+  // @ts-expect-error: TypeScript doesn't know how to use deal with generics
+  // and conditional types in this way.
+  return functionTypeMapping[type];
+}
+
+var grapherUtil = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    MOVABLES: MOVABLES,
+    allTypes: allTypes,
+    functionForType: functionForType
+});
+
+function isRealJSONParse(jsonParse) {
+  const randomPhrase = buildRandomPhrase();
+  const randomHintPhrase = buildRandomPhrase();
+  const randomString = buildRandomString();
+  const testingObject = JSON.stringify({
+    answerArea: {
+      calculator: false,
+      chi2Table: false,
+      financialCalculatorMonthlyPayment: false,
+      financialCalculatorTimeToPayOff: false,
+      financialCalculatorTotalAmount: false,
+      periodicTable: false,
+      periodicTableWithKey: false,
+      tTable: false,
+      zTable: false
+    },
+    hints: [randomHintPhrase, `=${Math.floor(Math.random() * 50) + 1}`],
+    itemDataVersion: {
+      major: 0,
+      minor: 1
+    },
+    question: {
+      content: `${randomPhrase}`,
+      images: {},
+      widgets: {
+        expression1: {
+          alignment: "default",
+          graded: false,
+          options: {
+            answerForms: [{
+              considered: "wrong",
+              form: false,
+              key: 0,
+              simplify: false,
+              value: `${randomString}`
+            }],
+            ariaLabel: "Answer",
+            buttonSets: ["basic"],
+            functions: ["f", "g", "h"],
+            static: true,
+            times: false,
+            visibleLabel: "Answer"
+          },
+          static: true,
+          type: "expression",
+          version: {
+            major: 1,
+            minor: 0
+          }
+        }
+      }
+    }
+  });
+  const testJSON = buildTestData(testingObject.replace(/"/g, '\\"'));
+  const parsedTestJSON = jsonParse(testJSON);
+  const parsedTestItemData = parsedTestJSON.data.assessmentItem.item.itemData;
+  return approximateDeepEqual(parsedTestItemData, testingObject);
+}
+function buildRandomString() {
+  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++) {
+    const randomLetter = String.fromCharCode(97 + Math.floor(Math.random() * 26));
+    randomString += capitalize && i === 0 ? randomLetter.toUpperCase() : randomLetter;
+  }
+  return randomString;
+}
+function buildRandomPhrase() {
+  const phrases = [];
+  const randomLength = Math.floor(Math.random() * 10) + 5;
+  for (let i = 0; i < randomLength; i++) {
+    phrases.push(buildRandomString(i === 0));
+  }
+  const modifierStart = ["**", "$"];
+  const modifierEnd = ["**", "$"];
+  const modifierIndex = Math.floor(Math.random() * modifierStart.length);
+  return `${modifierStart[modifierIndex]}${phrases.join(" ")}${modifierEnd[modifierIndex]}`;
+}
+function buildTestData(testObject) {
+  return `{"data":{"assessmentItem":{"__typename":"AssessmentItemOrError","error":null,"item":{"__typename":"AssessmentItem","id":"x890b3c70f3e8f4a6","itemData":"${testObject}","problemType":"Type 1","sha":"c7284a3ad65214b4e62bccce236d92f7f5d35941"}}}}`;
+}
+
+process.env.NODE_ENV === 'production';
+
+function success(value) {
+  return {
+    type: "success",
+    value
+  };
+}
+function failure(detail) {
+  return {
+    type: "failure",
+    detail
+  };
+}
+function isFailure(result) {
+  return result.type === "failure";
+}
+function isSuccess(result) {
+  return result.type === "success";
+}
+
+// Result's `all` function is similar to Promise.all: given an array of
+// results, it returns success if all succeeded, and failure if any failed.
+function all(results) {
+  let combineFailureDetails = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : a => a;
+  const values = [];
+  const failureDetails = [];
+  for (const result of results) {
+    if (result.type === "success") {
+      values.push(result.value);
+    } else {
+      failureDetails.push(result.detail);
+    }
+  }
+  if (failureDetails.length > 0) {
+    return failure(failureDetails.reduce(combineFailureDetails));
+  }
+  return success(values);
+}
+
+class ErrorTrackingParseContext {
+  constructor(path) {
+    this.path = path;
+  }
+  failure(expected, badValue) {
+    return failure([{
+      expected: wrapInArray(expected),
+      badValue,
+      path: this.path
+    }]);
+  }
+  forSubtree(key) {
+    return new ErrorTrackingParseContext([...this.path, key]);
+  }
+  success(value) {
+    return success(value);
+  }
+}
+function wrapInArray(a) {
+  return Array.isArray(a) ? a : [a];
+}
+
+function formatPath(path) {
+  return "(root)" + path.map(formatPathSegment).join("");
+}
+function formatPathSegment(segment) {
+  if (typeof segment === "string") {
+    return validIdentifier.test(segment) ? "." + segment : `[${JSON.stringify(segment)}]`;
+  }
+  return `[${segment.toString()}]`;
+}
+const validIdentifier = /^[A-Za-z$_][A-Za-z$_0-9]*$/;
+
+function message(failure) {
+  const expected = conjoin(failure.expected);
+  const path = formatPath(failure.path);
+  const badValue = JSON.stringify(failure.badValue);
+  return `At ${path} -- expected ${expected}, but got ${badValue}`;
+}
+function conjoin(items) {
+  switch (items.length) {
+    // TODO(benchristel): handle 0 if this is reused elsewhere.
+    case 1:
+      return items[0];
+    case 2:
+      return items.join(" or ");
+    default:
+      {
+        const allButLast = items.slice(0, items.length - 1);
+        const last = items[items.length - 1];
+        return allButLast.join(", ") + ", or " + last;
+      }
+  }
+}
+
+function parse(value, parser) {
+  const result = parser(value, new ErrorTrackingParseContext([]));
+  if (isFailure(result)) {
+    return failure(result.detail.map(message).join("; "));
+  }
+  return result;
+}
+
+const any = (rawValue, ctx) => ctx.success(rawValue);
+
+function array(elementParser) {
+  return (rawValue, ctx) => {
+    if (!Array.isArray(rawValue)) {
+      return ctx.failure("array", rawValue);
+    }
+    const elementResults = rawValue.map((elem, i) => elementParser(elem, ctx.forSubtree(i)));
+    return all(elementResults, concat);
+  };
+}
+function concat(a, b) {
+  return [...a, ...b];
+}
+
+function boolean(rawValue, ctx) {
+  if (typeof rawValue === "boolean") {
+    return ctx.success(rawValue);
+  }
+  return ctx.failure("boolean", rawValue);
+}
+
+function constant(acceptedValue) {
+  return (rawValue, ctx) => {
+    if (rawValue !== acceptedValue) {
+      return ctx.failure(String(JSON.stringify(acceptedValue)), rawValue);
+    }
+    return ctx.success(acceptedValue);
+  };
+}
+
+function enumeration() {
+  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);
+      if (index > -1) {
+        return ctx.success(acceptedValues[index]);
+      }
+    }
+    const expected = acceptedValues.map(v => JSON.stringify(v));
+    return ctx.failure(expected, rawValue);
+  };
+}
+
+function isObject(x) {
+  return x != null && Object.getPrototypeOf(x) === Object.prototype;
+}
+
+function nullable(parseValue) {
+  return (rawValue, ctx) => {
+    if (rawValue === null) {
+      return ctx.success(rawValue);
+    }
+    return parseValue(rawValue, ctx);
+  };
+}
+
+const number = (rawValue, ctx) => {
+  if (typeof rawValue === "number") {
+    return ctx.success(rawValue);
+  }
+  return ctx.failure("number", rawValue);
+};
+
+function object(schema) {
+  return (rawValue, ctx) => {
+    if (!isObject(rawValue)) {
+      return ctx.failure("object", rawValue);
+    }
+    const ret = {
+      ...rawValue
+    };
+    const mismatches = [];
+    for (const [prop, propParser] of Object.entries(schema)) {
+      const result = propParser(rawValue[prop], ctx.forSubtree(prop));
+      if (isSuccess(result)) {
+        if (result.value !== undefined || prop in rawValue) {
+          ret[prop] = result.value;
+        }
+      } else {
+        mismatches.push(...result.detail);
+      }
+    }
+    if (mismatches.length > 0) {
+      return failure(mismatches);
+    }
+    return ctx.success(ret);
+  };
+}
+
+function optional(parseValue) {
+  return (rawValue, ctx) => {
+    if (rawValue === undefined) {
+      return ctx.success(rawValue);
+    }
+    return parseValue(rawValue, ctx);
+  };
+}
+
+function pair(parseA, parseB) {
+  return (rawValue, ctx) => {
+    if (!Array.isArray(rawValue)) {
+      return ctx.failure("array", rawValue);
+    }
+    if (rawValue.length !== 2) {
+      return ctx.failure("array of length 2", rawValue);
+    }
+    const [rawA, rawB] = rawValue;
+    const resultA = parseA(rawA, ctx.forSubtree(0));
+    if (isFailure(resultA)) {
+      return resultA;
+    }
+    const resultB = parseB(rawB, ctx.forSubtree(1));
+    if (isFailure(resultB)) {
+      return resultB;
+    }
+    return ctx.success([resultA.value, resultB.value]);
+  };
+}
+
+function pipeParsers(p) {
+  return new ParserPipeline(p);
+}
+class ParserPipeline {
+  constructor(parser) {
+    this.parser = parser;
+  }
+  then(nextParser) {
+    return new ParserPipeline(composeParsers(this.parser, nextParser));
+  }
+}
+function composeParsers(parserA, parserB) {
+  return (rawValue, ctx) => {
+    const partialResult = parserA(rawValue, ctx);
+    if (isFailure(partialResult)) {
+      return partialResult;
+    }
+    return parserB(partialResult.value, ctx);
+  };
+}
+
+function record(parseKey, parseValue) {
+  return (rawValue, ctx) => {
+    if (!isObject(rawValue)) {
+      return ctx.failure("object", rawValue);
+    }
+    const result = {};
+    const mismatches = [];
+    for (const [key, value] of Object.entries(rawValue)) {
+      const entryCtx = ctx.forSubtree(key);
+      const keyResult = parseKey(key, entryCtx);
+      if (isFailure(keyResult)) {
+        mismatches.push(...keyResult.detail);
+      }
+      const valueResult = parseValue(value, entryCtx);
+      if (isFailure(valueResult)) {
+        mismatches.push(...valueResult.detail);
+      }
+      if (isSuccess(keyResult) && isSuccess(valueResult)) {
+        result[keyResult.value] = valueResult.value;
+      }
+    }
+    if (mismatches.length > 0) {
+      return failure(mismatches);
+    }
+    return ctx.success(result);
+  };
+}
+
+const string = (rawValue, ctx) => {
+  if (typeof rawValue === "string") {
+    return ctx.success(rawValue);
+  }
+  return ctx.failure("string", rawValue);
+};
+
+function trio(parseA, parseB, parseC) {
+  return (rawValue, ctx) => {
+    if (!Array.isArray(rawValue)) {
+      return ctx.failure("array", rawValue);
+    }
+    if (rawValue.length !== 3) {
+      return ctx.failure("array of length 3", rawValue);
+    }
+    const resultA = parseA(rawValue[0], ctx.forSubtree(0));
+    if (isFailure(resultA)) {
+      return resultA;
+    }
+    const resultB = parseB(rawValue[1], ctx.forSubtree(1));
+    if (isFailure(resultB)) {
+      return resultB;
+    }
+    const resultC = parseC(rawValue[2], ctx.forSubtree(2));
+    if (isFailure(resultC)) {
+      return resultC;
+    }
+    return ctx.success([resultA.value, resultB.value, resultC.value]);
+  };
+}
+
+function union(parseBranch) {
+  return new UnionBuilder(parseBranch);
+}
+class UnionBuilder {
+  constructor(parser) {
+    this.parser = parser;
+  }
+  or(newBranch) {
+    return new UnionBuilder(either(this.parser, newBranch));
+  }
+}
+function either(parseA, parseB) {
+  return (rawValue, ctx) => {
+    const resultA = parseA(rawValue, ctx);
+    if (isSuccess(resultA)) {
+      return resultA;
+    }
+    return parseB(rawValue, ctx);
+  };
+}
+
+function defaulted(parser, fallback) {
+  return (rawValue, ctx) => {
+    if (rawValue == null) {
+      return success(fallback(rawValue));
+    }
+    return parser(rawValue, ctx);
+  };
+}
+
+const parseImages = defaulted(record(string, object({
+  width: number,
+  height: number
+})), () => ({}));
+
+function parseWidget(parseType, parseOptions) {
+  return object({
+    type: parseType,
+    static: optional(boolean),
+    graded: optional(boolean),
+    alignment: optional(string),
+    options: parseOptions,
+    key: optional(number),
+    version: optional(object({
+      major: number,
+      minor: number
+    }))
+  });
+}
+function parseWidgetWithVersion(parseVersion, parseType, parseOptions) {
+  return object({
+    type: parseType,
+    static: optional(boolean),
+    graded: optional(boolean),
+    alignment: optional(string),
+    options: parseOptions,
+    key: optional(number),
+    version: parseVersion
+  });
+}
+
+const parseCategorizerWidget = parseWidget(constant("categorizer"), object({
+  items: array(string),
+  categories: array(string),
+  randomizeItems: defaulted(boolean, () => false),
+  static: defaulted(boolean, () => false),
+  values: array(defaulted(number, () => 0)),
+  highlightLint: optional(boolean),
+  linterContext: optional(object({
+    contentType: string,
+    paths: array(string),
+    stack: array(string)
+  }))
+}));
+
+const parseCSProgramWidget = parseWidget(constant("cs-program"), object({
+  programID: string,
+  programType: any,
+  settings: array(object({
+    name: string,
+    value: string
+  })),
+  showEditor: boolean,
+  showButtons: boolean,
+  height: number,
+  static: defaulted(boolean, () => false)
+}));
+
+const parseDefinitionWidget = parseWidget(constant("definition"), object({
+  togglePrompt: string,
+  definition: string,
+  static: defaulted(boolean, () => false)
+}));
+
+const parseDropdownWidget = parseWidget(constant("dropdown"), object({
+  placeholder: defaulted(string, () => ""),
+  ariaLabel: optional(string),
+  visibleLabel: optional(string),
+  static: defaulted(boolean, () => false),
+  choices: array(object({
+    content: string,
+    correct: boolean
+  }))
+}));
+
+const parseExplanationWidget = parseWidget(constant("explanation"), object({
+  showPrompt: string,
+  hidePrompt: string,
+  explanation: string,
+  // We wrap parseWidgetsMap in a function here to make sure it is not
+  // referenced before it is defined. There is an import cycle between
+  // this file and widgets-map.ts that could cause it to be undefined.
+  widgets: defaulted((rawVal, ctx) => parseWidgetsMap(rawVal, ctx), () => ({})),
+  static: defaulted(boolean, () => false)
+}));
+
+// 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));
+}
+
+/**
+ * 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.migrateToLatest = migrateToLatest;
+    this.parseOtherVersions = parseOtherVersions;
+    const parseThisVersionAndMigrateToLatest = pipeParsers(parseThisVersion).then(convert(this.migrateToLatest)).parser;
+    this.parser = (raw, ctx) => {
+      if (!isObject(raw)) {
+        return ctx.failure("object", raw);
+      }
+      const versionParseResult = parseVersionedObject(raw, ctx);
+      if (isFailure(versionParseResult)) {
+        return versionParseResult;
+      }
+      if (versionParseResult.value.version.major !== majorVersion) {
+        return this.parseOtherVersions(raw, ctx);
+      }
+      return parseThisVersionAndMigrateToLatest(raw, ctx);
+    };
+  }
+
+  /**
+   * Add a migration from an old version of the widget options.
+   */
+  withMigrationFrom(majorVersion, parseOldVersion, migrateToNextVersion) {
+    const parseOtherVersions = this.parser;
+    const migrateToLatest = old => this.migrateToLatest(migrateToNextVersion(old));
+    return new VersionedWidgetOptionsParserBuilder(majorVersion, parseOldVersion, migrateToLatest, parseOtherVersions);
+  }
+}
+const parseVersionedObject = object({
+  version: defaulted(object({
+    major: number,
+    minor: number
+  }), () => ({
+    major: 0,
+    minor: 0
+  }))
+});
+
+const stringOrNumberOrNullOrUndefined = union(string).or(number).or(constant(null)).or(constant(undefined)).parser;
+const parsePossiblyInvalidAnswerForm = object({
+  // `value` is the possibly invalid part of this. It should always be a
+  // string, but some answer forms don't have it. The Expression widget
+  // ignores invalid values, so we can safely filter them out during parsing.
+  value: optional(string),
+  form: defaulted(boolean, () => false),
+  simplify: defaulted(boolean, () => false),
+  considered: enumeration("correct", "wrong", "ungraded"),
+  key: pipeParsers(stringOrNumberOrNullOrUndefined).then(convert(String)).parser
+});
+function removeInvalidAnswerForms(possiblyInvalid) {
+  const valid = [];
+  for (const answerForm of possiblyInvalid) {
+    const {
+      value
+    } = answerForm;
+    if (value != null) {
+      // Copying the object seems to be needed to make TypeScript happy
+      valid.push({
+        ...answerForm,
+        value
+      });
+    }
+  }
+  return valid;
+}
+
+// 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.
+const parseButtonSets = defaulted(array(enumeration("basic", "basic+div", "trig", "prealgebra", "logarithms", "basic relations", "advanced relations")), () => ["basic", "trig", "prealgebra", "logarithms"]);
+const version1 = object({
+  major: constant(1),
+  minor: number
+});
+const parseExpressionWidgetV1 = parseWidgetWithVersion(version1, constant("expression"), object({
+  answerForms: pipeParsers(array(parsePossiblyInvalidAnswerForm)).then(convert(removeInvalidAnswerForms)).parser,
+  functions: array(string),
+  times: boolean,
+  visibleLabel: optional(string),
+  ariaLabel: optional(string),
+  buttonSets: parseButtonSets,
+  buttonsVisible: optional(enumeration("always", "never", "focused"))
+}));
+const version0 = optional(object({
+  major: constant(0),
+  minor: number
+}));
+const parseExpressionWidgetV0 = parseWidgetWithVersion(version0, constant("expression"), object({
+  functions: array(string),
+  times: boolean,
+  visibleLabel: optional(string),
+  ariaLabel: optional(string),
+  form: boolean,
+  simplify: boolean,
+  value: string,
+  buttonSets: parseButtonSets,
+  buttonsVisible: optional(enumeration("always", "never", "focused"))
+}));
+function migrateV0ToV1(widget) {
+  const {
+    options
+  } = widget;
+  return {
+    ...widget,
+    version: {
+      major: 1,
+      minor: 0
+    },
+    options: {
+      times: options.times,
+      buttonSets: options.buttonSets,
+      functions: options.functions,
+      buttonsVisible: options.buttonsVisible,
+      visibleLabel: options.visibleLabel,
+      ariaLabel: options.ariaLabel,
+      answerForms: [{
+        considered: "correct",
+        form: options.form,
+        simplify: options.simplify,
+        value: options.value
+      }]
+    }
+  };
+}
+const parseExpressionWidget = versionedWidgetOptions(1, parseExpressionWidgetV1).withMigrationFrom(0, parseExpressionWidgetV0, migrateV0ToV1).parser;
+
+const falseToNull = pipeParsers(constant(false)).then(convert(() => null)).parser;
+const parseGradedGroupWidgetOptions = object({
+  title: defaulted(string, () => ""),
+  hasHint: optional(nullable(boolean)),
+  // This module has an import cycle with parsePerseusRenderer.
+  // The anonymous function below ensures that we don't try to access
+  // parsePerseusRenderer before it's defined.
+  hint: union(falseToNull).or(constant(null)).or(constant(undefined)).or((rawVal, ctx) => parsePerseusRenderer(rawVal, ctx)).parser,
+  content: string,
+  // This module has an import cycle with parseWidgetsMap.
+  // The anonymous function below ensures that we don't try to access
+  // parseWidgetsMap before it's defined.
+  widgets: (rawVal, ctx) => parseWidgetsMap(rawVal, ctx),
+  widgetEnabled: optional(nullable(boolean)),
+  immutableWidgets: optional(nullable(boolean)),
+  images: record(string, object({
+    width: number,
+    height: number
+  }))
+});
+const parseGradedGroupWidget = parseWidget(constant("graded-group"), parseGradedGroupWidgetOptions);
+
+const parseGradedGroupSetWidget = parseWidget(constant("graded-group-set"), object({
+  gradedGroups: array(parseGradedGroupWidgetOptions)
+}));
+
+/**
+ * discriminatedUnion() should be preferred over union() when parsing a
+ * discriminated union type, because discriminatedUnion() produces more
+ * understandable failure messages. It takes the discriminant as the source of
+ * truth for which variant is to be parsed, and expects the other data to match
+ * that variant.
+ */
+function discriminatedUnionOn(discriminantKey) {
+  const noMoreBranches = (raw, ctx) => {
+    if (!isObject(raw)) {
+      return ctx.failure("object", raw);
+    }
+    return ctx.forSubtree(discriminantKey).failure("a valid value", raw[discriminantKey]);
+  };
+  return new DiscriminatedUnionBuilder(discriminantKey, noMoreBranches);
+}
+class DiscriminatedUnionBuilder {
+  constructor(discriminantKey, parser) {
+    this.discriminantKey = discriminantKey;
+    this.parser = parser;
+  }
+  withBranch(discriminantValue, parseNewVariant) {
+    const parseNewBranch = discriminatedUnionBranch(this.discriminantKey, discriminantValue, parseNewVariant, this.parser);
+    return new DiscriminatedUnionBuilder(this.discriminantKey, parseNewBranch);
+  }
+}
+function discriminatedUnionBranch(discriminantKey, discriminantValue, parseVariant, parseOtherBranches) {
+  return (raw, ctx) => {
+    if (!isObject(raw)) {
+      return ctx.failure("object", raw);
+    }
+    if (raw[discriminantKey] === discriminantValue) {
+      return parseVariant(raw, ctx);
+    }
+    return parseOtherBranches(raw, ctx);
+  };
+}
+
+const pairOfNumbers$3 = pair(number, number);
+const pairOfPoints = pair(pairOfNumbers$3, pairOfNumbers$3);
+const parseGrapherWidget = parseWidget(constant("grapher"), object({
+  availableTypes: array(enumeration("absolute_value", "exponential", "linear", "logarithm", "quadratic", "sinusoid", "tangent")),
+  correct: discriminatedUnionOn("type").withBranch("absolute_value", object({
+    type: constant("absolute_value"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("exponential", object({
+    type: constant("exponential"),
+    asymptote: pairOfPoints,
+    coords: nullable(pairOfPoints)
+  })).withBranch("linear", object({
+    type: constant("linear"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("logarithm", object({
+    type: constant("logarithm"),
+    asymptote: pairOfPoints,
+    coords: nullable(pairOfPoints)
+  })).withBranch("quadratic", object({
+    type: constant("quadratic"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("sinusoid", object({
+    type: constant("sinusoid"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("tangent", object({
+    type: constant("tangent"),
+    coords: nullable(pairOfPoints)
+  })).parser,
+  graph: object({
+    backgroundImage: object({
+      bottom: optional(number),
+      height: optional(number),
+      left: optional(number),
+      scale: optional(number),
+      url: optional(nullable(string)),
+      width: optional(number)
+    }),
+    box: optional(pairOfNumbers$3),
+    editableSettings: optional(array(enumeration("graph", "snap", "image", "measure"))),
+    gridStep: optional(pairOfNumbers$3),
+    labels: pair(string, string),
+    markings: enumeration("graph", "none", "grid"),
+    range: pair(pairOfNumbers$3, pairOfNumbers$3),
+    rulerLabel: constant(""),
+    rulerTicks: number,
+    showProtractor: optional(boolean),
+    showRuler: optional(boolean),
+    showTooltips: optional(boolean),
+    snapStep: optional(pairOfNumbers$3),
+    step: pairOfNumbers$3,
+    valid: optional(union(boolean).or(string).parser)
+  })
+}));
+
+const parseGroupWidget = parseWidget(constant("group"),
+// This module has an import cycle with parsePerseusRenderer.
+// The anonymous function below ensures that we don't try to access
+// parsePerseusRenderer before it's defined.
+(rawVal, ctx) => parsePerseusRenderer(rawVal, ctx));
+
+const parseIframeWidget = parseWidget(constant("iframe"), object({
+  url: string,
+  settings: optional(array(object({
+    name: string,
+    value: string
+  }))),
+  width: union(number).or(string).parser,
+  height: union(number).or(string).parser,
+  allowFullScreen: defaulted(boolean, () => false),
+  allowTopNavigation: optional(boolean),
+  static: defaulted(boolean, () => false)
+}));
+
+const stringToNumber = (rawValue, ctx) => {
+  if (typeof rawValue === "number") {
+    return ctx.success(rawValue);
+  }
+  const parsedNumber = +rawValue;
+  if (rawValue === "" || isNaN(parsedNumber)) {
+    return ctx.failure("a number or numeric string", rawValue);
+  }
+  return ctx.success(parsedNumber);
+};
+
+function emptyToZero(x) {
+  return x === "" ? 0 : x;
+}
+const imageDimensionToNumber = pipeParsers(union(number).or(string).parser)
+// In this specific case, empty string is equivalent to zero. An empty
+// string parses to either NaN (using parseInt) or 0 (using unary +) and
+// CSS will treat NaN as invalid and default to 0 instead.
+.then(convert(emptyToZero)).then(stringToNumber).parser;
+const parsePerseusImageBackground = object({
+  url: optional(nullable(string)),
+  width: optional(imageDimensionToNumber),
+  height: optional(imageDimensionToNumber),
+  top: optional(imageDimensionToNumber),
+  left: optional(imageDimensionToNumber),
+  bottom: optional(imageDimensionToNumber),
+  scale: optional(imageDimensionToNumber)
+});
+
+const pairOfNumbers$2 = pair(number, number);
+const parseImageWidget = parseWidget(constant("image"), object({
+  title: optional(string),
+  caption: optional(string),
+  alt: optional(string),
+  backgroundImage: parsePerseusImageBackground,
+  static: optional(boolean),
+  labels: optional(array(object({
+    content: string,
+    alignment: string,
+    coordinates: array(number)
+  }))),
+  range: optional(pair(pairOfNumbers$2, pairOfNumbers$2)),
+  box: optional(pairOfNumbers$2)
+}));
+
+const booleanToString = (rawValue, ctx) => {
+  if (typeof rawValue === "boolean") {
+    return ctx.success(String(rawValue));
+  }
+  return ctx.failure("boolean", rawValue);
+};
+const parseInputNumberWidget = parseWidget(constant("input-number"), object({
+  answerType: optional(enumeration("number", "decimal", "integer", "rational", "improper", "mixed", "percent", "pi")),
+  inexact: optional(boolean),
+  maxError: optional(union(number).or(string).parser),
+  rightAlign: optional(boolean),
+  simplify: enumeration("required", "optional", "enforced"),
+  size: enumeration("normal", "small"),
+  // TODO(benchristel): there are some content items where value is a
+  // boolean, even though that makes no sense. We should figure out if
+  // those content items are actually published anywhere, and consider
+  // updating them.
+  value: union(number).or(string).or(booleanToString).parser,
+  customKeypad: optional(boolean)
+}));
+
+const pairOfNumbers$1 = pair(number, number);
+const stringOrEmpty = defaulted(string, () => "");
+const parseKey = pipeParsers(optional(string)).then(convert(String)).parser;
+const parseFunctionElement = object({
+  type: constant("function"),
+  key: parseKey,
+  options: object({
+    value: string,
+    funcName: string,
+    rangeMin: string,
+    rangeMax: string,
+    color: string,
+    strokeDasharray: string,
+    strokeWidth: number
+  })
+});
+const parseLabelElement = object({
+  type: constant("label"),
+  key: parseKey,
+  options: object({
+    label: string,
+    color: string,
+    coordX: string,
+    coordY: string
+  })
+});
+const parseLineElement = object({
+  type: constant("line"),
+  key: parseKey,
+  options: object({
+    color: string,
+    startX: string,
+    startY: string,
+    endX: string,
+    endY: string,
+    strokeDasharray: string,
+    strokeWidth: number,
+    arrows: string
+  })
+});
+const parseMovableLineElement = object({
+  type: constant("movable-line"),
+  key: parseKey,
+  options: object({
+    startX: string,
+    startY: string,
+    startSubscript: number,
+    endX: string,
+    endY: string,
+    endSubscript: number,
+    constraint: string,
+    snap: number,
+    constraintFn: string,
+    constraintXMin: string,
+    constraintXMax: string,
+    constraintYMin: string,
+    constraintYMax: string
+  })
+});
+const parseMovablePointElement = object({
+  type: constant("movable-point"),
+  key: parseKey,
+  options: object({
+    startX: string,
+    startY: string,
+    varSubscript: number,
+    constraint: string,
+    snap: number,
+    constraintFn: string,
+    constraintXMin: stringOrEmpty,
+    constraintXMax: stringOrEmpty,
+    constraintYMin: stringOrEmpty,
+    constraintYMax: stringOrEmpty
+  })
+});
+const parseParametricElement = object({
+  type: constant("parametric"),
+  key: parseKey,
+  options: object({
+    x: string,
+    y: string,
+    rangeMin: string,
+    rangeMax: string,
+    color: string,
+    strokeDasharray: string,
+    strokeWidth: number
+  })
+});
+const parsePointElement = object({
+  type: constant("point"),
+  key: parseKey,
+  options: object({
+    color: string,
+    coordX: string,
+    coordY: string
+  })
+});
+const parseRectangleElement = object({
+  type: constant("rectangle"),
+  key: parseKey,
+  options: object({
+    color: string,
+    coordX: string,
+    coordY: string,
+    width: string,
+    height: string
+  })
+});
+const parseInteractionWidget = parseWidget(constant("interaction"), object({
+  static: defaulted(boolean, () => false),
+  graph: object({
+    editableSettings: optional(array(enumeration("canvas", "graph"))),
+    box: pairOfNumbers$1,
+    labels: array(string),
+    range: pair(pairOfNumbers$1, pairOfNumbers$1),
+    gridStep: pairOfNumbers$1,
+    markings: enumeration("graph", "grid", "none"),
+    snapStep: optional(pairOfNumbers$1),
+    valid: optional(union(boolean).or(string).parser),
+    backgroundImage: optional(parsePerseusImageBackground),
+    showProtractor: optional(boolean),
+    showRuler: optional(boolean),
+    rulerLabel: optional(string),
+    rulerTicks: optional(number),
+    tickStep: pairOfNumbers$1
+  }),
+  elements: array(discriminatedUnionOn("type").withBranch("function", parseFunctionElement).withBranch("label", parseLabelElement).withBranch("line", parseLineElement).withBranch("movable-line", parseMovableLineElement).withBranch("movable-point", parseMovablePointElement).withBranch("parametric", parseParametricElement).withBranch("point", parsePointElement).withBranch("rectangle", parseRectangleElement).parser)
+}));
+
+/**
+ * The Perseus "data schema" file.
+ *
+ * This file, and the types in it, represents the "data schema" that Perseus
+ * uses. The @khanacademy/perseus-editor package edits and produces objects
+ * that conform to the types in this file. Similarly, the top-level renderers
+ * in @khanacademy/perseus, consume objects that conform to these types.
+ *
+ * WARNING: This file should not import any types from elsewhere so that it is
+ * easy to reason about changes that alter the Perseus schema. This helps
+ * ensure that it is not changed accidentally when upgrading a dependant
+ * package or other part of Perseus code. Note that TypeScript does type
+ * checking via something called "structural typing". This means that as long
+ * as the shape of a type matches, the name it goes by doesn't matter. As a
+ * result, a `Coord` type that looks like this `[x: number, y: number]` is
+ * _identical_, in TypeScript's eyes, to this `Vector2` type `[x: number, y:
+ * number]`. Also, with tuples, the labels for each entry is ignored, so `[x:
+ * number, y: number]` is compatible with `[min: number, max: number]`. The
+ * labels are for humans, not TypeScript. :)
+ *
+ * If you make changes to types in this file, be very sure that:
+ *
+ *   a) the changes are backwards compatible. If they are not, old data from
+ *      previous versions of the "schema" could become unrenderable, or worse,
+ *      introduce hard-to-diagnose bugs.
+ *   b) the parsing code (`util/parse-perseus-json/`) is updated to handle
+ *      the new format _as well as_ the old format.
+ */
+
+// TODO(FEI-4010): Remove `Perseus` prefix for all types here
+
+// Same name as Mafs
+
+/**
+ * A utility type that constructs a widget map from a "registry interface".
+ * The keys of the registry should be the widget type (aka, "categorizer" or
+ * "radio", etc) and the value should be the option type stored in the value
+ * of the map.
+ *
+ * You can think of this as a type that generates another type. We use
+ * "registry interfaces" as a way to keep a set of widget types to their data
+ * type in several places in Perseus. This type then allows us to generate a
+ * map type that maps a widget id to its data type and keep strong typing by
+ * widget id.
+ *
+ * For example, given a fictitious registry such as this:
+ *
+ * ```
+ * interface DummyRegistry {
+ *     categorizer: { categories: ReadonlyArray<string> };
+ *     dropdown: { choices: ReadonlyArray<string> }:
+ * }
+ * ```
+ *
+ * If we create a DummyMap using this helper:
+ *
+ * ```
+ * type DummyMap = MakeWidgetMap<DummyRegistry>;
+ * ```
+ *
+ * We'll get a map that looks like this:
+ *
+ * ```
+ * type DummyMap = {
+ *     `categorizer ${number}`: { categories: ReadonlyArray<string> };
+ *     `dropdown ${number}`: { choices: ReadonlyArray<string> };
+ * }
+ * ```
+ *
+ * We use interfaces for the registries so that they can be extended in cases
+ * where the consuming app brings along their own widgets. Interfaces in
+ * TypeScript are always open (ie. you can extend them) whereas types aren't.
+ */
+
+/**
+ * Our core set of Perseus widgets.
+ *
+ * This interface is the basis for "registering" all Perseus widget types.
+ * There should be one key/value pair for each supported widget. If you create
+ * a new widget, an entry should be added to this interface. Note that this
+ * only registers the widget options type, you'll also need to register the
+ * widget so that it's available at runtime (@see
+ * {@link file://./widgets.ts#registerWidget}).
+ *
+ * Importantly, the key should be the name that is used in widget IDs. For most
+ * widgets that is the same as the widget option's `type` field. In cases where
+ * a widget has been deprecated and replaced with the deprecated-standin
+ * widget, it should be the original widget type!
+ *
+ * If you define the widget outside of this package, you can still add the new
+ * widget to this interface by writing the following in that package that
+ * contains the widget. TypeScript will merge that definition of the
+ * `PerseusWidgets` with the one defined below.
+ *
+ * ```typescript
+ * declare module "@khanacademy/perseus-core" {
+ *     interface PerseusWidgetTypes {
+ *         // A new widget
+ *         "new-awesomeness": MyAwesomeNewWidget;
+ *
+ *         // A deprecated widget
+ *         "super-old-widget": DeprecatedStandinWidget;
+ *     }
+ * }
+ *
+ * // The new widget's options definition
+ * type MyAwesomeNewWidget = WidgetOptions<'new-awesomeness', MyAwesomeNewWidgetOptions>;
+ *
+ * // The deprecated widget's options definition
+ * type SuperOldWidget = WidgetOptions<'super-old-widget', object>;
+ * ```
+ *
+ * This interface can be extended through the magic of TypeScript "Declaration
+ * merging". Specifically, we augment this module and extend this interface.
+ *
+ * @see {@link https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation}
+ */
+
+/**
+ * A map of widget IDs to widget options. This is most often used as the type
+ * for a set of widgets defined in a `PerseusItem` but can also be useful to
+ * represent a function parameter where only `widgets` from a `PerseusItem` are
+ * needed. Today Widget IDs are made up of the widget type and an incrementing
+ * integer (eg. `interactive-graph 1` or `radio 3`). It is suggested to avoid
+ * reading/parsing the widget id to derive any information from it, except in
+ * the case of this map.
+ *
+ * @see {@link PerseusWidgetTypes} additional widgets can be added to this map type
+ * by augmenting the PerseusWidgetTypes with new widget types!
+ */
+
+/**
+ * PerseusWidget is a union of all the different types of widget options that
+ * Perseus knows about.
+ *
+ * Thanks to it being based on PerseusWidgetTypes interface, this union is
+ * automatically extended to include widgets used in tests without those widget
+ * option types seeping into our production types.
+ *
+ * @see MockWidget for an example
+ */
+
+/**
+ * A "PerseusItem" is a classic Perseus item. It is rendered by the
+ * `ServerItemRenderer` and the layout is pre-set.
+ *
+ * To render more complex Perseus items, see the `Item` type in the multi item
+ * area.
+ */
+
+/**
+ * A "PerseusArticle" is an item that is meant to be rendered as an article.
+ * This item is never scored and is rendered by the `ArticleRenderer`.
+ */
+
+const ItemExtras = [
+// The user might benefit from using a Scientific Calculator.  Provided on Khan Academy when true
+"calculator",
+// The user might benefit from using a statistics Chi Squared Table like https://people.richland.edu/james/lecture/m170/tbl-chi.html
+"chi2Table",
+// The user might benefit from a monthly payments calculator.  Provided on Khan Academy when true
+"financialCalculatorMonthlyPayment",
+// The user might benefit from a total amount calculator.  Provided on Khan Academy when true
+"financialCalculatorTotalAmount",
+// The user might benefit from a time to pay off calculator.  Provided on Khan Academy when true
+"financialCalculatorTimeToPayOff",
+// The user might benefit from using a Periodic Table of Elements.  Provided on Khan Academy when true
+"periodicTable",
+// The user might benefit from using a Periodic Table of Elements with key.  Provided on Khan Academy when true
+"periodicTableWithKey",
+// The user might benefit from using a statistics T Table like https://www.statisticshowto.com/tables/t-distribution-table/
+"tTable",
+// The user might benefit from using a statistics Z Table like https://www.ztable.net/
+"zTable"];
+
+/**
+ * The type representing the common structure of all widget's options. The
+ * `Options` generic type represents the widget-specific option data.
+ */
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+//prettier-ignore
+
+/**
+ * A background image applied to various widgets.
+ */
+
+/**
+ * The type of markings to display on the graph.
+ * - axes: shows the axes without the gride lines
+ * - graph: shows the axes and the grid lines
+ * - grid: shows only the grid lines
+ * - none: shows no markings
+ */
+
+const PerseusExpressionAnswerFormConsidered = ["correct", "wrong", "ungraded"];
+
+// 2D range: xMin, xMax, yMin, yMax
+
+const lockedFigureColorNames = ["blue", "green", "grayH", "purple", "pink", "orange", "red"];
+const lockedFigureColors = {
+  blue: "#3D7586",
+  green: "#447A53",
+  grayH: "#3B3D45",
+  purple: "#594094",
+  pink: "#B25071",
+  red: "#D92916",
+  orange: "#946700"
+};
+const lockedFigureFillStyles = {
+  none: 0,
+  white: 1,
+  translucent: 0.4,
+  solid: 1
+};
+
+// Not associated with a specific figure
+
+const plotterPlotTypes = ["bar", "line", "pic", "histogram", "dotplot"];
+
+// Used to represent 2-D points and ranges
+const pairOfNumbers = pair(number, number);
+const parsePerseusGraphTypeAngle = object({
+  type: constant("angle"),
+  showAngles: optional(boolean),
+  allowReflexAngles: optional(boolean),
+  angleOffsetDeg: optional(number),
+  snapDegrees: optional(number),
+  match: optional(constant("congruent")),
+  coords: optional(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers)),
+  startCoords: optional(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers))
+});
+const parsePerseusGraphTypeCircle = object({
+  type: constant("circle"),
+  center: optional(pairOfNumbers),
+  radius: optional(number),
+  startCoords: optional(object({
+    center: pairOfNumbers,
+    radius: number
+  })),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeLinear = object({
+  type: constant("linear"),
+  coords: optional(nullable(pair(pairOfNumbers, pairOfNumbers))),
+  startCoords: optional(pair(pairOfNumbers, pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeLinearSystem = object({
+  type: constant("linear-system"),
+  // TODO(benchristel): default coords to empty array?
+  coords: optional(nullable(array(pair(pairOfNumbers, pairOfNumbers)))),
+  startCoords: optional(array(pair(pairOfNumbers, pairOfNumbers))),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeNone = object({
+  type: constant("none")
+});
+const parsePerseusGraphTypePoint = object({
+  type: constant("point"),
+  numPoints: optional(union(number).or(constant("unlimited")).parser),
+  coords: optional(nullable(array(pairOfNumbers))),
+  startCoords: optional(array(pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypePolygon = object({
+  type: constant("polygon"),
+  numSides: optional(union(number).or(constant("unlimited")).parser),
+  showAngles: optional(boolean),
+  showSides: optional(boolean),
+  snapTo: optional(enumeration("grid", "angles", "sides")),
+  match: optional(enumeration("similar", "congruent", "approx", "exact")),
+  startCoords: optional(array(pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeQuadratic = object({
+  type: constant("quadratic"),
+  coords: optional(nullable(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers))),
+  startCoords: optional(trio(pairOfNumbers, pairOfNumbers, pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeRay = object({
+  type: constant("ray"),
+  coords: optional(nullable(pair(pairOfNumbers, pairOfNumbers))),
+  startCoords: optional(pair(pairOfNumbers, pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeSegment = object({
+  type: constant("segment"),
+  // TODO(benchristel): default numSegments?
+  numSegments: optional(number),
+  coords: optional(nullable(array(pair(pairOfNumbers, pairOfNumbers)))),
+  startCoords: optional(array(pair(pairOfNumbers, pairOfNumbers))),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphTypeSinusoid = object({
+  type: constant("sinusoid"),
+  coords: optional(nullable(array(pairOfNumbers))),
+  startCoords: optional(array(pairOfNumbers)),
+  // TODO: remove coord? it's legacy.
+  coord: optional(pairOfNumbers)
+});
+const parsePerseusGraphType = discriminatedUnionOn("type").withBranch("angle", parsePerseusGraphTypeAngle).withBranch("circle", parsePerseusGraphTypeCircle).withBranch("linear", parsePerseusGraphTypeLinear).withBranch("linear-system", parsePerseusGraphTypeLinearSystem).withBranch("none", parsePerseusGraphTypeNone).withBranch("point", parsePerseusGraphTypePoint).withBranch("polygon", parsePerseusGraphTypePolygon).withBranch("quadratic", parsePerseusGraphTypeQuadratic).withBranch("ray", parsePerseusGraphTypeRay).withBranch("segment", parsePerseusGraphTypeSegment).withBranch("sinusoid", parsePerseusGraphTypeSinusoid).parser;
+const parseLockedFigureColor = enumeration(...lockedFigureColorNames);
+const parseLockedFigureFillType = enumeration("none", "white", "translucent", "solid");
+const parseLockedLineStyle = enumeration("solid", "dashed");
+const parseLockedLabelType = object({
+  type: constant("label"),
+  coord: pairOfNumbers,
+  text: string,
+  color: parseLockedFigureColor,
+  size: enumeration("small", "medium", "large")
+});
+const parseLockedPointType = object({
+  type: constant("point"),
+  coord: pairOfNumbers,
+  color: parseLockedFigureColor,
+  filled: boolean,
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+const parseLockedLineType = object({
+  type: constant("line"),
+  kind: enumeration("line", "ray", "segment"),
+  points: pair(parseLockedPointType, parseLockedPointType),
+  color: parseLockedFigureColor,
+  lineStyle: parseLockedLineStyle,
+  showPoint1: defaulted(boolean, () => false),
+  showPoint2: defaulted(boolean, () => false),
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+const parseLockedVectorType = object({
+  type: constant("vector"),
+  points: pair(pairOfNumbers, pairOfNumbers),
+  color: parseLockedFigureColor,
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+const parseLockedEllipseType = object({
+  type: constant("ellipse"),
+  center: pairOfNumbers,
+  radius: pairOfNumbers,
+  angle: number,
+  color: parseLockedFigureColor,
+  fillStyle: parseLockedFigureFillType,
+  strokeStyle: parseLockedLineStyle,
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+const parseLockedPolygonType = object({
+  type: constant("polygon"),
+  points: array(pairOfNumbers),
+  color: parseLockedFigureColor,
+  showVertices: boolean,
+  fillStyle: parseLockedFigureFillType,
+  strokeStyle: parseLockedLineStyle,
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+const parseLockedFunctionType = object({
+  type: constant("function"),
+  color: parseLockedFigureColor,
+  strokeStyle: parseLockedLineStyle,
+  equation: string,
+  directionalAxis: enumeration("x", "y"),
+  domain: optional(pairOfNumbers),
+  // TODO(benchristel): default labels to empty array?
+  labels: optional(array(parseLockedLabelType)),
+  ariaLabel: optional(string)
+});
+const parseLockedFigure = discriminatedUnionOn("type").withBranch("point", parseLockedPointType).withBranch("line", parseLockedLineType).withBranch("vector", parseLockedVectorType).withBranch("ellipse", parseLockedEllipseType).withBranch("polygon", parseLockedPolygonType).withBranch("function", parseLockedFunctionType).withBranch("label", parseLockedLabelType).parser;
+const parseInteractiveGraphWidget = parseWidget(constant("interactive-graph"), object({
+  step: pairOfNumbers,
+  // TODO(benchristel): rather than making gridStep and snapStep
+  // optional, we should duplicate the defaulting logic from the
+  // InteractiveGraph component. See parse-perseus-json/README.md for
+  // why.
+  gridStep: optional(pairOfNumbers),
+  snapStep: optional(pairOfNumbers),
+  backgroundImage: optional(parsePerseusImageBackground),
+  markings: enumeration("graph", "grid", "none"),
+  labels: optional(array(string)),
+  showProtractor: boolean,
+  showRuler: optional(boolean),
+  showTooltips: optional(boolean),
+  rulerLabel: optional(string),
+  rulerTicks: optional(number),
+  range: pair(pairOfNumbers, pairOfNumbers),
+  // NOTE(benchristel): I copied the default graph from
+  // interactive-graph.tsx. See the parse-perseus-json/README.md for
+  // an explanation of why we want to duplicate the default here.
+  graph: defaulted(parsePerseusGraphType, () => ({
+    type: "linear"
+  })),
+  correct: parsePerseusGraphType,
+  // TODO(benchristel): default lockedFigures to empty array
+  lockedFigures: optional(array(parseLockedFigure)),
+  fullGraphLabel: optional(string),
+  fullGraphAriaDescription: optional(string)
+}));
+
+const parseLabelImageWidget = parseWidget(constant("label-image"), object({
+  choices: array(string),
+  imageUrl: string,
+  imageAlt: string,
+  imageHeight: number,
+  imageWidth: number,
+  markers: array(object({
+    answers: array(string),
+    label: string,
+    x: number,
+    y: number
+  })),
+  hideChoicesFromInstructions: boolean,
+  multipleAnswers: boolean,
+  static: defaulted(boolean, () => false)
+}));
+
+const parseMatcherWidget = parseWidget(constant("matcher"), object({
+  labels: array(string),
+  left: array(string),
+  right: array(string),
+  orderMatters: boolean,
+  padding: boolean
+}));
+
+const numberOrString = union(number).or(string).parser;
+const numeric = pipeParsers(defaulted(numberOrString, () => NaN)).then(stringToNumber).parser;
+const parseMatrixWidget = parseWidget(defaulted(constant("matrix"), () => "matrix"), object({
+  prefix: optional(string),
+  suffix: optional(string),
+  answers: array(array(numeric)),
+  cursorPosition: optional(array(number)),
+  matrixBoardSize: array(number),
+  static: optional(boolean)
+}));
+
+const parseMeasurerWidget = parseWidget(constant("measurer"), object({
+  // The default value for image comes from measurer.tsx.
+  // See parse-perseus-json/README.md for why we want to duplicate the
+  // defaults here.
+  image: defaulted(parsePerseusImageBackground, () => ({
+    url: null,
+    top: 0,
+    left: 0
+  })),
+  showProtractor: boolean,
+  showRuler: boolean,
+  rulerLabel: string,
+  rulerTicks: number,
+  rulerPixels: number,
+  rulerLength: number,
+  box: pair(number, number),
+  // TODO(benchristel): static is not used. Remove it?
+  static: defaulted(boolean, () => false)
+}));
+
+const parseMoleculeRendererWidget = parseWidget(constant("molecule-renderer"), object({
+  widgetId: string,
+  rotationAngle: optional(number),
+  smiles: optional(string)
+}));
+
+const emptyStringToNull = pipeParsers(constant("")).then(convert(() => null)).parser;
+const parseNumberLineWidget = parseWidget(constant("number-line"), object({
+  range: array(number),
+  labelRange: array(nullable(union(number).or(emptyStringToNull).parser)),
+  labelStyle: string,
+  labelTicks: boolean,
+  isTickCtrl: optional(nullable(boolean)),
+  divisionRange: array(number),
+  numDivisions: optional(nullable(number)),
+  // NOTE(benchristel): I copied the default snapDivisions from
+  // number-line.tsx. See the parse-perseus-json/README.md for
+  // an explanation of why we want to duplicate the default here.
+  snapDivisions: defaulted(number, () => 2),
+  tickStep: optional(nullable(number)),
+  correctRel: optional(nullable(string)),
+  correctX: nullable(number),
+  initialX: optional(nullable(number)),
+  showTooltips: optional(boolean),
+  static: defaulted(boolean, () => false)
+}));
+
+const parseMathFormat = enumeration("integer", "mixed", "improper", "proper", "decimal", "percent", "pi");
+const 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: optional(array(parseMathFormat)),
+    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: optional(nullable(union(string).or(pipeParsers(boolean).then(convert(String)).parser).parser))
+  })),
+  labelText: optional(string),
+  size: string,
+  coefficient: defaulted(boolean, () => false),
+  rightAlign: optional(boolean),
+  static: defaulted(boolean, () => false),
+  answerForms: optional(array(object({
+    name: parseMathFormat,
+    simplify: optional(nullable(enumeration("required", "correct", "enforced", "optional")))
+  })))
+}));
+
+// There is an import cycle between orderer-widget.ts and perseus-renderer.ts.
+// This wrapper ensures that we don't refer to parsePerseusRenderer before
+// it's defined.
+function parseRenderer(rawValue, ctx) {
+  return parsePerseusRenderer(rawValue, ctx);
+}
+const largeToAuto = (height, ctx) => {
+  if (height === "large") {
+    return ctx.success("auto");
+  }
+  return ctx.success(height);
+};
+const parseOrdererWidget = parseWidget(constant("orderer"), object({
+  options: defaulted(array(parseRenderer), () => []),
+  correctOptions: array(parseRenderer),
+  otherOptions: array(parseRenderer),
+  height: pipeParsers(enumeration("normal", "auto", "large")).then(largeToAuto).parser,
+  layout: defaulted(enumeration("horizontal", "vertical"), () => "horizontal")
+}));
+
+const parsePassageRefWidget = parseWidget(constant("passage-ref"), object({
+  passageNumber: number,
+  referenceNumber: number,
+  summaryText: optional(string)
+}));
+
+const parsePassageWidget = parseWidget(constant("passage"), object({
+  footnotes: defaulted(string, () => ""),
+  passageText: string,
+  passageTitle: defaulted(string, () => ""),
+  showLineNumbers: boolean,
+  static: defaulted(boolean, () => false)
+}));
+
+const parsePhetSimulationWidget = parseWidget(constant("phet-simulation"), object({
+  url: string,
+  description: string
+}));
+
+const parsePlotterWidget = parseWidget(constant("plotter"), object({
+  labels: array(string),
+  categories: array(string),
+  type: enumeration(...plotterPlotTypes),
+  maxY: number,
+  // The default value for scaleY comes from plotter.tsx.
+  // See parse-perseus-json/README.md for why we want to duplicate the
+  // defaults here.
+  scaleY: defaulted(number, () => 1),
+  labelInterval: optional(nullable(number)),
+  // The default value for snapsPerLine comes from plotter.tsx.
+  // See parse-perseus-json/README.md for why we want to duplicate the
+  // defaults here.
+  snapsPerLine: defaulted(number, () => 2),
+  starting: array(number),
+  correct: array(number),
+  picUrl: optional(nullable(string)),
+  picSize: optional(nullable(number)),
+  picBoxHeight: optional(nullable(number)),
+  // NOTE(benchristel): I copied the default plotDimensions from
+  // plotter.tsx. See the parse-perseus-json/README.md for an explanation
+  // of why we want to duplicate the defaults here.
+  plotDimensions: defaulted(array(number), () => [380, 300])
+}));
+
+const parsePythonProgramWidget = parseWidget(constant("python-program"), object({
+  programID: string,
+  height: number
+}));
+
+const parseRadioWidget = parseWidget(constant("radio"), object({
+  choices: array(object({
+    content: defaulted(string, () => ""),
+    clue: optional(string),
+    correct: optional(boolean),
+    isNoneOfTheAbove: optional(boolean),
+    // deprecated
+    // There is an import cycle between radio-widget.ts and
+    // widgets-map.ts. The anonymous function below ensures that we
+    // don't refer to parseWidgetsMap before it's defined.
+    widgets: optional((rawVal, ctx) => parseWidgetsMap(rawVal, ctx))
+  })),
+  hasNoneOfTheAbove: optional(boolean),
+  countChoices: optional(boolean),
+  randomize: optional(boolean),
+  multipleSelect: optional(boolean),
+  deselectEnabled: optional(boolean),
+  // deprecated
+  onePerLine: optional(boolean),
+  // deprecated
+  displayCount: optional(any),
+  // v0 props
+  // `noneOfTheAbove` is still in use (but only set to `false`).
+  noneOfTheAbove: optional(constant(false))
+}));
+
+const parseSorterWidget = parseWidget(constant("sorter"), object({
+  correct: array(string),
+  padding: boolean,
+  layout: enumeration("horizontal", "vertical")
+}));
+
+const parseTableWidget = parseWidget(constant("table"), object({
+  headers: array(string),
+  rows: number,
+  columns: number,
+  answers: array(array(string))
+}));
+
+const parseVideoWidget = parseWidget(constant("video"), object({
+  location: string,
+  static: optional(boolean)
+}));
+
+const parseWidgetsMap = (rawValue, ctx) => {
+  if (!isObject(rawValue)) {
+    return ctx.failure("PerseusWidgetsMap", rawValue);
+  }
+  const widgetsMap = {};
+  for (const key of Object.keys(rawValue)) {
+    // parseWidgetsMapEntry modifies the widgetsMap. This is kind of gross,
+    // but it's the only way I could find to make TypeScript check the key
+    // against the widget type.
+    const entryResult = parseWidgetsMapEntry([key, rawValue[key]], widgetsMap, ctx.forSubtree(key));
+    if (isFailure(entryResult)) {
+      return entryResult;
+    }
+  }
+  return ctx.success(widgetsMap);
+};
+const parseWidgetsMapEntry = (_ref, widgetMap, ctx) => {
+  let [id, widget] = _ref;
+  const idComponentsResult = parseWidgetIdComponents(id.split(" "), ctx.forSubtree("(widget ID)"));
+  if (isFailure(idComponentsResult)) {
+    return idComponentsResult;
+  }
+  const [type, n] = idComponentsResult.value;
+  function parseAndAssign(key, parse) {
+    const widgetResult = parse(widget, ctx);
+    if (isFailure(widgetResult)) {
+      return widgetResult;
+    }
+    widgetMap[key] = widgetResult.value;
+    return ctx.success(undefined);
+  }
+  switch (type) {
+    case "categorizer":
+      return parseAndAssign(`categorizer ${n}`, parseCategorizerWidget);
+    case "cs-program":
+      return parseAndAssign(`cs-program ${n}`, parseCSProgramWidget);
+    case "definition":
+      return parseAndAssign(`definition ${n}`, parseDefinitionWidget);
+    case "dropdown":
+      return parseAndAssign(`dropdown ${n}`, parseDropdownWidget);
+    case "explanation":
+      return parseAndAssign(`explanation ${n}`, parseExplanationWidget);
+    case "expression":
+      return parseAndAssign(`expression ${n}`, parseExpressionWidget);
+    case "grapher":
+      return parseAndAssign(`grapher ${n}`, parseGrapherWidget);
+    case "group":
+      return parseAndAssign(`group ${n}`, parseGroupWidget);
+    case "graded-group":
+      return parseAndAssign(`graded-group ${n}`, parseGradedGroupWidget);
+    case "graded-group-set":
+      return parseAndAssign(`graded-group-set ${n}`, parseGradedGroupSetWidget);
+    case "iframe":
+      return parseAndAssign(`iframe ${n}`, parseIframeWidget);
+    case "image":
+      return parseAndAssign(`image ${n}`, parseImageWidget);
+    case "input-number":
+      return parseAndAssign(`input-number ${n}`, parseInputNumberWidget);
+    case "interaction":
+      return parseAndAssign(`interaction ${n}`, parseInteractionWidget);
+    case "interactive-graph":
+      return parseAndAssign(`interactive-graph ${n}`, parseInteractiveGraphWidget);
+    case "label-image":
+      return parseAndAssign(`label-image ${n}`, parseLabelImageWidget);
+    case "matcher":
+      return parseAndAssign(`matcher ${n}`, parseMatcherWidget);
+    case "matrix":
+      return parseAndAssign(`matrix ${n}`, parseMatrixWidget);
+    case "measurer":
+      return parseAndAssign(`measurer ${n}`, parseMeasurerWidget);
+    case "molecule-renderer":
+      return parseAndAssign(`molecule-renderer ${n}`, parseMoleculeRendererWidget);
+    case "number-line":
+      return parseAndAssign(`number-line ${n}`, parseNumberLineWidget);
+    case "numeric-input":
+      return parseAndAssign(`numeric-input ${n}`, parseNumericInputWidget);
+    case "orderer":
+      return parseAndAssign(`orderer ${n}`, parseOrdererWidget);
+    case "passage":
+      return parseAndAssign(`passage ${n}`, parsePassageWidget);
+    case "passage-ref":
+      return parseAndAssign(`passage-ref ${n}`, parsePassageRefWidget);
+    case "passage-ref-target":
+      // NOTE(benchristel): as of 2024-11-12, passage-ref-target is only
+      // used in test content. See:
+      // https://www.khanacademy.org/devadmin/content/search?query=widget:passage-ref-target
+      return parseAndAssign(`passage-ref-target ${n}`, any);
+    case "phet-simulation":
+      return parseAndAssign(`phet-simulation ${n}`, parsePhetSimulationWidget);
+    case "plotter":
+      return parseAndAssign(`plotter ${n}`, parsePlotterWidget);
+    case "python-program":
+      return parseAndAssign(`python-program ${n}`, parsePythonProgramWidget);
+    case "radio":
+      return parseAndAssign(`radio ${n}`, parseRadioWidget);
+    case "sorter":
+      return parseAndAssign(`sorter ${n}`, parseSorterWidget);
+    case "table":
+      return parseAndAssign(`table ${n}`, parseTableWidget);
+    case "video":
+      return parseAndAssign(`video ${n}`, parseVideoWidget);
+    case "sequence":
+      // sequence is a deprecated widget type, and the corresponding
+      // widget component no longer exists.
+      return parseAndAssign(`sequence ${n}`, parseDeprecatedWidget);
+    case "lights-puzzle":
+      return parseAndAssign(`lights-puzzle ${n}`, parseDeprecatedWidget);
+    case "simulator":
+      return parseAndAssign(`simulator ${n}`, parseDeprecatedWidget);
+    case "transformer":
+      return parseAndAssign(`transformer ${n}`, parseDeprecatedWidget);
+    default:
+      return parseAndAssign(`${type} ${n}`, parseWidget(constant(type), any));
+  }
+};
+const parseDeprecatedWidget = parseWidget(
+// Ignore the incoming widget type and hardcode "deprecated-standin"
+(_, ctx) => ctx.success("deprecated-standin"),
+// Allow any widget options
+object({}));
+const parseStringToPositiveInt = (rawValue, ctx) => {
+  if (typeof rawValue !== "string" || !/^[1-9][0-9]*$/.test(rawValue)) {
+    return ctx.failure("a string representing a positive integer", rawValue);
+  }
+  return ctx.success(+rawValue);
+};
+const parseWidgetIdComponents = pair(string, parseStringToPositiveInt);
+
+const parsePerseusRenderer = defaulted(object({
+  // TODO(benchristel): content is also defaulted to empty string in
+  // renderer.tsx. See if we can remove one default or the other.
+  content: defaulted(string, () => ""),
+  // This module has an import cycle with parseWidgetsMap, because the
+  // `group` widget can contain another renderer.
+  // The anonymous function below ensures that we don't try to access
+  // parseWidgetsMap before it's defined.
+  widgets: defaulted((rawVal, ctx) => parseWidgetsMap(rawVal, ctx), () => ({})),
+  metadata: optional(array(string)),
+  images: parseImages
+}),
+// Default value
+() => ({
+  content: "",
+  widgets: {},
+  images: {}
+}));
+
+const parsePerseusArticle = union(parsePerseusRenderer).or(array(parsePerseusRenderer)).parser;
+
+const parseHint = object({
+  replace: optional(boolean),
+  content: string,
+  widgets: defaulted(parseWidgetsMap, () => ({})),
+  metadata: optional(array(string)),
+  images: parseImages
+});
+
+const parsePerseusItem$1 = object({
+  question: parsePerseusRenderer,
+  hints: defaulted(array(parseHint), () => []),
+  answerArea: pipeParsers(defaulted(object({}), () => ({}))).then(migrateAnswerArea).then(record(enumeration(...ItemExtras), boolean)).parser,
+  itemDataVersion: optional(object({
+    major: number,
+    minor: number
+  })),
+  // Deprecated field
+  answer: any
+});
 
-// Add all of the Underscore functions to the wrapper object.
-var _ = mixin(allExports);
-// Legacy Node.js API.
-_._ = _;
+// Some answerAreas have extra fields, like:
+//
+//   "answerArea": {
+//     "type": "multiple",
+//     "options": {
+//       "content": "",
+//       "images": {},
+//       "widgets": {}
+//     }
+//   }
+//
+// The "type" and "options" fields don't seem to be used anywhere. This
+// migration function removes them.
+function migrateAnswerArea(rawValue, ctx) {
+  const {
+    type: _,
+    options: __,
+    ...rest
+  } = rawValue;
+  return ctx.success(rest);
+}
+
+/**
+ * Helper to parse PerseusItem JSON
+ * Why not just use JSON.parse? We want:
+ * - To make sure types are correct
+ * - To give us a central place to validate/transform output if needed
+ * @deprecated - use parseAndMigratePerseusItem instead
+ * @param {string} json - the stringified PerseusItem JSON
+ * @returns {PerseusItem} the parsed PerseusItem object
+ */
+function parsePerseusItem(json) {
+  // Try to block a cheating vector which relies on monkey-patching
+  // JSON.parse
+  if (isRealJSONParse(JSON.parse)) {
+    return JSON.parse(json);
+  }
+  throw new Error("Something went wrong.");
+}
+/**
+ * Parses a PerseusItem from a JSON string, migrates old formats to the latest
+ * schema, and runtime-typechecks the result. Use this to parse assessmentItem
+ * data.
+ *
+ * @returns a {@link Result} of the parsed PerseusItem. If the result is a
+ * failure, it will contain an error message describing where in the tree
+ * parsing failed.
+ * @throws SyntaxError if the argument is not well-formed JSON.
+ */
+function parseAndMigratePerseusItem(json) {
+  throwErrorIfCheatingDetected();
+  const object = JSON.parse(json);
+  const result = parse(object, parsePerseusItem$1);
+  if (isFailure(result)) {
+    return failure({
+      message: result.detail,
+      invalidObject: object
+    });
+  }
+  return result;
+}
+
+/**
+ * Parses a PerseusArticle from a JSON string, migrates old formats to the
+ * latest schema, and runtime-typechecks the result.
+ *
+ * @returns a {@link Result} of the parsed PerseusArticle. If the result is a
+ * failure, it will contain an error message describing where in the tree
+ * parsing failed.
+ * @throws SyntaxError if the argument is not well-formed JSON.
+ */
+function parseAndMigratePerseusArticle(json) {
+  throwErrorIfCheatingDetected();
+  const object = JSON.parse(json);
+  const result = parse(object, parsePerseusArticle);
+  if (isFailure(result)) {
+    return failure({
+      message: result.detail,
+      invalidObject: object
+    });
+  }
+  return result;
+}
+
+/**
+ * Tries to block a cheating vector that relies on monkey-patching JSON.parse.
+ */
+// TODO(LEMS-2331): delete this function once server-side scoring is done.
+function throwErrorIfCheatingDetected() {
+  if (!isRealJSONParse(JSON.parse)) {
+    throw new Error("Something went wrong.");
+  }
+}
+
+// This file is processed by a Rollup plugin (replace) to inject the production
+const libName = "@khanacademy/perseus-core";
+const libVersion = "3.3.0";
+addLibraryVersionToPerseusDebug(libName, libVersion);
+
+/**
+ * @typedef {Object} Errors utility for referencing the Perseus error taxonomy.
+ */
+const Errors = Object.freeze({
+  /**
+   * @property {ErrorKind} Unknown The kind of error is not known.
+   */
+  Unknown: "Unknown",
+  /**
+   * @property {ErrorKind} Internal The error is internal to the executing code.
+   */
+  Internal: "Internal",
+  /**
+   * @property {ErrorKind} InvalidInput There was a problem with the provided
+   * input, such as the wrong format or a null value.
+   */
+  InvalidInput: "InvalidInput",
+  /**
+   * @property {ErrorKind} NotAllowed There was a problem due to the state of
+   * the system not matching the requested operation or input. For example,
+   * trying to create a username that is valid, but is already taken by
+   * another user. Use {@link InvalidInput} instead when the input isn't
+   * valid regardless of the state of the system. Use {@link NotFound} when
+   * the failure is due to not being able to find a resource.
+   */
+  NotAllowed: "NotAllowed",
+  /**
+   * @property {ErrorKind} TransientService There was a problem when making a
+   * request to a service.
+   */
+  TransientService: "TransientService",
+  /**
+   * @property {ErrorKind} Service There was a non-transient problem when
+   * making a request to service.
+   */
+  Service: "Service"
+});
+
+/**
+ * @type {ErrorKind} The kind of error being reported
+ */
+
+class PerseusError extends Error {
+  kind;
+  metadata;
+  constructor(message, kind, options) {
+    super(message);
+    this.kind = kind;
+    this.metadata = options?.metadata;
+  }
+}
 
 /**
  * _ utilities for objects
@@ -2403,16 +4705,610 @@ const mapObject = function (obj, lambda) {
   return result;
 };
 
+const defaultWidgetOptions$u = {
+  items: [],
+  categories: [],
+  values: [],
+  randomizeItems: false
+};
+const categorizerWidgetLogic = {
+  name: "categorizer",
+  defaultWidgetOptions: defaultWidgetOptions$u
+};
+
+const DEFAULT_HEIGHT = 400;
+const defaultWidgetOptions$t = {
+  programID: "",
+  programType: null,
+  settings: [{
+    name: "",
+    value: ""
+  }],
+  showEditor: false,
+  showButtons: false,
+  height: DEFAULT_HEIGHT
+};
+const csProgramWidgetLogic = {
+  name: "cs-program",
+  defaultWidgetOptions: defaultWidgetOptions$t
+};
+
+const defaultWidgetOptions$s = {
+  togglePrompt: "",
+  definition: ""
+};
+const definitionWidgetLogic = {
+  name: "definition",
+  defaultWidgetOptions: defaultWidgetOptions$s
+};
+
+const defaultWidgetOptions$r = {
+  placeholder: "",
+  choices: [{
+    content: "",
+    correct: false
+  }]
+};
+const dropdownWidgetLogic = {
+  name: "definition",
+  defaultWidgetOptions: defaultWidgetOptions$r
+};
+
+const defaultWidgetOptions$q = {
+  showPrompt: "Explain",
+  hidePrompt: "Hide explanation",
+  explanation: "explanation goes here\n\nmore explanation",
+  widgets: {}
+};
+const explanationWidgetLogic = {
+  name: "explanation",
+  defaultWidgetOptions: defaultWidgetOptions$q
+};
+
+const currentVersion$3 = {
+  major: 1,
+  minor: 0
+};
+const widgetOptionsUpgrades$2 = {
+  "1": v0options => ({
+    times: v0options.times,
+    buttonSets: v0options.buttonSets,
+    functions: v0options.functions,
+    buttonsVisible: v0options.buttonsVisible,
+    visibleLabel: v0options.visibleLabel,
+    ariaLabel: v0options.ariaLabel,
+    answerForms: [{
+      considered: "correct",
+      form: v0options.form,
+      simplify: v0options.simplify,
+      value: v0options.value
+    }]
+  })
+};
+const defaultWidgetOptions$p = {
+  answerForms: [],
+  times: false,
+  buttonSets: ["basic"],
+  functions: ["f", "g", "h"]
+};
+
+const expressionWidgetLogic = {
+  name: "expression",
+  version: currentVersion$3,
+  widgetOptionsUpgrades: widgetOptionsUpgrades$2,
+  defaultWidgetOptions: defaultWidgetOptions$p
+};
+
+const defaultWidgetOptions$o = {
+  title: "",
+  content: "",
+  widgets: {},
+  images: {},
+  hint: null
+};
+const GradedGroupWidgetLogic = {
+  name: "graded-group",
+  defaultWidgetOptions: defaultWidgetOptions$o
+};
+
+const defaultWidgetOptions$n = {
+  gradedGroups: []
+};
+const GradedGroupSetWidgetLogic = {
+  name: "graded-group-set",
+  defaultWidgetOptions: defaultWidgetOptions$n
+};
+
+const defaultWidgetOptions$m = {
+  content: "",
+  widgets: {},
+  images: {},
+  // `undefined` instead of `null` so that getDefaultProps works for
+  // `the GroupMetadataEditor`
+  metadata: undefined
+};
+const GroupWidgetLogic = {
+  name: "group",
+  defaultWidgetOptions: defaultWidgetOptions$m
+};
+
+const defaultWidgetOptions$l = {
+  url: "",
+  settings: [{
+    name: "",
+    value: ""
+  }],
+  width: "400",
+  height: "400",
+  allowFullScreen: false,
+  allowTopNavigation: false
+};
+const iframeWidgetLogic = {
+  name: "iframe",
+  defaultWidgetOptions: defaultWidgetOptions$l
+};
+
+const defaultWidgetOptions$k = {
+  title: "",
+  range: [[0, 10], [0, 10]],
+  box: [400, 400],
+  backgroundImage: {
+    url: null,
+    width: 0,
+    height: 0
+  },
+  labels: [],
+  alt: "",
+  caption: ""
+};
+const imageWidgetLogic = {
+  name: "image",
+  defaultWidgetOptions: defaultWidgetOptions$k
+};
+
+const defaultWidgetOptions$j = {
+  value: 0,
+  simplify: "required",
+  size: "normal",
+  inexact: false,
+  maxError: 0.1,
+  answerType: "number",
+  rightAlign: false
+};
+const inputNumberWidgetLogic = {
+  name: "input-number",
+  defaultWidgetOptions: defaultWidgetOptions$j
+};
+
+const defaultWidgetOptions$i = {
+  graph: {
+    box: [400, 400],
+    labels: ["x", "y"],
+    range: [[-10, 10], [-10, 10]],
+    tickStep: [1, 1],
+    gridStep: [1, 1],
+    markings: "graph"
+  },
+  elements: []
+};
+const interactionWidgetLogic = {
+  name: "interaction",
+  defaultWidgetOptions: defaultWidgetOptions$i
+};
+
+const defaultWidgetOptions$h = {
+  labels: ["x", "y"],
+  range: [[-10, 10], [-10, 10]],
+  step: [1, 1],
+  backgroundImage: {
+    url: null
+  },
+  markings: "graph",
+  showTooltips: false,
+  showProtractor: false,
+  graph: {
+    type: "linear"
+  },
+  correct: {
+    type: "linear",
+    coords: null
+  }
+};
+const interactiveGraphWidgetLogic = {
+  name: "interactive-graph",
+  defaultWidgetOptions: defaultWidgetOptions$h
+};
+
+const defaultWidgetOptions$g = {
+  choices: [],
+  imageAlt: "",
+  imageUrl: "",
+  imageWidth: 0,
+  imageHeight: 0,
+  markers: [],
+  multipleAnswers: false,
+  hideChoicesFromInstructions: false
+};
+const labelImageWidgetLogic = {
+  name: "label-image",
+  defaultWidgetOptions: defaultWidgetOptions$g
+};
+
+const defaultWidgetOptions$f = {
+  left: ["$x$", "$y$", "$z$"],
+  right: ["$1$", "$2$", "$3$"],
+  labels: ["test", "label"],
+  orderMatters: false,
+  padding: true
+};
+const matcherWidgetLogic = {
+  name: "matcher",
+  defaultWidgetOptions: defaultWidgetOptions$f
+};
+
+const defaultWidgetOptions$e = {
+  matrixBoardSize: [3, 3],
+  answers: [[]],
+  prefix: "",
+  suffix: "",
+  cursorPosition: [0, 0]
+};
+const matrixWidgetLogic = {
+  name: "matrix",
+  defaultWidgetOptions: defaultWidgetOptions$e
+};
+
+const currentVersion$2 = {
+  major: 1,
+  minor: 0
+};
+const widgetOptionsUpgrades$1 = {
+  "1": v0options => {
+    const {
+      imageUrl,
+      imageTop,
+      imageLeft,
+      ...rest
+    } = v0options;
+    return {
+      ...rest,
+      image: {
+        url: imageUrl,
+        top: imageTop,
+        left: imageLeft
+      }
+    };
+  }
+};
+const defaultWidgetOptions$d = {
+  box: [480, 480],
+  image: {},
+  showProtractor: true,
+  showRuler: false,
+  rulerLabel: "",
+  rulerTicks: 10,
+  rulerPixels: 40,
+  rulerLength: 10
+};
+
+const measurerWidgetLogic = {
+  name: "measurer",
+  version: currentVersion$2,
+  widgetOptionsUpgrades: widgetOptionsUpgrades$1,
+  defaultWidgetOptions: defaultWidgetOptions$d
+};
+
+const defaultWidgetOptions$c = {
+  range: [0, 10],
+  labelRange: [null, null],
+  labelStyle: "decimal",
+  labelTicks: true,
+  divisionRange: [1, 12],
+  numDivisions: 5,
+  snapDivisions: 2,
+  tickStep: null,
+  correctRel: "eq",
+  correctX: null,
+  initialX: null,
+  showTooltips: false
+};
+const numberLineWidgetLogic = {
+  name: "number-line",
+  defaultWidgetOptions: defaultWidgetOptions$c
+};
+
+const defaultWidgetOptions$b = {
+  answers: [{
+    value: null,
+    status: "correct",
+    message: "",
+    simplify: "required",
+    answerForms: [],
+    strict: false,
+    maxError: null
+  }],
+  size: "normal",
+  coefficient: false,
+  labelText: "",
+  rightAlign: false
+};
+const numericInputWidgetLogic = {
+  name: "numeric-input",
+  defaultWidgetOptions: defaultWidgetOptions$b
+};
+
+const defaultWidgetOptions$a = {
+  correctOptions: [{
+    content: "$x$"
+  }],
+  otherOptions: [{
+    content: "$y$"
+  }],
+  height: "normal",
+  layout: "horizontal"
+};
+const ordererWidgetLogic = {
+  name: "orderer",
+  defaultWidgetOptions: defaultWidgetOptions$a
+};
+
+const defaultWidgetOptions$9 = {
+  passageTitle: "",
+  passageText: "",
+  footnotes: "",
+  showLineNumbers: true
+};
+const passageWidgetLogic = {
+  name: "passage",
+  defaultWidgetOptions: defaultWidgetOptions$9
+};
+
+const currentVersion$1 = {
+  major: 0,
+  minor: 1
+};
+const defaultWidgetOptions$8 = {
+  passageNumber: 1,
+  referenceNumber: 1,
+  summaryText: ""
+};
+
+const passageRefWidgetLogic = {
+  name: "passageRef",
+  version: currentVersion$1,
+  defaultWidgetOptions: defaultWidgetOptions$8
+};
+
+const defaultWidgetOptions$7 = {
+  content: ""
+};
+const passageRefTargetWidgetLogic = {
+  name: "passageRefTarget",
+  defaultWidgetOptions: defaultWidgetOptions$7
+};
+
+const defaultWidgetOptions$6 = {
+  url: "",
+  description: ""
+};
+const PhetSimulationWidgetLogic = {
+  name: "phet-simulation",
+  defaultWidgetOptions: defaultWidgetOptions$6
+};
+
+const defaultWidgetOptions$5 = {
+  scaleY: 1,
+  maxY: 10,
+  snapsPerLine: 2,
+  correct: [1],
+  starting: [1],
+  type: "bar",
+  labels: ["", ""],
+  categories: [""],
+  picSize: 30,
+  picBoxHeight: 36,
+  plotDimensions: [275, 200],
+  labelInterval: 1,
+  picUrl: null
+};
+const plotterWidgetLogic = {
+  name: "plotter",
+  defaultWidgetOptions: defaultWidgetOptions$5
+};
+
+const defaultWidgetOptions$4 = {
+  programID: "",
+  height: 400
+};
+const pythonProgramWidgetLogic = {
+  name: "python-program",
+  defaultWidgetOptions: defaultWidgetOptions$4
+};
+
+const currentVersion = {
+  major: 1,
+  minor: 0
+};
+const widgetOptionsUpgrades = {
+  "1": v0props => {
+    const {
+      noneOfTheAbove,
+      ...rest
+    } = v0props;
+    if (noneOfTheAbove) {
+      throw new Error("radio widget v0 no longer supports auto noneOfTheAbove");
+    }
+    return {
+      ...rest,
+      hasNoneOfTheAbove: false
+    };
+  }
+};
+const defaultWidgetOptions$3 = {
+  choices: [{}, {}, {}, {}],
+  displayCount: null,
+  randomize: false,
+  hasNoneOfTheAbove: false,
+  multipleSelect: false,
+  countChoices: false,
+  deselectEnabled: false
+};
+
+const radioWidgetLogic = {
+  name: "radio",
+  version: currentVersion,
+  widgetOptionsUpgrades: widgetOptionsUpgrades,
+  defaultWidgetOptions: defaultWidgetOptions$3
+};
+
+const defaultWidgetOptions$2 = {
+  correct: ["$x$", "$y$", "$z$"],
+  layout: "horizontal",
+  padding: true
+};
+const sorterWidgetLogic = {
+  name: "sorter",
+  defaultWidgetOptions: defaultWidgetOptions$2
+};
+
+const defaultRows = 4;
+const defaultColumns = 1;
+
+// initialize a 2D array
+// (defaultRows x defaultColumns) of empty strings
+const answers = new Array(defaultRows).fill(0).map(() => new Array(defaultColumns).fill(""));
+const defaultWidgetOptions$1 = {
+  headers: [""],
+  rows: defaultRows,
+  columns: defaultColumns,
+  answers: answers
+};
+const tableWidgetLogic = {
+  name: "table",
+  defaultWidgetOptions: defaultWidgetOptions$1
+};
+
+const defaultWidgetOptions = {
+  location: ""
+};
+const videoWidgetLogic = {
+  name: "video",
+  defaultWidgetOptions
+};
+
+/**
+ * For details on the individual options, see the
+ * PerseusOrdererWidgetOptions type
+ */
+
+/**
+ * Given a PerseusOrdererWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getOrdererPublicWidgetOptions(options) {
+  return {
+    options: options.options,
+    height: options.height,
+    layout: options.layout
+  };
+}
+
+/**
+ * For details on the individual options, see the
+ * PerseusCategorizerWidgetOptions type
+ */
+
+/**
+ * Given a PerseusCategorizerWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getCategorizerPublicWidgetOptions(options) {
+  return {
+    items: options.items,
+    categories: options.categories,
+    randomizeItems: options.randomizeItems,
+    static: options.static
+  };
+}
+
+/**
+ * For details on the individual options, see the
+ * PerseusExpressionWidgetOptions type
+ */
+
+/**
+ * Given a PerseusExpressionWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getExpressionPublicWidgetOptions(options) {
+  return {
+    buttonSets: options.buttonSets,
+    functions: options.functions,
+    times: options.times,
+    visibleLabel: options.visibleLabel,
+    ariaLabel: options.ariaLabel,
+    buttonsVisible: options.buttonsVisible
+  };
+}
+
 exports.Errors = Errors;
+exports.GrapherUtil = grapherUtil;
 exports.ItemExtras = ItemExtras;
 exports.PerseusError = PerseusError;
 exports.PerseusExpressionAnswerFormConsidered = PerseusExpressionAnswerFormConsidered;
 exports.addLibraryVersionToPerseusDebug = addLibraryVersionToPerseusDebug;
+exports.addWidget = addWidget;
+exports.approximateDeepEqual = approximateDeepEqual;
+exports.approximateEqual = approximateEqual;
+exports.categorizerLogic = categorizerWidgetLogic;
+exports.csProgramLogic = csProgramWidgetLogic;
+exports.deepClone = deepClone;
+exports.definitionLogic = definitionWidgetLogic;
+exports.dropdownLogic = dropdownWidgetLogic;
+exports.explanationLogic = explanationWidgetLogic;
+exports.expressionLogic = expressionWidgetLogic;
+exports.getCategorizerPublicWidgetOptions = getCategorizerPublicWidgetOptions;
+exports.getDecimalSeparator = getDecimalSeparator;
+exports.getExpressionPublicWidgetOptions = getExpressionPublicWidgetOptions;
+exports.getMatrixSize = getMatrixSize;
+exports.getOrdererPublicWidgetOptions = getOrdererPublicWidgetOptions;
+exports.getWidgetIdsFromContent = getWidgetIdsFromContent;
+exports.getWidgetIdsFromContentByType = getWidgetIdsFromContentByType;
+exports.gradedGroupLogic = GradedGroupWidgetLogic;
+exports.gradedGroupSetLogic = GradedGroupSetWidgetLogic;
+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.sorterLogic = sorterWidgetLogic;
+exports.tableLogic = tableWidgetLogic;
+exports.videoLogic = videoWidgetLogic;
 //# sourceMappingURL=index.js.map