@khanacademy/perseus-score 4.0.0 → 4.0.2

package/dist/index.js

@@ -30,2278 +30,87 @@ function _interopNamespaceCompat(e) {
 var KAS__namespace = /*#__PURE__*/_interopNamespaceCompat(KAS);
 var ___default = /*#__PURE__*/_interopDefaultCompat(_);
 
-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 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};
 
-/* eslint-disable no-useless-escape */
-const MAXERROR_EPSILON = Math.pow(2, -42);
+const MAXERROR_EPSILON=Math.pow(2,-42);const KhanAnswerTypes={predicate:{defaultForms:"integer, proper, improper, mixed, decimal",createValidatorFunctional:function(predicate,options){options=___default.default.extend({simplify:"required",ratio:false,forms:KhanAnswerTypes.predicate.defaultForms},options);let acceptableForms;if(!___default.default.isArray(options.forms)){acceptableForms=options.forms.split(/\s*,\s*/);}else {acceptableForms=options.forms;}if(options.inexact===undefined){options.maxError=0;}options.maxError=+options.maxError+MAXERROR_EPSILON;if(___default.default.contains(acceptableForms,"percent")){acceptableForms=___default.default.without(acceptableForms,"percent");acceptableForms.push("percent");}const fractionTransformer=function(text){text=text.replace(/\u2212/,"-").replace(/([+-])\s+/g,"$1").replace(/(^\s*)|(\s*$)/gi,"");const match=text.match(/^([+-]?\d+)\s*\/\s*([+-]?\d+)$/);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)&&kmath.KhanMath.getGCD(num,denom)===1;return [{value:num/denom,exact:simplified}]}if(!isNaN(parsedInt)&&""+parsedInt===text){return [{value:parsedInt,exact:true}]}return []};const forms={integer:function(text){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 []},proper:function(text){const transformed=fractionTransformer(text);return transformed.flatMap(o=>{if(Math.abs(o.value)<1){return [o]}return []})},improper:function(text){const fractionExists=text.includes("/")||text.match(/\\(d?frac)/);if(!fractionExists){return []}const transformed=fractionTransformer(text);return transformed.flatMap(o=>{if(Math.abs(o.value)>=1){return [o]}return []})},pi:function(text){let match;let possibilities=[];text=text.replace(/\u2212/,"-");if(match=text.match(/^([+-]?)\s*(\\?pi|p|\u03c0|\\?tau|t|\u03c4|pau)$/i)){possibilities=[{value:parseFloat(match[1]+"1"),exact:true}];}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]);}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;possibilities=[{value:sign*(integ+num/denom),exact:simplified}];}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]);}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]);}else if(text==="0"){possibilities=[{value:0,exact:true}];}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){return memo.concat(forms[form](text))},[]);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)<.01){approximatesPi=true;}}else if(text.match(/\/\s*7/)){approximatesPi=true;}if(approximatesPi){___default.default.each(possibilities,function(possibility){possibility.piApprox=true;});}return possibilities}let multiplier=Math.PI;if(text.match(/\\?tau|t|\u03c4/)){multiplier=Math.PI*2;}if(text.match(/pau/)){multiplier=Math.PI*1.5;}possibilities.forEach(possibility=>{possibility.value*=multiplier;});return possibilities},coefficient:function(text){let possibilities=[];text=text.replace(/\u2212/,"-");if(text===""){possibilities=[{value:1,exact:true}];}else if(text==="-"){possibilities=[{value:-1,exact:true}];}return possibilities},log:function(text){let match;let possibilities=[];text=text.replace(/\u2212/,"-");text=text.replace(/[ \(\)]/g,"");if(match=text.match(/^log\s*(\S+)\s*$/i)){possibilities=forms.decimal(match[1]);}else if(text==="0"){possibilities=[{value:0,exact:true}];}return possibilities},percent:function(text){text=String(text).trim();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;t.value=t.value/100;});return transformed},mixed:function(text){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;return [{value:sign*(integ+num/denom),exact:simplified}]}return []},decimal:function(text,precision=1e10){const normal=function(text){text=String(text).trim();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,""));if(options.inexact===undefined){x=Math.round(x*precision)/precision;}return x}};const commas=function(text){text=text.replace(/([\.,])/g,function(_,c){return c==="."?",":"."});return normal(text)};return [{value:normal(text),exact:true},{value:commas(text),exact:true}]}};return function(guess){const fallback=options.fallback!=null?""+options.fallback:"";guess=String(guess).trim()||fallback;const score={empty:guess==="",correct:false,message:null,guess:guess};const findCorrectAnswer=()=>{for(const form of acceptableForms){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(predicate(val,options.maxError)){if(exact||options.simplify==="optional"){score.correct=true;score.message=options.message||null;score.empty=false;}else if(form==="percent"){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;}return false}if(piApprox&&predicate(val,Math.abs(val*.001))){score.empty=true;score.message=ErrorCodes.APPROXIMATED_PI_ERROR;}}}};findCorrectAnswer();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)});if(anyAreNaN){interpretedGuess=true;}});if(!interpretedGuess){score.empty=true;score.message=ErrorCodes.EXTRA_SYMBOLS_ERROR;return score}}return score}}},number:{convertToPredicate:function(correctAnswer,options){const correctFloat=parseFloat(correctAnswer);return [function(guess,maxError){return Math.abs(guess-correctFloat)<maxError},{...options,type:"predicate"}]},createValidatorFunctional:function(correctAnswer,options){return KhanAnswerTypes.predicate.createValidatorFunctional(...KhanAnswerTypes.number.convertToPredicate(correctAnswer,options))}},expression:{parseSolution:function(solutionString,options){let solution=KAS__namespace.parse(solutionString,options);if(!solution.parsed){throw new perseusCore.PerseusError("The provided solution ("+solutionString+") didn't parse.",perseusCore.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)}else {solution=solution.expr;}return solution},createValidatorFunctional:function(solution,options){return function(guess){const score={empty:false,correct:false,message:null,guess:guess,ungraded:false};if(!guess){score.empty=true;return score}const answer=KAS__namespace.parse(guess,options);if(!answer.parsed){score.empty=true;return score}if(typeof solution==="string"){solution=KhanAnswerTypes.expression.parseSolution(solution,options);}const result=KAS__namespace.compare(answer.expr,solution,options);if(result.equal){score.correct=true;}else if(result.wrongVariableNames||result.wrongVariableCase){score.ungraded=true;score.message=result.wrongVariableCase?ErrorCodes.WRONG_CASE_ERROR:ErrorCodes.WRONG_LETTER_ERROR;score.suppressAlmostThere=true;}else if(result.message){score.message=result.message;}else {const answerX=KAS__namespace.parse(guess.replace(/[xX]/g,"*"),options);if(answerX.parsed){const resultX=KAS__namespace.compare(answerX.expr,solution,options);if(resultX.equal){score.ungraded=true;score.message=ErrorCodes.MULTIPLICATION_SIGN_ERROR;}else if(resultX.message){score.message=resultX.message+" Also, I'm a computer. I only understand "+"multiplication if you use an "+"asterisk (*) as the multiplication "+"sign.";}}}return score}}}};
 
-// 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.
+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}}
 
-/**
- * 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({
-        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)) {
-        acceptableForms = options.forms.split(/\s*,\s*/);
-      } else {
-        acceptableForms = options.forms;
-      }
+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}
 
-      // 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;
+function scoreCSProgram(userInput){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!"}}
 
-      // 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");
-        acceptableForms.push("percent");
-      }
+function scoreDropdown(userInput,rubric){const correct=rubric.choices[userInput.value-1].correct;return {type:"points",earned:correct?1:0,total:1,message:null}}
 
-      // 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, "");
+function validateDropdown(userInput){if(userInput.value===0){return {type:"invalid",message:null}}return null}
 
-        // 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) && kmath.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 && kmath.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) {
-              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) {
-              ___default.default.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 && kmath.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) {
-          let precision = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1e10;
-          const normal = function (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 (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;
-          ___default.default.each(forms, function (form) {
-            const anyAreNaN = ___default.default.any(form(guess), function (t) {
-              return t.value != null && !___default.default.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;
-      }, {
-        ...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);
-      if (!solution.parsed) {
-        throw new perseusCore.PerseusError("The provided solution (" + solutionString + ") didn't parse.", perseusCore.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);
-      } 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__namespace.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__namespace.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);
-          if (answerX.parsed) {
-            const resultX = KAS__namespace.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 = ___default.default.clone(rubric);
-  ___default.default.extend(options, {
-    decimal_separator: perseusCore.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.
-    if (!expression.parsed) {
-      /* c8 ignore next */
-      throw new perseusCore.PerseusError("Unable to parse solution answer for expression", perseusCore.Errors.InvalidInput, {
-        metadata: {
-          rubric: JSON.stringify(rubric)
-        }
-      });
-    }
-    return KhanAnswerTypes.expression.createValidatorFunctional(expression.expr, ___default.default({}).extend(options, {
-      simplify: answer.simplify,
-      form: answer.form
-    }));
-  };
-
-  // Find the first answer form that matches the user's input and that
-  // is considered correct. Also, track whether the input is
-  // considered "empty" for all answer forms, and keep the validation
-  // result for the first answer form for which the user's input was
-  // considered "ungraded".
-  // (Terminology reminder: the answer forms are provided by the
-  // assessment items; they are not the user's input. Each one might
-  // represent a correct answer, an incorrect one (if the exercise
-  // creator has predicted certain common wrong answers and wants to
-  // provide guidance via a message), or an ungraded one (same idea,
-  // but without giving the user an incorrect mark for the question).
-  let matchingAnswerForm;
-  let matchMessage;
-  let allEmpty = true;
-  let firstUngradedResult;
-  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-  for (const answerForm of rubric.answerForms || []) {
-    const validator = createValidator(answerForm);
-    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-    if (!validator) {
-      continue;
-    }
-    const result = validator(userInput);
-
-    // Short-circuit as soon as the user's input matches some answer
-    // (independently of whether the answer is correct)
-    if (result.correct) {
-      matchingAnswerForm = answerForm;
-      matchMessage = result.message || "";
-      break;
-    }
-    allEmpty = allEmpty && result.empty;
-    // If this answer form is correct and the user's input is considered
-    // "ungraded" for it, we'll want to keep the evaluation result for
-    // later. If the user's input doesn't match any answer forms, we'll
-    // show the message from this validation.
-    if (answerForm.considered === "correct" && result.ungraded && !firstUngradedResult) {
-      firstUngradedResult = result;
-    }
-  }
-
-  // Now check to see if we matched any answer form at all, and if
-  // we did, whether it's considered correct, incorrect, or ungraded
-  if (!matchingAnswerForm) {
-    if (firstUngradedResult) {
-      // While we didn't directly match with any answer form, we
-      // did at some point get an "ungraded" validation result,
-      // which might indicate e.g. a mismatch in variable casing.
-      // We'll return "invalid", which will let the user try again
-      // with no penalty, and the hopefully helpful validation
-      // message.
-      return {
-        type: "invalid",
-        message: firstUngradedResult.message,
-        suppressAlmostThere: firstUngradedResult.suppressAlmostThere
-      };
-    }
-    if (allEmpty) {
-      // If everything graded as empty, it's invalid.
-      return {
-        type: "invalid",
-        message: null
-      };
-    }
-    // We fell through all the possibilities and we're not empty,
-    // so the answer is considered incorrect.
-    return {
-      type: "points",
-      earned: 0,
-      total: 1
-    };
-  }
-  if (matchingAnswerForm.considered === "ungraded") {
-    return {
-      type: "invalid",
-      message: matchMessage
-    };
-  }
-  // We matched a graded answer form, so we can now tell the user
-  // whether their input was correct or incorrect, and hand out
-  // points accordingly
-  return {
-    type: "points",
-    earned: matchingAnswerForm.considered === "correct" ? 1 : 0,
-    total: 1,
-    message: matchMessage
-  };
-}
-
-/**
- * Checks user input from the expression widget to see if it is scorable.
- *
- * Note: Most of the expression widget's validation requires the Rubric because
- * of its use of KhanAnswerTypes as a core part of scoring.
- *
- * @see `scoreExpression()` for more details.
- */
-function validateExpression(userInput) {
-  if (userInput === "") {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
-
-function getCoefficientsByType(data) {
-  if (data.coords == null) {
-    return undefined;
-  }
-  if (data.type === "exponential" || data.type === "logarithm") {
-    const grader = perseusCore.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);
-    return grader.getCoefficients(data.coords);
-  } else {
-    throw new perseusCore.PerseusError("Invalid grapher type", perseusCore.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 = perseusCore.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
-} = kmath.geometry;
-const {
-  getClockwiseAngle
-} = kmath.angles;
-const {
-  getSinusoidCoefficients,
-  getQuadraticCoefficients
-} = kmath.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 (perseusCore.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 (perseusCore.approximateDeepEqual(canonicalGuessCoeffs, canonicalCorrectCoeffs)) {
-        return {
-          type: "points",
-          earned: 1,
-          total: 1,
-          message: null
-        };
-      }
-    } else if (userInput.type === "circle" && rubric.correct.type === "circle") {
-      if (perseusCore.approximateDeepEqual(userInput.center, rubric.correct.center) && perseusCore.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?.sort();
-      // @ts-expect-error - TS2339 - Property 'sort' does not exist on type 'readonly Coord[]'.
-      correct.sort();
-      if (perseusCore.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, kmath.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);
-      }
-      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 = 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)) {
-        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 (perseusCore.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 = ___default.default.map([guess, correct], function (coords) {
-          // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-          if (!coords) {
-            return false;
-          }
-          const angle = getClockwiseAngle(coords, allowReflexAngles);
-          return angle;
-        });
-        // @ts-expect-error - TS2556 - A spread argument must either have a tuple type or be passed to a rest parameter.
-        match = perseusCore.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]);
-      }
-      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 || ___default.default.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 = ___default.default.isEqual(userInput.left, rubric.left) && ___default.default.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 = perseusCore.getMatrixSize(solution);
-  const suppliedSize = perseusCore.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 => {
-      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 = perseusCore.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 = kmath.number.equal(userInput.numLinePosition,
-  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-  rubric.correctX || 0);
-  if (correctPos && correctRel === userInput.rel) {
-    return {
-      type: "points",
-      earned: 1,
-      total: 1,
-      message: null
-    };
-  }
-  if (userInput.numLinePosition === start && userInput.rel === startRel) {
-    // We're where we started.
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return {
-    type: "points",
-    earned: 0,
-    total: 1,
-    message: null
-  };
-}
-
-/**
- * Checks user input is within the allowed range and not the same as the initial
- * state.
- * @param userInput
- * @see 'scoreNumberLine' for the scoring logic.
- */
-function validateNumberLine(userInput) {
-  const divisionRange = userInput.divisionRange;
-  const outsideAllowedRange = userInput.numDivisions > divisionRange[1] || userInput.numDivisions < divisionRange[0];
-
-  // TODO: I don't think isTickCrtl is a thing anymore
-  if (userInput.isTickCrtl && outsideAllowedRange) {
-    return {
-      type: "invalid",
-      message: "Number of divisions is outside the allowed range."
-    };
-  }
-  return null;
-}
-
-/*
- * In this file, an `expression` is some portion of valid TeX enclosed in
- * curly brackets.
- */
-
-/*
- * Find the index at which an expression ends, i.e., has an unmatched
- * closing curly bracket. This method assumes that we start with a non-open
- * bracket character and end when we've seen more left than right brackets
- * (rather than assuming that we start with a bracket character and wait for
- * bracket equality).
- */
-function findEndpoint(tex, currentIndex) {
-  let bracketDepth = 0;
-  for (let i = currentIndex, len = tex.length; i < len; i++) {
-    const c = tex[i];
-    if (c === "{") {
-      bracketDepth++;
-    } else if (c === "}") {
-      bracketDepth--;
-    }
-    if (bracketDepth < 0) {
-      return i;
-    }
-  }
-  // If we never see unbalanced curly brackets, default to the
-  // entire string
-  return tex.length;
-}
-
-/*
- * Parses an individual set of curly brackets into TeX.
- */
-function parseNextExpression(tex, currentIndex, handler) {
-  // Find the first '{' and grab subsequent TeX
-  // Ex) tex: '{3}{7}', and we want the '3'
-  const openBracketIndex = tex.indexOf("{", currentIndex);
-
-  // If there is no open bracket, set the endpoint to the end of the string
-  // and the expression to an empty string. This helps ensure we don't
-  // get stuck in an infinite loop when users handtype TeX.
-  if (openBracketIndex === -1) {
-    return {
-      endpoint: tex.length,
-      expression: ""
-    };
-  }
-  const nextExpIndex = openBracketIndex + 1;
-
-  // Truncate to only contain remaining TeX
-  const endpoint = findEndpoint(tex, nextExpIndex);
-  const expressionTeX = tex.substring(nextExpIndex, endpoint);
-  const parsedExp = walkTex(expressionTeX, handler);
-  return {
-    endpoint: endpoint,
-    expression: parsedExp
-  };
-}
-function getNextFracIndex(tex, currentIndex) {
-  const dfrac = "\\dfrac";
-  const frac = "\\frac";
-  const nextFrac = tex.indexOf(frac, currentIndex);
-  const nextDFrac = tex.indexOf(dfrac, currentIndex);
-  if (nextFrac > -1 && nextDFrac > -1) {
-    return Math.min(nextFrac, nextDFrac);
-  }
-  if (nextFrac > -1) {
-    return nextFrac;
-  }
-  if (nextDFrac > -1) {
-    return nextDFrac;
-  }
-  return -1;
-}
-function walkTex(tex, handler) {
-  if (!tex) {
-    return "";
-  }
-
-  // Ex) tex: '2 \dfrac {3}{7}'
-  let parsedString = "";
-  let currentIndex = 0;
-  let nextFrac = getNextFracIndex(tex, currentIndex);
-
-  // For each \dfrac, find the two expressions (wrapped in {}) and recur
-  while (nextFrac > -1) {
-    // Gather first fragment, preceding \dfrac
-    // Ex) parsedString: '2 '
-    parsedString += tex.substring(currentIndex, nextFrac);
-
-    // Remove everything preceding \dfrac, which has been parsed
-    currentIndex = nextFrac;
-
-    // Parse first expression and move index past it
-    // Ex) firstParsedExpression.expression: '3'
-    const firstParsedExpression = parseNextExpression(tex, currentIndex, handler);
-    currentIndex = firstParsedExpression.endpoint + 1;
-
-    // Parse second expression
-    // Ex) secondParsedExpression.expression: '7'
-    const secondParsedExpression = parseNextExpression(tex, currentIndex, handler);
-    currentIndex = secondParsedExpression.endpoint + 1;
-
-    // Add expressions to running total of parsed expressions
-    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-    if (parsedString.length) {
-      parsedString += " ";
-    }
-
-    // Apply a custom handler based on the parsed subexpressions
-    parsedString += handler(firstParsedExpression.expression, secondParsedExpression.expression);
-
-    // Find next DFrac, relative to currentIndex
-    nextFrac = getNextFracIndex(tex, currentIndex);
-  }
-
-  // Add remaining TeX, which is \dfrac-free
-  parsedString += tex.slice(currentIndex);
-  return parsedString;
-}
-
-/*
- * Parse a TeX expression into something interpretable by input-number.
- * The process is concerned with: (1) parsing fractions, i.e., \dfracs; and
- * (2) removing backslash-escaping from certain characters (right now, only
- * percent signs).
- *
- * The basic algorithm for handling \dfracs splits on \dfracs and then recurs
- * on the subsequent "expressions", i.e., the {} pairs that follow \dfrac. The
- * recursion is to allow for nested \dfrac elements.
- *
- * Backslash-escapes are removed with a simple search-and-replace.
- */
-function parseTex(tex) {
-  const handler = function (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) {
-  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 => {
-    const stringAnswer = `${answer.value}`;
+function scoreExpression(userInput,rubric,locale){const options=___default.default.clone(rubric);___default.default.extend(options,{decimal_separator:perseusCore.getDecimalSeparator(locale)});const createValidator=answer=>{const expression=KAS__namespace.parse(answer.value,rubric);if(!expression.parsed){throw new perseusCore.PerseusError("Unable to parse solution answer for expression",perseusCore.Errors.InvalidInput,{metadata:{rubric:JSON.stringify(rubric)}})}return KhanAnswerTypes.expression.createValidatorFunctional(expression.expr,___default.default({}).extend(options,{simplify:answer.simplify,form:answer.form}))};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);if(result.correct){matchingAnswerForm=answerForm;matchMessage=result.message||"";break}allEmpty=allEmpty&&result.empty;if(answerForm.considered==="correct"&&result.ungraded&&!firstUngradedResult){firstUngradedResult=result;}}if(!matchingAnswerForm){if(firstUngradedResult){return {type:"invalid",message:firstUngradedResult.message,suppressAlmostThere:firstUngradedResult.suppressAlmostThere}}if(allEmpty){return {type:"invalid",message:null}}return {type:"points",earned:0,total:1}}if(matchingAnswerForm.considered==="ungraded"){return {type:"invalid",message:matchMessage}}return {type:"points",earned:matchingAnswerForm.considered==="correct"?1:0,total:1,message:matchMessage}}
 
-    // Always validate against the provided answer forms (pi, decimal, etc.)
-    const validatorForms = [...(answer.answerForms ?? [])];
+function validateExpression(userInput){if(userInput===""){return {type:"invalid",message:null}}return null}
 
-    // 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 {
-      ...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};
-  if (result.empty) {
-    return {
-      type: "invalid",
-      message: result.message
-    };
-  }
-  return {
-    type: "points",
-    earned: result.correct ? 1 : 0,
-    total: 1,
-    message: result.message
-  };
-}
+function getCoefficientsByType(data){if(data.coords==null){return undefined}if(data.type==="exponential"||data.type==="logarithm"){const grader=perseusCore.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);return grader.getCoefficients(data.coords)}else {throw new perseusCore.PerseusError("Invalid grapher type",perseusCore.Errors.InvalidInput)}}function scoreGrapher(userInput,rubric){if(userInput.type!==rubric.correct.type){return {type:"points",earned:0,total:1,message:null}}if(userInput.coords==null){return {type:"invalid",message:null}}const grader=perseusCore.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}}
 
-function scoreOrderer(userInput, rubric) {
-  const correct = ___default.default.isEqual(userInput.current, rubric.correctOptions.map(option => option.content));
-  return {
-    type: "points",
-    earned: correct ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
+function scoreIframe(userInput){if(userInput.status==="correct"){return {type:"points",earned:1,total:1,message:userInput.message||null}}if(userInput.status==="incorrect"){return {type:"points",earned:0,total:1,message:userInput.message||null}}return {type:"invalid",message:"Keep going, you're not there yet!"}}
 
-/**
- * Checks 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;
-}
+const{collinear,canonicalSineCoefficients,similar,clockwise}=kmath.geometry;const{getClockwiseAngle}=kmath.angles;const{getSinusoidCoefficients,getQuadraticCoefficients}=kmath.coefficients;function scoreInteractiveGraph(userInput,rubric){if(userInput.type==="none"&&rubric.correct.type==="none"){return {type:"points",earned:0,total:0,message:null}}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(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){const guessCoeffs=getQuadraticCoefficients(userInput.coords);const correctCoeffs=getQuadraticCoefficients(rubric.correct.coords);if(perseusCore.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(perseusCore.approximateDeepEqual(canonicalGuessCoeffs,canonicalCorrectCoeffs)){return {type:"points",earned:1,total:1,message:null}}}else if(userInput.type==="circle"&&rubric.correct.type==="circle"){if(perseusCore.approximateDeepEqual(userInput.center,rubric.correct.center)&&perseusCore.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();guess?.sort();correct.sort();if(perseusCore.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,kmath.number.DEFAULT_TOLERANCE);}else if(rubric.correct.match==="approx"){match=similar(guess,correct,.1);}else {guess.sort();correct.sort();match=perseusCore.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=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)){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(perseusCore.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;if(!coords){return {type:"invalid",message:null}}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){if(!coords){return false}const angle=getClockwiseAngle(coords,allowReflexAngles);return angle});match=perseusCore.approximateEqual(...angles);}else {match=perseusCore.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}}}}if(!hasValue||___default.default.isEqual(userInput,rubric.graph)){return {type:"invalid",message:null}}return {type:"points",earned:0,total:1,message:null}}
 
-function scorePlotter(userInput, rubric) {
-  return {
-    type: "points",
-    earned: perseusCore.approximateDeepEqual(userInput, rubric.correct) ? 1 : 0,
-    total: 1,
-    message: null
-  };
-}
+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){score.isCorrect=userInput.every(choice=>rubric.includes(choice));}}else if(!userInput||userInput.length===0){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",earned:numCorrect===userInput.markers.length?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)) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
+function scoreMatcher(userInput,rubric){const correct=___default.default.isEqual(userInput.left,rubric.left)&&___default.default.isEqual(userInput.right,rubric.right);return {type:"points",earned:correct?1:0,total:1,message: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
-  };
-}
+function scoreMatrix(userInput,rubric){const solution=rubric.answers;const supplied=userInput.answers;const solutionSize=perseusCore.getMatrixSize(solution);const suppliedSize=perseusCore.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=>{if(!incorrectSize){const validator=createValidator(solution[row][col],{simplify:true});const result=validator(supplied[row][col]);if(result.message){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 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 validateMatrix(userInput){const supplied=userInput.answers;const suppliedSize=perseusCore.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 scoreSorter(userInput, rubric) {
-  const correct = perseusCore.approximateDeepEqual(userInput.options, rubric.correct);
-  return {
-    type: "points",
-    earned: correct ? 1 : 0,
-    total: 1,
-    message: 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=kmath.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){return {type:"invalid",message:null}}return {type:"points",earned:0,total:1,message:null}}
 
-/**
- * Checks user input for the sorter widget to ensure that the user has made
- * changes before attempting to score the widget.
- * @param userInput
- * @see 'scoreSorter' in 'packages/perseus/src/widgets/sorter/score-sorter.ts'
- * for more details on how the sorter widget is scored.
- */
-function validateSorter(userInput) {
-  // If the sorter widget hasn't been changed yet, we treat it as "empty" which
-  // prevents the "Check" button from becoming active. We want the user
-  // to make a change before trying to move forward. This makes an
-  // assumption that the initial order isn't the correct order! However,
-  // this should be rare if it happens, and interacting with the list
-  // will enable the button, so they won't be locked out of progressing.
-  if (!userInput.changed) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
+function validateNumberLine(userInput){const divisionRange=userInput.divisionRange;const outsideAllowedRange=userInput.numDivisions>divisionRange[1]||userInput.numDivisions<divisionRange[0];if(userInput.isTickCrtl&&outsideAllowedRange){return {type:"invalid",message:"Number of divisions is outside the allowed range."}}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) {
-  return table.filter(function (row) {
-    // Return only rows that are non-empty.
-    return row.some(cell => cell);
-  });
-};
+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}}return tex.length}function parseNextExpression(tex,currentIndex,handler){const openBracketIndex=tex.indexOf("{",currentIndex);if(openBracketIndex===-1){return {endpoint:tex.length,expression:""}}const nextExpIndex=openBracketIndex+1;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 ""}let parsedString="";let currentIndex=0;let nextFrac=getNextFracIndex(tex,currentIndex);while(nextFrac>-1){parsedString+=tex.substring(currentIndex,nextFrac);currentIndex=nextFrac;const firstParsedExpression=parseNextExpression(tex,currentIndex,handler);currentIndex=firstParsedExpression.endpoint+1;const secondParsedExpression=parseNextExpression(tex,currentIndex,handler);currentIndex=secondParsedExpression.endpoint+1;if(parsedString.length){parsedString+=" ";}parsedString+=handler(firstParsedExpression.expression,secondParsedExpression.expression);nextFrac=getNextFracIndex(tex,currentIndex);}parsedString+=tex.slice(currentIndex);return parsedString}function parseTex(tex){const handler=function(exp1,exp2){return exp1+"/"+exp2};const texWithoutFracs=walkTex(tex,handler);return texWithoutFracs.replace("\\%","%")}
 
-function validateTable(userInput) {
-  const supplied = filterNonEmpty(userInput);
-  const hasEmptyCell = supplied.some(function (row) {
-    return row.some(function (cell) {
-      return cell === "";
-    });
-  });
+const answerFormButtons=[{title:"Integers",value:"integer",content:"6"},{title:"Decimals",value:"decimal",content:"0.75"},{title:"Proper fractions",value:"proper",content:"⅗"},{title:"Improper fractions",value:"improper",content:"⁷⁄₄"},{title:"Mixed numbers",value:"mixed",content:"1¾"},{title:"Numbers with π",value:"pi",content:"π"}];function maybeParsePercentInput(inputValue,normalizedAnswerExpected){if(!(typeof inputValue==="string"&&inputValue.endsWith("%"))){return inputValue}const value=parseFloat(inputValue.slice(0,-1));if(isNaN(value)){return inputValue}if(normalizedAnswerExpected){return value/100}return value}function scoreNumericInput(userInput,rubric){const defaultAnswerForms=answerFormButtons.map(e=>e["value"]).filter(e=>e!=="pi");const createValidator=answer=>{const stringAnswer=`${answer.value}`;const validatorForms=[...answer.answerForms??[]];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,maxError:answer.maxError,forms:validatorForms})};const currentValue=parseTex(userInput.currentValue);const normalizedAnswerExpected=rubric.answers.filter(answer=>answer.status==="correct").every(answer=>answer.value!=null&&Math.abs(answer.value)<=1);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 {...answer,score}}).find(answer=>{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};if(result.empty){return {type:"invalid",message:result.message}}return {type:"points",earned:result.correct?1:0,total:1,message:result.message}}
 
-  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-  if (hasEmptyCell || !supplied.length) {
-    return {
-      type: "invalid",
-      message: null
-    };
-  }
-  return null;
-}
+function scoreOrderer(userInput,rubric){const correct=___default.default.isEqual(userInput.current,rubric.correctOptions.map(option=>option.content));return {type:"points",earned:correct?1:0,total:1,message: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
-  };
-}
+function validateOrderer(userInput){if(userInput.current.length===0){return {type:"invalid",message:null}}return null}
 
-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";
-  }
+function scorePlotter(userInput,rubric){return {type:"points",earned:perseusCore.approximateDeepEqual(userInput,rubric.correct)?1:0,total:1,message:null}}
 
-  // 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
-  });
+function validatePlotter(userInput,validationData){if(perseusCore.approximateDeepEqual(userInput,validationData.starting)){return {type:"invalid",message:null}}return null}
 
-  // 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
-  };
-}
+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}}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}}
 
-/**
- * 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;
-  return {
-    type: "points",
-    earned: points,
-    total: points,
-    message: null
-  };
-}
+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}
 
-// The `group` widget is basically a widget hosting a full Perseus system in
+function scoreSorter(userInput,rubric){const correct=perseusCore.approximateDeepEqual(userInput.options,rubric.correct);return {type:"points",earned:correct?1:0,total:1,message:null}}
 
-// 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);
-}
+function validateSorter(userInput){if(!userInput.changed){return {type:"invalid",message:null}}return null}
 
-/**
- * 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?.(userInput, validationData, locale);
-    if (score) {
-      return scoreIsEmpty(score);
-    }
-  });
-}
+const filterNonEmpty=function(table){return table.filter(function(row){return row.some(cell=>cell)})};
 
-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 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 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 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}}
 
-function validateMockWidget(userInput) {
-  if (userInput.currentValue == null || userInput.currentValue === "") {
-    return {
-      type: "invalid",
-      message: ""
-    };
-  }
-  return null;
-}
+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";}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});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}}
 
-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: ""
-  };
-}
+function scoreNoop(points=0){return {type:"points",earned:points,total:points,message:null}}
 
-const widgets = {};
-function registerWidget(type, scorer, validator) {
-  widgets[type] = {
-    scorer,
-    validator
-  };
-}
-const getWidgetValidator = name => {
-  return widgets[name]?.validator ?? null;
-};
-const getWidgetScorer = name => {
-  return 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);
+function scoreGroup(userInput,rubric,locale){const scores=scoreWidgetsFunctional(rubric.widgets,Object.keys(rubric.widgets),userInput,locale);return flattenScores(scores)}
 
-const noScore = {
-  type: "points",
-  earned: 0,
-  total: 0,
-  message: null
-};
+function emptyWidgetsFunctional(widgets,widgetIds,userInputMap,locale){return widgetIds.filter(id=>{const widget=widgets[id];if(!widget||widget.static===true){return false}const validator=getWidgetValidator(widget.type);const userInput=userInputMap[id];const validationData=widget.options;const score=validator?.(userInput,validationData,locale);if(score){return scoreIsEmpty(score)}})}
 
-/**
- * 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);
-}
+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}}
 
-/**
- * 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
-    };
-  }
+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++;}}if(numAnswered!==userInput.markers.length){return {type:"invalid",message:null}}return null}
 
-  /**
-   * 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, {
-    metadata: {
-      scoreA: JSON.stringify(scoreA),
-      scoreB: JSON.stringify(scoreB)
-    }
-  });
-}
-function flattenScores(widgetScoreMap) {
-  return Object.values(widgetScoreMap).reduce(combineScores, noScore);
-}
+function validateMockWidget(userInput){if(userInput.currentValue==null||userInput.currentValue===""){return {type:"invalid",message:""}}return null}
 
-/**
- * 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 scores = scoreWidgetsFunctional(perseusRenderData.widgets, usedWidgetIds, userInputMap, locale);
-  return flattenScores(scores);
-}
+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:""}}
 
-// 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);
-  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.
-    return widgetIsGraded && !widgetIsStatic;
-  });
-  const widgetScores = {};
-  gradedWidgetIds.forEach(id => {
-    const widget = upgradedWidgets[id];
-    if (!widget) {
-      return;
-    }
-    const userInput = userInputMap[id];
-    const validator = getWidgetValidator(widget.type);
-    const scorer = getWidgetScorer(widget.type);
+const widgets={};function registerWidget(type,scorer,validator){widgets[type]={scorer,validator};}const getWidgetValidator=name=>{return widgets[name]?.validator??null};const getWidgetScorer=name=>{return 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);
 
-    // 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);
-    if (score != null) {
-      widgetScores[id] = score;
-    }
-  });
-  return widgetScores;
-}
+const noScore={type:"points",earned:0,total:0,message:null};function scoreIsEmpty(score){return score.type==="invalid"&&(!score.message||score.message.length===0)}function combineScores(scoreA,scoreB){let message;if(scoreA.type==="points"&&scoreB.type==="points"){if(scoreA.message&&scoreB.message&&scoreA.message!==scoreB.message){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){message=null;}else {message=scoreA.message||scoreB.message;}return {type:"invalid",message:message}}throw new perseusCore.PerseusError("PerseusScore with unknown type encountered",perseusCore.Errors.InvalidInput,{metadata:{scoreA:JSON.stringify(scoreA),scoreB:JSON.stringify(scoreB)}})}function flattenScores(widgetScoreMap){return Object.values(widgetScoreMap).reduce(combineScores,noScore)}function scorePerseusItem(perseusRenderData,userInputMap,locale){const usedWidgetIds=perseusCore.getWidgetIdsFromContent(perseusRenderData.content);const scores=scoreWidgetsFunctional(perseusRenderData.widgets,usedWidgetIds,userInputMap,locale);return flattenScores(scores)}function scoreWidgetsFunctional(widgets,widgetIds,userInputMap,locale){const upgradedWidgets=perseusCore.getUpgradedWidgetOptions(widgets);const gradedWidgetIds=widgetIds.filter(id=>{const props=upgradedWidgets[id];const widgetIsGraded=props?.graded==null||props.graded;const widgetIsStatic=!!props?.static;return widgetIsGraded&&!widgetIsStatic});const widgetScores={};gradedWidgetIds.forEach(id=>{const widget=upgradedWidgets[id];if(!widget){return}const userInput=userInputMap[id];const validator=getWidgetValidator(widget.type);const scorer=getWidgetScorer(widget.type);const score=validator?.(userInput,widget.options,locale)??scorer?.(userInput,widget.options,locale);if(score!=null){widgetScores[id]=score;}});return widgetScores}
 
 exports.ErrorCodes = ErrorCodes;
 exports.KhanAnswerTypes = KhanAnswerTypes;