@khanacademy/perseus-score 2.3.6 → 3.0.0

package/dist/index.js

@@ -1,35 +1,8 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var KAS = require('@khanacademy/kas');
-var kmath = require('@khanacademy/kmath');
-var perseusCore = require('@khanacademy/perseus-core');
-var _ = require('underscore');
-var perseusScore = require('@khanacademy/perseus-score');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-function _interopNamespace(e) {
-    if (e && e.__esModule) return e;
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n["default"] = e;
-    return Object.freeze(n);
-}
-
-var KAS__namespace = /*#__PURE__*/_interopNamespace(KAS);
-var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
+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";
@@ -56,135 +29,33 @@ const ErrorCodes = {
   FILL_ALL_CELLS_ERROR
 };
 
-/* eslint-disable no-useless-escape */
 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 = ___default["default"].extend({
+      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 (!___default["default"].isArray(options.forms)) {
+      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 (___default["default"].contains(acceptableForms, "percent")) {
-        acceptableForms = ___default["default"].without(acceptableForms, "percent");
+      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 (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 fractionTransformer = function fractionTransformer(text) {
+        text = text.replace(/\u2212/, "-").replace(/([+-])\s+/g, "$1").replace(/(^\s*)|(\s*$)/gi, "");
         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) {
@@ -204,7 +75,7 @@ const KhanAnswerTypes = {
             }
             denom = parseFloat(mobileDeviceMatch[3]);
           }
-          simplified = simplified && denom > 0 && (options.ratio || denom !== 1) && kmath.KhanMath.getGCD(num, denom) === 1;
+          simplified = simplified && denom > 0 && (options.ratio || denom !== 1) && KhanMath.getGCD(num, denom) === 1;
           return [{
             value: num / denom,
             exact: simplified
@@ -218,23 +89,8 @@ const KhanAnswerTypes = {
         }
         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) {
@@ -242,101 +98,64 @@ const KhanAnswerTypes = {
           }
           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 && kmath.KhanMath.getGCD(num, denom) === 1;
+            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 = ___default["default"].reduce(KhanAnswerTypes.predicate.defaultForms.split(/\s*,\s*/), function (memo, form) {
+            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)) {
@@ -349,7 +168,7 @@ const KhanAnswerTypes = {
               approximatesPi = true;
             }
             if (approximatesPi) {
-              ___default["default"].each(possibilities, function (possibility) {
+              _.each(possibilities, function (possibility) {
                 possibility.piApprox = true;
               });
             }
@@ -359,9 +178,6 @@ const KhanAnswerTypes = {
           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;
           }
@@ -370,12 +186,8 @@ const KhanAnswerTypes = {
           });
           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 = [{
@@ -390,19 +202,14 @@ const KhanAnswerTypes = {
           }
           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
@@ -410,10 +217,8 @@ const KhanAnswerTypes = {
           }
           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();
@@ -422,26 +227,18 @@ const KhanAnswerTypes = {
           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+)$/);
+          const match = text.replace(/\u2212/, "-").replace(/([+-])\s+/g, "$1").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 && kmath.KhanMath.getGCD(num, denom) === 1;
+            const simplified = num < denom && KhanMath.getGCD(num, denom) === 1;
             return [{
               value: sign * (integ + num / denom),
               exact: simplified
@@ -449,28 +246,10 @@ const KhanAnswerTypes = {
           }
           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) {
-          let precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1e10;
-          const normal = function (text) {
+        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 match = text.replace(/\u2212/, "-").replace(/([+-])\s+/g, "$1").match(/^([+-]?(?:\d{1,3}(?:[, ]?\d{3})*\.?|\d{0,3}(?:[, ]?\d{3})*\.(?:\d{3}[, ]?)*\d{1,3}))$/);
             const badLeadingZero = text.match(/^0[0,]*,/);
             if (match && !badLeadingZero) {
               let x = parseFloat(match[1].replace(/[, ]/g, ""));
@@ -480,7 +259,7 @@ const KhanAnswerTypes = {
               return x;
             }
           };
-          const commas = function (text) {
+          const commas = function commas(text) {
             text = text.replace(/([\.,])/g, function (_, c) {
               return c === "." ? "," : ".";
             });
@@ -495,11 +274,7 @@ const KhanAnswerTypes = {
           }];
         }
       };
-
-      // 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 = {
@@ -508,30 +283,18 @@ const KhanAnswerTypes = {
           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 {
@@ -540,9 +303,6 @@ const KhanAnswerTypes = {
                 }
                 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))) {
@@ -553,9 +313,9 @@ const KhanAnswerTypes = {
         });
         if (score.correct === false) {
           let interpretedGuess = false;
-          ___default["default"].each(forms, function (form) {
-            const anyAreNaN = ___default["default"].any(form(guess), function (t) {
-              return t.value != null && !___default["default"].isNaN(t.value);
+          _.each(forms, function (form) {
+            const anyAreNaN = _.any(form(guess), function (t) {
+              return t.value != null && !_.isNaN(t.value);
             });
             if (anyAreNaN) {
               interpretedGuess = true;
@@ -571,83 +331,26 @@ const KhanAnswerTypes = {
       };
     }
   },
-  /*
-   * 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;
-      }, {
-        ...options,
+      }, _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__namespace.parse(solutionString, options);
+      let solution = KAS.parse(solutionString, options);
       if (!solution.parsed) {
-        throw new perseusCore.PerseusError("The provided solution (" + solutionString + ") didn't parse.", perseusCore.Errors.InvalidInput);
+        throw new PerseusError("The provided solution (" + solutionString + ") didn't parse.", Errors.InvalidInput);
       } else if (options.simplified && !solution.expr.isSimplified()) {
-        throw new perseusCore.PerseusError("The provided solution (" + solutionString + ") isn't fully expanded and simplified.", perseusCore.Errors.InvalidInput);
+        throw new PerseusError("The provided solution (" + solutionString + ") isn't fully expanded and simplified.", Errors.InvalidInput);
       } else {
         solution = solution.expr;
       }
@@ -660,80 +363,37 @@ const KhanAnswerTypes = {
           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__namespace.parse(guess, options);
-
-        // An unsuccessful parse doesn't count as wrong
+        const answer = KAS.parse(guess, options);
         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__namespace.compare(answer.expr, 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__namespace.parse(guess.replace(/[xX]/g, "*"), options);
+          const answerX = KAS.parse(guess.replace(/[xX]/g, "*"), options);
           if (answerX.parsed) {
-            const resultX = KAS__namespace.compare(answerX.expr, solution, options);
+            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.";
             }
           }
@@ -759,28 +419,18 @@ function scoreCategorizer(userInput, rubric) {
   };
 }
 
-/**
- * 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: perseusScore.ErrorCodes.INVALID_SELECTION_ERROR
+      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",
@@ -813,10 +463,6 @@ function scoreDropdown(userInput, rubric) {
   };
 }
 
-/**
- * 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 {
@@ -827,63 +473,25 @@ function validateDropdown(userInput) {
   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 = ___default["default"].clone(rubric);
-  ___default["default"].extend(options, {
-    decimal_separator: perseusCore.getDecimalSeparator(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__namespace.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.
+    const expression = KAS.parse(answer.value, rubric);
     if (!expression.parsed) {
-      /* c8 ignore next */
-      throw new perseusCore.PerseusError("Unable to parse solution answer for expression", perseusCore.Errors.InvalidInput, {
+      throw new PerseusError("Unable to parse solution answer for expression", Errors.InvalidInput, {
         metadata: {
           rubric: JSON.stringify(rubric)
         }
       });
     }
-    return KhanAnswerTypes.expression.createValidatorFunctional(expression.expr, ___default["default"]({}).extend(options, {
+    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;
@@ -894,34 +502,18 @@ function scoreExpression(userInput, rubric, locale) {
       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,
@@ -929,14 +521,11 @@ function scoreExpression(userInput, rubric, locale) {
       };
     }
     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,
@@ -949,9 +538,6 @@ function scoreExpression(userInput, rubric, locale) {
       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,
@@ -960,14 +546,6 @@ function scoreExpression(userInput, rubric, locale) {
   };
 }
 
-/**
- * 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 {
@@ -983,13 +561,13 @@ function getCoefficientsByType(data) {
     return undefined;
   }
   if (data.type === "exponential" || data.type === "logarithm") {
-    const grader = perseusCore.GrapherUtil.functionForType(data.type);
+    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 = perseusCore.GrapherUtil.functionForType(data.type);
+    const grader = GrapherUtil.functionForType(data.type);
     return grader.getCoefficients(data.coords);
   } else {
-    throw new perseusCore.PerseusError("Invalid grapher type", perseusCore.Errors.InvalidInput);
+    throw new PerseusError("Invalid grapher type", Errors.InvalidInput);
   }
 }
 function scoreGrapher(userInput, rubric) {
@@ -1001,17 +579,13 @@ function scoreGrapher(userInput, rubric) {
       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 = perseusCore.GrapherUtil.functionForType(userInput.type);
+  const grader = GrapherUtil.functionForType(userInput.type);
   const guessCoeffs = getCoefficientsByType(userInput);
   const correctCoeffs = getCoefficientsByType(rubric.correct);
   if (guessCoeffs == null || correctCoeffs == null) {
@@ -1036,10 +610,7 @@ function scoreGrapher(userInput, rubric) {
   };
 }
 
-// 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",
@@ -1067,16 +638,15 @@ const {
   canonicalSineCoefficients,
   similar,
   clockwise
-} = kmath.geometry;
+} = geometry;
 const {
   getClockwiseAngle
-} = kmath.angles;
+} = angles;
 const {
   getSinusoidCoefficients,
   getQuadraticCoefficients
-} = kmath.coefficients;
+} = coefficients;
 function scoreInteractiveGraph(userInput, rubric) {
-  // None-type graphs are not graded
   if (userInput.type === "none" && rubric.correct.type === "none") {
     return {
       type: "points",
@@ -1085,22 +655,11 @@ function scoreInteractiveGraph(userInput, rubric) {
       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);
+  const hasValue = Boolean(userInput.coords || 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",
@@ -1121,10 +680,9 @@ function scoreInteractiveGraph(userInput, rubric) {
         };
       }
     } 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 (perseusCore.approximateDeepEqual(guessCoeffs, correctCoeffs)) {
+      if (approximateDeepEqual(guessCoeffs, correctCoeffs)) {
         return {
           type: "points",
           earned: 1,
@@ -1137,8 +695,7 @@ function scoreInteractiveGraph(userInput, rubric) {
       const correctCoeffs = getSinusoidCoefficients(rubric.correct.coords);
       const canonicalGuessCoeffs = canonicalSineCoefficients(guessCoeffs);
       const canonicalCorrectCoeffs = canonicalSineCoefficients(correctCoeffs);
-      // If the canonical coefficients match, it's correct.
-      if (perseusCore.approximateDeepEqual(canonicalGuessCoeffs, canonicalCorrectCoeffs)) {
+      if (approximateDeepEqual(canonicalGuessCoeffs, canonicalCorrectCoeffs)) {
         return {
           type: "points",
           earned: 1,
@@ -1147,7 +704,7 @@ function scoreInteractiveGraph(userInput, rubric) {
         };
       }
     } else if (userInput.type === "circle" && rubric.correct.type === "circle") {
-      if (perseusCore.approximateDeepEqual(userInput.center, rubric.correct.center) && perseusCore.approximateEqual(userInput.radius, rubric.correct.radius)) {
+      if (approximateDeepEqual(userInput.center, rubric.correct.center) && approximateEqual(userInput.radius, rubric.correct.radius)) {
         return {
           type: "points",
           earned: 1,
@@ -1162,14 +719,9 @@ function scoreInteractiveGraph(userInput, rubric) {
       }
       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?.sort();
-      // @ts-expect-error - TS2339 - Property 'sort' does not exist on type 'readonly Coord[]'.
+      guess == null || guess.sort();
       correct.sort();
-      if (perseusCore.approximateDeepEqual(guess, correct)) {
+      if (approximateDeepEqual(guess, correct)) {
         return {
           type: "points",
           earned: 1,
@@ -1184,14 +736,13 @@ function scoreInteractiveGraph(userInput, rubric) {
       if (rubric.correct.match === "similar") {
         match = similar(guess, correct, Number.POSITIVE_INFINITY);
       } else if (rubric.correct.match === "congruent") {
-        match = similar(guess, correct, kmath.number.DEFAULT_TOLERANCE);
+        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 = perseusCore.approximateDeepEqual(guess, correct);
+        match = approximateDeepEqual(guess, correct);
       }
       if (match) {
         return {
@@ -1202,11 +753,11 @@ function scoreInteractiveGraph(userInput, rubric) {
         };
       }
     } else if (userInput.type === "segment" && rubric.correct.type === "segment" && userInput.coords != null) {
-      let guess = perseusCore.deepClone(userInput.coords);
-      let correct = perseusCore.deepClone(rubric.correct.coords);
-      guess = ___default["default"].invoke(guess, "sort").sort();
-      correct = ___default["default"].invoke(correct, "sort").sort();
-      if (perseusCore.approximateDeepEqual(guess, correct)) {
+      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,
@@ -1217,7 +768,7 @@ function scoreInteractiveGraph(userInput, rubric) {
     } else if (userInput.type === "ray" && rubric.correct.type === "ray" && userInput.coords != null) {
       const guess = userInput.coords;
       const correct = rubric.correct.coords;
-      if (perseusCore.approximateDeepEqual(guess[0], correct[0]) && collinear(correct[0], correct[1], guess[1])) {
+      if (approximateDeepEqual(guess[0], correct[0]) && collinear(correct[0], correct[1], guess[1])) {
         return {
           type: "points",
           earned: 1,
@@ -1229,38 +780,27 @@ function scoreInteractiveGraph(userInput, rubric) {
       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 = ___default["default"].map([guess, correct], function (coords) {
+        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 = perseusCore.approximateEqual(...angles);
+        match = approximateEqual(...angles);
       } else {
-        /* exact */
-        match = perseusCore.approximateDeepEqual(guess[1], correct[1]) && collinear(correct[1], correct[0], guess[0]) && collinear(correct[1], correct[2], guess[2]);
+        match = approximateDeepEqual(guess[1], correct[1]) && collinear(correct[1], correct[0], guess[0]) && collinear(correct[1], correct[2], guess[2]);
       }
       if (match) {
         return {
@@ -1272,11 +812,7 @@ function scoreInteractiveGraph(userInput, rubric) {
       }
     }
   }
-
-  // The input wasn't correct, so check if it's a blank input or if it's
-  // actually just wrong
-  if (!hasValue || ___default["default"].isEqual(userInput, rubric.graph)) {
-    // We're where we started.
+  if (!hasValue || _.isEqual(userInput, rubric.graph)) {
     return {
       type: "invalid",
       message: null
@@ -1290,8 +826,6 @@ function scoreInteractiveGraph(userInput, rubric) {
   };
 }
 
-// Question state for marker as result of user selected answers.
-
 function scoreLabelImageMarker(userInput, rubric) {
   const score = {
     hasAnswers: false,
@@ -1302,11 +836,9 @@ function scoreLabelImageMarker(userInput, rubric) {
   }
   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;
@@ -1321,8 +853,6 @@ function scoreLabelImage(userInput, rubric) {
   }
   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
@@ -1330,7 +860,7 @@ function scoreLabelImage(userInput, rubric) {
 }
 
 function scoreMatcher(userInput, rubric) {
-  const correct = ___default["default"].isEqual(userInput.left, rubric.left) && ___default["default"].isEqual(userInput.right, rubric.right);
+  const correct = _.isEqual(userInput.left, rubric.left) && _.isEqual(userInput.right, rubric.right);
   return {
     type: "points",
     earned: correct ? 1 : 0,
@@ -1342,23 +872,20 @@ function scoreMatcher(userInput, rubric) {
 function scoreMatrix(userInput, rubric) {
   const solution = rubric.answers;
   const supplied = userInput.answers;
-  const solutionSize = perseusCore.getMatrixSize(solution);
-  const suppliedSize = perseusCore.getMatrixSize(supplied);
+  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;
-  ___default["default"](suppliedSize[0]).times(row => {
-    ___default["default"](suppliedSize[1]).times(col => {
+  _(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], {
+        const validator = createValidator(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) {
@@ -1383,17 +910,9 @@ function scoreMatrix(userInput, rubric) {
   };
 }
 
-/**
- * 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 = perseusCore.getMatrixSize(supplied);
+  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) {
@@ -1412,7 +931,7 @@ function scoreNumberLine(userInput, rubric) {
   const start = rubric.initialX != null ? rubric.initialX : range[0];
   const startRel = rubric.isInequality ? "ge" : "eq";
   const correctRel = rubric.correctRel || "eq";
-  const correctPos = kmath.number.equal(userInput.numLinePosition, rubric.correctX || 0);
+  const correctPos = number.equal(userInput.numLinePosition, rubric.correctX || 0);
   if (correctPos && correctRel === userInput.rel) {
     return {
       type: "points",
@@ -1422,7 +941,6 @@ function scoreNumberLine(userInput, rubric) {
     };
   }
   if (userInput.numLinePosition === start && userInput.rel === startRel) {
-    // We're where we started.
     return {
       type: "invalid",
       message: null
@@ -1436,17 +954,9 @@ function scoreNumberLine(userInput, rubric) {
   };
 }
 
-/**
- * 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",
@@ -1456,18 +966,6 @@ function validateNumberLine(userInput) {
   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++) {
@@ -1481,22 +979,10 @@ function findEndpoint(tex, currentIndex) {
       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,
@@ -1504,8 +990,6 @@ function parseNextExpression(tex, currentIndex, handler) {
     };
   }
   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);
@@ -1534,62 +1018,27 @@ 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 (exp1, exp2) {
+  const handler = function handler(exp1, exp2) {
     return exp1 + "/" + exp2;
   };
   const texWithoutFracs = walkTex(tex, handler);
@@ -1621,54 +1070,26 @@ const answerFormButtons = [{
   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) {
-  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");
+  var _matchedAnswer$messag;
+  const defaultAnswerForms = answerFormButtons.map(e => e["value"]).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 ?? [])];
-
-    // 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.
+    const validatorForms = [...((_answer$answerForms = answer.answerForms) != null ? _answer$answerForms : [])];
     if (!answer.strict || validatorForms.length === 0) {
       validatorForms.push(...defaultAnswerForms);
     }
@@ -1676,18 +1097,12 @@ function scoreNumericInput(userInput, rubric) {
       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) {
@@ -1699,21 +1114,16 @@ function scoreNumericInput(userInput, rubric) {
   const matchedAnswer = rubric.answers.map(answer => {
     const validateFn = createValidator(answer);
     const score = validateFn(maybeParsePercentInput(localValue, normalizedAnswerExpected));
-    return {
-      ...answer,
+    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?.status === "correct" ? matchedAnswer.score : {
-    empty: matchedAnswer?.status === "ungraded",
-    correct: matchedAnswer?.status === "correct",
-    message: matchedAnswer?.message ?? null,
-    guess: localValue
-  };
+  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",
@@ -1729,7 +1139,7 @@ function scoreNumericInput(userInput, rubric) {
 }
 
 function scoreOrderer(userInput, rubric) {
-  const correct = ___default["default"].isEqual(userInput.current, rubric.correctOptions.map(option => option.content));
+  const correct = _.isEqual(userInput.current, rubric.correctOptions.map(option => option.content));
   return {
     type: "points",
     earned: correct ? 1 : 0,
@@ -1738,12 +1148,6 @@ function scoreOrderer(userInput, rubric) {
   };
 }
 
-/**
- * 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 {
@@ -1757,20 +1161,14 @@ function validateOrderer(userInput) {
 function scorePlotter(userInput, rubric) {
   return {
     type: "points",
-    earned: perseusCore.approximateDeepEqual(userInput, rubric.correct) ? 1 : 0,
+    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 (perseusCore.approximateDeepEqual(userInput, validationData.starting)) {
+  if (approximateDeepEqual(userInput, validationData.starting)) {
     return {
       type: "invalid",
       message: null
@@ -1791,7 +1189,6 @@ function scoreRadio(userInput, rubric) {
       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) {
@@ -1819,14 +1216,6 @@ function scoreRadio(userInput, rubric) {
   };
 }
 
-/**
- * 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);
@@ -1841,7 +1230,7 @@ function validateRadio(userInput) {
 }
 
 function scoreSorter(userInput, rubric) {
-  const correct = perseusCore.approximateDeepEqual(userInput.options, rubric.correct);
+  const correct = approximateDeepEqual(userInput.options, rubric.correct);
   return {
     type: "points",
     earned: correct ? 1 : 0,
@@ -1850,20 +1239,7 @@ function scoreSorter(userInput, rubric) {
   };
 }
 
-/**
- * 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",
@@ -1873,15 +1249,8 @@ function validateSorter(userInput) {
   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 (table) {
+const filterNonEmpty = function filterNonEmpty(table) {
   return table.filter(function (row) {
-    // Return only rows that are non-empty.
     return row.some(cell => cell);
   });
 };
@@ -1986,10 +1355,6 @@ 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,
@@ -1997,9 +1362,6 @@ function scoreInputNumber(userInput, rubric) {
     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) {
@@ -2016,16 +1378,7 @@ function scoreInputNumber(userInput, rubric) {
   };
 }
 
-/**
- * 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() {
-  let points = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+function scoreNoop(points = 0) {
   return {
     type: "points",
     earned: points,
@@ -2034,32 +1387,21 @@ function scoreNoop() {
   };
 }
 
-// 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) {
+function emptyWidgetsFunctional(widgets, 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?.(userInput, validationData, locale);
+    const score = validator == null ? void 0 : validator(userInput, validationData, locale);
     if (score) {
       return scoreIsEmpty(score);
     }
@@ -2085,7 +1427,6 @@ function validateLabelImage(userInput) {
       numAnswered++;
     }
   }
-  // We expect all question markers to be answered before grading.
   if (numAnswered !== userInput.markers.length) {
     return {
       type: "invalid",
@@ -2126,10 +1467,12 @@ function registerWidget(type, scorer, validator) {
   };
 }
 const getWidgetValidator = name => {
-  return widgets[name]?.validator ?? null;
+  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 => {
-  return widgets[name]?.scorer ?? null;
+  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);
@@ -2169,40 +1512,13 @@ const noScore = {
   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;
@@ -2222,7 +1538,6 @@ function combineScores(scoreA, scoreB) {
   }
   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;
@@ -2232,12 +1547,7 @@ function combineScores(scoreA, scoreB) {
       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 perseusCore.PerseusError("PerseusScore with unknown type encountered", perseusCore.Errors.InvalidInput, {
+  throw new PerseusError("PerseusScore with unknown type encountered", Errors.InvalidInput, {
     metadata: {
       scoreA: JSON.stringify(scoreA),
       scoreB: JSON.stringify(scoreB)
@@ -2247,38 +1557,22 @@ function combineScores(scoreA, 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 = perseusCore.getWidgetIdsFromContent(perseusRenderData.content);
+  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 = perseusCore.getUpgradedWidgetOptions(widgets);
+function scoreWidgetsFunctional(widgets, widgetIds, userInputMap, locale) {
+  const upgradedWidgets = getUpgradedWidgetOptions(widgets);
   const gradedWidgetIds = widgetIds.filter(id => {
     const props = upgradedWidgets[id];
-    const widgetIsGraded = props?.graded == null || props.graded;
-    const widgetIsStatic = !!props?.static;
-    // Ungraded widgets or widgets set to static shouldn't be graded.
+    const widgetIsGraded = (props == null ? void 0 : props.graded) == null || props.graded;
+    const widgetIsStatic = !!(props != null && props.static);
     return widgetIsGraded && !widgetIsStatic;
   });
   const widgetScores = {};
   gradedWidgetIds.forEach(id => {
+    var _validator;
     const widget = upgradedWidgets[id];
     if (!widget) {
       return;
@@ -2286,10 +1580,7 @@ widgetIds, userInputMap, locale) {
     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?.(userInput, widget.options, locale) ?? scorer?.(userInput, widget.options, locale);
+    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;
     }
@@ -2297,43 +1588,5 @@ widgetIds, userInputMap, locale) {
   return widgetScores;
 }
 
-exports.ErrorCodes = ErrorCodes;
-exports.KhanAnswerTypes = KhanAnswerTypes;
-exports.emptyWidgetsFunctional = emptyWidgetsFunctional;
-exports.flattenScores = flattenScores;
-exports.getWidgetScorer = getWidgetScorer;
-exports.getWidgetValidator = getWidgetValidator;
-exports.inputNumberAnswerTypes = inputNumberAnswerTypes;
-exports.registerWidget = registerWidget;
-exports.scoreCSProgram = scoreCSProgram;
-exports.scoreCategorizer = scoreCategorizer;
-exports.scoreDropdown = scoreDropdown;
-exports.scoreExpression = scoreExpression;
-exports.scoreGrapher = scoreGrapher;
-exports.scoreIframe = scoreIframe;
-exports.scoreInputNumber = scoreInputNumber;
-exports.scoreInteractiveGraph = scoreInteractiveGraph;
-exports.scoreLabelImage = scoreLabelImage;
-exports.scoreLabelImageMarker = scoreLabelImageMarker;
-exports.scoreMatcher = scoreMatcher;
-exports.scoreMatrix = scoreMatrix;
-exports.scoreNumberLine = scoreNumberLine;
-exports.scoreNumericInput = scoreNumericInput;
-exports.scoreOrderer = scoreOrderer;
-exports.scorePerseusItem = scorePerseusItem;
-exports.scorePlotter = scorePlotter;
-exports.scoreRadio = scoreRadio;
-exports.scoreSorter = scoreSorter;
-exports.scoreTable = scoreTable;
-exports.scoreWidgetsFunctional = scoreWidgetsFunctional;
-exports.validateCategorizer = validateCategorizer;
-exports.validateDropdown = validateDropdown;
-exports.validateExpression = validateExpression;
-exports.validateMatrix = validateMatrix;
-exports.validateNumberLine = validateNumberLine;
-exports.validateOrderer = validateOrderer;
-exports.validatePlotter = validatePlotter;
-exports.validateRadio = validateRadio;
-exports.validateSorter = validateSorter;
-exports.validateTable = validateTable;
+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