@khanacademy/perseus-score 1.0.0 → 2.0.0

package/dist/es/index.js

@@ -1,6 +1,7 @@
 import * as KAS from '@khanacademy/kas';
-import { KhanMath } from '@khanacademy/kmath';
-import { PerseusError, Errors } from '@khanacademy/perseus-core';
+import { KhanMath, number, geometry, angles, coefficients } from '@khanacademy/kmath';
+import { PerseusError, Errors, getDecimalSeparator, GrapherUtil, approximateDeepEqual, approximateEqual, deepClone, getMatrixSize } from '@khanacademy/perseus-core';
+import { ErrorCodes as ErrorCodes$1 } from '@khanacademy/perseus-score';
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -11832,6 +11833,10 @@ const EXTRA_SYMBOLS_ERROR = "EXTRA_SYMBOLS_ERROR";
 const WRONG_CASE_ERROR = "WRONG_CASE_ERROR";
 const WRONG_LETTER_ERROR = "WRONG_LETTER_ERROR";
 const MULTIPLICATION_SIGN_ERROR = "MULTIPLICATION_SIGN_ERROR";
+const INVALID_SELECTION_ERROR = "INVALID_SELECTION_ERROR";
+const CHOOSE_CORRECT_NUM_ERROR = "CHOOSE_CORRECT_NUM_ERROR";
+const NOT_NONE_ABOVE_ERROR = "NOT_NONE_ABOVE_ERROR";
+const FILL_ALL_CELLS_ERROR = "FILL_ALL_CELLS_ERROR";
 const ErrorCodes = {
   MISSING_PERCENT_ERROR,
   NEEDS_TO_BE_SIMPLIFIED_ERROR,
@@ -11839,7 +11844,11 @@ const ErrorCodes = {
   EXTRA_SYMBOLS_ERROR,
   WRONG_CASE_ERROR,
   WRONG_LETTER_ERROR,
-  MULTIPLICATION_SIGN_ERROR
+  MULTIPLICATION_SIGN_ERROR,
+  INVALID_SELECTION_ERROR,
+  CHOOSE_CORRECT_NUM_ERROR,
+  NOT_NONE_ABOVE_ERROR,
+  FILL_ALL_CELLS_ERROR
 };
 
 /* eslint-disable no-useless-escape */
@@ -12517,5 +12526,1324 @@ const KhanAnswerTypes = {
   }
 };
 
-export { ErrorCodes, KhanAnswerTypes };
+/**
+ * Checks userInput from the categorizer widget to see if the user has selected
+ * a category for each item.
+ * @param userInput - The user's input corresponding to an array of indices that
+ * represent the selected category for each row/item.
+ * @param validationData - An array of strings corresponding to each row/item
+ * @param strings - Used to provide a validation message
+ */
+function validateCategorizer(userInput, validationData) {
+  const incomplete = validationData.items.some((_, i) => userInput.values[i] == null);
+  if (incomplete) {
+    return {
+      type: "invalid",
+      message: ErrorCodes$1.INVALID_SELECTION_ERROR
+    };
+  }
+  return null;
+}
+
+function scoreCategorizer(userInput, rubric) {
+  const validationError = validateCategorizer(userInput, rubric);
+  if (validationError) {
+    return validationError;
+  }
+  let allCorrect = true;
+  rubric.values.forEach((value, i) => {
+    if (userInput.values[i] !== value) {
+      allCorrect = false;
+    }
+  });
+  return {
+    type: "points",
+    earned: allCorrect ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
+function scoreCSProgram(userInput) {
+  // The CS program can tell us whether it's correct or incorrect,
+  // and pass an optional message
+  if (userInput.status === "correct") {
+    return {
+      type: "points",
+      earned: 1,
+      total: 1,
+      message: userInput.message || null
+    };
+  }
+  if (userInput.status === "incorrect") {
+    return {
+      type: "points",
+      earned: 0,
+      total: 1,
+      message: userInput.message || null
+    };
+  }
+  return {
+    type: "invalid",
+    message: "Keep going, you're not there yet!"
+  };
+}
+
+/**
+ * Checks if the user has selected an item from the dropdown before scoring.
+ * This is shown with a userInput value / index other than 0.
+ */
+function validateDropdown(userInput) {
+  if (userInput.value === 0) {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return null;
+}
+
+function scoreDropdown(userInput, rubric) {
+  const validationError = validateDropdown(userInput);
+  if (validationError) {
+    return validationError;
+  }
+  const correct = rubric.choices[userInput.value - 1].correct;
+  return {
+    type: "points",
+    earned: correct ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
+/**
+ * Checks user input from the expression widget to see if it is scorable.
+ *
+ * Note: Most of the expression widget's validation requires the Rubric because
+ * of its use of KhanAnswerTypes as a core part of scoring.
+ *
+ * @see `scoreExpression()` for more details.
+ */
+function validateExpression(userInput) {
+  if (userInput === "") {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return null;
+}
+
+/* Content creators input a list of answers which are matched from top to
+ * bottom. The intent is that they can include spcific solutions which should
+ * be graded as correct or incorrect (or ungraded!) first, then get more
+ * general.
+ *
+ * We iterate through each answer, trying to match it with the user's input
+ * using the following angorithm:
+ * - Try to parse the user's input. If it doesn't parse then return "not
+ *   graded".
+ * - For each answer:
+ *   ~ Try to validate the user's input against the answer. The answer is
+ *     expected to parse.
+ *   ~ If the user's input validates (the validator judges it "correct"), we've
+ *     matched and can stop considering answers.
+ * - If there were no matches or the matching answer is considered "ungraded",
+ *   show the user an error. TODO(joel) - what error?
+ * - Otherwise, pass through the resulting points and message.
+ */
+function scoreExpression(userInput, rubric, locale) {
+  const validationError = validateExpression(userInput);
+  if (validationError) {
+    return validationError;
+  }
+  const options = _.clone(rubric);
+  _.extend(options, {
+    decimal_separator: getDecimalSeparator(locale)
+  });
+  const createValidator = answer => {
+    // We give options to KAS.parse here because it is parsing the
+    // solution answer, not the student answer, and we don't want a
+    // solution to work if the student is using a different language
+    // (different from the content creation language, ie. English).
+    const expression = KAS.parse(answer.value, rubric);
+    // An answer may not be parsed if the expression was defined
+    // incorrectly. For example if the answer is using a symbol defined
+    // in the function variables list for the expression.
+    if (!expression.parsed) {
+      /* c8 ignore next */
+      throw new PerseusError("Unable to parse solution answer for expression", Errors.InvalidInput, {
+        metadata: {
+          rubric: JSON.stringify(rubric)
+        }
+      });
+    }
+    return KhanAnswerTypes.expression.createValidatorFunctional(expression.expr, _({}).extend(options, {
+      simplify: answer.simplify,
+      form: answer.form
+    }));
+  };
+
+  // Find the first answer form that matches the user's input and that
+  // is considered correct. Also, track whether the input is
+  // considered "empty" for all answer forms, and keep the validation
+  // result for the first answer form for which the user's input was
+  // considered "ungraded".
+  // (Terminology reminder: the answer forms are provided by the
+  // assessment items; they are not the user's input. Each one might
+  // represent a correct answer, an incorrect one (if the exercise
+  // creator has predicted certain common wrong answers and wants to
+  // provide guidance via a message), or an ungraded one (same idea,
+  // but without giving the user an incorrect mark for the question).
+  let matchingAnswerForm;
+  let matchMessage;
+  let allEmpty = true;
+  let firstUngradedResult;
+  for (const answerForm of rubric.answerForms || []) {
+    const validator = createValidator(answerForm);
+    if (!validator) {
+      continue;
+    }
+    const result = validator(userInput);
+
+    // Short-circuit as soon as the user's input matches some answer
+    // (independently of whether the answer is correct)
+    if (result.correct) {
+      matchingAnswerForm = answerForm;
+      matchMessage = result.message || "";
+      break;
+    }
+    allEmpty = allEmpty && result.empty;
+    // If this answer form is correct and the user's input is considered
+    // "ungraded" for it, we'll want to keep the evaluation result for
+    // later. If the user's input doesn't match any answer forms, we'll
+    // show the message from this validation.
+    if (answerForm.considered === "correct" && result.ungraded && !firstUngradedResult) {
+      firstUngradedResult = result;
+    }
+  }
+
+  // Now check to see if we matched any answer form at all, and if
+  // we did, whether it's considered correct, incorrect, or ungraded
+  if (!matchingAnswerForm) {
+    if (firstUngradedResult) {
+      // While we didn't directly match with any answer form, we
+      // did at some point get an "ungraded" validation result,
+      // which might indicate e.g. a mismatch in variable casing.
+      // We'll return "invalid", which will let the user try again
+      // with no penalty, and the hopefully helpful validation
+      // message.
+      return {
+        type: "invalid",
+        message: firstUngradedResult.message,
+        suppressAlmostThere: firstUngradedResult.suppressAlmostThere
+      };
+    }
+    if (allEmpty) {
+      // If everything graded as empty, it's invalid.
+      return {
+        type: "invalid",
+        message: null
+      };
+    }
+    // We fell through all the possibilities and we're not empty,
+    // so the answer is considered incorrect.
+    return {
+      type: "points",
+      earned: 0,
+      total: 1
+    };
+  }
+  if (matchingAnswerForm.considered === "ungraded") {
+    return {
+      type: "invalid",
+      message: matchMessage
+    };
+  }
+  // We matched a graded answer form, so we can now tell the user
+  // whether their input was correct or incorrect, and hand out
+  // points accordingly
+  return {
+    type: "points",
+    earned: matchingAnswerForm.considered === "correct" ? 1 : 0,
+    total: 1,
+    message: matchMessage
+  };
+}
+
+function getCoefficientsByType(data) {
+  if (data.coords == null) {
+    return undefined;
+  }
+  if (data.type === "exponential" || data.type === "logarithm") {
+    const grader = GrapherUtil.functionForType(data.type);
+    return grader.getCoefficients(data.coords, data.asymptote);
+  } else if (data.type === "linear" || data.type === "quadratic" || data.type === "absolute_value" || data.type === "sinusoid" || data.type === "tangent") {
+    const grader = GrapherUtil.functionForType(data.type);
+    return grader.getCoefficients(data.coords);
+  } else {
+    throw new PerseusError("Invalid grapher type", Errors.InvalidInput);
+  }
+}
+function scoreGrapher(userInput, rubric) {
+  if (userInput.type !== rubric.correct.type) {
+    return {
+      type: "points",
+      earned: 0,
+      total: 1,
+      message: null
+    };
+  }
+
+  // We haven't moved the coords
+  if (userInput.coords == null) {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+
+  // Get new function handler for grading
+  const grader = GrapherUtil.functionForType(userInput.type);
+  const guessCoeffs = getCoefficientsByType(userInput);
+  const correctCoeffs = getCoefficientsByType(rubric.correct);
+  if (guessCoeffs == null || correctCoeffs == null) {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  if (grader.areEqual(guessCoeffs, correctCoeffs)) {
+    return {
+      type: "points",
+      earned: 1,
+      total: 1,
+      message: null
+    };
+  }
+  return {
+    type: "points",
+    earned: 0,
+    total: 1,
+    message: null
+  };
+}
+
+// TODO: merge this with scoreCSProgram, it's the same code
+function scoreIframe(userInput) {
+  // The iframe can tell us whether it's correct or incorrect,
+  // and pass an optional message
+  if (userInput.status === "correct") {
+    return {
+      type: "points",
+      earned: 1,
+      total: 1,
+      message: userInput.message || null
+    };
+  }
+  if (userInput.status === "incorrect") {
+    return {
+      type: "points",
+      earned: 0,
+      total: 1,
+      message: userInput.message || null
+    };
+  }
+  return {
+    type: "invalid",
+    message: "Keep going, you're not there yet!"
+  };
+}
+
+const {
+  collinear,
+  canonicalSineCoefficients,
+  similar
+} = geometry;
+const {
+  getClockwiseAngle
+} = angles;
+const {
+  getSinusoidCoefficients,
+  getQuadraticCoefficients
+} = coefficients;
+function scoreInteractiveGraph(userInput, rubric) {
+  // None-type graphs are not graded
+  if (userInput.type === "none" && rubric.correct.type === "none") {
+    return {
+      type: "points",
+      earned: 0,
+      total: 0,
+      message: null
+    };
+  }
+
+  // When nothing has moved, there will neither be coords nor the
+  // circle's center/radius fields. When those fields are absent, skip
+  // all these checks; just go mark the answer as empty.
+  const hasValue = Boolean(
+  // @ts-expect-error - TS2339 - Property 'coords' does not exist on type 'PerseusGraphType'.
+  userInput.coords ||
+  // @ts-expect-error - TS2339 - Property 'center' does not exist on type 'PerseusGraphType'. | TS2339 - Property 'radius' does not exist on type 'PerseusGraphType'.
+  userInput.center && userInput.radius);
+  if (userInput.type === rubric.correct.type && hasValue) {
+    if (userInput.type === "linear" && rubric.correct.type === "linear" && userInput.coords != null) {
+      const guess = userInput.coords;
+      const correct = rubric.correct.coords;
+
+      // If both of the guess points are on the correct line, it's
+      // correct.
+      if (collinear(correct[0], correct[1], guess[0]) && collinear(correct[0], correct[1], guess[1])) {
+        return {
+          type: "points",
+          earned: 1,
+          total: 1,
+          message: null
+        };
+      }
+    } else if (userInput.type === "linear-system" && rubric.correct.type === "linear-system" && userInput.coords != null) {
+      const guess = userInput.coords;
+      const correct = rubric.correct.coords;
+      if (collinear(correct[0][0], correct[0][1], guess[0][0]) && collinear(correct[0][0], correct[0][1], guess[0][1]) && collinear(correct[1][0], correct[1][1], guess[1][0]) && collinear(correct[1][0], correct[1][1], guess[1][1]) || collinear(correct[0][0], correct[0][1], guess[1][0]) && collinear(correct[0][0], correct[0][1], guess[1][1]) && collinear(correct[1][0], correct[1][1], guess[0][0]) && collinear(correct[1][0], correct[1][1], guess[0][1])) {
+        return {
+          type: "points",
+          earned: 1,
+          total: 1,
+          message: null
+        };
+      }
+    } else if (userInput.type === "quadratic" && rubric.correct.type === "quadratic" && userInput.coords != null) {
+      // If the parabola coefficients match, it's correct.
+      const guessCoeffs = getQuadraticCoefficients(userInput.coords);
+      const correctCoeffs = getQuadraticCoefficients(rubric.correct.coords);
+      if (approximateDeepEqual(guessCoeffs, correctCoeffs)) {
+        return {
+          type: "points",
+          earned: 1,
+          total: 1,
+          message: null
+        };
+      }
+    } else if (userInput.type === "sinusoid" && rubric.correct.type === "sinusoid" && userInput.coords != null) {
+      const guessCoeffs = getSinusoidCoefficients(userInput.coords);
+      const correctCoeffs = getSinusoidCoefficients(rubric.correct.coords);
+      const canonicalGuessCoeffs = canonicalSineCoefficients(guessCoeffs);
+      const canonicalCorrectCoeffs = canonicalSineCoefficients(correctCoeffs);
+      // If the canonical coefficients match, it's correct.
+      if (approximateDeepEqual(canonicalGuessCoeffs, canonicalCorrectCoeffs)) {
+        return {
+          type: "points",
+          earned: 1,
+          total: 1,
+          message: null
+        };
+      }
+    } else if (userInput.type === "circle" && rubric.correct.type === "circle") {
+      if (approximateDeepEqual(userInput.center, rubric.correct.center) && approximateEqual(userInput.radius, rubric.correct.radius)) {
+        return {
+          type: "points",
+          earned: 1,
+          total: 1,
+          message: null
+        };
+      }
+    } else if (userInput.type === "point" && rubric.correct.type === "point" && userInput.coords != null) {
+      let correct = rubric.correct.coords;
+      if (correct == null) {
+        throw new Error("Point graph rubric has null coords");
+      }
+      const guess = userInput.coords.slice();
+      correct = correct.slice();
+      // Everything's already rounded so we shouldn't need to do an
+      // eq() comparison but _.isEqual(0, -0) is false, so we'll use
+      // eq() anyway. The sort should be fine because it'll stringify
+      // it and -0 converted to a string is "0"
+      guess == null || guess.sort();
+      // @ts-expect-error - TS2339 - Property 'sort' does not exist on type 'readonly Coord[]'.
+      correct.sort();
+      if (approximateDeepEqual(guess, correct)) {
+        return {
+          type: "points",
+          earned: 1,
+          total: 1,
+          message: null
+        };
+      }
+    } else if (userInput.type === "polygon" && rubric.correct.type === "polygon" && userInput.coords != null) {
+      const guess = userInput.coords.slice();
+      const correct = rubric.correct.coords.slice();
+      let match;
+      if (rubric.correct.match === "similar") {
+        match = similar(guess, correct, Number.POSITIVE_INFINITY);
+      } else if (rubric.correct.match === "congruent") {
+        match = similar(guess, correct, number.DEFAULT_TOLERANCE);
+      } else if (rubric.correct.match === "approx") {
+        match = similar(guess, correct, 0.1);
+      } else {
+        /* exact */
+        guess.sort();
+        correct.sort();
+        match = approximateDeepEqual(guess, correct);
+      }
+      if (match) {
+        return {
+          type: "points",
+          earned: 1,
+          total: 1,
+          message: null
+        };
+      }
+    } else if (userInput.type === "segment" && rubric.correct.type === "segment" && userInput.coords != null) {
+      let guess = deepClone(userInput.coords);
+      let correct = deepClone(rubric.correct.coords);
+      guess = _.invoke(guess, "sort").sort();
+      correct = _.invoke(correct, "sort").sort();
+      if (approximateDeepEqual(guess, correct)) {
+        return {
+          type: "points",
+          earned: 1,
+          total: 1,
+          message: null
+        };
+      }
+    } else if (userInput.type === "ray" && rubric.correct.type === "ray" && userInput.coords != null) {
+      const guess = userInput.coords;
+      const correct = rubric.correct.coords;
+      if (approximateDeepEqual(guess[0], correct[0]) && collinear(correct[0], correct[1], guess[1])) {
+        return {
+          type: "points",
+          earned: 1,
+          total: 1,
+          message: null
+        };
+      }
+    } else if (userInput.type === "angle" && rubric.correct.type === "angle") {
+      const guess = userInput.coords;
+      const correct = rubric.correct.coords;
+      const allowReflexAngles = rubric.correct.allowReflexAngles;
+      let match;
+      if (rubric.correct.match === "congruent") {
+        const angles = _.map([guess, correct], function (coords) {
+          if (!coords) {
+            return false;
+          }
+          const angle = getClockwiseAngle(coords, allowReflexAngles);
+          return angle;
+        });
+        // @ts-expect-error - TS2556 - A spread argument must either have a tuple type or be passed to a rest parameter.
+        match = approximateEqual(...angles);
+      } else {
+        /* exact */
+        match =
+        // @ts-expect-error - TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'.
+        approximateDeepEqual(guess[1], correct[1]) &&
+        // @ts-expect-error - TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'.
+        collinear(correct[1], correct[0], guess[0]) &&
+        // @ts-expect-error - TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'. | TS2532 - Object is possibly 'undefined'.
+        collinear(correct[1], correct[2], guess[2]);
+      }
+      if (match) {
+        return {
+          type: "points",
+          earned: 1,
+          total: 1,
+          message: null
+        };
+      }
+    }
+  }
+
+  // The input wasn't correct, so check if it's a blank input or if it's
+  // actually just wrong
+  if (!hasValue || _.isEqual(userInput, rubric.graph)) {
+    // We're where we started.
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return {
+    type: "points",
+    earned: 0,
+    total: 1,
+    message: null
+  };
+}
+
+function validateLabelImage(userInput) {
+  let numAnswered = 0;
+  for (let i = 0; i < userInput.markers.length; i++) {
+    const userSelection = userInput.markers[i].selected;
+    if (userSelection && userSelection.length > 0) {
+      numAnswered++;
+    }
+  }
+  // We expect all question markers to be answered before grading.
+  if (numAnswered !== userInput.markers.length) {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return null;
+}
+
+// Question state for marker as result of user selected answers.
+
+function scoreLabelImageMarker(userInput, rubric) {
+  const score = {
+    hasAnswers: false,
+    isCorrect: false
+  };
+  if (userInput && userInput.length > 0) {
+    score.hasAnswers = true;
+  }
+  if (rubric.length > 0) {
+    if (userInput && userInput.length === rubric.length) {
+      // All correct answers are selected by the user.
+      score.isCorrect = userInput.every(choice => rubric.includes(choice));
+    }
+  } else if (!userInput || userInput.length === 0) {
+    // Correct as no answers should be selected by the user.
+    score.isCorrect = true;
+  }
+  return score;
+}
+function scoreLabelImage(userInput, rubric) {
+  const validationError = validateLabelImage(userInput);
+  if (validationError) {
+    return validationError;
+  }
+  let numCorrect = 0;
+  for (let i = 0; i < userInput.markers.length; i++) {
+    const score = scoreLabelImageMarker(userInput.markers[i].selected, rubric.markers[i].answers);
+    if (score.isCorrect) {
+      numCorrect++;
+    }
+  }
+  return {
+    type: "points",
+    // Markers with no expected answers are graded as correct if user
+    // makes no answer selection.
+    earned: numCorrect === userInput.markers.length ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
+function scoreMatcher(userInput, rubric) {
+  const correct = _.isEqual(userInput.left, rubric.left) && _.isEqual(userInput.right, rubric.right);
+  return {
+    type: "points",
+    earned: correct ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
+/**
+ * Checks user input from the matrix widget to see if it is scorable.
+ *
+ * Note: The matrix widget cannot do much validation without the Scoring
+ * Data because of its use of KhanAnswerTypes as a core part of scoring.
+ *
+ * @see `scoreMatrix()` for more details.
+ */
+function validateMatrix(userInput) {
+  const supplied = userInput.answers;
+  const suppliedSize = getMatrixSize(supplied);
+  for (let row = 0; row < suppliedSize[0]; row++) {
+    for (let col = 0; col < suppliedSize[1]; col++) {
+      if (supplied[row][col] == null || supplied[row][col].toString().length === 0) {
+        return {
+          type: "invalid",
+          message: ErrorCodes.FILL_ALL_CELLS_ERROR
+        };
+      }
+    }
+  }
+  return null;
+}
+
+function scoreMatrix(userInput, rubric) {
+  const validationError = validateMatrix(userInput);
+  if (validationError != null) {
+    return validationError;
+  }
+  const solution = rubric.answers;
+  const supplied = userInput.answers;
+  const solutionSize = getMatrixSize(solution);
+  const suppliedSize = getMatrixSize(supplied);
+  const incorrectSize = solutionSize[0] !== suppliedSize[0] || solutionSize[1] !== suppliedSize[1];
+  const createValidator = KhanAnswerTypes.number.createValidatorFunctional;
+  let message = null;
+  let incorrect = false;
+  _(suppliedSize[0]).times(row => {
+    _(suppliedSize[1]).times(col => {
+      if (!incorrectSize) {
+        const validator = createValidator(
+        // @ts-expect-error - TS2345 - Argument of type 'number' is not assignable to parameter of type 'string'.
+        solution[row][col], {
+          simplify: true
+        });
+        const result = validator(supplied[row][col]);
+        if (result.message) {
+          // @ts-expect-error - TS2322 - Type 'string' is not assignable to type 'null'.
+          message = result.message;
+        }
+        if (!result.correct) {
+          incorrect = true;
+        }
+      }
+    });
+  });
+  if (incorrectSize) {
+    return {
+      type: "points",
+      earned: 0,
+      total: 1,
+      message: null
+    };
+  }
+  return {
+    type: "points",
+    earned: incorrect ? 0 : 1,
+    total: 1,
+    message: message
+  };
+}
+
+/**
+ * Checks user input is within the allowed range and not the same as the initial
+ * state.
+ * @param userInput
+ * @see 'scoreNumberLine' for the scoring logic.
+ */
+function validateNumberLine(userInput) {
+  const divisionRange = userInput.divisionRange;
+  const outsideAllowedRange = userInput.numDivisions > divisionRange[1] || userInput.numDivisions < divisionRange[0];
+
+  // TODO: I don't think isTickCrtl is a thing anymore
+  if (userInput.isTickCrtl && outsideAllowedRange) {
+    return {
+      type: "invalid",
+      message: "Number of divisions is outside the allowed range."
+    };
+  }
+  return null;
+}
+
+function scoreNumberLine(userInput, rubric) {
+  const validationError = validateNumberLine(userInput);
+  if (validationError) {
+    return validationError;
+  }
+  const range = rubric.range;
+  const start = rubric.initialX != null ? rubric.initialX : range[0];
+  const startRel = rubric.isInequality ? "ge" : "eq";
+  const correctRel = rubric.correctRel || "eq";
+  const correctPos = number.equal(userInput.numLinePosition, rubric.correctX || 0);
+  if (correctPos && correctRel === userInput.rel) {
+    return {
+      type: "points",
+      earned: 1,
+      total: 1,
+      message: null
+    };
+  }
+  if (userInput.numLinePosition === start && userInput.rel === startRel) {
+    // We're where we started.
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return {
+    type: "points",
+    earned: 0,
+    total: 1,
+    message: null
+  };
+}
+
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+/*
+ * In this file, an `expression` is some portion of valid TeX enclosed in
+ * curly brackets.
+ */
+
+/*
+ * Find the index at which an expression ends, i.e., has an unmatched
+ * closing curly bracket. This method assumes that we start with a non-open
+ * bracket character and end when we've seen more left than right brackets
+ * (rather than assuming that we start with a bracket character and wait for
+ * bracket equality).
+ */
+function findEndpoint(tex, currentIndex) {
+  let bracketDepth = 0;
+  for (let i = currentIndex, len = tex.length; i < len; i++) {
+    const c = tex[i];
+    if (c === "{") {
+      bracketDepth++;
+    } else if (c === "}") {
+      bracketDepth--;
+    }
+    if (bracketDepth < 0) {
+      return i;
+    }
+  }
+  // If we never see unbalanced curly brackets, default to the
+  // entire string
+  return tex.length;
+}
+
+/*
+ * Parses an individual set of curly brackets into TeX.
+ */
+function parseNextExpression(tex, currentIndex, handler) {
+  // Find the first '{' and grab subsequent TeX
+  // Ex) tex: '{3}{7}', and we want the '3'
+  const openBracketIndex = tex.indexOf("{", currentIndex);
+  const nextExpIndex = openBracketIndex + 1;
+
+  // Truncate to only contain remaining TeX
+  const endpoint = findEndpoint(tex, nextExpIndex);
+  const expressionTeX = tex.substring(nextExpIndex, endpoint);
+  const parsedExp = walkTex(expressionTeX, handler);
+  return {
+    endpoint: endpoint,
+    expression: parsedExp
+  };
+}
+function getNextFracIndex(tex, currentIndex) {
+  const dfrac = "\\dfrac";
+  const frac = "\\frac";
+  const nextFrac = tex.indexOf(frac, currentIndex);
+  const nextDFrac = tex.indexOf(dfrac, currentIndex);
+  if (nextFrac > -1 && nextDFrac > -1) {
+    return Math.min(nextFrac, nextDFrac);
+  }
+  if (nextFrac > -1) {
+    return nextFrac;
+  }
+  if (nextDFrac > -1) {
+    return nextDFrac;
+  }
+  return -1;
+}
+function walkTex(tex, handler) {
+  if (!tex) {
+    return "";
+  }
+
+  // Ex) tex: '2 \dfrac {3}{7}'
+  let parsedString = "";
+  let currentIndex = 0;
+  let nextFrac = getNextFracIndex(tex, currentIndex);
+
+  // For each \dfrac, find the two expressions (wrapped in {}) and recur
+  while (nextFrac > -1) {
+    // Gather first fragment, preceding \dfrac
+    // Ex) parsedString: '2 '
+    parsedString += tex.substring(currentIndex, nextFrac);
+
+    // Remove everything preceding \dfrac, which has been parsed
+    currentIndex = nextFrac;
+
+    // Parse first expression and move index past it
+    // Ex) firstParsedExpression.expression: '3'
+    const firstParsedExpression = parseNextExpression(tex, currentIndex, handler);
+    currentIndex = firstParsedExpression.endpoint + 1;
+
+    // Parse second expression
+    // Ex) secondParsedExpression.expression: '7'
+    const secondParsedExpression = parseNextExpression(tex, currentIndex, handler);
+    currentIndex = secondParsedExpression.endpoint + 1;
+
+    // Add expressions to running total of parsed expressions
+    if (parsedString.length) {
+      parsedString += " ";
+    }
+
+    // Apply a custom handler based on the parsed subexpressions
+    parsedString += handler(firstParsedExpression.expression, secondParsedExpression.expression);
+
+    // Find next DFrac, relative to currentIndex
+    nextFrac = getNextFracIndex(tex, currentIndex);
+  }
+
+  // Add remaining TeX, which is \dfrac-free
+  parsedString += tex.slice(currentIndex);
+  return parsedString;
+}
+
+/*
+ * Parse a TeX expression into something interpretable by input-number.
+ * The process is concerned with: (1) parsing fractions, i.e., \dfracs; and
+ * (2) removing backslash-escaping from certain characters (right now, only
+ * percent signs).
+ *
+ * The basic algorithm for handling \dfracs splits on \dfracs and then recurs
+ * on the subsequent "expressions", i.e., the {} pairs that follow \dfrac. The
+ * recursion is to allow for nested \dfrac elements.
+ *
+ * Backslash-escapes are removed with a simple search-and-replace.
+ */
+function parseTex(tex) {
+  const handler = function handler(exp1, exp2) {
+    return exp1 + "/" + exp2;
+  };
+  const texWithoutFracs = walkTex(tex, handler);
+  return texWithoutFracs.replace("\\%", "%");
+}
+
+const answerFormButtons = [{
+  title: "Integers",
+  value: "integer",
+  content: "6"
+}, {
+  title: "Decimals",
+  value: "decimal",
+  content: "0.75"
+}, {
+  title: "Proper fractions",
+  value: "proper",
+  content: "\u2157"
+}, {
+  title: "Improper fractions",
+  value: "improper",
+  content: "\u2077\u2044\u2084"
+}, {
+  title: "Mixed numbers",
+  value: "mixed",
+  content: "1\u00BE"
+}, {
+  title: "Numbers with \u03C0",
+  value: "pi",
+  content: "\u03C0"
+}];
+
+// This function checks if the user inputted a percent value, parsing
+// it as a number (and maybe scaling) so that it can be graded.
+// NOTE(michaelpolyak): Unlike `KhanAnswerTypes.number.percent()` which
+// can accept several input forms with or without "%", the decision
+// to parse based on the presence of "%" in the input, is so that we
+// don't accidently scale the user typed value before grading, CP-930.
+function maybeParsePercentInput(inputValue, normalizedAnswerExpected) {
+  // If the input value is not a string ending with "%", then there's
+  // nothing more to do. The value will be graded as inputted by user.
+  if (!(typeof inputValue === "string" && inputValue.endsWith("%"))) {
+    return inputValue;
+  }
+  const value = parseFloat(inputValue.slice(0, -1));
+  // If the input value stripped of the "%" cannot be parsed as a
+  // number (the slice is not really necessary for parseFloat to work
+  // if the string starts with a number) then return the original
+  // input for grading.
+  if (isNaN(value)) {
+    return inputValue;
+  }
+
+  // Next, if all correct answers are in the range of |0,1| then we
+  // scale the user typed value. We assume this is the correct thing
+  // to do since the input value ends with "%".
+  if (normalizedAnswerExpected) {
+    return value / 100;
+  }
+
+  // Otherwise, we return input value (number) stripped of the "%".
+  return value;
+}
+function scoreNumericInput(userInput, rubric) {
+  var _matchedAnswer$messag;
+  const defaultAnswerForms = answerFormButtons.map(e => e["value"])
+  // Don't default to validating the answer as a pi answer
+  // if answerForm isn't set on the answer
+  // https://khanacademy.atlassian.net/browse/LC-691
+  .filter(e => e !== "pi");
+  const createValidator = answer => {
+    var _answer$answerForms;
+    const stringAnswer = `${answer.value}`;
+
+    // Always validate against the provided answer forms (pi, decimal, etc.)
+    const validatorForms = [...((_answer$answerForms = answer.answerForms) != null ? _answer$answerForms : [])];
+
+    // When an answer is set to strict, we validate using ONLY
+    // the provided answerForms. If strict is false, or if there
+    // were no provided answer forms, we will include all
+    // of the default answer forms in our validator.
+    if (!answer.strict || validatorForms.length === 0) {
+      validatorForms.push(...defaultAnswerForms);
+    }
+    return KhanAnswerTypes.number.createValidatorFunctional(stringAnswer, {
+      message: answer.message,
+      simplify: answer.status === "correct" ? answer.simplify : "optional",
+      inexact: true,
+      // TODO(merlob) backfill / delete
+      maxError: answer.maxError,
+      forms: validatorForms
+    });
+  };
+
+  // We may have received TeX; try to parse it before grading.
+  // If `currentValue` is not TeX, this should be a no-op.
+  const currentValue = parseTex(userInput.currentValue);
+  const normalizedAnswerExpected = rubric.answers.filter(answer => answer.status === "correct").every(answer => answer.value != null && Math.abs(answer.value) <= 1);
+
+  // The coefficient is an attribute of the widget
+  let localValue = currentValue;
+  if (rubric.coefficient) {
+    if (!localValue) {
+      localValue = 1;
+    } else if (localValue === "-") {
+      localValue = -1;
+    }
+  }
+  const matchedAnswer = rubric.answers.map(answer => {
+    const validateFn = createValidator(answer);
+    const score = validateFn(maybeParsePercentInput(localValue, normalizedAnswerExpected));
+    return _extends({}, answer, {
+      score
+    });
+  }).find(answer => {
+    // NOTE: "answer.score.correct" indicates a match via the validate function.
+    //       It does NOT indicate that the answer itself is correct.
+    return answer.score.correct || answer.status === "correct" && answer.score.empty;
+  });
+  const result = (matchedAnswer == null ? void 0 : matchedAnswer.status) === "correct" ? matchedAnswer.score : {
+    empty: (matchedAnswer == null ? void 0 : matchedAnswer.status) === "ungraded",
+    correct: (matchedAnswer == null ? void 0 : matchedAnswer.status) === "correct",
+    message: (_matchedAnswer$messag = matchedAnswer == null ? void 0 : matchedAnswer.message) != null ? _matchedAnswer$messag : null,
+    guess: localValue
+  };
+  if (result.empty) {
+    return {
+      type: "invalid",
+      message: result.message
+    };
+  }
+  return {
+    type: "points",
+    earned: result.correct ? 1 : 0,
+    total: 1,
+    message: result.message
+  };
+}
+
+/**
+ * Checks user input from the orderer widget to see if the user has started
+ * ordering the options, making the widget scorable.
+ * @param userInput
+ * @see `scoreOrderer` for more details.
+ */
+function validateOrderer(userInput) {
+  if (userInput.current.length === 0) {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return null;
+}
+
+function scoreOrderer(userInput, rubric) {
+  const validationError = validateOrderer(userInput);
+  if (validationError) {
+    return validationError;
+  }
+  const correct = _.isEqual(userInput.current, rubric.correctOptions.map(option => option.content));
+  return {
+    type: "points",
+    earned: correct ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
+/**
+ * Checks user input to confirm it is not the same as the starting values for the graph.
+ * This means the user has modified the graph, and the question can be scored.
+ *
+ * @see 'scorePlotter' for more details on scoring.
+ */
+function validatePlotter(userInput, validationData) {
+  if (approximateDeepEqual(userInput, validationData.starting)) {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return null;
+}
+
+function scorePlotter(userInput, rubric) {
+  const validationError = validatePlotter(userInput, rubric);
+  if (validationError) {
+    return validationError;
+  }
+  return {
+    type: "points",
+    earned: approximateDeepEqual(userInput, rubric.correct) ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
+/**
+ * Checks if the user has selected at least one option. Additional validation
+ * is done in scoreRadio to check if the number of selected options is correct
+ * and if the user has selected both a correct option and the "none of the above"
+ * option.
+ * @param userInput
+ * @see `scoreRadio` for the additional validation logic and the scoring logic.
+ */
+function validateRadio(userInput) {
+  const numSelected = userInput.choicesSelected.reduce((sum, selected) => {
+    return sum + (selected ? 1 : 0);
+  }, 0);
+  if (numSelected === 0) {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return null;
+}
+
+function scoreRadio(userInput, rubric) {
+  const validationError = validateRadio(userInput);
+  if (validationError) {
+    return validationError;
+  }
+  const numSelected = userInput.choicesSelected.reduce((sum, selected) => {
+    return sum + (selected ? 1 : 0);
+  }, 0);
+  const numCorrect = rubric.choices.reduce((sum, currentChoice) => {
+    return currentChoice.correct ? sum + 1 : sum;
+  }, 0);
+  if (numCorrect > 1 && numSelected !== numCorrect) {
+    return {
+      type: "invalid",
+      message: ErrorCodes.CHOOSE_CORRECT_NUM_ERROR
+    };
+    // If NOTA and some other answer are checked, ...
+  }
+
+  const noneOfTheAboveSelected = rubric.choices.some((choice, index) => choice.isNoneOfTheAbove && userInput.choicesSelected[index]);
+  if (noneOfTheAboveSelected && numSelected > 1) {
+    return {
+      type: "invalid",
+      message: ErrorCodes.NOT_NONE_ABOVE_ERROR
+    };
+  }
+  const correct = userInput.choicesSelected.every((selected, i) => {
+    let isCorrect;
+    if (rubric.choices[i].isNoneOfTheAbove) {
+      isCorrect = rubric.choices.every((choice, j) => {
+        return i === j || !choice.correct;
+      });
+    } else {
+      isCorrect = !!rubric.choices[i].correct;
+    }
+    return isCorrect === selected;
+  });
+  return {
+    type: "points",
+    earned: correct ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
+/**
+ * Checks user input for the sorter widget to ensure that the user has made
+ * changes before attempting to score the widget.
+ * @param userInput
+ * @see 'scoreSorter' in 'packages/perseus/src/widgets/sorter/score-sorter.ts'
+ * for more details on how the sorter widget is scored.
+ */
+function validateSorter(userInput) {
+  // If the sorter widget hasn't been changed yet, we treat it as "empty" which
+  // prevents the "Check" button from becoming active. We want the user
+  // to make a change before trying to move forward. This makes an
+  // assumption that the initial order isn't the correct order! However,
+  // this should be rare if it happens, and interacting with the list
+  // will enable the button, so they won't be locked out of progressing.
+  if (!userInput.changed) {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return null;
+}
+
+function scoreSorter(userInput, rubric) {
+  const validationError = validateSorter(userInput);
+  if (validationError) {
+    return validationError;
+  }
+  const correct = approximateDeepEqual(userInput.options, rubric.correct);
+  return {
+    type: "points",
+    earned: correct ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
+/**
+ * Filters the given table (modelled as a 2D array) to remove any rows that are
+ * completely empty.
+ *
+ * @returns A new table with only non-empty rows.
+ */
+const filterNonEmpty = function filterNonEmpty(table) {
+  return table.filter(function (row) {
+    // Return only rows that are non-empty.
+    return row.some(cell => cell);
+  });
+};
+
+function validateTable(userInput) {
+  const supplied = filterNonEmpty(userInput);
+  const hasEmptyCell = supplied.some(function (row) {
+    return row.some(function (cell) {
+      return cell === "";
+    });
+  });
+  if (hasEmptyCell || !supplied.length) {
+    return {
+      type: "invalid",
+      message: null
+    };
+  }
+  return null;
+}
+
+function scoreTable(userInput, rubric) {
+  const validationResult = validateTable(userInput);
+  if (validationResult != null) {
+    return validationResult;
+  }
+  const supplied = filterNonEmpty(userInput);
+  const solution = filterNonEmpty(rubric.answers);
+  if (supplied.length !== solution.length) {
+    return {
+      type: "points",
+      earned: 0,
+      total: 1,
+      message: null
+    };
+  }
+  const createValidator = KhanAnswerTypes.number.createValidatorFunctional;
+  let message = null;
+  const allCorrect = solution.every(function (rowSolution) {
+    for (let i = 0; i < supplied.length; i++) {
+      const rowSupplied = supplied[i];
+      const correct = rowSupplied.every(function (cellSupplied, i) {
+        const cellSolution = rowSolution[i];
+        const validator = createValidator(cellSolution, {
+          simplify: true
+        });
+        const result = validator(cellSupplied);
+        if (result.message) {
+          message = result.message;
+        }
+        return result.correct;
+      });
+      if (correct) {
+        supplied.splice(i, 1);
+        return true;
+      }
+    }
+    return false;
+  });
+  return {
+    type: "points",
+    earned: allCorrect ? 1 : 0,
+    total: 1,
+    message
+  };
+}
+
+const inputNumberAnswerTypes = {
+  number: {
+    name: "Numbers",
+    forms: "integer, decimal, proper, improper, mixed"
+  },
+  decimal: {
+    name: "Decimals",
+    forms: "decimal"
+  },
+  integer: {
+    name: "Integers",
+    forms: "integer"
+  },
+  rational: {
+    name: "Fractions and mixed numbers",
+    forms: "integer, proper, improper, mixed"
+  },
+  improper: {
+    name: "Improper numbers (no mixed)",
+    forms: "integer, proper, improper"
+  },
+  mixed: {
+    name: "Mixed numbers (no improper)",
+    forms: "integer, proper, mixed"
+  },
+  percent: {
+    name: "Numbers or percents",
+    forms: "integer, decimal, proper, improper, mixed, percent"
+  },
+  pi: {
+    name: "Numbers with pi",
+    forms: "pi"
+  }
+};
+function scoreInputNumber(userInput, rubric) {
+  if (rubric.answerType == null) {
+    rubric.answerType = "number";
+  }
+
+  // note(matthewc): this will get immediately parsed again by
+  // `KhanAnswerTypes.number.convertToPredicate`, but a string is
+  // expected here
+  const stringValue = `${rubric.value}`;
+  const val = KhanAnswerTypes.number.createValidatorFunctional(stringValue, {
+    simplify: rubric.simplify,
+    inexact: rubric.inexact || undefined,
+    maxError: rubric.maxError,
+    forms: inputNumberAnswerTypes[rubric.answerType].forms
+  });
+
+  // We may have received TeX; try to parse it before grading.
+  // If `currentValue` is not TeX, this should be a no-op.
+  const currentValue = parseTex(userInput.currentValue);
+  const result = val(currentValue);
+  if (result.empty) {
+    return {
+      type: "invalid",
+      message: result.message
+    };
+  }
+  return {
+    type: "points",
+    earned: result.correct ? 1 : 0,
+    total: 1,
+    message: result.message
+  };
+}
+
+export { ErrorCodes, KhanAnswerTypes, inputNumberAnswerTypes, scoreCSProgram, scoreCategorizer, scoreDropdown, scoreExpression, scoreGrapher, scoreIframe, scoreInputNumber, scoreInteractiveGraph, scoreLabelImage, scoreLabelImageMarker, scoreMatcher, scoreMatrix, scoreNumberLine, scoreNumericInput, scoreOrderer, scorePlotter, scoreRadio, scoreSorter, scoreTable, validateCategorizer, validateDropdown, validateExpression, validateMatrix, validateNumberLine, validateOrderer, validatePlotter, validateRadio, validateSorter, validateTable };
 //# sourceMappingURL=index.js.map