@khanacademy/perseus 24.1.0 → 24.3.0

package/dist/index.js

@@ -9068,7 +9068,7 @@ var Tex$1 = {
 const {
   processMath: processMath$1
 } = Tex$1;
-function polar(r, th) {
+function polar$1(r, th) {
   if (typeof r === "number") {
     r = [r, r];
   }
@@ -9404,8 +9404,8 @@ class Graphie$1 {
       endAngle = (endAngle % 360 + 360) % 360;
       const cent = this.scalePoint(center);
       const radii = this.scaleVector(radius);
-      const startVector = polar(radius, startAngle);
-      const endVector = polar(radius, endAngle);
+      const startVector = polar$1(radius, startAngle);
+      const endVector = polar$1(radius, endAngle);
 
       // We round the coordinates to make testing easier, because trig
       // operations return unround numbers.
@@ -13834,7 +13834,7 @@ ___default["default"].extend(MovableAngle.prototype, {
           let angle = GraphUtils.findAngle(newPoint, vertex);
           angle = Math.round((angle - snapOffset) / snap) * snap + snapOffset;
           const distance = GraphUtils.getDistance(newPoint, vertex);
-          return kmath.vector.add(vertex, polar(distance, angle));
+          return kmath.vector.add(vertex, polar$1(distance, angle));
         }
         return true;
       };
@@ -16794,7 +16794,7 @@ const Path = GraphieClasses.createClass({
     this.path.toFront();
   }
 });
-const Arc = GraphieClasses.createSimpleClass((graphie, props) => {
+const Arc$1 = GraphieClasses.createSimpleClass((graphie, props) => {
   let center = props.center;
   let radius = props.radius;
   if (props.unscaled) {
@@ -16810,7 +16810,7 @@ const Rect$1 = GraphieClasses.createSimpleClass((graphie, props) => {
   return graphie.rect(props.x, props.y, props.width, props.height, props.style);
 });
 var Movables = {
-  Arc: Arc,
+  Arc: Arc$1,
   Circle: Circle,
   Label: Label$1,
   Line: Line$3,
@@ -28657,6 +28657,92 @@ const useTransformDimensionsToPixels = function () {
   return dimensionsToPixels(dimens, graphState);
 };
 
+// Restricts `value` to be between `min` and `max`.
+function clamp(value, min, max) {
+  if (value < min) {
+    return min;
+  }
+  if (value > max) {
+    return max;
+  }
+  return value;
+}
+
+// Rounds each component of `point` to the nearest multiple of the
+// corresponding component of `snapStep`. E.g. if the snap step is [2, 3],
+// the x-coord of the point will be rounded to the nearest multiple of 2, and
+// the y-coord of the point will be rounded to the nearest multiple of 3.
+function snap(snapStep, point) {
+  const [requestedX, requestedY] = point;
+  const [snapX, snapY] = snapStep;
+  return [Math.round(requestedX / snapX) * snapX, Math.round(requestedY / snapY) * snapY];
+}
+
+// Use X and Y to index into arrays that represent coordinate pairs.
+// e.g. point[X]
+const X = 0;
+const Y = 1;
+
+// Use MIN and MAX to index into arrays that represent intervals.
+// e.g. range[MAX]
+const MIN = 0;
+const MAX = 1;
+function size(_ref) {
+  let [min, max] = _ref;
+  return max - min;
+}
+
+// Removes an equal amount from each end of the interval.
+//
+// If the given amount cannot be removed (because the interval is too small),
+// half the interval's size is removed from each end instead, so the interval
+// ends up with size = 0, and both MAX and MIN equal to its former midpoint.
+//
+// If `amount` is negative, the interval is expanded instead.
+function trim(amount, interval) {
+  if (amount * 2 > size(interval)) {
+    const middle = average(...interval);
+    return [middle, middle];
+  }
+  return [interval[MIN] + amount, interval[MAX] - amount];
+}
+function average(a, b) {
+  return (a + b) / 2;
+}
+
+// Restricts the `point` to be within `box`, by clamping each coordinate to the
+// corresponding interval.
+function clampToBox(box, point) {
+  return [clamp(point[X], ...box[X]), clamp(point[Y], ...box[Y])];
+}
+
+// Reduces the size of `box`, trimming each corner by the given positive
+// `amount`. If a component of `amount` is negative, the box is expanded in
+// that dimension instead.
+function inset(amount, box) {
+  return [trim(amount[X], box[X]), trim(amount[Y], box[Y])];
+}
+
+// This file contains helper functions for working with angles.
+function polar(r, th) {
+  if (typeof r === "number") {
+    r = [r, r];
+  }
+  th = th * Math.PI / 180;
+  return [r[0] * Math.cos(th), r[1] * Math.sin(th)];
+}
+const findAngle = (point1, point2, vertex) => {
+  if (vertex === undefined) {
+    const x = point1[0] - point2[0];
+    const y = point1[1] - point2[1];
+    if (!x && !y) {
+      return 0;
+    }
+    return (180 + Math.atan2(-y, -x) * 180 / Math.PI + 360) % 360;
+  }
+  return findAngle(point1, vertex) - findAngle(point2, vertex);
+};
+
 function AxisLabels() {
   const {
     range,
@@ -28664,8 +28750,8 @@ function AxisLabels() {
     width,
     height
   } = useGraphConfig();
-  const yAxisLabelLocation = [0, range[1][1]];
-  const xAxisLabelLocation = [range[0][1], 0];
+  const yAxisLabelLocation = [0, range[Y][MAX]];
+  const xAxisLabelLocation = [range[X][MAX], 0];
   const [xAxisLabelText, yAxisLabelText] = labels;
   const graphInfo = {
     range,
@@ -28836,6 +28922,32 @@ const LockedEllipse = props => {
   });
 };
 
+const LockedFunction = props => {
+  const {
+    color,
+    strokeStyle,
+    directionalAxis,
+    domain
+  } = props;
+  const plotProps = {
+    color: lockedFigureColors[color],
+    style: strokeStyle,
+    domain
+  };
+  const equation = props.equationParsed || KAS__namespace.parse(props.equation).expr;
+  return /*#__PURE__*/React__namespace.createElement("g", {
+    className: "locked-function"
+  }, directionalAxis === "x" && /*#__PURE__*/React__namespace.createElement(mafs.Plot.OfX, _extends({
+    y: x => equation.eval({
+      x
+    })
+  }, plotProps)), directionalAxis === "y" && /*#__PURE__*/React__namespace.createElement(mafs.Plot.OfY, _extends({
+    x: y => equation.eval({
+      y
+    })
+  }, plotProps)));
+};
+
 function pathBuilder() {
   return new PathBuilder();
 }
@@ -28934,7 +29046,7 @@ function Arrowhead(props) {
   const [point] = useTransformVectorsToPixels(props.tip);
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: "interactive-graph-arrowhead",
-    transform: `translate(${point[0]} ${point[1]}) rotate(${props.angle})`
+    transform: `translate(${point[X]} ${point[Y]}) rotate(${props.angle})`
   }, /*#__PURE__*/React__namespace.createElement("g", {
     transform: "translate(-1.5)"
   }, /*#__PURE__*/React__namespace.createElement("path", {
@@ -29004,10 +29116,10 @@ function SVGLine(props) {
     testId
   } = props;
   return /*#__PURE__*/React__namespace.createElement("line", {
-    x1: start[0],
-    y1: start[1],
-    x2: end[0],
-    y2: end[1],
+    x1: start[X],
+    y1: start[Y],
+    x2: end[X],
+    y2: end[Y],
     style: style,
     className: className,
     "data-testid": testId
@@ -29092,8 +29204,8 @@ const LockedLine = props => {
   return /*#__PURE__*/React__namespace.createElement("g", {
     className: kind === "ray" ? "locked-ray" : "locked-line"
   }, line, showPoint1 && /*#__PURE__*/React__namespace.createElement(mafs.Point, {
-    x: point1.coord[0],
-    y: point1.coord[1],
+    x: point1.coord[X],
+    y: point1.coord[Y],
     svgCircleProps: {
       style: {
         fill: point1.filled ? lockedFigureColors[point1.color] : wonderBlocksTokens.color.white,
@@ -29102,8 +29214,8 @@ const LockedLine = props => {
       }
     }
   }), showPoint2 && /*#__PURE__*/React__namespace.createElement(mafs.Point, {
-    x: point2.coord[0],
-    y: point2.coord[1],
+    x: point2.coord[X],
+    y: point2.coord[Y],
     svgCircleProps: {
       style: {
         fill: point2.filled ? lockedFigureColors[point2.color] : wonderBlocksTokens.color.white,
@@ -29151,8 +29263,8 @@ const LockedPolygon = props => {
     color: lockedFigureColors[color]
   }), showVertices && points.map((point, index) => /*#__PURE__*/React__namespace.createElement(mafs.Point, {
     key: `locked-polygon-point-${index}`,
-    x: point[0],
-    y: point[1],
+    x: point[X],
+    y: point[Y],
     color: lockedFigureColors[color]
   })));
 };
@@ -29199,6 +29311,10 @@ const GraphLockedLayer = props => {
         return /*#__PURE__*/React__namespace.createElement(LockedPolygon, _extends({
           key: `polygon-${index}`
         }, figure));
+      case "function":
+        return /*#__PURE__*/React__namespace.createElement(LockedFunction, _extends({
+          key: `function-${index}`
+        }, figure));
       default:
         /**
          * Devlopment-time future-proofing: This should
@@ -29291,24 +29407,18 @@ const normalizePoints = (range, step, coordsList, noSnap) => coordsList.map(coor
 coords.map((coord, i) => {
   const axisRange = range[i];
   if (noSnap) {
-    return axisRange[0] + (axisRange[1] - axisRange[0]) * coord;
+    return axisRange[MIN] + size(axisRange) * coord;
   }
   const axisStep = step[i];
-  const nSteps = Math.floor((axisRange[1] - axisRange[0]) / axisStep);
+  const nSteps = Math.floor(size(axisRange) / axisStep);
   const tick = Math.round(coord * nSteps);
-  return axisRange[0] + axisStep * tick;
+  return axisRange[MIN] + axisStep * tick;
 }));
 
 // same as normalizeCoords in interactive-graph.tsx
 const normalizeCoords = (coordsList, ranges) => coordsList.map(coords => coords.map((coord, i) => {
-  const extent = ranges[i][1] - ranges[i][0];
-  return (coord + ranges[i][1]) / extent;
+  return (coord + ranges[i][1]) / size(ranges[i]);
 }));
-function snap(snapStep, point) {
-  const [requestedX, requestedY] = point;
-  const [snapX, snapY] = snapStep;
-  return [Math.round(requestedX / snapX) * snapX, Math.round(requestedY / snapY) * snapY];
-}
 
 // Returns the closest point to the given `point` that is within the graph
 // bounds given in `state`.
@@ -29318,19 +29428,8 @@ function bound$1(_ref) {
     range,
     point
   } = _ref;
-  const [requestedX, requestedY] = point;
-  const [snapX, snapY] = snapStep;
-  const [[minX, maxX], [minY, maxY]] = range;
-  return [clamp(requestedX, minX + snapX, maxX - snapX), clamp(requestedY, minY + snapY, maxY - snapY)];
-}
-function clamp(value, min, max) {
-  if (value < min) {
-    return min;
-  }
-  if (value > max) {
-    return max;
-  }
-  return value;
+  const boundingBox = inset(snapStep, range);
+  return clampToBox(boundingBox, point);
 }
 
 var isProduction = process.env.NODE_ENV === 'production';
@@ -29400,8 +29499,8 @@ function useDraggable(args) {
         metaKey,
         shiftKey
       } = state;
-      const direction = [yDownDirection[0], -yDownDirection[1]];
-      const span = Math.abs(direction[0]) ? xSpan : ySpan;
+      const direction = [yDownDirection[X], -yDownDirection[Y]];
+      const span = Math.abs(direction[X]) ? xSpan : ySpan;
       let divisions = 50;
       if (altKey || metaKey) {
         divisions = 200;
@@ -29512,8 +29611,10 @@ const MovablePointView = /*#__PURE__*/React.forwardRef((props, hitboxRef) => {
   })?.[0] ?? "blue";
   const pointClasses = `movable-point ${dragging ? "movable-point--dragging" : ""} ${focusClass(focusBehavior)}`;
   const [[x, y]] = useTransformVectorsToPixels(point);
-  const [xMin, xMax] = range[0];
-  const [yMin, yMax] = range[1];
+
+  // TODO(benchristel): destructure range in one line
+  const [xMin, xMax] = range[X];
+  const [yMin, yMax] = range[Y];
   const [[verticalStartX]] = useTransformVectorsToPixels([xMin, 0]);
   const [[verticalEndX]] = useTransformVectorsToPixels([xMax, 0]);
   const [[_, horizontalStartY]] = useTransformVectorsToPixels([0, yMin]);
@@ -29570,7 +29671,7 @@ const MovablePointView = /*#__PURE__*/React.forwardRef((props, hitboxRef) => {
   return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, showHairlines && hairlines, showTooltips ? /*#__PURE__*/React__namespace.createElement(Tooltip__default["default"], {
     autoUpdate: true,
     backgroundColor: wbColorName,
-    content: `(${point[0]}, ${point[1]})`,
+    content: `(${point[X]}, ${point[Y]})`,
     contentStyle: {
       color: "white"
     }
@@ -29755,16 +29856,7 @@ function trimRange(range, graphDimensionsInPixels) {
   const graphUnitsPerPixelY = size(yRange) / pixelsTall;
   const graphUnitsToTrimX = pixelsToTrim * graphUnitsPerPixelX;
   const graphUnitsToTrimY = pixelsToTrim * graphUnitsPerPixelY;
-  return [trim(xRange, graphUnitsToTrimX), trim(yRange, graphUnitsToTrimY)];
-}
-function trim(interval, amount) {
-  if (size(interval) < amount * 2) {
-    return [0, 0];
-  }
-  return [interval[0] + amount, interval[1] - amount];
-}
-function size(interval) {
-  return interval[1] - interval[0];
+  return inset([graphUnitsToTrimX, graphUnitsToTrimY], range);
 }
 
 const SegmentGraph = props => {
@@ -29899,7 +29991,7 @@ const SvgDefs = () => /*#__PURE__*/React__default["default"].createElement("defs
   in: "SourceGraphic"
 })));
 
-const Angle = _ref => {
+const PolygonAngle = _ref => {
   let {
     centerPoint,
     endPoints,
@@ -29927,7 +30019,7 @@ const Angle = _ref => {
   // Used to calculate the inside of the angle and to create square
   const [x3, y3] = mafs.vec.add(centerPoint, mafs.vec.add(mafs.vec.sub([x1, y1], centerPoint), mafs.vec.sub([x2, y2], centerPoint)));
   if (!showAngles) {
-    return isRightAngle(angle) ? /*#__PURE__*/React__namespace.createElement(RightAngleSquare, {
+    return isRightPolygonAngle(angle) ? /*#__PURE__*/React__namespace.createElement(RightAngleSquare, {
       start: [x1, y1],
       vertex: [x2, y2],
       end: [x3, y3]
@@ -29964,35 +30056,138 @@ const Angle = _ref => {
     start: [x1, y1],
     vertex: [x2, y2],
     end: [x3, y3]
-  }) : /*#__PURE__*/React__namespace.createElement(MafsCssTransformWrapper, null, /*#__PURE__*/React__namespace.createElement("path", {
-    d: arc,
-    strokeWidth: 0.02,
-    fill: "none"
-  })), /*#__PURE__*/React__namespace.createElement(TextLabel, {
+  }) : /*#__PURE__*/React__namespace.createElement(Arc, {
+    arc: arc
+  }), /*#__PURE__*/React__namespace.createElement(TextLabel, {
     x: x3,
     y: y3,
     attach: y3 - centerY > 0 ? "s" : "n",
     attachDistance: Math.abs(y3 - centerY) < 0.2 || mafs.vec.dist([x3, y3], centerPoint) < 0.3 ? 20 : 10
   }, angleLabel, "\xB0"));
 };
+const Angle = _ref2 => {
+  let {
+    vertex,
+    coords,
+    showAngles,
+    allowReflexAngles,
+    range
+  } = _ref2;
+  // Check if the points are clockwise or not, depending on whether we allow reflex angles
+  const areClockwise = clockwise$1([...coords, vertex]);
+  const shouldReverseCoords = areClockwise && !allowReflexAngles;
+
+  // Reverse the coordinates accordingly to ensure the angle is calculated correctly
+  const clockwiseCoords = shouldReverseCoords ? coords : coords.reverse();
+
+  // Calculate the angles between the two points
+  const startAngle = findAngle(clockwiseCoords[0], vertex);
+  const endAngle = findAngle(clockwiseCoords[1], vertex);
+  const angle = (startAngle + 360 - endAngle) % 360;
+
+  // Check if the angle is reflexive
+  const isReflexive = angle > 180;
+
+  // Break out the necessary points for the arc calculation
+  const [centerX, centerY] = vertex;
+  const [point1, point2] = clockwiseCoords;
+  const [startX, startY] = point1;
+  const [endX, endY] = point2;
+  const a = mafs.vec.dist(vertex, point1);
+  const b = mafs.vec.dist(vertex, point2);
+
+  // Set the radius of the arc
+  const radius = 2;
+
+  // Calculate the end points of the arc
+  const y1 = centerY + (startY - centerY) / a * radius;
+  const x2 = centerX + (endX - centerX) / b * radius;
+  const x1 = centerX + (startX - centerX) / a * radius;
+  const y2 = centerY + (endY - centerY) / b * radius;
+
+  // Used to calculate the inside of the angle and to create square
+  const [x3, y3] = mafs.vec.add(vertex, mafs.vec.add(mafs.vec.sub([x1, y1], vertex), mafs.vec.sub([x2, y2], vertex)));
+
+  // Determine whether the arc should be drawn outside the angle
+  const isOutside = shouldDrawArcOutside([x3, y3], vertex, range, [[vertex, point1], [vertex, point2]]);
+
+  // Determine the flags for the arc
+  // If the angle is outside OR reflexive, we want to draw a large arc
+  // If the angle is outside AND reflexive, we want to sweep the arc
+  const largeArcFlag = isOutside || isReflexive ? 1 : 0;
+  const sweepFlag = isOutside && isReflexive ? 1 : 0;
+
+  // Create the SVG path for the arc
+  const arc = `M ${x1} ${y1} A ${radius} ${radius} 0 ${largeArcFlag} ${sweepFlag} ${x2} ${y2}`;
+
+  // We only ever want to show whole angles
+  const angleLabel = parseFloat(angle.toFixed(0)); // Only want to show whole angles
+
+  // Calculate the text position based on the angle and whether we allow reflex angles
+  // Let's try the angle bisector method to find the midpoint of the arc
+  const [textX, textY] = calculateBisectorPoint(point1, point2, vertex, isReflexive, allowReflexAngles, radius);
+  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement("defs", null, /*#__PURE__*/React__namespace.createElement("filter", {
+    id: "background",
+    x: "-5%",
+    width: "110%",
+    y: "0%",
+    height: "100%"
+  }, /*#__PURE__*/React__namespace.createElement("feFlood", {
+    floodColor: "#FFF",
+    floodOpacity: "0.5"
+  }), /*#__PURE__*/React__namespace.createElement("feComposite", {
+    operator: "over",
+    in: "SourceGraphic"
+  }))), isRightAngle(angle) ? /*#__PURE__*/React__namespace.createElement(RightAngleSquare, {
+    start: [x1, y1],
+    vertex: [x2, y2],
+    end: [x3, y3],
+    className: "arc-right-angle"
+  }) : /*#__PURE__*/React__namespace.createElement(Arc, {
+    arc: arc,
+    className: "angle-arc"
+  }), showAngles && /*#__PURE__*/React__namespace.createElement(TextLabel, {
+    x: textX,
+    y: textY,
+    color: wonderBlocksTokens.color.blue
+  }, angleLabel, "\xB0"));
+};
 
 /**
  * This is broken out into its own component so that it can be used for an early return
  * (see line 55 or https://github.com/Khan/perseus/blob/84bbd882b11d16871e1b813a0b901f3b903d5479/packages/perseus/src/widgets/interactive-graphs/graphs/components/angle.tsx#L53-L57)
  */
-const RightAngleSquare = _ref2 => {
+const RightAngleSquare = _ref3 => {
   let {
     start: [x1, y1],
     vertex: [x2, y2],
-    end: [x3, y3]
-  } = _ref2;
+    end: [x3, y3],
+    className
+  } = _ref3;
   return /*#__PURE__*/React__namespace.createElement(MafsCssTransformWrapper, null, /*#__PURE__*/React__namespace.createElement("path", {
     d: `M ${x1} ${y1} L ${x3} ${y3} M ${x3} ${y3} L ${x2} ${y2}`,
     strokeWidth: 0.02,
-    fill: "none"
+    fill: "none",
+    className: className
   }));
 };
-const isRightAngle = angle => Math.abs(angle - Math.PI / 2) < 0.01;
+
+// We're conditionally adding the class name here so that we can style the arc differently
+// based on whether it's an angle or a polygon angle
+const Arc = _ref4 => {
+  let {
+    arc,
+    className
+  } = _ref4;
+  return /*#__PURE__*/React__namespace.createElement(MafsCssTransformWrapper, null, /*#__PURE__*/React__namespace.createElement("path", {
+    d: arc,
+    strokeWidth: 0.02,
+    fill: "none",
+    className: className
+  }));
+};
+const isRightPolygonAngle = angle => Math.abs(angle - Math.PI / 2) < 0.01;
+const isRightAngle = angle => Math.round(angle) === 90;
 
 /**
  * Determines if an angle is an inside (false) or outside (true) angle.
@@ -30014,9 +30209,9 @@ const shouldDrawArcOutside = (midpoint, vertex, range, polygonLines) => {
 
 // https://stackoverflow.com/a/24392281/7347484
 // The "intersects" function in geometry doesn't seem to work for this use case
-const linesIntersect = (_ref3, _ref4) => {
-  let [[a, b], [c, d]] = _ref3;
-  let [[p, q], [r, s]] = _ref4;
+const linesIntersect = (_ref5, _ref6) => {
+  let [[a, b], [c, d]] = _ref5;
+  let [[p, q], [r, s]] = _ref6;
   const determinant = (c - a) * (s - q) - (r - p) * (d - b);
   if (determinant === 0) {
     return false;
@@ -30028,6 +30223,75 @@ const linesIntersect = (_ref3, _ref4) => {
 };
 const isEven = n => n % 2 === 0;
 
+// This function calculates the bisector point of an angle formed by two points
+// and a vertex. It is used to position the angle label so that it is always
+// outside the arc at the exact midpoint of the angle.
+// Reflex angles make use of polar coordinates to determine the correct direction
+function calculateBisectorPoint(point1, point2, vertex, isReflex, allowReflex, arcRadius) {
+  const [originX, originY] = vertex;
+  const [x1, y1] = point1;
+  const [x2, y2] = point2;
+
+  // Convert the Cartesian Coordinates to vectors
+  const vectorA = [x1 - originX, y1 - originY];
+  const vectorB = [x2 - originX, y2 - originY];
+
+  // Calculate the average angle of the vectors
+  // so that we can point the bisector in the correct direction using polar coordinates
+  const angleA = Math.atan2(vectorA[1], vectorA[0]);
+  const angleB = Math.atan2(vectorB[1], vectorB[0]);
+
+  // Calculate the average of these two angles
+  let averageAngle = (angleA + angleB) / 2;
+  const angleRadians = Math.abs(angleA - angleB);
+
+  // Adjust the average angle to point in the correct direction
+  // and to account for reflex angles and a bug with 180 degrees
+  // that occurs due to our angleOffsetDegrees option in the graph
+  if (allowReflex) {
+    // If the resulting angles are less than 180 degrees,
+    // or if the user has flipped the points on the interactive element
+    // ensure that we have the correct direction for the reflex angle
+    if (angleRadians <= Math.PI && isReflex || angleB > angleA) {
+      averageAngle += Math.PI; // Add 180 degrees
+    }
+  } else {
+    // If the resulting angles are greater than 180 degrees, adjust
+    // to get the correct angle, as we already know that the angle is not reflexive
+    // This fixes a bug that occurs at 180 degrees due to our angleOffsetDegrees option in the graph
+    if (angleRadians > Math.PI) {
+      averageAngle -= Math.PI; // Subract 180 degrees
+    }
+  }
+
+  // Convert the average angle back to Cartesian coordinates
+  const sum = [Math.cos(averageAngle), Math.sin(averageAngle)];
+
+  // Calculate the magnitude of the sum to normalize it
+  const sumMagnitude = Math.sqrt(sum[0] ** 2 + sum[1] ** 2);
+  const bisectorDirection = [sum[0] / sumMagnitude, sum[1] / sumMagnitude];
+
+  // Calculate the initial distance of the bisector direction from the origin
+  const initialDistance = Math.sqrt(bisectorDirection[0] ** 2 + bisectorDirection[1] ** 2);
+
+  // Determine the minimum radius to ensure that the text is always outside the arc
+  const requiredDistance = arcRadius * 1.75;
+  let radius = requiredDistance / initialDistance;
+
+  // Apply radius only if the initial distance is less than required
+  if (initialDistance >= requiredDistance) {
+    radius = 1; // Use the unit vector as is
+  }
+
+  // Scale the bisector direction by the radius
+  const bisectorPoint = [bisectorDirection[0] * radius, bisectorDirection[1] * radius];
+
+  // Add the vertex to the bisector point to get the final position
+  // to ensure that the angle label moves with the interactive element
+  const scaledBisector = mafs.vec.add(bisectorPoint, vertex);
+  return scaledBisector;
+}
+
 const StyledMovablePoint = props => {
   const {
     snapStep
@@ -30108,7 +30372,7 @@ const PolygonGraph = props => {
     if (!pt1 || !pt2) {
       return null;
     }
-    return /*#__PURE__*/React__namespace.createElement(Angle, {
+    return /*#__PURE__*/React__namespace.createElement(PolygonAngle, {
       key: "angle-" + i,
       centerPoint: point,
       endPoints: [pt1, pt2],
@@ -30212,6 +30476,13 @@ function getGradableGraph(state, initialGraph) {
       coords: state.coords
     };
   }
+  if (state.type === "angle" && initialGraph.type === "angle") {
+    return {
+      ...initialGraph,
+      coords: state.coords,
+      allowReflexAngles: state.allowReflexAngles
+    };
+  }
   throw new Error("Mafs is not yet implemented for graph type: " + initialGraph.type);
 }
 
@@ -30274,16 +30545,16 @@ function MovableCircle(props) {
     className: `movable-circle ${dragging ? "movable-circle--dragging" : ""}`
   }, /*#__PURE__*/React__namespace.createElement("ellipse", {
     className: "focus-ring",
-    cx: centerPx[0],
-    cy: centerPx[1],
-    rx: radiiPx[0] + 3,
-    ry: radiiPx[1] + 3
+    cx: centerPx[X],
+    cy: centerPx[Y],
+    rx: radiiPx[X] + 3,
+    ry: radiiPx[Y] + 3
   }), /*#__PURE__*/React__namespace.createElement("ellipse", {
     className: "circle",
-    cx: centerPx[0],
-    cy: centerPx[1],
-    rx: radiiPx[0],
-    ry: radiiPx[1]
+    cx: centerPx[X],
+    cy: centerPx[Y],
+    rx: radiiPx[X],
+    ry: radiiPx[Y]
   }), /*#__PURE__*/React__namespace.createElement(DragHandle, {
     center: center
   }));
@@ -30299,15 +30570,16 @@ function DragHandle(props) {
   const topLeft = mafs.vec.sub(centerPx, mafs.vec.scale(dragHandleDimensions, 0.5));
   return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement("rect", {
     className: "movable-circle-handle",
-    x: topLeft[0],
-    y: topLeft[1],
-    width: dragHandleDimensions[0],
-    height: dragHandleDimensions[1],
+    x: topLeft[X],
+    y: topLeft[Y],
+    width: dragHandleDimensions[X],
+    height: dragHandleDimensions[Y],
     rx: cornerRadius,
     ry: cornerRadius
   }), dragHandleDotPositions.map(offsetPx => {
     const [xPx, yPx] = mafs.vec.add(offsetPx, centerPx);
     return /*#__PURE__*/React__namespace.createElement("circle", {
+      key: `circle-${xPx}-${yPx}`,
       className: "movable-circle-handle-dot",
       cx: xPx,
       cy: yPx
@@ -30436,15 +30708,15 @@ const getSinusoidCoefficients = coords => {
   const p2 = coords[1];
 
   // If the x-coordinates are the same, we are unable to calculate the coefficients
-  if (p2[0] === p1[0]) {
+  if (p2[X] === p1[X]) {
     return;
   }
 
   // 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];
+  const amplitude = p2[Y] - p1[Y];
+  const angularFrequency = Math.PI / (2 * (p2[X] - p1[X]));
+  const phase = p1[X] * angularFrequency;
+  const verticalOffset = p1[Y];
   return {
     amplitude,
     angularFrequency,
@@ -30453,6 +30725,75 @@ const getSinusoidCoefficients = coords => {
   };
 };
 
+function AngleGraph(props) {
+  const {
+    dispatch,
+    graphState
+  } = props;
+  const {
+    graphDimensionsInPixels
+  } = useGraphConfig();
+  const {
+    coords,
+    showAngles,
+    range,
+    allowReflexAngles,
+    angleOffsetDeg,
+    snapDegrees
+  } = graphState;
+
+  // Break the coords into the two end points and the center point
+  const endPoints = [coords[0], coords[2]];
+  const centerPoint = coords[1];
+
+  // Convert the vectors to pixels for rendering the svg lines
+  const angleLines = [[centerPoint, endPoints[0]], [centerPoint, endPoints[1]]];
+  const linePixelCoords = [useTransformVectorsToPixels(centerPoint, endPoints[0]), useTransformVectorsToPixels(centerPoint, endPoints[1])];
+
+  // Create the SVG lines for the angle
+  const svgLines = linePixelCoords.map((_ref, i) => {
+    let [startPtPx, endPtPx] = _ref;
+    const trimmedRange = trimRange(range, graphDimensionsInPixels);
+    const endExtend = getIntersectionOfRayWithBox(angleLines[i][0], angleLines[i][1], trimmedRange);
+    return /*#__PURE__*/React__namespace.createElement("g", {
+      key: `line-${i}`
+    }, /*#__PURE__*/React__namespace.createElement(SVGLine, {
+      start: startPtPx,
+      end: endPtPx,
+      style: {
+        stroke: "var(--movable-line-stroke-color)",
+        strokeWidth: "var(--movable-line-stroke-weight)"
+      }
+    }), /*#__PURE__*/React__namespace.createElement(Vector, {
+      tail: angleLines[i][1],
+      tip: endExtend,
+      color: "var(--movable-line-stroke-color)"
+    }));
+  });
+
+  // Create the angle indicator parameters
+  const angleParams = {
+    vertex: centerPoint,
+    coords: endPoints,
+    allowReflexAngles: allowReflexAngles || false,
+    // Whether to allow reflex angles or not
+    angleOffsetDeg: angleOffsetDeg || 0,
+    // The angle offset from the x-axis
+    snapDegrees: snapDegrees || 1,
+    // The multiple of degrees to snap to
+    range: range,
+    showAngles: showAngles || false // Whether to show the angle or not
+  };
+
+  // Render the lines, angle, and then movable points
+  return /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, svgLines, /*#__PURE__*/React__namespace.createElement(Angle, angleParams), coords.map((point, i) => /*#__PURE__*/React__namespace.createElement(StyledMovablePoint, {
+    key: "point-" + i,
+    snapTo: "angles",
+    point: point,
+    onMove: destination => dispatch(movePoint(i, destination))
+  })));
+}
+
 // Universal padding for the axis ticks to ensure that the labels
 // have enough space to render without overlapping the tick lines
 const tickPadding = 5;
@@ -30462,10 +30803,12 @@ const AxisTickLabels = () => {
     tickStep,
     range
   } = graphConfig;
-  const [xMin, xMax] = range[0];
-  const [yMin, yMax] = range[1];
-  const yTickStep = tickStep[1];
-  const xTickStep = tickStep[0];
+
+  // TODO(benchristel): use destructuring here
+  const [xMin, xMax] = range[X];
+  const [yMin, yMax] = range[Y];
+  const yTickStep = tickStep[Y];
+  const xTickStep = tickStep[X];
   const yGridTicks = generateTickLocations$1(yTickStep, yMin, yMax);
   const xGridTicks = generateTickLocations$1(xTickStep, xMin, xMax);
   return /*#__PURE__*/React__namespace.createElement("div", {
@@ -30747,13 +31090,13 @@ const YGridTick = _ref => {
 
   // If the graph is zoomed in, we want to make sure the ticks are still visible
   // even if they are outside the graph's range.
-  if (graphInfo.range[0][0] > 0) {
+  if (graphInfo.range[X][MIN] > 0) {
     // If the graph is on the positive side of the x-axis, lock the ticks to the left side of the graph
-    xPointOnAxis = graphInfo.range[0][0];
+    xPointOnAxis = graphInfo.range[X][MIN];
   }
-  if (graphInfo.range[0][1] < 0) {
+  if (graphInfo.range[X][MAX] < 0) {
     // If the graph is on the negative side of the x-axis, lock the ticks to the right side of the graph
-    xPointOnAxis = graphInfo.range[0][1];
+    xPointOnAxis = graphInfo.range[X][MAX];
   }
   const pointOnAxis = [xPointOnAxis, y];
   const [[xPosition, yPosition]] = useTransformVectorsToPixels(pointOnAxis);
@@ -30788,13 +31131,13 @@ const XGridTick = _ref2 => {
   let yPointOnAxis = 0;
   // If the graph is zoomed in, we want to make sure the ticks are still visible
   // even if they are outside the graph's range.
-  if (graphInfo.range[1][0] > 0) {
+  if (graphInfo.range[Y][MIN] > 0) {
     // If the graph is on the positive side of the y-axis, lock the ticks to the top of the graph
-    yPointOnAxis = graphInfo.range[1][0];
+    yPointOnAxis = graphInfo.range[Y][MIN];
   }
-  if (graphInfo.range[1][1] < 0) {
+  if (graphInfo.range[Y][MAX] < 0) {
     // If the graph is on the negative side of the x-axis, lock the ticks to the bottom of the graph
-    yPointOnAxis = graphInfo.range[1][1];
+    yPointOnAxis = graphInfo.range[Y][MAX];
   }
   const pointOnAxis = [x, yPointOnAxis];
   const [[xPosition, yPosition]] = useTransformVectorsToPixels(pointOnAxis);
@@ -30849,10 +31192,12 @@ const AxisTicks = () => {
     width,
     height
   };
-  const [xMin, xMax] = range[0];
-  const [yMin, yMax] = range[1];
-  const yTickStep = tickStep[1];
-  const xTickStep = tickStep[0];
+
+  // TODO(benchristel): destructure these in one line
+  const [xMin, xMax] = range[X];
+  const [yMin, yMax] = range[Y];
+  const yTickStep = tickStep[Y];
+  const xTickStep = tickStep[X];
   const yGridTicks = generateTickLocations(yTickStep, yMin, yMax);
   const xGridTicks = generateTickLocations(xTickStep, xMin, xMax);
   return /*#__PURE__*/React__namespace.createElement("g", {
@@ -30891,8 +31236,8 @@ const axisOptions = (props, axisIndex) => {
 };
 const Grid = props => {
   return props.markings === "none" ? null : /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(mafs.Coordinates.Cartesian, {
-    xAxis: axisOptions(props, 0),
-    yAxis: axisOptions(props, 1)
+    xAxis: axisOptions(props, X),
+    yAxis: axisOptions(props, Y)
   }),
   // 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)));
@@ -31500,7 +31845,7 @@ const LegacyGrid = _ref => {
     height
   } = backgroundImage ?? {};
   if (url && typeof url === "string") {
-    const scale = box[0] / interactiveSizes$1.defaultBoxSize;
+    const scale = box[X] / interactiveSizes$1.defaultBoxSize;
     return /*#__PURE__*/React__namespace.createElement(wonderBlocksCore.View, {
       style: {
         position: "absolute",
@@ -31568,9 +31913,9 @@ function Protractor() {
   const angle = calculateAngleInDegrees(rotationHandleOffset) - calculateAngleInDegrees(centerToRotationHandle);
   return /*#__PURE__*/React__namespace.createElement("g", {
     ref: draggableRef,
-    transform: `translate(${topLeftPx[0]}, ${topLeftPx[1]}), rotate(${angle})`,
+    transform: `translate(${topLeftPx[X]}, ${topLeftPx[Y]}), rotate(${angle})`,
     style: {
-      transformOrigin: `${-centerToTopLeft[0]}px ${-centerToTopLeft[1]}px`
+      transformOrigin: `${-centerToTopLeft[X]}px ${-centerToTopLeft[Y]}px`
     }
   }, /*#__PURE__*/React__namespace.createElement("image", {
     href: protractorImage
@@ -31744,7 +32089,19 @@ function initializeGraphState(params) {
         coords: getSinusoidCoords(graph, range, step)
       };
     case "angle":
-      throw new Error("Mafs not yet implemented for graph type: " + graph.type);
+      return {
+        ...shared,
+        type: graph.type,
+        showAngles: Boolean(graph.showAngles),
+        coords: getAngleCoords({
+          graph,
+          range,
+          step
+        }),
+        angleOffsetDeg: Number(graph.angleOffsetDeg),
+        allowReflexAngles: Boolean(graph.allowReflexAngles),
+        snapDegrees: Number(graph.snapDegrees)
+      };
     default:
       throw new wonderStuffCore.UnreachableCaseError(graph);
   }
@@ -31876,6 +32233,43 @@ function getCircleCoords(graph) {
     radiusPoint: [2, 0]
   };
 }
+const getAngleCoords = params => {
+  const {
+    graph,
+    range,
+    step
+  } = params;
+  if (graph.coords) {
+    return graph.coords;
+  }
+  const {
+    snapDegrees,
+    angleOffsetDeg
+  } = graph;
+  const snap = snapDegrees || 1;
+  let angle = snap;
+  while (angle < 20) {
+    angle += snap;
+  }
+  angle = angle * Math.PI / 180;
+  const offset = (angleOffsetDeg || 0) * Math.PI / 180;
+  let defaultCoords = [[0.85, 0.5], [0.5, 0.5]];
+  defaultCoords = normalizePoints(range, step, defaultCoords, true);
+
+  // @ts-expect-error - TS2345 - Argument of type 'number[]' is not assignable to parameter of type 'readonly Coord[]'. | TS2556 - A spread argument must either have a tuple type or be passed to a rest parameter.
+  const radius = magnitude(vector(...defaultCoords));
+
+  // We're adding a placeholder for the third point to appease ts and so that we
+  // can calculate it after we've adjusted the first point by the angleOffsetDeg
+  const coords = [...defaultCoords, [0, 0]];
+
+  // Adjust the lower point by angleOffsetDeg degrees
+  coords[0] = [coords[1][0] + radius * Math.cos(offset), coords[1][1] + radius * Math.sin(offset)];
+  // Position the upper point angle radians from the
+  // lower point
+  coords[2] = [coords[1][0] + radius * Math.cos(angle + offset), coords[1][1] + radius * Math.sin(angle + offset)];
+  return coords;
+};
 
 function interactiveGraphReducer(state, action) {
   switch (action.type) {
@@ -31939,6 +32333,7 @@ function doMoveControlPoint(state, action) {
           coords: newCoords
         };
       }
+    case "angle":
     case "circle":
       throw new Error("FIXME implement circle reducer");
     case "point":
@@ -32043,12 +32438,32 @@ function doMoveAll(state, action) {
 }
 function doMovePoint(state, action) {
   switch (state.type) {
+    case "angle":
+      // If the index is 1, we are moving the vertex of the angle,
+      // which will move the other two points as well
+      if (action.index === 1) {
+        const updatedCoords = boundAndSnapAngleVertex(state, action);
+        return {
+          ...state,
+          hasBeenInteractedWith: true,
+          coords: updatedCoords
+        };
+      }
+      return {
+        ...state,
+        hasBeenInteractedWith: true,
+        coords: setAtIndex({
+          array: state.coords,
+          index: action.index,
+          newValue: boundAndSnapAngleEndPoints(action.destination, state, action.index)
+        })
+      };
     case "polygon":
       let newValue;
       if (state.snapTo === "sides") {
         newValue = boundAndSnapToSides(action.destination, state, action.index);
       } else if (state.snapTo === "angles") {
-        newValue = boundAndSnapToAngle(action.destination, state, action.index);
+        newValue = boundAndSnapToPolygonAngle(action.destination, state, action.index);
       } else {
         newValue = boundAndSnapToGrid(action.destination, state);
       }
@@ -32089,7 +32504,7 @@ function doMovePoint(state, action) {
         // vertical line. If they are, then we don't want to move the point
         const newCoords = [...state.coords];
         newCoords[action.index] = boundDestination;
-        if (newCoords[0][0] === newCoords[1][0]) {
+        if (newCoords[0][X] === newCoords[1][X]) {
           return state;
         }
         return {
@@ -32149,13 +32564,13 @@ function doMoveCenter(state, action) {
         // if it otherwise would be off the chart
         // ex: if the handle is on the right and we move the center
         // to the rightmost position, move the handle to the left
-        const [xMin, xMax] = state.range[0];
+        const [xMin, xMax] = state.range[X];
         const [radX] = newRadiusPoint;
         if (radX < xMin || radX > xMax) {
-          const xJumpDist = (radX - constrainedCenter[0]) * 2;
+          const xJumpDist = (radX - constrainedCenter[X]) * 2;
           const possibleNewX = radX - xJumpDist;
           if (possibleNewX >= xMin && possibleNewX <= xMax) {
-            newRadiusPoint[0] = possibleNewX;
+            newRadiusPoint[X] = possibleNewX;
           }
         }
         return {
@@ -32173,11 +32588,11 @@ function doMoveRadiusPoint(state, action) {
   switch (state.type) {
     case "circle":
       {
-        const [xMin, xMax] = state.range[0];
+        const [xMin, xMax] = state.range[X];
         const nextRadiusPoint = [
         // Constrain to graph range
         // The +0 is to convert -0 to +0
-        Math.min(Math.max(xMin, action.destination[0] + 0), xMax), state.center[1]];
+        clamp(action.destination[X] + 0, xMin, xMax), state.center[1]];
         if (___default["default"].isEqual(nextRadiusPoint, state.center)) {
           return state;
         }
@@ -32215,10 +32630,10 @@ function doChangeRange(state, action) {
 }
 const getDeltaVertex = (maxMoves, minMoves, delta) => {
   const [deltaX, deltaY] = delta;
-  const maxXMove = Math.min(...maxMoves.map(move => move[0]));
-  const maxYMove = Math.min(...maxMoves.map(move => move[1]));
-  const minXMove = Math.max(...minMoves.map(move => move[0]));
-  const minYMove = Math.max(...minMoves.map(move => move[1]));
+  const maxXMove = Math.min(...maxMoves.map(move => move[X]));
+  const maxYMove = Math.min(...maxMoves.map(move => move[Y]));
+  const minXMove = Math.max(...minMoves.map(move => move[X]));
+  const minYMove = Math.max(...minMoves.map(move => move[Y]));
   const dx = clamp(deltaX, minXMove, maxXMove);
   const dy = clamp(deltaY, minYMove, maxYMove);
   return [dx, dy];
@@ -32252,11 +32667,130 @@ function boundAndSnapToGrid(point, _ref) {
     point
   }));
 }
-function boundAndSnapToAngle(destinationPoint, _ref2, index) {
+function boundAndSnapAngleVertex(_ref2, _ref3) {
   let {
     range,
-    coords
+    coords,
+    snapStep
   } = _ref2;
+  let {
+    destination
+  } = _ref3;
+  // Needed to prevent updating the original coords before the checks for
+  // degenerate triangles and overlapping sides
+  const coordsCopy = [...coords];
+
+  // Get the current and upcoming positions of the vertex
+  const startingVertex = coordsCopy[1];
+  const newVertex = bound$1({
+    snapStep,
+    range,
+    point: snap(snapStep, destination)
+  });
+
+  // Get the vector from the starting vertex to the new vertex
+  const delta = mafs.vec.add(newVertex, reverseVector(startingVertex));
+
+  // Apply the delta to each of the other two points so that the angle is maintained
+  let valid = true;
+  const newPoints = {};
+  for (const i of [0, 2]) {
+    const oldPoint = coordsCopy[i];
+    let newPoint = mafs.vec.add(oldPoint, delta);
+    let angle = findAngle(newVertex, newPoint);
+    angle *= Math.PI / 180;
+    newPoint = constrainToBoundsOnAngle(newPoint, angle, range, snapStep);
+    newPoints[i] = newPoint;
+
+    // Check if the new point is too close to the vertex
+    if (tooClose(newVertex, newPoint)) {
+      valid = false;
+    }
+  }
+
+  // Update the vertex after snapping to the snapStep
+  newPoints[1] = newVertex;
+  // Only move points if all new positions are valid
+  if (valid) {
+    Object.entries(newPoints).forEach(_ref4 => {
+      let [i, newPoint] = _ref4;
+      coordsCopy[i] = newPoint;
+    });
+  }
+  return coordsCopy;
+}
+
+// This function is used to ensure that the vertex of
+// an angle is not too close to the other points
+function tooClose(point1, point2, range) {
+  const safeDistance = 2;
+  const distance = mafs.vec.dist(point1, point2);
+  return distance < safeDistance;
+}
+function constrainToBoundsOnAngle(point, angle, range, snapStep) {
+  // We're subtracting the snapStep from the lower bound and adding it to the upper bound
+  // to ensure that the point is within the bounds of the graph even after snapping to the nearest degree
+  const lower = [range[0][0] + snapStep[0], range[1][0] + snapStep[0]];
+  const upper = [range[0][1] - snapStep[1], range[1][1] - snapStep[1]];
+  let result = point;
+  if (result[0] < lower[0]) {
+    result = [lower[0], result[1] + (lower[0] - result[0]) * Math.tan(angle)];
+  } else if (result[0] > upper[0]) {
+    result = [upper[0], result[1] - (result[0] - upper[0]) * Math.tan(angle)];
+  }
+  if (result[1] < lower[1]) {
+    result = [result[0] + (lower[1] - result[1]) / Math.tan(angle), lower[1]];
+  } else if (result[1] > upper[1]) {
+    result = [result[0] - (result[1] - upper[1]) / Math.tan(angle), upper[1]];
+  }
+  return result;
+}
+function boundAndSnapAngleEndPoints(destinationPoint, _ref5, index) {
+  let {
+    range,
+    coords,
+    snapDegrees,
+    angleOffsetDeg,
+    snapStep
+  } = _ref5;
+  const snap = snapDegrees || 1;
+  const offsetDegrees = angleOffsetDeg || 0;
+
+  // Needed to prevent updating the original coords before the checks for
+  // degenerate triangles and overlapping sides
+  const coordsCopy = [...coords];
+
+  // We want to subtract or add the snapStep to the lower and upper bounds
+  // respectively to ensure that the point is within the bounds of the graph
+  // even after snapping to the nearest degree
+  const angleRange = [[range[0][0] + snapStep[0], range[0][1] - snapStep[0]], [range[1][0] + snapStep[1], range[1][1] - snapStep[1]]];
+
+  // Takes the destination point and makes sure it is within the bounds of the graph
+  // SnapStep is [0, 0] because we don't want to snap these points to the grid at all
+  const boundPoint = bound$1({
+    snapStep: [0, 0],
+    range: angleRange,
+    point: destinationPoint
+  });
+  coordsCopy[index] = boundPoint;
+
+  // Get the vertex of the angle
+  const vertex = coords[1];
+
+  // Gets the angle between the coords and the vertex
+  let angle = findAngle(coordsCopy[index], vertex);
+
+  // Snap the angle to the nearest multiple of snapDegrees (if provided)
+  angle = Math.round((angle - offsetDegrees) / snap) * snap + offsetDegrees;
+  const distance = mafs.vec.dist(coordsCopy[index], vertex);
+  const snappedValue = mafs.vec.add(vertex, polar(distance, angle));
+  return snappedValue;
+}
+function boundAndSnapToPolygonAngle(destinationPoint, _ref6, index) {
+  let {
+    range,
+    coords
+  } = _ref6;
   const startingPoint = coords[index];
 
   // Needed to prevent updating the original coords before the checks for
@@ -32284,7 +32818,7 @@ function boundAndSnapToAngle(destinationPoint, _ref2, index) {
     angles[rel(j)] = Math.round(angles[rel(j)]);
   });
   const getAngle = function (a, vertex, b) {
-    const angle = GraphUtils.findAngle(coordsCopy[rel(a)], coordsCopy[rel(b)], coordsCopy[rel(vertex)]);
+    const angle = findAngle(coordsCopy[rel(a)], coordsCopy[rel(b)], coordsCopy[rel(vertex)]);
     return (angle + 360) % 360;
   };
   const innerAngles = [angles[rel(-1)] - getAngle(-2, -1, 1), angles[rel(1)] - getAngle(-1, 1, 2)];
@@ -32312,7 +32846,7 @@ function boundAndSnapToAngle(destinationPoint, _ref2, index) {
   const side = Math.sin(innerAngles[1] * Math.PI / 180) / Math.sin(innerAngles[2] * Math.PI / 180) * knownSide;
 
   // Angle at the second vertex of the polygon
-  const outerAngle = GraphUtils.findAngle(coordsCopy[rel(1)], coordsCopy[rel(-1)]);
+  const outerAngle = findAngle(coordsCopy[rel(1)], coordsCopy[rel(-1)]);
 
   // Uses the length of the side of the polygon (radial coordinate)
   // and the angle between the first and second sides of the
@@ -32320,11 +32854,11 @@ function boundAndSnapToAngle(destinationPoint, _ref2, index) {
   const offset = polar(side, outerAngle + (onLeft ? 1 : -1) * innerAngles[0]);
   return kmath.vector.add(coordsCopy[rel(-1)], offset);
 }
-function boundAndSnapToSides(destinationPoint, _ref3, index) {
+function boundAndSnapToSides(destinationPoint, _ref7, index) {
   let {
     range,
     coords
-  } = _ref3;
+  } = _ref7;
   const startingPoint = coords[index];
 
   // Needed to prevent updating the original coords before the checks for
@@ -32363,7 +32897,7 @@ function boundAndSnapToSides(destinationPoint, _ref3, index) {
   const innerAngle = lawOfCosines(sides[0], sides[2], sides[1]);
 
   // Angle at the second vertex of the polygon
-  const outerAngle = GraphUtils.findAngle(coordsCopy[rel(1)], coordsCopy[rel(-1)]);
+  const outerAngle = findAngle(coordsCopy[rel(1)], coordsCopy[rel(-1)]);
 
   // Returns true if the points form a counter-clockwise turn;
   // a.k.a if the point is on the left or right of the polygon.
@@ -32381,12 +32915,12 @@ function boundAndSnapToSides(destinationPoint, _ref3, index) {
 }
 
 // Returns the vector from the given point to the top-right corner of the graph when snapped to the grid
-function maxMove(_ref4) {
+function maxMove(_ref8) {
   let {
     snapStep,
     range,
     point
-  } = _ref4;
+  } = _ref8;
   const topRight = bound$1({
     snapStep,
     range,
@@ -32396,12 +32930,12 @@ function maxMove(_ref4) {
 }
 
 // Returns the vector from the given point to the bottom-left corner of the graph when snapped to the grid
-function minMove(_ref5) {
+function minMove(_ref9) {
   let {
     snapStep,
     range,
     point
-  } = _ref5;
+  } = _ref9;
   const bottomLeft = bound$1({
     snapStep,
     range,
@@ -32443,6 +32977,11 @@ const renderGraph = props => {
     type
   } = state;
   switch (type) {
+    case "angle":
+      return /*#__PURE__*/React__namespace.createElement(AngleGraph, {
+        graphState: state,
+        dispatch: dispatch
+      });
     case "segment":
       return /*#__PURE__*/React__namespace.createElement(SegmentGraph, {
         graphState: state,
@@ -32606,8 +33145,8 @@ const MafsGraph = props => {
   }, props.markings === "graph" && /*#__PURE__*/React__namespace.createElement(React__namespace.Fragment, null, /*#__PURE__*/React__namespace.createElement(AxisLabels, null), /*#__PURE__*/React__namespace.createElement(AxisTickLabels, null)), /*#__PURE__*/React__namespace.createElement(mafs.Mafs, {
     preserveAspectRatio: false,
     viewBox: {
-      x: state.range[0],
-      y: state.range[1],
+      x: state.range[X],
+      y: state.range[Y],
       padding: 0
     },
     pan: false,
@@ -33491,7 +34030,7 @@ class LegacyInteractiveGraph extends React__namespace.Component {
         // Solve for side by using the law of sines
         const side = Math.sin(innerAngles[1] * Math.PI / 180) / Math.sin(innerAngles[2] * Math.PI / 180) * knownSide;
         const outerAngle = GraphUtils.findAngle(coords[rel(1)], coords[rel(-1)]);
-        const offset = polar(side, outerAngle + (onLeft ? 1 : -1) * innerAngles[0]);
+        const offset = polar$1(side, outerAngle + (onLeft ? 1 : -1) * innerAngles[0]);
         return this.graphie?.addPoints(coords[rel(-1)], offset);
       }
       // @ts-expect-error - TS2339 - Property 'snapTo' does not exist on type 'PerseusGraphType'.
@@ -33515,7 +34054,7 @@ class LegacyInteractiveGraph extends React__namespace.Component {
         const innerAngle = lawOfCosines(sides[0], sides[2], sides[1]);
         const outerAngle = GraphUtils.findAngle(coords[rel(1)], coords[rel(-1)]);
         const onLeft = sign(ccw(coords[rel(-1)], coords[rel(1)], coords[i])) === 1;
-        const offset = polar(sides[0], outerAngle + (onLeft ? 1 : -1) * innerAngle);
+        const offset = polar$1(sides[0], outerAngle + (onLeft ? 1 : -1) * innerAngle);
         return this.graphie?.addPoints(coords[rel(-1)], offset);
       }
       // Snap to grid (already done)
@@ -34122,11 +34661,9 @@ class InteractiveGraph extends React__namespace.Component {
     const radius = magnitude(vector(...coords));
 
     // Adjust the lower point by angleOffsetDeg degrees
-    // @ts-expect-error - TS2542 - Index signature in type 'readonly Coord[]' only permits reading.
     coords[0] = [coords[1][0] + radius * Math.cos(offset), coords[1][1] + radius * Math.sin(offset)];
     // Position the upper point angle radians from the
     // lower point
-    // @ts-expect-error - TS2542 - Index signature in type 'readonly Coord[]' only permits reading.
     coords[2] = [coords[1][0] + radius * Math.cos(angle + offset), coords[1][1] + radius * Math.sin(angle + offset)];
     return coords;
   }
@@ -44746,7 +45283,7 @@ const init = function (options) {
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/perseus";
-const libVersion = "24.1.0";
+const libVersion = "24.3.0";
 perseusCore.addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {