mathjs 10.6.2 → 11.0.0

package/lib/cjs/type/matrix/utils/matrixAlgorithmSuite.js

@@ -0,0 +1,238 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createMatrixAlgorithmSuite = void 0;
+
+var _factory = require("../../../utils/factory.js");
+
+var _object = require("../../../utils/object.js");
+
+var _matAlgo13xDD = require("./matAlgo13xDD.js");
+
+var _matAlgo14xDs = require("./matAlgo14xDs.js");
+
+var name = 'matrixAlgorithmSuite';
+var dependencies = ['typed', 'matrix'];
+var createMatrixAlgorithmSuite = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+      matrix = _ref.matrix;
+  var matAlgo13xDD = (0, _matAlgo13xDD.createMatAlgo13xDD)({
+    typed: typed
+  });
+  var matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
+    typed: typed
+  });
+  /**
+   * Return a signatures object with the usual boilerplate of
+   * matrix algorithms, based on a plain options object with the
+   * following properties:
+   *   elop: function -- the elementwise operation to use, defaults to self
+   *   SS: function -- the algorithm to apply for two sparse matrices
+   *   DS: function -- the algorithm to apply for a dense and a sparse matrix
+   *   SD: function -- algo for a sparse and a dense; defaults to SD flipped
+   *   Ss: function -- the algorithm to apply for a sparse matrix and scalar
+   *   sS: function -- algo for scalar and sparse; defaults to Ss flipped
+   *   scalar: string -- typed-function type for scalars, defaults to 'any'
+   *
+   * If Ss is not specified, no matrix-scalar signatures are generated.
+   *
+   * @param {object} options
+   * @return {Object<string, function>} signatures
+   */
+
+  return function matrixAlgorithmSuite(options) {
+    var elop = options.elop;
+    var SD = options.SD || options.DS;
+    var matrixSignatures;
+
+    if (elop) {
+      // First the dense ones
+      matrixSignatures = {
+        'DenseMatrix, DenseMatrix': function DenseMatrixDenseMatrix(x, y) {
+          return matAlgo13xDD(x, y, elop);
+        },
+        'Array, Array': function ArrayArray(x, y) {
+          return matAlgo13xDD(matrix(x), matrix(y), elop).valueOf();
+        },
+        'Array, DenseMatrix': function ArrayDenseMatrix(x, y) {
+          return matAlgo13xDD(matrix(x), y, elop);
+        },
+        'DenseMatrix, Array': function DenseMatrixArray(x, y) {
+          return matAlgo13xDD(x, matrix(y), elop);
+        }
+      }; // Now incorporate sparse matrices
+
+      if (options.SS) {
+        matrixSignatures['SparseMatrix, SparseMatrix'] = function (x, y) {
+          return options.SS(x, y, elop, false);
+        };
+      }
+
+      if (options.DS) {
+        matrixSignatures['DenseMatrix, SparseMatrix'] = function (x, y) {
+          return options.DS(x, y, elop, false);
+        };
+
+        matrixSignatures['Array, SparseMatrix'] = function (x, y) {
+          return options.DS(matrix(x), y, elop, false);
+        };
+      }
+
+      if (SD) {
+        matrixSignatures['SparseMatrix, DenseMatrix'] = function (x, y) {
+          return SD(y, x, elop, true);
+        };
+
+        matrixSignatures['SparseMatrix, Array'] = function (x, y) {
+          return SD(matrix(y), x, elop, true);
+        };
+      }
+    } else {
+      // No elop, use this
+      // First the dense ones
+      matrixSignatures = {
+        'DenseMatrix, DenseMatrix': typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo13xDD(x, y, self);
+          };
+        }),
+        'Array, Array': typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo13xDD(matrix(x), matrix(y), self).valueOf();
+          };
+        }),
+        'Array, DenseMatrix': typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo13xDD(matrix(x), y, self);
+          };
+        }),
+        'DenseMatrix, Array': typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo13xDD(x, matrix(y), self);
+          };
+        })
+      }; // Now incorporate sparse matrices
+
+      if (options.SS) {
+        matrixSignatures['SparseMatrix, SparseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return options.SS(x, y, self, false);
+          };
+        });
+      }
+
+      if (options.DS) {
+        matrixSignatures['DenseMatrix, SparseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return options.DS(x, y, self, false);
+          };
+        });
+        matrixSignatures['Array, SparseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return options.DS(matrix(x), y, self, false);
+          };
+        });
+      }
+
+      if (SD) {
+        matrixSignatures['SparseMatrix, DenseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return SD(y, x, self, true);
+          };
+        });
+        matrixSignatures['SparseMatrix, Array'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return SD(matrix(y), x, self, true);
+          };
+        });
+      }
+    } // Now add the scalars
+
+
+    var scalar = options.scalar || 'any';
+    var Ds = options.Ds || options.Ss;
+
+    if (Ds) {
+      if (elop) {
+        matrixSignatures['DenseMatrix,' + scalar] = function (x, y) {
+          return matAlgo14xDs(x, y, elop, false);
+        };
+
+        matrixSignatures[scalar + ', DenseMatrix'] = function (x, y) {
+          return matAlgo14xDs(y, x, elop, true);
+        };
+
+        matrixSignatures['Array,' + scalar] = function (x, y) {
+          return matAlgo14xDs(matrix(x), y, elop, false).valueOf();
+        };
+
+        matrixSignatures[scalar + ', Array'] = function (x, y) {
+          return matAlgo14xDs(matrix(y), x, elop, true).valueOf();
+        };
+      } else {
+        matrixSignatures['DenseMatrix,' + scalar] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo14xDs(x, y, self, false);
+          };
+        });
+        matrixSignatures[scalar + ', DenseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo14xDs(y, x, self, true);
+          };
+        });
+        matrixSignatures['Array,' + scalar] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo14xDs(matrix(x), y, self, false).valueOf();
+          };
+        });
+        matrixSignatures[scalar + ', Array'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+          };
+        });
+      }
+    }
+
+    var sS = options.sS !== undefined ? options.sS : options.Ss;
+
+    if (elop) {
+      if (options.Ss) {
+        matrixSignatures['SparseMatrix,' + scalar] = function (x, y) {
+          return options.Ss(x, y, elop, false);
+        };
+      }
+
+      if (sS) {
+        matrixSignatures[scalar + ', SparseMatrix'] = function (x, y) {
+          return sS(y, x, elop, true);
+        };
+      }
+    } else {
+      if (options.Ss) {
+        matrixSignatures['SparseMatrix,' + scalar] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return options.Ss(x, y, self, false);
+          };
+        });
+      }
+
+      if (sS) {
+        matrixSignatures[scalar + ', SparseMatrix'] = typed.referToSelf(function (self) {
+          return function (x, y) {
+            return sS(y, x, self, true);
+          };
+        });
+      }
+    } // Also pull in the scalar signatures if the operator is a typed function
+
+
+    if (elop && elop.signatures) {
+      (0, _object.extend)(matrixSignatures, elop.signatures);
+    }
+
+    return matrixSignatures;
+  };
+});
+exports.createMatrixAlgorithmSuite = createMatrixAlgorithmSuite;

package/lib/cjs/type/number.js

@@ -147,15 +147,17 @@ var createNumber = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
     Unit: function Unit(x) {
       throw new Error('Second argument with valueless unit expected');
     },
-    null: function _null(x) {
+    "null": function _null(x) {
       return 0;
     },
     'Unit, string | Unit': function UnitStringUnit(unit, valuelessUnit) {
       return unit.toNumber(valuelessUnit);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   }); // reviver function to parse a JSON object like:
   //
   //     {"mathjs":"number","value":"2.3"}

package/lib/cjs/type/string.js

@@ -46,18 +46,20 @@ var createString = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
       return '';
     },
     number: _number.format,
-    null: function _null(x) {
+    "null": function _null(x) {
       return 'null';
     },
-    boolean: function boolean(x) {
+    "boolean": function boolean(x) {
       return x + '';
     },
     string: function string(x) {
       return x;
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    },
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    }),
     any: function any(x) {
       return String(x);
     }

package/lib/cjs/type/unit/Unit.js

@@ -27,7 +27,7 @@ var _constants = require("../../utils/bignumber/constants.js");
 
 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; }
+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 name = 'Unit';
 var dependencies = ['?on', 'config', 'addScalar', 'subtract', 'multiplyScalar', 'divideScalar', 'pow', 'abs', 'fix', 'round', 'equal', 'isNumeric', 'format', 'number', 'Complex', 'BigNumber', 'Fraction'];
@@ -88,12 +88,7 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       this.units = u.units;
       this.dimensions = u.dimensions;
     } else {
-      this.units = [{
-        unit: UNIT_NONE,
-        prefix: PREFIXES.NONE,
-        // link to a list with supported prefixes
-        power: 0
-      }];
+      this.units = [];
       this.dimensions = [];
 
       for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
@@ -115,6 +110,10 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
    */
 
 
+  Object.defineProperty(Unit, 'name', {
+    value: 'Unit'
+  });
+  Unit.prototype.constructor = Unit;
   Unit.prototype.type = 'Unit';
   Unit.prototype.isUnit = true; // private variables and functions for the Unit parser
 
@@ -477,6 +476,17 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
 
     return unit;
   };
+  /**
+   * Return the type of the value of this unit
+   *
+   * @memberof Unit
+   * @ return {string} type of the value of the unit
+   */
+
+
+  Unit.prototype.valueType = function () {
+    return (0, _is.typeOf)(this.value);
+  };
   /**
    * Return whether the unit is derived (such as m/s, or cm^2, but not N)
    * @memberof Unit
@@ -666,15 +676,16 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     return this.equalBase(other) && equal(this.value, other.value);
   };
   /**
-   * Multiply this unit with another one
+   * Multiply this unit with another one or with a scalar
    * @memberof Unit
    * @param {Unit} other
    * @return {Unit} product of this unit and the other unit
    */
 
 
-  Unit.prototype.multiply = function (other) {
+  Unit.prototype.multiply = function (_other) {
     var res = this.clone();
+    var other = (0, _is.isUnit)(_other) ? _other : new Unit(_other);
 
     for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
       // Dimensions arrays may be of different lengths. Default to 0.
@@ -698,19 +709,35 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       res.value = null;
     }
 
-    res.skipAutomaticSimplification = false;
+    if ((0, _is.isUnit)(_other)) {
+      res.skipAutomaticSimplification = false;
+    }
+
     return getNumericIfUnitless(res);
   };
+  /**
+   * Divide a number by this unit
+   *
+   * @memberof Unit
+   * @param {numeric} numerator
+   * @param {unit} result of dividing numerator by this unit
+   */
+
+
+  Unit.prototype.divideInto = function (numerator) {
+    return new Unit(numerator).divide(this);
+  };
   /**
    * Divide this unit by another one
    * @memberof Unit
-   * @param {Unit} other
+   * @param {Unit | numeric} other
    * @return {Unit} result of dividing this unit by the other unit
    */
 
 
-  Unit.prototype.divide = function (other) {
+  Unit.prototype.divide = function (_other) {
     var res = this.clone();
+    var other = (0, _is.isUnit)(_other) ? _other : new Unit(_other);
 
     for (var i = 0; i < BASE_DIMENSIONS.length; i++) {
       // Dimensions arrays may be of different lengths. Default to 0.
@@ -736,7 +763,10 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       res.value = null;
     }
 
-    res.skipAutomaticSimplification = false;
+    if ((0, _is.isUnit)(_other)) {
+      res.skipAutomaticSimplification = false;
+    }
+
     return getNumericIfUnitless(res);
   };
   /**
@@ -805,7 +835,7 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
         // To give the correct, but unexpected, results for units with an offset.
         // For example, abs(-283.15 degC) = -263.15 degC !!!
         // We must take the offset into consideration here
-        var convert = Unit._getNumberConverter((0, _is.typeOf)(ret.value)); // convert to Fraction or BigNumber if needed
+        var convert = ret._numberConverter(); // convert to Fraction or BigNumber if needed
 
 
         var unitValue = convert(ret.units[0].unit.value);
@@ -1939,9 +1969,9 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       }
     }
   };
-  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);
+  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
    * -----  ---------
@@ -2125,7 +2155,7 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       value: 1,
       offset: 0
     },
-    in: {
+    "in": {
       name: 'in',
       base: BASE_UNITS.LENGTH,
       prefixes: PREFIXES.NONE,
@@ -3389,7 +3419,7 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
     electronvolts: 'electronvolt',
     moles: 'mole',
     bit: 'bits',
-    byte: 'bytes'
+    "byte": 'bytes'
   };
   /**
    * Calculate the values for the angle units.
@@ -3647,6 +3677,23 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       return x;
     }
   };
+  /**
+   * Retrieve the right converter function corresponding with this unit's
+   * value
+   *
+   * @memberof Unit
+   * @return {Function}
+   */
+
+  Unit.prototype._numberConverter = function () {
+    var convert = Unit.typeConverters[this.valueType()];
+
+    if (convert) {
+      return convert;
+    }
+
+    throw new TypeError('Unsupported Unit value type "' + this.valueType() + '"');
+  };
   /**
    * Retrieve the right convertor function corresponding with the type
    * of provided exampleValue.
@@ -3656,6 +3703,7 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
    * @return {Function}
    */
 
+
   Unit._getNumberConverter = function (type) {
     if (!Unit.typeConverters[type]) {
       throw new TypeError('Unsupported type "' + type + '"');
@@ -3733,7 +3781,7 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
 
 
   Unit.createUnit = function (obj, options) {
-    if ((0, _typeof2.default)(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
 
@@ -3823,7 +3871,7 @@ var createUnitClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, f
       if (obj !== '') {
         definition = obj;
       }
-    } else if ((0, _typeof2.default)(obj) === 'object') {
+    } else if ((0, _typeof2["default"])(obj) === 'object') {
       definition = obj.definition;
       prefixes = obj.prefixes;
       offset = obj.offset;

package/lib/cjs/type/unit/function/createUnit.js

@@ -40,9 +40,10 @@ var createCreateUnit = /* #__PURE__ */(0, _factory.factory)(name, dependencies,
    *     math.createUnit('foo')
    *     math.createUnit('knot', {definition: '0.514444444 m/s', aliases: ['knots', 'kt', 'kts']})
    *     math.createUnit('mph', '1 mile/hour')
+   *     math.createUnit('km', math.unit(1000, 'm'))
    *
    * @param {string} name      The name of the new unit. Must be unique. Example: 'knot'
-   * @param {string, Unit} definition      Definition of the unit in terms of existing units. For example, '0.514444444 m / s'.
+   * @param {string, UnitDefinition, Unit} definition      Definition of the unit in terms of existing units. For example, '0.514444444 m / s'.
    * @param {Object} options   (optional) An object containing any of the following properties:
    *     - `prefixes {string}` "none", "short", "long", "binary_short", or "binary_long". The default is "none".
    *     - `aliases {Array}` Array of strings. Example: ['knots', 'kt', 'kts']

package/lib/cjs/type/unit/function/unit.js

@@ -55,9 +55,15 @@ var createUnitFunction = /* #__PURE__ */(0, _factory.factory)(name, dependencies
     'number | BigNumber | Fraction | Complex, string': function numberBigNumberFractionComplexString(value, unit) {
       return new Unit(value, unit);
     },
-    'Array | Matrix': function ArrayMatrix(x) {
-      return (0, _collection.deepMap)(x, this);
-    }
+    'number | BigNumber | Fraction': function numberBigNumberFraction(value) {
+      // dimensionless
+      return new Unit(value);
+    },
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self);
+      };
+    })
   });
 });
 exports.createUnitFunction = createUnitFunction;

package/lib/cjs/utils/customs.js

@@ -78,7 +78,7 @@ function hasSafeProperty(object, prop) {
 
 
 function isSafeProperty(object, prop) {
-  if (!object || (0, _typeof2.default)(object) !== 'object') {
+  if (!object || (0, _typeof2["default"])(object) !== 'object') {
     return false;
   } // SAFE: whitelisted
   // e.g length
@@ -171,7 +171,7 @@ function isSafeMethod(object, method) {
 }
 
 function isPlainObject(object) {
-  return (0, _typeof2.default)(object) === 'object' && object && object.constructor === Object;
+  return (0, _typeof2["default"])(object) === 'object' && object && object.constructor === Object;
 }
 
 var safeNativeProperties = {

package/lib/cjs/utils/emitter.js

@@ -16,7 +16,7 @@ var _tinyEmitter = _interopRequireDefault(require("tiny-emitter"));
  */
 function mixin(obj) {
   // create event emitter
-  var emitter = new _tinyEmitter.default(); // bind methods to obj (we don't want to expose the emitter.e Array...)
+  var emitter = new _tinyEmitter["default"](); // bind methods to obj (we don't want to expose the emitter.e Array...)
 
   obj.on = emitter.on.bind(emitter);
   obj.off = emitter.off.bind(emitter);

package/lib/cjs/utils/function.js

@@ -38,7 +38,7 @@ function memoize(fn) {
   limit = limit == null ? Number.POSITIVE_INFINITY : limit;
   hasher = hasher == null ? JSON.stringify : hasher;
   return function memoize() {
-    if ((0, _typeof2.default)(memoize.cache) !== 'object') {
+    if ((0, _typeof2["default"])(memoize.cache) !== 'object') {
       memoize.cache = {
         values: new Map(),
         lru: (0, _lruQueue.lruQueue)(limit || Number.POSITIVE_INFINITY)
@@ -60,7 +60,7 @@ function memoize(fn) {
 
     var newVal = fn.apply(fn, args);
     memoize.cache.values.set(hash, newVal);
-    memoize.cache.values.delete(memoize.cache.lru.hit(hash));
+    memoize.cache.values["delete"](memoize.cache.lru.hit(hash));
     return newVal;
   };
 }

package/lib/cjs/utils/is.js

@@ -43,6 +43,7 @@ exports.isString = isString;
 exports.isSymbolNode = isSymbolNode;
 exports.isUndefined = isUndefined;
 exports.isUnit = isUnit;
+exports.rule2Node = rule2Node;
 exports.typeOf = typeOf;
 
 var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
@@ -65,11 +66,11 @@ function isNumber(x) {
 }
 
 function isBigNumber(x) {
-  if (!x || (0, _typeof2.default)(x) !== 'object' || typeof x.constructor !== 'function') {
+  if (!x || (0, _typeof2["default"])(x) !== 'object' || typeof x.constructor !== 'function') {
     return false;
   }
 
-  if (x.isBigNumber === true && (0, _typeof2.default)(x.constructor.prototype) === 'object' && x.constructor.prototype.isBigNumber === true) {
+  if (x.isBigNumber === true && (0, _typeof2["default"])(x.constructor.prototype) === 'object' && x.constructor.prototype.isBigNumber === true) {
     return true;
   }
 
@@ -81,11 +82,11 @@ function isBigNumber(x) {
 }
 
 function isComplex(x) {
-  return x && (0, _typeof2.default)(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 && (0, _typeof2.default)(x) === 'object' && Object.getPrototypeOf(x).isFraction === true || false;
+  return x && (0, _typeof2["default"])(x) === 'object' && Object.getPrototypeOf(x).isFraction === true || false;
 }
 
 function isUnit(x) {
@@ -154,7 +155,7 @@ function isRegExp(x) {
 }
 
 function isObject(x) {
-  return !!(x && (0, _typeof2.default)(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) {
@@ -188,6 +189,21 @@ function isConditionalNode(x) {
 function isConstantNode(x) {
   return x && x.isConstantNode === true && x.constructor.prototype.isNode === true || false;
 }
+/* Very specialized: returns true for those nodes which in the numerator of
+   a fraction means that the division in that fraction has precedence over implicit
+   multiplication, e.g. -2/3 x parses as (-2/3) x and 3/4 x parses as (3/4) x but
+   6!/8 x parses as 6! / (8x). It is located here because it is shared between
+   parse.js and OperatorNode.js (for parsing and printing, respectively).
+
+   This should *not* be exported from mathjs, unlike most of the tests here.
+   Its name does not start with 'is' to prevent utils/snapshot.js from thinking
+   it should be exported.
+*/
+
+
+function rule2Node(node) {
+  return isConstantNode(node) || isOperatorNode(node) && node.args.length === 1 && isConstantNode(node.args[0]) && '-+~'.includes(node.op);
+}
 
 function isFunctionAssignmentNode(x) {
   return x && x.isFunctionAssignmentNode === true && x.constructor.prototype.isNode === true || false;
@@ -230,29 +246,15 @@ function isChain(x) {
 }
 
 function typeOf(x) {
-  var t = (0, _typeof2.default)(x);
+  var t = (0, _typeof2["default"])(x);
 
   if (t === 'object') {
-    // JavaScript types
     if (x === null) return 'null';
-    if (Array.isArray(x)) return 'Array';
-    if (x instanceof Date) return 'Date';
-    if (x instanceof RegExp) return 'RegExp'; // math.js types
-
-    if (isBigNumber(x)) return 'BigNumber';
-    if (isComplex(x)) return 'Complex';
-    if (isFraction(x)) return 'Fraction';
-    if (isMatrix(x)) return 'Matrix';
-    if (isUnit(x)) return 'Unit';
-    if (isIndex(x)) return 'Index';
-    if (isRange(x)) return 'Range';
-    if (isResultSet(x)) return 'ResultSet';
-    if (isNode(x)) return x.type;
-    if (isChain(x)) return 'Chain';
-    if (isHelp(x)) return 'Help';
-    return 'Object';
+    if (isBigNumber(x)) return 'BigNumber'; // Special: weird mashup with Decimal
+
+    if (x.constructor && x.constructor.name) return x.constructor.name;
+    return 'Object'; // just in case
   }
 
-  if (t === 'function') return 'Function';
-  return t; // can be 'string', 'number', 'boolean', ...
+  return t; // can be 'string', 'number', 'boolean', 'function', 'bigint', ...
 }