mathjs 8.1.0 → 12.2.1

package/lib/esm/utils/snapshot.js

@@ -1,11 +1,7 @@
-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 _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; }
-
+import _extends from "@babel/runtime/helpers/extends";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
 /**
  * This file contains helper methods to create expected snapshot structures
  * of both instance and ES6 exports.
@@ -17,31 +13,28 @@ import assert from 'assert';
 import * as allIsFunctions from './is.js';
 import { create } from '../core/create.js';
 import { endsWith } from './string.js';
+export var validateTypeOf = allIsFunctions.typeOf;
 export 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
+    var issues = [];
 
+    // see whether all expected functions and objects are there
     traverse(expectedBundleStructure, (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,
@@ -50,24 +43,23 @@ export function validateBundle(expectedBundleStructure, bundle) {
         });
         console.warn(message);
       }
-    }); // see whether there are any functions or objects that shouldn't be there
+    });
 
+    // see whether there are any functions or objects that shouldn't be there
     traverse(bundle, (actualValue, path) => {
       var actualType = validateTypeOf(actualValue);
-      var expectedType = get(expectedBundleStructure, path) || 'undefined'; // FIXME: ugly to have these special cases
+      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,
@@ -76,8 +68,9 @@ export function validateBundle(expectedBundleStructure, bundle) {
         });
         console.warn(message);
       }
-    }); // assert on the first issue (if any)
+    });
 
+    // assert on the first issue (if any)
     if (issues.length > 0) {
       var {
         actualType,
@@ -91,13 +84,13 @@ export function validateBundle(expectedBundleStructure, bundle) {
     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}}
  */
-
 export function createSnapshotFromFactories(factories) {
   var math = create(factories);
   var allFactoryFunctions = {};
@@ -111,21 +104,19 @@ export function createSnapshotFromFactories(factories) {
     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 isClass = !isLowerCase(name[0]) && validateTypeOf(math[name]) === 'function';
     var dependenciesName = factory.fn + (isTransformFunction ? 'Transform' : '') + 'Dependencies';
-    allFactoryFunctions[factoryName] = 'Function';
+    allFactoryFunctions[factoryName] = 'function';
     allFunctionsConstantsClasses[name] = validateTypeOf(math[name]);
     allDependencyCollections[dependenciesName] = 'Object';
-
     if (isTransformFunction) {
-      allTransformFunctions[name] = 'Function';
+      allTransformFunctions[name] = 'function';
     }
-
     if (isClass) {
       if (endsWith(name, 'Node')) {
-        allNodeClasses[name] = 'Function';
+        allNodeClasses[name] = 'function';
       } else {
-        allClasses[name] = 'Function';
+        allClasses[name] = 'function';
       }
     } else {
       allFunctionsConstants[name] = validateTypeOf(math[name]);
@@ -135,47 +126,44 @@ export function createSnapshotFromFactories(factories) {
   Object.keys(factories).forEach(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']);
+  embeddedDocs = exclude(embeddedDocs, ['equalScalar', 'apply', 'addScalar', 'subtractScalar', 'multiplyScalar', 'print', 'divideScalar', 'parse', 'compile', 'parser', 'chain', 'reviver', 'replacer']);
   var allTypeChecks = {};
   Object.keys(allIsFunctions).forEach(name => {
     if (name.indexOf('is') === 0) {
-      allTypeChecks[name] = 'Function';
+      allTypeChecks[name] = 'function';
     }
   });
   var allErrorClasses = {
-    ArgumentsError: 'Function',
-    DimensionError: 'Function',
-    IndexError: 'Function'
+    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'
+    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'
+        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',
+    create: 'function',
+    config: 'function',
+    factory: 'function',
     _true: 'boolean',
     _false: 'boolean',
     _null: 'null',
@@ -184,44 +172,14 @@ export function createSnapshotFromFactories(factories) {
   }, allTypeChecks), allErrorClasses), allDependencyCollections), allFactoryFunctions), {}, {
     docs: embeddedDocs
   });
-
   return {
     expectedInstanceStructure,
     expectedES6Structure
   };
 }
-export function validateTypeOf(x) {
-  if (x && x.type === 'Unit') {
-    return 'Unit';
-  }
-
-  if (x && x.type === 'Complex') {
-    return 'Complex';
-  }
-
-  if (Array.isArray(x)) {
-    return 'Array';
-  }
-
-  if (x === null) {
-    return 'null';
-  }
-
-  if (typeof x === 'function') {
-    return 'Function';
-  }
-
-  if (typeof x === 'object') {
-    return 'Object';
-  }
-
-  return typeof x;
-}
-
 function traverse(obj) {
   var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : (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
@@ -235,24 +193,21 @@ function traverse(obj) {
       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`
@@ -260,17 +215,13 @@ function get(object, path) {
  * @param {string[]} excludedProperties
  * @return {Object}
  */
-
-
 function exclude(object, excludedProperties) {
   var strippedObject = _extends({}, object);
-
   excludedProperties.forEach(excludedProperty => {
     delete strippedObject[excludedProperty];
   });
   return strippedObject;
 }
-
 function isLowerCase(text) {
   return typeof text === 'string' && text.toLowerCase() === text;
 }

package/lib/esm/utils/string.js

@@ -1,23 +1,25 @@
 import { isBigNumber, isString, typeOf } from './is.js';
 import { format as formatNumber } from './number.js';
 import { format as formatBigNumber } from './bignumber/formatter.js';
+
 /**
  * Check if a text ends with a certain string.
  * @param {string} text
  * @param {string} search
  */
-
 export function endsWith(text, search) {
   var start = text.length - search.length;
   var end = text.length;
   return text.substring(start, end) === search;
 }
+
 /**
  * Format a value of any type into a string.
  *
  * Usage:
  *     math.format(value)
  *     math.format(value, precision)
+ *     math.format(value, options)
  *
  * When value is a function:
  *
@@ -41,24 +43,31 @@ export function endsWith(text, search) {
  *     math.format('hello')            // '"hello"'
  *
  * @param {*} value             Value to be stringified
- * @param {Object | number | Function} [options]  Formatting options. See
- *                                                lib/utils/number:format for a
- *                                                description of the available
- *                                                options.
+ * @param {Object | number | Function} [options]
+ *     Formatting options. See src/utils/number.js:format for a
+ *     description of the available options controlling number output.
+ *     This generic "format" also supports the option property `truncate: NN`
+ *     giving the maximum number NN of characters to return (if there would
+ *     have been more, they are deleted and replaced by an ellipsis).
  * @return {string} str
  */
-
 export function format(value, options) {
+  var result = _format(value, options);
+  if (options && typeof 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 formatNumber(value, options);
   }
-
   if (isBigNumber(value)) {
     return formatBigNumber(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'
@@ -68,19 +77,15 @@ export function format(value, options) {
       return value.toString();
     }
   }
-
   if (Array.isArray(value)) {
     return formatArray(value, options);
   }
-
   if (isString(value)) {
-    return '"' + value + '"';
+    return stringify(value);
   }
-
   if (typeof value === 'function') {
     return value.syntax ? String(value.syntax) : 'function';
   }
-
   if (value && typeof value === 'object') {
     if (typeof value.format === 'function') {
       return value.format(options);
@@ -89,61 +94,52 @@ export function format(value, options) {
       return value.toString(options);
     } else {
       var entries = Object.keys(value).map(key => {
-        return '"' + key + '": ' + format(value[key], options);
+        return stringify(key) + ': ' + format(value[key], 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}
  */
-
 export 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
-      }
-
-      escaped += c;
-    } else if (c === '"') {
-      escaped += '\\"';
-    } else {
-      escaped += c;
-    }
-
+    escaped += c in controlCharacters ? controlCharacters[c] : c;
     i++;
   }
-
   return '"' + escaped + '"';
 }
+var controlCharacters = {
+  '"': '\\"',
+  '\\': '\\\\',
+  '\b': '\\b',
+  '\f': '\\f',
+  '\n': '\\n',
+  '\r': '\\r',
+  '\t': '\\t'
+};
+
 /**
  * Escape special HTML characters
  * @param {*} value
  * @return {string}
  */
-
 export 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]]"
@@ -154,53 +150,45 @@ export 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 && typeof 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}
  */
-
-
 export function compareText(x, y) {
   // we don't want to convert numbers to string, only accept string input
   if (!isString(x)) {
     throw new TypeError('Unexpected type of argument in function compareText ' + '(expected: string or Array or Matrix, actual: ' + typeOf(x) + ', index: 0)');
   }
-
   if (!isString(y)) {
     throw new TypeError('Unexpected type of argument in function compareText ' + '(expected: string or Array or Matrix, actual: ' + typeOf(y) + ', index: 1)');
   }
-
   return x === y ? 0 : x > y ? 1 : -1;
 }

package/lib/esm/utils/switch.js

@@ -0,0 +1,20 @@
+/**
+ * Transpose a matrix
+ * @param {Array} mat
+ * @returns {Array} ret
+ * @private
+ */
+export function _switch(mat) {
+  var I = mat.length;
+  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/esm/version.js

@@ -1,2 +1,3 @@
-export var version = '8.1.0'; // Note: This file is automatically generated when building math.js.
+export var version = '12.2.1';
+// Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.