mathjs 11.2.1 → 11.3.1

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

@@ -1,47 +1,29 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 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 _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-
 var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-
 var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-
 var _is = require("../../utils/is.js");
-
 var _array = require("../../utils/array.js");
-
 var _string = require("../../utils/string.js");
-
 var _customs = require("../../utils/customs.js");
-
 var _operators = require("../operators.js");
-
 var _latex = require("../../utils/latex.js");
-
 var _factory = require("../../utils/factory.js");
-
 function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2["default"])(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2["default"])(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2["default"])(this, result); }; }
-
 function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
 var name = 'OperatorNode';
 var dependencies = ['Node'];
 var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var Node = _ref.Node;
-
   /**
    * Returns true if the expression starts with a constant, under
    * the current parenthesization:
@@ -51,21 +33,18 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    */
   function startsWithConstant(expr, parenthesis) {
     var curNode = expr;
-
     if (parenthesis === 'auto') {
       while ((0, _is.isParenthesisNode)(curNode)) {
         curNode = curNode.content;
       }
     }
-
     if ((0, _is.isConstantNode)(curNode)) return true;
-
     if ((0, _is.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
@@ -79,13 +58,10 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
    * @return {boolean[]}
    * @private
    */
-
-
   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);
-
     if (parenthesis === 'all' || args.length > 2 && root.getIdentifier() !== 'OperatorNode:add' && root.getIdentifier() !== 'OperatorNode:multiply') {
       return args.map(function (arg) {
         switch (arg.getContent().type) {
@@ -95,30 +71,26 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           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 = (0, _operators.getPrecedence)(args[0], parenthesis, implicit, root); // handle special cases for LaTeX, where some of the parentheses aren't needed
+          var 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;
-
             if (parenthesis === 'keep') {
               operandIdentifier = args[0].getIdentifier();
               rootIdentifier = root.getIdentifier();
@@ -127,45 +99,38 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
               operandIdentifier = args[0].getContent().getIdentifier();
               rootIdentifier = root.getContent().getIdentifier();
             }
-
             if (_operators.properties[precedence][rootIdentifier].latexLeftParens === false) {
               result = [false];
               break;
             }
-
             if (_operators.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 = (0, _operators.getPrecedence)(args[0], parenthesis, implicit, root); // is the root node associative with the left hand side
-
+          var 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);
-
           if (lhsPrecedence === null) {
             // if the left hand side has no defined precedence, no parens are needed
             // FunctionNode for example
@@ -181,14 +146,11 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           } else {
             lhsParens = false;
           }
-
           var rhsParens; // right hand side needs parenthesis?
           // precedence of the right hand side
-
-          var rhsPrecedence = (0, _operators.getPrecedence)(args[1], parenthesis, implicit, root); // is the root node associative with the right hand side?
-
+          var 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);
-
           if (rhsPrecedence === null) {
             // if the right hand side has no defined precedence, no parens are needed
             // FunctionNode for example
@@ -203,15 +165,13 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             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();
@@ -222,39 +182,32 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
               lhsIdentifier = root.args[0].getContent().getIdentifier();
               rhsIdentifier = root.args[1].getContent().getIdentifier();
             }
-
             if (lhsPrecedence !== null) {
               if (_operators.properties[precedence][_rootIdentifier].latexLeftParens === false) {
                 lhsParens = false;
               }
-
               if (_operators.properties[lhsPrecedence][lhsIdentifier].latexParens === false) {
                 lhsParens = false;
               }
             }
-
             if (rhsPrecedence !== null) {
               if (_operators.properties[precedence][_rootIdentifier].latexRightParens === false) {
                 rhsParens = false;
               }
-
               if (_operators.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 = (0, _operators.getPrecedence)(arg, parenthesis, implicit, root);
             var assocWithArg = (0, _operators.isAssociativeWith)(root, arg, parenthesis);
             var argAssociativity = (0, _operators.getAssociativity)(arg, parenthesis);
-
             if (argPrecedence === null) {
               // if the argument has no defined precedence, no parens are needed
               return false;
@@ -263,18 +216,16 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             } 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' || !(0, _is.isParenthesisNode)(args[i - 1]))) {
@@ -282,15 +233,11 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
         }
       }
     }
-
     return result;
   }
-
   var OperatorNode = /*#__PURE__*/function (_Node) {
     (0, _inherits2["default"])(OperatorNode, _Node);
-
     var _super = _createSuper(OperatorNode);
-
     /**
      * @constructor OperatorNode
      * @extends {Node}
@@ -304,22 +251,18 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
      */
     function OperatorNode(op, fn, args, implicit, isPercentage) {
       var _this;
-
       (0, _classCallCheck2["default"])(this, OperatorNode);
-      _this = _super.call(this); // validate input
-
+      _this = _super.call(this);
+      // 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(_is.isNode)) {
         throw new TypeError('Array containing Nodes expected for parameter "args"');
       }
-
       _this.implicit = implicit === true;
       _this.isPercentage = isPercentage === true;
       _this.op = op;
@@ -327,7 +270,6 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
       _this.args = args || [];
       return _this;
     }
-
     (0, _createClass2["default"])(OperatorNode, [{
       key: "type",
       get: function get() {
@@ -338,6 +280,7 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
       get: function get() {
         return true;
       }
+
       /**
        * Compile a node into a JavaScript function.
        * This basically pre-calculates as much as possible and only leaves open
@@ -351,7 +294,6 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
        * @return {function} Returns a function which can be called like:
        *                        evalNode(scope: Object, args: Object, context: *)
        */
-
     }, {
       key: "_compile",
       value: function _compile(math, argNames) {
@@ -363,12 +305,10 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
             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 (evalArgs.length === 1) {
           var evalArg0 = evalArgs[0];
           return function evalOperatorNode(scope, args, context) {
@@ -388,11 +328,11 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           };
         }
       }
+
       /**
        * 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) {
@@ -400,64 +340,62 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           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
        */
-
     }, {
       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);
       }
+
       /**
        * 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);
       }
+
       /**
        * 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;
       }
+
       /**
        * 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;
       }
+
       /**
        * Get string representation.
        * @param {Object} options
        * @return {string} str
        */
-
     }, {
       key: "_toString",
       value: function _toString(options) {
@@ -465,76 +403,64 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
         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 + ')';
-          } // 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}
        */
-
     }, {
       key: "toJSON",
       value: function toJSON() {
@@ -547,6 +473,7 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           isPercentage: this.isPercentage
         };
       }
+
       /**
        * Instantiate an OperatorNode from its JSON representation
        * @param {Object} json
@@ -560,7 +487,6 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
        *     where mathjs is optional
        * @returns {OperatorNode}
        */
-
     }, {
       key: "toHTML",
       value:
@@ -574,16 +500,13 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
         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;
@@ -594,41 +517,32 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
         } 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">' + (0, _string.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">' + (0, _string.escape)(this.op) + '</span>');
           } else {
             // fallback to formatting as a function call
@@ -636,12 +550,12 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           }
         }
       }
+
       /**
        * Get LaTeX representation
        * @param {Object} options
        * @return {string} str
        */
-
     }, {
       key: "_toTex",
       value: function _toTex(options) {
@@ -656,90 +570,70 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           // 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;
-          } // 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
@@ -750,11 +644,11 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
           }).join(',') + '\\right)';
         }
       }
+
       /**
        * Get identifier.
        * @return {string}
        */
-
     }, {
       key: "getIdentifier",
       value: function getIdentifier() {
@@ -768,7 +662,6 @@ var createOperatorNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     }]);
     return OperatorNode;
   }(Node);
-
   (0, _defineProperty2["default"])(OperatorNode, "name", name);
   return OperatorNode;
 }, {