@khanacademy/perseus-core 7.0.0 → 7.0.2

package/dist/index.js

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