@khanacademy/perseus-core 3.2.0 → 3.3.0

package/dist/index.js

@@ -116,7 +116,7 @@ function restArguments(func, startIndex) {
 }
 
 // Is a given variable an object?
-function isObject(obj) {
+function isObject$1(obj) {
   var type = typeof obj;
   return type === 'function' || (type === 'object' && !!obj);
 }
@@ -230,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;
   };
@@ -267,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');
@@ -312,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);
@@ -510,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.
@@ -639,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;
@@ -659,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);
 }
 
@@ -768,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);
 }
 
@@ -1017,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;
 }
 
@@ -1779,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));
 });
 
@@ -1819,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) {
@@ -1914,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,
@@ -1958,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,
@@ -2047,13 +2047,13 @@ 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,
@@ -2166,6 +2166,70 @@ function approximateDeepEqual(x, y) {
   return approximateEqual(x, y);
 }
 
+/**
+ * Add a widget placeholder using the widget ID.
+ * ex. addWidget("radio 1") => "[[☃ radio 1]]"
+ *
+ * @param {string} id
+ * @returns {string}
+ */
+function addWidget(id) {
+  return `[[☃ ${id}]]`;
+}
+
+/**
+ * Regex for widget placeholders in a string.
+ *
+ * First capture group is the widget ID (ex. 'radio 1')
+ * Second capture group is the widget type (ex. "radio)
+ * exec return will look like: ['[[☃ radio 1]]', 'radio 1', 'radio']
+ */
+function getWidgetRegex() {
+  return /\[\[☃ ([A-Za-z0-9- ]+)\]\]/g;
+}
+
+/**
+ * Extract all widget IDs, which includes the widget type and instance number.
+ * example output: ['radio 1', 'categorizer 1', 'categorizor 2']
+ *
+ * Content should contain Perseus widget placeholders,
+ * which look like: '[[☃ radio 1]]'.
+ *
+ * @param {string} content
+ * @returns {ReadonlyArray<string>} widgetIds
+ */
+function getWidgetIdsFromContent(content) {
+  const widgets = [];
+  const localWidgetRegex = getWidgetRegex();
+  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.
 
@@ -2580,200 +2644,1188 @@ var grapherUtil = /*#__PURE__*/Object.freeze({
     functionForType: functionForType
 });
 
-// This file is processed by a Rollup plugin (replace) to inject the production
-const libName = "@khanacademy/perseus-core";
-const libVersion = "3.2.0";
-addLibraryVersionToPerseusDebug(libName, libVersion);
+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"}}}}`;
+}
 
-/**
- * @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"
-});
+process.env.NODE_ENV === 'production';
 
-/**
- * @type {ErrorKind} The kind of error being reported
- */
+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";
+}
 
-class PerseusError extends Error {
-  kind;
-  metadata;
-  constructor(message, kind, options) {
-    super(message);
-    this.kind = kind;
-    this.metadata = options?.metadata;
+// 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);
 }
 
-/**
- * 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
+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];
+}
 
-/**
- * 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}
- */
+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]*$/;
 
-/**
- * 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!
- */
+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;
+      }
+  }
+}
 
-/**
- * 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.
- */
+function parse(value, parser) {
+  const result = parser(value, new ErrorTrackingParseContext([]));
+  if (isFailure(result)) {
+    return failure(result.detail.map(message).join("; "));
+  }
+  return result;
+}
 
-/**
- * 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 any = (rawValue, ctx) => ctx.success(rawValue);
 
-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"];
+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];
+}
 
-/**
- * The type representing the common structure of all widget's options. The
- * `Options` generic type represents the widget-specific option data.
- */
+function boolean(rawValue, ctx) {
+  if (typeof rawValue === "boolean") {
+    return ctx.success(rawValue);
+  }
+  return ctx.failure("boolean", rawValue);
+}
 
-// prettier-ignore
+function constant(acceptedValue) {
+  return (rawValue, ctx) => {
+    if (rawValue !== acceptedValue) {
+      return ctx.failure(String(JSON.stringify(acceptedValue)), rawValue);
+    }
+    return ctx.success(acceptedValue);
+  };
+}
 
-// prettier-ignore
+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);
+  };
+}
 
-// prettier-ignore
+function isObject(x) {
+  return x != null && Object.getPrototypeOf(x) === Object.prototype;
+}
 
-// prettier-ignore
+function nullable(parseValue) {
+  return (rawValue, ctx) => {
+    if (rawValue === null) {
+      return ctx.success(rawValue);
+    }
+    return parseValue(rawValue, ctx);
+  };
+}
 
-// prettier-ignore
+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
 
@@ -2831,46 +3883,783 @@ const ItemExtras = [
 
 // 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
+});
 
-//prettier-ignore
+// 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);
+}
 
 /**
- * A background image applied to various widgets.
+ * 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;
+}
 
 /**
- * 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
+ * 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;
+}
 
-const PerseusExpressionAnswerFormConsidered = ["correct", "wrong", "ungraded"];
+/**
+ * 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.");
+  }
+}
 
-// 2D range: xMin, xMax, yMin, yMax
+// 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);
 
-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
-};
+/**
+ * @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"
+});
 
-// Not associated with a specific figure
+/**
+ * @type {ErrorKind} The kind of error being reported
+ */
 
-const plotterPlotTypes = ["bar", "line", "pic", "histogram", "dotplot"];
+class PerseusError extends Error {
+  kind;
+  metadata;
+  constructor(message, kind, options) {
+    super(message);
+    this.kind = kind;
+    this.metadata = options?.metadata;
+  }
+}
 
 /**
  * _ utilities for objects
@@ -2916,22 +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