mathjs 13.0.2 → 13.1.0

package/lib/esm/type/fraction/function/fraction.js

@@ -54,7 +54,7 @@ export var createFraction = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(x) {
       return new Fraction(x);
     },
-    'number, number': function numberNumber(numerator, denominator) {
+    'number, number': function number_number(numerator, denominator) {
       return new Fraction(numerator, denominator);
     },
     null: function _null(x) {

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

@@ -1,11 +1,11 @@
 import { isArray, isBigNumber, isCollection, isIndex, isMatrix, isNumber, isString, typeOf } from '../../utils/is.js';
-import { arraySize, getArrayDataType, processSizesWildcard, reshape, resize, unsqueeze, validate, validateIndex, broadcastTo } from '../../utils/array.js';
+import { arraySize, getArrayDataType, processSizesWildcard, reshape, resize, unsqueeze, validate, validateIndex, broadcastTo, get } from '../../utils/array.js';
 import { format } from '../../utils/string.js';
 import { isInteger } from '../../utils/number.js';
 import { clone, deepStrictEqual } from '../../utils/object.js';
 import { DimensionError } from '../../error/DimensionError.js';
 import { factory } from '../../utils/factory.js';
-import { maxArgumentCount } from '../../utils/function.js';
+import { applyCallback } from '../../utils/applyCallback.js';
 var name = 'DenseMatrix';
 var dependencies = ['Matrix'];
 export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -166,24 +166,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    * @return {*} value
    */
   DenseMatrix.prototype.get = function (index) {
-    if (!isArray(index)) {
-      throw new TypeError('Array expected');
-    }
-    if (index.length !== this._size.length) {
-      throw new DimensionError(index.length, this._size.length);
-    }
-
-    // check index
-    for (var x = 0; x < index.length; x++) {
-      validateIndex(index[x], this._size[x]);
-    }
-    var data = this._data;
-    for (var i = 0, ii = index.length; i < ii; i++) {
-      var indexI = index[i];
-      validateIndex(indexI, data.length);
-      data = data[indexI];
-    }
-    return data;
+    return get(this._data, index);
   };
 
   /**
@@ -546,28 +529,20 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
   DenseMatrix.prototype.map = function (callback) {
     // matrix instance
     var me = this;
-    var args = maxArgumentCount(callback);
-    var recurse = function recurse(value, index) {
+    var _recurse = function recurse(value, index) {
       if (isArray(value)) {
         return value.map(function (child, i) {
-          return recurse(child, index.concat(i));
+          return _recurse(child, index.concat(i));
         });
       } else {
         // invoke the callback function with the right number of arguments
-        if (args === 1) {
-          return callback(value);
-        } else if (args === 2) {
-          return callback(value, index);
-        } else {
-          // 3 or -1
-          return callback(value, index, me);
-        }
+        return applyCallback(callback, value, index, me, 'map');
       }
     };
 
     // 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 data = _recurse(this._data, []);
     var datatype = this._datatype !== undefined ? getArrayDataType(data, typeOf) : undefined;
     return new DenseMatrix(data, datatype);
   };
@@ -582,16 +557,16 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
   DenseMatrix.prototype.forEach = function (callback) {
     // matrix instance
     var me = this;
-    var recurse = function recurse(value, index) {
+    var _recurse2 = function recurse(value, index) {
       if (isArray(value)) {
         value.forEach(function (child, i) {
-          recurse(child, index.concat(i));
+          _recurse2(child, index.concat(i));
         });
       } else {
         callback(value, index, me);
       }
     };
-    recurse(this._data, []);
+    _recurse2(this._data, []);
   };
 
   /**
@@ -599,10 +574,10 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
    * @return {Iterable<{ value, index: number[] }>}
    */
   DenseMatrix.prototype[Symbol.iterator] = function* () {
-    var recurse = function* recurse(value, index) {
+    var _recurse3 = function* recurse(value, index) {
       if (isArray(value)) {
         for (var i = 0; i < value.length; i++) {
-          yield* recurse(value[i], index.concat(i));
+          yield* _recurse3(value[i], index.concat(i));
         }
       } else {
         yield {
@@ -611,7 +586,7 @@ export var createDenseMatrixClass = /* #__PURE__ */factory(name, dependencies, _
         };
       }
     };
-    yield* recurse(this._data, []);
+    yield* _recurse3(this._data, []);
   };
 
   /**

package/lib/esm/type/matrix/SparseMatrix.js

@@ -5,7 +5,7 @@ import { clone, deepStrictEqual } from '../../utils/object.js';
 import { arraySize, getArrayDataType, processSizesWildcard, unsqueeze, validateIndex } from '../../utils/array.js';
 import { factory } from '../../utils/factory.js';
 import { DimensionError } from '../../error/DimensionError.js';
-import { maxArgumentCount } from '../../utils/function.js';
+import { applyCallback } from '../../utils/applyCallback.js';
 var name = 'SparseMatrix';
 var dependencies = ['typed', 'equalScalar', 'Matrix'];
 export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies, _ref => {
@@ -873,12 +873,9 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     var rows = this._size[0];
     var columns = this._size[1];
     // invoke callback
-    var args = maxArgumentCount(callback);
     var invoke = function invoke(v, i, j) {
       // invoke callback
-      if (args === 1) return callback(v);
-      if (args === 2) return callback(v, [i, j]);
-      return callback(v, [i, j], me);
+      return applyCallback(callback, v, [i, j], me, 'map');
     };
     // invoke _map
     return _map(this, 0, rows - 1, 0, columns - 1, invoke, skipZeros);
@@ -908,11 +905,11 @@ export var createSparseMatrixClass = /* #__PURE__ */factory(name, dependencies,
     // invoke callback
     var invoke = function invoke(v, x, y) {
       // invoke callback
-      v = callback(v, x, y);
+      var value = callback(v, x, y);
       // check value != 0
-      if (!eq(v, zero)) {
+      if (!eq(value, zero)) {
         // store value
-        values.push(v);
+        values.push(value);
         // index
         index.push(x);
       }

package/lib/esm/type/matrix/function/index.js

@@ -43,7 +43,7 @@ export var createIndex = /* #__PURE__ */factory(name, dependencies, _ref => {
    * @return {Index}        Returns the created index
    */
   return typed(name, {
-    '...number | string | BigNumber | Range | Array | Matrix': function numberStringBigNumberRangeArrayMatrix(args) {
+    '...number | string | BigNumber | Range | Array | Matrix': function number__string__BigNumber__Range__Array__Matrix(args) {
       var ranges = args.map(function (arg) {
         if (isBigNumber(arg)) {
           return arg.toNumber(); // convert BigNumber to Number

package/lib/esm/type/matrix/function/matrix.js

@@ -48,7 +48,7 @@ export var createMatrix = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(format) {
       return _create([], format);
     },
-    'string, string': function stringString(format, datatype) {
+    'string, string': function string_string(format, datatype) {
       return _create([], format, datatype);
     },
     Array: function Array(data) {

package/lib/esm/type/matrix/function/sparse.js

@@ -46,10 +46,10 @@ export var createSparse = /* #__PURE__ */factory(name, dependencies, _ref => {
     string: function string(datatype) {
       return new SparseMatrix([], datatype);
     },
-    'Array | Matrix': function ArrayMatrix(data) {
+    'Array | Matrix': function Array__Matrix(data) {
       return new SparseMatrix(data);
     },
-    'Array | Matrix, string': function ArrayMatrixString(data, datatype) {
+    'Array | Matrix, string': function Array__Matrix_string(data, datatype) {
       return new SparseMatrix(data, datatype);
     }
   });

package/lib/esm/type/number.js

@@ -132,7 +132,7 @@ export var createNumber = /* #__PURE__ */factory(name, dependencies, _ref => {
     null: function _null(x) {
       return 0;
     },
-    'Unit, string | Unit': function UnitStringUnit(unit, valuelessUnit) {
+    'Unit, string | Unit': function Unit_string__Unit(unit, valuelessUnit) {
       return unit.toNumber(valuelessUnit);
     },
     'Array | Matrix': typed.referToSelf(self => x => deepMap(x, self))

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

@@ -426,7 +426,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    * Return the type of the value of this unit
    *
    * @memberof Unit
-   * @ return {string} type of the value of the unit
+   * @return {string} type of the value of the unit
    */
   Unit.prototype.valueType = function () {
     return typeOf(this.value);
@@ -436,6 +436,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    * Return whether the unit is derived (such as m/s, or cm^2, but not N)
    * @memberof Unit
    * @return {boolean} True if the unit is derived
+   * @private
    */
   Unit.prototype._isDerived = function () {
     if (this.units.length === 0) {
@@ -548,7 +549,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    * check if this unit has given base unit
    * If this unit is a derived unit, this will ALWAYS return false, since by definition base units are not derived.
    * @memberof Unit
-   * @param {BASE_UNITS | string | undefined} base
+   * @param {BASE_UNIT | string | undefined} base
    */
   Unit.prototype.hasBase = function (base) {
     if (typeof base === 'string') {
@@ -2316,34 +2317,34 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       name: 'minim',
       base: BASE_UNITS.VOLUME,
       prefixes: PREFIXES.NONE,
-      value: 0.00000006161152,
+      value: 0.000000061611519921875,
       offset: 0
     },
-    // 0.06161152 mL
+    // 1/61440 gallons
     fluiddram: {
       name: 'fluiddram',
       base: BASE_UNITS.VOLUME,
       prefixes: PREFIXES.NONE,
-      value: 0.0000036966911,
+      value: 0.0000036966911953125,
       offset: 0
     },
-    // 3.696691 mL
+    // 1/1024 gallons
     fluidounce: {
       name: 'fluidounce',
       base: BASE_UNITS.VOLUME,
       prefixes: PREFIXES.NONE,
-      value: 0.00002957353,
+      value: 0.0000295735295625,
       offset: 0
     },
-    // 29.57353 mL
+    // 1/128 gallons
     gill: {
       name: 'gill',
       base: BASE_UNITS.VOLUME,
       prefixes: PREFIXES.NONE,
-      value: 0.0001182941,
+      value: 0.00011829411825,
       offset: 0
     },
-    // 118.2941 mL
+    // 1/32 gallons
     cc: {
       name: 'cc',
       base: BASE_UNITS.VOLUME,
@@ -2356,133 +2357,58 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
       name: 'cup',
       base: BASE_UNITS.VOLUME,
       prefixes: PREFIXES.NONE,
-      value: 0.0002365882,
+      value: 0.0002365882365,
       offset: 0
     },
-    // 236.5882 mL
+    // 1/16 gallons
     pint: {
       name: 'pint',
       base: BASE_UNITS.VOLUME,
       prefixes: PREFIXES.NONE,
-      value: 0.0004731765,
+      value: 0.000473176473,
       offset: 0
     },
-    // 473.1765 mL
+    // 1/8 gallons
     quart: {
       name: 'quart',
       base: BASE_UNITS.VOLUME,
       prefixes: PREFIXES.NONE,
-      value: 0.0009463529,
+      value: 0.000946352946,
       offset: 0
     },
-    // 946.3529 mL
+    // 1/4 gallons
     gallon: {
       name: 'gallon',
       base: BASE_UNITS.VOLUME,
       prefixes: PREFIXES.NONE,
-      value: 0.003785412,
+      value: 0.003785411784,
       offset: 0
     },
-    // 3.785412 L
+    // 3.785411784 L
     beerbarrel: {
       name: 'beerbarrel',
       base: BASE_UNITS.VOLUME,
       prefixes: PREFIXES.NONE,
-      value: 0.1173478,
+      value: 0.117347765304,
       offset: 0
     },
-    // 117.3478 L
+    // 31 gallons
     oilbarrel: {
       name: 'oilbarrel',
       base: BASE_UNITS.VOLUME,
       prefixes: PREFIXES.NONE,
-      value: 0.1589873,
+      value: 0.158987294928,
       offset: 0
     },
-    // 158.9873 L
+    // 42 gallons
     hogshead: {
       name: 'hogshead',
       base: BASE_UNITS.VOLUME,
       prefixes: PREFIXES.NONE,
-      value: 0.2384810,
+      value: 0.238480942392,
       offset: 0
     },
-    // 238.4810 L
-
-    // {name: 'min', base: BASE_UNITS.VOLUME, prefixes: PREFIXES.NONE, value: 0.00000006161152, offset: 0}, // 0.06161152 mL // min is already in use as minute
-    fldr: {
-      name: 'fldr',
-      base: BASE_UNITS.VOLUME,
-      prefixes: PREFIXES.NONE,
-      value: 0.0000036966911,
-      offset: 0
-    },
-    // 3.696691 mL
-    floz: {
-      name: 'floz',
-      base: BASE_UNITS.VOLUME,
-      prefixes: PREFIXES.NONE,
-      value: 0.00002957353,
-      offset: 0
-    },
-    // 29.57353 mL
-    gi: {
-      name: 'gi',
-      base: BASE_UNITS.VOLUME,
-      prefixes: PREFIXES.NONE,
-      value: 0.0001182941,
-      offset: 0
-    },
-    // 118.2941 mL
-    cp: {
-      name: 'cp',
-      base: BASE_UNITS.VOLUME,
-      prefixes: PREFIXES.NONE,
-      value: 0.0002365882,
-      offset: 0
-    },
-    // 236.5882 mL
-    pt: {
-      name: 'pt',
-      base: BASE_UNITS.VOLUME,
-      prefixes: PREFIXES.NONE,
-      value: 0.0004731765,
-      offset: 0
-    },
-    // 473.1765 mL
-    qt: {
-      name: 'qt',
-      base: BASE_UNITS.VOLUME,
-      prefixes: PREFIXES.NONE,
-      value: 0.0009463529,
-      offset: 0
-    },
-    // 946.3529 mL
-    gal: {
-      name: 'gal',
-      base: BASE_UNITS.VOLUME,
-      prefixes: PREFIXES.NONE,
-      value: 0.003785412,
-      offset: 0
-    },
-    // 3.785412 L
-    bbl: {
-      name: 'bbl',
-      base: BASE_UNITS.VOLUME,
-      prefixes: PREFIXES.NONE,
-      value: 0.1173478,
-      offset: 0
-    },
-    // 117.3478 L
-    obl: {
-      name: 'obl',
-      base: BASE_UNITS.VOLUME,
-      prefixes: PREFIXES.NONE,
-      value: 0.1589873,
-      offset: 0
-    },
-    // 158.9873 L
-    // {name: 'hogshead', base: BASE_UNITS.VOLUME, prefixes: PREFIXES.NONE, value: 0.2384810, offset: 0}, // 238.4810 L // TODO: hh?
+    // 63 gallons
 
     // Mass
     g: {
@@ -3286,14 +3212,23 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
     teaspoons: 'teaspoon',
     tablespoons: 'tablespoon',
     minims: 'minim',
+    fldr: 'fluiddram',
     fluiddrams: 'fluiddram',
+    floz: 'fluidounce',
     fluidounces: 'fluidounce',
+    gi: 'gill',
     gills: 'gill',
+    cp: 'cup',
     cups: 'cup',
+    pt: 'pint',
     pints: 'pint',
+    qt: 'quart',
     quarts: 'quart',
+    gal: 'gallon',
     gallons: 'gallon',
+    bbl: 'beerbarrel',
     beerbarrels: 'beerbarrel',
+    obl: 'oilbarrel',
     oilbarrels: 'oilbarrel',
     hogsheads: 'hogshead',
     gtts: 'gtt',
@@ -3566,6 +3501,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
 
   /**
    * Set a unit system for formatting derived units.
+   * @memberof Unit
    * @param {string} [name] The name of the unit system.
    */
   Unit.setUnitSystem = function (name) {
@@ -3578,6 +3514,7 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
 
   /**
    * Return the current unit system.
+   * @memberof Unit
    * @return {string} The current unit system.
    */
   Unit.getUnitSystem = function () {
@@ -3667,7 +3604,9 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
   /**
    * Checks if a character is a valid latin letter (upper or lower case).
    * Note that this function can be overridden, for example to allow support of other alphabets.
+   * @memberof Unit
    * @param {string} c Tested character
+   * @return {boolean} true if the character is a latin letter
    */
   Unit.isValidAlpha = function isValidAlpha(c) {
     return /^[a-zA-Z]$/.test(c);
@@ -3687,20 +3626,24 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
   /**
    * Wrapper around createUnitSingle.
    * Example:
-   *  createUnit({
-   *    foo: { },
-   *    bar: {
-   *      definition: 'kg/foo',
-   *      aliases: ['ba', 'barr', 'bars'],
-   *      offset: 200
-   *    },
-   *    baz: '4 bar'
-   *  },
-   *  {
-   *    override: true
-   *  })
+   *  createUnit( {
+   *     foo: {
+   *       prefixes: 'long',
+   *       baseName: 'essence-of-foo'
+   *     },
+   *     bar: '40 foo',
+   *     baz: {
+   *       definition: '1 bar/hour',
+   *       prefixes: 'long'
+   *     }
+   *   },
+   *   {
+   *     override: true
+   *   })
+   * @memberof Unit
    * @param {object} obj      Object map. Each key becomes a unit which is defined by its value.
    * @param {object} options
+   * @return {Unit} the last created unit
    */
   Unit.createUnit = function (obj, options) {
     if (typeof obj !== 'object') {
@@ -3735,13 +3678,13 @@ export var createUnitClass = /* #__PURE__ */factory(name, dependencies, _ref =>
    * Create a user-defined unit and register it with the Unit type.
    * Example:
    *  createUnitSingle('knot', '0.514444444 m/s')
-   *  createUnitSingle('acre', new Unit(43560, 'ft^2'))
    *
+   * @memberof Unit
    * @param {string} name      The name of the new unit. Must be unique. Example: 'knot'
-   * @param {string, Unit, Object} definition      Definition of the unit in terms
+   * @param {string | Unit | object} definition      Definition of the unit in terms
    * of existing units. For example, '0.514444444 m / s'. Can be a Unit, a string,
    * or an Object. If an Object, may have the following properties:
-   *   - definition {string|Unit} The definition of this unit.
+   *   - definition {string | Unit} The definition of this unit.
    *   - prefixes {string} "none", "short", "long", "binary_short", or "binary_long".
    *     The default is "none".
    *   - aliases {Array} Array of strings. Example: ['knots', 'kt', 'kts']

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

@@ -50,7 +50,7 @@ export var createCreateUnit = /* #__PURE__ */factory(name, dependencies, _ref =>
    */
   return typed(name, {
     // General function signature. First parameter is an object where each property is the definition of a new unit. The object keys are the unit names and the values are the definitions. The values can be objects, strings, or Units. If a property is an empty object or an empty string, a new base unit is created. The second parameter is the options.
-    'Object, Object': function ObjectObject(obj, options) {
+    'Object, Object': function Object_Object(obj, options) {
       return Unit.createUnit(obj, options);
     },
     // Same as above but without the options.
@@ -58,13 +58,13 @@ export var createCreateUnit = /* #__PURE__ */factory(name, dependencies, _ref =>
       return Unit.createUnit(obj, {});
     },
     // Shortcut method for creating one unit.
-    'string, Unit | string | Object, Object': function stringUnitStringObjectObject(name, def, options) {
+    'string, Unit | string | Object, Object': function string_Unit__string__Object_Object(name, def, options) {
       var obj = {};
       obj[name] = def;
       return Unit.createUnit(obj, options);
     },
     // Same as above but without the options.
-    'string, Unit | string | Object': function stringUnitStringObject(name, def) {
+    'string, Unit | string | Object': function string_Unit__string__Object(name, def) {
       var obj = {};
       obj[name] = def;
       return Unit.createUnit(obj, {});

package/lib/esm/type/unit/function/splitUnit.js

@@ -25,7 +25,7 @@ export var createSplitUnit = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @return {Array} An array of units.
    */
   return typed(name, {
-    'Unit, Array': function UnitArray(unit, parts) {
+    'Unit, Array': function Unit_Array(unit, parts) {
       return unit.splitUnit(parts);
     }
   });

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

@@ -48,10 +48,10 @@ export var createUnitFunction = /* #__PURE__ */factory(name, dependencies, _ref
         allowNoUnits: true
       }); // a unit with value, like '5cm'
     },
-    'number | BigNumber | Fraction | Complex, string | Unit': function numberBigNumberFractionComplexStringUnit(value, unit) {
+    'number | BigNumber | Fraction | Complex, string | Unit': function number__BigNumber__Fraction__Complex_string__Unit(value, unit) {
       return new Unit(value, unit);
     },
-    'number | BigNumber | Fraction': function numberBigNumberFraction(value) {
+    'number | BigNumber | Fraction': function number__BigNumber__Fraction(value) {
       // dimensionless
       return new Unit(value);
     },

package/lib/esm/utils/array.js

@@ -780,6 +780,32 @@ export function stretch(arrayToStretch, sizeToStretch, dimToStretch) {
   return concat(...Array(sizeToStretch).fill(arrayToStretch), dimToStretch);
 }
 
+/**
+* Retrieves a single element from an array given an index.
+*
+* @param {Array} array - The array from which to retrieve the value.
+* @param {Array<number>} idx - An array of indices specifying the position of the desired element in each dimension.
+* @returns {*} - The value at the specified position in the array.
+*
+* @example
+* const arr = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]];
+* const index = [1, 0, 1];
+* console.log(getValue(arr, index)); // 6
+*/
+export function get(array, index) {
+  if (!Array.isArray(array)) {
+    throw new Error('Array expected');
+  }
+  var size = arraySize(array);
+  if (index.length !== size.length) {
+    throw new DimensionError(index.length, size.length);
+  }
+  for (var x = 0; x < index.length; x++) {
+    validateIndex(index[x], size[x]);
+  }
+  return index.reduce((acc, curr) => acc[curr], array);
+}
+
 /**
  * Deep clones a multidimensional array
  * @param {Array} array

package/lib/esm/utils/collection.js

@@ -78,7 +78,7 @@ export function reduce(mat, dim, callback) {
     throw new IndexError(dim, size.length);
   }
   if (isMatrix(mat)) {
-    return mat.create(_reduce(mat.valueOf(), dim, callback));
+    return mat.create(_reduce(mat.valueOf(), dim, callback), mat.datatype());
   } else {
     return _reduce(mat, dim, callback);
   }

package/lib/esm/utils/function.js

@@ -83,17 +83,4 @@ export function memoizeCompare(fn, isEqual) {
   };
   memoize.cache = [];
   return memoize;
-}
-
-/**
- * Find the maximum number of arguments expected by a typed function.
- * @param {function} fn   A typed function
- * @return {number} Returns the maximum number of expected arguments.
- *                  Returns -1 when no signatures where found on the function.
- */
-export function maxArgumentCount(fn) {
-  return Object.keys(fn.signatures || {}).reduce(function (args, signature) {
-    var count = (signature.match(/,/g) || []).length + 1;
-    return Math.max(args, count);
-  }, -1);
 }