mathjs 12.4.2 → 13.0.0

package/lib/cjs/type/boolean.js

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", {
 exports.createBoolean = void 0;
 var _factory = require("../utils/factory.js");
 var _collection = require("../utils/collection.js");
-var name = 'boolean';
-var dependencies = ['typed'];
-var createBoolean = exports.createBoolean = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed;
+const name = 'boolean';
+const dependencies = ['typed'];
+const createBoolean = exports.createBoolean = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed
+  } = _ref;
   /**
    * Create a boolean or convert a string or number to a boolean.
    * In case of a number, `true` is returned for non-zero numbers, and `false` in
@@ -38,24 +40,24 @@ var createBoolean = exports.createBoolean = /* #__PURE__ */(0, _factory.factory)
    * @return {boolean | Array | Matrix} The boolean value
    */
   return typed(name, {
-    '': function _() {
+    '': function () {
       return false;
     },
-    "boolean": function boolean(x) {
+    boolean: function (x) {
       return x;
     },
-    number: function number(x) {
+    number: function (x) {
       return !!x;
     },
-    "null": function _null(x) {
+    null: function (x) {
       return false;
     },
-    BigNumber: function BigNumber(x) {
+    BigNumber: function (x) {
       return !x.isZero();
     },
-    string: function string(x) {
+    string: function (x) {
       // try case insensitive
-      var lcase = x.toLowerCase();
+      const lcase = x.toLowerCase();
       if (lcase === 'true') {
         return true;
       } else if (lcase === 'false') {
@@ -63,16 +65,12 @@ var createBoolean = exports.createBoolean = /* #__PURE__ */(0, _factory.factory)
       }
 
       // test whether value is a valid number
-      var num = Number(x);
+      const num = Number(x);
       if (x !== '' && !isNaN(num)) {
         return !!num;
       }
       throw new Error('Cannot convert "' + x + '" to a boolean');
     },
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        return (0, _collection.deepMap)(x, self);
-      };
-    })
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

package/lib/cjs/type/chain/Chain.js

@@ -8,12 +8,14 @@ var _is = require("../../utils/is.js");
 var _string = require("../../utils/string.js");
 var _object = require("../../utils/object.js");
 var _factory = require("../../utils/factory.js");
-var name = 'Chain';
-var dependencies = ['?on', 'math', 'typed'];
-var createChainClass = exports.createChainClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var on = _ref.on,
-    math = _ref.math,
-    typed = _ref.typed;
+const name = 'Chain';
+const dependencies = ['?on', 'math', 'typed'];
+const createChainClass = exports.createChainClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    on,
+    math,
+    typed
+  } = _ref;
   /**
    * @constructor Chain
    * Wrap any value in a chain, allowing to perform chained operations on
@@ -119,7 +121,7 @@ var createChainClass = exports.createChainClass = /* #__PURE__ */(0, _factory.fa
    */
   function createLazyProxy(name, resolver) {
     (0, _object.lazy)(Chain.prototype, name, function outerResolver() {
-      var fn = resolver();
+      const fn = resolver();
       if (typeof fn === 'function') {
         return chainify(fn);
       }
@@ -139,12 +141,12 @@ var createChainClass = exports.createChainClass = /* #__PURE__ */(0, _factory.fa
       if (arguments.length === 0) {
         return new Chain(fn(this.value));
       }
-      var args = [this.value];
-      for (var i = 0; i < arguments.length; i++) {
+      const args = [this.value];
+      for (let i = 0; i < arguments.length; i++) {
         args[i + 1] = arguments[i];
       }
       if (typed.isTypedFunction(fn)) {
-        var sigObject = typed.resolve(fn, args);
+        const sigObject = typed.resolve(fn, args);
         // We want to detect if a rest parameter has matched across the
         // value in the chain and the current arguments of this call.
         // That is the case if and only if the matching signature has
@@ -178,20 +180,15 @@ var createChainClass = exports.createChainClass = /* #__PURE__ */(0, _factory.fa
       // createProxy(name, value)
       createProxy(arg0, arg1);
     } else {
-      var _loop = function _loop(_name) {
-        if ((0, _object.hasOwnProperty)(arg0, _name) && excludedNames[_name] === undefined) {
-          createLazyProxy(_name, function () {
-            return arg0[_name];
-          });
-        }
-      };
       // createProxy(values)
-      for (var _name in arg0) {
-        _loop(_name);
+      for (const name in arg0) {
+        if ((0, _object.hasOwnProperty)(arg0, name) && excludedNames[name] === undefined) {
+          createLazyProxy(name, () => arg0[name]);
+        }
       }
     }
   };
-  var excludedNames = {
+  const excludedNames = {
     expression: true,
     docs: true,
     type: true,

package/lib/cjs/type/chain/function/chain.js

@@ -5,11 +5,13 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createChain = void 0;
 var _factory = require("../../../utils/factory.js");
-var name = 'chain';
-var dependencies = ['typed', 'Chain'];
-var createChain = exports.createChain = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    Chain = _ref.Chain;
+const name = 'chain';
+const dependencies = ['typed', 'Chain'];
+const createChain = exports.createChain = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    Chain
+  } = _ref;
   /**
    * Wrap any value in a chain, allowing to perform chained operations on
    * the value.
@@ -46,10 +48,10 @@ var createChain = exports.createChain = /* #__PURE__ */(0, _factory.factory)(nam
    * @return {math.Chain} The created chain
    */
   return typed(name, {
-    '': function _() {
+    '': function () {
       return new Chain();
     },
-    any: function any(value) {
+    any: function (value) {
       return new Chain(value);
     }
   });

package/lib/cjs/type/complex/Complex.js

@@ -5,30 +5,29 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createComplexClass = void 0;
-var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _complex = _interopRequireDefault(require("complex.js"));
 var _number = require("../../utils/number.js");
 var _is = require("../../utils/is.js");
 var _factory = require("../../utils/factory.js");
-var name = 'Complex';
-var dependencies = [];
-var createComplexClass = exports.createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function () {
+const name = 'Complex';
+const dependencies = [];
+const createComplexClass = exports.createComplexClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, () => {
   /**
    * Attach type information
    */
-  Object.defineProperty(_complex["default"], 'name', {
+  Object.defineProperty(_complex.default, 'name', {
     value: 'Complex'
   });
-  _complex["default"].prototype.constructor = _complex["default"];
-  _complex["default"].prototype.type = 'Complex';
-  _complex["default"].prototype.isComplex = true;
+  _complex.default.prototype.constructor = _complex.default;
+  _complex.default.prototype.type = 'Complex';
+  _complex.default.prototype.isComplex = true;
 
   /**
    * Get a JSON representation of the complex number
    * @returns {Object} Returns a JSON object structured as:
    *                   `{"mathjs": "Complex", "re": 2, "im": 3}`
    */
-  _complex["default"].prototype.toJSON = function () {
+  _complex.default.prototype.toJSON = function () {
     return {
       mathjs: 'Complex',
       re: this.re,
@@ -41,7 +40,7 @@ var createComplexClass = exports.createComplexClass = /* #__PURE__ */(0, _factor
    * The angle phi will be set in the interval of [-pi, pi].
    * @return {{r: number, phi: number}} Returns and object with properties r and phi.
    */
-  _complex["default"].prototype.toPolar = function () {
+  _complex.default.prototype.toPolar = function () {
     return {
       r: this.abs(),
       phi: this.arg()
@@ -57,17 +56,17 @@ var createComplexClass = exports.createComplexClass = /* #__PURE__ */(0, _factor
    *                                                options.
    * @return {string} str
    */
-  _complex["default"].prototype.format = function (options) {
-    var str = '';
-    var im = this.im;
-    var re = this.re;
-    var strRe = (0, _number.format)(this.re, options);
-    var strIm = (0, _number.format)(this.im, options);
+  _complex.default.prototype.format = function (options) {
+    let str = '';
+    let im = this.im;
+    let re = this.re;
+    const strRe = (0, _number.format)(this.re, options);
+    const strIm = (0, _number.format)(this.im, options);
 
     // round either re or im when smaller than the configured precision
-    var precision = (0, _is.isNumber)(options) ? options : options ? options.precision : null;
+    const precision = (0, _is.isNumber)(options) ? options : options ? options.precision : null;
     if (precision !== null) {
-      var epsilon = Math.pow(10, -precision);
+      const epsilon = Math.pow(10, -precision);
       if (Math.abs(re / im) < epsilon) {
         re = 0;
       }
@@ -117,30 +116,30 @@ var createComplexClass = exports.createComplexClass = /* #__PURE__ */(0, _factor
    * @param {*} args...
    * @return {Complex}
    */
-  _complex["default"].fromPolar = function (args) {
+  _complex.default.fromPolar = function (args) {
     switch (arguments.length) {
       case 1:
         {
-          var arg = arguments[0];
-          if ((0, _typeof2["default"])(arg) === 'object') {
-            return (0, _complex["default"])(arg);
+          const arg = arguments[0];
+          if (typeof arg === 'object') {
+            return (0, _complex.default)(arg);
           } else {
             throw new TypeError('Input has to be an object with r and phi keys.');
           }
         }
       case 2:
         {
-          var r = arguments[0];
-          var phi = arguments[1];
+          const r = arguments[0];
+          let phi = arguments[1];
           if ((0, _is.isNumber)(r)) {
             if ((0, _is.isUnit)(phi) && phi.hasBase('ANGLE')) {
               // convert unit to a number in radians
               phi = phi.toNumber('rad');
             }
             if ((0, _is.isNumber)(phi)) {
-              return new _complex["default"]({
-                r: r,
-                phi: phi
+              return new _complex.default({
+                r,
+                phi
               });
             }
             throw new TypeError('Phi is not a number nor an angle unit.');
@@ -152,7 +151,7 @@ var createComplexClass = exports.createComplexClass = /* #__PURE__ */(0, _factor
         throw new SyntaxError('Wrong number of arguments in function fromPolar');
     }
   };
-  _complex["default"].prototype.valueOf = _complex["default"].prototype.toString;
+  _complex.default.prototype.valueOf = _complex.default.prototype.toString;
 
   /**
    * Create a Complex number from a JSON object
@@ -162,8 +161,8 @@ var createComplexClass = exports.createComplexClass = /* #__PURE__ */(0, _factor
    *                       for `re` and `im` are 0.
    * @return {Complex} Returns a new Complex number
    */
-  _complex["default"].fromJSON = function (json) {
-    return new _complex["default"](json);
+  _complex.default.fromJSON = function (json) {
+    return new _complex.default(json);
   };
 
   /**
@@ -181,7 +180,7 @@ var createComplexClass = exports.createComplexClass = /* #__PURE__ */(0, _factor
    * @params {Complex} b
    * @returns {number} Returns the comparison result: -1, 0, or 1
    */
-  _complex["default"].compare = function (a, b) {
+  _complex.default.compare = function (a, b) {
     if (a.re > b.re) {
       return 1;
     }
@@ -196,7 +195,7 @@ var createComplexClass = exports.createComplexClass = /* #__PURE__ */(0, _factor
     }
     return 0;
   };
-  return _complex["default"];
+  return _complex.default;
 }, {
   isClass: true
 });

package/lib/cjs/type/complex/function/complex.js

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.createComplex = void 0;
 var _factory = require("../../../utils/factory.js");
 var _collection = require("../../../utils/collection.js");
-var name = 'complex';
-var dependencies = ['typed', 'Complex'];
-var createComplex = exports.createComplex = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    Complex = _ref.Complex;
+const name = 'complex';
+const dependencies = ['typed', 'Complex'];
+const createComplex = exports.createComplex = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    Complex
+  } = _ref;
   /**
    * Create a complex value or convert a value to a complex value.
    *
@@ -50,32 +52,32 @@ var createComplex = exports.createComplex = /* #__PURE__ */(0, _factory.factory)
    * @return {Complex | Array | Matrix} Returns a complex value
    */
   return typed('complex', {
-    '': function _() {
+    '': function () {
       return Complex.ZERO;
     },
-    number: function number(x) {
+    number: function (x) {
       return new Complex(x, 0);
     },
-    'number, number': function numberNumber(re, im) {
+    'number, number': function (re, im) {
       return new Complex(re, im);
     },
     // TODO: this signature should be redundant
-    'BigNumber, BigNumber': function BigNumberBigNumber(re, im) {
+    'BigNumber, BigNumber': function (re, im) {
       return new Complex(re.toNumber(), im.toNumber());
     },
-    Fraction: function Fraction(x) {
+    Fraction: function (x) {
       return new Complex(x.valueOf(), 0);
     },
-    Complex: function Complex(x) {
+    Complex: function (x) {
       return x.clone();
     },
-    string: function string(x) {
+    string: function (x) {
       return Complex(x); // for example '2 + 3i'
     },
-    "null": function _null(x) {
+    null: function (x) {
       return Complex(0);
     },
-    Object: function Object(x) {
+    Object: function (x) {
       if ('re' in x && 'im' in x) {
         return new Complex(x.re, x.im);
       }
@@ -84,10 +86,6 @@ var createComplex = exports.createComplex = /* #__PURE__ */(0, _factory.factory)
       }
       throw new Error('Expected object with properties (re and im) or (r and phi) or (abs and arg)');
     },
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        return (0, _collection.deepMap)(x, self);
-      };
-    })
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });

package/lib/cjs/type/fraction/Fraction.js

@@ -7,25 +7,25 @@ Object.defineProperty(exports, "__esModule", {
 exports.createFractionClass = void 0;
 var _fraction = _interopRequireDefault(require("fraction.js"));
 var _factory = require("../../utils/factory.js");
-var name = 'Fraction';
-var dependencies = [];
-var createFractionClass = exports.createFractionClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function () {
+const name = 'Fraction';
+const dependencies = [];
+const createFractionClass = exports.createFractionClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, () => {
   /**
    * Attach type information
    */
-  Object.defineProperty(_fraction["default"], 'name', {
+  Object.defineProperty(_fraction.default, 'name', {
     value: 'Fraction'
   });
-  _fraction["default"].prototype.constructor = _fraction["default"];
-  _fraction["default"].prototype.type = 'Fraction';
-  _fraction["default"].prototype.isFraction = true;
+  _fraction.default.prototype.constructor = _fraction.default;
+  _fraction.default.prototype.type = 'Fraction';
+  _fraction.default.prototype.isFraction = true;
 
   /**
    * Get a JSON representation of a Fraction containing type information
    * @returns {Object} Returns a JSON object structured as:
    *                   `{"mathjs": "Fraction", "n": 3, "d": 8}`
    */
-  _fraction["default"].prototype.toJSON = function () {
+  _fraction.default.prototype.toJSON = function () {
     return {
       mathjs: 'Fraction',
       n: this.s * this.n,
@@ -39,10 +39,10 @@ var createFractionClass = exports.createFractionClass = /* #__PURE__ */(0, _fact
    *                       `{"mathjs": "Fraction", "n": 3, "d": 8}`
    * @return {BigNumber}
    */
-  _fraction["default"].fromJSON = function (json) {
-    return new _fraction["default"](json);
+  _fraction.default.fromJSON = function (json) {
+    return new _fraction.default(json);
   };
-  return _fraction["default"];
+  return _fraction.default;
 }, {
   isClass: true
 });

package/lib/cjs/type/fraction/function/fraction.js

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.createFraction = void 0;
 var _factory = require("../../../utils/factory.js");
 var _collection = require("../../../utils/collection.js");
-var name = 'fraction';
-var dependencies = ['typed', 'Fraction'];
-var createFraction = exports.createFraction = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    Fraction = _ref.Fraction;
+const name = 'fraction';
+const dependencies = ['typed', 'Fraction'];
+const createFraction = exports.createFraction = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    Fraction
+  } = _ref;
   /**
    * Create a fraction or convert a value to a fraction.
    *
@@ -43,47 +45,44 @@ var createFraction = exports.createFraction = /* #__PURE__ */(0, _factory.factor
    *
    *    bignumber, number, string, unit
    *
-   * @param {number | string | Fraction | BigNumber | Unit | Array | Matrix} [args]
+   * @param {number | string | Fraction | BigNumber | bigint | Unit | Array | Matrix} [args]
    *            Arguments specifying the value, or numerator and denominator of
    *            the fraction
    * @return {Fraction | Array | Matrix} Returns a fraction
    */
   return typed('fraction', {
-    number: function number(x) {
+    number: function (x) {
       if (!isFinite(x) || isNaN(x)) {
         throw new Error(x + ' cannot be represented as a fraction');
       }
       return new Fraction(x);
     },
-    string: function string(x) {
+    string: function (x) {
       return new Fraction(x);
     },
-    'number, number': function numberNumber(numerator, denominator) {
+    'number, number': function (numerator, denominator) {
       return new Fraction(numerator, denominator);
     },
-    "null": function _null(x) {
+    null: function (x) {
       return new Fraction(0);
     },
-    BigNumber: function BigNumber(x) {
+    BigNumber: function (x) {
       return new Fraction(x.toString());
     },
-    Fraction: function Fraction(x) {
+    bigint: function (x) {
+      return new Fraction(x.toString());
+    },
+    Fraction: function (x) {
       return x; // fractions are immutable
     },
-    Unit: typed.referToSelf(function (self) {
-      return function (x) {
-        var clone = x.clone();
-        clone.value = self(x.value);
-        return clone;
-      };
+    Unit: typed.referToSelf(self => x => {
+      const clone = x.clone();
+      clone.value = self(x.value);
+      return clone;
     }),
-    Object: function Object(x) {
+    Object: function (x) {
       return new Fraction(x);
     },
-    'Array | Matrix': typed.referToSelf(function (self) {
-      return function (x) {
-        return (0, _collection.deepMap)(x, self);
-      };
-    })
+    'Array | Matrix': typed.referToSelf(self => x => (0, _collection.deepMap)(x, self))
   });
 });