mathjs 12.4.3 → 13.0.0

package/lib/cjs/type/matrix/DenseMatrix.js

@@ -1,11 +1,9 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createDenseMatrixClass = void 0;
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _is = require("../../utils/is.js");
 var _array = require("../../utils/array.js");
 var _string = require("../../utils/string.js");
@@ -14,13 +12,12 @@ var _object = require("../../utils/object.js");
 var _DimensionError = require("../../error/DimensionError.js");
 var _factory = require("../../utils/factory.js");
 var _function = require("../../utils/function.js");
-function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
-function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
-function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
-var name = 'DenseMatrix';
-var dependencies = ['Matrix'];
-var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var Matrix = _ref.Matrix;
+const name = 'DenseMatrix';
+const dependencies = ['Matrix'];
+const createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    Matrix
+  } = _ref;
   /**
    * Dense Matrix implementation. A regular, dense matrix, supporting multi-dimensional matrices. This is the default matrix type.
    * @class DenseMatrix
@@ -183,12 +180,12 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
     }
 
     // check index
-    for (var x = 0; x < index.length; x++) {
+    for (let x = 0; x < index.length; x++) {
       (0, _array.validateIndex)(index[x], this._size[x]);
     }
-    var data = this._data;
-    for (var i = 0, ii = index.length; i < ii; i++) {
-      var indexI = index[i];
+    let data = this._data;
+    for (let i = 0, ii = index.length; i < ii; i++) {
+      const indexI = index[i];
       (0, _array.validateIndex)(indexI, data.length);
       data = data[indexI];
     }
@@ -212,16 +209,16 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
     if (index.length < this._size.length) {
       throw new _DimensionError.DimensionError(index.length, this._size.length, '<');
     }
-    var i, ii, indexI;
+    let i, ii, indexI;
 
     // enlarge matrix when needed
-    var size = index.map(function (i) {
+    const size = index.map(function (i) {
       return i + 1;
     });
     _fit(this, size, defaultValue);
 
     // traverse over the dimensions
-    var data = this._data;
+    let data = this._data;
     for (i = 0, ii = index.length - 1; i < ii; i++) {
       indexI = index[i];
       (0, _array.validateIndex)(indexI, data.length);
@@ -246,21 +243,21 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
     if (!(0, _is.isIndex)(index)) {
       throw new TypeError('Invalid index');
     }
-    var isScalar = index.isScalar();
+    const isScalar = index.isScalar();
     if (isScalar) {
       // return a scalar
       return matrix.get(index.min());
     } else {
       // validate dimensions
-      var size = index.size();
+      const size = index.size();
       if (size.length !== matrix._size.length) {
         throw new _DimensionError.DimensionError(size.length, matrix._size.length);
       }
 
       // validate if any of the ranges in the index is out of range
-      var min = index.min();
-      var max = index.max();
-      for (var i = 0, ii = matrix._size.length; i < ii; i++) {
+      const min = index.min();
+      const max = index.max();
+      for (let i = 0, ii = matrix._size.length; i < ii; i++) {
         (0, _array.validateIndex)(min[i], matrix._size[i]);
         (0, _array.validateIndex)(max[i], matrix._size[i]);
       }
@@ -283,8 +280,8 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
    * @private
    */
   function _getSubmatrix(data, index, dims, dim) {
-    var last = dim === dims - 1;
-    var range = index.dimension(dim);
+    const last = dim === dims - 1;
+    const range = index.dimension(dim);
     if (last) {
       return range.map(function (i) {
         (0, _array.validateIndex)(i, data.length);
@@ -293,7 +290,7 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
     } else {
       return range.map(function (i) {
         (0, _array.validateIndex)(i, data.length);
-        var child = data[i];
+        const child = data[i];
         return _getSubmatrix(child, index, dims, dim + 1);
       }).valueOf();
     }
@@ -317,11 +314,11 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
     }
 
     // get index size and check whether the index contains a single value
-    var iSize = index.size();
-    var isScalar = index.isScalar();
+    const iSize = index.size();
+    const isScalar = index.isScalar();
 
     // calculate the size of the submatrix, and convert it into an Array if needed
-    var sSize;
+    let sSize;
     if ((0, _is.isMatrix)(submatrix)) {
       sSize = submatrix.size();
       submatrix = submatrix.valueOf();
@@ -348,7 +345,7 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
             submatrix = (0, _array.broadcastTo)(submatrix, iSize);
           }
           sSize = (0, _array.arraySize)(submatrix);
-        } catch (_unused) {}
+        } catch {}
       }
 
       // validate dimensions
@@ -357,8 +354,8 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
       }
       if (sSize.length < iSize.length) {
         // calculate number of missing outer dimensions
-        var i = 0;
-        var outer = 0;
+        let i = 0;
+        let outer = 0;
         while (iSize[i] === 1 && sSize[i] === 1) {
           i++;
         }
@@ -377,14 +374,14 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
       }
 
       // enlarge matrix when needed
-      var size = index.max().map(function (i) {
+      const size = index.max().map(function (i) {
         return i + 1;
       });
       _fit(matrix, size, defaultValue);
 
       // insert the sub matrix
-      var dims = iSize.length;
-      var dim = 0;
+      const dims = iSize.length;
+      const dim = 0;
       _setSubmatrix(matrix._data, index, submatrix, dims, dim);
     }
     return matrix;
@@ -401,8 +398,8 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
    * @private
    */
   function _setSubmatrix(data, index, submatrix, dims, dim) {
-    var last = dim === dims - 1;
-    var range = index.dimension(dim);
+    const last = dim === dims - 1;
+    const range = index.dimension(dim);
     if (last) {
       range.forEach(function (dataIndex, subIndex) {
         (0, _array.validateIndex)(dataIndex);
@@ -436,12 +433,12 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
     }
 
     // SparseMatrix input is always 2d, flatten this into 1d if it's indeed a vector
-    var sizeArray = size.valueOf().map(function (value) {
+    const sizeArray = size.valueOf().map(value => {
       return Array.isArray(value) && value.length === 1 ? value[0] : value;
     });
 
     // matrix to resize
-    var m = copy ? this.clone() : this;
+    const m = copy ? this.clone() : this;
     // resize matrix
     return _resize(m, sizeArray, defaultValue);
   };
@@ -449,7 +446,7 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
     // check size
     if (size.length === 0) {
       // first value in matrix
-      var v = matrix._data;
+      let v = matrix._data;
       // go deep
       while ((0, _is.isArray)(v)) {
         v = v[0];
@@ -478,11 +475,9 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
    * @return {Matrix}                 The reshaped matrix
    */
   DenseMatrix.prototype.reshape = function (size, copy) {
-    var m = copy ? this.clone() : this;
+    const m = copy ? this.clone() : this;
     m._data = (0, _array.reshape)(m._data, size);
-    var currentLength = m._size.reduce(function (length, size) {
-      return length * size;
-    });
+    const currentLength = m._size.reduce((length, size) => length * size);
     m._size = (0, _array.processSizesWildcard)(size, currentLength);
     return m;
   };
@@ -497,10 +492,10 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
    * @private
    */
   function _fit(matrix, size, defaultValue) {
-    var
+    const
     // copy the array
     newSize = matrix._size.slice(0);
-    var changed = false;
+    let changed = false;
 
     // add dimensions when needed
     while (newSize.length < size.length) {
@@ -509,7 +504,7 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
     }
 
     // enlarge size when needed
-    for (var i = 0, ii = size.length; i < ii; i++) {
+    for (let i = 0, ii = size.length; i < ii; i++) {
       if (size[i] > newSize[i]) {
         newSize[i] = size[i];
         changed = true;
@@ -527,7 +522,7 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
    * @return {DenseMatrix} clone
    */
   DenseMatrix.prototype.clone = function () {
-    var m = new DenseMatrix({
+    const m = new DenseMatrix({
       data: (0, _object.clone)(this._data),
       size: (0, _object.clone)(this._size),
       datatype: this._datatype
@@ -556,9 +551,9 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
    */
   DenseMatrix.prototype.map = function (callback) {
     // matrix instance
-    var me = this;
-    var args = (0, _function.maxArgumentCount)(callback);
-    var recurse = function recurse(value, index) {
+    const me = this;
+    const args = (0, _function.maxArgumentCount)(callback);
+    const recurse = function (value, index) {
       if ((0, _is.isArray)(value)) {
         return value.map(function (child, i) {
           return recurse(child, index.concat(i));
@@ -578,8 +573,8 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
 
     // determine the new datatype when the original matrix has datatype defined
     // TODO: should be done in matrix constructor instead
-    var data = recurse(this._data, []);
-    var datatype = this._datatype !== undefined ? (0, _array.getArrayDataType)(data, _is.typeOf) : undefined;
+    const data = recurse(this._data, []);
+    const datatype = this._datatype !== undefined ? (0, _array.getArrayDataType)(data, _is.typeOf) : undefined;
     return new DenseMatrix(data, datatype);
   };
 
@@ -592,8 +587,8 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
    */
   DenseMatrix.prototype.forEach = function (callback) {
     // matrix instance
-    var me = this;
-    var recurse = function recurse(value, index) {
+    const me = this;
+    const recurse = function (value, index) {
       if ((0, _is.isArray)(value)) {
         value.forEach(function (child, i) {
           recurse(child, index.concat(i));
@@ -609,76 +604,35 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
    * Iterate over the matrix elements
    * @return {Iterable<{ value, index: number[] }>}
    */
-  DenseMatrix.prototype[Symbol.iterator] = /*#__PURE__*/_regenerator["default"].mark(function _callee() {
-    var recurse;
-    return _regenerator["default"].wrap(function _callee$(_context2) {
-      while (1) switch (_context2.prev = _context2.next) {
-        case 0:
-          recurse = /*#__PURE__*/_regenerator["default"].mark(function recurse(value, index) {
-            var i;
-            return _regenerator["default"].wrap(function recurse$(_context) {
-              while (1) switch (_context.prev = _context.next) {
-                case 0:
-                  if (!(0, _is.isArray)(value)) {
-                    _context.next = 9;
-                    break;
-                  }
-                  i = 0;
-                case 2:
-                  if (!(i < value.length)) {
-                    _context.next = 7;
-                    break;
-                  }
-                  return _context.delegateYield(recurse(value[i], index.concat(i)), "t0", 4);
-                case 4:
-                  i++;
-                  _context.next = 2;
-                  break;
-                case 7:
-                  _context.next = 11;
-                  break;
-                case 9:
-                  _context.next = 11;
-                  return {
-                    value: value,
-                    index: index
-                  };
-                case 11:
-                case "end":
-                  return _context.stop();
-              }
-            }, recurse);
-          });
-          return _context2.delegateYield(recurse(this._data, []), "t0", 2);
-        case 2:
-        case "end":
-          return _context2.stop();
+  DenseMatrix.prototype[Symbol.iterator] = function* () {
+    const recurse = function* (value, index) {
+      if ((0, _is.isArray)(value)) {
+        for (let i = 0; i < value.length; i++) {
+          yield* recurse(value[i], index.concat(i));
+        }
+      } else {
+        yield {
+          value,
+          index
+        };
       }
-    }, _callee, this);
-  });
+    };
+    yield* recurse(this._data, []);
+  };
 
   /**
    * Returns an array containing the rows of a 2D matrix
    * @returns {Array<Matrix>}
    */
   DenseMatrix.prototype.rows = function () {
-    var result = [];
-    var s = this.size();
+    const result = [];
+    const s = this.size();
     if (s.length !== 2) {
       throw new TypeError('Rows can only be returned for a 2D matrix.');
     }
-    var data = this._data;
-    var _iterator = _createForOfIteratorHelper(data),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var row = _step.value;
-        result.push(new DenseMatrix([row], this._datatype));
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
+    const data = this._data;
+    for (const row of data) {
+      result.push(new DenseMatrix([row], this._datatype));
     }
     return result;
   };
@@ -688,21 +642,15 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
    * @returns {Array<Matrix>}
    */
   DenseMatrix.prototype.columns = function () {
-    var _this = this;
-    var result = [];
-    var s = this.size();
+    const result = [];
+    const s = this.size();
     if (s.length !== 2) {
       throw new TypeError('Rows can only be returned for a 2D matrix.');
     }
-    var data = this._data;
-    var _loop = function _loop(i) {
-      var col = data.map(function (row) {
-        return [row[i]];
-      });
-      result.push(new DenseMatrix(col, _this._datatype));
-    };
-    for (var i = 0; i < s[1]; i++) {
-      _loop(i);
+    const data = this._data;
+    for (let i = 0; i < s[1]; i++) {
+      const col = data.map(row => [row[i]]);
+      result.push(new DenseMatrix(col, this._datatype));
     }
     return result;
   };
@@ -784,27 +732,27 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
       // default value
       k = 0;
     }
-    var kSuper = k > 0 ? k : 0;
-    var kSub = k < 0 ? -k : 0;
+    const kSuper = k > 0 ? k : 0;
+    const kSub = k < 0 ? -k : 0;
 
     // rows & columns
-    var rows = this._size[0];
-    var columns = this._size[1];
+    const rows = this._size[0];
+    const columns = this._size[1];
 
     // number diagonal values
-    var n = Math.min(rows - kSub, columns - kSuper);
+    const n = Math.min(rows - kSub, columns - kSuper);
 
     // x is a matrix get diagonal from matrix
-    var data = [];
+    const data = [];
 
     // loop rows
-    for (var i = 0; i < n; i++) {
+    for (let i = 0; i < n; i++) {
       data[i] = this._data[i + kSub][i + kSuper];
     }
 
     // create DenseMatrix
     return new DenseMatrix({
-      data: data,
+      data,
       size: [n],
       datatype: this._datatype
     });
@@ -858,18 +806,18 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
       // default value
       k = 0;
     }
-    var kSuper = k > 0 ? k : 0;
-    var kSub = k < 0 ? -k : 0;
+    const kSuper = k > 0 ? k : 0;
+    const kSub = k < 0 ? -k : 0;
 
     // rows and columns
-    var rows = size[0];
-    var columns = size[1];
+    const rows = size[0];
+    const columns = size[1];
 
     // number of non-zero items
-    var n = Math.min(rows - kSub, columns - kSuper);
+    const n = Math.min(rows - kSub, columns - kSuper);
 
     // value extraction function
-    var _value;
+    let _value;
 
     // check value
     if ((0, _is.isArray)(value)) {
@@ -879,26 +827,26 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
         throw new Error('Invalid value array length');
       }
       // define function
-      _value = function _value(i) {
+      _value = function (i) {
         // return value @ i
         return value[i];
       };
     } else if ((0, _is.isMatrix)(value)) {
       // matrix size
-      var ms = value.size();
+      const ms = value.size();
       // validate matrix
       if (ms.length !== 1 || ms[0] !== n) {
         // number of values in array must be n
         throw new Error('Invalid matrix length');
       }
       // define function
-      _value = function _value(i) {
+      _value = function (i) {
         // return value @ i
         return value.get([i]);
       };
     } else {
       // define function
-      _value = function _value() {
+      _value = function () {
         // return value
         return value;
       };
@@ -912,21 +860,21 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
     }
 
     // empty array
-    var data = [];
+    let data = [];
 
     // check we need to resize array
     if (size.length > 0) {
       // resize array
       data = (0, _array.resize)(data, size, defaultValue);
       // fill diagonal
-      for (var d = 0; d < n; d++) {
+      for (let d = 0; d < n; d++) {
         data[d + kSub][d + kSuper] = _value(d);
       }
     }
 
     // create DenseMatrix
     return new DenseMatrix({
-      data: data,
+      data,
       size: [rows, columns]
     });
   };
@@ -980,7 +928,7 @@ var createDenseMatrixClass = exports.createDenseMatrixClass = /* #__PURE__ */(0,
    */
   DenseMatrix._swapRows = function (i, j, data) {
     // swap values i <-> j
-    var vi = data[i];
+    const vi = data[i];
     data[i] = data[j];
     data[j] = vi;
   };

package/lib/cjs/type/matrix/FibonacciHeap.js

@@ -5,12 +5,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.createFibonacciHeapClass = void 0;
 var _factory = require("../../utils/factory.js");
-var name = 'FibonacciHeap';
-var dependencies = ['smaller', 'larger'];
-var createFibonacciHeapClass = exports.createFibonacciHeapClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var smaller = _ref.smaller,
-    larger = _ref.larger;
-  var oneOverLogPhi = 1.0 / Math.log((1.0 + Math.sqrt(5.0)) / 2.0);
+const name = 'FibonacciHeap';
+const dependencies = ['smaller', 'larger'];
+const createFibonacciHeapClass = exports.createFibonacciHeapClass = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    smaller,
+    larger
+  } = _ref;
+  const oneOverLogPhi = 1.0 / Math.log((1.0 + Math.sqrt(5.0)) / 2.0);
 
   /**
    * Fibonacci Heap implementation, used interally for Matrix math.
@@ -41,15 +43,15 @@ var createFibonacciHeapClass = exports.createFibonacciHeapClass = /* #__PURE__ *
    */
   FibonacciHeap.prototype.insert = function (key, value) {
     // create node
-    var node = {
-      key: key,
-      value: value,
+    const node = {
+      key,
+      value,
       degree: 0
     };
     // check we have a node in the minimum
     if (this._minimum) {
       // minimum node
-      var minimum = this._minimum;
+      const minimum = this._minimum;
       // update left & right of node
       node.left = minimum;
       node.right = minimum.right;
@@ -105,21 +107,21 @@ var createFibonacciHeapClass = exports.createFibonacciHeapClass = /* #__PURE__ *
    */
   FibonacciHeap.prototype.extractMinimum = function () {
     // node to remove
-    var node = this._minimum;
+    const node = this._minimum;
     // check we have a minimum
     if (node === null) {
       return node;
     }
     // current minimum
-    var minimum = this._minimum;
+    let minimum = this._minimum;
     // get number of children
-    var numberOfChildren = node.degree;
+    let numberOfChildren = node.degree;
     // pointer to the first child
-    var x = node.child;
+    let x = node.child;
     // for each child of node do...
     while (numberOfChildren > 0) {
       // store node in right side
-      var tempRight = x.right;
+      const tempRight = x.right;
       // remove x from child list
       x.left.right = x.right;
       x.right.left = x.left;
@@ -178,7 +180,7 @@ var createFibonacciHeapClass = exports.createFibonacciHeapClass = /* #__PURE__ *
     // set node key
     node.key = key;
     // get parent node
-    var parent = node.parent;
+    const parent = node.parent;
     if (parent && smaller(node.key, parent.key)) {
       // remove node from parent
       _cut(minimum, node, parent);
@@ -230,7 +232,7 @@ var createFibonacciHeapClass = exports.createFibonacciHeapClass = /* #__PURE__ *
    */
   function _cascadingCut(minimum, node) {
     // store parent node
-    var parent = node.parent;
+    const parent = node.parent;
     // if there's a parent...
     if (!parent) {
       return;
@@ -250,7 +252,7 @@ var createFibonacciHeapClass = exports.createFibonacciHeapClass = /* #__PURE__ *
    * Make the first node a child of the second one. Running time: O(1) actual.
    * @memberof FibonacciHeap
    */
-  var _linkNodes = function _linkNodes(node, parent) {
+  const _linkNodes = function (node, parent) {
     // remove node from root list of heap
     node.left.right = node.right;
     node.right.left = node.left;
@@ -273,12 +275,12 @@ var createFibonacciHeapClass = exports.createFibonacciHeapClass = /* #__PURE__ *
   };
   function _findMinimumNode(minimum, size) {
     // to find trees of the same degree efficiently we use an array of length O(log n) in which we keep a pointer to one root of each degree
-    var arraySize = Math.floor(Math.log(size) * oneOverLogPhi) + 1;
+    const arraySize = Math.floor(Math.log(size) * oneOverLogPhi) + 1;
     // create list with initial capacity
-    var array = new Array(arraySize);
+    const array = new Array(arraySize);
     // find the number of root nodes.
-    var numRoots = 0;
-    var x = minimum;
+    let numRoots = 0;
+    let x = minimum;
     if (x) {
       numRoots++;
       x = x.right;
@@ -288,13 +290,13 @@ var createFibonacciHeapClass = exports.createFibonacciHeapClass = /* #__PURE__ *
       }
     }
     // vars
-    var y;
+    let y;
     // For each node in root list do...
     while (numRoots > 0) {
       // access this node's degree..
-      var d = x.degree;
+      let d = x.degree;
       // get next node
-      var next = x.right;
+      const next = x.right;
       // check if there is a node already in array with the same degree
       while (true) {
         // get node with the same degree is any
@@ -304,7 +306,7 @@ var createFibonacciHeapClass = exports.createFibonacciHeapClass = /* #__PURE__ *
         }
         // make one node with the same degree a child of the other, do this based on the key value.
         if (larger(x.key, y.key)) {
-          var temp = y;
+          const temp = y;
           y = x;
           x = temp;
         }
@@ -323,7 +325,7 @@ var createFibonacciHeapClass = exports.createFibonacciHeapClass = /* #__PURE__ *
     // Set min to null (effectively losing the root list) and reconstruct the root list from the array entries in array[].
     minimum = null;
     // loop nodes in array
-    for (var i = 0; i < arraySize; i++) {
+    for (let i = 0; i < arraySize; i++) {
       // get current node
       y = array[i];
       if (!y) {