mathjs 9.2.0 → 9.4.0

package/lib/cjs/type/matrix/DenseMatrix.js

@@ -1,10 +1,14 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createDenseMatrixClass = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
 var _is = require("../../utils/is.js");
 
 var _array = require("../../utils/array.js");
@@ -19,6 +23,12 @@ var _DimensionError = require("../../error/DimensionError.js");
 
 var _factory = require("../../utils/factory.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; }
+
 var name = 'DenseMatrix';
 var dependencies = ['Matrix'];
 var createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
@@ -27,6 +37,7 @@ var createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependen
   /**
    * Dense Matrix implementation. A regular, dense matrix, supporting multi-dimensional matrices. This is the default matrix type.
    * @class DenseMatrix
+   * @enum {{ value, index: number[] }}
    */
   function DenseMatrix(data, datatype) {
     if (!(this instanceof DenseMatrix)) {
@@ -631,6 +642,133 @@ var createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependen
 
     recurse(this._data, []);
   };
+  /**
+   * Iterate over the matrix elements
+   * @return {Iterable<{ value, index: number[] }>}
+   */
+
+
+  DenseMatrix.prototype[Symbol.iterator] = /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var recurse;
+    return _regenerator["default"].wrap(function _callee$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            recurse = /*#__PURE__*/_regenerator["default"].mark(function recurse(value, index) {
+              var i;
+              return _regenerator["default"].wrap(function recurse$(_context) {
+                while (1) {
+                  switch (_context.prev = _context.next) {
+                    case 0:
+                      if (!(0, _is.isArray)(value)) {
+                        _context.next = 9;
+                        break;
+                      }
+
+                      i = 0;
+
+                    case 2:
+                      if (!(i < value.length)) {
+                        _context.next = 7;
+                        break;
+                      }
+
+                      return _context.delegateYield(recurse(value[i], index.concat(i)), "t0", 4);
+
+                    case 4:
+                      i++;
+                      _context.next = 2;
+                      break;
+
+                    case 7:
+                      _context.next = 11;
+                      break;
+
+                    case 9:
+                      _context.next = 11;
+                      return {
+                        value: value,
+                        index: index
+                      };
+
+                    case 11:
+                    case "end":
+                      return _context.stop();
+                  }
+                }
+              }, recurse);
+            });
+            return _context2.delegateYield(recurse(this._data, []), "t0", 2);
+
+          case 2:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee, this);
+  });
+  /**
+   * Returns an array containing the rows of a 2D matrix
+   * @returns {Array<Matrix>}
+   */
+
+  DenseMatrix.prototype.rows = function () {
+    var result = [];
+    var s = this.size();
+
+    if (s.length !== 2) {
+      throw new TypeError('Rows can only be returned for a 2D matrix.');
+    }
+
+    var data = this._data;
+
+    var _iterator = _createForOfIteratorHelper(data),
+        _step;
+
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var row = _step.value;
+        result.push(new DenseMatrix([row], this._datatype));
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+
+    return result;
+  };
+  /**
+   * Returns an array containing the columns of a 2D matrix
+   * @returns {Array<Matrix>}
+   */
+
+
+  DenseMatrix.prototype.columns = function () {
+    var _this = this;
+
+    var result = [];
+    var s = this.size();
+
+    if (s.length !== 2) {
+      throw new TypeError('Rows can only be returned for a 2D matrix.');
+    }
+
+    var data = this._data;
+
+    var _loop = function _loop(i) {
+      var col = data.map(function (row) {
+        return [row[i]];
+      });
+      result.push(new DenseMatrix(col, _this._datatype));
+    };
+
+    for (var i = 0; i < s[1]; i++) {
+      _loop(i);
+    }
+
+    return result;
+  };
   /**
    * Create an Array with a copy of the data of the DenseMatrix
    * @memberof DenseMatrix

package/lib/cjs/type/matrix/Matrix.js

@@ -207,6 +207,16 @@ var createMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
     // must be implemented by each of the Matrix implementations
     throw new Error('Cannot invoke forEach on a Matrix interface');
   };
+  /**
+   * Iterate over the matrix elements
+   * @return {Iterable<{ value, index: number[] }>}
+   */
+
+
+  Matrix.prototype[Symbol.iterator] = function () {
+    // must be implemented by each of the Matrix implementations
+    throw new Error('Cannot iterate a Matrix interface');
+  };
   /**
    * Create an Array with a copy of the data of the Matrix
    * @returns {Array} array

package/lib/cjs/type/matrix/SparseMatrix.js

@@ -1,10 +1,14 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createSparseMatrixClass = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
 var _is = require("../../utils/is.js");
 
 var _number = require("../../utils/number.js");
@@ -27,8 +31,9 @@ var createSparseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, depende
       Matrix = _ref.Matrix;
 
   /**
-   * Sparse Matrix implementation. This type implements a Compressed Column Storage format
-   * for sparse matrices.
+   * Sparse Matrix implementation. This type implements
+   * a [Compressed Column Storage](https://en.wikipedia.org/wiki/Sparse_matrix#Compressed_sparse_column_(CSC_or_CCS))
+   * format for two-dimensional sparse matrices.
    * @class SparseMatrix
    */
   function SparseMatrix(data, datatype) {
@@ -610,6 +615,8 @@ var createSparseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, depende
    *
    * @memberof SparseMatrix
    * @param {number[] | Matrix} size  The new size the matrix should have.
+   *                                  Since sparse matrices are always two-dimensional,
+   *                                  size must be two numbers in either an array or a matrix
    * @param {*} [defaultValue=0]      Default value, filled in on new entries.
    *                                  If not provided, the matrix elements will
    *                                  be filled with zeros.
@@ -780,6 +787,8 @@ var createSparseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, depende
    *
    * @memberof SparseMatrix
    * @param {number[]} sizes          The new size the matrix should have.
+   *                                  Since sparse matrices are always two-dimensional,
+   *                                  size must be two numbers in either an array or a matrix
    * @param {boolean} [copy]          Return a reshaped copy of the matrix
    *
    * @return {Matrix}                 The reshaped matrix
@@ -1020,6 +1029,8 @@ var createSparseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, depende
    *                              parameters: the value of the element, the index
    *                              of the element, and the Matrix being traversed.
    * @param {boolean} [skipZeros] Invoke callback function for non-zero values only.
+   *                              If false, the indices are guaranteed to be in order,
+   *                              if true, the indices can be unordered.
    */
 
 
@@ -1066,13 +1077,76 @@ var createSparseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, depende
       }
     }
   };
+  /**
+   * Iterate over the matrix elements, skipping zeros
+   * @return {Iterable<{ value, index: number[] }>}
+   */
+
+
+  SparseMatrix.prototype[Symbol.iterator] = /*#__PURE__*/_regenerator["default"].mark(function _callee() {
+    var columns, j, k0, k1, k, i;
+    return _regenerator["default"].wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (this._values) {
+              _context.next = 2;
+              break;
+            }
+
+            throw new Error('Cannot iterate a Pattern only matrix');
+
+          case 2:
+            columns = this._size[1];
+            j = 0;
+
+          case 4:
+            if (!(j < columns)) {
+              _context.next = 18;
+              break;
+            }
+
+            k0 = this._ptr[j];
+            k1 = this._ptr[j + 1];
+            k = k0;
+
+          case 8:
+            if (!(k < k1)) {
+              _context.next = 15;
+              break;
+            }
+
+            // row index
+            i = this._index[k];
+            _context.next = 12;
+            return {
+              value: this._values[k],
+              index: [i, j]
+            };
+
+          case 12:
+            k++;
+            _context.next = 8;
+            break;
+
+          case 15:
+            j++;
+            _context.next = 4;
+            break;
+
+          case 18:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee, this);
+  });
   /**
    * Create an Array with a copy of the data of the SparseMatrix
    * @memberof SparseMatrix
    * @returns {Array} array
    */
 
-
   SparseMatrix.prototype.toArray = function () {
     return _toArray(this._values, this._index, this._ptr, this._size, true);
   };

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

@@ -43,7 +43,8 @@ var createMatrix = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
    *    bignumber, boolean, complex, index, number, string, unit, sparse
    *
    * @param {Array | Matrix} [data]    A multi dimensional array
-   * @param {string} [format]          The Matrix storage format
+   * @param {string} [format]          The Matrix storage format, either `'dense'` or `'sparse'`
+   * @param {string} [datatype]        Type of the values
    *
    * @return {Matrix} The created matrix
    */

package/lib/cjs/type/number.js

@@ -11,6 +11,58 @@ var _collection = require("../utils/collection.js");
 
 var name = 'number';
 var dependencies = ['typed'];
+/**
+ * Separates the radix, integer part, and fractional part of a non decimal number string
+ * @param {string} input string to parse
+ * @returns {object} the parts of the string or null if not a valid input
+ */
+
+function getNonDecimalNumberParts(input) {
+  var nonDecimalWithRadixMatch = input.match(/(0[box])([0-9a-fA-F]*)\.([0-9a-fA-F]*)/);
+
+  if (nonDecimalWithRadixMatch) {
+    var radix = {
+      '0b': 2,
+      '0o': 8,
+      '0x': 16
+    }[nonDecimalWithRadixMatch[1]];
+    var integerPart = nonDecimalWithRadixMatch[2];
+    var fractionalPart = nonDecimalWithRadixMatch[3];
+    return {
+      input: input,
+      radix: radix,
+      integerPart: integerPart,
+      fractionalPart: fractionalPart
+    };
+  } else {
+    return null;
+  }
+}
+/**
+ * Makes a number from a radix, and integer part, and a fractional part
+ * @param {parts} [x] parts of the number string (from getNonDecimalNumberParts)
+ * @returns {number} the number
+ */
+
+
+function makeNumberFromNonDecimalParts(parts) {
+  var n = parseInt(parts.integerPart, parts.radix);
+  var f = 0;
+
+  for (var i = 0; i < parts.fractionalPart.length; i++) {
+    var digitValue = parseInt(parts.fractionalPart[i], parts.radix);
+    f += digitValue / Math.pow(parts.radix, i + 1);
+  }
+
+  var result = n + f;
+
+  if (isNaN(result)) {
+    throw new SyntaxError('String "' + parts.input + '" is no valid number');
+  }
+
+  return result;
+}
+
 var createNumber = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed;
 
@@ -48,14 +100,20 @@ var createNumber = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
     },
     string: function string(x) {
       if (x === 'NaN') return NaN;
+      var nonDecimalNumberParts = getNonDecimalNumberParts(x);
+
+      if (nonDecimalNumberParts) {
+        return makeNumberFromNonDecimalParts(nonDecimalNumberParts);
+      }
+
       var size = 0;
-      var boxMatch = x.match(/(0[box][0-9a-fA-F]*)i([0-9]*)/);
+      var wordSizeSuffixMatch = x.match(/(0[box][0-9a-fA-F]*)i([0-9]*)/);
 
-      if (boxMatch) {
+      if (wordSizeSuffixMatch) {
         // x includes a size suffix like 0xffffi32, so we extract
         // the suffix and remove it from x
-        size = Number(boxMatch[2]);
-        x = boxMatch[1];
+        size = Number(wordSizeSuffixMatch[2]);
+        x = wordSizeSuffixMatch[1];
       }
 
       var num = Number(x);
@@ -64,7 +122,7 @@ var createNumber = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
         throw new SyntaxError('String "' + x + '" is no valid number');
       }
 
-      if (boxMatch) {
+      if (wordSizeSuffixMatch) {
         // x is a signed bin, oct, or hex literal
         // num is the value of string x if x is interpreted as unsigned
         if (num > Math.pow(2, size) - 1) {

package/lib/cjs/type/unit/Unit.js

@@ -1,10 +1,18 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createUnitClass = void 0;
 
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _is = require("../../utils/is.js");
 
 var _factory = require("../../utils/factory.js");
@@ -17,15 +25,9 @@ var _object = require("../../utils/object.js");
 
 var _constants = require("../../utils/bignumber/constants.js");
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 var name = 'Unit';
 var dependencies = ['?on', 'config', 'addScalar', 'subtract', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'number', 'Complex', 'BigNumber', 'Fraction'];
@@ -1949,9 +1951,9 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       }
     }
   };
-  PREFIXES.SHORTLONG = _extends({}, PREFIXES.SHORT, PREFIXES.LONG);
-  PREFIXES.BINARY_SHORT = _extends({}, PREFIXES.BINARY_SHORT_SI, PREFIXES.BINARY_SHORT_IEC);
-  PREFIXES.BINARY_LONG = _extends({}, PREFIXES.BINARY_LONG_SI, PREFIXES.BINARY_LONG_IEC);
+  PREFIXES.SHORTLONG = (0, _extends2["default"])({}, PREFIXES.SHORT, PREFIXES.LONG);
+  PREFIXES.BINARY_SHORT = (0, _extends2["default"])({}, PREFIXES.BINARY_SHORT_SI, PREFIXES.BINARY_SHORT_IEC);
+  PREFIXES.BINARY_LONG = (0, _extends2["default"])({}, PREFIXES.BINARY_LONG_SI, PREFIXES.BINARY_LONG_IEC);
   /* Internally, each unit is represented by a value and a dimension array. The elements of the dimensions array have the following meaning:
    * Index  Dimension
    * -----  ---------
@@ -3743,7 +3745,7 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
 
 
   Unit.createUnit = function (obj, options) {
-    if (_typeof(obj) !== 'object') {
+    if ((0, _typeof2["default"])(obj) !== 'object') {
       throw new TypeError("createUnit expects first parameter to be of type 'Object'");
     } // Remove all units and aliases we are overriding
 
@@ -3833,7 +3835,7 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       if (obj !== '') {
         definition = obj;
       }
-    } else if (_typeof(obj) === 'object') {
+    } else if ((0, _typeof2["default"])(obj) === 'object') {
       definition = obj.definition;
       prefixes = obj.prefixes;
       offset = obj.offset;

package/lib/cjs/utils/array.js

@@ -616,7 +616,7 @@ function generalize(a) {
  * This method does not validate Array Matrix shape
  * @param {Array} array
  * @param {function} typeOf   Callback function to use to determine the type of a value
- * @return string
+ * @return {string}
  */
 
 

package/lib/cjs/utils/customs.js

@@ -1,18 +1,22 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getSafeProperty = getSafeProperty;
 exports.setSafeProperty = setSafeProperty;
 exports.isSafeProperty = isSafeProperty;
+exports.hasSafeProperty = hasSafeProperty;
+exports.getSafeProperties = getSafeProperties;
 exports.validateSafeMethod = validateSafeMethod;
 exports.isSafeMethod = isSafeMethod;
 exports.isPlainObject = isPlainObject;
 
-var _object = require("./object.js");
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+var _object = require("./object.js");
 
 /**
  * Get a property of a plain object
@@ -55,6 +59,16 @@ function setSafeProperty(object, prop, value) {
 
   throw new Error('No access to property "' + prop + '"');
 }
+
+function getSafeProperties(object) {
+  return Object.keys(object).filter(function (prop) {
+    return (0, _object.hasOwnProperty)(object, prop);
+  });
+}
+
+function hasSafeProperty(object, prop) {
+  return prop in object;
+}
 /**
  * Test whether a property is safe to use for an object.
  * For example .toString and .constructor are not safe
@@ -64,7 +78,7 @@ function setSafeProperty(object, prop, value) {
 
 
 function isSafeProperty(object, prop) {
-  if (!object || _typeof(object) !== 'object') {
+  if (!object || (0, _typeof2["default"])(object) !== 'object') {
     return false;
   } // SAFE: whitelisted
   // e.g length
@@ -157,7 +171,7 @@ function isSafeMethod(object, method) {
 }
 
 function isPlainObject(object) {
-  return _typeof(object) === 'object' && object && object.constructor === Object;
+  return (0, _typeof2["default"])(object) === 'object' && object && object.constructor === Object;
 }
 
 var safeNativeProperties = {

package/lib/cjs/utils/emitter.js

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -7,8 +9,6 @@ exports.mixin = mixin;
 
 var _tinyEmitter = _interopRequireDefault(require("tiny-emitter"));
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
 /**
  * Extend given object with emitter functions `on`, `off`, `once`, `emit`
  * @param {Object} obj

package/lib/cjs/utils/function.js

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -7,9 +9,11 @@ exports.memoize = memoize;
 exports.memoizeCompare = memoizeCompare;
 exports.maxArgumentCount = maxArgumentCount;
 
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
 var _lruQueue = require("./lruQueue.js");
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+// function utils
 
 /**
  * Memoize a given function by caching the computed result.
@@ -34,7 +38,7 @@ function memoize(fn) {
   limit = limit == null ? Number.POSITIVE_INFINITY : limit;
   hasher = hasher == null ? JSON.stringify : hasher;
   return function memoize() {
-    if (_typeof(memoize.cache) !== 'object') {
+    if ((0, _typeof2["default"])(memoize.cache) !== 'object') {
       memoize.cache = {
         values: new Map(),
         lru: (0, _lruQueue.lruQueue)(limit || Number.POSITIVE_INFINITY)

package/lib/cjs/utils/is.js

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -43,7 +45,7 @@ exports.isChain = isChain;
 exports.typeOf = typeOf;
 exports.isArray = void 0;
 
-function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
 // type checks for all known types
 //
@@ -67,11 +69,11 @@ function isBigNumber(x) {
 }
 
 function isComplex(x) {
-  return x && _typeof(x) === 'object' && Object.getPrototypeOf(x).isComplex === true || false;
+  return x && (0, _typeof2["default"])(x) === 'object' && Object.getPrototypeOf(x).isComplex === true || false;
 }
 
 function isFraction(x) {
-  return x && _typeof(x) === 'object' && Object.getPrototypeOf(x).isFraction === true || false;
+  return x && (0, _typeof2["default"])(x) === 'object' && Object.getPrototypeOf(x).isFraction === true || false;
 }
 
 function isUnit(x) {
@@ -140,7 +142,7 @@ function isRegExp(x) {
 }
 
 function isObject(x) {
-  return !!(x && _typeof(x) === 'object' && x.constructor === Object && !isComplex(x) && !isFraction(x));
+  return !!(x && (0, _typeof2["default"])(x) === 'object' && x.constructor === Object && !isComplex(x) && !isFraction(x));
 }
 
 function isNull(x) {
@@ -216,7 +218,7 @@ function isChain(x) {
 }
 
 function typeOf(x) {
-  var t = _typeof(x);
+  var t = (0, _typeof2["default"])(x);
 
   if (t === 'object') {
     // JavaScript types

package/lib/cjs/utils/latex.js

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -11,8 +13,6 @@ var _escapeLatex = _interopRequireDefault(require("escape-latex"));
 
 var _object = require("./object.js");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
 /* eslint no-template-curly-in-string: "off" */
 var latexSymbols = {
   // GREEK LETTERS