mathjs 11.2.1 → 11.3.1

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

@@ -9,7 +9,6 @@ export var createNode = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     mathWithTransform
   } = _ref;
-
   /**
    * Validate the symbol names of a scope.
    * Throws an error when the scope contains an illegal symbol.
@@ -22,25 +21,23 @@ export var createNode = /* #__PURE__ */factory(name, dependencies, _ref => {
       }
     }
   }
-
   class Node {
     get type() {
       return 'Node';
     }
-
     get isNode() {
       return true;
     }
+
     /**
      * Evaluate the node
      * @param {Object} [scope]  Scope to read/write variables
      * @return {*}              Returns the result
      */
-
-
     evaluate(scope) {
       return this.compile().evaluate(scope);
     }
+
     /**
      * Compile the node into an optimized, evauatable JavaScript function
      * @return {{evaluate: function([Object])}} object
@@ -49,26 +46,20 @@ export var createNode = /* #__PURE__ */factory(name, dependencies, _ref => {
      *                where scope is an optional object with
      *                variables.
      */
-
-
     compile() {
       var expr = this._compile(mathWithTransform, {});
-
       var args = {};
       var context = null;
-
       function evaluate(scope) {
         var s = createMap(scope);
-
         _validateScope(s);
-
         return expr(s, args, context);
       }
-
       return {
         evaluate
       };
     }
+
     /**
      * Compile a node into a JavaScript function.
      * This basically pre-calculates as much as possible and only leaves open
@@ -82,71 +73,64 @@ export var createNode = /* #__PURE__ */factory(name, dependencies, _ref => {
      * @return {function} Returns a function which can be called like:
      *                        evalNode(scope: Object, args: Object, context: *)
      */
-
-
     _compile(math, argNames) {
       throw new Error('Method _compile must be implemented by type ' + this.type);
     }
+
     /**
      * Execute a callback for each of the child nodes of this node
      * @param {function(child: Node, path: string, parent: Node)} callback
      */
-
-
     forEach(callback) {
       // must be implemented by each of the Node implementations
       throw new Error('Cannot run forEach on a Node interface');
     }
+
     /**
      * Create a new Node 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) {
       // must be implemented by each of the Node implementations
       throw new Error('Cannot run map on a Node interface');
     }
+
     /**
      * Validate whether an object is a Node, for use with map
      * @param {Node} node
      * @returns {Node} Returns the input if it's a node, else throws an Error
      * @protected
      */
-
-
     _ifNode(node) {
       if (!isNode(node)) {
         throw new TypeError('Callback function must return a Node');
       }
-
       return node;
     }
+
     /**
      * Recursively traverse all nodes in a node tree. Executes given callback for
      * this node and each of its child nodes.
      * @param {function(node: Node, path: string, parent: Node)} callback
      *          A callback called for every node in the node tree.
      */
-
-
     traverse(callback) {
       // execute callback for itself
       // eslint-disable-next-line
-      callback(this, null, null); // recursively traverse over all children of a node
+      callback(this, null, null);
 
+      // recursively traverse over all children of a node
       function _traverse(node, callback) {
         node.forEach(function (child, path, parent) {
           callback(child, path, parent);
-
           _traverse(child, callback);
         });
       }
-
       _traverse(this, callback);
     }
+
     /**
      * Recursively transform a node tree via a transform function.
      *
@@ -169,22 +153,18 @@ export var createNode = /* #__PURE__ */factory(name, dependencies, _ref => {
      *          callback(node: Node, index: string, parent: Node) : Node
      * @return {Node} Returns the original node or its replacement
      */
-
-
     transform(callback) {
       function _transform(child, path, parent) {
         var replacement = callback(child, path, parent);
-
         if (replacement !== child) {
           // stop iterating when the node is replaced
           return replacement;
         }
-
         return child.map(_transform);
       }
-
       return _transform(this, null, null);
     }
+
     /**
      * Find any node in the node tree matching given filter function. For
      * example, to find all nodes of type SymbolNode having name 'x':
@@ -200,8 +180,6 @@ export var createNode = /* #__PURE__ */factory(name, dependencies, _ref => {
      * @return {Node[]} nodes
      *            An array with nodes matching given filter criteria
      */
-
-
     filter(callback) {
       var nodes = [];
       this.traverse(function (node, path, parent) {
@@ -211,38 +189,36 @@ export var createNode = /* #__PURE__ */factory(name, dependencies, _ref => {
       });
       return nodes;
     }
+
     /**
      * Create a shallow clone of this node
      * @return {Node}
      */
-
-
     clone() {
       // must be implemented by each of the Node implementations
       throw new Error('Cannot clone a Node interface');
     }
+
     /**
      * Create a deep clone of this node
      * @return {Node}
      */
-
-
     cloneDeep() {
       return this.map(function (node) {
         return node.cloneDeep();
       });
     }
+
     /**
      * Deep compare this node with another node.
      * @param {Node} other
      * @return {boolean} Returns true when both nodes are of the same type and
      *                   contain the same values (as do their childs)
      */
-
-
     equals(other) {
       return other ? this.type === other.type && deepStrictEqual(this, other) : false;
     }
+
     /**
      * Get string representation. (wrapper function)
      *
@@ -258,28 +234,24 @@ export var createNode = /* #__PURE__ */factory(name, dependencies, _ref => {
      * @param {Object} [options]
      * @return {string}
      */
-
-
     toString(options) {
       var customString = this._getCustomString(options);
-
       if (typeof customString !== 'undefined') {
         return customString;
       }
-
       return this._toString(options);
     }
+
     /**
      * Get a JSON representation of the node
      * Both .toJSON() and the static .fromJSON(json) should be implemented by all
      * implementations of Node
      * @returns {Object}
      */
-
-
     toJSON() {
       throw new Error('Cannot serialize object: toJSON not implemented by ' + this.type);
     }
+
     /**
      * Get HTML representation. (wrapper function)
      *
@@ -295,29 +267,25 @@ export var createNode = /* #__PURE__ */factory(name, dependencies, _ref => {
      * @param {Object} [options]
      * @return {string}
      */
-
-
     toHTML(options) {
       var customString = this._getCustomString(options);
-
       if (typeof customString !== 'undefined') {
         return customString;
       }
-
       return this.toHTML(options);
     }
+
     /**
      * Internal function to generate the string output.
      * This has to be implemented by every Node
      *
      * @throws {Error}
      */
-
-
     _toString() {
       // must be implemented by each of the Node implementations
       throw new Error('_toString not implemented for ' + this.type);
     }
+
     /**
      * Get LaTeX representation. (wrapper function)
      *
@@ -333,17 +301,14 @@ export var createNode = /* #__PURE__ */factory(name, dependencies, _ref => {
      * @param {Object} [options]
      * @return {string}
      */
-
-
     toTex(options) {
       var customString = this._getCustomString(options);
-
       if (typeof customString !== 'undefined') {
         return customString;
       }
-
       return this._toTex(options);
     }
+
     /**
      * Internal function to generate the LaTeX output.
      * This has to be implemented by every Node
@@ -351,53 +316,44 @@ export var createNode = /* #__PURE__ */factory(name, dependencies, _ref => {
      * @param {Object} [options]
      * @throws {Error}
      */
-
-
     _toTex(options) {
       // must be implemented by each of the Node implementations
       throw new Error('_toTex not implemented for ' + this.type);
     }
+
     /**
      * Helper used by `to...` functions.
      */
-
-
     _getCustomString(options) {
       if (options && typeof options === 'object') {
         switch (typeof options.handler) {
           case 'object':
           case 'undefined':
             return;
-
           case 'function':
             return options.handler(this, options);
-
           default:
             throw new TypeError('Object or function expected as callback');
         }
       }
     }
+
     /**
      * Get identifier.
      * @return {string}
      */
-
-
     getIdentifier() {
       return this.type;
     }
+
     /**
      * Get the content of the current Node.
      * @return {Node} node
      **/
-
-
     getContent() {
       return this;
     }
-
   }
-
   return Node;
 }, {
   isClass: true,

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

@@ -10,7 +10,6 @@ export var createObjectNode = /* #__PURE__ */factory(name, dependencies, _ref =>
   var {
     Node
   } = _ref;
-
   class ObjectNode extends Node {
     /**
      * @constructor ObjectNode
@@ -20,8 +19,9 @@ export var createObjectNode = /* #__PURE__ */factory(name, dependencies, _ref =>
      */
     constructor(properties) {
       super();
-      this.properties = properties || {}; // validate input
+      this.properties = properties || {};
 
+      // validate input
       if (properties) {
         if (!(typeof properties === 'object') || !Object.keys(properties).every(function (key) {
           return isNode(properties[key]);
@@ -30,14 +30,13 @@ export var createObjectNode = /* #__PURE__ */factory(name, dependencies, _ref =>
         }
       }
     }
-
     get type() {
       return name;
     }
-
     get isObjectNode() {
       return true;
     }
+
     /**
      * Compile a node into a JavaScript function.
      * This basically pre-calculates as much as possible and only leaves open
@@ -51,44 +50,35 @@ export var createObjectNode = /* #__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 evalEntries = {};
-
       for (var key in this.properties) {
         if (hasOwnProperty(this.properties, key)) {
           // we stringify/parse the key here to resolve unicode characters,
           // so you cannot create a key like {"co\\u006Estructor": null}
           var stringifiedKey = stringify(key);
           var parsedKey = JSON.parse(stringifiedKey);
-
           if (!isSafeProperty(this.properties, parsedKey)) {
             throw new Error('No access to property "' + parsedKey + '"');
           }
-
           evalEntries[parsedKey] = this.properties[key]._compile(math, argNames);
         }
       }
-
       return function evalObjectNode(scope, args, context) {
         var obj = {};
-
         for (var _key in evalEntries) {
           if (hasOwnProperty(evalEntries, _key)) {
             obj[_key] = evalEntries[_key](scope, args, context);
           }
         }
-
         return obj;
       };
     }
+
     /**
      * 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 key in this.properties) {
         if (hasOwnProperty(this.properties, key)) {
@@ -96,73 +86,64 @@ export var createObjectNode = /* #__PURE__ */factory(name, dependencies, _ref =>
         }
       }
     }
+
     /**
      * Create a new ObjectNode 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 {ObjectNode} Returns a transformed copy of the node
      */
-
-
     map(callback) {
       var properties = {};
-
       for (var key in this.properties) {
         if (hasOwnProperty(this.properties, key)) {
           properties[key] = this._ifNode(callback(this.properties[key], 'properties[' + stringify(key) + ']', this));
         }
       }
-
       return new ObjectNode(properties);
     }
+
     /**
      * Create a clone of this node, a shallow copy
      * @return {ObjectNode}
      */
-
-
     clone() {
       var properties = {};
-
       for (var key in this.properties) {
         if (hasOwnProperty(this.properties, key)) {
           properties[key] = this.properties[key];
         }
       }
-
       return new ObjectNode(properties);
     }
+
     /**
      * Get string representation
      * @param {Object} options
      * @return {string} str
      * @override
      */
-
-
     _toString(options) {
       var entries = [];
-
       for (var key in this.properties) {
         if (hasOwnProperty(this.properties, key)) {
           entries.push(stringify(key) + ': ' + this.properties[key].toString(options));
         }
       }
-
       return '{' + entries.join(', ') + '}';
     }
+
     /**
      * Get a JSON representation of the node
      * @returns {Object}
      */
-
-
     toJSON() {
       return {
         mathjs: name,
         properties: this.properties
       };
     }
+
     /**
      * Instantiate an OperatorNode from its JSON representation
      * @param {Object} json  An object structured like
@@ -170,54 +151,43 @@ export var createObjectNode = /* #__PURE__ */factory(name, dependencies, _ref =>
      *                       where mathjs is optional
      * @returns {ObjectNode}
      */
-
-
     static fromJSON(json) {
       return new ObjectNode(json.properties);
     }
+
     /**
      * Get HTML representation
      * @param {Object} options
      * @return {string} str
      * @override
      */
-
-
     toHTML(options) {
       var entries = [];
-
       for (var key in this.properties) {
         if (hasOwnProperty(this.properties, key)) {
           entries.push('<span class="math-symbol math-property">' + escape(key) + '</span>' + '<span class="math-operator math-assignment-operator ' + 'math-property-assignment-operator math-binary-operator">' + ':</span>' + this.properties[key].toHTML(options));
         }
       }
-
       return '<span class="math-parenthesis math-curly-parenthesis">{</span>' + entries.join('<span class="math-separator">,</span>') + '<span class="math-parenthesis math-curly-parenthesis">}</span>';
     }
+
     /**
      * Get LaTeX representation
      * @param {Object} options
      * @return {string} str
      */
-
-
     _toTex(options) {
       var entries = [];
-
       for (var key in this.properties) {
         if (hasOwnProperty(this.properties, key)) {
           entries.push('\\mathbf{' + key + ':} & ' + this.properties[key].toTex(options) + '\\\\');
         }
       }
-
       var tex = '\\left\\{\\begin{array}{ll}' + entries.join('\n') + '\\end{array}\\right\\}';
       return tex;
     }
-
   }
-
   _defineProperty(ObjectNode, "name", name);
-
   return ObjectNode;
 }, {
   isClass: true,