mathjs 8.1.0 → 12.2.1

package/lib/esm/function/statistics/prod.js

@@ -3,17 +3,16 @@ import { factory } from '../../utils/factory.js';
 import { improveErrorMessage } from './utils/improveErrorMessage.js';
 var name = 'prod';
 var dependencies = ['typed', 'config', 'multiplyScalar', 'numeric'];
-export var createProd = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createProd = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
     multiplyScalar,
     numeric
   } = _ref;
-
   /**
    * Compute the product of a matrix or a list with values.
-   * In case of a (multi dimensional) array or matrix, the sum of all
+   * In case of a multidimensional array or matrix, the sum of all
    * elements will be calculated.
    *
    * Syntax:
@@ -42,20 +41,21 @@ export var createProd = /* #__PURE__ */factory(name, dependencies, (_ref) => {
     // prod([a, b, c, d, ...], dim)
     'Array | Matrix, number | BigNumber': function ArrayMatrixNumberBigNumber(array, dim) {
       // TODO: implement prod(A, dim)
-      throw new Error('prod(A, dim) is not yet supported'); // return reduce(arguments[0], arguments[1], math.prod)
+      throw new Error('prod(A, dim) is not yet supported');
+      // return reduce(arguments[0], arguments[1], math.prod)
     },
     // prod(a, b, c, d, ...)
     '...': function _(args) {
       return _prod(args);
     }
   });
+
   /**
    * Recursively calculate the product of an n-dimensional array
    * @param {Array} array
    * @return {number} prod
    * @private
    */
-
   function _prod(array) {
     var prod;
     deepForEach(array, function (value) {
@@ -64,16 +64,15 @@ export var createProd = /* #__PURE__ */factory(name, dependencies, (_ref) => {
       } catch (err) {
         throw improveErrorMessage(err, 'prod', value);
       }
-    }); // make sure returning numeric value: parse a string into a numeric value
+    });
 
+    // make sure returning numeric value: parse a string into a numeric value
     if (typeof prod === 'string') {
       prod = numeric(prod, config.number);
     }
-
     if (prod === undefined) {
       throw new Error('Cannot calculate prod of an empty array');
     }
-
     return prod;
   }
 });

package/lib/esm/function/statistics/quantileSeq.js

@@ -1,17 +1,28 @@
-import { isBigNumber, isCollection, isNumber } from '../../utils/is.js';
-import { isInteger } from '../../utils/number.js';
+import { isNumber } from '../../utils/is.js';
 import { flatten } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
+import { createApply } from '../matrix/apply.js';
 var name = 'quantileSeq';
-var dependencies = ['typed', 'add', 'multiply', 'partitionSelect', 'compare'];
-export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+var dependencies = ['typed', '?bignumber', 'add', 'subtract', 'divide', 'multiply', 'partitionSelect', 'compare', 'isInteger', 'smaller', 'smallerEq', 'larger'];
+export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
+    bignumber,
     add,
+    subtract,
+    divide,
     multiply,
     partitionSelect,
-    compare
+    compare,
+    isInteger,
+    smaller,
+    smallerEq,
+    larger
   } = _ref;
+  var apply = createApply({
+    typed,
+    isInteger
+  });
 
   /**
    * Compute the prob order quantile of a matrix or a list with values.
@@ -19,7 +30,7 @@ export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, (_ref)
    * Supported types of sequence values are: Number, BigNumber, Unit
    * Supported types of probability are: Number, BigNumber
    *
-   * In case of a (multi dimensional) array or matrix, the prob order quantile
+   * In case of a multidimensional array or matrix, the prob order quantile
    * of all elements will be calculated.
    *
    * Syntax:
@@ -47,121 +58,71 @@ export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, (_ref)
    * @param {Boolean} sorted=false              is data sorted in ascending order
    * @return {Number, BigNumber, Unit, Array}   Quantile(s)
    */
-  function quantileSeq(data, probOrN, sorted) {
-    var probArr, dataArr, one;
-
-    if (arguments.length < 2 || arguments.length > 3) {
-      throw new SyntaxError('Function quantileSeq requires two or three parameters');
+  return typed(name, {
+    'Array | Matrix, number | BigNumber': (data, p) => _quantileSeqProbNumber(data, p, false),
+    'Array | Matrix, number | BigNumber, number': (data, prob, dim) => _quantileSeqDim(data, prob, false, dim, _quantileSeqProbNumber),
+    'Array | Matrix, number | BigNumber, boolean': _quantileSeqProbNumber,
+    'Array | Matrix, number | BigNumber, boolean, number': (data, prob, sorted, dim) => _quantileSeqDim(data, prob, sorted, dim, _quantileSeqProbNumber),
+    'Array | Matrix, Array | Matrix': (data, p) => _quantileSeqProbCollection(data, p, false),
+    'Array | Matrix, Array | Matrix, number': (data, prob, dim) => _quantileSeqDim(data, prob, false, dim, _quantileSeqProbCollection),
+    'Array | Matrix, Array | Matrix, boolean': _quantileSeqProbCollection,
+    'Array | Matrix, Array | Matrix, boolean, number': (data, prob, sorted, dim) => _quantileSeqDim(data, prob, sorted, dim, _quantileSeqProbCollection)
+  });
+  function _quantileSeqDim(data, prob, sorted, dim, fn) {
+    return apply(data, dim, x => fn(x, prob, sorted));
+  }
+  function _quantileSeqProbNumber(data, probOrN, sorted) {
+    var probArr;
+    var dataArr = data.valueOf();
+    if (smaller(probOrN, 0)) {
+      throw new Error('N/prob must be non-negative');
     }
-
-    if (isCollection(data)) {
-      sorted = sorted || false;
-
-      if (typeof sorted === 'boolean') {
-        dataArr = data.valueOf();
-
-        if (isNumber(probOrN)) {
-          if (probOrN < 0) {
-            throw new Error('N/prob must be non-negative');
-          }
-
-          if (probOrN <= 1) {
-            // quantileSeq([a, b, c, d, ...], prob[,sorted])
-            return _quantileSeq(dataArr, probOrN, sorted);
-          }
-
-          if (probOrN > 1) {
-            // quantileSeq([a, b, c, d, ...], N[,sorted])
-            if (!isInteger(probOrN)) {
-              throw new Error('N must be a positive integer');
-            }
-
-            var nPlusOne = probOrN + 1;
-            probArr = new Array(probOrN);
-
-            for (var i = 0; i < probOrN;) {
-              probArr[i] = _quantileSeq(dataArr, ++i / nPlusOne, sorted);
-            }
-
-            return probArr;
-          }
-        }
-
-        if (isBigNumber(probOrN)) {
-          var BigNumber = probOrN.constructor;
-
-          if (probOrN.isNegative()) {
-            throw new Error('N/prob must be non-negative');
-          }
-
-          one = new BigNumber(1);
-
-          if (probOrN.lte(one)) {
-            // quantileSeq([a, b, c, d, ...], prob[,sorted])
-            return new BigNumber(_quantileSeq(dataArr, probOrN, sorted));
-          }
-
-          if (probOrN.gt(one)) {
-            // quantileSeq([a, b, c, d, ...], N[,sorted])
-            if (!probOrN.isInteger()) {
-              throw new Error('N must be a positive integer');
-            } // largest possible Array length is 2^32-1
-            // 2^32 < 10^15, thus safe conversion guaranteed
-
-
-            var intN = probOrN.toNumber();
-
-            if (intN > 4294967295) {
-              throw new Error('N must be less than or equal to 2^32-1, as that is the maximum length of an Array');
-            }
-
-            var _nPlusOne = new BigNumber(intN + 1);
-
-            probArr = new Array(intN);
-
-            for (var _i = 0; _i < intN;) {
-              probArr[_i] = new BigNumber(_quantileSeq(dataArr, new BigNumber(++_i).div(_nPlusOne), sorted));
-            }
-
-            return probArr;
-          }
-        }
-
-        if (Array.isArray(probOrN)) {
-          // quantileSeq([a, b, c, d, ...], [prob1, prob2, ...][,sorted])
-          probArr = new Array(probOrN.length);
-
-          for (var _i2 = 0; _i2 < probArr.length; ++_i2) {
-            var currProb = probOrN[_i2];
-
-            if (isNumber(currProb)) {
-              if (currProb < 0 || currProb > 1) {
-                throw new Error('Probability must be between 0 and 1, inclusive');
-              }
-            } else if (isBigNumber(currProb)) {
-              one = new currProb.constructor(1);
-
-              if (currProb.isNegative() || currProb.gt(one)) {
-                throw new Error('Probability must be between 0 and 1, inclusive');
-              }
-            } else {
-              throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
-            }
-
-            probArr[_i2] = _quantileSeq(dataArr, currProb, sorted);
-          }
-
-          return probArr;
-        }
-
-        throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
+    if (smallerEq(probOrN, 1)) {
+      // quantileSeq([a, b, c, d, ...], prob[,sorted])
+      return isNumber(probOrN) ? _quantileSeq(dataArr, probOrN, sorted) : bignumber(_quantileSeq(dataArr, probOrN, sorted));
+    }
+    if (larger(probOrN, 1)) {
+      // quantileSeq([a, b, c, d, ...], N[,sorted])
+      if (!isInteger(probOrN)) {
+        throw new Error('N must be a positive integer');
       }
 
-      throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
+      // largest possible Array length is 2^32-1
+      // 2^32 < 10^15, thus safe conversion guaranteed
+      if (larger(probOrN, 4294967295)) {
+        throw new Error('N must be less than or equal to 2^32-1, as that is the maximum length of an Array');
+      }
+      var nPlusOne = add(probOrN, 1);
+      probArr = [];
+      for (var i = 0; smaller(i, probOrN); i++) {
+        var prob = divide(i + 1, nPlusOne);
+        probArr.push(_quantileSeq(dataArr, prob, sorted));
+      }
+      return isNumber(probOrN) ? probArr : bignumber(probArr);
     }
+  }
 
-    throw new TypeError('Unexpected type of argument in function quantileSeq'); // FIXME: becomes redundant when converted to typed-function
+  /**
+   * Calculate the prob order quantile of an n-dimensional array.
+   *
+   * @param {Array, Matrix} array
+   * @param {Array, Matrix} prob
+   * @param {Boolean} sorted
+   * @return {Number, BigNumber, Unit} prob order quantile
+   * @private
+   */
+
+  function _quantileSeqProbCollection(data, probOrN, sorted) {
+    var dataArr = data.valueOf();
+    // quantileSeq([a, b, c, d, ...], [prob1, prob2, ...][,sorted])
+    var probOrNArr = probOrN.valueOf();
+    var probArr = [];
+    for (var i = 0; i < probOrNArr.length; ++i) {
+      probArr.push(_quantileSeq(dataArr, probOrNArr[i], sorted));
+    }
+    return probArr;
   }
+
   /**
    * Calculate the prob order quantile of an n-dimensional array.
    *
@@ -171,105 +132,35 @@ export var createQuantileSeq = /* #__PURE__ */factory(name, dependencies, (_ref)
    * @return {Number, BigNumber, Unit} prob order quantile
    * @private
    */
-
-
   function _quantileSeq(array, prob, sorted) {
     var flat = flatten(array);
     var len = flat.length;
-
     if (len === 0) {
       throw new Error('Cannot calculate quantile of an empty sequence');
     }
-
-    if (isNumber(prob)) {
-      var _index = prob * (len - 1);
-
-      var _fracPart = _index % 1;
-
-      if (_fracPart === 0) {
-        var value = sorted ? flat[_index] : partitionSelect(flat, _index);
-        validate(value);
-        return value;
-      }
-
-      var _integerPart = Math.floor(_index);
-
-      var _left;
-
-      var _right;
-
-      if (sorted) {
-        _left = flat[_integerPart];
-        _right = flat[_integerPart + 1];
-      } else {
-        _right = partitionSelect(flat, _integerPart + 1); // max of partition is kth largest
-
-        _left = flat[_integerPart];
-
-        for (var i = 0; i < _integerPart; ++i) {
-          if (compare(flat[i], _left) > 0) {
-            _left = flat[i];
-          }
-        }
-      }
-
-      validate(_left);
-      validate(_right); // Q(prob) = (1-f)*A[floor(index)] + f*A[floor(index)+1]
-
-      return add(multiply(_left, 1 - _fracPart), multiply(_right, _fracPart));
-    } // If prob is a BigNumber
-
-
-    var index = prob.times(len - 1);
-
-    if (index.isInteger()) {
-      index = index.toNumber();
-
-      var _value = sorted ? flat[index] : partitionSelect(flat, index);
-
-      validate(_value);
-      return _value;
+    var index = isNumber(prob) ? prob * (len - 1) : prob.times(len - 1);
+    var integerPart = isNumber(prob) ? Math.floor(index) : index.floor().toNumber();
+    var fracPart = isNumber(prob) ? index % 1 : index.minus(integerPart);
+    if (isInteger(index)) {
+      return sorted ? flat[index] : partitionSelect(flat, isNumber(prob) ? index : index.valueOf());
     }
-
-    var integerPart = index.floor();
-    var fracPart = index.minus(integerPart);
-    var integerPartNumber = integerPart.toNumber();
     var left;
     var right;
-
     if (sorted) {
-      left = flat[integerPartNumber];
-      right = flat[integerPartNumber + 1];
+      left = flat[integerPart];
+      right = flat[integerPart + 1];
     } else {
-      right = partitionSelect(flat, integerPartNumber + 1); // max of partition is kth largest
+      right = partitionSelect(flat, integerPart + 1);
 
-      left = flat[integerPartNumber];
-
-      for (var _i3 = 0; _i3 < integerPartNumber; ++_i3) {
-        if (compare(flat[_i3], left) > 0) {
-          left = flat[_i3];
+      // max of partition is kth largest
+      left = flat[integerPart];
+      for (var i = 0; i < integerPart; ++i) {
+        if (compare(flat[i], left) > 0) {
+          left = flat[i];
         }
       }
     }
-
-    validate(left);
-    validate(right); // Q(prob) = (1-f)*A[floor(index)] + f*A[floor(index)+1]
-
-    var one = new fracPart.constructor(1);
-    return add(multiply(left, one.minus(fracPart)), multiply(right, fracPart));
+    // Q(prob) = (1-f)*A[floor(index)] + f*A[floor(index)+1]
+    return add(multiply(left, subtract(1, fracPart)), multiply(right, fracPart));
   }
-  /**
-   * Check if array value types are valid, throw error otherwise.
-   * @param {number | BigNumber | Unit} x
-   * @param {number | BigNumber | Unit} x
-   * @private
-   */
-
-
-  var validate = typed({
-    'number | BigNumber | Unit': function numberBigNumberUnit(x) {
-      return x;
-    }
-  });
-  return quantileSeq;
 });

package/lib/esm/function/statistics/std.js

@@ -1,13 +1,14 @@
 import { factory } from '../../utils/factory.js';
+import { isCollection } from '../../utils/is.js';
 var name = 'std';
-var dependencies = ['typed', 'sqrt', 'variance'];
-export var createStd = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+var dependencies = ['typed', 'map', 'sqrt', 'variance'];
+export var createStd = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
+    map,
     sqrt,
     variance
   } = _ref;
-
   /**
    * Compute the standard deviation of a matrix or a  list with values.
    * The standard deviations is defined as the square root of the variance:
@@ -74,14 +75,17 @@ export var createStd = /* #__PURE__ */factory(name, dependencies, (_ref) => {
       return _std(args);
     }
   });
-
   function _std(array, normalization) {
     if (array.length === 0) {
       throw new SyntaxError('Function std requires one or more parameters (0 provided)');
     }
-
     try {
-      return sqrt(variance.apply(null, arguments));
+      var v = variance.apply(null, arguments);
+      if (isCollection(v)) {
+        return map(v, sqrt);
+      } else {
+        return sqrt(v);
+      }
     } catch (err) {
       if (err instanceof TypeError && err.message.indexOf(' variance') !== -1) {
         throw new TypeError(err.message.replace(' variance', ' std'));

package/lib/esm/function/statistics/sum.js

@@ -3,23 +3,23 @@ import { factory } from '../../utils/factory.js';
 import { improveErrorMessage } from './utils/improveErrorMessage.js';
 var name = 'sum';
 var dependencies = ['typed', 'config', 'add', 'numeric'];
-export var createSum = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createSum = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     config,
     add,
     numeric
   } = _ref;
-
   /**
    * Compute the sum of a matrix or a list with values.
-   * In case of a (multi dimensional) array or matrix, the sum of all
+   * In case of a multidimensional array or matrix, the sum of all
    * elements will be calculated.
    *
    * Syntax:
    *
    *     math.sum(a, b, c, ...)
    *     math.sum(A)
+   *     math.sum(A, dimension)
    *
    * Examples:
    *
@@ -29,9 +29,9 @@ export var createSum = /* #__PURE__ */factory(name, dependencies, (_ref) => {
    *
    * See also:
    *
-   *    mean, median, min, max, prod, std, variance
+   *    mean, median, min, max, prod, std, variance, cumsum
    *
-   * @param {... *} args  A single matrix or or multiple scalar values
+   * @param {... *} args  A single matrix or multiple scalar values
    * @return {*} The sum of all values
    */
   return typed(name, {
@@ -44,17 +44,16 @@ export var createSum = /* #__PURE__ */factory(name, dependencies, (_ref) => {
       if (containsCollections(args)) {
         throw new TypeError('Scalar values expected in function sum');
       }
-
       return _sum(args);
     }
   });
+
   /**
    * Recursively calculate the sum of an n-dimensional array
    * @param {Array | Matrix} array
    * @return {number} sum
    * @private
    */
-
   function _sum(array) {
     var sum;
     deepForEach(array, function (value) {
@@ -63,19 +62,17 @@ export var createSum = /* #__PURE__ */factory(name, dependencies, (_ref) => {
       } catch (err) {
         throw improveErrorMessage(err, 'sum', value);
       }
-    }); // make sure returning numeric value: parse a string into a numeric value
+    });
 
+    // make sure returning numeric value: parse a string into a numeric value
     if (sum === undefined) {
       sum = numeric(0, config.number);
     }
-
     if (typeof sum === 'string') {
       sum = numeric(sum, config.number);
     }
-
     return sum;
   }
-
   function _nsumDim(array, dim) {
     try {
       var sum = reduce(array, dim, add);

package/lib/esm/function/statistics/utils/improveErrorMessage.js

@@ -1,4 +1,5 @@
 import { typeOf } from '../../../utils/is.js';
+
 /**
  * Improve error messages for statistics functions. Errors are typically
  * thrown in an internally used function like larger, causing the error
@@ -9,20 +10,16 @@ import { typeOf } from '../../../utils/is.js';
  * @param {*} [value]
  * @return {Error}
  */
-
 export function improveErrorMessage(err, fnName, value) {
   // TODO: add information with the index (also needs transform in expression parser)
   var details;
-
   if (String(err).indexOf('Unexpected type') !== -1) {
     details = arguments.length > 2 ? ' (type: ' + typeOf(value) + ', value: ' + JSON.stringify(value) + ')' : ' (type: ' + err.data.actual + ')';
     return new TypeError('Cannot calculate ' + fnName + ', unexpected type of argument' + details);
   }
-
   if (String(err).indexOf('complex numbers') !== -1) {
     details = arguments.length > 2 ? ' (type: ' + typeOf(value) + ', value: ' + JSON.stringify(value) + ')' : '';
     return new TypeError('Cannot calculate ' + fnName + ', no ordering relation is defined for complex numbers' + details);
   }
-
   return err;
 }

package/lib/esm/function/statistics/variance.js

@@ -5,7 +5,7 @@ import { improveErrorMessage } from './utils/improveErrorMessage.js';
 var DEFAULT_NORMALIZATION = 'unbiased';
 var name = 'variance';
 var dependencies = ['typed', 'add', 'subtract', 'multiply', 'divide', 'apply', 'isNaN'];
-export var createVariance = /* #__PURE__ */factory(name, dependencies, (_ref) => {
+export var createVariance = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
     add,
@@ -15,10 +15,9 @@ export var createVariance = /* #__PURE__ */factory(name, dependencies, (_ref) =>
     apply,
     isNaN
   } = _ref;
-
   /**
    * Compute the variance of a matrix or a  list with values.
-   * In case of a (multi dimensional) array or matrix, the variance over all
+   * In case of a multidimensional array or matrix, the variance over all
    * elements will be calculated.
    *
    * Additionally, it is possible to compute the variance along the rows
@@ -87,6 +86,7 @@ export var createVariance = /* #__PURE__ */factory(name, dependencies, (_ref) =>
       return _var(args, DEFAULT_NORMALIZATION);
     }
   });
+
   /**
    * Recursively calculate the variance of an n-dimensional array
    * @param {Array} array
@@ -98,16 +98,14 @@ export var createVariance = /* #__PURE__ */factory(name, dependencies, (_ref) =>
    * @return {number | BigNumber} variance
    * @private
    */
-
   function _var(array, normalization) {
     var sum;
     var num = 0;
-
     if (array.length === 0) {
       throw new SyntaxError('Function variance requires one or more parameters (0 provided)');
-    } // calculate the mean and number of elements
-
+    }
 
+    // calculate the mean and number of elements
     deepForEach(array, function (value) {
       try {
         sum = sum === undefined ? value : add(sum, value);
@@ -117,42 +115,36 @@ export var createVariance = /* #__PURE__ */factory(name, dependencies, (_ref) =>
       }
     });
     if (num === 0) throw new Error('Cannot calculate variance of an empty array');
-    var mean = divide(sum, num); // calculate the variance
+    var mean = divide(sum, num);
 
+    // calculate the variance
     sum = undefined;
     deepForEach(array, function (value) {
       var diff = subtract(value, mean);
       sum = sum === undefined ? multiply(diff, diff) : add(sum, multiply(diff, diff));
     });
-
     if (isNaN(sum)) {
       return sum;
     }
-
     switch (normalization) {
       case 'uncorrected':
         return divide(sum, num);
-
       case 'biased':
         return divide(sum, num + 1);
-
       case 'unbiased':
         {
           var zero = isBigNumber(sum) ? sum.mul(0) : 0;
           return num === 1 ? zero : divide(sum, num - 1);
         }
-
       default:
         throw new Error('Unknown normalization "' + normalization + '". ' + 'Choose "unbiased" (default), "uncorrected", or "biased".');
     }
   }
-
   function _varDim(array, dim, normalization) {
     try {
       if (array.length === 0) {
         throw new SyntaxError('Function variance requires one or more parameters (0 provided)');
       }
-
       return apply(array, dim, x => _var(x, normalization));
     } catch (err) {
       throw improveErrorMessage(err, 'variance');

package/lib/esm/function/string/bin.js

@@ -1,4 +1,7 @@
-import { createBaseFormatterFactory } from './baseUtils.js';
+import { factory } from '../../utils/factory.js';
+var name = 'bin';
+var dependencies = ['typed', 'format'];
+
 /**
  * Format a number as binary.
  *
@@ -17,7 +20,25 @@ import { createBaseFormatterFactory } from './baseUtils.js';
  *    hex
  *
  * @param {number} value    Value to be stringified
+ * @param {number} wordSize Optional word size (see `format`)
  * @return {string}         The formatted value
  */
-
-export var createBin = createBaseFormatterFactory('bin', 2);
+export var createBin = factory(name, dependencies, _ref => {
+  var {
+    typed,
+    format
+  } = _ref;
+  return typed(name, {
+    'number | BigNumber': function numberBigNumber(n) {
+      return format(n, {
+        notation: 'bin'
+      });
+    },
+    'number | BigNumber, number': function numberBigNumberNumber(n, wordSize) {
+      return format(n, {
+        notation: 'bin',
+        wordSize
+      });
+    }
+  });
+});