mathjs 11.2.1 → 11.3.0

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

@@ -12,7 +12,6 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
   var {
     Node
   } = _ref;
-
   /**
    * Returns true if the expression starts with a constant, under
    * the current parenthesization:
@@ -22,21 +21,18 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
    */
   function startsWithConstant(expr, parenthesis) {
     var curNode = expr;
-
     if (parenthesis === 'auto') {
       while (isParenthesisNode(curNode)) {
         curNode = curNode.content;
       }
     }
-
     if (isConstantNode(curNode)) return true;
-
     if (isOperatorNode(curNode)) {
       return startsWithConstant(curNode.args[0], parenthesis);
     }
-
     return false;
   }
+
   /**
    * Calculate which parentheses are necessary. Gets an OperatorNode
    * (which is the root of the tree) and an Array of Nodes
@@ -50,13 +46,10 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
    * @return {boolean[]}
    * @private
    */
-
-
   function calculateNecessaryParentheses(root, parenthesis, implicit, args, latex) {
     // precedence of the root OperatorNode
     var precedence = getPrecedence(root, parenthesis, implicit);
     var associativity = 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) {
@@ -66,30 +59,26 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
           case 'SymbolNode':
           case 'ParenthesisNode':
             return false;
-
           default:
             return true;
         }
       });
     }
-
     var result;
-
     switch (args.length) {
       case 0:
         result = [];
         break;
-
       case 1:
         // unary operators
         {
           // precedence of the operand
-          var operandPrecedence = getPrecedence(args[0], parenthesis, implicit, root); // handle special cases for LaTeX, where some of the parentheses aren't needed
+          var operandPrecedence = 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;
-
             if (parenthesis === 'keep') {
               operandIdentifier = args[0].getIdentifier();
               rootIdentifier = root.getIdentifier();
@@ -98,45 +87,38 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
               operandIdentifier = args[0].getContent().getIdentifier();
               rootIdentifier = root.getContent().getIdentifier();
             }
-
             if (properties[precedence][rootIdentifier].latexLeftParens === false) {
               result = [false];
               break;
             }
-
             if (properties[operandPrecedence][operandIdentifier].latexParens === false) {
               result = [false];
               break;
             }
           }
-
           if (operandPrecedence === null) {
             // if the operand has no defined precedence, no parens are needed
             result = [false];
             break;
           }
-
           if (operandPrecedence <= precedence) {
             // if the operands precedence is lower, parens are needed
             result = [true];
             break;
-          } // otherwise, no parens needed
-
+          }
 
+          // otherwise, no parens needed
           result = [false];
         }
         break;
-
       case 2:
         // binary operators
         {
           var lhsParens; // left hand side needs parenthesis?
           // precedence of the left hand side
-
-          var lhsPrecedence = getPrecedence(args[0], parenthesis, implicit, root); // is the root node associative with the left hand side
-
+          var lhsPrecedence = getPrecedence(args[0], parenthesis, implicit, root);
+          // is the root node associative with the left hand side
           var assocWithLhs = isAssociativeWith(root, args[0], parenthesis);
-
           if (lhsPrecedence === null) {
             // if the left hand side has no defined precedence, no parens are needed
             // FunctionNode for example
@@ -152,14 +134,11 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
           } else {
             lhsParens = false;
           }
-
           var rhsParens; // right hand side needs parenthesis?
           // precedence of the right hand side
-
-          var rhsPrecedence = getPrecedence(args[1], parenthesis, implicit, root); // is the root node associative with the right hand side?
-
+          var rhsPrecedence = getPrecedence(args[1], parenthesis, implicit, root);
+          // is the root node associative with the right hand side?
           var assocWithRhs = isAssociativeWith(root, args[1], parenthesis);
-
           if (rhsPrecedence === null) {
             // if the right hand side has no defined precedence, no parens are needed
             // FunctionNode for example
@@ -174,15 +153,13 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
             rhsParens = true;
           } else {
             rhsParens = false;
-          } // handle special cases for LaTeX, where some of the parentheses aren't needed
-
+          }
 
+          // handle special cases for LaTeX, where some of the parentheses aren't needed
           if (latex) {
             var _rootIdentifier;
-
             var lhsIdentifier;
             var rhsIdentifier;
-
             if (parenthesis === 'keep') {
               _rootIdentifier = root.getIdentifier();
               lhsIdentifier = root.args[0].getIdentifier();
@@ -193,39 +170,32 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
               lhsIdentifier = root.args[0].getContent().getIdentifier();
               rhsIdentifier = root.args[1].getContent().getIdentifier();
             }
-
             if (lhsPrecedence !== null) {
               if (properties[precedence][_rootIdentifier].latexLeftParens === false) {
                 lhsParens = false;
               }
-
               if (properties[lhsPrecedence][lhsIdentifier].latexParens === false) {
                 lhsParens = false;
               }
             }
-
             if (rhsPrecedence !== null) {
               if (properties[precedence][_rootIdentifier].latexRightParens === false) {
                 rhsParens = false;
               }
-
               if (properties[rhsPrecedence][rhsIdentifier].latexParens === false) {
                 rhsParens = false;
               }
             }
           }
-
           result = [lhsParens, rhsParens];
         }
         break;
-
       default:
         if (root.getIdentifier() === 'OperatorNode:add' || root.getIdentifier() === 'OperatorNode:multiply') {
           result = args.map(function (arg) {
             var argPrecedence = getPrecedence(arg, parenthesis, implicit, root);
             var assocWithArg = isAssociativeWith(root, arg, parenthesis);
             var argAssociativity = getAssociativity(arg, parenthesis);
-
             if (argPrecedence === null) {
               // if the argument has no defined precedence, no parens are needed
               return false;
@@ -234,18 +204,16 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
             } else if (argPrecedence < precedence) {
               return true;
             }
-
             return false;
           });
         }
-
         break;
-    } // Handles an edge case of parentheses with implicit multiplication
+    }
+
+    // Handles an edge case of parentheses with implicit multiplication
     // of ConstantNode.
     // 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) {
         if (startsWithConstant(args[i], parenthesis) && !result[i - 1] && (parenthesis !== 'keep' || !isParenthesisNode(args[i - 1]))) {
@@ -253,10 +221,8 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
         }
       }
     }
-
     return result;
   }
-
   class OperatorNode extends Node {
     /**
      * @constructor OperatorNode
@@ -270,34 +236,30 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
      * @param {boolean} [isPercentage] Is this an percentage Operation?
      */
     constructor(op, fn, args, implicit, isPercentage) {
-      super(); // validate input
-
+      super();
+      // validate input
       if (typeof op !== 'string') {
         throw new TypeError('string expected for parameter "op"');
       }
-
       if (typeof fn !== 'string') {
         throw new TypeError('string expected for parameter "fn"');
       }
-
       if (!Array.isArray(args) || !args.every(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 || [];
     }
-
     get type() {
       return name;
     }
-
     get isOperatorNode() {
       return true;
     }
+
     /**
      * Compile a node into a JavaScript function.
      * This basically pre-calculates as much as possible and only leaves open
@@ -311,8 +273,6 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
      * @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' || !isSafeMethod(math, this.fn)) {
@@ -322,12 +282,10 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
           throw new Error('No access to function "' + this.fn + '"');
         }
       }
-
       var fn = getSafeProperty(math, this.fn);
       var evalArgs = map(this.args, function (arg) {
         return arg._compile(math, argNames);
       });
-
       if (evalArgs.length === 1) {
         var evalArg0 = evalArgs[0];
         return function evalOperatorNode(scope, args, context) {
@@ -347,148 +305,127 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
         };
       }
     }
+
     /**
      * Execute a callback for each of the child nodes of this node
      * @param {function(child: Node, path: string, parent: Node)} callback
      */
-
-
     forEach(callback) {
       for (var i = 0; i < this.args.length; i++) {
         callback(this.args[i], 'args[' + i + ']', this);
       }
     }
+
     /**
      * 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) {
       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);
     }
+
     /**
      * 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 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;
     }
+
     /**
      * 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;
     }
+
     /**
      * Get string representation.
      * @param {Object} options
      * @return {string} str
      */
-
-
     _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 = getAssociativity(this, parenthesis);
         var operand = args[0].toString(options);
-
         if (parens[0]) {
           operand = '(' + operand + ')';
-        } // for example for "not", we want a space between operand and argument
-
+        }
 
+        // 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;
-        } // fall back to postfix
-
+        }
 
+        // 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(' ');
         }
-
         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}
      */
-
-
     toJSON() {
       return {
         mathjs: name,
@@ -499,6 +436,7 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
         isPercentage: this.isPercentage
       };
     }
+
     /**
      * Instantiate an OperatorNode from its JSON representation
      * @param {Object} json
@@ -512,33 +450,27 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
      *     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) {
       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 = 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">' + escape(this.op) + '</span>' + operand;
@@ -549,41 +481,32 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
       } 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>';
         }
-
         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">' + escape(this.op) + '</span>' + rhs;
       } 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">' + escape(this.op) + '</span>');
         } else {
           // fallback to formatting as a function call
@@ -591,13 +514,12 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
         }
       }
     }
+
     /**
      * Get LaTeX representation
      * @param {Object} options
      * @return {string} str
      */
-
-
     _toTex(options) {
       var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
       var implicit = options && options.implicit ? options.implicit : 'hide';
@@ -610,90 +532,70 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
         // unary operators
         var assoc = 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;
-        } // fall back to postfix
-
+        }
 
+        // fall back to postfix
         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)
-
+        }
 
+        // 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)");
           }
-
           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
@@ -704,20 +606,16 @@ export var createOperatorNode = /* #__PURE__ */factory(name, dependencies, _ref
         }).join(',') + '\\right)';
       }
     }
+
     /**
      * Get identifier.
      * @return {string}
      */
-
-
     getIdentifier() {
       return this.type + ':' + this.fn;
     }
-
   }
-
   _defineProperty(OperatorNode, "name", name);
-
   return OperatorNode;
 }, {
   isClass: true,