mathjs 8.1.0 → 12.2.1

package/lib/cjs/utils/object.js

@@ -1,29 +1,27 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.canDefineProperty = canDefineProperty;
 exports.clone = clone;
-exports.mapObject = mapObject;
-exports.extend = extend;
 exports.deepExtend = deepExtend;
-exports.deepStrictEqual = deepStrictEqual;
 exports.deepFlatten = deepFlatten;
-exports.canDefineProperty = canDefineProperty;
-exports.lazy = lazy;
-exports.traverse = traverse;
+exports.deepStrictEqual = deepStrictEqual;
+exports.extend = extend;
+exports.get = get;
 exports.hasOwnProperty = hasOwnProperty;
 exports.isLegacyFactory = isLegacyFactory;
-exports.get = get;
-exports.set = set;
+exports.lazy = lazy;
+exports.mapObject = mapObject;
 exports.pick = pick;
 exports.pickShallow = pickShallow;
+exports.set = set;
+exports.traverse = traverse;
 exports.values = values;
-
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 var _is = require("./is.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); }
-
 /**
  * Clone an object
  *
@@ -36,83 +34,76 @@ 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;
-  } // use clone function of the object when available
-
+  }
 
+  // use clone function of the object when available
   if (typeof x.clone === 'function') {
     return x.clone();
-  } // array
-
+  }
 
+  // array
   if (Array.isArray(x)) {
     return x.map(function (value) {
       return clone(value);
     });
   }
-
   if (x instanceof Date) return new Date(x.valueOf());
   if ((0, _is.isBigNumber)(x)) return x; // bignumbers are immutable
 
-  if (x instanceof RegExp) throw new TypeError('Cannot clone ' + x); // TODO: clone a RegExp
   // object
-
-  return mapObject(x, clone);
+  if ((0, _is.isObject)(x)) {
+    return mapObject(x, clone);
+  }
+  throw new TypeError("Cannot clone: unknown type of value (value: ".concat(x, ")"));
 }
+
 /**
  * Apply map to all properties of an object
  * @param {Object} object
  * @param {function} callback
  * @return {Object} Returns a copy of the object with mapped properties
  */
-
-
 function mapObject(object, callback) {
   var clone = {};
-
   for (var key in object) {
     if (hasOwnProperty(object, key)) {
       clone[key] = callback(object[key]);
     }
   }
-
   return clone;
 }
+
 /**
  * Extend object a with the properties of object b
  * @param {Object} a
  * @param {Object} b
  * @return {Object} a
  */
-
-
 function extend(a, b) {
   for (var prop in b) {
     if (hasOwnProperty(b, prop)) {
       a[prop] = b[prop];
     }
   }
-
   return a;
 }
+
 /**
  * Deep extend an object a with the properties of object b
  * @param {Object} a
  * @param {Object} b
  * @returns {Object}
  */
-
-
 function deepExtend(a, b) {
   // TODO: add support for Arrays to deepExtend
   if (Array.isArray(b)) {
     throw new TypeError('Arrays are not supported by deepExtend');
   }
-
   for (var prop in b) {
     // We check against prop not being in Object.prototype or Function.prototype
     // to prevent polluting for example Object.__proto__.
@@ -121,7 +112,6 @@ function deepExtend(a, b) {
         if (a[prop] === undefined) {
           a[prop] = {};
         }
-
         if (a[prop] && a[prop].constructor === Object) {
           deepExtend(a[prop], b[prop]);
         } else {
@@ -134,9 +124,9 @@ function deepExtend(a, b) {
       }
     }
   }
-
   return a;
 }
+
 /**
  * Deep test equality of all fields in two pairs of arrays or objects.
  * Compares values and functions strictly (ie. 2 is not the same as '2').
@@ -144,26 +134,20 @@ function deepExtend(a, b) {
  * @param {Array | Object} b
  * @returns {boolean}
  */
-
-
 function deepStrictEqual(a, b) {
   var prop, i, len;
-
   if (Array.isArray(a)) {
     if (!Array.isArray(b)) {
       return false;
     }
-
     if (a.length !== b.length) {
       return false;
     }
-
     for (i = 0, len = a.length; i < len; i++) {
       if (!deepStrictEqual(a[i], b[i])) {
         return false;
       }
     }
-
     return true;
   } else if (typeof a === 'function') {
     return a === b;
@@ -171,48 +155,41 @@ function deepStrictEqual(a, b) {
     if (Array.isArray(b) || !(b instanceof Object)) {
       return false;
     }
-
     for (prop in a) {
       // noinspection JSUnfilteredForInLoop
       if (!(prop in b) || !deepStrictEqual(a[prop], b[prop])) {
         return false;
       }
     }
-
     for (prop in b) {
       // noinspection JSUnfilteredForInLoop
-      if (!(prop in a) || !deepStrictEqual(a[prop], b[prop])) {
+      if (!(prop in a)) {
         return false;
       }
     }
-
     return true;
   } else {
     return a === b;
   }
 }
+
 /**
  * Recursively flatten a nested object.
  * @param {Object} nestedObject
  * @return {Object} Returns the flattened object
  */
-
-
 function deepFlatten(nestedObject) {
   var flattenedObject = {};
-
   _deepFlatten(nestedObject, flattenedObject);
-
   return flattenedObject;
-} // helper function used by deepFlatten
-
+}
 
+// helper function used by deepFlatten
 function _deepFlatten(nestedObject, flattenedObject) {
   for (var prop in nestedObject) {
     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;
@@ -220,25 +197,26 @@ function _deepFlatten(nestedObject, flattenedObject) {
     }
   }
 }
+
 /**
  * Test whether the current JavaScript engine supports Object.defineProperty
  * @returns {boolean} returns true if supported
  */
-
-
 function canDefineProperty() {
   // test needed for broken IE8 implementation
   try {
     if (Object.defineProperty) {
       Object.defineProperty({}, 'x', {
-        get: function get() {}
+        get: function get() {
+          return null;
+        }
       });
       return true;
     }
   } catch (e) {}
-
   return false;
 }
+
 /**
  * Attach a lazy loading property to a constant.
  * The given function `fn` is called once when the property is first requested.
@@ -248,20 +226,15 @@ function canDefineProperty() {
  * @param {Function} valueResolver Function returning the property value. Called
  *                                without arguments.
  */
-
-
 function lazy(object, prop, valueResolver) {
   var _uninitialized = true;
-
   var _value;
-
   Object.defineProperty(object, prop, {
     get: function get() {
       if (_uninitialized) {
         _value = valueResolver();
         _uninitialized = false;
       }
-
       return _value;
     },
     set: function set(value) {
@@ -272,6 +245,7 @@ function lazy(object, prop, valueResolver) {
     enumerable: true
   });
 }
+
 /**
  * Traverse a path into an object.
  * When a namespace is missing, it will be created
@@ -279,39 +253,32 @@ function lazy(object, prop, valueResolver) {
  * @param {string | string[]} path   A dot separated string like 'name.space'
  * @return {Object} Returns the object at the end of the path
  */
-
-
 function traverse(object, path) {
   if (path && typeof path === 'string') {
     return traverse(object, path.split('.'));
   }
-
   var obj = object;
-
   if (path) {
     for (var i = 0; i < path.length; i++) {
       var key = path[i];
-
       if (!(key in obj)) {
         obj[key] = {};
       }
-
       obj = obj[key];
     }
   }
-
   return obj;
 }
+
 /**
  * A safe hasOwnProperty
  * @param {Object} object
  * @param {string} property
  */
-
-
 function hasOwnProperty(object, property) {
   return object && Object.hasOwnProperty.call(object, property);
 }
+
 /**
  * Test whether an object is a factory. a factory has fields:
  *
@@ -324,19 +291,16 @@ function hasOwnProperty(object, property) {
  * @param {*} object
  * @returns {boolean}
  */
-
-
 function isLegacyFactory(object) {
   return object && typeof object.factory === 'function';
 }
+
 /**
  * Get a nested property from an object
  * @param {Object} object
  * @param {string | string[]} path
  * @returns {Object}
  */
-
-
 function get(object, path) {
   if (typeof path === 'string') {
     if (isPath(path)) {
@@ -345,16 +309,14 @@ function get(object, path) {
       return object[path];
     }
   }
-
   var child = object;
-
   for (var i = 0; i < path.length; i++) {
     var key = path[i];
     child = child ? child[key] : undefined;
   }
-
   return child;
 }
+
 /**
  * Set a nested property in an object
  * Mutates the object itself
@@ -364,8 +326,6 @@ function get(object, path) {
  * @param {*} value
  * @returns {Object}
  */
-
-
 function set(object, path, value) {
   if (typeof path === 'string') {
     if (isPath(path)) {
@@ -375,26 +335,21 @@ function set(object, path, value) {
       return object;
     }
   }
-
   var child = object;
-
   for (var i = 0; i < path.length - 1; i++) {
     var key = path[i];
-
     if (child[key] === undefined) {
       child[key] = {};
     }
-
     child = child[key];
   }
-
   if (path.length > 0) {
     var lastKey = path[path.length - 1];
     child[lastKey] = value;
   }
-
   return object;
 }
+
 /**
  * Create an object composed of the picked object properties
  * @param {Object} object
@@ -402,22 +357,18 @@ function set(object, path, value) {
  * @param {function} [transform] Optional value to transform a value when picking it
  * @return {Object}
  */
-
-
 function pick(object, properties, transform) {
   var copy = {};
-
   for (var i = 0; i < properties.length; i++) {
     var key = properties[i];
     var value = get(object, key);
-
     if (value !== undefined) {
       set(copy, key, transform ? transform(value, key) : value);
     }
   }
-
   return copy;
 }
+
 /**
  * Shallow version of pick, creating an object composed of the picked object properties
  * but not for nested properties
@@ -425,30 +376,24 @@ function pick(object, properties, transform) {
  * @param {string[]} properties
  * @return {Object}
  */
-
-
 function pickShallow(object, properties) {
   var copy = {};
-
   for (var i = 0; i < properties.length; i++) {
     var key = properties[i];
     var value = object[key];
-
     if (value !== undefined) {
       copy[key] = value;
     }
   }
-
   return copy;
 }
-
 function values(object) {
   return Object.keys(object).map(function (key) {
     return object[key];
   });
-} // helper function to test whether a string contains a path like 'user.name'
-
+}
 
+// helper function to test whether a string contains a path like 'user.name'
 function isPath(str) {
   return str.indexOf('.') !== -1;
 }

package/lib/cjs/utils/print.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.printTemplate = void 0;
+var printTemplate = exports.printTemplate = /\$([\w.]+)/g;

package/lib/cjs/utils/product.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.product = product;
-
 /** @param {number} i
  *  @param {number} n
  *  @returns {number} product of i to n
@@ -13,12 +12,9 @@ function product(i, n) {
   if (n < i) {
     return 1;
   }
-
   if (n === i) {
     return n;
   }
-
   var half = n + i >> 1; // divide (n + i) by 2 and truncate to integer
-
   return product(i, half) * product(half + 1, n);
 }

package/lib/cjs/utils/scope.js

@@ -0,0 +1,29 @@
+"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));
+}