mathjs 12.4.3 → 13.0.1

package/lib/cjs/expression/node/OperatorNode.js

@@ -5,11 +5,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createOperatorNode = void 0;
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 var _is = require("../../utils/is.js");
 var _array = require("../../utils/array.js");
@@ -19,12 +14,12 @@ var _customs = require("../../utils/customs.js");
 var _operators = require("../operators.js");
 var _latex = require("../../utils/latex.js");
 var _factory = require("../../utils/factory.js");
-function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2["default"])(o), (0, _possibleConstructorReturn2["default"])(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2["default"])(t).constructor) : o.apply(t, e)); }
-function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
-var name = 'OperatorNode';
-var dependencies = ['Node'];
-var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var Node = _ref.Node;
+const name = 'OperatorNode';
+const dependencies = ['Node'];
+const createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    Node
+  } = _ref;
   /**
    * Returns true if the expression starts with a constant, under
    * the current parenthesization:
@@ -33,7 +28,7 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
    * @return {boolean}
    */
   function startsWithConstant(expr, parenthesis) {
-    var curNode = expr;
+    let curNode = expr;
     if (parenthesis === 'auto') {
       while ((0, _is.isParenthesisNode)(curNode)) curNode = curNode.content;
     }
@@ -59,8 +54,8 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
    */
   function calculateNecessaryParentheses(root, parenthesis, implicit, args, latex) {
     // precedence of the root OperatorNode
-    var precedence = (0, _operators.getPrecedence)(root, parenthesis, implicit);
-    var associativity = (0, _operators.getAssociativity)(root, parenthesis);
+    const precedence = (0, _operators.getPrecedence)(root, parenthesis, implicit);
+    const associativity = (0, _operators.getAssociativity)(root, parenthesis);
     if (parenthesis === 'all' || args.length > 2 && root.getIdentifier() !== 'OperatorNode:add' && root.getIdentifier() !== 'OperatorNode:multiply') {
       return args.map(function (arg) {
         switch (arg.getContent().type) {
@@ -75,7 +70,7 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
         }
       });
     }
-    var result;
+    let result;
     switch (args.length) {
       case 0:
         result = [];
@@ -84,12 +79,12 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
         // unary operators
         {
           // precedence of the operand
-          var operandPrecedence = (0, _operators.getPrecedence)(args[0], parenthesis, implicit, root);
+          const operandPrecedence = (0, _operators.getPrecedence)(args[0], parenthesis, implicit, root);
 
           // handle special cases for LaTeX, where some of the parentheses aren't needed
           if (latex && operandPrecedence !== null) {
-            var operandIdentifier;
-            var rootIdentifier;
+            let operandIdentifier;
+            let rootIdentifier;
             if (parenthesis === 'keep') {
               operandIdentifier = args[0].getIdentifier();
               rootIdentifier = root.getIdentifier();
@@ -125,11 +120,11 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
       case 2:
         // binary operators
         {
-          var lhsParens; // left hand side needs parenthesis?
+          let lhsParens; // left hand side needs parenthesis?
           // precedence of the left hand side
-          var lhsPrecedence = (0, _operators.getPrecedence)(args[0], parenthesis, implicit, root);
+          const lhsPrecedence = (0, _operators.getPrecedence)(args[0], parenthesis, implicit, root);
           // is the root node associative with the left hand side
-          var assocWithLhs = (0, _operators.isAssociativeWith)(root, args[0], parenthesis);
+          const assocWithLhs = (0, _operators.isAssociativeWith)(root, args[0], parenthesis);
           if (lhsPrecedence === null) {
             // if the left hand side has no defined precedence, no parens are needed
             // FunctionNode for example
@@ -145,11 +140,11 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
           } else {
             lhsParens = false;
           }
-          var rhsParens; // right hand side needs parenthesis?
+          let rhsParens; // right hand side needs parenthesis?
           // precedence of the right hand side
-          var rhsPrecedence = (0, _operators.getPrecedence)(args[1], parenthesis, implicit, root);
+          const rhsPrecedence = (0, _operators.getPrecedence)(args[1], parenthesis, implicit, root);
           // is the root node associative with the right hand side?
-          var assocWithRhs = (0, _operators.isAssociativeWith)(root, args[1], parenthesis);
+          const assocWithRhs = (0, _operators.isAssociativeWith)(root, args[1], parenthesis);
           if (rhsPrecedence === null) {
             // if the right hand side has no defined precedence, no parens are needed
             // FunctionNode for example
@@ -168,21 +163,21 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
 
           // handle special cases for LaTeX, where some of the parentheses aren't needed
           if (latex) {
-            var _rootIdentifier;
-            var lhsIdentifier;
-            var rhsIdentifier;
+            let rootIdentifier;
+            let lhsIdentifier;
+            let rhsIdentifier;
             if (parenthesis === 'keep') {
-              _rootIdentifier = root.getIdentifier();
+              rootIdentifier = root.getIdentifier();
               lhsIdentifier = root.args[0].getIdentifier();
               rhsIdentifier = root.args[1].getIdentifier();
             } else {
               // Ignore ParenthesisNodes when not in 'keep' mode
-              _rootIdentifier = root.getContent().getIdentifier();
+              rootIdentifier = root.getContent().getIdentifier();
               lhsIdentifier = root.args[0].getContent().getIdentifier();
               rhsIdentifier = root.args[1].getContent().getIdentifier();
             }
             if (lhsPrecedence !== null) {
-              if (_operators.properties[precedence][_rootIdentifier].latexLeftParens === false) {
+              if (_operators.properties[precedence][rootIdentifier].latexLeftParens === false) {
                 lhsParens = false;
               }
               if (_operators.properties[lhsPrecedence][lhsIdentifier].latexParens === false) {
@@ -190,7 +185,7 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
               }
             }
             if (rhsPrecedence !== null) {
-              if (_operators.properties[precedence][_rootIdentifier].latexRightParens === false) {
+              if (_operators.properties[precedence][rootIdentifier].latexRightParens === false) {
                 rhsParens = false;
               }
               if (_operators.properties[rhsPrecedence][rhsIdentifier].latexParens === false) {
@@ -204,9 +199,9 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
       default:
         if (root.getIdentifier() === 'OperatorNode:add' || root.getIdentifier() === 'OperatorNode:multiply') {
           result = args.map(function (arg) {
-            var argPrecedence = (0, _operators.getPrecedence)(arg, parenthesis, implicit, root);
-            var assocWithArg = (0, _operators.isAssociativeWith)(root, arg, parenthesis);
-            var argAssociativity = (0, _operators.getAssociativity)(arg, parenthesis);
+            const argPrecedence = (0, _operators.getPrecedence)(arg, parenthesis, implicit, root);
+            const assocWithArg = (0, _operators.isAssociativeWith)(root, arg, parenthesis);
+            const argAssociativity = (0, _operators.getAssociativity)(arg, parenthesis);
             if (argPrecedence === null) {
               // if the argument has no defined precedence, no parens are needed
               return false;
@@ -226,7 +221,7 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
     // In that case, parenthesize ConstantNodes that follow an unparenthesized
     // expression, even though they normally wouldn't be printed.
     if (args.length >= 2 && root.getIdentifier() === 'OperatorNode:multiply' && root.implicit && parenthesis !== 'all' && implicit === 'hide') {
-      for (var i = 1; i < result.length; ++i) {
+      for (let i = 1; i < result.length; ++i) {
         if (startsWithConstant(args[i], parenthesis) && !result[i - 1] && (parenthesis !== 'keep' || !(0, _is.isParenthesisNode)(args[i - 1]))) {
           result[i] = true;
         }
@@ -234,7 +229,7 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
     }
     return result;
   }
-  var OperatorNode = /*#__PURE__*/function (_Node) {
+  class OperatorNode extends Node {
     /**
      * @constructor OperatorNode
      * @extends {Node}
@@ -246,10 +241,8 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
      * @param {boolean} [implicit]  Is this an implicit multiplication?
      * @param {boolean} [isPercentage] Is this an percentage Operation?
      */
-    function OperatorNode(op, fn, args, implicit, isPercentage) {
-      var _this;
-      (0, _classCallCheck2["default"])(this, OperatorNode);
-      _this = _callSuper(this, OperatorNode);
+    constructor(op, fn, args, implicit, isPercentage) {
+      super();
       // validate input
       if (typeof op !== 'string') {
         throw new TypeError('string expected for parameter "op"');
@@ -260,413 +253,382 @@ var createOperatorNode = exports.createOperatorNode = /* #__PURE__ */(0, _factor
       if (!Array.isArray(args) || !args.every(_is.isNode)) {
         throw new TypeError('Array containing Nodes expected for parameter "args"');
       }
-      _this.implicit = implicit === true;
-      _this.isPercentage = isPercentage === true;
-      _this.op = op;
-      _this.fn = fn;
-      _this.args = args || [];
-      return _this;
+      this.implicit = implicit === true;
+      this.isPercentage = isPercentage === true;
+      this.op = op;
+      this.fn = fn;
+      this.args = args || [];
+    }
+    get type() {
+      return name;
+    }
+    get isOperatorNode() {
+      return true;
     }
-    (0, _inherits2["default"])(OperatorNode, _Node);
-    return (0, _createClass2["default"])(OperatorNode, [{
-      key: "type",
-      get: function get() {
-        return name;
-      }
-    }, {
-      key: "isOperatorNode",
-      get: function get() {
-        return true;
-      }
 
-      /**
-       * Compile a node into a JavaScript function.
-       * This basically pre-calculates as much as possible and only leaves open
-       * calculations which depend on a dynamic scope with variables.
-       * @param {Object} math     Math.js namespace with functions and constants.
-       * @param {Object} argNames An object with argument names as key and `true`
-       *                          as value. Used in the SymbolNode to optimize
-       *                          for arguments from user assigned functions
-       *                          (see FunctionAssignmentNode) or special symbols
-       *                          like `end` (see IndexNode).
-       * @return {function} Returns a function which can be called like:
-       *                        evalNode(scope: Object, args: Object, context: *)
-       */
-    }, {
-      key: "_compile",
-      value: function _compile(math, argNames) {
-        // validate fn
-        if (typeof this.fn !== 'string' || !(0, _customs.isSafeMethod)(math, this.fn)) {
-          if (!math[this.fn]) {
-            throw new Error('Function ' + this.fn + ' missing in provided namespace "math"');
-          } else {
-            throw new Error('No access to function "' + this.fn + '"');
-          }
-        }
-        var fn = (0, _customs.getSafeProperty)(math, this.fn);
-        var evalArgs = (0, _array.map)(this.args, function (arg) {
-          return arg._compile(math, argNames);
-        });
-        if (typeof fn === 'function' && fn.rawArgs === true) {
-          // pass unevaluated parameters (nodes) to the function
-          // "raw" evaluation
-          var rawArgs = this.args;
-          return function evalOperatorNode(scope, args, context) {
-            return fn(rawArgs, math, (0, _scope.createSubScope)(scope, args));
-          };
-        } else if (evalArgs.length === 1) {
-          var evalArg0 = evalArgs[0];
-          return function evalOperatorNode(scope, args, context) {
-            return fn(evalArg0(scope, args, context));
-          };
-        } else if (evalArgs.length === 2) {
-          var _evalArg = evalArgs[0];
-          var evalArg1 = evalArgs[1];
-          return function evalOperatorNode(scope, args, context) {
-            return fn(_evalArg(scope, args, context), evalArg1(scope, args, context));
-          };
+    /**
+     * Compile a node into a JavaScript function.
+     * This basically pre-calculates as much as possible and only leaves open
+     * calculations which depend on a dynamic scope with variables.
+     * @param {Object} math     Math.js namespace with functions and constants.
+     * @param {Object} argNames An object with argument names as key and `true`
+     *                          as value. Used in the SymbolNode to optimize
+     *                          for arguments from user assigned functions
+     *                          (see FunctionAssignmentNode) or special symbols
+     *                          like `end` (see IndexNode).
+     * @return {function} Returns a function which can be called like:
+     *                        evalNode(scope: Object, args: Object, context: *)
+     */
+    _compile(math, argNames) {
+      // validate fn
+      if (typeof this.fn !== 'string' || !(0, _customs.isSafeMethod)(math, this.fn)) {
+        if (!math[this.fn]) {
+          throw new Error('Function ' + this.fn + ' missing in provided namespace "math"');
         } else {
-          return function evalOperatorNode(scope, args, context) {
-            return fn.apply(null, (0, _array.map)(evalArgs, function (evalArg) {
-              return evalArg(scope, args, context);
-            }));
-          };
+          throw new Error('No access to function "' + this.fn + '"');
         }
       }
-
-      /**
-       * Execute a callback for each of the child nodes of this node
-       * @param {function(child: Node, path: string, parent: Node)} callback
-       */
-    }, {
-      key: "forEach",
-      value: function forEach(callback) {
-        for (var i = 0; i < this.args.length; i++) {
-          callback(this.args[i], 'args[' + i + ']', this);
-        }
+      const fn = (0, _customs.getSafeProperty)(math, this.fn);
+      const evalArgs = (0, _array.map)(this.args, function (arg) {
+        return arg._compile(math, argNames);
+      });
+      if (typeof fn === 'function' && fn.rawArgs === true) {
+        // pass unevaluated parameters (nodes) to the function
+        // "raw" evaluation
+        const rawArgs = this.args;
+        return function evalOperatorNode(scope, args, context) {
+          return fn(rawArgs, math, (0, _scope.createSubScope)(scope, args));
+        };
+      } else if (evalArgs.length === 1) {
+        const evalArg0 = evalArgs[0];
+        return function evalOperatorNode(scope, args, context) {
+          return fn(evalArg0(scope, args, context));
+        };
+      } else if (evalArgs.length === 2) {
+        const evalArg0 = evalArgs[0];
+        const evalArg1 = evalArgs[1];
+        return function evalOperatorNode(scope, args, context) {
+          return fn(evalArg0(scope, args, context), evalArg1(scope, args, context));
+        };
+      } else {
+        return function evalOperatorNode(scope, args, context) {
+          return fn.apply(null, (0, _array.map)(evalArgs, function (evalArg) {
+            return evalArg(scope, args, context);
+          }));
+        };
       }
+    }
 
-      /**
-       * Create a new OperatorNode whose children are the results of calling
-       * the provided callback function for each child of the original node.
-       * @param {function(child: Node, path: string, parent: Node): Node} callback
-       * @returns {OperatorNode} Returns a transformed copy of the node
-       */
-    }, {
-      key: "map",
-      value: function map(callback) {
-        var args = [];
-        for (var i = 0; i < this.args.length; i++) {
-          args[i] = this._ifNode(callback(this.args[i], 'args[' + i + ']', this));
-        }
-        return new OperatorNode(this.op, this.fn, args, this.implicit, this.isPercentage);
+    /**
+     * Execute a callback for each of the child nodes of this node
+     * @param {function(child: Node, path: string, parent: Node)} callback
+     */
+    forEach(callback) {
+      for (let i = 0; i < this.args.length; i++) {
+        callback(this.args[i], 'args[' + i + ']', this);
       }
+    }
 
-      /**
-       * Create a clone of this node, a shallow copy
-       * @return {OperatorNode}
-       */
-    }, {
-      key: "clone",
-      value: function clone() {
-        return new OperatorNode(this.op, this.fn, this.args.slice(0), this.implicit, this.isPercentage);
+    /**
+     * Create a new OperatorNode whose children are the results of calling
+     * the provided callback function for each child of the original node.
+     * @param {function(child: Node, path: string, parent: Node): Node} callback
+     * @returns {OperatorNode} Returns a transformed copy of the node
+     */
+    map(callback) {
+      const args = [];
+      for (let i = 0; i < this.args.length; i++) {
+        args[i] = this._ifNode(callback(this.args[i], 'args[' + i + ']', this));
       }
+      return new OperatorNode(this.op, this.fn, args, this.implicit, this.isPercentage);
+    }
 
-      /**
-       * Check whether this is an unary OperatorNode:
-       * has exactly one argument, like `-a`.
-       * @return {boolean}
-       *     Returns true when an unary operator node, false otherwise.
-       */
-    }, {
-      key: "isUnary",
-      value: function isUnary() {
-        return this.args.length === 1;
-      }
+    /**
+     * Create a clone of this node, a shallow copy
+     * @return {OperatorNode}
+     */
+    clone() {
+      return new OperatorNode(this.op, this.fn, this.args.slice(0), this.implicit, this.isPercentage);
+    }
 
-      /**
-       * Check whether this is a binary OperatorNode:
-       * has exactly two arguments, like `a + b`.
-       * @return {boolean}
-       *     Returns true when a binary operator node, false otherwise.
-       */
-    }, {
-      key: "isBinary",
-      value: function isBinary() {
-        return this.args.length === 2;
-      }
+    /**
+     * Check whether this is an unary OperatorNode:
+     * has exactly one argument, like `-a`.
+     * @return {boolean}
+     *     Returns true when an unary operator node, false otherwise.
+     */
+    isUnary() {
+      return this.args.length === 1;
+    }
 
-      /**
-       * Get string representation.
-       * @param {Object} options
-       * @return {string} str
-       */
-    }, {
-      key: "_toString",
-      value: function _toString(options) {
-        var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
-        var implicit = options && options.implicit ? options.implicit : 'hide';
-        var args = this.args;
-        var parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, false);
-        if (args.length === 1) {
-          // unary operators
-          var assoc = (0, _operators.getAssociativity)(this, parenthesis);
-          var operand = args[0].toString(options);
-          if (parens[0]) {
-            operand = '(' + operand + ')';
-          }
+    /**
+     * Check whether this is a binary OperatorNode:
+     * has exactly two arguments, like `a + b`.
+     * @return {boolean}
+     *     Returns true when a binary operator node, false otherwise.
+     */
+    isBinary() {
+      return this.args.length === 2;
+    }
 
-          // for example for "not", we want a space between operand and argument
-          var opIsNamed = /[a-zA-Z]+/.test(this.op);
-          if (assoc === 'right') {
-            // prefix operator
-            return this.op + (opIsNamed ? ' ' : '') + operand;
-          } else if (assoc === 'left') {
-            // postfix
-            return operand + (opIsNamed ? ' ' : '') + this.op;
-          }
+    /**
+     * Get string representation.
+     * @param {Object} options
+     * @return {string} str
+     */
+    _toString(options) {
+      const parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+      const implicit = options && options.implicit ? options.implicit : 'hide';
+      const args = this.args;
+      const parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, false);
+      if (args.length === 1) {
+        // unary operators
+        const assoc = (0, _operators.getAssociativity)(this, parenthesis);
+        let operand = args[0].toString(options);
+        if (parens[0]) {
+          operand = '(' + operand + ')';
+        }
 
-          // fall back to postfix
-          return operand + this.op;
-        } else if (args.length === 2) {
-          var lhs = args[0].toString(options); // left hand side
-          var rhs = args[1].toString(options); // right hand side
-          if (parens[0]) {
-            // left hand side in parenthesis?
-            lhs = '(' + lhs + ')';
-          }
-          if (parens[1]) {
-            // right hand side in parenthesis?
-            rhs = '(' + rhs + ')';
-          }
-          if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') {
-            return lhs + ' ' + rhs;
-          }
-          return lhs + ' ' + this.op + ' ' + rhs;
-        } else if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) {
-          var stringifiedArgs = args.map(function (arg, index) {
-            arg = arg.toString(options);
-            if (parens[index]) {
-              // put in parenthesis?
-              arg = '(' + arg + ')';
-            }
-            return arg;
-          });
-          if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') {
-            return stringifiedArgs.join(' ');
+        // for example for "not", we want a space between operand and argument
+        const opIsNamed = /[a-zA-Z]+/.test(this.op);
+        if (assoc === 'right') {
+          // prefix operator
+          return this.op + (opIsNamed ? ' ' : '') + operand;
+        } else if (assoc === 'left') {
+          // postfix
+          return operand + (opIsNamed ? ' ' : '') + this.op;
+        }
+
+        // fall back to postfix
+        return operand + this.op;
+      } else if (args.length === 2) {
+        let lhs = args[0].toString(options); // left hand side
+        let rhs = args[1].toString(options); // right hand side
+        if (parens[0]) {
+          // left hand side in parenthesis?
+          lhs = '(' + lhs + ')';
+        }
+        if (parens[1]) {
+          // right hand side in parenthesis?
+          rhs = '(' + rhs + ')';
+        }
+        if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') {
+          return lhs + ' ' + rhs;
+        }
+        return lhs + ' ' + this.op + ' ' + rhs;
+      } else if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) {
+        const stringifiedArgs = args.map(function (arg, index) {
+          arg = arg.toString(options);
+          if (parens[index]) {
+            // put in parenthesis?
+            arg = '(' + arg + ')';
           }
-          return stringifiedArgs.join(' ' + this.op + ' ');
-        } else {
-          // fallback to formatting as a function call
-          return this.fn + '(' + this.args.join(', ') + ')';
+          return arg;
+        });
+        if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') {
+          return stringifiedArgs.join(' ');
         }
+        return stringifiedArgs.join(' ' + this.op + ' ');
+      } else {
+        // fallback to formatting as a function call
+        return this.fn + '(' + this.args.join(', ') + ')';
       }
+    }
 
-      /**
-       * Get a JSON representation of the node
-       * @returns {Object}
-       */
-    }, {
-      key: "toJSON",
-      value: function toJSON() {
-        return {
-          mathjs: name,
-          op: this.op,
-          fn: this.fn,
-          args: this.args,
-          implicit: this.implicit,
-          isPercentage: this.isPercentage
-        };
-      }
+    /**
+     * Get a JSON representation of the node
+     * @returns {Object}
+     */
+    toJSON() {
+      return {
+        mathjs: name,
+        op: this.op,
+        fn: this.fn,
+        args: this.args,
+        implicit: this.implicit,
+        isPercentage: this.isPercentage
+      };
+    }
 
-      /**
-       * Instantiate an OperatorNode from its JSON representation
-       * @param {Object} json
-       *     An object structured like
-       *     ```
-       *     {"mathjs": "OperatorNode",
-       *      "op": "+", "fn": "add", "args": [...],
-       *      "implicit": false,
-       *      "isPercentage":false}
-       *     ```
-       *     where mathjs is optional
-       * @returns {OperatorNode}
-       */
-    }, {
-      key: "_toHTML",
-      value:
-      /**
-       * Get HTML representation.
-       * @param {Object} options
-       * @return {string} str
-       */
-      function _toHTML(options) {
-        var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
-        var implicit = options && options.implicit ? options.implicit : 'hide';
-        var args = this.args;
-        var parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, false);
-        if (args.length === 1) {
-          // unary operators
-          var assoc = (0, _operators.getAssociativity)(this, parenthesis);
-          var operand = args[0].toHTML(options);
-          if (parens[0]) {
-            operand = '<span class="math-parenthesis math-round-parenthesis">(</span>' + operand + '<span class="math-parenthesis math-round-parenthesis">)</span>';
-          }
-          if (assoc === 'right') {
-            // prefix operator
-            return '<span class="math-operator math-unary-operator ' + 'math-lefthand-unary-operator">' + (0, _string.escape)(this.op) + '</span>' + operand;
-          } else {
-            // postfix when assoc === 'left' or undefined
-            return operand + '<span class="math-operator math-unary-operator ' + 'math-righthand-unary-operator">' + (0, _string.escape)(this.op) + '</span>';
-          }
-        } else if (args.length === 2) {
-          // binary operatoes
-          var lhs = args[0].toHTML(options); // left hand side
-          var rhs = args[1].toHTML(options); // right hand side
-          if (parens[0]) {
-            // left hand side in parenthesis?
-            lhs = '<span class="math-parenthesis math-round-parenthesis">(</span>' + lhs + '<span class="math-parenthesis math-round-parenthesis">)</span>';
-          }
-          if (parens[1]) {
-            // right hand side in parenthesis?
-            rhs = '<span class="math-parenthesis math-round-parenthesis">(</span>' + rhs + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+    /**
+     * Instantiate an OperatorNode from its JSON representation
+     * @param {Object} json
+     *     An object structured like
+     *     ```
+     *     {"mathjs": "OperatorNode",
+     *      "op": "+", "fn": "add", "args": [...],
+     *      "implicit": false,
+     *      "isPercentage":false}
+     *     ```
+     *     where mathjs is optional
+     * @returns {OperatorNode}
+     */
+    static fromJSON(json) {
+      return new OperatorNode(json.op, json.fn, json.args, json.implicit, json.isPercentage);
+    }
+
+    /**
+     * Get HTML representation.
+     * @param {Object} options
+     * @return {string} str
+     */
+    _toHTML(options) {
+      const parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+      const implicit = options && options.implicit ? options.implicit : 'hide';
+      const args = this.args;
+      const parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, false);
+      if (args.length === 1) {
+        // unary operators
+        const assoc = (0, _operators.getAssociativity)(this, parenthesis);
+        let operand = args[0].toHTML(options);
+        if (parens[0]) {
+          operand = '<span class="math-parenthesis math-round-parenthesis">(</span>' + operand + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+        }
+        if (assoc === 'right') {
+          // prefix operator
+          return '<span class="math-operator math-unary-operator ' + 'math-lefthand-unary-operator">' + (0, _string.escape)(this.op) + '</span>' + operand;
+        } else {
+          // postfix when assoc === 'left' or undefined
+          return operand + '<span class="math-operator math-unary-operator ' + 'math-righthand-unary-operator">' + (0, _string.escape)(this.op) + '</span>';
+        }
+      } else if (args.length === 2) {
+        // binary operatoes
+        let lhs = args[0].toHTML(options); // left hand side
+        let rhs = args[1].toHTML(options); // right hand side
+        if (parens[0]) {
+          // left hand side in parenthesis?
+          lhs = '<span class="math-parenthesis math-round-parenthesis">(</span>' + lhs + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+        }
+        if (parens[1]) {
+          // right hand side in parenthesis?
+          rhs = '<span class="math-parenthesis math-round-parenthesis">(</span>' + rhs + '<span class="math-parenthesis math-round-parenthesis">)</span>';
+        }
+        if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') {
+          return lhs + '<span class="math-operator math-binary-operator ' + 'math-implicit-binary-operator"></span>' + rhs;
+        }
+        return lhs + '<span class="math-operator math-binary-operator ' + 'math-explicit-binary-operator">' + (0, _string.escape)(this.op) + '</span>' + rhs;
+      } else {
+        const stringifiedArgs = args.map(function (arg, index) {
+          arg = arg.toHTML(options);
+          if (parens[index]) {
+            // put in parenthesis?
+            arg = '<span class="math-parenthesis math-round-parenthesis">(</span>' + arg + '<span class="math-parenthesis math-round-parenthesis">)</span>';
           }
+          return arg;
+        });
+        if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) {
           if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') {
-            return lhs + '<span class="math-operator math-binary-operator ' + 'math-implicit-binary-operator"></span>' + rhs;
+            return stringifiedArgs.join('<span class="math-operator math-binary-operator ' + 'math-implicit-binary-operator"></span>');
           }
-          return lhs + '<span class="math-operator math-binary-operator ' + 'math-explicit-binary-operator">' + (0, _string.escape)(this.op) + '</span>' + rhs;
+          return stringifiedArgs.join('<span class="math-operator math-binary-operator ' + 'math-explicit-binary-operator">' + (0, _string.escape)(this.op) + '</span>');
         } else {
-          var stringifiedArgs = args.map(function (arg, index) {
-            arg = arg.toHTML(options);
-            if (parens[index]) {
-              // put in parenthesis?
-              arg = '<span class="math-parenthesis math-round-parenthesis">(</span>' + arg + '<span class="math-parenthesis math-round-parenthesis">)</span>';
-            }
-            return arg;
-          });
-          if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) {
-            if (this.implicit && this.getIdentifier() === 'OperatorNode:multiply' && implicit === 'hide') {
-              return stringifiedArgs.join('<span class="math-operator math-binary-operator ' + 'math-implicit-binary-operator"></span>');
-            }
-            return stringifiedArgs.join('<span class="math-operator math-binary-operator ' + 'math-explicit-binary-operator">' + (0, _string.escape)(this.op) + '</span>');
-          } else {
-            // fallback to formatting as a function call
-            return '<span class="math-function">' + (0, _string.escape)(this.fn) + '</span><span class="math-paranthesis math-round-parenthesis">' + '(</span>' + stringifiedArgs.join('<span class="math-separator">,</span>') + '<span class="math-paranthesis math-round-parenthesis">)</span>';
-          }
+          // fallback to formatting as a function call
+          return '<span class="math-function">' + (0, _string.escape)(this.fn) + '</span><span class="math-paranthesis math-round-parenthesis">' + '(</span>' + stringifiedArgs.join('<span class="math-separator">,</span>') + '<span class="math-paranthesis math-round-parenthesis">)</span>';
         }
       }
+    }
 
-      /**
-       * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
-       */
-    }, {
-      key: "_toTex",
-      value: function _toTex(options) {
-        var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
-        var implicit = options && options.implicit ? options.implicit : 'hide';
-        var args = this.args;
-        var parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, true);
-        var op = _latex.latexOperators[this.fn];
-        op = typeof op === 'undefined' ? this.op : op; // fall back to using this.op
-
-        if (args.length === 1) {
-          // unary operators
-          var assoc = (0, _operators.getAssociativity)(this, parenthesis);
-          var operand = args[0].toTex(options);
-          if (parens[0]) {
-            operand = "\\left(".concat(operand, "\\right)");
-          }
-          if (assoc === 'right') {
-            // prefix operator
-            return op + operand;
-          } else if (assoc === 'left') {
-            // postfix operator
-            return operand + op;
-          }
+    /**
+     * Get LaTeX representation
+     * @param {Object} options
+     * @return {string} str
+     */
+    _toTex(options) {
+      const parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
+      const implicit = options && options.implicit ? options.implicit : 'hide';
+      const args = this.args;
+      const parens = calculateNecessaryParentheses(this, parenthesis, implicit, args, true);
+      let op = _latex.latexOperators[this.fn];
+      op = typeof op === 'undefined' ? this.op : op; // fall back to using this.op
 
-          // fall back to postfix
+      if (args.length === 1) {
+        // unary operators
+        const assoc = (0, _operators.getAssociativity)(this, parenthesis);
+        let operand = args[0].toTex(options);
+        if (parens[0]) {
+          operand = `\\left(${operand}\\right)`;
+        }
+        if (assoc === 'right') {
+          // prefix operator
+          return op + operand;
+        } else if (assoc === 'left') {
+          // postfix operator
           return operand + op;
-        } else if (args.length === 2) {
-          // binary operators
-          var lhs = args[0]; // left hand side
-          var lhsTex = lhs.toTex(options);
-          if (parens[0]) {
-            lhsTex = "\\left(".concat(lhsTex, "\\right)");
-          }
-          var rhs = args[1]; // right hand side
-          var rhsTex = rhs.toTex(options);
-          if (parens[1]) {
-            rhsTex = "\\left(".concat(rhsTex, "\\right)");
-          }
+        }
 
-          // handle some exceptions (due to the way LaTeX works)
-          var lhsIdentifier;
-          if (parenthesis === 'keep') {
-            lhsIdentifier = lhs.getIdentifier();
-          } else {
-            // Ignore ParenthesisNodes if in 'keep' mode
-            lhsIdentifier = lhs.getContent().getIdentifier();
-          }
-          switch (this.getIdentifier()) {
-            case 'OperatorNode:divide':
-              // op contains '\\frac' at this point
-              return op + '{' + lhsTex + '}' + '{' + rhsTex + '}';
-            case 'OperatorNode:pow':
-              lhsTex = '{' + lhsTex + '}';
-              rhsTex = '{' + rhsTex + '}';
-              switch (lhsIdentifier) {
-                case 'ConditionalNode': //
-                case 'OperatorNode:divide':
-                  lhsTex = "\\left(".concat(lhsTex, "\\right)");
-              }
-              break;
-            case 'OperatorNode:multiply':
-              if (this.implicit && implicit === 'hide') {
-                return lhsTex + '~' + rhsTex;
-              }
-          }
-          return lhsTex + op + rhsTex;
-        } else if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) {
-          var texifiedArgs = args.map(function (arg, index) {
-            arg = arg.toTex(options);
-            if (parens[index]) {
-              arg = "\\left(".concat(arg, "\\right)");
+        // fall back to postfix
+        return operand + op;
+      } else if (args.length === 2) {
+        // binary operators
+        const lhs = args[0]; // left hand side
+        let lhsTex = lhs.toTex(options);
+        if (parens[0]) {
+          lhsTex = `\\left(${lhsTex}\\right)`;
+        }
+        const rhs = args[1]; // right hand side
+        let rhsTex = rhs.toTex(options);
+        if (parens[1]) {
+          rhsTex = `\\left(${rhsTex}\\right)`;
+        }
+
+        // handle some exceptions (due to the way LaTeX works)
+        let lhsIdentifier;
+        if (parenthesis === 'keep') {
+          lhsIdentifier = lhs.getIdentifier();
+        } else {
+          // Ignore ParenthesisNodes if in 'keep' mode
+          lhsIdentifier = lhs.getContent().getIdentifier();
+        }
+        switch (this.getIdentifier()) {
+          case 'OperatorNode:divide':
+            // op contains '\\frac' at this point
+            return op + '{' + lhsTex + '}' + '{' + rhsTex + '}';
+          case 'OperatorNode:pow':
+            lhsTex = '{' + lhsTex + '}';
+            rhsTex = '{' + rhsTex + '}';
+            switch (lhsIdentifier) {
+              case 'ConditionalNode': //
+              case 'OperatorNode:divide':
+                lhsTex = `\\left(${lhsTex}\\right)`;
             }
-            return arg;
-          });
-          if (this.getIdentifier() === 'OperatorNode:multiply' && this.implicit && implicit === 'hide') {
-            return texifiedArgs.join('~');
+            break;
+          case 'OperatorNode:multiply':
+            if (this.implicit && implicit === 'hide') {
+              return lhsTex + '~' + rhsTex;
+            }
+        }
+        return lhsTex + op + rhsTex;
+      } else if (args.length > 2 && (this.getIdentifier() === 'OperatorNode:add' || this.getIdentifier() === 'OperatorNode:multiply')) {
+        const texifiedArgs = args.map(function (arg, index) {
+          arg = arg.toTex(options);
+          if (parens[index]) {
+            arg = `\\left(${arg}\\right)`;
           }
-          return texifiedArgs.join(op);
-        } else {
-          // fall back to formatting as a function call
-          // as this is a fallback, it doesn't use
-          // fancy function names
-          return '\\mathrm{' + this.fn + '}\\left(' + args.map(function (arg) {
-            return arg.toTex(options);
-          }).join(',') + '\\right)';
+          return arg;
+        });
+        if (this.getIdentifier() === 'OperatorNode:multiply' && this.implicit && implicit === 'hide') {
+          return texifiedArgs.join('~');
         }
+        return texifiedArgs.join(op);
+      } else {
+        // fall back to formatting as a function call
+        // as this is a fallback, it doesn't use
+        // fancy function names
+        return '\\mathrm{' + this.fn + '}\\left(' + args.map(function (arg) {
+          return arg.toTex(options);
+        }).join(',') + '\\right)';
       }
+    }
 
-      /**
-       * Get identifier.
-       * @return {string}
-       */
-    }, {
-      key: "getIdentifier",
-      value: function getIdentifier() {
-        return this.type + ':' + this.fn;
-      }
-    }], [{
-      key: "fromJSON",
-      value: function fromJSON(json) {
-        return new OperatorNode(json.op, json.fn, json.args, json.implicit, json.isPercentage);
-      }
-    }]);
-  }(Node);
-  (0, _defineProperty2["default"])(OperatorNode, "name", name);
+    /**
+     * Get identifier.
+     * @return {string}
+     */
+    getIdentifier() {
+      return this.type + ':' + this.fn;
+    }
+  }
+  (0, _defineProperty2.default)(OperatorNode, "name", name);
   return OperatorNode;
 }, {
   isClass: true,