@khanacademy/perseus 33.0.0 → 33.2.0

package/dist/es/index.js

@@ -8673,10 +8673,10 @@ var Raphael$1 = (function () {
  * provided on KhanUtil.
  */
 const KhanColors = {
-  BLUE: "#6495ED",
+  BLUE: color.blue,
   ORANGE: "#FFA500",
   PINK: "#FF00AF",
-  GREEN: "#28AE7B",
+  GREEN: color.green,
   PURPLE: "#9D38BD",
   RED: "#DF0030",
   GRAY: "gray",
@@ -8752,11 +8752,9 @@ const KhanColors = {
   // of any redesigns.
   _BACKGROUND: "#FDFDFD",
   // TODO(eater): Get rid of this altogether.
-  INTERACTING: "#71B307",
-  // KA_GREEN
-  INTERACTIVE: "#71B307",
-  // KA_GREEN
-  DYNAMIC: "#6495ED" // BLUE
+  INTERACTING: color.green,
+  INTERACTIVE: color.green,
+  DYNAMIC: color.blue
 };
 
 // DrawingTransform is responsible for transforming from "math coordinates"
@@ -10036,21 +10034,50 @@ const setLabelMargins = function setLabelMargins(span, size) {
     });
   } else {
     var _$container$css, _$container$width, _$span$css;
-    const $container = $span.closest(".svg-image");
+    // We are using jQuery to collect information and calculate a scale
+    //     since we don't have a way to pass it to this function.
+    // We need the width of the container in order to calculate the scale to apply to the label.
+    // Unfortunately, the DOM tree leading to the label is not consistent.
+    // Therefore, we need to check different elements and different style properties to get the width of the container.
+    // Some graphie labels exist within an ".svg-image" container, and others do not.
+    // All graphie labels have a ".graphie" container.
+    // When a label has an ".svg-image" container,
+    //     the width information in the ".graphie" element is expressed as a percentage instead of pixels,
+    //     so we can't use it.
+    // Instead, the ".svg-image" container can be used to get the width information.
+    // The following lines determine which container element to use for the width measurement.
+    const $svgImage = $span.closest(".svg-image");
+    const $graphie = $span.closest(".graphie");
+    // If an ".svg-image" container exists in the DOM tree, then use it, otherwise use the ".graphie" container.
+    const $container = $svgImage.length > 0 ? $svgImage : $graphie;
+
     // Ensuring that the line-height of the text doesn't throw off placement of the text element.
     // Inherited line-height values can really mess up placement.
     $container.css("line-height", "normal");
 
-    // The 'max-width' value is the same as the expected (100% scale) width of the graphie.
-    // We are using jQuery to get this information since we don't have a way to pass it to this function.
-    const expectedWidth = (_$container$css = $container.css("max-width")) != null ? _$container$css : "0px";
+    // The expected width of the graphie is found in the "max-width" property on ".svg-image" containers,
+    //     and is found in the "width" property on ".graphie" containers.
+    const widthValues = (_$container$css = $container.css(["max-width", "width"])) != null ? _$container$css : {
+      // The browser will always return a value, but tests won't, so ensuring something is returned.
+      "max-width": "0px"
+    };
+    const expectedWidth =
+    // Verified in Chrome, Firefox, and Safari - all return the same "none" value if the property does not exist.
+    widthValues["max-width"] !== "none" ? widthValues["max-width"] : widthValues["width"];
     // We can calculate the true scale of the graphie by taking actual width and dividing by the expected width.
-    // NOTE: Using 'slice' to remove the "px" unit from the end of the expected width value.
-    const scale = ((_$container$width = $container.width()) != null ? _$container$width : 0) / parseInt(expectedWidth.replace(/px$/, "")) * 100;
+    // NOTE: Using 'replace' to remove the "px" unit from the end of the expected width value.
+    let scale = ((_$container$width = $container.width()) != null ? _$container$width : 0) / parseInt(expectedWidth.replace(/px$/, "")) * 100;
+    // If something failed in the calculation, then default to 100% scale.
+    if (isNaN(scale)) {
+      scale = 100;
+    } else if (scale === 0) {
+      scale = 100;
+    }
 
     // Any padding needs to be scaled accordingly.
-    const currentPadding = (_$span$css = $span.css("padding")) != null ? _$span$css : "0px";
-    const newPadding = Math.round(parseInt(currentPadding.slice(0, -2)) * scale) / 100;
+    const padding = (_$span$css = $span.css("padding")) != null ? _$span$css : "0px";
+    const currentPadding = padding !== "none" ? padding : "0px";
+    const newPadding = Math.round(parseInt(currentPadding.replace(/px$/, "")) * scale) / 100;
 
     // "multipliers" basically move the position of the text by using 1, 0, -1
     // 'margin-left' and 'margin-top' are used to position the text.
@@ -28320,6 +28347,94 @@ Graph.defaultProps = {
   isMobile: false
 };
 
+function pathBuilder() {
+  return new PathBuilder();
+}
+class PathBuilder {
+  constructor() {
+    this.path = [];
+    this.scaleFactor = 1;
+  }
+  build() {
+    return this.path.map(scaleCommandBy(this.scaleFactor)).map(commandToString).join("");
+  }
+
+  // add a move (M) command to the path
+  move(x, y) {
+    this.path.push({
+      action: "M",
+      args: [x, y]
+    });
+    return this;
+  }
+  line(x, y) {
+    this.path.push({
+      action: "L",
+      args: [x, y]
+    });
+    return this;
+  }
+  circularArc(radius, toX, toY, {
+    sweep = false,
+    largeArc = false
+  } = {}) {
+    this.path.push({
+      action: "A",
+      args: [radius, radius, 0 /* rotation */, largeArc ? 1 : 0, sweep ? 1 : 0, toX, toY]
+    });
+    return this;
+  }
+
+  // add a curve (C) command to the path
+  curve(control1X, control1Y, control2X, control2Y, endX, endY) {
+    this.path.push({
+      action: "C",
+      args: [control1X, control1Y, control2X, control2Y, endX, endY]
+    });
+    return this;
+  }
+
+  // Scale all coordinates of the path by a factor
+  scale(factor) {
+    this.scaleFactor *= factor;
+    return this;
+  }
+}
+function commandToString(command) {
+  return `${command.action}${command.args.join(" ")}`;
+}
+function scaleCommandBy(scaleFactor) {
+  return command => {
+    switch (command.action) {
+      case "A":
+        // TODO(benchristel): do we want to refactor this switch to
+        // use polymorphism?
+        // Arc command
+        return _extends({}, command, {
+          args: [command.args[0] * scaleFactor,
+          // x radius
+          command.args[1] * scaleFactor,
+          // y radius
+          command.args[2],
+          // rotation
+          command.args[3],
+          // largeArc flag
+          command.args[4],
+          // sweep flag
+          command.args[5] * scaleFactor,
+          // end x
+          command.args[6] * scaleFactor // end y
+          ]
+        });
+
+      default:
+        return _extends({}, command, {
+          args: command.args.map(c => c * scaleFactor)
+        });
+    }
+  };
+}
+
 // Restricts `value` to be between `min` and `max`.
 function clamp(value, min, max) {
   if (value < min) {
@@ -28536,377 +28651,6 @@ function pixelsToVectors(pixels, graphState) {
   });
 }
 
-function AxisLabels() {
-  const {
-    range,
-    labels,
-    width,
-    height
-  } = useGraphConfig();
-  const yAxisLabelLocation = [0, range[Y][MAX]];
-  const xAxisLabelLocation = [range[X][MAX], 0];
-  const [xAxisLabelText, yAxisLabelText] = labels;
-  const graphInfo = {
-    range,
-    width,
-    height
-  };
-  const [x1, y1] = pointToPixel(xAxisLabelLocation, graphInfo);
-  // The default location for the y-axis-label is at the maximum y point
-  // This is just underneath the tick line for that point. The -24 moves the
-  // label up one grid square, so it sits on top of the graph
-  const [x2, y2] = vec.add(pointToPixel(yAxisLabelLocation, graphInfo), [0, -24]);
-  const {
-    TeX
-  } = getDependencies();
-  return /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement("span", {
-    style: {
-      position: "absolute",
-      left: x1,
-      top: y1,
-      fontSize: "14px",
-      transform: "translate(7px, -50%)"
-    }
-  }, /*#__PURE__*/React__default.createElement(TeX, null, xAxisLabelText)), /*#__PURE__*/React__default.createElement("span", {
-    style: {
-      position: "absolute",
-      left: x2,
-      top: y2,
-      fontSize: "14px",
-      transform: "translate(-50%, 0px)"
-    }
-  }, /*#__PURE__*/React__default.createElement(TeX, null, yAxisLabelText)));
-}
-
-// Universal padding for the axis ticks to ensure that the labels
-// have enough space to render without overlapping the tick lines
-const tickPadding = 5;
-const AxisTickLabels = () => {
-  const graphConfig = useGraphConfig();
-  const {
-    tickStep,
-    range
-  } = graphConfig;
-  const [[xMin, xMax], [yMin, yMax]] = range;
-  const [xTickStep, yTickStep] = tickStep;
-  const yGridTicks = generateTickLocations$1(yTickStep, yMin, yMax);
-  const xGridTicks = generateTickLocations$1(xTickStep, xMin, xMax);
-  return /*#__PURE__*/React.createElement("div", {
-    className: "axis-tick-labels"
-  }, /*#__PURE__*/React.createElement(YGridAxis, {
-    axisTicks: yGridTicks,
-    graphConfig: graphConfig
-  }), /*#__PURE__*/React.createElement(XGridAxis, {
-    axisTicks: xGridTicks,
-    graphConfig: graphConfig
-  }));
-};
-
-// Generate the necessary styles and ticks for the y-axis tick labels container
-const YGridAxis = props => {
-  const {
-    axisTicks,
-    graphConfig
-  } = props;
-  const {
-    width,
-    height
-  } = graphConfig;
-
-  // First get the label height by calculating the difference between the first two y-axis labels
-  const yTopPoint = pointToPixel([0, axisTicks[0]], graphConfig);
-  const ySecondPoint = pointToPixel([0, axisTicks[1]], graphConfig);
-  const yLabelHeight = ySecondPoint[1] - yTopPoint[1];
-
-  // When rendering purely positive y-axis labels, we want to adjust the left position
-  // from the lowest calculated tick, as yMin may be negative
-  const yLowestTick = axisTicks[axisTicks.length - 1];
-  const yLeftAdjustment = Math.min(Math.max(yTopPoint[0] - tickPadding, 0), width);
-
-  // We only want to render the 0 label on the y-axis if it is left of the grid
-  const yAxisIsLeftOfGrid = yLeftAdjustment === 0;
-
-  // If the y-axis is right of the graph's viewbox/range,
-  // we want to adjust both the positioning and text alignment
-  const yAxisRightOfGrid = yLeftAdjustment === width;
-
-  // Determine the default spacing for the labels based on whether the y-axis is right of the grid
-  const defaultSpacing = yAxisRightOfGrid ? 0.5 : 0;
-
-  // We also want to adjust the spacing if there are no negative y-axis labels as the extra space is not needed
-  const marginSpacing = yLowestTick >= 0 ? defaultSpacing * 2 : defaultSpacing;
-
-  // Determine the text alignment based on whether the y-axis is right of the grid
-  // We need to cast this as a const as it is used in the inline styles
-  const textAlign = yAxisRightOfGrid ? "left" : "right";
-  const yAxisStyles = {
-    left: `calc(${yLeftAdjustment}px - ${marginSpacing}em)`,
-    top: `calc(${yTopPoint[1]}px - 0.5em)`,
-    height,
-    textAlign,
-    "--y-axis-label-height": yLabelHeight + "px"
-  };
-  const classNames = yAxisRightOfGrid ? "y-axis-tick-labels y-axis-right-of-grid" : "y-axis-tick-labels ";
-  return /*#__PURE__*/React.createElement("div", {
-    className: classNames,
-    "data-testid": "y-axis-tick-labels",
-    style: yAxisStyles
-  }, axisTicks.map(label => {
-    return /*#__PURE__*/React.createElement(AxisTickLabel, {
-      label: label,
-      axis: "y",
-      key: `y-grid-tick-${label}`,
-      graphConfig: graphConfig,
-      axisOutOfBounds: yAxisIsLeftOfGrid
-    });
-  }));
-};
-
-// Generate the necessary styles and ticks for the x-axis tick labels container
-const XGridAxis = props => {
-  const {
-    axisTicks,
-    graphConfig
-  } = props;
-  const {
-    width,
-    height
-  } = graphConfig;
-
-  // Determine label width by calculating the difference between the first two x-axis labels
-  const xFirstPoint = pointToPixel([axisTicks[0], 0], graphConfig);
-  const xSecondPoint = pointToPixel([axisTicks[1], 0], graphConfig);
-  const xLabelWidth = Math.abs(xSecondPoint[0] - xFirstPoint[0]);
-
-  // Determine the top position of the x-axis labels based on
-  // whether the x-axis is above, within, or below the graph
-  const xAxisAboveGraph = xFirstPoint[1] < 0;
-  const xTopAdjustment = xAxisAboveGraph ? 0 : Math.min(xFirstPoint[1] + tickPadding, height);
-
-  // Determine whether the x-axis is outside of the graph's viewbox/range
-  // This is used to conditionally render the 0 label on the x-axis
-  const xAxisOutOfBounds = xTopAdjustment === height || xAxisAboveGraph;
-
-  // Determine the available space to the right of the x-axis labels
-  const availableSpaceRight = width - xFirstPoint[0];
-
-  // Calculate the total combined width of ALL the x-axis labels
-  const axisTicksWidth = axisTicks.length * xLabelWidth;
-
-  // Determine if we need to increase the width of the axis past the graph width
-  const calculatedWidth = axisTicksWidth > width ? axisTicksWidth : width;
-
-  // Determine the right adjustment for the x-axis labels based on the available space
-  // We're adjusting the right as the flex-direction is row-reverse
-  const xRightAdjustment = availableSpaceRight - xLabelWidth / 2;
-  const xAxisStyles = {
-    top: xTopAdjustment,
-    right: xRightAdjustment,
-    width: calculatedWidth,
-    "--x-axis-label-width": xLabelWidth + "px"
-  };
-  return /*#__PURE__*/React.createElement("div", {
-    className: `x-axis-tick-labels ${xAxisAboveGraph && "x-axis-top-of-grid"}`,
-    "data-testid": "x-axis-tick-labels",
-    style: xAxisStyles
-  }, axisTicks.map(label => {
-    return /*#__PURE__*/React.createElement(AxisTickLabel, {
-      axis: "x",
-      label: label,
-      key: `x-grid-tick-${label}`,
-      graphConfig: graphConfig,
-      axisOutOfBounds: xAxisOutOfBounds
-    });
-  }));
-};
-
-// Generate the individual tick label elements
-const AxisTickLabel = ({
-  label,
-  graphConfig,
-  axisOutOfBounds,
-  axis
-}) => {
-  const {
-    gridStep,
-    tickStep
-  } = graphConfig;
-  // Determine the point on the axis based on the axis type
-  const pointOnAxis = axis === "x" ? [label, 0] : [0, label];
-  const pixelPoint = pointToPixel(pointOnAxis, graphConfig);
-
-  // Determine the relevant edge of the graph based on the axis type
-  const graphEdge = axis === "x" ? graphConfig.width : graphConfig.height;
-
-  // Determine the vector index based on the axis type
-  const vectorIndex = axis === "x" ? 0 : 1;
-
-  // Determine whether or not to render the tick label text
-  const shouldShowLabel = showTickLabel({
-    label,
-    axisOutOfBounds,
-    graphEdge,
-    position: pixelPoint[vectorIndex],
-    gridStep: gridStep[vectorIndex],
-    tickStep: tickStep[vectorIndex]
-  });
-  return /*#__PURE__*/React.createElement("span", {
-    className: `${axis}-axis-tick-label`
-  }, shouldShowLabel && label);
-};
-
-// Determine whether or not to show the tick label text
-const showTickLabel = ({
-  gridStep,
-  tickStep,
-  label,
-  graphEdge,
-  position,
-  axisOutOfBounds
-}) => {
-  let showLabel = true;
-
-  // We only want to show the initial negative tick labels (e.g. -1) on each
-  // axis if the tickStep > gridStep, to ensure that these labels do not overlap.
-  // e.g. If gridStep = 1 and tickStep = 2, there are 2 grid lines for every 1 tick,
-  // which allows enough room for both these tick labels to render.
-  showLabel = tickStep > gridStep ? true : label !== -tickStep;
-
-  // If the tick label position is greater than the relevant edge of the graph, don't render it
-  if (position <= -graphEdge || position >= graphEdge) {
-    showLabel = false;
-  }
-
-  // If the label is 0, we only want to show it if the axis is to the left of the graph's viewbox/range
-  // otherwise it will overlap with graph axis labels
-  if (label === 0 && !axisOutOfBounds) {
-    showLabel = false;
-  }
-  return showLabel;
-};
-
-// Generate the tick labels for an axis based on the tick step
-function generateTickLocations$1(tickStep, min, max) {
-  const positiveTicks = [];
-  const negativeTicks = [];
-  const ticks = [];
-
-  // Add 0 if it is applicable.
-  // This will be conditionally rendered using showTickLabel.
-  if (min <= 0 && max >= 0) {
-    positiveTicks.push(0);
-  }
-
-  // Add ticks on the positive axis
-  // Start at the first tick after 0 or the minimum value,
-  // taking into account that the graph may be zoomed in on the positive axis
-  let i = Math.max(min, 0) + tickStep;
-  for (i; min < i && i < max; i += tickStep) {
-    positiveTicks.push(i);
-  }
-
-  // Add ticks on the negative axis
-  // Start at the first tick before 0 or the maximum value,
-  // taking into account that the graph may be zoomed in on the negative axis
-  i = Math.min(max, 0) - tickStep;
-  for (i; i > min; i -= tickStep) {
-    negativeTicks.push(i);
-  }
-
-  // Reverse the ticks so that they are in the correct render order
-  positiveTicks.reverse();
-  ticks.push(...positiveTicks, ...negativeTicks);
-  return ticks;
-}
-
-function pathBuilder() {
-  return new PathBuilder();
-}
-class PathBuilder {
-  constructor() {
-    this.path = [];
-    this.scaleFactor = 1;
-  }
-  build() {
-    return this.path.map(scaleCommandBy(this.scaleFactor)).map(commandToString).join("");
-  }
-
-  // add a move (M) command to the path
-  move(x, y) {
-    this.path.push({
-      action: "M",
-      args: [x, y]
-    });
-    return this;
-  }
-  line(x, y) {
-    this.path.push({
-      action: "L",
-      args: [x, y]
-    });
-    return this;
-  }
-  circularArc(radius, toX, toY, {
-    sweep = false,
-    largeArc = false
-  } = {}) {
-    this.path.push({
-      action: "A",
-      args: [radius, radius, 0 /* rotation */, largeArc ? 1 : 0, sweep ? 1 : 0, toX, toY]
-    });
-    return this;
-  }
-
-  // add a curve (C) command to the path
-  curve(control1X, control1Y, control2X, control2Y, endX, endY) {
-    this.path.push({
-      action: "C",
-      args: [control1X, control1Y, control2X, control2Y, endX, endY]
-    });
-    return this;
-  }
-
-  // Scale all coordinates of the path by a factor
-  scale(factor) {
-    this.scaleFactor *= factor;
-    return this;
-  }
-}
-function commandToString(command) {
-  return `${command.action}${command.args.join(" ")}`;
-}
-function scaleCommandBy(scaleFactor) {
-  return command => {
-    switch (command.action) {
-      case "A":
-        // TODO(benchristel): do we want to refactor this switch to
-        // use polymorphism?
-        // Arc command
-        return _extends({}, command, {
-          args: [command.args[0] * scaleFactor,
-          // x radius
-          command.args[1] * scaleFactor,
-          // y radius
-          command.args[2],
-          // rotation
-          command.args[3],
-          // largeArc flag
-          command.args[4],
-          // sweep flag
-          command.args[5] * scaleFactor,
-          // end x
-          command.args[6] * scaleFactor // end y
-          ]
-        });
-
-      default:
-        return _extends({}, command, {
-          args: command.args.map(c => c * scaleFactor)
-        });
-    }
-  };
-}
-
 // We use the pathBuilder here to scale up the SVG path coordinates used
 // elsewhere for arrowheads. We scale in the path itself instead of using a CSS
 // transform because a transform would also scale up the stroke weight, and we
@@ -28937,7 +28681,10 @@ function AxisArrows() {
     range: [[xMin, xMax], [yMin, yMax]]
   } = useGraphConfig();
   const axisColor = "var(--mafs-fg)";
-  return /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(Arrowhead, {
+
+  // Only render the arrows if the axis is within the visible range
+  // as otherwise the arrows will be rendered outside the graph
+  return /*#__PURE__*/React__default.createElement(React__default.Fragment, null, !(yMin > 0 || yMax < 0) && /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(Arrowhead, {
     color: axisColor,
     tip: [xMin, 0],
     angle: 180
@@ -28945,7 +28692,7 @@ function AxisArrows() {
     color: axisColor,
     tip: [xMax, 0],
     angle: 0
-  }), /*#__PURE__*/React__default.createElement(Arrowhead, {
+  })), !(xMin > 0 || xMax < 0) && /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement(Arrowhead, {
     color: axisColor,
     tip: [0, yMin],
     angle: 90
@@ -28953,38 +28700,75 @@ function AxisArrows() {
     color: axisColor,
     tip: [0, yMax],
     angle: 270
-  }));
+  })));
 }
 
+function AxisLabels() {
+  const {
+    range,
+    labels,
+    width,
+    height
+  } = useGraphConfig();
+  const yAxisLabelLocation = [0, range[Y][MAX]];
+  const xAxisLabelLocation = [range[X][MAX], 0];
+  const [xAxisLabelText, yAxisLabelText] = labels;
+  const graphInfo = {
+    range,
+    width,
+    height
+  };
+  const [x1, y1] = pointToPixel(xAxisLabelLocation, graphInfo);
+  // The default location for the y-axis-label is at the maximum y point
+  // This is just underneath the tick line for that point. The -24 moves the
+  // label up one grid square, so it sits on top of the graph
+  const [x2, y2] = vec.add(pointToPixel(yAxisLabelLocation, graphInfo), [0, -24]);
+  const {
+    TeX
+  } = getDependencies();
+  return /*#__PURE__*/React__default.createElement(React__default.Fragment, null, /*#__PURE__*/React__default.createElement("span", {
+    style: {
+      position: "absolute",
+      left: x1,
+      top: y1,
+      fontSize: "14px",
+      transform: "translate(7px, -50%)"
+    }
+  }, /*#__PURE__*/React__default.createElement(TeX, null, xAxisLabelText)), /*#__PURE__*/React__default.createElement("span", {
+    style: {
+      position: "absolute",
+      left: x2,
+      top: y2,
+      fontSize: "14px",
+      transform: "translate(-50%, 0px)"
+    }
+  }, /*#__PURE__*/React__default.createElement(TeX, null, yAxisLabelText)));
+}
+
+// The size of the ticks and labels in pixels
 const tickSize = 10;
-const tickStyle = {
-  stroke: "black",
-  strokeWidth: 1
-};
+const tickLabelSize = 14;
 const YGridTick = ({
   y,
-  graphInfo
+  range
 }) => {
+  // If the graph requires out-of-bounds labels, we want to make sure to set the
+  // coordinates to the edge of the visible range of the graph. Otherwise,
+  // the ticks and labels would render outside of the clipping-mask.
   let xPointOnAxis = 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[X][MIN] > 0) {
+  if (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[X][MIN];
+    xPointOnAxis = range[X][MIN];
   }
-  if (graphInfo.range[X][MAX] < 0) {
+  if (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[X][MAX];
+    xPointOnAxis = range[X][MAX];
   }
+
+  // Convert the Vector2 coordinates to pixel coordinates
   const pointOnAxis = [xPointOnAxis, y];
   const [[xPosition, yPosition]] = useTransformVectorsToPixels(pointOnAxis);
 
-  // If the tick is on the edge of the graph's range, don't render it
-  if (yPosition === -graphInfo.height || yPosition === graphInfo.height + 20) {
-    return null;
-  }
-
   // Position of the start of the tick
   const x1 = xPosition - tickSize / 2;
   const y1 = yPosition;
@@ -28992,39 +28776,55 @@ const YGridTick = ({
   // Position of the end of the tick
   const x2 = xPosition + tickSize / 2;
   const y2 = yPosition;
+
+  // Adjust the y position of the x-axis labels based on
+  // whether the x-axis is above, within, or below the graph
+  const xAdjustment = range[X][MAX] <= 0 ? tickLabelSize * 1.5 : -tickLabelSize * 1.1;
+  const xPositionText = xPosition + xAdjustment;
+  const yPositionText = yPosition + tickLabelSize * 0.25; // Center the text vertically on the tick
+
+  // If the graph displays both the y and x axis lines within the graph, we want
+  // to hide the label at -1 on the y-axis to prevent overlap with the x-axis label
+  const showLabel = shouldShowLabel(y, range);
   return /*#__PURE__*/React.createElement("g", {
-    className: "y-axis-ticks"
+    className: "tick"
   }, /*#__PURE__*/React.createElement("line", {
     x1: x1,
     y1: y1,
     x2: x2,
     y2: y2,
-    style: tickStyle
-  }));
+    className: "axis-tick"
+  }), showLabel && /*#__PURE__*/React.createElement("text", {
+    className: "axis-tick-label",
+    style: {
+      fontSize: tickLabelSize
+    },
+    textAnchor: "end",
+    x: xPositionText,
+    y: yPositionText
+  }, y.toString()));
 };
 const XGridTick = ({
   x,
-  graphInfo
+  range
 }) => {
+  // If the graph requires out-of-bounds labels, we want to make sure to set the
+  // coordinates to the edge of the visible range of the graph. Otherwise,
+  // the ticks and labels would render outside of the clipping-mask.
   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[Y][MIN] > 0) {
+  if (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[Y][MIN];
+    yPointOnAxis = range[Y][MIN];
   }
-  if (graphInfo.range[Y][MAX] < 0) {
+  if (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[Y][MAX];
+    yPointOnAxis = range[Y][MAX];
   }
+
+  // Convert the Vector2 coordinates to pixel coordinates
   const pointOnAxis = [x, yPointOnAxis];
   const [[xPosition, yPosition]] = useTransformVectorsToPixels(pointOnAxis);
 
-  // If the tick is on the edge of the graph's range, don't render it
-  if (xPosition === -graphInfo.width / 2 || xPosition === graphInfo.width) {
-    return null;
-  }
-
   // Position of the start of the tick
   const x1 = xPosition;
   const y1 = yPosition + tickSize / 2;
@@ -29032,21 +28832,56 @@ const XGridTick = ({
   // Position of the end of the tick
   const x2 = xPosition;
   const y2 = yPosition - tickSize / 2;
+
+  // Adjust the Y position of the x-axis labels based on
+  // whether the x-axis is above, within, or below the graph
+  const yAdjustment = range[Y][MAX] < 0 ? -tickLabelSize : tickLabelSize * 1.75;
+
+  // Adjust the X position of the x-axis labels based on
+  // whether the label is positive or negative, in order to
+  // account for the width of the negative sign
+  const xAdjustment = x < 0 ? -2 : 0;
+
+  // Apply the adjustments to the x and y positions for the text
+  const xPositionText = xPosition + xAdjustment;
+  const yPositionText = yPosition + yAdjustment;
   return /*#__PURE__*/React.createElement("g", {
-    className: "x-axis-ticks"
+    className: "tick"
   }, /*#__PURE__*/React.createElement("line", {
     x1: x1,
     y1: y1,
     x2: x2,
     y2: y2,
-    style: tickStyle
-  }));
+    className: "axis-tick"
+  }), /*#__PURE__*/React.createElement("text", {
+    className: "axis-tick-label",
+    style: {
+      fontSize: tickLabelSize
+    },
+    textAnchor: "middle",
+    x: xPositionText,
+    y: yPositionText
+  }, x.toString()));
+};
+
+// Determines whether to show the label for the given tick
+// Currently, the only condition is to hide the label at -1
+// on the y-axis when the x-axis is within the graph
+const shouldShowLabel = (number, range) => {
+  let showLabel = true;
+
+  // If the x-axis is within the graph and the y-axis is at -1, hide the label
+  if (range[X][MIN] < -1 && range[X][MAX] > 0 && number === -1) {
+    showLabel = false;
+  }
+  return showLabel;
 };
 function generateTickLocations(tickStep, min, max) {
   const ticks = [];
 
   // Add ticks in the positive direction
-  for (let _i = 0 + tickStep; _i < max; _i += tickStep) {
+  const start = Math.max(min, 0);
+  for (let _i = start + tickStep; _i < max; _i += tickStep) {
     ticks.push(_i);
   }
 
@@ -29061,34 +28896,34 @@ function generateTickLocations(tickStep, min, max) {
 const AxisTicks = () => {
   const {
     tickStep,
-    range,
-    width,
-    height
+    range
   } = useGraphConfig();
-  const graphInfo = {
-    range,
-    width,
-    height
-  };
   const [[xMin, xMax], [yMin, yMax]] = range;
   const [xTickStep, yTickStep] = tickStep;
+
+  // Generate the tick locations & labels for the x and y axes
   const yGridTicks = generateTickLocations(yTickStep, yMin, yMax);
   const xGridTicks = generateTickLocations(xTickStep, xMin, xMax);
   return /*#__PURE__*/React.createElement("g", {
-    className: "axis-ticks"
+    className: "axis-ticks",
+    role: "presentation"
+  }, /*#__PURE__*/React.createElement("g", {
+    className: "y-axis-ticks"
   }, yGridTicks.map(y => {
     return /*#__PURE__*/React.createElement(YGridTick, {
       y: y,
       key: `y-grid-tick-${y}`,
-      graphInfo: graphInfo
+      range: range
     });
-  }), xGridTicks.map(x => {
+  })), /*#__PURE__*/React.createElement("g", {
+    className: "x-axis-ticks"
+  }, xGridTicks.map(x => {
     return /*#__PURE__*/React.createElement(XGridTick, {
       x: x,
       key: `x-grid-tick-${x}`,
-      graphInfo: graphInfo
+      range: range
     });
-  }));
+  })));
 };
 
 /**
@@ -29109,12 +28944,10 @@ const axisOptions = (props, axisIndex) => {
   };
 };
 const Grid = props => {
-  return props.markings === "none" ? null : /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(Coordinates.Cartesian, {
+  return props.markings === "none" ? null : /*#__PURE__*/React.createElement(Coordinates.Cartesian, {
     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.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(AxisTicks, null), /*#__PURE__*/React.createElement(AxisArrows, null)));
+  });
 };
 
 // Displays a stylized open eye: lint warnings are visible
@@ -31851,7 +31684,8 @@ function UnlimitedPointGraph(props) {
   const [[left, top]] = useTransformVectorsToPixels([minX, maxY]);
   return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement("rect", {
     style: {
-      fill: "rgba(0,0,0,0)"
+      fill: "rgba(0,0,0,0)",
+      cursor: "crosshair"
     },
     width: widthPx,
     height: heightPx,
@@ -32035,6 +31869,22 @@ const MafsGraph = props => {
   const uniqueId = React.useId();
   const descriptionId = `interactive-graph-description-${uniqueId}`;
   const graphRef = React.useRef(null);
+
+  // Set up the SVG attributes for the nested SVGs that help lock
+  // the grid and graph elements to the bounds of the graph.
+  const {
+    viewboxX,
+    viewboxY
+  } = calculateNestedSVGCoords(state.range, width, height);
+  const viewBox = `${viewboxX} ${viewboxY} ${width} ${height}`;
+  const nestedSVGAttributes = {
+    width,
+    height,
+    viewBox,
+    preserveAspectRatio: "xMidYMin",
+    x: viewboxX,
+    y: viewboxY
+  };
   return /*#__PURE__*/React.createElement(GraphConfigContext.Provider, {
     value: {
       range: state.range,
@@ -32056,7 +31906,7 @@ const MafsGraph = props => {
       padding: "25px 25px 0 0",
       boxSizing: "content-box",
       marginLeft: "20px",
-      marginBottom: "20px",
+      marginBottom: "30px",
       pointerEvents: props.static ? "none" : "auto",
       userSelect: "none",
       width,
@@ -32092,7 +31942,7 @@ const MafsGraph = props => {
       bottom: 0,
       left: 0
     }
-  }, props.markings === "graph" && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(AxisLabels, null), /*#__PURE__*/React.createElement(AxisTickLabels, null)), /*#__PURE__*/React.createElement(Mafs, {
+  }, props.markings === "graph" && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(AxisLabels, null)), /*#__PURE__*/React.createElement(Mafs, {
     preserveAspectRatio: false,
     viewBox: {
       x: state.range[X],
@@ -32103,37 +31953,59 @@ const MafsGraph = props => {
     zoom: false,
     width: width,
     height: height
-  }, /*#__PURE__*/React.createElement(SvgDefs, null), /*#__PURE__*/React.createElement(Grid, {
-    tickStep: props.step,
+  }, /*#__PURE__*/React.createElement(SvgDefs, null), /*#__PURE__*/React.createElement("svg", nestedSVGAttributes, /*#__PURE__*/React.createElement(Grid, {
     gridStep: props.gridStep,
     range: state.range,
     containerSizeClass: props.containerSizeClass,
-    markings: props.markings
-  }), props.lockedFigures && /*#__PURE__*/React.createElement(GraphLockedLayer, {
+    markings: props.markings,
+    width: width,
+    height: height
+  })),
+  // Only render the axis ticks and arrows if the markings are set to a full "graph"
+  props.markings === "graph" && /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(AxisTicks, null), /*#__PURE__*/React.createElement(AxisArrows, null)), /*#__PURE__*/React.createElement("svg", nestedSVGAttributes, props.lockedFigures && /*#__PURE__*/React.createElement(GraphLockedLayer, {
     lockedFigures: props.lockedFigures,
     range: state.range
   }), props.showProtractor && /*#__PURE__*/React.createElement(Protractor, null), renderGraph({
     state,
     dispatch
-  })))), renderGraphControls({
+  }))))), renderGraphControls({
     state,
-    dispatch
+    dispatch,
+    width
   })));
 };
-const renderPointGraphControls = props => /*#__PURE__*/React.createElement(Button, {
+const renderPointGraphControls = props => /*#__PURE__*/React.createElement(View, {
+  style: {
+    flexDirection: "row",
+    width: props.width
+  }
+}, /*#__PURE__*/React.createElement(Button, {
   kind: "secondary",
   style: {
     width: "100%",
     marginLeft: "20px"
   },
+  tabIndex: 0,
   onClick: () => {
     props.dispatch(actions.pointGraph.addPoint([0, 0]));
   }
-}, "Add Point");
+}, "Add Point"), (props.state.focusedPointIndex !== null || props.state.previouslyFocusedPointIndex !== null) && /*#__PURE__*/React.createElement(Button, {
+  kind: "secondary",
+  color: "destructive",
+  tabIndex: 0,
+  style: {
+    width: "100%",
+    marginLeft: "20px"
+  },
+  onClick: event => {
+    props.dispatch(actions.pointGraph.removePoint(props.state.previouslyFocusedPointIndex));
+  }
+}, "Remove Point"));
 const renderGraphControls = props => {
   const {
     state,
-    dispatch
+    dispatch,
+    width
   } = props;
   const {
     type
@@ -32143,7 +32015,8 @@ const renderGraphControls = props => {
       if (state.numPoints === "unlimited") {
         return renderPointGraphControls({
           state,
-          dispatch
+          dispatch,
+          width
         });
       }
       return null;
@@ -32151,6 +32024,56 @@ const renderGraphControls = props => {
       return null;
   }
 };
+
+// Calculate the difference between the min and max values of a range
+const getRangeDiff = range => {
+  const [min, max] = range;
+  return Math.abs(max - min);
+};
+
+// We need to adjust the nested SVG viewbox x and Y values based on the range of the graph in order
+// to ensure that the graph is sized and positioned correctly within the Mafs SVG and the clipping mask.
+// Exported for testing.
+const calculateNestedSVGCoords = (range, width, height) => {
+  // X RANGE
+  let viewboxX = 0; // When xMin is 0, we want to use 0 as the viewboxX value
+  const totalXRange = getRangeDiff(range[X]);
+  const gridCellWidth = width / totalXRange;
+  const minX = range[X][MIN];
+
+  // If xMin is entirely positive, we need to adjust the
+  // viewboxX to be the grid cell width multiplied by xMin
+  if (minX > 0) {
+    viewboxX = gridCellWidth * Math.abs(minX);
+  }
+  // If xMin is negative, we need to adjust the viewboxX to be
+  // the negative value of the grid cell width multiplied by xMin
+  if (minX < 0) {
+    viewboxX = -gridCellWidth * Math.abs(minX);
+  }
+
+  // Y RANGE
+  let viewboxY = -height; // When yMin is 0, we want to use the negative value of the graph height
+  const totalYRange = getRangeDiff(range[Y]);
+  const gridCellHeight = height / totalYRange;
+  const minY = range[Y][MIN];
+
+  // If the y range is entirely positive, we want a negative sum of the
+  // height and the gridcell height multiplied by the absolute value of yMin
+  if (minY > 0) {
+    viewboxY = -height - gridCellHeight * Math.abs(minY);
+  }
+
+  // If the yMin is negative, we want to multiply the gridcell height
+  // by the absolute value of yMin, and subtract the full height of the graph
+  if (minY < 0) {
+    viewboxY = gridCellHeight * Math.abs(minY) - height;
+  }
+  return {
+    viewboxX,
+    viewboxY
+  };
+};
 const renderGraph = props => {
   const {
     state,
@@ -32262,7 +32185,8 @@ function initializeGraphState(params) {
         type: graph.type,
         coords: getPointCoords(graph, range, step),
         numPoints: graph.numPoints || 0,
-        focusedPointIndex: null
+        focusedPointIndex: null,
+        previouslyFocusedPointIndex: null
       });
     case "circle":
       return _extends({}, shared, {
@@ -32555,6 +32479,7 @@ function doBlurPoint(state, action) {
   switch (state.type) {
     case "point":
       return _extends({}, state, {
+        previouslyFocusedPointIndex: state.focusedPointIndex,
         focusedPointIndex: null
       });
     default:
@@ -32599,7 +32524,6 @@ function doMovePointInFigure(state, action) {
       }
     case "angle":
     case "circle":
-      throw new Error("FIXME implement circle reducer");
     case "point":
     case "polygon":
     case "quadratic":
@@ -32910,7 +32834,8 @@ function doRemovePoint(state, action) {
   }
   return _extends({}, state, {
     coords: state.coords.filter((_, i) => i !== action.index),
-    focusedPointIndex: null
+    focusedPointIndex: null,
+    previouslyFocusedPointIndex: null
   });
 }
 const getDeltaVertex = (maxMoves, minMoves, delta) => {
@@ -39737,15 +39662,15 @@ const TickMarks = Graphie.createSimpleClass((graphie, props) => {
 
   // Render the text labels
   results.push(graphie.style(props.isMobile ? {
-    color: KhanColors.BLUE_D
+    color: KhanColors.BLUE
   } : {}, () => _label(graphie, props.labelStyle, leftLabel, leftLabel, base)));
   results.push(graphie.style(props.isMobile ? {
-    color: KhanColors.BLUE_D
+    color: KhanColors.BLUE
   } : {}, () => _label(graphie, props.labelStyle, rightLabel, rightLabel, base)));
 
   // Render the labels' lines
   graphie.style({
-    stroke: props.isMobile ? KhanColors.BLUE_D : KhanColors.DYNAMIC,
+    stroke: KhanColors.BLUE,
     strokeWidth: 3.5
   }, () => {
     results.push(graphie.line([leftLabel, -0.2], [leftLabel, 0.2]));
@@ -39912,21 +39837,21 @@ class NumberLine extends React.Component {
       if (isOpen) {
         fill = KhanColors._BACKGROUND;
       } else if (props.static) {
-        fill = KhanColors.DYNAMIC;
+        fill = KhanColors.BLUE;
       } else {
-        fill = KhanColors.INTERACTIVE;
+        fill = KhanColors.GREEN;
       }
       const normalStyle = {
         fill: fill,
-        stroke: props.static ? KhanColors.DYNAMIC : KhanColors.INTERACTIVE,
+        stroke: props.static ? KhanColors.BLUE : KhanColors.GREEN,
         "stroke-width": isOpen ? 3 : 1
       };
       const highlightStyle = {
-        fill: isOpen ? KhanColors._BACKGROUND : KhanColors.INTERACTING,
+        fill: isOpen ? KhanColors._BACKGROUND : KhanColors.GREEN,
         "stroke-width": isOpen ? 3 : 1
       };
       const mobileDotStyle = props.isInequality ? {
-        stroke: KhanColors.INTERACTIVE,
+        stroke: KhanColors.GREEN,
         "fill-opacity": isOpen ? 0 : 1
       } : {};
       return /*#__PURE__*/React.createElement(MovablePoint
@@ -39984,7 +39909,7 @@ class NumberLine extends React.Component {
         const end = this._getInequalityEndpoint(props);
         const style = {
           arrows: "->",
-          stroke: this.props.apiOptions.isMobile ? KhanColors.INTERACTIVE : KhanColors.DYNAMIC,
+          stroke: this.props.apiOptions.isMobile ? KhanColors.GREEN : KhanColors.BLUE,
           strokeWidth: 3.5
         };
         const isGreater = ["ge", "gt"].includes(props.rel);
@@ -44741,7 +44666,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 = "33.0.0";
+const libVersion = "33.2.0";
 addLibraryVersionToPerseusDebug(libName, libVersion);
 
 const apiVersion = {