@khanacademy/kas 0.5.1 → 1.0.0

package/dist/index.js

@@ -1,98 +1,15 @@
-'use strict';
+import { addLibraryVersionToPerseusDebug } from '@khanacademy/perseus-utils';
+import _extends from '@babel/runtime/helpers/extends';
+import _ from 'underscore';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var perseusUtils = require('@khanacademy/perseus-utils');
-var _ = require('underscore');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
-
-// This file is processed by a Rollup plugin (replace) to inject the production
 const libName = "@khanacademy/kas";
-const libVersion = "0.5.1";
-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)
-  }
-
+const libVersion = "1.0.0";
+addLibraryVersionToPerseusDebug(libName, libVersion);
 
-  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 (k, v, o, l) {
-      for (o = o || {}, l = k.length; l--; o[k[l]] = v);
-      return o;
+  var o = function o(k, v, _o, l) {
+      for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v);
+      return _o;
     },
     $V0 = [1, 11],
     $V1 = [1, 9],
@@ -138,9 +55,7 @@ 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 /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
-      /* this == yyval */
-
+    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
       var $0 = $$.length - 1;
       switch (yystate) {
         case 1:
@@ -325,7 +240,6 @@ var parser$1 = function () {
       } else {
         this.parseError = Object.getPrototypeOf(this).parseError;
       }
-      //_token_stack:
       function lex() {
         var token;
         token = lexer.lex() || EOF;
@@ -425,7 +339,6 @@ var parser$1 = function () {
       return true;
     }
   };
-  /* generated by jison-lex 0.3.4 */
   var lexer = function () {
     var lexer = {
       EOF: 1,
@@ -436,7 +349,6 @@ 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;
@@ -456,7 +368,6 @@ 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;
@@ -477,13 +388,11 @@ 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);
@@ -504,12 +413,10 @@ 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;
@@ -522,16 +429,13 @@ 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) {
@@ -539,17 +443,14 @@ 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: {
@@ -602,15 +503,13 @@ 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; // rule action called reject() implying the next rule should be tested instead.
+          return false;
         }
         return false;
       },
-      // return next match in input
       next: function () {
         if (this.done) {
           return this.EOF;
@@ -635,9 +534,8 @@ var parser$1 = function () {
                 return token;
               } else if (this._backtrack) {
                 match = false;
-                continue; // rule action called reject() implying a rule MISmatch.
+                continue;
               } else {
-                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                 return false;
               }
             } else if (!this.options.flex) {
@@ -650,7 +548,6 @@ 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 === "") {
@@ -663,7 +560,6 @@ var parser$1 = function () {
           });
         }
       },
-      // return next match that has a token
       lex: function lex() {
         var r = this.next();
         if (r) {
@@ -672,11 +568,9 @@ 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) {
@@ -685,7 +579,6 @@ 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;
@@ -693,7 +586,6 @@ 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) {
@@ -702,11 +594,9 @@ 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;
       },
@@ -738,7 +628,6 @@ var parser$1 = function () {
           case 11:
             return 17;
           case 12:
-            /* skip whitespace */
             break;
           case 13:
             return 6;
@@ -764,85 +653,10 @@ 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 (k, v, o, l) {
-      for (o = o || {}, l = k.length; l--; o[k[l]] = v);
-      return o;
+  var o = function o(k, v, _o, l) {
+      for (_o = _o || {}, l = k.length; l--; _o[k[l]] = v);
+      return _o;
     },
     $V0 = [1, 7],
     $V1 = [1, 17],
@@ -954,9 +768,7 @@ 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 /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
-      /* this == yyval */
-
+    performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {
       var $0 = $$.length - 1;
       switch (yystate) {
         case 1:
@@ -2002,7 +1814,6 @@ var parser = function () {
       } else {
         this.parseError = Object.getPrototypeOf(this).parseError;
       }
-      //_token_stack:
       function lex() {
         var token;
         token = lexer.lex() || EOF;
@@ -2102,7 +1913,6 @@ var parser = function () {
       return true;
     }
   };
-  /* generated by jison-lex 0.3.4 */
   var lexer = function () {
     var lexer = {
       EOF: 1,
@@ -2113,7 +1923,6 @@ 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;
@@ -2133,7 +1942,6 @@ 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;
@@ -2154,13 +1962,11 @@ 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);
@@ -2181,12 +1987,10 @@ 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;
@@ -2199,16 +2003,13 @@ 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) {
@@ -2216,17 +2017,14 @@ 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: {
@@ -2279,15 +2077,13 @@ var parser = function () {
         if (token) {
           return token;
         } else if (this._backtrack) {
-          // recover context
           for (var k in backup) {
             this[k] = backup[k];
           }
-          return false; // rule action called reject() implying the next rule should be tested instead.
+          return false;
         }
         return false;
       },
-      // return next match in input
       next: function () {
         if (this.done) {
           return this.EOF;
@@ -2312,9 +2108,8 @@ var parser = function () {
                 return token;
               } else if (this._backtrack) {
                 match = false;
-                continue; // rule action called reject() implying a rule MISmatch.
+                continue;
               } else {
-                // else: this is a lexer rule which consumes input without producing a token (e.g. whitespace)
                 return false;
               }
             } else if (!this.options.flex) {
@@ -2327,7 +2122,6 @@ 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 === "") {
@@ -2340,7 +2134,6 @@ var parser = function () {
           });
         }
       },
-      // return next match that has a token
       lex: function lex() {
         var r = this.next();
         if (r) {
@@ -2349,11 +2142,9 @@ 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) {
@@ -2362,7 +2153,6 @@ 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;
@@ -2370,7 +2160,6 @@ 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) {
@@ -2379,11 +2168,9 @@ 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;
       },
@@ -2393,13 +2180,10 @@ 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";
@@ -2621,62 +2405,20 @@ var parser = function () {
   return new Parser();
 }();
 
-/* eslint-disable prettier/prettier */
-
-/*  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) {
+var _class5, _class12;
+const isNaN = function isNaN(object) {
   return object !== object;
 };
-
-// return a random float between min (inclusive) and max (exclusive),
-// not that inclusivity means much, probabilistically, on floats
-const randomFloat = function (min, max) {
+const randomFloat = function randomFloat(min, max) {
   var extent = max - min;
   return Math.random() * extent + min;
 };
-
-/* constants */
 var ITERATIONS = 12;
-var TOLERANCE = 9; // decimal places
-
-// NOTE(kevinb): _.partition exists in a more recent version of underscore.
-// To avoid having to update underscore I've added a hacky version of this
-// method here.
+var TOLERANCE = 9;
 function partition(list, iteratee) {
   const a = [];
   const b = [];
-  ___default["default"].forEach(list, (elem, key, ctx) => {
+  _.forEach(list, (elem, key, ctx) => {
     if (iteratee(elem, key, ctx)) {
       a.push(elem);
     } else {
@@ -2688,7 +2430,7 @@ function partition(list, iteratee) {
 function isExpr(arg) {
   return arg instanceof Expr;
 }
-const isAdd = function (term) {
+const isAdd = function isAdd(term) {
   return term instanceof Add;
 };
 function isRational(arg) {
@@ -2701,23 +2443,13 @@ 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);
@@ -2726,59 +2458,29 @@ class Expr {
     }
     return instance;
   }
-
-  // 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];
-    }
+  recurse(method, ...passed) {
     var args = this.args().map(function (arg) {
-      return ___default["default"].isString(arg) || ___default["default"].isNumber(arg) ? arg : arg?.[method].apply(arg, passed);
+      return _.isString(arg) || _.isNumber(arg) ? arg : arg == null ? void 0 : arg[method].apply(arg, passed);
     });
     return this.construct(args);
   }
-
-  // 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());
+  eval(vars = {}, options) {
+    throw new Error("Abstract method - must override for expr: " + this.print());
   }
-
-  // NOTE(kevin): This could made into an abstract method but
-  // Eq doesn't implement it.  This indicates that we probably
-  // need to introduce another class in our hierarchy.
   codegen() {
-    throw new Error("Abstract method - must override for expr: " +
-    // eslint-disable-next-line @babel/no-invalid-this
-    this.print());
+    throw new Error("Abstract method - must override for expr: " + 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 {
+    } catch (_unused) {
       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 || {};
-    ___default["default"].defaults(options, {
+    _.defaults(options, {
       display: true,
       dynamic: true,
       times: false
@@ -2796,76 +2498,46 @@ 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 ___default["default"].isString(arg) || ___default["default"].isNumber(arg) ? arg : arg?.repr();
+      return _.isString(arg) || _.isNumber(arg) ? arg : arg == null ? void 0 : 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 = {
-      once: false,
-      ...options
-    };
-
-    // Attempt to factor and collect
+    options = _extends({
+      once: false
+    }, options);
     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;
@@ -2873,52 +2545,35 @@ 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 ___default["default"].uniq(___default["default"].flatten(___default["default"].invoke(this.exprArgs(), "getVars", excludeFunc))).sort();
+    return _.uniq(_.flatten(_.invoke(this.exprArgs(), "getVars", excludeFunc))).sort();
   }
   getConsts() {
-    return ___default["default"].uniq(___default["default"].flatten(___default["default"].invoke(this.exprArgs(), "getConsts"))).sort();
+    return _.uniq(_.flatten(_.invoke(this.exprArgs(), "getConsts"))).sort();
   }
   getUnits() {
-    return ___default["default"].flatten(___default["default"].invoke(this.exprArgs(), "getUnits"));
+    return _.flatten(_.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 ___default["default"].any(this.exprArgs(), function (arg) {
+    return _.any(this.exprArgs(), function (arg) {
       return arg.has(func);
     });
   }
-
-  // raise this expression to a given exponent
-  // most useful for eventually implementing i^3 = -i, etc.
   raiseToThe(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;
   }
@@ -2928,24 +2583,17 @@ 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();
-
-    // the other Expr can have more variables than this one
-    // this lets you multiply equations by other variables
-    var same = function (array1, array2) {
-      return !___default["default"].difference(array1, array2).length;
+    var same = function same(array1, array2) {
+      return !_.difference(array1, array2).length;
     };
-    var lower = function (array) {
-      return ___default["default"].uniq(___default["default"].invoke(array, "toLowerCase")).sort();
+    var lower = function lower(array) {
+      return _.uniq(_.invoke(array, "toLowerCase")).sort();
     };
     var equal = same(vars1, vars2);
     var equalIgnoringCase = same(lower(vars1), lower(vars2));
@@ -2954,85 +2602,39 @@ 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 = ___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) {
+    var varList = _.union(this.getVars(true), other.getVars(true));
+    var getDelta = function getDelta(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 (num1, num2) {
+    var equalNumbers = function equalNumbers(num1, num2) {
       var delta = getDelta(num1, num2);
-      return num1 === num2 /* needed if either is +/- Infinity */ || isNaN(num1) && isNaN(num2) || delta < Math.pow(10, -TOLERANCE);
+      return num1 === num2 || isNaN(num1) && isNaN(num2) || delta < Math.pow(10, -9);
     };
-
-    // 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));
+    const varAndFuncList = _.union(this.getVars(false), other.getVars(false));
     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 (!___default["default"].isEqual(unitList1, unitList2)) {
+    if (!_.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;
-      ___default["default"].each(varList, function (v) {
-        vars[v] = useFloats ? randomFloat(-range, range) : ___default["default"].random(-range, range);
+      _.each(varList, function (v) {
+        vars[v] = useFloats ? randomFloat(-range, range) : _.random(-range, range);
       });
       let equal;
       if (expr1.has(Func) || expr2.has(Func) || expr1.has(Unit) || expr2.has(Unit)) {
@@ -3050,8 +2652,6 @@ class Expr {
     }
     return true;
   }
-
-  // evaluate as much of the expression as possible
   partialEval(vars) {
     if (this instanceof Unit) {
       return this;
@@ -3063,86 +2663,50 @@ 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: " +
-    // eslint-disable-next-line @babel/no-invalid-this
-    this.print());
+    throw new Error("Abstract method - must override for expr: " + 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 = ___default["default"].clone(this.hints);
+    expr.hints = _.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: " +
-    // eslint-disable-next-line @babel/no-invalid-this
-    this.print());
+    throw new Error("Abstract method - must override for expr: " + this.print());
   }
   negate() {
     return new Mul(NumNeg, this);
   }
 }
-
-/* abstract sequence node */
 class Seq extends Expr {
-  // 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() {
+  constructor(...args) {
     super();
-    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-      args[_key2] = arguments[_key2];
-    }
+    this.terms = void 0;
     if (args.length === 1) {
       this.terms = args[0];
     } else {
@@ -3153,7 +2717,7 @@ class Seq extends Expr {
     return this.terms;
   }
   normalize() {
-    var terms = ___default["default"].sortBy(___default["default"].invoke(this.terms, "normalize"), term => {
+    var terms = _.sortBy(_.invoke(this.terms, "normalize"), term => {
       return term.print();
     });
     return new this.func(terms);
@@ -3161,54 +2725,35 @@ 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 = ___default["default"].reject(this.terms, term => {
-      // @ts-expect-error: `identity` is defined on Add and Mul but doesn't
-      // exist on Seq itself.
+    var terms = _.reject(this.terms, term => {
       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(___default["default"].flatten(___default["default"].pluck(same, "terms"), /* shallow: */true));
+    var flattened = others.concat(_.flatten(_.pluck(same, "terms"), true));
     return new type.func(flattened);
   }
-
-  // reduce a numeric sequence to a Num
-
   isPositive() {
-    var terms = ___default["default"].invoke(this.terms, "collect");
-    return ___default["default"].all(___default["default"].invoke(terms, "isPositive"));
+    var terms = _.invoke(this.terms, "collect");
+    return _.all(_.invoke(terms, "isPositive"));
   }
-
-  // return a new Seq with a given term replaced by a different term
-  // (or array of terms). given term can be passed directly, or by index
-  // if no new term is provided, the old one is simply removed
   replace(oldTerm, newTerm) {
-    const index = oldTerm instanceof Expr ? ___default["default"].indexOf(this.terms, oldTerm) : oldTerm;
+    const index = oldTerm instanceof Expr ? _.indexOf(this.terms, oldTerm) : oldTerm;
     var newTerms = [];
     if (Array.isArray(newTerm)) {
       newTerms = newTerm;
@@ -3218,39 +2763,35 @@ 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() {
-    // TODO(alex): find and return LCM
-    return new Mul(___default["default"].invoke(this.terms, "getDenominator")).flatten();
+    return new Mul(_.invoke(this.terms, "getDenominator")).flatten();
   }
 }
-
-/* sequence of additive terms */
 class Add extends Seq {
-  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) => {
+  constructor(...args) {
+    super(...args);
+    this.identity = NumZero;
+    this.func = Add;
+  }
+  eval(vars = {}, options) {
+    return _.reduce(this.terms, (memo, term) => {
       return memo + term.eval(vars, options);
     }, 0);
   }
   codegen() {
-    return ___default["default"].map(this.terms, term => {
+    return _.map(this.terms, term => {
       return "(" + term.codegen() + ")";
     }).join(" + ") || "0";
   }
   print() {
-    return ___default["default"].invoke(this.terms, "print").join("+");
+    return _.invoke(this.terms, "print").join("+");
   }
   tex() {
     let tex = "";
-    ___default["default"].each(this.terms, term => {
+    _.each(this.terms, term => {
       if (!tex || term.isSubtract()) {
         tex += term.tex();
       } else {
@@ -3260,9 +2801,9 @@ class Add extends Seq {
     return tex;
   }
   collect(options) {
-    var terms = ___default["default"].invoke(this.terms, "collect", options);
+    var terms = _.invoke(this.terms, "collect", options);
     var pairs = [];
-    ___default["default"].each(terms, term => {
+    _.each(terms, term => {
       if (term instanceof Mul) {
         var muls = term.partition();
         pairs.push([muls[1].flatten(), muls[0].reduce(options)]);
@@ -3272,30 +2813,20 @@ class Add extends Seq {
         pairs.push([term, NumOne]);
       }
     });
-
-    // { (Expr expr).print(): [[Expr expr, Num coefficient]] }
-    var grouped = ___default["default"].groupBy(pairs, pair => {
+    var grouped = _.groupBy(pairs, pair => {
       return pair[0].normalize().print();
     });
-    var collected = ___default["default"].compact(___default["default"].map(grouped, pairs => {
+    var collected = _.compact(_.map(grouped, pairs => {
       var expr = pairs[0][0];
-      var sum = new Add(___default["default"].zip.apply(___default["default"], pairs)[1]);
+      var sum = new Add(_.zip.apply(_, 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();
   }
-
-  // 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
-    };
+  factor(options = {
+    keepNegative: false
+  }) {
     const terms = this.terms.map(term => term.collect());
     let factors;
     if (terms[0] instanceof Mul) {
@@ -3303,8 +2834,8 @@ class Add extends Seq {
     } else {
       factors = [terms[0]];
     }
-    ___default["default"].each(___default["default"].rest(this.terms), term => {
-      factors = ___default["default"].map(factors, factor => {
+    _.each(_.rest(this.terms), term => {
+      factors = _.map(factors, factor => {
         return term.findGCD(factor);
       });
     });
@@ -3317,9 +2848,7 @@ class Add extends Seq {
     return Mul.createOrAppend(left, right).flatten();
   }
   reduce(options) {
-    return ___default["default"].reduce(this.terms,
-    // @ts-expect-error: Type 'Expr' is not assignable to type 'Num'.
-    (memo, term) => {
+    return _.reduce(this.terms, (memo, term) => {
       return memo.add(term, options);
     }, this.identity);
   }
@@ -3327,14 +2856,12 @@ class Add extends Seq {
     return false;
   }
   isNegative() {
-    var terms = ___default["default"].invoke(this.terms, "collect");
-    return ___default["default"].all(___default["default"].invoke(terms, "isNegative"));
+    var terms = _.invoke(this.terms, "collect");
+    return _.all(_.invoke(terms, "isNegative"));
   }
   negate() {
-    return new Add(___default["default"].invoke(this.terms, "negate"));
+    return new Add(_.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));
@@ -3343,41 +2870,37 @@ class Add extends Seq {
     }
   }
 }
-
-/* sequence of multiplicative terms */
 class Mul extends Seq {
-  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) => {
+  constructor(...args) {
+    super(...args);
+    this.identity = NumOne;
+    this.func = Mul;
+  }
+  eval(vars = {}, options) {
+    return _.reduce(this.terms, (memo, term) => {
       return memo * term.eval(vars, options);
     }, 1);
   }
   codegen() {
-    return ___default["default"].map(this.terms, term => {
+    return _.map(this.terms, term => {
       return "(" + term.codegen() + ")";
     }).join(" * ") || "0";
   }
   print() {
-    return ___default["default"].map(this.terms, term => {
+    return _.map(this.terms, term => {
       return term instanceof Add ? "(" + term.print() + ")" : term.print();
     }).join("*");
   }
   getUnits() {
-    var tmUnits = ___default["default"](this.terms).chain().map(term => {
+    var tmUnits = _(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 = ___default["default"].groupBy(this.terms, term => {
+    var terms = _.groupBy(this.terms, term => {
       if (term.isDivide()) {
         return "inverse";
       } else if (term instanceof Num) {
@@ -3391,10 +2914,6 @@ class Mul extends Seq {
     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) {
@@ -3404,45 +2923,37 @@ class Mul extends Seq {
         return numbers[i].tex() + new Mul(newTerms).tex();
       }
     }
-    numbers = ___default["default"].compact(___default["default"].map(numbers, term => {
+    numbers = _.compact(_.map(numbers, term => {
       var shouldPushDown = !term.hints.fraction || inverses.length > 0;
       if (term instanceof Rational && !(term instanceof Int) && shouldPushDown) {
-        // e.g. 3x/4 -> 3/4*x (internally) -> 3x/4 (rendered)
         inverses.push(new Pow(new Int(term.d), NumDiv));
         var number = new Int(term.n);
         number.hints = term.hints;
-        return ___default["default"].any(term.hints) ? number : null;
+        return _.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 = "";
-      ___default["default"].each(numbers, term => {
+      _.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();
         }
       });
-      ___default["default"].each(others, term => {
+      _.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();
         }
       });
@@ -3451,53 +2962,45 @@ class Mul extends Seq {
     if (!inverses.length) {
       return negatives + numerator;
     } else {
-      var denominator = new Mul(___default["default"].invoke(inverses, "asDivide")).flatten().tex();
+      var denominator = new Mul(_.invoke(inverses, "asDivide")).flatten().tex();
       return negatives + "\\frac{" + numerator + "}{" + denominator + "}";
     }
   }
   strip() {
-    var terms = ___default["default"].map(this.terms, term => {
+    var terms = _.map(this.terms, term => {
       return term instanceof Num ? term.abs() : term.strip();
     });
     return new Mul(terms).flatten();
   }
-
-  // expand numerator and denominator separately
   expand() {
-    const isInverse = function (term) {
+    const isInverse = function isInverse(term) {
       return term instanceof Pow && term.exp.isNegative();
     };
-    const isInverseAdd = function (term) {
+    const isInverseAdd = function isInverseAdd(term) {
       return isInverse(term) && isAdd(term.base);
     };
     const mul = this.recurse("expand").flatten();
     const factors = getFactors(mul);
-    const hasAdd = ___default["default"].any(factors, isAdd);
-    const hasInverseAdd = ___default["default"].any(factors, isInverseAdd);
+    const hasAdd = _.any(factors, isAdd);
+    const hasInverseAdd = _.any(factors, isInverseAdd);
     if (!(hasAdd || hasInverseAdd)) {
       return mul;
     }
     let [inverses, normals] = partition(factors, isInverse);
     if (hasAdd) {
       const [adds, others] = partition(normals, isAdd);
-
-      // 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 expanded = _.reduce(adds, function (expanded, add) {
+        return _.reduce(expanded, function (temp, array) {
+          return temp.concat(_.map(add.terms, term => array.concat(term)));
         }, []);
       }, [[]]);
-
-      // join each fully expanded array of factors with remaining multiplicative factors
-      const muls = ___default["default"].map(expanded, function (array) {
+      const muls = _.map(expanded, function (array) {
         return new Mul(others.concat(array)).flatten();
       });
       normals = [new Add(muls)];
     }
     if (hasInverseAdd) {
-      const denominator = new Mul(___default["default"].invoke(inverses, "getDenominator")).flatten();
+      const denominator = new Mul(_.invoke(inverses, "getDenominator")).flatten();
       inverses = [new Pow(denominator.expand(), NumDiv)];
     }
     return new Mul(normals.concat(inverses)).flatten();
@@ -3507,16 +3010,10 @@ 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;
     });
-
-    // Could also accomplish this by passing a new option
-    // e.g. return  memo.mul(term, {autocollect: false});
-    // TODO(alex): Decide whether this is a good use of options or not
-    const ratObj = ___default["default"].reduce(rationals, (memo, term) => {
+    const ratObj = _.reduce(rationals, (memo, term) => {
       return {
         n: memo.n * term.n,
         d: memo.d * term.d
@@ -3531,35 +3028,28 @@ 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 = [];
-    ___default["default"].each(others, term => {
+    _.each(others, term => {
       if (term instanceof Pow) {
         pairs.push([term.base, term.exp]);
       } else {
         pairs.push([term, NumOne]);
       }
     });
-
-    // {(Expr base).print(): [[Expr base, Expr exp]]}
-    var grouped = ___default["default"].groupBy(pairs, pair => {
+    var grouped = _.groupBy(pairs, pair => {
       return pair[0].normalize().print();
     });
-    var summed = ___default["default"].compact(___default["default"].map(grouped, pairs => {
+    var summed = _.compact(_.map(grouped, pairs => {
       var base = pairs[0][0];
-      var sum = new Add(___default["default"].zip.apply(___default["default"], pairs)[1]);
+      var sum = new Add(_.zip.apply(_, pairs)[1]);
       var exp = sum.collect(options);
       if (exp instanceof Num && exp.eval() === 0) {
         return null;
@@ -3567,9 +3057,7 @@ class Mul extends Seq {
         return [base, exp];
       }
     }));
-
-    // XXX `pairs` is shadowed four or five times in this function
-    const groupedPairs = ___default["default"].groupBy(summed, pair => {
+    const groupedPairs = _.groupBy(summed, pair => {
       if (pair[0] instanceof Trig && pair[0].isBasic()) {
         return "trig";
       } else if (pair[0] instanceof Log) {
@@ -3582,26 +3070,20 @@ class Mul extends Seq {
     let logs = groupedPairs.log || [];
     const exprs = groupedPairs.expr || [];
     if (trigs.length > 1) {
-      // combine sines and cosines into other trig functions
-
-      // {Trig.arg.print(): [[Trig base, Expr exp]]}
-      var byArg = ___default["default"].groupBy(trigs, pair => {
+      var byArg = _.groupBy(trigs, pair => {
         return pair[0].arg.normalize().print();
       });
       trigs = [];
-      ___default["default"].each(byArg, pairs => {
+      _.each(byArg, pairs => {
         const arg = pairs[0][0].arg;
-
-        // {Trig.type: Expr exp}
         let funcs = {
           sin: NumZero,
           cos: NumZero
         };
-        ___default["default"].each(pairs, pair => {
+        _.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
@@ -3612,30 +3094,18 @@ class Mul extends Seq {
             };
           }
         }
-
-        // TODO(alex): combine even if exponents not a perfect match
-        // TODO(alex): transform 1/sin and 1/cos into csc and sec
-
-        ___default["default"].each(funcs, (exp, type) => {
+        _.each(funcs, (exp, type) => {
           trigs.push([new Trig(type, arg), exp]);
         });
       });
     }
     if (logs.length > 1) {
-      // combine logs with the same base
-
-      // {Log.base.print(): [[Log base, Expr exp]]}
-      var byBase = ___default["default"].groupBy(logs, pair => {
+      var byBase = _.groupBy(logs, pair => {
         return pair[0].base.normalize().print();
       });
       logs = [];
-      ___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)
+      _.each(byBase, pairs => {
         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 {
@@ -3645,45 +3115,32 @@ 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 = ___default["default"].map([...trigs, ...logs, ...exprs], pair => {
+    var collected = _.map([...trigs, ...logs, ...exprs], pair => {
       return new Pow(pair[0], pair[1]).collect(options);
     });
     return new Mul([number].concat(collected)).flatten();
   }
   isSubtract() {
-    return ___default["default"].any(this.terms, term => {
+    return _.any(this.terms, term => {
       return term instanceof Num && Boolean(term.hints.subtract);
     });
   }
-
-  // factor a single -1 in to the Mul
-  // combine with a Num if all Nums are positive, else add as a term
   factorIn(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 && ___default["default"].all(numbers, num => num.n > 0);
+    var fold = numbers.length && _.all(numbers, num => num.n > 0);
     if (fold) {
-      // e.g. - x*2*3 -> x*-2*3
       var num = numbers[0].negate();
       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 = ___default["default"].compact(___default["default"].map(this.terms, term => {
+    var terms = _.compact(_.map(this.terms, term => {
       if (!factored && term instanceof Num && term.hints.divide) {
         factored = true;
         return term.n !== -1 ? term.negate() : null;
@@ -3698,14 +3155,12 @@ class Mul extends Seq {
     }
   }
   reduce(options) {
-    return ___default["default"].reduce(this.terms,
-    // @ts-expect-error: Type 'Expr' is not assignable to type 'Num'.
-    (memo, term) => {
+    return _.reduce(this.terms, (memo, term) => {
       return memo.mul(term, options);
     }, this.identity);
   }
   findGCD(factor) {
-    return new Mul(___default["default"].invoke(this.terms, "findGCD", factor)).flatten();
+    return new Mul(_.invoke(this.terms, "findGCD", factor)).flatten();
   }
   asMul() {
     return this;
@@ -3720,7 +3175,7 @@ class Mul extends Seq {
   }
   isNegative() {
     const terms = getFactors(this.collect()).map(factor => factor.isNegative());
-    return ___default["default"].any(terms);
+    return _.any(terms);
   }
   fold() {
     return Mul.fold(this);
@@ -3729,42 +3184,28 @@ class Mul extends Seq {
     var isNum = expr => {
       return expr instanceof Num;
     };
-    const num = ___default["default"].find(this.terms, isNum);
+    const num = _.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(___default["default"].rest(right.terms)).flatten();
+      var rest = new Mul(_.rest(right.terms)).flatten();
       return Mul.handleDivide(first, rest);
     }
     var isInt = expr => {
@@ -3773,11 +3214,7 @@ class Mul extends Seq {
     var isRational = expr => {
       return expr instanceof Rational;
     };
-
-    // 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
+    if (isInt(right) && left instanceof Mul && _.any(left.terms, isInt)) {
       var reversed = left.terms.slice().reverse();
       var num = reversed.find(isRational);
       if (!isInt(num)) {
@@ -3785,9 +3222,6 @@ 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");
       }
@@ -3802,17 +3236,11 @@ 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")];
@@ -3823,66 +3251,42 @@ 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) {
-      // NOTE(kevinb): `terms` should always have at least two
-      // elements so getting the last element is safe to do.
-      var divided = divide(___default["default"].last(left.terms), right);
-      return new Mul(___default["default"].initial(left.terms).concat(divided));
+      var divided = divide(_.last(left.terms), right);
+      return new Mul(_.initial(left.terms).concat(divided));
     } else {
       var divided = divide(left, right);
       return new Mul(divided).flatten();
     }
   }
-
-  // fold negative signs into numbers if possible
-  // negative signs are not the same as multiplying by negative one!
-  // e.g. -x      ->  -1*x    simplified
-  // 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) {
-      // assuming that this will be second to last
-      var trigLog = ___default["default"].find(___default["default"].initial(expr.terms), term => {
+      var trigLog = _.find(_.initial(expr.terms), term => {
         return (term instanceof Trig || term instanceof Log) && Boolean(term.hints.open);
       });
       if (trigLog) {
-        // expr.terms should always have at least two terms
-        const last = ___default["default"].last(expr.terms);
+        const last = _.last(expr.terms);
         if (trigLog.hints.parens || last.hints.parens || last.has(Trig) || last.has(Log)) {
           trigLog.hints.open = false;
         } else {
           const newTrigLog = trigLog instanceof Trig ? Trig.create([trigLog.type, trigLog.exp], Mul.createOrAppend(trigLog.arg, last).fold()) : Log.create(trigLog.base, Mul.createOrAppend(trigLog.power, last).fold());
-          const index = ___default["default"].indexOf(expr.terms, trigLog);
+          const index = _.indexOf(expr.terms, trigLog);
           if (index === 0) {
             return newTrigLog;
           } else {
@@ -3898,32 +3302,21 @@ class Mul extends Seq {
       var neg = num => {
         return num.n === -1 && Boolean(num.hints.negate);
       };
-      var posOrNeg = function (num) {
+      var posOrNeg = function posOrNeg(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 &&
-      // @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 (numbers.length > 1 && negNum && posNum && _.every(numbers, posOrNeg)) {
+        var firstNeg = _.indexOf(expr.terms, negNum);
+        var firstNum = _.indexOf(expr.terms, posNum);
         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));
@@ -3932,39 +3325,23 @@ 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() {
-    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let options = arguments.length > 1 ? arguments[1] : undefined;
+  eval(vars = {}, options) {
     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;
@@ -3987,7 +3364,6 @@ 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
       };
     });
@@ -4004,31 +3380,24 @@ 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() + "}";
@@ -4040,43 +3409,30 @@ class Pow extends Expr {
   expand() {
     var pow = this.recurse("expand");
     if (pow.base instanceof Mul) {
-      // e.g. (ab)^c -> a^c*b^c
-
-      var terms = ___default["default"].map(pow.base.terms, term => {
+      var terms = _.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 (mul) {
+      var signed = function signed(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]);
       }
-
-      // otherwise decompose n into powers of 2 ...
-      let indices = ___default["default"].map(n.toString(2).split(""), function (str, i, list) {
+      let indices = _.map(n.toString(2).split(""), function (str, i, list) {
         return Number(str) * Math.pow(2, list.length - i - 1);
       });
-      indices = ___default["default"].without(indices, 0);
-
-      // ... then combine
+      indices = _.without(indices, 0);
       const factors = [];
       for (const index of indices) {
         if (index in cache) {
@@ -4086,13 +3442,10 @@ class Pow extends Expr {
       const mul = new Mul(factors).expand().collect();
       return signed(mul);
     } else if (pow.exp instanceof Add) {
-      // DEFINITELY want behind super-simplify() flag
-      // e.g. x^(a+b) -> x^a*x^b
-
-      const terms = ___default["default"].map(pow.exp.terms, term => {
+      const _terms = _.map(pow.exp.terms, term => {
         return new Pow(pow.base, term).expand();
       });
-      return new Mul(terms).expand();
+      return new Mul(_terms).expand();
     } else {
       return pow;
     }
@@ -4100,10 +3453,8 @@ class Pow extends Expr {
   factor() {
     var pow = this.recurse("factor");
     if (pow.base instanceof Mul) {
-      var terms = ___default["default"].map(pow.base.terms, term => {
+      var terms = _.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);
@@ -4116,86 +3467,54 @@ 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 (term) {
+    const isSimilarLog = function isSimilarLog(term) {
       return term instanceof Log && term.base.equals(pow.base);
     };
     if (pow.exp instanceof Num && pow.exp.eval() === 0) {
-      // e.g. x^0 -> 1
       return 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 && ___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.
+    } else if (pow.exp instanceof Mul && _.any(pow.exp.terms, isSimilarLog)) {
       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()
-        // @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();
+        const decimalsInRoot = root.collect().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 (arg) {
+    var isDiv = function isDiv(arg) {
       return arg instanceof Num && Boolean(arg.hints.divide);
     };
-    return isDiv(this.exp) || this.exp instanceof Mul && ___default["default"].any(this.exp.terms, isDiv);
+    return isDiv(this.exp) || this.exp instanceof Mul && _.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 = ___default["default"].clone(this.exp.hints);
+        negated.hints = _.clone(this.exp.hints);
         negated.hints.divide = false;
         return new Pow(this.base, negated);
       }
@@ -4211,9 +3530,6 @@ 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();
@@ -4228,27 +3544,17 @@ 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();
@@ -4271,10 +3577,8 @@ 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));
         }
       }
@@ -4284,40 +3588,28 @@ 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"));
-  };
 }
-
-/* logarithm */
+_class5 = Pow;
+Pow.nthroot = function (radicand, degree) {
+  var exp = Mul.fold(Mul.handleDivide(new Int(1), degree));
+  return new _class5(radicand, exp.addHint("root"));
+};
 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 = {
-      ...this.hints,
+    this.hints = _extends({}, this.hints, {
       open: false
-    };
+    });
   }
-  func = Log;
   args() {
     return [this.base, this.power];
   }
-  eval() {
-    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let options = arguments.length > 1 ? arguments[1] : undefined;
+  eval(vars = {}, options) {
     return Math.log(this.power.eval(vars, options)) / Math.log(this.base.eval(vars, options));
   }
   codegen() {
@@ -4342,13 +3634,10 @@ 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;
@@ -4357,21 +3646,13 @@ class Log extends Expr {
   expand() {
     var log = this.recurse("expand");
     if (log.power instanceof Mul) {
-      // might want behind super-simplify() flag
-      // e.g. ln(xy) -> ln(x) + ln(y)
-
-      var terms = ___default["default"].map(log.power.terms, term => {
-        // need to expand again in case new log powers are Pows
+      var terms = _.map(log.power.terms, term => {
         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;
@@ -4405,178 +3686,172 @@ class Log extends Expr {
     return log;
   }
 }
-/* trigonometric functions */
 class Trig extends Expr {
-  type; // TODO(kevinb): Use a union type for this
-  arg;
-  exp;
-  constructor(type, arg) {
+  constructor(type, _arg) {
     super();
-    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);
-      },
-      codegen: "(1/Math.sin(",
-      tex: "\\csc",
-      expand: () => Mul.handleDivide(NumOne, Trig.sin(this.arg))
-    },
-    sec: {
-      eval: arg => {
-        return 1 / Math.cos(arg);
+    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
       },
-      codegen: "(1/Math.cos(",
-      tex: "\\sec",
-      expand: () => Mul.handleDivide(NumOne, Trig.cos(this.arg))
-    },
-    cot: {
-      eval: arg => {
-        return 1 / Math.tan(arg);
+      cos: {
+        eval: Math.cos,
+        codegen: "Math.cos((",
+        tex: "\\cos",
+        expand: () => this
       },
-      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);
+      tan: {
+        eval: Math.tan,
+        codegen: "Math.tan((",
+        tex: "\\tan",
+        expand: () => Mul.handleDivide(Trig.sin(this.arg), Trig.cos(this.arg))
       },
-      codegen: "Math.asin(1/(",
-      tex: "\\operatorname{arccsc}"
-    },
-    arcsec: {
-      eval: arg => {
-        return Math.acos(1 / arg);
+      csc: {
+        eval: arg => {
+          return 1 / Math.sin(arg);
+        },
+        codegen: "(1/Math.sin(",
+        tex: "\\csc",
+        expand: () => Mul.handleDivide(NumOne, Trig.sin(this.arg))
       },
-      codegen: "Math.acos(1/(",
-      tex: "\\operatorname{arcsec}"
-    },
-    arccot: {
-      eval: arg => {
-        return Math.atan(1 / arg);
+      sec: {
+        eval: arg => {
+          return 1 / Math.cos(arg);
+        },
+        codegen: "(1/Math.cos(",
+        tex: "\\sec",
+        expand: () => Mul.handleDivide(NumOne, Trig.cos(this.arg))
       },
-      codegen: "Math.atan(1/(",
-      tex: "\\operatorname{arccot}"
-    },
-    sinh: {
-      eval: arg => {
-        return (Math.exp(arg) - Math.exp(-arg)) / 2;
+      cot: {
+        eval: arg => {
+          return 1 / Math.tan(arg);
+        },
+        codegen: "(1/Math.tan(",
+        tex: "\\cot",
+        expand: () => Mul.handleDivide(Trig.cos(this.arg), Trig.sin(this.arg))
       },
-      codegen: argStr => {
-        return "((Math.exp(" + argStr + ") - Math.exp(-(" + argStr + "))) / 2)";
+      arcsin: {
+        eval: Math.asin,
+        codegen: "Math.asin((",
+        tex: "\\arcsin"
       },
-      tex: "\\sinh",
-      expand: () => this
-    },
-    cosh: {
-      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: "\\cosh",
-      expand: () => this
-    },
-    tanh: {
-      eval: arg => {
-        return (Math.exp(arg) - Math.exp(-arg)) / (Math.exp(arg) + Math.exp(-arg));
+      arccsc: {
+        eval: arg => {
+          return Math.asin(1 / arg);
+        },
+        codegen: "Math.asin(1/(",
+        tex: "\\operatorname{arccsc}"
       },
-      codegen: argStr => {
-        return "(" + "(Math.exp(" + argStr + ") - Math.exp(-(" + argStr + ")))" + " / " + "(Math.exp(" + argStr + ") + Math.exp(-(" + argStr + ")))" + ")";
+      arcsec: {
+        eval: arg => {
+          return Math.acos(1 / arg);
+        },
+        codegen: "Math.acos(1/(",
+        tex: "\\operatorname{arcsec}"
       },
-      tex: "\\tanh",
-      expand: () => Mul.handleDivide(Trig.sinh(this.arg), Trig.cosh(this.arg))
-    },
-    csch: {
-      eval: arg => {
-        return 2 / (Math.exp(arg) - Math.exp(-arg));
+      arccot: {
+        eval: arg => {
+          return Math.atan(1 / arg);
+        },
+        codegen: "Math.atan(1/(",
+        tex: "\\operatorname{arccot}"
       },
-      codegen: argStr => {
-        return "(2 / (Math.exp(" + argStr + ") - Math.exp(-(" + argStr + "))))";
+      sinh: {
+        eval: arg => {
+          return (Math.exp(arg) - Math.exp(-arg)) / 2;
+        },
+        codegen: argStr => {
+          return "((Math.exp(" + argStr + ") - Math.exp(-(" + argStr + "))) / 2)";
+        },
+        tex: "\\sinh",
+        expand: () => this
       },
-      tex: "\\csch",
-      expand: () => Mul.handleDivide(NumOne, Trig.sinh(this.arg))
-    },
-    sech: {
-      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: "\\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));
+      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 "(" + "(Math.exp(" + argStr + ") + Math.exp(-(" + argStr + ")))" + " / " + "(Math.exp(" + argStr + ") - Math.exp(-(" + argStr + ")))" + ")";
+      sech: {
+        eval: arg => {
+          return 2 / (Math.exp(arg) + Math.exp(-arg));
+        },
+        codegen: argStr => {
+          return "(2 / (Math.exp(" + argStr + ") + Math.exp(-(" + argStr + "))))";
+        },
+        tex: "\\sech",
+        expand: () => Mul.handleDivide(NumOne, Trig.cosh(this.arg))
       },
-      tex: "\\coth",
-      expand: () => Mul.handleDivide(Trig.cosh(this.arg), Trig.sinh(this.arg))
-    }
-  };
+      coth: {
+        eval: arg => {
+          return (Math.exp(arg) + Math.exp(-arg)) / (Math.exp(arg) - Math.exp(-arg));
+        },
+        codegen: argStr => {
+          return "(" + "(Math.exp(" + argStr + ") + Math.exp(-(" + argStr + ")))" + " / " + "(Math.exp(" + argStr + ") - Math.exp(-(" + argStr + ")))" + ")";
+        },
+        tex: "\\coth",
+        expand: () => Mul.handleDivide(Trig.cosh(this.arg), Trig.sinh(this.arg))
+      }
+    };
+    this.type = type;
+    this.arg = _arg;
+    this.hints = _extends({}, this.hints, {
+      open: false
+    });
+  }
+  args() {
+    return [this.type, this.arg];
+  }
   isEven() {
-    return ___default["default"].contains(["cos", "sec"], this.type);
+    return _.contains(["cos", "sec"], this.type);
   }
   isInverse() {
     return this.type.indexOf("arc") === 0;
   }
   isBasic() {
-    return ___default["default"].contains(["sin", "cos"], this.type);
+    return _.contains(["sin", "cos"], this.type);
   }
-  eval() {
-    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let options = arguments.length > 1 ? arguments[1] : undefined;
+  eval(vars = {}, options) {
     var func = this.functions[this.type].eval;
     var arg = this.arg.eval(vars, options);
     return func(arg);
@@ -4621,18 +3896,14 @@ 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 ___default["default"].bind(expand, trig)();
+      return _.bind(expand, trig)();
     } else {
       return trig;
     }
@@ -4642,10 +3913,8 @@ 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 {
@@ -4656,7 +3925,6 @@ 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;
     }
@@ -4683,18 +3951,16 @@ 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() {
-    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let options = arguments.length > 1 ? arguments[1] : undefined;
+  eval(vars = {}, options) {
     return Math.abs(this.arg.eval(vars, options));
   }
   codegen() {
@@ -4709,14 +3975,11 @@ 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) {
-      // e.g. |-2*pi*x| -> 2*pi*|x|
-      var terms = ___default["default"].groupBy(abs.arg.terms, term => {
+      var terms = _.groupBy(abs.arg.terms, term => {
         if (term.isPositive()) {
           return "positive";
         } else if (term instanceof Num) {
@@ -4725,7 +3988,7 @@ class Abs extends Expr {
           return "other";
         }
       });
-      var positives = terms.positive.concat(___default["default"].invoke(terms.number, "abs"));
+      var positives = terms.positive.concat(_.invoke(terms.number, "abs"));
       if (terms.other.length) {
         positives.push(new Abs(new Mul(terms.other).flatten()));
       }
@@ -4734,13 +3997,10 @@ 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) {
-      // e.g. |xyz| -> |x|*|y|*|z|
-      var terms = ___default["default"].map(abs.arg.terms, term => {
+      var terms = _.map(abs.arg.terms, term => {
         return new Abs(term);
       });
       return new Mul(terms);
@@ -4752,19 +4012,25 @@ 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];
   }
@@ -4774,41 +4040,24 @@ 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 (___default["default"].contains([">", ">="], eq.type)) {
-      // inequalities should have the smaller side on the left
+    if (_.contains([">", ">="], eq.type)) {
       return new Eq(eq.right, eq.type.replace(">", "<"), eq.left);
     } else {
       return eq;
     }
   }
-
-  // convert this equation to an expression set to zero
-  // the expression is normalized to a canonical form
-  // e.g. y/2=x/4 -> y/2-x/4(=0) -> 2y-x(=0)
-  // unless unfactored is specified, will then divide through
-  asExpr() {
-    let unfactored = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  asExpr(unfactored = 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 = ___default["default"].clone(this.left.terms);
+      terms = _.clone(this.left.terms);
     } else if (!isZero(this.left)) {
       terms = [this.left];
     }
@@ -4818,26 +4067,16 @@ class Eq extends Expr {
       terms.push(this.right.negate());
     }
     var isInequality = !this.isEquality();
-
-    // 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", {
+    terms = _.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 = ___default["default"].map(terms, term => {
+        terms = _.map(terms, term => {
           return Mul.createOrAppend(term, denominator).simplify({
             once: true,
             preciseFloats: true
@@ -4848,11 +4087,6 @@ 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({
@@ -4869,31 +4103,20 @@ class Eq extends Expr {
     const isOne = term => term.equals(NumOne);
     const [adds, others] = partition(terms, isAdd);
     if (adds.length && this.isEquality()) {
-      // keep only Adds
-      // e.g. 2xy(z+1)(=0) -> z+1(=0)
       return new Mul(adds).flatten();
     }
     let denominator = others;
     if (!adds.length) {
-      // if no Adds, keep all variable terms to preserve meaning
-      // e.g. 42xyz(=0) -> xyz(=0)
-      denominator = ___default["default"].reject(denominator, hasVar);
+      denominator = _.reject(denominator, hasVar);
     }
     if (isInequality) {
-      // can't divide inequalities by non 100% positive factors
-      // e.g. 42x^2y(z+1)(=0) -> y(z+1)(=0)
-      denominator = ___default["default"].invoke(denominator, "asPositiveFactor");
+      denominator = _.invoke(denominator, "asPositiveFactor");
     }
-
-    // don't need to divide by one
-    denominator = ___default["default"].reject(denominator, isOne);
-    denominator = ___default["default"].map(denominator, term => {
+    denominator = _.reject(denominator, isOne);
+    denominator = _.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 {
@@ -4901,10 +4124,9 @@ class Eq extends Expr {
     }
   }
   isEquality() {
-    return ___default["default"].contains(["=", "<>"], this.type);
+    return _.contains(["=", "<>"], this.type);
   }
   compare(other) {
-    // expression comparisons are handled by Expr.compare()
     if (!(other instanceof Eq)) {
       return false;
     }
@@ -4913,48 +4135,36 @@ class Eq extends Expr {
     if (eq1.type !== eq2.type) {
       return false;
     }
-
-    // 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());
+    var expr1 = eq1.divideThrough(eq1.asExpr(true).collect());
+    var expr2 = eq2.divideThrough(eq2.asExpr(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(/* unfactored */true);
+    var expr = this.asExpr(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) && ___default["default"].contains(term.getVars(), variable.symbol);
+      return term.has(Var) && _.contains(term.getVars(), variable.symbol);
     };
     const termHasVar = hasVar(expr.terms[0]);
     const a = termHasVar ? Mul.handleNegative(expr.terms[1]) : Mul.handleNegative(expr.terms[0]);
@@ -4962,8 +4172,6 @@ class Eq extends Expr {
     return Mul.handleDivide(a, b).simplify();
   }
 }
-
-/* abstract symbol node */
 class Sym extends Expr {
   needsExplicitMul() {
     return false;
@@ -4976,17 +4184,15 @@ 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];
   }
@@ -4996,19 +4202,16 @@ class Func extends Sym {
   tex() {
     return this.symbol + "(" + this.arg.tex() + ")";
   }
-  eval() {
-    let vars = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    let options = arguments.length > 1 ? arguments[1] : undefined;
+  eval(vars = {}, options) {
     var arg = this.arg;
     var func = vars[this.symbol];
-    var newVars = ___default["default"].extend(___default["default"].clone(vars), {
+    var newVars = _.extend(_.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() {
@@ -5021,24 +4224,22 @@ class Func extends Sym {
     if (excludeFunc) {
       return this.arg.getVars();
     } else {
-      return ___default["default"].union(this.arg.getVars(), [this.symbol]).sort();
+      return _.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];
   }
@@ -5055,9 +4256,6 @@ 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)) {
@@ -5077,12 +4275,7 @@ class Var extends Sym {
   repr() {
     return "Var(" + this.print() + ")";
   }
-  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.
+  eval(vars = {}, options) {
     return vars[this.prettyPrint()];
   }
   codegen() {
@@ -5095,28 +4288,25 @@ 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() {
+  eval(vars = {}, options) {
     if (this.symbol === "pi") {
       return Math.PI;
     } else if (this.symbol === "e") {
       return Math.E;
     } else {
-      // @ts-expect-error: should we throw an error here?
       return undefined;
     }
   }
@@ -5126,7 +4316,6 @@ class Const extends Sym {
     } else if (this.symbol === "e") {
       return "Math.E";
     } else {
-      // @ts-expect-error: should we throw an error here?
       return undefined;
     }
   }
@@ -5139,7 +4328,6 @@ class Const extends Sym {
     } else if (this.symbol === "e") {
       return "e";
     } else {
-      // @ts-expect-error: should we return this.symbol here?
       return undefined;
     }
   }
@@ -5156,25 +4344,22 @@ class Const extends Sym {
   getConsts() {
     return [this.print()];
   }
-  static e = new Const("e");
-  static pi = new Const("pi");
 }
-
-/* abstract number node */
+_class12 = Const;
+Const.e = new _class12("e");
+Const.pi = new _class12("pi");
 class Num extends Expr {
-  n = 0;
   constructor() {
     super();
-    // hints for interpreting and rendering user input
-    this.hints = {
-      ...this.hints,
+    this.n = 0;
+    this.hints = _extends({}, this.hints, {
       negate: false,
       subtract: false,
       divide: false,
       root: false,
       fraction: false,
       entered: false
-    };
+    });
   }
   repr() {
     return this.print();
@@ -5188,17 +4373,9 @@ 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;
   }
@@ -5211,19 +4388,10 @@ 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,
-      // Number of digits right of decimal point
-      (match[1] ? match[1].length : 0) - (
-      // Adjust for scientific notation
-      match[2] ? +match[2] : 0));
+      return Math.max(0, (match[1] ? match[1].length : 0) - (match[2] ? +match[2] : 0));
     } else {
       return 0;
     }
@@ -5237,16 +4405,10 @@ 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;
     }
@@ -5257,26 +4419,19 @@ class Num extends Expr {
     }
     return a;
   }
-  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 min(...args) {
+    return _.min(args, num => num.eval());
   }
-  static max() {
-    for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
-      args[_key4] = arguments[_key4];
-    }
-    return ___default["default"].max(args, num => num.eval());
+  static max(...args) {
+    return _.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) {
@@ -5286,7 +4441,6 @@ class Rational extends Num {
     this.n = n;
     this.d = d;
   }
-  func = Rational;
   args() {
     return [this.n, this.d];
   }
@@ -5331,14 +4485,9 @@ 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);
@@ -5346,8 +4495,6 @@ 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;
@@ -5373,13 +4520,11 @@ 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];
   }
@@ -5409,24 +4554,19 @@ 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();
   }
@@ -5448,8 +4588,6 @@ 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() {
@@ -5465,8 +4603,6 @@ 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);
@@ -5474,8 +4610,6 @@ 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) {
@@ -5495,9 +4629,6 @@ 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();
   }
@@ -5509,13 +4640,9 @@ 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 (str, hash) {
-  // return int location of parsing error
+var parseError = function parseError(str, hash) {
   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,
@@ -5532,28 +4659,22 @@ parser.yy = {
   parseError: parseError,
   constants: ["e"],
   symbolLexer: function (symbol) {
-    if (___default["default"].contains(parser.yy.constants, symbol)) {
+    if (_.contains(parser.yy.constants, symbol)) {
       return "CONST";
-    } else if (___default["default"].contains(parser.yy.functions, symbol)) {
+    } else if (_.contains(parser.yy.functions, symbol)) {
       return "FUNC";
     } else {
       return "VAR";
     }
   }
 };
-const parse = function (input, options) {
+const parse = function parse(input, options) {
   try {
     if (options && options.functions) {
-      // reserve the symbol "i" for complex numbers
-      parser.yy.functions = ___default["default"].without(options.functions, "i");
+      parser.yy.functions = _.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(".");
     }
@@ -5569,29 +4690,20 @@ const parse = function (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() {
-    // 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.
+  eval(vars = {}, options) {
     return 1;
   }
   getUnits() {
@@ -5609,42 +4721,26 @@ class Unit extends Sym {
   tex() {
     return this.symbol;
   }
-
-  // Simplify units by replacing prefixes with multiplication
   collect(options) {
-    if (___default["default"](baseUnits).has(this.symbol)) {
+    if (_(baseUnits).has(this.symbol)) {
       return this;
-    } else if (___default["default"](derivedUnits).has(this.symbol)) {
+    } else if (_(derivedUnits).has(this.symbol)) {
       return derivedUnits[this.symbol].conversion;
     } else {
       throw new Error("could not understand unit: " + this.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)) {
+var unprefixify = function unprefixify(symbol) {
+  if (_(baseUnits).has(symbol) || _(derivedUnits).has(symbol)) {
     return new Unit(symbol);
   }
-
-  // check for prefix
-  var prefix = ___default["default"](___default["default"](siPrefixes).keys()).find(testPrefix => {
+  var prefix = _(_(siPrefixes).keys()).find(testPrefix => {
     return new RegExp("^" + testPrefix).test(symbol);
   });
   if (prefix) {
     var base = symbol.replace(new RegExp("^" + prefix), "");
-
-    // 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) {
+    if (_(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");
@@ -5653,36 +4749,18 @@ var unprefixify = function (symbol) {
     return new Unit(symbol);
   }
 };
-const unitParse = function (input) {
+const unitParse = function unitParse(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 = [];
-    ___default["default"](parseResult.unit.num).each(unitSpec => {
+    _(parseResult.unit.num).each(unitSpec => {
       unitArray.push(new Pow(unprefixify(unitSpec.name), new Int(unitSpec.pow)));
     });
-    ___default["default"](parseResult.unit.denom).each(unitSpec => {
+    _(parseResult.unit.denom).each(unitSpec => {
       unitArray.push(new Pow(unprefixify(unitSpec.name), new Int(-1 * unitSpec.pow)));
     });
     var unit = new Mul(unitArray).flatten();
     if (parseResult.type === "unitMagnitude") {
-      // in the first case we have a magnitude coefficient as well as the
-      // unit itself.
       var coefArray = [new Float(+parseResult.magnitude), ...unitArray];
       var expr = new Mul(coefArray);
       return {
@@ -5693,7 +4771,6 @@ const unitParse = function (input) {
         type: parseResult.type
       };
     } else {
-      // in the second case it's just the unit with no magnitude.
       return {
         parsed: true,
         unit: unit,
@@ -5709,7 +4786,6 @@ const unitParse = function (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"),
@@ -5734,14 +4810,11 @@ 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 (str, prefixes) {
+const makeAlias = function makeAlias(str, prefixes) {
   var splits = str.split("|");
   var coefficientStr = splits[0].trim();
   var unitsStr = splits[1].trim();
@@ -5762,35 +4835,9 @@ const makeAlias = function (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),
@@ -5801,43 +4848,32 @@ 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),
@@ -5845,7 +4881,6 @@ 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),
@@ -5853,7 +4888,6 @@ 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),
@@ -5866,25 +4900,17 @@ 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),
@@ -5894,8 +4920,6 @@ 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),
@@ -5909,38 +4933,17 @@ 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;
 
-/**
- * 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 compare = function compare(expr1, expr2, options = {}) {
   const defaults = {
     form: false,
     simplify: false
   };
-
-  /* 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 optionsWithDefaults = _extends({}, defaults, options);
   const vars = expr1.sameVars(expr2);
   if (!vars.equal) {
     let message;
@@ -5956,24 +4959,18 @@ const compare = function (expr1, expr2) {
       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,
@@ -5986,24 +4983,5 @@ const compare = function (expr1, expr2) {
   };
 };
 
-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;
+export { Abs, Add, Const, Eq, Float, Func, Int, Log, Mul, One, Pow, Rational, Trig, Unit, Var, Zero, compare, libVersion, parse, unitParse };
 //# sourceMappingURL=index.js.map