mathjs 12.4.2 → 13.0.0

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

@@ -1,27 +1,21 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createSymbolNode = 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 _string = require("../../utils/string.js");
 var _customs = require("../../utils/customs.js");
 var _factory = require("../../utils/factory.js");
 var _latex = require("../../utils/latex.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 = 'SymbolNode';
-var dependencies = ['math', '?Unit', 'Node'];
-var createSymbolNode = exports.createSymbolNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var math = _ref.math,
-    Unit = _ref.Unit,
-    Node = _ref.Node;
+const name = 'SymbolNode';
+const dependencies = ['math', '?Unit', 'Node'];
+const createSymbolNode = exports.createSymbolNode = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    math,
+    Unit,
+    Node
+  } = _ref;
   /**
    * Check whether some name is a valueless unit like "inch".
    * @param {string} name
@@ -30,7 +24,7 @@ var createSymbolNode = exports.createSymbolNode = /* #__PURE__ */(0, _factory.fa
   function isValuelessUnit(name) {
     return Unit ? Unit.isValuelessUnit(name) : false;
   }
-  var SymbolNode = /*#__PURE__*/function (_Node) {
+  class SymbolNode extends Node {
     /**
      * @constructor SymbolNode
      * @extends {Node}
@@ -38,195 +32,166 @@ var createSymbolNode = exports.createSymbolNode = /* #__PURE__ */(0, _factory.fa
      * @param {string} name
      * @extends {Node}
      */
-    function SymbolNode(name) {
-      var _this;
-      (0, _classCallCheck2["default"])(this, SymbolNode);
-      _this = _callSuper(this, SymbolNode);
+    constructor(name) {
+      super();
       // validate input
       if (typeof name !== 'string') {
         throw new TypeError('String expected for parameter "name"');
       }
-      _this.name = name;
-      return _this;
+      this.name = name;
+    }
+    get type() {
+      return 'SymbolNode';
+    }
+    get isSymbolNode() {
+      return true;
     }
-    (0, _inherits2["default"])(SymbolNode, _Node);
-    return (0, _createClass2["default"])(SymbolNode, [{
-      key: "type",
-      get: function get() {
-        return 'SymbolNode';
-      }
-    }, {
-      key: "isSymbolNode",
-      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) {
-        var name = this.name;
-        if (argNames[name] === true) {
-          // this is a FunctionAssignment argument
-          // (like an x when inside the expression of a function
-          // assignment `f(x) = ...`)
-          return function (scope, args, context) {
-            return (0, _customs.getSafeProperty)(args, name);
-          };
-        } else if (name in math) {
-          return function (scope, args, context) {
-            return scope.has(name) ? scope.get(name) : (0, _customs.getSafeProperty)(math, name);
-          };
-        } else {
-          var isUnit = isValuelessUnit(name);
-          return function (scope, args, context) {
-            return scope.has(name) ? scope.get(name) : isUnit ? new Unit(null, name) : SymbolNode.onUndefinedSymbol(name);
-          };
-        }
+    /**
+     * 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) {
+      const name = this.name;
+      if (argNames[name] === true) {
+        // this is a FunctionAssignment argument
+        // (like an x when inside the expression of a function
+        // assignment `f(x) = ...`)
+        return function (scope, args, context) {
+          return (0, _customs.getSafeProperty)(args, name);
+        };
+      } else if (name in math) {
+        return function (scope, args, context) {
+          return scope.has(name) ? scope.get(name) : (0, _customs.getSafeProperty)(math, name);
+        };
+      } else {
+        const isUnit = isValuelessUnit(name);
+        return function (scope, args, context) {
+          return scope.has(name) ? scope.get(name) : isUnit ? new Unit(null, name) : SymbolNode.onUndefinedSymbol(name);
+        };
       }
+    }
 
-      /**
-       * 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) {
-        // nothing to do, we don't have any children
-      }
+    /**
+     * Execute a callback for each of the child nodes of this node
+     * @param {function(child: Node, path: string, parent: Node)} callback
+     */
+    forEach(callback) {
+      // nothing to do, we don't have any children
+    }
 
-      /**
-       * Create a new SymbolNode with children produced by the given callback.
-       * Trivial since a SymbolNode has no children
-       * @param {function(child: Node, path: string, parent: Node) : Node} callback
-       * @returns {SymbolNode} Returns a clone of the node
-       */
-    }, {
-      key: "map",
-      value: function map(callback) {
-        return this.clone();
-      }
+    /**
+     * Create a new SymbolNode with children produced by the given callback.
+     * Trivial since a SymbolNode has no children
+     * @param {function(child: Node, path: string, parent: Node) : Node} callback
+     * @returns {SymbolNode} Returns a clone of the node
+     */
+    map(callback) {
+      return this.clone();
+    }
 
-      /**
-       * Throws an error 'Undefined symbol {name}'
-       * @param {string} name
-       */
-    }, {
-      key: "clone",
-      value:
-      /**
-       * Create a clone of this node, a shallow copy
-       * @return {SymbolNode}
-       */
-      function clone() {
-        return new SymbolNode(this.name);
-      }
+    /**
+     * Throws an error 'Undefined symbol {name}'
+     * @param {string} name
+     */
+    static onUndefinedSymbol(name) {
+      throw new Error('Undefined symbol ' + name);
+    }
 
-      /**
-       * Get string representation
-       * @param {Object} options
-       * @return {string} str
-       * @override
-       */
-    }, {
-      key: "_toString",
-      value: function _toString(options) {
-        return this.name;
-      }
+    /**
+     * Create a clone of this node, a shallow copy
+     * @return {SymbolNode}
+     */
+    clone() {
+      return new SymbolNode(this.name);
+    }
 
-      /**
-       * Get HTML representation
-       * @param {Object} options
-       * @return {string} str
-       * @override
-       */
-    }, {
-      key: "_toHTML",
-      value: function _toHTML(options) {
-        var name = (0, _string.escape)(this.name);
-        if (name === 'true' || name === 'false') {
-          return '<span class="math-symbol math-boolean">' + name + '</span>';
-        } else if (name === 'i') {
-          return '<span class="math-symbol math-imaginary-symbol">' + name + '</span>';
-        } else if (name === 'Infinity') {
-          return '<span class="math-symbol math-infinity-symbol">' + name + '</span>';
-        } else if (name === 'NaN') {
-          return '<span class="math-symbol math-nan-symbol">' + name + '</span>';
-        } else if (name === 'null') {
-          return '<span class="math-symbol math-null-symbol">' + name + '</span>';
-        } else if (name === 'undefined') {
-          return '<span class="math-symbol math-undefined-symbol">' + name + '</span>';
-        }
-        return '<span class="math-symbol">' + name + '</span>';
-      }
+    /**
+     * Get string representation
+     * @param {Object} options
+     * @return {string} str
+     * @override
+     */
+    _toString(options) {
+      return this.name;
+    }
 
-      /**
-       * Get a JSON representation of the node
-       * @returns {Object}
-       */
-    }, {
-      key: "toJSON",
-      value: function toJSON() {
-        return {
-          mathjs: 'SymbolNode',
-          name: this.name
-        };
+    /**
+     * Get HTML representation
+     * @param {Object} options
+     * @return {string} str
+     * @override
+     */
+    _toHTML(options) {
+      const name = (0, _string.escape)(this.name);
+      if (name === 'true' || name === 'false') {
+        return '<span class="math-symbol math-boolean">' + name + '</span>';
+      } else if (name === 'i') {
+        return '<span class="math-symbol math-imaginary-symbol">' + name + '</span>';
+      } else if (name === 'Infinity') {
+        return '<span class="math-symbol math-infinity-symbol">' + name + '</span>';
+      } else if (name === 'NaN') {
+        return '<span class="math-symbol math-nan-symbol">' + name + '</span>';
+      } else if (name === 'null') {
+        return '<span class="math-symbol math-null-symbol">' + name + '</span>';
+      } else if (name === 'undefined') {
+        return '<span class="math-symbol math-undefined-symbol">' + name + '</span>';
       }
+      return '<span class="math-symbol">' + name + '</span>';
+    }
 
-      /**
-       * Instantiate a SymbolNode from its JSON representation
-       * @param {Object} json  An object structured like
-       *                       `{"mathjs": "SymbolNode", name: "x"}`,
-       *                       where mathjs is optional
-       * @returns {SymbolNode}
-       */
-    }, {
-      key: "_toTex",
-      value:
-      /**
-       * Get LaTeX representation
-       * @param {Object} options
-       * @return {string} str
-       * @override
-       */
-      function _toTex(options) {
-        var isUnit = false;
-        if (typeof math[this.name] === 'undefined' && isValuelessUnit(this.name)) {
-          isUnit = true;
-        }
-        var symbol = (0, _latex.toSymbol)(this.name, isUnit);
-        if (symbol[0] === '\\') {
-          // no space needed if the symbol starts with '\'
-          return symbol;
-        }
-        // the space prevents symbols from breaking stuff like '\cdot'
-        // if it's written right before the symbol
-        return ' ' + symbol;
-      }
-    }], [{
-      key: "onUndefinedSymbol",
-      value: function onUndefinedSymbol(name) {
-        throw new Error('Undefined symbol ' + name);
+    /**
+     * Get a JSON representation of the node
+     * @returns {Object}
+     */
+    toJSON() {
+      return {
+        mathjs: 'SymbolNode',
+        name: this.name
+      };
+    }
+
+    /**
+     * Instantiate a SymbolNode from its JSON representation
+     * @param {Object} json  An object structured like
+     *                       `{"mathjs": "SymbolNode", name: "x"}`,
+     *                       where mathjs is optional
+     * @returns {SymbolNode}
+     */
+    static fromJSON(json) {
+      return new SymbolNode(json.name);
+    }
+
+    /**
+     * Get LaTeX representation
+     * @param {Object} options
+     * @return {string} str
+     * @override
+     */
+    _toTex(options) {
+      let isUnit = false;
+      if (typeof math[this.name] === 'undefined' && isValuelessUnit(this.name)) {
+        isUnit = true;
       }
-    }, {
-      key: "fromJSON",
-      value: function fromJSON(json) {
-        return new SymbolNode(json.name);
+      const symbol = (0, _latex.toSymbol)(this.name, isUnit);
+      if (symbol[0] === '\\') {
+        // no space needed if the symbol starts with '\'
+        return symbol;
       }
-    }]);
-  }(Node);
+      // the space prevents symbols from breaking stuff like '\cdot'
+      // if it's written right before the symbol
+      return ' ' + symbol;
+    }
+  }
   return SymbolNode;
 }, {
   isClass: true,

package/lib/cjs/expression/node/utils/access.js

@@ -1,15 +1,15 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.accessFactory = accessFactory;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _errorTransform = require("../../transform/utils/errorTransform.js");
 var _customs = require("../../../utils/customs.js");
 function accessFactory(_ref) {
-  var subset = _ref.subset;
+  let {
+    subset
+  } = _ref;
   /**
    * Retrieve part of an object:
    *
@@ -31,7 +31,7 @@ function accessFactory(_ref) {
       } else if (typeof object === 'string') {
         // TODO: move getStringSubset into a separate util file, use that
         return subset(object, index);
-      } else if ((0, _typeof2["default"])(object) === 'object') {
+      } else if (typeof object === 'object') {
         if (!index.isObjectProperty()) {
           throw new TypeError('Cannot apply a numeric index as object property');
         }

package/lib/cjs/expression/node/utils/assign.js

@@ -1,16 +1,16 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.assignFactory = assignFactory;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _errorTransform = require("../../transform/utils/errorTransform.js");
 var _customs = require("../../../utils/customs.js");
 function assignFactory(_ref) {
-  var subset = _ref.subset,
-    matrix = _ref.matrix;
+  let {
+    subset,
+    matrix
+  } = _ref;
   /**
    * Replace part of an object:
    *
@@ -28,10 +28,10 @@ function assignFactory(_ref) {
   return function assign(object, index, value) {
     try {
       if (Array.isArray(object)) {
-        var result = matrix(object).subset(index, value).valueOf();
+        const result = matrix(object).subset(index, value).valueOf();
 
         // shallow copy all (updated) items into the original array
-        result.forEach(function (item, index) {
+        result.forEach((item, index) => {
           object[index] = item;
         });
         return object;
@@ -41,7 +41,7 @@ function assignFactory(_ref) {
       } else if (typeof object === 'string') {
         // TODO: move setStringSubset into a separate util file, use that
         return subset(object, index, value);
-      } else if ((0, _typeof2["default"])(object) === 'object') {
+      } else if (typeof object === 'object') {
         if (!index.isObjectProperty()) {
           throw TypeError('Cannot apply a numeric index as object property');
         }

package/lib/cjs/expression/operators.js

@@ -10,9 +10,7 @@ exports.isAssociativeWith = isAssociativeWith;
 exports.properties = void 0;
 var _object = require("../utils/object.js");
 var _is = require("../utils/is.js");
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } // list of identifiers of nodes in order of their precedence
+// list of identifiers of nodes in order of their precedence
 // also contains information about left/right associativity
 // and which other operator the operator is associative with
 // Example:
@@ -30,7 +28,8 @@ function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len
 //                  left argument doesn't need to be enclosed
 //                  in parentheses
 // latexRightParens: the same for the right argument
-var properties = exports.properties = [{
+
+const properties = exports.properties = [{
   // assignment
   AssignmentNode: {},
   FunctionAssignmentNode: {}
@@ -256,7 +255,7 @@ var properties = exports.properties = [{
  */
 function unwrapParen(_node, parenthesis) {
   if (!parenthesis || parenthesis !== 'auto') return _node;
-  var node = _node;
+  let node = _node;
   while ((0, _is.isParenthesisNode)(node)) node = node.content;
   return node;
 }
@@ -273,14 +272,14 @@ function unwrapParen(_node, parenthesis) {
  * @return {number | null}
  */
 function getPrecedence(_node, parenthesis, implicit, parent) {
-  var node = _node;
+  let node = _node;
   if (parenthesis !== 'keep') {
     // ParenthesisNodes are only ignored when not in 'keep' mode
     node = _node.getContent();
   }
-  var identifier = node.getIdentifier();
-  var precedence = null;
-  for (var i = 0; i < properties.length; i++) {
+  const identifier = node.getIdentifier();
+  let precedence = null;
+  for (let i = 0; i < properties.length; i++) {
     if (identifier in properties[i]) {
       precedence = i;
       break;
@@ -289,7 +288,7 @@ function getPrecedence(_node, parenthesis, implicit, parent) {
   // Bump up precedence of implicit multiplication, except when preceded
   // by a "Rule 2" fraction ( [unaryOp]constant / constant )
   if (identifier === 'OperatorNode:multiply' && node.implicit && implicit !== 'show') {
-    var leftArg = unwrapParen(node.args[0], parenthesis);
+    const leftArg = unwrapParen(node.args[0], parenthesis);
     if (!((0, _is.isConstantNode)(leftArg) && parent && parent.getIdentifier() === 'OperatorNode:divide' && (0, _is.rule2Node)(unwrapParen(parent.args[0], parenthesis))) && !(leftArg.getIdentifier() === 'OperatorNode:divide' && (0, _is.rule2Node)(unwrapParen(leftArg.args[0], parenthesis)) && (0, _is.isConstantNode)(unwrapParen(leftArg.args[1])))) {
       precedence += 1;
     }
@@ -308,18 +307,18 @@ function getPrecedence(_node, parenthesis, implicit, parent) {
  * @throws {Error}
  */
 function getAssociativity(_node, parenthesis) {
-  var node = _node;
+  let node = _node;
   if (parenthesis !== 'keep') {
     // ParenthesisNodes are only ignored when not in 'keep' mode
     node = _node.getContent();
   }
-  var identifier = node.getIdentifier();
-  var index = getPrecedence(node, parenthesis);
+  const identifier = node.getIdentifier();
+  const index = getPrecedence(node, parenthesis);
   if (index === null) {
     // node isn't in the list
     return null;
   }
-  var property = properties[index][identifier];
+  const property = properties[index][identifier];
   if ((0, _object.hasOwnProperty)(property, 'associativity')) {
     if (property.associativity === 'left') {
       return 'left';
@@ -346,18 +345,18 @@ function getAssociativity(_node, parenthesis) {
  */
 function isAssociativeWith(nodeA, nodeB, parenthesis) {
   // ParenthesisNodes are only ignored when not in 'keep' mode
-  var a = parenthesis !== 'keep' ? nodeA.getContent() : nodeA;
-  var b = parenthesis !== 'keep' ? nodeA.getContent() : nodeB;
-  var identifierA = a.getIdentifier();
-  var identifierB = b.getIdentifier();
-  var index = getPrecedence(a, parenthesis);
+  const a = parenthesis !== 'keep' ? nodeA.getContent() : nodeA;
+  const b = parenthesis !== 'keep' ? nodeA.getContent() : nodeB;
+  const identifierA = a.getIdentifier();
+  const identifierB = b.getIdentifier();
+  const index = getPrecedence(a, parenthesis);
   if (index === null) {
     // node isn't in the list
     return null;
   }
-  var property = properties[index][identifierA];
+  const property = properties[index][identifierA];
   if ((0, _object.hasOwnProperty)(property, 'associativeWith') && property.associativeWith instanceof Array) {
-    for (var i = 0; i < property.associativeWith.length; i++) {
+    for (let i = 0; i < property.associativeWith.length; i++) {
       if (property.associativeWith[i] === identifierB) {
         return true;
       }
@@ -379,20 +378,11 @@ function isAssociativeWith(nodeA, nodeB, parenthesis) {
  * @return {string | null} Associated operator symbol, if any
  */
 function getOperator(fn) {
-  var identifier = 'OperatorNode:' + fn;
-  var _iterator = _createForOfIteratorHelper(properties),
-    _step;
-  try {
-    for (_iterator.s(); !(_step = _iterator.n()).done;) {
-      var group = _step.value;
-      if (identifier in group) {
-        return group[identifier].op;
-      }
+  const identifier = 'OperatorNode:' + fn;
+  for (const group of properties) {
+    if (identifier in group) {
+      return group[identifier].op;
     }
-  } catch (err) {
-    _iterator.e(err);
-  } finally {
-    _iterator.f();
   }
   return null;
 }