mathjs 9.3.2 → 9.4.0

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/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

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));
+}