@khanacademy/perseus 49.2.0 → 49.2.2

package/dist/index.js

@@ -32688,7 +32688,7 @@ const LegacyGrid = _ref => {
  *         "new-awesomeness": MyAwesomeNewWidget;
  *
  *         // A deprecated widget
- *         "super-old-widget": AutoCorrectWidget;
+ *         "super-old-widget": DeprecatedStandinWidget;
  *     }
  * }
  *
@@ -32882,7 +32882,6 @@ function LockedLabel(props) {
 
 function GraphLockedLabelsLayer(props) {
   const {
-    flags,
     lockedFigures
   } = props;
   return lockedFigures.map((figure, i) => {
@@ -32891,30 +32890,15 @@ function GraphLockedLabelsLayer(props) {
         key: `label-${i}`
       }, figure));
     }
-    if (
-    // Point flag + point type
-    flags?.["mafs"]?.["locked-point-labels"] && figure.type === "point" ||
-    // Line flag + line type
-    flags?.["mafs"]?.["locked-line-labels"] && figure.type === "line" ||
-    // Vector flag + vector type
-    flags?.["mafs"]?.["locked-vector-labels"] && figure.type === "vector" ||
-    // Ellipse flag + ellipse type
-    flags?.["mafs"]?.["locked-ellipse-labels"] && figure.type === "ellipse" ||
-    // Polygon flag + polygon type
-    flags?.["mafs"]?.["locked-polygon-labels"] && figure.type === "polygon" ||
-    // Function flag + function type
-    flags?.["mafs"]?.["locked-function-labels"] && figure.type === "function") {
-      return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, {
-        key: i
-      }, figure.labels?.map((label, j) => /*#__PURE__*/React__namespace.createElement(LockedLabel, _extends({
-        key: `${i}-label-${j}`
-      }, label))), figure.type === "line" && /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, figure.points[0].labels?.map((label, k) => /*#__PURE__*/React__namespace.createElement(LockedLabel, _extends({
-        key: `locked-figure-${i}-point-1-label-${k}`
-      }, label))), figure.points[1].labels?.map((label, k) => /*#__PURE__*/React__namespace.createElement(LockedLabel, _extends({
-        key: `locked-figure-${i}-point-2-label-${k}`
-      }, label)))));
-    }
-    return null;
+    return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, {
+      key: i
+    }, figure.labels?.map((label, j) => /*#__PURE__*/React__namespace.createElement(LockedLabel, _extends({
+      key: `${i}-label-${j}`
+    }, label))), figure.type === "line" && /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, figure.points[0].labels?.map((label, k) => /*#__PURE__*/React__namespace.createElement(LockedLabel, _extends({
+      key: `locked-figure-${i}-point-1-label-${k}`
+    }, label))), figure.points[1].labels?.map((label, k) => /*#__PURE__*/React__namespace.createElement(LockedLabel, _extends({
+      key: `locked-figure-${i}-point-2-label-${k}`
+    }, label)))));
   });
 }
 
@@ -32926,10 +32910,9 @@ const LockedEllipse = props => {
     color,
     fillStyle,
     strokeStyle,
-    ariaLabel,
-    flags
+    ariaLabel
   } = props;
-  const hasAria = ariaLabel && flags?.["mafs"]?.["locked-figures-aria"];
+  const hasAria = !!ariaLabel;
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: "locked-ellipse",
     "aria-label": hasAria ? ariaLabel : undefined,
@@ -32966,7 +32949,7 @@ const LockedFunction = props => {
     style: strokeStyle,
     domain
   };
-  const hasAria = props.ariaLabel && props.flags?.["mafs"]?.["locked-figures-aria"];
+  const hasAria = !!props.ariaLabel;
   React.useEffect(() => {
     // Parsing the equation in a "useEffect" hook saves about 2ms each frame
     //    when the learner is interacting with the graph (i.e. moving points).
@@ -33093,11 +33076,10 @@ const LockedLine = props => {
     showPoint1,
     showPoint2,
     ariaLabel,
-    flags,
     range
   } = props;
   const [point1, point2] = points;
-  const hasAria = ariaLabel && flags?.["mafs"]?.["locked-figures-aria"];
+  const hasAria = !!ariaLabel;
   let line;
   if (kind === "ray") {
     // Rays extend to the end of the graph in one direction.
@@ -33165,14 +33147,13 @@ const LockedLine = props => {
 
 const LockedPoint = props => {
   const {
-    flags,
     color,
     coord,
     filled,
     ariaLabel
   } = props;
   const [x, y] = coord;
-  const hasAria = ariaLabel && flags?.["mafs"]?.["locked-figures-aria"];
+  const hasAria = !!ariaLabel;
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: "locked-point",
     "aria-label": hasAria ? ariaLabel : undefined,
@@ -33198,7 +33179,7 @@ const LockedPolygon = props => {
     fillStyle,
     strokeStyle
   } = props;
-  const hasAria = props.ariaLabel && props.flags?.["mafs"]?.["locked-figures-aria"];
+  const hasAria = !!props.ariaLabel;
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: "locked-polygon",
     "aria-label": hasAria ? props.ariaLabel : undefined,
@@ -33229,11 +33210,10 @@ const LockedVector = props => {
   const {
     color,
     points,
-    ariaLabel,
-    flags
+    ariaLabel
   } = props;
   const [tail, tip] = points;
-  const hasAria = ariaLabel && flags?.["mafs"]?.["locked-figures-aria"];
+  const hasAria = !!ariaLabel;
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: "locked-vector",
     "aria-label": hasAria ? ariaLabel : undefined,
@@ -33247,7 +33227,6 @@ const LockedVector = props => {
 
 const GraphLockedLayer = props => {
   const {
-    flags,
     lockedFigures
   } = props;
   return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, lockedFigures.map((figure, index) => {
@@ -33255,40 +33234,28 @@ const GraphLockedLayer = props => {
       case "point":
         return /*#__PURE__*/React__namespace.createElement(LockedPoint, _extends({
           key: `point-${index}`
-        }, figure, {
-          flags: flags
-        }));
+        }, figure));
       case "line":
         return /*#__PURE__*/React__namespace.createElement(LockedLine, _extends({
           key: `line-${index}`,
           range: props.range
-        }, figure, {
-          flags: flags
-        }));
+        }, figure));
       case "vector":
         return /*#__PURE__*/React__namespace.createElement(LockedVector, _extends({
           key: `vector-${index}`
-        }, figure, {
-          flags: flags
-        }));
+        }, figure));
       case "ellipse":
         return /*#__PURE__*/React__namespace.createElement(LockedEllipse, _extends({
           key: `ellipse-${index}`
-        }, figure, {
-          flags: flags
-        }));
+        }, figure));
       case "polygon":
         return /*#__PURE__*/React__namespace.createElement(LockedPolygon, _extends({
           key: `polygon-${index}`
-        }, figure, {
-          flags: flags
-        }));
+        }, figure));
       case "function":
         return /*#__PURE__*/React__namespace.createElement(LockedFunction, _extends({
           key: `function-${index}`
-        }, figure, {
-          flags: flags
-        }));
+        }, figure));
       case "label":
         // This is rendered outside the SVG element, since
         // TeX cannot be rendered inside an SVG.
@@ -35930,11 +35897,9 @@ const MafsGraph = props => {
   })),
   // Only render the axis ticks and arrows if the markings are set to a full "graph"
   props.markings === "graph" && /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(AxisTicks, null), /*#__PURE__*/React__namespace.createElement(AxisArrows, null)), /*#__PURE__*/React__namespace.createElement("svg", nestedSVGAttributes, props.lockedFigures && /*#__PURE__*/React__namespace.createElement(GraphLockedLayer, {
-    flags: props.flags,
     lockedFigures: props.lockedFigures,
     range: state.range
-  }))), props.flags?.["mafs"]?.["interactive-graph-locked-features-labels"] && props.lockedFigures && /*#__PURE__*/React__namespace.createElement(GraphLockedLabelsLayer, {
-    flags: props.flags,
+  }))), props.lockedFigures && /*#__PURE__*/React__namespace.createElement(GraphLockedLabelsLayer, {
     lockedFigures: props.lockedFigures
   }), /*#__PURE__*/React__namespace.createElement(wonderBlocksCore.View, {
     style: {
@@ -45944,7 +45909,7 @@ const init = function () {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus";
-const libVersion = "49.2.0";
+const libVersion = "49.2.2";
 perseusCore.addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {
@@ -48244,10 +48209,10 @@ class UnionBuilder {
     this.parser = parser;
   }
   or(newBranch) {
-    return new UnionBuilder(either$1(this.parser, newBranch));
+    return new UnionBuilder(either(this.parser, newBranch));
   }
 }
-function either$1(parseA, parseB) {
+function either(parseA, parseB) {
   return (rawValue, ctx) => {
     const resultA = parseA(rawValue, ctx);
     if (isSuccess(resultA)) {
@@ -48300,9 +48265,9 @@ function parseWidgetWithVersion(parseVersion, parseType, parseOptions) {
 const parseCategorizerWidget = parseWidget(constant("categorizer"), object({
   items: array(string),
   categories: array(string),
-  randomizeItems: boolean,
+  randomizeItems: defaulted(boolean, () => false),
   static: defaulted(boolean, () => false),
-  values: array(number),
+  values: array(defaulted(number, () => 0)),
   highlightLint: optional(boolean),
   linterContext: optional(object({
     contentType: string,
@@ -48322,7 +48287,7 @@ const parseCSProgramWidget = parseWidget(constant("cs-program"), object({
   showButtons: boolean,
   width: number,
   height: number,
-  static: boolean
+  static: defaulted(boolean, () => false)
 }));
 
 const parseDefinitionWidget = parseWidget(constant("definition"), object({
@@ -48332,7 +48297,7 @@ const parseDefinitionWidget = parseWidget(constant("definition"), object({
 }));
 
 const parseDropdownWidget = parseWidget(constant("dropdown"), object({
-  placeholder: string,
+  placeholder: defaulted(string, () => ""),
   ariaLabel: optional(string),
   visibleLabel: optional(string),
   static: defaulted(boolean, () => false),
@@ -48365,60 +48330,63 @@ function convert(f) {
  * data does not match any of the versions.
  *
  * @example
- * const parseOptions = versionedWidgetOptions(parseOptionsV3)
- *     .withMigrationFrom(parseOptionsV2, migrateV2ToV3)
- *     .withMigrationFrom(parseOptionsV1, migrateV1ToV2)
- *     .withMigrationFrom(parseOptionsV0, migrateV0ToV1)
+ * 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. This should check version.major and fail if it's not the latest
- * version.
+ * 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(parseLatest) {
-  return new VersionedWidgetOptionsParserBuilder(parseLatest, latest => latest);
+function versionedWidgetOptions(latestMajorVersion, parseLatest) {
+  return new VersionedWidgetOptionsParserBuilder(latestMajorVersion, parseLatest, latest => latest, (raw, ctx) => ctx.failure("widget options with a known version number", raw));
 }
 class VersionedWidgetOptionsParserBuilder {
-  constructor(parser, migrate) {
-    this.parser = parser;
-    this.migrate = migrate;
+  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.
-   *
-   * @returns a VersionedWidgetOptionsParserBuilder whose `parser` function
-   * is capable of migrating the old version to the latest version. The parser
-   * will always return the latest version of the widget options on a
-   * successful parse.
-   * @param parseOldVersion should be a {@link Parser} for the old options
-   * type. It should fail if version.major isn't correct.
-   * @param migrateToNextVersion should migrate the `Old` data to the
-   * `Migratable` version of the current VersionedWidgetOptionsParserBuilder.
-   * Usually, this means migrating to the next major version.
    */
-  withMigrationFrom(parseOldVersion, migrateToNextVersion) {
-    const parseLatestVersion = this.parser;
-    const migrateToLatest = old => this.migrate(migrateToNextVersion(old));
-    return new VersionedWidgetOptionsParserBuilder((raw, ctx) => {
-      const resultOfParsingLatest = parseLatestVersion(raw, ctx);
-      if (isSuccess(resultOfParsingLatest)) {
-        return resultOfParsingLatest;
-      }
-      const resultOfParsingOld = parseOldVersion(raw, ctx);
-      if (isSuccess(resultOfParsingOld)) {
-        return success(migrateToLatest(resultOfParsingOld.value));
-      }
-
-      // If we're here, neither parse succeeded. Return the failure.
-      return resultOfParsingOld;
-    }, migrateToLatest);
+  withMigrationFrom(majorVersion, parseOldVersion, migrateToNextVersion) {
+    const parseOtherVersions = this.parser;
+    const migrateToLatest = old => this.migrateToLatest(migrateToNextVersion(old));
+    return new VersionedWidgetOptionsParserBuilder(majorVersion, parseOldVersion, migrateToLatest, parseOtherVersions);
   }
 }
+const parseVersionedObject = object({
+  version: defaulted(object({
+    major: number,
+    minor: number
+  }), () => ({
+    major: 0,
+    minor: 0
+  }))
+});
 
+const stringOrNumberOrNullOrUndefined = union(string).or(number).or(constant(null)).or(constant(undefined)).parser;
 const parsePossiblyInvalidAnswerForm = object({
   // `value` is the possibly invalid part of this. It should always be a
   // string, but some answer forms don't have it. The Expression widget
@@ -48427,7 +48395,7 @@ const parsePossiblyInvalidAnswerForm = object({
   form: defaulted(boolean, () => false),
   simplify: defaulted(boolean, () => false),
   considered: enumeration("correct", "wrong", "ungraded"),
-  key: pipeParsers(optional(union(string).or(number).parser)).then((key, ctx) => ctx.success(String(key))).parser
+  key: pipeParsers(stringOrNumberOrNullOrUndefined).then(convert(String)).parser
 });
 function removeInvalidAnswerForms(possiblyInvalid) {
   const valid = [];
@@ -48445,6 +48413,11 @@ function removeInvalidAnswerForms(possiblyInvalid) {
   }
   return valid;
 }
+
+// NOTE(benchristel): I copied the default buttonSets from
+// expression.tsx. See the parse-perseus-json/README.md for
+// an explanation of why we want to duplicate the default here.
+const parseButtonSets = defaulted(array(enumeration("basic", "basic+div", "trig", "prealgebra", "logarithms", "basic relations", "advanced relations")), () => ["basic", "trig", "prealgebra", "logarithms"]);
 const version1 = object({
   major: constant(1),
   minor: number
@@ -48455,7 +48428,7 @@ const parseExpressionWidgetV1 = parseWidgetWithVersion(version1, constant("expre
   times: boolean,
   visibleLabel: optional(string),
   ariaLabel: optional(string),
-  buttonSets: array(enumeration("basic", "basic+div", "trig", "prealgebra", "logarithms", "basic relations", "advanced relations")),
+  buttonSets: parseButtonSets,
   buttonsVisible: optional(enumeration("always", "never", "focused"))
 }));
 const version0 = optional(object({
@@ -48470,7 +48443,7 @@ const parseExpressionWidgetV0 = parseWidgetWithVersion(version0, constant("expre
   form: boolean,
   simplify: boolean,
   value: string,
-  buttonSets: array(enumeration("basic", "basic+div", "trig", "prealgebra", "logarithms", "basic relations", "advanced relations")),
+  buttonSets: parseButtonSets,
   buttonsVisible: optional(enumeration("always", "never", "focused"))
 }));
 function migrateV0ToV1(widget) {
@@ -48499,7 +48472,7 @@ function migrateV0ToV1(widget) {
     }
   };
 }
-const parseExpressionWidget = versionedWidgetOptions(parseExpressionWidgetV1).withMigrationFrom(parseExpressionWidgetV0, migrateV0ToV1).parser;
+const parseExpressionWidget = versionedWidgetOptions(1, parseExpressionWidgetV1).withMigrationFrom(0, parseExpressionWidgetV0, migrateV0ToV1).parser;
 
 const parsePerseusRenderer = defaulted(object({
   // TODO(benchristel): content is also defaulted to empty string in
@@ -48520,13 +48493,14 @@ const parsePerseusRenderer = defaulted(object({
   images: {}
 }));
 
+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: optional(nullable((rawVal, ctx) => parsePerseusRenderer(rawVal, ctx))),
+  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
@@ -48545,28 +48519,41 @@ const parseGradedGroupSetWidget = parseWidget(constant("graded-group-set"), obje
   gradedGroups: array(parseGradedGroupWidgetOptions)
 }));
 
-// discriminatedUnion() should be preferred over union() when parsing a
-// discriminated union type, because discriminatedUnion() produces more
-// understandable failure messages. It takes the discriminant as the source of
-// truth for which variant is to be parsed, and expects the other data to match
-// that variant.
-function discriminatedUnion(narrow, parseVariant) {
-  return new DiscriminatedUnionBuilder(pipeParsers(narrow).then(parseVariant).parser);
+/**
+ * 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(parser) {
+  constructor(discriminantKey, parser) {
+    this.discriminantKey = discriminantKey;
     this.parser = parser;
   }
-  or(narrow, parseVariant) {
-    return new DiscriminatedUnionBuilder(either(narrow, parseVariant, this.parser));
+  withBranch(discriminantValue, parseNewVariant) {
+    const parseNewBranch = discriminatedUnionBranch(this.discriminantKey, discriminantValue, parseNewVariant, this.parser);
+    return new DiscriminatedUnionBuilder(this.discriminantKey, parseNewBranch);
   }
 }
-function either(narrowToA, parseA, parseB) {
-  return (rawValue, ctx) => {
-    if (isSuccess(narrowToA(rawValue, ctx))) {
-      return parseA(rawValue, ctx);
+function discriminatedUnionBranch(discriminantKey, discriminantValue, parseVariant, parseOtherBranches) {
+  return (raw, ctx) => {
+    if (!isObject(raw)) {
+      return ctx.failure("object", raw);
     }
-    return parseB(rawValue, ctx);
+    if (raw[discriminantKey] === discriminantValue) {
+      return parseVariant(raw, ctx);
+    }
+    return parseOtherBranches(raw, ctx);
   };
 }
 
@@ -48574,41 +48561,27 @@ 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: discriminatedUnion(object({
-    type: constant("absolute_value")
-  }), object({
+  correct: discriminatedUnionOn("type").withBranch("absolute_value", object({
     type: constant("absolute_value"),
     coords: pairOfPoints
-  })).or(object({
-    type: constant("exponential")
-  }), object({
+  })).withBranch("exponential", object({
     type: constant("exponential"),
     asymptote: pairOfPoints,
     coords: pairOfPoints
-  })).or(object({
-    type: constant("linear")
-  }), object({
+  })).withBranch("linear", object({
     type: constant("linear"),
-    coords: pairOfPoints
-  })).or(object({
-    type: constant("logarithm")
-  }), object({
+    coords: defaulted(pairOfPoints, () => [[-5, 5], [5, 5]])
+  })).withBranch("logarithm", object({
     type: constant("logarithm"),
     asymptote: pairOfPoints,
     coords: pairOfPoints
-  })).or(object({
-    type: constant("quadratic")
-  }), object({
+  })).withBranch("quadratic", object({
     type: constant("quadratic"),
     coords: pairOfPoints
-  })).or(object({
-    type: constant("sinusoid")
-  }), object({
+  })).withBranch("sinusoid", object({
     type: constant("sinusoid"),
     coords: pairOfPoints
-  })).or(object({
-    type: constant("tangent")
-  }), object({
+  })).withBranch("tangent", object({
     type: constant("tangent"),
     coords: pairOfPoints
   })).parser,
@@ -48856,23 +48829,7 @@ const parseInteractionWidget = parseWidget(constant("interaction"), object({
     rulerTicks: optional(number),
     tickStep: pairOfNumbers$1
   }),
-  elements: array(discriminatedUnion(object({
-    type: parseFunctionType
-  }), parseFunctionElement).or(object({
-    type: parseLabelType
-  }), parseLabelElement).or(object({
-    type: parseLineType
-  }), parseLineElement).or(object({
-    type: parseMovableLineType
-  }), parseMovableLineElement).or(object({
-    type: parseMovablePointType
-  }), parseMovablePointElement).or(object({
-    type: parseParametricType
-  }), parseParametricElement).or(object({
-    type: parsePointType
-  }), parsePointElement).or(object({
-    type: parseRectangleType
-  }), parseRectangleElement).parser)
+  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)
 }));
 
 // Used to represent 2-D points and ranges
@@ -48930,7 +48887,7 @@ const parsePerseusGraphTypePolygon = object({
   showAngles: optional(boolean),
   showSides: optional(boolean),
   snapTo: optional(enumeration("grid", "angles", "sides")),
-  match: optional(enumeration("similar", "congruent", "approx")),
+  match: optional(enumeration("similar", "congruent", "approx", "exact")),
   startCoords: optional(array(pairOfNumbers)),
   // TODO: remove coord? it's legacy.
   coord: optional(pairOfNumbers)
@@ -48965,7 +48922,7 @@ const parsePerseusGraphTypeSinusoid = object({
   // TODO: remove coord? it's legacy.
   coord: optional(pairOfNumbers)
 });
-const parsePerseusGraphType = union(parsePerseusGraphTypeAngle).or(parsePerseusGraphTypeAngle).or(parsePerseusGraphTypeCircle).or(parsePerseusGraphTypeLinear).or(parsePerseusGraphTypeLinearSystem).or(parsePerseusGraphTypeNone).or(parsePerseusGraphTypePoint).or(parsePerseusGraphTypePolygon).or(parsePerseusGraphTypeQuadratic).or(parsePerseusGraphTypeRay).or(parsePerseusGraphTypeSegment).or(parsePerseusGraphTypeSinusoid).parser;
+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");
@@ -49084,7 +49041,7 @@ const parseLabelImageWidget = parseWidget(constant("label-image"), object({
   })),
   hideChoicesFromInstructions: boolean,
   multipleAnswers: boolean,
-  static: boolean
+  static: defaulted(boolean, () => false)
 }));
 
 const parseMatcherWidget = parseWidget(constant("matcher"), object({
@@ -49095,7 +49052,8 @@ const parseMatcherWidget = parseWidget(constant("matcher"), object({
   padding: boolean
 }));
 
-const numeric = pipeParsers(union(number).or(string).parser).then(stringToNumber).parser;
+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),
@@ -49114,7 +49072,8 @@ const parseMeasurerWidget = parseWidget(constant("measurer"), object({
   rulerPixels: number,
   rulerLength: number,
   box: pair(number, number),
-  static: boolean
+  // TODO(benchristel): static is not used. Remove it?
+  static: defaulted(boolean, () => false)
 }));
 
 const parseMoleculeRendererWidget = parseWidget(constant("molecule-renderer"), object({
@@ -49123,9 +49082,10 @@ const parseMoleculeRendererWidget = parseWidget(constant("molecule-renderer"), o
   smiles: optional(string)
 }));
 
+const emptyStringToNull = pipeParsers(constant("")).then(convert(() => null)).parser;
 const parseNumberLineWidget = parseWidget(constant("number-line"), object({
   range: array(number),
-  labelRange: array(nullable(number)),
+  labelRange: array(nullable(union(number).or(emptyStringToNull).parser)),
   labelStyle: string,
   labelTicks: boolean,
   isTickCtrl: optional(nullable(boolean)),
@@ -49137,10 +49097,10 @@ const parseNumberLineWidget = parseWidget(constant("number-line"), object({
   snapDivisions: defaulted(number, () => 2),
   tickStep: optional(nullable(number)),
   correctRel: optional(nullable(string)),
-  correctX: number,
+  correctX: nullable(number),
   initialX: optional(nullable(number)),
   showTooltip: optional(boolean),
-  static: boolean
+  static: defaulted(boolean, () => false)
 }));
 
 const parseMathFormat = enumeration("integer", "mixed", "improper", "proper", "decimal", "percent", "pi");
@@ -49155,14 +49115,14 @@ const parseNumericInputWidget = parseWidget(constant("numeric-input"), object({
     answerForms: optional(array(parseMathFormat)),
     strict: boolean,
     maxError: optional(nullable(number)),
-    // TODO(benchristel): simplify should never be `true`, but we
+    // TODO(benchristel): simplify should never be a boolean, but we
     // have some content where it is anyway. If we ever backfill
     // the data, we should simplify `simplify`.
-    simplify: optional(nullable(union(string).or(pipeParsers(constant(true)).then(convert(String)).parser).parser))
+    simplify: optional(nullable(union(string).or(pipeParsers(boolean).then(convert(String)).parser).parser))
   })),
   labelText: optional(string),
   size: string,
-  coefficient: boolean,
+  coefficient: defaulted(boolean, () => false),
   rightAlign: optional(boolean),
   static: defaulted(boolean, () => false),
   answerForms: optional(array(object({
@@ -49198,9 +49158,9 @@ const parsePassageRefWidget = parseWidget(constant("passage-ref"), object({
 }));
 
 const parsePassageWidget = parseWidget(constant("passage"), object({
-  footnotes: string,
+  footnotes: defaulted(string, () => ""),
   passageText: string,
-  passageTitle: string,
+  passageTitle: defaulted(string, () => ""),
   showLineNumbers: boolean,
   static: defaulted(boolean, () => false)
 }));
@@ -49385,6 +49345,10 @@ const parseWidgetsMapEntry = (_ref, widgetMap, ctx) => {
       return parseAndAssign(`sequence ${id}`, parseDeprecatedWidget);
     case "lights-puzzle":
       return parseAndAssign(`lights-puzzle ${id}`, parseDeprecatedWidget);
+    case "simulator":
+      return parseAndAssign(`simulator ${id}`, parseDeprecatedWidget);
+    case "transformer":
+      return parseAndAssign(`transformer ${id}`, parseDeprecatedWidget);
     default:
       if (getWidget(type)) {
         // @ts-expect-error - 'type' is not a valid widget type