@khanacademy/kas 0.3.0 → 0.3.1

package/dist/es/index.js

@@ -77,8 +77,7 @@ import _ from 'underscore';
 */
 var parser$1 = function () {
   var o = function o(k, v, _o, l) {
-      for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v) {
-      }
+      for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v);
       return _o;
     },
     $V0 = [1, 11],
@@ -424,7 +423,7 @@ var parser$1 = function () {
         }
       },
       // resets the lexer, sets new input
-      setInput: function setInput(input, yy) {
+      setInput: function (input, yy) {
         this.yy = yy || this.yy || {};
         this._input = input;
         this._more = this._backtrack = this.done = false;
@@ -444,7 +443,7 @@ var parser$1 = function () {
         return this;
       },
       // consumes and returns one char from the input
-      input: function input() {
+      input: function () {
         var ch = this._input[0];
         this.yytext += ch;
         this.yyleng++;
@@ -465,7 +464,7 @@ var parser$1 = function () {
         return ch;
       },
       // unshifts one char (or a string) into the input
-      unput: function unput(ch) {
+      unput: function (ch) {
         var len = ch.length;
         var lines = ch.split(/(?:\r\n?|\n)/g);
         this._input = ch + this._input;
@@ -492,12 +491,12 @@ var parser$1 = function () {
         return this;
       },
       // When called from action, caches matched text and appends it on next action
-      more: function more() {
+      more: function () {
         this._more = true;
         return this;
       },
       // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
-      reject: function reject() {
+      reject: function () {
         if (this.options.backtrack_lexer) {
           this._backtrack = true;
         } else {
@@ -510,16 +509,16 @@ var parser$1 = function () {
         return this;
       },
       // retain first n characters of the match
-      less: function less(n) {
+      less: function (n) {
         this.unput(this.match.slice(n));
       },
       // displays already matched input, i.e. for error messages
-      pastInput: function pastInput() {
+      pastInput: function () {
         var past = this.matched.substr(0, this.matched.length - this.match.length);
         return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
       },
       // displays upcoming input, i.e. for error messages
-      upcomingInput: function upcomingInput() {
+      upcomingInput: function () {
         var next = this.match;
         if (next.length < 20) {
           next += this._input.substr(0, 20 - next.length);
@@ -527,13 +526,13 @@ var parser$1 = function () {
         return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
       },
       // displays the character position where the lexing error occurred, i.e. for error messages
-      showPosition: function showPosition() {
+      showPosition: function () {
         var pre = this.pastInput();
         var c = new Array(pre.length + 1).join("-");
         return pre + this.upcomingInput() + "\n" + c + "^";
       },
       // test the lexed token: return FALSE when not a match, otherwise return token
-      test_match: function test_match(match, indexed_rule) {
+      test_match: function (match, indexed_rule) {
         var token, lines, backup;
         if (this.options.backtrack_lexer) {
           // save context
@@ -599,7 +598,7 @@ var parser$1 = function () {
         return false;
       },
       // return next match in input
-      next: function next() {
+      next: function () {
         if (this.done) {
           return this.EOF;
         }
@@ -750,7 +749,7 @@ var parser$1 = function () {
   parser.Parser = Parser;
   return new Parser();
 }();
-var unitParser = parser$1;
+const unitParser = parser$1;
 
 // This is a @generated file
 
@@ -829,8 +828,7 @@ var unitParser = parser$1;
 */
 var parser = function () {
   var o = function o(k, v, _o, l) {
-      for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v) {
-      }
+      for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v);
       return _o;
     },
     $V0 = [1, 7],
@@ -2103,7 +2101,7 @@ var parser = function () {
         }
       },
       // resets the lexer, sets new input
-      setInput: function setInput(input, yy) {
+      setInput: function (input, yy) {
         this.yy = yy || this.yy || {};
         this._input = input;
         this._more = this._backtrack = this.done = false;
@@ -2123,7 +2121,7 @@ var parser = function () {
         return this;
       },
       // consumes and returns one char from the input
-      input: function input() {
+      input: function () {
         var ch = this._input[0];
         this.yytext += ch;
         this.yyleng++;
@@ -2144,7 +2142,7 @@ var parser = function () {
         return ch;
       },
       // unshifts one char (or a string) into the input
-      unput: function unput(ch) {
+      unput: function (ch) {
         var len = ch.length;
         var lines = ch.split(/(?:\r\n?|\n)/g);
         this._input = ch + this._input;
@@ -2171,12 +2169,12 @@ var parser = function () {
         return this;
       },
       // When called from action, caches matched text and appends it on next action
-      more: function more() {
+      more: function () {
         this._more = true;
         return this;
       },
       // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.
-      reject: function reject() {
+      reject: function () {
         if (this.options.backtrack_lexer) {
           this._backtrack = true;
         } else {
@@ -2189,16 +2187,16 @@ var parser = function () {
         return this;
       },
       // retain first n characters of the match
-      less: function less(n) {
+      less: function (n) {
         this.unput(this.match.slice(n));
       },
       // displays already matched input, i.e. for error messages
-      pastInput: function pastInput() {
+      pastInput: function () {
         var past = this.matched.substr(0, this.matched.length - this.match.length);
         return (past.length > 20 ? '...' : '') + past.substr(-20).replace(/\n/g, "");
       },
       // displays upcoming input, i.e. for error messages
-      upcomingInput: function upcomingInput() {
+      upcomingInput: function () {
         var next = this.match;
         if (next.length < 20) {
           next += this._input.substr(0, 20 - next.length);
@@ -2206,13 +2204,13 @@ var parser = function () {
         return (next.substr(0, 20) + (next.length > 20 ? '...' : '')).replace(/\n/g, "");
       },
       // displays the character position where the lexing error occurred, i.e. for error messages
-      showPosition: function showPosition() {
+      showPosition: function () {
         var pre = this.pastInput();
         var c = new Array(pre.length + 1).join("-");
         return pre + this.upcomingInput() + "\n" + c + "^";
       },
       // test the lexed token: return FALSE when not a match, otherwise return token
-      test_match: function test_match(match, indexed_rule) {
+      test_match: function (match, indexed_rule) {
         var token, lines, backup;
         if (this.options.backtrack_lexer) {
           // save context
@@ -2278,7 +2276,7 @@ var parser = function () {
         return false;
       },
       // return next match in input
-      next: function next() {
+      next: function () {
         if (this.done) {
           return this.EOF;
         }
@@ -2681,13 +2679,13 @@ _.extend(Expr.prototype, {
   // an array of the arguments to this node's immediate constructor
   args: abstract,
   // make a new node with the given arguments
-  construct: function construct(args) {
+  construct: function (args) {
     var instance = new this.func();
     this.func.apply(instance, args);
     return instance;
   },
   // an abstraction for chainable, bottom-up recursion
-  recurse: function recurse(method) {
+  recurse: function (method) {
     var passed = Array.prototype.slice.call(arguments, 1);
     var args = _.map(this.args(), function (arg) {
       return _.isString(arg) ? arg : arg[method].apply(arg, passed);
@@ -2697,7 +2695,7 @@ _.extend(Expr.prototype, {
   // evaluate numerically with given variable mapping
   eval: abstract,
   codegen: abstract,
-  compile: function compile() {
+  compile: function () {
     var code = this.codegen();
     try {
       return new Function("vars", "return " + code + ";");
@@ -2712,7 +2710,7 @@ _.extend(Expr.prototype, {
   // returns a TeX string representing the expression
   tex: abstract,
   // returns a TeX string, modified by the given options
-  asTex: function asTex(options) {
+  asTex: function (options) {
     options = options || {};
     _.defaults(options, {
       display: true,
@@ -2734,7 +2732,7 @@ _.extend(Expr.prototype, {
   },
   // 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 name() {
+  name: function () {
     if (this.func.name) {
       return this.func.name;
     } else {
@@ -2742,37 +2740,37 @@ _.extend(Expr.prototype, {
     }
   },
   // returns a string representing current node structure
-  repr: function repr() {
+  repr: function () {
     return this.name() + "(" + _.map(this.args(), function (arg) {
       return _.isString(arg) ? arg : arg.repr();
     }).join(",") + ")";
   },
   // removes all negative signs
-  strip: function strip() {
+  strip: function () {
     return this.recurse("strip");
   },
   // canonically reorders all commutative elements
-  normalize: function normalize() {
+  normalize: function () {
     return this.recurse("normalize");
   },
   // expands the expression
-  expand: function expand() {
+  expand: function () {
     return this.recurse("expand");
   },
   // naively factors out like terms
-  factor: function factor(options) {
+  factor: function (options) {
     return this.recurse("factor", options);
   },
   // collect all like terms
-  collect: function collect(options) {
+  collect: function (options) {
     return this.recurse("collect", options);
   },
   // strict syntactic equality check
-  equals: function equals(other) {
+  equals: function (other) {
     return this.normalize().print() === other.normalize().print();
   },
   // expand and collect until the expression no longer changes
-  simplify: function simplify(options) {
+  simplify: function (options) {
     options = _.extend({
       once: false
     }, options);
@@ -2804,31 +2802,31 @@ _.extend(Expr.prototype, {
     }
   },
   // check whether this expression is simplified
-  isSimplified: function isSimplified() {
+  isSimplified: function () {
     return this.equals(this.simplify());
   },
   // return the child nodes of this node
-  exprArgs: function exprArgs() {
+  exprArgs: function () {
     return _.filter(this.args(), function (arg) {
       return arg instanceof Expr;
     });
   },
   // return the variables (function and non) within the expression
-  getVars: function getVars(excludeFunc) {
+  getVars: function (excludeFunc) {
     return _.uniq(_.flatten(_.invoke(this.exprArgs(), "getVars", excludeFunc))).sort();
   },
-  getConsts: function getConsts() {
+  getConsts: function () {
     return _.uniq(_.flatten(_.invoke(this.exprArgs(), "getConsts"))).sort();
   },
-  getUnits: function getUnits() {
+  getUnits: function () {
     return _.flatten(_.invoke(this.exprArgs(), "getUnits"));
   },
   // check whether this expression node is of a particular type
-  is: function is(func) {
+  is: function (func) {
     return this instanceof func;
   },
   // check whether this expression has a particular node type
-  has: function has(func) {
+  has: function (func) {
     if (this instanceof func) {
       return true;
     }
@@ -2838,26 +2836,26 @@ _.extend(Expr.prototype, {
   },
   // raise this expression to a given exponent
   // most useful for eventually implementing i^3 = -i, etc.
-  raiseToThe: function raiseToThe(exp) {
+  raiseToThe: function (exp) {
     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() {
+  isSubtract: function () {
     return false;
   },
-  isDivide: function isDivide() {
+  isDivide: function () {
     return false;
   },
-  isRoot: function isRoot() {
+  isRoot: function () {
     return false;
   },
   // whether this node needs an explicit multiplication sign if following a Num
-  needsExplicitMul: function needsExplicitMul() {
+  needsExplicitMul: function () {
     return this.args()[0].needsExplicitMul();
   },
   // check that the variables in both expressions are the same
-  sameVars: function sameVars(other) {
+  sameVars: function (other) {
     var vars1 = this.getVars();
     var vars2 = other.getVars();
 
@@ -2879,7 +2877,7 @@ _.extend(Expr.prototype, {
   // 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 compare(other) {
+  compare: function (other) {
     // equation comparisons are handled by Eq.compare()
     if (other instanceof Eq) {
       return false;
@@ -2967,7 +2965,7 @@ _.extend(Expr.prototype, {
     return true;
   },
   // evaluate as much of the expression as possible
-  partialEval: function partialEval(vars) {
+  partialEval: function (vars) {
     if (this instanceof Unit) {
       return this;
     } else if (!this.has(Func)) {
@@ -2982,19 +2980,19 @@ _.extend(Expr.prototype, {
   // 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 sameForm(other) {
+  sameForm: function (other) {
     return this.strip().equals(other.strip());
   },
   // returns the GCD of this expression and the given factor
-  findGCD: function findGCD(factor) {
+  findGCD: function (factor) {
     return this.equals(factor) ? factor : Num.One;
   },
   // return this expression's denominator
-  getDenominator: function getDenominator() {
+  getDenominator: function () {
     return Num.One;
   },
   // return this expression as a Mul
-  asMul: function asMul() {
+  asMul: function () {
     return new Mul(Num.One, this);
   },
   // TODO(alex): rename to isDefinitePositive or similar?
@@ -3002,15 +3000,15 @@ _.extend(Expr.prototype, {
   isPositive: abstract,
   // TODO(alex): rename to hasNegativeSign or similar?
   // return whether this expression has a negative sign
-  isNegative: function isNegative() {
+  isNegative: function () {
     return false;
   },
   // return a factor of this expression that is 100% positive
-  asPositiveFactor: function asPositiveFactor() {
+  asPositiveFactor: function () {
     return this.isPositive() ? this : Num.One;
   },
   // return a copy of the expression with a new hint set (preserves hints)
-  addHint: function addHint(hint) {
+  addHint: function (hint) {
     if (!hint) {
       return this;
     }
@@ -3023,15 +3021,15 @@ _.extend(Expr.prototype, {
     parens: false
   },
   // currently unused!
-  asExpr: function asExpr() {
+  asExpr: function () {
     return this;
   },
   // complete parse by performing a few necessary transformations
-  completeParse: function completeParse() {
+  completeParse: function () {
     return this.recurse("completeParse");
   },
   abs: abstract,
-  negate: function negate() {
+  negate: function () {
     return new Mul(Num.Neg, this);
   }
 });
@@ -3040,21 +3038,21 @@ _.extend(Expr.prototype, {
 function Seq() {}
 Seq.prototype = new Expr();
 _.extend(Seq.prototype, {
-  args: function args() {
+  args: function () {
     return this.terms;
   },
-  normalize: function normalize() {
+  normalize: function () {
     var terms = _.sortBy(_.invoke(this.terms, "normalize"), function (term) {
       return term.print();
     });
     return new this.func(terms);
   },
-  expand: function expand() {
+  expand: function () {
     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 partition() {
+  partition: function () {
     var terms = _.groupBy(this.terms, function (term) {
       return term instanceof Num;
     });
@@ -3068,7 +3066,7 @@ _.extend(Seq.prototype, {
   },
   // 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() {
+  flatten: function () {
     var type = this;
     var terms = _.reject(this.terms, function (term) {
       return term.equals(type.identity);
@@ -3093,14 +3091,14 @@ _.extend(Seq.prototype, {
   identity: undefined,
   // reduce a numeric sequence to a Num
   reduce: abstract,
-  isPositive: function isPositive() {
+  isPositive: function () {
     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 replace(oldTerm, newTerm) {
+  replace: function (oldTerm, newTerm) {
     var index;
     if (oldTerm instanceof Expr) {
       index = _.indexOf(this.terms, oldTerm);
@@ -3117,10 +3115,10 @@ _.extend(Seq.prototype, {
     return new this.func(terms);
   },
   // syntactic sugar for replace()
-  remove: function remove(term) {
+  remove: function (term) {
     return this.replace(term);
   },
-  getDenominator: function getDenominator() {
+  getDenominator: function () {
     // TODO(alex): find and return LCM
     return new Mul(_.invoke(this.terms, "getDenominator")).flatten();
   }
@@ -3137,20 +3135,20 @@ function Add() {
 Add.prototype = new Seq();
 _.extend(Add.prototype, {
   func: Add,
-  eval: function _eval(vars, options) {
+  eval: function (vars, options) {
     return _.reduce(this.terms, function (memo, term) {
       return memo + term.eval(vars, options);
     }, 0);
   },
-  codegen: function codegen() {
+  codegen: function () {
     return _.map(this.terms, function (term) {
       return "(" + term.codegen() + ")";
     }).join(" + ") || "0";
   },
-  print: function print() {
+  print: function () {
     return _.invoke(this.terms, "print").join("+");
   },
-  tex: function tex() {
+  tex: function () {
     var tex = "";
     _.each(this.terms, function (term) {
       if (!tex || term.isSubtract()) {
@@ -3161,7 +3159,7 @@ _.extend(Add.prototype, {
     });
     return tex;
   },
-  collect: function collect(options) {
+  collect: function (options) {
     var terms = _.invoke(this.terms, "collect", options);
 
     // [Expr expr, Num coefficient]
@@ -3195,7 +3193,7 @@ _.extend(Add.prototype, {
   },
   // naively factor out anything that is common to all terms
   // if options.keepNegative is specified, won't factor out a common -1
-  factor: function factor(options) {
+  factor: function (options) {
     options = _.extend({
       keepNegative: false
     }, options);
@@ -3221,19 +3219,19 @@ _.extend(Add.prototype, {
     remainder = new Add(remainder).flatten();
     return Mul.createOrAppend(factors, remainder).flatten();
   },
-  reduce: function reduce(options) {
+  reduce: function (options) {
     return _.reduce(this.terms, function (memo, term) {
       return memo.add(term, options);
     }, this.identity);
   },
-  needsExplicitMul: function needsExplicitMul() {
+  needsExplicitMul: function () {
     return false;
   },
-  isNegative: function isNegative() {
+  isNegative: function () {
     var terms = _.invoke(this.terms, "collect");
     return _.all(_.invoke(terms, "isNegative"));
   },
-  negate: function negate() {
+  negate: function () {
     return new Add(_.invoke(this.terms, "negate"));
   }
 });
@@ -3249,22 +3247,22 @@ function Mul() {
 Mul.prototype = new Seq();
 _.extend(Mul.prototype, {
   func: Mul,
-  eval: function _eval(vars, options) {
+  eval: function (vars, options) {
     return _.reduce(this.terms, function (memo, term) {
       return memo * term.eval(vars, options);
     }, 1);
   },
-  codegen: function codegen() {
+  codegen: function () {
     return _.map(this.terms, function (term) {
       return "(" + term.codegen() + ")";
     }).join(" * ") || "0";
   },
-  print: function print() {
+  print: function () {
     return _.map(this.terms, function (term) {
       return term instanceof Add ? "(" + term.print() + ")" : term.print();
     }).join("*");
   },
-  getUnits: function getUnits() {
+  getUnits: function () {
     var tmUnits = _(this.terms).chain().map(function (term) {
       return term.getUnits();
     }).flatten().value();
@@ -3273,7 +3271,7 @@ _.extend(Mul.prototype, {
   },
   // 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() {
+  tex: function () {
     var cdot = " \\cdot ";
     var terms = _.groupBy(this.terms, function (term) {
       if (term.isDivide()) {
@@ -3354,14 +3352,14 @@ _.extend(Mul.prototype, {
       return negatives + "\\frac{" + numerator + "}{" + denominator + "}";
     }
   },
-  strip: function strip() {
+  strip: function () {
     var terms = _.map(this.terms, function (term) {
       return term instanceof Num ? term.abs() : term.strip();
     });
     return new Mul(terms).flatten();
   },
   // expand numerator and denominator separately
-  expand: function expand() {
+  expand: function () {
     var isAdd = function isAdd(term) {
       return term instanceof Add;
     };
@@ -3408,7 +3406,7 @@ _.extend(Mul.prototype, {
     }
     return new Mul(normals.concat(inverses)).flatten();
   },
-  factor: function factor(options) {
+  factor: function (options) {
     var factored = this.recurse("factor", options).flatten();
     if (!(factored instanceof Mul)) {
       return factored;
@@ -3438,7 +3436,7 @@ _.extend(Mul.prototype, {
     }
     return new Mul((grouped[false] || []).concat(rational)).flatten();
   },
-  collect: function collect(options) {
+  collect: function (options) {
     var partitioned = this.recurse("collect", options).partition();
     var number = partitioned[0].reduce(options);
 
@@ -3569,14 +3567,14 @@ _.extend(Mul.prototype, {
     });
     return new Mul([number].concat(collected)).flatten();
   },
-  isSubtract: function isSubtract() {
+  isSubtract: function () {
     return _.any(this.terms, function (term) {
       return term instanceof Num && 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 factorIn(hint) {
+  factorIn: function (hint) {
     var partitioned = this.partition();
     var numbers = partitioned[0].terms;
     var fold = numbers.length && _.all(numbers, function (num) {
@@ -3595,7 +3593,7 @@ _.extend(Mul.prototype, {
   },
   // 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() {
+  factorOut: function () {
     var factored = false;
     var terms = _.compact(_.map(this.terms, function (term, i, list) {
       if (!factored && term instanceof Num && term.hints.divide) {
@@ -3611,18 +3609,18 @@ _.extend(Mul.prototype, {
       return new Mul(terms);
     }
   },
-  reduce: function reduce(options) {
+  reduce: function (options) {
     return _.reduce(this.terms, function (memo, term) {
       return memo.mul(term, options);
     }, this.identity);
   },
-  findGCD: function findGCD(factor) {
+  findGCD: function (factor) {
     return new Mul(_.invoke(this.terms, "findGCD", factor)).flatten();
   },
-  asMul: function asMul() {
+  asMul: function () {
     return this;
   },
-  asPositiveFactor: function asPositiveFactor() {
+  asPositiveFactor: function () {
     if (this.isPositive()) {
       return this;
     } else {
@@ -3630,13 +3628,13 @@ _.extend(Mul.prototype, {
       return new Mul(terms).flatten();
     }
   },
-  isNegative: function isNegative() {
+  isNegative: function () {
     return _.any(_.invoke(this.collect().terms, "isNegative"));
   },
-  fold: function fold() {
+  fold: function () {
     return Mul.fold(this);
   },
-  negate: function negate() {
+  negate: function () {
     var isNum = function isNum(expr) {
       return expr instanceof Num;
     };
@@ -3653,7 +3651,7 @@ _.extend(Mul.prototype, {
 _.each([Add, Mul], function (type) {
   _.extend(type, {
     // create a new sequence unless left is already one (returns a copy)
-    createOrAppend: function createOrAppend(left, right) {
+    createOrAppend: function (left, right) {
       if (left instanceof type) {
         return new type(left.terms.concat(right));
       } else {
@@ -3667,7 +3665,7 @@ _.extend(Mul, {
   // 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 handleNegative(expr, hint) {
+  handleNegative: function (expr, hint) {
     if (expr instanceof Num && expr.n > 0) {
       // e.g. - 2 -> -2
       var negated = expr.negate();
@@ -3685,7 +3683,7 @@ _.extend(Mul, {
     }
   },
   // division can create either a Rational or a Mul
-  handleDivide: function handleDivide(left, right) {
+  handleDivide: function (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]);
@@ -3791,7 +3789,7 @@ _.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 fold(expr) {
+  fold: function (expr) {
     if (expr instanceof Mul) {
       // assuming that this will be second to last
       var trigLog = _.find(_.initial(expr.terms), function (term) {
@@ -3851,10 +3849,10 @@ function Pow(base, exp) {
 Pow.prototype = new Expr();
 _.extend(Pow.prototype, {
   func: Pow,
-  args: function args() {
+  args: function () {
     return [this.base, this.exp];
   },
-  eval: function _eval(vars, options) {
+  eval: function (vars, options) {
     var evaledBase = this.base.eval(vars, options);
     var evaledExp = this.exp.eval(vars, options);
 
@@ -3889,7 +3887,7 @@ _.extend(Pow.prototype, {
     }
     return Math.pow(evaledBase, evaledExp);
   },
-  getUnits: function getUnits() {
+  getUnits: function () {
     return this.base.getUnits().map(function (unit) {
       return {
         unit: unit.unit,
@@ -3897,17 +3895,17 @@ _.extend(Pow.prototype, {
       };
     }.bind(this));
   },
-  codegen: function codegen() {
+  codegen: function () {
     return "Math.pow(" + this.base.codegen() + ", " + this.exp.codegen() + ")";
   },
-  print: function print() {
+  print: function () {
     var base = this.base.print();
     if (this.base instanceof Seq || this.base instanceof Pow) {
       base = "(" + base + ")";
     }
     return base + "^(" + this.exp.print() + ")";
   },
-  tex: function tex() {
+  tex: function () {
     if (this.isDivide()) {
       // e.g. x ^ -1 w/hint -> 1/x
       return "\\frac{1}{" + this.asDivide().tex() + "}";
@@ -3941,10 +3939,10 @@ _.extend(Pow.prototype, {
       return base + "^{" + this.exp.tex() + "}";
     }
   },
-  needsExplicitMul: function needsExplicitMul() {
+  needsExplicitMul: function () {
     return this.isRoot() ? false : this.base.needsExplicitMul();
   },
-  expand: function expand() {
+  expand: function () {
     var pow = this.recurse("expand");
     if (pow.base instanceof Mul) {
       // e.g. (ab)^c -> a^c*b^c
@@ -3998,7 +3996,7 @@ _.extend(Pow.prototype, {
       return pow;
     }
   },
-  factor: function factor() {
+  factor: function () {
     var pow = this.recurse("factor");
     if (pow.base instanceof Mul) {
       var terms = _.map(pow.base.terms, function (term) {
@@ -4015,7 +4013,7 @@ _.extend(Pow.prototype, {
       return pow;
     }
   },
-  collect: function collect(options) {
+  collect: function (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
@@ -4075,14 +4073,14 @@ _.extend(Pow.prototype, {
     }
   },
   // checks whether this Pow represents user-entered division
-  isDivide: function isDivide() {
+  isDivide: function () {
     var isDiv = function isDiv(arg) {
       return arg instanceof Num && 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() {
+  asDivide: function () {
     if (this.exp instanceof Num) {
       if (this.exp.eval() === -1) {
         return this.base;
@@ -4098,15 +4096,15 @@ _.extend(Pow.prototype, {
       error("called asDivide() on an Expr that wasn't a Num or Mul");
     }
   },
-  isRoot: function isRoot() {
+  isRoot: function () {
     return this.exp instanceof Rational && this.exp.hints.root;
   },
-  isSquaredTrig: function isSquaredTrig() {
+  isSquaredTrig: function () {
     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() {
+  getDenominator: function () {
     if (this.exp instanceof Num && this.exp.eval() === -1) {
       return Mul.createOrAppend(this.base, this.base.getDenominator()).flatten();
     } else if (this.exp.isNegative()) {
@@ -4118,7 +4116,7 @@ _.extend(Pow.prototype, {
       return Num.One;
     }
   },
-  findGCD: function findGCD(factor) {
+  findGCD: function (factor) {
     var base, exp;
     if (factor instanceof Pow) {
       base = factor.base;
@@ -4155,14 +4153,14 @@ _.extend(Pow.prototype, {
     }
     return Num.One;
   },
-  isPositive: function isPositive() {
+  isPositive: function () {
     if (this.base.isPositive()) {
       return true;
     }
     var exp = this.exp.simplify();
     return exp instanceof Int && exp.eval() % 2 === 0;
   },
-  asPositiveFactor: function asPositiveFactor() {
+  asPositiveFactor: function () {
     if (this.isPositive()) {
       return this;
     } else {
@@ -4182,10 +4180,10 @@ _.extend(Pow.prototype, {
   }
 });
 _.extend(Pow, {
-  sqrt: function sqrt(arg) {
+  sqrt: function (arg) {
     return new Pow(arg, Num.Sqrt);
   },
-  nthroot: function nthroot(radicand, degree) {
+  nthroot: function (radicand, degree) {
     var exp = Mul.fold(Mul.handleDivide(new Int(1), degree));
 
     // FIXME(johnsullivan): If oneOverDegree ends up being a pow object,
@@ -4202,16 +4200,16 @@ function Log(base, power) {
 Log.prototype = new Expr();
 _.extend(Log.prototype, {
   func: Log,
-  args: function args() {
+  args: function () {
     return [this.base, this.power];
   },
-  eval: function _eval(vars, options) {
+  eval: function (vars, options) {
     return Math.log(this.power.eval(vars, options)) / Math.log(this.base.eval(vars, options));
   },
-  codegen: function codegen() {
+  codegen: function () {
     return "(Math.log(" + this.power.codegen() + ") / Math.log(" + this.base.codegen() + "))";
   },
-  print: function print() {
+  print: function () {
     var power = "(" + this.power.print() + ")";
     if (this.isNatural()) {
       return "ln" + power;
@@ -4219,7 +4217,7 @@ _.extend(Log.prototype, {
       return "log_(" + this.base.print() + ") " + power;
     }
   },
-  tex: function tex() {
+  tex: function () {
     var power = "(" + this.power.tex() + ")";
     if (this.isNatural()) {
       return "\\ln" + power;
@@ -4227,7 +4225,7 @@ _.extend(Log.prototype, {
       return "\\log_{" + this.base.tex() + "}" + power;
     }
   },
-  collect: function collect(options) {
+  collect: function (options) {
     var log = this.recurse("collect", options);
     if (log.power instanceof Num && log.power.eval() === 1) {
       // e.g. ln(1) -> 0
@@ -4242,7 +4240,7 @@ _.extend(Log.prototype, {
       return log;
     }
   },
-  expand: function expand() {
+  expand: function () {
     var log = this.recurse("expand");
     if (log.power instanceof Mul) {
       // might want behind super-simplify() flag
@@ -4268,7 +4266,7 @@ _.extend(Log.prototype, {
   hints: _.extend(Log.prototype.hints, {
     open: false
   }),
-  isPositive: function isPositive() {
+  isPositive: function () {
     var log = this.collect();
     if (log.base instanceof Num && log.power instanceof Num) {
       return this.eval() > 0;
@@ -4276,21 +4274,21 @@ _.extend(Log.prototype, {
       return false;
     }
   },
-  needsExplicitMul: function needsExplicitMul() {
+  needsExplicitMul: function () {
     return false;
   },
-  isNatural: function isNatural() {
+  isNatural: function () {
     return this.base.equals(Const.e);
   }
 });
 _.extend(Log, {
-  natural: function natural() {
+  natural: function () {
     return Const.e;
   },
-  common: function common() {
+  common: function () {
     return Num.Ten;
   },
-  create: function create(base, power) {
+  create: function (base, power) {
     var log = new Log(base, power);
     if (!power.hints.parens) {
       log = log.addHint("open");
@@ -4307,7 +4305,7 @@ function Trig(type, arg) {
 Trig.prototype = new Expr();
 _.extend(Trig.prototype, {
   func: Trig,
-  args: function args() {
+  args: function () {
     return [this.type, this.arg];
   },
   functions: {
@@ -4315,7 +4313,7 @@ _.extend(Trig.prototype, {
       eval: Math.sin,
       codegen: "Math.sin((",
       tex: "\\sin",
-      expand: function expand() {
+      expand: function () {
         return this;
       }
     },
@@ -4323,7 +4321,7 @@ _.extend(Trig.prototype, {
       eval: Math.cos,
       codegen: "Math.cos((",
       tex: "\\cos",
-      expand: function expand() {
+      expand: function () {
         return this;
       }
     },
@@ -4331,37 +4329,37 @@ _.extend(Trig.prototype, {
       eval: Math.tan,
       codegen: "Math.tan((",
       tex: "\\tan",
-      expand: function expand() {
+      expand: function () {
         return Mul.handleDivide(Trig.sin(this.arg), Trig.cos(this.arg));
       }
     },
     csc: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return 1 / Math.sin(arg);
       },
       codegen: "(1/Math.sin(",
       tex: "\\csc",
-      expand: function expand() {
+      expand: function () {
         return Mul.handleDivide(Num.One, Trig.sin(this.arg));
       }
     },
     sec: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return 1 / Math.cos(arg);
       },
       codegen: "(1/Math.cos(",
       tex: "\\sec",
-      expand: function expand() {
+      expand: function () {
         return Mul.handleDivide(Num.One, Trig.cos(this.arg));
       }
     },
     cot: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return 1 / Math.tan(arg);
       },
       codegen: "(1/Math.tan(",
       tex: "\\cot",
-      expand: function expand() {
+      expand: function () {
         return Mul.handleDivide(Trig.cos(this.arg), Trig.sin(this.arg));
       }
     },
@@ -4381,114 +4379,114 @@ _.extend(Trig.prototype, {
       tex: "\\arctan"
     },
     arccsc: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return Math.asin(1 / arg);
       },
       codegen: "Math.asin(1/(",
       tex: "\\operatorname{arccsc}"
     },
     arcsec: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return Math.acos(1 / arg);
       },
       codegen: "Math.acos(1/(",
       tex: "\\operatorname{arcsec}"
     },
     arccot: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return Math.atan(1 / arg);
       },
       codegen: "Math.atan(1/(",
       tex: "\\operatorname{arccot}"
     },
     sinh: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return (Math.exp(arg) - Math.exp(-arg)) / 2;
       },
-      codegen: function codegen(argStr) {
+      codegen: function (argStr) {
         return "((Math.exp(" + argStr + ") - Math.exp(-(" + argStr + "))) / 2)";
       },
       tex: "\\sinh",
-      expand: function expand() {
+      expand: function () {
         return this;
       }
     },
     cosh: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return (Math.exp(arg) + Math.exp(-arg)) / 2;
       },
-      codegen: function codegen(argStr) {
+      codegen: function (argStr) {
         return "((Math.exp(" + argStr + ") + Math.exp(-(" + argStr + "))) / 2)";
       },
       tex: "\\cosh",
-      expand: function expand() {
+      expand: function () {
         return this;
       }
     },
     tanh: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return (Math.exp(arg) - Math.exp(-arg)) / (Math.exp(arg) + Math.exp(-arg));
       },
-      codegen: function codegen(argStr) {
+      codegen: function (argStr) {
         return "(" + "(Math.exp(" + argStr + ") - Math.exp(-(" + argStr + ")))" + " / " + "(Math.exp(" + argStr + ") + Math.exp(-(" + argStr + ")))" + ")";
       },
       tex: "\\tanh",
-      expand: function expand() {
+      expand: function () {
         return Mul.handleDivide(Trig.sinh(this.arg), Trig.cosh(this.arg));
       }
     },
     csch: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return 2 / (Math.exp(arg) - Math.exp(-arg));
       },
-      codegen: function codegen(argStr) {
+      codegen: function (argStr) {
         return "(2 / (Math.exp(" + argStr + ") - Math.exp(-(" + argStr + "))))";
       },
       tex: "\\csch",
-      expand: function expand() {
+      expand: function () {
         return Mul.handleDivide(Num.One, Trig.sinh(this.arg));
       }
     },
     sech: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return 2 / (Math.exp(arg) + Math.exp(-arg));
       },
-      codegen: function codegen(argStr) {
+      codegen: function (argStr) {
         return "(2 / (Math.exp(" + argStr + ") + Math.exp(-(" + argStr + "))))";
       },
       tex: "\\sech",
-      expand: function expand() {
+      expand: function () {
         return Mul.handleDivide(Num.One, Trig.cosh(this.arg));
       }
     },
     coth: {
-      eval: function _eval(arg) {
+      eval: function (arg) {
         return (Math.exp(arg) + Math.exp(-arg)) / (Math.exp(arg) - Math.exp(-arg));
       },
-      codegen: function codegen(argStr) {
+      codegen: function (argStr) {
         return "(" + "(Math.exp(" + argStr + ") + Math.exp(-(" + argStr + ")))" + " / " + "(Math.exp(" + argStr + ") - Math.exp(-(" + argStr + ")))" + ")";
       },
       tex: "\\coth",
-      expand: function expand() {
+      expand: function () {
         return Mul.handleDivide(Trig.cosh(this.arg), Trig.sinh(this.arg));
       }
     }
   },
-  isEven: function isEven() {
+  isEven: function () {
     return _.contains(["cos", "sec"], this.type);
   },
-  isInverse: function isInverse() {
+  isInverse: function () {
     return this.type.indexOf("arc") === 0;
   },
-  isBasic: function isBasic() {
+  isBasic: function () {
     return _.contains(["sin", "cos"], this.type);
   },
-  eval: function _eval(vars, options) {
+  eval: function (vars, options) {
     var func = this.functions[this.type].eval;
     var arg = this.arg.eval(vars, options);
     return func(arg);
   },
-  codegen: function codegen() {
+  codegen: function () {
     var func = this.functions[this.type].codegen;
     if (typeof func === "function") {
       return func(this.arg.codegen());
@@ -4498,10 +4496,10 @@ _.extend(Trig.prototype, {
       throw new Error("codegen not implemented for " + this.type);
     }
   },
-  print: function print() {
+  print: function () {
     return this.type + "(" + this.arg.print() + ")";
   },
-  tex: function tex(options) {
+  tex: function (options) {
     var func = this.functions[this.type].tex;
     var arg = "(" + this.arg.tex() + ")";
     return options && options.split ? [func, arg] : func + arg;
@@ -4509,7 +4507,7 @@ _.extend(Trig.prototype, {
   hints: _.extend(Trig.prototype.hints, {
     open: false
   }),
-  isPositive: function isPositive() {
+  isPositive: function () {
     var trig = this.collect();
     if (trig.arg instanceof Num) {
       return this.eval() > 0;
@@ -4517,7 +4515,7 @@ _.extend(Trig.prototype, {
       return false;
     }
   },
-  completeParse: function completeParse() {
+  completeParse: function () {
     if (this.exp) {
       var pow = new Pow(this, this.exp);
       this.exp = undefined;
@@ -4527,10 +4525,10 @@ _.extend(Trig.prototype, {
     }
   },
   // TODO(alex): does every new node type need to redefine these?
-  needsExplicitMul: function needsExplicitMul() {
+  needsExplicitMul: function () {
     return false;
   },
-  expand: function expand() {
+  expand: function () {
     var trig = this.recurse("expand");
     if (!trig.isInverse()) {
       // e.g. tan(x) -> sin(x)/cos(x)
@@ -4540,7 +4538,7 @@ _.extend(Trig.prototype, {
       return trig;
     }
   },
-  collect: function collect(options) {
+  collect: function (options) {
     var trig = this.recurse("collect", options);
     if (!trig.isInverse() && trig.arg.isNegative()) {
       var arg;
@@ -4562,7 +4560,7 @@ _.extend(Trig.prototype, {
   }
 });
 _.extend(Trig, {
-  create: function create(pair, arg) {
+  create: function (pair, arg) {
     var type = pair[0];
     var exp = pair[1];
     if (exp && exp.equals(Num.Neg)) {
@@ -4579,16 +4577,16 @@ _.extend(Trig, {
     }
     return trig;
   },
-  sin: function sin(arg) {
+  sin: function (arg) {
     return new Trig("sin", arg);
   },
-  cos: function cos(arg) {
+  cos: function (arg) {
     return new Trig("cos", arg);
   },
-  sinh: function sinh(arg) {
+  sinh: function (arg) {
     return new Trig("sinh", arg);
   },
-  cosh: function cosh(arg) {
+  cosh: function (arg) {
     return new Trig("cosh", arg);
   }
 });
@@ -4598,22 +4596,22 @@ function Abs(arg) {
 Abs.prototype = new Expr();
 _.extend(Abs.prototype, {
   func: Abs,
-  args: function args() {
+  args: function () {
     return [this.arg];
   },
-  eval: function _eval(vars, options) {
+  eval: function (vars, options) {
     return Math.abs(this.arg.eval(vars, options));
   },
-  codegen: function codegen() {
+  codegen: function () {
     return "Math.abs(" + this.arg.codegen() + ")";
   },
-  print: function print() {
+  print: function () {
     return "abs(" + this.arg.print() + ")";
   },
-  tex: function tex() {
+  tex: function () {
     return "\\left|" + this.arg.tex() + "\\right|";
   },
-  collect: function collect(options) {
+  collect: function (options) {
     var abs = this.recurse("collect", options);
     if (abs.arg.isPositive()) {
       // e.g. |2^x| -> 2^x
@@ -4642,7 +4640,7 @@ _.extend(Abs.prototype, {
     }
   },
   // this should definitely be behind a super-simplify flag
-  expand: function expand() {
+  expand: function () {
     var abs = this.recurse("expand");
     if (abs.arg instanceof Mul) {
       // e.g. |xyz| -> |x|*|y|*|z|
@@ -4654,7 +4652,7 @@ _.extend(Abs.prototype, {
       return abs;
     }
   },
-  isPositive: function isPositive() {
+  isPositive: function () {
     return true;
   }
 });
@@ -4668,13 +4666,13 @@ function Eq(left, type, right) {
 Eq.prototype = new Expr();
 _.extend(Eq.prototype, {
   func: Eq,
-  args: function args() {
+  args: function () {
     return [this.left, this.type, this.right];
   },
-  needsExplicitMul: function needsExplicitMul() {
+  needsExplicitMul: function () {
     return false;
   },
-  print: function print() {
+  print: function () {
     return this.left.print() + this.type + this.right.print();
   },
   signs: {
@@ -4685,10 +4683,10 @@ _.extend(Eq.prototype, {
     "<=": " \\le ",
     ">=": " \\ge "
   },
-  tex: function tex() {
+  tex: function () {
     return this.left.tex() + this.signs[this.type] + this.right.tex();
   },
-  normalize: function normalize() {
+  normalize: function () {
     var eq = this.recurse("normalize");
     if (_.contains([">", ">="], eq.type)) {
       // inequalities should have the smaller side on the left
@@ -4701,7 +4699,7 @@ _.extend(Eq.prototype, {
   // 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 asExpr(unfactored) {
+  asExpr: function (unfactored) {
     var isZero = function isZero(expr) {
       return expr instanceof Num && expr.isSimple() && expr.eval() === 0;
     };
@@ -4753,7 +4751,7 @@ _.extend(Eq.prototype, {
   // 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 divideThrough(expr) {
+  divideThrough: function (expr) {
     var isInequality = !this.isEquality();
     var simplified = expr.simplify({
       once: true
@@ -4809,10 +4807,10 @@ _.extend(Eq.prototype, {
       return dividedResult;
     }
   },
-  isEquality: function isEquality() {
+  isEquality: function () {
     return _.contains(["=", "<>"], this.type);
   },
-  compare: function compare(other) {
+  compare: function (other) {
     // expression comparisons are handled by Expr.compare()
     if (!(other instanceof Eq)) {
       return false;
@@ -4835,7 +4833,7 @@ _.extend(Eq.prototype, {
     }
   },
   // should only be done after compare() returns true to avoid false positives
-  sameForm: function sameForm(other) {
+  sameForm: function (other) {
     var eq1 = this.normalize();
     var eq2 = other.normalize();
     var same = eq1.left.sameForm(eq2.left) && eq1.right.sameForm(eq2.right);
@@ -4848,7 +4846,7 @@ _.extend(Eq.prototype, {
   },
   // 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() {
+  isSimplified: function () {
     var expr = this.asExpr( /* unfactored */true);
     var simplified = this.divideThrough(expr).simplify();
     return expr.equals(simplified) && this.left.isSimplified() && this.right.isSimplified();
@@ -4856,7 +4854,7 @@ _.extend(Eq.prototype, {
 });
 _.extend(Eq.prototype, {
   // Assumptions: Expression is of the form a+bx, and we solve for x
-  solveLinearEquationForVariable: function solveLinearEquationForVariable(variable) {
+  solveLinearEquationForVariable: function (variable) {
     var expr = this.asExpr();
     if (!expr.is(Add) || expr.terms.length !== 2) {
       throw new Error("Can only handle linear equations of the form " + "a + bx (= 0)");
@@ -4880,10 +4878,10 @@ _.extend(Eq.prototype, {
 function Symbol() {}
 Symbol.prototype = new Expr();
 _.extend(Symbol.prototype, {
-  needsExplicitMul: function needsExplicitMul() {
+  needsExplicitMul: function () {
     return false;
   },
-  findGCD: function findGCD(factor) {
+  findGCD: function (factor) {
     if (factor instanceof Symbol || factor instanceof Num) {
       return this.equals(factor) ? this : Num.One;
     } else {
@@ -4900,16 +4898,16 @@ function Func(symbol, arg) {
 Func.prototype = new Symbol();
 _.extend(Func.prototype, {
   func: Func,
-  args: function args() {
+  args: function () {
     return [this.symbol, this.arg];
   },
-  print: function print() {
+  print: function () {
     return this.symbol + "(" + this.arg.print() + ")";
   },
-  tex: function tex() {
+  tex: function () {
     return this.symbol + "(" + this.arg.tex() + ")";
   },
-  eval: function _eval(vars, options) {
+  eval: function (vars, options) {
     var arg = this.arg;
     var func = vars[this.symbol];
     var newVars = _.extend(_.clone(vars), {
@@ -4922,20 +4920,20 @@ _.extend(Func.prototype, {
     // If parsedFunc isn't actually parsed, return its error
     return parsedFunc;
   },
-  codegen: function codegen() {
+  codegen: function () {
     return 'vars["' + this.symbol + '"](' + this.arg.codegen() + ")";
   },
-  getUnits: function getUnits() {
+  getUnits: function () {
     return this.arg.getUnits();
   },
-  getVars: function getVars(excludeFunc) {
+  getVars: function (excludeFunc) {
     if (excludeFunc) {
       return this.arg.getVars();
     } else {
       return _.union(this.arg.getVars(), [this.symbol]).sort();
     }
   },
-  getConsts: function getConsts() {
+  getConsts: function () {
     return this.arg.getConsts();
   }
 });
@@ -4948,16 +4946,16 @@ function Var(symbol, subscript) {
 Var.prototype = new Symbol();
 _.extend(Var.prototype, {
   func: Var,
-  args: function args() {
+  args: function () {
     return [this.symbol, this.subscript];
   },
-  exprArgs: function exprArgs() {
+  exprArgs: function () {
     return [];
   },
-  recurse: function recurse() {
+  recurse: function () {
     return this;
   },
-  print: function print() {
+  print: function () {
     var sub = "";
     if (this.subscript) {
       sub = "_(" + this.subscript.print() + ")";
@@ -4966,7 +4964,7 @@ _.extend(Var.prototype, {
   },
   // 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() {
+  prettyPrint: function () {
     var sub = this.subscript;
     if (sub && (sub instanceof Num || sub instanceof Symbol)) {
       return this.symbol + "_" + sub.print();
@@ -4974,7 +4972,7 @@ _.extend(Var.prototype, {
       return this.print();
     }
   },
-  tex: function tex() {
+  tex: function () {
     var sub = "";
     if (this.subscript) {
       sub = "_{" + this.subscript.tex() + "}";
@@ -4982,19 +4980,19 @@ _.extend(Var.prototype, {
     var prefix = this.symbol.length > 1 ? "\\" : "";
     return prefix + this.symbol + sub;
   },
-  repr: function repr() {
+  repr: function () {
     return "Var(" + this.print() + ")";
   },
-  eval: function _eval(vars, options) {
+  eval: function (vars, options) {
     return vars[this.prettyPrint()];
   },
-  codegen: function codegen() {
+  codegen: function () {
     return 'vars["' + this.prettyPrint() + '"]';
   },
-  getVars: function getVars() {
+  getVars: function () {
     return [this.prettyPrint()];
   },
-  isPositive: function isPositive() {
+  isPositive: function () {
     return false;
   }
 });
@@ -5006,47 +5004,47 @@ function Const(symbol) {
 Const.prototype = new Symbol();
 _.extend(Const.prototype, {
   func: Const,
-  args: function args() {
+  args: function () {
     return [this.symbol];
   },
-  recurse: function recurse() {
+  recurse: function () {
     return this;
   },
-  eval: function _eval(vars, options) {
+  eval: function (vars, options) {
     if (this.symbol === "pi") {
       return Math.PI;
     } else if (this.symbol === "e") {
       return Math.E;
     }
   },
-  codegen: function codegen() {
+  codegen: function () {
     if (this.symbol === "pi") {
       return "Math.PI";
     } else if (this.symbol === "e") {
       return "Math.E";
     }
   },
-  print: function print() {
+  print: function () {
     return this.symbol;
   },
-  tex: function tex() {
+  tex: function () {
     if (this.symbol === "pi") {
       return "\\pi ";
     } else if (this.symbol === "e") {
       return "e";
     }
   },
-  isPositive: function isPositive() {
+  isPositive: function () {
     return this.eval() > 0;
   },
-  abs: function abs() {
+  abs: function () {
     if (this.eval() > 0) {
       return this;
     } else {
       return Mul.handleNegative(this);
     }
   },
-  getConsts: function getConsts() {
+  getConsts: function () {
     return [this.print()];
   }
 });
@@ -5057,16 +5055,16 @@ Const.pi = new Const("pi");
 function Num() {}
 Num.prototype = new Expr();
 _.extend(Num.prototype, {
-  repr: function repr() {
+  repr: function () {
     return this.print();
   },
-  strip: function strip() {
+  strip: function () {
     return this.abs();
   },
-  recurse: function recurse() {
+  recurse: function () {
     return this;
   },
-  codegen: function codegen() {
+  codegen: function () {
     return this.print();
   },
   // takes another Num and returns a new Num
@@ -5074,22 +5072,22 @@ _.extend(Num.prototype, {
   mul: abstract,
   // returns this Num's additive inverse
   negate: abstract,
-  isSubtract: function isSubtract() {
+  isSubtract: function () {
     return this.hints.subtract;
   },
   // return the absolute value of the number
   abs: abstract,
-  needsExplicitMul: function needsExplicitMul() {
+  needsExplicitMul: function () {
     return true;
   },
   findGCD: abstract,
-  isPositive: function isPositive() {
+  isPositive: function () {
     return this.eval() > 0;
   },
-  isNegative: function isNegative() {
+  isNegative: function () {
     return this.eval() < 0;
   },
-  asPositiveFactor: function asPositiveFactor() {
+  asPositiveFactor: function () {
     return this.isPositive() ? this : this.abs();
   },
   // hints for interpreting and rendering user input
@@ -5105,7 +5103,7 @@ _.extend(Num.prototype, {
   // e.g. for reals, ints and floats are simple
   isSimple: abstract,
   // Based on http://stackoverflow.com/a/10454560/2571482
-  getDecimalPlaces: function getDecimalPlaces() {
+  getDecimalPlaces: function () {
     var match = ("" + this.n).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
     if (match) {
       return Math.max(0,
@@ -5134,34 +5132,34 @@ function Rational(numerator, denominator) {
 Rational.prototype = new Num();
 _.extend(Rational.prototype, {
   func: Rational,
-  args: function args() {
+  args: function () {
     return [this.n, this.d];
   },
-  eval: function _eval() {
+  eval: function () {
     return this.n / this.d;
   },
-  print: function print() {
+  print: function () {
     return this.n.toString() + "/" + this.d.toString();
   },
-  tex: function tex() {
+  tex: function () {
     var tex = "\\frac{" + Math.abs(this.n).toString() + "}{" + this.d.toString() + "}";
     return this.n < 0 ? "-" + tex : tex;
   },
-  add: function add(num, options) {
+  add: function (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 mul(num, options) {
+  mul: function (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() {
+  collect: function () {
     var gcd = Num.findGCD(this.n, this.d);
     var n = this.n / gcd;
     var d = this.d / gcd;
@@ -5171,13 +5169,13 @@ _.extend(Rational.prototype, {
       return new Rational(n, d);
     }
   },
-  negate: function negate() {
+  negate: function () {
     return new Rational(-this.n, this.d);
   },
-  abs: function abs() {
+  abs: function () {
     return new Rational(Math.abs(this.n), this.d);
   },
-  findGCD: function findGCD(factor) {
+  findGCD: function (factor) {
     // Attempt to factor out common numerators and denominators to return
     // a Rational instead of a Float
     if (factor instanceof Rational) {
@@ -5194,7 +5192,7 @@ _.extend(Rational.prototype, {
     }
   },
   // for now, assuming that exp is a Num
-  raiseToThe: function raiseToThe(exp) {
+  raiseToThe: function (exp) {
     if (exp instanceof Int) {
       var positive = exp.eval() > 0;
       var abs = exp.abs().eval();
@@ -5209,13 +5207,13 @@ _.extend(Rational.prototype, {
       return new Float(this.eval()).raiseToThe(exp);
     }
   },
-  getDenominator: function getDenominator() {
+  getDenominator: function () {
     return new Int(this.d);
   },
-  isSimple: function isSimple() {
+  isSimple: function () {
     return false;
   },
-  asRational: function asRational() {
+  asRational: function () {
     return this;
   }
 });
@@ -5227,25 +5225,25 @@ function Int(number) {
 Int.prototype = new Rational(0, 1);
 _.extend(Int.prototype, {
   func: Int,
-  args: function args() {
+  args: function () {
     return [this.n];
   },
-  print: function print() {
+  print: function () {
     return this.n.toString();
   },
-  tex: function tex() {
+  tex: function () {
     return this.n.toString();
   },
-  negate: function negate() {
+  negate: function () {
     return new Int(-this.n);
   },
-  abs: function abs() {
+  abs: function () {
     return new Int(Math.abs(this.n));
   },
-  isSimple: function isSimple() {
+  isSimple: function () {
     return true;
   },
-  findGCD: function findGCD(factor) {
+  findGCD: function (factor) {
     if (factor instanceof Int) {
       return new Int(Num.findGCD(this.n, factor.n));
     } else {
@@ -5254,7 +5252,7 @@ _.extend(Int.prototype, {
   }
 });
 _.extend(Int, {
-  create: function create(n) {
+  create: function (n) {
     return new Int(n).addHint("entered");
   }
 });
@@ -5266,46 +5264,46 @@ function Float(number) {
 Float.prototype = new Num();
 _.extend(Float.prototype, {
   func: Float,
-  args: function args() {
+  args: function () {
     return [this.n];
   },
-  eval: function _eval() {
+  eval: function () {
     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() {
+  print: function () {
     return this.n.toString();
   },
-  tex: function tex() {
+  tex: function () {
     return this.n.toString();
   },
-  add: function add(num, options) {
+  add: function (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 mul(num, options) {
+  mul: function (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() {
+  collect: function () {
     // 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() {
+  negate: function () {
     return new Float(-this.n);
   },
-  abs: function abs() {
+  abs: function () {
     return new Float(Math.abs(this.n));
   },
-  findGCD: function findGCD(factor) {
+  findGCD: function (factor) {
     if (factor instanceof Num) {
       return new Float(Num.findGCD(this.eval(), factor.eval())).collect();
     } else {
@@ -5313,7 +5311,7 @@ _.extend(Float.prototype, {
     }
   },
   // for now, assuming that exp is a Num
-  raiseToThe: function raiseToThe(exp, options) {
+  raiseToThe: function (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 {
@@ -5321,7 +5319,7 @@ _.extend(Float.prototype, {
     }
   },
   // only to be used on non-repeating decimals (e.g. user-provided)
-  asRational: function asRational() {
+  asRational: function () {
     var parts = this.n.toString().split(".");
     if (parts.length === 1) {
       return new Rational(this.n, 1);
@@ -5331,27 +5329,27 @@ _.extend(Float.prototype, {
       return new Rational(numerator, denominator).collect();
     }
   },
-  getDenominator: function getDenominator() {
+  getDenominator: function () {
     return this.asRational().getDenominator();
   },
-  isSimple: function isSimple() {
+  isSimple: function () {
     return true;
   }
 });
 _.extend(Float, {
-  create: function create(n) {
+  create: function (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 toDecimalPlaces(n, places) {
+  toDecimalPlaces: function (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 negativeOne(hint) {
+  negativeOne: function (hint) {
     if (hint === "subtract") {
       return Num.Sub;
     } else if (hint === "divide") {
@@ -5361,7 +5359,7 @@ _.extend(Num, {
     }
   },
   // find the greatest common denominator
-  findGCD: function findGCD(a, b) {
+  findGCD: function (a, b) {
     var mod;
     a = Math.abs(a);
     b = Math.abs(b);
@@ -5379,12 +5377,12 @@ _.extend(Num, {
     }
     return a;
   },
-  min: function min() {
+  min: function () {
     return _.min(_.toArray(arguments), function (num) {
       return num.eval();
     });
   },
-  max: function max() {
+  max: function () {
     return _.max(_.toArray(arguments), function (num) {
       return num.eval();
     });
@@ -5423,7 +5421,7 @@ parser.yy = {
   Float: Float,
   parseError: parseError,
   constants: ["e"],
-  symbolLexer: function symbolLexer(symbol) {
+  symbolLexer: function (symbol) {
     if (_.contains(parser.yy.constants, symbol)) {
       return "CONST";
     } else if (_.contains(parser.yy.functions, symbol)) {
@@ -5433,7 +5431,7 @@ parser.yy = {
     }
   }
 };
-var parse = function parse(input, options) {
+const parse = function parse(input, options) {
   try {
     if (options && options.functions) {
       // reserve the symbol "i" for complex numbers
@@ -5499,7 +5497,7 @@ var unprefixify = function unprefixify(symbol) {
     return new Unit(symbol);
   }
 };
-var unitParse = function unitParse(input) {
+const unitParse = function unitParse(input) {
   try {
     var parseResult = unitParser.parse(input);
 
@@ -5555,13 +5553,13 @@ var unitParse = function unitParse(input) {
 };
 _.extend(Unit.prototype, {
   func: Unit,
-  args: function args() {
+  args: function () {
     return [this.symbol];
   },
-  recurse: function recurse() {
+  recurse: function () {
     return this;
   },
-  eval: function _eval(vars, options) {
+  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.
     //
@@ -5571,23 +5569,23 @@ _.extend(Unit.prototype, {
     // However, there are a couple tests checking this.
     return 1;
   },
-  getUnits: function getUnits() {
+  getUnits: function () {
     return [{
       unit: this.symbol,
       pow: 1
     }];
   },
-  codegen: function codegen() {
+  codegen: function () {
     return "1";
   },
-  print: function print() {
+  print: function () {
     return this.symbol;
   },
-  tex: function tex() {
+  tex: function () {
     return this.symbol;
   },
   // Simplify units by replacing prefixes with multiplication
-  collect: function collect(options) {
+  collect: function (options) {
     if (_(baseUnits).has(this.symbol)) {
       return this;
     } else if (_(derivedUnits).has(this.symbol)) {
@@ -5810,14 +5808,14 @@ var derivedUnits = {
   // other
   Hz: makeAlias("| / s", hasPrefixes)
 };
-var Zero = Num.Zero;
-var One = Num.One;
+const Zero = Num.Zero;
+const One = Num.One;
 
 /* eslint-disable */
 
 // Assumes that both expressions have already been parsed
 // TODO(alex): be able to pass a random() function to compare()
-var compare = function compare(expr1, expr2, options) {
+const compare = function compare(expr1, expr2, options) {
   var defaults = {
     form: false,
     // Check that the two expressions have the same form