mathjs 9.2.0 → 9.4.0

package/lib/cjs/utils/map.js

@@ -0,0 +1,197 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEmptyMap = createEmptyMap;
+exports.createMap = createMap;
+exports.toObject = toObject;
+exports.isMap = isMap;
+exports.assign = assign;
+exports.ObjectWrappingMap = void 0;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _customs = require("./customs.js");
+
+var _is = require("./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; }
+
+/**
+ * A map facade on a bare object.
+ *
+ * The small number of methods needed to implement a scope,
+ * forwarding on to the SafeProperty functions. Over time, the codebase
+ * will stop using this method, as all objects will be Maps, rather than
+ * more security prone objects.
+ */
+var ObjectWrappingMap = /*#__PURE__*/function () {
+  function ObjectWrappingMap(object) {
+    (0, _classCallCheck2["default"])(this, ObjectWrappingMap);
+    this.wrappedObject = object;
+  }
+
+  (0, _createClass2["default"])(ObjectWrappingMap, [{
+    key: "keys",
+    value: function keys() {
+      return Object.keys(this.wrappedObject);
+    }
+  }, {
+    key: "get",
+    value: function get(key) {
+      return (0, _customs.getSafeProperty)(this.wrappedObject, key);
+    }
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      (0, _customs.setSafeProperty)(this.wrappedObject, key, value);
+      return this;
+    }
+  }, {
+    key: "has",
+    value: function has(key) {
+      return (0, _customs.hasSafeProperty)(this.wrappedObject, key);
+    }
+  }]);
+  return ObjectWrappingMap;
+}();
+/**
+ * Creates an empty map, or whatever your platform's polyfill is.
+ *
+ * @returns an empty Map or Map like object.
+ */
+
+
+exports.ObjectWrappingMap = ObjectWrappingMap;
+
+function createEmptyMap() {
+  return new Map();
+}
+/**
+ * Creates a Map from the given object.
+ *
+ * @param { Map | { [key: string]: unknown } | undefined } mapOrObject
+ * @returns
+ */
+
+
+function createMap(mapOrObject) {
+  if (!mapOrObject) {
+    return createEmptyMap();
+  }
+
+  if (isMap(mapOrObject)) {
+    return mapOrObject;
+  }
+
+  if ((0, _is.isObject)(mapOrObject)) {
+    return new ObjectWrappingMap(mapOrObject);
+  }
+
+  throw new Error('createMap can create maps from objects or Maps');
+}
+/**
+ * Unwraps a map into an object.
+ *
+ * @param {Map} map
+ * @returns { [key: string]: unknown }
+ */
+
+
+function toObject(map) {
+  if (map instanceof ObjectWrappingMap) {
+    return map.wrappedObject;
+  }
+
+  var object = {};
+
+  var _iterator = _createForOfIteratorHelper(map.keys()),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var key = _step.value;
+      var value = map.get(key);
+      (0, _customs.setSafeProperty)(object, key, value);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  return object;
+}
+/**
+ * Returns `true` if the passed object appears to be a Map (i.e. duck typing).
+ *
+ * Methods looked for are `get`, `set`, `keys` and `has`.
+ *
+ * @param {Map | object} object
+ * @returns
+ */
+
+
+function isMap(object) {
+  // We can use the fast instanceof, or a slower duck typing check.
+  // The duck typing method needs to cover enough methods to not be confused with DenseMatrix.
+  if (!object) {
+    return false;
+  }
+
+  return object instanceof Map || object instanceof ObjectWrappingMap || typeof object.set === 'function' && typeof object.get === 'function' && typeof object.keys === 'function' && typeof object.has === 'function';
+}
+/**
+ * Copies the contents of key-value pairs from each `objects` in to `map`.
+ *
+ * Object is `objects` can be a `Map` or object.
+ *
+ * This is the `Map` analog to `Object.assign`.
+ */
+
+
+function assign(map) {
+  for (var _len = arguments.length, objects = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    objects[_key - 1] = arguments[_key];
+  }
+
+  for (var _i = 0, _objects = objects; _i < _objects.length; _i++) {
+    var args = _objects[_i];
+
+    if (!args) {
+      continue;
+    }
+
+    if (isMap(args)) {
+      var _iterator2 = _createForOfIteratorHelper(args.keys()),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var key = _step2.value;
+          map.set(key, args.get(key));
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    } else if ((0, _is.isObject)(args)) {
+      for (var _i2 = 0, _Object$keys = Object.keys(args); _i2 < _Object$keys.length; _i2++) {
+        var _key2 = _Object$keys[_i2];
+        map.set(_key2, args[_key2]);
+      }
+    }
+  }
+
+  return map;
+}

package/lib/cjs/utils/object.js

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -20,9 +22,9 @@ exports.pick = pick;
 exports.pickShallow = pickShallow;
 exports.values = values;
 
-var _is = require("./is.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 _is = require("./is.js");
 
 /**
  * Clone an object
@@ -36,8 +38,7 @@ function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "functi
  * @return {*} clone
  */
 function clone(x) {
-  var type = _typeof(x); // immutable primitive types
-
+  var type = (0, _typeof2["default"])(x); // immutable primitive types
 
   if (type === 'number' || type === 'string' || type === 'boolean' || x === null || x === undefined) {
     return x;
@@ -212,7 +213,7 @@ function _deepFlatten(nestedObject, flattenedObject) {
     if (hasOwnProperty(nestedObject, prop)) {
       var value = nestedObject[prop];
 
-      if (_typeof(value) === 'object' && value !== null) {
+      if ((0, _typeof2["default"])(value) === 'object' && value !== null) {
         _deepFlatten(value, flattenedObject);
       } else {
         flattenedObject[prop] = value;

package/lib/cjs/utils/scope.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSubScope = createSubScope;
+
+var _map = require("./map.js");
+
+/**
+ * Create a new scope which can access the parent scope,
+ * but does not affect it when written. This is suitable for variable definitions
+ * within a block node, or function definition.
+ *
+ * If parent scope has a createSubScope method, it delegates to that. Otherwise,
+ * creates an empty map, and copies the parent scope to it, adding in
+ * the remaining `args`.
+ *
+ * @param {Map} parentScope
+ * @param  {...any} args
+ * @returns {Map}
+ */
+function createSubScope(parentScope) {
+  for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+    args[_key - 1] = arguments[_key];
+  }
+
+  if (typeof parentScope.createSubScope === 'function') {
+    return _map.assign.apply(void 0, [parentScope.createSubScope()].concat(args));
+  }
+
+  return _map.assign.apply(void 0, [(0, _map.createEmptyMap)(), parentScope].concat(args));
+}

package/lib/cjs/utils/snapshot.js

@@ -1,5 +1,9 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+var _typeof3 = require("@babel/runtime/helpers/typeof");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -7,6 +11,12 @@ exports.validateBundle = validateBundle;
 exports.createSnapshotFromFactories = createSnapshotFromFactories;
 exports.validateTypeOf = validateTypeOf;
 
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _assert = _interopRequireDefault(require("assert"));
 
 var allIsFunctions = _interopRequireWildcard(require("./is.js"));
@@ -15,21 +25,13 @@ var _create = require("../core/create.js");
 
 var _string = require("./string.js");
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof3(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+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 _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 _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 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 _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; }
 
 function validateBundle(expectedBundleStructure, bundle) {
   var originalWarn = console.warn;
@@ -227,11 +229,11 @@ function validateTypeOf(x) {
     return 'Function';
   }
 
-  if (_typeof(x) === 'object') {
+  if ((0, _typeof2["default"])(x) === 'object') {
     return 'Object';
   }
 
-  return _typeof(x);
+  return (0, _typeof2["default"])(x);
 }
 
 function traverse(obj) {
@@ -281,8 +283,7 @@ function get(object, path) {
 
 
 function exclude(object, excludedProperties) {
-  var strippedObject = _extends({}, object);
-
+  var strippedObject = (0, _extends2["default"])({}, object);
   excludedProperties.forEach(function (excludedProperty) {
     delete strippedObject[excludedProperty];
   });

package/lib/cjs/utils/string.js

@@ -1,5 +1,7 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -9,14 +11,14 @@ exports.stringify = stringify;
 exports.escape = escape;
 exports.compareText = compareText;
 
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
 var _is = require("./is.js");
 
 var _number = require("./number.js");
 
 var _formatter = require("./bignumber/formatter.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); }
-
 /**
  * Check if a text ends with a certain string.
  * @param {string} text
@@ -97,7 +99,7 @@ function format(value, options) {
     return value.syntax ? String(value.syntax) : 'function';
   }
 
-  if (value && _typeof(value) === 'object') {
+  if (value && (0, _typeof2["default"])(value) === 'object') {
     if (typeof value.format === 'function') {
       return value.format(options);
     } else if (value && value.toString(options) !== {}.toString()) {
@@ -201,7 +203,7 @@ function formatArray(array, options) {
 
 
 function looksLikeFraction(value) {
-  return value && _typeof(value) === 'object' && typeof value.s === 'number' && typeof value.n === 'number' && typeof value.d === 'number' || false;
+  return value && (0, _typeof2["default"])(value) === 'object' && typeof value.s === 'number' && typeof value.n === 'number' && typeof value.d === 'number' || false;
 }
 /**
  * Compare two strings

package/lib/cjs/version.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-var version = '9.2.0'; // Note: This file is automatically generated when building math.js.
+var version = '9.4.0'; // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.
 
 exports.version = version;

package/lib/esm/constants.js

@@ -5,35 +5,35 @@ import { pi, tau, e, phi } from './plain/number/index.js';
 export var createTrue = /* #__PURE__ */factory('true', [], () => true);
 export var createFalse = /* #__PURE__ */factory('false', [], () => false);
 export var createNull = /* #__PURE__ */factory('null', [], () => null);
-export var createInfinity = /* #__PURE__ */recreateFactory('Infinity', ['config', '?BigNumber'], (_ref) => {
+export var createInfinity = /* #__PURE__ */recreateFactory('Infinity', ['config', '?BigNumber'], _ref => {
   var {
     config,
     BigNumber
   } = _ref;
   return config.number === 'BigNumber' ? new BigNumber(Infinity) : Infinity;
 });
-export var createNaN = /* #__PURE__ */recreateFactory('NaN', ['config', '?BigNumber'], (_ref2) => {
+export var createNaN = /* #__PURE__ */recreateFactory('NaN', ['config', '?BigNumber'], _ref2 => {
   var {
     config,
     BigNumber
   } = _ref2;
   return config.number === 'BigNumber' ? new BigNumber(NaN) : NaN;
 });
-export var createPi = /* #__PURE__ */recreateFactory('pi', ['config', '?BigNumber'], (_ref3) => {
+export var createPi = /* #__PURE__ */recreateFactory('pi', ['config', '?BigNumber'], _ref3 => {
   var {
     config,
     BigNumber
   } = _ref3;
   return config.number === 'BigNumber' ? createBigNumberPi(BigNumber) : pi;
 });
-export var createTau = /* #__PURE__ */recreateFactory('tau', ['config', '?BigNumber'], (_ref4) => {
+export var createTau = /* #__PURE__ */recreateFactory('tau', ['config', '?BigNumber'], _ref4 => {
   var {
     config,
     BigNumber
   } = _ref4;
   return config.number === 'BigNumber' ? createBigNumberTau(BigNumber) : tau;
 });
-export var createE = /* #__PURE__ */recreateFactory('e', ['config', '?BigNumber'], (_ref5) => {
+export var createE = /* #__PURE__ */recreateFactory('e', ['config', '?BigNumber'], _ref5 => {
   var {
     config,
     BigNumber
@@ -41,35 +41,35 @@ export var createE = /* #__PURE__ */recreateFactory('e', ['config', '?BigNumber'
   return config.number === 'BigNumber' ? createBigNumberE(BigNumber) : e;
 }); // golden ratio, (1+sqrt(5))/2
 
-export var createPhi = /* #__PURE__ */recreateFactory('phi', ['config', '?BigNumber'], (_ref6) => {
+export var createPhi = /* #__PURE__ */recreateFactory('phi', ['config', '?BigNumber'], _ref6 => {
   var {
     config,
     BigNumber
   } = _ref6;
   return config.number === 'BigNumber' ? createBigNumberPhi(BigNumber) : phi;
 });
-export var createLN2 = /* #__PURE__ */recreateFactory('LN2', ['config', '?BigNumber'], (_ref7) => {
+export var createLN2 = /* #__PURE__ */recreateFactory('LN2', ['config', '?BigNumber'], _ref7 => {
   var {
     config,
     BigNumber
   } = _ref7;
   return config.number === 'BigNumber' ? new BigNumber(2).ln() : Math.LN2;
 });
-export var createLN10 = /* #__PURE__ */recreateFactory('LN10', ['config', '?BigNumber'], (_ref8) => {
+export var createLN10 = /* #__PURE__ */recreateFactory('LN10', ['config', '?BigNumber'], _ref8 => {
   var {
     config,
     BigNumber
   } = _ref8;
   return config.number === 'BigNumber' ? new BigNumber(10).ln() : Math.LN10;
 });
-export var createLOG2E = /* #__PURE__ */recreateFactory('LOG2E', ['config', '?BigNumber'], (_ref9) => {
+export var createLOG2E = /* #__PURE__ */recreateFactory('LOG2E', ['config', '?BigNumber'], _ref9 => {
   var {
     config,
     BigNumber
   } = _ref9;
   return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(2).ln()) : Math.LOG2E;
 });
-export var createLOG10E = /* #__PURE__ */recreateFactory('LOG10E', ['config', '?BigNumber'], (_ref10) => {
+export var createLOG10E = /* #__PURE__ */recreateFactory('LOG10E', ['config', '?BigNumber'], _ref10 => {
   var {
     config,
     BigNumber
@@ -77,34 +77,34 @@ export var createLOG10E = /* #__PURE__ */recreateFactory('LOG10E', ['config', '?
   return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(10).ln()) : Math.LOG10E;
 });
 export var createSQRT1_2 = /* #__PURE__ */recreateFactory( // eslint-disable-line camelcase
-'SQRT1_2', ['config', '?BigNumber'], (_ref11) => {
+'SQRT1_2', ['config', '?BigNumber'], _ref11 => {
   var {
     config,
     BigNumber
   } = _ref11;
   return config.number === 'BigNumber' ? new BigNumber('0.5').sqrt() : Math.SQRT1_2;
 });
-export var createSQRT2 = /* #__PURE__ */recreateFactory('SQRT2', ['config', '?BigNumber'], (_ref12) => {
+export var createSQRT2 = /* #__PURE__ */recreateFactory('SQRT2', ['config', '?BigNumber'], _ref12 => {
   var {
     config,
     BigNumber
   } = _ref12;
   return config.number === 'BigNumber' ? new BigNumber(2).sqrt() : Math.SQRT2;
 });
-export var createI = /* #__PURE__ */recreateFactory('i', ['Complex'], (_ref13) => {
+export var createI = /* #__PURE__ */recreateFactory('i', ['Complex'], _ref13 => {
   var {
     Complex
   } = _ref13;
   return Complex.I;
 }); // for backward compatibility with v5
 
-export var createUppercasePi = /* #__PURE__ */factory('PI', ['pi'], (_ref14) => {
+export var createUppercasePi = /* #__PURE__ */factory('PI', ['pi'], _ref14 => {
   var {
     pi
   } = _ref14;
   return pi;
 });
-export var createUppercaseE = /* #__PURE__ */factory('E', ['e'], (_ref15) => {
+export var createUppercaseE = /* #__PURE__ */factory('E', ['e'], _ref15 => {
   var {
     e
   } = _ref15;

package/lib/esm/core/create.js

@@ -1,5 +1,4 @@
-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); }
-
+import _extends from "@babel/runtime/helpers/extends";
 import './../utils/polyfills.js';
 import { deepFlatten, isLegacyFactory, values } from '../utils/object.js';
 import * as emitter from './../utils/emitter.js';

package/lib/esm/core/function/typed.js

@@ -38,7 +38,8 @@
 import { isAccessorNode, isArray, isArrayNode, isAssignmentNode, isBigNumber, isBlockNode, isBoolean, isChain, isComplex, isConditionalNode, isConstantNode, isDate, isDenseMatrix, isFraction, isFunction, isFunctionAssignmentNode, isFunctionNode, isHelp, isIndex, isIndexNode, isMatrix, isNode, isNull, isNumber, isObject, isObjectNode, isOperatorNode, isParenthesisNode, isRange, isRangeNode, isRegExp, isResultSet, isSparseMatrix, isString, isSymbolNode, isUndefined, isUnit } from '../../utils/is.js';
 import typedFunction from 'typed-function';
 import { digits } from '../../utils/number.js';
-import { factory } from '../../utils/factory.js'; // returns a new instance of typed-function
+import { factory } from '../../utils/factory.js';
+import { isMap } from '../../utils/map.js'; // returns a new instance of typed-function
 
 var _createTyped2 = function _createTyped() {
   // initially, return the original instance of typed-function
@@ -177,6 +178,9 @@ export var createTyped = /* #__PURE__ */factory('typed', dependencies, function
   }, {
     name: 'SymbolNode',
     test: isSymbolNode
+  }, {
+    name: 'Map',
+    test: isMap
   }, {
     name: 'Object',
     test: isObject

package/lib/esm/entry/configReadonly.js

@@ -1,5 +1,4 @@
-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); }
-
+import _extends from "@babel/runtime/helpers/extends";
 import { DEFAULT_CONFIG } from '../core/config.js';
 import { MATRIX_OPTIONS, NUMBER_OPTIONS } from '../core/function/config.js'; // create a read-only version of config
 

package/lib/esm/entry/dependenciesAny/dependenciesEigs.generated.js

@@ -7,15 +7,32 @@ import { addDependencies } from './dependenciesAdd.generated.js';
 import { addScalarDependencies } from './dependenciesAddScalar.generated.js';
 import { atanDependencies } from './dependenciesAtan.generated.js';
 import { bignumberDependencies } from './dependenciesBignumber.generated.js';
+import { columnDependencies } from './dependenciesColumn.generated.js';
+import { complexDependencies } from './dependenciesComplex.generated.js';
 import { cosDependencies } from './dependenciesCos.generated.js';
+import { diagDependencies } from './dependenciesDiag.generated.js';
+import { divideScalarDependencies } from './dependenciesDivideScalar.generated.js';
 import { equalDependencies } from './dependenciesEqual.generated.js';
+import { flattenDependencies } from './dependenciesFlatten.generated.js';
+import { imDependencies } from './dependenciesIm.generated.js';
 import { invDependencies } from './dependenciesInv.generated.js';
+import { largerDependencies } from './dependenciesLarger.generated.js';
+import { log10Dependencies } from './dependenciesLog10.generated.js';
 import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { matrixFromColumnsDependencies } from './dependenciesMatrixFromColumns.generated.js';
 import { multiplyDependencies } from './dependenciesMultiply.generated.js';
 import { multiplyScalarDependencies } from './dependenciesMultiplyScalar.generated.js';
+import { numberDependencies } from './dependenciesNumber.generated.js';
+import { qrDependencies } from './dependenciesQr.generated.js';
+import { reDependencies } from './dependenciesRe.generated.js';
+import { roundDependencies } from './dependenciesRound.generated.js';
 import { sinDependencies } from './dependenciesSin.generated.js';
+import { smallerDependencies } from './dependenciesSmaller.generated.js';
+import { sqrtDependencies } from './dependenciesSqrt.generated.js';
 import { subtractDependencies } from './dependenciesSubtract.generated.js';
+import { transposeDependencies } from './dependenciesTranspose.generated.js';
 import { typedDependencies } from './dependenciesTyped.generated.js';
+import { usolveAllDependencies } from './dependenciesUsolveAll.generated.js';
 import { createEigs } from '../../factoriesAny.js';
 export var eigsDependencies = {
   absDependencies,
@@ -23,14 +40,31 @@ export var eigsDependencies = {
   addScalarDependencies,
   atanDependencies,
   bignumberDependencies,
+  columnDependencies,
+  complexDependencies,
   cosDependencies,
+  diagDependencies,
+  divideScalarDependencies,
   equalDependencies,
+  flattenDependencies,
+  imDependencies,
   invDependencies,
+  largerDependencies,
+  log10Dependencies,
   matrixDependencies,
+  matrixFromColumnsDependencies,
   multiplyDependencies,
   multiplyScalarDependencies,
+  numberDependencies,
+  qrDependencies,
+  reDependencies,
+  roundDependencies,
   sinDependencies,
+  smallerDependencies,
+  sqrtDependencies,
   subtractDependencies,
+  transposeDependencies,
   typedDependencies,
+  usolveAllDependencies,
   createEigs
 };

package/lib/esm/entry/dependenciesAny/dependenciesMatrixFromColumns.generated.js

@@ -0,0 +1,16 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { flattenDependencies } from './dependenciesFlatten.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { sizeDependencies } from './dependenciesSize.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createMatrixFromColumns } from '../../factoriesAny.js';
+export var matrixFromColumnsDependencies = {
+  flattenDependencies,
+  matrixDependencies,
+  sizeDependencies,
+  typedDependencies,
+  createMatrixFromColumns
+};

package/lib/esm/entry/dependenciesAny/dependenciesMatrixFromFunction.generated.js

@@ -0,0 +1,14 @@
+/**
+ * THIS FILE IS AUTO-GENERATED
+ * DON'T MAKE CHANGES HERE
+ */
+import { isZeroDependencies } from './dependenciesIsZero.generated.js';
+import { matrixDependencies } from './dependenciesMatrix.generated.js';
+import { typedDependencies } from './dependenciesTyped.generated.js';
+import { createMatrixFromFunction } from '../../factoriesAny.js';
+export var matrixFromFunctionDependencies = {
+  isZeroDependencies,
+  matrixDependencies,
+  typedDependencies,
+  createMatrixFromFunction
+};