@khanacademy/perseus-core 3.2.0 → 3.4.0

package/dist/es/index.js

@@ -113,7 +113,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);
 }
@@ -227,7 +227,7 @@ function isNaN$1(obj) {
 }
 
 // Predicate-generating function. Often useful outside of Underscore.
-function constant(value) {
+function constant$1(value) {
   return function() {
     return value;
   };
@@ -264,7 +264,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');
@@ -309,7 +309,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);
@@ -507,7 +507,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.
@@ -636,7 +636,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;
@@ -656,7 +656,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);
 }
 
@@ -765,7 +765,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);
 }
 
@@ -1014,7 +1014,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;
 }
 
@@ -1776,7 +1776,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));
 });
 
@@ -1816,7 +1816,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) {
@@ -1911,7 +1911,7 @@ var allExports = /*#__PURE__*/Object.freeze({
     __proto__: null,
     VERSION: VERSION,
     restArguments: restArguments,
-    isObject: isObject,
+    isObject: isObject$1,
     isNull: isNull,
     isUndefined: isUndefined,
     isBoolean: isBoolean,
@@ -1955,7 +1955,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,
@@ -2044,13 +2044,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,
@@ -2164,6 +2164,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 == null ? void 0 : widget.type) === type) {
+      rv.push(widgetId);
+    }
+  });
+  return rv;
+}
+
 // TODO(benchristel): in the future, we may want to make deepClone work for
 // Record<string, Cloneable> as well. Currently, it only does arrays.
 
@@ -2578,341 +2642,2965 @@ 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(capitalize = false) {
+  let randomString = "";
+  const randomLength = Math.floor(Math.random() * 8) + 3;
+  for (let i = 0; i < randomLength; i++) {
+    const randomLetter = String.fromCharCode(97 + Math.floor(Math.random() * 26));
+    randomString += capitalize && i === 0 ? randomLetter.toUpperCase() : randomLetter;
+  }
+  return randomString;
+}
+function buildRandomPhrase() {
+  const phrases = [];
+  const randomLength = Math.floor(Math.random() * 10) + 5;
+  for (let i = 0; i < randomLength; i++) {
+    phrases.push(buildRandomString(i === 0));
+  }
+  const modifierStart = ["**", "$"];
+  const modifierEnd = ["**", "$"];
+  const modifierIndex = Math.floor(Math.random() * modifierStart.length);
+  return `${modifierStart[modifierIndex]}${phrases.join(" ")}${modifierEnd[modifierIndex]}`;
+}
+function buildTestData(testObject) {
+  return `{"data":{"assessmentItem":{"__typename":"AssessmentItemOrError","error":null,"item":{"__typename":"AssessmentItem","id":"x890b3c70f3e8f4a6","itemData":"${testObject}","problemType":"Type 1","sha":"c7284a3ad65214b4e62bccce236d92f7f5d35941"}}}}`;
+}
 
-/**
- * @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 {
-  constructor(message, kind, options) {
-    super(message);
-    this.kind = void 0;
-    this.metadata = void 0;
-    this.kind = kind;
-    this.metadata = options == null ? void 0 : options.metadata;
+// Result's `all` function is similar to Promise.all: given an array of
+// results, it returns success if all succeeded, and failure if any failed.
+function all(results, combineFailureDetails = a => a) {
+  const values = [];
+  const failureDetails = [];
+  for (const result of results) {
+    if (result.type === "success") {
+      values.push(result.value);
+    } else {
+      failureDetails.push(result.detail);
+    }
+  }
+  if (failureDetails.length > 0) {
+    return failure(failureDetails.reduce(combineFailureDetails));
   }
+  return success(values);
 }
 
-/**
- * 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
+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];
+}
 
-// Same name as Mafs
+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]*$/;
 
-/**
- * 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 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 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 parse(value, parser) {
+  const result = parser(value, new ErrorTrackingParseContext([]));
+  if (isFailure(result)) {
+    return failure(result.detail.map(message).join("; "));
+  }
+  return result;
+}
 
-/**
- * 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.
- */
+const any = (rawValue, ctx) => ctx.success(rawValue);
 
-/**
- * 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`.
- */
+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];
+}
 
-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 boolean(rawValue, ctx) {
+  if (typeof rawValue === "boolean") {
+    return ctx.success(rawValue);
+  }
+  return ctx.failure("boolean", rawValue);
+}
 
-/**
- * The type representing the common structure of all widget's options. The
- * `Options` generic type represents the widget-specific option data.
- */
+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(...acceptedValues) {
+  return (rawValue, ctx) => {
+    if (typeof rawValue === "string") {
+      const index = acceptedValues.indexOf(rawValue);
+      if (index > -1) {
+        return ctx.success(acceptedValues[index]);
+      }
+    }
+    const expected = acceptedValues.map(v => JSON.stringify(v));
+    return ctx.failure(expected, rawValue);
+  };
+}
 
-// 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);
+};
 
-// prettier-ignore
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+function object(schema) {
+  return (rawValue, ctx) => {
+    if (!isObject(rawValue)) {
+      return ctx.failure("object", rawValue);
+    }
+    const ret = _extends({}, rawValue);
+    const mismatches = [];
+    for (const [prop, propParser] of Object.entries(schema)) {
+      const result = propParser(rawValue[prop], ctx.forSubtree(prop));
+      if (isSuccess(result)) {
+        if (result.value !== undefined || prop in rawValue) {
+          ret[prop] = result.value;
+        }
+      } else {
+        mismatches.push(...result.detail);
+      }
+    }
+    if (mismatches.length > 0) {
+      return failure(mismatches);
+    }
+    return ctx.success(ret);
+  };
+}
+
+function optional(parseValue) {
+  return (rawValue, ctx) => {
+    if (rawValue === undefined) {
+      return ctx.success(rawValue);
+    }
+    return parseValue(rawValue, ctx);
+  };
+}
+
+function pair(parseA, parseB) {
+  return (rawValue, ctx) => {
+    if (!Array.isArray(rawValue)) {
+      return ctx.failure("array", rawValue);
+    }
+    if (rawValue.length !== 2) {
+      return ctx.failure("array of length 2", rawValue);
+    }
+    const [rawA, rawB] = rawValue;
+    const resultA = parseA(rawA, ctx.forSubtree(0));
+    if (isFailure(resultA)) {
+      return resultA;
+    }
+    const resultB = parseB(rawB, ctx.forSubtree(1));
+    if (isFailure(resultB)) {
+      return resultB;
+    }
+    return ctx.success([resultA.value, resultB.value]);
+  };
+}
+
+function pipeParsers(p) {
+  return new ParserPipeline(p);
+}
+class ParserPipeline {
+  constructor(parser) {
+    this.parser = parser;
+  }
+  then(nextParser) {
+    return new ParserPipeline(composeParsers(this.parser, nextParser));
+  }
+}
+function composeParsers(parserA, parserB) {
+  return (rawValue, ctx) => {
+    const partialResult = parserA(rawValue, ctx);
+    if (isFailure(partialResult)) {
+      return partialResult;
+    }
+    return parserB(partialResult.value, ctx);
+  };
+}
+
+function record(parseKey, parseValue) {
+  return (rawValue, ctx) => {
+    if (!isObject(rawValue)) {
+      return ctx.failure("object", rawValue);
+    }
+    const result = {};
+    const mismatches = [];
+    for (const [key, value] of Object.entries(rawValue)) {
+      const entryCtx = ctx.forSubtree(key);
+      const keyResult = parseKey(key, entryCtx);
+      if (isFailure(keyResult)) {
+        mismatches.push(...keyResult.detail);
+      }
+      const valueResult = parseValue(value, entryCtx);
+      if (isFailure(valueResult)) {
+        mismatches.push(...valueResult.detail);
+      }
+      if (isSuccess(keyResult) && isSuccess(valueResult)) {
+        result[keyResult.value] = valueResult.value;
+      }
+    }
+    if (mismatches.length > 0) {
+      return failure(mismatches);
+    }
+    return ctx.success(result);
+  };
+}
+
+const string = (rawValue, ctx) => {
+  if (typeof rawValue === "string") {
+    return ctx.success(rawValue);
+  }
+  return ctx.failure("string", rawValue);
+};
+
+function trio(parseA, parseB, parseC) {
+  return (rawValue, ctx) => {
+    if (!Array.isArray(rawValue)) {
+      return ctx.failure("array", rawValue);
+    }
+    if (rawValue.length !== 3) {
+      return ctx.failure("array of length 3", rawValue);
+    }
+    const resultA = parseA(rawValue[0], ctx.forSubtree(0));
+    if (isFailure(resultA)) {
+      return resultA;
+    }
+    const resultB = parseB(rawValue[1], ctx.forSubtree(1));
+    if (isFailure(resultB)) {
+      return resultB;
+    }
+    const resultC = parseC(rawValue[2], ctx.forSubtree(2));
+    if (isFailure(resultC)) {
+      return resultC;
+    }
+    return ctx.success([resultA.value, resultB.value, resultC.value]);
+  };
+}
+
+function union(parseBranch) {
+  return new UnionBuilder(parseBranch);
+}
+class UnionBuilder {
+  constructor(parser) {
+    this.parser = parser;
+  }
+  or(newBranch) {
+    return new UnionBuilder(either(this.parser, newBranch));
+  }
+}
+function either(parseA, parseB) {
+  return (rawValue, ctx) => {
+    const resultA = parseA(rawValue, ctx);
+    if (isSuccess(resultA)) {
+      return resultA;
+    }
+    return parseB(rawValue, ctx);
+  };
+}
+
+function defaulted(parser, fallback) {
+  return (rawValue, ctx) => {
+    if (rawValue == null) {
+      return success(fallback(rawValue));
+    }
+    return parser(rawValue, ctx);
+  };
+}
+
+const parseImages = defaulted(record(string, object({
+  width: number,
+  height: number
+})), () => ({}));
+
+function parseWidget(parseType, parseOptions) {
+  return object({
+    type: parseType,
+    static: optional(boolean),
+    graded: optional(boolean),
+    alignment: optional(string),
+    options: parseOptions,
+    key: optional(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 {
+  constructor(majorVersion, parseThisVersion, migrateToLatest, parseOtherVersions) {
+    this.parser = void 0;
+    this.migrateToLatest = migrateToLatest;
+    this.parseOtherVersions = parseOtherVersions;
+    const parseThisVersionAndMigrateToLatest = pipeParsers(parseThisVersion).then(convert(this.migrateToLatest)).parser;
+    this.parser = (raw, ctx) => {
+      if (!isObject(raw)) {
+        return ctx.failure("object", raw);
+      }
+      const versionParseResult = parseVersionedObject(raw, ctx);
+      if (isFailure(versionParseResult)) {
+        return versionParseResult;
+      }
+      if (versionParseResult.value.version.major !== majorVersion) {
+        return this.parseOtherVersions(raw, ctx);
+      }
+      return parseThisVersionAndMigrateToLatest(raw, ctx);
+    };
+  }
+
+  /**
+   * Add a migration from an old version of the widget options.
+   */
+  withMigrationFrom(majorVersion, parseOldVersion, migrateToNextVersion) {
+    const parseOtherVersions = this.parser;
+    const migrateToLatest = old => this.migrateToLatest(migrateToNextVersion(old));
+    return new VersionedWidgetOptionsParserBuilder(majorVersion, parseOldVersion, migrateToLatest, parseOtherVersions);
+  }
+}
+const parseVersionedObject = object({
+  version: defaulted(object({
+    major: number,
+    minor: number
+  }), () => ({
+    major: 0,
+    minor: 0
+  }))
+});
+
+const stringOrNumberOrNullOrUndefined = union(string).or(number).or(constant(null)).or(constant(undefined)).parser;
+const parsePossiblyInvalidAnswerForm = object({
+  // `value` is the possibly invalid part of this. It should always be a
+  // string, but some answer forms don't have it. The Expression widget
+  // ignores invalid values, so we can safely filter them out during parsing.
+  value: optional(string),
+  form: defaulted(boolean, () => false),
+  simplify: defaulted(boolean, () => false),
+  considered: enumeration("correct", "wrong", "ungraded"),
+  key: pipeParsers(stringOrNumberOrNullOrUndefined).then(convert(String)).parser
+});
+function removeInvalidAnswerForms(possiblyInvalid) {
+  const valid = [];
+  for (const answerForm of possiblyInvalid) {
+    const {
+      value
+    } = answerForm;
+    if (value != null) {
+      // Copying the object seems to be needed to make TypeScript happy
+      valid.push(_extends({}, answerForm, {
+        value
+      }));
+    }
+  }
+  return valid;
+}
+
+// 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 _extends({}, widget, {
+    version: {
+      major: 1,
+      minor: 0
+    },
+    options: {
+      times: options.times,
+      buttonSets: options.buttonSets,
+      functions: options.functions,
+      buttonsVisible: options.buttonsVisible,
+      visibleLabel: options.visibleLabel,
+      ariaLabel: options.ariaLabel,
+      answerForms: [{
+        considered: "correct",
+        form: options.form,
+        simplify: options.simplify,
+        value: options.value
+      }]
+    }
+  });
+}
+const parseExpressionWidget = versionedWidgetOptions(1, parseExpressionWidgetV1).withMigrationFrom(0, parseExpressionWidgetV0, migrateV0ToV1).parser;
+
+const falseToNull = pipeParsers(constant(false)).then(convert(() => null)).parser;
+const parseGradedGroupWidgetOptions = object({
+  title: defaulted(string, () => ""),
+  hasHint: optional(nullable(boolean)),
+  // This module has an import cycle with parsePerseusRenderer.
+  // The anonymous function below ensures that we don't try to access
+  // parsePerseusRenderer before it's defined.
+  hint: union(falseToNull).or(constant(null)).or(constant(undefined)).or((rawVal, ctx) => parsePerseusRenderer(rawVal, ctx)).parser,
+  content: string,
+  // This module has an import cycle with parseWidgetsMap.
+  // The anonymous function below ensures that we don't try to access
+  // parseWidgetsMap before it's defined.
+  widgets: (rawVal, ctx) => parseWidgetsMap(rawVal, ctx),
+  widgetEnabled: optional(nullable(boolean)),
+  immutableWidgets: optional(nullable(boolean)),
+  images: record(string, object({
+    width: number,
+    height: number
+  }))
+});
+const parseGradedGroupWidget = parseWidget(constant("graded-group"), parseGradedGroupWidgetOptions);
+
+const parseGradedGroupSetWidget = parseWidget(constant("graded-group-set"), object({
+  gradedGroups: array(parseGradedGroupWidgetOptions)
+}));
+
+/**
+ * discriminatedUnion() should be preferred over union() when parsing a
+ * discriminated union type, because discriminatedUnion() produces more
+ * understandable failure messages. It takes the discriminant as the source of
+ * truth for which variant is to be parsed, and expects the other data to match
+ * that variant.
+ */
+function discriminatedUnionOn(discriminantKey) {
+  const noMoreBranches = (raw, ctx) => {
+    if (!isObject(raw)) {
+      return ctx.failure("object", raw);
+    }
+    return ctx.forSubtree(discriminantKey).failure("a valid value", raw[discriminantKey]);
+  };
+  return new DiscriminatedUnionBuilder(discriminantKey, noMoreBranches);
+}
+class DiscriminatedUnionBuilder {
+  constructor(discriminantKey, parser) {
+    this.discriminantKey = discriminantKey;
+    this.parser = parser;
+  }
+  withBranch(discriminantValue, parseNewVariant) {
+    const parseNewBranch = discriminatedUnionBranch(this.discriminantKey, discriminantValue, parseNewVariant, this.parser);
+    return new DiscriminatedUnionBuilder(this.discriminantKey, parseNewBranch);
+  }
+}
+function discriminatedUnionBranch(discriminantKey, discriminantValue, parseVariant, parseOtherBranches) {
+  return (raw, ctx) => {
+    if (!isObject(raw)) {
+      return ctx.failure("object", raw);
+    }
+    if (raw[discriminantKey] === discriminantValue) {
+      return parseVariant(raw, ctx);
+    }
+    return parseOtherBranches(raw, ctx);
+  };
+}
+
+const pairOfNumbers$3 = pair(number, number);
+const pairOfPoints = pair(pairOfNumbers$3, pairOfNumbers$3);
+const parseGrapherWidget = parseWidget(constant("grapher"), object({
+  availableTypes: array(enumeration("absolute_value", "exponential", "linear", "logarithm", "quadratic", "sinusoid", "tangent")),
+  correct: discriminatedUnionOn("type").withBranch("absolute_value", object({
+    type: constant("absolute_value"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("exponential", object({
+    type: constant("exponential"),
+    asymptote: pairOfPoints,
+    coords: nullable(pairOfPoints)
+  })).withBranch("linear", object({
+    type: constant("linear"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("logarithm", object({
+    type: constant("logarithm"),
+    asymptote: pairOfPoints,
+    coords: nullable(pairOfPoints)
+  })).withBranch("quadratic", object({
+    type: constant("quadratic"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("sinusoid", object({
+    type: constant("sinusoid"),
+    coords: nullable(pairOfPoints)
+  })).withBranch("tangent", object({
+    type: constant("tangent"),
+    coords: nullable(pairOfPoints)
+  })).parser,
+  graph: object({
+    backgroundImage: object({
+      bottom: optional(number),
+      height: optional(number),
+      left: optional(number),
+      scale: optional(number),
+      url: optional(nullable(string)),
+      width: optional(number)
+    }),
+    box: optional(pairOfNumbers$3),
+    editableSettings: optional(array(enumeration("graph", "snap", "image", "measure"))),
+    gridStep: optional(pairOfNumbers$3),
+    labels: pair(string, string),
+    markings: enumeration("graph", "none", "grid"),
+    range: pair(pairOfNumbers$3, pairOfNumbers$3),
+    rulerLabel: constant(""),
+    rulerTicks: number,
+    showProtractor: optional(boolean),
+    showRuler: optional(boolean),
+    showTooltips: optional(boolean),
+    snapStep: optional(pairOfNumbers$3),
+    step: pairOfNumbers$3,
+    valid: optional(union(boolean).or(string).parser)
+  })
+}));
+
+const parseGroupWidget = parseWidget(constant("group"),
+// This module has an import cycle with parsePerseusRenderer.
+// The anonymous function below ensures that we don't try to access
+// parsePerseusRenderer before it's defined.
+(rawVal, ctx) => parsePerseusRenderer(rawVal, ctx));
+
+const parseIframeWidget = parseWidget(constant("iframe"), object({
+  url: string,
+  settings: optional(array(object({
+    name: string,
+    value: string
+  }))),
+  width: union(number).or(string).parser,
+  height: union(number).or(string).parser,
+  allowFullScreen: defaulted(boolean, () => false),
+  allowTopNavigation: optional(boolean),
+  static: defaulted(boolean, () => false)
+}));
+
+const stringToNumber = (rawValue, ctx) => {
+  if (typeof rawValue === "number") {
+    return ctx.success(rawValue);
+  }
+  const parsedNumber = +rawValue;
+  if (rawValue === "" || isNaN(parsedNumber)) {
+    return ctx.failure("a number or numeric string", rawValue);
+  }
+  return ctx.success(parsedNumber);
+};
+
+function emptyToZero(x) {
+  return x === "" ? 0 : x;
+}
+const imageDimensionToNumber = pipeParsers(union(number).or(string).parser)
+// In this specific case, empty string is equivalent to zero. An empty
+// string parses to either NaN (using parseInt) or 0 (using unary +) and
+// CSS will treat NaN as invalid and default to 0 instead.
+.then(convert(emptyToZero)).then(stringToNumber).parser;
+const parsePerseusImageBackground = object({
+  url: optional(nullable(string)),
+  width: optional(imageDimensionToNumber),
+  height: optional(imageDimensionToNumber),
+  top: optional(imageDimensionToNumber),
+  left: optional(imageDimensionToNumber),
+  bottom: optional(imageDimensionToNumber),
+  scale: optional(imageDimensionToNumber)
+});
+
+const pairOfNumbers$2 = pair(number, number);
+const parseImageWidget = parseWidget(constant("image"), object({
+  title: optional(string),
+  caption: optional(string),
+  alt: optional(string),
+  backgroundImage: parsePerseusImageBackground,
+  static: optional(boolean),
+  labels: optional(array(object({
+    content: string,
+    alignment: string,
+    coordinates: array(number)
+  }))),
+  range: optional(pair(pairOfNumbers$2, pairOfNumbers$2)),
+  box: optional(pairOfNumbers$2)
+}));
+
+const booleanToString = (rawValue, ctx) => {
+  if (typeof rawValue === "boolean") {
+    return ctx.success(String(rawValue));
+  }
+  return ctx.failure("boolean", rawValue);
+};
+const parseInputNumberWidget = parseWidget(constant("input-number"), object({
+  answerType: optional(enumeration("number", "decimal", "integer", "rational", "improper", "mixed", "percent", "pi")),
+  inexact: optional(boolean),
+  maxError: optional(union(number).or(string).parser),
+  rightAlign: optional(boolean),
+  simplify: enumeration("required", "optional", "enforced"),
+  size: enumeration("normal", "small"),
+  // TODO(benchristel): there are some content items where value is a
+  // boolean, even though that makes no sense. We should figure out if
+  // those content items are actually published anywhere, and consider
+  // updating them.
+  value: union(number).or(string).or(booleanToString).parser,
+  customKeypad: optional(boolean)
+}));
+
+const pairOfNumbers$1 = pair(number, number);
+const stringOrEmpty = defaulted(string, () => "");
+const parseKey = pipeParsers(optional(string)).then(convert(String)).parser;
+const parseFunctionElement = object({
+  type: constant("function"),
+  key: parseKey,
+  options: object({
+    value: string,
+    funcName: string,
+    rangeMin: string,
+    rangeMax: string,
+    color: string,
+    strokeDasharray: string,
+    strokeWidth: number
+  })
+});
+const parseLabelElement = object({
+  type: constant("label"),
+  key: parseKey,
+  options: object({
+    label: string,
+    color: string,
+    coordX: string,
+    coordY: string
+  })
+});
+const parseLineElement = object({
+  type: constant("line"),
+  key: parseKey,
+  options: object({
+    color: string,
+    startX: string,
+    startY: string,
+    endX: string,
+    endY: string,
+    strokeDasharray: string,
+    strokeWidth: number,
+    arrows: string
+  })
+});
+const parseMovableLineElement = object({
+  type: constant("movable-line"),
+  key: parseKey,
+  options: object({
+    startX: string,
+    startY: string,
+    startSubscript: number,
+    endX: string,
+    endY: string,
+    endSubscript: number,
+    constraint: string,
+    snap: number,
+    constraintFn: string,
+    constraintXMin: string,
+    constraintXMax: string,
+    constraintYMin: string,
+    constraintYMax: string
+  })
+});
+const parseMovablePointElement = object({
+  type: constant("movable-point"),
+  key: parseKey,
+  options: object({
+    startX: string,
+    startY: string,
+    varSubscript: number,
+    constraint: string,
+    snap: number,
+    constraintFn: string,
+    constraintXMin: stringOrEmpty,
+    constraintXMax: stringOrEmpty,
+    constraintYMin: stringOrEmpty,
+    constraintYMax: stringOrEmpty
+  })
+});
+const parseParametricElement = object({
+  type: constant("parametric"),
+  key: parseKey,
+  options: object({
+    x: string,
+    y: string,
+    rangeMin: string,
+    rangeMax: string,
+    color: string,
+    strokeDasharray: string,
+    strokeWidth: number
+  })
+});
+const parsePointElement = object({
+  type: constant("point"),
+  key: parseKey,
+  options: object({
+    color: string,
+    coordX: string,
+    coordY: string
+  })
+});
+const parseRectangleElement = object({
+  type: constant("rectangle"),
+  key: parseKey,
+  options: object({
+    color: string,
+    coordX: string,
+    coordY: string,
+    width: string,
+    height: string
+  })
+});
+const parseInteractionWidget = parseWidget(constant("interaction"), object({
+  static: defaulted(boolean, () => false),
+  graph: object({
+    editableSettings: optional(array(enumeration("canvas", "graph"))),
+    box: pairOfNumbers$1,
+    labels: array(string),
+    range: pair(pairOfNumbers$1, pairOfNumbers$1),
+    gridStep: pairOfNumbers$1,
+    markings: enumeration("graph", "grid", "none"),
+    snapStep: optional(pairOfNumbers$1),
+    valid: optional(union(boolean).or(string).parser),
+    backgroundImage: optional(parsePerseusImageBackground),
+    showProtractor: optional(boolean),
+    showRuler: optional(boolean),
+    rulerLabel: optional(string),
+    rulerTicks: optional(number),
+    tickStep: pairOfNumbers$1
+  }),
+  elements: array(discriminatedUnionOn("type").withBranch("function", parseFunctionElement).withBranch("label", parseLabelElement).withBranch("line", parseLineElement).withBranch("movable-line", parseMovableLineElement).withBranch("movable-point", parseMovablePointElement).withBranch("parametric", parseParametricElement).withBranch("point", parsePointElement).withBranch("rectangle", parseRectangleElement).parser)
+}));
+
+/**
+ * The Perseus "data schema" file.
+ *
+ * This file, and the types in it, represents the "data schema" that Perseus
+ * uses. The @khanacademy/perseus-editor package edits and produces objects
+ * that conform to the types in this file. Similarly, the top-level renderers
+ * in @khanacademy/perseus, consume objects that conform to these types.
+ *
+ * WARNING: This file should not import any types from elsewhere so that it is
+ * easy to reason about changes that alter the Perseus schema. This helps
+ * ensure that it is not changed accidentally when upgrading a dependant
+ * package or other part of Perseus code. Note that TypeScript does type
+ * checking via something called "structural typing". This means that as long
+ * as the shape of a type matches, the name it goes by doesn't matter. As a
+ * result, a `Coord` type that looks like this `[x: number, y: number]` is
+ * _identical_, in TypeScript's eyes, to this `Vector2` type `[x: number, y:
+ * number]`. Also, with tuples, the labels for each entry is ignored, so `[x:
+ * number, y: number]` is compatible with `[min: number, max: number]`. The
+ * labels are for humans, not TypeScript. :)
+ *
+ * If you make changes to types in this file, be very sure that:
+ *
+ *   a) the changes are backwards compatible. If they are not, old data from
+ *      previous versions of the "schema" could become unrenderable, or worse,
+ *      introduce hard-to-diagnose bugs.
+ *   b) the parsing code (`util/parse-perseus-json/`) is updated to handle
+ *      the new format _as well as_ the old format.
+ */
+
+// TODO(FEI-4010): Remove `Perseus` prefix for all types here
+
+// Same name as Mafs
+
+/**
+ * A utility type that constructs a widget map from a "registry interface".
+ * The keys of the registry should be the widget type (aka, "categorizer" or
+ * "radio", etc) and the value should be the option type stored in the value
+ * of the map.
+ *
+ * You can think of this as a type that generates another type. We use
+ * "registry interfaces" as a way to keep a set of widget types to their data
+ * type in several places in Perseus. This type then allows us to generate a
+ * map type that maps a widget id to its data type and keep strong typing by
+ * widget id.
+ *
+ * For example, given a fictitious registry such as this:
+ *
+ * ```
+ * interface DummyRegistry {
+ *     categorizer: { categories: ReadonlyArray<string> };
+ *     dropdown: { choices: ReadonlyArray<string> }:
+ * }
+ * ```
+ *
+ * If we create a DummyMap using this helper:
+ *
+ * ```
+ * type DummyMap = MakeWidgetMap<DummyRegistry>;
+ * ```
+ *
+ * We'll get a map that looks like this:
+ *
+ * ```
+ * type DummyMap = {
+ *     `categorizer ${number}`: { categories: ReadonlyArray<string> };
+ *     `dropdown ${number}`: { choices: ReadonlyArray<string> };
+ * }
+ * ```
+ *
+ * We use interfaces for the registries so that they can be extended in cases
+ * where the consuming app brings along their own widgets. Interfaces in
+ * TypeScript are always open (ie. you can extend them) whereas types aren't.
+ */
+
+/**
+ * Our core set of Perseus widgets.
+ *
+ * This interface is the basis for "registering" all Perseus widget types.
+ * There should be one key/value pair for each supported widget. If you create
+ * a new widget, an entry should be added to this interface. Note that this
+ * only registers the widget options type, you'll also need to register the
+ * widget so that it's available at runtime (@see
+ * {@link file://./widgets.ts#registerWidget}).
+ *
+ * Importantly, the key should be the name that is used in widget IDs. For most
+ * widgets that is the same as the widget option's `type` field. In cases where
+ * a widget has been deprecated and replaced with the deprecated-standin
+ * widget, it should be the original widget type!
+ *
+ * If you define the widget outside of this package, you can still add the new
+ * widget to this interface by writing the following in that package that
+ * contains the widget. TypeScript will merge that definition of the
+ * `PerseusWidgets` with the one defined below.
+ *
+ * ```typescript
+ * declare module "@khanacademy/perseus-core" {
+ *     interface PerseusWidgetTypes {
+ *         // A new widget
+ *         "new-awesomeness": MyAwesomeNewWidget;
+ *
+ *         // A deprecated widget
+ *         "super-old-widget": DeprecatedStandinWidget;
+ *     }
+ * }
+ *
+ * // The new widget's options definition
+ * type MyAwesomeNewWidget = WidgetOptions<'new-awesomeness', MyAwesomeNewWidgetOptions>;
+ *
+ * // The deprecated widget's options definition
+ * type SuperOldWidget = WidgetOptions<'super-old-widget', object>;
+ * ```
+ *
+ * This interface can be extended through the magic of TypeScript "Declaration
+ * merging". Specifically, we augment this module and extend this interface.
+ *
+ * @see {@link https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation}
+ */
+
+/**
+ * A map of widget IDs to widget options. This is most often used as the type
+ * for a set of widgets defined in a `PerseusItem` but can also be useful to
+ * represent a function parameter where only `widgets` from a `PerseusItem` are
+ * needed. Today Widget IDs are made up of the widget type and an incrementing
+ * integer (eg. `interactive-graph 1` or `radio 3`). It is suggested to avoid
+ * reading/parsing the widget id to derive any information from it, except in
+ * the case of this map.
+ *
+ * @see {@link PerseusWidgetTypes} additional widgets can be added to this map type
+ * by augmenting the PerseusWidgetTypes with new widget types!
+ */
+
+/**
+ * PerseusWidget is a union of all the different types of widget options that
+ * Perseus knows about.
+ *
+ * Thanks to it being based on PerseusWidgetTypes interface, this union is
+ * automatically extended to include widgets used in tests without those widget
+ * option types seeping into our production types.
+ *
+ * @see MockWidget for an example
+ */
+
+/**
+ * A "PerseusItem" is a classic Perseus item. It is rendered by the
+ * `ServerItemRenderer` and the layout is pre-set.
+ *
+ * To render more complex Perseus items, see the `Item` type in the multi item
+ * area.
+ */
+
+/**
+ * A "PerseusArticle" is an item that is meant to be rendered as an article.
+ * This item is never scored and is rendered by the `ArticleRenderer`.
+ */
+
+const ItemExtras = [
+// The user might benefit from using a Scientific Calculator.  Provided on Khan Academy when true
+"calculator",
+// The user might benefit from using a statistics Chi Squared Table like https://people.richland.edu/james/lecture/m170/tbl-chi.html
+"chi2Table",
+// The user might benefit from a monthly payments calculator.  Provided on Khan Academy when true
+"financialCalculatorMonthlyPayment",
+// The user might benefit from a total amount calculator.  Provided on Khan Academy when true
+"financialCalculatorTotalAmount",
+// The user might benefit from a time to pay off calculator.  Provided on Khan Academy when true
+"financialCalculatorTimeToPayOff",
+// The user might benefit from using a Periodic Table of Elements.  Provided on Khan Academy when true
+"periodicTable",
+// The user might benefit from using a Periodic Table of Elements with key.  Provided on Khan Academy when true
+"periodicTableWithKey",
+// The user might benefit from using a statistics T Table like https://www.statisticshowto.com/tables/t-distribution-table/
+"tTable",
+// The user might benefit from using a statistics Z Table like https://www.ztable.net/
+"zTable"];
+
+/**
+ * The type representing the common structure of all widget's options. The
+ * `Options` generic type represents the widget-specific option data.
+ */
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
+
+// prettier-ignore
 
 // prettier-ignore
 
-// prettier-ignore
+//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 = ([id, widget], widgetMap, ctx) => {
+  const idComponentsResult = parseWidgetIdComponents(id.split(" "), ctx.forSubtree("(widget ID)"));
+  if (isFailure(idComponentsResult)) {
+    return idComponentsResult;
+  }
+  const [type, n] = idComponentsResult.value;
+  function parseAndAssign(key, parse) {
+    const widgetResult = parse(widget, ctx);
+    if (isFailure(widgetResult)) {
+      return widgetResult;
+    }
+    widgetMap[key] = widgetResult.value;
+    return ctx.success(undefined);
+  }
+  switch (type) {
+    case "categorizer":
+      return parseAndAssign(`categorizer ${n}`, parseCategorizerWidget);
+    case "cs-program":
+      return parseAndAssign(`cs-program ${n}`, parseCSProgramWidget);
+    case "definition":
+      return parseAndAssign(`definition ${n}`, parseDefinitionWidget);
+    case "dropdown":
+      return parseAndAssign(`dropdown ${n}`, parseDropdownWidget);
+    case "explanation":
+      return parseAndAssign(`explanation ${n}`, parseExplanationWidget);
+    case "expression":
+      return parseAndAssign(`expression ${n}`, parseExpressionWidget);
+    case "grapher":
+      return parseAndAssign(`grapher ${n}`, parseGrapherWidget);
+    case "group":
+      return parseAndAssign(`group ${n}`, parseGroupWidget);
+    case "graded-group":
+      return parseAndAssign(`graded-group ${n}`, parseGradedGroupWidget);
+    case "graded-group-set":
+      return parseAndAssign(`graded-group-set ${n}`, parseGradedGroupSetWidget);
+    case "iframe":
+      return parseAndAssign(`iframe ${n}`, parseIframeWidget);
+    case "image":
+      return parseAndAssign(`image ${n}`, parseImageWidget);
+    case "input-number":
+      return parseAndAssign(`input-number ${n}`, parseInputNumberWidget);
+    case "interaction":
+      return parseAndAssign(`interaction ${n}`, parseInteractionWidget);
+    case "interactive-graph":
+      return parseAndAssign(`interactive-graph ${n}`, parseInteractiveGraphWidget);
+    case "label-image":
+      return parseAndAssign(`label-image ${n}`, parseLabelImageWidget);
+    case "matcher":
+      return parseAndAssign(`matcher ${n}`, parseMatcherWidget);
+    case "matrix":
+      return parseAndAssign(`matrix ${n}`, parseMatrixWidget);
+    case "measurer":
+      return parseAndAssign(`measurer ${n}`, parseMeasurerWidget);
+    case "molecule-renderer":
+      return parseAndAssign(`molecule-renderer ${n}`, parseMoleculeRendererWidget);
+    case "number-line":
+      return parseAndAssign(`number-line ${n}`, parseNumberLineWidget);
+    case "numeric-input":
+      return parseAndAssign(`numeric-input ${n}`, parseNumericInputWidget);
+    case "orderer":
+      return parseAndAssign(`orderer ${n}`, parseOrdererWidget);
+    case "passage":
+      return parseAndAssign(`passage ${n}`, parsePassageWidget);
+    case "passage-ref":
+      return parseAndAssign(`passage-ref ${n}`, parsePassageRefWidget);
+    case "passage-ref-target":
+      // NOTE(benchristel): as of 2024-11-12, passage-ref-target is only
+      // used in test content. See:
+      // https://www.khanacademy.org/devadmin/content/search?query=widget:passage-ref-target
+      return parseAndAssign(`passage-ref-target ${n}`, any);
+    case "phet-simulation":
+      return parseAndAssign(`phet-simulation ${n}`, parsePhetSimulationWidget);
+    case "plotter":
+      return parseAndAssign(`plotter ${n}`, parsePlotterWidget);
+    case "python-program":
+      return parseAndAssign(`python-program ${n}`, parsePythonProgramWidget);
+    case "radio":
+      return parseAndAssign(`radio ${n}`, parseRadioWidget);
+    case "sorter":
+      return parseAndAssign(`sorter ${n}`, parseSorterWidget);
+    case "table":
+      return parseAndAssign(`table ${n}`, parseTableWidget);
+    case "video":
+      return parseAndAssign(`video ${n}`, parseVideoWidget);
+    case "sequence":
+      // sequence is a deprecated widget type, and the corresponding
+      // widget component no longer exists.
+      return parseAndAssign(`sequence ${n}`, parseDeprecatedWidget);
+    case "lights-puzzle":
+      return parseAndAssign(`lights-puzzle ${n}`, parseDeprecatedWidget);
+    case "simulator":
+      return parseAndAssign(`simulator ${n}`, parseDeprecatedWidget);
+    case "transformer":
+      return parseAndAssign(`transformer ${n}`, parseDeprecatedWidget);
+    default:
+      return parseAndAssign(`${type} ${n}`, parseWidget(constant(type), any));
+  }
+};
+const parseDeprecatedWidget = parseWidget(
+// Ignore the incoming widget type and hardcode "deprecated-standin"
+(_, ctx) => ctx.success("deprecated-standin"),
+// Allow any widget options
+object({}));
+const 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;
+
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (e.includes(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+
+const parseHint = object({
+  replace: optional(boolean),
+  content: string,
+  widgets: defaulted(parseWidgetsMap, () => ({})),
+  metadata: optional(array(string)),
+  images: parseImages
+});
+
+const _excluded$5 = ["type", "options"];
+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
+});
+
+// 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 rest = _objectWithoutPropertiesLoose(rawValue, _excluded$5);
+  return ctx.success(rest);
+}
+
+/**
+ * Helper to parse PerseusItem JSON
+ * Why not just use JSON.parse? We want:
+ * - To make sure types are correct
+ * - To give us a central place to validate/transform output if needed
+ * @deprecated - use parseAndMigratePerseusItem instead
+ * @param {string} json - the stringified PerseusItem JSON
+ * @returns {PerseusItem} the parsed PerseusItem object
+ */
+function parsePerseusItem(json) {
+  // Try to block a cheating vector which relies on monkey-patching
+  // JSON.parse
+  if (isRealJSONParse(JSON.parse)) {
+    return JSON.parse(json);
+  }
+  throw new Error("Something went wrong.");
+}
+/**
+ * Parses a PerseusItem from a JSON string, migrates old formats to the latest
+ * schema, and runtime-typechecks the result. Use this to parse assessmentItem
+ * data.
+ *
+ * @returns a {@link Result} of the parsed PerseusItem. If the result is a
+ * failure, it will contain an error message describing where in the tree
+ * parsing failed.
+ * @throws SyntaxError if the argument is not well-formed JSON.
+ */
+function parseAndMigratePerseusItem(json) {
+  throwErrorIfCheatingDetected();
+  const object = JSON.parse(json);
+  const result = parse(object, parsePerseusItem$1);
+  if (isFailure(result)) {
+    return failure({
+      message: result.detail,
+      invalidObject: object
+    });
+  }
+  return result;
+}
+
+/**
+ * Parses a PerseusArticle from a JSON string, migrates old formats to the
+ * latest schema, and runtime-typechecks the result.
+ *
+ * @returns a {@link Result} of the parsed PerseusArticle. If the result is a
+ * failure, it will contain an error message describing where in the tree
+ * parsing failed.
+ * @throws SyntaxError if the argument is not well-formed JSON.
+ */
+function parseAndMigratePerseusArticle(json) {
+  throwErrorIfCheatingDetected();
+  const object = JSON.parse(json);
+  const result = parse(object, parsePerseusArticle);
+  if (isFailure(result)) {
+    return failure({
+      message: result.detail,
+      invalidObject: object
+    });
+  }
+  return result;
+}
+
+/**
+ * Tries to block a cheating vector that relies on monkey-patching JSON.parse.
+ */
+// TODO(LEMS-2331): delete this function once server-side scoring is done.
+function throwErrorIfCheatingDetected() {
+  if (!isRealJSONParse(JSON.parse)) {
+    throw new Error("Something went wrong.");
+  }
+}
+
+// This file is processed by a Rollup plugin (replace) to inject the production
+const libName = "@khanacademy/perseus-core";
+const libVersion = "3.4.0";
+addLibraryVersionToPerseusDebug(libName, libVersion);
+
+/**
+ * @typedef {Object} Errors utility for referencing the Perseus error taxonomy.
+ */
+const Errors = Object.freeze({
+  /**
+   * @property {ErrorKind} Unknown The kind of error is not known.
+   */
+  Unknown: "Unknown",
+  /**
+   * @property {ErrorKind} Internal The error is internal to the executing code.
+   */
+  Internal: "Internal",
+  /**
+   * @property {ErrorKind} InvalidInput There was a problem with the provided
+   * input, such as the wrong format or a null value.
+   */
+  InvalidInput: "InvalidInput",
+  /**
+   * @property {ErrorKind} NotAllowed There was a problem due to the state of
+   * the system not matching the requested operation or input. For example,
+   * trying to create a username that is valid, but is already taken by
+   * another user. Use {@link InvalidInput} instead when the input isn't
+   * valid regardless of the state of the system. Use {@link NotFound} when
+   * the failure is due to not being able to find a resource.
+   */
+  NotAllowed: "NotAllowed",
+  /**
+   * @property {ErrorKind} TransientService There was a problem when making a
+   * request to a service.
+   */
+  TransientService: "TransientService",
+  /**
+   * @property {ErrorKind} Service There was a non-transient problem when
+   * making a request to service.
+   */
+  Service: "Service"
+});
+
+/**
+ * @type {ErrorKind} The kind of error being reported
+ */
+
+class PerseusError extends Error {
+  constructor(message, kind, options) {
+    super(message);
+    this.kind = void 0;
+    this.metadata = void 0;
+    this.kind = kind;
+    this.metadata = options == null ? void 0 : options.metadata;
+  }
+}
+
+/**
+ * _ utilities for objects
+ */
+
+/**
+ * Does a pluck on keys inside objects in an object
+ *
+ * Ex:
+ * tools = {
+ *     translation: {
+ *         enabled: true
+ *     },
+ *     rotation: {
+ *         enabled: false
+ *     }
+ * };
+ * pluckObject(tools, "enabled") returns {
+ *     translation: true
+ *     rotation: false
+ * }
+ */
+const pluck = function pluck(table, subKey) {
+  return _.object(_.map(table, function (value, key) {
+    return [key, value[subKey]];
+  }));
+};
+
+/**
+ * Maps an object to an object
+ *
+ * > mapObject({a: '1', b: '2'}, (value, key) => {
+ *       return value + 1;
+ *   });
+ * {a: 2, b: 3}
+ */
+const mapObject = function mapObject(obj, lambda) {
+  const result = {};
+  Object.keys(obj).forEach(key => {
+    // @ts-expect-error - TS2345 - Argument of type 'string' is not assignable to parameter of type 'K'.
+    result[key] = lambda(obj[key], key);
+  });
+  return result;
+};
+
+const defaultWidgetOptions$v = {
+  items: [],
+  categories: [],
+  values: [],
+  randomizeItems: false
+};
+const categorizerWidgetLogic = {
+  name: "categorizer",
+  defaultWidgetOptions: defaultWidgetOptions$v
+};
+
+const DEFAULT_HEIGHT = 400;
+const defaultWidgetOptions$u = {
+  programID: "",
+  programType: null,
+  settings: [{
+    name: "",
+    value: ""
+  }],
+  showEditor: false,
+  showButtons: false,
+  height: DEFAULT_HEIGHT
+};
+const csProgramWidgetLogic = {
+  name: "cs-program",
+  defaultWidgetOptions: defaultWidgetOptions$u,
+  supportedAlignments: ["block", "full-width"]
+};
+
+const defaultWidgetOptions$t = {
+  togglePrompt: "",
+  definition: ""
+};
+const definitionWidgetLogic = {
+  name: "definition",
+  defaultWidgetOptions: defaultWidgetOptions$t,
+  defaultAlignment: "inline"
+};
+
+const defaultWidgetOptions$s = {
+  placeholder: "",
+  choices: [{
+    content: "",
+    correct: false
+  }]
+};
+const dropdownWidgetLogic = {
+  name: "definition",
+  defaultWidgetOptions: defaultWidgetOptions$s,
+  defaultAlignment: "inline-block"
+};
+
+const defaultWidgetOptions$r = {
+  showPrompt: "Explain",
+  hidePrompt: "Hide explanation",
+  explanation: "explanation goes here\n\nmore explanation",
+  widgets: {}
+};
+const explanationWidgetLogic = {
+  name: "explanation",
+  defaultWidgetOptions: defaultWidgetOptions$r,
+  defaultAlignment: "inline"
+};
 
-// prettier-ignore
+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$q = {
+  answerForms: [],
+  times: false,
+  buttonSets: ["basic"],
+  functions: ["f", "g", "h"]
+};
 
-// prettier-ignore
+const expressionWidgetLogic = {
+  name: "expression",
+  version: currentVersion$3,
+  widgetOptionsUpgrades: widgetOptionsUpgrades$2,
+  defaultWidgetOptions: defaultWidgetOptions$q,
+  defaultAlignment: "inline-block"
+};
 
-// prettier-ignore
+const defaultWidgetOptions$p = {
+  title: "",
+  content: "",
+  widgets: {},
+  images: {},
+  hint: null
+};
+const gradedGroupWidgetLogic = {
+  name: "graded-group",
+  defaultWidgetOptions: defaultWidgetOptions$p
+};
 
-// prettier-ignore
+const defaultWidgetOptions$o = {
+  gradedGroups: []
+};
+const gradedGroupSetWidgetLogic = {
+  name: "graded-group-set",
+  defaultWidgetOptions: defaultWidgetOptions$o
+};
 
-// prettier-ignore
+const defaultWidgetOptions$n = {
+  graph: {
+    labels: ["x", "y"],
+    range: [[-10, 10], [-10, 10]],
+    step: [1, 1],
+    backgroundImage: {
+      url: null
+    },
+    markings: "graph",
+    rulerLabel: "",
+    rulerTicks: 10,
+    valid: true,
+    showTooltips: false
+  },
+  correct: {
+    type: "linear",
+    coords: null
+  },
+  availableTypes: ["linear"]
+};
+const grapherWidgetLogic = {
+  name: "grapher",
+  defaultWidgetOptions: defaultWidgetOptions$n
+};
 
-// prettier-ignore
+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
+};
 
-// prettier-ignore
+const defaultWidgetOptions$l = {
+  url: "",
+  settings: [{
+    name: "",
+    value: ""
+  }],
+  width: "400",
+  height: "400",
+  allowFullScreen: false,
+  allowTopNavigation: false
+};
+const iframeWidgetLogic = {
+  name: "iframe",
+  defaultWidgetOptions: defaultWidgetOptions$l
+};
 
-// prettier-ignore
+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,
+  supportedAlignments: ["block", "full-width"],
+  defaultAlignment: "block"
+};
 
-// prettier-ignore
+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,
+  defaultAlignment: "inline-block"
+};
 
-// prettier-ignore
+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
+};
 
-// prettier-ignore
+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
+};
 
-// prettier-ignore
+const defaultWidgetOptions$g = {
+  choices: [],
+  imageAlt: "",
+  imageUrl: "",
+  imageWidth: 0,
+  imageHeight: 0,
+  markers: [],
+  multipleAnswers: false,
+  hideChoicesFromInstructions: false
+};
+const labelImageWidgetLogic = {
+  name: "label-image",
+  defaultWidgetOptions: defaultWidgetOptions$g
+};
 
-// prettier-ignore
+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
+};
 
-// prettier-ignore
+const defaultWidgetOptions$e = {
+  matrixBoardSize: [3, 3],
+  answers: [[]],
+  prefix: "",
+  suffix: "",
+  cursorPosition: [0, 0]
+};
+const matrixWidgetLogic = {
+  name: "matrix",
+  defaultWidgetOptions: defaultWidgetOptions$e
+};
 
-// prettier-ignore
+const _excluded$4 = ["imageUrl", "imageTop", "imageLeft"];
+const currentVersion$2 = {
+  major: 1,
+  minor: 0
+};
+const widgetOptionsUpgrades$1 = {
+  "1": v0options => {
+    const {
+        imageUrl,
+        imageTop,
+        imageLeft
+      } = v0options,
+      rest = _objectWithoutPropertiesLoose(v0options, _excluded$4);
+    return _extends({}, 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
+};
 
-// prettier-ignore
+const measurerWidgetLogic = {
+  name: "measurer",
+  version: currentVersion$2,
+  widgetOptionsUpgrades: widgetOptionsUpgrades$1,
+  defaultWidgetOptions: defaultWidgetOptions$d
+};
 
-// prettier-ignore
+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
+};
 
-// prettier-ignore
+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,
+  defaultAlignment: "inline-block"
+};
 
-// prettier-ignore
+const defaultWidgetOptions$a = {
+  correctOptions: [{
+    content: "$x$"
+  }],
+  otherOptions: [{
+    content: "$y$"
+  }],
+  height: "normal",
+  layout: "horizontal"
+};
+const ordererWidgetLogic = {
+  name: "orderer",
+  defaultWidgetOptions: defaultWidgetOptions$a
+};
 
-// prettier-ignore
+const defaultWidgetOptions$9 = {
+  passageTitle: "",
+  passageText: "",
+  footnotes: "",
+  showLineNumbers: true
+};
+const passageWidgetLogic = {
+  name: "passage",
+  defaultWidgetOptions: defaultWidgetOptions$9
+};
 
-// prettier-ignore
+const currentVersion$1 = {
+  major: 0,
+  minor: 1
+};
+const defaultWidgetOptions$8 = {
+  passageNumber: 1,
+  referenceNumber: 1,
+  summaryText: ""
+};
 
-// prettier-ignore
+const passageRefWidgetLogic = {
+  name: "passageRef",
+  version: currentVersion$1,
+  defaultWidgetOptions: defaultWidgetOptions$8,
+  defaultAlignment: "inline"
+};
 
-// prettier-ignore
+const defaultWidgetOptions$7 = {
+  content: ""
+};
+const passageRefTargetWidgetLogic = {
+  name: "passageRefTarget",
+  defaultWidgetOptions: defaultWidgetOptions$7,
+  defaultAlignment: "inline"
+};
 
-// prettier-ignore
+const defaultWidgetOptions$6 = {
+  url: "",
+  description: ""
+};
+const phetSimulationWidgetLogic = {
+  name: "phet-simulation",
+  defaultWidgetOptions: defaultWidgetOptions$6
+};
 
-// prettier-ignore
+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
+};
 
-// prettier-ignore
+const defaultWidgetOptions$4 = {
+  programID: "",
+  height: 400
+};
+const pythonProgramWidgetLogic = {
+  name: "python-program",
+  defaultWidgetOptions: defaultWidgetOptions$4
+};
 
-// prettier-ignore
+const _excluded$3 = ["noneOfTheAbove"];
+const currentVersion = {
+  major: 1,
+  minor: 0
+};
+const widgetOptionsUpgrades = {
+  "1": v0props => {
+    const {
+        noneOfTheAbove
+      } = v0props,
+      rest = _objectWithoutPropertiesLoose(v0props, _excluded$3);
+    if (noneOfTheAbove) {
+      throw new Error("radio widget v0 no longer supports auto noneOfTheAbove");
+    }
+    return _extends({}, rest, {
+      hasNoneOfTheAbove: false
+    });
+  }
+};
+const defaultWidgetOptions$3 = {
+  choices: [{}, {}, {}, {}],
+  displayCount: null,
+  randomize: false,
+  hasNoneOfTheAbove: false,
+  multipleSelect: false,
+  countChoices: false,
+  deselectEnabled: false
+};
 
-//prettier-ignore
+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,
+  supportedAlignments: ["block", "float-left", "float-right", "full-width"],
+  defaultAlignment: "block"
+};
+
+const widgets = {};
+function registerWidget(type, logic) {
+  widgets[type] = logic;
+}
+function isWidgetRegistered(type) {
+  const widgetLogic = widgets[type];
+  return !!widgetLogic;
+}
+function getCurrentVersion(type) {
+  const widgetLogic = widgets[type];
+  return (widgetLogic == null ? void 0 : widgetLogic.version) || {
+    major: 0,
+    minor: 0
+  };
+}
+function getWidgetOptionsUpgrades(type) {
+  const widgetLogic = widgets[type];
+  return (widgetLogic == null ? void 0 : widgetLogic.widgetOptionsUpgrades) || {};
+}
+function getDefaultWidgetOptions(type) {
+  const widgetLogic = widgets[type];
+  return (widgetLogic == null ? void 0 : widgetLogic.defaultWidgetOptions) || {};
+}
 
 /**
- * A background image applied to various widgets.
+ * Handling for the optional alignments for widgets
+ * See widget-container.jsx for details on how alignments are implemented.
  */
 
 /**
- * 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
+ * Returns the list of supported alignments for the given (string) widget
+ * type. This is used primarily at editing time to display the choices
+ * for the user.
+ *
+ * Supported alignments are given as an array of strings in the exports of
+ * a widget's module.
  */
+const getSupportedAlignments = type => {
+  var _widgetLogic$supporte;
+  const widgetLogic = widgets[type];
+  if (!(widgetLogic != null && (_widgetLogic$supporte = widgetLogic.supportedAlignments) != null && _widgetLogic$supporte[0])) {
+    // default alignments
+    return ["default"];
+  }
+  return widgetLogic == null ? void 0 : widgetLogic.supportedAlignments;
+};
 
-const PerseusExpressionAnswerFormConsidered = ["correct", "wrong", "ungraded"];
+/**
+ * For the given (string) widget type, determine the default alignment for
+ * the widget. This is used at rendering time to go from "default" alignment
+ * to the actual alignment displayed on the screen.
+ *
+ * The default alignment is given either as a string (called
+ * `defaultAlignment`) or a function (called `getDefaultAlignment`) on
+ * the exports of a widget's module.
+ */
+const getDefaultAlignment = type => {
+  const widgetLogic = widgets[type];
+  if (!(widgetLogic != null && widgetLogic.defaultAlignment)) {
+    return "block";
+  }
+  return widgetLogic.defaultAlignment;
+};
+registerWidget("categorizer", categorizerWidgetLogic);
+registerWidget("cs-program", csProgramWidgetLogic);
+registerWidget("definition", definitionWidgetLogic);
+registerWidget("dropdown", dropdownWidgetLogic);
+registerWidget("explanation", explanationWidgetLogic);
+registerWidget("expression", expressionWidgetLogic);
+registerWidget("graded-group", gradedGroupWidgetLogic);
+registerWidget("graded-group-set", gradedGroupSetWidgetLogic);
+registerWidget("grapher", grapherWidgetLogic);
+registerWidget("group", groupWidgetLogic);
+registerWidget("iframe", iframeWidgetLogic);
+registerWidget("image", imageWidgetLogic);
+registerWidget("input-number", inputNumberWidgetLogic);
+registerWidget("interaction", interactionWidgetLogic);
+registerWidget("interactive-graph", interactiveGraphWidgetLogic);
+registerWidget("label-image", labelImageWidgetLogic);
+registerWidget("matcher", matcherWidgetLogic);
+registerWidget("matrix", matrixWidgetLogic);
+registerWidget("measurer", measurerWidgetLogic);
+registerWidget("number-line", numberLineWidgetLogic);
+registerWidget("numeric-input", numericInputWidgetLogic);
+registerWidget("orderer", ordererWidgetLogic);
+registerWidget("passage", passageWidgetLogic);
+registerWidget("passage-ref", passageRefWidgetLogic);
+registerWidget("passage-ref-target", passageRefTargetWidgetLogic);
+registerWidget("phet-simulation", phetSimulationWidgetLogic);
+registerWidget("plotter", plotterWidgetLogic);
+registerWidget("python-program", pythonProgramWidgetLogic);
+registerWidget("radio", radioWidgetLogic);
+registerWidget("sorter", sorterWidgetLogic);
+registerWidget("table", tableWidgetLogic);
+registerWidget("video", videoWidgetLogic);
+
+var coreWidgetRegistry = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    isWidgetRegistered: isWidgetRegistered,
+    getCurrentVersion: getCurrentVersion,
+    getWidgetOptionsUpgrades: getWidgetOptionsUpgrades,
+    getDefaultWidgetOptions: getDefaultWidgetOptions,
+    getSupportedAlignments: getSupportedAlignments,
+    getDefaultAlignment: getDefaultAlignment
+});
 
-// 2D range: xMin, xMax, yMin, yMax
+const DEFAULT_STATIC = false;
+const upgradeWidgetInfoToLatestVersion = oldWidgetInfo => {
+  const type = oldWidgetInfo.type;
+  // NOTE(jeremy): This looks like it could be replaced by fixing types so
+  // that `type` is non-optional. But we're seeing this in Sentry today so I
+  // suspect we have legacy data (potentially unpublished) and we should
+  // figure that out before depending solely on types.
+  if (!_.isString(type)) {
+    throw new PerseusError("widget type must be a string, but was: " + type, Errors.Internal);
+  }
+  if (!isWidgetRegistered(type)) {
+    // If we have a widget that isn't registered, we can't upgrade it
+    // TODO(aria): Figure out what the best thing to do here would be
+    return oldWidgetInfo;
+  }
 
-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
+  // Unversioned widgets (pre-July 2014) are all implicitly 0.0
+  const initialVersion = oldWidgetInfo.version || {
+    major: 0,
+    minor: 0
+  };
+  const latestVersion = getCurrentVersion(type);
+
+  // If the widget version is later than what we understand (major
+  // version is higher than latest, or major versions are equal and minor
+  // version is higher than latest), don't perform any upgrades.
+  if (initialVersion.major > latestVersion.major || initialVersion.major === latestVersion.major && initialVersion.minor > latestVersion.minor) {
+    return oldWidgetInfo;
+  }
+
+  // We do a clone here so that it's safe to mutate the input parameter
+  // in propUpgrades functions (which I will probably accidentally do at
+  // some point, and we would like to not break when that happens).
+  let newEditorOptions = _.clone(oldWidgetInfo.options) || {};
+  const upgradePropsMap = getWidgetOptionsUpgrades(type);
+
+  // Empty props usually mean a newly created widget by the editor,
+  // and are always considerered up-to-date.
+  // Mostly, we'd rather not run upgrade functions on props that are
+  // not complete.
+  if (_.keys(newEditorOptions).length !== 0) {
+    // We loop through all the versions after the current version of
+    // the loaded widget, up to and including the latest version of the
+    // loaded widget, and run the upgrade function to bring our loaded
+    // widget's props up to that version.
+    // There is a little subtlety here in that we call
+    // upgradePropsMap[1] to upgrade *to* version 1,
+    // (not from version 1).
+    for (let nextVersion = initialVersion.major + 1; nextVersion <= latestVersion.major; nextVersion++) {
+      if (upgradePropsMap[String(nextVersion)]) {
+        newEditorOptions = upgradePropsMap[String(nextVersion)](newEditorOptions);
+      } else {
+        throw new PerseusError("No upgrade found for widget. Cannot render.", Errors.Internal, {
+          metadata: {
+            type,
+            fromMajorVersion: nextVersion - 1,
+            toMajorVersion: nextVersion,
+            oldWidgetInfo: JSON.stringify(oldWidgetInfo)
+          }
+        });
+      }
+    }
+  }
+
+  // Minor version upgrades (eg. new optional props) don't have
+  // transform functions. Instead, we fill in the new props with their
+  // defaults.
+  const defaultOptions = getDefaultWidgetOptions(type);
+  newEditorOptions = _extends({}, defaultOptions, newEditorOptions);
+  let alignment = oldWidgetInfo.alignment;
+
+  // Widgets that support multiple alignments will "lock in" the
+  // alignment to the alignment that would be listed first in the
+  // select box. If the widget only supports one alignment, the
+  // alignment value will likely just end up as "default".
+  if (alignment == null || alignment === "default") {
+    var _getSupportedAlignmen;
+    alignment = (_getSupportedAlignmen = getSupportedAlignments(type)) == null ? void 0 : _getSupportedAlignmen[0];
+    if (!alignment) {
+      throw new PerseusError("No default alignment found when upgrading widget", Errors.Internal, {
+        metadata: {
+          widgetType: type
+        }
+      });
+    }
+  }
+  let widgetStatic = oldWidgetInfo.static;
+  if (widgetStatic == null) {
+    widgetStatic = DEFAULT_STATIC;
+  }
+  return _extends({}, oldWidgetInfo, {
+    // maintain other info, like type
+    // After upgrading we guarantee that the version is up-to-date
+    version: latestVersion,
+    // Default graded to true (so null/undefined becomes true):
+    graded: oldWidgetInfo.graded != null ? oldWidgetInfo.graded : true,
+    alignment: alignment,
+    static: widgetStatic,
+    options: newEditorOptions
+  });
 };
+function getUpgradedWidgetOptions(oldWidgetOptions) {
+  return mapObject(oldWidgetOptions, (widgetInfo, widgetId) => {
+    if (!widgetInfo.type || !widgetInfo.alignment) {
+      const newValues = {};
+      if (!widgetInfo.type) {
+        // TODO: why does widget have no type?
+        // We don't want to derive type from widget ID
+        // see: LEMS-1845
+        newValues.type = widgetId.split(" ")[0];
+      }
+      if (!widgetInfo.alignment) {
+        newValues.alignment = "default";
+      }
+      widgetInfo = _extends({}, widgetInfo, newValues);
+    }
+    return upgradeWidgetInfoToLatestVersion(widgetInfo);
+  });
+}
 
-// Not associated with a specific figure
+/**
+ * For details on the individual options, see the
+ * PerseusOrdererWidgetOptions type
+ */
 
-const plotterPlotTypes = ["bar", "line", "pic", "histogram", "dotplot"];
+/**
+ * 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
+  };
+}
 
 /**
- * _ utilities for objects
+ * For details on the individual options, see the
+ * PerseusCategorizerWidgetOptions type
  */
 
 /**
- * Does a pluck on keys inside objects in an object
- *
- * Ex:
- * tools = {
- *     translation: {
- *         enabled: true
- *     },
- *     rotation: {
- *         enabled: false
- *     }
- * };
- * pluckObject(tools, "enabled") returns {
- *     translation: true
- *     rotation: false
- * }
+ * Given a PerseusCategorizerWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
  */
-const pluck = function pluck(table, subKey) {
-  return _.object(_.map(table, function (value, key) {
-    return [key, value[subKey]];
-  }));
-};
+function getCategorizerPublicWidgetOptions(options) {
+  return {
+    items: options.items,
+    categories: options.categories,
+    randomizeItems: options.randomizeItems,
+    static: options.static
+  };
+}
+
+function getCSProgramPublicWidgetOptions(options) {
+  return options;
+}
 
 /**
- * Maps an object to an object
- *
- * > mapObject({a: '1', b: '2'}, (value, key) => {
- *       return value + 1;
- *   });
- * {a: 2, b: 3}
+ * For details on the individual options, see the
+ * PerseusExpressionWidgetOptions type
  */
-const mapObject = function mapObject(obj, lambda) {
-  const result = {};
-  Object.keys(obj).forEach(key => {
-    // @ts-expect-error - TS2345 - Argument of type 'string' is not assignable to parameter of type 'K'.
-    result[key] = lambda(obj[key], key);
+
+/**
+ * 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
+  };
+}
+
+const _excluded$2 = ["answers"];
+/**
+ * For details on the individual options, see the
+ * PerseusLabelImageWidgetOptions type
+ */
+
+function getLabelImagePublicWidgetOptions(options) {
+  return _extends({}, options, {
+    markers: options.markers.map(getLabelImageMarkerPublicData)
   });
-  return result;
-};
+}
+function getLabelImageMarkerPublicData(marker) {
+  const publicData = _objectWithoutPropertiesLoose(marker, _excluded$2);
+  return publicData;
+}
+
+/**
+ * For details on the individual options, see the
+ * PerseusSorterWidgetOptions type
+ */
+
+/**
+ * Given a PerseusSorterWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getSorterPublicWidgetOptions(options) {
+  return {
+    // Note(Tamara): This does not provide correct answer information any longer.
+    // To maintain compatibility with the original widget options, we are
+    // keeping the key the same. Represents initial state of the cards here.
+    correct: options.correct.slice().sort(),
+    padding: options.padding,
+    layout: options.layout
+  };
+}
+
+/**
+ * For details on the individual options, see the
+ * PerseusDropdownWidgetOptions type
+ */
+
+/**
+ * Given a PerseusDropdownWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getDropdownPublicWidgetOptions(options) {
+  return {
+    choices: options.choices.map(choice => ({
+      content: choice.content
+    })),
+    placeholder: options.placeholder,
+    static: options.static,
+    visibleLabel: options.visibleLabel,
+    ariaLabel: options.ariaLabel
+  };
+}
+
+const _excluded$1 = ["answers"];
+/**
+ * For details on the individual options, see the
+ * PerseusNumericInputWidgetOptions type
+ */
+
+/**
+ * Given a PerseusNumericInputWidgetOptions object, return a new object with only
+ * the public options that should be exposed to the client.
+ */
+function getNumericInputPublicWidgetOptions(options) {
+  const publicWidgetOptions = _objectWithoutPropertiesLoose(options, _excluded$1);
+  return publicWidgetOptions;
+}
+
+const _excluded = ["correctX", "correctRel"];
+function getNumberLinePublicWidgetOptions(options) {
+  const publicOptions = _objectWithoutPropertiesLoose(options, _excluded);
+  return publicOptions;
+}
 
-export { Errors, grapherUtil as GrapherUtil, ItemExtras, PerseusError, PerseusExpressionAnswerFormConsidered, addLibraryVersionToPerseusDebug, approximateDeepEqual, approximateEqual, deepClone, getDecimalSeparator, getMatrixSize, libVersion, lockedFigureColorNames, lockedFigureColors, lockedFigureFillStyles, mapObject, plotterPlotTypes, pluck };
+export { coreWidgetRegistry as CoreWidgetRegistry, Errors, grapherUtil as GrapherUtil, ItemExtras, PerseusError, PerseusExpressionAnswerFormConsidered, addLibraryVersionToPerseusDebug, addWidget, approximateDeepEqual, approximateEqual, categorizerWidgetLogic as categorizerLogic, csProgramWidgetLogic as csProgramLogic, deepClone, definitionWidgetLogic as definitionLogic, dropdownWidgetLogic as dropdownLogic, explanationWidgetLogic as explanationLogic, expressionWidgetLogic as expressionLogic, getCSProgramPublicWidgetOptions, getCategorizerPublicWidgetOptions, getDecimalSeparator, getDropdownPublicWidgetOptions, getExpressionPublicWidgetOptions, getLabelImagePublicWidgetOptions, getMatrixSize, getNumberLinePublicWidgetOptions, getNumericInputPublicWidgetOptions, getOrdererPublicWidgetOptions, getSorterPublicWidgetOptions, getUpgradedWidgetOptions, getWidgetIdsFromContent, getWidgetIdsFromContentByType, gradedGroupWidgetLogic as gradedGroupLogic, gradedGroupSetWidgetLogic as gradedGroupSetLogic, grapherWidgetLogic as grapherLogic, groupWidgetLogic as groupLogic, iframeWidgetLogic as iframeLogic, imageWidgetLogic as imageLogic, inputNumberWidgetLogic as inputNumberLogic, interactionWidgetLogic as interactionLogic, interactiveGraphWidgetLogic as interactiveGraphLogic, isFailure, isSuccess, labelImageWidgetLogic as labelImageLogic, libVersion, lockedFigureColorNames, lockedFigureColors, lockedFigureFillStyles, mapObject, matcherWidgetLogic as matcherLogic, matrixWidgetLogic as matrixLogic, measurerWidgetLogic as measurerLogic, numberLineWidgetLogic as numberLineLogic, numericInputWidgetLogic as numericInputLogic, ordererWidgetLogic as ordererLogic, parseAndMigratePerseusArticle, parseAndMigratePerseusItem, parsePerseusItem, passageWidgetLogic as passageLogic, passageRefWidgetLogic as passageRefLogic, passageRefTargetWidgetLogic as passageRefTargetLogic, phetSimulationWidgetLogic as phetSimulationLogic, plotterWidgetLogic as plotterLogic, plotterPlotTypes, pluck, pythonProgramWidgetLogic as pythonProgramLogic, radioWidgetLogic as radioLogic, sorterWidgetLogic as sorterLogic, tableWidgetLogic as tableLogic, upgradeWidgetInfoToLatestVersion, videoWidgetLogic as videoLogic };
 //# sourceMappingURL=index.js.map