npm - @khanacademy/perseus-score - Versions diffs - 2.3.7 → 3.0.0 - Mend

@khanacademy/perseus-score 2.3.7 → 3.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/es/index.js DELETED Viewed

@@ -1,2274 +0,0 @@
-import _extends from '@babel/runtime/helpers/extends';
-import * as KAS from '@khanacademy/kas';
-import { KhanMath, number, geometry, angles, coefficients } 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;
-  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
-  };
-}
-/**
- * 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) {
-          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, 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
-    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
-  };
-}
-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 === "";
-    });
-  });
-  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