mathjs 12.4.2 → 13.0.0

package/lib/cjs/function/matrix/range.js

@@ -6,19 +6,21 @@ Object.defineProperty(exports, "__esModule", {
 exports.createRange = void 0;
 var _factory = require("../../utils/factory.js");
 var _noop = require("../../utils/noop.js");
-var name = 'range';
-var dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq', 'add', 'isPositive'];
-var createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    matrix = _ref.matrix,
-    bignumber = _ref.bignumber,
-    smaller = _ref.smaller,
-    smallerEq = _ref.smallerEq,
-    larger = _ref.larger,
-    largerEq = _ref.largerEq,
-    add = _ref.add,
-    isPositive = _ref.isPositive;
+const name = 'range';
+const dependencies = ['typed', 'config', '?matrix', '?bignumber', 'smaller', 'smallerEq', 'larger', 'largerEq', 'add', 'isPositive'];
+const createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    matrix,
+    bignumber,
+    smaller,
+    smallerEq,
+    larger,
+    largerEq,
+    add,
+    isPositive
+  } = _ref;
   /**
    * Create an array from a range.
    * By default, the range end is excluded. This can be customized by providing
@@ -69,36 +71,36 @@ var createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(nam
     // TODO: a number or boolean should not be converted to string here
     string: _strRange,
     'string, boolean': _strRange,
-    'number, number': function numberNumber(start, end) {
+    'number, number': function (start, end) {
       return _out(_range(start, end, 1, false));
     },
-    'number, number, number': function numberNumberNumber(start, end, step) {
+    'number, number, number': function (start, end, step) {
       return _out(_range(start, end, step, false));
     },
-    'number, number, boolean': function numberNumberBoolean(start, end, includeEnd) {
+    'number, number, boolean': function (start, end, includeEnd) {
       return _out(_range(start, end, 1, includeEnd));
     },
-    'number, number, number, boolean': function numberNumberNumberBoolean(start, end, step, includeEnd) {
+    'number, number, number, boolean': function (start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
-    'BigNumber, BigNumber': function BigNumberBigNumber(start, end) {
-      var BigNumber = start.constructor;
+    'BigNumber, BigNumber': function (start, end) {
+      const BigNumber = start.constructor;
       return _out(_range(start, end, new BigNumber(1), false));
     },
-    'BigNumber, BigNumber, BigNumber': function BigNumberBigNumberBigNumber(start, end, step) {
+    'BigNumber, BigNumber, BigNumber': function (start, end, step) {
       return _out(_range(start, end, step, false));
     },
-    'BigNumber, BigNumber, boolean': function BigNumberBigNumberBoolean(start, end, includeEnd) {
-      var BigNumber = start.constructor;
+    'BigNumber, BigNumber, boolean': function (start, end, includeEnd) {
+      const BigNumber = start.constructor;
       return _out(_range(start, end, new BigNumber(1), includeEnd));
     },
-    'BigNumber, BigNumber, BigNumber, boolean': function BigNumberBigNumberBigNumberBoolean(start, end, step, includeEnd) {
+    'BigNumber, BigNumber, BigNumber, boolean': function (start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     },
-    'Unit, Unit, Unit': function UnitUnitUnit(start, end, step) {
+    'Unit, Unit, Unit': function (start, end, step) {
       return _out(_range(start, end, step, false));
     },
-    'Unit, Unit, Unit, boolean': function UnitUnitUnitBoolean(start, end, step, includeEnd) {
+    'Unit, Unit, Unit, boolean': function (start, end, step, includeEnd) {
       return _out(_range(start, end, step, includeEnd));
     }
   });
@@ -109,7 +111,7 @@ var createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(nam
     return arr;
   }
   function _strRange(str, includeEnd) {
-    var r = _parse(str);
+    const r = _parse(str);
     if (!r) {
       throw new SyntaxError('String "' + str + '" is no valid range');
     }
@@ -133,9 +135,9 @@ var createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(nam
    * @private
    */
   function _range(start, end, step, includeEnd) {
-    var array = [];
-    var ongoing = isPositive(step) ? includeEnd ? smallerEq : smaller : includeEnd ? largerEq : larger;
-    var x = start;
+    const array = [];
+    const ongoing = isPositive(step) ? includeEnd ? smallerEq : smaller : includeEnd ? largerEq : larger;
+    let x = start;
     while (ongoing(x, end)) {
       array.push(x);
       x = add(x, step);
@@ -153,14 +155,14 @@ var createRange = exports.createRange = /* #__PURE__ */(0, _factory.factory)(nam
    * @private
    */
   function _parse(str) {
-    var args = str.split(':');
+    const args = str.split(':');
 
     // number
-    var nums = args.map(function (arg) {
+    const nums = args.map(function (arg) {
       // use Number and not parseFloat as Number returns NaN on invalid garbage in the string
       return Number(arg);
     });
-    var invalid = nums.some(function (num) {
+    const invalid = nums.some(function (num) {
       return isNaN(num);
     });
     if (invalid) {

package/lib/cjs/function/matrix/reshape.js

@@ -6,11 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.createReshape = void 0;
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
-var name = 'reshape';
-var dependencies = ['typed', 'isInteger', 'matrix'];
-var createReshape = exports.createReshape = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    isInteger = _ref.isInteger;
+const name = 'reshape';
+const dependencies = ['typed', 'isInteger', 'matrix'];
+const createReshape = exports.createReshape = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    isInteger
+  } = _ref;
   /**
    * Reshape a multi dimensional array to fit the specified dimensions
    *
@@ -52,10 +54,10 @@ var createReshape = exports.createReshape = /* #__PURE__ */(0, _factory.factory)
    *                                not equal that of the old ones
    */
   return typed(name, {
-    'Matrix, Array': function MatrixArray(x, sizes) {
+    'Matrix, Array': function (x, sizes) {
       return x.reshape(sizes, true);
     },
-    'Array, Array': function ArrayArray(x, sizes) {
+    'Array, Array': function (x, sizes) {
       sizes.forEach(function (size) {
         if (!isInteger(size)) {
           throw new TypeError('Invalid size for dimension: ' + size);

package/lib/cjs/function/matrix/resize.js

@@ -12,11 +12,13 @@ var _string = require("../../utils/string.js");
 var _object = require("../../utils/object.js");
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
-var name = 'resize';
-var dependencies = ['config', 'matrix'];
-var createResize = exports.createResize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var config = _ref.config,
-    matrix = _ref.matrix;
+const name = 'resize';
+const dependencies = ['config', 'matrix'];
+const createResize = exports.createResize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    config,
+    matrix
+  } = _ref;
   /**
    * Resize a matrix
    *
@@ -69,7 +71,7 @@ var createResize = exports.createResize = /* #__PURE__ */(0, _factory.factory)(n
     }
 
     // check result should be a matrix
-    var asMatrix = Array.isArray(x) ? false : config.matrix !== 'Array';
+    const asMatrix = Array.isArray(x) ? false : config.matrix !== 'Array';
     if (size.length === 0) {
       // output a scalar
       while (Array.isArray(x)) {
@@ -82,7 +84,7 @@ var createResize = exports.createResize = /* #__PURE__ */(0, _factory.factory)(n
         x = [x];
       }
       x = (0, _object.clone)(x);
-      var res = (0, _array.resize)(x, size, defaultValue);
+      const res = (0, _array.resize)(x, size, defaultValue);
       return asMatrix ? matrix(res) : res;
     }
   };
@@ -105,15 +107,15 @@ var createResize = exports.createResize = /* #__PURE__ */(0, _factory.factory)(n
     if (size.length !== 1) {
       throw new _DimensionError.DimensionError(size.length, 1);
     }
-    var len = size[0];
+    const len = size[0];
     if (typeof len !== 'number' || !(0, _number.isInteger)(len)) {
       throw new TypeError('Invalid size, must contain positive integers ' + '(size: ' + (0, _string.format)(size) + ')');
     }
     if (str.length > len) {
       return str.substring(0, len);
     } else if (str.length < len) {
-      var res = str;
-      for (var i = 0, ii = len - str.length; i < ii; i++) {
+      let res = str;
+      for (let i = 0, ii = len - str.length; i < ii; i++) {
         res += defaultChar;
       }
       return res;

package/lib/cjs/function/matrix/rotate.js

@@ -6,12 +6,14 @@ Object.defineProperty(exports, "__esModule", {
 exports.createRotate = void 0;
 var _factory = require("../../utils/factory.js");
 var _array = require("../../utils/array.js");
-var name = 'rotate';
-var dependencies = ['typed', 'multiply', 'rotationMatrix'];
-var createRotate = exports.createRotate = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    multiply = _ref.multiply,
-    rotationMatrix = _ref.rotationMatrix;
+const name = 'rotate';
+const dependencies = ['typed', 'multiply', 'rotationMatrix'];
+const createRotate = exports.createRotate = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    multiply,
+    rotationMatrix
+  } = _ref;
   /**
      * Rotate a vector of size 1x2 counter-clockwise by a given angle
      * Rotate a vector of size 1x3 counter-clockwise by a given angle around the given axis
@@ -41,35 +43,35 @@ var createRotate = exports.createRotate = /* #__PURE__ */(0, _factory.factory)(n
      * @return {Array | Matrix}                              Multiplication of the rotation matrix and w
      */
   return typed(name, {
-    'Array , number | BigNumber | Complex | Unit': function ArrayNumberBigNumberComplexUnit(w, theta) {
+    'Array , number | BigNumber | Complex | Unit': function (w, theta) {
       _validateSize(w, 2);
-      var matrixRes = multiply(rotationMatrix(theta), w);
+      const matrixRes = multiply(rotationMatrix(theta), w);
       return matrixRes.toArray();
     },
-    'Matrix , number | BigNumber | Complex | Unit': function MatrixNumberBigNumberComplexUnit(w, theta) {
+    'Matrix , number | BigNumber | Complex | Unit': function (w, theta) {
       _validateSize(w, 2);
       return multiply(rotationMatrix(theta), w);
     },
-    'Array, number | BigNumber | Complex | Unit, Array | Matrix': function ArrayNumberBigNumberComplexUnitArrayMatrix(w, theta, v) {
+    'Array, number | BigNumber | Complex | Unit, Array | Matrix': function (w, theta, v) {
       _validateSize(w, 3);
-      var matrixRes = multiply(rotationMatrix(theta, v), w);
+      const matrixRes = multiply(rotationMatrix(theta, v), w);
       return matrixRes;
     },
-    'Matrix, number | BigNumber | Complex | Unit, Array | Matrix': function MatrixNumberBigNumberComplexUnitArrayMatrix(w, theta, v) {
+    'Matrix, number | BigNumber | Complex | Unit, Array | Matrix': function (w, theta, v) {
       _validateSize(w, 3);
       return multiply(rotationMatrix(theta, v), w);
     }
   });
   function _validateSize(v, expectedSize) {
-    var actualSize = Array.isArray(v) ? (0, _array.arraySize)(v) : v.size();
+    const actualSize = Array.isArray(v) ? (0, _array.arraySize)(v) : v.size();
     if (actualSize.length > 2) {
-      throw new RangeError("Vector must be of dimensions 1x".concat(expectedSize));
+      throw new RangeError(`Vector must be of dimensions 1x${expectedSize}`);
     }
     if (actualSize.length === 2 && actualSize[1] !== 1) {
-      throw new RangeError("Vector must be of dimensions 1x".concat(expectedSize));
+      throw new RangeError(`Vector must be of dimensions 1x${expectedSize}`);
     }
     if (actualSize[0] !== expectedSize) {
-      throw new RangeError("Vector must be of dimensions 1x".concat(expectedSize));
+      throw new RangeError(`Vector must be of dimensions 1x${expectedSize}`);
     }
   }
 });

package/lib/cjs/function/matrix/rotationMatrix.js

@@ -6,21 +6,23 @@ Object.defineProperty(exports, "__esModule", {
 exports.createRotationMatrix = void 0;
 var _is = require("../../utils/is.js");
 var _factory = require("../../utils/factory.js");
-var name = 'rotationMatrix';
-var dependencies = ['typed', 'config', 'multiplyScalar', 'addScalar', 'unaryMinus', 'norm', 'matrix', 'BigNumber', 'DenseMatrix', 'SparseMatrix', 'cos', 'sin'];
-var createRotationMatrix = exports.createRotationMatrix = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    multiplyScalar = _ref.multiplyScalar,
-    addScalar = _ref.addScalar,
-    unaryMinus = _ref.unaryMinus,
-    norm = _ref.norm,
-    BigNumber = _ref.BigNumber,
-    matrix = _ref.matrix,
-    DenseMatrix = _ref.DenseMatrix,
-    SparseMatrix = _ref.SparseMatrix,
-    cos = _ref.cos,
-    sin = _ref.sin;
+const name = 'rotationMatrix';
+const dependencies = ['typed', 'config', 'multiplyScalar', 'addScalar', 'unaryMinus', 'norm', 'matrix', 'BigNumber', 'DenseMatrix', 'SparseMatrix', 'cos', 'sin'];
+const createRotationMatrix = exports.createRotationMatrix = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    multiplyScalar,
+    addScalar,
+    unaryMinus,
+    norm,
+    BigNumber,
+    matrix,
+    DenseMatrix,
+    SparseMatrix,
+    cos,
+    sin
+  } = _ref;
   /**
    * Create a 2-dimensional counter-clockwise rotation matrix (2x2) for a given angle (expressed in radians).
    * Create a 2-dimensional counter-clockwise rotation matrix (3x3) by a given angle (expressed in radians) around a given axis (1x3).
@@ -55,34 +57,34 @@ var createRotationMatrix = exports.createRotationMatrix = /* #__PURE__ */(0, _fa
    */
 
   return typed(name, {
-    '': function _() {
+    '': function () {
       return config.matrix === 'Matrix' ? matrix([]) : [];
     },
-    string: function string(format) {
+    string: function (format) {
       return matrix(format);
     },
-    'number | BigNumber | Complex | Unit': function numberBigNumberComplexUnit(theta) {
+    'number | BigNumber | Complex | Unit': function (theta) {
       return _rotationMatrix2x2(theta, config.matrix === 'Matrix' ? 'dense' : undefined);
     },
-    'number | BigNumber | Complex | Unit, string': function numberBigNumberComplexUnitString(theta, format) {
+    'number | BigNumber | Complex | Unit, string': function (theta, format) {
       return _rotationMatrix2x2(theta, format);
     },
-    'number | BigNumber | Complex | Unit, Array': function numberBigNumberComplexUnitArray(theta, v) {
-      var matrixV = matrix(v);
+    'number | BigNumber | Complex | Unit, Array': function (theta, v) {
+      const matrixV = matrix(v);
       _validateVector(matrixV);
       return _rotationMatrix3x3(theta, matrixV, undefined);
     },
-    'number | BigNumber | Complex | Unit, Matrix': function numberBigNumberComplexUnitMatrix(theta, v) {
+    'number | BigNumber | Complex | Unit, Matrix': function (theta, v) {
       _validateVector(v);
-      var storageType = v.storage() || (config.matrix === 'Matrix' ? 'dense' : undefined);
+      const storageType = v.storage() || (config.matrix === 'Matrix' ? 'dense' : undefined);
       return _rotationMatrix3x3(theta, v, storageType);
     },
-    'number | BigNumber | Complex | Unit, Array, string': function numberBigNumberComplexUnitArrayString(theta, v, format) {
-      var matrixV = matrix(v);
+    'number | BigNumber | Complex | Unit, Array, string': function (theta, v, format) {
+      const matrixV = matrix(v);
       _validateVector(matrixV);
       return _rotationMatrix3x3(theta, matrixV, format);
     },
-    'number | BigNumber | Complex | Unit, Matrix, string': function numberBigNumberComplexUnitMatrixString(theta, v, format) {
+    'number | BigNumber | Complex | Unit, Matrix, string': function (theta, v, format) {
       _validateVector(v);
       return _rotationMatrix3x3(theta, v, format);
     }
@@ -97,23 +99,21 @@ var createRotationMatrix = exports.createRotationMatrix = /* #__PURE__ */(0, _fa
    * @private
    */
   function _rotationMatrix2x2(theta, format) {
-    var Big = (0, _is.isBigNumber)(theta);
-    var minusOne = Big ? new BigNumber(-1) : -1;
-    var cosTheta = cos(theta);
-    var sinTheta = sin(theta);
-    var data = [[cosTheta, multiplyScalar(minusOne, sinTheta)], [sinTheta, cosTheta]];
+    const Big = (0, _is.isBigNumber)(theta);
+    const minusOne = Big ? new BigNumber(-1) : -1;
+    const cosTheta = cos(theta);
+    const sinTheta = sin(theta);
+    const data = [[cosTheta, multiplyScalar(minusOne, sinTheta)], [sinTheta, cosTheta]];
     return _convertToFormat(data, format);
   }
   function _validateVector(v) {
-    var size = v.size();
+    const size = v.size();
     if (size.length < 1 || size[0] !== 3) {
       throw new RangeError('Vector must be of dimensions 1x3');
     }
   }
   function _mul(array) {
-    return array.reduce(function (p, curr) {
-      return multiplyScalar(p, curr);
-    });
+    return array.reduce((p, curr) => multiplyScalar(p, curr));
   }
   function _convertToFormat(data, format) {
     if (format) {
@@ -123,7 +123,7 @@ var createRotationMatrix = exports.createRotationMatrix = /* #__PURE__ */(0, _fa
       if (format === 'dense') {
         return new DenseMatrix(data);
       }
-      throw new TypeError("Unknown matrix type \"".concat(format, "\""));
+      throw new TypeError(`Unknown matrix type "${format}"`);
     }
     return data;
   }
@@ -138,29 +138,29 @@ var createRotationMatrix = exports.createRotationMatrix = /* #__PURE__ */(0, _fa
    * @private
    */
   function _rotationMatrix3x3(theta, v, format) {
-    var normV = norm(v);
+    const normV = norm(v);
     if (normV === 0) {
       throw new RangeError('Rotation around zero vector');
     }
-    var Big = (0, _is.isBigNumber)(theta) ? BigNumber : null;
-    var one = Big ? new Big(1) : 1;
-    var minusOne = Big ? new Big(-1) : -1;
-    var vx = Big ? new Big(v.get([0]) / normV) : v.get([0]) / normV;
-    var vy = Big ? new Big(v.get([1]) / normV) : v.get([1]) / normV;
-    var vz = Big ? new Big(v.get([2]) / normV) : v.get([2]) / normV;
-    var c = cos(theta);
-    var oneMinusC = addScalar(one, unaryMinus(c));
-    var s = sin(theta);
-    var r11 = addScalar(c, _mul([vx, vx, oneMinusC]));
-    var r12 = addScalar(_mul([vx, vy, oneMinusC]), _mul([minusOne, vz, s]));
-    var r13 = addScalar(_mul([vx, vz, oneMinusC]), _mul([vy, s]));
-    var r21 = addScalar(_mul([vx, vy, oneMinusC]), _mul([vz, s]));
-    var r22 = addScalar(c, _mul([vy, vy, oneMinusC]));
-    var r23 = addScalar(_mul([vy, vz, oneMinusC]), _mul([minusOne, vx, s]));
-    var r31 = addScalar(_mul([vx, vz, oneMinusC]), _mul([minusOne, vy, s]));
-    var r32 = addScalar(_mul([vy, vz, oneMinusC]), _mul([vx, s]));
-    var r33 = addScalar(c, _mul([vz, vz, oneMinusC]));
-    var data = [[r11, r12, r13], [r21, r22, r23], [r31, r32, r33]];
+    const Big = (0, _is.isBigNumber)(theta) ? BigNumber : null;
+    const one = Big ? new Big(1) : 1;
+    const minusOne = Big ? new Big(-1) : -1;
+    const vx = Big ? new Big(v.get([0]) / normV) : v.get([0]) / normV;
+    const vy = Big ? new Big(v.get([1]) / normV) : v.get([1]) / normV;
+    const vz = Big ? new Big(v.get([2]) / normV) : v.get([2]) / normV;
+    const c = cos(theta);
+    const oneMinusC = addScalar(one, unaryMinus(c));
+    const s = sin(theta);
+    const r11 = addScalar(c, _mul([vx, vx, oneMinusC]));
+    const r12 = addScalar(_mul([vx, vy, oneMinusC]), _mul([minusOne, vz, s]));
+    const r13 = addScalar(_mul([vx, vz, oneMinusC]), _mul([vy, s]));
+    const r21 = addScalar(_mul([vx, vy, oneMinusC]), _mul([vz, s]));
+    const r22 = addScalar(c, _mul([vy, vy, oneMinusC]));
+    const r23 = addScalar(_mul([vy, vz, oneMinusC]), _mul([minusOne, vx, s]));
+    const r31 = addScalar(_mul([vx, vz, oneMinusC]), _mul([minusOne, vy, s]));
+    const r32 = addScalar(_mul([vy, vz, oneMinusC]), _mul([vx, s]));
+    const r33 = addScalar(c, _mul([vz, vz, oneMinusC]));
+    const data = [[r11, r12, r13], [r21, r22, r23], [r31, r32, r33]];
     return _convertToFormat(data, format);
   }
 });

package/lib/cjs/function/matrix/row.js

@@ -8,13 +8,15 @@ var _factory = require("../../utils/factory.js");
 var _is = require("../../utils/is.js");
 var _object = require("../../utils/object.js");
 var _array = require("../../utils/array.js");
-var name = 'row';
-var dependencies = ['typed', 'Index', 'matrix', 'range'];
-var createRow = exports.createRow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    Index = _ref.Index,
-    matrix = _ref.matrix,
-    range = _ref.range;
+const name = 'row';
+const dependencies = ['typed', 'Index', 'matrix', 'range'];
+const createRow = exports.createRow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    Index,
+    matrix,
+    range
+  } = _ref;
   /**
    * Return a row from a Matrix.
    *
@@ -38,7 +40,7 @@ var createRow = exports.createRow = /* #__PURE__ */(0, _factory.factory)(name, d
    */
   return typed(name, {
     'Matrix, number': _row,
-    'Array, number': function ArrayNumber(value, row) {
+    'Array, number': function (value, row) {
       return _row(matrix((0, _object.clone)(value)), row).valueOf();
     }
   });
@@ -55,9 +57,9 @@ var createRow = exports.createRow = /* #__PURE__ */(0, _factory.factory)(name, d
       throw new Error('Only two dimensional matrix is supported');
     }
     (0, _array.validateIndex)(row, value.size()[0]);
-    var columnRange = range(0, value.size()[1]);
-    var index = new Index(row, columnRange);
-    var result = value.subset(index);
+    const columnRange = range(0, value.size()[1]);
+    const index = new Index(row, columnRange);
+    const result = value.subset(index);
     return (0, _is.isMatrix)(result) ? result : matrix([[result]]);
   }
 });

package/lib/cjs/function/matrix/size.js

@@ -7,12 +7,14 @@ exports.createSize = void 0;
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
 var _noop = require("../../utils/noop.js");
-var name = 'size';
-var dependencies = ['typed', 'config', '?matrix'];
-var createSize = exports.createSize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    config = _ref.config,
-    matrix = _ref.matrix;
+const name = 'size';
+const dependencies = ['typed', 'config', '?matrix'];
+const createSize = exports.createSize = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    config,
+    matrix
+  } = _ref;
   /**
    * Calculate the size of a matrix or scalar.
    *
@@ -37,14 +39,14 @@ var createSize = exports.createSize = /* #__PURE__ */(0, _factory.factory)(name,
    * @return {Array | Matrix} A vector with size of `x`.
    */
   return typed(name, {
-    Matrix: function Matrix(x) {
+    Matrix: function (x) {
       return x.create(x.size());
     },
     Array: _array.arraySize,
-    string: function string(x) {
+    string: function (x) {
       return config.matrix === 'Array' ? [x.length] : matrix([x.length]);
     },
-    'number | Complex | BigNumber | Unit | boolean | null': function numberComplexBigNumberUnitBooleanNull(x) {
+    'number | Complex | BigNumber | Unit | boolean | null': function (x) {
       // scalar
       return config.matrix === 'Array' ? [] : matrix ? matrix([]) : (0, _noop.noMatrix)();
     }

package/lib/cjs/function/matrix/sort.js

@@ -6,17 +6,17 @@ Object.defineProperty(exports, "__esModule", {
 exports.createSort = void 0;
 var _array = require("../../utils/array.js");
 var _factory = require("../../utils/factory.js");
-var name = 'sort';
-var dependencies = ['typed', 'matrix', 'compare', 'compareNatural'];
-var createSort = exports.createSort = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var typed = _ref.typed,
-    matrix = _ref.matrix,
-    compare = _ref.compare,
-    compareNatural = _ref.compareNatural;
-  var compareAsc = compare;
-  var compareDesc = function compareDesc(a, b) {
-    return -compare(a, b);
-  };
+const name = 'sort';
+const dependencies = ['typed', 'matrix', 'compare', 'compareNatural'];
+const createSort = exports.createSort = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    compare,
+    compareNatural
+  } = _ref;
+  const compareAsc = compare;
+  const compareDesc = (a, b) => -compare(a, b);
 
   /**
    * Sort the items in a matrix.
@@ -50,27 +50,27 @@ var createSort = exports.createSort = /* #__PURE__ */(0, _factory.factory)(name,
    * @return {Matrix | Array} Returns the sorted matrix.
    */
   return typed(name, {
-    Array: function Array(x) {
+    Array: function (x) {
       _arrayIsVector(x);
       return x.sort(compareAsc);
     },
-    Matrix: function Matrix(x) {
+    Matrix: function (x) {
       _matrixIsVector(x);
       return matrix(x.toArray().sort(compareAsc), x.storage());
     },
-    'Array, function': function ArrayFunction(x, _comparator) {
+    'Array, function': function (x, _comparator) {
       _arrayIsVector(x);
       return x.sort(_comparator);
     },
-    'Matrix, function': function MatrixFunction(x, _comparator) {
+    'Matrix, function': function (x, _comparator) {
       _matrixIsVector(x);
       return matrix(x.toArray().sort(_comparator), x.storage());
     },
-    'Array, string': function ArrayString(x, order) {
+    'Array, string': function (x, order) {
       _arrayIsVector(x);
       return x.sort(_comparator(order));
     },
-    'Matrix, string': function MatrixString(x, order) {
+    'Matrix, string': function (x, order) {
       _matrixIsVector(x);
       return matrix(x.toArray().sort(_comparator(order)), x.storage());
     }