mathjs 12.4.2 → 13.0.0

package/lib/cjs/utils/array.js

@@ -11,7 +11,6 @@ exports.broadcastTo = broadcastTo;
 exports.checkBroadcastingRules = checkBroadcastingRules;
 exports.clone = clone;
 exports.concat = concat;
-exports.contains = contains;
 exports.filter = filter;
 exports.filterRegExp = filterRegExp;
 exports.flatten = flatten;
@@ -34,7 +33,6 @@ exports.validate = validate;
 exports.validateIndex = validateIndex;
 exports.validateIndexSourceSize = validateIndexSourceSize;
 var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _number = require("./number.js");
 var _is = require("./is.js");
 var _string = require("./string.js");
@@ -49,7 +47,7 @@ var _object = require("./object.js");
  * @Return {Number[]} size
  */
 function arraySize(x) {
-  var s = [];
+  const s = [];
   while (Array.isArray(x)) {
     s.push(x.length);
     x = x[0];
@@ -67,16 +65,16 @@ function arraySize(x) {
  * @private
  */
 function _validate(array, size, dim) {
-  var i;
-  var len = array.length;
+  let i;
+  const len = array.length;
   if (len !== size[dim]) {
     throw new _DimensionError.DimensionError(len, size[dim]);
   }
   if (dim < size.length - 1) {
     // recursively validate each child array
-    var dimNext = dim + 1;
+    const dimNext = dim + 1;
     for (i = 0; i < len; i++) {
-      var child = array[i];
+      const child = array[i];
       if (!Array.isArray(child)) {
         throw new _DimensionError.DimensionError(size.length - 1, size.length, '<');
       }
@@ -100,7 +98,7 @@ function _validate(array, size, dim) {
  * @throws DimensionError
  */
 function validate(array, size) {
-  var isScalar = size.length === 0;
+  const isScalar = size.length === 0;
   if (isScalar) {
     // scalar
     if (Array.isArray(array)) {
@@ -119,10 +117,10 @@ function validate(array, size) {
  * @throws DimensionError
  */
 function validateIndexSourceSize(value, index) {
-  var valueSize = value.isMatrix ? value._size : arraySize(value);
-  var sourceSize = index._sourceSize;
+  const valueSize = value.isMatrix ? value._size : arraySize(value);
+  const sourceSize = index._sourceSize;
   // checks if the source size is not null and matches the valueSize
-  sourceSize.forEach(function (sourceDim, i) {
+  sourceSize.forEach((sourceDim, i) => {
     if (sourceDim !== null && sourceDim !== valueSize[i]) {
       throw new _DimensionError.DimensionError(sourceDim, valueSize[i]);
     }
@@ -151,8 +149,8 @@ function validateIndex(index, length) {
  * @param {number} index    Zero-based index
  */
 function isEmptyIndex(index) {
-  for (var i = 0; i < index._dimensions.length; ++i) {
-    var dimension = index._dimensions[i];
+  for (let i = 0; i < index._dimensions.length; ++i) {
+    const dimension = index._dimensions[i];
     if (dimension._data && (0, _is.isArray)(dimension._data)) {
       if (dimension._size[0] === 0) {
         return true;
@@ -202,7 +200,7 @@ function resize(array, size, defaultValue) {
   }
 
   // recursively resize the array
-  var _defaultValue = defaultValue !== undefined ? defaultValue : 0;
+  const _defaultValue = defaultValue !== undefined ? defaultValue : 0;
   _resize(array, size, 0, _defaultValue);
   return array;
 }
@@ -217,17 +215,17 @@ function resize(array, size, defaultValue) {
  * @private
  */
 function _resize(array, size, dim, defaultValue) {
-  var i;
-  var elem;
-  var oldLen = array.length;
-  var newLen = size[dim];
-  var minLen = Math.min(oldLen, newLen);
+  let i;
+  let elem;
+  const oldLen = array.length;
+  const newLen = size[dim];
+  const minLen = Math.min(oldLen, newLen);
 
   // apply new length
   array.length = newLen;
   if (dim < size.length - 1) {
     // non-last dimension
-    var dimNext = dim + 1;
+    const dimNext = dim + 1;
 
     // resize existing child arrays
     for (i = 0; i < minLen; i++) {
@@ -277,8 +275,8 @@ function _resize(array, size, dim, defaultValue) {
  *                                not equal that of the old ones
  */
 function reshape(array, sizes) {
-  var flatArray = flatten(array);
-  var currentLength = flatArray.length;
+  const flatArray = flatten(array);
+  const currentLength = flatArray.length;
   if (!Array.isArray(array) || !Array.isArray(sizes)) {
     throw new TypeError('Array expected');
   }
@@ -286,7 +284,7 @@ function reshape(array, sizes) {
     throw new _DimensionError.DimensionError(0, currentLength, '!=');
   }
   sizes = processSizesWildcard(sizes, currentLength);
-  var newLength = product(sizes);
+  const newLength = product(sizes);
   if (currentLength !== newLength) {
     throw new _DimensionError.DimensionError(newLength, currentLength, '!=');
   }
@@ -308,16 +306,16 @@ function reshape(array, sizes) {
  * @returns {number[]}      The sizes array with wildcard replaced.
  */
 function processSizesWildcard(sizes, currentLength) {
-  var newLength = product(sizes);
-  var processedSizes = sizes.slice();
-  var WILDCARD = -1;
-  var wildCardIndex = sizes.indexOf(WILDCARD);
-  var isMoreThanOneWildcard = sizes.indexOf(WILDCARD, wildCardIndex + 1) >= 0;
+  const newLength = product(sizes);
+  const processedSizes = sizes.slice();
+  const WILDCARD = -1;
+  const wildCardIndex = sizes.indexOf(WILDCARD);
+  const isMoreThanOneWildcard = sizes.indexOf(WILDCARD, wildCardIndex + 1) >= 0;
   if (isMoreThanOneWildcard) {
     throw new Error('More than one wildcard in sizes');
   }
-  var hasWildcard = wildCardIndex >= 0;
-  var canReplaceWildcard = currentLength % newLength === 0;
+  const hasWildcard = wildCardIndex >= 0;
+  const canReplaceWildcard = currentLength % newLength === 0;
   if (hasWildcard) {
     if (canReplaceWildcard) {
       processedSizes[wildCardIndex] = -currentLength / newLength;
@@ -334,9 +332,7 @@ function processSizesWildcard(sizes, currentLength) {
  * @returns {number}            Product of all elements
  */
 function product(array) {
-  return array.reduce(function (prev, curr) {
-    return prev * curr;
-  }, 1);
+  return array.reduce((prev, curr) => prev * curr, 1);
 }
 
 /**
@@ -349,16 +345,16 @@ function product(array) {
 
 function _reshape(array, sizes) {
   // testing if there are enough elements for the requested shape
-  var tmpArray = array;
-  var tmpArray2;
+  let tmpArray = array;
+  let tmpArray2;
   // for each dimensions starting by the last one and ignoring the first one
-  for (var sizeIndex = sizes.length - 1; sizeIndex > 0; sizeIndex--) {
-    var size = sizes[sizeIndex];
+  for (let sizeIndex = sizes.length - 1; sizeIndex > 0; sizeIndex--) {
+    const size = sizes[sizeIndex];
     tmpArray2 = [];
 
     // aggregate the elements of the current tmpArray in elements of the requested size
-    var length = tmpArray.length / size;
-    for (var i = 0; i < length; i++) {
+    const length = tmpArray.length / size;
+    for (let i = 0; i < length; i++) {
       tmpArray2.push(tmpArray.slice(i * size, (i + 1) * size));
     }
     // set it as the new tmpArray for the next loop turn or for return
@@ -374,7 +370,7 @@ function _reshape(array, sizes) {
  * @returns {Array} returns the array itself
  */
 function squeeze(array, size) {
-  var s = size || arraySize(array);
+  const s = size || arraySize(array);
 
   // squeeze outer dimensions
   while (Array.isArray(array) && array.length === 1) {
@@ -383,7 +379,7 @@ function squeeze(array, size) {
   }
 
   // find the first dimension to be squeezed
-  var dims = s.length;
+  let dims = s.length;
   while (s[dims - 1] === 1) {
     dims--;
   }
@@ -405,9 +401,9 @@ function squeeze(array, size) {
  * @private
  */
 function _squeeze(array, dims, dim) {
-  var i, ii;
+  let i, ii;
   if (dim < dims) {
-    var next = dim + 1;
+    const next = dim + 1;
     for (i = 0, ii = array.length; i < ii; i++) {
       array[i] = _squeeze(array[i], dims, next);
     }
@@ -432,11 +428,11 @@ function _squeeze(array, dims, dim) {
  * @private
  */
 function unsqueeze(array, dims, outer, size) {
-  var s = size || arraySize(array);
+  const s = size || arraySize(array);
 
   // unsqueeze outer dimensions
   if (outer) {
-    for (var i = 0; i < outer; i++) {
+    for (let i = 0; i < outer; i++) {
       array = [array];
       s.unshift(1);
     }
@@ -459,14 +455,14 @@ function unsqueeze(array, dims, outer, size) {
  * @private
  */
 function _unsqueeze(array, dims, dim) {
-  var i, ii;
+  let i, ii;
   if (Array.isArray(array)) {
-    var next = dim + 1;
+    const next = dim + 1;
     for (i = 0, ii = array.length; i < ii; i++) {
       array[i] = _unsqueeze(array[i], dims, next);
     }
   } else {
-    for (var d = dim; d < dims; d++) {
+    for (let d = dim; d < dims; d++) {
       array = [array];
     }
   }
@@ -483,7 +479,7 @@ function flatten(array) {
     // if not an array, return as is
     return array;
   }
-  var flat = [];
+  const flat = [];
   array.forEach(function callback(value) {
     if (Array.isArray(value)) {
       value.forEach(callback); // traverse through sub-arrays recursively
@@ -535,9 +531,7 @@ function filterRegExp(array, regexp) {
   if (arraySize(array).length !== 1) {
     throw new Error('Only one dimensional matrices supported');
   }
-  return Array.prototype.filter.call(array, function (entry) {
-    return regexp.test(entry);
-  });
+  return Array.prototype.filter.call(array, entry => regexp.test(entry));
 }
 
 /**
@@ -561,13 +555,13 @@ function identify(a) {
   if (a.length === 0) {
     return a;
   }
-  var b = [];
-  var count = 0;
+  const b = [];
+  let count = 0;
   b[0] = {
     value: a[0],
     identifier: 0
   };
-  for (var i = 1; i < a.length; i++) {
+  for (let i = 1; i < a.length; i++) {
     if (a[i] === a[i - 1]) {
       count++;
     } else {
@@ -593,8 +587,8 @@ function generalize(a) {
   if (a.length === 0) {
     return a;
   }
-  var b = [];
-  for (var i = 0; i < a.length; i++) {
+  const b = [];
+  for (let i = 0; i < a.length; i++) {
     b.push(a[i].value);
   }
   return b;
@@ -610,23 +604,23 @@ function generalize(a) {
  * @return {string}
  */
 function getArrayDataType(array, typeOf) {
-  var type; // to hold type info
-  var length = 0; // to hold length value to ensure it has consistent sizes
+  let type; // to hold type info
+  let length = 0; // to hold length value to ensure it has consistent sizes
 
-  for (var i = 0; i < array.length; i++) {
-    var item = array[i];
-    var _isArray = Array.isArray(item);
+  for (let i = 0; i < array.length; i++) {
+    const item = array[i];
+    const isArray = Array.isArray(item);
 
     // Saving the target matrix row size
-    if (i === 0 && _isArray) {
+    if (i === 0 && isArray) {
       length = item.length;
     }
 
     // If the current item is an array but the length does not equal the targetVectorSize
-    if (_isArray && item.length !== length) {
+    if (isArray && item.length !== length) {
       return undefined;
     }
-    var itemType = _isArray ? getArrayDataType(item, typeOf) // recurse into a nested array
+    const itemType = isArray ? getArrayDataType(item, typeOf) // recurse into a nested array
     : typeOf(item);
     if (type === undefined) {
       type = itemType; // first item
@@ -657,16 +651,6 @@ function initial(array) {
   return array.slice(0, array.length - 1);
 }
 
-/**
- * Test whether an array or string contains an item
- * @param {Array | string} array
- * @param {*} item
- * @return {boolean}
- */
-function contains(array, item) {
-  return array.indexOf(item) !== -1;
-}
-
 /**
  * Recursively concatenate two matrices.
  * The contents of the matrices is not cloned.
@@ -683,8 +667,8 @@ function concatRecursive(a, b, concatDim, dim) {
     if (a.length !== b.length) {
       throw new _DimensionError.DimensionError(a.length, b.length);
     }
-    var c = [];
-    for (var i = 0; i < a.length; i++) {
+    const c = [];
+    for (let i = 0; i < a.length; i++) {
       c[i] = concatRecursive(a[i], b[i], concatDim, dim + 1);
     }
     return c;
@@ -701,8 +685,8 @@ function concatRecursive(a, b, concatDim, dim) {
  * @returns
 */
 function concat() {
-  var arrays = Array.prototype.slice.call(arguments, 0, -1);
-  var concatDim = Array.prototype.slice.call(arguments, -1);
+  const arrays = Array.prototype.slice.call(arguments, 0, -1);
+  const concatDim = Array.prototype.slice.call(arguments, -1);
   if (arrays.length === 1) {
     return arrays[0];
   }
@@ -724,24 +708,22 @@ function broadcastSizes() {
   for (var _len = arguments.length, sizes = new Array(_len), _key = 0; _key < _len; _key++) {
     sizes[_key] = arguments[_key];
   }
-  var dimensions = sizes.map(function (s) {
-    return s.length;
-  });
-  var N = Math.max.apply(Math, (0, _toConsumableArray2["default"])(dimensions));
-  var sizeMax = new Array(N).fill(null);
+  const dimensions = sizes.map(s => s.length);
+  const N = Math.max(...dimensions);
+  const sizeMax = new Array(N).fill(null);
   // check for every size
-  for (var i = 0; i < sizes.length; i++) {
-    var size = sizes[i];
-    var dim = dimensions[i];
-    for (var j = 0; j < dim; j++) {
-      var n = N - dim + j;
+  for (let i = 0; i < sizes.length; i++) {
+    const size = sizes[i];
+    const dim = dimensions[i];
+    for (let j = 0; j < dim; j++) {
+      const n = N - dim + j;
       if (size[j] > sizeMax[n]) {
         sizeMax[n] = size[j];
       }
     }
   }
-  for (var _i = 0; _i < sizes.length; _i++) {
-    checkBroadcastingRules(sizes[_i], sizeMax);
+  for (let i = 0; i < sizes.length; i++) {
+    checkBroadcastingRules(sizes[i], sizeMax);
   }
   return sizeMax;
 }
@@ -752,12 +734,12 @@ function broadcastSizes() {
  * @param {number[]} toSize The size of the array to validate if it can be broadcasted to
  */
 function checkBroadcastingRules(size, toSize) {
-  var N = toSize.length;
-  var dim = size.length;
-  for (var j = 0; j < dim; j++) {
-    var n = N - dim + j;
+  const N = toSize.length;
+  const dim = size.length;
+  for (let j = 0; j < dim; j++) {
+    const n = N - dim + j;
     if (size[j] < toSize[n] && size[j] > 1 || size[j] > toSize[n]) {
-      throw new Error("shape missmatch: missmatch is found in arg with shape (".concat(size, ") not possible to broadcast dimension ").concat(dim, " with size ").concat(size[j], " to size ").concat(toSize[n]));
+      throw new Error(`shape missmatch: missmatch is found in arg with shape (${size}) not possible to broadcast dimension ${dim} with size ${size[j]} to size ${toSize[n]}`);
     }
   }
 }
@@ -769,15 +751,15 @@ function checkBroadcastingRules(size, toSize) {
  * @returns The broadcasted array
  */
 function broadcastTo(array, toSize) {
-  var Asize = arraySize(array);
+  let Asize = arraySize(array);
   if ((0, _object.deepStrictEqual)(Asize, toSize)) {
     return array;
   }
   checkBroadcastingRules(Asize, toSize);
-  var broadcastedSize = broadcastSizes(Asize, toSize);
-  var N = broadcastedSize.length;
-  var paddedSize = [].concat((0, _toConsumableArray2["default"])(Array(N - Asize.length).fill(1)), (0, _toConsumableArray2["default"])(Asize));
-  var A = clone(array);
+  const broadcastedSize = broadcastSizes(Asize, toSize);
+  const N = broadcastedSize.length;
+  const paddedSize = [...Array(N - Asize.length).fill(1), ...Asize];
+  let A = clone(array);
   // reshape A if needed to make it ready for concat
   if (Asize.length < N) {
     A = reshape(A, paddedSize);
@@ -785,7 +767,7 @@ function broadcastTo(array, toSize) {
   }
 
   // stretches the array on each dimension to make it the same size as index
-  for (var dim = 0; dim < N; dim++) {
+  for (let dim = 0; dim < N; dim++) {
     if (Asize[dim] < broadcastedSize[dim]) {
       A = stretch(A, broadcastedSize[dim], dim);
       Asize = arraySize(A);
@@ -809,11 +791,11 @@ function broadcastArrays() {
   if (arrays.length === 1) {
     return arrays[0];
   }
-  var sizes = arrays.map(function (array) {
+  const sizes = arrays.map(function (array) {
     return arraySize(array);
   });
-  var broadcastedSize = broadcastSizes.apply(void 0, (0, _toConsumableArray2["default"])(sizes));
-  var broadcastedArrays = [];
+  const broadcastedSize = broadcastSizes(...sizes);
+  const broadcastedArrays = [];
   arrays.forEach(function (array) {
     broadcastedArrays.push(broadcastTo(array, broadcastedSize));
   });
@@ -828,7 +810,7 @@ function broadcastArrays() {
  * @returns
  */
 function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
-  return concat.apply(void 0, (0, _toConsumableArray2["default"])(Array(sizeToStretch).fill(arrayToStretch)).concat([dimToStretch]));
+  return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
 }
 
 /**
@@ -837,5 +819,5 @@ function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
  * @returns cloned array
  */
 function clone(array) {
-  return (0, _extends2["default"])([], array);
+  return (0, _extends2.default)([], array);
 }

package/lib/cjs/utils/bignumber/bitwise.js

@@ -35,7 +35,7 @@ function bitAndBigNumber(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
     throw new Error('Integers expected in function bitAnd');
   }
-  var BigNumber = x.constructor;
+  const BigNumber = x.constructor;
   if (x.isNaN() || y.isNaN()) {
     return new BigNumber(NaN);
   }
@@ -86,12 +86,12 @@ function bitNotBigNumber(x) {
   if (x.isFinite() && !x.isInteger()) {
     throw new Error('Integer expected in function bitNot');
   }
-  var BigNumber = x.constructor;
-  var prevPrec = BigNumber.precision;
+  const BigNumber = x.constructor;
+  const prevPrec = BigNumber.precision;
   BigNumber.config({
     precision: 1E9
   });
-  var result = x.plus(new BigNumber(1));
+  const result = x.plus(new BigNumber(1));
   result.s = -result.s || null;
   BigNumber.config({
     precision: prevPrec
@@ -123,11 +123,11 @@ function bitOrBigNumber(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
     throw new Error('Integers expected in function bitOr');
   }
-  var BigNumber = x.constructor;
+  const BigNumber = x.constructor;
   if (x.isNaN() || y.isNaN()) {
     return new BigNumber(NaN);
   }
-  var negOne = new BigNumber(-1);
+  const negOne = new BigNumber(-1);
   if (x.isZero() || y.eq(negOne) || x.eq(y)) {
     return y;
   }
@@ -156,13 +156,13 @@ function bitOrBigNumber(x, y) {
  * @return {BigNumber}
  */
 function bitwise(x, y, func) {
-  var BigNumber = x.constructor;
-  var xBits, yBits;
-  var xSign = +(x.s < 0);
-  var ySign = +(y.s < 0);
+  const BigNumber = x.constructor;
+  let xBits, yBits;
+  const xSign = +(x.s < 0);
+  const ySign = +(y.s < 0);
   if (xSign) {
     xBits = decCoefficientToBinaryString(bitNotBigNumber(x));
-    for (var i = 0; i < xBits.length; ++i) {
+    for (let i = 0; i < xBits.length; ++i) {
       xBits[i] ^= 1;
     }
   } else {
@@ -170,13 +170,13 @@ function bitwise(x, y, func) {
   }
   if (ySign) {
     yBits = decCoefficientToBinaryString(bitNotBigNumber(y));
-    for (var _i = 0; _i < yBits.length; ++_i) {
-      yBits[_i] ^= 1;
+    for (let i = 0; i < yBits.length; ++i) {
+      yBits[i] ^= 1;
     }
   } else {
     yBits = decCoefficientToBinaryString(y);
   }
-  var minBits, maxBits, minSign;
+  let minBits, maxBits, minSign;
   if (xBits.length <= yBits.length) {
     minBits = xBits;
     maxBits = yBits;
@@ -186,13 +186,13 @@ function bitwise(x, y, func) {
     maxBits = xBits;
     minSign = ySign;
   }
-  var shortLen = minBits.length;
-  var longLen = maxBits.length;
-  var expFuncVal = func(xSign, ySign) ^ 1;
-  var outVal = new BigNumber(expFuncVal ^ 1);
-  var twoPower = new BigNumber(1);
-  var two = new BigNumber(2);
-  var prevPrec = BigNumber.precision;
+  let shortLen = minBits.length;
+  let longLen = maxBits.length;
+  const expFuncVal = func(xSign, ySign) ^ 1;
+  let outVal = new BigNumber(expFuncVal ^ 1);
+  let twoPower = new BigNumber(1);
+  const two = new BigNumber(2);
+  const prevPrec = BigNumber.precision;
   BigNumber.config({
     precision: 1E9
   });
@@ -220,22 +220,22 @@ function bitwise(x, y, func) {
 /* Extracted from decimal.js, and edited to specialize. */
 function decCoefficientToBinaryString(x) {
   // Convert to string
-  var a = x.d; // array with digits
-  var r = a[0] + '';
-  for (var i = 1; i < a.length; ++i) {
-    var s = a[i] + '';
-    for (var z = 7 - s.length; z--;) {
+  const a = x.d; // array with digits
+  let r = a[0] + '';
+  for (let i = 1; i < a.length; ++i) {
+    let s = a[i] + '';
+    for (let z = 7 - s.length; z--;) {
       s = '0' + s;
     }
     r += s;
   }
-  var j = r.length;
+  let j = r.length;
   while (r.charAt(j) === '0') {
     j--;
   }
-  var xe = x.e;
-  var str = r.slice(0, j + 1 || 1);
-  var strL = str.length;
+  let xe = x.e;
+  let str = r.slice(0, j + 1 || 1);
+  const strL = str.length;
   if (xe > 0) {
     if (++xe > strL) {
       // Append zeros.
@@ -249,20 +249,20 @@ function decCoefficientToBinaryString(x) {
   }
 
   // Convert from base 10 (decimal) to base 2
-  var arr = [0];
-  for (var _i2 = 0; _i2 < str.length;) {
-    var arrL = arr.length;
+  const arr = [0];
+  for (let i = 0; i < str.length;) {
+    let arrL = arr.length;
     while (arrL--) {
       arr[arrL] *= 10;
     }
-    arr[0] += parseInt(str.charAt(_i2++)); // convert to int
-    for (var _j = 0; _j < arr.length; ++_j) {
-      if (arr[_j] > 1) {
-        if (arr[_j + 1] === null || arr[_j + 1] === undefined) {
-          arr[_j + 1] = 0;
+    arr[0] += parseInt(str.charAt(i++)); // convert to int
+    for (let j = 0; j < arr.length; ++j) {
+      if (arr[j] > 1) {
+        if (arr[j + 1] === null || arr[j + 1] === undefined) {
+          arr[j + 1] = 0;
         }
-        arr[_j + 1] += arr[_j] >> 1;
-        arr[_j] &= 1;
+        arr[j + 1] += arr[j] >> 1;
+        arr[j] &= 1;
       }
     }
   }
@@ -292,7 +292,7 @@ function bitXor(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
     throw new Error('Integers expected in function bitXor');
   }
-  var BigNumber = x.constructor;
+  const BigNumber = x.constructor;
   if (x.isNaN() || y.isNaN()) {
     return new BigNumber(NaN);
   }
@@ -305,7 +305,7 @@ function bitXor(x, y) {
   if (x.eq(y)) {
     return new BigNumber(0);
   }
-  var negOne = new BigNumber(-1);
+  const negOne = new BigNumber(-1);
   if (x.eq(negOne)) {
     return bitNotBigNumber(y);
   }
@@ -345,7 +345,7 @@ function leftShiftBigNumber(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
     throw new Error('Integers expected in function leftShift');
   }
-  var BigNumber = x.constructor;
+  const BigNumber = x.constructor;
   if (x.isNaN() || y.isNaN() || y.isNegative() && !y.isZero()) {
     return new BigNumber(NaN);
   }
@@ -386,7 +386,7 @@ function rightArithShiftBigNumber(x, y) {
   if (x.isFinite() && !x.isInteger() || y.isFinite() && !y.isInteger()) {
     throw new Error('Integers expected in function rightArithShift');
   }
-  var BigNumber = x.constructor;
+  const BigNumber = x.constructor;
   if (x.isNaN() || y.isNaN() || y.isNegative() && !y.isZero()) {
     return new BigNumber(NaN);
   }