mathjs-min 11.7.2

package/lib/cjs/utils/object.js

@@ -0,0 +1,397 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.canDefineProperty = canDefineProperty;
+exports.clone = clone;
+exports.deepExtend = deepExtend;
+exports.deepFlatten = deepFlatten;
+exports.deepStrictEqual = deepStrictEqual;
+exports.extend = extend;
+exports.get = get;
+exports.hasOwnProperty = hasOwnProperty;
+exports.isLegacyFactory = isLegacyFactory;
+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");
+/**
+ * Clone an object
+ *
+ *     clone(x)
+ *
+ * Can clone any primitive type, array, and object.
+ * If x has a function clone, this function will be invoked to clone the object.
+ *
+ * @param {*} x
+ * @return {*} clone
+ */
+function clone(x) {
+  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
+  if (typeof x.clone === 'function') {
+    return x.clone();
+  }
+
+  // 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);
+}
+
+/**
+ * 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__.
+    if (hasOwnProperty(b, prop) && !(prop in Object.prototype) && !(prop in Function.prototype)) {
+      if (b[prop] && b[prop].constructor === Object) {
+        if (a[prop] === undefined) {
+          a[prop] = {};
+        }
+        if (a[prop] && a[prop].constructor === Object) {
+          deepExtend(a[prop], b[prop]);
+        } else {
+          a[prop] = b[prop];
+        }
+      } else if (Array.isArray(b[prop])) {
+        throw new TypeError('Arrays are not supported by deepExtend');
+      } else {
+        a[prop] = b[prop];
+      }
+    }
+  }
+  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').
+ * @param {Array | Object} a
+ * @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;
+  } else if (a instanceof Object) {
+    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)) {
+        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
+function _deepFlatten(nestedObject, flattenedObject) {
+  for (var prop in nestedObject) {
+    if (hasOwnProperty(nestedObject, prop)) {
+      var value = nestedObject[prop];
+      if ((0, _typeof2["default"])(value) === 'object' && value !== null) {
+        _deepFlatten(value, flattenedObject);
+      } else {
+        flattenedObject[prop] = value;
+      }
+    }
+  }
+}
+
+/**
+ * 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() {
+          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.
+ *
+ * @param {Object} object         Object where to add the property
+ * @param {string} prop           Property name
+ * @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) {
+      _value = value;
+      _uninitialized = false;
+    },
+    configurable: true,
+    enumerable: true
+  });
+}
+
+/**
+ * Traverse a path into an object.
+ * When a namespace is missing, it will be created
+ * @param {Object} object
+ * @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:
+ *
+ * - factory: function (type: Object, config: Object, load: function, typed: function [, math: Object])   (required)
+ * - name: string (optional)
+ * - path: string    A dot separated path (optional)
+ * - math: boolean   If true (false by default), the math namespace is passed
+ *                   as fifth argument of the factory function
+ *
+ * @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)) {
+      return get(object, path.split('.'));
+    } else {
+      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
+ * If the path doesn't exist, it will be created
+ * @param {Object} object
+ * @param {string | string[]} path
+ * @param {*} value
+ * @returns {Object}
+ */
+function set(object, path, value) {
+  if (typeof path === 'string') {
+    if (isPath(path)) {
+      return set(object, path.split('.'), value);
+    } else {
+      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
+ * @param {string[]} properties
+ * @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
+ * @param {Object} object
+ * @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'
+function isPath(str) {
+  return str.indexOf('.') !== -1;
+}

package/lib/cjs/utils/product.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.product = product;
+/** @param {number} i
+ *  @param {number} n
+ *  @returns {number} product of i to n
+ */
+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));
+}

package/lib/cjs/utils/snapshot.js

@@ -0,0 +1,234 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSnapshotFromFactories = createSnapshotFromFactories;
+exports.validateBundle = validateBundle;
+exports.validateTypeOf = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _assert = _interopRequireDefault(require("assert"));
+var allIsFunctions = _interopRequireWildcard(require("./is.js"));
+var _create = require("../core/create.js");
+var _string = require("./string.js");
+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, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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 = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2["default"])(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var validateTypeOf = allIsFunctions.typeOf;
+exports.validateTypeOf = validateTypeOf;
+function validateBundle(expectedBundleStructure, bundle) {
+  var originalWarn = console.warn;
+  console.warn = function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    if (args.join(' ').indexOf('is moved to') !== -1 && args.join(' ').indexOf('Please use the new location instead') !== -1) {
+      // Ignore warnings like:
+      // Warning: math.type.isNumber is moved to math.isNumber in v6.0.0. Please use the new location instead.
+      return;
+    }
+    originalWarn.apply(console, args);
+  };
+  try {
+    var issues = [];
+
+    // see whether all expected functions and objects are there
+    traverse(expectedBundleStructure, function (expectedType, path) {
+      var actualValue = get(bundle, path);
+      var actualType = validateTypeOf(actualValue);
+      var message = actualType === 'undefined' ? 'Missing entry in bundle. ' + "Path: ".concat(JSON.stringify(path), ", expected type: ").concat(expectedType, ", actual type: ").concat(actualType) : 'Unexpected entry type in bundle. ' + "Path: ".concat(JSON.stringify(path), ", expected type: ").concat(expectedType, ", actual type: ").concat(actualType);
+      if (actualType !== expectedType) {
+        issues.push({
+          actualType: actualType,
+          expectedType: expectedType,
+          message: message
+        });
+        console.warn(message);
+      }
+    });
+
+    // see whether there are any functions or objects that shouldn't be there
+    traverse(bundle, function (actualValue, path) {
+      var actualType = validateTypeOf(actualValue);
+      var expectedType = get(expectedBundleStructure, path) || 'undefined';
+
+      // FIXME: ugly to have these special cases
+      if (path.join('.').indexOf('docs.') !== -1) {
+        // ignore the contents of docs
+        return;
+      }
+      if (path.join('.').indexOf('all.') !== -1) {
+        // ignore the contents of all dependencies
+        return;
+      }
+      var message = expectedType === 'undefined' ? 'Unknown entry in bundle. ' + 'Is there a new function added which is missing in this snapshot test? ' + "Path: ".concat(JSON.stringify(path), ", expected type: ").concat(expectedType, ", actual type: ").concat(actualType) : 'Unexpected entry type in bundle. ' + "Path: ".concat(JSON.stringify(path), ", expected type: ").concat(expectedType, ", actual type: ").concat(actualType);
+      if (actualType !== expectedType) {
+        issues.push({
+          actualType: actualType,
+          expectedType: expectedType,
+          message: message
+        });
+        console.warn(message);
+      }
+    });
+
+    // assert on the first issue (if any)
+    if (issues.length > 0) {
+      var _issues$ = issues[0],
+        actualType = _issues$.actualType,
+        expectedType = _issues$.expectedType,
+        message = _issues$.message;
+      console.warn("".concat(issues.length, " bundle issues found"));
+      _assert["default"].strictEqual(actualType, expectedType, message);
+    }
+  } finally {
+    console.warn = originalWarn;
+  }
+}
+
+/**
+ * Based on an object with factory functions, create the expected
+ * structures for ES6 export and a mathjs instance.
+ * @param {Object} factories
+ * @return {{expectedInstanceStructure: Object, expectedES6Structure: Object}}
+ */
+function createSnapshotFromFactories(factories) {
+  var math = (0, _create.create)(factories);
+  var allFactoryFunctions = {};
+  var allFunctionsConstantsClasses = {};
+  var allFunctionsConstants = {};
+  var allTransformFunctions = {};
+  var allDependencyCollections = {};
+  var allClasses = {};
+  var allNodeClasses = {};
+  Object.keys(factories).forEach(function (factoryName) {
+    var factory = factories[factoryName];
+    var name = factory.fn;
+    var isTransformFunction = factory.meta && factory.meta.isTransformFunction;
+    var isClass = !isLowerCase(name[0]) && validateTypeOf(math[name]) === 'function';
+    var dependenciesName = factory.fn + (isTransformFunction ? 'Transform' : '') + 'Dependencies';
+    allFactoryFunctions[factoryName] = 'function';
+    allFunctionsConstantsClasses[name] = validateTypeOf(math[name]);
+    allDependencyCollections[dependenciesName] = 'Object';
+    if (isTransformFunction) {
+      allTransformFunctions[name] = 'function';
+    }
+    if (isClass) {
+      if ((0, _string.endsWith)(name, 'Node')) {
+        allNodeClasses[name] = 'function';
+      } else {
+        allClasses[name] = 'function';
+      }
+    } else {
+      allFunctionsConstants[name] = validateTypeOf(math[name]);
+    }
+  });
+  var embeddedDocs = {};
+  Object.keys(factories).forEach(function (factoryName) {
+    var factory = factories[factoryName];
+    var name = factory.fn;
+    if (isLowerCase(factory.fn[0])) {
+      // ignore class names starting with upper case
+      embeddedDocs[name] = 'Object';
+    }
+  });
+  embeddedDocs = exclude(embeddedDocs, ['equalScalar', 'apply', 'addScalar', 'multiplyScalar', 'print', 'divideScalar', 'parse', 'compile', 'parser', 'chain', 'reviver', 'replacer']);
+  var allTypeChecks = {};
+  Object.keys(allIsFunctions).forEach(function (name) {
+    if (name.indexOf('is') === 0) {
+      allTypeChecks[name] = 'function';
+    }
+  });
+  var allErrorClasses = {
+    ArgumentsError: 'function',
+    DimensionError: 'function',
+    IndexError: 'function'
+  };
+  var expectedInstanceStructure = _objectSpread(_objectSpread(_objectSpread(_objectSpread({}, allFunctionsConstantsClasses), {}, {
+    on: 'function',
+    off: 'function',
+    once: 'function',
+    emit: 'function',
+    "import": 'function',
+    config: 'function',
+    create: 'function',
+    factory: 'function'
+  }, allTypeChecks), allErrorClasses), {}, {
+    expression: {
+      transform: _objectSpread({}, allTransformFunctions),
+      mathWithTransform: _objectSpread(_objectSpread({}, exclude(allFunctionsConstants, ['chain'])), {}, {
+        config: 'function'
+      })
+    }
+  });
+  var expectedES6Structure = _objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, exclude(allFunctionsConstantsClasses, ['E', 'false', 'Infinity', 'NaN', 'null', 'PI', 'true'])), {}, {
+    create: 'function',
+    config: 'function',
+    factory: 'function',
+    _true: 'boolean',
+    _false: 'boolean',
+    _null: 'null',
+    _Infinity: 'number',
+    _NaN: 'number'
+  }, allTypeChecks), allErrorClasses), allDependencyCollections), allFactoryFunctions), {}, {
+    docs: embeddedDocs
+  });
+  return {
+    expectedInstanceStructure: expectedInstanceStructure,
+    expectedES6Structure: expectedES6Structure
+  };
+}
+function traverse(obj) {
+  var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (value, path) {};
+  var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  // FIXME: ugly to have these special cases
+  if (path.length > 0 && path[0].indexOf('Dependencies') !== -1) {
+    // special case for objects holding a collection of dependencies
+    callback(obj, path);
+  } else if (validateTypeOf(obj) === 'Array') {
+    obj.map(function (item, index) {
+      return traverse(item, callback, path.concat(index));
+    });
+  } else if (validateTypeOf(obj) === 'Object') {
+    Object.keys(obj).forEach(function (key) {
+      // FIXME: ugly to have these special cases
+      // ignore special case of deprecated docs
+      if (key === 'docs' && path.join('.') === 'expression') {
+        return;
+      }
+      traverse(obj[key], callback, path.concat(key));
+    });
+  } else {
+    callback(obj, path);
+  }
+}
+function get(object, path) {
+  var child = object;
+  for (var i = 0; i < path.length; i++) {
+    var key = path[i];
+    child = child ? child[key] : undefined;
+  }
+  return child;
+}
+
+/**
+ * Create a copy of the provided `object` and delete
+ * all properties listed in `excludedProperties`
+ * @param {Object} object
+ * @param {string[]} excludedProperties
+ * @return {Object}
+ */
+function exclude(object, excludedProperties) {
+  var strippedObject = (0, _extends2["default"])({}, object);
+  excludedProperties.forEach(function (excludedProperty) {
+    delete strippedObject[excludedProperty];
+  });
+  return strippedObject;
+}
+function isLowerCase(text) {
+  return typeof text === 'string' && text.toLowerCase() === text;
+}