mathjs 11.2.0 → 11.3.0

package/lib/cjs/utils/string.js

@@ -1,7 +1,6 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -10,15 +9,10 @@ exports.endsWith = endsWith;
 exports.escape = escape;
 exports.format = format;
 exports.stringify = stringify;
-
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
-
 var _is = require("./is.js");
-
 var _number = require("./number.js");
-
 var _formatter = require("./bignumber/formatter.js");
-
 /**
  * Check if a text ends with a certain string.
  * @param {string} text
@@ -29,6 +23,7 @@ function endsWith(text, search) {
   var end = text.length;
   return text.substring(start, end) === search;
 }
+
 /**
  * Format a value of any type into a string.
  *
@@ -67,29 +62,23 @@ function endsWith(text, search) {
  *     have been more, they are deleted and replaced by an ellipsis).
  * @return {string} str
  */
-
-
 function format(value, options) {
   var result = _format(value, options);
-
   if (options && (0, _typeof2["default"])(options) === 'object' && 'truncate' in options && result.length > options.truncate) {
     return result.substring(0, options.truncate - 3) + '...';
   }
-
   return result;
 }
-
 function _format(value, options) {
   if (typeof value === 'number') {
     return (0, _number.format)(value, options);
   }
-
   if ((0, _is.isBigNumber)(value)) {
     return (0, _formatter.format)(value, options);
-  } // note: we use unsafe duck-typing here to check for Fractions, this is
-  // ok here since we're only invoking toString or concatenating its values
-
+  }
 
+  // note: we use unsafe duck-typing here to check for Fractions, this is
+  // ok here since we're only invoking toString or concatenating its values
   if (looksLikeFraction(value)) {
     if (!options || options.fraction !== 'decimal') {
       // output as ratio, like '1/3'
@@ -99,19 +88,15 @@ function _format(value, options) {
       return value.toString();
     }
   }
-
   if (Array.isArray(value)) {
     return formatArray(value, options);
   }
-
   if ((0, _is.isString)(value)) {
     return '"' + value + '"';
   }
-
   if (typeof value === 'function') {
     return value.syntax ? String(value.syntax) : 'function';
   }
-
   if (value && (0, _typeof2["default"])(value) === 'object') {
     if (typeof value.format === 'function') {
       return value.format(options);
@@ -125,30 +110,25 @@ function _format(value, options) {
       return '{' + entries.join(', ') + '}';
     }
   }
-
   return String(value);
 }
+
 /**
  * Stringify a value into a string enclosed in double quotes.
  * Unescaped double quotes and backslashes inside the value are escaped.
  * @param {*} value
  * @return {string}
  */
-
-
 function stringify(value) {
   var text = String(value);
   var escaped = '';
   var i = 0;
-
   while (i < text.length) {
     var c = text.charAt(i);
-
     if (c === '\\') {
       escaped += c;
       i++;
       c = text.charAt(i);
-
       if (c === '' || '"\\/bfnrtu'.indexOf(c) === -1) {
         escaped += '\\'; // no valid escape character -> escape it
       }
@@ -159,24 +139,22 @@ function stringify(value) {
     } else {
       escaped += c;
     }
-
     i++;
   }
-
   return '"' + escaped + '"';
 }
+
 /**
  * Escape special HTML characters
  * @param {*} value
  * @return {string}
  */
-
-
 function escape(value) {
   var text = String(value);
   text = text.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/'/g, '&#39;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
   return text;
 }
+
 /**
  * Recursively format an n-dimensional matrix
  * Example output: "[[1, 2], [3, 4]]"
@@ -187,54 +165,45 @@ function escape(value) {
  *                                                options.
  * @returns {string} str
  */
-
-
 function formatArray(array, options) {
   if (Array.isArray(array)) {
     var str = '[';
     var len = array.length;
-
     for (var i = 0; i < len; i++) {
       if (i !== 0) {
         str += ', ';
       }
-
       str += formatArray(array[i], options);
     }
-
     str += ']';
     return str;
   } else {
     return format(array, options);
   }
 }
+
 /**
  * Check whether a value looks like a Fraction (unsafe duck-type check)
  * @param {*} value
  * @return {boolean}
  */
-
-
 function looksLikeFraction(value) {
   return value && (0, _typeof2["default"])(value) === 'object' && typeof value.s === 'number' && typeof value.n === 'number' && typeof value.d === 'number' || false;
 }
+
 /**
  * Compare two strings
  * @param {string} x
  * @param {string} y
  * @returns {number}
  */
-
-
 function compareText(x, y) {
   // we don't want to convert numbers to string, only accept string input
   if (!(0, _is.isString)(x)) {
     throw new TypeError('Unexpected type of argument in function compareText ' + '(expected: string or Array or Matrix, actual: ' + (0, _is.typeOf)(x) + ', index: 0)');
   }
-
   if (!(0, _is.isString)(y)) {
     throw new TypeError('Unexpected type of argument in function compareText ' + '(expected: string or Array or Matrix, actual: ' + (0, _is.typeOf)(y) + ', index: 1)');
   }
-
   return x === y ? 0 : x > y ? 1 : -1;
 }

package/lib/cjs/utils/switch.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports._switch = _switch;
-
 /**
  * Transpose a matrix
  * @param {Array} mat
@@ -16,16 +15,12 @@ function _switch(mat) {
   var J = mat[0].length;
   var i, j;
   var ret = [];
-
   for (j = 0; j < J; j++) {
     var tmp = [];
-
     for (i = 0; i < I; i++) {
       tmp.push(mat[i][j]);
     }
-
     ret.push(tmp);
   }
-
   return ret;
 }

package/lib/cjs/version.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-var version = '11.2.0'; // Note: This file is automatically generated when building math.js.
+var version = '11.3.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

@@ -39,8 +39,9 @@ export var createE = /* #__PURE__ */recreateFactory('e', ['config', '?BigNumber'
     BigNumber
   } = _ref5;
   return config.number === 'BigNumber' ? createBigNumberE(BigNumber) : e;
-}); // golden ratio, (1+sqrt(5))/2
+});
 
+// golden ratio, (1+sqrt(5))/2
 export var createPhi = /* #__PURE__ */recreateFactory('phi', ['config', '?BigNumber'], _ref6 => {
   var {
     config,
@@ -76,7 +77,8 @@ export var createLOG10E = /* #__PURE__ */recreateFactory('LOG10E', ['config', '?
   } = _ref10;
   return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(10).ln()) : Math.LOG10E;
 });
-export var createSQRT1_2 = /* #__PURE__ */recreateFactory( // eslint-disable-line camelcase
+export var createSQRT1_2 = /* #__PURE__ */recreateFactory(
+// eslint-disable-line camelcase
 'SQRT1_2', ['config', '?BigNumber'], _ref11 => {
   var {
     config,
@@ -96,8 +98,9 @@ export var createI = /* #__PURE__ */recreateFactory('i', ['Complex'], _ref13 =>
     Complex
   } = _ref13;
   return Complex.I;
-}); // for backward compatibility with v5
+});
 
+// for backward compatibility with v5
 export var createUppercasePi = /* #__PURE__ */factory('PI', ['pi'], _ref14 => {
   var {
     pi
@@ -110,9 +113,10 @@ export var createUppercaseE = /* #__PURE__ */factory('E', ['e'], _ref15 => {
   } = _ref15;
   return e;
 });
-export var createVersion = /* #__PURE__ */factory('version', [], () => version); // helper function to create a factory with a flag recreateOnConfigChange
-// idea: allow passing optional properties to be attached to the factory function as 4th argument?
+export var createVersion = /* #__PURE__ */factory('version', [], () => version);
 
+// helper function to create a factory with a flag recreateOnConfigChange
+// idea: allow passing optional properties to be attached to the factory function as 4th argument?
 function recreateFactory(name, dependencies, create) {
   return factory(name, dependencies, create, {
     recreateOnConfigChange: true

package/lib/esm/core/create.js

@@ -10,6 +10,7 @@ import { ArgumentsError } from '../error/ArgumentsError.js';
 import { DimensionError } from '../error/DimensionError.js';
 import { IndexError } from '../error/IndexError.js';
 import { DEFAULT_CONFIG } from './config.js';
+
 /**
  * Create a mathjs instance from given factory functions and optionally config
  *
@@ -49,16 +50,15 @@ import { DEFAULT_CONFIG } from './config.js';
  *                   - `config` to change configuration
  *                   - `on`, `off`, `once`, `emit` for events
  */
-
 export function create(factories, config) {
-  var configInternal = _extends({}, DEFAULT_CONFIG, config); // simple test for ES5 support
-
+  var configInternal = _extends({}, DEFAULT_CONFIG, config);
 
+  // simple test for ES5 support
   if (typeof Object.create !== 'function') {
     throw new Error('ES5 not supported by this JavaScript engine. ' + 'Please load the es5-shim and es5-sham library for compatibility.');
-  } // create the mathjs instance
-
+  }
 
+  // create the mathjs instance
   var math = emitter.mixin({
     // only here for backward compatibility for legacy factory functions
     isNumber,
@@ -100,18 +100,21 @@ export function create(factories, config) {
     isRelationalNode,
     isSymbolNode,
     isChain
-  }); // load config function and apply provided config
+  });
 
+  // load config function and apply provided config
   math.config = configFactory(configInternal, math.emit);
   math.expression = {
     transform: {},
     mathWithTransform: {
       config: math.config
     }
-  }; // cached factories and instances used by function load
+  };
 
+  // cached factories and instances used by function load
   var legacyFactories = [];
   var legacyInstances = [];
+
   /**
    * Load a function or data type from a factory.
    * If the function or data type already exists, the existing instance is
@@ -119,26 +122,20 @@ export function create(factories, config) {
    * @param {Function} factory
    * @returns {*}
    */
-
   function load(factory) {
     if (isFactory(factory)) {
       return factory(math);
     }
-
     var firstProperty = factory[Object.keys(factory)[0]];
-
     if (isFactory(firstProperty)) {
       return firstProperty(math);
     }
-
     if (!isLegacyFactory(factory)) {
       console.warn('Factory object with properties `type`, `name`, and `factory` expected', factory);
       throw new Error('Factory object with properties `type`, `name`, and `factory` expected');
     }
-
     var index = legacyFactories.indexOf(factory);
     var instance;
-
     if (index === -1) {
       // doesn't yet exist
       if (factory.math === true) {
@@ -146,34 +143,32 @@ export function create(factories, config) {
         instance = factory.factory(math.type, configInternal, load, math.typed, math);
       } else {
         instance = factory.factory(math.type, configInternal, load, math.typed);
-      } // append to the cache
-
+      }
 
+      // append to the cache
       legacyFactories.push(factory);
       legacyInstances.push(instance);
     } else {
       // already existing function, return the cached instance
       instance = legacyInstances[index];
     }
-
     return instance;
   }
+  var importedFactories = {};
 
-  var importedFactories = {}; // load the import function
-
+  // load the import function
   function lazyTyped() {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-
     return math.typed.apply(math.typed, args);
   }
-
   lazyTyped.isTypedFunction = typedFunction.isTypedFunction;
   var internalImport = importFactory(lazyTyped, load, math, importedFactories);
-  math.import = internalImport; // listen for changes in config, import all functions again when changed
-  // TODO: move this listener into the import function?
+  math.import = internalImport;
 
+  // listen for changes in config, import all functions again when changed
+  // TODO: move this listener into the import function?
   math.on('config', () => {
     values(importedFactories).forEach(factory => {
       if (factory && factory.meta && factory.meta.recreateOnConfigChange) {
@@ -184,14 +179,17 @@ export function create(factories, config) {
         });
       }
     });
-  }); // the create function exposed on the mathjs instance is bound to
+  });
+
+  // the create function exposed on the mathjs instance is bound to
   // the factory functions passed before
+  math.create = create.bind(null, factories);
 
-  math.create = create.bind(null, factories); // export factory function
+  // export factory function
+  math.factory = factory;
 
-  math.factory = factory; // import the factory functions like createAdd as an array instead of object,
+  // import the factory functions like createAdd as an array instead of object,
   // else they will get a different naming (`createAdd` instead of `add`).
-
   math.import(values(deepFlatten(factories)));
   math.ArgumentsError = ArgumentsError;
   math.DimensionError = DimensionError;

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

@@ -1,7 +1,6 @@
 import { clone, mapObject, deepExtend } from '../../utils/object.js';
 import { DEFAULT_CONFIG } from '../config.js';
 export var MATRIX_OPTIONS = ['Matrix', 'Array']; // valid values for option matrix
-
 export var NUMBER_OPTIONS = ['number', 'BigNumber', 'Fraction']; // valid values for option number
 
 export function configFactory(config, emit) {
@@ -49,26 +48,30 @@ export function configFactory(config, emit) {
    */
   function _config(options) {
     if (options) {
-      var prev = mapObject(config, clone); // validate some of the options
+      var prev = mapObject(config, clone);
 
+      // validate some of the options
       validateOption(options, 'matrix', MATRIX_OPTIONS);
-      validateOption(options, 'number', NUMBER_OPTIONS); // merge options
+      validateOption(options, 'number', NUMBER_OPTIONS);
 
+      // merge options
       deepExtend(config, options);
       var curr = mapObject(config, clone);
-      var changes = mapObject(options, clone); // emit 'config' event
+      var changes = mapObject(options, clone);
 
+      // emit 'config' event
       emit('config', curr, prev, changes);
       return curr;
     } else {
       return mapObject(config, clone);
     }
-  } // attach the valid options to the function so they can be extended
-
+  }
 
+  // attach the valid options to the function so they can be extended
   _config.MATRIX_OPTIONS = MATRIX_OPTIONS;
-  _config.NUMBER_OPTIONS = NUMBER_OPTIONS; // attach the config properties as readonly properties to the config function
+  _config.NUMBER_OPTIONS = NUMBER_OPTIONS;
 
+  // attach the config properties as readonly properties to the config function
   Object.keys(DEFAULT_CONFIG).forEach(key => {
     Object.defineProperty(_config, key, {
       get: () => config[key],
@@ -78,24 +81,23 @@ export function configFactory(config, emit) {
   });
   return _config;
 }
+
 /**
  * Test whether an Array contains a specific item.
  * @param {Array.<string>} array
  * @param {string} item
  * @return {boolean}
  */
-
 function contains(array, item) {
   return array.indexOf(item) !== -1;
 }
+
 /**
  * Validate an option
  * @param {Object} options         Object with options
  * @param {string} name            Name of the option to validate
  * @param {Array.<string>} values  Array with valid values for this option
  */
-
-
 function validateOption(options, name, values) {
   if (options[name] !== undefined && !contains(values, options[name])) {
     // unknown value