@khanacademy/perseus-score 3.0.0 → 4.0.0

package/dist/es/index.js

@@ -0,0 +1,2281 @@
+import _extends from '@babel/runtime/helpers/extends';
+import * as KAS from '@khanacademy/kas';
+import { KhanMath, geometry, angles, coefficients, number } from '@khanacademy/kmath';
+import { PerseusError, Errors, getDecimalSeparator, GrapherUtil, approximateDeepEqual, approximateEqual, deepClone, getMatrixSize, getWidgetIdsFromContent, getUpgradedWidgetOptions } from '@khanacademy/perseus-core';
+import _ from 'underscore';
+
+const MISSING_PERCENT_ERROR = "MISSING_PERCENT_ERROR";
+const NEEDS_TO_BE_SIMPLIFIED_ERROR = "NEEDS_TO_BE_SIMPLIFIED_ERROR";
+const APPROXIMATED_PI_ERROR = "APPROXIMATED_PI_ERROR";
+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,
+  APPROXIMATED_PI_ERROR,
+  EXTRA_SYMBOLS_ERROR,
+  WRONG_CASE_ERROR,
+  WRONG_LETTER_ERROR,
+  MULTIPLICATION_SIGN_ERROR,
+  INVALID_SELECTION_ERROR,
+  CHOOSE_CORRECT_NUM_ERROR,
+  NOT_NONE_ABOVE_ERROR,
+  FILL_ALL_CELLS_ERROR
+};
+
+const MAXERROR_EPSILON = Math.pow(2, -42);
+
+// TOOD(kevinb): Figure out how this relates to KEScore in
+// perseus-all-package/types.js and see if there's a way to
+// unify these types.
+
+/**
+ * Answer types
+ *
+ * Utility for creating answerable questions displayed in exercises
+ *
+ * Different answer types produce different kinds of input displays, and do
+ * different kinds of checking on the solutions.
+ *
+ * Each of the objects contain two functions, setup and createValidator.
+ *
+ * The setup function takes a solutionarea and solution, and performs setup
+ * within the solutionarea, and then returns an object which contains:
+ *
+ * answer: a function which, when called, will retrieve the current answer from
+ *         the solutionarea, which can then be validated using the validator
+ *         function
+ * validator: a function returned from the createValidator function (defined
+ *            below)
+ * solution: the correct answer to the problem
+ * showGuess: a function which, when given a guess, shows the guess within the
+ *            provided solutionarea
+ * showGuessCustom: a function which displays parts of a guess that are not
+ *                  within the solutionarea; currently only used for custom
+ *                  answers
+ *
+ * The createValidator function only takes a solution, and it returns a
+ * function which can be used to validate an answer.
+ *
+ * The resulting validator function returns:
+ * - true: if the answer is fully correct
+ * - false: if the answer is incorrect
+ * - "" (the empty string): if no answer has been provided (e.g. the answer box
+ *   is left unfilled)
+ * - a string: if there is some slight error
+ *
+ * In most cases, setup and createValidator don't really need the solution DOM
+ * element so we have setupFunctional and createValidatorFunctional for them
+ * which take only $solution.text() and $solution.data(). This makes it easier
+ * to reuse specific answer types.
+ *
+ * TODO(alpert): Think of a less-absurd name for createValidatorFunctional.
+ *
+ */
+const KhanAnswerTypes = {
+  /*
+   * predicate answer type
+   *
+   * performs simple predicate-based checking of a numeric solution, with
+   * different kinds of number formats
+   *
+   * Uses the data-forms option on the solution to choose which number formats
+   * are acceptable. Available data-forms:
+   *
+   * - integer:  3
+   * - proper:   3/5
+   * - improper: 5/3
+   * - pi:       3 pi
+   * - log:      log(5)
+   * - percent:  15%
+   * - mixed:    1 1/3
+   * - decimal:  1.7
+   *
+   * The solution should be a predicate of the form:
+   *
+   * function(guess, maxError) {
+   *     return abs(guess - 3) < maxError;
+   * }
+   *
+   */
+  predicate: {
+    defaultForms: "integer, proper, improper, mixed, decimal",
+    createValidatorFunctional: function (predicate, options) {
+      // Extract the options from the given solution object
+      options = _.extend({
+        simplify: "required",
+        ratio: false,
+        forms: KhanAnswerTypes.predicate.defaultForms
+      }, options);
+      let acceptableForms;
+      // this is maintaining backwards compatibility
+      // TODO(merlob) fix all places that depend on this, then delete
+      if (!_.isArray(options.forms)) {
+        acceptableForms = options.forms.split(/\s*,\s*/);
+      } else {
+        acceptableForms = options.forms;
+      }
+
+      // TODO(jack): remove options.inexact in favor of options.maxError
+      if (options.inexact === undefined) {
+        // If we aren't allowing inexact, ensure that we don't have a
+        // large maxError as well.
+        options.maxError = 0;
+      }
+      // Allow a small tolerance on maxError, to avoid numerical
+      // representation issues (2.3 should be correct for a solution of
+      // 2.45 with maxError=0.15).
+      options.maxError = +options.maxError + MAXERROR_EPSILON;
+
+      // If percent is an acceptable form, make sure it's the last one
+      // in the list so we don't prematurely complain about not having
+      // a percent sign when the user entered the correct answer in a
+      // different form (such as a decimal or fraction)
+      if (_.contains(acceptableForms, "percent")) {
+        acceptableForms = _.without(acceptableForms, "percent");
+        acceptableForms.push("percent");
+      }
+
+      // Take text looking like a fraction, and turn it into a number
+      const fractionTransformer = function fractionTransformer(text) {
+        text = text
+        // Replace unicode minus sign with hyphen
+        .replace(/\u2212/, "-")
+        // Remove space after +, -
+        .replace(/([+-])\s+/g, "$1")
+        // Remove leading/trailing whitespace
+        .replace(/(^\s*)|(\s*$)/gi, "");
+
+        // Extract numerator and denominator
+        const match = text.match(/^([+-]?\d+)\s*\/\s*([+-]?\d+)$/);
+        // Fractions are represented as "-\frac{numerator}{denominator}"
+        // in Mobile device input instead of "numerator/denominator" as
+        // in web-browser.
+        const mobileDeviceMatch = text.match(/^([+-]?)\\frac\{([+-]?\d+)\}\{([+-]?\d+)\}$/);
+        const parsedInt = parseInt(text, 10);
+        if (match || mobileDeviceMatch) {
+          let num;
+          let denom;
+          let simplified = true;
+          if (match) {
+            num = parseFloat(match[1]);
+            denom = parseFloat(match[2]);
+          } else {
+            num = parseFloat(mobileDeviceMatch[2]);
+            if (mobileDeviceMatch[1] === "-") {
+              if (num < 0) {
+                simplified = false;
+              }
+              num = -num;
+            }
+            denom = parseFloat(mobileDeviceMatch[3]);
+          }
+          simplified = simplified && denom > 0 && (options.ratio || denom !== 1) && KhanMath.getGCD(num, denom) === 1;
+          return [{
+            value: num / denom,
+            exact: simplified
+          }];
+        }
+        if (!isNaN(parsedInt) && "" + parsedInt === text) {
+          return [{
+            value: parsedInt,
+            exact: true
+          }];
+        }
+        return [];
+      };
+
+      /*
+       * Different forms of numbers
+       *
+       * Each function returns a list of objects of the form:
+       *
+       * {
+       *    value: numerical value,
+       *    exact: true/false
+       * }
+       */
+      const forms = {
+        // integer, which is encompassed by decimal
+        integer: function (text) {
+          // Compare the decimal form to the decimal form rounded to
+          // an integer. Only accept if the user actually entered an
+          // integer.
+          const decimal = forms.decimal(text);
+          const rounded = forms.decimal(text, 1);
+          if (decimal[0].value != null && decimal[0].value === rounded[0].value || decimal[1].value != null && decimal[1].value === rounded[1].value) {
+            return decimal;
+          }
+          return [];
+        },
+        // A proper fraction
+        proper: function (text) {
+          const transformed = fractionTransformer(text);
+          return transformed.flatMap(o => {
+            // All fractions that are less than 1
+            if (Math.abs(o.value) < 1) {
+              return [o];
+            }
+            return [];
+          });
+        },
+        // an improper fraction
+        improper: function (text) {
+          // As our answer keys are always in simplest form, we need
+          // to check for the existence of a fraction in the input before
+          // validating the answer. If no fraction is found, we consider
+          // the answer to be incorrect.
+          const fractionExists = text.includes("/") || text.match(/\\(d?frac)/);
+          if (!fractionExists) {
+            return [];
+          }
+          const transformed = fractionTransformer(text);
+          return transformed.flatMap(o => {
+            // All fractions that are greater than 1
+            if (Math.abs(o.value) >= 1) {
+              return [o];
+            }
+            return [];
+          });
+        },
+        // pi-like numbers
+        pi: function (text) {
+          let match;
+          let possibilities = [];
+
+          // Replace unicode minus sign with hyphen
+          text = text.replace(/\u2212/, "-");
+
+          // - pi
+          // (Note: we also support \pi (for TeX), p, tau (and \tau,
+          // and t), pau.)
+          if (match = text.match(/^([+-]?)\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i)) {
+            possibilities = [{
+              value: parseFloat(match[1] + "1"),
+              exact: true
+            }];
+
+            // 5 / 6 pi
+          } else if (match = text.match(/^([+-]?\s*\d+\s*(?:\/\s*[+-]?\s*\d+)?)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i)) {
+            possibilities = fractionTransformer(match[1]);
+
+            // 4 5 / 6 pi
+          } else if (match = text.match(/^([+-]?)\s*(\d+)\s*([+-]?\d+)\s*\/\s*([+-]?\d+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i)) {
+            const sign = parseFloat(match[1] + "1");
+            const integ = parseFloat(match[2]);
+            const num = parseFloat(match[3]);
+            const denom = parseFloat(match[4]);
+            const simplified = num < denom && KhanMath.getGCD(num, denom) === 1;
+            possibilities = [{
+              value: sign * (integ + num / denom),
+              exact: simplified
+            }];
+
+            // 5 pi / 6
+          } else if (match = text.match(/^([+-]?\s*\d+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)\s*(?:\/\s*([+-]?\s*\d+))?$/i)) {
+            possibilities = fractionTransformer(match[1] + "/" + match[3]);
+
+            // - pi / 4
+          } else if (match = text.match(/^([+-]?)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)\s*(?:\/\s*([+-]?\d+))?$/i)) {
+            possibilities = fractionTransformer(match[1] + "1/" + match[3]);
+
+            // 0
+          } else if (text === "0") {
+            possibilities = [{
+              value: 0,
+              exact: true
+            }];
+
+            // 0.5 pi (fallback)
+          } else if (match = text.match(/^(.+)\s*\*?\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i)) {
+            possibilities = forms.decimal(match[1]);
+          } else {
+            possibilities = _.reduce(KhanAnswerTypes.predicate.defaultForms.split(/\s*,\s*/), function (memo, form) {
+              return memo.concat(forms[form](text));
+            }, []);
+
+            // If the answer is a floating point number that's
+            // near a multiple of pi, mark is as being possibly
+            // an approximation of pi.  We actually check if
+            // it's a plausible approximation of pi/12, since
+            // sometimes the correct answer is like pi/3 or pi/4.
+            // We also say it's a pi-approximation if it involves
+            // x/7 (since 22/7 is an approximation of pi.)
+            // Never mark an integer as being an approximation
+            // of pi.
+            let approximatesPi = false;
+            const number = parseFloat(text);
+            if (!isNaN(number) && number !== parseInt(text)) {
+              const piMult = Math.PI / 12;
+              const roundedNumber = piMult * Math.round(number / piMult);
+              if (Math.abs(number - roundedNumber) < 0.01) {
+                approximatesPi = true;
+              }
+            } else if (text.match(/\/\s*7/)) {
+              approximatesPi = true;
+            }
+            if (approximatesPi) {
+              _.each(possibilities, function (possibility) {
+                possibility.piApprox = true;
+              });
+            }
+            return possibilities;
+          }
+          let multiplier = Math.PI;
+          if (text.match(/\\?tau|t|\u03c4/)) {
+            multiplier = Math.PI * 2;
+          }
+
+          // We're taking an early stand along side xkcd in the
+          // inevitable ti vs. pau debate... http://xkcd.com/1292
+          if (text.match(/pau/)) {
+            multiplier = Math.PI * 1.5;
+          }
+          possibilities.forEach(possibility => {
+            possibility.value *= multiplier;
+          });
+          return possibilities;
+        },
+        // Converts '' to 1 and '-' to -1 so you can write "[___] x"
+        // and accept sane things
+        coefficient: function (text) {
+          let possibilities = [];
+
+          // Replace unicode minus sign with hyphen
+          text = text.replace(/\u2212/, "-");
+          if (text === "") {
+            possibilities = [{
+              value: 1,
+              exact: true
+            }];
+          } else if (text === "-") {
+            possibilities = [{
+              value: -1,
+              exact: true
+            }];
+          }
+          return possibilities;
+        },
+        // simple log(c) form
+        log: function (text) {
+          let match;
+          let possibilities = [];
+
+          // Replace unicode minus sign with hyphen
+          text = text.replace(/\u2212/, "-");
+          text = text.replace(/[ \(\)]/g, "");
+          if (match = text.match(/^log\s*(\S+)\s*$/i)) {
+            // @ts-expect-error - TS2322 - Type '{ value: number | undefined; exact: boolean; }[]' is not assignable to type 'never[]'.
+            possibilities = forms.decimal(match[1]);
+          } else if (text === "0") {
+            // @ts-expect-error - TS2322 - Type 'number' is not assignable to type 'never'. | TS2322 - Type 'boolean' is not assignable to type 'never'.
+            possibilities = [{
+              value: 0,
+              exact: true
+            }];
+          }
+          return possibilities;
+        },
+        // Numbers with percent signs
+        percent: function (text) {
+          text = String(text).trim();
+          // store whether or not there is a percent sign
+          let hasPercentSign = false;
+          if (text.indexOf("%") === text.length - 1) {
+            text = text.substring(0, text.length - 1).trim();
+            hasPercentSign = true;
+          }
+          const transformed = forms.decimal(text);
+          transformed.forEach(t => {
+            t.exact = hasPercentSign;
+            // @ts-expect-error - TS2532 - Object is possibly 'undefined'.
+            t.value = t.value / 100;
+          });
+          return transformed;
+        },
+        // Mixed numbers, like 1 3/4
+        mixed: function (text) {
+          const match = text
+          // Replace unicode minus sign with hyphen
+          .replace(/\u2212/, "-")
+          // Remove space after +, -
+          .replace(/([+-])\s+/g, "$1")
+          // Extract integer, numerator and denominator
+          .match(/^([+-]?)(\d+)\s+(\d+)\s*\/\s*(\d+)$/);
+          if (match) {
+            const sign = parseFloat(match[1] + "1");
+            const integ = parseFloat(match[2]);
+            const num = parseFloat(match[3]);
+            const denom = parseFloat(match[4]);
+            const simplified = num < denom && KhanMath.getGCD(num, denom) === 1;
+            return [{
+              value: sign * (integ + num / denom),
+              exact: simplified
+            }];
+          }
+          return [];
+        },
+        // Decimal numbers -- compare entered text rounded to
+        // 'precision' Reciprical of the precision against the correct
+        // answer. We round to 1/1e10 by default, which is healthily
+        // less than machine epsilon but should be more than any real
+        // decimal answer would use. (The 'integer' answer type uses
+        // precision == 1.)
+        decimal: function (text, precision = 1e10) {
+          const normal = function normal(text) {
+            text = String(text).trim();
+            const match = text
+            // Replace unicode minus sign with hyphen
+            .replace(/\u2212/, "-")
+            // Remove space after +, -
+            .replace(/([+-])\s+/g, "$1")
+            // Extract integer, numerator and denominator. If
+            // commas or spaces are used, they must be in the
+            // "correct" places
+            .match(/^([+-]?(?:\d{1,3}(?:[, ]?\d{3})*\.?|\d{0,3}(?:[, ]?\d{3})*\.(?:\d{3}[, ]?)*\d{1,3}))$/);
+
+            // You can't start a number with `0,`, to prevent us
+            // interpeting '0.342' as correct for '342'
+            const badLeadingZero = text.match(/^0[0,]*,/);
+            if (match && !badLeadingZero) {
+              let x = parseFloat(match[1].replace(/[, ]/g, ""));
+              if (options.inexact === undefined) {
+                x = Math.round(x * precision) / precision;
+              }
+              return x;
+            }
+          };
+          const commas = function commas(text) {
+            text = text.replace(/([\.,])/g, function (_, c) {
+              return c === "." ? "," : ".";
+            });
+            return normal(text);
+          };
+          return [{
+            value: normal(text),
+            exact: true
+          }, {
+            value: commas(text),
+            exact: true
+          }];
+        }
+      };
+
+      // validator function
+      return function (guess) {
+        // The fallback variable is used in place of the answer, if no
+        // answer is provided (i.e. the field is left blank)
+        const fallback = options.fallback != null ? "" + options.fallback : "";
+        guess = String(guess).trim() || fallback;
+        const score = {
+          empty: guess === "",
+          correct: false,
+          message: null,
+          guess: guess
+        };
+
+        // iterate over all the acceptable forms, and if one of the
+        // answers is correct, return true
+        acceptableForms.forEach(form => {
+          const transformed = forms[form](guess);
+          for (let j = 0, l = transformed.length; j < l; j++) {
+            const val = transformed[j].value;
+            const exact = transformed[j].exact;
+            const piApprox = transformed[j].piApprox;
+            // If a string was returned, and it exactly matches,
+            // return true
+            if (predicate(val, options.maxError)) {
+              // If the exact correct number was returned,
+              // return true
+              if (exact || options.simplify === "optional") {
+                score.correct = true;
+                score.message = options.message || null;
+                // If the answer is correct, don't say it's
+                // empty. This happens, for example, with the
+                // coefficient type where guess === "" but is
+                // interpreted as "1" which is correct.
+                score.empty = false;
+              } else if (form === "percent") {
+                // Otherwise, an error was returned
+                score.empty = true;
+                score.message = ErrorCodes.MISSING_PERCENT_ERROR;
+              } else {
+                if (options.simplify !== "enforced") {
+                  score.empty = true;
+                }
+                score.message = ErrorCodes.NEEDS_TO_BE_SIMPLIFIED_ERROR;
+              }
+              // The return false below stops the looping of the
+              // callback since predicate check  succeeded.
+              // No more forms to look to verify the user guess.
+              return false;
+            }
+            if (piApprox && predicate(val, Math.abs(val * 0.001))) {
+              score.empty = true;
+              score.message = ErrorCodes.APPROXIMATED_PI_ERROR;
+            }
+          }
+        });
+        if (score.correct === false) {
+          let interpretedGuess = false;
+          _.each(forms, function (form) {
+            const anyAreNaN = _.any(form(guess), function (t) {
+              return t.value != null && !_.isNaN(t.value);
+            });
+            if (anyAreNaN) {
+              interpretedGuess = true;
+            }
+          });
+          if (!interpretedGuess) {
+            score.empty = true;
+            score.message = ErrorCodes.EXTRA_SYMBOLS_ERROR;
+            return score;
+          }
+        }
+        return score;
+      };
+    }
+  },
+  /*
+   * number answer type
+   *
+   * wraps the predicate answer type to performs simple number-based checking
+   * of a solution
+   */
+  number: {
+    convertToPredicate: function (correctAnswer, options) {
+      const correctFloat = parseFloat(correctAnswer);
+      return [function (guess, maxError) {
+        return Math.abs(guess - correctFloat) < maxError;
+      }, _extends({}, options, {
+        type: "predicate"
+      })];
+    },
+    createValidatorFunctional: function (correctAnswer, options) {
+      return KhanAnswerTypes.predicate.createValidatorFunctional(...KhanAnswerTypes.number.convertToPredicate(correctAnswer, options));
+    }
+  },
+  /*
+   * The expression answer type parses a given expression or equation
+   * and semantically compares it to the solution. In addition, instant
+   * feedback is provided by rendering the last answer that fully parsed.
+   *
+   * Parsing options:
+   * functions (e.g. data-functions="f g h")
+   *     A space or comma separated list of single-letter variables that
+   *     should be interpreted as functions. Case sensitive. "e" and "i"
+   *     are reserved.
+   *
+   *     no functions specified: f(x+y) == fx + fy
+   *     with "f" as a function: f(x+y) != fx + fy
+   *
+   * Comparison options:
+   * same-form (e.g. data-same-form)
+   *     If present, the answer must match the solution's structure in
+   *     addition to evaluating the same. Commutativity and excess negation
+   *     are ignored, but all other changes will trigger a rejection. Useful
+   *     for requiring a particular form of an equation, or if the answer
+   *     must be factored.
+   *
+   *     example question:    Factor x^2 + x - 2
+   *     example solution:    (x-1)(x+2)
+   *     accepted answers:    (x-1)(x+2), (x+2)(x-1), ---(-x-2)(-1+x), etc.
+   *     rejected answers:    x^2+x-2, x*x+x-2, x(x+1)-2, (x-1)(x+2)^1, etc.
+   *     rejection message:   Your answer is not in the correct form
+   *
+   * simplify (e.g. data-simplify)
+   *     If present, the answer must be fully expanded and simplified. Use
+   *     carefully - simplification is hard and there may be bugs, or you
+   *     might not agree on the definition of "simplified" used. You will
+   *     get an error if the provided solution is not itself fully expanded
+   *     and simplified.
+   *
+   *     example question:    Simplify ((n*x^5)^5) / (n^(-2)*x^2)^-3
+   *     example solution:    x^31 / n
+   *     accepted answers:    x^31 / n, x^31 / n^1, x^31 * n^(-1), etc.
+   *     rejected answers:    (x^25 * n^5) / (x^(-6) * n^6), etc.
+   *     rejection message:   Your answer is not fully expanded and simplified
+   *
+   * Rendering options:
+   * times (e.g. data-times)
+   *     If present, explicit multiplication (such as between numbers) will
+   *     be rendered with a cross/x symbol (TeX: \times) instead of the usual
+   *     center dot (TeX: \cdot).
+   *
+   *     normal rendering:    2 * 3^x -> 2 \cdot 3^{x}
+   *     but with "times":    2 * 3^x -> 2 \times 3^{x}
+   */
+  expression: {
+    parseSolution: function (solutionString, options) {
+      let solution = KAS.parse(solutionString, options);
+      if (!solution.parsed) {
+        throw new PerseusError("The provided solution (" + solutionString + ") didn't parse.", Errors.InvalidInput);
+      } else if (options.simplified && !solution.expr.isSimplified()) {
+        throw new PerseusError("The provided solution (" + solutionString + ") isn't fully expanded and simplified.", Errors.InvalidInput);
+      } else {
+        solution = solution.expr;
+      }
+      return solution;
+    },
+    createValidatorFunctional: function (solution, options) {
+      return function (guess) {
+        const score = {
+          empty: false,
+          correct: false,
+          message: null,
+          guess: guess,
+          // Setting `ungraded` to true indicates that if the
+          // guess doesn't match any of the solutions, the guess
+          // shouldn't be marked as incorrect; instead, `message`
+          // should be shown to the user. This is different from
+          // setting `empty` to true, since the behavior of `empty`
+          // is that `message` only will be shown if the guess is
+          // graded as empty for every solution.
+          ungraded: false
+        };
+
+        // Don't bother parsing an empty input
+        if (!guess) {
+          // @ts-expect-error - TS2540 - Cannot assign to 'empty' because it is a read-only property.
+          score.empty = true;
+          return score;
+        }
+        const answer = KAS.parse(guess, options);
+
+        // An unsuccessful parse doesn't count as wrong
+        if (!answer.parsed) {
+          // @ts-expect-error - TS2540 - Cannot assign to 'empty' because it is a read-only property.
+          score.empty = true;
+          return score;
+        }
+
+        // Solution will need to be parsed again if we're creating
+        // this from a multiple question type
+        if (typeof solution === "string") {
+          solution = KhanAnswerTypes.expression.parseSolution(solution, options);
+        }
+        const result = KAS.compare(answer.expr, solution, options);
+        if (result.equal) {
+          // Correct answer
+          // @ts-expect-error - TS2540 - Cannot assign to 'correct' because it is a read-only property.
+          score.correct = true;
+        } else if (result.wrongVariableNames || result.wrongVariableCase) {
+          // We don't want to give people an error for getting the
+          // variable names or the variable case wrong.
+          // TODO(aasmund): This should ideally have been handled
+          // under the `result.message` condition, but the
+          // KAS messages currently aren't translatable.
+          // @ts-expect-error - TS2540 - Cannot assign to 'ungraded' because it is a read-only property.
+          score.ungraded = true;
+          // @ts-expect-error - TS2540 - Cannot assign to 'message' because it is a read-only property.
+          score.message = result.wrongVariableCase ? ErrorCodes.WRONG_CASE_ERROR : ErrorCodes.WRONG_LETTER_ERROR;
+          // Don't tell the use they're "almost there" in this case, that may not be true and isn't helpful.
+          // @ts-expect-error - TS2339 - Property 'suppressAlmostThere' does not exist on type '{ readonly empty: false; readonly correct: false; readonly message: string | null | undefined; readonly guess: any; readonly ungraded: false; }'.
+          score.suppressAlmostThere = true;
+        } else if (result.message) {
+          // Nearly correct answer
+          // TODO(aasmund): This message also isn't translatable;
+          // need to fix that in KAS
+          // @ts-expect-error - TS2540 - Cannot assign to 'message' because it is a read-only property.
+          score.message = result.message;
+        } else {
+          // Replace x with * and see if it would have been correct
+          // TODO(aasmund): I think this branch is effectively dead,
+          // because the replacement will only work in situations
+          // where the variables are wrong (except if the variable
+          // is x, in which case the replacement won't work either),
+          // which is handled by another branch. When we implement a
+          // more sophisticated variable check, revive this or
+          // remove it completely if it will never come into play.
+          const answerX = KAS.parse(guess.replace(/[xX]/g, "*"), options);
+          if (answerX.parsed) {
+            const resultX = KAS.compare(answerX.expr, solution, options);
+            if (resultX.equal) {
+              // @ts-expect-error - TS2540 - Cannot assign to 'ungraded' because it is a read-only property.
+              score.ungraded = true;
+              // @ts-expect-error - TS2540 - Cannot assign to 'message' because it is a read-only property.
+              score.message = ErrorCodes.MULTIPLICATION_SIGN_ERROR;
+            } else if (resultX.message) {
+              // TODO(aasmund): I18nize `score.message`
+              // @ts-expect-error - TS2540 - Cannot assign to 'message' because it is a read-only property.
+              score.message = resultX.message + " Also, I'm a computer. I only understand " + "multiplication if you use an " + "asterisk (*) as the multiplication " + "sign.";
+            }
+          }
+        }
+        return score;
+      };
+    }
+  }
+};
+
+function scoreCategorizer(userInput, rubric) {
+  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
+  };
+}
+
+/**
+ * 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.INVALID_SELECTION_ERROR
+    };
+  }
+  return 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!"
+  };
+}
+
+function scoreDropdown(userInput, rubric) {
+  const correct = rubric.choices[userInput.value - 1].correct;
+  return {
+    type: "points",
+    earned: correct ? 1 : 0,
+    total: 1,
+    message: null
+  };
+}
+
+/**
+ * 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;
+}
+
+/* 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 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;
+  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+  for (const answerForm of rubric.answerForms || []) {
+    const validator = createValidator(answerForm);
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    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
+  };
+}
+
+/**
+ * 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;
+}
+
+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,
+  clockwise
+} = 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 coords = userInput.coords;
+      const correct = rubric.correct.coords;
+      const allowReflexAngles = rubric.correct.allowReflexAngles;
+
+      // While the angle graph should always have 3 points, our types
+      // technically allow for null values. We'll check for that here.
+      // TODO: (LEMS-2857) We would like to update the type of coords
+      // to be non-nullable, as the graph should always have 3 points.
+      if (!coords) {
+        return {
+          type: "invalid",
+          message: null
+        };
+      }
+
+      // We need to check both the direction of the angle and the
+      // whether the graph allows for reflexive angles in order to
+      // to determine if we need to reverse the coords for scoring.
+      const areClockwise = clockwise([coords[0], coords[2], coords[1]]);
+      const shouldReverseCoords = areClockwise && !allowReflexAngles;
+      const guess = shouldReverseCoords ? coords.slice().reverse() : coords;
+      let match;
+      if (rubric.correct.match === "congruent") {
+        const angles = _.map([guess, correct], function (coords) {
+          // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+          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 = approximateDeepEqual(guess[1], correct[1]) && collinear(correct[1], correct[0], guess[0]) && 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
+  };
+}
+
+// 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) {
+  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
+  };
+}
+
+function scoreMatrix(userInput, rubric) {
+  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 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 scoreNumberLine(userInput, rubric) {
+  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,
+  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+  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
+  };
+}
+
+/**
+ * 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;
+}
+
+/*
+ * 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);
+
+  // If there is no open bracket, set the endpoint to the end of the string
+  // and the expression to an empty string. This helps ensure we don't
+  // get stuck in an infinite loop when users handtype TeX.
+  if (openBracketIndex === -1) {
+    return {
+      endpoint: tex.length,
+      expression: ""
+    };
+  }
+  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
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-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};
+  if (result.empty) {
+    return {
+      type: "invalid",
+      message: result.message
+    };
+  }
+  return {
+    type: "points",
+    earned: result.correct ? 1 : 0,
+    total: 1,
+    message: result.message
+  };
+}
+
+function scoreOrderer(userInput, rubric) {
+  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 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 scorePlotter(userInput, rubric) {
+  return {
+    type: "points",
+    earned: approximateDeepEqual(userInput, rubric.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 scoreRadio(userInput, rubric) {
+  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 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 scoreSorter(userInput, rubric) {
+  const correct = approximateDeepEqual(userInput.options, rubric.correct);
+  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;
+}
+
+/**
+ * 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 === "";
+    });
+  });
+
+  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+  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
+  };
+}
+
+/**
+ * Several widgets don't have "right"/"wrong" scoring logic,
+ * so this just says to move on past those widgets
+ *
+ * TODO(LEMS-2543) widgets that use this probably shouldn't have any
+ * scoring logic and the thing scoring an exercise
+ * should just know to skip these
+ */
+function scoreNoop(points = 0) {
+  return {
+    type: "points",
+    earned: points,
+    total: points,
+    message: null
+  };
+}
+
+// The `group` widget is basically a widget hosting a full Perseus system in
+
+// it. As such, scoring a group means scoring all widgets it contains.
+function scoreGroup(userInput, rubric, locale) {
+  const scores = scoreWidgetsFunctional(rubric.widgets, Object.keys(rubric.widgets), userInput, locale);
+  return flattenScores(scores);
+}
+
+/**
+ * Checks the given user input to see if any answerable widgets have not been
+ * "filled in" (ie. if they're empty). Another way to think about this
+ * function is that its a check to see if we can score the provided input.
+ */
+function emptyWidgetsFunctional(widgets,
+// This is a port of old code, I'm not sure why
+// we need widgetIds vs the keys of the widgets object
+widgetIds, userInputMap, locale) {
+  return widgetIds.filter(id => {
+    const widget = widgets[id];
+    if (!widget || widget.static === true) {
+      // Static widgets shouldn't count as empty
+      return false;
+    }
+    const validator = getWidgetValidator(widget.type);
+    const userInput = userInputMap[id];
+    const validationData = widget.options;
+    const score = validator == null ? void 0 : validator(userInput, validationData, locale);
+    if (score) {
+      return scoreIsEmpty(score);
+    }
+  });
+}
+
+function validateGroup(userInput, validationData, locale) {
+  const emptyWidgets = emptyWidgetsFunctional(validationData.widgets, Object.keys(validationData.widgets), userInput, locale);
+  if (emptyWidgets.length === 0) {
+    return null;
+  }
+  return {
+    type: "invalid",
+    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;
+}
+
+function validateMockWidget(userInput) {
+  if (userInput.currentValue == null || userInput.currentValue === "") {
+    return {
+      type: "invalid",
+      message: ""
+    };
+  }
+  return null;
+}
+
+function scoreMockWidget(userInput, rubric) {
+  const validationResult = validateMockWidget(userInput);
+  if (validationResult != null) {
+    return validationResult;
+  }
+  return {
+    type: "points",
+    earned: userInput.currentValue === rubric.value ? 1 : 0,
+    total: 1,
+    message: ""
+  };
+}
+
+const widgets = {};
+function registerWidget(type, scorer, validator) {
+  widgets[type] = {
+    scorer,
+    validator
+  };
+}
+const getWidgetValidator = name => {
+  var _widgets$name$validat, _widgets$name;
+  return (_widgets$name$validat = (_widgets$name = widgets[name]) == null ? void 0 : _widgets$name.validator) != null ? _widgets$name$validat : null;
+};
+const getWidgetScorer = name => {
+  var _widgets$name$scorer, _widgets$name2;
+  return (_widgets$name$scorer = (_widgets$name2 = widgets[name]) == null ? void 0 : _widgets$name2.scorer) != null ? _widgets$name$scorer : null;
+};
+registerWidget("categorizer", scoreCategorizer, validateCategorizer);
+registerWidget("cs-program", scoreCSProgram);
+registerWidget("dropdown", scoreDropdown, validateDropdown);
+registerWidget("expression", scoreExpression, validateExpression);
+registerWidget("grapher", scoreGrapher);
+registerWidget("group", scoreGroup, validateGroup);
+registerWidget("iframe", scoreIframe);
+registerWidget("input-number", scoreInputNumber);
+registerWidget("interactive-graph", scoreInteractiveGraph);
+registerWidget("label-image", scoreLabelImage, validateLabelImage);
+registerWidget("matcher", scoreMatcher);
+registerWidget("matrix", scoreMatrix, validateMatrix);
+registerWidget("mock-widget", scoreMockWidget, scoreMockWidget);
+registerWidget("number-line", scoreNumberLine, validateNumberLine);
+registerWidget("numeric-input", scoreNumericInput);
+registerWidget("orderer", scoreOrderer, validateOrderer);
+registerWidget("plotter", scorePlotter, validatePlotter);
+registerWidget("radio", scoreRadio, validateRadio);
+registerWidget("sorter", scoreSorter, validateSorter);
+registerWidget("table", scoreTable, validateTable);
+registerWidget("deprecated-standin", () => scoreNoop(1));
+registerWidget("measurer", () => scoreNoop(1));
+registerWidget("definition", scoreNoop);
+registerWidget("explanation", scoreNoop);
+registerWidget("image", scoreNoop);
+registerWidget("interaction", scoreNoop);
+registerWidget("molecule", scoreNoop);
+registerWidget("passage", scoreNoop);
+registerWidget("passage-ref", scoreNoop);
+registerWidget("passage-ref-target", scoreNoop);
+registerWidget("video", scoreNoop);
+
+const noScore = {
+  type: "points",
+  earned: 0,
+  total: 0,
+  message: null
+};
+
+/**
+ * If a widget says that it is empty once it is graded.
+ * Trying to encapsulate references to the score format.
+ */
+function scoreIsEmpty(score) {
+  // HACK(benkomalo): ugh. this isn't great; the Perseus score objects
+  // overload the type "invalid" for what should probably be three
+  // distinct cases:
+  //  - truly empty or not fully filled out
+  //  - invalid or malformed inputs
+  //  - "almost correct" like inputs where the widget wants to give
+  //  feedback (e.g. a fraction needs to be reduced, or `pi` should
+  //  be used instead of 3.14)
+  //
+  //  Unfortunately the coercion happens all over the place, as these
+  //  Perseus style score objects are created *everywhere* (basically
+  //  in every widget), so it's hard to change now. We assume that
+  //  anything with a "message" is not truly empty, and one of the
+  //  latter two cases for now.
+  return score.type === "invalid" && (!score.message || score.message.length === 0);
+}
+
+/**
+ * Combine two score objects.
+ *
+ * Given two score objects for two different widgets, combine them so that
+ * if one is wrong, the total score is wrong, etc.
+ */
+function combineScores(scoreA, scoreB) {
+  let message;
+  if (scoreA.type === "points" && scoreB.type === "points") {
+    if (scoreA.message && scoreB.message && scoreA.message !== scoreB.message) {
+      // TODO(alpert): Figure out how to combine messages usefully
+      message = null;
+    } else {
+      message = scoreA.message || scoreB.message;
+    }
+    return {
+      type: "points",
+      earned: scoreA.earned + scoreB.earned,
+      total: scoreA.total + scoreB.total,
+      message: message
+    };
+  }
+  if (scoreA.type === "points" && scoreB.type === "invalid") {
+    return scoreB;
+  }
+  if (scoreA.type === "invalid" && scoreB.type === "points") {
+    return scoreA;
+  }
+  if (scoreA.type === "invalid" && scoreB.type === "invalid") {
+    if (scoreA.message && scoreB.message && scoreA.message !== scoreB.message) {
+      // TODO(alpert): Figure out how to combine messages usefully
+      message = null;
+    } else {
+      message = scoreA.message || scoreB.message;
+    }
+    return {
+      type: "invalid",
+      message: message
+    };
+  }
+
+  /**
+   * The above checks cover all combinations of score type, so if we get here
+   * then something is amiss with our inputs.
+   */
+  throw new PerseusError("PerseusScore with unknown type encountered", Errors.InvalidInput, {
+    metadata: {
+      scoreA: JSON.stringify(scoreA),
+      scoreB: JSON.stringify(scoreB)
+    }
+  });
+}
+function flattenScores(widgetScoreMap) {
+  return Object.values(widgetScoreMap).reduce(combineScores, noScore);
+}
+
+/**
+ * score a Perseus item
+ *
+ * @param perseusRenderData - the full answer data, includes the correct answer
+ * @param userInputMap - the user's input for each widget, mapped by ID
+ * @param locale - string locale for math parsing ("de" 1.000,00 vs "en" 1,000.00)
+ */
+function scorePerseusItem(perseusRenderData, userInputMap, locale) {
+  // There seems to be a chance that PerseusRenderer.widgets might include
+  // widget data for widgets that are not in PerseusRenderer.content,
+  // so this checks that the widgets are being used before scoring them
+  const usedWidgetIds = getWidgetIdsFromContent(perseusRenderData.content);
+  const scores = scoreWidgetsFunctional(perseusRenderData.widgets, usedWidgetIds, userInputMap, locale);
+  return flattenScores(scores);
+}
+
+// TODO: combine scorePerseusItem with scoreWidgetsFunctional
+function scoreWidgetsFunctional(widgets,
+// This is a port of old code, I'm not sure why
+// we need widgetIds vs the keys of the widgets object
+widgetIds, userInputMap, locale) {
+  const upgradedWidgets = getUpgradedWidgetOptions(widgets);
+  const gradedWidgetIds = widgetIds.filter(id => {
+    const props = upgradedWidgets[id];
+    const widgetIsGraded = (props == null ? void 0 : props.graded) == null || props.graded;
+    const widgetIsStatic = !!(props != null && props.static);
+    // Ungraded widgets or widgets set to static shouldn't be graded.
+    return widgetIsGraded && !widgetIsStatic;
+  });
+  const widgetScores = {};
+  gradedWidgetIds.forEach(id => {
+    var _validator;
+    const widget = upgradedWidgets[id];
+    if (!widget) {
+      return;
+    }
+    const userInput = userInputMap[id];
+    const validator = getWidgetValidator(widget.type);
+    const scorer = getWidgetScorer(widget.type);
+
+    // We do validation (empty checks) first and then scoring. If
+    // validation fails, it's result is itself a PerseusScore.
+    const score = (_validator = validator == null ? void 0 : validator(userInput, widget.options, locale)) != null ? _validator : scorer == null ? void 0 : scorer(userInput, widget.options, locale);
+    if (score != null) {
+      widgetScores[id] = score;
+    }
+  });
+  return widgetScores;
+}
+
+export { ErrorCodes, KhanAnswerTypes, emptyWidgetsFunctional, flattenScores, getWidgetScorer, getWidgetValidator, inputNumberAnswerTypes, registerWidget, scoreCSProgram, scoreCategorizer, scoreDropdown, scoreExpression, scoreGrapher, scoreIframe, scoreInputNumber, scoreInteractiveGraph, scoreLabelImage, scoreLabelImageMarker, scoreMatcher, scoreMatrix, scoreNumberLine, scoreNumericInput, scoreOrderer, scorePerseusItem, scorePlotter, scoreRadio, scoreSorter, scoreTable, scoreWidgetsFunctional, validateCategorizer, validateDropdown, validateExpression, validateMatrix, validateNumberLine, validateOrderer, validatePlotter, validateRadio, validateSorter, validateTable };
+//# sourceMappingURL=index.js.map