@khanacademy/kas 0.3.13 → 0.3.15

package/dist/es/index.js

@@ -3,9 +3,19 @@ import _ from 'underscore';
 
 // This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/kas";
-const libVersion = "0.3.13";
+const libVersion = "0.3.15";
 addLibraryVersionToPerseusDebug(libName, libVersion);
 
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
 // this is a @generated file
 
 /* parser generated by jison 0.4.15 */
@@ -2615,7 +2625,7 @@ var parser = function () {
   return new Parser();
 }();
 
-/* eslint-disable prettier/prettier */
+var _class5, _class12;
 
 /*  The node hierarcy is as follows:
 
@@ -2628,7 +2638,7 @@ var parser = function () {
         Eq              2 children
         Trig            1 child
         Abs             1 child
-        (Symbol)
+        (Sym)
             Func        1 child     e.g. f(x)
             Var         leaf node   e.g. x, x_n
             Const       leaf node   e.g. pi, e, <i>
@@ -2648,27 +2658,14 @@ var parser = function () {
 
 /* non user-facing functions */
 
-// assert that all abstract methods have been overridden
-var abstract = function abstract() {
-  // Try to give people a bit of information when this happens
-  throw new Error("Abstract method - must override for expr: " +
-  // eslint-disable-next-line @babel/no-invalid-this
-  this.print());
-};
-
-// throw an error that is meant to be caught by the test suite (not user facing)
-var error = function error(message) {
-  throw new Error(message);
-};
-
 // reliably detect NaN
-var isNaN = function isNaN(object) {
+const isNaN = function isNaN(object) {
   return object !== object;
 };
 
 // return a random float between min (inclusive) and max (exclusive),
 // not that inclusivity means much, probabilistically, on floats
-var randomFloat = function randomFloat(min, max) {
+const randomFloat = function randomFloat(min, max) {
   var extent = max - min;
   return Math.random() * extent + min;
 };
@@ -2677,53 +2674,113 @@ var randomFloat = function randomFloat(min, max) {
 var ITERATIONS = 12;
 var TOLERANCE = 9; // decimal places
 
+// NOTE(kevinb): _.partition exists in a more recent version of underscore.
+// To avoid having to update underscore I've added a hacky version of this
+// method here.
+function partition(list, iteratee) {
+  const a = [];
+  const b = [];
+  _.forEach(list, (elem, key, ctx) => {
+    if (iteratee(elem, key, ctx)) {
+      a.push(elem);
+    } else {
+      b.push(elem);
+    }
+  });
+  return [a, b];
+}
+function isExpr(arg) {
+  return arg instanceof Expr;
+}
+const isAdd = function isAdd(term) {
+  return term instanceof Add;
+};
+function isRational(arg) {
+  return arg instanceof Rational;
+}
+function getFactors(expr) {
+  if (expr instanceof Mul) {
+    return expr.terms;
+  } else {
+    return [expr];
+  }
+}
 /* abstract base expression node */
-function Expr() {}
-_.extend(Expr.prototype, {
+class Expr {
+  constructor() {
+    this.hints = void 0;
+    this.hints = {
+      parens: false
+    };
+  }
+
   // this node's immediate constructor
-  func: abstract,
+  // The `new (...args: any[]): any;` part of the type is a
+  // "construct" signature.  It indicates that `func` is a class.
+  // See https://www.typescriptlang.org/docs/handbook/2/functions.html#construct-signatures.
   // an array of the arguments to this node's immediate constructor
-  args: abstract,
   // make a new node with the given arguments
-  construct: function (args) {
-    var instance = new this.func();
-    this.func.apply(instance, args);
+  construct(args) {
+    const func = this.func;
+    const instance = new func(...args);
+    if (typeof instance === "undefined") {
+      throw new Error("constructor function returning undefined");
+    }
     return instance;
-  },
+  }
+
   // an abstraction for chainable, bottom-up recursion
-  recurse: function (method) {
-    var passed = Array.prototype.slice.call(arguments, 1);
+  // NOTE(kevinb): This method is highly dynamic.  It's possible that it
+  // could be made more type-safe using overload signatures.
+  recurse(method, ...passed) {
     var args = _.map(this.args(), function (arg) {
-      return _.isString(arg) ? arg : arg[method].apply(arg, passed);
+      return _.isString(arg) || _.isNumber(arg) ? arg : arg[method].apply(arg, passed);
     });
     return this.construct(args);
-  },
+  }
+
   // evaluate numerically with given variable mapping
-  eval: abstract,
-  codegen: abstract,
-  compile: function () {
+  // NOTE(kevin): This could made into an abstract method but
+  // Eq doesn't implement it.  This indicates that we probably
+  // need to introduce another class in our hierarchy.
+  eval(vars = {}, options) {
+    throw new Error("Abstract method - must override for expr: " +
+    // eslint-disable-next-line @babel/no-invalid-this
+    this.print());
+  }
+
+  // NOTE(kevin): This could made into an abstract method but
+  // Eq doesn't implement it.  This indicates that we probably
+  // need to introduce another class in our hierarchy.
+  codegen() {
+    throw new Error("Abstract method - must override for expr: " +
+    // eslint-disable-next-line @babel/no-invalid-this
+    this.print());
+  }
+  compile() {
     var code = this.codegen();
     try {
+      // @ts-expect-error: TypeScript doesn't want to unify
+      // `Function` with the `compile`'s return type.
       return new Function("vars", "return " + code + ";");
     } catch (e) {
       throw new Error("Function did not compile: " + code);
     }
-  },
+  }
+
   // returns a string unambiguously representing the expression
   // should be valid as input
   // e.g. this.equals(parse(this.print())) === true
-  print: abstract,
   // returns a TeX string representing the expression
-  tex: abstract,
   // returns a TeX string, modified by the given options
-  asTex: function (options) {
+  asTex(options) {
     options = options || {};
     _.defaults(options, {
       display: true,
       dynamic: true,
       times: false
     });
-    var tex = this.tex();
+    let tex = this.tex();
     if (options.display) {
       tex = "\\displaystyle " + tex;
     }
@@ -2735,49 +2792,54 @@ _.extend(Expr.prototype, {
       tex = tex.replace(/\\cdot/g, "\\times");
     }
     return tex;
-  },
+  }
+
   // returns the name of this expression's constructor as a string
-  // only used for testing and debugging (the ugly regex is for IE8)
-  name: function () {
-    if (this.func.name) {
-      return this.func.name;
-    } else {
-      return this.func.toString().match(/^function\s*([^\s(]+)/)[1];
-    }
-  },
+  // only used for testing and debugging
+  name() {
+    return this.func.name;
+  }
+
   // returns a string representing current node structure
-  repr: function () {
+  repr() {
     return this.name() + "(" + _.map(this.args(), function (arg) {
-      return _.isString(arg) ? arg : arg.repr();
+      return _.isString(arg) || _.isNumber(arg) ? arg : arg.repr();
     }).join(",") + ")";
-  },
+  }
+
   // removes all negative signs
-  strip: function () {
+  strip() {
     return this.recurse("strip");
-  },
+  }
+
   // canonically reorders all commutative elements
-  normalize: function () {
+  normalize() {
     return this.recurse("normalize");
-  },
+  }
+
   // expands the expression
-  expand: function () {
+  expand() {
     return this.recurse("expand");
-  },
+  }
+
   // naively factors out like terms
-  factor: function (options) {
+  factor(options) {
     return this.recurse("factor", options);
-  },
+  }
+
   // collect all like terms
-  collect: function (options) {
+  collect(options) {
     return this.recurse("collect", options);
-  },
+  }
+
   // strict syntactic equality check
-  equals: function (other) {
+  equals(other) {
     return this.normalize().print() === other.normalize().print();
-  },
+  }
+
   // expand and collect until the expression no longer changes
-  simplify: function (options) {
-    options = _.extend({
+  simplify(options) {
+    options = _extends({
       once: false
     }, options);
 
@@ -2791,7 +2853,7 @@ _.extend(Expr.prototype, {
     }
 
     // Attempt to expand and collect
-    var step3 = step2.expand(options);
+    var step3 = step2.expand();
     var step4 = step3.collect(options);
 
     // Rollback if collect didn't do anything
@@ -2806,62 +2868,69 @@ _.extend(Expr.prototype, {
     } else {
       return simplified.simplify(options);
     }
-  },
+  }
+
   // check whether this expression is simplified
-  isSimplified: function () {
+  isSimplified() {
     return this.equals(this.simplify());
-  },
+  }
+
   // return the child nodes of this node
-  exprArgs: function () {
-    return _.filter(this.args(), function (arg) {
-      return arg instanceof Expr;
-    });
-  },
+  exprArgs() {
+    return this.args().filter(isExpr);
+  }
+
   // return the variables (function and non) within the expression
-  getVars: function (excludeFunc) {
+  getVars(excludeFunc) {
     return _.uniq(_.flatten(_.invoke(this.exprArgs(), "getVars", excludeFunc))).sort();
-  },
-  getConsts: function () {
+  }
+  getConsts() {
     return _.uniq(_.flatten(_.invoke(this.exprArgs(), "getConsts"))).sort();
-  },
-  getUnits: function () {
+  }
+  getUnits() {
     return _.flatten(_.invoke(this.exprArgs(), "getUnits"));
-  },
+  }
+
   // check whether this expression node is of a particular type
-  is: function (func) {
+  is(func) {
     return this instanceof func;
-  },
+  }
+
   // check whether this expression has a particular node type
-  has: function (func) {
+  has(func) {
     if (this instanceof func) {
       return true;
     }
     return _.any(this.exprArgs(), function (arg) {
       return arg.has(func);
     });
-  },
+  }
+
   // raise this expression to a given exponent
   // most useful for eventually implementing i^3 = -i, etc.
-  raiseToThe: function (exp) {
+  raiseToThe(exp, options) {
     return new Pow(this, exp);
-  },
+  }
+
   // does this expression have a specific rendering hint?
   // rendering hints are picked up while parsing, but are lost during transformations
-  isSubtract: function () {
+  isSubtract() {
     return false;
-  },
-  isDivide: function () {
+  }
+  isDivide() {
     return false;
-  },
-  isRoot: function () {
+  }
+  isRoot() {
     return false;
-  },
+  }
+
   // whether this node needs an explicit multiplication sign if following a Num
-  needsExplicitMul: function () {
-    return this.args()[0].needsExplicitMul();
-  },
+  needsExplicitMul() {
+    return this.exprArgs()[0].needsExplicitMul();
+  }
+
   // check that the variables in both expressions are the same
-  sameVars: function (other) {
+  sameVars(other) {
     var vars1 = this.getVars();
     var vars2 = other.getVars();
 
@@ -2879,11 +2948,12 @@ _.extend(Expr.prototype, {
       equal: equal,
       equalIgnoringCase: equalIgnoringCase
     };
-  },
+  }
+
   // semantic equality check, call after sameVars() to avoid potential false positives
   // plug in random numbers for the variables in both expressions
   // if they both consistently evaluate the same, then they're the same
-  compare: function (other) {
+  compare(other) {
     // equation comparisons are handled by Eq.compare()
     if (other instanceof Eq) {
       return false;
@@ -2954,14 +3024,14 @@ _.extend(Expr.prototype, {
       _.each(varList, function (v) {
         vars[v] = useFloats ? randomFloat(-range, range) : _.random(-range, range);
       });
-      var equal;
+      let equal;
       if (expr1.has(Func) || expr2.has(Func) || expr1.has(Unit) || expr2.has(Unit)) {
-        var result1 = expr1.partialEval(vars);
-        var result2 = expr2.partialEval(vars);
+        const result1 = expr1.partialEval(vars);
+        const result2 = expr2.partialEval(vars);
         equal = result1.simplify().equals(result2.simplify());
       } else {
-        var result1 = expr1.eval(vars);
-        var result2 = expr2.eval(vars);
+        const result1 = expr1.eval(vars);
+        const result2 = expr2.eval(vars);
         equal = equalNumbers(result1, result2);
       }
       if (!equal) {
@@ -2969,52 +3039,65 @@ _.extend(Expr.prototype, {
       }
     }
     return true;
-  },
+  }
+
   // evaluate as much of the expression as possible
-  partialEval: function (vars) {
+  partialEval(vars) {
     if (this instanceof Unit) {
       return this;
     } else if (!this.has(Func)) {
-      return new Float(this.eval(vars).toFixed(TOLERANCE)).collect();
+      return new Float(+this.eval(vars).toFixed(TOLERANCE)).collect();
     } else if (this instanceof Func) {
       return new Func(this.symbol, this.arg.partialEval(vars));
     } else {
       return this.recurse("partialEval", vars);
     }
-  },
+  }
+
   // check that the structure of both expressions is the same
   // all negative signs are stripped and the expressions are converted to
   // a canonical commutative form
   // should only be done after compare() returns true to avoid false positives
-  sameForm: function (other) {
+  sameForm(other) {
     return this.strip().equals(other.strip());
-  },
+  }
+
   // returns the GCD of this expression and the given factor
-  findGCD: function (factor) {
-    return this.equals(factor) ? factor : Num.One;
-  },
+  findGCD(factor) {
+    return this.equals(factor) ? factor : NumOne;
+  }
+
   // return this expression's denominator
-  getDenominator: function () {
-    return Num.One;
-  },
+  getDenominator() {
+    return NumOne;
+  }
+
   // return this expression as a Mul
-  asMul: function () {
-    return new Mul(Num.One, this);
-  },
+  asMul() {
+    return new Mul(NumOne, this);
+  }
+
   // TODO(alex): rename to isDefinitePositive or similar?
   // return whether this expression is 100% positive
-  isPositive: abstract,
+  isPositive() {
+    throw new Error("Abstract method - must override for expr: " +
+    // eslint-disable-next-line @babel/no-invalid-this
+    this.print());
+  }
+
   // TODO(alex): rename to hasNegativeSign or similar?
   // return whether this expression has a negative sign
-  isNegative: function () {
+  isNegative() {
     return false;
-  },
+  }
+
   // return a factor of this expression that is 100% positive
-  asPositiveFactor: function () {
-    return this.isPositive() ? this : Num.One;
-  },
+  asPositiveFactor() {
+    return this.isPositive() ? this : NumOne;
+  }
+
   // return a copy of the expression with a new hint set (preserves hints)
-  addHint: function (hint) {
+  addHint(hint) {
     if (!hint) {
       return this;
     }
@@ -3022,141 +3105,139 @@ _.extend(Expr.prototype, {
     expr.hints = _.clone(this.hints);
     expr.hints[hint] = true;
     return expr;
-  },
-  hints: {
-    parens: false
-  },
-  // currently unused!
-  asExpr: function () {
-    return this;
-  },
+  }
+
   // complete parse by performing a few necessary transformations
-  completeParse: function () {
+  completeParse() {
     return this.recurse("completeParse");
-  },
-  abs: abstract,
-  negate: function () {
-    return new Mul(Num.Neg, this);
   }
-});
+  abs() {
+    throw new Error("Abstract method - must override for expr: " +
+    // eslint-disable-next-line @babel/no-invalid-this
+    this.print());
+  }
+  negate() {
+    return new Mul(NumNeg, this);
+  }
+}
 
 /* abstract sequence node */
-function Seq() {}
-Seq.prototype = new Expr();
-_.extend(Seq.prototype, {
-  args: function () {
+class Seq extends Expr {
+  // TODO(kevinb): Update this use `...args: Expr[]`
+  constructor(...args) {
+    super();
+    // This should always have at least two terms.
+    // TODO(kevinb): Try enforcing this at the type-level using [T, T, T[]]
+    this.terms = void 0;
+    if (args.length === 1) {
+      this.terms = args[0];
+    } else {
+      this.terms = args;
+    }
+  }
+  args() {
     return this.terms;
-  },
-  normalize: function () {
-    var terms = _.sortBy(_.invoke(this.terms, "normalize"), function (term) {
+  }
+  normalize() {
+    var terms = _.sortBy(_.invoke(this.terms, "normalize"), term => {
       return term.print();
     });
     return new this.func(terms);
-  },
-  expand: function () {
+  }
+  expand() {
     return this.recurse("expand").flatten();
-  },
+  }
+
   // partition the sequence into its numeric and non-numeric parts
   // makes no guarantees about the validity of either part!
-  partition: function () {
-    var terms = _.groupBy(this.terms, function (term) {
+  partition() {
+    var [numbers, others] = partition(this.terms, term => {
       return term instanceof Num;
     });
-
-    // XXX using a boolean as a key just converts it to a string. I don't
-    // think this code was written with that in mind. Probably doesn't
-    // matter except for readability.
-    var numbers = terms[true] || [];
-    var others = terms[false] || [];
     return [new this.func(numbers), new this.func(others)];
-  },
+  }
+
   // ensure that sequences have 2+ terms and no nested sequences of the same type
   // this is a shallow flattening and will return a non-Seq if terms.length <= 1
-  flatten: function () {
+  flatten() {
     var type = this;
-    var terms = _.reject(this.terms, function (term) {
+    var terms = _.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);
     });
     if (terms.length === 0) {
+      // @ts-expect-error: `identity` is defined on Add and Mul but doesn't
+      // exist on Seq itself.
       return type.identity;
     }
     if (terms.length === 1) {
       return terms[0];
     }
-    var grouped = _.groupBy(terms, function (term) {
-      return term instanceof type.func;
-    });
 
     // same contains the children which are Seqs of the same type as this Seq
-    var same = grouped[true] || [];
-    var others = grouped[false] || [];
+    const [same, others] = partition(terms, term => {
+      return term instanceof type.func;
+    });
     var flattened = others.concat(_.flatten(_.pluck(same, "terms"), /* shallow: */true));
     return new type.func(flattened);
-  },
-  // the identity associated with the sequence
-  identity: undefined,
+  }
+
   // reduce a numeric sequence to a Num
-  reduce: abstract,
-  isPositive: function () {
+
+  isPositive() {
     var terms = _.invoke(this.terms, "collect");
     return _.all(_.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: function (oldTerm, newTerm) {
-    var index;
-    if (oldTerm instanceof Expr) {
-      index = _.indexOf(this.terms, oldTerm);
-    } else {
-      index = oldTerm;
-    }
+  replace(oldTerm, newTerm) {
+    const index = oldTerm instanceof Expr ? _.indexOf(this.terms, oldTerm) : oldTerm;
     var newTerms = [];
-    if (_.isArray(newTerm)) {
+    if (Array.isArray(newTerm)) {
       newTerms = newTerm;
     } else if (newTerm) {
       newTerms = [newTerm];
     }
     var terms = this.terms.slice(0, index).concat(newTerms).concat(this.terms.slice(index + 1));
     return new this.func(terms);
-  },
+  }
+
   // syntactic sugar for replace()
-  remove: function (term) {
+  remove(term) {
     return this.replace(term);
-  },
-  getDenominator: function () {
+  }
+  getDenominator() {
     // TODO(alex): find and return LCM
     return new Mul(_.invoke(this.terms, "getDenominator")).flatten();
   }
-});
+}
 
 /* sequence of additive terms */
-function Add() {
-  if (arguments.length === 1) {
-    this.terms = arguments[0];
-  } else {
-    this.terms = _.toArray(arguments);
+class Add extends Seq {
+  constructor(...args) {
+    super(...args);
+    this.identity = NumZero;
+    this.func = Add;
   }
-}
-Add.prototype = new Seq();
-_.extend(Add.prototype, {
-  func: Add,
-  eval: function (vars, options) {
-    return _.reduce(this.terms, function (memo, term) {
+  eval(vars = {}, options) {
+    return _.reduce(this.terms, (memo, term) => {
       return memo + term.eval(vars, options);
     }, 0);
-  },
-  codegen: function () {
-    return _.map(this.terms, function (term) {
+  }
+  codegen() {
+    return _.map(this.terms, term => {
       return "(" + term.codegen() + ")";
     }).join(" + ") || "0";
-  },
-  print: function () {
+  }
+  print() {
     return _.invoke(this.terms, "print").join("+");
-  },
-  tex: function () {
-    var tex = "";
-    _.each(this.terms, function (term) {
+  }
+  tex() {
+    let tex = "";
+    _.each(this.terms, term => {
       if (!tex || term.isSubtract()) {
         tex += term.tex();
       } else {
@@ -3164,28 +3245,26 @@ _.extend(Add.prototype, {
       }
     });
     return tex;
-  },
-  collect: function (options) {
+  }
+  collect(options) {
     var terms = _.invoke(this.terms, "collect", options);
-
-    // [Expr expr, Num coefficient]
     var pairs = [];
-    _.each(terms, function (term) {
+    _.each(terms, term => {
       if (term instanceof Mul) {
         var muls = term.partition();
         pairs.push([muls[1].flatten(), muls[0].reduce(options)]);
       } else if (term instanceof Num) {
-        pairs.push([Num.One, term]);
+        pairs.push([NumOne, term]);
       } else {
-        pairs.push([term, Num.One]);
+        pairs.push([term, NumOne]);
       }
     });
 
     // { (Expr expr).print(): [[Expr expr, Num coefficient]] }
-    var grouped = _.groupBy(pairs, function (pair) {
+    var grouped = _.groupBy(pairs, pair => {
       return pair[0].normalize().print();
     });
-    var collected = _.compact(_.map(grouped, function (pairs) {
+    var collected = _.compact(_.map(grouped, pairs => {
       var expr = pairs[0][0];
       var sum = new Add(_.zip.apply(_, pairs)[1]);
       var coefficient = sum.reduce(options);
@@ -3196,90 +3275,94 @@ _.extend(Add.prototype, {
     // e.g. x*sin^2(y) + x*cos^2(y) -> x
 
     return new Add(collected).flatten();
-  },
+  }
+
   // naively factor out anything that is common to all terms
   // if options.keepNegative is specified, won't factor out a common -1
-  factor: function (options) {
-    options = _.extend({
-      keepNegative: false
-    }, options);
-    var terms = _.invoke(this.terms, "collect");
-    var factors;
+  factor(options = {
+    keepNegative: false
+  }) {
+    const terms = this.terms.map(term => term.collect());
+    let factors;
     if (terms[0] instanceof Mul) {
       factors = terms[0].terms;
     } else {
       factors = [terms[0]];
     }
-    _.each(_.rest(this.terms), function (term) {
-      factors = _.map(factors, function (factor) {
+    _.each(_.rest(this.terms), term => {
+      factors = _.map(factors, factor => {
         return term.findGCD(factor);
       });
     });
     if (!options.keepNegative && this.isNegative()) {
-      factors.push(Num.Neg);
+      factors.push(NumNeg);
     }
-    factors = new Mul(factors).flatten().collect();
-    var remainder = _.map(terms, function (term) {
-      return Mul.handleDivide(term, factors).simplify();
-    });
-    remainder = new Add(remainder).flatten();
-    return Mul.createOrAppend(factors, remainder).flatten();
-  },
-  reduce: function (options) {
-    return _.reduce(this.terms, function (memo, term) {
+    const left = new Mul(factors).flatten().collect();
+    const remainder = terms.map(term => Mul.handleDivide(term, left).simplify());
+    const right = new Add(remainder).flatten();
+    return Mul.createOrAppend(left, right).flatten();
+  }
+  reduce(options) {
+    return _.reduce(this.terms, (memo, term) => {
       return memo.add(term, options);
     }, this.identity);
-  },
-  needsExplicitMul: function () {
+  }
+  needsExplicitMul() {
     return false;
-  },
-  isNegative: function () {
+  }
+  isNegative() {
     var terms = _.invoke(this.terms, "collect");
     return _.all(_.invoke(terms, "isNegative"));
-  },
-  negate: function () {
+  }
+  negate() {
     return new Add(_.invoke(this.terms, "negate"));
   }
-});
 
-/* sequence of multiplicative terms */
-function Mul() {
-  if (arguments.length === 1) {
-    this.terms = arguments[0];
-  } else {
-    this.terms = _.toArray(arguments);
+  // create a new sequence unless left is already one (returns a copy)
+  static createOrAppend(left, right) {
+    if (left instanceof Add) {
+      return new Add(left.terms.concat(right));
+    } else {
+      return new Add(left, right);
+    }
   }
 }
-Mul.prototype = new Seq();
-_.extend(Mul.prototype, {
-  func: Mul,
-  eval: function (vars, options) {
-    return _.reduce(this.terms, function (memo, term) {
+
+/* sequence of multiplicative terms */
+class Mul extends Seq {
+  constructor(...args) {
+    super(...args);
+    this.identity = NumOne;
+    this.func = Mul;
+  }
+  eval(vars = {}, options) {
+    return _.reduce(this.terms, (memo, term) => {
       return memo * term.eval(vars, options);
     }, 1);
-  },
-  codegen: function () {
-    return _.map(this.terms, function (term) {
+  }
+  codegen() {
+    return _.map(this.terms, term => {
       return "(" + term.codegen() + ")";
     }).join(" * ") || "0";
-  },
-  print: function () {
-    return _.map(this.terms, function (term) {
+  }
+  print() {
+    return _.map(this.terms, term => {
       return term instanceof Add ? "(" + term.print() + ")" : term.print();
     }).join("*");
-  },
-  getUnits: function () {
-    var tmUnits = _(this.terms).chain().map(function (term) {
+  }
+  getUnits() {
+    var tmUnits = _(this.terms).chain().map(term => {
       return term.getUnits();
     }).flatten().value();
     tmUnits.sort((a, b) => a.unit.localeCompare(b.unit));
     return tmUnits;
-  },
+  }
+
   // since we don't care about commutativity, we can render a Mul any way we choose
   // so we follow convention: first any negatives, then any numbers, then everything else
-  tex: function () {
+  tex() {
     var cdot = " \\cdot ";
-    var terms = _.groupBy(this.terms, function (term) {
+    var terms = _.groupBy(this.terms, term => {
       if (term.isDivide()) {
         return "inverse";
       } else if (term instanceof Num) {
@@ -3306,12 +3389,11 @@ _.extend(Mul.prototype, {
         return numbers[i].tex() + new Mul(newTerms).tex();
       }
     }
-    numbers = _.compact(_.map(numbers, function (term) {
-      var hasDenom = term instanceof Rational && !(term instanceof Int);
+    numbers = _.compact(_.map(numbers, term => {
       var shouldPushDown = !term.hints.fraction || inverses.length > 0;
-      if (hasDenom && shouldPushDown) {
+      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), Num.Div));
+        inverses.push(new Pow(new Int(term.d), NumDiv));
         var number = new Int(term.n);
         number.hints = term.hints;
         return _.any(term.hints) ? number : null;
@@ -3324,7 +3406,7 @@ _.extend(Mul.prototype, {
       numerator = others[0].tex();
     } else {
       var tex = "";
-      _.each(numbers, function (term) {
+      _.each(numbers, term => {
         if (term.hints.subtract && term.hints.entered) {
           negatives += "-";
           tex += (tex ? cdot : "") + term.abs().tex();
@@ -3337,7 +3419,7 @@ _.extend(Mul.prototype, {
           tex += (tex ? cdot : "") + term.tex();
         }
       });
-      _.each(others, function (term) {
+      _.each(others, term => {
         if (term.needsExplicitMul()) {
           // e.g. 2*2^3 -> 2(dot)2^3
           tex += (tex ? cdot : "") + term.tex();
@@ -3357,76 +3439,69 @@ _.extend(Mul.prototype, {
       var denominator = new Mul(_.invoke(inverses, "asDivide")).flatten().tex();
       return negatives + "\\frac{" + numerator + "}{" + denominator + "}";
     }
-  },
-  strip: function () {
-    var terms = _.map(this.terms, function (term) {
+  }
+  strip() {
+    var terms = _.map(this.terms, term => {
       return term instanceof Num ? term.abs() : term.strip();
     });
     return new Mul(terms).flatten();
-  },
+  }
+
   // expand numerator and denominator separately
-  expand: function () {
-    var isAdd = function isAdd(term) {
-      return term instanceof Add;
-    };
-    var isInverse = function isInverse(term) {
+  expand() {
+    const isInverse = function isInverse(term) {
       return term instanceof Pow && term.exp.isNegative();
     };
-    var isInverseAdd = function isInverseAdd(term) {
+    const isInverseAdd = function isInverseAdd(term) {
       return isInverse(term) && isAdd(term.base);
     };
-    var mul = this.recurse("expand").flatten();
-    var hasAdd = _.any(mul.terms, isAdd);
-    var hasInverseAdd = _.any(mul.terms, isInverseAdd);
+    const mul = this.recurse("expand").flatten();
+    const factors = getFactors(mul);
+    const hasAdd = _.any(factors, isAdd);
+    const hasInverseAdd = _.any(factors, isInverseAdd);
     if (!(hasAdd || hasInverseAdd)) {
       return mul;
     }
-    var terms = _.groupBy(mul.terms, isInverse);
-    var normals = terms[false] || [];
-    var inverses = terms[true] || [];
+    let [inverses, normals] = partition(factors, isInverse);
     if (hasAdd) {
-      var grouped = _.groupBy(normals, isAdd);
-      var adds = grouped[true] || [];
-      var others = grouped[false] || [];
+      const [adds, others] = partition(normals, isAdd);
 
       // loop over each additive sequence
-      var expanded = _.reduce(adds, function (expanded, add) {
+      const expanded = _.reduce(adds, function (expanded, add) {
         // loop over each expanded array of terms
         return _.reduce(expanded, function (temp, array) {
           // loop over each additive sequence's terms
-          return temp.concat(_.map(add.terms, function (term) {
-            return array.concat(term);
-          }));
+          return temp.concat(_.map(add.terms, term => array.concat(term)));
         }, []);
       }, [[]]);
 
       // join each fully expanded array of factors with remaining multiplicative factors
-      var muls = _.map(expanded, function (array) {
+      const muls = _.map(expanded, function (array) {
         return new Mul(others.concat(array)).flatten();
       });
       normals = [new Add(muls)];
     }
     if (hasInverseAdd) {
-      var denominator = new Mul(_.invoke(inverses, "getDenominator")).flatten();
-      inverses = [new Pow(denominator.expand(), Num.Div)];
+      const denominator = new Mul(_.invoke(inverses, "getDenominator")).flatten();
+      inverses = [new Pow(denominator.expand(), NumDiv)];
     }
     return new Mul(normals.concat(inverses)).flatten();
-  },
-  factor: function (options) {
+  }
+  factor(options) {
     var factored = this.recurse("factor", options).flatten();
     if (!(factored instanceof Mul)) {
       return factored;
     }
 
     // Combine any factored out Rationals into one, but don't collect
-    var grouped = _.groupBy(factored.terms, function (term) {
+    var [rationals, others] = partition(factored.terms, term => {
       return term instanceof Rational;
     });
 
     // 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
-    var rational = _.reduce(grouped[true], function (memo, term) {
+    const ratObj = _.reduce(rationals, (memo, term) => {
       return {
         n: memo.n * term.n,
         d: memo.d * term.d
@@ -3435,47 +3510,39 @@ _.extend(Mul.prototype, {
       n: 1,
       d: 1
     });
-    if (rational.d === 1) {
-      rational = new Int(rational.n);
-    } else {
-      rational = new Rational(rational.n, rational.d);
-    }
-    return new Mul((grouped[false] || []).concat(rational)).flatten();
-  },
-  collect: function (options) {
+    const rational = ratObj.d === 1 ? new Int(ratObj.n) : new Rational(ratObj.n, ratObj.d);
+    return new Mul(others.concat(rational)).flatten();
+  }
+  collect(options) {
     var partitioned = this.recurse("collect", options).partition();
     var number = partitioned[0].reduce(options);
 
     // e.g. 0*x -> 0
     if (number.eval() === 0) {
-      return Num.Zero;
+      return NumZero;
     }
-    var others = partitioned[1].flatten();
+    const other = partitioned[1].flatten();
 
     // e.g. 2*2 -> 4
     // e.g. 2*2*x -> 4*x
-    if (!(others instanceof Mul)) {
-      return new Mul(number, others).flatten();
+    if (!(other instanceof Mul)) {
+      return new Mul(number, other).flatten();
     }
-    others = others.terms;
-
-    // [Expr base, Expr exp]
+    const others = other.terms;
     var pairs = [];
-    _.each(others, function (term) {
+    _.each(others, term => {
       if (term instanceof Pow) {
         pairs.push([term.base, term.exp]);
       } else {
-        pairs.push([term, Num.One]);
+        pairs.push([term, NumOne]);
       }
     });
 
     // {(Expr base).print(): [[Expr base, Expr exp]]}
-    var grouped = _.groupBy(pairs, function (pair) {
+    var grouped = _.groupBy(pairs, pair => {
       return pair[0].normalize().print();
     });
-
-    // [[Expr base, Expr exp]]
-    var summed = _.compact(_.map(grouped, function (pairs) {
+    var summed = _.compact(_.map(grouped, pairs => {
       var base = pairs[0][0];
       var sum = new Add(_.zip.apply(_, pairs)[1]);
       var exp = sum.collect(options);
@@ -3487,7 +3554,7 @@ _.extend(Mul.prototype, {
     }));
 
     // XXX `pairs` is shadowed four or five times in this function
-    var pairs = _.groupBy(summed, function (pair) {
+    const groupedPairs = _.groupBy(summed, pair => {
       if (pair[0] instanceof Trig && pair[0].isBasic()) {
         return "trig";
       } else if (pair[0] instanceof Log) {
@@ -3496,26 +3563,26 @@ _.extend(Mul.prototype, {
         return "expr";
       }
     });
-    var trigs = pairs.trig || [];
-    var logs = pairs.log || [];
-    var exprs = pairs.expr || [];
+    let trigs = groupedPairs.trig || [];
+    let logs = groupedPairs.log || [];
+    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 = _.groupBy(trigs, function (pair) {
+      var byArg = _.groupBy(trigs, pair => {
         return pair[0].arg.normalize().print();
       });
       trigs = [];
-      _.each(byArg, function (pairs) {
-        var arg = pairs[0][0].arg;
+      _.each(byArg, pairs => {
+        const arg = pairs[0][0].arg;
 
         // {Trig.type: Expr exp}
-        var funcs = {
-          sin: Num.Zero,
-          cos: Num.Zero
+        let funcs = {
+          sin: NumZero,
+          cos: NumZero
         };
-        _.each(pairs, function (pair) {
+        _.each(pairs, pair => {
           funcs[pair[0].type] = pair[1];
         });
         if (Mul.handleNegative(funcs.sin).collect(options).equals(funcs.cos)) {
@@ -3534,7 +3601,7 @@ _.extend(Mul.prototype, {
         // TODO(alex): combine even if exponents not a perfect match
         // TODO(alex): transform 1/sin and 1/cos into csc and sec
 
-        _.each(funcs, function (exp, type) {
+        _.each(funcs, (exp, type) => {
           trigs.push([new Trig(type, arg), exp]);
         });
       });
@@ -3543,11 +3610,11 @@ _.extend(Mul.prototype, {
       // combine logs with the same base
 
       // {Log.base.print(): [[Log base, Expr exp]]}
-      var byBase = _.groupBy(logs, function (pair) {
+      var byBase = _.groupBy(logs, pair => {
         return pair[0].base.normalize().print();
       });
       logs = [];
-      _.each(byBase, function (pairs) {
+      _.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)
@@ -3567,25 +3634,25 @@ _.extend(Mul.prototype, {
       // TODO(alex): combine if all inverses are the same e.g. ln(y)*ln(z)/ln(x)/ln(x)
     }
 
-    pairs = trigs.concat(logs).concat(exprs);
-    var collected = _.map(pairs, function (pair) {
+    var collected = _.map([...trigs, ...logs, ...exprs], pair => {
       return new Pow(pair[0], pair[1]).collect(options);
     });
     return new Mul([number].concat(collected)).flatten();
-  },
-  isSubtract: function () {
-    return _.any(this.terms, function (term) {
-      return term instanceof Num && term.hints.subtract;
+  }
+  isSubtract() {
+    return _.any(this.terms, term => {
+      return term instanceof Num && Boolean(term.hints.subtract);
     });
-  },
+  }
+
   // factor a single -1 in to the Mul
   // combine with a Num if all Nums are positive, else add as a term
-  factorIn: function (hint) {
+  factorIn(hint) {
     var partitioned = this.partition();
+    // `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 && _.all(numbers, function (num) {
-      return num.n > 0;
-    });
+    var fold = numbers.length && _.all(numbers, num => num.n > 0);
     if (fold) {
       // e.g. - x*2*3 -> x*-2*3
       var num = numbers[0].negate();
@@ -3596,12 +3663,13 @@ _.extend(Mul.prototype, {
       // e.g. - x*-2 -> -1*x*-2
       return new Mul([Num.negativeOne(hint)].concat(this.terms));
     }
-  },
+  }
+
   // factor out a single hinted -1 (assume it is the division hint)
   // TODO(alex): make more general or rename to be more specific
-  factorOut: function () {
+  factorOut() {
     var factored = false;
-    var terms = _.compact(_.map(this.terms, function (term, i, list) {
+    var terms = _.compact(_.map(this.terms, term => {
       if (!factored && term instanceof Num && term.hints.divide) {
         factored = true;
         return term.n !== -1 ? term.negate() : null;
@@ -3614,64 +3682,50 @@ _.extend(Mul.prototype, {
     } else {
       return new Mul(terms);
     }
-  },
-  reduce: function (options) {
-    return _.reduce(this.terms, function (memo, term) {
+  }
+  reduce(options) {
+    return _.reduce(this.terms, (memo, term) => {
       return memo.mul(term, options);
     }, this.identity);
-  },
-  findGCD: function (factor) {
+  }
+  findGCD(factor) {
     return new Mul(_.invoke(this.terms, "findGCD", factor)).flatten();
-  },
-  asMul: function () {
+  }
+  asMul() {
     return this;
-  },
-  asPositiveFactor: function () {
+  }
+  asPositiveFactor() {
     if (this.isPositive()) {
       return this;
     } else {
-      var terms = _.invoke(this.collect().terms, "asPositiveFactor");
+      const terms = getFactors(this.collect()).map(factor => factor.asPositiveFactor());
       return new Mul(terms).flatten();
     }
-  },
-  isNegative: function () {
-    return _.any(_.invoke(this.collect().terms, "isNegative"));
-  },
-  fold: function () {
+  }
+  isNegative() {
+    const terms = getFactors(this.collect()).map(factor => factor.isNegative());
+    return _.any(terms);
+  }
+  fold() {
     return Mul.fold(this);
-  },
-  negate: function () {
-    var isNum = function isNum(expr) {
+  }
+  negate() {
+    var isNum = expr => {
       return expr instanceof Num;
     };
-    if (_.any(this.terms, isNum)) {
-      var num = _.find(this.terms, isNum);
+    const num = _.find(this.terms, isNum);
+    if (num) {
       return this.replace(num, num.negate());
     } else {
-      return new Mul([Num.Neg].concat(this.terms));
+      return new Mul([NumNeg].concat(this.terms));
     }
   }
-});
 
-// static methods for the sequence types
-_.each([Add, Mul], function (type) {
-  _.extend(type, {
-    // create a new sequence unless left is already one (returns a copy)
-    createOrAppend: function (left, right) {
-      if (left instanceof type) {
-        return new type(left.terms.concat(right));
-      } else {
-        return new type(left, right);
-      }
-    }
-  });
-});
-_.extend(Mul, {
   // negative signs should be folded into numbers whenever possible
   // never fold into a Num that's already negative or a Mul that has a negative Num
   // an optional hint is kept track of to properly render user input
   // an empty hint means negation
-  handleNegative: function (expr, hint) {
+  static handleNegative(expr, hint) {
     if (expr instanceof Num && expr.n > 0) {
       // e.g. - 2 -> -2
       var negated = expr.negate();
@@ -3687,19 +3741,20 @@ _.extend(Mul, {
       // e.g. - x -> -1*x
       return new Mul(Num.negativeOne(hint), expr);
     }
-  },
+  }
+
   // division can create either a Rational or a Mul
-  handleDivide: function (left, right) {
+  static handleDivide(left, right) {
     // 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(_.rest(right.terms)).flatten();
       return Mul.handleDivide(first, rest);
     }
-    var isInt = function isInt(expr) {
+    var isInt = expr => {
       return expr instanceof Int;
     };
-    var isRational = function isRational(expr) {
+    var isRational = expr => {
       return expr instanceof Rational;
     };
 
@@ -3708,7 +3763,7 @@ _.extend(Mul, {
     if (isInt(right) && left instanceof Mul && _.any(left.terms, isInt)) {
       // search from the right
       var reversed = left.terms.slice().reverse();
-      var num = _.find(reversed, isRational);
+      var num = reversed.find(isRational);
       if (!isInt(num)) {
         return new Mul(left.terms.concat([new Rational(1, right.n).addHint("fraction")]));
       }
@@ -3722,17 +3777,17 @@ _.extend(Mul, {
       }
       if (num.n < 0 && right.n < 0) {
         rational.d = -rational.d;
-        return left.replace(num, [Num.Neg, rational]);
+        return left.replace(num, [NumNeg, rational]);
       } else {
         return left.replace(num, rational);
       }
     }
-    var divide = function divide(a, b) {
+    var divide = (a, b) => {
       if (b instanceof Int) {
         if (a instanceof Int) {
           if (a.n < 0 && b.n < 0) {
             // e.g. -2 / -3 -> -1*-2/3
-            return [Num.Neg, new Rational(a.n, -b.n).addHint("fraction")];
+            return [NumNeg, new Rational(a.n, -b.n).addHint("fraction")];
           } else {
             // e.g. 2 / 3 -> 2/3
             // e.g. -2 / 3 -> -2/3
@@ -3764,7 +3819,7 @@ _.extend(Mul, {
           pow = new Pow(b.base, Mul.handleNegative(b.exp, "divide"));
         } else {
           // e.g. x ^ -1 -> x^-1
-          pow = new Pow(b, Num.Div);
+          pow = new Pow(b, NumDiv);
         }
         if (a instanceof Int && a.n === 1) {
           // e.g. 1 / x -> x^-1
@@ -3776,13 +3831,16 @@ _.extend(Mul, {
       }
     };
     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(_.last(left.terms), right);
       return new Mul(_.initial(left.terms).concat(divided));
     } else {
       var divided = divide(left, right);
       return new Mul(divided).flatten();
     }
-  },
+  }
+
   // fold negative signs into numbers if possible
   // negative signs are not the same as multiplying by negative one!
   // e.g. -x      ->  -1*x    simplified
@@ -3795,24 +3853,20 @@ _.extend(Mul, {
   // e.g. sin(x)*x -> sin(x)*x
   // e.g. sin(x)*(x) -> sin(x)*x
   // e.g. sin(x)*sin(y) -> sin(x)*sin(y)
-  fold: function (expr) {
+  static fold(expr) {
     if (expr instanceof Mul) {
       // assuming that this will be second to last
-      var trigLog = _.find(_.initial(expr.terms), function (term) {
-        return (term instanceof Trig || term instanceof Log) && term.hints.open;
+      var trigLog = _.find(_.initial(expr.terms), term => {
+        return (term instanceof Trig || term instanceof Log) && Boolean(term.hints.open);
       });
-      var index = _.indexOf(expr.terms, trigLog);
       if (trigLog) {
-        var last = _.last(expr.terms);
+        // expr.terms should always have at least two terms
+        const last = _.last(expr.terms);
         if (trigLog.hints.parens || last.hints.parens || last.has(Trig) || last.has(Log)) {
           trigLog.hints.open = false;
         } else {
-          var newTrigLog;
-          if (trigLog instanceof Trig) {
-            newTrigLog = Trig.create([trigLog.type, trigLog.exp], Mul.createOrAppend(trigLog.arg, last).fold());
-          } else {
-            newTrigLog = Log.create(trigLog.base, Mul.createOrAppend(trigLog.power, last).fold());
-          }
+          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 = _.indexOf(expr.terms, trigLog);
           if (index === 0) {
             return newTrigLog;
           } else {
@@ -3822,18 +3876,20 @@ _.extend(Mul, {
       }
       var partitioned = expr.partition();
       var numbers = partitioned[0].terms;
-      var pos = function pos(num) {
+      var pos = num => {
         return num.n > 0;
       };
-      var neg = function neg(num) {
-        return num.n === -1 && num.hints.negate;
+      var neg = num => {
+        return num.n === -1 && Boolean(num.hints.negate);
       };
       var posOrNeg = function posOrNeg(num) {
         return pos(num) || neg(num);
       };
-      if (numbers.length > 1 && _.some(numbers, neg) && _.some(numbers, pos) && _.every(numbers, posOrNeg)) {
-        var firstNeg = _.indexOf(expr.terms, _.find(expr.terms, neg));
-        var firstNum = _.indexOf(expr.terms, _.find(expr.terms, pos));
+      const posNum = numbers.find(pos);
+      const negNum = numbers.find(neg);
+      if (numbers.length > 1 && negNum && posNum && _.every(numbers, posOrNeg)) {
+        var firstNeg = _.indexOf(expr.terms, negNum);
+        var firstNum = _.indexOf(expr.terms, posNum);
 
         // e.g. -x*2 -> x*-2
         if (firstNeg < firstNum) {
@@ -3845,20 +3901,31 @@ _.extend(Mul, {
     // in all other cases, make no change
     return expr;
   }
-});
 
-/* exponentiation */
-function Pow(base, exp) {
-  this.base = base;
-  this.exp = exp;
+  // create a new sequence unless left is already one (returns a copy)
+  static createOrAppend(left, right) {
+    if (left instanceof Mul) {
+      return new Mul(left.terms.concat(right));
+    } else {
+      return new Mul(left, right);
+    }
+  }
 }
-Pow.prototype = new Expr();
-_.extend(Pow.prototype, {
-  func: Pow,
-  args: function () {
+
+/* exponentiation */
+class Pow extends Expr {
+  constructor(base, exp) {
+    super();
+    this.base = void 0;
+    this.exp = void 0;
+    this.func = Pow;
+    this.base = base;
+    this.exp = exp;
+  }
+  args() {
     return [this.base, this.exp];
-  },
-  eval: function (vars, options) {
+  }
+  eval(vars = {}, options) {
     var evaledBase = this.base.eval(vars, options);
     var evaledExp = this.exp.eval(vars, options);
 
@@ -3877,7 +3944,7 @@ _.extend(Pow.prototype, {
       // If Float, convert to a Rational to enable the logic below
       if (simplifiedExp instanceof Float) {
         var num = simplifiedExp.n;
-        var decimals = (num - num.toFixed()).toString().length - 2;
+        var decimals = (num - +num.toFixed()).toString().length - 2;
         var denominator = Math.pow(10, decimals);
         var rationalExp = new Rational(num * denominator, denominator);
         simplifiedExp = rationalExp.simplify();
@@ -3892,32 +3959,33 @@ _.extend(Pow.prototype, {
       }
     }
     return Math.pow(evaledBase, evaledExp);
-  },
-  getUnits: function () {
-    return this.base.getUnits().map(function (unit) {
+  }
+  getUnits() {
+    return this.base.getUnits().map(unit => {
       return {
         unit: unit.unit,
+        // Exponents in units should always be integers
         pow: unit.pow * this.exp.n
       };
-    }.bind(this));
-  },
-  codegen: function () {
+    });
+  }
+  codegen() {
     return "Math.pow(" + this.base.codegen() + ", " + this.exp.codegen() + ")";
-  },
-  print: function () {
+  }
+  print() {
     var base = this.base.print();
     if (this.base instanceof Seq || this.base instanceof Pow) {
       base = "(" + base + ")";
     }
     return base + "^(" + this.exp.print() + ")";
-  },
-  tex: function () {
+  }
+  tex() {
     if (this.isDivide()) {
       // e.g. x ^ -1 w/hint -> 1/x
       return "\\frac{1}{" + this.asDivide().tex() + "}";
-    } else if (this.isRoot()) {
+    } else if (this.isRoot() && isRational(this.exp)) {
       if (this.exp.n !== 1) {
-        error("Node marked with hint 'root' does not have exponent " + "of form 1/x.");
+        throw new Error("Node marked with hint 'root' does not have exponent " + "of form 1/x.");
       }
       if (this.exp.d === 2) {
         // e.g. x ^ 1/2 w/hint -> sqrt{x}
@@ -3928,9 +3996,7 @@ _.extend(Pow.prototype, {
       }
     } else if (this.base instanceof Trig && !this.base.isInverse() && this.exp instanceof Num && this.exp.isSimple() && this.exp.eval() >= 0) {
       // e.g sin(x) ^ 2 -> sin^2(x)
-      var split = this.base.tex({
-        split: true
-      });
+      var split = this.base.texSplit();
       return split[0] + "^{" + this.exp.tex() + "}" + split[1];
     } else {
       // e.g. x ^ y -> x^y
@@ -3944,16 +4010,16 @@ _.extend(Pow.prototype, {
       }
       return base + "^{" + this.exp.tex() + "}";
     }
-  },
-  needsExplicitMul: function () {
+  }
+  needsExplicitMul() {
     return this.isRoot() ? false : this.base.needsExplicitMul();
-  },
-  expand: function () {
+  }
+  expand() {
     var pow = this.recurse("expand");
     if (pow.base instanceof Mul) {
       // e.g. (ab)^c -> a^c*b^c
 
-      var terms = _.map(pow.base.terms, function (term) {
+      var terms = _.map(pow.base.terms, term => {
         return new Pow(term, pow.exp);
       });
       return new Mul(terms).expand();
@@ -3964,49 +4030,55 @@ _.extend(Pow.prototype, {
       var positive = pow.exp.eval() > 0;
       var n = pow.exp.abs().eval();
       var signed = function signed(mul) {
-        return positive ? mul : new Pow(mul, Num.Div);
+        return positive ? mul : new Pow(mul, NumDiv);
       };
 
       // compute and cache powers of 2 up to n
-      var cache = {
+      const cache = {
         1: pow.base
       };
       for (var i = 2; i <= n; i *= 2) {
-        var mul = new Mul(cache[i / 2], cache[i / 2]);
-        cache[i] = mul.expand().collect();
+        const _mul = new Mul(cache[i / 2], cache[i / 2]);
+        cache[i] = _mul.expand().collect();
       }
 
       // if n is a power of 2, you're done!
-      if (_.has(cache, n)) {
+      if (n in cache) {
         return signed(cache[n]);
       }
 
       // otherwise decompose n into powers of 2 ...
-      var indices = _.map(n.toString(2).split(""), function (str, i, list) {
+      let indices = _.map(n.toString(2).split(""), function (str, i, list) {
         return Number(str) * Math.pow(2, list.length - i - 1);
       });
       indices = _.without(indices, 0);
 
       // ... then combine
-      var mul = new Mul(_.pick(cache, indices)).expand().collect();
+      const factors = [];
+      for (const index of indices) {
+        if (index in cache) {
+          factors.push(cache[index]);
+        }
+      }
+      const mul = new Mul(factors).expand().collect();
       return signed(mul);
     } else if (pow.exp instanceof Add) {
       // DEFINITELY want behind super-simplify() flag
       // e.g. x^(a+b) -> x^a*x^b
 
-      var terms = _.map(pow.exp.terms, function (term) {
+      const _terms = _.map(pow.exp.terms, term => {
         return new Pow(pow.base, term).expand();
       });
-      return new Mul(terms).expand();
+      return new Mul(_terms).expand();
     } else {
       return pow;
     }
-  },
-  factor: function () {
+  }
+  factor() {
     var pow = this.recurse("factor");
     if (pow.base instanceof Mul) {
-      var terms = _.map(pow.base.terms, function (term) {
-        if (term instanceof Int && pow.exp.equals(Num.Div)) {
+      var terms = _.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
           return new Rational(1, term.n);
@@ -4018,23 +4090,23 @@ _.extend(Pow.prototype, {
     } else {
       return pow;
     }
-  },
-  collect: function (options) {
+  }
+  collect(options) {
     if (this.base instanceof Pow) {
       // collect this first to avoid having to deal with float precision
       // e.g. sqrt(2)^2 -> 2, not 2.0000000000000004
       // e.g. (x^y)^z -> x^(yz)
-      var base = this.base.base;
-      var exp = Mul.createOrAppend(this.base.exp, this.exp);
+      const base = this.base.base;
+      const exp = Mul.createOrAppend(this.base.exp, this.exp);
       return new Pow(base, exp).collect(options);
     }
-    var pow = this.recurse("collect", options);
-    var isSimilarLog = function isSimilarLog(term) {
+    const pow = this.recurse("collect", options);
+    const isSimilarLog = function isSimilarLog(term) {
       return term instanceof Log && term.base.equals(pow.base);
     };
     if (pow.exp instanceof Num && pow.exp.eval() === 0) {
       // e.g. x^0 -> 1
-      return Num.One;
+      return NumOne;
     } else if (pow.exp instanceof Num && pow.exp.eval() === 1) {
       // e.g. x^1 -> x
       return pow.base;
@@ -4043,9 +4115,11 @@ _.extend(Pow.prototype, {
       return pow.exp.power;
     } else if (pow.exp instanceof Mul && _.any(pow.exp.terms, isSimilarLog)) {
       // e.g. b^(2*y*log_b(x)) -> x^(2*y)
-      var log = _.find(pow.exp.terms, isSimilarLog);
-      var base = log.power;
-      var exp = pow.exp.remove(log).flatten();
+      // `log` will always be defined here because of the
+      // `_.any(pow.exp.terms, isSimilarLog)` check above.
+      const log = pow.exp.terms.find(isSimilarLog);
+      const base = log.power;
+      const exp = pow.exp.remove(log).flatten();
       return new Pow(base, exp).collect(options);
     } else if (pow.base instanceof Num && pow.exp instanceof Num) {
       // TODO(alex): Consider encapsualting this logic (and similar logic
@@ -4060,14 +4134,18 @@ _.extend(Pow.prototype, {
         // as floats, but ideally rationals should be pre-processed
         // e.g. (1/27)^(1/3) -> 1/3 to avoid most cases.
         // TODO(alex): Catch such cases and avoid converting to floats.
-        var exp = pow.exp.asRational();
-        var decimalsInBase = pow.base.getDecimalPlaces();
-        var root = new Pow(pow.base, new Rational(1, exp.d));
-        var decimalsInRoot = root.collect().getDecimalPlaces();
+        const exp = pow.exp.asRational();
+        const decimalsInBase = pow.base.getDecimalPlaces();
+        const root = new Pow(pow.base, new Rational(1, exp.d));
+        const decimalsInRoot = root.collect()
+        // @ts-expect-error: we assume that `root.collect()` returns
+        // a Num here but tbh I'm not sure how this code isn't causing
+        // an infinite loop.
+        .getDecimalPlaces();
         if (decimalsInRoot > decimalsInBase) {
           // Collecting over this denominator would result in an
           // imprecise float, so avoid doing so.
-          var newBase = new Pow(pow.base, new Int(exp.n)).collect();
+          const newBase = new Pow(pow.base, new Int(exp.n)).collect();
           return new Pow(newBase, new Rational(1, exp.d));
         }
       }
@@ -4077,16 +4155,18 @@ _.extend(Pow.prototype, {
     } else {
       return pow;
     }
-  },
+  }
+
   // checks whether this Pow represents user-entered division
-  isDivide: function () {
+  isDivide() {
     var isDiv = function isDiv(arg) {
-      return arg instanceof Num && arg.hints.divide;
+      return arg instanceof Num && Boolean(arg.hints.divide);
     };
     return isDiv(this.exp) || this.exp instanceof Mul && _.any(this.exp.terms, isDiv);
-  },
+  }
+
   // assuming this Pow represents user-entered division, returns the denominator
-  asDivide: function () {
+  asDivide() {
     if (this.exp instanceof Num) {
       if (this.exp.eval() === -1) {
         return this.base;
@@ -4099,18 +4179,19 @@ _.extend(Pow.prototype, {
     } else if (this.exp instanceof Mul) {
       return new Pow(this.base, this.exp.factorOut());
     } else {
-      error("called asDivide() on an Expr that wasn't a Num or Mul");
+      throw new Error("called asDivide() on an Expr that wasn't a Num or Mul");
     }
-  },
-  isRoot: function () {
-    return this.exp instanceof Rational && this.exp.hints.root;
-  },
-  isSquaredTrig: function () {
+  }
+  isRoot() {
+    return this.exp instanceof Rational && Boolean(this.exp.hints.root);
+  }
+  isSquaredTrig() {
     return this.base instanceof Trig && !this.base.isInverse() && this.exp instanceof Num && this.exp.eval() === 2;
-  },
+  }
+
   // extract whatever denominator makes sense, ignoring hints
   // if negative exponent, will recursively include the base's denominator as well
-  getDenominator: function () {
+  getDenominator() {
     if (this.exp instanceof Num && this.exp.eval() === -1) {
       return Mul.createOrAppend(this.base, this.base.getDenominator()).flatten();
     } else if (this.exp.isNegative()) {
@@ -4119,18 +4200,11 @@ _.extend(Pow.prototype, {
     } else if (this.base instanceof Num) {
       return new Pow(this.base.getDenominator(), this.exp).collect();
     } else {
-      return Num.One;
-    }
-  },
-  findGCD: function (factor) {
-    var base, exp;
-    if (factor instanceof Pow) {
-      base = factor.base;
-      exp = factor.exp;
-    } else {
-      base = factor;
-      exp = Num.One;
+      return NumOne;
     }
+  }
+  findGCD(factor) {
+    const [base, exp] = factor instanceof Pow ? [factor.base, factor.exp] : [factor, NumOne];
 
     // GCD is only relevant if same base
     if (this.base.equals(base)) {
@@ -4145,7 +4219,7 @@ _.extend(Pow.prototype, {
       } else if (this.exp instanceof Num || exp instanceof Num) {
         // one numerical exponent
         // e.g. GCD(x^2, x^y) -> 1
-        return Num.One;
+        return NumOne;
       }
       var expA = this.exp.asMul().partition();
       var expB = exp.asMul().partition();
@@ -4157,16 +4231,16 @@ _.extend(Pow.prototype, {
         return new Pow(base, mul).collect();
       }
     }
-    return Num.One;
-  },
-  isPositive: function () {
+    return NumOne;
+  }
+  isPositive() {
     if (this.base.isPositive()) {
       return true;
     }
     var exp = this.exp.simplify();
     return exp instanceof Int && exp.eval() % 2 === 0;
-  },
-  asPositiveFactor: function () {
+  }
+  asPositiveFactor() {
     if (this.isPositive()) {
       return this;
     } else {
@@ -4181,78 +4255,87 @@ _.extend(Pow.prototype, {
           return new Pow(this.base, new Int(n + 1));
         }
       }
-      return Num.One;
+      return NumOne;
     }
   }
-});
-_.extend(Pow, {
-  sqrt: function (arg) {
-    return new Pow(arg, Num.Sqrt);
-  },
-  nthroot: function (radicand, degree) {
-    var exp = Mul.fold(Mul.handleDivide(new Int(1), degree));
-
-    // FIXME(johnsullivan): If oneOverDegree ends up being a pow object,
-    //     this "root" hint is lost between here and when tex() is called.
-    return new Pow(radicand, exp.addHint("root"));
+  static sqrt(arg) {
+    return new Pow(arg, NumSqrt);
   }
-});
 
-/* logarithm */
-function Log(base, power) {
-  this.base = base;
-  this.power = power;
+  // NOTE(kevinb): nthroot is used as a constructor so we need to
+  // define it as a static property instead of a static method.
+  // TODO(kevinb): update parser-generator.ts to call nthrooth
+  // without using `new`.
 }
-Log.prototype = new Expr();
-_.extend(Log.prototype, {
-  func: Log,
-  args: function () {
+
+/* logarithm */
+_class5 = Pow;
+Pow.nthroot = function (radicand, degree) {
+  var exp = Mul.fold(Mul.handleDivide(new Int(1), degree));
+
+  // FIXME(johnsullivan): If oneOverDegree ends up being a pow object,
+  //     this "root" hint is lost between here and when tex() is called.
+  return new _class5(radicand, exp.addHint("root"));
+};
+class Log extends Expr {
+  constructor(base, power) {
+    super();
+    this.base = void 0;
+    this.power = void 0;
+    this.func = Log;
+    this.base = base;
+    this.power = power;
+    this.hints = _extends({}, this.hints, {
+      open: false
+    });
+  }
+  args() {
     return [this.base, this.power];
-  },
-  eval: function (vars, options) {
+  }
+  eval(vars = {}, options) {
     return Math.log(this.power.eval(vars, options)) / Math.log(this.base.eval(vars, options));
-  },
-  codegen: function () {
+  }
+  codegen() {
     return "(Math.log(" + this.power.codegen() + ") / Math.log(" + this.base.codegen() + "))";
-  },
-  print: function () {
+  }
+  print() {
     var power = "(" + this.power.print() + ")";
     if (this.isNatural()) {
       return "ln" + power;
     } else {
       return "log_(" + this.base.print() + ") " + power;
     }
-  },
-  tex: function () {
+  }
+  tex() {
     var power = "(" + this.power.tex() + ")";
     if (this.isNatural()) {
       return "\\ln" + power;
     } else {
       return "\\log_{" + this.base.tex() + "}" + power;
     }
-  },
-  collect: function (options) {
+  }
+  collect(options) {
     var log = this.recurse("collect", options);
     if (log.power instanceof Num && log.power.eval() === 1) {
       // e.g. ln(1) -> 0
-      return Num.Zero;
+      return NumZero;
     } else if (log.base.equals(log.power)) {
       // e.g. log_b(b) -> 1
-      return Num.One;
+      return NumOne;
     } else if (log.power instanceof Pow && log.power.base.equals(log.base)) {
       // e.g. log_b(b^x) -> x
       return log.power.exp;
     } else {
       return log;
     }
-  },
-  expand: function () {
+  }
+  expand() {
     var log = this.recurse("expand");
     if (log.power instanceof Mul) {
       // might want behind super-simplify() flag
       // e.g. ln(xy) -> ln(x) + ln(y)
 
-      var terms = _.map(log.power.terms, function (term) {
+      var terms = _.map(log.power.terms, term => {
         // need to expand again in case new log powers are Pows
         return new Log(log.base, term).expand();
       });
@@ -4268,231 +4351,209 @@ _.extend(Log.prototype, {
     } else {
       return log;
     }
-  },
-  hints: _.extend(Log.prototype.hints, {
-    open: false
-  }),
-  isPositive: function () {
+  }
+  isPositive() {
     var log = this.collect();
-    if (log.base instanceof Num && log.power instanceof Num) {
+    if (log instanceof Log && log.base instanceof Num && log.power instanceof Num) {
       return this.eval() > 0;
     } else {
       return false;
     }
-  },
-  needsExplicitMul: function () {
+  }
+  needsExplicitMul() {
     return false;
-  },
-  isNatural: function () {
+  }
+  isNatural() {
     return this.base.equals(Const.e);
   }
-});
-_.extend(Log, {
-  natural: function () {
+  static natural() {
     return Const.e;
-  },
-  common: function () {
-    return Num.Ten;
-  },
-  create: function (base, power) {
+  }
+  static common() {
+    return NumTen;
+  }
+  static create(base, power) {
     var log = new Log(base, power);
     if (!power.hints.parens) {
       log = log.addHint("open");
     }
     return log;
   }
-});
-
-/* trigonometric functions */
-function Trig(type, arg) {
-  this.type = type;
-  this.arg = arg;
 }
-Trig.prototype = new Expr();
-_.extend(Trig.prototype, {
-  func: Trig,
-  args: function () {
-    return [this.type, this.arg];
-  },
-  functions: {
-    sin: {
-      eval: Math.sin,
-      codegen: "Math.sin((",
-      tex: "\\sin",
-      expand: function () {
-        return this;
-      }
-    },
-    cos: {
-      eval: Math.cos,
-      codegen: "Math.cos((",
-      tex: "\\cos",
-      expand: function () {
-        return this;
-      }
-    },
-    tan: {
-      eval: Math.tan,
-      codegen: "Math.tan((",
-      tex: "\\tan",
-      expand: function () {
-        return Mul.handleDivide(Trig.sin(this.arg), Trig.cos(this.arg));
-      }
-    },
-    csc: {
-      eval: function (arg) {
-        return 1 / Math.sin(arg);
+/* trigonometric functions */
+class Trig extends Expr {
+  constructor(type, _arg) {
+    super();
+    this.type = void 0;
+    // TODO(kevinb): Use a union type for this
+    this.arg = void 0;
+    this.exp = void 0;
+    this.func = Trig;
+    // TODO(kevinb): Use union type for the function names.
+    this.functions = {
+      sin: {
+        eval: Math.sin,
+        codegen: "Math.sin((",
+        tex: "\\sin",
+        expand: () => this
       },
-      codegen: "(1/Math.sin(",
-      tex: "\\csc",
-      expand: function () {
-        return Mul.handleDivide(Num.One, Trig.sin(this.arg));
-      }
-    },
-    sec: {
-      eval: function (arg) {
-        return 1 / Math.cos(arg);
+      cos: {
+        eval: Math.cos,
+        codegen: "Math.cos((",
+        tex: "\\cos",
+        expand: () => this
       },
-      codegen: "(1/Math.cos(",
-      tex: "\\sec",
-      expand: function () {
-        return Mul.handleDivide(Num.One, Trig.cos(this.arg));
-      }
-    },
-    cot: {
-      eval: function (arg) {
-        return 1 / Math.tan(arg);
-      },
-      codegen: "(1/Math.tan(",
-      tex: "\\cot",
-      expand: function () {
-        return Mul.handleDivide(Trig.cos(this.arg), Trig.sin(this.arg));
-      }
-    },
-    arcsin: {
-      eval: Math.asin,
-      codegen: "Math.asin((",
-      tex: "\\arcsin"
-    },
-    arccos: {
-      eval: Math.acos,
-      codegen: "Math.acos((",
-      tex: "\\arccos"
-    },
-    arctan: {
-      eval: Math.atan,
-      codegen: "Math.atan((",
-      tex: "\\arctan"
-    },
-    arccsc: {
-      eval: function (arg) {
-        return Math.asin(1 / arg);
+      tan: {
+        eval: Math.tan,
+        codegen: "Math.tan((",
+        tex: "\\tan",
+        expand: () => Mul.handleDivide(Trig.sin(this.arg), Trig.cos(this.arg))
       },
-      codegen: "Math.asin(1/(",
-      tex: "\\operatorname{arccsc}"
-    },
-    arcsec: {
-      eval: function (arg) {
-        return Math.acos(1 / arg);
+      csc: {
+        eval: arg => {
+          return 1 / Math.sin(arg);
+        },
+        codegen: "(1/Math.sin(",
+        tex: "\\csc",
+        expand: () => Mul.handleDivide(NumOne, Trig.sin(this.arg))
       },
-      codegen: "Math.acos(1/(",
-      tex: "\\operatorname{arcsec}"
-    },
-    arccot: {
-      eval: function (arg) {
-        return Math.atan(1 / arg);
+      sec: {
+        eval: arg => {
+          return 1 / Math.cos(arg);
+        },
+        codegen: "(1/Math.cos(",
+        tex: "\\sec",
+        expand: () => Mul.handleDivide(NumOne, Trig.cos(this.arg))
       },
-      codegen: "Math.atan(1/(",
-      tex: "\\operatorname{arccot}"
-    },
-    sinh: {
-      eval: function (arg) {
-        return (Math.exp(arg) - Math.exp(-arg)) / 2;
+      cot: {
+        eval: arg => {
+          return 1 / Math.tan(arg);
+        },
+        codegen: "(1/Math.tan(",
+        tex: "\\cot",
+        expand: () => Mul.handleDivide(Trig.cos(this.arg), Trig.sin(this.arg))
       },
-      codegen: function (argStr) {
-        return "((Math.exp(" + argStr + ") - Math.exp(-(" + argStr + "))) / 2)";
+      arcsin: {
+        eval: Math.asin,
+        codegen: "Math.asin((",
+        tex: "\\arcsin"
       },
-      tex: "\\sinh",
-      expand: function () {
-        return this;
-      }
-    },
-    cosh: {
-      eval: function (arg) {
-        return (Math.exp(arg) + Math.exp(-arg)) / 2;
+      arccos: {
+        eval: Math.acos,
+        codegen: "Math.acos((",
+        tex: "\\arccos"
       },
-      codegen: function (argStr) {
-        return "((Math.exp(" + argStr + ") + Math.exp(-(" + argStr + "))) / 2)";
+      arctan: {
+        eval: Math.atan,
+        codegen: "Math.atan((",
+        tex: "\\arctan"
       },
-      tex: "\\cosh",
-      expand: function () {
-        return this;
-      }
-    },
-    tanh: {
-      eval: function (arg) {
-        return (Math.exp(arg) - Math.exp(-arg)) / (Math.exp(arg) + Math.exp(-arg));
+      arccsc: {
+        eval: arg => {
+          return Math.asin(1 / arg);
+        },
+        codegen: "Math.asin(1/(",
+        tex: "\\operatorname{arccsc}"
       },
-      codegen: function (argStr) {
-        return "(" + "(Math.exp(" + argStr + ") - Math.exp(-(" + argStr + ")))" + " / " + "(Math.exp(" + argStr + ") + Math.exp(-(" + argStr + ")))" + ")";
+      arcsec: {
+        eval: arg => {
+          return Math.acos(1 / arg);
+        },
+        codegen: "Math.acos(1/(",
+        tex: "\\operatorname{arcsec}"
       },
-      tex: "\\tanh",
-      expand: function () {
-        return Mul.handleDivide(Trig.sinh(this.arg), Trig.cosh(this.arg));
-      }
-    },
-    csch: {
-      eval: function (arg) {
-        return 2 / (Math.exp(arg) - Math.exp(-arg));
+      arccot: {
+        eval: arg => {
+          return Math.atan(1 / arg);
+        },
+        codegen: "Math.atan(1/(",
+        tex: "\\operatorname{arccot}"
       },
-      codegen: function (argStr) {
-        return "(2 / (Math.exp(" + argStr + ") - Math.exp(-(" + argStr + "))))";
+      sinh: {
+        eval: arg => {
+          return (Math.exp(arg) - Math.exp(-arg)) / 2;
+        },
+        codegen: argStr => {
+          return "((Math.exp(" + argStr + ") - Math.exp(-(" + argStr + "))) / 2)";
+        },
+        tex: "\\sinh",
+        expand: () => this
       },
-      tex: "\\csch",
-      expand: function () {
-        return Mul.handleDivide(Num.One, Trig.sinh(this.arg));
-      }
-    },
-    sech: {
-      eval: function (arg) {
-        return 2 / (Math.exp(arg) + Math.exp(-arg));
+      cosh: {
+        eval: arg => {
+          return (Math.exp(arg) + Math.exp(-arg)) / 2;
+        },
+        codegen: argStr => {
+          return "((Math.exp(" + argStr + ") + Math.exp(-(" + argStr + "))) / 2)";
+        },
+        tex: "\\cosh",
+        expand: () => this
       },
-      codegen: function (argStr) {
-        return "(2 / (Math.exp(" + argStr + ") + Math.exp(-(" + argStr + "))))";
+      tanh: {
+        eval: arg => {
+          return (Math.exp(arg) - Math.exp(-arg)) / (Math.exp(arg) + Math.exp(-arg));
+        },
+        codegen: argStr => {
+          return "(" + "(Math.exp(" + argStr + ") - Math.exp(-(" + argStr + ")))" + " / " + "(Math.exp(" + argStr + ") + Math.exp(-(" + argStr + ")))" + ")";
+        },
+        tex: "\\tanh",
+        expand: () => Mul.handleDivide(Trig.sinh(this.arg), Trig.cosh(this.arg))
       },
-      tex: "\\sech",
-      expand: function () {
-        return Mul.handleDivide(Num.One, Trig.cosh(this.arg));
-      }
-    },
-    coth: {
-      eval: function (arg) {
-        return (Math.exp(arg) + Math.exp(-arg)) / (Math.exp(arg) - Math.exp(-arg));
+      csch: {
+        eval: arg => {
+          return 2 / (Math.exp(arg) - Math.exp(-arg));
+        },
+        codegen: argStr => {
+          return "(2 / (Math.exp(" + argStr + ") - Math.exp(-(" + argStr + "))))";
+        },
+        tex: "\\csch",
+        expand: () => Mul.handleDivide(NumOne, Trig.sinh(this.arg))
       },
-      codegen: function (argStr) {
-        return "(" + "(Math.exp(" + argStr + ") + Math.exp(-(" + argStr + ")))" + " / " + "(Math.exp(" + argStr + ") - Math.exp(-(" + argStr + ")))" + ")";
+      sech: {
+        eval: arg => {
+          return 2 / (Math.exp(arg) + Math.exp(-arg));
+        },
+        codegen: argStr => {
+          return "(2 / (Math.exp(" + argStr + ") + Math.exp(-(" + argStr + "))))";
+        },
+        tex: "\\sech",
+        expand: () => Mul.handleDivide(NumOne, Trig.cosh(this.arg))
       },
-      tex: "\\coth",
-      expand: function () {
-        return Mul.handleDivide(Trig.cosh(this.arg), Trig.sinh(this.arg));
+      coth: {
+        eval: arg => {
+          return (Math.exp(arg) + Math.exp(-arg)) / (Math.exp(arg) - Math.exp(-arg));
+        },
+        codegen: argStr => {
+          return "(" + "(Math.exp(" + argStr + ") + Math.exp(-(" + argStr + ")))" + " / " + "(Math.exp(" + argStr + ") - Math.exp(-(" + argStr + ")))" + ")";
+        },
+        tex: "\\coth",
+        expand: () => Mul.handleDivide(Trig.cosh(this.arg), Trig.sinh(this.arg))
       }
-    }
-  },
-  isEven: function () {
+    };
+    this.type = type;
+    this.arg = _arg;
+    this.hints = _extends({}, this.hints, {
+      open: false
+    });
+  }
+  args() {
+    return [this.type, this.arg];
+  }
+  isEven() {
     return _.contains(["cos", "sec"], this.type);
-  },
-  isInverse: function () {
+  }
+  isInverse() {
     return this.type.indexOf("arc") === 0;
-  },
-  isBasic: function () {
+  }
+  isBasic() {
     return _.contains(["sin", "cos"], this.type);
-  },
-  eval: function (vars, options) {
+  }
+  eval(vars = {}, options) {
     var func = this.functions[this.type].eval;
     var arg = this.arg.eval(vars, options);
     return func(arg);
-  },
-  codegen: function () {
+  }
+  codegen() {
     var func = this.functions[this.type].codegen;
     if (typeof func === "function") {
       return func(this.arg.codegen());
@@ -4501,27 +4562,29 @@ _.extend(Trig.prototype, {
     } else {
       throw new Error("codegen not implemented for " + this.type);
     }
-  },
-  print: function () {
+  }
+  print() {
     return this.type + "(" + this.arg.print() + ")";
-  },
-  tex: function (options) {
+  }
+  tex() {
+    var func = this.functions[this.type].tex;
+    var arg = "(" + this.arg.tex() + ")";
+    return func + arg;
+  }
+  texSplit() {
     var func = this.functions[this.type].tex;
     var arg = "(" + this.arg.tex() + ")";
-    return options && options.split ? [func, arg] : func + arg;
-  },
-  hints: _.extend(Trig.prototype.hints, {
-    open: false
-  }),
-  isPositive: function () {
+    return [func, arg];
+  }
+  isPositive() {
     var trig = this.collect();
-    if (trig.arg instanceof Num) {
+    if (trig instanceof Trig && trig.arg instanceof Num) {
       return this.eval() > 0;
     } else {
       return false;
     }
-  },
-  completeParse: function () {
+  }
+  completeParse() {
     if (this.exp) {
       var pow = new Pow(this, this.exp);
       this.exp = undefined;
@@ -4529,47 +4592,42 @@ _.extend(Trig.prototype, {
     } else {
       return this;
     }
-  },
+  }
+
   // TODO(alex): does every new node type need to redefine these?
-  needsExplicitMul: function () {
+  needsExplicitMul() {
     return false;
-  },
-  expand: function () {
+  }
+  expand() {
     var trig = this.recurse("expand");
     if (!trig.isInverse()) {
       // 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 _.bind(expand, trig)();
     } else {
       return trig;
     }
-  },
-  collect: function (options) {
+  }
+  collect(options) {
     var trig = this.recurse("collect", options);
     if (!trig.isInverse() && trig.arg.isNegative()) {
-      var arg;
-      if (trig.arg instanceof Num) {
-        arg = trig.arg.abs();
-      } else {
-        arg = Mul.handleDivide(trig.arg, Num.Neg).collect(options);
-      }
+      const arg = trig.arg instanceof Num ? trig.arg.abs() : Mul.handleDivide(trig.arg, NumNeg).collect(options);
       if (trig.isEven()) {
         // e.g. cos(-x) -> cos(x)
         return new Trig(trig.type, arg);
       } else {
         // e.g. sin(-x) -> -sin(x)
-        return new Mul(Num.Neg, new Trig(trig.type, arg));
+        return new Mul(NumNeg, new Trig(trig.type, arg));
       }
     } else {
       return trig;
     }
   }
-});
-_.extend(Trig, {
-  create: function (pair, arg) {
+  static create(pair, arg) {
     var type = pair[0];
     var exp = pair[1];
-    if (exp && exp.equals(Num.Neg)) {
+    if (exp && exp.equals(NumNeg)) {
       // e.g. sin^-1(x) -> arcsin(x)
       type = "arc" + type;
       exp = undefined;
@@ -4582,42 +4640,43 @@ _.extend(Trig, {
       trig.exp = exp;
     }
     return trig;
-  },
-  sin: function (arg) {
+  }
+  static sin(arg) {
     return new Trig("sin", arg);
-  },
-  cos: function (arg) {
+  }
+  static cos(arg) {
     return new Trig("cos", arg);
-  },
-  sinh: function (arg) {
+  }
+  static sinh(arg) {
     return new Trig("sinh", arg);
-  },
-  cosh: function (arg) {
+  }
+  static cosh(arg) {
     return new Trig("cosh", arg);
   }
-});
-function Abs(arg) {
-  this.arg = arg;
 }
-Abs.prototype = new Expr();
-_.extend(Abs.prototype, {
-  func: Abs,
-  args: function () {
+class Abs extends Expr {
+  constructor(arg) {
+    super();
+    this.arg = void 0;
+    this.func = Abs;
+    this.arg = arg;
+  }
+  args() {
     return [this.arg];
-  },
-  eval: function (vars, options) {
+  }
+  eval(vars = {}, options) {
     return Math.abs(this.arg.eval(vars, options));
-  },
-  codegen: function () {
+  }
+  codegen() {
     return "Math.abs(" + this.arg.codegen() + ")";
-  },
-  print: function () {
+  }
+  print() {
     return "abs(" + this.arg.print() + ")";
-  },
-  tex: function () {
+  }
+  tex() {
     return "\\left|" + this.arg.tex() + "\\right|";
-  },
-  collect: function (options) {
+  }
+  collect(options) {
     var abs = this.recurse("collect", options);
     if (abs.arg.isPositive()) {
       // e.g. |2^x| -> 2^x
@@ -4627,7 +4686,7 @@ _.extend(Abs.prototype, {
       return abs.arg.abs();
     } else if (abs.arg instanceof Mul) {
       // e.g. |-2*pi*x| -> 2*pi*|x|
-      var terms = _.groupBy(abs.arg.terms, function (term) {
+      var terms = _.groupBy(abs.arg.terms, term => {
         if (term.isPositive()) {
           return "positive";
         } else if (term instanceof Num) {
@@ -4644,55 +4703,60 @@ _.extend(Abs.prototype, {
     } else {
       return abs;
     }
-  },
+  }
+
   // this should definitely be behind a super-simplify flag
-  expand: function () {
+  expand() {
     var abs = this.recurse("expand");
     if (abs.arg instanceof Mul) {
       // e.g. |xyz| -> |x|*|y|*|z|
-      var terms = _.map(abs.arg.terms, function (term) {
+      var terms = _.map(abs.arg.terms, term => {
         return new Abs(term);
       });
       return new Mul(terms);
     } else {
       return abs;
     }
-  },
-  isPositive: function () {
+  }
+  isPositive() {
     return true;
   }
-});
+}
 
 /* equation */
-function Eq(left, type, right) {
-  this.left = left;
-  this.type = type;
-  this.right = right;
-}
-Eq.prototype = new Expr();
-_.extend(Eq.prototype, {
-  func: Eq,
-  args: function () {
+class Eq extends Expr {
+  constructor(left, type, right) {
+    super();
+    this.left = void 0;
+    this.type = void 0;
+    // TODO(kevinb): use an enum for this
+    this.right = void 0;
+    this.func = Eq;
+    this.signs = {
+      "=": " = ",
+      "<": " < ",
+      ">": " > ",
+      "<>": " \\ne ",
+      "<=": " \\le ",
+      ">=": " \\ge "
+    };
+    this.left = left;
+    this.type = type;
+    this.right = right;
+  }
+  args() {
     return [this.left, this.type, this.right];
-  },
-  needsExplicitMul: function () {
+  }
+  needsExplicitMul() {
     return false;
-  },
-  print: function () {
+  }
+  print() {
     return this.left.print() + this.type + this.right.print();
-  },
-  signs: {
-    "=": " = ",
-    "<": " < ",
-    ">": " > ",
-    "<>": " \\ne ",
-    "<=": " \\le ",
-    ">=": " \\ge "
-  },
-  tex: function () {
+  }
+  tex() {
     return this.left.tex() + this.signs[this.type] + this.right.tex();
-  },
-  normalize: function () {
+  }
+  normalize() {
     var eq = this.recurse("normalize");
     if (_.contains([">", ">="], eq.type)) {
       // inequalities should have the smaller side on the left
@@ -4700,18 +4764,19 @@ _.extend(Eq.prototype, {
     } else {
       return eq;
     }
-  },
+  }
+
   // convert this equation to an expression set to zero
   // the expression is normalized to a canonical form
   // e.g. y/2=x/4 -> y/2-x/4(=0) -> 2y-x(=0)
   // unless unfactored is specified, will then divide through
-  asExpr: function (unfactored) {
-    var isZero = function isZero(expr) {
+  asExpr(unfactored = false) {
+    var isZero = expr => {
       return expr instanceof Num && expr.isSimple() && expr.eval() === 0;
     };
 
     // first convert to a sequence of additive terms
-    var terms = [];
+    let terms = [];
     if (this.left instanceof Add) {
       terms = _.clone(this.left.terms);
     } else if (!isZero(this.left)) {
@@ -4741,8 +4806,8 @@ _.extend(Eq.prototype, {
       if (isInequality && !denominator.isPositive()) {
         denominator = denominator.asPositiveFactor();
       }
-      if (!denominator.equals(Num.One)) {
-        terms = _.map(terms, function (term) {
+      if (!denominator.equals(NumOne)) {
+        terms = _.map(terms, term => {
           return Mul.createOrAppend(term, denominator).simplify({
             once: true,
             preciseFloats: true
@@ -4752,41 +4817,33 @@ _.extend(Eq.prototype, {
     }
     var add = new Add(terms).flatten();
     return unfactored ? add : this.divideThrough(add);
-  },
+  }
+
   // divide through by every common factor in the expression
   // e.g. 2y-4x(=0) -> y-2x(=0)
   // TODO(alex): Make it an option to only divide by variables/expressions
   // guaranteed to be nonzero
-  divideThrough: function (expr) {
-    var isInequality = !this.isEquality();
-    var simplified = expr.simplify({
+  divideThrough(expr) {
+    const isInequality = !this.isEquality();
+    const simplified = expr.simplify({
       once: true
     });
-    var factored = simplified.factor({
+    const factored = simplified.factor({
       keepNegative: isInequality
     });
     if (!(factored instanceof Mul)) {
       return expr;
     }
-    var terms = factored.terms;
-    var isAdd = function isAdd(term) {
-      return term instanceof Add;
-    };
-    var hasVar = function hasVar(term) {
-      return !!term.getVars().length;
-    };
-    var isOne = function isOne(term) {
-      return term.equals(Num.One);
-    };
-    var grouped = _.groupBy(terms, isAdd);
-    var adds = grouped[true] || [];
-    var others = grouped[false] || [];
+    const terms = factored.terms;
+    const hasVar = term => !!term.getVars().length;
+    const isOne = term => term.equals(NumOne);
+    const [adds, others] = partition(terms, isAdd);
     if (adds.length && this.isEquality()) {
       // keep only Adds
       // e.g. 2xy(z+1)(=0) -> z+1(=0)
       return new Mul(adds).flatten();
     }
-    var denominator = others;
+    let denominator = others;
     if (!adds.length) {
       // if no Adds, keep all variable terms to preserve meaning
       // e.g. 42xyz(=0) -> xyz(=0)
@@ -4800,10 +4857,10 @@ _.extend(Eq.prototype, {
 
     // don't need to divide by one
     denominator = _.reject(denominator, isOne);
-    denominator = _.map(denominator, function (term) {
-      return new Pow(term, Num.Div);
+    denominator = _.map(denominator, term => {
+      return new Pow(term, NumDiv);
     });
-    var dividedResult = new Mul(terms.concat(denominator)).collect();
+    const dividedResult = new Mul(terms.concat(denominator)).collect();
 
     // If the end result is the same as the original factoring,
     // rollback the factoring and discard all intermediate steps.
@@ -4812,11 +4869,11 @@ _.extend(Eq.prototype, {
     } else {
       return dividedResult;
     }
-  },
-  isEquality: function () {
+  }
+  isEquality() {
     return _.contains(["=", "<>"], this.type);
-  },
-  compare: function (other) {
+  }
+  compare(other) {
     // expression comparisons are handled by Expr.compare()
     if (!(other instanceof Eq)) {
       return false;
@@ -4837,9 +4894,10 @@ _.extend(Eq.prototype, {
     } else {
       return expr1.compare(expr2);
     }
-  },
+  }
+
   // should only be done after compare() returns true to avoid false positives
-  sameForm: function (other) {
+  sameForm(other) {
     var eq1 = this.normalize();
     var eq2 = other.normalize();
     var same = eq1.left.sameForm(eq2.left) && eq1.right.sameForm(eq2.right);
@@ -4849,71 +4907,66 @@ _.extend(Eq.prototype, {
     } else {
       return same;
     }
-  },
+  }
+
   // we don't want to override collect because it would turn y=x into y-x(=0)
   // instead, we ask if the equation was in that form, would it be simplified?
-  isSimplified: function () {
+  isSimplified() {
     var expr = this.asExpr( /* unfactored */true);
     var simplified = this.divideThrough(expr).simplify();
     return expr.equals(simplified) && this.left.isSimplified() && this.right.isSimplified();
   }
-});
-_.extend(Eq.prototype, {
+
   // Assumptions: Expression is of the form a+bx, and we solve for x
-  solveLinearEquationForVariable: function (variable) {
+  solveLinearEquationForVariable(variable) {
     var expr = this.asExpr();
-    if (!expr.is(Add) || expr.terms.length !== 2) {
+    if (!(expr instanceof Add) || expr.terms.length !== 2) {
       throw new Error("Can only handle linear equations of the form " + "a + bx (= 0)");
     }
-    var hasVar = function hasVar(term) {
+    var hasVar = term => {
       return term.has(Var) && _.contains(term.getVars(), variable.symbol);
     };
-    var a, b;
-    if (hasVar(expr.terms[0])) {
-      a = Mul.handleNegative(expr.terms[1]);
-      b = Mul.handleDivide(expr.terms[0], variable);
-    } else {
-      a = Mul.handleNegative(expr.terms[0]);
-      b = Mul.handleDivide(expr.terms[1], variable);
-    }
+    const termHasVar = hasVar(expr.terms[0]);
+    const a = termHasVar ? Mul.handleNegative(expr.terms[1]) : Mul.handleNegative(expr.terms[0]);
+    const b = termHasVar ? Mul.handleDivide(expr.terms[0], variable) : Mul.handleDivide(expr.terms[1], variable);
     return Mul.handleDivide(a, b).simplify();
   }
-});
+}
 
 /* abstract symbol node */
-function Symbol() {}
-Symbol.prototype = new Expr();
-_.extend(Symbol.prototype, {
-  needsExplicitMul: function () {
+class Sym extends Expr {
+  needsExplicitMul() {
     return false;
-  },
-  findGCD: function (factor) {
-    if (factor instanceof Symbol || factor instanceof Num) {
-      return this.equals(factor) ? this : Num.One;
+  }
+  findGCD(factor) {
+    if (factor instanceof Sym || factor instanceof Num) {
+      return this.equals(factor) ? this : NumOne;
     } else {
       return factor.findGCD(this);
     }
   }
-});
+}
 
 /* function variable */
-function Func(symbol, arg) {
-  this.symbol = symbol;
-  this.arg = arg;
-}
-Func.prototype = new Symbol();
-_.extend(Func.prototype, {
-  func: Func,
-  args: function () {
+class Func extends Sym {
+  constructor(symbol, arg) {
+    super();
+    this.symbol = void 0;
+    this.arg = void 0;
+    this.func = Func;
+    this.symbol = symbol;
+    this.arg = arg;
+  }
+  args() {
     return [this.symbol, this.arg];
-  },
-  print: function () {
+  }
+  print() {
     return this.symbol + "(" + this.arg.print() + ")";
-  },
-  tex: function () {
+  }
+  tex() {
     return this.symbol + "(" + this.arg.tex() + ")";
-  },
-  eval: function (vars, options) {
+  }
+  eval(vars = {}, options) {
     var arg = this.arg;
     var func = vars[this.symbol];
     var newVars = _.extend(_.clone(vars), {
@@ -4925,191 +4978,211 @@ _.extend(Func.prototype, {
     }
     // If parsedFunc isn't actually parsed, return its error
     return parsedFunc;
-  },
-  codegen: function () {
+  }
+  codegen() {
     return 'vars["' + this.symbol + '"](' + this.arg.codegen() + ")";
-  },
-  getUnits: function () {
+  }
+  getUnits() {
     return this.arg.getUnits();
-  },
-  getVars: function (excludeFunc) {
+  }
+  getVars(excludeFunc) {
     if (excludeFunc) {
       return this.arg.getVars();
     } else {
       return _.union(this.arg.getVars(), [this.symbol]).sort();
     }
-  },
-  getConsts: function () {
+  }
+  getConsts() {
     return this.arg.getConsts();
   }
-});
+}
 
 /* variable */
-function Var(symbol, subscript) {
-  this.symbol = symbol;
-  this.subscript = subscript;
-}
-Var.prototype = new Symbol();
-_.extend(Var.prototype, {
-  func: Var,
-  args: function () {
+class Var extends Sym {
+  constructor(symbol, subscript) {
+    super();
+    this.symbol = void 0;
+    this.subscript = void 0;
+    this.func = Var;
+    this.symbol = symbol;
+    this.subscript = subscript;
+  }
+  args() {
     return [this.symbol, this.subscript];
-  },
-  exprArgs: function () {
+  }
+  exprArgs() {
     return [];
-  },
-  recurse: function () {
+  }
+  recurse() {
     return this;
-  },
-  print: function () {
+  }
+  print() {
     var sub = "";
     if (this.subscript) {
       sub = "_(" + this.subscript.print() + ")";
     }
     return this.symbol + sub;
-  },
+  }
+
   // Provide a way to easily evalate expressions with the common case,
   // subscripts that consist of a single number or symbol e.g. x_a or x_42
-  prettyPrint: function () {
+  prettyPrint() {
     var sub = this.subscript;
-    if (sub && (sub instanceof Num || sub instanceof Symbol)) {
+    if (sub && (sub instanceof Num || sub instanceof Sym)) {
       return this.symbol + "_" + sub.print();
     } else {
       return this.print();
     }
-  },
-  tex: function () {
+  }
+  tex() {
     var sub = "";
     if (this.subscript) {
       sub = "_{" + this.subscript.tex() + "}";
     }
     var prefix = this.symbol.length > 1 ? "\\" : "";
     return prefix + this.symbol + sub;
-  },
-  repr: function () {
+  }
+  repr() {
     return "Var(" + this.print() + ")";
-  },
-  eval: function (vars, options) {
+  }
+  eval(vars = {}, options) {
+    // @ts-expect-error: values is Vars are strings, but here
+    // we expect them to be numbers.  We should probably store
+    // Var and Func entries separately in the Vars type so that
+    // they can be typed correctly.
     return vars[this.prettyPrint()];
-  },
-  codegen: function () {
+  }
+  codegen() {
     return 'vars["' + this.prettyPrint() + '"]';
-  },
-  getVars: function () {
+  }
+  getVars() {
     return [this.prettyPrint()];
-  },
-  isPositive: function () {
+  }
+  isPositive() {
     return false;
   }
-});
+}
 
 /* constant */
-function Const(symbol) {
-  this.symbol = symbol;
-}
-Const.prototype = new Symbol();
-_.extend(Const.prototype, {
-  func: Const,
-  args: function () {
+class Const extends Sym {
+  constructor(symbol) {
+    super();
+    this.symbol = void 0;
+    this.func = Const;
+    this.symbol = symbol;
+  }
+  args() {
     return [this.symbol];
-  },
-  recurse: function () {
+  }
+  recurse() {
     return this;
-  },
-  eval: function (vars, options) {
+  }
+  eval(vars = {}, options) {
     if (this.symbol === "pi") {
       return Math.PI;
     } else if (this.symbol === "e") {
       return Math.E;
+    } else {
+      // @ts-expect-error: should we throw an error here?
+      return undefined;
     }
-  },
-  codegen: function () {
+  }
+  codegen() {
     if (this.symbol === "pi") {
       return "Math.PI";
     } else if (this.symbol === "e") {
       return "Math.E";
+    } else {
+      // @ts-expect-error: should we throw an error here?
+      return undefined;
     }
-  },
-  print: function () {
+  }
+  print() {
     return this.symbol;
-  },
-  tex: function () {
+  }
+  tex() {
     if (this.symbol === "pi") {
       return "\\pi ";
     } else if (this.symbol === "e") {
       return "e";
+    } else {
+      // @ts-expect-error: should we return this.symbol here?
+      return undefined;
     }
-  },
-  isPositive: function () {
+  }
+  isPositive() {
     return this.eval() > 0;
-  },
-  abs: function () {
+  }
+  abs() {
     if (this.eval() > 0) {
       return this;
     } else {
       return Mul.handleNegative(this);
     }
-  },
-  getConsts: function () {
+  }
+  getConsts() {
     return [this.print()];
   }
-});
-Const.e = new Const("e");
-Const.pi = new Const("pi");
+}
 
 /* abstract number node */
-function Num() {}
-Num.prototype = new Expr();
-_.extend(Num.prototype, {
-  repr: function () {
+_class12 = Const;
+Const.e = new _class12("e");
+Const.pi = new _class12("pi");
+class Num extends Expr {
+  constructor() {
+    super();
+    // hints for interpreting and rendering user input
+    this.n = 0;
+    this.hints = _extends({}, this.hints, {
+      negate: false,
+      subtract: false,
+      divide: false,
+      root: false,
+      fraction: false,
+      entered: false
+    });
+  }
+  repr() {
     return this.print();
-  },
-  strip: function () {
+  }
+  strip() {
     return this.abs();
-  },
-  recurse: function () {
+  }
+  recurse() {
     return this;
-  },
-  codegen: function () {
+  }
+  codegen() {
     return this.print();
-  },
+  }
+
   // takes another Num and returns a new Num
-  add: abstract,
-  mul: abstract,
+
   // returns this Num's additive inverse
-  negate: abstract,
-  isSubtract: function () {
-    return this.hints.subtract;
-  },
+
+  isSubtract() {
+    return Boolean(this.hints.subtract);
+  }
+
   // return the absolute value of the number
-  abs: abstract,
-  needsExplicitMul: function () {
+
+  needsExplicitMul() {
     return true;
-  },
-  findGCD: abstract,
-  isPositive: function () {
+  }
+  isPositive() {
     return this.eval() > 0;
-  },
-  isNegative: function () {
+  }
+  isNegative() {
     return this.eval() < 0;
-  },
-  asPositiveFactor: function () {
+  }
+  asPositiveFactor() {
     return this.isPositive() ? this : this.abs();
-  },
-  // hints for interpreting and rendering user input
-  hints: _.extend(Num.prototype.hints, {
-    negate: false,
-    subtract: false,
-    divide: false,
-    root: false,
-    fraction: false,
-    entered: false
-  }),
+  }
+
   // whether a number is considered simple (one term)
   // e.g. for reals, ints and floats are simple
-  isSimple: abstract,
   // Based on http://stackoverflow.com/a/10454560/2571482
-  getDecimalPlaces: function () {
+  getDecimalPlaces() {
     var match = ("" + this.n).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
     if (match) {
       return Math.max(0,
@@ -5120,52 +5193,88 @@ _.extend(Num.prototype, {
     } else {
       return 0;
     }
-  },
-  asRational: abstract
-});
+  }
+  static negativeOne(hint) {
+    if (hint === "subtract") {
+      return NumSub;
+    } else if (hint === "divide") {
+      return NumDiv;
+    } else {
+      return NumNeg;
+    }
+  }
 
-/* rational number (n: numerator, d: denominator) */
-function Rational(numerator, denominator) {
-  var n = numerator;
-  var d = denominator;
-  if (d < 0) {
-    n = -n;
-    d = -d;
-  }
-  this.n = n;
-  this.d = d;
+  // find the greatest common denominator
+  static findGCD(a, b) {
+    var mod;
+    a = Math.abs(a);
+    b = Math.abs(b);
+
+    // Euclid's method doesn't handle non-integers very well. For now
+    // we just say we can't pull out a common factor. It might be
+    // reasonable to do better than this in the future.
+    if (a !== Math.floor(a) || b !== Math.floor(b)) {
+      return 1;
+    }
+    while (b) {
+      mod = a % b;
+      a = b;
+      b = mod;
+    }
+    return a;
+  }
+  static min(...args) {
+    return _.min(args, num => num.eval());
+  }
+  static max(...args) {
+    return _.max(args, num => num.eval());
+  }
 }
-Rational.prototype = new Num();
-_.extend(Rational.prototype, {
-  func: Rational,
-  args: function () {
+
+/* rational number (n: numerator, d: denominator) */
+class Rational extends Num {
+  constructor(numerator, denominator) {
+    super();
+    this.n = void 0;
+    this.d = void 0;
+    this.func = Rational;
+    var n = numerator;
+    var d = denominator;
+    if (d < 0) {
+      n = -n;
+      d = -d;
+    }
+    this.n = n;
+    this.d = d;
+  }
+  args() {
     return [this.n, this.d];
-  },
-  eval: function () {
+  }
+  eval() {
     return this.n / this.d;
-  },
-  print: function () {
+  }
+  print() {
     return this.n.toString() + "/" + this.d.toString();
-  },
-  tex: function () {
+  }
+  tex() {
     var tex = "\\frac{" + Math.abs(this.n).toString() + "}{" + this.d.toString() + "}";
     return this.n < 0 ? "-" + tex : tex;
-  },
-  add: function (num, options) {
+  }
+  add(num, options) {
     if (num instanceof Rational) {
       return new Rational(this.n * num.d + this.d * num.n, this.d * num.d).collect();
     } else {
       return num.add(this, options);
     }
-  },
-  mul: function (num, options) {
+  }
+  mul(num, options) {
     if (num instanceof Rational) {
       return new Rational(this.n * num.n, this.d * num.d).collect();
     } else {
       return num.mul(this, options);
     }
-  },
-  collect: function () {
+  }
+  collect() {
     var gcd = Num.findGCD(this.n, this.d);
     var n = this.n / gcd;
     var d = this.d / gcd;
@@ -5174,14 +5283,14 @@ _.extend(Rational.prototype, {
     } else {
       return new Rational(n, d);
     }
-  },
-  negate: function () {
+  }
+  negate() {
     return new Rational(-this.n, this.d);
-  },
-  abs: function () {
+  }
+  abs() {
     return new Rational(Math.abs(this.n), this.d);
-  },
-  findGCD: function (factor) {
+  }
+  findGCD(factor) {
     // Attempt to factor out common numerators and denominators to return
     // a Rational instead of a Float
     if (factor instanceof Rational) {
@@ -5196,9 +5305,10 @@ _.extend(Rational.prototype, {
     } else {
       return factor.findGCD(this);
     }
-  },
+  }
+
   // for now, assuming that exp is a Num
-  raiseToThe: function (exp) {
+  raiseToThe(exp) {
     if (exp instanceof Int) {
       var positive = exp.eval() > 0;
       var abs = exp.abs().eval();
@@ -5212,120 +5322,121 @@ _.extend(Rational.prototype, {
     } else {
       return new Float(this.eval()).raiseToThe(exp);
     }
-  },
-  getDenominator: function () {
+  }
+  getDenominator() {
     return new Int(this.d);
-  },
-  isSimple: function () {
+  }
+  isSimple() {
     return false;
-  },
-  asRational: function () {
+  }
+  asRational() {
     return this;
   }
-});
+}
 
 /* integer (n: numerator/number) */
-function Int(number) {
-  this.n = number;
-}
-Int.prototype = new Rational(0, 1);
-_.extend(Int.prototype, {
-  func: Int,
-  args: function () {
+class Int extends Rational {
+  constructor(number) {
+    super(number, 1);
+    this.func = Int;
+  }
+  args() {
     return [this.n];
-  },
-  print: function () {
+  }
+  print() {
     return this.n.toString();
-  },
-  tex: function () {
+  }
+  tex() {
     return this.n.toString();
-  },
-  negate: function () {
+  }
+  negate() {
     return new Int(-this.n);
-  },
-  abs: function () {
+  }
+  abs() {
     return new Int(Math.abs(this.n));
-  },
-  isSimple: function () {
+  }
+  isSimple() {
     return true;
-  },
-  findGCD: function (factor) {
+  }
+  findGCD(factor) {
     if (factor instanceof Int) {
       return new Int(Num.findGCD(this.n, factor.n));
     } else {
       return factor.findGCD(this);
     }
   }
-});
-_.extend(Int, {
-  create: function (n) {
+  static create(n) {
     return new Int(n).addHint("entered");
   }
-});
+}
 
 /* float (n: number) */
-function Float(number) {
-  this.n = number;
-}
-Float.prototype = new Num();
-_.extend(Float.prototype, {
-  func: Float,
-  args: function () {
+class Float extends Num {
+  constructor(number) {
+    super();
+    this.n = void 0;
+    this.func = Float;
+    this.n = number;
+  }
+  args() {
     return [this.n];
-  },
-  eval: function () {
+  }
+  eval() {
     return this.n;
-  },
+  }
+
   // TODO(alex): when we internationalize number parsing/display
   // we should make sure to use the appropriate decimal mark here
-  print: function () {
+  print() {
     return this.n.toString();
-  },
-  tex: function () {
+  }
+  tex() {
     return this.n.toString();
-  },
-  add: function (num, options) {
+  }
+  add(num, options) {
     if (options && options.preciseFloats) {
       return Float.toDecimalPlaces(this.n + num.eval(), Math.max(this.getDecimalPlaces(), num.getDecimalPlaces()));
     } else {
       return new Float(this.n + num.eval()).collect();
     }
-  },
-  mul: function (num, options) {
+  }
+  mul(num, options) {
     if (options && options.preciseFloats) {
       return Float.toDecimalPlaces(this.n * num.eval(), this.getDecimalPlaces() + num.getDecimalPlaces());
     } else {
       return new Float(this.n * num.eval()).collect();
     }
-  },
-  collect: function () {
+  }
+  collect(options) {
     // We used to simplify Floats to Ints here whenever possible, but no
     // longer do so in order to preserve significant figures.
     return this;
-  },
-  negate: function () {
+  }
+  negate() {
     return new Float(-this.n);
-  },
-  abs: function () {
+  }
+  abs() {
     return new Float(Math.abs(this.n));
-  },
-  findGCD: function (factor) {
+  }
+  findGCD(factor) {
     if (factor instanceof Num) {
       return new Float(Num.findGCD(this.eval(), factor.eval())).collect();
     } else {
       return factor.findGCD(this);
     }
-  },
+  }
+
   // for now, assuming that exp is a Num
-  raiseToThe: function (exp, options) {
+  raiseToThe(exp, options) {
     if (options && options.preciseFloats && exp instanceof Int && exp.n > 1) {
       return Float.toDecimalPlaces(new Pow(this, exp).eval(), this.getDecimalPlaces() * exp.n);
     } else {
       return new Float(new Pow(this, exp).eval()).collect();
     }
-  },
+  }
+
   // only to be used on non-repeating decimals (e.g. user-provided)
-  asRational: function () {
+  asRational() {
     var parts = this.n.toString().split(".");
     if (parts.length === 1) {
       return new Rational(this.n, 1);
@@ -5334,77 +5445,30 @@ _.extend(Float.prototype, {
       var denominator = Math.pow(10, parts[1].length);
       return new Rational(numerator, denominator).collect();
     }
-  },
-  getDenominator: function () {
+  }
+  getDenominator() {
     return this.asRational().getDenominator();
-  },
-  isSimple: function () {
+  }
+  isSimple() {
     return true;
   }
-});
-_.extend(Float, {
-  create: function (n) {
+  static create(n) {
     return new Float(n).addHint("entered");
-  },
+  }
+
   // Account for floating point imprecision by explicitly controlling the
   // number of decimal places in common operations (e.g. +, *, ^)
-  toDecimalPlaces: function (n, places) {
+  static toDecimalPlaces(n, places) {
     return new Float(+n.toFixed(Math.min(places, 20))).collect();
   }
-});
-
-// static methods and fields that are best defined on Num
-_.extend(Num, {
-  negativeOne: function (hint) {
-    if (hint === "subtract") {
-      return Num.Sub;
-    } else if (hint === "divide") {
-      return Num.Div;
-    } else {
-      return Num.Neg;
-    }
-  },
-  // find the greatest common denominator
-  findGCD: function (a, b) {
-    var mod;
-    a = Math.abs(a);
-    b = Math.abs(b);
-
-    // Euclid's method doesn't handle non-integers very well. For now
-    // we just say we can't pull out a common factor. It might be
-    // reasonable to do better than this in the future.
-    if (a !== Math.floor(a) || b !== Math.floor(b)) {
-      return 1;
-    }
-    while (b) {
-      mod = a % b;
-      a = b;
-      b = mod;
-    }
-    return a;
-  },
-  min: function () {
-    return _.min(_.toArray(arguments), function (num) {
-      return num.eval();
-    });
-  },
-  max: function () {
-    return _.max(_.toArray(arguments), function (num) {
-      return num.eval();
-    });
-  }
-});
-Num.Neg = new Int(-1).addHint("negate");
-Num.Sub = new Int(-1).addHint("subtract");
-Num.Div = new Int(-1).addHint("divide");
-Num.Sqrt = new Rational(1, 2).addHint("root");
-Num.Zero = new Int(0);
-Num.One = new Int(1);
-Num.Ten = new Int(10);
-
-// set identities here
-Add.prototype.identity = Num.Zero;
-Mul.prototype.identity = Num.One;
+}
+const NumNeg = new Int(-1).addHint("negate");
+const NumSub = new Int(-1).addHint("subtract");
+const NumDiv = new Int(-1).addHint("divide");
+const NumSqrt = new Rational(1, 2).addHint("root");
+const NumZero = new Int(0);
+const NumOne = new Int(1);
+const NumTen = new Int(10);
 var parseError = function parseError(str, hash) {
   // return int location of parsing error
   throw new Error(hash.loc.first_column);
@@ -5467,10 +5531,56 @@ const parse = function parse(input, options) {
 };
 
 /* unit */
-function Unit(symbol) {
-  this.symbol = symbol;
+class Unit extends Sym {
+  constructor(symbol) {
+    super();
+    this.symbol = void 0;
+    this.func = Unit;
+    this.symbol = symbol;
+  }
+  args() {
+    return [this.symbol];
+  }
+  recurse() {
+    return this;
+  }
+  eval(vars = {}, options) {
+    // This is called when comparing units. A unit doesn't affect the
+    // numerical value of its coefficient, so this needs to be 1.
+    //
+    // On the other hand, things must not evaluate to the same thing if
+    // they don't have the same type. I believe that's also true - form is
+    // checked before numerical equivalence. I do not know where, though.
+    // However, there are a couple tests checking this.
+    return 1;
+  }
+  getUnits() {
+    return [{
+      unit: this.symbol,
+      pow: 1
+    }];
+  }
+  codegen() {
+    return "1";
+  }
+  print() {
+    return this.symbol;
+  }
+  tex() {
+    return this.symbol;
+  }
+
+  // Simplify units by replacing prefixes with multiplication
+  collect(options) {
+    if (_(baseUnits).has(this.symbol)) {
+      return this;
+    } else if (_(derivedUnits).has(this.symbol)) {
+      return derivedUnits[this.symbol].conversion;
+    } else {
+      throw new Error("could not understand unit: " + this.symbol);
+    }
+  }
 }
-Unit.prototype = new Symbol();
 
 // If possible, replace unit prefixes with a multiplication.
 //
@@ -5482,7 +5592,7 @@ var unprefixify = function unprefixify(symbol) {
   }
 
   // check for prefix
-  var prefix = _(_(siPrefixes).keys()).find(function (testPrefix) {
+  var prefix = _(_(siPrefixes).keys()).find(testPrefix => {
     return new RegExp("^" + testPrefix).test(symbol);
   });
   if (prefix) {
@@ -5522,18 +5632,18 @@ const unitParse = function unitParse(input) {
     //
     // denom is optionally null
 
-    var unitArray = [];
-    _(parseResult.unit.num).each(function (unitSpec) {
+    const unitArray = [];
+    _(parseResult.unit.num).each(unitSpec => {
       unitArray.push(new Pow(unprefixify(unitSpec.name), new Int(unitSpec.pow)));
     });
-    _(parseResult.unit.denom).each(function (unitSpec) {
+    _(parseResult.unit.denom).each(unitSpec => {
       unitArray.push(new Pow(unprefixify(unitSpec.name), new Int(-1 * unitSpec.pow)));
     });
     var unit = new Mul(unitArray).flatten();
     if (parseResult.type === "unitMagnitude") {
       // in the first case we have a magnitude coefficient as well as the
       // unit itself.
-      var coefArray = [new Float(+parseResult.magnitude)].concat(unitArray);
+      var coefArray = [new Float(+parseResult.magnitude), ...unitArray];
       var expr = new Mul(coefArray);
       return {
         parsed: true,
@@ -5557,50 +5667,6 @@ const unitParse = function unitParse(input) {
     };
   }
 };
-_.extend(Unit.prototype, {
-  func: Unit,
-  args: function () {
-    return [this.symbol];
-  },
-  recurse: function () {
-    return this;
-  },
-  eval: function (vars, options) {
-    // This is called when comparing units. A unit doesn't affect the
-    // numerical value of its coefficient, so this needs to be 1.
-    //
-    // On the other hand, things must not evaluate to the same thing if
-    // they don't have the same type. I believe that's also true - form is
-    // checked before numerical equivalence. I do not know where, though.
-    // However, there are a couple tests checking this.
-    return 1;
-  },
-  getUnits: function () {
-    return [{
-      unit: this.symbol,
-      pow: 1
-    }];
-  },
-  codegen: function () {
-    return "1";
-  },
-  print: function () {
-    return this.symbol;
-  },
-  tex: function () {
-    return this.symbol;
-  },
-  // Simplify units by replacing prefixes with multiplication
-  collect: function (options) {
-    if (_(baseUnits).has(this.symbol)) {
-      return this;
-    } else if (_(derivedUnits).has(this.symbol)) {
-      return derivedUnits[this.symbol].conversion;
-    } else {
-      throw new Error("could not understand unit: " + this.symbol);
-    }
-  }
-});
 var baseUnits = {
   m: new Unit("m"),
   // Note: kg is the SI base unit but we use g for consistency
@@ -5633,31 +5699,23 @@ var siPrefixes = {
 };
 
 // Use these two values to mark a unit as either SI-prefixable or not.
-var hasPrefixes = {};
-var hasntPrefixes = {};
-var makeAlias = function makeAlias(str, prefixes) {
+const hasPrefixes = "hasPrefixes";
+const hasntPrefixes = "hasntPrefixes";
+const makeAlias = function makeAlias(str, prefixes) {
   var splits = str.split("|");
   var coefficientStr = splits[0].trim();
   var unitsStr = splits[1].trim();
-  var coefficient = Num.One;
+  var coefficient = NumOne;
   if (coefficientStr !== "") {
     coefficient = parse(coefficientStr).expr;
   }
   var numdenomStr = unitsStr.split("/");
   var numdenom = [coefficient];
   if (numdenomStr[0]) {
-    numdenomStr[0].split(" ").filter(function (x) {
-      return x !== "";
-    }).map(function (x) {
-      numdenom.push(new Unit(x));
-    });
+    numdenomStr[0].split(" ").filter(x => x !== "").forEach(x => numdenom.push(new Unit(x)));
   }
   if (numdenomStr[1]) {
-    numdenomStr[1].split(" ").filter(function (x) {
-      return x !== "";
-    }).map(function (x) {
-      numdenom.push(new Pow(new Unit(x), Num.Div));
-    });
+    numdenomStr[1].split(" ").filter(x => x !== "").forEach(x => numdenom.push(new Pow(new Unit(x), NumDiv)));
   }
   return {
     conversion: new Mul(numdenom),
@@ -5814,18 +5872,8 @@ var derivedUnits = {
   // other
   Hz: makeAlias("| / s", hasPrefixes)
 };
-const Zero = Num.Zero;
-const One = Num.One;
-
-function _extends() {
-  return _extends = Object.assign ? Object.assign.bind() : function (n) {
-    for (var e = 1; e < arguments.length; e++) {
-      var t = arguments[e];
-      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
-    }
-    return n;
-  }, _extends.apply(null, arguments);
-}
+const Zero = NumZero;
+const One = NumOne;
 
 // Assumes that both expressions have already been parsed
 // TODO(alex): be able to pass a random() function to compare()