@khanacademy/perseus 23.0.0 → 23.3.0

package/dist/es/index.js

@@ -29,7 +29,7 @@ import { OptionItem, SingleSelect, MultiSelect } from '@khanacademy/wonder-block
 import caretDown from '@phosphor-icons/core/regular/caret-down.svg';
 import caretUp from '@phosphor-icons/core/regular/caret-up.svg';
 import debounce$2 from 'lodash.debounce';
-import { vec, Line as Line$4, Point as Point$2, useMovable, Text as Text$1, Polygon, Plot as Plot$3, Coordinates, Mafs } from 'mafs';
+import { vec, Ellipse, Line as Line$4, Point as Point$2, useMovable, Text as Text$1, Polygon, Plot as Plot$3, Coordinates, Mafs } from 'mafs';
 import { PhosphorIcon } from '@khanacademy/wonder-blocks-icon';
 import { Body, LabelSmall, LabelMedium } from '@khanacademy/wonder-blocks-typography';
 import questionIcon from '@phosphor-icons/core/regular/question.svg';
@@ -10827,6 +10827,33 @@ function intersects(ab, cd) {
   }
   return false;
 }
+
+// Whether any two sides of a polygon intersect each other
+function polygonSidesIntersect(vertices) {
+  for (let i = 0; i < vertices.length; i++) {
+    for (let k = i + 1; k < vertices.length; k++) {
+      // If any two vertices are the same point, sides overlap
+      if (point.equal(vertices[i], vertices[k])) {
+        return true;
+      }
+
+      // Find the other end of the sides starting at vertices i and k
+      const iNext = (i + 1) % vertices.length;
+      const kNext = (k + 1) % vertices.length;
+
+      // Adjacent sides always intersect (at the vertex); skip those
+      if (iNext === k || kNext === i) {
+        continue;
+      }
+      const side1 = [vertices[i], vertices[iNext]];
+      const side2 = [vertices[k], vertices[kNext]];
+      if (intersects(side1, side2)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
 function vector(a, b) {
   return _.map(_.zip(a, b), function (pair) {
     return pair[0] - pair[1];
@@ -17430,16 +17457,8 @@ class SvgImage extends React.Component {
     // Props to send to all images
     const imageProps = {
       alt: this.props.alt,
-      title: this.props.title,
-      tabIndex: "0"
+      title: this.props.title
     };
-    // If alt text is present, AND overrideAriaHidden is true,
-    // include aria-hidden to avoid screen reader from crawling texts
-    // both from the div meant for screen readers (see svg-image.jsx)
-    // and alt attribute.
-    if (this.props.alt && this.props.overrideAriaHidden) {
-      imageProps["aria-hidden"] = true;
-    }
     const width = this.props.width && this.props.width * this.props.scale;
     const height = this.props.height && this.props.height * this.props.scale;
     const dimensions = {
@@ -27361,7 +27380,7 @@ class ImageWidget extends React.Component {
 
   render() {
     let image;
-    let alt;
+    const alt = this.props.caption === this.props.alt ? "" : this.props.alt;
     const {
       apiOptions
     } = this.props;
@@ -27372,29 +27391,7 @@ class ImageWidget extends React.Component {
         setAssetStatus
       }) => /*#__PURE__*/React.createElement(SvgImage, {
         src: url,
-        alt:
-        /* alt text is formatted in a sr-only
-        div next to the image in addition to
-        the alt attribute.
-        If there is no alt text at all,
-        we don't put an alt attribute on
-        the image, so that screen readers
-        know there's something they can't
-        read there :(.
-        NOTE: React <=0.13 (maybe later)
-        has a bug where it won't ever
-        remove an attribute, so if this
-        alt node is ever defined it's
-        not removed. This is sort of
-        dangerous, but we usually re-key
-        new renderers so that they're
-        rendered from scratch anyways,
-        so this shouldn't be a problem
-        in practice right now, although
-        it will exhibit weird behaviour
-        while editing. */
-        this.props.alt,
-        overrideAriaHidden: true,
+        alt: alt,
         width: backgroundImage.width,
         height: backgroundImage.height,
         preloader: apiOptions.imagePreloader,
@@ -27410,16 +27407,6 @@ class ImageWidget extends React.Component {
         setAssetStatus: setAssetStatus
       }));
     }
-    if (this.props.alt) {
-      alt = /*#__PURE__*/React.createElement("span", {
-        className: "perseus-sr-only"
-      }, /*#__PURE__*/React.createElement(Renderer, {
-        content: this.props.alt,
-        apiOptions: apiOptions,
-        linterContext: this.props.linterContext,
-        strings: this.context.strings
-      }));
-    }
 
     // For mobile we combine an image's title and caption.
     if (apiOptions.isMobile) {
@@ -27486,7 +27473,7 @@ class ImageWidget extends React.Component {
         style: {
           maxWidth: backgroundImage.width
         }
-      }, image, alt, titleAndCaption);
+      }, image, titleAndCaption);
     }
     let title;
     let caption;
@@ -27518,7 +27505,7 @@ class ImageWidget extends React.Component {
       style: {
         maxWidth: backgroundImage.width
       }
-    }, title, image, alt, caption);
+    }, title, image, caption);
   }
   static validate(userInput, rubric) {
     return {
@@ -28671,8 +28658,32 @@ const lockedFigureColors = {
   pink: "#B25071",
   red: "#D92916"
 };
+const lockedEllipseFillStyles = {
+  none: 0,
+  solid: 1,
+  translucent: 0.4
+};
 const plotterPlotTypes = ["bar", "line", "pic", "histogram", "dotplot"];
 
+const LockedEllipse = props => {
+  const {
+    center,
+    radius,
+    angle,
+    color,
+    fillStyle,
+    strokeStyle
+  } = props;
+  return /*#__PURE__*/React.createElement(Ellipse, {
+    center: center,
+    radius: radius,
+    angle: angle,
+    fillOpacity: lockedEllipseFillStyles[fillStyle],
+    strokeStyle: strokeStyle,
+    color: lockedFigureColors[color]
+  });
+};
+
 function pathBuilder() {
   return new PathBuilder();
 }
@@ -28927,6 +28938,21 @@ const LockedPoint = props => {
   });
 };
 
+const LockedVector = props => {
+  const {
+    color,
+    points
+  } = props;
+  const [tail, tip] = points;
+  return /*#__PURE__*/React.createElement("g", {
+    className: "locked-vector"
+  }, /*#__PURE__*/React.createElement(Vector, {
+    tail: tail,
+    tip: tip,
+    color: lockedFigureColors[color]
+  }));
+};
+
 const GraphLockedLayer = props => {
   const {
     lockedFigures
@@ -28942,6 +28968,14 @@ const GraphLockedLayer = props => {
           key: `line-${index}`,
           range: props.range
         }, figure));
+      case "ellipse":
+        return /*#__PURE__*/React.createElement(LockedEllipse, _extends({
+          key: `ellipse-${index}`
+        }, figure));
+      case "vector":
+        return /*#__PURE__*/React.createElement(LockedVector, _extends({
+          key: `vector-${index}`
+        }, figure));
       default:
         /**
          * Devlopment-time future-proofing: This should
@@ -29070,7 +29104,8 @@ const MovablePointView = /*#__PURE__*/forwardRef((props, hitboxRef) => {
     point,
     color: color$1 = color.blue,
     dragging,
-    focusBehavior
+    focusBehavior,
+    cursor
   } = props;
 
   // WB Tooltip requires a color name for the background color.
@@ -29102,7 +29137,8 @@ const MovablePointView = /*#__PURE__*/forwardRef((props, hitboxRef) => {
     ref: hitboxRef,
     className: pointClasses,
     style: {
-      "--movable-point-color": color$1
+      "--movable-point-color": color$1,
+      cursor
     },
     "data-testid": "movable-point",
     tabIndex: tabIndex(focusBehavior)
@@ -29350,7 +29386,33 @@ const SegmentGraph = props => {
   })));
 };
 
-const LinearGraph = props => {
+const LinearGraph = (props, key) => {
+  const {
+    dispatch
+  } = props;
+  const {
+    coords: line
+  } = props.graphState;
+
+  // Linear graphs only have one line
+  // (LEMS-2050): Update the reducer so that we have a separate action for moving one line
+  // and another action for moving multiple lines
+  return /*#__PURE__*/React.createElement(MovableLine, {
+    key: 0,
+    points: line,
+    onMoveLine: delta => {
+      dispatch(moveLine(0, delta));
+    },
+    extend: {
+      start: true,
+      end: true
+    },
+    onMovePoint: (endpointIndex, destination) => dispatch(moveControlPoint(endpointIndex, destination, 0)),
+    color: "var(--movable-line-stroke-color)"
+  });
+};
+
+const LinearSystemGraph = props => {
   const {
     dispatch
   } = props;
@@ -29370,7 +29432,7 @@ const LinearGraph = props => {
     },
     onMovePoint: (endpointIndex, destination) => dispatch(moveControlPoint(endpointIndex, destination, i)),
     color: colors[i]
-  })));
+  })), ";");
 };
 
 const RayGraph = props => {
@@ -29378,14 +29440,14 @@ const RayGraph = props => {
     dispatch
   } = props;
   const {
-    coords: lines
+    coords: line
   } = props.graphState;
   const handleMoveLine = delta => dispatch(moveLine(0, delta));
   const handleMovePoint = (pointIndex, newPoint) => dispatch(moveControlPoint(pointIndex, newPoint, 0));
-  return /*#__PURE__*/React.createElement(MovableLine
-  // a ray only has one line
-  , {
-    points: lines[0],
+
+  // Ray graphs only have one line
+  return /*#__PURE__*/React.createElement(MovableLine, {
+    points: line,
     onMoveLine: handleMoveLine,
     onMovePoint: handleMovePoint,
     extend: {
@@ -29564,6 +29626,7 @@ const StyledMovablePoint = props => {
   const {
     point,
     onMove,
+    cursor,
     color: color$1 = color.blue
   } = props;
   const {
@@ -29582,7 +29645,8 @@ const StyledMovablePoint = props => {
     focusBehavior: {
       type: "uncontrolled",
       tabIndex: 0
-    }
+    },
+    cursor: cursor
   });
 };
 
@@ -29686,25 +29750,39 @@ function initializeGraphState(params) {
     case "segment":
       return _extends({}, shared, {
         type: "segment",
-        coords: getDefaultSegments({
+        coords: getSegmentCoords({
           graph,
           step,
           range
         })
       });
     case "linear":
-    case "linear-system":
+      return _extends({}, shared, {
+        type: graph.type,
+        coords: getLineCoords({
+          graph,
+          range,
+          step
+        })
+      });
     case "ray":
       return _extends({}, shared, {
         type: graph.type,
-        // Linear and ray graphs have a single tuple of points, while a
-        // linear system has two tuples of points.
         coords: getLineCoords({
           graph,
           range,
           step
         })
       });
+    case "linear-system":
+      return _extends({}, shared, {
+        type: graph.type,
+        coords: getLinearSystemCoords({
+          graph,
+          range,
+          step
+        })
+      });
     case "polygon":
       return _extends({}, shared, {
         type: "polygon",
@@ -29727,17 +29805,19 @@ function initializeGraphState(params) {
       });
     case "circle":
       return _extends({}, shared, {
-        type: graph.type,
-        center: [0, 0],
-        radiusPoint: [1, 0]
-      });
+        type: graph.type
+      }, getCircleCoords(graph));
     case "quadratic":
       return _extends({}, shared, {
         type: graph.type,
         coords: getQuadraticCoords(graph, range, step)
       });
-    case "angle":
     case "sinusoid":
+      return _extends({}, shared, {
+        type: graph.type,
+        coords: getSinusoidCoords(graph, range, step)
+      });
+    case "angle":
       throw new Error("Mafs not yet implemented for graph type: " + graph.type);
     default:
       throw new UnreachableCaseError(graph);
@@ -29802,12 +29882,12 @@ function getGradableGraph(state, initialGraph) {
   }
   if (state.type === "linear" && initialGraph.type === "linear") {
     return _extends({}, initialGraph, {
-      coords: state.coords[0]
+      coords: state.coords
     });
   }
   if (state.type === "ray" && initialGraph.type === "ray") {
     return _extends({}, initialGraph, {
-      coords: state.coords[0]
+      coords: state.coords
     });
   }
   if (state.type === "polygon" && initialGraph.type === "polygon") {
@@ -29831,13 +29911,21 @@ function getGradableGraph(state, initialGraph) {
       coords: state.coords
     });
   }
+  if (state.type === "sinusoid" && initialGraph.type === "sinusoid") {
+    return _extends({}, initialGraph, {
+      coords: state.coords
+    });
+  }
   throw new Error("Mafs is not yet implemented for graph type: " + initialGraph.type);
 }
-const getDefaultSegments = ({
+const getSegmentCoords = ({
   graph,
   range,
   step
 }) => {
+  if (graph.coords) {
+    return graph.coords;
+  }
   const ys = n => {
     switch (n) {
       case 2:
@@ -29868,16 +29956,20 @@ const getLineCoords = ({
   range,
   step
 }) => {
-  //  Return two lines for a linear system, one for a ray or linear
-  switch (graph.type) {
-    case "linear-system":
-      return defaultLinearCoords.map(points => normalizePoints(range, step, points));
-    case "linear":
-    case "ray":
-      return [normalizePoints(range, step, defaultLinearCoords[0])];
-    default:
-      throw new UnreachableCaseError(graph);
+  if (graph.coords) {
+    return graph.coords;
+  }
+  return normalizePoints(range, step, defaultLinearCoords[0]);
+};
+const getLinearSystemCoords = ({
+  graph,
+  range,
+  step
+}) => {
+  if (graph.coords) {
+    return graph.coords;
   }
+  return defaultLinearCoords.map(points => normalizePoints(range, step, points));
 };
 const getPolygonCoords = ({
   graph,
@@ -29908,11 +30000,33 @@ const getPolygonCoords = ({
   coords = normalizePoints(range, step, coords, /* noSnap */!snapToGrid);
   return coords;
 };
-const getQuadraticCoords = (graph, range, step) => {
-  let coords = [[0.25, 0.75], [0.5, 0.25], [0.75, 0.75]];
+const getSinusoidCoords = (graph, range, step) => {
+  if (graph.coords) {
+    return [graph.coords[0], graph.coords[1]];
+  }
+  let coords = [[0.5, 0.5], [0.65, 0.6]];
   coords = normalizePoints(range, step, coords, true);
   return coords;
 };
+const getQuadraticCoords = (graph, range, step) => {
+  if (graph.coords) {
+    return graph.coords;
+  }
+  const defaultCoords = [[0.25, 0.75], [0.5, 0.25], [0.75, 0.75]];
+  return normalizePoints(range, step, defaultCoords, true);
+};
+const getCircleCoords = (graph, range, step) => {
+  if (graph.center != null && graph.radius != null) {
+    return {
+      center: graph.center,
+      radiusPoint: vec.add(graph.center, [graph.radius, 0])
+    };
+  }
+  return {
+    center: [0, 0],
+    radiusPoint: [1, 0]
+  };
+};
 
 /**
  * determine radius of a circle graph
@@ -29941,6 +30055,7 @@ function CircleGraph(props) {
     onMove: newCenter => dispatch(moveCenter(newCenter))
   }), /*#__PURE__*/React.createElement(StyledMovablePoint, {
     point: radiusPoint,
+    cursor: "ew-resize",
     onMove: newRadiusPoint => {
       dispatch(moveRadiusPoint(newRadiusPoint));
     }
@@ -30098,6 +30213,62 @@ const getQuadraticCoefficients = coords => {
   return [a, b, c];
 };
 
+function SinusoidGraph(props) {
+  const {
+    dispatch,
+    graphState
+  } = props;
+
+  // Destructure the coordinates from the graph state
+  // Note: The order of the coordinates is important:
+  // The coords[0] is the root and the coords[1] is the first peak
+  const {
+    coords
+  } = graphState;
+
+  // Get the coefficients for calculating the quadratic equation
+  const coeffs = getSinusoidCoefficients(coords);
+  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Plot$3.OfX, {
+    y: x => computeSine(x, coeffs),
+    color: color.blue
+  }), coords.map((coord, i) => /*#__PURE__*/React.createElement(StyledMovablePoint, {
+    key: "point-" + i,
+    point: coord,
+    onMove: destination => dispatch(movePoint(i, destination))
+  })));
+}
+
+// Plot a sinusoid of the form: f(x) = a * sin(b * x - c) + d
+const computeSine = function computeSine(x,
+// x-coordinate
+sinusoidCoefficients) {
+  // Break down the coefficients for the sine function to improve readability
+  const {
+    amplitude: a,
+    angularFrequency: b,
+    phase: c,
+    verticalOffset: d
+  } = sinusoidCoefficients;
+  return a * Math.sin(b * x - c) + d;
+};
+const getSinusoidCoefficients = coords => {
+  // It's assumed that p1 is the root and p2 is the first peak
+  const p1 = coords[0];
+  const p2 = coords[1];
+
+  // Resulting coefficients are canonical for this sine curve
+  const amplitude = p2[1] - p1[1];
+  const angularFrequency = Math.PI / (2 * (p2[0] - p1[0]));
+  const phase = p1[0] * angularFrequency;
+  const verticalOffset = p1[1];
+  return {
+    amplitude,
+    angularFrequency,
+    phase,
+    verticalOffset
+  };
+};
+
 // Universal padding for the axis ticks to ensure that the labels
 // have enough space to render without overlapping the tick lines
 const tickPadding = 5;
@@ -31187,15 +31358,9 @@ function interactiveGraphReducer(state, action) {
   }
 }
 function doMoveControlPoint(state, action) {
-  const {
-    snapStep,
-    range
-  } = state;
   switch (state.type) {
     case "segment":
-    case "linear":
     case "linear-system":
-    case "ray":
       {
         const newCoords = updateAtIndex({
           array: state.coords,
@@ -31203,11 +31368,7 @@ function doMoveControlPoint(state, action) {
           update: tuple => setAtIndex({
             array: tuple,
             index: action.pointIndex,
-            newValue: snap(snapStep, bound$1({
-              snapStep,
-              range,
-              point: action.destination
-            }))
+            newValue: boundAndSnapToGrid(action.destination, state)
           })
         });
         const coordsToCheck = newCoords[action.itemIndex];
@@ -31219,16 +31380,33 @@ function doMoveControlPoint(state, action) {
           coords: newCoords
         });
       }
+    case "linear":
+    case "ray":
+      {
+        const newCoords = setAtIndex({
+          array: state.coords,
+          index: action.pointIndex,
+          newValue: boundAndSnapToGrid(action.destination, state)
+        });
+        return _extends({}, state, {
+          hasBeenInteractedWith: true,
+          coords: newCoords
+        });
+      }
     case "circle":
       throw new Error("FIXME implement circle reducer");
     case "point":
     case "polygon":
     case "quadratic":
+    case "sinusoid":
       throw new Error(`Don't use moveControlPoint for ${state.type} graphs. Use movePoint instead!`);
     default:
       throw new UnreachableCaseError(state);
   }
 }
+
+// (LEMS-2050): Update the reducer so that we have a separate action for moving one line
+// and another action for moving multiple lines
 function doMoveLine(state, action) {
   const {
     snapStep,
@@ -31236,9 +31414,7 @@ function doMoveLine(state, action) {
   } = state;
   switch (state.type) {
     case "segment":
-    case "linear":
     case "linear-system":
-    case "ray":
       {
         if (action.itemIndex === undefined) {
           throw new Error("Please provide index of line to move");
@@ -31263,6 +31439,21 @@ function doMoveLine(state, action) {
           coords: newCoords
         });
       }
+    case "linear":
+    case "ray":
+      {
+        const currentLine = state.coords;
+        const change = getChange(currentLine, action.delta, {
+          snapStep,
+          range
+        });
+        const newLine = [snap(snapStep, vec.add(currentLine[0], change)), snap(snapStep, vec.add(currentLine[1], change))];
+        return _extends({}, state, {
+          type: state.type,
+          hasBeenInteractedWith: true,
+          coords: newLine
+        });
+      }
     default:
       // The MoveLine action doesn't make sense for other graph types;
       // ignore it if it somehow happens
@@ -31295,6 +31486,20 @@ function doMoveAll(state, action) {
 function doMovePoint(state, action) {
   switch (state.type) {
     case "polygon":
+      const newCoords = setAtIndex({
+        array: state.coords,
+        index: action.index,
+        newValue: boundAndSnapToGrid(action.destination, state)
+      });
+
+      // Reject the move if it would cause the sides of the polygon to cross
+      if (polygonSidesIntersect(newCoords)) {
+        return state;
+      }
+      return _extends({}, state, {
+        hasBeenInteractedWith: true,
+        coords: newCoords
+      });
     case "point":
       {
         return _extends({}, state, {
@@ -31302,11 +31507,26 @@ function doMovePoint(state, action) {
           coords: setAtIndex({
             array: state.coords,
             index: action.index,
-            newValue: snap(state.snapStep, bound$1({
-              snapStep: state.snapStep,
-              range: state.range,
-              point: action.destination
-            }))
+            newValue: boundAndSnapToGrid(action.destination, state)
+          })
+        });
+      }
+    case "sinusoid":
+      {
+        // First, we need to verify that the new coordinates are not on the same vertical line
+        // If they are, we don't want to move the point
+        const destination = action.destination;
+        const _newCoords = [...state.coords];
+        _newCoords[action.index] = action.destination;
+        if (_newCoords[0][0] === _newCoords[1][0]) {
+          return state;
+        }
+        return _extends({}, state, {
+          hasBeenInteractedWith: true,
+          coords: setAtIndex({
+            array: state.coords,
+            index: action.index,
+            newValue: boundAndSnapToGrid(destination, state)
           })
         });
       }
@@ -31317,11 +31537,7 @@ function doMovePoint(state, action) {
           coords: setAtIndex({
             array: state.coords,
             index: action.index,
-            newValue: snap(state.snapStep, bound$1({
-              snapStep: state.snapStep,
-              range: state.range,
-              point: action.destination
-            }))
+            newValue: boundAndSnapToGrid(action.destination, state)
           })
         });
       }
@@ -31424,6 +31640,17 @@ const getChange = (coords, delta, constraintOpts) => {
   const dy = clamp(deltaY, minYMove, maxYMove);
   return [dx, dy];
 };
+function boundAndSnapToGrid(point, {
+  snapStep,
+  range
+}) {
+  return snap(snapStep, bound$1({
+    snapStep,
+    range,
+    point
+  }));
+}
+
 // Returns the closest point to the given `point` that is within the graph
 // bounds given in `state`.
 function bound$1({
@@ -31513,8 +31740,12 @@ const renderGraph = props => {
         graphState: state,
         dispatch: dispatch
       });
-    case "linear":
     case "linear-system":
+      return /*#__PURE__*/React.createElement(LinearSystemGraph, {
+        graphState: state,
+        dispatch: dispatch
+      });
+    case "linear":
       return /*#__PURE__*/React.createElement(LinearGraph, {
         graphState: state,
         dispatch: dispatch
@@ -31544,6 +31775,11 @@ const renderGraph = props => {
         graphState: state,
         dispatch: dispatch
       });
+    case "sinusoid":
+      return /*#__PURE__*/React.createElement(SinusoidGraph, {
+        graphState: state,
+        dispatch: dispatch
+      });
     default:
       return new UnreachableCaseError(type);
   }
@@ -43758,7 +43994,7 @@ const init = function init(options) {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus";
-const libVersion = "23.0.0";
+const libVersion = "23.3.0";
 addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {
@@ -46759,5 +46995,5 @@ const EditorJsonify = {
   }
 };
 
-export { ApiOptions, ArrowPicker, ArticleRenderer, BaseRadio, Categorizer$1 as Categorizer, changeable as Changeable, ClassNames, ColorPicker, DashPicker, dependencies as Dependencies, EditorJsonify, ElementContainer, Errors, Expression, util as GrapherUtil, Grapher$1 as GrapherWidget, HintRenderer, HintsRenderer, InputNumber$1 as InputNumber, InteractiveGraph$1 as InteractiveGraphWidget, ItemExtras, JiptParagraphs, KhanColors, KhanMath, context as LoadingContext, Log, Matrix$1 as MatrixWidget, MultiItems, NumericInput$1 as NumericInput, PerseusError, PerseusExpressionAnswerFormConsidered, PerseusI18nContext, PerseusI18nContextProvider, PerseusMarkdown, Plotter$1 as PlotterWidget, QUESTION_WIDGETS, Radio, Renderer, ref as ServerItemRenderer, sizingUtils as SizingUtils, Table$1 as TableWidget, Util, denylist as WIDGET_PROP_DENYLIST, WidgetJsonifyDeprecated, widgets$1 as Widgets, addWidget, apiVersion, buildEmptyItemTreeForShape, buildMapper, components, constants, contentHasWidgetType, convertWidgetNameToEnum, displaySigFigs, generateTestCategorizerWidget, generateTestExpressionWidget, generateTestInteractiveGraphWidget, generateTestNumericInputWidget, generateTestPerseusItem, generateTestRadioWidget, genericPerseusItemData, getAnswerFromUserInput, getAnswersFromWidgets, getCorrectAnswerForWidgetId, getValidWidgetIds, getWidgetFromWidgetMap, getWidgetIdsFromContent, getWidgetIdsFromContentByType, getWidgetTypeByWidgetId, getWidgetsFromWidgetMap, getWidgetsMapFromItemData, globalConstants, globalStyles, iconPaths as icons, init, injectWidgets, interactiveSizes$1 as interactiveSizes, isItemRenderableByVersion, isWidgetIdInContent, isWrongAnswerSupported, itemDataVersion, itemToTree, ItemVersion as itemVersion, libVersion, lockedFigureColors, mediaQueries, parsePerseusItem, plotterPlotTypes, preprocessTex, registerAllWidgetsForTesting, shapes, shouldHaveIndividualAnswer, traverse, usePerseusI18n, violatingWidgets, allWidgets as widgets };
+export { ApiOptions, ArrowPicker, ArticleRenderer, BaseRadio, Categorizer$1 as Categorizer, changeable as Changeable, ClassNames, ColorPicker, DashPicker, dependencies as Dependencies, EditorJsonify, ElementContainer, Errors, Expression, util as GrapherUtil, Grapher$1 as GrapherWidget, HintRenderer, HintsRenderer, InputNumber$1 as InputNumber, InteractiveGraph$1 as InteractiveGraphWidget, ItemExtras, JiptParagraphs, KhanColors, KhanMath, context as LoadingContext, Log, Matrix$1 as MatrixWidget, MultiItems, NumericInput$1 as NumericInput, PerseusError, PerseusExpressionAnswerFormConsidered, PerseusI18nContext, PerseusI18nContextProvider, PerseusMarkdown, Plotter$1 as PlotterWidget, QUESTION_WIDGETS, Radio, Renderer, ref as ServerItemRenderer, sizingUtils as SizingUtils, Table$1 as TableWidget, Util, denylist as WIDGET_PROP_DENYLIST, WidgetJsonifyDeprecated, widgets$1 as Widgets, addWidget, apiVersion, buildEmptyItemTreeForShape, buildMapper, components, constants, contentHasWidgetType, convertWidgetNameToEnum, displaySigFigs, generateTestCategorizerWidget, generateTestExpressionWidget, generateTestInteractiveGraphWidget, generateTestNumericInputWidget, generateTestPerseusItem, generateTestRadioWidget, genericPerseusItemData, getAnswerFromUserInput, getAnswersFromWidgets, getCorrectAnswerForWidgetId, getValidWidgetIds, getWidgetFromWidgetMap, getWidgetIdsFromContent, getWidgetIdsFromContentByType, getWidgetTypeByWidgetId, getWidgetsFromWidgetMap, getWidgetsMapFromItemData, globalConstants, globalStyles, iconPaths as icons, init, injectWidgets, interactiveSizes$1 as interactiveSizes, isItemRenderableByVersion, isWidgetIdInContent, isWrongAnswerSupported, itemDataVersion, itemToTree, ItemVersion as itemVersion, libVersion, lockedEllipseFillStyles, lockedFigureColors, mediaQueries, parsePerseusItem, plotterPlotTypes, preprocessTex, registerAllWidgetsForTesting, shapes, shouldHaveIndividualAnswer, traverse, usePerseusI18n, violatingWidgets, allWidgets as widgets };
 //# sourceMappingURL=index.js.map