@khanacademy/kas 1.0.0 → 2.0.0

package/dist/index.js

@@ -1,15 +1,101 @@
-import { addLibraryVersionToPerseusDebug } from '@khanacademy/perseus-utils';
-import _extends from '@babel/runtime/helpers/extends';
-import _ from 'underscore';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var perseusUtils = require('@khanacademy/perseus-utils');
+var _ = require('underscore');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+var ___default = /*#__PURE__*/_interopDefaultCompat(_);
+
+// This file is processed by a Rollup plugin (replace) to inject the production
+// version number during the release build.
+// In dev, you'll never see the version number.
 
 const libName = "@khanacademy/kas";
-const libVersion = "1.0.0";
-addLibraryVersionToPerseusDebug(libName, libVersion);
+const libVersion = "2.0.0";
+perseusUtils.addLibraryVersionToPerseusDebug(libName, libVersion);
+
+// this is a @generated file
+
+/* parser generated by jison 0.4.15 */
+/*
+  Returns a Parser object of the following structure:
+
+  Parser: {
+    yy: {}
+  }
+
+  Parser.prototype: {
+    yy: {},
+    trace: function(),
+    symbols_: {associative list: name ==> number},
+    terminals_: {associative list: number ==> name},
+    productions_: [...],
+    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
+    table: [...],
+    defaultActions: {...},
+    parseError: function(str, hash),
+    parse: function(input),
+
+    lexer: {
+        EOF: 1,
+        parseError: function(str, hash),
+        setInput: function(input),
+        input: function(),
+        unput: function(str),
+        more: function(),
+        less: function(n),
+        pastInput: function(),
+        upcomingInput: function(),
+        showPosition: function(),
+        test_match: function(regex_match_array, rule_index),
+        next: function(),
+        lex: function(),
+        begin: function(condition),
+        popState: function(),
+        _currentRules: function(),
+        topState: function(),
+        pushState: function(condition),
+
+        options: {
+            ranges: boolean           (optional: true ==> token location info will include a .range[] member)
+            flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
+            backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
+        },
+
+        performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
+        rules: [...],
+        conditions: {associative list: name ==> set},
+    }
+  }
+
+
+  token location info (@$, _$, etc.): {
+    first_line: n,
+    last_line: n,
+    first_column: n,
+    last_column: n,
+    range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
+  }
+
 
+  the parseError function receives a 'hash' object with these members for lexer and parser errors: {
+    text:        (matched text)
+    token:       (the produced terminal token, if any)
+    line:        (yylineno)
+  }
+  while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
+    loc:         (yylloc)
+    expected:    (string describing the set of expected tokens)
+    recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
+  }
+*/
 var parser$1 = function () {
-  var o = function o(k, v, _o, l) {
-      for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v);
-      return _o;
+  var o = function (k, v, o, l) {
+      for (o = o || {}, l = k.length; l--; o[k[l]] = v);
+      return o;
     },
     $V0 = [1, 11],
     $V1 = [1, 9],
@@ -55,7 +141,9 @@ var parser$1 = function () {
       20: "NEG"
     },
     productions_: [0, [3, 3], [3, 2], [4, 3], [4, 1], [5, 3], [5, 1], [10, 3], [10, 2], [10, 1], [12, 3], [12, 1], [14, 1], [7, 1], [7, 1], [16, 1], [9, 2], [9, 1]],
-    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
+    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
+      /* this == yyval */
+
       var $0 = $$.length - 1;
       switch (yystate) {
         case 1:
@@ -240,6 +328,7 @@ var parser$1 = function () {
       } else {
         this.parseError = Object.getPrototypeOf(this).parseError;
       }
+      //_token_stack:
       function lex() {
         var token;
         token = lexer.lex() || EOF;
@@ -339,6 +428,7 @@ var parser$1 = function () {
       return true;
     }
   };
+  /* generated by jison-lex 0.3.4 */
   var lexer = function () {
     var lexer = {
       EOF: 1,
@@ -349,6 +439,7 @@ var parser$1 = function () {
           throw new Error(str);
         }
       },
+      // resets the lexer, sets new input
       setInput: function (input, yy) {
         this.yy = yy || this.yy || {};
         this._input = input;
@@ -368,6 +459,7 @@ var parser$1 = function () {
         this.offset = 0;
         return this;
       },
+      // consumes and returns one char from the input
       input: function () {
         var ch = this._input[0];
         this.yytext += ch;
@@ -388,11 +480,13 @@ var parser$1 = function () {
         this._input = this._input.slice(1);
         return ch;
       },
+      // unshifts one char (or a string) into the input
       unput: function (ch) {
         var len = ch.length;
         var lines = ch.split(/(?:\r\n?|\n)/g);
         this._input = ch + this._input;
         this.yytext = this.yytext.substr(0, this.yytext.length - len);
+        //this.yyleng -= len;
         this.offset -= len;
         var oldLines = this.match.split(/(?:\r\n?|\n)/g);
         this.match = this.match.substr(0, this.match.length - 1);
@@ -413,10 +507,12 @@ var parser$1 = function () {
         this.yyleng = this.yytext.length;
         return this;
       },
+      // When called from action, caches matched text and appends it on next action
       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 () {
         if (this.options.backtrack_lexer) {
           this._backtrack = true;
@@ -429,13 +525,16 @@ var parser$1 = function () {
         }
         return this;
       },
+      // retain first n characters of the match
       less: function (n) {
         this.unput(this.match.slice(n));
       },
+      // displays already matched input, i.e. for error messages
       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 () {
         var next = this.match;
         if (next.length < 20) {
@@ -443,14 +542,17 @@ 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 () {
         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 (match, indexed_rule) {
         var token, lines, backup;
         if (this.options.backtrack_lexer) {
+          // save context
           backup = {
             yylineno: this.yylineno,
             yylloc: {
@@ -503,13 +605,15 @@ var parser$1 = function () {
         if (token) {
           return token;
         } else if (this._backtrack) {
+          // recover context
           for (var k in backup) {
             this[k] = backup[k];
           }
-          return false;
+          return false; // rule action called reject() implying the next rule should be tested instead.
         }
         return false;
       },
+      // return next match in input
       next: function () {
         if (this.done) {
           return this.EOF;
@@ -534,8 +638,9 @@ var parser$1 = function () {
                 return token;
               } else if (this._backtrack) {
                 match = false;
-                continue;
+                continue; // rule action called reject() implying a rule MISmatch.
               } else {
+                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                 return false;
               }
             } else if (!this.options.flex) {
@@ -548,6 +653,7 @@ var parser$1 = function () {
           if (token !== false) {
             return token;
           }
+          // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
           return false;
         }
         if (this._input === "") {
@@ -560,6 +666,7 @@ var parser$1 = function () {
           });
         }
       },
+      // return next match that has a token
       lex: function lex() {
         var r = this.next();
         if (r) {
@@ -568,9 +675,11 @@ var parser$1 = function () {
           return this.lex();
         }
       },
+      // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
       begin: function begin(condition) {
         this.conditionStack.push(condition);
       },
+      // pop the previously active lexer condition state off the condition stack
       popState: function popState() {
         var n = this.conditionStack.length - 1;
         if (n > 0) {
@@ -579,6 +688,7 @@ var parser$1 = function () {
           return this.conditionStack[0];
         }
       },
+      // produce the lexer rule set which is active for the currently active lexer condition state
       _currentRules: function _currentRules() {
         if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
           return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
@@ -586,6 +696,7 @@ var parser$1 = function () {
           return this.conditions["INITIAL"].rules;
         }
       },
+      // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
       topState: function topState(n) {
         n = this.conditionStack.length - 1 - Math.abs(n || 0);
         if (n >= 0) {
@@ -594,9 +705,11 @@ var parser$1 = function () {
           return "INITIAL";
         }
       },
+      // alias for begin(condition)
       pushState: function pushState(condition) {
         this.begin(condition);
       },
+      // return the number of states currently on the stack
       stateStackSize: function stateStackSize() {
         return this.conditionStack.length;
       },
@@ -628,6 +741,7 @@ var parser$1 = function () {
           case 11:
             return 17;
           case 12:
+            /* skip whitespace */
             break;
           case 13:
             return 6;
@@ -653,10 +767,85 @@ var parser$1 = function () {
 }();
 const unitParser = parser$1;
 
+// This is a @generated file
+
+/* parser generated by jison 0.4.15 */
+/*
+  Returns a Parser object of the following structure:
+
+  Parser: {
+    yy: {}
+  }
+
+  Parser.prototype: {
+    yy: {},
+    trace: function(),
+    symbols_: {associative list: name ==> number},
+    terminals_: {associative list: number ==> name},
+    productions_: [...],
+    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$),
+    table: [...],
+    defaultActions: {...},
+    parseError: function(str, hash),
+    parse: function(input),
+
+    lexer: {
+        EOF: 1,
+        parseError: function(str, hash),
+        setInput: function(input),
+        input: function(),
+        unput: function(str),
+        more: function(),
+        less: function(n),
+        pastInput: function(),
+        upcomingInput: function(),
+        showPosition: function(),
+        test_match: function(regex_match_array, rule_index),
+        next: function(),
+        lex: function(),
+        begin: function(condition),
+        popState: function(),
+        _currentRules: function(),
+        topState: function(),
+        pushState: function(condition),
+
+        options: {
+            ranges: boolean           (optional: true ==> token location info will include a .range[] member)
+            flex: boolean             (optional: true ==> flex-like lexing behaviour where the rules are tested exhaustively to find the longest match)
+            backtrack_lexer: boolean  (optional: true ==> lexer regexes are tested in order and for each matching regex the action code is invoked; the lexer terminates the scan when a token is returned by the action code)
+        },
+
+        performAction: function(yy, yy_, $avoiding_name_collisions, YY_START),
+        rules: [...],
+        conditions: {associative list: name ==> set},
+    }
+  }
+
+
+  token location info (@$, _$, etc.): {
+    first_line: n,
+    last_line: n,
+    first_column: n,
+    last_column: n,
+    range: [start_number, end_number]       (where the numbers are indexes into the input string, regular zero-based)
+  }
+
+
+  the parseError function receives a 'hash' object with these members for lexer and parser errors: {
+    text:        (matched text)
+    token:       (the produced terminal token, if any)
+    line:        (yylineno)
+  }
+  while parser (grammar) errors will also provide these members, i.e. parser errors deliver a superset of attributes: {
+    loc:         (yylloc)
+    expected:    (string describing the set of expected tokens)
+    recoverable: (boolean: TRUE when the parser has a error recovery rule available for this particular error)
+  }
+*/
 var parser = function () {
-  var o = function o(k, v, _o, l) {
-      for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v);
-      return _o;
+  var o = function (k, v, o, l) {
+      for (o = o || {}, l = k.length; l--; o[k[l]] = v);
+      return o;
     },
     $V0 = [1, 7],
     $V1 = [1, 17],
@@ -768,7 +957,9 @@ var parser = function () {
       46: "FRAC"
     },
     productions_: [0, [3, 4], [3, 2], [3, 1], [4, 1], [7, 3], [7, 3], [7, 1], [9, 2], [9, 3], [9, 3], [9, 1], [13, 2], [13, 1], [15, 1], [17, 1], [17, 3], [17, 1], [20, 1], [20, 1], [20, 3], [11, 2], [11, 2], [11, 1], [25, 3], [25, 1], [27, 1], [24, 3], [24, 1], [24, 1], [24, 1], [24, 1], [24, 3], [24, 3], [36, 1], [38, 4], [38, 4], [38, 7], [38, 4], [38, 3], [38, 3], [38, 4], [26, 1], [26, 1], [26, 7]],
-    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
+    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
+      /* this == yyval */
+
       var $0 = $$.length - 1;
       switch (yystate) {
         case 1:
@@ -1814,6 +2005,7 @@ var parser = function () {
       } else {
         this.parseError = Object.getPrototypeOf(this).parseError;
       }
+      //_token_stack:
       function lex() {
         var token;
         token = lexer.lex() || EOF;
@@ -1913,6 +2105,7 @@ var parser = function () {
       return true;
     }
   };
+  /* generated by jison-lex 0.3.4 */
   var lexer = function () {
     var lexer = {
       EOF: 1,
@@ -1923,6 +2116,7 @@ var parser = function () {
           throw new Error(str);
         }
       },
+      // resets the lexer, sets new input
       setInput: function (input, yy) {
         this.yy = yy || this.yy || {};
         this._input = input;
@@ -1942,6 +2136,7 @@ var parser = function () {
         this.offset = 0;
         return this;
       },
+      // consumes and returns one char from the input
       input: function () {
         var ch = this._input[0];
         this.yytext += ch;
@@ -1962,11 +2157,13 @@ var parser = function () {
         this._input = this._input.slice(1);
         return ch;
       },
+      // unshifts one char (or a string) into the input
       unput: function (ch) {
         var len = ch.length;
         var lines = ch.split(/(?:\r\n?|\n)/g);
         this._input = ch + this._input;
         this.yytext = this.yytext.substr(0, this.yytext.length - len);
+        //this.yyleng -= len;
         this.offset -= len;
         var oldLines = this.match.split(/(?:\r\n?|\n)/g);
         this.match = this.match.substr(0, this.match.length - 1);
@@ -1987,10 +2184,12 @@ var parser = function () {
         this.yyleng = this.yytext.length;
         return this;
       },
+      // When called from action, caches matched text and appends it on next action
       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 () {
         if (this.options.backtrack_lexer) {
           this._backtrack = true;
@@ -2003,13 +2202,16 @@ var parser = function () {
         }
         return this;
       },
+      // retain first n characters of the match
       less: function (n) {
         this.unput(this.match.slice(n));
       },
+      // displays already matched input, i.e. for error messages
       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 () {
         var next = this.match;
         if (next.length < 20) {
@@ -2017,14 +2219,17 @@ 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 () {
         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 (match, indexed_rule) {
         var token, lines, backup;
         if (this.options.backtrack_lexer) {
+          // save context
           backup = {
             yylineno: this.yylineno,
             yylloc: {
@@ -2077,13 +2282,15 @@ var parser = function () {
         if (token) {
           return token;
         } else if (this._backtrack) {
+          // recover context
           for (var k in backup) {
             this[k] = backup[k];
           }
-          return false;
+          return false; // rule action called reject() implying the next rule should be tested instead.
         }
         return false;
       },
+      // return next match in input
       next: function () {
         if (this.done) {
           return this.EOF;
@@ -2108,8 +2315,9 @@ var parser = function () {
                 return token;
               } else if (this._backtrack) {
                 match = false;
-                continue;
+                continue; // rule action called reject() implying a rule MISmatch.
               } else {
+                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                 return false;
               }
             } else if (!this.options.flex) {
@@ -2122,6 +2330,7 @@ var parser = function () {
           if (token !== false) {
             return token;
           }
+          // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
           return false;
         }
         if (this._input === "") {
@@ -2134,6 +2343,7 @@ var parser = function () {
           });
         }
       },
+      // return next match that has a token
       lex: function lex() {
         var r = this.next();
         if (r) {
@@ -2142,9 +2352,11 @@ var parser = function () {
           return this.lex();
         }
       },
+      // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)
       begin: function begin(condition) {
         this.conditionStack.push(condition);
       },
+      // pop the previously active lexer condition state off the condition stack
       popState: function popState() {
         var n = this.conditionStack.length - 1;
         if (n > 0) {
@@ -2153,6 +2365,7 @@ var parser = function () {
           return this.conditionStack[0];
         }
       },
+      // produce the lexer rule set which is active for the currently active lexer condition state
       _currentRules: function _currentRules() {
         if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {
           return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;
@@ -2160,6 +2373,7 @@ var parser = function () {
           return this.conditions["INITIAL"].rules;
         }
       },
+      // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available
       topState: function topState(n) {
         n = this.conditionStack.length - 1 - Math.abs(n || 0);
         if (n >= 0) {
@@ -2168,9 +2382,11 @@ var parser = function () {
           return "INITIAL";
         }
       },
+      // alias for begin(condition)
       pushState: function pushState(condition) {
         this.begin(condition);
       },
+      // return the number of states currently on the stack
       stateStackSize: function stateStackSize() {
         return this.conditionStack.length;
       },
@@ -2180,10 +2396,13 @@ var parser = function () {
       performAction: function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {
         switch ($avoiding_name_collisions) {
           case 0:
+            /* skip whitespace */
             break;
           case 1:
+            /* skip \space */
             break;
           case 2:
+            /* skip '\ ' */
             break;
           case 3:
             return "INT";
@@ -2405,20 +2624,65 @@ var parser = function () {
   return new Parser();
 }();
 
-var _class5, _class12;
-const isNaN = function isNaN(object) {
+/* eslint-disable prettier/prettier */
+/* eslint-disable import/order */
+/* TODO: fix these lint errors (http://eslint.org/docs/rules): */
+/* eslint-disable indent, no-undef, no-var, no-dupe-keys, no-new-func, no-redeclare, comma-dangle, max-len, prefer-spread, space-infix-ops, space-unary-ops */
+
+/*  The node hierarcy is as follows:
+
+    (Expr)
+        (Seq)           2+ children
+            Add
+            Mul
+        Pow             2 children
+        Log             2 children
+        Eq              2 children
+        Trig            1 child
+        Abs             1 child
+        (Sym)
+            Func        1 child     e.g. f(x)
+            Var         leaf node   e.g. x, x_n
+            Const       leaf node   e.g. pi, e, <i>
+            Unit        leaf node   e.g. kg
+        (Num)           leaf node
+            Rational                e.g. 2/3
+                Int
+            Float
+
+    (abstract, not meant to be instantiated)
+
+    == Key design concepts ==
+    Functional: All methods return new nodes - nodes are never mutated.
+    Ignore commutativity: Commutative inputs should be parsed equivalently.
+    Exploit commutativity: Output should take advantage of ordering.
+*/
+
+/* non user-facing functions */
+
+// reliably detect NaN
+const isNaN = function (object) {
   return object !== object;
 };
-const randomFloat = function randomFloat(min, max) {
+
+// return a random float between min (inclusive) and max (exclusive),
+// not that inclusivity means much, probabilistically, on floats
+const randomFloat = function (min, max) {
   var extent = max - min;
   return Math.random() * extent + min;
 };
+
+/* constants */
 var ITERATIONS = 12;
-var TOLERANCE = 9;
+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) => {
+  ___default.default.forEach(list, (elem, key, ctx) => {
     if (iteratee(elem, key, ctx)) {
       a.push(elem);
     } else {
@@ -2430,7 +2694,7 @@ function partition(list, iteratee) {
 function isExpr(arg) {
   return arg instanceof Expr;
 }
-const isAdd = function isAdd(term) {
+const isAdd = function (term) {
   return term instanceof Add;
 };
 function isRational(arg) {
@@ -2443,13 +2707,23 @@ function getFactors(expr) {
     return [expr];
   }
 }
+/* abstract base expression node */
 class Expr {
+  hints;
   constructor() {
-    this.hints = void 0;
     this.hints = {
       parens: false
     };
   }
+
+  // this node's immediate constructor
+  // 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
+
+  // make a new node with the given arguments
   construct(args) {
     const func = this.func;
     const instance = new func(...args);
@@ -2458,29 +2732,59 @@ class Expr {
     }
     return instance;
   }
-  recurse(method, ...passed) {
+
+  // an abstraction for chainable, bottom-up recursion
+  // NOTE(kevinb): This method is highly dynamic.  It's possible that it
+  // could be made more type-safe using overload signatures.
+  recurse(method) {
+    for (var _len = arguments.length, passed = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      passed[_key - 1] = arguments[_key];
+    }
     var args = this.args().map(function (arg) {
-      return _.isString(arg) || _.isNumber(arg) ? arg : arg == null ? void 0 : arg[method].apply(arg, passed);
+      return ___default.default.isString(arg) || ___default.default.isNumber(arg) ? arg : arg?.[method].apply(arg, passed);
     });
     return this.construct(args);
   }
-  eval(vars = {}, options) {
-    throw new Error("Abstract method - must override for expr: " + this.print());
+
+  // evaluate numerically with given variable mapping
+  // 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() {
+    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: " + this.print());
+    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 (_unused) {
+    } catch {
       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
+
+  // returns a TeX string representing the expression
+
+  // returns a TeX string, modified by the given options
   asTex(options) {
     options = options || {};
-    _.defaults(options, {
+    ___default.default.defaults(options, {
       display: true,
       dynamic: true,
       times: false
@@ -2498,46 +2802,76 @@ class Expr {
     }
     return tex;
   }
+
+  // returns the name of this expression's constructor as a string
+  // only used for testing and debugging
   name() {
     return this.func.name;
   }
+
+  // returns a string representing current node structure
   repr() {
     return this.name() + "(" + this.args().map(function (arg) {
-      return _.isString(arg) || _.isNumber(arg) ? arg : arg == null ? void 0 : arg.repr();
+      return ___default.default.isString(arg) || ___default.default.isNumber(arg) ? arg : arg?.repr();
     }).join(",") + ")";
   }
+
+  // removes all negative signs
   strip() {
     return this.recurse("strip");
   }
+
+  // canonically reorders all commutative elements
   normalize() {
     return this.recurse("normalize");
   }
+
+  // expands the expression
   expand() {
     return this.recurse("expand");
   }
+
+  // naively factors out like terms
   factor(options) {
     return this.recurse("factor", options);
   }
+
+  // collect all like terms
   collect(options) {
     return this.recurse("collect", options);
   }
+
+  // strict syntactic equality check
   equals(other) {
     return this.normalize().print() === other.normalize().print();
   }
+
+  // expand and collect until the expression no longer changes
   simplify(options) {
-    options = _extends({
-      once: false
-    }, options);
+    options = {
+      once: false,
+      ...options
+    };
+
+    // Attempt to factor and collect
     var step1 = this.factor(options);
     var step2 = step1.collect(options);
+
+    // Rollback if collect didn't do anything
     if (step1.equals(step2)) {
       step2 = this.collect(options);
     }
+
+    // Attempt to expand and collect
     var step3 = step2.expand();
     var step4 = step3.collect(options);
+
+    // Rollback if collect didn't do anything
     if (step3.equals(step4)) {
       step4 = step2.collect(options);
     }
+
+    // One round of simplification complete
     var simplified = step4;
     if (options.once || this.equals(simplified)) {
       return simplified;
@@ -2545,35 +2879,52 @@ class Expr {
       return simplified.simplify(options);
     }
   }
+
+  // check whether this expression is simplified
   isSimplified() {
     return this.equals(this.simplify());
   }
+
+  // return the child nodes of this node
   exprArgs() {
+    // @ts-expect-error: Type 'string | number | Expr | undefined' is not assignable to type 'string | Expr'.
     return this.args().filter(isExpr);
   }
+
+  // return the variables (function and non) within the expression
   getVars(excludeFunc) {
-    return _.uniq(_.flatten(_.invoke(this.exprArgs(), "getVars", excludeFunc))).sort();
+    return ___default.default.uniq(___default.default.flatten(___default.default.invoke(this.exprArgs(), "getVars", excludeFunc))).sort();
   }
   getConsts() {
-    return _.uniq(_.flatten(_.invoke(this.exprArgs(), "getConsts"))).sort();
+    return ___default.default.uniq(___default.default.flatten(___default.default.invoke(this.exprArgs(), "getConsts"))).sort();
   }
   getUnits() {
-    return _.flatten(_.invoke(this.exprArgs(), "getUnits"));
+    return ___default.default.flatten(___default.default.invoke(this.exprArgs(), "getUnits"));
   }
+
+  // check whether this expression node is of a particular type
   is(func) {
     return this instanceof func;
   }
+
+  // check whether this expression has a particular node type
   has(func) {
     if (this instanceof func) {
       return true;
     }
-    return _.any(this.exprArgs(), function (arg) {
+    return ___default.default.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(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() {
     return false;
   }
@@ -2583,17 +2934,25 @@ class Expr {
   isRoot() {
     return false;
   }
+
+  // whether this node needs an explicit multiplication sign if following a Num
   needsExplicitMul() {
     return this.exprArgs()[0].needsExplicitMul();
   }
+
+  // check that the variables in both expressions are the same
   sameVars(other) {
     var vars1 = this.getVars();
     var vars2 = other.getVars();
-    var same = function same(array1, array2) {
-      return !_.difference(array1, array2).length;
+
+    // the other Expr can have more variables than this one
+    // this lets you multiply equations by other variables
+    var same = function (array1, array2) {
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+      return !___default.default.difference(array1, array2).length;
     };
-    var lower = function lower(array) {
-      return _.uniq(_.invoke(array, "toLowerCase")).sort();
+    var lower = function (array) {
+      return ___default.default.uniq(___default.default.invoke(array, "toLowerCase")).sort();
     };
     var equal = same(vars1, vars2);
     var equalIgnoringCase = same(lower(vars1), lower(vars2));
@@ -2602,39 +2961,86 @@ class Expr {
       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(other) {
+    // equation comparisons are handled by Eq.compare()
     if (other instanceof Eq) {
       return false;
     }
-    var varList = _.union(this.getVars(true), other.getVars(true));
-    var getDelta = function getDelta(num1, num2) {
+    var varList = ___default.default.union(this.getVars(/* excludeFunc */true), other.getVars(/* excludeFunc */true));
+
+    // If the numbers are large we would like to do a relative comparison
+    // rather than an absolute one, but if they're small enough then an
+    // absolute comparison makes more sense
+    var getDelta = function (num1, num2) {
       if (Math.abs(num1) < 1 || Math.abs(num2) < 1) {
         return Math.abs(num1 - num2);
       } else {
         return Math.abs(1 - num1 / num2);
       }
     };
-    var equalNumbers = function equalNumbers(num1, num2) {
+    var equalNumbers = function (num1, num2) {
       var delta = getDelta(num1, num2);
-      return num1 === num2 || isNaN(num1) && isNaN(num2) || delta < Math.pow(10, -9);
+      return num1 === num2 /* needed if either is +/- Infinity */ || isNaN(num1) && isNaN(num2) || delta < Math.pow(10, -9);
     };
-    const varAndFuncList = _.union(this.getVars(false), other.getVars(false));
+
+    // If no variables, only need to evaluate once.
+    // note(matthew) Seems to be an optimization for simple cases like `2+2=4`
+    // where there are no variables / functions.
+    // Ran into issues with it in LEMS-2777 and found that tests pass
+    // with this removed, but keeping a modified version out of caution.
+    const varAndFuncList = ___default.default.union(this.getVars(/* excludeFunc */false), other.getVars(/* excludeFunc */false));
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (!varAndFuncList.length && !this.has(Unit) && !other.has(Unit)) {
       return equalNumbers(this.eval(), other.eval());
     }
+
+    // collect here to avoid sometimes dividing by zero, and sometimes not
+    // it is better to be deterministic, e.g. x/x -> 1
+    // TODO(alex): may want to keep track of assumptions as they're made
     var expr1 = this.collect();
     var expr2 = other.collect();
     var unitList1 = this.getUnits();
     var unitList2 = other.getUnits();
-    if (!_.isEqual(unitList1, unitList2)) {
+    if (!___default.default.isEqual(unitList1, unitList2)) {
       return false;
     }
+
+    // Compare at a set number (currently 12) of points to determine
+    // equality.
+    //
+    // `range` (and `vars`) is the only variable that varies through the
+    // iterations. For each of range = 10, 100, and 1000, each random
+    // variable is picked from (-range, range).
+    //
+    // Note that because there are 12 iterations and three ranges, each
+    // range is checked four times.
     for (var i = 0; i < ITERATIONS; i++) {
       var vars = {};
+
+      // One third total iterations each with range 10, 100, and 1000
       var range = Math.pow(10, 1 + Math.floor(3 * i / ITERATIONS));
+
+      // Half of the iterations should only use integer values.
+      // This is because expressions like (-2)^x are common but result
+      // in NaN when evaluated in JS with non-integer values of x.
+      // Without this, (-2)^x and (-2)^(x+1) both end up always being NaN
+      // and thus equivalent. With this, the most common failure case is
+      // avoided. However, less common cases such as (-2)^(x+0.1) and
+      // (-2)^(x+1.1) will still both evaluate to NaN and result in a
+      // false positive.
+      //
+      // Note that the above is only true in vanilla JS Number-land,
+      // which has no concept of complex numbers. The solution is simple:
+      // Integrate a library for handling complex numbers.
+      //
+      // TODO(alex): Add support for complex numbers, then remove this.
       var useFloats = i % 2 === 0;
-      _.each(varList, function (v) {
-        vars[v] = useFloats ? randomFloat(-range, range) : _.random(-range, range);
+      ___default.default.each(varList, function (v) {
+        vars[v] = useFloats ? randomFloat(-range, range) : ___default.default.random(-range, range);
       });
       let equal;
       if (expr1.has(Func) || expr2.has(Func) || expr1.has(Unit) || expr2.has(Unit)) {
@@ -2652,6 +3058,8 @@ class Expr {
     }
     return true;
   }
+
+  // evaluate as much of the expression as possible
   partialEval(vars) {
     if (this instanceof Unit) {
       return this;
@@ -2663,50 +3071,86 @@ class Expr {
       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(other) {
     return this.strip().equals(other.strip());
   }
+
+  // returns the GCD of this expression and the given factor
   findGCD(factor) {
     return this.equals(factor) ? factor : NumOne;
   }
+
+  // return this expression's denominator
   getDenominator() {
     return NumOne;
   }
+
+  // return this expression as a Mul
   asMul() {
     return new Mul(NumOne, this);
   }
+
+  // TODO(alex): rename to isDefinitePositive or similar?
+  // return whether this expression is 100% positive
   isPositive() {
-    throw new Error("Abstract method - must override for expr: " + this.print());
+    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() {
     return false;
   }
+
+  // return a factor of this expression that is 100% positive
   asPositiveFactor() {
     return this.isPositive() ? this : NumOne;
   }
+
+  // return a copy of the expression with a new hint set (preserves hints)
   addHint(hint) {
     if (!hint) {
       return this;
     }
     var expr = this.construct(this.args());
-    expr.hints = _.clone(this.hints);
+    expr.hints = ___default.default.clone(this.hints);
     expr.hints[hint] = true;
     return expr;
   }
+
+  // complete parse by performing a few necessary transformations
   completeParse() {
     return this.recurse("completeParse");
   }
   abs() {
-    throw new Error("Abstract method - must override for expr: " + this.print());
+    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 */
 class Seq extends Expr {
-  constructor(...args) {
+  // This should always have at least two terms.
+  // TODO(kevinb): Try enforcing this at the type-level using [T, T, T[]]
+  terms;
+
+  // TODO(kevinb): Update this use `...args: Expr[]`
+  constructor() {
     super();
-    this.terms = void 0;
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
     if (args.length === 1) {
       this.terms = args[0];
     } else {
@@ -2717,7 +3161,7 @@ class Seq extends Expr {
     return this.terms;
   }
   normalize() {
-    var terms = _.sortBy(_.invoke(this.terms, "normalize"), term => {
+    var terms = ___default.default.sortBy(___default.default.invoke(this.terms, "normalize"), term => {
       return term.print();
     });
     return new this.func(terms);
@@ -2725,35 +3169,54 @@ class Seq extends Expr {
   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() {
     var [numbers, others] = partition(this.terms, term => {
       return term instanceof Num;
     });
     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() {
     var type = this;
-    var terms = _.reject(this.terms, term => {
+    var terms = ___default.default.reject(this.terms, term => {
+      // @ts-expect-error: `identity` is defined on Add and Mul but doesn't
+      // exist on Seq itself.
       return term.equals(type.identity);
     });
     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];
     }
+
+    // same contains the children which are Seqs of the same type as this Seq
     const [same, others] = partition(terms, term => {
       return term instanceof type.func;
     });
-    var flattened = others.concat(_.flatten(_.pluck(same, "terms"), true));
+    var flattened = others.concat(___default.default.flatten(___default.default.pluck(same, "terms"), /* shallow: */true));
     return new type.func(flattened);
   }
+
+  // reduce a numeric sequence to a Num
+
   isPositive() {
-    var terms = _.invoke(this.terms, "collect");
-    return _.all(_.invoke(terms, "isPositive"));
+    var terms = ___default.default.invoke(this.terms, "collect");
+    return ___default.default.all(___default.default.invoke(terms, "isPositive"));
   }
+
+  // return a new Seq with a given term replaced by a different term
+  // (or array of terms). given term can be passed directly, or by index
+  // if no new term is provided, the old one is simply removed
   replace(oldTerm, newTerm) {
-    const index = oldTerm instanceof Expr ? _.indexOf(this.terms, oldTerm) : oldTerm;
+    const index = oldTerm instanceof Expr ? ___default.default.indexOf(this.terms, oldTerm) : oldTerm;
     var newTerms = [];
     if (Array.isArray(newTerm)) {
       newTerms = newTerm;
@@ -2763,35 +3226,39 @@ class Seq extends Expr {
     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(term) {
     return this.replace(term);
   }
   getDenominator() {
-    return new Mul(_.invoke(this.terms, "getDenominator")).flatten();
+    // TODO(alex): find and return LCM
+    return new Mul(___default.default.invoke(this.terms, "getDenominator")).flatten();
   }
 }
+
+/* sequence of additive terms */
 class Add extends Seq {
-  constructor(...args) {
-    super(...args);
-    this.identity = NumZero;
-    this.func = Add;
-  }
-  eval(vars = {}, options) {
-    return _.reduce(this.terms, (memo, term) => {
+  identity = NumZero;
+  func = Add;
+  eval() {
+    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let options = arguments.length > 1 ? arguments[1] : undefined;
+    return ___default.default.reduce(this.terms, (memo, term) => {
       return memo + term.eval(vars, options);
     }, 0);
   }
   codegen() {
-    return _.map(this.terms, term => {
+    return ___default.default.map(this.terms, term => {
       return "(" + term.codegen() + ")";
     }).join(" + ") || "0";
   }
   print() {
-    return _.invoke(this.terms, "print").join("+");
+    return ___default.default.invoke(this.terms, "print").join("+");
   }
   tex() {
     let tex = "";
-    _.each(this.terms, term => {
+    ___default.default.each(this.terms, term => {
       if (!tex || term.isSubtract()) {
         tex += term.tex();
       } else {
@@ -2801,9 +3268,9 @@ class Add extends Seq {
     return tex;
   }
   collect(options) {
-    var terms = _.invoke(this.terms, "collect", options);
+    var terms = ___default.default.invoke(this.terms, "collect", options);
     var pairs = [];
-    _.each(terms, term => {
+    ___default.default.each(terms, term => {
       if (term instanceof Mul) {
         var muls = term.partition();
         pairs.push([muls[1].flatten(), muls[0].reduce(options)]);
@@ -2813,20 +3280,30 @@ class Add extends Seq {
         pairs.push([term, NumOne]);
       }
     });
-    var grouped = _.groupBy(pairs, pair => {
+
+    // { (Expr expr).print(): [[Expr expr, Num coefficient]] }
+    var grouped = ___default.default.groupBy(pairs, pair => {
       return pair[0].normalize().print();
     });
-    var collected = _.compact(_.map(grouped, pairs => {
+    var collected = ___default.default.compact(___default.default.map(grouped, pairs => {
       var expr = pairs[0][0];
-      var sum = new Add(_.zip.apply(_, pairs)[1]);
+      var sum = new Add(___default.default.zip.apply(___default.default, pairs)[1]);
       var coefficient = sum.reduce(options);
       return new Mul(coefficient, expr).collect(options);
     }));
+
+    // TODO(alex): use the Pythagorean identity here
+    // e.g. x*sin^2(y) + x*cos^2(y) -> x
+
     return new Add(collected).flatten();
   }
-  factor(options = {
-    keepNegative: false
-  }) {
+
+  // naively factor out anything that is common to all terms
+  // if options.keepNegative is specified, won't factor out a common -1
+  factor() {
+    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
+      keepNegative: false
+    };
     const terms = this.terms.map(term => term.collect());
     let factors;
     if (terms[0] instanceof Mul) {
@@ -2834,8 +3311,8 @@ class Add extends Seq {
     } else {
       factors = [terms[0]];
     }
-    _.each(_.rest(this.terms), term => {
-      factors = _.map(factors, factor => {
+    ___default.default.each(___default.default.rest(this.terms), term => {
+      factors = ___default.default.map(factors, factor => {
         return term.findGCD(factor);
       });
     });
@@ -2848,7 +3325,9 @@ class Add extends Seq {
     return Mul.createOrAppend(left, right).flatten();
   }
   reduce(options) {
-    return _.reduce(this.terms, (memo, term) => {
+    return ___default.default.reduce(this.terms,
+    // @ts-expect-error: Type 'Expr' is not assignable to type 'Num'.
+    (memo, term) => {
       return memo.add(term, options);
     }, this.identity);
   }
@@ -2856,12 +3335,14 @@ class Add extends Seq {
     return false;
   }
   isNegative() {
-    var terms = _.invoke(this.terms, "collect");
-    return _.all(_.invoke(terms, "isNegative"));
+    var terms = ___default.default.invoke(this.terms, "collect");
+    return ___default.default.all(___default.default.invoke(terms, "isNegative"));
   }
   negate() {
-    return new Add(_.invoke(this.terms, "negate"));
+    return new Add(___default.default.invoke(this.terms, "negate"));
   }
+
+  // create a new sequence unless left is already one (returns a copy)
   static createOrAppend(left, right) {
     if (left instanceof Add) {
       return new Add(left.terms.concat(right));
@@ -2870,37 +3351,41 @@ class Add extends Seq {
     }
   }
 }
+
+/* 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) => {
+  identity = NumOne;
+  func = Mul;
+  eval() {
+    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let options = arguments.length > 1 ? arguments[1] : undefined;
+    return ___default.default.reduce(this.terms, (memo, term) => {
       return memo * term.eval(vars, options);
     }, 1);
   }
   codegen() {
-    return _.map(this.terms, term => {
+    return ___default.default.map(this.terms, term => {
       return "(" + term.codegen() + ")";
     }).join(" * ") || "0";
   }
   print() {
-    return _.map(this.terms, term => {
+    return ___default.default.map(this.terms, term => {
       return term instanceof Add ? "(" + term.print() + ")" : term.print();
     }).join("*");
   }
   getUnits() {
-    var tmUnits = _(this.terms).chain().map(term => {
+    var tmUnits = ___default.default(this.terms).chain().map(term => {
       return term.getUnits();
     }).flatten().value();
     tmUnits.sort((a, b) => a.unit.localeCompare(b.unit));
     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() {
     var cdot = " \\cdot ";
-    var terms = _.groupBy(this.terms, term => {
+    var terms = ___default.default.groupBy(this.terms, term => {
       if (term.isDivide()) {
         return "inverse";
       } else if (term instanceof Num) {
@@ -2909,11 +3394,19 @@ class Mul extends Seq {
         return "other";
       }
     });
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     var inverses = terms.inverse || [];
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     var numbers = terms.number || [];
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     var others = terms.other || [];
     var negatives = "";
     var numerator;
+
+    // check all the numbers to see if there is a rational we can extract,
+    // since we would like 1/2x/y to come out as \frac{1}{2}\frac{x}{y},
+    // and not \frac{1x}{2y}.
     for (var i = 0; i < numbers.length; i++) {
       var isRational = numbers[i] instanceof Rational && !(numbers[i] instanceof Int);
       if (isRational && others.length > 0 && inverses.length > 0) {
@@ -2923,84 +3416,102 @@ class Mul extends Seq {
         return numbers[i].tex() + new Mul(newTerms).tex();
       }
     }
-    numbers = _.compact(_.map(numbers, term => {
+    numbers = ___default.default.compact(___default.default.map(numbers, term => {
       var shouldPushDown = !term.hints.fraction || inverses.length > 0;
       if (term instanceof Rational && !(term instanceof Int) && shouldPushDown) {
+        // e.g. 3x/4 -> 3/4*x (internally) -> 3x/4 (rendered)
         inverses.push(new Pow(new Int(term.d), NumDiv));
         var number = new Int(term.n);
         number.hints = term.hints;
-        return _.any(term.hints) ? number : null;
+        return ___default.default.any(term.hints) ? number : null;
       } else {
         return term;
       }
     }));
     if (numbers.length === 0 && others.length === 1) {
+      // e.g. (x+y)/z -> \frac{x+y}{z}
       numerator = others[0].tex();
     } else {
       var tex = "";
-      _.each(numbers, term => {
+      ___default.default.each(numbers, term => {
         if (term.hints.subtract && term.hints.entered) {
           negatives += "-";
           tex += (tex ? cdot : "") + term.abs().tex();
         } else if (term instanceof Int && term.n === -1 && (term.hints.negate || term.hints.subtract)) {
+          // e.g. -1*-1 -> --1
+          // e.g. -1*x -> -x
           negatives += "-";
         } else {
+          // e.g. 2*3 -> 2(dot)3
           tex += (tex ? cdot : "") + term.tex();
         }
       });
-      _.each(others, term => {
+      ___default.default.each(others, term => {
         if (term.needsExplicitMul()) {
+          // e.g. 2*2^3 -> 2(dot)2^3
           tex += (tex ? cdot : "") + term.tex();
         } else if (term instanceof Add) {
+          // e.g. (a+b)*c -> (a+b)c
           tex += "(" + term.tex() + ")";
         } else {
+          // e.g. a*b*c -> abc
           tex += term.tex();
         }
       });
       numerator = tex ? tex : "1";
     }
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (!inverses.length) {
       return negatives + numerator;
     } else {
-      var denominator = new Mul(_.invoke(inverses, "asDivide")).flatten().tex();
+      var denominator = new Mul(___default.default.invoke(inverses, "asDivide")).flatten().tex();
       return negatives + "\\frac{" + numerator + "}{" + denominator + "}";
     }
   }
   strip() {
-    var terms = _.map(this.terms, term => {
+    var terms = ___default.default.map(this.terms, term => {
       return term instanceof Num ? term.abs() : term.strip();
     });
     return new Mul(terms).flatten();
   }
+
+  // expand numerator and denominator separately
   expand() {
-    const isInverse = function isInverse(term) {
+    const isInverse = function (term) {
       return term instanceof Pow && term.exp.isNegative();
     };
-    const isInverseAdd = function isInverseAdd(term) {
+    const isInverseAdd = function (term) {
       return isInverse(term) && isAdd(term.base);
     };
     const mul = this.recurse("expand").flatten();
     const factors = getFactors(mul);
-    const hasAdd = _.any(factors, isAdd);
-    const hasInverseAdd = _.any(factors, isInverseAdd);
+    const hasAdd = ___default.default.any(factors, isAdd);
+    const hasInverseAdd = ___default.default.any(factors, isInverseAdd);
     if (!(hasAdd || hasInverseAdd)) {
       return mul;
     }
     let [inverses, normals] = partition(factors, isInverse);
     if (hasAdd) {
       const [adds, others] = partition(normals, isAdd);
-      const expanded = _.reduce(adds, function (expanded, add) {
-        return _.reduce(expanded, function (temp, array) {
-          return temp.concat(_.map(add.terms, term => array.concat(term)));
+
+      // loop over each additive sequence
+      const expanded = ___default.default.reduce(adds, function (expanded, add) {
+        // loop over each expanded array of terms
+        return ___default.default.reduce(expanded, function (temp, array) {
+          // loop over each additive sequence's terms
+          return temp.concat(___default.default.map(add.terms, term => array.concat(term)));
         }, []);
       }, [[]]);
-      const muls = _.map(expanded, function (array) {
+
+      // join each fully expanded array of factors with remaining multiplicative factors
+      const muls = ___default.default.map(expanded, function (array) {
         return new Mul(others.concat(array)).flatten();
       });
       normals = [new Add(muls)];
     }
     if (hasInverseAdd) {
-      const denominator = new Mul(_.invoke(inverses, "getDenominator")).flatten();
+      const denominator = new Mul(___default.default.invoke(inverses, "getDenominator")).flatten();
       inverses = [new Pow(denominator.expand(), NumDiv)];
     }
     return new Mul(normals.concat(inverses)).flatten();
@@ -3010,10 +3521,16 @@ class Mul extends Seq {
     if (!(factored instanceof Mul)) {
       return factored;
     }
+
+    // Combine any factored out Rationals into one, but don't collect
     var [rationals, others] = partition(factored.terms, term => {
       return term instanceof Rational;
     });
-    const ratObj = _.reduce(rationals, (memo, term) => {
+
+    // Could also accomplish this by passing a new option
+    // e.g. return  memo.mul(term, {autocollect: false});
+    // TODO(alex): Decide whether this is a good use of options or not
+    const ratObj = ___default.default.reduce(rationals, (memo, term) => {
       return {
         n: memo.n * term.n,
         d: memo.d * term.d
@@ -3028,28 +3545,35 @@ class Mul extends Seq {
   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 NumZero;
     }
     const other = partitioned[1].flatten();
+
+    // e.g. 2*2 -> 4
+    // e.g. 2*2*x -> 4*x
     if (!(other instanceof Mul)) {
       return new Mul(number, other).flatten();
     }
     const others = other.terms;
     var pairs = [];
-    _.each(others, term => {
+    ___default.default.each(others, term => {
       if (term instanceof Pow) {
         pairs.push([term.base, term.exp]);
       } else {
         pairs.push([term, NumOne]);
       }
     });
-    var grouped = _.groupBy(pairs, pair => {
+
+    // {(Expr base).print(): [[Expr base, Expr exp]]}
+    var grouped = ___default.default.groupBy(pairs, pair => {
       return pair[0].normalize().print();
     });
-    var summed = _.compact(_.map(grouped, pairs => {
+    var summed = ___default.default.compact(___default.default.map(grouped, pairs => {
       var base = pairs[0][0];
-      var sum = new Add(_.zip.apply(_, pairs)[1]);
+      var sum = new Add(___default.default.zip.apply(___default.default, pairs)[1]);
       var exp = sum.collect(options);
       if (exp instanceof Num && exp.eval() === 0) {
         return null;
@@ -3057,7 +3581,9 @@ class Mul extends Seq {
         return [base, exp];
       }
     }));
-    const groupedPairs = _.groupBy(summed, pair => {
+
+    // XXX `pairs` is shadowed four or five times in this function
+    const groupedPairs = ___default.default.groupBy(summed, pair => {
       if (pair[0] instanceof Trig && pair[0].isBasic()) {
         return "trig";
       } else if (pair[0] instanceof Log) {
@@ -3066,24 +3592,33 @@ class Mul extends Seq {
         return "expr";
       }
     });
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     let trigs = groupedPairs.trig || [];
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     let logs = groupedPairs.log || [];
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     const exprs = groupedPairs.expr || [];
     if (trigs.length > 1) {
-      var byArg = _.groupBy(trigs, pair => {
+      // combine sines and cosines into other trig functions
+
+      // {Trig.arg.print(): [[Trig base, Expr exp]]}
+      var byArg = ___default.default.groupBy(trigs, pair => {
         return pair[0].arg.normalize().print();
       });
       trigs = [];
-      _.each(byArg, pairs => {
+      ___default.default.each(byArg, pairs => {
         const arg = pairs[0][0].arg;
+
+        // {Trig.type: Expr exp}
         let funcs = {
           sin: NumZero,
           cos: NumZero
         };
-        _.each(pairs, pair => {
+        ___default.default.each(pairs, pair => {
           funcs[pair[0].type] = pair[1];
         });
         if (Mul.handleNegative(funcs.sin).collect(options).equals(funcs.cos)) {
+          // e.g. sin^x(y)/cos^x(y) -> tan^x(y)
           if (funcs.cos.isNegative()) {
             funcs = {
               tan: funcs.sin
@@ -3094,18 +3629,30 @@ class Mul extends Seq {
             };
           }
         }
-        _.each(funcs, (exp, type) => {
+
+        // TODO(alex): combine even if exponents not a perfect match
+        // TODO(alex): transform 1/sin and 1/cos into csc and sec
+
+        ___default.default.each(funcs, (exp, type) => {
           trigs.push([new Trig(type, arg), exp]);
         });
       });
     }
     if (logs.length > 1) {
-      var byBase = _.groupBy(logs, pair => {
+      // combine logs with the same base
+
+      // {Log.base.print(): [[Log base, Expr exp]]}
+      var byBase = ___default.default.groupBy(logs, pair => {
         return pair[0].base.normalize().print();
       });
       logs = [];
-      _.each(byBase, pairs => {
+      ___default.default.each(byBase, pairs => {
+        // only combine two logs of the same base, otherwise commutative
+        // differences result in different equally valid output
+        // e.g. ln(x)/ln(z)*ln(y) -> log_z(x)*ln(y)
+        // e.g. ln(x)*ln(y)/ln(z) -> ln(x)*log_z(y)
         if (pairs.length === 2 && Mul.handleNegative(pairs[0][1]).collect(options).equals(pairs[1][1])) {
+          // e.g. ln(x)^y/ln(b)^y -> log_b(x)^y
           if (pairs[0][1].isNegative()) {
             logs.push([new Log(pairs[0][0].power, pairs[1][0].power), pairs[1][1]]);
           } else {
@@ -3115,32 +3662,48 @@ class Mul extends Seq {
           logs = logs.concat(pairs);
         }
       });
+
+      // TODO(alex): combine if all inverses are the same e.g. ln(y)*ln(z)/ln(x)/ln(x)
     }
-    var collected = _.map([...trigs, ...logs, ...exprs], pair => {
+    var collected = ___default.default.map([...trigs, ...logs, ...exprs], pair => {
       return new Pow(pair[0], pair[1]).collect(options);
     });
     return new Mul([number].concat(collected)).flatten();
   }
   isSubtract() {
-    return _.any(this.terms, term => {
+    return ___default.default.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(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, num => num.n > 0);
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+    var fold = numbers.length && ___default.default.all(numbers, num => num.n > 0);
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (fold) {
+      // e.g. - x*2*3 -> x*-2*3
       var num = numbers[0].negate();
       num.hints = numbers[0].hints;
       return this.replace(numbers[0], num.addHint(hint));
     } else {
+      // e.g. - x*y -> -1*x*y
+      // 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() {
     var factored = false;
-    var terms = _.compact(_.map(this.terms, term => {
+    var terms = ___default.default.compact(___default.default.map(this.terms, term => {
       if (!factored && term instanceof Num && term.hints.divide) {
         factored = true;
         return term.n !== -1 ? term.negate() : null;
@@ -3155,12 +3718,14 @@ class Mul extends Seq {
     }
   }
   reduce(options) {
-    return _.reduce(this.terms, (memo, term) => {
+    return ___default.default.reduce(this.terms,
+    // @ts-expect-error: Type 'Expr' is not assignable to type 'Num'.
+    (memo, term) => {
       return memo.mul(term, options);
     }, this.identity);
   }
   findGCD(factor) {
-    return new Mul(_.invoke(this.terms, "findGCD", factor)).flatten();
+    return new Mul(___default.default.invoke(this.terms, "findGCD", factor)).flatten();
   }
   asMul() {
     return this;
@@ -3175,7 +3740,7 @@ class Mul extends Seq {
   }
   isNegative() {
     const terms = getFactors(this.collect()).map(factor => factor.isNegative());
-    return _.any(terms);
+    return ___default.default.any(terms);
   }
   fold() {
     return Mul.fold(this);
@@ -3184,28 +3749,42 @@ class Mul extends Seq {
     var isNum = expr => {
       return expr instanceof Num;
     };
-    const num = _.find(this.terms, isNum);
+    const num = ___default.default.find(this.terms, isNum);
     if (num) {
       return this.replace(num, num.negate());
     } else {
       return new Mul([NumNeg].concat(this.terms));
     }
   }
+
+  // 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
   static handleNegative(expr, hint) {
     if (expr instanceof Num && expr.n > 0) {
+      // e.g. - 2 -> -2
       var negated = expr.negate();
+      // TODO(alex): rework hint system so that this isn't necessary
       negated.hints = expr.hints;
       return negated.addHint(hint);
     } else if (expr instanceof Mul) {
+      // e.g. - x*2*3 -> x*-2*3
+      // e.g. - x*y -> -1*x*y
+      // e.g. - x*-2 -> -1*x*-2
       return expr.factorIn(hint);
     } else {
+      // e.g. - x -> -1*x
       return new Mul(Num.negativeOne(hint), expr);
     }
   }
+
+  // division can create either a Rational or a Mul
   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();
+      var rest = new Mul(___default.default.rest(right.terms)).flatten();
       return Mul.handleDivide(first, rest);
     }
     var isInt = expr => {
@@ -3214,7 +3793,11 @@ class Mul extends Seq {
     var isRational = expr => {
       return expr instanceof Rational;
     };
-    if (isInt(right) && left instanceof Mul && _.any(left.terms, isInt)) {
+
+    // for simplification purposes, fold Ints into Rationals if possible
+    // e.g. 3x / 4 -> 3/4 * x (will still render as 3x/4)
+    if (isInt(right) && left instanceof Mul && ___default.default.any(left.terms, isInt)) {
+      // search from the right
       var reversed = left.terms.slice().reverse();
       var num = reversed.find(isRational);
       if (!isInt(num)) {
@@ -3222,6 +3805,9 @@ class Mul extends Seq {
       }
       var rational = new Rational(num.n, right.n);
       rational.hints = num.hints;
+
+      // in the case of something like 1/3 * 6/8, we want the
+      // 6/8 to be considered a fraction, not just a division
       if (num === reversed[0]) {
         rational = rational.addHint("fraction");
       }
@@ -3236,11 +3822,17 @@ class Mul extends Seq {
       if (b instanceof Int) {
         if (a instanceof Int) {
           if (a.n < 0 && b.n < 0) {
+            // e.g. -2 / -3 -> -1*-2/3
             return [NumNeg, new Rational(a.n, -b.n).addHint("fraction")];
           } else {
+            // e.g. 2 / 3 -> 2/3
+            // e.g. -2 / 3 -> -2/3
+            // e.g. 2 / -3 -> -2/3
             return [new Rational(a.n, b.n).addHint("fraction")];
           }
         } else {
+          // e.g. x / 3 -> x*1/3
+          // e.g. x / -3 -> x*-1/3
           var inverse = new Rational(1, b.eval());
           if (b.eval() < 0) {
             return [a, inverse.addHint("negate")];
@@ -3251,42 +3843,66 @@ class Mul extends Seq {
       } else {
         var pow;
         if (b instanceof Trig && b.exp) {
+          // e.g. sin^2(x) -> sin(x)^2
           var exp = b.exp;
           b.exp = undefined;
           b = new Pow(b, exp);
         }
         if (b instanceof Pow) {
+          // e.g. (x^2) ^ -1 -> x^-2
+          // e.g. (x^y) ^ -1 -> x^(-1*y)
+          // e.g. (x^(yz)) ^ -1 -> x^(-1*y*z)
           pow = new Pow(b.base, Mul.handleNegative(b.exp, "divide"));
         } else {
+          // e.g. x ^ -1 -> x^-1
           pow = new Pow(b, NumDiv);
         }
         if (a instanceof Int && a.n === 1) {
+          // e.g. 1 / x -> x^-1
           return [pow];
         } else {
+          // e.g. 2 / x -> 2*x^-1
           return [a, pow];
         }
       }
     };
     if (left instanceof Mul) {
-      var divided = divide(_.last(left.terms), right);
-      return new Mul(_.initial(left.terms).concat(divided));
+      // NOTE(kevinb): `terms` should always have at least two
+      // elements so getting the last element is safe to do.
+      var divided = divide(___default.default.last(left.terms), right);
+      return new Mul(___default.default.initial(left.terms).concat(divided));
     } 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
+  // e.g. -2*x    ->  -2*x    simplified
+  // e.g. -x*2    ->  -1*x*2  not simplified -> x*-2 simplified
+  // e.g. -1*x*2  ->  -1*x*2  not simplified
+
+  // also fold multiplicative terms into open Trig and Log nodes
+  // e.g. (sin x)*x -> sin(x)*x
+  // 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)
   static fold(expr) {
     if (expr instanceof Mul) {
-      var trigLog = _.find(_.initial(expr.terms), term => {
+      // assuming that this will be second to last
+      var trigLog = ___default.default.find(___default.default.initial(expr.terms), term => {
         return (term instanceof Trig || term instanceof Log) && Boolean(term.hints.open);
       });
       if (trigLog) {
-        const last = _.last(expr.terms);
+        // expr.terms should always have at least two terms
+        const last = ___default.default.last(expr.terms);
         if (trigLog.hints.parens || last.hints.parens || last.has(Trig) || last.has(Log)) {
           trigLog.hints.open = false;
         } else {
           const newTrigLog = trigLog instanceof Trig ? Trig.create([trigLog.type, trigLog.exp], Mul.createOrAppend(trigLog.arg, last).fold()) : Log.create(trigLog.base, Mul.createOrAppend(trigLog.power, last).fold());
-          const index = _.indexOf(expr.terms, trigLog);
+          const index = ___default.default.indexOf(expr.terms, trigLog);
           if (index === 0) {
             return newTrigLog;
           } else {
@@ -3302,21 +3918,32 @@ class Mul extends Seq {
       var neg = num => {
         return num.n === -1 && Boolean(num.hints.negate);
       };
-      var posOrNeg = function posOrNeg(num) {
+      var posOrNeg = function (num) {
         return pos(num) || neg(num);
       };
+
+      // @ts-expect-error: Type 'Expr' is not assignable to type 'Num'.
       const posNum = numbers.find(pos);
+      // @ts-expect-error: Type 'Expr' is not assignable to type 'Num'.
       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);
+      if (numbers.length > 1 && negNum && posNum &&
+      // @ts-expect-error: Type 'Expr' is not assignable to type 'Num'.
+      ___default.default.every(numbers, posOrNeg)) {
+        var firstNeg = ___default.default.indexOf(expr.terms, negNum);
+        var firstNum = ___default.default.indexOf(expr.terms, posNum);
+
+        // e.g. -x*2 -> x*-2
         if (firstNeg < firstNum) {
           return expr.replace(firstNum, expr.terms[firstNum].negate()).remove(firstNeg);
         }
       }
     }
+
+    // in all other cases, make no change
     return expr;
   }
+
+  // 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));
@@ -3325,23 +3952,39 @@ class Mul extends Seq {
     }
   }
 }
+
+/* exponentiation */
 class Pow extends Expr {
+  base;
+  exp;
   constructor(base, exp) {
     super();
-    this.base = void 0;
-    this.exp = void 0;
-    this.func = Pow;
     this.base = base;
     this.exp = exp;
   }
+  func = Pow;
   args() {
     return [this.base, this.exp];
   }
-  eval(vars = {}, options) {
+  eval() {
+    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let options = arguments.length > 1 ? arguments[1] : undefined;
     var evaledBase = this.base.eval(vars, options);
     var evaledExp = this.exp.eval(vars, options);
+
+    // Math.pow unequivocally returns NaN when provided with both a
+    // negative base and a fractional exponent. However, in some cases, we
+    // know that our exponent is actually valid for use with negative
+    // bases (e.g., (-5)^(1/3)).
+    //
+    // Here, we explicitly check for such cases. We really only handle a
+    // limited subset (by requiring that the exponent is rational with an
+    // odd denominator), but it's still useful.
+    //   See: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow
     if (evaledBase < 0) {
       var simplifiedExp = this.exp.simplify();
+
+      // 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;
@@ -3364,6 +4007,7 @@ class Pow extends Expr {
     return this.base.getUnits().map(unit => {
       return {
         unit: unit.unit,
+        // Exponents in units should always be integers
         pow: unit.pow * this.exp.n
       };
     });
@@ -3380,24 +4024,31 @@ class Pow extends Expr {
   }
   tex() {
     if (this.isDivide()) {
+      // e.g. x ^ -1 w/hint -> 1/x
       return "\\frac{1}{" + this.asDivide().tex() + "}";
     } else if (this.isRoot() && isRational(this.exp)) {
       if (this.exp.n !== 1) {
         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}
         return "\\sqrt{" + this.base.tex() + "}";
       } else {
+        // e.g. x ^ 1/y w/hint -> sqrt[y]{x}
         return "\\sqrt[" + this.exp.d + "]{" + this.base.tex() + "}";
       }
     } 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.texSplit();
       return split[0] + "^{" + this.exp.tex() + "}" + split[1];
     } else {
+      // e.g. x ^ y -> x^y
       var base = this.base.tex();
       if (this.base instanceof Seq || this.base instanceof Pow || this.base instanceof Num && !this.base.isSimple()) {
+        // e.g. a+b ^ c -> (a+b)^c
         base = "(" + base + ")";
       } else if (this.base instanceof Trig || this.base instanceof Log) {
+        // e.g. ln(x) ^ 2 -> [ln(x)]^2
         base = "[" + base + "]";
       }
       return base + "^{" + this.exp.tex() + "}";
@@ -3409,30 +4060,43 @@ class Pow extends Expr {
   expand() {
     var pow = this.recurse("expand");
     if (pow.base instanceof Mul) {
-      var terms = _.map(pow.base.terms, term => {
+      // e.g. (ab)^c -> a^c*b^c
+
+      var terms = ___default.default.map(pow.base.terms, term => {
         return new Pow(term, pow.exp);
       });
       return new Mul(terms).expand();
     } else if (pow.base instanceof Add && pow.exp instanceof Int && pow.exp.abs().eval() > 1) {
+      // e.g. (a+b)^2 -> a*a+a*b+a*b+b*b
+      // e.g. (a+b)^-2 -> (a*a+a*b+a*b+b*b)^-1
+
       var positive = pow.exp.eval() > 0;
       var n = pow.exp.abs().eval();
-      var signed = function signed(mul) {
+      var signed = function (mul) {
         return positive ? mul : new Pow(mul, NumDiv);
       };
+
+      // compute and cache powers of 2 up to n
       const cache = {
         1: pow.base
       };
       for (var i = 2; i <= n; i *= 2) {
-        const _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 (n in cache) {
         return signed(cache[n]);
       }
-      let indices = _.map(n.toString(2).split(""), function (str, i, list) {
+
+      // otherwise decompose n into powers of 2 ...
+      let indices = ___default.default.map(n.toString(2).split(""), function (str, i, list) {
         return Number(str) * Math.pow(2, list.length - i - 1);
       });
-      indices = _.without(indices, 0);
+      indices = ___default.default.without(indices, 0);
+
+      // ... then combine
       const factors = [];
       for (const index of indices) {
         if (index in cache) {
@@ -3442,10 +4106,13 @@ class Pow extends Expr {
       const mul = new Mul(factors).expand().collect();
       return signed(mul);
     } else if (pow.exp instanceof Add) {
-      const _terms = _.map(pow.exp.terms, term => {
+      // DEFINITELY want behind super-simplify() flag
+      // e.g. x^(a+b) -> x^a*x^b
+
+      const terms = ___default.default.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;
     }
@@ -3453,8 +4120,10 @@ class Pow extends Expr {
   factor() {
     var pow = this.recurse("factor");
     if (pow.base instanceof Mul) {
-      var terms = _.map(pow.base.terms, term => {
+      var terms = ___default.default.map(pow.base.terms, term => {
         if (term instanceof Int && pow.exp.equals(NumDiv)) {
+          // Anything that can be a Rational should be a Rational
+          // e.g. 2^(-1) -> 1/2
           return new Rational(1, term.n);
         } else {
           return new Pow(term, pow.exp);
@@ -3467,54 +4136,86 @@ class Pow extends Expr {
   }
   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)
       const base = this.base.base;
       const exp = Mul.createOrAppend(this.base.exp, this.exp);
       return new Pow(base, exp).collect(options);
     }
     const pow = this.recurse("collect", options);
-    const isSimilarLog = function isSimilarLog(term) {
+    const isSimilarLog = function (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 NumOne;
     } else if (pow.exp instanceof Num && pow.exp.eval() === 1) {
+      // e.g. x^1 -> x
       return pow.base;
     } else if (isSimilarLog(pow.exp)) {
+      // e.g. b^(log_b(x)) -> x
       return pow.exp.power;
-    } else if (pow.exp instanceof Mul && _.any(pow.exp.terms, isSimilarLog)) {
+    } else if (pow.exp instanceof Mul && ___default.default.any(pow.exp.terms, isSimilarLog)) {
+      // e.g. b^(2*y*log_b(x)) -> x^(2*y)
+      // `log` will always be defined here because of the
+      // `_.any(pow.exp.terms, isSimilarLog)` check above.
       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
+      // elsewhere) into a separate Decimal class for user-entered floats
       if (options && options.preciseFloats) {
+        // Avoid creating an imprecise float
+        // e.g. 23^1.5 -> 12167^0.5, not ~110.304
+
+        // If you take the root as specified by the denominator and
+        // end up with more digits after the decimal point,
+        // the result is imprecise. This works for rationals as well
+        // 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.
         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().getDecimalPlaces();
+        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.
           const newBase = new Pow(pow.base, new Int(exp.n)).collect();
           return new Pow(newBase, new Rational(1, exp.d));
         }
       }
+
+      // e.g. 4^1.5 -> 8
       return pow.base.raiseToThe(pow.exp, options);
     } else {
       return pow;
     }
   }
+
+  // checks whether this Pow represents user-entered division
   isDivide() {
-    var isDiv = function isDiv(arg) {
+    var isDiv = function (arg) {
       return arg instanceof Num && Boolean(arg.hints.divide);
     };
-    return isDiv(this.exp) || this.exp instanceof Mul && _.any(this.exp.terms, isDiv);
+    return isDiv(this.exp) || this.exp instanceof Mul && ___default.default.any(this.exp.terms, isDiv);
   }
+
+  // assuming this Pow represents user-entered division, returns the denominator
   asDivide() {
     if (this.exp instanceof Num) {
       if (this.exp.eval() === -1) {
         return this.base;
       } else {
         var negated = this.exp.negate();
-        negated.hints = _.clone(this.exp.hints);
+        negated.hints = ___default.default.clone(this.exp.hints);
         negated.hints.divide = false;
         return new Pow(this.base, negated);
       }
@@ -3530,6 +4231,9 @@ class Pow extends Expr {
   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() {
     if (this.exp instanceof Num && this.exp.eval() === -1) {
       return Mul.createOrAppend(this.base, this.base.getDenominator()).flatten();
@@ -3544,17 +4248,27 @@ class Pow extends Expr {
   }
   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)) {
       if (this.exp.equals(exp)) {
+        // exact match
+        // e.g. GCD(x^y^z, x^y^z) -> x^y^z
         return this;
       } else if (this.exp instanceof Num && exp instanceof Num) {
+        // two numerical exponents
+        // e.g. GCD(x^3, x^2) -> x^2
         return new Pow(this.base, Num.min(this.exp, exp)).collect();
       } else if (this.exp instanceof Num || exp instanceof Num) {
+        // one numerical exponent
+        // e.g. GCD(x^2, x^y) -> 1
         return NumOne;
       }
       var expA = this.exp.asMul().partition();
       var expB = exp.asMul().partition();
       if (expA[1].equals(expB[1])) {
+        // exponents match except for coefficient
+        // e.g. GCD(x^3y, x^y) -> x^y
         var coefficient = Num.min(expA[0].reduce(), expB[0].reduce());
         var mul = new Mul(coefficient, expA[1].flatten()).flatten();
         return new Pow(base, mul).collect();
@@ -3577,8 +4291,10 @@ class Pow extends Expr {
       if (exp instanceof Int) {
         var n = exp.eval();
         if (n > 2) {
+          // e.g. x^3 -> x^2
           return new Pow(this.base, new Int(n - 1));
         } else if (n < -2) {
+          // e.g. x^-3 -> x^-2
           return new Pow(this.base, new Int(n + 1));
         }
       }
@@ -3588,28 +4304,40 @@ class Pow extends Expr {
   static sqrt(arg) {
     return new Pow(arg, NumSqrt);
   }
+
+  // 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`.
+  static 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"));
+  };
 }
-_class5 = Pow;
-Pow.nthroot = function (radicand, degree) {
-  var exp = Mul.fold(Mul.handleDivide(new Int(1), degree));
-  return new _class5(radicand, exp.addHint("root"));
-};
+
+/* logarithm */
 class Log extends Expr {
+  base;
+  power;
   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, {
+    this.hints = {
+      ...this.hints,
       open: false
-    });
+    };
   }
+  func = Log;
   args() {
     return [this.base, this.power];
   }
-  eval(vars = {}, options) {
+  eval() {
+    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let options = arguments.length > 1 ? arguments[1] : undefined;
     return Math.log(this.power.eval(vars, options)) / Math.log(this.base.eval(vars, options));
   }
   codegen() {
@@ -3634,10 +4362,13 @@ class Log extends Expr {
   collect(options) {
     var log = this.recurse("collect", options);
     if (log.power instanceof Num && log.power.eval() === 1) {
+      // e.g. ln(1) -> 0
       return NumZero;
     } else if (log.base.equals(log.power)) {
+      // e.g. log_b(b) -> 1
       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;
@@ -3646,13 +4377,21 @@ class Log extends Expr {
   expand() {
     var log = this.recurse("expand");
     if (log.power instanceof Mul) {
-      var terms = _.map(log.power.terms, term => {
+      // might want behind super-simplify() flag
+      // e.g. ln(xy) -> ln(x) + ln(y)
+
+      var terms = ___default.default.map(log.power.terms, term => {
+        // need to expand again in case new log powers are Pows
         return new Log(log.base, term).expand();
       });
       return new Add(terms);
     } else if (log.power instanceof Pow) {
+      // e.g. ln(x^y) -> y*ln(x)
+
       return new Mul(log.power.exp, new Log(log.base, log.power.base).expand()).flatten();
     } else if (!log.isNatural()) {
+      // e.g. log_b(x) -> ln(x)/ln(b)
+
       return Mul.handleDivide(new Log(Const.e, log.power), new Log(Const.e, log.base));
     } else {
       return log;
@@ -3686,172 +4425,178 @@ class Log extends Expr {
     return log;
   }
 }
+/* trigonometric functions */
 class Trig extends Expr {
-  constructor(type, _arg) {
+  type; // TODO(kevinb): Use a union type for this
+  arg;
+  exp;
+  constructor(type, arg) {
     super();
-    this.type = void 0;
-    this.arg = void 0;
-    this.exp = void 0;
-    this.func = Trig;
-    this.functions = {
-      sin: {
-        eval: Math.sin,
-        codegen: "Math.sin((",
-        tex: "\\sin",
-        expand: () => this
+    this.type = type;
+    this.arg = arg;
+    this.hints = {
+      ...this.hints,
+      open: false
+    };
+  }
+  func = Trig;
+  args() {
+    return [this.type, this.arg];
+  }
+
+  // TODO(kevinb): Use union type for the function names.
+  functions = {
+    sin: {
+      eval: Math.sin,
+      codegen: "Math.sin((",
+      tex: "\\sin",
+      expand: () => this
+    },
+    cos: {
+      eval: Math.cos,
+      codegen: "Math.cos((",
+      tex: "\\cos",
+      expand: () => this
+    },
+    tan: {
+      eval: Math.tan,
+      codegen: "Math.tan((",
+      tex: "\\tan",
+      expand: () => Mul.handleDivide(Trig.sin(this.arg), Trig.cos(this.arg))
+    },
+    csc: {
+      eval: arg => {
+        return 1 / Math.sin(arg);
       },
-      cos: {
-        eval: Math.cos,
-        codegen: "Math.cos((",
-        tex: "\\cos",
-        expand: () => this
+      codegen: "(1/Math.sin(",
+      tex: "\\csc",
+      expand: () => Mul.handleDivide(NumOne, Trig.sin(this.arg))
+    },
+    sec: {
+      eval: arg => {
+        return 1 / Math.cos(arg);
       },
-      tan: {
-        eval: Math.tan,
-        codegen: "Math.tan((",
-        tex: "\\tan",
-        expand: () => Mul.handleDivide(Trig.sin(this.arg), Trig.cos(this.arg))
+      codegen: "(1/Math.cos(",
+      tex: "\\sec",
+      expand: () => Mul.handleDivide(NumOne, Trig.cos(this.arg))
+    },
+    cot: {
+      eval: arg => {
+        return 1 / Math.tan(arg);
       },
-      csc: {
-        eval: arg => {
-          return 1 / Math.sin(arg);
-        },
-        codegen: "(1/Math.sin(",
-        tex: "\\csc",
-        expand: () => Mul.handleDivide(NumOne, Trig.sin(this.arg))
+      codegen: "(1/Math.tan(",
+      tex: "\\cot",
+      expand: () => 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: arg => {
+        return Math.asin(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.asin(1/(",
+      tex: "\\operatorname{arccsc}"
+    },
+    arcsec: {
+      eval: arg => {
+        return Math.acos(1 / arg);
       },
-      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: "Math.acos(1/(",
+      tex: "\\operatorname{arcsec}"
+    },
+    arccot: {
+      eval: arg => {
+        return Math.atan(1 / arg);
       },
-      arcsin: {
-        eval: Math.asin,
-        codegen: "Math.asin((",
-        tex: "\\arcsin"
+      codegen: "Math.atan(1/(",
+      tex: "\\operatorname{arccot}"
+    },
+    sinh: {
+      eval: arg => {
+        return (Math.exp(arg) - Math.exp(-arg)) / 2;
       },
-      arccos: {
-        eval: Math.acos,
-        codegen: "Math.acos((",
-        tex: "\\arccos"
+      codegen: argStr => {
+        return "((Math.exp(" + argStr + ") - Math.exp(-(" + argStr + "))) / 2)";
       },
-      arctan: {
-        eval: Math.atan,
-        codegen: "Math.atan((",
-        tex: "\\arctan"
+      tex: "\\sinh",
+      expand: () => this
+    },
+    cosh: {
+      eval: arg => {
+        return (Math.exp(arg) + Math.exp(-arg)) / 2;
       },
-      arccsc: {
-        eval: arg => {
-          return Math.asin(1 / arg);
-        },
-        codegen: "Math.asin(1/(",
-        tex: "\\operatorname{arccsc}"
+      codegen: argStr => {
+        return "((Math.exp(" + argStr + ") + Math.exp(-(" + argStr + "))) / 2)";
       },
-      arcsec: {
-        eval: arg => {
-          return Math.acos(1 / arg);
-        },
-        codegen: "Math.acos(1/(",
-        tex: "\\operatorname{arcsec}"
+      tex: "\\cosh",
+      expand: () => this
+    },
+    tanh: {
+      eval: arg => {
+        return (Math.exp(arg) - Math.exp(-arg)) / (Math.exp(arg) + Math.exp(-arg));
       },
-      arccot: {
-        eval: arg => {
-          return Math.atan(1 / arg);
-        },
-        codegen: "Math.atan(1/(",
-        tex: "\\operatorname{arccot}"
+      codegen: argStr => {
+        return "(" + "(Math.exp(" + argStr + ") - Math.exp(-(" + argStr + ")))" + " / " + "(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: "\\tanh",
+      expand: () => Mul.handleDivide(Trig.sinh(this.arg), Trig.cosh(this.arg))
+    },
+    csch: {
+      eval: 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: 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: "\\csch",
+      expand: () => Mul.handleDivide(NumOne, Trig.sinh(this.arg))
+    },
+    sech: {
+      eval: arg => {
+        return 2 / (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: argStr => {
+        return "(2 / (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: "\\sech",
+      expand: () => Mul.handleDivide(NumOne, Trig.cosh(this.arg))
+    },
+    coth: {
+      eval: arg => {
+        return (Math.exp(arg) + Math.exp(-arg)) / (Math.exp(arg) - Math.exp(-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))
-      }
-    };
-    this.type = type;
-    this.arg = _arg;
-    this.hints = _extends({}, this.hints, {
-      open: false
-    });
-  }
-  args() {
-    return [this.type, this.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() {
-    return _.contains(["cos", "sec"], this.type);
+    return ___default.default.contains(["cos", "sec"], this.type);
   }
   isInverse() {
     return this.type.indexOf("arc") === 0;
   }
   isBasic() {
-    return _.contains(["sin", "cos"], this.type);
+    return ___default.default.contains(["sin", "cos"], this.type);
   }
-  eval(vars = {}, options) {
+  eval() {
+    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let options = arguments.length > 1 ? arguments[1] : undefined;
     var func = this.functions[this.type].eval;
     var arg = this.arg.eval(vars, options);
     return func(arg);
@@ -3896,14 +4641,18 @@ class Trig extends Expr {
       return this;
     }
   }
+
+  // TODO(alex): does every new node type need to redefine these?
   needsExplicitMul() {
     return false;
   }
   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)();
+      return ___default.default.bind(expand, trig)();
     } else {
       return trig;
     }
@@ -3913,8 +4662,10 @@ class Trig extends Expr {
     if (!trig.isInverse() && trig.arg.isNegative()) {
       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(NumNeg, new Trig(trig.type, arg));
       }
     } else {
@@ -3925,6 +4676,7 @@ class Trig extends Expr {
     var type = pair[0];
     var exp = pair[1];
     if (exp && exp.equals(NumNeg)) {
+      // e.g. sin^-1(x) -> arcsin(x)
       type = "arc" + type;
       exp = undefined;
     }
@@ -3951,16 +4703,18 @@ class Trig extends Expr {
   }
 }
 class Abs extends Expr {
+  arg;
   constructor(arg) {
     super();
-    this.arg = void 0;
-    this.func = Abs;
     this.arg = arg;
   }
+  func = Abs;
   args() {
     return [this.arg];
   }
-  eval(vars = {}, options) {
+  eval() {
+    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let options = arguments.length > 1 ? arguments[1] : undefined;
     return Math.abs(this.arg.eval(vars, options));
   }
   codegen() {
@@ -3975,11 +4729,14 @@ class Abs extends Expr {
   collect(options) {
     var abs = this.recurse("collect", options);
     if (abs.arg.isPositive()) {
+      // e.g. |2^x| -> 2^x
       return abs.arg;
     } else if (abs.arg instanceof Num) {
+      // e.g. |-2| -> 2
       return abs.arg.abs();
     } else if (abs.arg instanceof Mul) {
-      var terms = _.groupBy(abs.arg.terms, term => {
+      // e.g. |-2*pi*x| -> 2*pi*|x|
+      var terms = ___default.default.groupBy(abs.arg.terms, term => {
         if (term.isPositive()) {
           return "positive";
         } else if (term instanceof Num) {
@@ -3988,7 +4745,9 @@ class Abs extends Expr {
           return "other";
         }
       });
-      var positives = terms.positive.concat(_.invoke(terms.number, "abs"));
+      var positives = terms.positive.concat(___default.default.invoke(terms.number, "abs"));
+
+      // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
       if (terms.other.length) {
         positives.push(new Abs(new Mul(terms.other).flatten()));
       }
@@ -3997,10 +4756,13 @@ class Abs extends Expr {
       return abs;
     }
   }
+
+  // this should definitely be behind a super-simplify flag
   expand() {
     var abs = this.recurse("expand");
     if (abs.arg instanceof Mul) {
-      var terms = _.map(abs.arg.terms, term => {
+      // e.g. |xyz| -> |x|*|y|*|z|
+      var terms = ___default.default.map(abs.arg.terms, term => {
         return new Abs(term);
       });
       return new Mul(terms);
@@ -4012,25 +4774,19 @@ class Abs extends Expr {
     return true;
   }
 }
+
+/* equation */
 class Eq extends Expr {
+  left;
+  type; // TODO(kevinb): use an enum for this
+  right;
   constructor(left, type, right) {
     super();
-    this.left = void 0;
-    this.type = void 0;
-    this.right = void 0;
-    this.func = Eq;
-    this.signs = {
-      "=": " = ",
-      "<": " < ",
-      ">": " > ",
-      "<>": " \\ne ",
-      "<=": " \\le ",
-      ">=": " \\ge "
-    };
     this.left = left;
     this.type = type;
     this.right = right;
   }
+  func = Eq;
   args() {
     return [this.left, this.type, this.right];
   }
@@ -4040,24 +4796,41 @@ class Eq extends Expr {
   print() {
     return this.left.print() + this.type + this.right.print();
   }
+  signs = {
+    "=": " = ",
+    "<": " < ",
+    ">": " > ",
+    "<>": " \\ne ",
+    "<=": " \\le ",
+    ">=": " \\ge "
+  };
   tex() {
     return this.left.tex() + this.signs[this.type] + this.right.tex();
   }
   normalize() {
     var eq = this.recurse("normalize");
-    if (_.contains([">", ">="], eq.type)) {
+    if (___default.default.contains([">", ">="], eq.type)) {
+      // inequalities should have the smaller side on the left
       return new Eq(eq.right, eq.type.replace(">", "<"), eq.left);
     } else {
       return eq;
     }
   }
-  asExpr(unfactored = false) {
+
+  // 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() {
+    let unfactored = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
     var isZero = expr => {
       return expr instanceof Num && expr.isSimple() && expr.eval() === 0;
     };
+
+    // first convert to a sequence of additive terms
     let terms = [];
     if (this.left instanceof Add) {
-      terms = _.clone(this.left.terms);
+      terms = ___default.default.clone(this.left.terms);
     } else if (!isZero(this.left)) {
       terms = [this.left];
     }
@@ -4067,16 +4840,26 @@ class Eq extends Expr {
       terms.push(this.right.negate());
     }
     var isInequality = !this.isEquality();
-    terms = _.invoke(terms, "collect", {
+
+    // Collect over each term individually to transform simple expressions
+    // into numbers that might have denominators, taking into account
+    // float precision. We have to be very careful to not introduce any
+    // irrational floats before asExpr() returns, because by definition
+    // they do not have exact denominators...
+    terms = ___default.default.invoke(terms, "collect", {
       preciseFloats: true
     });
+
+    // ...and we multiply through by every denominator.
     for (var i = 0; i < terms.length; i++) {
       var denominator = terms[i].getDenominator();
+
+      // Can't multiply inequalities by non 100% positive factors
       if (isInequality && !denominator.isPositive()) {
         denominator = denominator.asPositiveFactor();
       }
       if (!denominator.equals(NumOne)) {
-        terms = _.map(terms, term => {
+        terms = ___default.default.map(terms, term => {
           return Mul.createOrAppend(term, denominator).simplify({
             once: true,
             preciseFloats: true
@@ -4087,6 +4870,11 @@ class Eq extends Expr {
     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(expr) {
     const isInequality = !this.isEquality();
     const simplified = expr.simplify({
@@ -4099,24 +4887,41 @@ class Eq extends Expr {
       return expr;
     }
     const terms = factored.terms;
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     const hasVar = term => !!term.getVars().length;
     const isOne = term => term.equals(NumOne);
     const [adds, others] = partition(terms, isAdd);
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (adds.length && this.isEquality()) {
+      // keep only Adds
+      // e.g. 2xy(z+1)(=0) -> z+1(=0)
       return new Mul(adds).flatten();
     }
     let denominator = others;
+
+    // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
     if (!adds.length) {
-      denominator = _.reject(denominator, hasVar);
+      // if no Adds, keep all variable terms to preserve meaning
+      // e.g. 42xyz(=0) -> xyz(=0)
+      denominator = ___default.default.reject(denominator, hasVar);
     }
     if (isInequality) {
-      denominator = _.invoke(denominator, "asPositiveFactor");
+      // can't divide inequalities by non 100% positive factors
+      // e.g. 42x^2y(z+1)(=0) -> y(z+1)(=0)
+      denominator = ___default.default.invoke(denominator, "asPositiveFactor");
     }
-    denominator = _.reject(denominator, isOne);
-    denominator = _.map(denominator, term => {
+
+    // don't need to divide by one
+    denominator = ___default.default.reject(denominator, isOne);
+    denominator = ___default.default.map(denominator, term => {
       return new Pow(term, NumDiv);
     });
     const dividedResult = new Mul(terms.concat(denominator)).collect();
+
+    // If the end result is the same as the original factoring,
+    // rollback the factoring and discard all intermediate steps.
     if (dividedResult.equals(factored)) {
       return simplified;
     } else {
@@ -4124,9 +4929,10 @@ class Eq extends Expr {
     }
   }
   isEquality() {
-    return _.contains(["=", "<>"], this.type);
+    return ___default.default.contains(["=", "<>"], this.type);
   }
   compare(other) {
+    // expression comparisons are handled by Expr.compare()
     if (!(other instanceof Eq)) {
       return false;
     }
@@ -4135,36 +4941,48 @@ class Eq extends Expr {
     if (eq1.type !== eq2.type) {
       return false;
     }
-    var expr1 = eq1.divideThrough(eq1.asExpr(true).collect());
-    var expr2 = eq2.divideThrough(eq2.asExpr(true).collect());
+
+    // need to collect to properly factor out common factors
+    // e.g x+2x=6 -> 3x=6 -> 3x-6(=0) -> x-2(=0)
+    var expr1 = eq1.divideThrough(eq1.asExpr(/* unfactored */true).collect());
+    var expr2 = eq2.divideThrough(eq2.asExpr(/* unfactored */true).collect());
     if (eq1.isEquality()) {
+      // equals and not-equals can be subtracted either way
       return expr1.compare(expr2) || expr1.compare(Mul.handleNegative(expr2));
     } else {
       return expr1.compare(expr2);
     }
   }
+
+  // should only be done after compare() returns true to avoid false positives
   sameForm(other) {
     var eq1 = this.normalize();
     var eq2 = other.normalize();
     var same = eq1.left.sameForm(eq2.left) && eq1.right.sameForm(eq2.right);
     if (eq1.isEquality()) {
+      // equals and not-equals can be commutative with respect to the sign
       return same || eq1.left.sameForm(eq2.right) && eq1.right.sameForm(eq2.left);
     } 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() {
-    var expr = this.asExpr(true);
+    var expr = this.asExpr(/* unfactored */true);
     var simplified = this.divideThrough(expr).simplify();
     return expr.equals(simplified) && this.left.isSimplified() && this.right.isSimplified();
   }
+
+  // Assumptions: Expression is of the form a+bx, and we solve for x
   solveLinearEquationForVariable(variable) {
     var expr = this.asExpr();
     if (!(expr instanceof Add) || expr.terms.length !== 2) {
       throw new Error("Can only handle linear equations of the form " + "a + bx (= 0)");
     }
     var hasVar = term => {
-      return term.has(Var) && _.contains(term.getVars(), variable.symbol);
+      return term.has(Var) && ___default.default.contains(term.getVars(), variable.symbol);
     };
     const termHasVar = hasVar(expr.terms[0]);
     const a = termHasVar ? Mul.handleNegative(expr.terms[1]) : Mul.handleNegative(expr.terms[0]);
@@ -4172,6 +4990,8 @@ class Eq extends Expr {
     return Mul.handleDivide(a, b).simplify();
   }
 }
+
+/* abstract symbol node */
 class Sym extends Expr {
   needsExplicitMul() {
     return false;
@@ -4184,15 +5004,17 @@ class Sym extends Expr {
     }
   }
 }
+
+/* function variable */
 class Func extends Sym {
+  symbol;
+  arg;
   constructor(symbol, arg) {
     super();
-    this.symbol = void 0;
-    this.arg = void 0;
-    this.func = Func;
     this.symbol = symbol;
     this.arg = arg;
   }
+  func = Func;
   args() {
     return [this.symbol, this.arg];
   }
@@ -4202,16 +5024,19 @@ class Func extends Sym {
   tex() {
     return this.symbol + "(" + this.arg.tex() + ")";
   }
-  eval(vars = {}, options) {
+  eval() {
+    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    let options = arguments.length > 1 ? arguments[1] : undefined;
     var arg = this.arg;
     var func = vars[this.symbol];
-    var newVars = _.extend(_.clone(vars), {
+    var newVars = ___default.default.extend(___default.default.clone(vars), {
       x: arg.eval(vars, options)
     });
     var parsedFunc = parse(func, options);
     if (parsedFunc.parsed) {
       return parsedFunc.expr.eval(newVars, options);
     }
+    // If parsedFunc isn't actually parsed, return its error
     return parsedFunc;
   }
   codegen() {
@@ -4224,22 +5049,24 @@ class Func extends Sym {
     if (excludeFunc) {
       return this.arg.getVars();
     } else {
-      return _.union(this.arg.getVars(), [this.symbol]).sort();
+      return ___default.default.union(this.arg.getVars(), [this.symbol]).sort();
     }
   }
   getConsts() {
     return this.arg.getConsts();
   }
 }
+
+/* variable */
 class Var extends Sym {
+  symbol;
+  subscript;
   constructor(symbol, subscript) {
     super();
-    this.symbol = void 0;
-    this.subscript = void 0;
-    this.func = Var;
     this.symbol = symbol;
     this.subscript = subscript;
   }
+  func = Var;
   args() {
     return [this.symbol, this.subscript];
   }
@@ -4256,6 +5083,9 @@ class Var extends Sym {
     }
     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() {
     var sub = this.subscript;
     if (sub && (sub instanceof Num || sub instanceof Sym)) {
@@ -4275,7 +5105,12 @@ class Var extends Sym {
   repr() {
     return "Var(" + this.print() + ")";
   }
-  eval(vars = {}, options) {
+  eval() {
+    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    // @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() {
@@ -4288,25 +5123,28 @@ class Var extends Sym {
     return false;
   }
 }
+
+/* constant */
 class Const extends Sym {
+  symbol;
   constructor(symbol) {
     super();
-    this.symbol = void 0;
-    this.func = Const;
     this.symbol = symbol;
   }
+  func = Const;
   args() {
     return [this.symbol];
   }
   recurse() {
     return this;
   }
-  eval(vars = {}, options) {
+  eval() {
     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;
     }
   }
@@ -4316,6 +5154,7 @@ class Const extends Sym {
     } else if (this.symbol === "e") {
       return "Math.E";
     } else {
+      // @ts-expect-error: should we throw an error here?
       return undefined;
     }
   }
@@ -4328,6 +5167,7 @@ class Const extends Sym {
     } else if (this.symbol === "e") {
       return "e";
     } else {
+      // @ts-expect-error: should we return this.symbol here?
       return undefined;
     }
   }
@@ -4344,22 +5184,25 @@ class Const extends Sym {
   getConsts() {
     return [this.print()];
   }
+  static e = new Const("e");
+  static pi = new Const("pi");
 }
-_class12 = Const;
-Const.e = new _class12("e");
-Const.pi = new _class12("pi");
+
+/* abstract number node */
 class Num extends Expr {
+  n = 0;
   constructor() {
     super();
-    this.n = 0;
-    this.hints = _extends({}, this.hints, {
+    // hints for interpreting and rendering user input
+    this.hints = {
+      ...this.hints,
       negate: false,
       subtract: false,
       divide: false,
       root: false,
       fraction: false,
       entered: false
-    });
+    };
   }
   repr() {
     return this.print();
@@ -4373,9 +5216,17 @@ class Num extends Expr {
   codegen() {
     return this.print();
   }
+
+  // takes another Num and returns a new Num
+
+  // returns this Num's additive inverse
+
   isSubtract() {
     return Boolean(this.hints.subtract);
   }
+
+  // return the absolute value of the number
+
   needsExplicitMul() {
     return true;
   }
@@ -4388,10 +5239,19 @@ class Num extends Expr {
   asPositiveFactor() {
     return this.isPositive() ? this : this.abs();
   }
+
+  // whether a number is considered simple (one term)
+  // e.g. for reals, ints and floats are simple
+
+  // Based on http://stackoverflow.com/a/10454560/2571482
   getDecimalPlaces() {
     var match = ("" + this.n).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/);
     if (match) {
-      return Math.max(0, (match[1] ? match[1].length : 0) - (match[2] ? +match[2] : 0));
+      return Math.max(0,
+      // Number of digits right of decimal point
+      (match[1] ? match[1].length : 0) - (
+      // Adjust for scientific notation
+      match[2] ? +match[2] : 0));
     } else {
       return 0;
     }
@@ -4405,10 +5265,16 @@ class Num extends Expr {
       return NumNeg;
     }
   }
+
+  // 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;
     }
@@ -4419,19 +5285,26 @@ class Num extends Expr {
     }
     return a;
   }
-  static min(...args) {
-    return _.min(args, num => num.eval());
+  static min() {
+    for (var _len3 = arguments.length, args = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      args[_key3] = arguments[_key3];
+    }
+    return ___default.default.min(args, num => num.eval());
   }
-  static max(...args) {
-    return _.max(args, num => num.eval());
+  static max() {
+    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+      args[_key4] = arguments[_key4];
+    }
+    return ___default.default.max(args, num => num.eval());
   }
 }
+
+/* rational number (n: numerator, d: denominator) */
 class Rational extends Num {
+  n;
+  d;
   constructor(numerator, denominator) {
     super();
-    this.n = void 0;
-    this.d = void 0;
-    this.func = Rational;
     var n = numerator;
     var d = denominator;
     if (d < 0) {
@@ -4441,6 +5314,7 @@ class Rational extends Num {
     this.n = n;
     this.d = d;
   }
+  func = Rational;
   args() {
     return [this.n, this.d];
   }
@@ -4485,9 +5359,14 @@ class Rational extends Num {
     return new Rational(Math.abs(this.n), this.d);
   }
   findGCD(factor) {
+    // Attempt to factor out common numerators and denominators to return
+    // a Rational instead of a Float
     if (factor instanceof Rational) {
+      // For more background, see
+      // http://math.stackexchange.com/questions/151081/gcd-of-rationals
       var numerator = Num.findGCD(this.n * factor.d, factor.n * this.d);
       var denominator = this.d * factor.d;
+      // Create the rational, then call .collect() to simplify it
       return new Rational(numerator, denominator).collect();
     } else if (factor instanceof Int) {
       return new Rational(Num.findGCD(this.n, factor.n), this.d);
@@ -4495,6 +5374,8 @@ class Rational extends Num {
       return factor.findGCD(this);
     }
   }
+
+  // for now, assuming that exp is a Num
   raiseToThe(exp) {
     if (exp instanceof Int) {
       var positive = exp.eval() > 0;
@@ -4520,11 +5401,13 @@ class Rational extends Num {
     return this;
   }
 }
+
+/* integer (n: numerator/number) */
 class Int extends Rational {
   constructor(number) {
     super(number, 1);
-    this.func = Int;
   }
+  func = Int;
   args() {
     return [this.n];
   }
@@ -4554,19 +5437,24 @@ class Int extends Rational {
     return new Int(n).addHint("entered");
   }
 }
+
+/* float (n: number) */
 class Float extends Num {
+  n;
   constructor(number) {
     super();
-    this.n = void 0;
-    this.func = Float;
     this.n = number;
   }
+  func = Float;
   args() {
     return [this.n];
   }
   eval() {
     return this.n;
   }
+
+  // TODO(alex): when we internationalize number parsing/display
+  // we should make sure to use the appropriate decimal mark here
   print() {
     return this.n.toString();
   }
@@ -4588,6 +5476,8 @@ class Float extends Num {
     }
   }
   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() {
@@ -4603,6 +5493,8 @@ class Float extends Num {
       return factor.findGCD(this);
     }
   }
+
+  // for now, assuming that exp is a Num
   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);
@@ -4610,6 +5502,8 @@ class Float extends Num {
       return new Float(new Pow(this, exp).eval()).collect();
     }
   }
+
+  // only to be used on non-repeating decimals (e.g. user-provided)
   asRational() {
     var parts = this.n.toString().split(".");
     if (parts.length === 1) {
@@ -4629,6 +5523,9 @@ class Float extends Num {
   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. +, *, ^)
   static toDecimalPlaces(n, places) {
     return new Float(+n.toFixed(Math.min(places, 20))).collect();
   }
@@ -4640,9 +5537,13 @@ 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) {
+var parseError = function (str, hash) {
+  // return int location of parsing error
   throw new Error(hash.loc.first_column);
 };
+
+// expose concrete nodes to parser scope
+// see http://zaach.github.io/jison/docs/#sharing-scope
 parser.yy = {
   Add: Add,
   Mul: Mul,
@@ -4659,22 +5560,28 @@ parser.yy = {
   parseError: parseError,
   constants: ["e"],
   symbolLexer: function (symbol) {
-    if (_.contains(parser.yy.constants, symbol)) {
+    if (___default.default.contains(parser.yy.constants, symbol)) {
       return "CONST";
-    } else if (_.contains(parser.yy.functions, symbol)) {
+    } else if (___default.default.contains(parser.yy.functions, symbol)) {
       return "FUNC";
     } else {
       return "VAR";
     }
   }
 };
-const parse = function parse(input, options) {
+const parse = function (input, options) {
   try {
     if (options && options.functions) {
-      parser.yy.functions = _.without(options.functions, "i");
+      // reserve the symbol "i" for complex numbers
+      parser.yy.functions = ___default.default.without(options.functions, "i");
     } else {
       parser.yy.functions = [];
     }
+
+    // If ',' is the decimal dividor in your country, replace any ','s
+    // with '.'s.
+    // This isn't perfect, since the output will all still have '.'s.
+    // TODO(jack): Fix the output to have ','s in this case
     if (options && options.decimal_separator) {
       input = input.split(options.decimal_separator).join(".");
     }
@@ -4690,20 +5597,29 @@ const parse = function parse(input, options) {
     };
   }
 };
+
+/* unit */
 class Unit extends Sym {
+  symbol;
   constructor(symbol) {
     super();
-    this.symbol = void 0;
-    this.func = Unit;
     this.symbol = symbol;
   }
+  func = Unit;
   args() {
     return [this.symbol];
   }
   recurse() {
     return this;
   }
-  eval(vars = {}, options) {
+  eval() {
+    // 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() {
@@ -4721,26 +5637,42 @@ class Unit extends Sym {
   tex() {
     return this.symbol;
   }
+
+  // Simplify units by replacing prefixes with multiplication
   collect(options) {
-    if (_(baseUnits).has(this.symbol)) {
+    if (___default.default(baseUnits).has(this.symbol)) {
       return this;
-    } else if (_(derivedUnits).has(this.symbol)) {
+    } else if (___default.default(derivedUnits).has(this.symbol)) {
       return derivedUnits[this.symbol].conversion;
     } else {
       throw new Error("could not understand unit: " + this.symbol);
     }
   }
 }
-var unprefixify = function unprefixify(symbol) {
-  if (_(baseUnits).has(symbol) || _(derivedUnits).has(symbol)) {
+
+// If possible, replace unit prefixes with a multiplication.
+//
+// "g" -> Unit("g")
+// "kg" -> 1000 * Unit("g")
+var unprefixify = function (symbol) {
+  if (___default.default(baseUnits).has(symbol) || ___default.default(derivedUnits).has(symbol)) {
     return new Unit(symbol);
   }
-  var prefix = _(_(siPrefixes).keys()).find(testPrefix => {
+
+  // check for prefix
+  var prefix = ___default.default(___default.default(siPrefixes).keys()).find(testPrefix => {
     return new RegExp("^" + testPrefix).test(symbol);
   });
   if (prefix) {
     var base = symbol.replace(new RegExp("^" + prefix), "");
-    if (_(baseUnits).has(base) || derivedUnits[base] && derivedUnits[base].prefixes === hasPrefixes) {
+
+    // It's okay to be here if either:
+    // * `base` is a base unit (the seven units listed in baseUnits)
+    // * `base` is a derived unit which allows prefixes
+    //
+    // Otherwise, we're trying to parse a unit label which is not
+    // allowed (mwk, mBTU, etc).
+    if (___default.default(baseUnits).has(base) || derivedUnits[base] && derivedUnits[base].prefixes === hasPrefixes) {
       return new Mul(siPrefixes[prefix], new Unit(base));
     } else {
       throw new Error(base + " does not allow prefixes");
@@ -4749,18 +5681,36 @@ var unprefixify = function unprefixify(symbol) {
     return new Unit(symbol);
   }
 };
-const unitParse = function unitParse(input) {
+const unitParse = function (input) {
   try {
     var parseResult = unitParser.parse(input);
+
+    // parseResult looks like:
+    // {
+    //   magnitude: "5",
+    //   unit: {
+    //     num: [
+    //       { name: "s", pow: 2 }
+    //     ],
+    //     denom: [
+    //       { name: "kg", pow: 1 }
+    //     ]
+    //   }
+    // }
+    //
+    // denom is optionally null
+
     const unitArray = [];
-    _(parseResult.unit.num).each(unitSpec => {
+    ___default.default(parseResult.unit.num).each(unitSpec => {
       unitArray.push(new Pow(unprefixify(unitSpec.name), new Int(unitSpec.pow)));
     });
-    _(parseResult.unit.denom).each(unitSpec => {
+    ___default.default(parseResult.unit.denom).each(unitSpec => {
       unitArray.push(new Pow(unprefixify(unitSpec.name), new Int(-1 * unitSpec.pow)));
     });
     var unit = new Mul(unitArray).flatten();
     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), ...unitArray];
       var expr = new Mul(coefArray);
       return {
@@ -4771,6 +5721,7 @@ const unitParse = function unitParse(input) {
         type: parseResult.type
       };
     } else {
+      // in the second case it's just the unit with no magnitude.
       return {
         parsed: true,
         unit: unit,
@@ -4786,6 +5737,7 @@ const unitParse = function unitParse(input) {
 };
 var baseUnits = {
   m: new Unit("m"),
+  // Note: kg is the SI base unit but we use g for consistency
   g: new Unit("g"),
   s: new Unit("s"),
   A: new Unit("A"),
@@ -4810,11 +5762,14 @@ var siPrefixes = {
   T: new Pow(new Int(10), new Int(12)),
   P: new Pow(new Int(10), new Int(15)),
   E: new Pow(new Int(10), new Int(18)),
+  // http://en.wikipedia.org/wiki/Metric_prefix#.22Hella.22_prefix_proposal
   hella: new Pow(new Int(10), new Int(27))
 };
+
+// Use these two values to mark a unit as either SI-prefixable or not.
 const hasPrefixes = "hasPrefixes";
 const hasntPrefixes = "hasntPrefixes";
-const makeAlias = function makeAlias(str, prefixes) {
+const makeAlias = function (str, prefixes) {
   var splits = str.split("|");
   var coefficientStr = splits[0].trim();
   var unitsStr = splits[1].trim();
@@ -4835,9 +5790,35 @@ const makeAlias = function makeAlias(str, prefixes) {
     prefixes: prefixes
   };
 };
+
+// This is a mapping of derived units (or different names for a unit) to their
+// definitions. For example, an inch is defined as 0.0254 m.
+//
+// Definitions don't need to be in terms of base units. For example, tsp is
+// defined in terms of tbsp (which is defined in terms of cup -> gal -> L ->
+// m^3). However, units must get simpler. I.e. there's no loop checking.
+//
+// makeAlias takes two parameters:
+// * a string specifying the simplification to perform
+//   - a required pipe separates the constant factor from the base units
+//   - the constant factor is parsed by KAS
+//   - the base units are in a simple format which disallows exponents and
+//     requires multiplicands to be space-separated ("m m" rather than "m^2)
+//     with an optional "/" separating numerator and denominator
+//   - prefixes are not allowed to be used in the converted to units
+//     (note that this restriction, the format of the string, and the choice to
+//     use a string in the first place are made out of laziness to minimize
+//     both typing and parsing)
+// * a boolean specifying whether or not it's acceptable to use SI units
+//
+// Where possible, these units are taken from "The International System of
+// Units (SI)" 8th edition (2006).
 var derivedUnits = {
+  // mass
+  // The atomic mass unit / dalton.
   Da: makeAlias("1.6605388628 x 10^-24 | g", hasPrefixes),
   u: makeAlias("| Da", hasntPrefixes),
+  // length
   meter: makeAlias("| m", hasntPrefixes),
   meters: makeAlias("| m", hasntPrefixes),
   in: makeAlias("254 / 10000 | m", hasntPrefixes),
@@ -4848,32 +5829,43 @@ var derivedUnits = {
   nmi: makeAlias("1852 | m", hasntPrefixes),
   Å: makeAlias("10^-10 | m", hasntPrefixes),
   pc: makeAlias("3.0857 x 10^16 | m", hasntPrefixes),
+  // time
   min: makeAlias("60 | s", hasntPrefixes),
   hr: makeAlias("3600 | s", hasntPrefixes),
   sec: makeAlias("| s", hasntPrefixes),
+  // TODO(joel) make day work
   day: makeAlias("86400 | s", hasntPrefixes),
   wk: makeAlias("604800 | s", hasntPrefixes),
   fortnight: makeAlias("14 | day", hasntPrefixes),
   shake: makeAlias("10^-8 | s", hasntPrefixes),
   olympiad: makeAlias("126200000 | s", hasntPrefixes),
+  // temperature
   "°C": makeAlias("1 | K", hasntPrefixes),
   "°F": makeAlias("5/9 | K", hasntPrefixes),
   "°R": makeAlias("5/9 | K", hasntPrefixes),
+  // electric charge
   e: makeAlias("1.6021765314 x 10^-19 | C", hasntPrefixes),
+  // speed
   c: makeAlias("299792458 | m / s", hasntPrefixes),
   kn: makeAlias("514/1000 | m / s", hasntPrefixes),
   kt: makeAlias("| kn", hasntPrefixes),
   knot: makeAlias("| kn", hasntPrefixes),
+  // energy
   J: makeAlias("| N m", hasPrefixes),
   BTU: makeAlias("1060 | J", hasntPrefixes),
   cal: makeAlias("4184 / 1000 | J", hasPrefixes),
   eV: makeAlias("1.602176514 x 10^-19 | J", hasPrefixes),
   erg: makeAlias("10^−7 | J", hasPrefixes),
+  // power
   W: makeAlias("| J / s", hasPrefixes),
   "H-e": makeAlias("80 | W", hasntPrefixes),
+  // force
   N: makeAlias("1000 | g m / s s", hasPrefixes),
+  // "lb": makeAlias("4448 / 1000 | N", hasntPrefixes),
+  // 4.4482216152605
   lb: makeAlias("4448221615 / 1000000000 | N", hasntPrefixes),
   dyn: makeAlias("10^-5 | N", hasntPrefixes),
+  // pressure
   Pa: makeAlias("1 | N / m m m", hasPrefixes),
   bar: makeAlias("10^5 | Pa", hasPrefixes),
   "㏔": makeAlias("1/1000 | bar", hasntPrefixes),
@@ -4881,6 +5873,7 @@ var derivedUnits = {
   atm: makeAlias("101325 | Pa", hasntPrefixes),
   Torr: makeAlias("1/760 | atm", hasntPrefixes),
   mmHg: makeAlias("| Torr", hasntPrefixes),
+  // area
   ha: makeAlias("10^4 | m m", hasntPrefixes),
   b: makeAlias("10^−28 | m m", hasPrefixes),
   barn: makeAlias("| b", hasPrefixes),
@@ -4888,6 +5881,7 @@ var derivedUnits = {
   skilodge: makeAlias("10^-31 | m m", hasntPrefixes),
   outhouse: makeAlias("10^-34 | m m", hasntPrefixes),
   shed: makeAlias("10^-52 | m m", hasntPrefixes),
+  // volume
   L: makeAlias("1/1000 | m m m", hasPrefixes),
   gal: makeAlias("3785/1000 | L", hasPrefixes),
   cup: makeAlias("1/16 | gal", hasntPrefixes),
@@ -4900,17 +5894,25 @@ var derivedUnits = {
   "fl. oz.": makeAlias("1/8 | cup", hasntPrefixes),
   tbsp: makeAlias("1/16 | cup", hasntPrefixes),
   tsp: makeAlias("1/3 | tbsp", hasntPrefixes),
+  // rotational
+  // "rad":
   rev: makeAlias("2 pi | rad", hasntPrefixes),
   deg: makeAlias("180 pi | rad", hasntPrefixes),
   "°": makeAlias("| deg", hasntPrefixes),
   arcminute: makeAlias("1/60 | deg", hasntPrefixes),
   arcsec: makeAlias("1/3600 | deg", hasntPrefixes),
+  // dimensionless
+  // "B": makeAlias("10 | dB", hasntPrefixes), // XXX danger - logarithmic
+  // "dB"
+  // "nP"
   Hu: makeAlias("1000 | dB", hasPrefixes),
   dozen: makeAlias("12 |", hasntPrefixes),
+  // XXX
   mol: makeAlias("6.0221412927 x 10^23 |", hasPrefixes),
   "%": makeAlias("1/100 |", hasntPrefixes),
   percent: makeAlias("| %", hasntPrefixes),
   ppm: makeAlias("1/1000000 |", hasntPrefixes),
+  // electric / magnetic
   V: makeAlias("1000 | g m m / s s C", hasPrefixes),
   C: makeAlias("| A s", hasPrefixes),
   ampere: makeAlias("| A", hasntPrefixes),
@@ -4920,6 +5922,8 @@ var derivedUnits = {
   H: makeAlias("| ohm s", hasPrefixes),
   T: makeAlias("1000 | g / C s", hasPrefixes),
   Wb: makeAlias("1000 | g m m / C s", hasPrefixes),
+  // photometry
+  // TODO not sure this is right
   lm: makeAlias("pi x 10^4 | cd / m m", hasntPrefixes),
   lx: makeAlias("| lm / m m", hasntPrefixes),
   nit: makeAlias("| cd / m m", hasntPrefixes),
@@ -4933,17 +5937,38 @@ var derivedUnits = {
   sk: makeAlias("10^-7 | lm", hasntPrefixes),
   skot: makeAlias("| sk", hasntPrefixes),
   bril: makeAlias("10^-11 | lm", hasntPrefixes),
+  // other
   Hz: makeAlias("| / s", hasPrefixes)
 };
 const Zero = NumZero;
 const One = NumOne;
 
-const compare = function compare(expr1, expr2, options = {}) {
+/**
+ * Compares two expressions for equality.
+ *
+ * Assumes that both expressions have already been parsed.
+ */
+// TODO(alex): be able to pass a random() function to compare()
+const compare = function (expr1, expr2) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   const defaults = {
     form: false,
     simplify: false
   };
-  const optionsWithDefaults = _extends({}, defaults, options);
+
+  /* Options that could be added in the future:
+   * - Allow ratios: e.g. 3/1 and 3 should both be accepted for something
+   *   like slope
+   * - Allow student to choose their own variable names
+   */
+  const optionsWithDefaults = {
+    ...defaults,
+    ...options
+  };
+
+  // TODO(CP-1614): Figure out how to make these messages translatable
+
+  // Variable check
   const vars = expr1.sameVars(expr2);
   if (!vars.equal) {
     let message;
@@ -4959,18 +5984,24 @@ const compare = function compare(expr1, expr2, options = {}) {
       message: message
     };
   }
+
+  // Semantic check
   if (!expr1.compare(expr2)) {
     return {
       equal: false,
       message: null
     };
   }
+
+  // Syntactic check
   if (optionsWithDefaults.form && !expr1.sameForm(expr2)) {
     return {
       equal: false,
       message: "Your answer is not in the correct form."
     };
   }
+
+  // Syntactic check
   if (optionsWithDefaults.simplify && !expr1.isSimplified()) {
     return {
       equal: false,
@@ -4983,5 +6014,24 @@ const compare = function compare(expr1, expr2, options = {}) {
   };
 };
 
-export { Abs, Add, Const, Eq, Float, Func, Int, Log, Mul, One, Pow, Rational, Trig, Unit, Var, Zero, compare, libVersion, parse, unitParse };
+exports.Abs = Abs;
+exports.Add = Add;
+exports.Const = Const;
+exports.Eq = Eq;
+exports.Float = Float;
+exports.Func = Func;
+exports.Int = Int;
+exports.Log = Log;
+exports.Mul = Mul;
+exports.One = One;
+exports.Pow = Pow;
+exports.Rational = Rational;
+exports.Trig = Trig;
+exports.Unit = Unit;
+exports.Var = Var;
+exports.Zero = Zero;
+exports.compare = compare;
+exports.libVersion = libVersion;
+exports.parse = parse;
+exports.unitParse = unitParse;
 //# sourceMappingURL=index.js.map