mathjs 11.2.1 → 11.3.0

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

@@ -7,7 +7,6 @@ export var createParenthesisNode = /* #__PURE__ */factory(name, dependencies, _r
   var {
     Node
   } = _ref;
-
   class ParenthesisNode extends Node {
     /**
      * @constructor ParenthesisNode
@@ -17,22 +16,20 @@ export var createParenthesisNode = /* #__PURE__ */factory(name, dependencies, _r
      * @extends {Node}
      */
     constructor(content) {
-      super(); // validate input
-
+      super();
+      // validate input
       if (!isNode(content)) {
         throw new TypeError('Node expected for parameter "content"');
       }
-
       this.content = content;
     }
-
     get type() {
       return name;
     }
-
     get isParenthesisNode() {
       return true;
     }
+
     /**
      * Compile a node into a JavaScript function.
      * This basically pre-calculates as much as possible and only leaves open
@@ -46,78 +43,70 @@ export var createParenthesisNode = /* #__PURE__ */factory(name, dependencies, _r
      * @return {function} Returns a function which can be called like:
      *                        evalNode(scope: Object, args: Object, context: *)
      */
-
-
     _compile(math, argNames) {
       return this.content._compile(math, argNames);
     }
+
     /**
      * Get the content of the current Node.
      * @return {Node} content
      * @override
      **/
-
-
     getContent() {
       return this.content.getContent();
     }
+
     /**
      * Execute a callback for each of the child nodes of this node
      * @param {function(child: Node, path: string, parent: Node)} callback
      */
-
-
     forEach(callback) {
       callback(this.content, 'content', this);
     }
+
     /**
      * Create a new ParenthesisNode whose child is the result of calling
      * the provided callback function on the child of this node.
      * @param {function(child: Node, path: string, parent: Node) : Node} callback
      * @returns {ParenthesisNode} Returns a clone of the node
      */
-
-
     map(callback) {
       var content = callback(this.content, 'content', this);
       return new ParenthesisNode(content);
     }
+
     /**
      * Create a clone of this node, a shallow copy
      * @return {ParenthesisNode}
      */
-
-
     clone() {
       return new ParenthesisNode(this.content);
     }
+
     /**
      * Get string representation
      * @param {Object} options
      * @return {string} str
      * @override
      */
-
-
     _toString(options) {
       if (!options || options && !options.parenthesis || options && options.parenthesis === 'keep') {
         return '(' + this.content.toString(options) + ')';
       }
-
       return this.content.toString(options);
     }
+
     /**
      * Get a JSON representation of the node
      * @returns {Object}
      */
-
-
     toJSON() {
       return {
         mathjs: name,
         content: this.content
       };
     }
+
     /**
      * Instantiate an ParenthesisNode from its JSON representation
      * @param {Object} json  An object structured like
@@ -125,46 +114,37 @@ export var createParenthesisNode = /* #__PURE__ */factory(name, dependencies, _r
      *                       where mathjs is optional
      * @returns {ParenthesisNode}
      */
-
-
     static fromJSON(json) {
       return new ParenthesisNode(json.content);
     }
+
     /**
      * Get HTML representation
      * @param {Object} options
      * @return {string} str
      * @override
      */
-
-
     toHTML(options) {
       if (!options || options && !options.parenthesis || options && options.parenthesis === 'keep') {
         return '<span class="math-parenthesis math-round-parenthesis">(</span>' + this.content.toHTML(options) + '<span class="math-parenthesis math-round-parenthesis">)</span>';
       }
-
       return this.content.toHTML(options);
     }
+
     /**
      * Get LaTeX representation
      * @param {Object} options
      * @return {string} str
      * @override
      */
-
-
     _toTex(options) {
       if (!options || options && !options.parenthesis || options && options.parenthesis === 'keep') {
         return "\\left(".concat(this.content.toTex(options), "\\right)");
       }
-
       return this.content.toTex(options);
     }
-
   }
-
   _defineProperty(ParenthesisNode, "name", name);
-
   return ParenthesisNode;
 }, {
   isClass: true,

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

@@ -8,7 +8,6 @@ export var createRangeNode = /* #__PURE__ */factory(name, dependencies, _ref =>
   var {
     Node
   } = _ref;
-
   /**
    * Calculate the necessary parentheses
    * @param {Node} node
@@ -22,17 +21,14 @@ export var createRangeNode = /* #__PURE__ */factory(name, dependencies, _ref =>
     var parens = {};
     var startPrecedence = getPrecedence(node.start, parenthesis, implicit);
     parens.start = startPrecedence !== null && startPrecedence <= precedence || parenthesis === 'all';
-
     if (node.step) {
       var stepPrecedence = getPrecedence(node.step, parenthesis, implicit);
       parens.step = stepPrecedence !== null && stepPrecedence <= precedence || parenthesis === 'all';
     }
-
     var endPrecedence = getPrecedence(node.end, parenthesis, implicit);
     parens.end = endPrecedence !== null && endPrecedence <= precedence || parenthesis === 'all';
     return parens;
   }
-
   class RangeNode extends Node {
     /**
      * @constructor RangeNode
@@ -43,33 +39,29 @@ export var createRangeNode = /* #__PURE__ */factory(name, dependencies, _ref =>
      * @param {Node} [step] optional step
      */
     constructor(start, end, step) {
-      super(); // validate inputs
-
+      super();
+      // validate inputs
       if (!isNode(start)) throw new TypeError('Node expected');
       if (!isNode(end)) throw new TypeError('Node expected');
       if (step && !isNode(step)) throw new TypeError('Node expected');
       if (arguments.length > 3) throw new Error('Too many arguments');
       this.start = start; // included lower-bound
-
       this.end = end; // included upper-bound
-
       this.step = step || null; // optional step
     }
 
     get type() {
       return name;
     }
-
     get isRangeNode() {
       return true;
     }
+
     /**
      * Check whether the RangeNode needs the `end` symbol to be defined.
      * This end is the size of the Matrix in current dimension.
      * @return {boolean}
      */
-
-
     needsEnd() {
       // find all `end` symbols in this RangeNode
       var endSymbols = this.filter(function (node) {
@@ -77,6 +69,7 @@ export var createRangeNode = /* #__PURE__ */factory(name, dependencies, _ref =>
       });
       return endSymbols.length > 0;
     }
+
     /**
      * Compile a node into a JavaScript function.
      * This basically pre-calculates as much as possible and only leaves open
@@ -90,18 +83,12 @@ export var createRangeNode = /* #__PURE__ */factory(name, dependencies, _ref =>
      * @return {function} Returns a function which can be called like:
      *                        evalNode(scope: Object, args: Object, context: *)
      */
-
-
     _compile(math, argNames) {
       var range = math.range;
-
       var evalStart = this.start._compile(math, argNames);
-
       var evalEnd = this.end._compile(math, argNames);
-
       if (this.step) {
         var evalStep = this.step._compile(math, argNames);
-
         return function evalRangeNode(scope, args, context) {
           return range(evalStart(scope, args, context), evalEnd(scope, args, context), evalStep(scope, args, context));
         };
@@ -111,85 +98,72 @@ export var createRangeNode = /* #__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) {
       callback(this.start, 'start', this);
       callback(this.end, 'end', this);
-
       if (this.step) {
         callback(this.step, 'step', this);
       }
     }
+
     /**
      * Create a new RangeNode 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 {RangeNode} Returns a transformed copy of the node
      */
-
-
     map(callback) {
       return new RangeNode(this._ifNode(callback(this.start, 'start', this)), this._ifNode(callback(this.end, 'end', this)), this.step && this._ifNode(callback(this.step, 'step', this)));
     }
+
     /**
      * Create a clone of this node, a shallow copy
      * @return {RangeNode}
      */
-
-
     clone() {
       return new RangeNode(this.start, this.end, this.step && this.step);
     }
+
     /**
      * Get string representation
      * @param {Object} options
      * @return {string} str
      */
-
-
     _toString(options) {
       var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
-      var parens = calculateNecessaryParentheses(this, parenthesis, options && options.implicit); // format string as start:step:stop
+      var parens = calculateNecessaryParentheses(this, parenthesis, options && options.implicit);
 
+      // format string as start:step:stop
       var str;
       var start = this.start.toString(options);
-
       if (parens.start) {
         start = '(' + start + ')';
       }
-
       str = start;
-
       if (this.step) {
         var step = this.step.toString(options);
-
         if (parens.step) {
           step = '(' + step + ')';
         }
-
         str += ':' + step;
       }
-
       var end = this.end.toString(options);
-
       if (parens.end) {
         end = '(' + end + ')';
       }
-
       str += ':' + end;
       return str;
     }
+
     /**
      * Get a JSON representation of the node
      * @returns {Object}
      */
-
-
     toJSON() {
       return {
         mathjs: name,
@@ -198,6 +172,7 @@ export var createRangeNode = /* #__PURE__ */factory(name, dependencies, _ref =>
         step: this.step
       };
     }
+
     /**
      * Instantiate an RangeNode from its JSON representation
      * @param {Object} json
@@ -206,90 +181,69 @@ export var createRangeNode = /* #__PURE__ */factory(name, dependencies, _ref =>
      *     where mathjs is optional
      * @returns {RangeNode}
      */
-
-
     static fromJSON(json) {
       return new RangeNode(json.start, json.end, json.step);
     }
+
     /**
      * Get HTML representation
      * @param {Object} options
      * @return {string} str
      */
-
-
     toHTML(options) {
       var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
-      var parens = calculateNecessaryParentheses(this, parenthesis, options && options.implicit); // format string as start:step:stop
+      var parens = calculateNecessaryParentheses(this, parenthesis, options && options.implicit);
 
+      // format string as start:step:stop
       var str;
       var start = this.start.toHTML(options);
-
       if (parens.start) {
         start = '<span class="math-parenthesis math-round-parenthesis">(</span>' + start + '<span class="math-parenthesis math-round-parenthesis">)</span>';
       }
-
       str = start;
-
       if (this.step) {
         var step = this.step.toHTML(options);
-
         if (parens.step) {
           step = '<span class="math-parenthesis math-round-parenthesis">(</span>' + step + '<span class="math-parenthesis math-round-parenthesis">)</span>';
         }
-
         str += '<span class="math-operator math-range-operator">:</span>' + step;
       }
-
       var end = this.end.toHTML(options);
-
       if (parens.end) {
         end = '<span class="math-parenthesis math-round-parenthesis">(</span>' + end + '<span class="math-parenthesis math-round-parenthesis">)</span>';
       }
-
       str += '<span class="math-operator math-range-operator">:</span>' + end;
       return str;
     }
+
     /**
      * Get LaTeX representation
      * @params {Object} options
      * @return {string} str
      */
-
-
     _toTex(options) {
       var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
       var parens = calculateNecessaryParentheses(this, parenthesis, options && options.implicit);
       var str = this.start.toTex(options);
-
       if (parens.start) {
         str = "\\left(".concat(str, "\\right)");
       }
-
       if (this.step) {
         var step = this.step.toTex(options);
-
         if (parens.step) {
           step = "\\left(".concat(step, "\\right)");
         }
-
         str += ':' + step;
       }
-
       var end = this.end.toTex(options);
-
       if (parens.end) {
         end = "\\left(".concat(end, "\\right)");
       }
-
       str += ':' + end;
       return str;
     }
-
   }
-
   _defineProperty(RangeNode, "name", name);
-
   return RangeNode;
 }, {
   isClass: true,

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

@@ -18,7 +18,6 @@ export var createRelationalNode = /* #__PURE__ */factory(name, dependencies, _re
     smallerEq: '<=',
     largerEq: '>='
   };
-
   class RelationalNode extends Node {
     /**
      * A node representing a chained conditional expression, such as 'x > y > z'
@@ -33,30 +32,25 @@ export var createRelationalNode = /* #__PURE__ */factory(name, dependencies, _re
      */
     constructor(conditionals, params) {
       super();
-
       if (!Array.isArray(conditionals)) {
         throw new TypeError('Parameter conditionals must be an array');
       }
-
       if (!Array.isArray(params)) {
         throw new TypeError('Parameter params must be an array');
       }
-
       if (conditionals.length !== params.length - 1) {
         throw new TypeError('Parameter params must contain exactly one more element ' + 'than parameter conditionals');
       }
-
       this.conditionals = conditionals;
       this.params = params;
     }
-
     get type() {
       return name;
     }
-
     get isRelationalNode() {
       return true;
     }
+
     /**
      * Compile a node into a JavaScript function.
      * This basically pre-calculates as much as possible and only leaves open
@@ -70,64 +64,55 @@ export var createRelationalNode = /* #__PURE__ */factory(name, dependencies, _re
      * @return {function} Returns a function which can be called like:
      *                        evalNode(scope: Object, args: Object, context: *)
      */
-
-
     _compile(math, argNames) {
       var self = this;
       var compiled = this.params.map(p => p._compile(math, argNames));
       return function evalRelationalNode(scope, args, context) {
         var evalLhs;
         var evalRhs = compiled[0](scope, args, context);
-
         for (var i = 0; i < self.conditionals.length; i++) {
           evalLhs = evalRhs;
           evalRhs = compiled[i + 1](scope, args, context);
           var condFn = getSafeProperty(math, self.conditionals[i]);
-
           if (!condFn(evalLhs, evalRhs)) {
             return false;
           }
         }
-
         return true;
       };
     }
+
     /**
      * Execute a callback for each of the child nodes of this node
      * @param {function(child: Node, path: string, parent: Node)} callback
      */
-
-
     forEach(callback) {
       this.params.forEach((n, i) => callback(n, 'params[' + i + ']', this), this);
     }
+
     /**
      * Create a new RelationalNode 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 {RelationalNode} Returns a transformed copy of the node
      */
-
-
     map(callback) {
       return new RelationalNode(this.conditionals.slice(), this.params.map((n, i) => this._ifNode(callback(n, 'params[' + i + ']', this)), this));
     }
+
     /**
      * Create a clone of this node, a shallow copy
      * @return {RelationalNode}
      */
-
-
     clone() {
       return new RelationalNode(this.conditionals, this.params);
     }
+
     /**
      * Get string representation.
      * @param {Object} options
      * @return {string} str
      */
-
-
     _toString(options) {
       var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
       var precedence = getPrecedence(this, parenthesis, options && options.implicit);
@@ -136,20 +121,17 @@ export var createRelationalNode = /* #__PURE__ */factory(name, dependencies, _re
         return parenthesis === 'all' || paramPrecedence !== null && paramPrecedence <= precedence ? '(' + p.toString(options) + ')' : p.toString(options);
       });
       var ret = paramStrings[0];
-
       for (var i = 0; i < this.conditionals.length; i++) {
         ret += ' ' + operatorMap[this.conditionals[i]];
         ret += ' ' + paramStrings[i + 1];
       }
-
       return ret;
     }
+
     /**
      * Get a JSON representation of the node
      * @returns {Object}
      */
-
-
     toJSON() {
       return {
         mathjs: name,
@@ -157,6 +139,7 @@ export var createRelationalNode = /* #__PURE__ */factory(name, dependencies, _re
         params: this.params
       };
     }
+
     /**
      * Instantiate a RelationalNode from its JSON representation
      * @param {Object} json
@@ -165,18 +148,15 @@ export var createRelationalNode = /* #__PURE__ */factory(name, dependencies, _re
      *     where mathjs is optional
      * @returns {RelationalNode}
      */
-
-
     static fromJSON(json) {
       return new RelationalNode(json.conditionals, json.params);
     }
+
     /**
      * Get HTML representation
      * @param {Object} options
      * @return {string} str
      */
-
-
     toHTML(options) {
       var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
       var precedence = getPrecedence(this, parenthesis, options && options.implicit);
@@ -185,20 +165,17 @@ export var createRelationalNode = /* #__PURE__ */factory(name, dependencies, _re
         return parenthesis === 'all' || paramPrecedence !== null && paramPrecedence <= precedence ? '<span class="math-parenthesis math-round-parenthesis">(</span>' + p.toHTML(options) + '<span class="math-parenthesis math-round-parenthesis">)</span>' : p.toHTML(options);
       });
       var ret = paramStrings[0];
-
       for (var i = 0; i < this.conditionals.length; i++) {
         ret += '<span class="math-operator math-binary-operator ' + 'math-explicit-binary-operator">' + escape(operatorMap[this.conditionals[i]]) + '</span>' + paramStrings[i + 1];
       }
-
       return ret;
     }
+
     /**
      * Get LaTeX representation
      * @param {Object} options
      * @return {string} str
      */
-
-
     _toTex(options) {
       var parenthesis = options && options.parenthesis ? options.parenthesis : 'keep';
       var precedence = getPrecedence(this, parenthesis, options && options.implicit);
@@ -207,18 +184,13 @@ export var createRelationalNode = /* #__PURE__ */factory(name, dependencies, _re
         return parenthesis === 'all' || paramPrecedence !== null && paramPrecedence <= precedence ? '\\left(' + p.toTex(options) + '\right)' : p.toTex(options);
       });
       var ret = paramStrings[0];
-
       for (var i = 0; i < this.conditionals.length; i++) {
         ret += latexOperators[this.conditionals[i]] + paramStrings[i + 1];
       }
-
       return ret;
     }
-
   }
-
   _defineProperty(RelationalNode, "name", name);
-
   return RelationalNode;
 }, {
   isClass: true,