@khanacademy/kas 0.5.1 → 2.0.0

package/dist/index.js

@@ -5,13 +5,16 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var perseusUtils = require('@khanacademy/perseus-utils');
 var _ = require('underscore');
 
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
 
-var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
+var ___default = /*#__PURE__*/_interopDefaultCompat(_);
 
 // This file is processed by a Rollup plugin (replace) to inject the production
+// version number during the release build.
+// In dev, you'll never see the version number.
+
 const libName = "@khanacademy/kas";
-const libVersion = "0.5.1";
+const libVersion = "2.0.0";
 perseusUtils.addLibraryVersionToPerseusDebug(libName, libVersion);
 
 // this is a @generated file
@@ -2622,6 +2625,9 @@ var parser = function () {
 }();
 
 /* eslint-disable prettier/prettier */
+/* eslint-disable import/order */
+/* TODO: fix these lint errors (http://eslint.org/docs/rules): */
+/* eslint-disable indent, no-undef, no-var, no-dupe-keys, no-new-func, no-redeclare, comma-dangle, max-len, prefer-spread, space-infix-ops, space-unary-ops */
 
 /*  The node hierarcy is as follows:
 
@@ -2676,7 +2682,7 @@ var TOLERANCE = 9; // decimal places
 function partition(list, iteratee) {
   const a = [];
   const b = [];
-  ___default["default"].forEach(list, (elem, key, ctx) => {
+  ___default.default.forEach(list, (elem, key, ctx) => {
     if (iteratee(elem, key, ctx)) {
       a.push(elem);
     } else {
@@ -2735,7 +2741,7 @@ class Expr {
       passed[_key - 1] = arguments[_key];
     }
     var args = this.args().map(function (arg) {
-      return ___default["default"].isString(arg) || ___default["default"].isNumber(arg) ? arg : arg?.[method].apply(arg, passed);
+      return ___default.default.isString(arg) || ___default.default.isNumber(arg) ? arg : arg?.[method].apply(arg, passed);
     });
     return this.construct(args);
   }
@@ -2778,7 +2784,7 @@ class Expr {
   // returns a TeX string, modified by the given options
   asTex(options) {
     options = options || {};
-    ___default["default"].defaults(options, {
+    ___default.default.defaults(options, {
       display: true,
       dynamic: true,
       times: false
@@ -2806,7 +2812,7 @@ class Expr {
   // returns a string representing current node structure
   repr() {
     return this.name() + "(" + this.args().map(function (arg) {
-      return ___default["default"].isString(arg) || ___default["default"].isNumber(arg) ? arg : arg?.repr();
+      return ___default.default.isString(arg) || ___default.default.isNumber(arg) ? arg : arg?.repr();
     }).join(",") + ")";
   }
 
@@ -2887,13 +2893,13 @@ class Expr {
 
   // return the variables (function and non) within the expression
   getVars(excludeFunc) {
-    return ___default["default"].uniq(___default["default"].flatten(___default["default"].invoke(this.exprArgs(), "getVars", excludeFunc))).sort();
+    return ___default.default.uniq(___default.default.flatten(___default.default.invoke(this.exprArgs(), "getVars", excludeFunc))).sort();
   }
   getConsts() {
-    return ___default["default"].uniq(___default["default"].flatten(___default["default"].invoke(this.exprArgs(), "getConsts"))).sort();
+    return ___default.default.uniq(___default.default.flatten(___default.default.invoke(this.exprArgs(), "getConsts"))).sort();
   }
   getUnits() {
-    return ___default["default"].flatten(___default["default"].invoke(this.exprArgs(), "getUnits"));
+    return ___default.default.flatten(___default.default.invoke(this.exprArgs(), "getUnits"));
   }
 
   // check whether this expression node is of a particular type
@@ -2906,7 +2912,7 @@ class Expr {
     if (this instanceof func) {
       return true;
     }
-    return ___default["default"].any(this.exprArgs(), function (arg) {
+    return ___default.default.any(this.exprArgs(), function (arg) {
       return arg.has(func);
     });
   }
@@ -2942,10 +2948,11 @@ class Expr {
     // the other Expr can have more variables than this one
     // this lets you multiply equations by other variables
     var same = function (array1, array2) {
-      return !___default["default"].difference(array1, array2).length;
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+      return !___default.default.difference(array1, array2).length;
     };
     var lower = function (array) {
-      return ___default["default"].uniq(___default["default"].invoke(array, "toLowerCase")).sort();
+      return ___default.default.uniq(___default.default.invoke(array, "toLowerCase")).sort();
     };
     var equal = same(vars1, vars2);
     var equalIgnoringCase = same(lower(vars1), lower(vars2));
@@ -2963,7 +2970,7 @@ class Expr {
     if (other instanceof Eq) {
       return false;
     }
-    var varList = ___default["default"].union(this.getVars(/* excludeFunc */true), other.getVars(/* excludeFunc */true));
+    var varList = ___default.default.union(this.getVars(/* excludeFunc */true), other.getVars(/* excludeFunc */true));
 
     // If the numbers are large we would like to do a relative comparison
     // rather than an absolute one, but if they're small enough then an
@@ -2977,7 +2984,7 @@ class Expr {
     };
     var equalNumbers = function (num1, num2) {
       var delta = getDelta(num1, num2);
-      return num1 === num2 /* needed if either is +/- Infinity */ || isNaN(num1) && isNaN(num2) || delta < Math.pow(10, -TOLERANCE);
+      return num1 === num2 /* needed if either is +/- Infinity */ || isNaN(num1) && isNaN(num2) || delta < Math.pow(10, -9);
     };
 
     // If no variables, only need to evaluate once.
@@ -2985,7 +2992,8 @@ class Expr {
     // where there are no variables / functions.
     // Ran into issues with it in LEMS-2777 and found that tests pass
     // with this removed, but keeping a modified version out of caution.
-    const varAndFuncList = ___default["default"].union(this.getVars(/* excludeFunc */false), other.getVars(/* excludeFunc */false));
+    const varAndFuncList = ___default.default.union(this.getVars(/* excludeFunc */false), other.getVars(/* excludeFunc */false));
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (!varAndFuncList.length && !this.has(Unit) && !other.has(Unit)) {
       return equalNumbers(this.eval(), other.eval());
     }
@@ -2997,7 +3005,7 @@ class Expr {
     var expr2 = other.collect();
     var unitList1 = this.getUnits();
     var unitList2 = other.getUnits();
-    if (!___default["default"].isEqual(unitList1, unitList2)) {
+    if (!___default.default.isEqual(unitList1, unitList2)) {
       return false;
     }
 
@@ -3031,8 +3039,8 @@ class Expr {
       //
       // TODO(alex): Add support for complex numbers, then remove this.
       var useFloats = i % 2 === 0;
-      ___default["default"].each(varList, function (v) {
-        vars[v] = useFloats ? randomFloat(-range, range) : ___default["default"].random(-range, range);
+      ___default.default.each(varList, function (v) {
+        vars[v] = useFloats ? randomFloat(-range, range) : ___default.default.random(-range, range);
       });
       let equal;
       if (expr1.has(Func) || expr2.has(Func) || expr1.has(Unit) || expr2.has(Unit)) {
@@ -3112,7 +3120,7 @@ class Expr {
       return this;
     }
     var expr = this.construct(this.args());
-    expr.hints = ___default["default"].clone(this.hints);
+    expr.hints = ___default.default.clone(this.hints);
     expr.hints[hint] = true;
     return expr;
   }
@@ -3153,7 +3161,7 @@ class Seq extends Expr {
     return this.terms;
   }
   normalize() {
-    var terms = ___default["default"].sortBy(___default["default"].invoke(this.terms, "normalize"), term => {
+    var terms = ___default.default.sortBy(___default.default.invoke(this.terms, "normalize"), term => {
       return term.print();
     });
     return new this.func(terms);
@@ -3175,7 +3183,7 @@ class Seq extends Expr {
   // this is a shallow flattening and will return a non-Seq if terms.length <= 1
   flatten() {
     var type = this;
-    var terms = ___default["default"].reject(this.terms, term => {
+    var terms = ___default.default.reject(this.terms, term => {
       // @ts-expect-error: `identity` is defined on Add and Mul but doesn't
       // exist on Seq itself.
       return term.equals(type.identity);
@@ -3193,22 +3201,22 @@ class Seq extends Expr {
     const [same, others] = partition(terms, term => {
       return term instanceof type.func;
     });
-    var flattened = others.concat(___default["default"].flatten(___default["default"].pluck(same, "terms"), /* shallow: */true));
+    var flattened = others.concat(___default.default.flatten(___default.default.pluck(same, "terms"), /* shallow: */true));
     return new type.func(flattened);
   }
 
   // reduce a numeric sequence to a Num
 
   isPositive() {
-    var terms = ___default["default"].invoke(this.terms, "collect");
-    return ___default["default"].all(___default["default"].invoke(terms, "isPositive"));
+    var terms = ___default.default.invoke(this.terms, "collect");
+    return ___default.default.all(___default.default.invoke(terms, "isPositive"));
   }
 
   // return a new Seq with a given term replaced by a different term
   // (or array of terms). given term can be passed directly, or by index
   // if no new term is provided, the old one is simply removed
   replace(oldTerm, newTerm) {
-    const index = oldTerm instanceof Expr ? ___default["default"].indexOf(this.terms, oldTerm) : oldTerm;
+    const index = oldTerm instanceof Expr ? ___default.default.indexOf(this.terms, oldTerm) : oldTerm;
     var newTerms = [];
     if (Array.isArray(newTerm)) {
       newTerms = newTerm;
@@ -3225,7 +3233,7 @@ class Seq extends Expr {
   }
   getDenominator() {
     // TODO(alex): find and return LCM
-    return new Mul(___default["default"].invoke(this.terms, "getDenominator")).flatten();
+    return new Mul(___default.default.invoke(this.terms, "getDenominator")).flatten();
   }
 }
 
@@ -3236,21 +3244,21 @@ class Add extends Seq {
   eval() {
     let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     let options = arguments.length > 1 ? arguments[1] : undefined;
-    return ___default["default"].reduce(this.terms, (memo, term) => {
+    return ___default.default.reduce(this.terms, (memo, term) => {
       return memo + term.eval(vars, options);
     }, 0);
   }
   codegen() {
-    return ___default["default"].map(this.terms, term => {
+    return ___default.default.map(this.terms, term => {
       return "(" + term.codegen() + ")";
     }).join(" + ") || "0";
   }
   print() {
-    return ___default["default"].invoke(this.terms, "print").join("+");
+    return ___default.default.invoke(this.terms, "print").join("+");
   }
   tex() {
     let tex = "";
-    ___default["default"].each(this.terms, term => {
+    ___default.default.each(this.terms, term => {
       if (!tex || term.isSubtract()) {
         tex += term.tex();
       } else {
@@ -3260,9 +3268,9 @@ class Add extends Seq {
     return tex;
   }
   collect(options) {
-    var terms = ___default["default"].invoke(this.terms, "collect", options);
+    var terms = ___default.default.invoke(this.terms, "collect", options);
     var pairs = [];
-    ___default["default"].each(terms, term => {
+    ___default.default.each(terms, term => {
       if (term instanceof Mul) {
         var muls = term.partition();
         pairs.push([muls[1].flatten(), muls[0].reduce(options)]);
@@ -3274,12 +3282,12 @@ class Add extends Seq {
     });
 
     // { (Expr expr).print(): [[Expr expr, Num coefficient]] }
-    var grouped = ___default["default"].groupBy(pairs, pair => {
+    var grouped = ___default.default.groupBy(pairs, pair => {
       return pair[0].normalize().print();
     });
-    var collected = ___default["default"].compact(___default["default"].map(grouped, pairs => {
+    var collected = ___default.default.compact(___default.default.map(grouped, pairs => {
       var expr = pairs[0][0];
-      var sum = new Add(___default["default"].zip.apply(___default["default"], pairs)[1]);
+      var sum = new Add(___default.default.zip.apply(___default.default, pairs)[1]);
       var coefficient = sum.reduce(options);
       return new Mul(coefficient, expr).collect(options);
     }));
@@ -3303,8 +3311,8 @@ class Add extends Seq {
     } else {
       factors = [terms[0]];
     }
-    ___default["default"].each(___default["default"].rest(this.terms), term => {
-      factors = ___default["default"].map(factors, factor => {
+    ___default.default.each(___default.default.rest(this.terms), term => {
+      factors = ___default.default.map(factors, factor => {
         return term.findGCD(factor);
       });
     });
@@ -3317,7 +3325,7 @@ class Add extends Seq {
     return Mul.createOrAppend(left, right).flatten();
   }
   reduce(options) {
-    return ___default["default"].reduce(this.terms,
+    return ___default.default.reduce(this.terms,
     // @ts-expect-error: Type 'Expr' is not assignable to type 'Num'.
     (memo, term) => {
       return memo.add(term, options);
@@ -3327,11 +3335,11 @@ class Add extends Seq {
     return false;
   }
   isNegative() {
-    var terms = ___default["default"].invoke(this.terms, "collect");
-    return ___default["default"].all(___default["default"].invoke(terms, "isNegative"));
+    var terms = ___default.default.invoke(this.terms, "collect");
+    return ___default.default.all(___default.default.invoke(terms, "isNegative"));
   }
   negate() {
-    return new Add(___default["default"].invoke(this.terms, "negate"));
+    return new Add(___default.default.invoke(this.terms, "negate"));
   }
 
   // create a new sequence unless left is already one (returns a copy)
@@ -3351,22 +3359,22 @@ class Mul extends Seq {
   eval() {
     let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
     let options = arguments.length > 1 ? arguments[1] : undefined;
-    return ___default["default"].reduce(this.terms, (memo, term) => {
+    return ___default.default.reduce(this.terms, (memo, term) => {
       return memo * term.eval(vars, options);
     }, 1);
   }
   codegen() {
-    return ___default["default"].map(this.terms, term => {
+    return ___default.default.map(this.terms, term => {
       return "(" + term.codegen() + ")";
     }).join(" * ") || "0";
   }
   print() {
-    return ___default["default"].map(this.terms, term => {
+    return ___default.default.map(this.terms, term => {
       return term instanceof Add ? "(" + term.print() + ")" : term.print();
     }).join("*");
   }
   getUnits() {
-    var tmUnits = ___default["default"](this.terms).chain().map(term => {
+    var tmUnits = ___default.default(this.terms).chain().map(term => {
       return term.getUnits();
     }).flatten().value();
     tmUnits.sort((a, b) => a.unit.localeCompare(b.unit));
@@ -3377,7 +3385,7 @@ class Mul extends Seq {
   // so we follow convention: first any negatives, then any numbers, then everything else
   tex() {
     var cdot = " \\cdot ";
-    var terms = ___default["default"].groupBy(this.terms, term => {
+    var terms = ___default.default.groupBy(this.terms, term => {
       if (term.isDivide()) {
         return "inverse";
       } else if (term instanceof Num) {
@@ -3386,8 +3394,12 @@ class Mul extends Seq {
         return "other";
       }
     });
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     var inverses = terms.inverse || [];
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     var numbers = terms.number || [];
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     var others = terms.other || [];
     var negatives = "";
     var numerator;
@@ -3404,14 +3416,14 @@ class Mul extends Seq {
         return numbers[i].tex() + new Mul(newTerms).tex();
       }
     }
-    numbers = ___default["default"].compact(___default["default"].map(numbers, term => {
+    numbers = ___default.default.compact(___default.default.map(numbers, term => {
       var shouldPushDown = !term.hints.fraction || inverses.length > 0;
       if (term instanceof Rational && !(term instanceof Int) && shouldPushDown) {
         // e.g. 3x/4 -> 3/4*x (internally) -> 3x/4 (rendered)
         inverses.push(new Pow(new Int(term.d), NumDiv));
         var number = new Int(term.n);
         number.hints = term.hints;
-        return ___default["default"].any(term.hints) ? number : null;
+        return ___default.default.any(term.hints) ? number : null;
       } else {
         return term;
       }
@@ -3421,7 +3433,7 @@ class Mul extends Seq {
       numerator = others[0].tex();
     } else {
       var tex = "";
-      ___default["default"].each(numbers, term => {
+      ___default.default.each(numbers, term => {
         if (term.hints.subtract && term.hints.entered) {
           negatives += "-";
           tex += (tex ? cdot : "") + term.abs().tex();
@@ -3434,7 +3446,7 @@ class Mul extends Seq {
           tex += (tex ? cdot : "") + term.tex();
         }
       });
-      ___default["default"].each(others, term => {
+      ___default.default.each(others, term => {
         if (term.needsExplicitMul()) {
           // e.g. 2*2^3 -> 2(dot)2^3
           tex += (tex ? cdot : "") + term.tex();
@@ -3448,15 +3460,17 @@ class Mul extends Seq {
       });
       numerator = tex ? tex : "1";
     }
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (!inverses.length) {
       return negatives + numerator;
     } else {
-      var denominator = new Mul(___default["default"].invoke(inverses, "asDivide")).flatten().tex();
+      var denominator = new Mul(___default.default.invoke(inverses, "asDivide")).flatten().tex();
       return negatives + "\\frac{" + numerator + "}{" + denominator + "}";
     }
   }
   strip() {
-    var terms = ___default["default"].map(this.terms, term => {
+    var terms = ___default.default.map(this.terms, term => {
       return term instanceof Num ? term.abs() : term.strip();
     });
     return new Mul(terms).flatten();
@@ -3472,8 +3486,8 @@ class Mul extends Seq {
     };
     const mul = this.recurse("expand").flatten();
     const factors = getFactors(mul);
-    const hasAdd = ___default["default"].any(factors, isAdd);
-    const hasInverseAdd = ___default["default"].any(factors, isInverseAdd);
+    const hasAdd = ___default.default.any(factors, isAdd);
+    const hasInverseAdd = ___default.default.any(factors, isInverseAdd);
     if (!(hasAdd || hasInverseAdd)) {
       return mul;
     }
@@ -3482,22 +3496,22 @@ class Mul extends Seq {
       const [adds, others] = partition(normals, isAdd);
 
       // loop over each additive sequence
-      const expanded = ___default["default"].reduce(adds, function (expanded, add) {
+      const expanded = ___default.default.reduce(adds, function (expanded, add) {
         // loop over each expanded array of terms
-        return ___default["default"].reduce(expanded, function (temp, array) {
+        return ___default.default.reduce(expanded, function (temp, array) {
           // loop over each additive sequence's terms
-          return temp.concat(___default["default"].map(add.terms, term => array.concat(term)));
+          return temp.concat(___default.default.map(add.terms, term => array.concat(term)));
         }, []);
       }, [[]]);
 
       // join each fully expanded array of factors with remaining multiplicative factors
-      const muls = ___default["default"].map(expanded, function (array) {
+      const muls = ___default.default.map(expanded, function (array) {
         return new Mul(others.concat(array)).flatten();
       });
       normals = [new Add(muls)];
     }
     if (hasInverseAdd) {
-      const denominator = new Mul(___default["default"].invoke(inverses, "getDenominator")).flatten();
+      const denominator = new Mul(___default.default.invoke(inverses, "getDenominator")).flatten();
       inverses = [new Pow(denominator.expand(), NumDiv)];
     }
     return new Mul(normals.concat(inverses)).flatten();
@@ -3516,7 +3530,7 @@ class Mul extends Seq {
     // Could also accomplish this by passing a new option
     // e.g. return  memo.mul(term, {autocollect: false});
     // TODO(alex): Decide whether this is a good use of options or not
-    const ratObj = ___default["default"].reduce(rationals, (memo, term) => {
+    const ratObj = ___default.default.reduce(rationals, (memo, term) => {
       return {
         n: memo.n * term.n,
         d: memo.d * term.d
@@ -3545,7 +3559,7 @@ class Mul extends Seq {
     }
     const others = other.terms;
     var pairs = [];
-    ___default["default"].each(others, term => {
+    ___default.default.each(others, term => {
       if (term instanceof Pow) {
         pairs.push([term.base, term.exp]);
       } else {
@@ -3554,12 +3568,12 @@ class Mul extends Seq {
     });
 
     // {(Expr base).print(): [[Expr base, Expr exp]]}
-    var grouped = ___default["default"].groupBy(pairs, pair => {
+    var grouped = ___default.default.groupBy(pairs, pair => {
       return pair[0].normalize().print();
     });
-    var summed = ___default["default"].compact(___default["default"].map(grouped, pairs => {
+    var summed = ___default.default.compact(___default.default.map(grouped, pairs => {
       var base = pairs[0][0];
-      var sum = new Add(___default["default"].zip.apply(___default["default"], pairs)[1]);
+      var sum = new Add(___default.default.zip.apply(___default.default, pairs)[1]);
       var exp = sum.collect(options);
       if (exp instanceof Num && exp.eval() === 0) {
         return null;
@@ -3569,7 +3583,7 @@ class Mul extends Seq {
     }));
 
     // XXX `pairs` is shadowed four or five times in this function
-    const groupedPairs = ___default["default"].groupBy(summed, pair => {
+    const groupedPairs = ___default.default.groupBy(summed, pair => {
       if (pair[0] instanceof Trig && pair[0].isBasic()) {
         return "trig";
       } else if (pair[0] instanceof Log) {
@@ -3578,18 +3592,21 @@ class Mul extends Seq {
         return "expr";
       }
     });
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     let trigs = groupedPairs.trig || [];
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     let logs = groupedPairs.log || [];
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     const exprs = groupedPairs.expr || [];
     if (trigs.length > 1) {
       // combine sines and cosines into other trig functions
 
       // {Trig.arg.print(): [[Trig base, Expr exp]]}
-      var byArg = ___default["default"].groupBy(trigs, pair => {
+      var byArg = ___default.default.groupBy(trigs, pair => {
         return pair[0].arg.normalize().print();
       });
       trigs = [];
-      ___default["default"].each(byArg, pairs => {
+      ___default.default.each(byArg, pairs => {
         const arg = pairs[0][0].arg;
 
         // {Trig.type: Expr exp}
@@ -3597,7 +3614,7 @@ class Mul extends Seq {
           sin: NumZero,
           cos: NumZero
         };
-        ___default["default"].each(pairs, pair => {
+        ___default.default.each(pairs, pair => {
           funcs[pair[0].type] = pair[1];
         });
         if (Mul.handleNegative(funcs.sin).collect(options).equals(funcs.cos)) {
@@ -3616,7 +3633,7 @@ class Mul extends Seq {
         // TODO(alex): combine even if exponents not a perfect match
         // TODO(alex): transform 1/sin and 1/cos into csc and sec
 
-        ___default["default"].each(funcs, (exp, type) => {
+        ___default.default.each(funcs, (exp, type) => {
           trigs.push([new Trig(type, arg), exp]);
         });
       });
@@ -3625,11 +3642,11 @@ class Mul extends Seq {
       // combine logs with the same base
 
       // {Log.base.print(): [[Log base, Expr exp]]}
-      var byBase = ___default["default"].groupBy(logs, pair => {
+      var byBase = ___default.default.groupBy(logs, pair => {
         return pair[0].base.normalize().print();
       });
       logs = [];
-      ___default["default"].each(byBase, pairs => {
+      ___default.default.each(byBase, pairs => {
         // only combine two logs of the same base, otherwise commutative
         // differences result in different equally valid output
         // e.g. ln(x)/ln(z)*ln(y) -> log_z(x)*ln(y)
@@ -3648,13 +3665,13 @@ class Mul extends Seq {
 
       // TODO(alex): combine if all inverses are the same e.g. ln(y)*ln(z)/ln(x)/ln(x)
     }
-    var collected = ___default["default"].map([...trigs, ...logs, ...exprs], pair => {
+    var collected = ___default.default.map([...trigs, ...logs, ...exprs], pair => {
       return new Pow(pair[0], pair[1]).collect(options);
     });
     return new Mul([number].concat(collected)).flatten();
   }
   isSubtract() {
-    return ___default["default"].any(this.terms, term => {
+    return ___default.default.any(this.terms, term => {
       return term instanceof Num && Boolean(term.hints.subtract);
     });
   }
@@ -3666,7 +3683,10 @@ class Mul extends Seq {
     // `partition` splits the terms into two Seqs - one containing
     // only Nums and the all non-Num nodes.
     var numbers = partitioned[0].terms;
-    var fold = numbers.length && ___default["default"].all(numbers, num => num.n > 0);
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    var fold = numbers.length && ___default.default.all(numbers, num => num.n > 0);
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (fold) {
       // e.g. - x*2*3 -> x*-2*3
       var num = numbers[0].negate();
@@ -3683,7 +3703,7 @@ class Mul extends Seq {
   // TODO(alex): make more general or rename to be more specific
   factorOut() {
     var factored = false;
-    var terms = ___default["default"].compact(___default["default"].map(this.terms, term => {
+    var terms = ___default.default.compact(___default.default.map(this.terms, term => {
       if (!factored && term instanceof Num && term.hints.divide) {
         factored = true;
         return term.n !== -1 ? term.negate() : null;
@@ -3698,14 +3718,14 @@ class Mul extends Seq {
     }
   }
   reduce(options) {
-    return ___default["default"].reduce(this.terms,
+    return ___default.default.reduce(this.terms,
     // @ts-expect-error: Type 'Expr' is not assignable to type 'Num'.
     (memo, term) => {
       return memo.mul(term, options);
     }, this.identity);
   }
   findGCD(factor) {
-    return new Mul(___default["default"].invoke(this.terms, "findGCD", factor)).flatten();
+    return new Mul(___default.default.invoke(this.terms, "findGCD", factor)).flatten();
   }
   asMul() {
     return this;
@@ -3720,7 +3740,7 @@ class Mul extends Seq {
   }
   isNegative() {
     const terms = getFactors(this.collect()).map(factor => factor.isNegative());
-    return ___default["default"].any(terms);
+    return ___default.default.any(terms);
   }
   fold() {
     return Mul.fold(this);
@@ -3729,7 +3749,7 @@ class Mul extends Seq {
     var isNum = expr => {
       return expr instanceof Num;
     };
-    const num = ___default["default"].find(this.terms, isNum);
+    const num = ___default.default.find(this.terms, isNum);
     if (num) {
       return this.replace(num, num.negate());
     } else {
@@ -3764,7 +3784,7 @@ class Mul extends Seq {
     // dividing by a Mul is the same as repeated division by its terms
     if (right instanceof Mul) {
       var first = Mul.handleDivide(left, right.terms[0]);
-      var rest = new Mul(___default["default"].rest(right.terms)).flatten();
+      var rest = new Mul(___default.default.rest(right.terms)).flatten();
       return Mul.handleDivide(first, rest);
     }
     var isInt = expr => {
@@ -3776,7 +3796,7 @@ class Mul extends Seq {
 
     // for simplification purposes, fold Ints into Rationals if possible
     // e.g. 3x / 4 -> 3/4 * x (will still render as 3x/4)
-    if (isInt(right) && left instanceof Mul && ___default["default"].any(left.terms, isInt)) {
+    if (isInt(right) && left instanceof Mul && ___default.default.any(left.terms, isInt)) {
       // search from the right
       var reversed = left.terms.slice().reverse();
       var num = reversed.find(isRational);
@@ -3849,8 +3869,8 @@ class Mul extends Seq {
     if (left instanceof Mul) {
       // NOTE(kevinb): `terms` should always have at least two
       // elements so getting the last element is safe to do.
-      var divided = divide(___default["default"].last(left.terms), right);
-      return new Mul(___default["default"].initial(left.terms).concat(divided));
+      var divided = divide(___default.default.last(left.terms), right);
+      return new Mul(___default.default.initial(left.terms).concat(divided));
     } else {
       var divided = divide(left, right);
       return new Mul(divided).flatten();
@@ -3872,17 +3892,17 @@ class Mul extends Seq {
   static fold(expr) {
     if (expr instanceof Mul) {
       // assuming that this will be second to last
-      var trigLog = ___default["default"].find(___default["default"].initial(expr.terms), term => {
+      var trigLog = ___default.default.find(___default.default.initial(expr.terms), term => {
         return (term instanceof Trig || term instanceof Log) && Boolean(term.hints.open);
       });
       if (trigLog) {
         // expr.terms should always have at least two terms
-        const last = ___default["default"].last(expr.terms);
+        const last = ___default.default.last(expr.terms);
         if (trigLog.hints.parens || last.hints.parens || last.has(Trig) || last.has(Log)) {
           trigLog.hints.open = false;
         } else {
           const newTrigLog = trigLog instanceof Trig ? Trig.create([trigLog.type, trigLog.exp], Mul.createOrAppend(trigLog.arg, last).fold()) : Log.create(trigLog.base, Mul.createOrAppend(trigLog.power, last).fold());
-          const index = ___default["default"].indexOf(expr.terms, trigLog);
+          const index = ___default.default.indexOf(expr.terms, trigLog);
           if (index === 0) {
             return newTrigLog;
           } else {
@@ -3908,9 +3928,9 @@ class Mul extends Seq {
       const negNum = numbers.find(neg);
       if (numbers.length > 1 && negNum && posNum &&
       // @ts-expect-error: Type 'Expr' is not assignable to type 'Num'.
-      ___default["default"].every(numbers, posOrNeg)) {
-        var firstNeg = ___default["default"].indexOf(expr.terms, negNum);
-        var firstNum = ___default["default"].indexOf(expr.terms, posNum);
+      ___default.default.every(numbers, posOrNeg)) {
+        var firstNeg = ___default.default.indexOf(expr.terms, negNum);
+        var firstNum = ___default.default.indexOf(expr.terms, posNum);
 
         // e.g. -x*2 -> x*-2
         if (firstNeg < firstNum) {
@@ -4042,7 +4062,7 @@ class Pow extends Expr {
     if (pow.base instanceof Mul) {
       // e.g. (ab)^c -> a^c*b^c
 
-      var terms = ___default["default"].map(pow.base.terms, term => {
+      var terms = ___default.default.map(pow.base.terms, term => {
         return new Pow(term, pow.exp);
       });
       return new Mul(terms).expand();
@@ -4071,10 +4091,10 @@ class Pow extends Expr {
       }
 
       // otherwise decompose n into powers of 2 ...
-      let indices = ___default["default"].map(n.toString(2).split(""), function (str, i, list) {
+      let indices = ___default.default.map(n.toString(2).split(""), function (str, i, list) {
         return Number(str) * Math.pow(2, list.length - i - 1);
       });
-      indices = ___default["default"].without(indices, 0);
+      indices = ___default.default.without(indices, 0);
 
       // ... then combine
       const factors = [];
@@ -4089,7 +4109,7 @@ class Pow extends Expr {
       // DEFINITELY want behind super-simplify() flag
       // e.g. x^(a+b) -> x^a*x^b
 
-      const terms = ___default["default"].map(pow.exp.terms, term => {
+      const terms = ___default.default.map(pow.exp.terms, term => {
         return new Pow(pow.base, term).expand();
       });
       return new Mul(terms).expand();
@@ -4100,7 +4120,7 @@ class Pow extends Expr {
   factor() {
     var pow = this.recurse("factor");
     if (pow.base instanceof Mul) {
-      var terms = ___default["default"].map(pow.base.terms, term => {
+      var terms = ___default.default.map(pow.base.terms, term => {
         if (term instanceof Int && pow.exp.equals(NumDiv)) {
           // Anything that can be a Rational should be a Rational
           // e.g. 2^(-1) -> 1/2
@@ -4136,7 +4156,7 @@ class Pow extends Expr {
     } else if (isSimilarLog(pow.exp)) {
       // e.g. b^(log_b(x)) -> x
       return pow.exp.power;
-    } else if (pow.exp instanceof Mul && ___default["default"].any(pow.exp.terms, isSimilarLog)) {
+    } else if (pow.exp instanceof Mul && ___default.default.any(pow.exp.terms, isSimilarLog)) {
       // e.g. b^(2*y*log_b(x)) -> x^(2*y)
       // `log` will always be defined here because of the
       // `_.any(pow.exp.terms, isSimilarLog)` check above.
@@ -4185,7 +4205,7 @@ class Pow extends Expr {
     var isDiv = function (arg) {
       return arg instanceof Num && Boolean(arg.hints.divide);
     };
-    return isDiv(this.exp) || this.exp instanceof Mul && ___default["default"].any(this.exp.terms, isDiv);
+    return isDiv(this.exp) || this.exp instanceof Mul && ___default.default.any(this.exp.terms, isDiv);
   }
 
   // assuming this Pow represents user-entered division, returns the denominator
@@ -4195,7 +4215,7 @@ class Pow extends Expr {
         return this.base;
       } else {
         var negated = this.exp.negate();
-        negated.hints = ___default["default"].clone(this.exp.hints);
+        negated.hints = ___default.default.clone(this.exp.hints);
         negated.hints.divide = false;
         return new Pow(this.base, negated);
       }
@@ -4360,7 +4380,7 @@ class Log extends Expr {
       // might want behind super-simplify() flag
       // e.g. ln(xy) -> ln(x) + ln(y)
 
-      var terms = ___default["default"].map(log.power.terms, term => {
+      var terms = ___default.default.map(log.power.terms, term => {
         // need to expand again in case new log powers are Pows
         return new Log(log.base, term).expand();
       });
@@ -4566,13 +4586,13 @@ class Trig extends Expr {
     }
   };
   isEven() {
-    return ___default["default"].contains(["cos", "sec"], this.type);
+    return ___default.default.contains(["cos", "sec"], this.type);
   }
   isInverse() {
     return this.type.indexOf("arc") === 0;
   }
   isBasic() {
-    return ___default["default"].contains(["sin", "cos"], this.type);
+    return ___default.default.contains(["sin", "cos"], this.type);
   }
   eval() {
     let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
@@ -4632,7 +4652,7 @@ class Trig extends Expr {
       // e.g. tan(x) -> sin(x)/cos(x)
       // NOTE(kevinb): All non-inverse trig functions have an expand property.
       var expand = trig.functions[trig.type].expand;
-      return ___default["default"].bind(expand, trig)();
+      return ___default.default.bind(expand, trig)();
     } else {
       return trig;
     }
@@ -4716,7 +4736,7 @@ class Abs extends Expr {
       return abs.arg.abs();
     } else if (abs.arg instanceof Mul) {
       // e.g. |-2*pi*x| -> 2*pi*|x|
-      var terms = ___default["default"].groupBy(abs.arg.terms, term => {
+      var terms = ___default.default.groupBy(abs.arg.terms, term => {
         if (term.isPositive()) {
           return "positive";
         } else if (term instanceof Num) {
@@ -4725,7 +4745,9 @@ class Abs extends Expr {
           return "other";
         }
       });
-      var positives = terms.positive.concat(___default["default"].invoke(terms.number, "abs"));
+      var positives = terms.positive.concat(___default.default.invoke(terms.number, "abs"));
+
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
       if (terms.other.length) {
         positives.push(new Abs(new Mul(terms.other).flatten()));
       }
@@ -4740,7 +4762,7 @@ class Abs extends Expr {
     var abs = this.recurse("expand");
     if (abs.arg instanceof Mul) {
       // e.g. |xyz| -> |x|*|y|*|z|
-      var terms = ___default["default"].map(abs.arg.terms, term => {
+      var terms = ___default.default.map(abs.arg.terms, term => {
         return new Abs(term);
       });
       return new Mul(terms);
@@ -4787,7 +4809,7 @@ class Eq extends Expr {
   }
   normalize() {
     var eq = this.recurse("normalize");
-    if (___default["default"].contains([">", ">="], eq.type)) {
+    if (___default.default.contains([">", ">="], eq.type)) {
       // inequalities should have the smaller side on the left
       return new Eq(eq.right, eq.type.replace(">", "<"), eq.left);
     } else {
@@ -4808,7 +4830,7 @@ class Eq extends Expr {
     // first convert to a sequence of additive terms
     let terms = [];
     if (this.left instanceof Add) {
-      terms = ___default["default"].clone(this.left.terms);
+      terms = ___default.default.clone(this.left.terms);
     } else if (!isZero(this.left)) {
       terms = [this.left];
     }
@@ -4824,7 +4846,7 @@ class Eq extends Expr {
     // float precision. We have to be very careful to not introduce any
     // irrational floats before asExpr() returns, because by definition
     // they do not have exact denominators...
-    terms = ___default["default"].invoke(terms, "collect", {
+    terms = ___default.default.invoke(terms, "collect", {
       preciseFloats: true
     });
 
@@ -4837,7 +4859,7 @@ class Eq extends Expr {
         denominator = denominator.asPositiveFactor();
       }
       if (!denominator.equals(NumOne)) {
-        terms = ___default["default"].map(terms, term => {
+        terms = ___default.default.map(terms, term => {
           return Mul.createOrAppend(term, denominator).simplify({
             once: true,
             preciseFloats: true
@@ -4865,29 +4887,35 @@ class Eq extends Expr {
       return expr;
     }
     const terms = factored.terms;
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     const hasVar = term => !!term.getVars().length;
     const isOne = term => term.equals(NumOne);
     const [adds, others] = partition(terms, isAdd);
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (adds.length && this.isEquality()) {
       // keep only Adds
       // e.g. 2xy(z+1)(=0) -> z+1(=0)
       return new Mul(adds).flatten();
     }
     let denominator = others;
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (!adds.length) {
       // if no Adds, keep all variable terms to preserve meaning
       // e.g. 42xyz(=0) -> xyz(=0)
-      denominator = ___default["default"].reject(denominator, hasVar);
+      denominator = ___default.default.reject(denominator, hasVar);
     }
     if (isInequality) {
       // can't divide inequalities by non 100% positive factors
       // e.g. 42x^2y(z+1)(=0) -> y(z+1)(=0)
-      denominator = ___default["default"].invoke(denominator, "asPositiveFactor");
+      denominator = ___default.default.invoke(denominator, "asPositiveFactor");
     }
 
     // don't need to divide by one
-    denominator = ___default["default"].reject(denominator, isOne);
-    denominator = ___default["default"].map(denominator, term => {
+    denominator = ___default.default.reject(denominator, isOne);
+    denominator = ___default.default.map(denominator, term => {
       return new Pow(term, NumDiv);
     });
     const dividedResult = new Mul(terms.concat(denominator)).collect();
@@ -4901,7 +4929,7 @@ class Eq extends Expr {
     }
   }
   isEquality() {
-    return ___default["default"].contains(["=", "<>"], this.type);
+    return ___default.default.contains(["=", "<>"], this.type);
   }
   compare(other) {
     // expression comparisons are handled by Expr.compare()
@@ -4954,7 +4982,7 @@ class Eq extends Expr {
       throw new Error("Can only handle linear equations of the form " + "a + bx (= 0)");
     }
     var hasVar = term => {
-      return term.has(Var) && ___default["default"].contains(term.getVars(), variable.symbol);
+      return term.has(Var) && ___default.default.contains(term.getVars(), variable.symbol);
     };
     const termHasVar = hasVar(expr.terms[0]);
     const a = termHasVar ? Mul.handleNegative(expr.terms[1]) : Mul.handleNegative(expr.terms[0]);
@@ -5001,7 +5029,7 @@ class Func extends Sym {
     let options = arguments.length > 1 ? arguments[1] : undefined;
     var arg = this.arg;
     var func = vars[this.symbol];
-    var newVars = ___default["default"].extend(___default["default"].clone(vars), {
+    var newVars = ___default.default.extend(___default.default.clone(vars), {
       x: arg.eval(vars, options)
     });
     var parsedFunc = parse(func, options);
@@ -5021,7 +5049,7 @@ class Func extends Sym {
     if (excludeFunc) {
       return this.arg.getVars();
     } else {
-      return ___default["default"].union(this.arg.getVars(), [this.symbol]).sort();
+      return ___default.default.union(this.arg.getVars(), [this.symbol]).sort();
     }
   }
   getConsts() {
@@ -5261,13 +5289,13 @@ class Num extends Expr {
     for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
       args[_key3] = arguments[_key3];
     }
-    return ___default["default"].min(args, num => num.eval());
+    return ___default.default.min(args, num => num.eval());
   }
   static max() {
     for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
       args[_key4] = arguments[_key4];
     }
-    return ___default["default"].max(args, num => num.eval());
+    return ___default.default.max(args, num => num.eval());
   }
 }
 
@@ -5532,9 +5560,9 @@ parser.yy = {
   parseError: parseError,
   constants: ["e"],
   symbolLexer: function (symbol) {
-    if (___default["default"].contains(parser.yy.constants, symbol)) {
+    if (___default.default.contains(parser.yy.constants, symbol)) {
       return "CONST";
-    } else if (___default["default"].contains(parser.yy.functions, symbol)) {
+    } else if (___default.default.contains(parser.yy.functions, symbol)) {
       return "FUNC";
     } else {
       return "VAR";
@@ -5545,7 +5573,7 @@ const parse = function (input, options) {
   try {
     if (options && options.functions) {
       // reserve the symbol "i" for complex numbers
-      parser.yy.functions = ___default["default"].without(options.functions, "i");
+      parser.yy.functions = ___default.default.without(options.functions, "i");
     } else {
       parser.yy.functions = [];
     }
@@ -5612,9 +5640,9 @@ class Unit extends Sym {
 
   // Simplify units by replacing prefixes with multiplication
   collect(options) {
-    if (___default["default"](baseUnits).has(this.symbol)) {
+    if (___default.default(baseUnits).has(this.symbol)) {
       return this;
-    } else if (___default["default"](derivedUnits).has(this.symbol)) {
+    } else if (___default.default(derivedUnits).has(this.symbol)) {
       return derivedUnits[this.symbol].conversion;
     } else {
       throw new Error("could not understand unit: " + this.symbol);
@@ -5627,12 +5655,12 @@ class Unit extends Sym {
 // "g" -> Unit("g")
 // "kg" -> 1000 * Unit("g")
 var unprefixify = function (symbol) {
-  if (___default["default"](baseUnits).has(symbol) || ___default["default"](derivedUnits).has(symbol)) {
+  if (___default.default(baseUnits).has(symbol) || ___default.default(derivedUnits).has(symbol)) {
     return new Unit(symbol);
   }
 
   // check for prefix
-  var prefix = ___default["default"](___default["default"](siPrefixes).keys()).find(testPrefix => {
+  var prefix = ___default.default(___default.default(siPrefixes).keys()).find(testPrefix => {
     return new RegExp("^" + testPrefix).test(symbol);
   });
   if (prefix) {
@@ -5644,7 +5672,7 @@ var unprefixify = function (symbol) {
     //
     // Otherwise, we're trying to parse a unit label which is not
     // allowed (mwk, mBTU, etc).
-    if (___default["default"](baseUnits).has(base) || derivedUnits[base] && derivedUnits[base].prefixes === hasPrefixes) {
+    if (___default.default(baseUnits).has(base) || derivedUnits[base] && derivedUnits[base].prefixes === hasPrefixes) {
       return new Mul(siPrefixes[prefix], new Unit(base));
     } else {
       throw new Error(base + " does not allow prefixes");
@@ -5673,10 +5701,10 @@ const unitParse = function (input) {
     // denom is optionally null
 
     const unitArray = [];
-    ___default["default"](parseResult.unit.num).each(unitSpec => {
+    ___default.default(parseResult.unit.num).each(unitSpec => {
       unitArray.push(new Pow(unprefixify(unitSpec.name), new Int(unitSpec.pow)));
     });
-    ___default["default"](parseResult.unit.denom).each(unitSpec => {
+    ___default.default(parseResult.unit.denom).each(unitSpec => {
       unitArray.push(new Pow(unprefixify(unitSpec.name), new Int(-1 * unitSpec.pow)));
     });
     var unit = new Mul(unitArray).flatten();