projet/node_modules/accepts/LICENSE

+(The MIT License)
+
+Copyright (c) 2014 Jonathan Ong <me@jongleberry.com>
+Copyright (c) 2015 Douglas Christopher Wilson <doug@somethingdoug.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

projet/node_modules/accepts/README.md

+# accepts
+
+[![NPM Version][npm-version-image]][npm-url]
+[![NPM Downloads][npm-downloads-image]][npm-url]
+[![Node.js Version][node-version-image]][node-version-url]
+[![Build Status][travis-image]][travis-url]
+[![Test Coverage][coveralls-image]][coveralls-url]
+
+Higher level content negotiation based on [negotiator](https://www.npmjs.com/package/negotiator).
+Extracted from [koa](https://www.npmjs.com/package/koa) for general use.
+
+In addition to negotiator, it allows:
+
+- Allows types as an array or arguments list, ie `(['text/html', 'application/json'])`
+  as well as `('text/html', 'application/json')`.
+- Allows type shorthands such as `json`.
+- Returns `false` when no types match
+- Treats non-existent headers as `*`
+
+## Installation
+
+This is a [Node.js](https://nodejs.org/en/) module available through the
+[npm registry](https://www.npmjs.com/). Installation is done using the
+[`npm install` command](https://docs.npmjs.com/getting-started/installing-npm-packages-locally):
+
+```sh
+$ npm install accepts
+```
+
+## API
+
+<!-- eslint-disable no-unused-vars -->
+
+```js
+var accepts = require('accepts')
+```
+
+### accepts(req)
+
+Create a new `Accepts` object for the given `req`.
+
+#### .charset(charsets)
+
+Return the first accepted charset. If nothing in `charsets` is accepted,
+then `false` is returned.
+
+#### .charsets()
+
+Return the charsets that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .encoding(encodings)
+
+Return the first accepted encoding. If nothing in `encodings` is accepted,
+then `false` is returned.
+
+#### .encodings()
+
+Return the encodings that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .language(languages)
+
+Return the first accepted language. If nothing in `languages` is accepted,
+then `false` is returned.
+
+#### .languages()
+
+Return the languages that the request accepts, in the order of the client's
+preference (most preferred first).
+
+#### .type(types)
+
+Return the first accepted type (and it is returned as the same text as what
+appears in the `types` array). If nothing in `types` is accepted, then `false`
+is returned.
+
+The `types` array can contain full MIME types or file extensions. Any value
+that is not a full MIME types is passed to `require('mime-types').lookup`.
+
+#### .types()
+
+Return the types that the request accepts, in the order of the client's
+preference (most preferred first).
+
+## Examples
+
+### Simple type negotiation
+
+This simple example shows how to use `accepts` to return a different typed
+respond body based on what the client wants to accept. The server lists it's
+preferences in order and will get back the best match between the client and
+server.
+
+```js
+var accepts = require('accepts')
+var http = require('http')
+
+function app (req, res) {
+  var accept = accepts(req)
+
+  // the order of this list is significant; should be server preferred order
+  switch (accept.type(['json', 'html'])) {
+    case 'json':
+      res.setHeader('Content-Type', 'application/json')
+      res.write('{"hello":"world!"}')
+      break
+    case 'html':
+      res.setHeader('Content-Type', 'text/html')
+      res.write('<b>hello, world!</b>')
+      break
+    default:
+      // the fallback is text/plain, so no need to specify it above
+      res.setHeader('Content-Type', 'text/plain')
+      res.write('hello, world!')
+      break
+  }
+
+  res.end()
+}
+
+http.createServer(app).listen(3000)
+```
+
+You can test this out with the cURL program:
+```sh
+curl -I -H'Accept: text/html' http://localhost:3000/
+```
+
+## License
+
+[MIT](LICENSE)
+
+[coveralls-image]: https://badgen.net/coveralls/c/github/jshttp/accepts/master
+[coveralls-url]: https://coveralls.io/r/jshttp/accepts?branch=master
+[node-version-image]: https://badgen.net/npm/node/accepts
+[node-version-url]: https://nodejs.org/en/download
+[npm-downloads-image]: https://badgen.net/npm/dm/accepts
+[npm-url]: https://npmjs.org/package/accepts
+[npm-version-image]: https://badgen.net/npm/v/accepts
+[travis-image]: https://badgen.net/travis/jshttp/accepts/master
+[travis-url]: https://travis-ci.org/jshttp/accepts

projet/node_modules/accepts/index.js

+/*!
+ * accepts
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+'use strict'
+
+/**
+ * Module dependencies.
+ * @private
+ */
+
+var Negotiator = require('negotiator')
+var mime = require('mime-types')
+
+/**
+ * Module exports.
+ * @public
+ */
+
+module.exports = Accepts
+
+/**
+ * Create a new Accepts object for the given req.
+ *
+ * @param {object} req
+ * @public
+ */
+
+function Accepts (req) {
+  if (!(this instanceof Accepts)) {
+    return new Accepts(req)
+  }
+
+  this.headers = req.headers
+  this.negotiator = new Negotiator(req)
+}
+
+/**
+ * Check if the given `type(s)` is acceptable, returning
+ * the best match when true, otherwise `undefined`, in which
+ * case you should respond with 406 "Not Acceptable".
+ *
+ * The `type` value may be a single mime type string
+ * such as "application/json", the extension name
+ * such as "json" or an array `["json", "html", "text/plain"]`. When a list
+ * or array is given the _best_ match, if any is returned.
+ *
+ * Examples:
+ *
+ *     // Accept: text/html
+ *     this.types('html');
+ *     // => "html"
+ *
+ *     // Accept: text/*, application/json
+ *     this.types('html');
+ *     // => "html"
+ *     this.types('text/html');
+ *     // => "text/html"
+ *     this.types('json', 'text');
+ *     // => "json"
+ *     this.types('application/json');
+ *     // => "application/json"
+ *
+ *     // Accept: text/*, application/json
+ *     this.types('image/png');
+ *     this.types('png');
+ *     // => undefined
+ *
+ *     // Accept: text/*;q=.5, application/json
+ *     this.types(['html', 'json']);
+ *     this.types('html', 'json');
+ *     // => "json"
+ *
+ * @param {String|Array} types...
+ * @return {String|Array|Boolean}
+ * @public
+ */
+
+Accepts.prototype.type =
+Accepts.prototype.types = function (types_) {
+  var types = types_
+
+  // support flattened arguments
+  if (types && !Array.isArray(types)) {
+    types = new Array(arguments.length)
+    for (var i = 0; i < types.length; i++) {
+      types[i] = arguments[i]
+    }
+  }
+
+  // no types, return all requested types
+  if (!types || types.length === 0) {
+    return this.negotiator.mediaTypes()
+  }
+
+  // no accept header, return first given type
+  if (!this.headers.accept) {
+    return types[0]
+  }
+
+  var mimes = types.map(extToMime)
+  var accepts = this.negotiator.mediaTypes(mimes.filter(validMime))
+  var first = accepts[0]
+
+  return first
+    ? types[mimes.indexOf(first)]
+    : false
+}
+
+/**
+ * Return accepted encodings or best fit based on `encodings`.
+ *
+ * Given `Accept-Encoding: gzip, deflate`
+ * an array sorted by quality is returned:
+ *
+ *     ['gzip', 'deflate']
+ *
+ * @param {String|Array} encodings...
+ * @return {String|Array}
+ * @public
+ */
+
+Accepts.prototype.encoding =
+Accepts.prototype.encodings = function (encodings_) {
+  var encodings = encodings_
+
+  // support flattened arguments
+  if (encodings && !Array.isArray(encodings)) {
+    encodings = new Array(arguments.length)
+    for (var i = 0; i < encodings.length; i++) {
+      encodings[i] = arguments[i]
+    }
+  }
+
+  // no encodings, return all requested encodings
+  if (!encodings || encodings.length === 0) {
+    return this.negotiator.encodings()
+  }
+
+  return this.negotiator.encodings(encodings)[0] || false
+}
+
+/**
+ * Return accepted charsets or best fit based on `charsets`.
+ *
+ * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+ * an array sorted by quality is returned:
+ *
+ *     ['utf-8', 'utf-7', 'iso-8859-1']
+ *
+ * @param {String|Array} charsets...
+ * @return {String|Array}
+ * @public
+ */
+
+Accepts.prototype.charset =
+Accepts.prototype.charsets = function (charsets_) {
+  var charsets = charsets_
+
+  // support flattened arguments
+  if (charsets && !Array.isArray(charsets)) {
+    charsets = new Array(arguments.length)
+    for (var i = 0; i < charsets.length; i++) {
+      charsets[i] = arguments[i]
+    }
+  }
+
+  // no charsets, return all requested charsets
+  if (!charsets || charsets.length === 0) {
+    return this.negotiator.charsets()
+  }
+
+  return this.negotiator.charsets(charsets)[0] || false
+}
+
+/**
+ * Return accepted languages or best fit based on `langs`.
+ *
+ * Given `Accept-Language: en;q=0.8, es, pt`
+ * an array sorted by quality is returned:
+ *
+ *     ['es', 'pt', 'en']
+ *
+ * @param {String|Array} langs...
+ * @return {Array|String}
+ * @public
+ */
+
+Accepts.prototype.lang =
+Accepts.prototype.langs =
+Accepts.prototype.language =
+Accepts.prototype.languages = function (languages_) {
+  var languages = languages_
+
+  // support flattened arguments
+  if (languages && !Array.isArray(languages)) {
+    languages = new Array(arguments.length)
+    for (var i = 0; i < languages.length; i++) {
+      languages[i] = arguments[i]
+    }
+  }
+
+  // no languages, return all requested languages
+  if (!languages || languages.length === 0) {
+    return this.negotiator.languages()
+  }
+
+  return this.negotiator.languages(languages)[0] || false
+}
+
+/**
+ * Convert extnames to mime.
+ *
+ * @param {String} type
+ * @return {String}
+ * @private
+ */
+
+function extToMime (type) {
+  return type.indexOf('/') === -1
+    ? mime.lookup(type)
+    : type
+}
+
+/**
+ * Check if mime is valid.
+ *
+ * @param {String} type
+ * @return {String}
+ * @private
+ */
+
+function validMime (type) {
+  return typeof type === 'string'
+}

projet/node_modules/accepts/package.json

+{
+  "_args": [
+    [
+      "accepts@1.3.7",
+      "/Users/klaus/Documents/Web/Back/2019_tp2/projet"
+    ]
+  ],
+  "_from": "accepts@1.3.7",
+  "_id": "accepts@1.3.7",
+  "_inBundle": false,
+  "_integrity": "sha512-Il80Qs2WjYlJIBNzNkK6KYqlVMTbZLXgHx2oT0pU/fjRHyEp+PEfEPY0R3WCwAGVOtauxh1hOxNgIf5bv7dQpA==",
+  "_location": "/accepts",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "accepts@1.3.7",
+    "name": "accepts",
+    "escapedName": "accepts",
+    "rawSpec": "1.3.7",
+    "saveSpec": null,
+    "fetchSpec": "1.3.7"
+  },
+  "_requiredBy": [
+    "/express"
+  ],
+  "_resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.7.tgz",
+  "_spec": "1.3.7",
+  "_where": "/Users/klaus/Documents/Web/Back/2019_tp2/projet",
+  "bugs": {
+    "url": "https://github.com/jshttp/accepts/issues"
+  },
+  "contributors": [
+    {
+      "name": "Douglas Christopher Wilson",
+      "email": "doug@somethingdoug.com"
+    },
+    {
+      "name": "Jonathan Ong",
+      "email": "me@jongleberry.com",
+      "url": "http://jongleberry.com"
+    }
+  ],
+  "dependencies": {
+    "mime-types": "~2.1.24",
+    "negotiator": "0.6.2"
+  },
+  "description": "Higher-level content negotiation",
+  "devDependencies": {
+    "deep-equal": "1.0.1",
+    "eslint": "5.16.0",
+    "eslint-config-standard": "12.0.0",
+    "eslint-plugin-import": "2.17.2",
+    "eslint-plugin-markdown": "1.0.0",
+    "eslint-plugin-node": "8.0.1",
+    "eslint-plugin-promise": "4.1.1",
+    "eslint-plugin-standard": "4.0.0",
+    "mocha": "6.1.4",
+    "nyc": "14.0.0"
+  },
+  "engines": {
+    "node": ">= 0.6"
+  },
+  "files": [
+    "LICENSE",
+    "HISTORY.md",
+    "index.js"
+  ],
+  "homepage": "https://github.com/jshttp/accepts#readme",
+  "keywords": [
+    "content",
+    "negotiation",
+    "accept",
+    "accepts"
+  ],
+  "license": "MIT",
+  "name": "accepts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jshttp/accepts.git"
+  },
+  "scripts": {
+    "lint": "eslint --plugin markdown --ext js,md .",
+    "test": "mocha --reporter spec --check-leaks --bail test/",
+    "test-cov": "nyc --reporter=html --reporter=text npm test",
+    "test-travis": "nyc --reporter=text npm test"
+  },
+  "version": "1.3.7"
+}

projet/node_modules/array-flatten/LICENSE

+The MIT License (MIT)
+
+Copyright (c) 2014 Blake Embrey (hello@blakeembrey.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

projet/node_modules/array-flatten/README.md

+# Array Flatten
+
+[![NPM version][npm-image]][npm-url]
+[![NPM downloads][downloads-image]][downloads-url]
+[![Build status][travis-image]][travis-url]
+[![Test coverage][coveralls-image]][coveralls-url]
+
+> Flatten an array of nested arrays into a single flat array. Accepts an optional depth.
+
+## Installation
+
+```
+npm install array-flatten --save
+```
+
+## Usage
+
+```javascript
+var flatten = require('array-flatten')
+
+flatten([1, [2, [3, [4, [5], 6], 7], 8], 9])
+//=> [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+flatten([1, [2, [3, [4, [5], 6], 7], 8], 9], 2)
+//=> [1, 2, 3, [4, [5], 6], 7, 8, 9]
+
+(function () {
+  flatten(arguments) //=> [1, 2, 3]
+})(1, [2, 3])
+```
+
+## License
+
+MIT
+
+[npm-image]: https://img.shields.io/npm/v/array-flatten.svg?style=flat
+[npm-url]: https://npmjs.org/package/array-flatten
+[downloads-image]: https://img.shields.io/npm/dm/array-flatten.svg?style=flat
+[downloads-url]: https://npmjs.org/package/array-flatten
+[travis-image]: https://img.shields.io/travis/blakeembrey/array-flatten.svg?style=flat
+[travis-url]: https://travis-ci.org/blakeembrey/array-flatten
+[coveralls-image]: https://img.shields.io/coveralls/blakeembrey/array-flatten.svg?style=flat
+[coveralls-url]: https://coveralls.io/r/blakeembrey/array-flatten?branch=master

projet/node_modules/array-flatten/array-flatten.js

+'use strict'
+
+/**
+ * Expose `arrayFlatten`.
+ */
+module.exports = arrayFlatten
+
+/**
+ * Recursive flatten function with depth.
+ *
+ * @param  {Array}  array
+ * @param  {Array}  result
+ * @param  {Number} depth
+ * @return {Array}
+ */
+function flattenWithDepth (array, result, depth) {
+  for (var i = 0; i < array.length; i++) {
+    var value = array[i]
+
+    if (depth > 0 && Array.isArray(value)) {
+      flattenWithDepth(value, result, depth - 1)
+    } else {
+      result.push(value)
+    }
+  }
+
+  return result
+}
+
+/**
+ * Recursive flatten function. Omitting depth is slightly faster.
+ *
+ * @param  {Array} array
+ * @param  {Array} result
+ * @return {Array}
+ */
+function flattenForever (array, result) {
+  for (var i = 0; i < array.length; i++) {
+    var value = array[i]
+
+    if (Array.isArray(value)) {
+      flattenForever(value, result)
+    } else {
+      result.push(value)
+    }
+  }
+
+  return result
+}
+
+/**
+ * Flatten an array, with the ability to define a depth.
+ *
+ * @param  {Array}  array
+ * @param  {Number} depth
+ * @return {Array}
+ */
+function arrayFlatten (array, depth) {
+  if (depth == null) {
+    return flattenForever(array, [])
+  }
+
+  return flattenWithDepth(array, [], depth)
+}

projet/node_modules/array-flatten/package.json

+{
+  "_args": [
+    [
+      "array-flatten@1.1.1",
+      "/Users/klaus/Documents/Web/Back/2019_tp2/projet"
+    ]
+  ],
+  "_from": "array-flatten@1.1.1",
+  "_id": "array-flatten@1.1.1",
+  "_inBundle": false,
+  "_integrity": "sha1-ml9pkFGx5wczKPKgCJaLZOopVdI=",
+  "_location": "/array-flatten",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "array-flatten@1.1.1",
+    "name": "array-flatten",
+    "escapedName": "array-flatten",
+    "rawSpec": "1.1.1",
+    "saveSpec": null,
+    "fetchSpec": "1.1.1"
+  },
+  "_requiredBy": [
+    "/express"
+  ],
+  "_resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+  "_spec": "1.1.1",
+  "_where": "/Users/klaus/Documents/Web/Back/2019_tp2/projet",
+  "author": {
+    "name": "Blake Embrey",
+    "email": "hello@blakeembrey.com",
+    "url": "http://blakeembrey.me"
+  },
+  "bugs": {
+    "url": "https://github.com/blakeembrey/array-flatten/issues"
+  },
+  "description": "Flatten an array of nested arrays into a single flat array",
+  "devDependencies": {
+    "istanbul": "^0.3.13",
+    "mocha": "^2.2.4",
+    "pre-commit": "^1.0.7",
+    "standard": "^3.7.3"
+  },
+  "files": [
+    "array-flatten.js",
+    "LICENSE"
+  ],
+  "homepage": "https://github.com/blakeembrey/array-flatten",
+  "keywords": [
+    "array",
+    "flatten",
+    "arguments",
+    "depth"
+  ],
+  "license": "MIT",
+  "main": "array-flatten.js",
+  "name": "array-flatten",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/blakeembrey/array-flatten.git"
+  },
+  "scripts": {
+    "test": "istanbul cover _mocha -- -R spec"
+  },
+  "version": "1.1.1"
+}

projet/node_modules/bignumber.js/CHANGELOG.md

+#### 7.2.1
+* 24/05/2018
+* Add `browser` field to *package.json*.
+
+#### 7.2.0
+* 22/05/2018
+* #166 Correct *.mjs* file. Remove extension from `main` field in *package.json*.
+
+#### 7.1.0
+* 18/05/2018
+* Add `module` field to *package.json* for *bignumber.mjs*.
+
+#### 7.0.2
+* 17/05/2018
+* #165 Bugfix: upper-case letters for bases 11-36 in a custom alphabet.
+* Add note to *README* regarding creating BigNumbers from Number values.
+
+#### 7.0.1
+* 26/04/2018
+* #158 Fix global object variable name typo.
+
+#### 7.0.0
+* 26/04/2018
+* #143 Remove global BigNumber from typings.
+* #144 Enable compatibility with `Object.freeze(Object.prototype)`.
+* #148 #123 #11 Only throw on a number primitive with more than 15 significant digits if `BigNumber.DEBUG` is `true`.
+* Only throw on an invalid BigNumber value if `BigNumber.DEBUG` is `true`. Return BigNumber `NaN` instead.
+* #154 `exponentiatedBy`: allow BigNumber exponent.
+* #156 Prevent Content Security Policy *unsafe-eval* issue.
+* `toFraction`: allow `Infinity` maximum denominator.
+* Comment-out some excess tests to reduce test time.
+* Amend indentation and other spacing.
+
+#### 6.0.0
+* 26/01/2018
+* #137 Implement `APLHABET` configuration option.
+* Remove `ERRORS` configuration option.
+* Remove `toDigits` method; extend `precision` method accordingly.
+* Remove s`round` method; extend `decimalPlaces` method accordingly.
+* Remove methods: `ceil`, `floor`, and `truncated`.
+* Remove method aliases: `add`, `cmp`, `isInt`, `isNeg`, `trunc`, `mul`, `neg` and `sub`.
+* Rename methods: `shift` to `shiftedBy`, `another` to `clone`, `toPower` to `exponentiatedBy`, and `equals` to `isEqualTo`.
+* Rename methods: add `is` prefix to `greaterThan`, `greaterThanOrEqualTo`, `lessThan` and `lessThanOrEqualTo`.
+* Add methods: `multipliedBy`, `isBigNumber`, `isPositive`, `integerValue`, `maximum` and `minimum`.
+* Refactor test suite.
+* Add *CHANGELOG.md*.
+* Rewrite *bignumber.d.ts*.
+* Redo API image.
+
+#### 5.0.0
+* 27/11/2017
+* #81 Don't throw on constructor call without `new`.
+
+#### 4.1.0
+* 26/09/2017
+* Remove node 0.6 from *.travis.yml*.
+* Add *bignumber.mjs*.
+
+#### 4.0.4
+* 03/09/2017
+* Add missing aliases to *bignumber.d.ts*.
+
+#### 4.0.3
+* 30/08/2017
+* Add types: *bignumber.d.ts*.
+
+#### 4.0.2
+* 03/05/2017
+* #120 Workaround Safari/Webkit bug.
+
+#### 4.0.1
+* 05/04/2017
+* #121 BigNumber.default to BigNumber['default'].
+
+#### 4.0.0
+* 09/01/2017
+* Replace BigNumber.isBigNumber method with isBigNumber prototype property.
+
+#### 3.1.2
+* 08/01/2017
+* Minor documentation edit.
+
+#### 3.1.1
+* 08/01/2017
+* Uncomment `isBigNumber` tests.
+* Ignore dot files.
+
+#### 3.1.0
+* 08/01/2017
+* Add `isBigNumber` method.
+
+#### 3.0.2
+* 08/01/2017
+* Bugfix: Possible incorrect value of `ERRORS` after a `BigNumber.another` call (due to `parseNumeric` declaration in outer scope).
+
+#### 3.0.1
+* 23/11/2016
+* Apply fix for old ipads with `%` issue, see #57 and #102.
+* Correct error message.
+
+#### 3.0.0
+* 09/11/2016
+* Remove `require('crypto')` - leave it to the user.
+* Add `BigNumber.set` as `BigNumber.config` alias.
+* Default `POW_PRECISION` to `0`.
+
+#### 2.4.0
+* 14/07/2016
+* #97 Add exports to support ES6 imports.
+
+#### 2.3.0
+* 07/03/2016
+* #86 Add modulus parameter to `toPower`.
+
+#### 2.2.0
+* 03/03/2016
+* #91 Permit larger JS integers.
+
+#### 2.1.4
+* 15/12/2015
+* Correct UMD.
+
+#### 2.1.3
+* 13/12/2015
+* Refactor re global object and crypto availability when bundling.
+
+#### 2.1.2
+* 10/12/2015
+* Bugfix: `window.crypto` not assigned to `crypto`.
+
+#### 2.1.1
+* 09/12/2015
+* Prevent code bundler from adding `crypto` shim.
+
+#### 2.1.0
+* 26/10/2015
+* For `valueOf` and `toJSON`, include the minus sign with negative zero.
+
+#### 2.0.8
+* 2/10/2015
+* Internal round function bugfix.
+
+#### 2.0.6
+* 31/03/2015
+* Add bower.json. Tweak division after in-depth review.
+
+#### 2.0.5
+* 25/03/2015
+* Amend README. Remove bitcoin address.
+
+#### 2.0.4
+* 25/03/2015
+* Critical bugfix #58: division.
+
+#### 2.0.3
+* 18/02/2015
+* Amend README. Add source map.
+
+#### 2.0.2
+* 18/02/2015
+* Correct links.
+
+#### 2.0.1
+* 18/02/2015
+* Add `max`, `min`, `precision`, `random`, `shiftedBy`, `toDigits` and `truncated` methods.
+* Add the short-forms: `add`, `mul`, `sd`, `sub` and `trunc`.
+* Add an `another` method to enable multiple independent constructors to be created.
+* Add support for the base 2, 8 and 16 prefixes `0b`, `0o` and `0x`.
+* Enable a rounding mode to be specified as a second parameter to `toExponential`, `toFixed`, `toFormat` and `toPrecision`.
+* Add a `CRYPTO` configuration property so cryptographically-secure pseudo-random number generation can be specified.
+* Add a `MODULO_MODE` configuration property to enable the rounding mode used by the `modulo` operation to be specified.
+* Add a `POW_PRECISION` configuration property to enable the number of significant digits calculated by the power operation to be limited.
+* Improve code quality.
+* Improve documentation.
+
+#### 2.0.0
+* 29/12/2014
+* Add `dividedToIntegerBy`, `isInteger` and `toFormat` methods.
+* Remove the following short-forms: `isF`, `isZ`, `toE`, `toF`, `toFr`, `toN`, `toP`, `toS`.
+* Store a BigNumber's coefficient in base 1e14, rather than base 10.
+* Add fast path for integers to BigNumber constructor.
+* Incorporate the library into the online documentation.
+
+#### 1.5.0
+* 13/11/2014
+* Add `toJSON` and `decimalPlaces` methods.
+
+#### 1.4.1
+* 08/06/2014
+* Amend README.
+
+#### 1.4.0
+* 08/05/2014
+* Add `toNumber`.
+
+#### 1.3.0
+* 08/11/2013
+* Ensure correct rounding of `sqrt` in all, rather than almost all, cases.
+* Maximum radix to 64.
+
+#### 1.2.1
+* 17/10/2013
+* Sign of zero when x < 0 and x + (-x) = 0.
+
+#### 1.2.0
+* 19/9/2013
+* Throw Error objects for stack.
+
+#### 1.1.1
+* 22/8/2013
+* Show original value in constructor error message.
+
+#### 1.1.0
+* 1/8/2013
+* Allow numbers with trailing radix point.
+
+#### 1.0.1
+* Bugfix: error messages with incorrect method name
+
+#### 1.0.0
+* 8/11/2012
+* Initial release

projet/node_modules/bignumber.js/LICENCE

+The MIT Licence.
+
+Copyright (c) 2018 Michael Mclaughlin
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

projet/node_modules/bignumber.js/README.md

+![bignumber.js](https://raw.githubusercontent.com/MikeMcl/bignumber.js/gh-pages/bignumberjs.png)
+
+A JavaScript library for arbitrary-precision decimal and non-decimal arithmetic.
+
+[![Build Status](https://travis-ci.org/MikeMcl/bignumber.js.svg)](https://travis-ci.org/MikeMcl/bignumber.js)
+
+<br />
+
+## Features
+
+  - Integers and decimals
+  - Simple API but full-featured
+  - Faster, smaller, and perhaps easier to use than JavaScript versions of Java's BigDecimal
+  - 8 KB minified and gzipped
+  - Replicates the `toExponential`, `toFixed`, `toPrecision` and `toString` methods of JavaScript's Number type
+  - Includes a `toFraction` and a correctly-rounded `squareRoot` method
+  - Supports cryptographically-secure pseudo-random number generation
+  - No dependencies
+  - Wide platform compatibility: uses JavaScript 1.5 (ECMAScript 3) features only
+  - Comprehensive [documentation](http://mikemcl.github.io/bignumber.js/) and test set
+
+![API](https://raw.githubusercontent.com/MikeMcl/bignumber.js/gh-pages/API.png)
+
+If a smaller and simpler library is required see [big.js](https://github.com/MikeMcl/big.js/).
+It's less than half the size but only works with decimal numbers and only has half the methods.
+It also does not allow `NaN` or `Infinity`, or have the configuration options of this library.
+
+See also [decimal.js](https://github.com/MikeMcl/decimal.js/), which among other things adds support for non-integer powers, and performs all operations to a specified number of significant digits.
+
+## Load
+
+The library is the single JavaScript file *bignumber.js* (or minified, *bignumber.min.js*).
+
+Browser:
+
+```html
+<script src='path/to/bignumber.js'></script>
+```
+
+[Node.js](http://nodejs.org):
+
+```bash
+$ npm install --save bignumber.js
+```
+
+```javascript
+var BigNumber = require('bignumber.js');
+```
+
+ES6 module (*bignumber.mjs*):
+
+```javascript
+//import BigNumber from 'bignumber.js';
+import {BigNumber} from 'bignumber.js';
+```
+
+AMD loader libraries such as [requireJS](http://requirejs.org/):
+
+```javascript
+require(['bignumber'], function(BigNumber) {
+    // Use BigNumber here in local scope. No global BigNumber.
+});
+```
+
+## Use
+
+*In all examples below, `var`, semicolons and `toString` calls are not shown.
+If a commented-out value is in quotes it means `toString` has been called on the preceding expression.*
+
+The library exports a single function: `BigNumber`, the constructor of BigNumber instances.
+
+It accepts a value of type Number, String or BigNumber,
+
+```javascript
+x = new BigNumber(123.4567)
+y = BigNumber('123456.7e-3')
+z = new BigNumber(x)
+x.isEqualTo(y) && y.isEqualTo(z) && x.isEqualTo(z)      // true
+```
+
+and a base can be specified.
+
+```javascript
+a = new BigNumber(1011, 2)          // "11"
+b = new BigNumber('zz.9', 36)       // "1295.25"
+c = x.plus(y)                       // "1306.25"
+```
+
+Note that a BigNumber is created from a Number's decimal `toString()` value not from its underlying binary value. If the latter is required, then pass the Number's `toString(2)` value and specify base 2.
+
+```javascript
+new BigNumber(Number.MAX_VALUE.toString(2), 2)
+``` 
+
+If the limited precision of Number values is not well understood, **it is recommended to pass String values rather than Number values** to avoid a potential loss of precision.
+
+```javascript
+// Precision loss from using numeric literals with more than 15 significant digits.   
+new BigNumber(1.0000000000000001);                 // '1'
+new BigNumber(88259496234518.57);                  // '88259496234518.56'
+new BigNumber(99999999999999999999);               // '100000000000000000000'
+
+// Precision loss from using numeric literals outside the range of Number values.
+new BigNumber(2e+308);                             // 'Infinity'
+new BigNumber(1e-324);                             // '0'
+
+// Precision loss from the unexpected result of arithmetic with Number values.
+new BigNumber(0.7 + 0.1);                          // '0.7999999999999999' 
+```
+
+A BigNumber is immutable in the sense that it is not changed by its methods.
+
+```javascript
+0.3 - 0.1                           // 0.19999999999999998
+x = new BigNumber(0.3)
+x.minus(0.1)                        // "0.2"
+x                                   // "0.3"
+```
+
+The methods that return a BigNumber can be chained.
+
+```javascript
+x.dividedBy(y).plus(z).times(9)
+x.times('1.23456780123456789e+9').plus(9876.5432321).dividedBy('4444562598.111772').integerValue()
+```
+
+Some of the longer method names have a shorter alias.
+
+```javascript
+x.squareRoot().dividedBy(y).exponentiatedBy(3).isEqualTo( x.sqrt().div(y).pow(3) )    // true
+x.modulo(y).multipliedBy(z).eq( x.mod(y).times(z) )                                   // true
+```
+
+As with JavaScript's Number type, there are `toExponential`, `toFixed` and `toPrecision` methods
+
+```javascript
+x = new BigNumber(255.5)
+x.toExponential(5)                  // "2.55500e+2"
+x.toFixed(5)                        // "255.50000"
+x.toPrecision(5)                    // "255.50"
+x.toNumber()                        //  255.5
+```
+
+ and a base can be specified for `toString`.
+
+ ```javascript
+ x.toString(16)                     // "ff.8"
+ ```
+
+There is also a `toFormat` method which may be useful for internationalisation
+
+```javascript
+y = new BigNumber('1234567.898765')
+y.toFormat(2)                       // "1,234,567.90"
+```
+
+The maximum number of decimal places of the result of an operation involving division (i.e. a division, square root, base conversion or negative power operation) is set using the `config` method of the `BigNumber` constructor.
+
+The other arithmetic operations always give the exact result.
+
+```javascript
+BigNumber.config({ DECIMAL_PLACES: 10, ROUNDING_MODE: 4 })
+
+x = new BigNumber(2);
+y = new BigNumber(3);
+z = x.dividedBy(y)                        // "0.6666666667"
+z.squareRoot()                            // "0.8164965809"
+z.exponentiatedBy(-3)                     // "3.3749999995"
+z.toString(2)                             // "0.1010101011"
+z.multipliedBy(z)                         // "0.44444444448888888889"
+z.multipliedBy(z).decimalPlaces(10)       // "0.4444444445"
+```
+
+There is a `toFraction` method with an optional *maximum denominator* argument
+
+```javascript
+y = new BigNumber(355)
+pi = y.dividedBy(113)               // "3.1415929204"
+pi.toFraction()                     // [ "7853982301", "2500000000" ]
+pi.toFraction(1000)                 // [ "355", "113" ]
+```
+
+and `isNaN` and `isFinite` methods, as `NaN` and `Infinity` are valid `BigNumber` values.
+
+```javascript
+x = new BigNumber(NaN)                                           // "NaN"
+y = new BigNumber(Infinity)                                      // "Infinity"
+x.isNaN() && !y.isNaN() && !x.isFinite() && !y.isFinite()        // true
+```
+
+The value of a BigNumber is stored in a decimal floating point format in terms of a coefficient, exponent and sign.
+
+```javascript
+x = new BigNumber(-123.456);
+x.c                                 // [ 123, 45600000000000 ]  coefficient (i.e. significand)
+x.e                                 // 2                        exponent
+x.s                                 // -1                       sign
+```
+
+For advanced usage, multiple BigNumber constructors can be created, each with their own independent configuration which applies to all BigNumber's created from it.
+
+```javascript
+// Set DECIMAL_PLACES for the original BigNumber constructor
+BigNumber.config({ DECIMAL_PLACES: 10 })
+
+// Create another BigNumber constructor, optionally passing in a configuration object
+BN = BigNumber.clone({ DECIMAL_PLACES: 5 })
+
+x = new BigNumber(1)
+y = new BN(1)
+
+x.div(3)                            // '0.3333333333'
+y.div(3)                            // '0.33333'
+```
+
+For futher information see the [API](http://mikemcl.github.io/bignumber.js/) reference in the *doc* directory.
+
+## Test
+
+The *test/modules* directory contains the test scripts for each method.
+
+The tests can be run with Node.js or a browser. For Node.js use
+
+    $ npm test
+
+or
+
+    $ node test/test
+
+To test a single method, use, for example
+
+    $ node test/methods/toFraction
+
+For the browser, open *test/test.html*.
+
+## Performance
+
+See the [README](https://github.com/MikeMcl/bignumber.js/tree/master/perf) in the *perf* directory.
+
+## Build
+
+For Node, if [uglify-js](https://github.com/mishoo/UglifyJS2) is installed
+
+    npm install uglify-js -g
+
+then
+
+    npm run build
+
+will create *bignumber.min.js*.
+
+A source map will also be created in the root directory.
+
+## Feedback
+
+Open an issue, or email
+
+Michael
+
+<a href="mailto:M8ch88l@gmail.com">M8ch88l@gmail.com</a>
+
+## Licence
+
+The MIT Licence.
+
+See [LICENCE](https://github.com/MikeMcl/bignumber.js/blob/master/LICENCE).

projet/node_modules/bignumber.js/bignumber.d.ts

+// Type definitions for bignumber.js >=6.0.0
+// Project: https://github.com/MikeMcl/bignumber.js
+// Definitions by: Michael Mclaughlin <https://github.com/MikeMcl>
+// Definitions: https://github.com/MikeMcl/bignumber.js
+
+// Documentation: http://mikemcl.github.io/bignumber.js/
+//
+// Exports:
+//
+//   class     BigNumber (default export)
+//   type      BigNumber.Constructor
+//   type      BigNumber.Instance
+//   type      BigNumber.ModuloMode
+//   type      BigNumber.RoundingMOde
+//   type      BigNumber.Value
+//   interface BigNumber.Config
+//   interface BigNumber.Format
+//
+// Example (alternative syntax commented-out):
+//
+//   import {BigNumber} from "bignumber.js"
+//   //import BigNumber from "bignumber.js"
+//
+//   let rm: BigNumber.RoundingMode = BigNumber.ROUND_UP;
+//   let f: BigNumber.Format = { decimalSeparator: ',' };
+//   let c: BigNumber.Config = { DECIMAL_PLACES: 4, ROUNDING_MODE: rm, FORMAT: f };
+//   BigNumber.config(c);
+//
+//   let v: BigNumber.Value = '12345.6789';
+//   let b: BigNumber = new BigNumber(v);
+//   //let b: BigNumber.Instance = new BigNumber(v);
+//
+// The use of compiler option `--strictNullChecks` is recommended.
+
+export default BigNumber;
+
+export namespace BigNumber {
+
+  /**
+   * See `BigNumber.config` and `BigNumber.clone`.
+   */
+  export interface Config {
+
+    /**
+     * An integer, 0 to 1e+9. Default value: 20.
+     *
+     * The maximum number of decimal places of the result of operations involving division, i.e.
+     * division, square root and base conversion operations, and exponentiation when the exponent is
+     * negative.
+     *
+     * ```ts
+     * BigNumber.config({ DECIMAL_PLACES: 5 })
+     * BigNumber.set({ DECIMAL_PLACES: 5 })
+     * ```
+     */
+    DECIMAL_PLACES?: number;
+
+    /**
+     * An integer, 0 to 8. Default value: `BigNumber.ROUND_HALF_UP` (4).
+     *
+     * The rounding mode used in operations that involve division (see `DECIMAL_PLACES`) and the
+     * default rounding mode of the `decimalPlaces`, `precision`, `toExponential`, `toFixed`,
+     * `toFormat` and `toPrecision` methods.
+     *
+     * The modes are available as enumerated properties of the BigNumber constructor.
+     *
+     * ```ts
+     * BigNumber.config({ ROUNDING_MODE: 0 })
+     * BigNumber.set({ ROUNDING_MODE: BigNumber.ROUND_UP })
+     * ```
+     */
+    ROUNDING_MODE?: BigNumber.RoundingMode;
+
+    /**
+     * An integer, 0 to 1e+9, or an array, [-1e+9 to 0, 0 to 1e+9].
+     * Default value: `[-7, 20]`.
+     *
+     * The exponent value(s) at which `toString` returns exponential notation.
+     *
+     * If a single number is assigned, the value is the exponent magnitude.
+     *
+     * If an array of two numbers is assigned then the first number is the negative exponent value at
+     * and beneath which exponential notation is used, and the second number is the positive exponent
+     * value at and above which exponential notation is used.
+     *
+     * For example, to emulate JavaScript numbers in terms of the exponent values at which they begin
+     * to use exponential notation, use `[-7, 20]`.
+     *
+     * ```ts
+     * BigNumber.config({ EXPONENTIAL_AT: 2 })
+     * new BigNumber(12.3)         // '12.3'        e is only 1
+     * new BigNumber(123)          // '1.23e+2'
+     * new BigNumber(0.123)        // '0.123'       e is only -1
+     * new BigNumber(0.0123)       // '1.23e-2'
+     *
+     * BigNumber.config({ EXPONENTIAL_AT: [-7, 20] })
+     * new BigNumber(123456789)    // '123456789'   e is only 8
+     * new BigNumber(0.000000123)  // '1.23e-7'
+     *
+     * // Almost never return exponential notation:
+     * BigNumber.config({ EXPONENTIAL_AT: 1e+9 })
+     *
+     * // Always return exponential notation:
+     * BigNumber.config({ EXPONENTIAL_AT: 0 })
+     * ```
+     *
+     * Regardless of the value of `EXPONENTIAL_AT`, the `toFixed` method will always return a value in
+     * normal notation and the `toExponential` method will always return a value in exponential form.
+     * Calling `toString` with a base argument, e.g. `toString(10)`, will also always return normal
+     * notation.
+     */
+    EXPONENTIAL_AT?: number|[number, number];
+
+    /**
+     * An integer, magnitude 1 to 1e+9, or an array, [-1e+9 to -1, 1 to 1e+9].
+     * Default value: `[-1e+9, 1e+9]`.
+     *
+     * The exponent value(s) beyond which overflow to Infinity and underflow to zero occurs.
+     *
+     * If a single number is assigned, it is the maximum exponent magnitude: values wth a positive
+     * exponent of greater magnitude become Infinity and those with a negative exponent of greater
+     * magnitude become zero.
+     *
+     * If an array of two numbers is assigned then the first number is the negative exponent limit and
+     * the second number is the positive exponent limit.
+     *
+     * For example, to emulate JavaScript numbers in terms of the exponent values at which they
+     * become zero and Infinity, use [-324, 308].
+     *
+     * ```ts
+     * BigNumber.config({ RANGE: 500 })
+     * BigNumber.config().RANGE     // [ -500, 500 ]
+     * new BigNumber('9.999e499')   // '9.999e+499'
+     * new BigNumber('1e500')       // 'Infinity'
+     * new BigNumber('1e-499')      // '1e-499'
+     * new BigNumber('1e-500')      // '0'
+     *
+     * BigNumber.config({ RANGE: [-3, 4] })
+     * new BigNumber(99999)         // '99999'      e is only 4
+     * new BigNumber(100000)        // 'Infinity'   e is 5
+     * new BigNumber(0.001)         // '0.01'       e is only -3
+     * new BigNumber(0.0001)        // '0'          e is -4
+     * ```
+     * The largest possible magnitude of a finite BigNumber is 9.999...e+1000000000.
+     * The smallest possible magnitude of a non-zero BigNumber is 1e-1000000000.
+     */
+    RANGE?: number|[number, number];
+
+    /**
+     * A boolean: `true` or `false`. Default value: `false`.
+     *
+     * The value that determines whether cryptographically-secure pseudo-random number generation is
+     * used. If `CRYPTO` is set to true then the random method will generate random digits using
+     * `crypto.getRandomValues` in browsers that support it, or `crypto.randomBytes` if using a
+     * version of Node.js that supports it.
+     *
+     * If neither function is supported by the host environment then attempting to set `CRYPTO` to
+     * `true` will fail and an exception will be thrown.
+     *
+     * If `CRYPTO` is `false` then the source of randomness used will be `Math.random` (which is
+     * assumed to generate at least 30 bits of randomness).
+     *
+     * See `BigNumber.random`.
+     *
+     * ```ts
+     * BigNumber.config({ CRYPTO: true })
+     * BigNumber.config().CRYPTO       // true
+     * BigNumber.random()              // 0.54340758610486147524
+     * ```
+     */
+    CRYPTO?: boolean;
+
+    /**
+     * An integer, 0, 1, 3, 6 or 9. Default value: `BigNumber.ROUND_DOWN` (1).
+     *
+     * The modulo mode used when calculating the modulus: `a mod n`.
+     * The quotient, `q = a / n`, is calculated according to the `ROUNDING_MODE` that corresponds to
+     * the chosen `MODULO_MODE`.
+     * The remainder, `r`, is calculated as: `r = a - n * q`.
+     *
+     * The modes that are most commonly used for the modulus/remainder operation are shown in the
+     * following table. Although the other rounding modes can be used, they may not give useful
+     * results.
+     *
+     * Property           | Value | Description
+     * :------------------|:------|:------------------------------------------------------------------
+     *  `ROUND_UP`        |   0   | The remainder is positive if the dividend is negative.
+     *  `ROUND_DOWN`      |   1   | The remainder has the same sign as the dividend.
+     *                    |       | Uses 'truncating division' and matches JavaScript's `%` operator .
+     *  `ROUND_FLOOR`     |   3   | The remainder has the same sign as the divisor.
+     *                    |       | This matches Python's `%` operator.
+     *  `ROUND_HALF_EVEN` |   6   | The IEEE 754 remainder function.
+     *  `EUCLID`          |   9   | The remainder is always positive.
+     *                    |       | Euclidian division: `q = sign(n) * floor(a / abs(n))`
+     *
+     * The rounding/modulo modes are available as enumerated properties of the BigNumber constructor.
+     *
+     * See `modulo`.
+     *
+     * ```ts
+     * BigNumber.config({ MODULO_MODE: BigNumber.EUCLID })
+     * BigNumber.set({ MODULO_MODE: 9 })          // equivalent
+     * ```
+     */
+    MODULO_MODE?: BigNumber.ModuloMode;
+
+    /**
+     * An integer, 0 to 1e+9. Default value: 0.
+     *
+     * The maximum precision, i.e. number of significant digits, of the result of the power operation
+     * - unless a modulus is specified.
+     *
+     * If set to 0, the number of significant digits will not be limited.
+     *
+     * See `exponentiatedBy`.
+     *
+     * ```ts
+     * BigNumber.config({ POW_PRECISION: 100 })
+     * ```
+     */
+    POW_PRECISION?: number;
+
+    /**
+     * An object including any number of the properties shown below.
+     *
+     * The object configures the format of the string returned by the `toFormat` method.
+     * The example below shows the properties of the object that are recognised, and
+     * their default values.
+     *
+     * Unlike the other configuration properties, the values of the properties of the `FORMAT` object
+     * will not be checked for validity - the existing object will simply be replaced by the object
+     * that is passed in.
+     *
+     * See `toFormat`.
+     *
+     * ```ts
+     * BigNumber.config({
+     *   FORMAT: {
+     *     // the decimal separator
+     *     decimalSeparator: '.',
+     *     // the grouping separator of the integer part
+     *     groupSeparator: ',',
+     *     // the primary grouping size of the integer part
+     *     groupSize: 3,
+     *     // the secondary grouping size of the integer part
+     *     secondaryGroupSize: 0,
+     *     // the grouping separator of the fraction part
+     *     fractionGroupSeparator: ' ',
+     *     // the grouping size of the fraction part
+     *     fractionGroupSize: 0
+     *   }
+     * })
+     * ```
+     */
+    FORMAT?: BigNumber.Format;
+
+    /**
+     * A string representing the alphabet used for base conversion.
+     * Default value: `'0123456789abcdefghijklmnopqrstuvwxyz'`.
+     *
+     * The length of the alphabet corresponds to the maximum value of the base argument that can be
+     * passed to the BigNumber constructor or `toString`. There is no maximum length, but it must be
+     * at least 2 characters long, and it must not contain a repeated character, or `'.'` - the
+     * decimal separator for all values whatever their base.
+     *
+     * ```ts
+     * // duodecimal (base 12)
+     * BigNumber.config({ ALPHABET: '0123456789TE' })
+     * x = new BigNumber('T', 12)
+     * x.toString()                // '10'
+     * x.toString(12)              // 'T'
+     * ```
+     */
+    ALPHABET?: string;
+  }
+
+  export type Constructor = typeof BigNumber;
+
+  /**
+   * See `FORMAT` and `toFormat`.
+   */
+  export interface Format {
+
+    /**
+     * The decimal separator.
+     */
+    decimalSeparator?: string;
+
+    /**
+     * The grouping separator of the integer part.
+     */
+    groupSeparator?: string;
+
+    /**
+     * The primary grouping size of the integer part.
+     */
+    groupSize?: number;
+
+    /**
+     * The secondary grouping size of the integer part.
+     */
+    secondaryGroupSize?: number;
+
+    /**
+     * The grouping separator of the fraction part.
+     */
+    fractionGroupSeparator?: string;
+
+    /**
+     * The grouping size of the fraction part.
+     */
+    fractionGroupSize?: number;
+  }
+
+  export type Instance = BigNumber;
+  export type ModuloMode = 0 | 1 | 3 | 6 | 9;
+  export type RoundingMode = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+  export type Value = string | number | BigNumber;
+}
+
+export declare class BigNumber {
+
+  /**
+   * Used internally by the `BigNumber.isBigNumber` method.
+   */
+  private readonly _isBigNumber: true;
+
+  /**
+   * The coefficient of the value of this BigNumber, an array of base 1e14 integer numbers.
+   */
+  readonly c: number[];
+
+  /**
+   * The exponent of the value of this BigNumber, an integer number, -1000000000 to 1000000000.
+   */
+  readonly e: number;
+
+  /**
+   * The sign of the value of this BigNumber, -1 or 1.
+   */
+  readonly s: number;
+
+  /**
+   * Returns a new instance of a BigNumber object with value `n`, where `n` is a numeric value in
+   * the specified `base`, or base 10 if `base` is omitted or is `null` or `undefined`.
+   *
+   * ```ts
+   * x = new BigNumber(123.4567)              // '123.4567'
+   * // 'new' is optional
+   * y = BigNumber(x)                         // '123.4567'
+   * ```
+   *
+   * If `n` is a base 10 value it can be in normal (fixed-point) or exponential notation.
+   * Values in other bases must be in normal notation. Values in any base can have fraction digits,
+   * i.e. digits after the decimal point.
+   *
+   * ```ts
+   * new BigNumber(43210)                     // '43210'
+   * new BigNumber('4.321e+4')                // '43210'
+   * new BigNumber('-735.0918e-430')          // '-7.350918e-428'
+   * new BigNumber('123412421.234324', 5)     // '607236.557696'
+   * ```
+   *
+   * Signed `0`, signed `Infinity` and `NaN` are supported.
+   *
+   * ```ts
+   * new BigNumber('-Infinity')               // '-Infinity'
+   * new BigNumber(NaN)                       // 'NaN'
+   * new BigNumber(-0)                        // '0'
+   * new BigNumber('.5')                      // '0.5'
+   * new BigNumber('+2')                      // '2'
+   * ```
+   *
+   * String values in hexadecimal literal form, e.g. `'0xff'`, are valid, as are string values with
+   * the octal and binary prefixs `'0o'` and `'0b'`. String values in octal literal form without the
+   * prefix will be interpreted as decimals, e.g. `'011'` is interpreted as 11, not 9.
+   *
+   * ```ts
+   * new BigNumber(-10110100.1, 2)            // '-180.5'
+   * new BigNumber('-0b10110100.1')           // '-180.5'
+   * new BigNumber('ff.8', 16)                // '255.5'
+   * new BigNumber('0xff.8')                  // '255.5'
+   * ```
+   *
+   * If a base is specified, `n` is rounded according to the current `DECIMAL_PLACES` and
+   * `ROUNDING_MODE` settings. This includes base 10, so don't include a `base` parameter for decimal
+   * values unless this behaviour is desired.
+   *
+   * ```ts
+   * BigNumber.config({ DECIMAL_PLACES: 5 })
+   * new BigNumber(1.23456789)                // '1.23456789'
+   * new BigNumber(1.23456789, 10)            // '1.23457'
+   * ```
+   *
+   * An error is thrown if `base` is invalid.
+   *
+   * There is no limit to the number of digits of a value of type string (other than that of
+   * JavaScript's maximum array size). See `RANGE` to set the maximum and minimum possible exponent
+   * value of a BigNumber.
+   *
+   * ```ts
+   * new BigNumber('5032485723458348569331745.33434346346912144534543')
+   * new BigNumber('4.321e10000000')
+   * ```
+   *
+   * BigNumber `NaN` is returned if `n` is invalid (unless `BigNumber.DEBUG` is `true`, see below).
+   *
+   * ```ts
+   * new BigNumber('.1*')                    // 'NaN'
+   * new BigNumber('blurgh')                 // 'NaN'
+   * new BigNumber(9, 2)                     // 'NaN'
+   * ```
+   *
+   * To aid in debugging, if `BigNumber.DEBUG` is `true` then an error will be thrown on an
+   * invalid `n`. An error will also be thrown if `n` is of type number with more than 15
+   * significant digits, as calling `toString` or `valueOf` on these numbers may not result in the
+   * intended value.
+   *
+   * ```ts
+   * console.log(823456789123456.3)          //  823456789123456.2
+   * new BigNumber(823456789123456.3)        // '823456789123456.2'
+   * BigNumber.DEBUG = true
+   * // 'Error: Number has more than 15 significant digits'
+   * new BigNumber(823456789123456.3)
+   * // 'Error: Not a base 2 number'
+   * new BigNumber(9, 2)
+   * ```
+   *
+   * @param n A numeric value.
+   * @param base The base of `n`, integer, 2 to 36 (or `ALPHABET.length`, see `ALPHABET`).
+   */
+  constructor(n: BigNumber.Value, base?: number);
+
+  /**
+   * Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of this
+   * BigNumber.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * ```ts
+   * x = new BigNumber(-0.8)
+   * x.absoluteValue()           // '0.8'
+   * ```
+   */
+  absoluteValue(): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of this
+   * BigNumber.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * ```ts
+   * x = new BigNumber(-0.8)
+   * x.abs()                     // '0.8'
+   * ```
+   */
+  abs(): BigNumber;
+
+  /**
+   *  Returns |                                                               |
+   * :-------:|:--------------------------------------------------------------|
+   *     1    | If the value of this BigNumber is greater than the value of `n`
+   *    -1    | If the value of this BigNumber is less than the value of `n`
+   *     0    | If this BigNumber and `n` have the same value
+   *  `null`  | If the value of either this BigNumber or `n` is `NaN`
+   *
+   * ```ts
+   *
+   * x = new BigNumber(Infinity)
+   * y = new BigNumber(5)
+   * x.comparedTo(y)                 // 1
+   * x.comparedTo(x.minus(1))        // 0
+   * y.comparedTo(NaN)               // null
+   * y.comparedTo('110', 2)          // -1
+   * ```
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  comparedTo(n: BigNumber.Value, base?: number): number;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber rounded by rounding mode
+   * `roundingMode` to a maximum of `decimalPlaces` decimal places.
+   *
+   * If `decimalPlaces` is omitted, or is `null` or `undefined`, the return value is the number of
+   * decimal places of the value of this BigNumber, or `null` if the value of this BigNumber is
+   * ±`Infinity` or `NaN`.
+   *
+   * If `roundingMode` is omitted, or is `null` or `undefined`, `ROUNDING_MODE` is used.
+   *
+   * Throws if `decimalPlaces` or `roundingMode` is invalid.
+   *
+   * ```ts
+   * x = new BigNumber(1234.56)
+   * x.decimalPlaces()                      // 2
+   * x.decimalPlaces(1)                     // '1234.6'
+   * x.decimalPlaces(2)                     // '1234.56'
+   * x.decimalPlaces(10)                    // '1234.56'
+   * x.decimalPlaces(0, 1)                  // '1234'
+   * x.decimalPlaces(0, 6)                  // '1235'
+   * x.decimalPlaces(1, 1)                  // '1234.5'
+   * x.decimalPlaces(1, BigNumber.ROUND_HALF_EVEN)     // '1234.6'
+   * x                                      // '1234.56'
+   * y = new BigNumber('9.9e-101')
+   * y.decimalPlaces()                      // 102
+   * ```
+   *
+   * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
+   * @param [roundingMode] Rounding mode, integer, 0 to 8.
+   */
+  decimalPlaces(): number;
+  decimalPlaces(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber rounded by rounding mode
+   * `roundingMode` to a maximum of `decimalPlaces` decimal places.
+   *
+   * If `decimalPlaces` is omitted, or is `null` or `undefined`, the return value is the number of
+   * decimal places of the value of this BigNumber, or `null` if the value of this BigNumber is
+   * ±`Infinity` or `NaN`.
+   *
+   * If `roundingMode` is omitted, or is `null` or `undefined`, `ROUNDING_MODE` is used.
+   *
+   * Throws if `decimalPlaces` or `roundingMode` is invalid.
+   *
+   * ```ts
+   * x = new BigNumber(1234.56)
+   * x.dp()                                 // 2
+   * x.dp(1)                                // '1234.6'
+   * x.dp(2)                                // '1234.56'
+   * x.dp(10)                               // '1234.56'
+   * x.dp(0, 1)                             // '1234'
+   * x.dp(0, 6)                             // '1235'
+   * x.dp(1, 1)                             // '1234.5'
+   * x.dp(1, BigNumber.ROUND_HALF_EVEN)     // '1234.6'
+   * x                                      // '1234.56'
+   * y = new BigNumber('9.9e-101')
+   * y.dp()                                 // 102
+   * ```
+   *
+   * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
+   * @param [roundingMode] Rounding mode, integer, 0 to 8.
+   */
+  dp(): number;
+  dp(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber divided by `n`, rounded
+   * according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` settings.
+   *
+   * ```ts
+   * x = new BigNumber(355)
+   * y = new BigNumber(113)
+   * x.dividedBy(y)                  // '3.14159292035398230088'
+   * x.dividedBy(5)                  // '71'
+   * x.dividedBy(47, 16)             // '5'
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  dividedBy(n: BigNumber.Value, base?: number): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber divided by `n`, rounded
+   * according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` settings.
+   *
+   * ```ts
+   * x = new BigNumber(355)
+   * y = new BigNumber(113)
+   * x.div(y)                    // '3.14159292035398230088'
+   * x.div(5)                    // '71'
+   * x.div(47, 16)               // '5'
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  div(n: BigNumber.Value, base?: number): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the integer part of dividing the value of this BigNumber by
+   * `n`.
+   *
+   * ```ts
+   * x = new BigNumber(5)
+   * y = new BigNumber(3)
+   * x.dividedToIntegerBy(y)              // '1'
+   * x.dividedToIntegerBy(0.7)            // '7'
+   * x.dividedToIntegerBy('0.f', 16)      // '5'
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  dividedToIntegerBy(n: BigNumber.Value, base?: number): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the integer part of dividing the value of this BigNumber by
+   * `n`.
+   *
+   * ```ts
+   * x = new BigNumber(5)
+   * y = new BigNumber(3)
+   * x.idiv(y)                       // '1'
+   * x.idiv(0.7)                     // '7'
+   * x.idiv('0.f', 16)               // '5'
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  idiv(n: BigNumber.Value, base?: number): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber exponentiated by `n`, i.e.
+   * raised to the power `n`, and optionally modulo a modulus `m`.
+   *
+   * If `n` is negative the result is rounded according to the current `DECIMAL_PLACES` and
+   * `ROUNDING_MODE` settings.
+   *
+   * As the number of digits of the result of the power operation can grow so large so quickly,
+   * e.g. 123.456**10000 has over 50000 digits, the number of significant digits calculated is
+   * limited to the value of the `POW_PRECISION` setting (unless a modulus `m` is specified).
+   *
+   * By default `POW_PRECISION` is set to 0. This means that an unlimited number of significant
+   * digits will be calculated, and that the method's performance will decrease dramatically for
+   * larger exponents.
+   *
+   * If `m` is specified and the value of `m`, `n` and this BigNumber are integers and `n` is
+   * positive, then a fast modular exponentiation algorithm is used, otherwise the operation will
+   * be performed as `x.exponentiatedBy(n).modulo(m)` with a `POW_PRECISION` of 0.
+   *
+   * Throws if `n` is not an integer.
+   *
+   * ```ts
+   * Math.pow(0.7, 2)                    // 0.48999999999999994
+   * x = new BigNumber(0.7)
+   * x.exponentiatedBy(2)                // '0.49'
+   * BigNumber(3).exponentiatedBy(-2)    // '0.11111111111111111111'
+   * ```
+   *
+   * @param n The exponent, an integer.
+   * @param [m] The modulus.
+   */
+  exponentiatedBy(n: number, m?: BigNumber.Value): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber exponentiated by `n`, i.e.
+   * raised to the power `n`, and optionally modulo a modulus `m`.
+   *
+   * If `n` is negative the result is rounded according to the current `DECIMAL_PLACES` and
+   * `ROUNDING_MODE` settings.
+   *
+   * As the number of digits of the result of the power operation can grow so large so quickly,
+   * e.g. 123.456**10000 has over 50000 digits, the number of significant digits calculated is
+   * limited to the value of the `POW_PRECISION` setting (unless a modulus `m` is specified).
+   *
+   * By default `POW_PRECISION` is set to 0. This means that an unlimited number of significant
+   * digits will be calculated, and that the method's performance will decrease dramatically for
+   * larger exponents.
+   *
+   * If `m` is specified and the value of `m`, `n` and this BigNumber are integers and `n` is
+   * positive, then a fast modular exponentiation algorithm is used, otherwise the operation will
+   * be performed as `x.pow(n).modulo(m)` with a `POW_PRECISION` of 0.
+   *
+   * Throws if `n` is not an integer.
+   *
+   * ```ts
+   * Math.pow(0.7, 2)                   // 0.48999999999999994
+   * x = new BigNumber(0.7)
+   * x.pow(2)                           // '0.49'
+   * BigNumber(3).pow(-2)               // '0.11111111111111111111'
+   * ```
+   *
+   * @param n The exponent, an integer.
+   * @param [m] The modulus.
+   */
+  pow(n: number, m?: BigNumber.Value): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber rounded to an integer using
+   * rounding mode `rm`.
+   *
+   * If `rm` is omitted, or is `null` or `undefined`, `ROUNDING_MODE` is used.
+   *
+   * Throws if `rm` is invalid.
+   *
+   * ```ts
+   * x = new BigNumber(123.456)
+   * x.integerValue()                        // '123'
+   * x.integerValue(BigNumber.ROUND_CEIL)    // '124'
+   * y = new BigNumber(-12.7)
+   * y.integerValue()                        // '-13'
+   * x.integerValue(BigNumber.ROUND_DOWN)    // '-12'
+   * ```
+   *
+   * @param {BigNumber.RoundingMode} [rm] The roundng mode, an integer, 0 to 8.
+   */
+  integerValue(rm?: BigNumber.RoundingMode): BigNumber;
+
+  /**
+   * Returns `true` if the value of this BigNumber is equal to the value of `n`, otherwise returns
+   * `false`.
+   *
+   * As with JavaScript, `NaN` does not equal `NaN`.
+   *
+   * ```ts
+   * 0 === 1e-324                           // true
+   * x = new BigNumber(0)
+   * x.isEqualTo('1e-324')                  // false
+   * BigNumber(-0).isEqualTo(x)             // true  ( -0 === 0 )
+   * BigNumber(255).isEqualTo('ff', 16)     // true
+   *
+   * y = new BigNumber(NaN)
+   * y.isEqualTo(NaN)                // false
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  isEqualTo(n: BigNumber.Value, base?: number): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is equal to the value of `n`, otherwise returns
+   * `false`.
+   *
+   * As with JavaScript, `NaN` does not equal `NaN`.
+   *
+   * ```ts
+   * 0 === 1e-324                    // true
+   * x = new BigNumber(0)
+   * x.eq('1e-324')                  // false
+   * BigNumber(-0).eq(x)             // true  ( -0 === 0 )
+   * BigNumber(255).eq('ff', 16)     // true
+   *
+   * y = new BigNumber(NaN)
+   * y.eq(NaN)                       // false
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  eq(n: BigNumber.Value, base?: number): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is a finite number, otherwise returns `false`.
+   *
+   * The only possible non-finite values of a BigNumber are `NaN`, `Infinity` and `-Infinity`.
+   *
+   * ```ts
+   * x = new BigNumber(1)
+   * x.isFinite()                    // true
+   * y = new BigNumber(Infinity)
+   * y.isFinite()                    // false
+   * ```
+   */
+  isFinite(): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is greater than the value of `n`, otherwise
+   * returns `false`.
+   *
+   * ```ts
+   * 0.1 > (0.3 - 0.2)                             // true
+   * x = new BigNumber(0.1)
+   * x.isGreaterThan(BigNumber(0.3).minus(0.2))    // false
+   * BigNumber(0).isGreaterThan(x)                 // false
+   * BigNumber(11, 3).isGreaterThan(11.1, 2)       // true
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  isGreaterThan(n: BigNumber.Value, base?: number): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is greater than the value of `n`, otherwise
+   * returns `false`.
+   *
+   * ```ts
+   * 0.1 > (0.3 - 0                     // true
+   * x = new BigNumber(0.1)
+   * x.gt(BigNumber(0.3).minus(0.2))    // false
+   * BigNumber(0).gt(x)                 // false
+   * BigNumber(11, 3).gt(11.1, 2)       // true
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  gt(n: BigNumber.Value, base?: number): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is greater than or equal to the value of `n`,
+   * otherwise returns `false`.
+   *
+   * ```ts
+   * (0.3 - 0.2) >= 0.1                                  // false
+   * x = new BigNumber(0.3).minus(0.2)
+   * x.isGreaterThanOrEqualTo(0.1)                       // true
+   * BigNumber(1).isGreaterThanOrEqualTo(x)              // true
+   * BigNumber(10, 18).isGreaterThanOrEqualTo('i', 36)   // true
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  isGreaterThanOrEqualTo(n: BigNumber.Value, base?: number): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is greater than or equal to the value of `n`,
+   * otherwise returns `false`.
+   *
+   * ```ts
+   * (0.3 - 0.2) >= 0.1                    // false
+   * x = new BigNumber(0.3).minus(0.2)
+   * x.gte(0.1)                            // true
+   * BigNumber(1).gte(x)                   // true
+   * BigNumber(10, 18).gte('i', 36)        // true
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  gte(n: BigNumber.Value, base?: number): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is an integer, otherwise returns `false`.
+   *
+   * ```ts
+   * x = new BigNumber(1)
+   * x.isInteger()                   // true
+   * y = new BigNumber(123.456)
+   * y.isInteger()                   // false
+   * ```
+   */
+  isInteger(): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is less than the value of `n`, otherwise returns
+   * `false`.
+   *
+   * ```ts
+   * (0.3 - 0.2) < 0.1                       // true
+   * x = new BigNumber(0.3).minus(0.2)
+   * x.isLessThan(0.1)                       // false
+   * BigNumber(0).isLessThan(x)              // true
+   * BigNumber(11.1, 2).isLessThan(11, 3)    // true
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  isLessThan(n: BigNumber.Value, base?: number): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is less than the value of `n`, otherwise returns
+   * `false`.
+   *
+   * ```ts
+   * (0.3 - 0.2) < 0.1                       // true
+   * x = new BigNumber(0.3).minus(0.2)
+   * x.lt(0.1)                               // false
+   * BigNumber(0).lt(x)                      // true
+   * BigNumber(11.1, 2).lt(11, 3)            // true
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  lt(n: BigNumber.Value, base?: number): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is less than or equal to the value of `n`,
+   * otherwise returns `false`.
+   *
+   * ```ts
+   * 0.1 <= (0.3 - 0.2)                                 // false
+   * x = new BigNumber(0.1)
+   * x.isLessThanOrEqualTo(BigNumber(0.3).minus(0.2))   // true
+   * BigNumber(-1).isLessThanOrEqualTo(x)               // true
+   * BigNumber(10, 18).isLessThanOrEqualTo('i', 36)     // true
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  isLessThanOrEqualTo(n: BigNumber.Value, base?: number): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is less than or equal to the value of `n`,
+   * otherwise returns `false`.
+   *
+   * ```ts
+   * 0.1 <= (0.3 - 0.2)                  // false
+   * x = new BigNumber(0.1)
+   * x.lte(BigNumber(0.3).minus(0.2))    // true
+   * BigNumber(-1).lte(x)                // true
+   * BigNumber(10, 18).lte('i', 36)      // true
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  lte(n: BigNumber.Value, base?: number): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is `NaN`, otherwise returns `false`.
+   *
+   * ```ts
+   * x = new BigNumber(NaN)
+   * x.isNaN()                       // true
+   * y = new BigNumber('Infinity')
+   * y.isNaN()                       // false
+   * ```
+   */
+  isNaN(): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is negative, otherwise returns `false`.
+   *
+   * ```ts
+   * x = new BigNumber(-0)
+   * x.isNegative()                  // true
+   * y = new BigNumber(2)
+   * y.isNegative()                  // false
+   * ```
+   */
+  isNegative(): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is positive, otherwise returns `false`.
+   *
+   * ```ts
+   * x = new BigNumber(-0)
+   * x.isPositive()                  // false
+   * y = new BigNumber(2)
+   * y.isPositive()                  // true
+   * ```
+   */
+  isPositive(): boolean;
+
+  /**
+   * Returns `true` if the value of this BigNumber is zero or minus zero, otherwise returns `false`.
+   *
+   * ```ts
+   * x = new BigNumber(-0)
+   * x.isZero()                 // true
+   * ```
+   */
+  isZero(): boolean;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber minus `n`.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * ```ts
+   * 0.3 - 0.1                       // 0.19999999999999998
+   * x = new BigNumber(0.3)
+   * x.minus(0.1)                    // '0.2'
+   * x.minus(0.6, 20)                // '0'
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  minus(n: BigNumber.Value, base?: number): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber modulo `n`, i.e. the integer
+   * remainder of dividing this BigNumber by `n`.
+   *
+   * The value returned, and in particular its sign, is dependent on the value of the `MODULO_MODE`
+   * setting of this BigNumber constructor. If it is 1 (default value), the result will have the
+   * same sign as this BigNumber, and it will match that of Javascript's `%` operator (within the
+   * limits of double precision) and BigDecimal's `remainder` method.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * See `MODULO_MODE` for a description of the other modulo modes.
+   *
+   * ```ts
+   * 1 % 0.9                         // 0.09999999999999998
+   * x = new BigNumber(1)
+   * x.modulo(0.9)                   // '0.1'
+   * y = new BigNumber(33)
+   * y.modulo('a', 33)               // '3'
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  modulo(n: BigNumber.Value, base?: number): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber modulo `n`, i.e. the integer
+   * remainder of dividing this BigNumber by `n`.
+   *
+   * The value returned, and in particular its sign, is dependent on the value of the `MODULO_MODE`
+   * setting of this BigNumber constructor. If it is 1 (default value), the result will have the
+   * same sign as this BigNumber, and it will match that of Javascript's `%` operator (within the
+   * limits of double precision) and BigDecimal's `remainder` method.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * See `MODULO_MODE` for a description of the other modulo modes.
+   *
+   * ```ts
+   * 1 % 0.9                      // 0.09999999999999998
+   * x = new BigNumber(1)
+   * x.mod(0.9)                   // '0.1'
+   * y = new BigNumber(33)
+   * y.mod('a', 33)               // '3'
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  mod(n: BigNumber.Value, base?: number): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber multiplied by `n`.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * ```ts
+   * 0.6 * 3                                // 1.7999999999999998
+   * x = new BigNumber(0.6)
+   * y = x.multipliedBy(3)                  // '1.8'
+   * BigNumber('7e+500').multipliedBy(y)    // '1.26e+501'
+   * x.multipliedBy('-a', 16)               // '-6'
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  multipliedBy(n: BigNumber.Value, base?: number) : BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber multiplied by `n`.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * ```ts
+   * 0.6 * 3                         // 1.7999999999999998
+   * x = new BigNumber(0.6)
+   * y = x.times(3)                  // '1.8'
+   * BigNumber('7e+500').times(y)    // '1.26e+501'
+   * x.times('-a', 16)               // '-6'
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  times(n: BigNumber.Value, base?: number): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber negated, i.e. multiplied by -1.
+   *
+   * ```ts
+   * x = new BigNumber(1.8)
+   * x.negated()                     // '-1.8'
+   * y = new BigNumber(-1.3)
+   * y.negated()                     // '1.3'
+   * ```
+   */
+  negated(): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber plus `n`.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * ```ts
+   * 0.1 + 0.2                       // 0.30000000000000004
+   * x = new BigNumber(0.1)
+   * y = x.plus(0.2)                 // '0.3'
+   * BigNumber(0.7).plus(x).plus(y)  // '1'
+   * x.plus('0.1', 8)                // '0.225'
+   * ```
+   *
+   * @param n A numeric value.
+   * @param [base] The base of n.
+   */
+  plus(n: BigNumber.Value, base?: number): BigNumber;
+
+  /**
+   * Returns the number of significant digits of the value of this BigNumber, or `null` if the value
+   * of this BigNumber is ±`Infinity` or `NaN`.
+   *
+   * If `includeZeros` is true then any trailing zeros of the integer part of the value of this
+   * BigNumber are counted as significant digits, otherwise they are not.
+   *
+   * Throws if `includeZeros` is invalid.
+   *
+   * ```ts
+   * x = new BigNumber(9876.54321)
+   * x.precision()                         // 9
+   * y = new BigNumber(987000)
+   * y.precision(false)                    // 3
+   * y.precision(true)                     // 6
+   * ```
+   *
+   * @param [includeZeros] Whether to include integer trailing zeros in the significant digit count.
+   */
+  precision(includeZeros?: boolean): number;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber rounded to a precision of
+   * `significantDigits` significant digits using rounding mode `roundingMode`.
+   *
+   * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` will be used.
+   *
+   * Throws if `significantDigits` or `roundingMode` is invalid.
+   *
+   * ```ts
+   * x = new BigNumber(9876.54321)
+   * x.precision(6)                         // '9876.54'
+   * x.precision(6, BigNumber.ROUND_UP)     // '9876.55'
+   * x.precision(2)                         // '9900'
+   * x.precision(2, 1)                      // '9800'
+   * x                                      // '9876.54321'
+   * ```
+   *
+   * @param significantDigits Significant digits, integer, 1 to 1e+9.
+   * @param [roundingMode] Rounding mode, integer, 0 to 8.
+   */
+  precision(significantDigits: number, roundingMode?: BigNumber.RoundingMode): BigNumber;
+
+  /**
+   * Returns the number of significant digits of the value of this BigNumber,
+   * or `null` if the value of this BigNumber is ±`Infinity` or `NaN`.
+   *
+   * If `includeZeros` is true then any trailing zeros of the integer part of
+   * the value of this BigNumber are counted as significant digits, otherwise
+   * they are not.
+   *
+   * Throws if `includeZeros` is invalid.
+   *
+   * ```ts
+   * x = new BigNumber(9876.54321)
+   * x.sd()                         // 9
+   * y = new BigNumber(987000)
+   * y.sd(false)                    // 3
+   * y.sd(true)                     // 6
+   * ```
+   *
+   * @param [includeZeros] Whether to include integer trailing zeros in the significant digit count.
+   */
+  sd(includeZeros?: boolean): number;
+
+  /*
+   * Returns a BigNumber whose value is the value of this BigNumber rounded to a precision of
+   * `significantDigits` significant digits using rounding mode `roundingMode`.
+   *
+   * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` will be used.
+   *
+   * Throws if `significantDigits` or `roundingMode` is invalid.
+   *
+   * ```ts
+   * x = new BigNumber(9876.54321)
+   * x.sd(6)                           // '9876.54'
+   * x.sd(6, BigNumber.ROUND_UP)       // '9876.55'
+   * x.sd(2)                           // '9900'
+   * x.sd(2, 1)                        // '9800'
+   * x                                 // '9876.54321'
+   * ```
+   *
+   * @param significantDigits Significant digits, integer, 1 to 1e+9.
+   * @param [roundingMode] Rounding mode, integer, 0 to 8.
+   */
+  sd(significantDigits: number, roundingMode?: BigNumber.RoundingMode): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the value of this BigNumber shifted by `n` places.
+   *
+   * The shift is of the decimal point, i.e. of powers of ten, and is to the left if `n` is negative
+   * or to the right if `n` is positive.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * Throws if `n` is invalid.
+   *
+   * ```ts
+   * x = new BigNumber(1.23)
+   * x.shiftedBy(3)                      // '1230'
+   * x.shiftedBy(-3)                     // '0.00123'
+   * ```
+   *
+   * @param n The shift value, integer, -9007199254740991 to 9007199254740991.
+   */
+  shiftedBy(n: number): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the square root of the value of this BigNumber, rounded
+   * according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` settings.
+   *
+   * The return value will be correctly rounded, i.e. rounded as if the result was first calculated
+   * to an infinite number of correct digits before rounding.
+   *
+   * ```ts
+   * x = new BigNumber(16)
+   * x.squareRoot()                  // '4'
+   * y = new BigNumber(3)
+   * y.squareRoot()                  // '1.73205080756887729353'
+   * ```
+   */
+  squareRoot(): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the square root of the value of this BigNumber, rounded
+   * according to the current `DECIMAL_PLACES` and `ROUNDING_MODE` settings.
+   *
+   * The return value will be correctly rounded, i.e. rounded as if the result was first calculated
+   * to an infinite number of correct digits before rounding.
+   *
+   * ```ts
+   * x = new BigNumber(16)
+   * x.sqrt()                  // '4'
+   * y = new BigNumber(3)
+   * y.sqrt()                  // '1.73205080756887729353'
+   * ```
+   */
+  sqrt(): BigNumber;
+
+  /**
+   * Returns a string representing the value of this BigNumber in exponential notation rounded using
+   * rounding mode `roundingMode` to `decimalPlaces` decimal places, i.e with one digit before the
+   * decimal point and `decimalPlaces` digits after it.
+   *
+   * If the value of this BigNumber in exponential notation has fewer than `decimalPlaces` fraction
+   * digits, the return value will be appended with zeros accordingly.
+   *
+   * If `decimalPlaces` is omitted, or is `null` or `undefined`, the number of digits after the
+   * decimal point defaults to the minimum number of digits necessary to represent the value
+   * exactly.
+   *
+   * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used.
+   *
+   * Throws if `decimalPlaces` or `roundingMode` is invalid.
+   *
+   * ```ts
+   * x = 45.6
+   * y = new BigNumber(x)
+   * x.toExponential()               // '4.56e+1'
+   * y.toExponential()               // '4.56e+1'
+   * x.toExponential(0)              // '5e+1'
+   * y.toExponential(0)              // '5e+1'
+   * x.toExponential(1)              // '4.6e+1'
+   * y.toExponential(1)              // '4.6e+1'
+   * y.toExponential(1, 1)           // '4.5e+1'  (ROUND_DOWN)
+   * x.toExponential(3)              // '4.560e+1'
+   * y.toExponential(3)              // '4.560e+1'
+   * ```
+   *
+   * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
+   * @param [roundingMode] Rounding mode, integer, 0 to 8.
+   */
+  toExponential(decimalPlaces?: number, roundingMode?: BigNumber.RoundingMode): string;
+
+  /**
+   * Returns a string representing the value of this BigNumber in normal (fixed-point) notation
+   * rounded to `decimalPlaces` decimal places using rounding mode `roundingMode`.
+   *
+   * If the value of this BigNumber in normal notation has fewer than `decimalPlaces` fraction
+   * digits, the return value will be appended with zeros accordingly.
+   *
+   * Unlike `Number.prototype.toFixed`, which returns exponential notation if a number is greater or
+   * equal to 10**21, this method will always return normal notation.
+   *
+   * If `decimalPlaces` is omitted or is `null` or `undefined`, the return value will be unrounded
+   * and in normal notation. This is also unlike `Number.prototype.toFixed`, which returns the value
+   * to zero decimal places. It is useful when normal notation is required and the current
+   * `EXPONENTIAL_AT` setting causes `toString` to return exponential notation.
+   *
+   * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used.
+   *
+   * Throws if `decimalPlaces` or `roundingMode` is invalid.
+   *
+   * ```ts
+   * x = 3.456
+   * y = new BigNumber(x)
+   * x.toFixed()                     // '3'
+   * y.toFixed()                     // '3.456'
+   * y.toFixed(0)                    // '3'
+   * x.toFixed(2)                    // '3.46'
+   * y.toFixed(2)                    // '3.46'
+   * y.toFixed(2, 1)                 // '3.45'  (ROUND_DOWN)
+   * x.toFixed(5)                    // '3.45600'
+   * y.toFixed(5)                    // '3.45600'
+   * ```
+   *
+   * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
+   * @param [roundingMode] Rounding mode, integer, 0 to 8.
+   */
+  toFixed(decimalPlaces?: number, roundingMode?: BigNumber.RoundingMode): string;
+
+  /**
+   * Returns a string representing the value of this BigNumber in normal (fixed-point) notation
+   * rounded to `decimalPlaces` decimal places using rounding mode `roundingMode`, and formatted
+   * according to the properties of the `FORMAT` object.
+   *
+   * The properties of the `FORMAT` object are shown in the examples below.
+   *
+   * If `decimalPlaces` is omitted or is `null` or `undefined`, then the return value is not
+   * rounded to a fixed number of decimal places.
+   *
+   * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used.
+   *
+   * Throws if `decimalPlaces` or `roundingMode` is invalid.
+   *
+   * ```ts
+   * format = {
+   *     decimalSeparator: '.',
+   *     groupSeparator: ',',
+   *     groupSize: 3,
+   *     secondaryGroupSize: 0,
+   *     fractionGroupSeparator: ' ',
+   *     fractionGroupSize: 0
+   * }
+   * BigNumber.config({ FORMAT: format })
+   *
+   * x = new BigNumber('123456789.123456789')
+   * x.toFormat()                    // '123,456,789.123456789'
+   * x.toFormat(1)                   // '123,456,789.1'
+   *
+   * format.groupSeparator = ' '
+   * format.fractionGroupSize = 5
+   * x.toFormat()                    // '123 456 789.12345 6789'
+   *
+   * BigNumber.config({
+   *     FORMAT: {
+   *         decimalSeparator: ',',
+   *         groupSeparator: '.',
+   *         groupSize: 3,
+   *         secondaryGroupSize: 2
+   *     }
+   * })
+   *
+   * x.toFormat(6)                   // '12.34.56.789,123'
+   * ```
+   *
+   * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
+   * @param [roundingMode] Rounding mode, integer, 0 to 8.
+   */
+  toFormat(decimalPlaces?: number, roundingMode?: BigNumber.RoundingMode): string;
+
+  /**
+   * Returns a string array representing the value of this BigNumber as a simple fraction with an
+   * integer numerator and an integer denominator. The denominator will be a positive non-zero value
+   * less than or equal to `max_denominator`.
+   *
+   * If a maximum denominator, `max_denominator`, is not specified, or is `null` or `undefined`, the
+   * denominator will be the lowest value necessary to represent the number exactly.
+   *
+   * Throws if `max_denominator` is invalid.
+   *
+   * ```ts
+   * x = new BigNumber(1.75)
+   * x.toFraction()                  // '7, 4'
+   *
+   * pi = new BigNumber('3.14159265358')
+   * pi.toFraction()                 // '157079632679,50000000000'
+   * pi.toFraction(100000)           // '312689, 99532'
+   * pi.toFraction(10000)            // '355, 113'
+   * pi.toFraction(100)              // '311, 99'
+   * pi.toFraction(10)               // '22, 7'
+   * pi.toFraction(1)                // '3, 1'
+   * ```
+   *
+   * @param [max_denominator] The maximum denominator, integer > 0, or Infinity.
+   */
+  toFraction(max_denominator?: BigNumber.Value): BigNumber[];
+
+  /**
+   * As `valueOf`.
+   */
+  toJSON(): string;
+
+  /**
+   * Returns the value of this BigNumber as a JavaScript primitive number.
+   *
+   * Using the unary plus operator gives the same result.
+   *
+   * ```ts
+   * x = new BigNumber(456.789)
+   * x.toNumber()                    // 456.789
+   * +x                              // 456.789
+   *
+   * y = new BigNumber('45987349857634085409857349856430985')
+   * y.toNumber()                    // 4.598734985763409e+34
+   *
+   * z = new BigNumber(-0)
+   * 1 / z.toNumber()                // -Infinity
+   * 1 / +z                          // -Infinity
+   * ```
+   */
+  toNumber(): number;
+
+  /**
+   * Returns a string representing the value of this BigNumber rounded to `significantDigits`
+   * significant digits using rounding mode `roundingMode`.
+   *
+   * If `significantDigits` is less than the number of digits necessary to represent the integer
+   * part of the value in normal (fixed-point) notation, then exponential notation is used.
+   *
+   * If `significantDigits` is omitted, or is `null` or `undefined`, then the return value is the
+   * same as `n.toString()`.
+   *
+   * If `roundingMode` is omitted or is `null` or `undefined`, `ROUNDING_MODE` is used.
+   *
+   * Throws if `significantDigits` or `roundingMode` is invalid.
+   *
+   * ```ts
+   * x = 45.6
+   * y = new BigNumber(x)
+   * x.toPrecision()                 // '45.6'
+   * y.toPrecision()                 // '45.6'
+   * x.toPrecision(1)                // '5e+1'
+   * y.toPrecision(1)                // '5e+1'
+   * y.toPrecision(2, 0)             // '4.6e+1'  (ROUND_UP)
+   * y.toPrecision(2, 1)             // '4.5e+1'  (ROUND_DOWN)
+   * x.toPrecision(5)                // '45.600'
+   * y.toPrecision(5)                // '45.600'
+   * ```
+   *
+   * @param [significantDigits] Significant digits, integer, 1 to 1e+9.
+   * @param [roundingMode] Rounding mode, integer 0 to 8.
+   */
+  toPrecision(significantDigits?: number, roundingMode?: BigNumber.RoundingMode): string;
+
+  /**
+   * Returns a string representing the value of this BigNumber in base `base`, or base 10 if `base`
+   * is omitted or is `null` or `undefined`.
+   *
+   * For bases above 10, and using the default base conversion alphabet (see `ALPHABET`), values
+   * from 10 to 35 are represented by a-z (the same as `Number.prototype.toString`).
+   *
+   * If a base is specified the value is rounded according to the current `DECIMAL_PLACES` and
+   * `ROUNDING_MODE` settings, otherwise it is not.
+   *
+   * If a base is not specified, and this BigNumber has a positive exponent that is equal to or
+   * greater than the positive component of the current `EXPONENTIAL_AT` setting, or a negative
+   * exponent equal to or less than the negative component of the setting, then exponential notation
+   * is returned.
+   *
+   * If `base` is `null` or `undefined` it is ignored.
+   *
+   * Throws if `base` is invalid.
+   *
+   * ```ts
+   * x = new BigNumber(750000)
+   * x.toString()                    // '750000'
+   * BigNumber.config({ EXPONENTIAL_AT: 5 })
+   * x.toString()                    // '7.5e+5'
+   *
+   * y = new BigNumber(362.875)
+   * y.toString(2)                   // '101101010.111'
+   * y.toString(9)                   // '442.77777777777777777778'
+   * y.toString(32)                  // 'ba.s'
+   *
+   * BigNumber.config({ DECIMAL_PLACES: 4 });
+   * z = new BigNumber('1.23456789')
+   * z.toString()                    // '1.23456789'
+   * z.toString(10)                  // '1.2346'
+   * ```
+   *
+   * @param [base] The base, integer, 2 to 36 (or `ALPHABET.length`, see `ALPHABET`).
+   */
+  toString(base?: number): string;
+
+  /**
+   * As `toString`, but does not accept a base argument and includes the minus sign for negative
+   * zero.
+   *
+   * ``ts
+   * x = new BigNumber('-0')
+   * x.toString()                    // '0'
+   * x.valueOf()                     // '-0'
+   * y = new BigNumber('1.777e+457')
+   * y.valueOf()                     // '1.777e+457'
+   * ```
+   */
+  valueOf(): string;
+
+  /**
+   * Returns a new independent BigNumber constructor with configuration as described by `object`, or
+   * with the default configuration if object is `null` or `undefined`.
+   *
+   * Throws if `object` is not an object.
+   *
+   * ```ts
+   * BigNumber.config({ DECIMAL_PLACES: 5 })
+   * BN = BigNumber.clone({ DECIMAL_PLACES: 9 })
+   *
+   * x = new BigNumber(1)
+   * y = new BN(1)
+   *
+   * x.div(3)                        // 0.33333
+   * y.div(3)                        // 0.333333333
+   *
+   * // BN = BigNumber.clone({ DECIMAL_PLACES: 9 }) is equivalent to:
+   * BN = BigNumber.clone()
+   * BN.config({ DECIMAL_PLACES: 9 })
+   * ```
+   *
+   * @param [object] The configuration object.
+   */
+  static clone(object?: BigNumber.Config): BigNumber.Constructor;
+
+  /**
+   * Configures the settings that apply to this BigNumber constructor.
+   *
+   * The configuration object, `object`, contains any number of the properties shown in the example
+   * below.
+   *
+   * Returns an object with the above properties and their current values.
+   *
+   * Throws if `object` is not an object, or if an invalid value is assigned to one or more of the
+   * properties.
+   *
+   * ```ts
+   * BigNumber.config({
+   *     DECIMAL_PLACES: 40,
+   *     ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL,
+   *     EXPONENTIAL_AT: [-10, 20],
+   *     RANGE: [-500, 500],
+   *     CRYPTO: true,
+   *     MODULO_MODE: BigNumber.ROUND_FLOOR,
+   *     POW_PRECISION: 80,
+   *     FORMAT: {
+   *         groupSize: 3,
+   *         groupSeparator: ' ',
+   *         decimalSeparator: ','
+   *     },
+   *     ALPHABET: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
+   * });
+   *
+   * BigNumber.config().DECIMAL_PLACES        // 40
+   * ```
+   *
+   * @param object The configuration object.
+   */
+  static config(object: BigNumber.Config): BigNumber.Config;
+
+  /**
+   * Returns `true` if `value` is a BigNumber instance, otherwise returns `false`.
+   *
+   * ```ts
+   * x = 42
+   * y = new BigNumber(x)
+   *
+   * BigNumber.isBigNumber(x)             // false
+   * y instanceof BigNumber               // true
+   * BigNumber.isBigNumber(y)             // true
+   *
+   * BN = BigNumber.clone();
+   * z = new BN(x)
+   * z instanceof BigNumber               // false
+   * BigNumber.isBigNumber(z)             // true
+   * ```
+   *
+   * @param value The value to test.
+   */
+  static isBigNumber(value: any): boolean;
+
+  /**
+   *
+   * Returns a BigNumber whose value is the maximum of the arguments.
+   *
+   * Accepts either an argument list or an array of values.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * ```ts
+   * x = new BigNumber('3257869345.0378653')
+   * BigNumber.maximum(4e9, x, '123456789.9')      // '4000000000'
+   *
+   * arr = [12, '13', new BigNumber(14)]
+   * BigNumber.maximum(arr)                        // '14'
+   * ```
+   *
+   * @param n A numeric value.
+   */
+  static maximum(...n: BigNumber.Value[]): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the maximum of the arguments.
+   *
+   * Accepts either an argument list or an array of values.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * ```ts
+   * x = new BigNumber('3257869345.0378653')
+   * BigNumber.max(4e9, x, '123456789.9')      // '4000000000'
+   *
+   * arr = [12, '13', new BigNumber(14)]
+   * BigNumber.max(arr)                        // '14'
+   * ```
+   *
+   * @param n A numeric value.
+   */
+  static max(...n: BigNumber.Value[]): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the minimum of the arguments.
+   *
+   * Accepts either an argument list or an array of values.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * ```ts
+   * x = new BigNumber('3257869345.0378653')
+   * BigNumber.minimum(4e9, x, '123456789.9')          // '123456789.9'
+   *
+   * arr = [2, new BigNumber(-14), '-15.9999', -12]
+   * BigNumber.minimum(arr)                            // '-15.9999'
+   * ```
+   *
+   * @param n A numeric value.
+   */
+  static minimum(...n: BigNumber.Value[]): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the minimum of the arguments.
+   *
+   * Accepts either an argument list or an array of values.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * ```ts
+   * x = new BigNumber('3257869345.0378653')
+   * BigNumber.min(4e9, x, '123456789.9')             // '123456789.9'
+   *
+   * arr = [2, new BigNumber(-14), '-15.9999', -12]
+   * BigNumber.min(arr)                               // '-15.9999'
+   * ```
+   *
+   * @param n A numeric value.
+   */
+  static min(...n: BigNumber.Value[]): BigNumber;
+
+  /**
+   * Returns a new BigNumber with a pseudo-random value equal to or greater than 0 and less than 1.
+   *
+   * The return value will have `decimalPlaces` decimal places, or less if trailing zeros are
+   * produced. If `decimalPlaces` is omitted, the current `DECIMAL_PLACES` setting will be used.
+   *
+   * Depending on the value of this BigNumber constructor's `CRYPTO` setting and the support for the
+   * `crypto` object in the host environment, the random digits of the return value are generated by
+   * either `Math.random` (fastest), `crypto.getRandomValues` (Web Cryptography API in recent
+   * browsers) or `crypto.randomBytes` (Node.js).
+   *
+   * If `CRYPTO` is true, i.e. one of the `crypto` methods is to be used, the value of a returned
+   * BigNumber should be cryptographically secure and statistically indistinguishable from a random
+   * value.
+   *
+   * Throws if `decimalPlaces` is invalid.
+   *
+   * ```ts
+   * BigNumber.config({ DECIMAL_PLACES: 10 })
+   * BigNumber.random()              // '0.4117936847'
+   * BigNumber.random(20)            // '0.78193327636914089009'
+   * ```
+   *
+   * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
+   */
+  static random(decimalPlaces?: number): BigNumber;
+
+  /**
+   * Configures the settings that apply to this BigNumber constructor.
+   *
+   * The configuration object, `object`, contains any number of the properties shown in the example
+   * below.
+   *
+   * Returns an object with the above properties and their current values.
+   *
+   * Throws if `object` is not an object, or if an invalid value is assigned to one or more of the
+   * properties.
+   *
+   * ```ts
+   * BigNumber.set({
+   *     DECIMAL_PLACES: 40,
+   *     ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL,
+   *     EXPONENTIAL_AT: [-10, 20],
+   *     RANGE: [-500, 500],
+   *     CRYPTO: true,
+   *     MODULO_MODE: BigNumber.ROUND_FLOOR,
+   *     POW_PRECISION: 80,
+   *     FORMAT: {
+   *         groupSize: 3,
+   *         groupSeparator: ' ',
+   *         decimalSeparator: ','
+   *     },
+   *     ALPHABET: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
+   * });
+   *
+   * BigNumber.set().DECIMAL_PLACES        // 40
+   * ```
+   *
+   * @param object The configuration object.
+   */
+  static set(object: BigNumber.Config): BigNumber.Config;
+
+  /**
+   * Helps ES6 import.
+   */
+  private static readonly default?: BigNumber.Constructor;
+
+  /**
+   * Helps ES6 import.
+   */
+  private static readonly BigNumber?: BigNumber.Constructor;
+
+  /**
+   * Rounds away from zero.
+   */
+  static readonly ROUND_UP: 0;
+
+  /**
+   * Rounds towards zero.
+   */
+  static readonly ROUND_DOWN: 1;
+
+  /**
+   * Rounds towards Infinity.
+   */
+  static readonly ROUND_CEIL: 2;
+
+  /**
+   * Rounds towards -Infinity.
+   */
+  static readonly ROUND_FLOOR: 3;
+
+  /**
+   * Rounds towards nearest neighbour. If equidistant, rounds away from zero .
+   */
+  static readonly ROUND_HALF_UP: 4;
+
+  /**
+   * Rounds towards nearest neighbour. If equidistant, rounds towards zero.
+   */
+  static readonly ROUND_HALF_DOWN: 5;
+
+  /**
+   * Rounds towards nearest neighbour. If equidistant, rounds towards even neighbour.
+   */
+  static readonly ROUND_HALF_EVEN: 6;
+
+  /**
+   * Rounds towards nearest neighbour. If equidistant, rounds towards Infinity.
+   */
+  static readonly ROUND_HALF_CEIL: 7;
+
+  /**
+   * Rounds towards nearest neighbour. If equidistant, rounds towards -Infinity.
+   */
+  static readonly ROUND_HALF_FLOOR: 8;
+
+  /**
+   * See `MODULO_MODE`.
+   */
+  static readonly EUCLID: 9;
+
+  /**
+   * To aid in debugging, if a `BigNumber.DEBUG` property is `true` then an error will be thrown
+   * on an invalid `BigNumber.Value`.
+   * 
+   * ```ts
+   * // No error, and BigNumber NaN is returned.
+   * new BigNumber('blurgh')    // 'NaN'
+   * new BigNumber(9, 2)        // 'NaN'
+   * BigNumber.DEBUG = true
+   * new BigNumber('blurgh')    // '[BigNumber Error] Not a number'
+   * new BigNumber(9, 2)        // '[BigNumber Error] Not a base 2 number'
+   * ```
+   * 
+   * An error will also be thrown if a `BigNumber.Value` is of type number with more than 15
+   * significant digits, as calling `toString` or `valueOf` on such numbers may not result
+   * in the intended value.
+   * 
+   * ```ts
+   * console.log(823456789123456.3)       //  823456789123456.2
+   * // No error, and the returned BigNumber does not have the same value as the number literal.
+   * new BigNumber(823456789123456.3)     // '823456789123456.2'
+   * BigNumber.DEBUG = true
+   * new BigNumber(823456789123456.3)     
+   * // '[BigNumber Error] Number primitive has more than 15 significant digits'
+   * ```
+   * 
+   */
+  static DEBUG?: boolean;
+}

projet/node_modules/bignumber.js/bignumber.js

+;(function (globalObject) {
+  'use strict';
+
+/*
+ *      bignumber.js v7.2.1
+ *      A JavaScript library for arbitrary-precision arithmetic.
+ *      https://github.com/MikeMcl/bignumber.js
+ *      Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>
+ *      MIT Licensed.
+ *
+ *      BigNumber.prototype methods     |  BigNumber methods
+ *                                      |
+ *      absoluteValue            abs    |  clone
+ *      comparedTo                      |  config               set
+ *      decimalPlaces            dp     |      DECIMAL_PLACES
+ *      dividedBy                div    |      ROUNDING_MODE
+ *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT
+ *      exponentiatedBy          pow    |      RANGE
+ *      integerValue                    |      CRYPTO
+ *      isEqualTo                eq     |      MODULO_MODE
+ *      isFinite                        |      POW_PRECISION
+ *      isGreaterThan            gt     |      FORMAT
+ *      isGreaterThanOrEqualTo   gte    |      ALPHABET
+ *      isInteger                       |  isBigNumber
+ *      isLessThan               lt     |  maximum              max
+ *      isLessThanOrEqualTo      lte    |  minimum              min
+ *      isNaN                           |  random
+ *      isNegative                      |
+ *      isPositive                      |
+ *      isZero                          |
+ *      minus                           |
+ *      modulo                   mod    |
+ *      multipliedBy             times  |
+ *      negated                         |
+ *      plus                            |
+ *      precision                sd     |
+ *      shiftedBy                       |
+ *      squareRoot               sqrt   |
+ *      toExponential                   |
+ *      toFixed                         |
+ *      toFormat                        |
+ *      toFraction                      |
+ *      toJSON                          |
+ *      toNumber                        |
+ *      toPrecision                     |
+ *      toString                        |
+ *      valueOf                         |
+ *
+ */
+
+
+  var BigNumber,
+    isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i,
+
+    mathceil = Math.ceil,
+    mathfloor = Math.floor,
+
+    bignumberError = '[BigNumber Error] ',
+    tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',
+
+    BASE = 1e14,
+    LOG_BASE = 14,
+    MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1
+    // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1
+    POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],
+    SQRT_BASE = 1e7,
+
+    // EDITABLE
+    // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and
+    // the arguments to toExponential, toFixed, toFormat, and toPrecision.
+    MAX = 1E9;                                   // 0 to MAX_INT32
+
+
+  /*
+   * Create and return a BigNumber constructor.
+   */
+  function clone(configObject) {
+    var div, convertBase, parseNumeric,
+      P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },
+      ONE = new BigNumber(1),
+
+
+      //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------
+
+
+      // The default values below must be integers within the inclusive ranges stated.
+      // The values can also be changed at run-time using BigNumber.set.
+
+      // The maximum number of decimal places for operations involving division.
+      DECIMAL_PLACES = 20,                     // 0 to MAX
+
+      // The rounding mode used when rounding to the above decimal places, and when using
+      // toExponential, toFixed, toFormat and toPrecision, and round (default value).
+      // UP         0 Away from zero.
+      // DOWN       1 Towards zero.
+      // CEIL       2 Towards +Infinity.
+      // FLOOR      3 Towards -Infinity.
+      // HALF_UP    4 Towards nearest neighbour. If equidistant, up.
+      // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.
+      // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.
+      // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.
+      // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.
+      ROUNDING_MODE = 4,                       // 0 to 8
+
+      // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]
+
+      // The exponent value at and beneath which toString returns exponential notation.
+      // Number type: -7
+      TO_EXP_NEG = -7,                         // 0 to -MAX
+
+      // The exponent value at and above which toString returns exponential notation.
+      // Number type: 21
+      TO_EXP_POS = 21,                         // 0 to MAX
+
+      // RANGE : [MIN_EXP, MAX_EXP]
+
+      // The minimum exponent value, beneath which underflow to zero occurs.
+      // Number type: -324  (5e-324)
+      MIN_EXP = -1e7,                          // -1 to -MAX
+
+      // The maximum exponent value, above which overflow to Infinity occurs.
+      // Number type:  308  (1.7976931348623157e+308)
+      // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.
+      MAX_EXP = 1e7,                           // 1 to MAX
+
+      // Whether to use cryptographically-secure random number generation, if available.
+      CRYPTO = false,                          // true or false
+
+      // The modulo mode used when calculating the modulus: a mod n.
+      // The quotient (q = a / n) is calculated according to the corresponding rounding mode.
+      // The remainder (r) is calculated as: r = a - n * q.
+      //
+      // UP        0 The remainder is positive if the dividend is negative, else is negative.
+      // DOWN      1 The remainder has the same sign as the dividend.
+      //             This modulo mode is commonly known as 'truncated division' and is
+      //             equivalent to (a % n) in JavaScript.
+      // FLOOR     3 The remainder has the same sign as the divisor (Python %).
+      // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.
+      // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).
+      //             The remainder is always positive.
+      //
+      // The truncated division, floored division, Euclidian division and IEEE 754 remainder
+      // modes are commonly used for the modulus operation.
+      // Although the other rounding modes can also be used, they may not give useful results.
+      MODULO_MODE = 1,                         // 0 to 9
+
+      // The maximum number of significant digits of the result of the exponentiatedBy operation.
+      // If POW_PRECISION is 0, there will be unlimited significant digits.
+      POW_PRECISION = 0,                    // 0 to MAX
+
+      // The format specification used by the BigNumber.prototype.toFormat method.
+      FORMAT = {
+        decimalSeparator: '.',
+        groupSeparator: ',',
+        groupSize: 3,
+        secondaryGroupSize: 0,
+        fractionGroupSeparator: '\xA0',      // non-breaking space
+        fractionGroupSize: 0
+      },
+
+      // The alphabet used for base conversion.
+      // It must be at least 2 characters long, with no '.' or repeated character.
+      // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
+      ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+
+
+    //------------------------------------------------------------------------------------------
+
+
+    // CONSTRUCTOR
+
+
+    /*
+     * The BigNumber constructor and exported function.
+     * Create and return a new instance of a BigNumber object.
+     *
+     * n {number|string|BigNumber} A numeric value.
+     * [b] {number} The base of n. Integer, 2 to ALPHABET.length inclusive.
+     */
+    function BigNumber(n, b) {
+      var alphabet, c, caseChanged, e, i, isNum, len, str,
+        x = this;
+
+      // Enable constructor usage without new.
+      if (!(x instanceof BigNumber)) {
+
+        // Don't throw on constructor call without new (#81).
+        // '[BigNumber Error] Constructor call without new: {n}'
+        //throw Error(bignumberError + ' Constructor call without new: ' + n);
+        return new BigNumber(n, b);
+      }
+
+      if (b == null) {
+
+        // Duplicate.
+        if (n instanceof BigNumber) {
+          x.s = n.s;
+          x.e = n.e;
+          x.c = (n = n.c) ? n.slice() : n;
+          return;
+        }
+
+        isNum = typeof n == 'number';
+
+        if (isNum && n * 0 == 0) {
+
+          // Use `1 / n` to handle minus zero also.
+          x.s = 1 / n < 0 ? (n = -n, -1) : 1;
+
+          // Faster path for integers.
+          if (n === ~~n) {
+            for (e = 0, i = n; i >= 10; i /= 10, e++);
+            x.e = e;
+            x.c = [n];
+            return;
+          }
+
+          str = n + '';
+        } else {
+          if (!isNumeric.test(str = n + '')) return parseNumeric(x, str, isNum);
+          x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;
+        }
+
+        // Decimal point?
+        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');
+
+        // Exponential form?
+        if ((i = str.search(/e/i)) > 0) {
+
+          // Determine exponent.
+          if (e < 0) e = i;
+          e += +str.slice(i + 1);
+          str = str.substring(0, i);
+        } else if (e < 0) {
+
+          // Integer.
+          e = str.length;
+        }
+
+      } else {
+
+        // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'
+        intCheck(b, 2, ALPHABET.length, 'Base');
+        str = n + '';
+
+        // Allow exponential notation to be used with base 10 argument, while
+        // also rounding to DECIMAL_PLACES as with other bases.
+        if (b == 10) {
+          x = new BigNumber(n instanceof BigNumber ? n : str);
+          return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
+        }
+
+        isNum = typeof n == 'number';
+
+        if (isNum) {
+
+          // Avoid potential interpretation of Infinity and NaN as base 44+ values.
+          if (n * 0 != 0) return parseNumeric(x, str, isNum, b);
+
+          x.s = 1 / n < 0 ? (str = str.slice(1), -1) : 1;
+
+          // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'
+          if (BigNumber.DEBUG && str.replace(/^0\.0*|\./, '').length > 15) {
+            throw Error
+             (tooManyDigits + n);
+          }
+
+          // Prevent later check for length on converted number.
+          isNum = false;
+        } else {
+          x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
+        }
+
+        alphabet = ALPHABET.slice(0, b);
+        e = i = 0;
+
+        // Check that str is a valid base b number.
+        // Don't use RegExp so alphabet can contain special characters.
+        for (len = str.length; i < len; i++) {
+          if (alphabet.indexOf(c = str.charAt(i)) < 0) {
+            if (c == '.') {
+
+              // If '.' is not the first character and it has not be found before.
+              if (i > e) {
+                e = len;
+                continue;
+              }
+            } else if (!caseChanged) {
+
+              // Allow e.g. hexadecimal 'FF' as well as 'ff'.
+              if (str == str.toUpperCase() && (str = str.toLowerCase()) ||
+                  str == str.toLowerCase() && (str = str.toUpperCase())) {
+                caseChanged = true;
+                i = -1;
+                e = 0;
+                continue;
+              }
+            }
+
+            return parseNumeric(x, n + '', isNum, b);
+          }
+        }
+
+        str = convertBase(str, b, 10, x.s);
+
+        // Decimal point?
+        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');
+        else e = str.length;
+      }
+
+      // Determine leading zeros.
+      for (i = 0; str.charCodeAt(i) === 48; i++);
+
+      // Determine trailing zeros.
+      for (len = str.length; str.charCodeAt(--len) === 48;);
+
+      str = str.slice(i, ++len);
+
+      if (str) {
+        len -= i;
+
+        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'
+        if (isNum && BigNumber.DEBUG &&
+          len > 15 && (n > MAX_SAFE_INTEGER || n !== mathfloor(n))) {
+            throw Error
+             (tooManyDigits + (x.s * n));
+        }
+
+        e = e - i - 1;
+
+         // Overflow?
+        if (e > MAX_EXP) {
+
+          // Infinity.
+          x.c = x.e = null;
+
+        // Underflow?
+        } else if (e < MIN_EXP) {
+
+          // Zero.
+          x.c = [x.e = 0];
+        } else {
+          x.e = e;
+          x.c = [];
+
+          // Transform base
+
+          // e is the base 10 exponent.
+          // i is where to slice str to get the first element of the coefficient array.
+          i = (e + 1) % LOG_BASE;
+          if (e < 0) i += LOG_BASE;
+
+          if (i < len) {
+            if (i) x.c.push(+str.slice(0, i));
+
+            for (len -= LOG_BASE; i < len;) {
+              x.c.push(+str.slice(i, i += LOG_BASE));
+            }
+
+            str = str.slice(i);
+            i = LOG_BASE - str.length;
+          } else {
+            i -= len;
+          }
+
+          for (; i--; str += '0');
+          x.c.push(+str);
+        }
+      } else {
+
+        // Zero.
+        x.c = [x.e = 0];
+      }
+    }
+
+
+    // CONSTRUCTOR PROPERTIES
+
+
+    BigNumber.clone = clone;
+
+    BigNumber.ROUND_UP = 0;
+    BigNumber.ROUND_DOWN = 1;
+    BigNumber.ROUND_CEIL = 2;
+    BigNumber.ROUND_FLOOR = 3;
+    BigNumber.ROUND_HALF_UP = 4;
+    BigNumber.ROUND_HALF_DOWN = 5;
+    BigNumber.ROUND_HALF_EVEN = 6;
+    BigNumber.ROUND_HALF_CEIL = 7;
+    BigNumber.ROUND_HALF_FLOOR = 8;
+    BigNumber.EUCLID = 9;
+
+
+    /*
+     * Configure infrequently-changing library-wide settings.
+     *
+     * Accept an object with the following optional properties (if the value of a property is
+     * a number, it must be an integer within the inclusive range stated):
+     *
+     *   DECIMAL_PLACES   {number}           0 to MAX
+     *   ROUNDING_MODE    {number}           0 to 8
+     *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]
+     *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]
+     *   CRYPTO           {boolean}          true or false
+     *   MODULO_MODE      {number}           0 to 9
+     *   POW_PRECISION       {number}           0 to MAX
+     *   ALPHABET         {string}           A string of two or more unique characters which does
+     *                                       not contain '.'.
+     *   FORMAT           {object}           An object with some of the following properties:
+     *      decimalSeparator       {string}
+     *      groupSeparator         {string}
+     *      groupSize              {number}
+     *      secondaryGroupSize     {number}
+     *      fractionGroupSeparator {string}
+     *      fractionGroupSize      {number}
+     *
+     * (The values assigned to the above FORMAT object properties are not checked for validity.)
+     *
+     * E.g.
+     * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })
+     *
+     * Ignore properties/parameters set to null or undefined, except for ALPHABET.
+     *
+     * Return an object with the properties current values.
+     */
+    BigNumber.config = BigNumber.set = function (obj) {
+      var p, v;
+
+      if (obj != null) {
+
+        if (typeof obj == 'object') {
+
+          // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.
+          // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'
+          if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {
+            v = obj[p];
+            intCheck(v, 0, MAX, p);
+            DECIMAL_PLACES = v;
+          }
+
+          // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.
+          // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'
+          if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {
+            v = obj[p];
+            intCheck(v, 0, 8, p);
+            ROUNDING_MODE = v;
+          }
+
+          // EXPONENTIAL_AT {number|number[]}
+          // Integer, -MAX to MAX inclusive or
+          // [integer -MAX to 0 inclusive, 0 to MAX inclusive].
+          // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'
+          if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {
+            v = obj[p];
+            if (isArray(v)) {
+              intCheck(v[0], -MAX, 0, p);
+              intCheck(v[1], 0, MAX, p);
+              TO_EXP_NEG = v[0];
+              TO_EXP_POS = v[1];
+            } else {
+              intCheck(v, -MAX, MAX, p);
+              TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);
+            }
+          }
+
+          // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or
+          // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].
+          // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'
+          if (obj.hasOwnProperty(p = 'RANGE')) {
+            v = obj[p];
+            if (isArray(v)) {
+              intCheck(v[0], -MAX, -1, p);
+              intCheck(v[1], 1, MAX, p);
+              MIN_EXP = v[0];
+              MAX_EXP = v[1];
+            } else {
+              intCheck(v, -MAX, MAX, p);
+              if (v) {
+                MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);
+              } else {
+                throw Error
+                 (bignumberError + p + ' cannot be zero: ' + v);
+              }
+            }
+          }
+
+          // CRYPTO {boolean} true or false.
+          // '[BigNumber Error] CRYPTO not true or false: {v}'
+          // '[BigNumber Error] crypto unavailable'
+          if (obj.hasOwnProperty(p = 'CRYPTO')) {
+            v = obj[p];
+            if (v === !!v) {
+              if (v) {
+                if (typeof crypto != 'undefined' && crypto &&
+                 (crypto.getRandomValues || crypto.randomBytes)) {
+                  CRYPTO = v;
+                } else {
+                  CRYPTO = !v;
+                  throw Error
+                   (bignumberError + 'crypto unavailable');
+                }
+              } else {
+                CRYPTO = v;
+              }
+            } else {
+              throw Error
+               (bignumberError + p + ' not true or false: ' + v);
+            }
+          }
+
+          // MODULO_MODE {number} Integer, 0 to 9 inclusive.
+          // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'
+          if (obj.hasOwnProperty(p = 'MODULO_MODE')) {
+            v = obj[p];
+            intCheck(v, 0, 9, p);
+            MODULO_MODE = v;
+          }
+
+          // POW_PRECISION {number} Integer, 0 to MAX inclusive.
+          // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'
+          if (obj.hasOwnProperty(p = 'POW_PRECISION')) {
+            v = obj[p];
+            intCheck(v, 0, MAX, p);
+            POW_PRECISION = v;
+          }
+
+          // FORMAT {object}
+          // '[BigNumber Error] FORMAT not an object: {v}'
+          if (obj.hasOwnProperty(p = 'FORMAT')) {
+            v = obj[p];
+            if (typeof v == 'object') FORMAT = v;
+            else throw Error
+             (bignumberError + p + ' not an object: ' + v);
+          }
+
+          // ALPHABET {string}
+          // '[BigNumber Error] ALPHABET invalid: {v}'
+          if (obj.hasOwnProperty(p = 'ALPHABET')) {
+            v = obj[p];
+
+            // Disallow if only one character, or contains '.' or a repeated character.
+            if (typeof v == 'string' && !/^.$|\.|(.).*\1/.test(v)) {
+              ALPHABET = v;
+            } else {
+              throw Error
+               (bignumberError + p + ' invalid: ' + v);
+            }
+          }
+
+        } else {
+
+          // '[BigNumber Error] Object expected: {v}'
+          throw Error
+           (bignumberError + 'Object expected: ' + obj);
+        }
+      }
+
+      return {
+        DECIMAL_PLACES: DECIMAL_PLACES,
+        ROUNDING_MODE: ROUNDING_MODE,
+        EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],
+        RANGE: [MIN_EXP, MAX_EXP],
+        CRYPTO: CRYPTO,
+        MODULO_MODE: MODULO_MODE,
+        POW_PRECISION: POW_PRECISION,
+        FORMAT: FORMAT,
+        ALPHABET: ALPHABET
+      };
+    };
+
+
+    /*
+     * Return true if v is a BigNumber instance, otherwise return false.
+     *
+     * v {any}
+     */
+    BigNumber.isBigNumber = function (v) {
+      return v instanceof BigNumber || v && v._isBigNumber === true || false;
+    };
+
+
+    /*
+     * Return a new BigNumber whose value is the maximum of the arguments.
+     *
+     * arguments {number|string|BigNumber}
+     */
+    BigNumber.maximum = BigNumber.max = function () {
+      return maxOrMin(arguments, P.lt);
+    };
+
+
+    /*
+     * Return a new BigNumber whose value is the minimum of the arguments.
+     *
+     * arguments {number|string|BigNumber}
+     */
+    BigNumber.minimum = BigNumber.min = function () {
+      return maxOrMin(arguments, P.gt);
+    };
+
+
+    /*
+     * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,
+     * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing
+     * zeros are produced).
+     *
+     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.
+     *
+     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'
+     * '[BigNumber Error] crypto unavailable'
+     */
+    BigNumber.random = (function () {
+      var pow2_53 = 0x20000000000000;
+
+      // Return a 53 bit integer n, where 0 <= n < 9007199254740992.
+      // Check if Math.random() produces more than 32 bits of randomness.
+      // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.
+      // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.
+      var random53bitInt = (Math.random() * pow2_53) & 0x1fffff
+       ? function () { return mathfloor(Math.random() * pow2_53); }
+       : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +
+         (Math.random() * 0x800000 | 0); };
+
+      return function (dp) {
+        var a, b, e, k, v,
+          i = 0,
+          c = [],
+          rand = new BigNumber(ONE);
+
+        if (dp == null) dp = DECIMAL_PLACES;
+        else intCheck(dp, 0, MAX);
+
+        k = mathceil(dp / LOG_BASE);
+
+        if (CRYPTO) {
+
+          // Browsers supporting crypto.getRandomValues.
+          if (crypto.getRandomValues) {
+
+            a = crypto.getRandomValues(new Uint32Array(k *= 2));
+
+            for (; i < k;) {
+
+              // 53 bits:
+              // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)
+              // 11111 11111111 11111111 11111111 11100000 00000000 00000000
+              // ((Math.pow(2, 32) - 1) >>> 11).toString(2)
+              //                                     11111 11111111 11111111
+              // 0x20000 is 2^21.
+              v = a[i] * 0x20000 + (a[i + 1] >>> 11);
+
+              // Rejection sampling:
+              // 0 <= v < 9007199254740992
+              // Probability that v >= 9e15, is
+              // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251
+              if (v >= 9e15) {
+                b = crypto.getRandomValues(new Uint32Array(2));
+                a[i] = b[0];
+                a[i + 1] = b[1];
+              } else {
+
+                // 0 <= v <= 8999999999999999
+                // 0 <= (v % 1e14) <= 99999999999999
+                c.push(v % 1e14);
+                i += 2;
+              }
+            }
+            i = k / 2;
+
+          // Node.js supporting crypto.randomBytes.
+          } else if (crypto.randomBytes) {
+
+            // buffer
+            a = crypto.randomBytes(k *= 7);
+
+            for (; i < k;) {
+
+              // 0x1000000000000 is 2^48, 0x10000000000 is 2^40
+              // 0x100000000 is 2^32, 0x1000000 is 2^24
+              // 11111 11111111 11111111 11111111 11111111 11111111 11111111
+              // 0 <= v < 9007199254740992
+              v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +
+                 (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +
+                 (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];
+
+              if (v >= 9e15) {
+                crypto.randomBytes(7).copy(a, i);
+              } else {
+
+                // 0 <= (v % 1e14) <= 99999999999999
+                c.push(v % 1e14);
+                i += 7;
+              }
+            }
+            i = k / 7;
+          } else {
+            CRYPTO = false;
+            throw Error
+             (bignumberError + 'crypto unavailable');
+          }
+        }
+
+        // Use Math.random.
+        if (!CRYPTO) {
+
+          for (; i < k;) {
+            v = random53bitInt();
+            if (v < 9e15) c[i++] = v % 1e14;
+          }
+        }
+
+        k = c[--i];
+        dp %= LOG_BASE;
+
+        // Convert trailing digits to zeros according to dp.
+        if (k && dp) {
+          v = POWS_TEN[LOG_BASE - dp];
+          c[i] = mathfloor(k / v) * v;
+        }
+
+        // Remove trailing elements which are zero.
+        for (; c[i] === 0; c.pop(), i--);
+
+        // Zero?
+        if (i < 0) {
+          c = [e = 0];
+        } else {
+
+          // Remove leading elements which are zero and adjust exponent accordingly.
+          for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);
+
+          // Count the digits of the first element of c to determine leading zeros, and...
+          for (i = 1, v = c[0]; v >= 10; v /= 10, i++);
+
+          // adjust the exponent accordingly.
+          if (i < LOG_BASE) e -= LOG_BASE - i;
+        }
+
+        rand.e = e;
+        rand.c = c;
+        return rand;
+      };
+    })();
+
+
+    // PRIVATE FUNCTIONS
+
+
+    // Called by BigNumber and BigNumber.prototype.toString.
+    convertBase = (function () {
+      var decimal = '0123456789';
+
+      /*
+       * Convert string of baseIn to an array of numbers of baseOut.
+       * Eg. toBaseOut('255', 10, 16) returns [15, 15].
+       * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].
+       */
+      function toBaseOut(str, baseIn, baseOut, alphabet) {
+        var j,
+          arr = [0],
+          arrL,
+          i = 0,
+          len = str.length;
+
+        for (; i < len;) {
+          for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);
+
+          arr[0] += alphabet.indexOf(str.charAt(i++));
+
+          for (j = 0; j < arr.length; j++) {
+
+            if (arr[j] > baseOut - 1) {
+              if (arr[j + 1] == null) arr[j + 1] = 0;
+              arr[j + 1] += arr[j] / baseOut | 0;
+              arr[j] %= baseOut;
+            }
+          }
+        }
+
+        return arr.reverse();
+      }
+
+      // Convert a numeric string of baseIn to a numeric string of baseOut.
+      // If the caller is toString, we are converting from base 10 to baseOut.
+      // If the caller is BigNumber, we are converting from baseIn to base 10.
+      return function (str, baseIn, baseOut, sign, callerIsToString) {
+        var alphabet, d, e, k, r, x, xc, y,
+          i = str.indexOf('.'),
+          dp = DECIMAL_PLACES,
+          rm = ROUNDING_MODE;
+
+        // Non-integer.
+        if (i >= 0) {
+          k = POW_PRECISION;
+
+          // Unlimited precision.
+          POW_PRECISION = 0;
+          str = str.replace('.', '');
+          y = new BigNumber(baseIn);
+          x = y.pow(str.length - i);
+          POW_PRECISION = k;
+
+          // Convert str as if an integer, then restore the fraction part by dividing the
+          // result by its base raised to a power.
+
+          y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),
+           10, baseOut, decimal);
+          y.e = y.c.length;
+        }
+
+        // Convert the number as integer.
+
+        xc = toBaseOut(str, baseIn, baseOut, callerIsToString
+         ? (alphabet = ALPHABET, decimal)
+         : (alphabet = decimal, ALPHABET));
+
+        // xc now represents str as an integer and converted to baseOut. e is the exponent.
+        e = k = xc.length;
+
+        // Remove trailing zeros.
+        for (; xc[--k] == 0; xc.pop());
+
+        // Zero?
+        if (!xc[0]) return alphabet.charAt(0);
+
+        // Does str represent an integer? If so, no need for the division.
+        if (i < 0) {
+          --e;
+        } else {
+          x.c = xc;
+          x.e = e;
+
+          // The sign is needed for correct rounding.
+          x.s = sign;
+          x = div(x, y, dp, rm, baseOut);
+          xc = x.c;
+          r = x.r;
+          e = x.e;
+        }
+
+        // xc now represents str converted to baseOut.
+
+        // THe index of the rounding digit.
+        d = e + dp + 1;
+
+        // The rounding digit: the digit to the right of the digit that may be rounded up.
+        i = xc[d];
+
+        // Look at the rounding digits and mode to determine whether to round up.
+
+        k = baseOut / 2;
+        r = r || d < 0 || xc[d + 1] != null;
+
+        r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))
+              : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||
+               rm == (x.s < 0 ? 8 : 7));
+
+        // If the index of the rounding digit is not greater than zero, or xc represents
+        // zero, then the result of the base conversion is zero or, if rounding up, a value
+        // such as 0.00001.
+        if (d < 1 || !xc[0]) {
+
+          // 1^-dp or 0
+          str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0))
+              : alphabet.charAt(0);
+        } else {
+
+          // Truncate xc to the required number of decimal places.
+          xc.length = d;
+
+          // Round up?
+          if (r) {
+
+            // Rounding up may mean the previous digit has to be rounded up and so on.
+            for (--baseOut; ++xc[--d] > baseOut;) {
+              xc[d] = 0;
+
+              if (!d) {
+                ++e;
+                xc = [1].concat(xc);
+              }
+            }
+          }
+
+          // Determine trailing zeros.
+          for (k = xc.length; !xc[--k];);
+
+          // E.g. [4, 11, 15] becomes 4bf.
+          for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));
+
+          // Add leading zeros, decimal point and trailing zeros as required.
+          str = toFixedPoint(str, e, alphabet.charAt(0));
+        }
+
+        // The caller will add the sign.
+        return str;
+      };
+    })();
+
+
+    // Perform division in the specified base. Called by div and convertBase.
+    div = (function () {
+
+      // Assume non-zero x and k.
+      function multiply(x, k, base) {
+        var m, temp, xlo, xhi,
+          carry = 0,
+          i = x.length,
+          klo = k % SQRT_BASE,
+          khi = k / SQRT_BASE | 0;
+
+        for (x = x.slice(); i--;) {
+          xlo = x[i] % SQRT_BASE;
+          xhi = x[i] / SQRT_BASE | 0;
+          m = khi * xlo + xhi * klo;
+          temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;
+          carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;
+          x[i] = temp % base;
+        }
+
+        if (carry) x = [carry].concat(x);
+
+        return x;
+      }
+
+      function compare(a, b, aL, bL) {
+        var i, cmp;
+
+        if (aL != bL) {
+          cmp = aL > bL ? 1 : -1;
+        } else {
+
+          for (i = cmp = 0; i < aL; i++) {
+
+            if (a[i] != b[i]) {
+              cmp = a[i] > b[i] ? 1 : -1;
+              break;
+            }
+          }
+        }
+
+        return cmp;
+      }
+
+      function subtract(a, b, aL, base) {
+        var i = 0;
+
+        // Subtract b from a.
+        for (; aL--;) {
+          a[aL] -= i;
+          i = a[aL] < b[aL] ? 1 : 0;
+          a[aL] = i * base + a[aL] - b[aL];
+        }
+
+        // Remove leading zeros.
+        for (; !a[0] && a.length > 1; a.splice(0, 1));
+      }
+
+      // x: dividend, y: divisor.
+      return function (x, y, dp, rm, base) {
+        var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,
+          yL, yz,
+          s = x.s == y.s ? 1 : -1,
+          xc = x.c,
+          yc = y.c;
+
+        // Either NaN, Infinity or 0?
+        if (!xc || !xc[0] || !yc || !yc[0]) {
+
+          return new BigNumber(
+
+           // Return NaN if either NaN, or both Infinity or 0.
+           !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :
+
+            // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.
+            xc && xc[0] == 0 || !yc ? s * 0 : s / 0
+         );
+        }
+
+        q = new BigNumber(s);
+        qc = q.c = [];
+        e = x.e - y.e;
+        s = dp + e + 1;
+
+        if (!base) {
+          base = BASE;
+          e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);
+          s = s / LOG_BASE | 0;
+        }
+
+        // Result exponent may be one less then the current value of e.
+        // The coefficients of the BigNumbers from convertBase may have trailing zeros.
+        for (i = 0; yc[i] == (xc[i] || 0); i++);
+
+        if (yc[i] > (xc[i] || 0)) e--;
+
+        if (s < 0) {
+          qc.push(1);
+          more = true;
+        } else {
+          xL = xc.length;
+          yL = yc.length;
+          i = 0;
+          s += 2;
+
+          // Normalise xc and yc so highest order digit of yc is >= base / 2.
+
+          n = mathfloor(base / (yc[0] + 1));
+
+          // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.
+          // if (n > 1 || n++ == 1 && yc[0] < base / 2) {
+          if (n > 1) {
+            yc = multiply(yc, n, base);
+            xc = multiply(xc, n, base);
+            yL = yc.length;
+            xL = xc.length;
+          }
+
+          xi = yL;
+          rem = xc.slice(0, yL);
+          remL = rem.length;
+
+          // Add zeros to make remainder as long as divisor.
+          for (; remL < yL; rem[remL++] = 0);
+          yz = yc.slice();
+          yz = [0].concat(yz);
+          yc0 = yc[0];
+          if (yc[1] >= base / 2) yc0++;
+          // Not necessary, but to prevent trial digit n > base, when using base 3.
+          // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;
+
+          do {
+            n = 0;
+
+            // Compare divisor and remainder.
+            cmp = compare(yc, rem, yL, remL);
+
+            // If divisor < remainder.
+            if (cmp < 0) {
+
+              // Calculate trial digit, n.
+
+              rem0 = rem[0];
+              if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);
+
+              // n is how many times the divisor goes into the current remainder.
+              n = mathfloor(rem0 / yc0);
+
+              //  Algorithm:
+              //  product = divisor multiplied by trial digit (n).
+              //  Compare product and remainder.
+              //  If product is greater than remainder:
+              //    Subtract divisor from product, decrement trial digit.
+              //  Subtract product from remainder.
+              //  If product was less than remainder at the last compare:
+              //    Compare new remainder and divisor.
+              //    If remainder is greater than divisor:
+              //      Subtract divisor from remainder, increment trial digit.
+
+              if (n > 1) {
+
+                // n may be > base only when base is 3.
+                if (n >= base) n = base - 1;
+
+                // product = divisor * trial digit.
+                prod = multiply(yc, n, base);
+                prodL = prod.length;
+                remL = rem.length;
+
+                // Compare product and remainder.
+                // If product > remainder then trial digit n too high.
+                // n is 1 too high about 5% of the time, and is not known to have
+                // ever been more than 1 too high.
+                while (compare(prod, rem, prodL, remL) == 1) {
+                  n--;
+
+                  // Subtract divisor from product.
+                  subtract(prod, yL < prodL ? yz : yc, prodL, base);
+                  prodL = prod.length;
+                  cmp = 1;
+                }
+              } else {
+
+                // n is 0 or 1, cmp is -1.
+                // If n is 0, there is no need to compare yc and rem again below,
+                // so change cmp to 1 to avoid it.
+                // If n is 1, leave cmp as -1, so yc and rem are compared again.
+                if (n == 0) {
+
+                  // divisor < remainder, so n must be at least 1.
+                  cmp = n = 1;
+                }
+
+                // product = divisor
+                prod = yc.slice();
+                prodL = prod.length;
+              }
+
+              if (prodL < remL) prod = [0].concat(prod);
+
+              // Subtract product from remainder.
+              subtract(rem, prod, remL, base);
+              remL = rem.length;
+
+               // If product was < remainder.
+              if (cmp == -1) {
+
+                // Compare divisor and new remainder.
+                // If divisor < new remainder, subtract divisor from remainder.
+                // Trial digit n too low.
+                // n is 1 too low about 5% of the time, and very rarely 2 too low.
+                while (compare(yc, rem, yL, remL) < 1) {
+                  n++;
+
+                  // Subtract divisor from remainder.
+                  subtract(rem, yL < remL ? yz : yc, remL, base);
+                  remL = rem.length;
+                }
+              }
+            } else if (cmp === 0) {
+              n++;
+              rem = [0];
+            } // else cmp === 1 and n will be 0
+
+            // Add the next digit, n, to the result array.
+            qc[i++] = n;
+
+            // Update the remainder.
+            if (rem[0]) {
+              rem[remL++] = xc[xi] || 0;
+            } else {
+              rem = [xc[xi]];
+              remL = 1;
+            }
+          } while ((xi++ < xL || rem[0] != null) && s--);
+
+          more = rem[0] != null;
+
+          // Leading zero?
+          if (!qc[0]) qc.splice(0, 1);
+        }
+
+        if (base == BASE) {
+
+          // To calculate q.e, first get the number of digits of qc[0].
+          for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);
+
+          round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);
+
+        // Caller is convertBase.
+        } else {
+          q.e = e;
+          q.r = +more;
+        }
+
+        return q;
+      };
+    })();
+
+
+    /*
+     * Return a string representing the value of BigNumber n in fixed-point or exponential
+     * notation rounded to the specified decimal places or significant digits.
+     *
+     * n: a BigNumber.
+     * i: the index of the last digit required (i.e. the digit that may be rounded up).
+     * rm: the rounding mode.
+     * id: 1 (toExponential) or 2 (toPrecision).
+     */
+    function format(n, i, rm, id) {
+      var c0, e, ne, len, str;
+
+      if (rm == null) rm = ROUNDING_MODE;
+      else intCheck(rm, 0, 8);
+
+      if (!n.c) return n.toString();
+
+      c0 = n.c[0];
+      ne = n.e;
+
+      if (i == null) {
+        str = coeffToString(n.c);
+        str = id == 1 || id == 2 && ne <= TO_EXP_NEG
+         ? toExponential(str, ne)
+         : toFixedPoint(str, ne, '0');
+      } else {
+        n = round(new BigNumber(n), i, rm);
+
+        // n.e may have changed if the value was rounded up.
+        e = n.e;
+
+        str = coeffToString(n.c);
+        len = str.length;
+
+        // toPrecision returns exponential notation if the number of significant digits
+        // specified is less than the number of digits necessary to represent the integer
+        // part of the value in fixed-point notation.
+
+        // Exponential notation.
+        if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {
+
+          // Append zeros?
+          for (; len < i; str += '0', len++);
+          str = toExponential(str, e);
+
+        // Fixed-point notation.
+        } else {
+          i -= ne;
+          str = toFixedPoint(str, e, '0');
+
+          // Append zeros?
+          if (e + 1 > len) {
+            if (--i > 0) for (str += '.'; i--; str += '0');
+          } else {
+            i += e - len;
+            if (i > 0) {
+              if (e + 1 == len) str += '.';
+              for (; i--; str += '0');
+            }
+          }
+        }
+      }
+
+      return n.s < 0 && c0 ? '-' + str : str;
+    }
+
+
+    // Handle BigNumber.max and BigNumber.min.
+    function maxOrMin(args, method) {
+      var m, n,
+        i = 0;
+
+      if (isArray(args[0])) args = args[0];
+      m = new BigNumber(args[0]);
+
+      for (; ++i < args.length;) {
+        n = new BigNumber(args[i]);
+
+        // If any number is NaN, return NaN.
+        if (!n.s) {
+          m = n;
+          break;
+        } else if (method.call(m, n)) {
+          m = n;
+        }
+      }
+
+      return m;
+    }
+
+
+    /*
+     * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.
+     * Called by minus, plus and times.
+     */
+    function normalise(n, c, e) {
+      var i = 1,
+        j = c.length;
+
+       // Remove trailing zeros.
+      for (; !c[--j]; c.pop());
+
+      // Calculate the base 10 exponent. First get the number of digits of c[0].
+      for (j = c[0]; j >= 10; j /= 10, i++);
+
+      // Overflow?
+      if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {
+
+        // Infinity.
+        n.c = n.e = null;
+
+      // Underflow?
+      } else if (e < MIN_EXP) {
+
+        // Zero.
+        n.c = [n.e = 0];
+      } else {
+        n.e = e;
+        n.c = c;
+      }
+
+      return n;
+    }
+
+
+    // Handle values that fail the validity test in BigNumber.
+    parseNumeric = (function () {
+      var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i,
+        dotAfter = /^([^.]+)\.$/,
+        dotBefore = /^\.([^.]+)$/,
+        isInfinityOrNaN = /^-?(Infinity|NaN)$/,
+        whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g;
+
+      return function (x, str, isNum, b) {
+        var base,
+          s = isNum ? str : str.replace(whitespaceOrPlus, '');
+
+        // No exception on ±Infinity or NaN.
+        if (isInfinityOrNaN.test(s)) {
+          x.s = isNaN(s) ? null : s < 0 ? -1 : 1;
+          x.c = x.e = null;
+        } else {
+          if (!isNum) {
+
+            // basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i
+            s = s.replace(basePrefix, function (m, p1, p2) {
+              base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;
+              return !b || b == base ? p1 : m;
+            });
+
+            if (b) {
+              base = b;
+
+              // E.g. '1.' to '1', '.1' to '0.1'
+              s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');
+            }
+
+            if (str != s) return new BigNumber(s, base);
+          }
+
+          // '[BigNumber Error] Not a number: {n}'
+          // '[BigNumber Error] Not a base {b} number: {n}'
+          if (BigNumber.DEBUG) {
+            throw Error
+              (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);
+          }
+
+          // NaN
+          x.c = x.e = x.s = null;
+        }
+      }
+    })();
+
+
+    /*
+     * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.
+     * If r is truthy, it is known that there are more digits after the rounding digit.
+     */
+    function round(x, sd, rm, r) {
+      var d, i, j, k, n, ni, rd,
+        xc = x.c,
+        pows10 = POWS_TEN;
+
+      // if x is not Infinity or NaN...
+      if (xc) {
+
+        // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.
+        // n is a base 1e14 number, the value of the element of array x.c containing rd.
+        // ni is the index of n within x.c.
+        // d is the number of digits of n.
+        // i is the index of rd within n including leading zeros.
+        // j is the actual index of rd within n (if < 0, rd is a leading zero).
+        out: {
+
+          // Get the number of digits of the first element of xc.
+          for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);
+          i = sd - d;
+
+          // If the rounding digit is in the first element of xc...
+          if (i < 0) {
+            i += LOG_BASE;
+            j = sd;
+            n = xc[ni = 0];
+
+            // Get the rounding digit at index j of n.
+            rd = n / pows10[d - j - 1] % 10 | 0;
+          } else {
+            ni = mathceil((i + 1) / LOG_BASE);
+
+            if (ni >= xc.length) {
+
+              if (r) {
+
+                // Needed by sqrt.
+                for (; xc.length <= ni; xc.push(0));
+                n = rd = 0;
+                d = 1;
+                i %= LOG_BASE;
+                j = i - LOG_BASE + 1;
+              } else {
+                break out;
+              }
+            } else {
+              n = k = xc[ni];
+
+              // Get the number of digits of n.
+              for (d = 1; k >= 10; k /= 10, d++);
+
+              // Get the index of rd within n.
+              i %= LOG_BASE;
+
+              // Get the index of rd within n, adjusted for leading zeros.
+              // The number of leading zeros of n is given by LOG_BASE - d.
+              j = i - LOG_BASE + d;
+
+              // Get the rounding digit at index j of n.
+              rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;
+            }
+          }
+
+          r = r || sd < 0 ||
+
+          // Are there any non-zero digits after the rounding digit?
+          // The expression  n % pows10[d - j - 1]  returns all digits of n to the right
+          // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.
+           xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);
+
+          r = rm < 4
+           ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))
+           : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&
+
+            // Check whether the digit to the left of the rounding digit is odd.
+            ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||
+             rm == (x.s < 0 ? 8 : 7));
+
+          if (sd < 1 || !xc[0]) {
+            xc.length = 0;
+
+            if (r) {
+
+              // Convert sd to decimal places.
+              sd -= x.e + 1;
+
+              // 1, 0.1, 0.01, 0.001, 0.0001 etc.
+              xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];
+              x.e = -sd || 0;
+            } else {
+
+              // Zero.
+              xc[0] = x.e = 0;
+            }
+
+            return x;
+          }
+
+          // Remove excess digits.
+          if (i == 0) {
+            xc.length = ni;
+            k = 1;
+            ni--;
+          } else {
+            xc.length = ni + 1;
+            k = pows10[LOG_BASE - i];
+
+            // E.g. 56700 becomes 56000 if 7 is the rounding digit.
+            // j > 0 means i > number of leading zeros of n.
+            xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;
+          }
+
+          // Round up?
+          if (r) {
+
+            for (; ;) {
+
+              // If the digit to be rounded up is in the first element of xc...
+              if (ni == 0) {
+
+                // i will be the length of xc[0] before k is added.
+                for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);
+                j = xc[0] += k;
+                for (k = 1; j >= 10; j /= 10, k++);
+
+                // if i != k the length has increased.
+                if (i != k) {
+                  x.e++;
+                  if (xc[0] == BASE) xc[0] = 1;
+                }
+
+                break;
+              } else {
+                xc[ni] += k;
+                if (xc[ni] != BASE) break;
+                xc[ni--] = 0;
+                k = 1;
+              }
+            }
+          }
+
+          // Remove trailing zeros.
+          for (i = xc.length; xc[--i] === 0; xc.pop());
+        }
+
+        // Overflow? Infinity.
+        if (x.e > MAX_EXP) {
+          x.c = x.e = null;
+
+        // Underflow? Zero.
+        } else if (x.e < MIN_EXP) {
+          x.c = [x.e = 0];
+        }
+      }
+
+      return x;
+    }
+
+
+    // PROTOTYPE/INSTANCE METHODS
+
+
+    /*
+     * Return a new BigNumber whose value is the absolute value of this BigNumber.
+     */
+    P.absoluteValue = P.abs = function () {
+      var x = new BigNumber(this);
+      if (x.s < 0) x.s = 1;
+      return x;
+    };
+
+
+    /*
+     * Return
+     *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),
+     *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),
+     *   0 if they have the same value,
+     *   or null if the value of either is NaN.
+     */
+    P.comparedTo = function (y, b) {
+      return compare(this, new BigNumber(y, b));
+    };
+
+
+    /*
+     * If dp is undefined or null or true or false, return the number of decimal places of the
+     * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.
+     *
+     * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this
+     * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or
+     * ROUNDING_MODE if rm is omitted.
+     *
+     * [dp] {number} Decimal places: integer, 0 to MAX inclusive.
+     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'
+     */
+    P.decimalPlaces = P.dp = function (dp, rm) {
+      var c, n, v,
+        x = this;
+
+      if (dp != null) {
+        intCheck(dp, 0, MAX);
+        if (rm == null) rm = ROUNDING_MODE;
+        else intCheck(rm, 0, 8);
+
+        return round(new BigNumber(x), dp + x.e + 1, rm);
+      }
+
+      if (!(c = x.c)) return null;
+      n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;
+
+      // Subtract the number of trailing zeros of the last number.
+      if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);
+      if (n < 0) n = 0;
+
+      return n;
+    };
+
+
+    /*
+     *  n / 0 = I
+     *  n / N = N
+     *  n / I = 0
+     *  0 / n = 0
+     *  0 / 0 = N
+     *  0 / N = N
+     *  0 / I = 0
+     *  N / n = N
+     *  N / 0 = N
+     *  N / N = N
+     *  N / I = N
+     *  I / n = I
+     *  I / 0 = I
+     *  I / N = N
+     *  I / I = N
+     *
+     * Return a new BigNumber whose value is the value of this BigNumber divided by the value of
+     * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.
+     */
+    P.dividedBy = P.div = function (y, b) {
+      return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);
+    };
+
+
+    /*
+     * Return a new BigNumber whose value is the integer part of dividing the value of this
+     * BigNumber by the value of BigNumber(y, b).
+     */
+    P.dividedToIntegerBy = P.idiv = function (y, b) {
+      return div(this, new BigNumber(y, b), 0, 1);
+    };
+
+
+    /*
+     * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.
+     *
+     * If m is present, return the result modulo m.
+     * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.
+     * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.
+     *
+     * The modular power operation works efficiently when x, n, and m are integers, otherwise it
+     * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.
+     *
+     * n {number|string|BigNumber} The exponent. An integer.
+     * [m] {number|string|BigNumber} The modulus.
+     *
+     * '[BigNumber Error] Exponent not an integer: {n}'
+     */
+    P.exponentiatedBy = P.pow = function (n, m) {
+      var half, isModExp, k, more, nIsBig, nIsNeg, nIsOdd, y,
+        x = this;
+
+      n = new BigNumber(n);
+
+      // Allow NaN and ±Infinity, but not other non-integers.
+      if (n.c && !n.isInteger()) {
+        throw Error
+          (bignumberError + 'Exponent not an integer: ' + n);
+      }
+
+      if (m != null) m = new BigNumber(m);
+
+      // Exponent of MAX_SAFE_INTEGER is 15.
+      nIsBig = n.e > 14;
+
+      // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.
+      if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {
+
+        // The sign of the result of pow when x is negative depends on the evenness of n.
+        // If +n overflows to ±Infinity, the evenness of n would be not be known.
+        y = new BigNumber(Math.pow(+x.valueOf(), nIsBig ? 2 - isOdd(n) : +n));
+        return m ? y.mod(m) : y;
+      }
+
+      nIsNeg = n.s < 0;
+
+      if (m) {
+
+        // x % m returns NaN if abs(m) is zero, or m is NaN.
+        if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);
+
+        isModExp = !nIsNeg && x.isInteger() && m.isInteger();
+
+        if (isModExp) x = x.mod(m);
+
+      // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.
+      // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.
+      } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0
+        // [1, 240000000]
+        ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7
+        // [80000000000000]  [99999750000000]
+        : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {
+
+        // If x is negative and n is odd, k = -0, else k = 0.
+        k = x.s < 0 && isOdd(n) ? -0 : 0;
+
+        // If x >= 1, k = ±Infinity.
+        if (x.e > -1) k = 1 / k;
+
+        // If n is negative return ±0, else return ±Infinity.
+        return new BigNumber(nIsNeg ? 1 / k : k);
+
+      } else if (POW_PRECISION) {
+
+        // Truncating each coefficient array to a length of k after each multiplication
+        // equates to truncating significant digits to POW_PRECISION + [28, 41],
+        // i.e. there will be a minimum of 28 guard digits retained.
+        k = mathceil(POW_PRECISION / LOG_BASE + 2);
+      }
+
+      if (nIsBig) {
+        half = new BigNumber(0.5);
+        nIsOdd = isOdd(n);
+      } else {
+        nIsOdd = n % 2;
+      }
+
+      if (nIsNeg) n.s = 1;
+
+      y = new BigNumber(ONE);
+
+      // Performs 54 loop iterations for n of 9007199254740991.
+      for (; ;) {
+
+        if (nIsOdd) {
+          y = y.times(x);
+          if (!y.c) break;
+
+          if (k) {
+            if (y.c.length > k) y.c.length = k;
+          } else if (isModExp) {
+            y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));
+          }
+        }
+
+        if (nIsBig) {
+          n = n.times(half);
+          round(n, n.e + 1, 1);
+          if (!n.c[0]) break;
+          nIsBig = n.e > 14;
+          nIsOdd = isOdd(n);
+        } else {
+          n = mathfloor(n / 2);
+          if (!n) break;
+          nIsOdd = n % 2;
+        }
+
+        x = x.times(x);
+
+        if (k) {
+          if (x.c && x.c.length > k) x.c.length = k;
+        } else if (isModExp) {
+          x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));
+        }
+      }
+
+      if (isModExp) return y;
+      if (nIsNeg) y = ONE.div(y);
+
+      return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;
+    };
+
+
+    /*
+     * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer
+     * using rounding mode rm, or ROUNDING_MODE if rm is omitted.
+     *
+     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'
+     */
+    P.integerValue = function (rm) {
+      var n = new BigNumber(this);
+      if (rm == null) rm = ROUNDING_MODE;
+      else intCheck(rm, 0, 8);
+      return round(n, n.e + 1, rm);
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),
+     * otherwise return false.
+     */
+    P.isEqualTo = P.eq = function (y, b) {
+      return compare(this, new BigNumber(y, b)) === 0;
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is a finite number, otherwise return false.
+     */
+    P.isFinite = function () {
+      return !!this.c;
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),
+     * otherwise return false.
+     */
+    P.isGreaterThan = P.gt = function (y, b) {
+      return compare(this, new BigNumber(y, b)) > 0;
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is greater than or equal to the value of
+     * BigNumber(y, b), otherwise return false.
+     */
+    P.isGreaterThanOrEqualTo = P.gte = function (y, b) {
+      return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;
+
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is an integer, otherwise return false.
+     */
+    P.isInteger = function () {
+      return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),
+     * otherwise return false.
+     */
+    P.isLessThan = P.lt = function (y, b) {
+      return compare(this, new BigNumber(y, b)) < 0;
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is less than or equal to the value of
+     * BigNumber(y, b), otherwise return false.
+     */
+    P.isLessThanOrEqualTo = P.lte = function (y, b) {
+      return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is NaN, otherwise return false.
+     */
+    P.isNaN = function () {
+      return !this.s;
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is negative, otherwise return false.
+     */
+    P.isNegative = function () {
+      return this.s < 0;
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is positive, otherwise return false.
+     */
+    P.isPositive = function () {
+      return this.s > 0;
+    };
+
+
+    /*
+     * Return true if the value of this BigNumber is 0 or -0, otherwise return false.
+     */
+    P.isZero = function () {
+      return !!this.c && this.c[0] == 0;
+    };
+
+
+    /*
+     *  n - 0 = n
+     *  n - N = N
+     *  n - I = -I
+     *  0 - n = -n
+     *  0 - 0 = 0
+     *  0 - N = N
+     *  0 - I = -I
+     *  N - n = N
+     *  N - 0 = N
+     *  N - N = N
+     *  N - I = N
+     *  I - n = I
+     *  I - 0 = I
+     *  I - N = N
+     *  I - I = N
+     *
+     * Return a new BigNumber whose value is the value of this BigNumber minus the value of
+     * BigNumber(y, b).
+     */
+    P.minus = function (y, b) {
+      var i, j, t, xLTy,
+        x = this,
+        a = x.s;
+
+      y = new BigNumber(y, b);
+      b = y.s;
+
+      // Either NaN?
+      if (!a || !b) return new BigNumber(NaN);
+
+      // Signs differ?
+      if (a != b) {
+        y.s = -b;
+        return x.plus(y);
+      }
+
+      var xe = x.e / LOG_BASE,
+        ye = y.e / LOG_BASE,
+        xc = x.c,
+        yc = y.c;
+
+      if (!xe || !ye) {
+
+        // Either Infinity?
+        if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);
+
+        // Either zero?
+        if (!xc[0] || !yc[0]) {
+
+          // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.
+          return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :
+
+           // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity
+           ROUNDING_MODE == 3 ? -0 : 0);
+        }
+      }
+
+      xe = bitFloor(xe);
+      ye = bitFloor(ye);
+      xc = xc.slice();
+
+      // Determine which is the bigger number.
+      if (a = xe - ye) {
+
+        if (xLTy = a < 0) {
+          a = -a;
+          t = xc;
+        } else {
+          ye = xe;
+          t = yc;
+        }
+
+        t.reverse();
+
+        // Prepend zeros to equalise exponents.
+        for (b = a; b--; t.push(0));
+        t.reverse();
+      } else {
+
+        // Exponents equal. Check digit by digit.
+        j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;
+
+        for (a = b = 0; b < j; b++) {
+
+          if (xc[b] != yc[b]) {
+            xLTy = xc[b] < yc[b];
+            break;
+          }
+        }
+      }
+
+      // x < y? Point xc to the array of the bigger number.
+      if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;
+
+      b = (j = yc.length) - (i = xc.length);
+
+      // Append zeros to xc if shorter.
+      // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.
+      if (b > 0) for (; b--; xc[i++] = 0);
+      b = BASE - 1;
+
+      // Subtract yc from xc.
+      for (; j > a;) {
+
+        if (xc[--j] < yc[j]) {
+          for (i = j; i && !xc[--i]; xc[i] = b);
+          --xc[i];
+          xc[j] += BASE;
+        }
+
+        xc[j] -= yc[j];
+      }
+
+      // Remove leading zeros and adjust exponent accordingly.
+      for (; xc[0] == 0; xc.splice(0, 1), --ye);
+
+      // Zero?
+      if (!xc[0]) {
+
+        // Following IEEE 754 (2008) 6.3,
+        // n - n = +0  but  n - n = -0  when rounding towards -Infinity.
+        y.s = ROUNDING_MODE == 3 ? -1 : 1;
+        y.c = [y.e = 0];
+        return y;
+      }
+
+      // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity
+      // for finite x and y.
+      return normalise(y, xc, ye);
+    };
+
+
+    /*
+     *   n % 0 =  N
+     *   n % N =  N
+     *   n % I =  n
+     *   0 % n =  0
+     *  -0 % n = -0
+     *   0 % 0 =  N
+     *   0 % N =  N
+     *   0 % I =  0
+     *   N % n =  N
+     *   N % 0 =  N
+     *   N % N =  N
+     *   N % I =  N
+     *   I % n =  N
+     *   I % 0 =  N
+     *   I % N =  N
+     *   I % I =  N
+     *
+     * Return a new BigNumber whose value is the value of this BigNumber modulo the value of
+     * BigNumber(y, b). The result depends on the value of MODULO_MODE.
+     */
+    P.modulo = P.mod = function (y, b) {
+      var q, s,
+        x = this;
+
+      y = new BigNumber(y, b);
+
+      // Return NaN if x is Infinity or NaN, or y is NaN or zero.
+      if (!x.c || !y.s || y.c && !y.c[0]) {
+        return new BigNumber(NaN);
+
+      // Return x if y is Infinity or x is zero.
+      } else if (!y.c || x.c && !x.c[0]) {
+        return new BigNumber(x);
+      }
+
+      if (MODULO_MODE == 9) {
+
+        // Euclidian division: q = sign(y) * floor(x / abs(y))
+        // r = x - qy    where  0 <= r < abs(y)
+        s = y.s;
+        y.s = 1;
+        q = div(x, y, 0, 3);
+        y.s = s;
+        q.s *= s;
+      } else {
+        q = div(x, y, 0, MODULO_MODE);
+      }
+
+      y = x.minus(q.times(y));
+
+      // To match JavaScript %, ensure sign of zero is sign of dividend.
+      if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;
+
+      return y;
+    };
+
+
+    /*
+     *  n * 0 = 0
+     *  n * N = N
+     *  n * I = I
+     *  0 * n = 0
+     *  0 * 0 = 0
+     *  0 * N = N
+     *  0 * I = N
+     *  N * n = N
+     *  N * 0 = N
+     *  N * N = N
+     *  N * I = N
+     *  I * n = I
+     *  I * 0 = N
+     *  I * N = N
+     *  I * I = I
+     *
+     * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value
+     * of BigNumber(y, b).
+     */
+    P.multipliedBy = P.times = function (y, b) {
+      var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,
+        base, sqrtBase,
+        x = this,
+        xc = x.c,
+        yc = (y = new BigNumber(y, b)).c;
+
+      // Either NaN, ±Infinity or ±0?
+      if (!xc || !yc || !xc[0] || !yc[0]) {
+
+        // Return NaN if either is NaN, or one is 0 and the other is Infinity.
+        if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {
+          y.c = y.e = y.s = null;
+        } else {
+          y.s *= x.s;
+
+          // Return ±Infinity if either is ±Infinity.
+          if (!xc || !yc) {
+            y.c = y.e = null;
+
+          // Return ±0 if either is ±0.
+          } else {
+            y.c = [0];
+            y.e = 0;
+          }
+        }
+
+        return y;
+      }
+
+      e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);
+      y.s *= x.s;
+      xcL = xc.length;
+      ycL = yc.length;
+
+      // Ensure xc points to longer array and xcL to its length.
+      if (xcL < ycL) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;
+
+      // Initialise the result array with zeros.
+      for (i = xcL + ycL, zc = []; i--; zc.push(0));
+
+      base = BASE;
+      sqrtBase = SQRT_BASE;
+
+      for (i = ycL; --i >= 0;) {
+        c = 0;
+        ylo = yc[i] % sqrtBase;
+        yhi = yc[i] / sqrtBase | 0;
+
+        for (k = xcL, j = i + k; j > i;) {
+          xlo = xc[--k] % sqrtBase;
+          xhi = xc[k] / sqrtBase | 0;
+          m = yhi * xlo + xhi * ylo;
+          xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;
+          c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;
+          zc[j--] = xlo % base;
+        }
+
+        zc[j] = c;
+      }
+
+      if (c) {
+        ++e;
+      } else {
+        zc.splice(0, 1);
+      }
+
+      return normalise(y, zc, e);
+    };
+
+
+    /*
+     * Return a new BigNumber whose value is the value of this BigNumber negated,
+     * i.e. multiplied by -1.
+     */
+    P.negated = function () {
+      var x = new BigNumber(this);
+      x.s = -x.s || null;
+      return x;
+    };
+
+
+    /*
+     *  n + 0 = n
+     *  n + N = N
+     *  n + I = I
+     *  0 + n = n
+     *  0 + 0 = 0
+     *  0 + N = N
+     *  0 + I = I
+     *  N + n = N
+     *  N + 0 = N
+     *  N + N = N
+     *  N + I = N
+     *  I + n = I
+     *  I + 0 = I
+     *  I + N = N
+     *  I + I = I
+     *
+     * Return a new BigNumber whose value is the value of this BigNumber plus the value of
+     * BigNumber(y, b).
+     */
+    P.plus = function (y, b) {
+      var t,
+        x = this,
+        a = x.s;
+
+      y = new BigNumber(y, b);
+      b = y.s;
+
+      // Either NaN?
+      if (!a || !b) return new BigNumber(NaN);
+
+      // Signs differ?
+       if (a != b) {
+        y.s = -b;
+        return x.minus(y);
+      }
+
+      var xe = x.e / LOG_BASE,
+        ye = y.e / LOG_BASE,
+        xc = x.c,
+        yc = y.c;
+
+      if (!xe || !ye) {
+
+        // Return ±Infinity if either ±Infinity.
+        if (!xc || !yc) return new BigNumber(a / 0);
+
+        // Either zero?
+        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.
+        if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);
+      }
+
+      xe = bitFloor(xe);
+      ye = bitFloor(ye);
+      xc = xc.slice();
+
+      // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.
+      if (a = xe - ye) {
+        if (a > 0) {
+          ye = xe;
+          t = yc;
+        } else {
+          a = -a;
+          t = xc;
+        }
+
+        t.reverse();
+        for (; a--; t.push(0));
+        t.reverse();
+      }
+
+      a = xc.length;
+      b = yc.length;
+
+      // Point xc to the longer array, and b to the shorter length.
+      if (a - b < 0) t = yc, yc = xc, xc = t, b = a;
+
+      // Only start adding at yc.length - 1 as the further digits of xc can be ignored.
+      for (a = 0; b;) {
+        a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;
+        xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;
+      }
+
+      if (a) {
+        xc = [a].concat(xc);
+        ++ye;
+      }
+
+      // No need to check for zero, as +x + +y != 0 && -x + -y != 0
+      // ye = MAX_EXP + 1 possible
+      return normalise(y, xc, ye);
+    };
+
+
+    /*
+     * If sd is undefined or null or true or false, return the number of significant digits of
+     * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.
+     * If sd is true include integer-part trailing zeros in the count.
+     *
+     * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this
+     * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or
+     * ROUNDING_MODE if rm is omitted.
+     *
+     * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.
+     *                     boolean: whether to count integer-part trailing zeros: true or false.
+     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'
+     */
+    P.precision = P.sd = function (sd, rm) {
+      var c, n, v,
+        x = this;
+
+      if (sd != null && sd !== !!sd) {
+        intCheck(sd, 1, MAX);
+        if (rm == null) rm = ROUNDING_MODE;
+        else intCheck(rm, 0, 8);
+
+        return round(new BigNumber(x), sd, rm);
+      }
+
+      if (!(c = x.c)) return null;
+      v = c.length - 1;
+      n = v * LOG_BASE + 1;
+
+      if (v = c[v]) {
+
+        // Subtract the number of trailing zeros of the last element.
+        for (; v % 10 == 0; v /= 10, n--);
+
+        // Add the number of digits of the first element.
+        for (v = c[0]; v >= 10; v /= 10, n++);
+      }
+
+      if (sd && x.e + 1 > n) n = x.e + 1;
+
+      return n;
+    };
+
+
+    /*
+     * Return a new BigNumber whose value is the value of this BigNumber shifted by k places
+     * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.
+     *
+     * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.
+     *
+     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'
+     */
+    P.shiftedBy = function (k) {
+      intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
+      return this.times('1e' + k);
+    };
+
+
+    /*
+     *  sqrt(-n) =  N
+     *  sqrt(N) =  N
+     *  sqrt(-I) =  N
+     *  sqrt(I) =  I
+     *  sqrt(0) =  0
+     *  sqrt(-0) = -0
+     *
+     * Return a new BigNumber whose value is the square root of the value of this BigNumber,
+     * rounded according to DECIMAL_PLACES and ROUNDING_MODE.
+     */
+    P.squareRoot = P.sqrt = function () {
+      var m, n, r, rep, t,
+        x = this,
+        c = x.c,
+        s = x.s,
+        e = x.e,
+        dp = DECIMAL_PLACES + 4,
+        half = new BigNumber('0.5');
+
+      // Negative/NaN/Infinity/zero?
+      if (s !== 1 || !c || !c[0]) {
+        return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);
+      }
+
+      // Initial estimate.
+      s = Math.sqrt(+x);
+
+      // Math.sqrt underflow/overflow?
+      // Pass x to Math.sqrt as integer, then adjust the exponent of the result.
+      if (s == 0 || s == 1 / 0) {
+        n = coeffToString(c);
+        if ((n.length + e) % 2 == 0) n += '0';
+        s = Math.sqrt(n);
+        e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);
+
+        if (s == 1 / 0) {
+          n = '1e' + e;
+        } else {
+          n = s.toExponential();
+          n = n.slice(0, n.indexOf('e') + 1) + e;
+        }
+
+        r = new BigNumber(n);
+      } else {
+        r = new BigNumber(s + '');
+      }
+
+      // Check for zero.
+      // r could be zero if MIN_EXP is changed after the this value was created.
+      // This would cause a division by zero (x/t) and hence Infinity below, which would cause
+      // coeffToString to throw.
+      if (r.c[0]) {
+        e = r.e;
+        s = e + dp;
+        if (s < 3) s = 0;
+
+        // Newton-Raphson iteration.
+        for (; ;) {
+          t = r;
+          r = half.times(t.plus(div(x, t, dp, 1)));
+
+          if (coeffToString(t.c  ).slice(0, s) === (n =
+             coeffToString(r.c)).slice(0, s)) {
+
+            // The exponent of r may here be one less than the final result exponent,
+            // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits
+            // are indexed correctly.
+            if (r.e < e) --s;
+            n = n.slice(s - 3, s + 1);
+
+            // The 4th rounding digit may be in error by -1 so if the 4 rounding digits
+            // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the
+            // iteration.
+            if (n == '9999' || !rep && n == '4999') {
+
+              // On the first iteration only, check to see if rounding up gives the
+              // exact result as the nines may infinitely repeat.
+              if (!rep) {
+                round(t, t.e + DECIMAL_PLACES + 2, 0);
+
+                if (t.times(t).eq(x)) {
+                  r = t;
+                  break;
+                }
+              }
+
+              dp += 4;
+              s += 4;
+              rep = 1;
+            } else {
+
+              // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact
+              // result. If not, then there are further digits and m will be truthy.
+              if (!+n || !+n.slice(1) && n.charAt(0) == '5') {
+
+                // Truncate to the first rounding digit.
+                round(r, r.e + DECIMAL_PLACES + 2, 1);
+                m = !r.times(r).eq(x);
+              }
+
+              break;
+            }
+          }
+        }
+      }
+
+      return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);
+    };
+
+
+    /*
+     * Return a string representing the value of this BigNumber in exponential notation and
+     * rounded using ROUNDING_MODE to dp fixed decimal places.
+     *
+     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.
+     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'
+     */
+    P.toExponential = function (dp, rm) {
+      if (dp != null) {
+        intCheck(dp, 0, MAX);
+        dp++;
+      }
+      return format(this, dp, rm, 1);
+    };
+
+
+    /*
+     * Return a string representing the value of this BigNumber in fixed-point notation rounding
+     * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.
+     *
+     * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',
+     * but e.g. (-0.00001).toFixed(0) is '-0'.
+     *
+     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.
+     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'
+     */
+    P.toFixed = function (dp, rm) {
+      if (dp != null) {
+        intCheck(dp, 0, MAX);
+        dp = dp + this.e + 1;
+      }
+      return format(this, dp, rm);
+    };
+
+
+    /*
+     * Return a string representing the value of this BigNumber in fixed-point notation rounded
+     * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties
+     * of the FORMAT object (see BigNumber.set).
+     *
+     * FORMAT = {
+     *      decimalSeparator : '.',
+     *      groupSeparator : ',',
+     *      groupSize : 3,
+     *      secondaryGroupSize : 0,
+     *      fractionGroupSeparator : '\xA0',    // non-breaking space
+     *      fractionGroupSize : 0
+     * };
+     *
+     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.
+     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'
+     */
+    P.toFormat = function (dp, rm) {
+      var str = this.toFixed(dp, rm);
+
+      if (this.c) {
+        var i,
+          arr = str.split('.'),
+          g1 = +FORMAT.groupSize,
+          g2 = +FORMAT.secondaryGroupSize,
+          groupSeparator = FORMAT.groupSeparator,
+          intPart = arr[0],
+          fractionPart = arr[1],
+          isNeg = this.s < 0,
+          intDigits = isNeg ? intPart.slice(1) : intPart,
+          len = intDigits.length;
+
+        if (g2) i = g1, g1 = g2, g2 = i, len -= i;
+
+        if (g1 > 0 && len > 0) {
+          i = len % g1 || g1;
+          intPart = intDigits.substr(0, i);
+
+          for (; i < len; i += g1) {
+            intPart += groupSeparator + intDigits.substr(i, g1);
+          }
+
+          if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);
+          if (isNeg) intPart = '-' + intPart;
+        }
+
+        str = fractionPart
+         ? intPart + FORMAT.decimalSeparator + ((g2 = +FORMAT.fractionGroupSize)
+          ? fractionPart.replace(new RegExp('\\d{' + g2 + '}\\B', 'g'),
+           '$&' + FORMAT.fractionGroupSeparator)
+          : fractionPart)
+         : intPart;
+      }
+
+      return str;
+    };
+
+
+    /*
+     * Return a string array representing the value of this BigNumber as a simple fraction with
+     * an integer numerator and an integer denominator. The denominator will be a positive
+     * non-zero value less than or equal to the specified maximum denominator. If a maximum
+     * denominator is not specified, the denominator will be the lowest value necessary to
+     * represent the number exactly.
+     *
+     * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.
+     *
+     * '[BigNumber Error] Argument {not an integer|out of range} : {md}'
+     */
+    P.toFraction = function (md) {
+      var arr, d, d0, d1, d2, e, exp, n, n0, n1, q, s,
+        x = this,
+        xc = x.c;
+
+      if (md != null) {
+        n = new BigNumber(md);
+
+        // Throw if md is less than one or is not an integer, unless it is Infinity.
+        if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {
+          throw Error
+            (bignumberError + 'Argument ' +
+              (n.isInteger() ? 'out of range: ' : 'not an integer: ') + md);
+        }
+      }
+
+      if (!xc) return x.toString();
+
+      d = new BigNumber(ONE);
+      n1 = d0 = new BigNumber(ONE);
+      d1 = n0 = new BigNumber(ONE);
+      s = coeffToString(xc);
+
+      // Determine initial denominator.
+      // d is a power of 10 and the minimum max denominator that specifies the value exactly.
+      e = d.e = s.length - x.e - 1;
+      d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];
+      md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;
+
+      exp = MAX_EXP;
+      MAX_EXP = 1 / 0;
+      n = new BigNumber(s);
+
+      // n0 = d1 = 0
+      n0.c[0] = 0;
+
+      for (; ;)  {
+        q = div(n, d, 0, 1);
+        d2 = d0.plus(q.times(d1));
+        if (d2.comparedTo(md) == 1) break;
+        d0 = d1;
+        d1 = d2;
+        n1 = n0.plus(q.times(d2 = n1));
+        n0 = d2;
+        d = n.minus(q.times(d2 = d));
+        n = d2;
+      }
+
+      d2 = div(md.minus(d0), d1, 0, 1);
+      n0 = n0.plus(d2.times(n1));
+      d0 = d0.plus(d2.times(d1));
+      n0.s = n1.s = x.s;
+      e *= 2;
+
+      // Determine which fraction is closer to x, n0/d0 or n1/d1
+      arr = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(
+         div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1
+          ? [n1.toString(), d1.toString()]
+          : [n0.toString(), d0.toString()];
+
+      MAX_EXP = exp;
+      return arr;
+    };
+
+
+    /*
+     * Return the value of this BigNumber converted to a number primitive.
+     */
+    P.toNumber = function () {
+      return +this;
+    };
+
+
+    /*
+     * Return a string representing the value of this BigNumber rounded to sd significant digits
+     * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits
+     * necessary to represent the integer part of the value in fixed-point notation, then use
+     * exponential notation.
+     *
+     * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.
+     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+     *
+     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'
+     */
+    P.toPrecision = function (sd, rm) {
+      if (sd != null) intCheck(sd, 1, MAX);
+      return format(this, sd, rm, 2);
+    };
+
+
+    /*
+     * Return a string representing the value of this BigNumber in base b, or base 10 if b is
+     * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and
+     * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent
+     * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than
+     * TO_EXP_NEG, return exponential notation.
+     *
+     * [b] {number} Integer, 2 to ALPHABET.length inclusive.
+     *
+     * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'
+     */
+    P.toString = function (b) {
+      var str,
+        n = this,
+        s = n.s,
+        e = n.e;
+
+      // Infinity or NaN?
+      if (e === null) {
+
+        if (s) {
+          str = 'Infinity';
+          if (s < 0) str = '-' + str;
+        } else {
+          str = 'NaN';
+        }
+      } else {
+        str = coeffToString(n.c);
+
+        if (b == null) {
+          str = e <= TO_EXP_NEG || e >= TO_EXP_POS
+           ? toExponential(str, e)
+           : toFixedPoint(str, e, '0');
+        } else {
+          intCheck(b, 2, ALPHABET.length, 'Base');
+          str = convertBase(toFixedPoint(str, e, '0'), 10, b, s, true);
+        }
+
+        if (s < 0 && n.c[0]) str = '-' + str;
+      }
+
+      return str;
+    };
+
+
+    /*
+     * Return as toString, but do not accept a base argument, and include the minus sign for
+     * negative zero.
+     */
+    P.valueOf = P.toJSON = function () {
+      var str,
+        n = this,
+        e = n.e;
+
+      if (e === null) return n.toString();
+
+      str = coeffToString(n.c);
+
+      str = e <= TO_EXP_NEG || e >= TO_EXP_POS
+        ? toExponential(str, e)
+        : toFixedPoint(str, e, '0');
+
+      return n.s < 0 ? '-' + str : str;
+    };
+
+
+    P._isBigNumber = true;
+
+    if (configObject != null) BigNumber.set(configObject);
+
+    return BigNumber;
+  }
+
+
+  // PRIVATE HELPER FUNCTIONS
+
+
+  function bitFloor(n) {
+    var i = n | 0;
+    return n > 0 || n === i ? i : i - 1;
+  }
+
+
+  // Return a coefficient array as a string of base 10 digits.
+  function coeffToString(a) {
+    var s, z,
+      i = 1,
+      j = a.length,
+      r = a[0] + '';
+
+    for (; i < j;) {
+      s = a[i++] + '';
+      z = LOG_BASE - s.length;
+      for (; z--; s = '0' + s);
+      r += s;
+    }
+
+    // Determine trailing zeros.
+    for (j = r.length; r.charCodeAt(--j) === 48;);
+    return r.slice(0, j + 1 || 1);
+  }
+
+
+  // Compare the value of BigNumbers x and y.
+  function compare(x, y) {
+    var a, b,
+      xc = x.c,
+      yc = y.c,
+      i = x.s,
+      j = y.s,
+      k = x.e,
+      l = y.e;
+
+    // Either NaN?
+    if (!i || !j) return null;
+
+    a = xc && !xc[0];
+    b = yc && !yc[0];
+
+    // Either zero?
+    if (a || b) return a ? b ? 0 : -j : i;
+
+    // Signs differ?
+    if (i != j) return i;
+
+    a = i < 0;
+    b = k == l;
+
+    // Either Infinity?
+    if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;
+
+    // Compare exponents.
+    if (!b) return k > l ^ a ? 1 : -1;
+
+    j = (k = xc.length) < (l = yc.length) ? k : l;
+
+    // Compare digit by digit.
+    for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;
+
+    // Compare lengths.
+    return k == l ? 0 : k > l ^ a ? 1 : -1;
+  }
+
+
+  /*
+   * Check that n is a primitive number, an integer, and in range, otherwise throw.
+   */
+  function intCheck(n, min, max, name) {
+    if (n < min || n > max || n !== (n < 0 ? mathceil(n) : mathfloor(n))) {
+      throw Error
+       (bignumberError + (name || 'Argument') + (typeof n == 'number'
+         ? n < min || n > max ? ' out of range: ' : ' not an integer: '
+         : ' not a primitive number: ') + n);
+    }
+  }
+
+
+  function isArray(obj) {
+    return Object.prototype.toString.call(obj) == '[object Array]';
+  }
+
+
+  // Assumes finite n.
+  function isOdd(n) {
+    var k = n.c.length - 1;
+    return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;
+  }
+
+
+  function toExponential(str, e) {
+    return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +
+     (e < 0 ? 'e' : 'e+') + e;
+  }
+
+
+  function toFixedPoint(str, e, z) {
+    var len, zs;
+
+    // Negative exponent?
+    if (e < 0) {
+
+      // Prepend zeros.
+      for (zs = z + '.'; ++e; zs += z);
+      str = zs + str;
+
+    // Positive exponent
+    } else {
+      len = str.length;
+
+      // Append zeros.
+      if (++e > len) {
+        for (zs = z, e -= len; --e; zs += z);
+        str += zs;
+      } else if (e < len) {
+        str = str.slice(0, e) + '.' + str.slice(e);
+      }
+    }
+
+    return str;
+  }
+
+
+  // EXPORT
+
+
+  BigNumber = clone();
+  BigNumber['default'] = BigNumber.BigNumber = BigNumber;
+
+  // AMD.
+  if (typeof define == 'function' && define.amd) {
+    define(function () { return BigNumber; });
+
+  // Node.js and other environments that support module.exports.
+  } else if (typeof module != 'undefined' && module.exports) {
+    module.exports = BigNumber;
+
+  // Browser.
+  } else {
+    if (!globalObject) {
+      globalObject = typeof self != 'undefined' && self ? self : window;
+    }
+
+    globalObject.BigNumber = BigNumber;
+  }
+})(this);

projet/node_modules/bignumber.js/bignumber.js.map

+{"version":3,"file":"bignumber.min.js","sources":["bignumber.js"],"names":["globalObject","clone","configObject","BigNumber","n","b","alphabet","c","caseChanged","e","i","isNum","len","str","x","this","s","slice","isNumeric","test","parseNumeric","charCodeAt","indexOf","replace","search","substring","length","intCheck","ALPHABET","round","DECIMAL_PLACES","ROUNDING_MODE","DEBUG","Error","tooManyDigits","charAt","toUpperCase","toLowerCase","convertBase","MAX_SAFE_INTEGER","mathfloor","MAX_EXP","MIN_EXP","LOG_BASE","push","format","rm","id","c0","ne","toString","coeffToString","TO_EXP_NEG","toExponential","toFixedPoint","maxOrMin","args","method","m","isArray","call","normalise","j","pop","sd","r","d","k","ni","rd","xc","pows10","POWS_TEN","out","mathceil","BASE","div","P","prototype","constructor","valueOf","ONE","TO_EXP_POS","CRYPTO","MODULO_MODE","POW_PRECISION","FORMAT","decimalSeparator","groupSeparator","groupSize","secondaryGroupSize","fractionGroupSeparator","fractionGroupSize","ROUND_UP","ROUND_DOWN","ROUND_CEIL","ROUND_FLOOR","ROUND_HALF_UP","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_CEIL","ROUND_HALF_FLOOR","EUCLID","config","set","obj","p","v","bignumberError","hasOwnProperty","MAX","crypto","getRandomValues","randomBytes","EXPONENTIAL_AT","RANGE","isBigNumber","_isBigNumber","maximum","max","arguments","lt","minimum","min","gt","random","pow2_53","random53bitInt","Math","dp","a","rand","Uint32Array","copy","splice","toBaseOut","baseIn","baseOut","arrL","arr","reverse","decimal","sign","callerIsToString","y","pow","concat","multiply","base","temp","xlo","xhi","carry","klo","SQRT_BASE","khi","compare","aL","bL","cmp","subtract","more","prod","prodL","q","qc","rem","remL","rem0","xi","xL","yc0","yL","yz","yc","NaN","bitFloor","basePrefix","dotAfter","dotBefore","isInfinityOrNaN","whitespaceOrPlus","isNaN","p1","p2","absoluteValue","abs","comparedTo","decimalPlaces","dividedBy","dividedToIntegerBy","idiv","exponentiatedBy","half","isModExp","nIsBig","nIsNeg","nIsOdd","isInteger","isOdd","mod","times","integerValue","isEqualTo","eq","isFinite","isGreaterThan","isGreaterThanOrEqualTo","gte","isLessThan","isLessThanOrEqualTo","lte","isNegative","isPositive","isZero","minus","t","xLTy","plus","xe","ye","modulo","multipliedBy","xcL","ycL","ylo","yhi","zc","sqrtBase","negated","precision","shiftedBy","squareRoot","sqrt","rep","toFixed","toFormat","split","g1","g2","intPart","fractionPart","isNeg","intDigits","substr","RegExp","toFraction","md","d0","d1","d2","exp","n0","n1","toNumber","toPrecision","toJSON","z","l","name","Object","zs","ceil","floor","define","amd","module","exports","self","window"],"mappings":"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"}
\ No newline at end of file

projet/node_modules/bignumber.js/bignumber.min.js

+/* bignumber.js v7.2.1 https://github.com/MikeMcl/bignumber.js/LICENCE */
+!function(e){"use strict";function r(e){function l(e,r){var n,t,i,s,f,u,c,h,p=this;if(!(p instanceof l))return new l(e,r);if(null==r){if(e instanceof l)return p.s=e.s,p.e=e.e,void(p.c=(e=e.c)?e.slice():e);if(u="number"==typeof e,u&&0*e==0){if(p.s=0>1/e?(e=-e,-1):1,e===~~e){for(s=0,f=e;f>=10;f/=10,s++);return p.e=s,void(p.c=[e])}h=e+""}else{if(!a.test(h=e+""))return _(p,h,u);p.s=45==h.charCodeAt(0)?(h=h.slice(1),-1):1}(s=h.indexOf("."))>-1&&(h=h.replace(".","")),(f=h.search(/e/i))>0?(0>s&&(s=f),s+=+h.slice(f+1),h=h.substring(0,f)):0>s&&(s=h.length)}else{if(o(r,2,q.length,"Base"),h=e+"",10==r)return p=new l(e instanceof l?e:h),R(p,B+p.e+1,U);if(u="number"==typeof e){if(0*e!=0)return _(p,h,u,r);if(p.s=0>1/e?(h=h.slice(1),-1):1,l.DEBUG&&h.replace(/^0\.0*|\./,"").length>15)throw Error(w+e);u=!1}else p.s=45===h.charCodeAt(0)?(h=h.slice(1),-1):1;for(n=q.slice(0,r),s=f=0,c=h.length;c>f;f++)if(n.indexOf(t=h.charAt(f))<0){if("."==t){if(f>s){s=c;continue}}else if(!i&&(h==h.toUpperCase()&&(h=h.toLowerCase())||h==h.toLowerCase()&&(h=h.toUpperCase()))){i=!0,f=-1,s=0;continue}return _(p,e+"",u,r)}h=P(h,r,10,p.s),(s=h.indexOf("."))>-1?h=h.replace(".",""):s=h.length}for(f=0;48===h.charCodeAt(f);f++);for(c=h.length;48===h.charCodeAt(--c););if(h=h.slice(f,++c)){if(c-=f,u&&l.DEBUG&&c>15&&(e>v||e!==g(e)))throw Error(w+p.s*e);if(s=s-f-1,s>C)p.c=p.e=null;else if(x>s)p.c=[p.e=0];else{if(p.e=s,p.c=[],f=(s+1)%m,0>s&&(f+=m),c>f){for(f&&p.c.push(+h.slice(0,f)),c-=m;c>f;)p.c.push(+h.slice(f,f+=m));h=h.slice(f),f=m-h.length}else f-=c;for(;f--;h+="0");p.c.push(+h)}}else p.c=[p.e=0]}function E(e,r,n,i){var s,f,a,h,g;if(null==n?n=U:o(n,0,8),!e.c)return e.toString();if(s=e.c[0],a=e.e,null==r)g=t(e.c),g=1==i||2==i&&I>=a?u(g,a):c(g,a,"0");else if(e=R(new l(e),r,n),f=e.e,g=t(e.c),h=g.length,1==i||2==i&&(f>=r||I>=f)){for(;r>h;g+="0",h++);g=u(g,f)}else if(r-=a,g=c(g,f,"0"),f+1>h){if(--r>0)for(g+=".";r--;g+="0");}else if(r+=f-h,r>0)for(f+1==h&&(g+=".");r--;g+="0");return e.s<0&&s?"-"+g:g}function b(e,r){var n,t,i=0;for(s(e[0])&&(e=e[0]),n=new l(e[0]);++i<e.length;){if(t=new l(e[i]),!t.s){n=t;break}r.call(n,t)&&(n=t)}return n}function A(e,r,n){for(var t=1,i=r.length;!r[--i];r.pop());for(i=r[0];i>=10;i/=10,t++);return(n=t+n*m-1)>C?e.c=e.e=null:x>n?e.c=[e.e=0]:(e.e=n,e.c=r),e}function R(e,r,n,t){var i,o,s,f,u,c,l,a=e.c,p=O;if(a){e:{for(i=1,f=a[0];f>=10;f/=10,i++);if(o=r-i,0>o)o+=m,s=r,u=a[c=0],l=u/p[i-s-1]%10|0;else if(c=h((o+1)/m),c>=a.length){if(!t)break e;for(;a.length<=c;a.push(0));u=l=0,i=1,o%=m,s=o-m+1}else{for(u=f=a[c],i=1;f>=10;f/=10,i++);o%=m,s=o-m+i,l=0>s?0:u/p[i-s-1]%10|0}if(t=t||0>r||null!=a[c+1]||(0>s?u:u%p[i-s-1]),t=4>n?(l||t)&&(0==n||n==(e.s<0?3:2)):l>5||5==l&&(4==n||t||6==n&&(o>0?s>0?u/p[i-s]:0:a[c-1])%10&1||n==(e.s<0?8:7)),1>r||!a[0])return a.length=0,t?(r-=e.e+1,a[0]=p[(m-r%m)%m],e.e=-r||0):a[0]=e.e=0,e;if(0==o?(a.length=c,f=1,c--):(a.length=c+1,f=p[m-o],a[c]=s>0?g(u/p[i-s]%p[s])*f:0),t)for(;;){if(0==c){for(o=1,s=a[0];s>=10;s/=10,o++);for(s=a[0]+=f,f=1;s>=10;s/=10,f++);o!=f&&(e.e++,a[0]==d&&(a[0]=1));break}if(a[c]+=f,a[c]!=d)break;a[c--]=0,f=1}for(o=a.length;0===a[--o];a.pop());}e.e>C?e.c=e.e=null:e.e<x&&(e.c=[e.e=0])}return e}var S,P,_,D=l.prototype={constructor:l,toString:null,valueOf:null},L=new l(1),B=20,U=4,I=-7,T=21,x=-1e7,C=1e7,M=!1,G=1,F=0,k={decimalSeparator:".",groupSeparator:",",groupSize:3,secondaryGroupSize:0,fractionGroupSeparator:" ",fractionGroupSize:0},q="0123456789abcdefghijklmnopqrstuvwxyz";return l.clone=r,l.ROUND_UP=0,l.ROUND_DOWN=1,l.ROUND_CEIL=2,l.ROUND_FLOOR=3,l.ROUND_HALF_UP=4,l.ROUND_HALF_DOWN=5,l.ROUND_HALF_EVEN=6,l.ROUND_HALF_CEIL=7,l.ROUND_HALF_FLOOR=8,l.EUCLID=9,l.config=l.set=function(e){var r,n;if(null!=e){if("object"!=typeof e)throw Error(p+"Object expected: "+e);if(e.hasOwnProperty(r="DECIMAL_PLACES")&&(n=e[r],o(n,0,y,r),B=n),e.hasOwnProperty(r="ROUNDING_MODE")&&(n=e[r],o(n,0,8,r),U=n),e.hasOwnProperty(r="EXPONENTIAL_AT")&&(n=e[r],s(n)?(o(n[0],-y,0,r),o(n[1],0,y,r),I=n[0],T=n[1]):(o(n,-y,y,r),I=-(T=0>n?-n:n))),e.hasOwnProperty(r="RANGE"))if(n=e[r],s(n))o(n[0],-y,-1,r),o(n[1],1,y,r),x=n[0],C=n[1];else{if(o(n,-y,y,r),!n)throw Error(p+r+" cannot be zero: "+n);x=-(C=0>n?-n:n)}if(e.hasOwnProperty(r="CRYPTO")){if(n=e[r],n!==!!n)throw Error(p+r+" not true or false: "+n);if(n){if("undefined"==typeof crypto||!crypto||!crypto.getRandomValues&&!crypto.randomBytes)throw M=!n,Error(p+"crypto unavailable");M=n}else M=n}if(e.hasOwnProperty(r="MODULO_MODE")&&(n=e[r],o(n,0,9,r),G=n),e.hasOwnProperty(r="POW_PRECISION")&&(n=e[r],o(n,0,y,r),F=n),e.hasOwnProperty(r="FORMAT")){if(n=e[r],"object"!=typeof n)throw Error(p+r+" not an object: "+n);k=n}if(e.hasOwnProperty(r="ALPHABET")){if(n=e[r],"string"!=typeof n||/^.$|\.|(.).*\1/.test(n))throw Error(p+r+" invalid: "+n);q=n}}return{DECIMAL_PLACES:B,ROUNDING_MODE:U,EXPONENTIAL_AT:[I,T],RANGE:[x,C],CRYPTO:M,MODULO_MODE:G,POW_PRECISION:F,FORMAT:k,ALPHABET:q}},l.isBigNumber=function(e){return e instanceof l||e&&e._isBigNumber===!0||!1},l.maximum=l.max=function(){return b(arguments,D.lt)},l.minimum=l.min=function(){return b(arguments,D.gt)},l.random=function(){var e=9007199254740992,r=Math.random()*e&2097151?function(){return g(Math.random()*e)}:function(){return 8388608*(1073741824*Math.random()|0)+(8388608*Math.random()|0)};return function(e){var n,t,i,s,f,u=0,c=[],a=new l(L);if(null==e?e=B:o(e,0,y),s=h(e/m),M)if(crypto.getRandomValues){for(n=crypto.getRandomValues(new Uint32Array(s*=2));s>u;)f=131072*n[u]+(n[u+1]>>>11),f>=9e15?(t=crypto.getRandomValues(new Uint32Array(2)),n[u]=t[0],n[u+1]=t[1]):(c.push(f%1e14),u+=2);u=s/2}else{if(!crypto.randomBytes)throw M=!1,Error(p+"crypto unavailable");for(n=crypto.randomBytes(s*=7);s>u;)f=281474976710656*(31&n[u])+1099511627776*n[u+1]+4294967296*n[u+2]+16777216*n[u+3]+(n[u+4]<<16)+(n[u+5]<<8)+n[u+6],f>=9e15?crypto.randomBytes(7).copy(n,u):(c.push(f%1e14),u+=7);u=s/7}if(!M)for(;s>u;)f=r(),9e15>f&&(c[u++]=f%1e14);for(s=c[--u],e%=m,s&&e&&(f=O[m-e],c[u]=g(s/f)*f);0===c[u];c.pop(),u--);if(0>u)c=[i=0];else{for(i=-1;0===c[0];c.splice(0,1),i-=m);for(u=1,f=c[0];f>=10;f/=10,u++);m>u&&(i-=m-u)}return a.e=i,a.c=c,a}}(),P=function(){function e(e,r,n,t){for(var i,o,s=[0],f=0,u=e.length;u>f;){for(o=s.length;o--;s[o]*=r);for(s[0]+=t.indexOf(e.charAt(f++)),i=0;i<s.length;i++)s[i]>n-1&&(null==s[i+1]&&(s[i+1]=0),s[i+1]+=s[i]/n|0,s[i]%=n)}return s.reverse()}var r="0123456789";return function(n,i,o,s,f){var u,a,h,g,p,w,d,m,v=n.indexOf("."),O=B,N=U;for(v>=0&&(g=F,F=0,n=n.replace(".",""),m=new l(i),w=m.pow(n.length-v),F=g,m.c=e(c(t(w.c),w.e,"0"),10,o,r),m.e=m.c.length),d=e(n,i,o,f?(u=q,r):(u=r,q)),h=g=d.length;0==d[--g];d.pop());if(!d[0])return u.charAt(0);if(0>v?--h:(w.c=d,w.e=h,w.s=s,w=S(w,m,O,N,o),d=w.c,p=w.r,h=w.e),a=h+O+1,v=d[a],g=o/2,p=p||0>a||null!=d[a+1],p=4>N?(null!=v||p)&&(0==N||N==(w.s<0?3:2)):v>g||v==g&&(4==N||p||6==N&&1&d[a-1]||N==(w.s<0?8:7)),1>a||!d[0])n=p?c(u.charAt(1),-O,u.charAt(0)):u.charAt(0);else{if(d.length=a,p)for(--o;++d[--a]>o;)d[a]=0,a||(++h,d=[1].concat(d));for(g=d.length;!d[--g];);for(v=0,n="";g>=v;n+=u.charAt(d[v++]));n=c(n,h,u.charAt(0))}return n}}(),S=function(){function e(e,r,n){var t,i,o,s,f=0,u=e.length,c=r%N,l=r/N|0;for(e=e.slice();u--;)o=e[u]%N,s=e[u]/N|0,t=l*o+s*c,i=c*o+t%N*N+f,f=(i/n|0)+(t/N|0)+l*s,e[u]=i%n;return f&&(e=[f].concat(e)),e}function r(e,r,n,t){var i,o;if(n!=t)o=n>t?1:-1;else for(i=o=0;n>i;i++)if(e[i]!=r[i]){o=e[i]>r[i]?1:-1;break}return o}function t(e,r,n,t){for(var i=0;n--;)e[n]-=i,i=e[n]<r[n]?1:0,e[n]=i*t+e[n]-r[n];for(;!e[0]&&e.length>1;e.splice(0,1));}return function(i,o,s,f,u){var c,a,h,p,w,v,O,N,y,E,b,A,S,P,_,D,L,B=i.s==o.s?1:-1,U=i.c,I=o.c;if(!(U&&U[0]&&I&&I[0]))return new l(i.s&&o.s&&(U?!I||U[0]!=I[0]:I)?U&&0==U[0]||!I?0*B:B/0:NaN);for(N=new l(B),y=N.c=[],a=i.e-o.e,B=s+a+1,u||(u=d,a=n(i.e/m)-n(o.e/m),B=B/m|0),h=0;I[h]==(U[h]||0);h++);if(I[h]>(U[h]||0)&&a--,0>B)y.push(1),p=!0;else{for(P=U.length,D=I.length,h=0,B+=2,w=g(u/(I[0]+1)),w>1&&(I=e(I,w,u),U=e(U,w,u),D=I.length,P=U.length),S=D,E=U.slice(0,D),b=E.length;D>b;E[b++]=0);L=I.slice(),L=[0].concat(L),_=I[0],I[1]>=u/2&&_++;do{if(w=0,c=r(I,E,D,b),0>c){if(A=E[0],D!=b&&(A=A*u+(E[1]||0)),w=g(A/_),w>1)for(w>=u&&(w=u-1),v=e(I,w,u),O=v.length,b=E.length;1==r(v,E,O,b);)w--,t(v,O>D?L:I,O,u),O=v.length,c=1;else 0==w&&(c=w=1),v=I.slice(),O=v.length;if(b>O&&(v=[0].concat(v)),t(E,v,b,u),b=E.length,-1==c)for(;r(I,E,D,b)<1;)w++,t(E,b>D?L:I,b,u),b=E.length}else 0===c&&(w++,E=[0]);y[h++]=w,E[0]?E[b++]=U[S]||0:(E=[U[S]],b=1)}while((S++<P||null!=E[0])&&B--);p=null!=E[0],y[0]||y.splice(0,1)}if(u==d){for(h=1,B=y[0];B>=10;B/=10,h++);R(N,s+(N.e=h+a*m-1)+1,f,p)}else N.e=a,N.r=+p;return N}}(),_=function(){var e=/^(-?)0([xbo])(?=\w[\w.]*$)/i,r=/^([^.]+)\.$/,n=/^\.([^.]+)$/,t=/^-?(Infinity|NaN)$/,i=/^\s*\+(?=[\w.])|^\s+|\s+$/g;return function(o,s,f,u){var c,a=f?s:s.replace(i,"");if(t.test(a))o.s=isNaN(a)?null:0>a?-1:1,o.c=o.e=null;else{if(!f&&(a=a.replace(e,function(e,r,n){return c="x"==(n=n.toLowerCase())?16:"b"==n?2:8,u&&u!=c?e:r}),u&&(c=u,a=a.replace(r,"$1").replace(n,"0.$1")),s!=a))return new l(a,c);if(l.DEBUG)throw Error(p+"Not a"+(u?" base "+u:"")+" number: "+s);o.c=o.e=o.s=null}}}(),D.absoluteValue=D.abs=function(){var e=new l(this);return e.s<0&&(e.s=1),e},D.comparedTo=function(e,r){return i(this,new l(e,r))},D.decimalPlaces=D.dp=function(e,r){var t,i,s,f=this;if(null!=e)return o(e,0,y),null==r?r=U:o(r,0,8),R(new l(f),e+f.e+1,r);if(!(t=f.c))return null;if(i=((s=t.length-1)-n(this.e/m))*m,s=t[s])for(;s%10==0;s/=10,i--);return 0>i&&(i=0),i},D.dividedBy=D.div=function(e,r){return S(this,new l(e,r),B,U)},D.dividedToIntegerBy=D.idiv=function(e,r){return S(this,new l(e,r),0,1)},D.exponentiatedBy=D.pow=function(e,r){var n,t,i,o,s,u,c,a,w=this;if(e=new l(e),e.c&&!e.isInteger())throw Error(p+"Exponent not an integer: "+e);if(null!=r&&(r=new l(r)),s=e.e>14,!w.c||!w.c[0]||1==w.c[0]&&!w.e&&1==w.c.length||!e.c||!e.c[0])return a=new l(Math.pow(+w.valueOf(),s?2-f(e):+e)),r?a.mod(r):a;if(u=e.s<0,r){if(r.c?!r.c[0]:!r.s)return new l(NaN);t=!u&&w.isInteger()&&r.isInteger(),t&&(w=w.mod(r))}else{if(e.e>9&&(w.e>0||w.e<-1||(0==w.e?w.c[0]>1||s&&w.c[1]>=24e7:w.c[0]<8e13||s&&w.c[0]<=9999975e7)))return i=w.s<0&&f(e)?-0:0,w.e>-1&&(i=1/i),new l(u?1/i:i);F&&(i=h(F/m+2))}for(s?(n=new l(.5),c=f(e)):c=e%2,u&&(e.s=1),a=new l(L);;){if(c){if(a=a.times(w),!a.c)break;i?a.c.length>i&&(a.c.length=i):t&&(a=a.mod(r))}if(s){if(e=e.times(n),R(e,e.e+1,1),!e.c[0])break;s=e.e>14,c=f(e)}else{if(e=g(e/2),!e)break;c=e%2}w=w.times(w),i?w.c&&w.c.length>i&&(w.c.length=i):t&&(w=w.mod(r))}return t?a:(u&&(a=L.div(a)),r?a.mod(r):i?R(a,F,U,o):a)},D.integerValue=function(e){var r=new l(this);return null==e?e=U:o(e,0,8),R(r,r.e+1,e)},D.isEqualTo=D.eq=function(e,r){return 0===i(this,new l(e,r))},D.isFinite=function(){return!!this.c},D.isGreaterThan=D.gt=function(e,r){return i(this,new l(e,r))>0},D.isGreaterThanOrEqualTo=D.gte=function(e,r){return 1===(r=i(this,new l(e,r)))||0===r},D.isInteger=function(){return!!this.c&&n(this.e/m)>this.c.length-2},D.isLessThan=D.lt=function(e,r){return i(this,new l(e,r))<0},D.isLessThanOrEqualTo=D.lte=function(e,r){return-1===(r=i(this,new l(e,r)))||0===r},D.isNaN=function(){return!this.s},D.isNegative=function(){return this.s<0},D.isPositive=function(){return this.s>0},D.isZero=function(){return!!this.c&&0==this.c[0]},D.minus=function(e,r){var t,i,o,s,f=this,u=f.s;if(e=new l(e,r),r=e.s,!u||!r)return new l(NaN);if(u!=r)return e.s=-r,f.plus(e);var c=f.e/m,a=e.e/m,h=f.c,g=e.c;if(!c||!a){if(!h||!g)return h?(e.s=-r,e):new l(g?f:NaN);if(!h[0]||!g[0])return g[0]?(e.s=-r,e):new l(h[0]?f:3==U?-0:0)}if(c=n(c),a=n(a),h=h.slice(),u=c-a){for((s=0>u)?(u=-u,o=h):(a=c,o=g),o.reverse(),r=u;r--;o.push(0));o.reverse()}else for(i=(s=(u=h.length)<(r=g.length))?u:r,u=r=0;i>r;r++)if(h[r]!=g[r]){s=h[r]<g[r];break}if(s&&(o=h,h=g,g=o,e.s=-e.s),r=(i=g.length)-(t=h.length),r>0)for(;r--;h[t++]=0);for(r=d-1;i>u;){if(h[--i]<g[i]){for(t=i;t&&!h[--t];h[t]=r);--h[t],h[i]+=d}h[i]-=g[i]}for(;0==h[0];h.splice(0,1),--a);return h[0]?A(e,h,a):(e.s=3==U?-1:1,e.c=[e.e=0],e)},D.modulo=D.mod=function(e,r){var n,t,i=this;return e=new l(e,r),!i.c||!e.s||e.c&&!e.c[0]?new l(NaN):!e.c||i.c&&!i.c[0]?new l(i):(9==G?(t=e.s,e.s=1,n=S(i,e,0,3),e.s=t,n.s*=t):n=S(i,e,0,G),e=i.minus(n.times(e)),e.c[0]||1!=G||(e.s=i.s),e)},D.multipliedBy=D.times=function(e,r){var t,i,o,s,f,u,c,a,h,g,p,w,v,O,y,E=this,b=E.c,R=(e=new l(e,r)).c;if(!(b&&R&&b[0]&&R[0]))return!E.s||!e.s||b&&!b[0]&&!R||R&&!R[0]&&!b?e.c=e.e=e.s=null:(e.s*=E.s,b&&R?(e.c=[0],e.e=0):e.c=e.e=null),e;for(i=n(E.e/m)+n(e.e/m),e.s*=E.s,c=b.length,g=R.length,g>c&&(v=b,b=R,R=v,o=c,c=g,g=o),o=c+g,v=[];o--;v.push(0));for(O=d,y=N,o=g;--o>=0;){for(t=0,p=R[o]%y,w=R[o]/y|0,f=c,s=o+f;s>o;)a=b[--f]%y,h=b[f]/y|0,u=w*a+h*p,a=p*a+u%y*y+v[s]+t,t=(a/O|0)+(u/y|0)+w*h,v[s--]=a%O;v[s]=t}return t?++i:v.splice(0,1),A(e,v,i)},D.negated=function(){var e=new l(this);return e.s=-e.s||null,e},D.plus=function(e,r){var t,i=this,o=i.s;if(e=new l(e,r),r=e.s,!o||!r)return new l(NaN);if(o!=r)return e.s=-r,i.minus(e);var s=i.e/m,f=e.e/m,u=i.c,c=e.c;if(!s||!f){if(!u||!c)return new l(o/0);if(!u[0]||!c[0])return c[0]?e:new l(u[0]?i:0*o)}if(s=n(s),f=n(f),u=u.slice(),o=s-f){for(o>0?(f=s,t=c):(o=-o,t=u),t.reverse();o--;t.push(0));t.reverse()}for(o=u.length,r=c.length,0>o-r&&(t=c,c=u,u=t,r=o),o=0;r;)o=(u[--r]=u[r]+c[r]+o)/d|0,u[r]=d===u[r]?0:u[r]%d;return o&&(u=[o].concat(u),++f),A(e,u,f)},D.precision=D.sd=function(e,r){var n,t,i,s=this;if(null!=e&&e!==!!e)return o(e,1,y),null==r?r=U:o(r,0,8),R(new l(s),e,r);if(!(n=s.c))return null;if(i=n.length-1,t=i*m+1,i=n[i]){for(;i%10==0;i/=10,t--);for(i=n[0];i>=10;i/=10,t++);}return e&&s.e+1>t&&(t=s.e+1),t},D.shiftedBy=function(e){return o(e,-v,v),this.times("1e"+e)},D.squareRoot=D.sqrt=function(){var e,r,i,o,s,f=this,u=f.c,c=f.s,a=f.e,h=B+4,g=new l("0.5");if(1!==c||!u||!u[0])return new l(!c||0>c&&(!u||u[0])?NaN:u?f:1/0);if(c=Math.sqrt(+f),0==c||c==1/0?(r=t(u),(r.length+a)%2==0&&(r+="0"),c=Math.sqrt(r),a=n((a+1)/2)-(0>a||a%2),c==1/0?r="1e"+a:(r=c.toExponential(),r=r.slice(0,r.indexOf("e")+1)+a),i=new l(r)):i=new l(c+""),i.c[0])for(a=i.e,c=a+h,3>c&&(c=0);;)if(s=i,i=g.times(s.plus(S(f,s,h,1))),t(s.c).slice(0,c)===(r=t(i.c)).slice(0,c)){if(i.e<a&&--c,r=r.slice(c-3,c+1),"9999"!=r&&(o||"4999"!=r)){(!+r||!+r.slice(1)&&"5"==r.charAt(0))&&(R(i,i.e+B+2,1),e=!i.times(i).eq(f));break}if(!o&&(R(s,s.e+B+2,0),s.times(s).eq(f))){i=s;break}h+=4,c+=4,o=1}return R(i,i.e+B+1,U,e)},D.toExponential=function(e,r){return null!=e&&(o(e,0,y),e++),E(this,e,r,1)},D.toFixed=function(e,r){return null!=e&&(o(e,0,y),e=e+this.e+1),E(this,e,r)},D.toFormat=function(e,r){var n=this.toFixed(e,r);if(this.c){var t,i=n.split("."),o=+k.groupSize,s=+k.secondaryGroupSize,f=k.groupSeparator,u=i[0],c=i[1],l=this.s<0,a=l?u.slice(1):u,h=a.length;if(s&&(t=o,o=s,s=t,h-=t),o>0&&h>0){for(t=h%o||o,u=a.substr(0,t);h>t;t+=o)u+=f+a.substr(t,o);s>0&&(u+=f+a.slice(t)),l&&(u="-"+u)}n=c?u+k.decimalSeparator+((s=+k.fractionGroupSize)?c.replace(new RegExp("\\d{"+s+"}\\B","g"),"$&"+k.fractionGroupSeparator):c):u}return n},D.toFraction=function(e){var r,n,i,o,s,f,u,c,a,h,g,w,d=this,v=d.c;if(null!=e&&(c=new l(e),!c.isInteger()&&(c.c||1!==c.s)||c.lt(L)))throw Error(p+"Argument "+(c.isInteger()?"out of range: ":"not an integer: ")+e);if(!v)return d.toString();for(n=new l(L),h=i=new l(L),o=a=new l(L),w=t(v),f=n.e=w.length-d.e-1,n.c[0]=O[(u=f%m)<0?m+u:u],e=!e||c.comparedTo(n)>0?f>0?n:h:c,u=C,C=1/0,c=new l(w),a.c[0]=0;g=S(c,n,0,1),s=i.plus(g.times(o)),1!=s.comparedTo(e);)i=o,o=s,h=a.plus(g.times(s=h)),a=s,n=c.minus(g.times(s=n)),c=s;return s=S(e.minus(i),o,0,1),a=a.plus(s.times(h)),i=i.plus(s.times(o)),a.s=h.s=d.s,f*=2,r=S(h,o,f,U).minus(d).abs().comparedTo(S(a,i,f,U).minus(d).abs())<1?[h.toString(),o.toString()]:[a.toString(),i.toString()],C=u,r},D.toNumber=function(){return+this},D.toPrecision=function(e,r){return null!=e&&o(e,1,y),E(this,e,r,2)},D.toString=function(e){var r,n=this,i=n.s,s=n.e;return null===s?i?(r="Infinity",0>i&&(r="-"+r)):r="NaN":(r=t(n.c),null==e?r=I>=s||s>=T?u(r,s):c(r,s,"0"):(o(e,2,q.length,"Base"),r=P(c(r,s,"0"),10,e,i,!0)),0>i&&n.c[0]&&(r="-"+r)),r},D.valueOf=D.toJSON=function(){var e,r=this,n=r.e;return null===n?r.toString():(e=t(r.c),e=I>=n||n>=T?u(e,n):c(e,n,"0"),r.s<0?"-"+e:e)},D._isBigNumber=!0,null!=e&&l.set(e),l}function n(e){var r=0|e;return e>0||e===r?r:r-1}function t(e){for(var r,n,t=1,i=e.length,o=e[0]+"";i>t;){for(r=e[t++]+"",n=m-r.length;n--;r="0"+r);o+=r}for(i=o.length;48===o.charCodeAt(--i););return o.slice(0,i+1||1)}function i(e,r){var n,t,i=e.c,o=r.c,s=e.s,f=r.s,u=e.e,c=r.e;if(!s||!f)return null;if(n=i&&!i[0],t=o&&!o[0],n||t)return n?t?0:-f:s;if(s!=f)return s;if(n=0>s,t=u==c,!i||!o)return t?0:!i^n?1:-1;if(!t)return u>c^n?1:-1;for(f=(u=i.length)<(c=o.length)?u:c,s=0;f>s;s++)if(i[s]!=o[s])return i[s]>o[s]^n?1:-1;return u==c?0:u>c^n?1:-1}function o(e,r,n,t){if(r>e||e>n||e!==(0>e?h(e):g(e)))throw Error(p+(t||"Argument")+("number"==typeof e?r>e||e>n?" out of range: ":" not an integer: ":" not a primitive number: ")+e)}function s(e){return"[object Array]"==Object.prototype.toString.call(e)}function f(e){var r=e.c.length-1;return n(e.e/m)==r&&e.c[r]%2!=0}function u(e,r){return(e.length>1?e.charAt(0)+"."+e.slice(1):e)+(0>r?"e":"e+")+r}function c(e,r,n){var t,i;if(0>r){for(i=n+".";++r;i+=n);e=i+e}else if(t=e.length,++r>t){for(i=n,r-=t;--r;i+=n);e+=i}else t>r&&(e=e.slice(0,r)+"."+e.slice(r));return e}var l,a=/^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i,h=Math.ceil,g=Math.floor,p="[BigNumber Error] ",w=p+"Number primitive has more than 15 significant digits: ",d=1e14,m=14,v=9007199254740991,O=[1,10,100,1e3,1e4,1e5,1e6,1e7,1e8,1e9,1e10,1e11,1e12,1e13],N=1e7,y=1e9;l=r(),l["default"]=l.BigNumber=l,"function"==typeof define&&define.amd?define(function(){return l}):"undefined"!=typeof module&&module.exports?module.exports=l:(e||(e="undefined"!=typeof self&&self?self:window),e.BigNumber=l)}(this);
+//# sourceMappingURL=bignumber.js.map
\ No newline at end of file

projet/node_modules/bignumber.js/bignumber.mjs

+/*
+ *      bignumber.js v7.2.1
+ *      A JavaScript library for arbitrary-precision arithmetic.
+ *      https://github.com/MikeMcl/bignumber.js
+ *      Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>
+ *      MIT Licensed.
+ *
+ *      BigNumber.prototype methods     |  BigNumber methods
+ *                                      |
+ *      absoluteValue            abs    |  clone
+ *      comparedTo                      |  config               set
+ *      decimalPlaces            dp     |      DECIMAL_PLACES
+ *      dividedBy                div    |      ROUNDING_MODE
+ *      dividedToIntegerBy       idiv   |      EXPONENTIAL_AT
+ *      exponentiatedBy          pow    |      RANGE
+ *      integerValue                    |      CRYPTO
+ *      isEqualTo                eq     |      MODULO_MODE
+ *      isFinite                        |      POW_PRECISION
+ *      isGreaterThan            gt     |      FORMAT
+ *      isGreaterThanOrEqualTo   gte    |      ALPHABET
+ *      isInteger                       |  isBigNumber
+ *      isLessThan               lt     |  maximum              max
+ *      isLessThanOrEqualTo      lte    |  minimum              min
+ *      isNaN                           |  random
+ *      isNegative                      |
+ *      isPositive                      |
+ *      isZero                          |
+ *      minus                           |
+ *      modulo                   mod    |
+ *      multipliedBy             times  |
+ *      negated                         |
+ *      plus                            |
+ *      precision                sd     |
+ *      shiftedBy                       |
+ *      squareRoot               sqrt   |
+ *      toExponential                   |
+ *      toFixed                         |
+ *      toFormat                        |
+ *      toFraction                      |
+ *      toJSON                          |
+ *      toNumber                        |
+ *      toPrecision                     |
+ *      toString                        |
+ *      valueOf                         |
+ *
+ */
+
+
+var isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i,
+
+  mathceil = Math.ceil,
+  mathfloor = Math.floor,
+
+  bignumberError = '[BigNumber Error] ',
+  tooManyDigits = bignumberError + 'Number primitive has more than 15 significant digits: ',
+
+  BASE = 1e14,
+  LOG_BASE = 14,
+  MAX_SAFE_INTEGER = 0x1fffffffffffff,         // 2^53 - 1
+  // MAX_INT32 = 0x7fffffff,                   // 2^31 - 1
+  POWS_TEN = [1, 10, 100, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11, 1e12, 1e13],
+  SQRT_BASE = 1e7,
+
+  // EDITABLE
+  // The limit on the value of DECIMAL_PLACES, TO_EXP_NEG, TO_EXP_POS, MIN_EXP, MAX_EXP, and
+  // the arguments to toExponential, toFixed, toFormat, and toPrecision.
+  MAX = 1E9;                                   // 0 to MAX_INT32
+
+
+/*
+ * Create and return a BigNumber constructor.
+ */
+function clone(configObject) {
+  var div, convertBase, parseNumeric,
+    P = BigNumber.prototype = { constructor: BigNumber, toString: null, valueOf: null },
+    ONE = new BigNumber(1),
+
+
+    //----------------------------- EDITABLE CONFIG DEFAULTS -------------------------------
+
+
+    // The default values below must be integers within the inclusive ranges stated.
+    // The values can also be changed at run-time using BigNumber.set.
+
+    // The maximum number of decimal places for operations involving division.
+    DECIMAL_PLACES = 20,                     // 0 to MAX
+
+    // The rounding mode used when rounding to the above decimal places, and when using
+    // toExponential, toFixed, toFormat and toPrecision, and round (default value).
+    // UP         0 Away from zero.
+    // DOWN       1 Towards zero.
+    // CEIL       2 Towards +Infinity.
+    // FLOOR      3 Towards -Infinity.
+    // HALF_UP    4 Towards nearest neighbour. If equidistant, up.
+    // HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.
+    // HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.
+    // HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.
+    // HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.
+    ROUNDING_MODE = 4,                       // 0 to 8
+
+    // EXPONENTIAL_AT : [TO_EXP_NEG , TO_EXP_POS]
+
+    // The exponent value at and beneath which toString returns exponential notation.
+    // Number type: -7
+    TO_EXP_NEG = -7,                         // 0 to -MAX
+
+    // The exponent value at and above which toString returns exponential notation.
+    // Number type: 21
+    TO_EXP_POS = 21,                         // 0 to MAX
+
+    // RANGE : [MIN_EXP, MAX_EXP]
+
+    // The minimum exponent value, beneath which underflow to zero occurs.
+    // Number type: -324  (5e-324)
+    MIN_EXP = -1e7,                          // -1 to -MAX
+
+    // The maximum exponent value, above which overflow to Infinity occurs.
+    // Number type:  308  (1.7976931348623157e+308)
+    // For MAX_EXP > 1e7, e.g. new BigNumber('1e100000000').plus(1) may be slow.
+    MAX_EXP = 1e7,                           // 1 to MAX
+
+    // Whether to use cryptographically-secure random number generation, if available.
+    CRYPTO = false,                          // true or false
+
+    // The modulo mode used when calculating the modulus: a mod n.
+    // The quotient (q = a / n) is calculated according to the corresponding rounding mode.
+    // The remainder (r) is calculated as: r = a - n * q.
+    //
+    // UP        0 The remainder is positive if the dividend is negative, else is negative.
+    // DOWN      1 The remainder has the same sign as the dividend.
+    //             This modulo mode is commonly known as 'truncated division' and is
+    //             equivalent to (a % n) in JavaScript.
+    // FLOOR     3 The remainder has the same sign as the divisor (Python %).
+    // HALF_EVEN 6 This modulo mode implements the IEEE 754 remainder function.
+    // EUCLID    9 Euclidian division. q = sign(n) * floor(a / abs(n)).
+    //             The remainder is always positive.
+    //
+    // The truncated division, floored division, Euclidian division and IEEE 754 remainder
+    // modes are commonly used for the modulus operation.
+    // Although the other rounding modes can also be used, they may not give useful results.
+    MODULO_MODE = 1,                         // 0 to 9
+
+    // The maximum number of significant digits of the result of the exponentiatedBy operation.
+    // If POW_PRECISION is 0, there will be unlimited significant digits.
+    POW_PRECISION = 0,                    // 0 to MAX
+
+    // The format specification used by the BigNumber.prototype.toFormat method.
+    FORMAT = {
+      decimalSeparator: '.',
+      groupSeparator: ',',
+      groupSize: 3,
+      secondaryGroupSize: 0,
+      fractionGroupSeparator: '\xA0',      // non-breaking space
+      fractionGroupSize: 0
+    },
+
+    // The alphabet used for base conversion.
+    // It must be at least 2 characters long, with no '.' or repeated character.
+    // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
+    ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+
+
+  //------------------------------------------------------------------------------------------
+
+
+  // CONSTRUCTOR
+
+
+  /*
+   * The BigNumber constructor and exported function.
+   * Create and return a new instance of a BigNumber object.
+   *
+   * n {number|string|BigNumber} A numeric value.
+   * [b] {number} The base of n. Integer, 2 to ALPHABET.length inclusive.
+   */
+  function BigNumber(n, b) {
+    var alphabet, c, caseChanged, e, i, isNum, len, str,
+      x = this;
+
+    // Enable constructor usage without new.
+    if (!(x instanceof BigNumber)) {
+
+      // Don't throw on constructor call without new (#81).
+      // '[BigNumber Error] Constructor call without new: {n}'
+      //throw Error(bignumberError + ' Constructor call without new: ' + n);
+      return new BigNumber(n, b);
+    }
+
+    if (b == null) {
+
+      // Duplicate.
+      if (n instanceof BigNumber) {
+        x.s = n.s;
+        x.e = n.e;
+        x.c = (n = n.c) ? n.slice() : n;
+        return;
+      }
+
+      isNum = typeof n == 'number';
+
+      if (isNum && n * 0 == 0) {
+
+        // Use `1 / n` to handle minus zero also.
+        x.s = 1 / n < 0 ? (n = -n, -1) : 1;
+
+        // Faster path for integers.
+        if (n === ~~n) {
+          for (e = 0, i = n; i >= 10; i /= 10, e++);
+          x.e = e;
+          x.c = [n];
+          return;
+        }
+
+        str = n + '';
+      } else {
+        if (!isNumeric.test(str = n + '')) return parseNumeric(x, str, isNum);
+        x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;
+      }
+
+      // Decimal point?
+        if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');
+
+        // Exponential form?
+        if ((i = str.search(/e/i)) > 0) {
+
+          // Determine exponent.
+          if (e < 0) e = i;
+          e += +str.slice(i + 1);
+          str = str.substring(0, i);
+        } else if (e < 0) {
+
+          // Integer.
+          e = str.length;
+        }
+
+    } else {
+
+      // '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'
+      intCheck(b, 2, ALPHABET.length, 'Base');
+      str = n + '';
+
+      // Allow exponential notation to be used with base 10 argument, while
+      // also rounding to DECIMAL_PLACES as with other bases.
+      if (b == 10) {
+        x = new BigNumber(n instanceof BigNumber ? n : str);
+        return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
+      }
+
+      isNum = typeof n == 'number';
+
+      if (isNum) {
+
+        // Avoid potential interpretation of Infinity and NaN as base 44+ values.
+        if (n * 0 != 0) return parseNumeric(x, str, isNum, b);
+
+        x.s = 1 / n < 0 ? (str = str.slice(1), -1) : 1;
+
+        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'
+        if (BigNumber.DEBUG && str.replace(/^0\.0*|\./, '').length > 15) {
+          throw Error
+           (tooManyDigits + n);
+        }
+
+        // Prevent later check for length on converted number.
+        isNum = false;
+      } else {
+        x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
+      }
+
+      alphabet = ALPHABET.slice(0, b);
+      e = i = 0;
+
+      // Check that str is a valid base b number.
+      // Don't use RegExp so alphabet can contain special characters.
+      for (len = str.length; i < len; i++) {
+        if (alphabet.indexOf(c = str.charAt(i)) < 0) {
+          if (c == '.') {
+
+            // If '.' is not the first character and it has not be found before.
+            if (i > e) {
+              e = len;
+              continue;
+            }
+          } else if (!caseChanged) {
+
+            // Allow e.g. hexadecimal 'FF' as well as 'ff'.
+            if (str == str.toUpperCase() && (str = str.toLowerCase()) ||
+                str == str.toLowerCase() && (str = str.toUpperCase())) {
+              caseChanged = true;
+              i = -1;
+              e = 0;
+              continue;
+            }
+          }
+
+          return parseNumeric(x, n + '', isNum, b);
+        }
+      }
+
+      str = convertBase(str, b, 10, x.s);
+
+      // Decimal point?
+      if ((e = str.indexOf('.')) > -1) str = str.replace('.', '');
+      else e = str.length;
+    }
+
+    // Determine leading zeros.
+    for (i = 0; str.charCodeAt(i) === 48; i++);
+
+    // Determine trailing zeros.
+    for (len = str.length; str.charCodeAt(--len) === 48;);
+
+    str = str.slice(i, ++len);
+
+    if (str) {
+      len -= i;
+
+      // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'
+      if (isNum && BigNumber.DEBUG &&
+        len > 15 && (n > MAX_SAFE_INTEGER || n !== mathfloor(n))) {
+          throw Error
+           (tooManyDigits + (x.s * n));
+      }
+
+      e = e - i - 1;
+
+       // Overflow?
+      if (e > MAX_EXP) {
+
+        // Infinity.
+        x.c = x.e = null;
+
+      // Underflow?
+      } else if (e < MIN_EXP) {
+
+        // Zero.
+        x.c = [x.e = 0];
+      } else {
+        x.e = e;
+        x.c = [];
+
+        // Transform base
+
+        // e is the base 10 exponent.
+        // i is where to slice str to get the first element of the coefficient array.
+        i = (e + 1) % LOG_BASE;
+        if (e < 0) i += LOG_BASE;
+
+        if (i < len) {
+          if (i) x.c.push(+str.slice(0, i));
+
+          for (len -= LOG_BASE; i < len;) {
+            x.c.push(+str.slice(i, i += LOG_BASE));
+          }
+
+          str = str.slice(i);
+          i = LOG_BASE - str.length;
+        } else {
+          i -= len;
+        }
+
+        for (; i--; str += '0');
+        x.c.push(+str);
+      }
+    } else {
+
+      // Zero.
+      x.c = [x.e = 0];
+    }
+  }
+
+
+  // CONSTRUCTOR PROPERTIES
+
+
+  BigNumber.clone = clone;
+
+  BigNumber.ROUND_UP = 0;
+  BigNumber.ROUND_DOWN = 1;
+  BigNumber.ROUND_CEIL = 2;
+  BigNumber.ROUND_FLOOR = 3;
+  BigNumber.ROUND_HALF_UP = 4;
+  BigNumber.ROUND_HALF_DOWN = 5;
+  BigNumber.ROUND_HALF_EVEN = 6;
+  BigNumber.ROUND_HALF_CEIL = 7;
+  BigNumber.ROUND_HALF_FLOOR = 8;
+  BigNumber.EUCLID = 9;
+
+
+  /*
+   * Configure infrequently-changing library-wide settings.
+   *
+   * Accept an object with the following optional properties (if the value of a property is
+   * a number, it must be an integer within the inclusive range stated):
+   *
+   *   DECIMAL_PLACES   {number}           0 to MAX
+   *   ROUNDING_MODE    {number}           0 to 8
+   *   EXPONENTIAL_AT   {number|number[]}  -MAX to MAX  or  [-MAX to 0, 0 to MAX]
+   *   RANGE            {number|number[]}  -MAX to MAX (not zero)  or  [-MAX to -1, 1 to MAX]
+   *   CRYPTO           {boolean}          true or false
+   *   MODULO_MODE      {number}           0 to 9
+   *   POW_PRECISION       {number}           0 to MAX
+   *   ALPHABET         {string}           A string of two or more unique characters which does
+   *                                     not contain '.'.
+   *   FORMAT           {object}           An object with some of the following properties:
+   *      decimalSeparator       {string}
+   *      groupSeparator         {string}
+   *      groupSize              {number}
+   *      secondaryGroupSize     {number}
+   *      fractionGroupSeparator {string}
+   *      fractionGroupSize      {number}
+   *
+   * (The values assigned to the above FORMAT object properties are not checked for validity.)
+   *
+   * E.g.
+   * BigNumber.config({ DECIMAL_PLACES : 20, ROUNDING_MODE : 4 })
+   *
+   * Ignore properties/parameters set to null or undefined, except for ALPHABET.
+   *
+   * Return an object with the properties current values.
+   */
+  BigNumber.config = BigNumber.set = function (obj) {
+    var p, v;
+
+    if (obj != null) {
+
+      if (typeof obj == 'object') {
+
+        // DECIMAL_PLACES {number} Integer, 0 to MAX inclusive.
+        // '[BigNumber Error] DECIMAL_PLACES {not a primitive number|not an integer|out of range}: {v}'
+        if (obj.hasOwnProperty(p = 'DECIMAL_PLACES')) {
+          v = obj[p];
+          intCheck(v, 0, MAX, p);
+          DECIMAL_PLACES = v;
+        }
+
+        // ROUNDING_MODE {number} Integer, 0 to 8 inclusive.
+        // '[BigNumber Error] ROUNDING_MODE {not a primitive number|not an integer|out of range}: {v}'
+        if (obj.hasOwnProperty(p = 'ROUNDING_MODE')) {
+          v = obj[p];
+          intCheck(v, 0, 8, p);
+          ROUNDING_MODE = v;
+        }
+
+        // EXPONENTIAL_AT {number|number[]}
+        // Integer, -MAX to MAX inclusive or
+        // [integer -MAX to 0 inclusive, 0 to MAX inclusive].
+        // '[BigNumber Error] EXPONENTIAL_AT {not a primitive number|not an integer|out of range}: {v}'
+        if (obj.hasOwnProperty(p = 'EXPONENTIAL_AT')) {
+          v = obj[p];
+          if (isArray(v)) {
+            intCheck(v[0], -MAX, 0, p);
+            intCheck(v[1], 0, MAX, p);
+            TO_EXP_NEG = v[0];
+            TO_EXP_POS = v[1];
+          } else {
+            intCheck(v, -MAX, MAX, p);
+            TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);
+          }
+        }
+
+        // RANGE {number|number[]} Non-zero integer, -MAX to MAX inclusive or
+        // [integer -MAX to -1 inclusive, integer 1 to MAX inclusive].
+        // '[BigNumber Error] RANGE {not a primitive number|not an integer|out of range|cannot be zero}: {v}'
+        if (obj.hasOwnProperty(p = 'RANGE')) {
+          v = obj[p];
+          if (isArray(v)) {
+            intCheck(v[0], -MAX, -1, p);
+            intCheck(v[1], 1, MAX, p);
+            MIN_EXP = v[0];
+            MAX_EXP = v[1];
+          } else {
+            intCheck(v, -MAX, MAX, p);
+            if (v) {
+              MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);
+            } else {
+              throw Error
+               (bignumberError + p + ' cannot be zero: ' + v);
+            }
+          }
+        }
+
+        // CRYPTO {boolean} true or false.
+        // '[BigNumber Error] CRYPTO not true or false: {v}'
+        // '[BigNumber Error] crypto unavailable'
+        if (obj.hasOwnProperty(p = 'CRYPTO')) {
+          v = obj[p];
+          if (v === !!v) {
+            if (v) {
+              if (typeof crypto != 'undefined' && crypto &&
+               (crypto.getRandomValues || crypto.randomBytes)) {
+                CRYPTO = v;
+              } else {
+                CRYPTO = !v;
+                throw Error
+                 (bignumberError + 'crypto unavailable');
+              }
+            } else {
+              CRYPTO = v;
+            }
+          } else {
+            throw Error
+             (bignumberError + p + ' not true or false: ' + v);
+          }
+        }
+
+        // MODULO_MODE {number} Integer, 0 to 9 inclusive.
+        // '[BigNumber Error] MODULO_MODE {not a primitive number|not an integer|out of range}: {v}'
+        if (obj.hasOwnProperty(p = 'MODULO_MODE')) {
+          v = obj[p];
+          intCheck(v, 0, 9, p);
+          MODULO_MODE = v;
+        }
+
+        // POW_PRECISION {number} Integer, 0 to MAX inclusive.
+        // '[BigNumber Error] POW_PRECISION {not a primitive number|not an integer|out of range}: {v}'
+        if (obj.hasOwnProperty(p = 'POW_PRECISION')) {
+          v = obj[p];
+          intCheck(v, 0, MAX, p);
+          POW_PRECISION = v;
+        }
+
+        // FORMAT {object}
+        // '[BigNumber Error] FORMAT not an object: {v}'
+        if (obj.hasOwnProperty(p = 'FORMAT')) {
+          v = obj[p];
+          if (typeof v == 'object') FORMAT = v;
+          else throw Error
+           (bignumberError + p + ' not an object: ' + v);
+        }
+
+        // ALPHABET {string}
+        // '[BigNumber Error] ALPHABET invalid: {v}'
+        if (obj.hasOwnProperty(p = 'ALPHABET')) {
+          v = obj[p];
+
+          // Disallow if only one character, or contains '.' or a repeated character.
+          if (typeof v == 'string' && !/^.$|\.|(.).*\1/.test(v)) {
+            ALPHABET = v;
+          } else {
+            throw Error
+             (bignumberError + p + ' invalid: ' + v);
+          }
+        }
+
+      } else {
+
+        // '[BigNumber Error] Object expected: {v}'
+        throw Error
+         (bignumberError + 'Object expected: ' + obj);
+      }
+    }
+
+    return {
+      DECIMAL_PLACES: DECIMAL_PLACES,
+      ROUNDING_MODE: ROUNDING_MODE,
+      EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],
+      RANGE: [MIN_EXP, MAX_EXP],
+      CRYPTO: CRYPTO,
+      MODULO_MODE: MODULO_MODE,
+      POW_PRECISION: POW_PRECISION,
+      FORMAT: FORMAT,
+      ALPHABET: ALPHABET
+    };
+  };
+
+
+  /*
+   * Return true if v is a BigNumber instance, otherwise return false.
+   *
+   * v {any}
+   */
+  BigNumber.isBigNumber = function (v) {
+    return v instanceof BigNumber || v && v._isBigNumber === true || false;
+  };
+
+
+  /*
+   * Return a new BigNumber whose value is the maximum of the arguments.
+   *
+   * arguments {number|string|BigNumber}
+   */
+  BigNumber.maximum = BigNumber.max = function () {
+    return maxOrMin(arguments, P.lt);
+  };
+
+
+  /*
+   * Return a new BigNumber whose value is the minimum of the arguments.
+   *
+   * arguments {number|string|BigNumber}
+   */
+  BigNumber.minimum = BigNumber.min = function () {
+    return maxOrMin(arguments, P.gt);
+  };
+
+
+  /*
+   * Return a new BigNumber with a random value equal to or greater than 0 and less than 1,
+   * and with dp, or DECIMAL_PLACES if dp is omitted, decimal places (or less if trailing
+   * zeros are produced).
+   *
+   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.
+   *
+   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp}'
+   * '[BigNumber Error] crypto unavailable'
+   */
+  BigNumber.random = (function () {
+    var pow2_53 = 0x20000000000000;
+
+    // Return a 53 bit integer n, where 0 <= n < 9007199254740992.
+    // Check if Math.random() produces more than 32 bits of randomness.
+    // If it does, assume at least 53 bits are produced, otherwise assume at least 30 bits.
+    // 0x40000000 is 2^30, 0x800000 is 2^23, 0x1fffff is 2^21 - 1.
+    var random53bitInt = (Math.random() * pow2_53) & 0x1fffff
+     ? function () { return mathfloor(Math.random() * pow2_53); }
+     : function () { return ((Math.random() * 0x40000000 | 0) * 0x800000) +
+       (Math.random() * 0x800000 | 0); };
+
+    return function (dp) {
+      var a, b, e, k, v,
+        i = 0,
+        c = [],
+        rand = new BigNumber(ONE);
+
+      if (dp == null) dp = DECIMAL_PLACES;
+      else intCheck(dp, 0, MAX);
+
+      k = mathceil(dp / LOG_BASE);
+
+      if (CRYPTO) {
+
+        // Browsers supporting crypto.getRandomValues.
+        if (crypto.getRandomValues) {
+
+          a = crypto.getRandomValues(new Uint32Array(k *= 2));
+
+          for (; i < k;) {
+
+            // 53 bits:
+            // ((Math.pow(2, 32) - 1) * Math.pow(2, 21)).toString(2)
+            // 11111 11111111 11111111 11111111 11100000 00000000 00000000
+            // ((Math.pow(2, 32) - 1) >>> 11).toString(2)
+            //                                     11111 11111111 11111111
+            // 0x20000 is 2^21.
+            v = a[i] * 0x20000 + (a[i + 1] >>> 11);
+
+            // Rejection sampling:
+            // 0 <= v < 9007199254740992
+            // Probability that v >= 9e15, is
+            // 7199254740992 / 9007199254740992 ~= 0.0008, i.e. 1 in 1251
+            if (v >= 9e15) {
+              b = crypto.getRandomValues(new Uint32Array(2));
+              a[i] = b[0];
+              a[i + 1] = b[1];
+            } else {
+
+              // 0 <= v <= 8999999999999999
+              // 0 <= (v % 1e14) <= 99999999999999
+              c.push(v % 1e14);
+              i += 2;
+            }
+          }
+          i = k / 2;
+
+        // Node.js supporting crypto.randomBytes.
+        } else if (crypto.randomBytes) {
+
+          // buffer
+          a = crypto.randomBytes(k *= 7);
+
+          for (; i < k;) {
+
+            // 0x1000000000000 is 2^48, 0x10000000000 is 2^40
+            // 0x100000000 is 2^32, 0x1000000 is 2^24
+            // 11111 11111111 11111111 11111111 11111111 11111111 11111111
+            // 0 <= v < 9007199254740992
+            v = ((a[i] & 31) * 0x1000000000000) + (a[i + 1] * 0x10000000000) +
+               (a[i + 2] * 0x100000000) + (a[i + 3] * 0x1000000) +
+               (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];
+
+            if (v >= 9e15) {
+              crypto.randomBytes(7).copy(a, i);
+            } else {
+
+              // 0 <= (v % 1e14) <= 99999999999999
+              c.push(v % 1e14);
+              i += 7;
+            }
+          }
+          i = k / 7;
+        } else {
+          CRYPTO = false;
+          throw Error
+           (bignumberError + 'crypto unavailable');
+        }
+      }
+
+      // Use Math.random.
+      if (!CRYPTO) {
+
+        for (; i < k;) {
+          v = random53bitInt();
+          if (v < 9e15) c[i++] = v % 1e14;
+        }
+      }
+
+      k = c[--i];
+      dp %= LOG_BASE;
+
+      // Convert trailing digits to zeros according to dp.
+      if (k && dp) {
+        v = POWS_TEN[LOG_BASE - dp];
+        c[i] = mathfloor(k / v) * v;
+      }
+
+      // Remove trailing elements which are zero.
+      for (; c[i] === 0; c.pop(), i--);
+
+      // Zero?
+      if (i < 0) {
+        c = [e = 0];
+      } else {
+
+        // Remove leading elements which are zero and adjust exponent accordingly.
+        for (e = -1 ; c[0] === 0; c.splice(0, 1), e -= LOG_BASE);
+
+        // Count the digits of the first element of c to determine leading zeros, and...
+        for (i = 1, v = c[0]; v >= 10; v /= 10, i++);
+
+        // adjust the exponent accordingly.
+        if (i < LOG_BASE) e -= LOG_BASE - i;
+      }
+
+      rand.e = e;
+      rand.c = c;
+      return rand;
+    };
+  })();
+
+
+  // PRIVATE FUNCTIONS
+
+
+  // Called by BigNumber and BigNumber.prototype.toString.
+  convertBase = (function () {
+    var decimal = '0123456789';
+
+    /*
+     * Convert string of baseIn to an array of numbers of baseOut.
+     * Eg. toBaseOut('255', 10, 16) returns [15, 15].
+     * Eg. toBaseOut('ff', 16, 10) returns [2, 5, 5].
+     */
+    function toBaseOut(str, baseIn, baseOut, alphabet) {
+      var j,
+        arr = [0],
+        arrL,
+        i = 0,
+        len = str.length;
+
+      for (; i < len;) {
+        for (arrL = arr.length; arrL--; arr[arrL] *= baseIn);
+
+        arr[0] += alphabet.indexOf(str.charAt(i++));
+
+        for (j = 0; j < arr.length; j++) {
+
+          if (arr[j] > baseOut - 1) {
+            if (arr[j + 1] == null) arr[j + 1] = 0;
+            arr[j + 1] += arr[j] / baseOut | 0;
+            arr[j] %= baseOut;
+          }
+        }
+      }
+
+      return arr.reverse();
+    }
+
+    // Convert a numeric string of baseIn to a numeric string of baseOut.
+    // If the caller is toString, we are converting from base 10 to baseOut.
+    // If the caller is BigNumber, we are converting from baseIn to base 10.
+    return function (str, baseIn, baseOut, sign, callerIsToString) {
+      var alphabet, d, e, k, r, x, xc, y,
+        i = str.indexOf('.'),
+        dp = DECIMAL_PLACES,
+        rm = ROUNDING_MODE;
+
+      // Non-integer.
+      if (i >= 0) {
+        k = POW_PRECISION;
+
+        // Unlimited precision.
+        POW_PRECISION = 0;
+        str = str.replace('.', '');
+        y = new BigNumber(baseIn);
+        x = y.pow(str.length - i);
+        POW_PRECISION = k;
+
+        // Convert str as if an integer, then restore the fraction part by dividing the
+        // result by its base raised to a power.
+
+        y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, '0'),
+         10, baseOut, decimal);
+        y.e = y.c.length;
+      }
+
+      // Convert the number as integer.
+
+      xc = toBaseOut(str, baseIn, baseOut, callerIsToString
+       ? (alphabet = ALPHABET, decimal)
+       : (alphabet = decimal, ALPHABET));
+
+      // xc now represents str as an integer and converted to baseOut. e is the exponent.
+      e = k = xc.length;
+
+      // Remove trailing zeros.
+      for (; xc[--k] == 0; xc.pop());
+
+      // Zero?
+      if (!xc[0]) return alphabet.charAt(0);
+
+      // Does str represent an integer? If so, no need for the division.
+      if (i < 0) {
+        --e;
+      } else {
+        x.c = xc;
+        x.e = e;
+
+        // The sign is needed for correct rounding.
+        x.s = sign;
+        x = div(x, y, dp, rm, baseOut);
+        xc = x.c;
+        r = x.r;
+        e = x.e;
+      }
+
+      // xc now represents str converted to baseOut.
+
+      // THe index of the rounding digit.
+      d = e + dp + 1;
+
+      // The rounding digit: the digit to the right of the digit that may be rounded up.
+      i = xc[d];
+
+      // Look at the rounding digits and mode to determine whether to round up.
+
+      k = baseOut / 2;
+      r = r || d < 0 || xc[d + 1] != null;
+
+      r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))
+            : i > k || i == k &&(rm == 4 || r || rm == 6 && xc[d - 1] & 1 ||
+             rm == (x.s < 0 ? 8 : 7));
+
+      // If the index of the rounding digit is not greater than zero, or xc represents
+      // zero, then the result of the base conversion is zero or, if rounding up, a value
+      // such as 0.00001.
+      if (d < 1 || !xc[0]) {
+
+        // 1^-dp or 0
+        str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0))
+            : alphabet.charAt(0);
+      } else {
+
+        // Truncate xc to the required number of decimal places.
+        xc.length = d;
+
+        // Round up?
+        if (r) {
+
+          // Rounding up may mean the previous digit has to be rounded up and so on.
+          for (--baseOut; ++xc[--d] > baseOut;) {
+            xc[d] = 0;
+
+            if (!d) {
+              ++e;
+              xc = [1].concat(xc);
+            }
+          }
+        }
+
+        // Determine trailing zeros.
+        for (k = xc.length; !xc[--k];);
+
+        // E.g. [4, 11, 15] becomes 4bf.
+        for (i = 0, str = ''; i <= k; str += alphabet.charAt(xc[i++]));
+
+        // Add leading zeros, decimal point and trailing zeros as required.
+        str = toFixedPoint(str, e, alphabet.charAt(0));
+      }
+
+      // The caller will add the sign.
+      return str;
+    };
+  })();
+
+
+  // Perform division in the specified base. Called by div and convertBase.
+  div = (function () {
+
+    // Assume non-zero x and k.
+    function multiply(x, k, base) {
+      var m, temp, xlo, xhi,
+        carry = 0,
+        i = x.length,
+        klo = k % SQRT_BASE,
+        khi = k / SQRT_BASE | 0;
+
+      for (x = x.slice(); i--;) {
+        xlo = x[i] % SQRT_BASE;
+        xhi = x[i] / SQRT_BASE | 0;
+        m = khi * xlo + xhi * klo;
+        temp = klo * xlo + ((m % SQRT_BASE) * SQRT_BASE) + carry;
+        carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;
+        x[i] = temp % base;
+      }
+
+      if (carry) x = [carry].concat(x);
+
+      return x;
+    }
+
+    function compare(a, b, aL, bL) {
+      var i, cmp;
+
+      if (aL != bL) {
+        cmp = aL > bL ? 1 : -1;
+      } else {
+
+        for (i = cmp = 0; i < aL; i++) {
+
+          if (a[i] != b[i]) {
+            cmp = a[i] > b[i] ? 1 : -1;
+            break;
+          }
+        }
+      }
+
+      return cmp;
+    }
+
+    function subtract(a, b, aL, base) {
+      var i = 0;
+
+      // Subtract b from a.
+      for (; aL--;) {
+        a[aL] -= i;
+        i = a[aL] < b[aL] ? 1 : 0;
+        a[aL] = i * base + a[aL] - b[aL];
+      }
+
+      // Remove leading zeros.
+      for (; !a[0] && a.length > 1; a.splice(0, 1));
+    }
+
+    // x: dividend, y: divisor.
+    return function (x, y, dp, rm, base) {
+      var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0,
+        yL, yz,
+        s = x.s == y.s ? 1 : -1,
+        xc = x.c,
+        yc = y.c;
+
+      // Either NaN, Infinity or 0?
+      if (!xc || !xc[0] || !yc || !yc[0]) {
+
+        return new BigNumber(
+
+         // Return NaN if either NaN, or both Infinity or 0.
+         !x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN :
+
+          // Return ±0 if x is ±0 or y is ±Infinity, or return ±Infinity as y is ±0.
+          xc && xc[0] == 0 || !yc ? s * 0 : s / 0
+       );
+      }
+
+      q = new BigNumber(s);
+      qc = q.c = [];
+      e = x.e - y.e;
+      s = dp + e + 1;
+
+      if (!base) {
+        base = BASE;
+        e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);
+        s = s / LOG_BASE | 0;
+      }
+
+      // Result exponent may be one less then the current value of e.
+      // The coefficients of the BigNumbers from convertBase may have trailing zeros.
+      for (i = 0; yc[i] == (xc[i] || 0); i++);
+
+      if (yc[i] > (xc[i] || 0)) e--;
+
+      if (s < 0) {
+        qc.push(1);
+        more = true;
+      } else {
+        xL = xc.length;
+        yL = yc.length;
+        i = 0;
+        s += 2;
+
+        // Normalise xc and yc so highest order digit of yc is >= base / 2.
+
+        n = mathfloor(base / (yc[0] + 1));
+
+        // Not necessary, but to handle odd bases where yc[0] == (base / 2) - 1.
+        // if (n > 1 || n++ == 1 && yc[0] < base / 2) {
+        if (n > 1) {
+          yc = multiply(yc, n, base);
+          xc = multiply(xc, n, base);
+          yL = yc.length;
+          xL = xc.length;
+        }
+
+        xi = yL;
+        rem = xc.slice(0, yL);
+        remL = rem.length;
+
+        // Add zeros to make remainder as long as divisor.
+        for (; remL < yL; rem[remL++] = 0);
+        yz = yc.slice();
+        yz = [0].concat(yz);
+        yc0 = yc[0];
+        if (yc[1] >= base / 2) yc0++;
+        // Not necessary, but to prevent trial digit n > base, when using base 3.
+        // else if (base == 3 && yc0 == 1) yc0 = 1 + 1e-15;
+
+        do {
+          n = 0;
+
+          // Compare divisor and remainder.
+          cmp = compare(yc, rem, yL, remL);
+
+          // If divisor < remainder.
+          if (cmp < 0) {
+
+            // Calculate trial digit, n.
+
+            rem0 = rem[0];
+            if (yL != remL) rem0 = rem0 * base + (rem[1] || 0);
+
+            // n is how many times the divisor goes into the current remainder.
+            n = mathfloor(rem0 / yc0);
+
+            //  Algorithm:
+            //  product = divisor multiplied by trial digit (n).
+            //  Compare product and remainder.
+            //  If product is greater than remainder:
+            //    Subtract divisor from product, decrement trial digit.
+            //  Subtract product from remainder.
+            //  If product was less than remainder at the last compare:
+            //    Compare new remainder and divisor.
+            //    If remainder is greater than divisor:
+            //      Subtract divisor from remainder, increment trial digit.
+
+            if (n > 1) {
+
+              // n may be > base only when base is 3.
+              if (n >= base) n = base - 1;
+
+              // product = divisor * trial digit.
+              prod = multiply(yc, n, base);
+              prodL = prod.length;
+              remL = rem.length;
+
+              // Compare product and remainder.
+              // If product > remainder then trial digit n too high.
+              // n is 1 too high about 5% of the time, and is not known to have
+              // ever been more than 1 too high.
+              while (compare(prod, rem, prodL, remL) == 1) {
+                n--;
+
+                // Subtract divisor from product.
+                subtract(prod, yL < prodL ? yz : yc, prodL, base);
+                prodL = prod.length;
+                cmp = 1;
+              }
+            } else {
+
+              // n is 0 or 1, cmp is -1.
+              // If n is 0, there is no need to compare yc and rem again below,
+              // so change cmp to 1 to avoid it.
+              // If n is 1, leave cmp as -1, so yc and rem are compared again.
+              if (n == 0) {
+
+                // divisor < remainder, so n must be at least 1.
+                cmp = n = 1;
+              }
+
+              // product = divisor
+              prod = yc.slice();
+              prodL = prod.length;
+            }
+
+            if (prodL < remL) prod = [0].concat(prod);
+
+            // Subtract product from remainder.
+            subtract(rem, prod, remL, base);
+            remL = rem.length;
+
+             // If product was < remainder.
+            if (cmp == -1) {
+
+              // Compare divisor and new remainder.
+              // If divisor < new remainder, subtract divisor from remainder.
+              // Trial digit n too low.
+              // n is 1 too low about 5% of the time, and very rarely 2 too low.
+              while (compare(yc, rem, yL, remL) < 1) {
+                n++;
+
+                // Subtract divisor from remainder.
+                subtract(rem, yL < remL ? yz : yc, remL, base);
+                remL = rem.length;
+              }
+            }
+          } else if (cmp === 0) {
+            n++;
+            rem = [0];
+          } // else cmp === 1 and n will be 0
+
+          // Add the next digit, n, to the result array.
+          qc[i++] = n;
+
+          // Update the remainder.
+          if (rem[0]) {
+            rem[remL++] = xc[xi] || 0;
+          } else {
+            rem = [xc[xi]];
+            remL = 1;
+          }
+        } while ((xi++ < xL || rem[0] != null) && s--);
+
+        more = rem[0] != null;
+
+        // Leading zero?
+        if (!qc[0]) qc.splice(0, 1);
+      }
+
+      if (base == BASE) {
+
+        // To calculate q.e, first get the number of digits of qc[0].
+        for (i = 1, s = qc[0]; s >= 10; s /= 10, i++);
+
+        round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);
+
+      // Caller is convertBase.
+      } else {
+        q.e = e;
+        q.r = +more;
+      }
+
+      return q;
+    };
+  })();
+
+
+  /*
+   * Return a string representing the value of BigNumber n in fixed-point or exponential
+   * notation rounded to the specified decimal places or significant digits.
+   *
+   * n: a BigNumber.
+   * i: the index of the last digit required (i.e. the digit that may be rounded up).
+   * rm: the rounding mode.
+   * id: 1 (toExponential) or 2 (toPrecision).
+   */
+  function format(n, i, rm, id) {
+    var c0, e, ne, len, str;
+
+    if (rm == null) rm = ROUNDING_MODE;
+    else intCheck(rm, 0, 8);
+
+    if (!n.c) return n.toString();
+
+    c0 = n.c[0];
+    ne = n.e;
+
+    if (i == null) {
+      str = coeffToString(n.c);
+      str = id == 1 || id == 2 && ne <= TO_EXP_NEG
+       ? toExponential(str, ne)
+       : toFixedPoint(str, ne, '0');
+    } else {
+      n = round(new BigNumber(n), i, rm);
+
+      // n.e may have changed if the value was rounded up.
+      e = n.e;
+
+      str = coeffToString(n.c);
+      len = str.length;
+
+      // toPrecision returns exponential notation if the number of significant digits
+      // specified is less than the number of digits necessary to represent the integer
+      // part of the value in fixed-point notation.
+
+      // Exponential notation.
+      if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {
+
+        // Append zeros?
+        for (; len < i; str += '0', len++);
+        str = toExponential(str, e);
+
+      // Fixed-point notation.
+      } else {
+        i -= ne;
+        str = toFixedPoint(str, e, '0');
+
+        // Append zeros?
+        if (e + 1 > len) {
+          if (--i > 0) for (str += '.'; i--; str += '0');
+        } else {
+          i += e - len;
+          if (i > 0) {
+            if (e + 1 == len) str += '.';
+            for (; i--; str += '0');
+          }
+        }
+      }
+    }
+
+    return n.s < 0 && c0 ? '-' + str : str;
+  }
+
+
+  // Handle BigNumber.max and BigNumber.min.
+  function maxOrMin(args, method) {
+    var m, n,
+      i = 0;
+
+    if (isArray(args[0])) args = args[0];
+    m = new BigNumber(args[0]);
+
+    for (; ++i < args.length;) {
+      n = new BigNumber(args[i]);
+
+      // If any number is NaN, return NaN.
+      if (!n.s) {
+        m = n;
+        break;
+      } else if (method.call(m, n)) {
+        m = n;
+      }
+    }
+
+    return m;
+  }
+
+
+  /*
+   * Strip trailing zeros, calculate base 10 exponent and check against MIN_EXP and MAX_EXP.
+   * Called by minus, plus and times.
+   */
+  function normalise(n, c, e) {
+    var i = 1,
+      j = c.length;
+
+     // Remove trailing zeros.
+    for (; !c[--j]; c.pop());
+
+    // Calculate the base 10 exponent. First get the number of digits of c[0].
+    for (j = c[0]; j >= 10; j /= 10, i++);
+
+    // Overflow?
+    if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {
+
+      // Infinity.
+      n.c = n.e = null;
+
+    // Underflow?
+    } else if (e < MIN_EXP) {
+
+      // Zero.
+      n.c = [n.e = 0];
+    } else {
+      n.e = e;
+      n.c = c;
+    }
+
+    return n;
+  }
+
+
+  // Handle values that fail the validity test in BigNumber.
+  parseNumeric = (function () {
+    var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i,
+      dotAfter = /^([^.]+)\.$/,
+      dotBefore = /^\.([^.]+)$/,
+      isInfinityOrNaN = /^-?(Infinity|NaN)$/,
+      whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g;
+
+    return function (x, str, isNum, b) {
+      var base,
+        s = isNum ? str : str.replace(whitespaceOrPlus, '');
+
+      // No exception on ±Infinity or NaN.
+      if (isInfinityOrNaN.test(s)) {
+        x.s = isNaN(s) ? null : s < 0 ? -1 : 1;
+        x.c = x.e = null;
+      } else {
+        if (!isNum) {
+
+          // basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i
+          s = s.replace(basePrefix, function (m, p1, p2) {
+            base = (p2 = p2.toLowerCase()) == 'x' ? 16 : p2 == 'b' ? 2 : 8;
+            return !b || b == base ? p1 : m;
+          });
+
+          if (b) {
+            base = b;
+
+            // E.g. '1.' to '1', '.1' to '0.1'
+            s = s.replace(dotAfter, '$1').replace(dotBefore, '0.$1');
+          }
+
+          if (str != s) return new BigNumber(s, base);
+        }
+
+        // '[BigNumber Error] Not a number: {n}'
+        // '[BigNumber Error] Not a base {b} number: {n}'
+        if (BigNumber.DEBUG) {
+          throw Error
+            (bignumberError + 'Not a' + (b ? ' base ' + b : '') + ' number: ' + str);
+        }
+
+        // NaN
+        x.c = x.e = x.s = null;
+      }
+    }
+  })();
+
+
+  /*
+   * Round x to sd significant digits using rounding mode rm. Check for over/under-flow.
+   * If r is truthy, it is known that there are more digits after the rounding digit.
+   */
+  function round(x, sd, rm, r) {
+    var d, i, j, k, n, ni, rd,
+      xc = x.c,
+      pows10 = POWS_TEN;
+
+    // if x is not Infinity or NaN...
+    if (xc) {
+
+      // rd is the rounding digit, i.e. the digit after the digit that may be rounded up.
+      // n is a base 1e14 number, the value of the element of array x.c containing rd.
+      // ni is the index of n within x.c.
+      // d is the number of digits of n.
+      // i is the index of rd within n including leading zeros.
+      // j is the actual index of rd within n (if < 0, rd is a leading zero).
+      out: {
+
+        // Get the number of digits of the first element of xc.
+        for (d = 1, k = xc[0]; k >= 10; k /= 10, d++);
+        i = sd - d;
+
+        // If the rounding digit is in the first element of xc...
+        if (i < 0) {
+          i += LOG_BASE;
+          j = sd;
+          n = xc[ni = 0];
+
+          // Get the rounding digit at index j of n.
+          rd = n / pows10[d - j - 1] % 10 | 0;
+        } else {
+          ni = mathceil((i + 1) / LOG_BASE);
+
+          if (ni >= xc.length) {
+
+            if (r) {
+
+              // Needed by sqrt.
+              for (; xc.length <= ni; xc.push(0));
+              n = rd = 0;
+              d = 1;
+              i %= LOG_BASE;
+              j = i - LOG_BASE + 1;
+            } else {
+              break out;
+            }
+          } else {
+            n = k = xc[ni];
+
+            // Get the number of digits of n.
+            for (d = 1; k >= 10; k /= 10, d++);
+
+            // Get the index of rd within n.
+            i %= LOG_BASE;
+
+            // Get the index of rd within n, adjusted for leading zeros.
+            // The number of leading zeros of n is given by LOG_BASE - d.
+            j = i - LOG_BASE + d;
+
+            // Get the rounding digit at index j of n.
+            rd = j < 0 ? 0 : n / pows10[d - j - 1] % 10 | 0;
+          }
+        }
+
+        r = r || sd < 0 ||
+
+        // Are there any non-zero digits after the rounding digit?
+        // The expression  n % pows10[d - j - 1]  returns all digits of n to the right
+        // of the digit at j, e.g. if n is 908714 and j is 2, the expression gives 714.
+         xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);
+
+        r = rm < 4
+         ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2))
+         : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 &&
+
+          // Check whether the digit to the left of the rounding digit is odd.
+          ((i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10) & 1 ||
+           rm == (x.s < 0 ? 8 : 7));
+
+        if (sd < 1 || !xc[0]) {
+          xc.length = 0;
+
+          if (r) {
+
+            // Convert sd to decimal places.
+            sd -= x.e + 1;
+
+            // 1, 0.1, 0.01, 0.001, 0.0001 etc.
+            xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];
+            x.e = -sd || 0;
+          } else {
+
+            // Zero.
+            xc[0] = x.e = 0;
+          }
+
+          return x;
+        }
+
+        // Remove excess digits.
+        if (i == 0) {
+          xc.length = ni;
+          k = 1;
+          ni--;
+        } else {
+          xc.length = ni + 1;
+          k = pows10[LOG_BASE - i];
+
+          // E.g. 56700 becomes 56000 if 7 is the rounding digit.
+          // j > 0 means i > number of leading zeros of n.
+          xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;
+        }
+
+        // Round up?
+        if (r) {
+
+          for (; ;) {
+
+            // If the digit to be rounded up is in the first element of xc...
+            if (ni == 0) {
+
+              // i will be the length of xc[0] before k is added.
+              for (i = 1, j = xc[0]; j >= 10; j /= 10, i++);
+              j = xc[0] += k;
+              for (k = 1; j >= 10; j /= 10, k++);
+
+              // if i != k the length has increased.
+              if (i != k) {
+                x.e++;
+                if (xc[0] == BASE) xc[0] = 1;
+              }
+
+              break;
+            } else {
+              xc[ni] += k;
+              if (xc[ni] != BASE) break;
+              xc[ni--] = 0;
+              k = 1;
+            }
+          }
+        }
+
+        // Remove trailing zeros.
+        for (i = xc.length; xc[--i] === 0; xc.pop());
+      }
+
+      // Overflow? Infinity.
+      if (x.e > MAX_EXP) {
+        x.c = x.e = null;
+
+      // Underflow? Zero.
+      } else if (x.e < MIN_EXP) {
+        x.c = [x.e = 0];
+      }
+    }
+
+    return x;
+  }
+
+
+  // PROTOTYPE/INSTANCE METHODS
+
+
+  /*
+   * Return a new BigNumber whose value is the absolute value of this BigNumber.
+   */
+  P.absoluteValue = P.abs = function () {
+    var x = new BigNumber(this);
+    if (x.s < 0) x.s = 1;
+    return x;
+  };
+
+
+  /*
+   * Return
+   *   1 if the value of this BigNumber is greater than the value of BigNumber(y, b),
+   *   -1 if the value of this BigNumber is less than the value of BigNumber(y, b),
+   *   0 if they have the same value,
+   *   or null if the value of either is NaN.
+   */
+  P.comparedTo = function (y, b) {
+    return compare(this, new BigNumber(y, b));
+  };
+
+
+  /*
+   * If dp is undefined or null or true or false, return the number of decimal places of the
+   * value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.
+   *
+   * Otherwise, if dp is a number, return a new BigNumber whose value is the value of this
+   * BigNumber rounded to a maximum of dp decimal places using rounding mode rm, or
+   * ROUNDING_MODE if rm is omitted.
+   *
+   * [dp] {number} Decimal places: integer, 0 to MAX inclusive.
+   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+   *
+   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'
+   */
+  P.decimalPlaces = P.dp = function (dp, rm) {
+    var c, n, v,
+      x = this;
+
+    if (dp != null) {
+      intCheck(dp, 0, MAX);
+      if (rm == null) rm = ROUNDING_MODE;
+      else intCheck(rm, 0, 8);
+
+      return round(new BigNumber(x), dp + x.e + 1, rm);
+    }
+
+    if (!(c = x.c)) return null;
+    n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;
+
+    // Subtract the number of trailing zeros of the last number.
+    if (v = c[v]) for (; v % 10 == 0; v /= 10, n--);
+    if (n < 0) n = 0;
+
+    return n;
+  };
+
+
+  /*
+   *  n / 0 = I
+   *  n / N = N
+   *  n / I = 0
+   *  0 / n = 0
+   *  0 / 0 = N
+   *  0 / N = N
+   *  0 / I = 0
+   *  N / n = N
+   *  N / 0 = N
+   *  N / N = N
+   *  N / I = N
+   *  I / n = I
+   *  I / 0 = I
+   *  I / N = N
+   *  I / I = N
+   *
+   * Return a new BigNumber whose value is the value of this BigNumber divided by the value of
+   * BigNumber(y, b), rounded according to DECIMAL_PLACES and ROUNDING_MODE.
+   */
+  P.dividedBy = P.div = function (y, b) {
+    return div(this, new BigNumber(y, b), DECIMAL_PLACES, ROUNDING_MODE);
+  };
+
+
+  /*
+   * Return a new BigNumber whose value is the integer part of dividing the value of this
+   * BigNumber by the value of BigNumber(y, b).
+   */
+  P.dividedToIntegerBy = P.idiv = function (y, b) {
+    return div(this, new BigNumber(y, b), 0, 1);
+  };
+
+
+  /*
+   * Return a BigNumber whose value is the value of this BigNumber exponentiated by n.
+   *
+   * If m is present, return the result modulo m.
+   * If n is negative round according to DECIMAL_PLACES and ROUNDING_MODE.
+   * If POW_PRECISION is non-zero and m is not present, round to POW_PRECISION using ROUNDING_MODE.
+   *
+   * The modular power operation works efficiently when x, n, and m are integers, otherwise it
+   * is equivalent to calculating x.exponentiatedBy(n).modulo(m) with a POW_PRECISION of 0.
+   *
+   * n {number|string|BigNumber} The exponent. An integer.
+   * [m] {number|string|BigNumber} The modulus.
+   *
+   * '[BigNumber Error] Exponent not an integer: {n}'
+   */
+  P.exponentiatedBy = P.pow = function (n, m) {
+    var half, isModExp, k, more, nIsBig, nIsNeg, nIsOdd, y,
+      x = this;
+
+    n = new BigNumber(n);
+
+    // Allow NaN and ±Infinity, but not other non-integers.
+    if (n.c && !n.isInteger()) {
+      throw Error
+        (bignumberError + 'Exponent not an integer: ' + n);
+    }
+
+    if (m != null) m = new BigNumber(m);
+
+    // Exponent of MAX_SAFE_INTEGER is 15.
+    nIsBig = n.e > 14;
+
+    // If x is NaN, ±Infinity, ±0 or ±1, or n is ±Infinity, NaN or ±0.
+    if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {
+
+      // The sign of the result of pow when x is negative depends on the evenness of n.
+      // If +n overflows to ±Infinity, the evenness of n would be not be known.
+      y = new BigNumber(Math.pow(+x.valueOf(), nIsBig ? 2 - isOdd(n) : +n));
+      return m ? y.mod(m) : y;
+    }
+
+    nIsNeg = n.s < 0;
+
+    if (m) {
+
+      // x % m returns NaN if abs(m) is zero, or m is NaN.
+      if (m.c ? !m.c[0] : !m.s) return new BigNumber(NaN);
+
+      isModExp = !nIsNeg && x.isInteger() && m.isInteger();
+
+      if (isModExp) x = x.mod(m);
+
+    // Overflow to ±Infinity: >=2**1e10 or >=1.0000024**1e15.
+    // Underflow to ±0: <=0.79**1e10 or <=0.9999975**1e15.
+    } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0
+      // [1, 240000000]
+      ? x.c[0] > 1 || nIsBig && x.c[1] >= 24e7
+      // [80000000000000]  [99999750000000]
+      : x.c[0] < 8e13 || nIsBig && x.c[0] <= 9999975e7))) {
+
+      // If x is negative and n is odd, k = -0, else k = 0.
+      k = x.s < 0 && isOdd(n) ? -0 : 0;
+
+      // If x >= 1, k = ±Infinity.
+      if (x.e > -1) k = 1 / k;
+
+      // If n is negative return ±0, else return ±Infinity.
+      return new BigNumber(nIsNeg ? 1 / k : k);
+
+    } else if (POW_PRECISION) {
+
+      // Truncating each coefficient array to a length of k after each multiplication
+      // equates to truncating significant digits to POW_PRECISION + [28, 41],
+      // i.e. there will be a minimum of 28 guard digits retained.
+      k = mathceil(POW_PRECISION / LOG_BASE + 2);
+    }
+
+    if (nIsBig) {
+      half = new BigNumber(0.5);
+      nIsOdd = isOdd(n);
+    } else {
+      nIsOdd = n % 2;
+    }
+
+    if (nIsNeg) n.s = 1;
+
+    y = new BigNumber(ONE);
+
+    // Performs 54 loop iterations for n of 9007199254740991.
+    for (; ;) {
+
+      if (nIsOdd) {
+        y = y.times(x);
+        if (!y.c) break;
+
+        if (k) {
+          if (y.c.length > k) y.c.length = k;
+        } else if (isModExp) {
+          y = y.mod(m);    //y = y.minus(div(y, m, 0, MODULO_MODE).times(m));
+        }
+      }
+
+      if (nIsBig) {
+        n = n.times(half);
+        round(n, n.e + 1, 1);
+        if (!n.c[0]) break;
+        nIsBig = n.e > 14;
+        nIsOdd = isOdd(n);
+      } else {
+        n = mathfloor(n / 2);
+        if (!n) break;
+        nIsOdd = n % 2;
+      }
+
+      x = x.times(x);
+
+      if (k) {
+        if (x.c && x.c.length > k) x.c.length = k;
+      } else if (isModExp) {
+        x = x.mod(m);    //x = x.minus(div(x, m, 0, MODULO_MODE).times(m));
+      }
+    }
+
+    if (isModExp) return y;
+    if (nIsNeg) y = ONE.div(y);
+
+    return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;
+  };
+
+
+  /*
+   * Return a new BigNumber whose value is the value of this BigNumber rounded to an integer
+   * using rounding mode rm, or ROUNDING_MODE if rm is omitted.
+   *
+   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+   *
+   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {rm}'
+   */
+  P.integerValue = function (rm) {
+    var n = new BigNumber(this);
+    if (rm == null) rm = ROUNDING_MODE;
+    else intCheck(rm, 0, 8);
+    return round(n, n.e + 1, rm);
+  };
+
+
+  /*
+   * Return true if the value of this BigNumber is equal to the value of BigNumber(y, b),
+   * otherwise return false.
+   */
+  P.isEqualTo = P.eq = function (y, b) {
+    return compare(this, new BigNumber(y, b)) === 0;
+  };
+
+
+  /*
+   * Return true if the value of this BigNumber is a finite number, otherwise return false.
+   */
+  P.isFinite = function () {
+    return !!this.c;
+  };
+
+
+  /*
+   * Return true if the value of this BigNumber is greater than the value of BigNumber(y, b),
+   * otherwise return false.
+   */
+  P.isGreaterThan = P.gt = function (y, b) {
+    return compare(this, new BigNumber(y, b)) > 0;
+  };
+
+
+  /*
+   * Return true if the value of this BigNumber is greater than or equal to the value of
+   * BigNumber(y, b), otherwise return false.
+   */
+  P.isGreaterThanOrEqualTo = P.gte = function (y, b) {
+    return (b = compare(this, new BigNumber(y, b))) === 1 || b === 0;
+
+  };
+
+
+  /*
+   * Return true if the value of this BigNumber is an integer, otherwise return false.
+   */
+  P.isInteger = function () {
+    return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;
+  };
+
+
+  /*
+   * Return true if the value of this BigNumber is less than the value of BigNumber(y, b),
+   * otherwise return false.
+   */
+  P.isLessThan = P.lt = function (y, b) {
+    return compare(this, new BigNumber(y, b)) < 0;
+  };
+
+
+  /*
+   * Return true if the value of this BigNumber is less than or equal to the value of
+   * BigNumber(y, b), otherwise return false.
+   */
+  P.isLessThanOrEqualTo = P.lte = function (y, b) {
+    return (b = compare(this, new BigNumber(y, b))) === -1 || b === 0;
+  };
+
+
+  /*
+   * Return true if the value of this BigNumber is NaN, otherwise return false.
+   */
+  P.isNaN = function () {
+    return !this.s;
+  };
+
+
+  /*
+   * Return true if the value of this BigNumber is negative, otherwise return false.
+   */
+  P.isNegative = function () {
+    return this.s < 0;
+  };
+
+
+  /*
+   * Return true if the value of this BigNumber is positive, otherwise return false.
+   */
+  P.isPositive = function () {
+    return this.s > 0;
+  };
+
+
+  /*
+   * Return true if the value of this BigNumber is 0 or -0, otherwise return false.
+   */
+  P.isZero = function () {
+    return !!this.c && this.c[0] == 0;
+  };
+
+
+  /*
+   *  n - 0 = n
+   *  n - N = N
+   *  n - I = -I
+   *  0 - n = -n
+   *  0 - 0 = 0
+   *  0 - N = N
+   *  0 - I = -I
+   *  N - n = N
+   *  N - 0 = N
+   *  N - N = N
+   *  N - I = N
+   *  I - n = I
+   *  I - 0 = I
+   *  I - N = N
+   *  I - I = N
+   *
+   * Return a new BigNumber whose value is the value of this BigNumber minus the value of
+   * BigNumber(y, b).
+   */
+  P.minus = function (y, b) {
+    var i, j, t, xLTy,
+      x = this,
+      a = x.s;
+
+    y = new BigNumber(y, b);
+    b = y.s;
+
+    // Either NaN?
+    if (!a || !b) return new BigNumber(NaN);
+
+    // Signs differ?
+    if (a != b) {
+      y.s = -b;
+      return x.plus(y);
+    }
+
+    var xe = x.e / LOG_BASE,
+      ye = y.e / LOG_BASE,
+      xc = x.c,
+      yc = y.c;
+
+    if (!xe || !ye) {
+
+      // Either Infinity?
+      if (!xc || !yc) return xc ? (y.s = -b, y) : new BigNumber(yc ? x : NaN);
+
+      // Either zero?
+      if (!xc[0] || !yc[0]) {
+
+        // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.
+        return yc[0] ? (y.s = -b, y) : new BigNumber(xc[0] ? x :
+
+         // IEEE 754 (2008) 6.3: n - n = -0 when rounding to -Infinity
+         ROUNDING_MODE == 3 ? -0 : 0);
+      }
+    }
+
+    xe = bitFloor(xe);
+    ye = bitFloor(ye);
+    xc = xc.slice();
+
+    // Determine which is the bigger number.
+    if (a = xe - ye) {
+
+      if (xLTy = a < 0) {
+        a = -a;
+        t = xc;
+      } else {
+        ye = xe;
+        t = yc;
+      }
+
+      t.reverse();
+
+      // Prepend zeros to equalise exponents.
+      for (b = a; b--; t.push(0));
+      t.reverse();
+    } else {
+
+      // Exponents equal. Check digit by digit.
+      j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;
+
+      for (a = b = 0; b < j; b++) {
+
+        if (xc[b] != yc[b]) {
+          xLTy = xc[b] < yc[b];
+          break;
+        }
+      }
+    }
+
+    // x < y? Point xc to the array of the bigger number.
+    if (xLTy) t = xc, xc = yc, yc = t, y.s = -y.s;
+
+    b = (j = yc.length) - (i = xc.length);
+
+    // Append zeros to xc if shorter.
+    // No need to add zeros to yc if shorter as subtract only needs to start at yc.length.
+    if (b > 0) for (; b--; xc[i++] = 0);
+    b = BASE - 1;
+
+    // Subtract yc from xc.
+    for (; j > a;) {
+
+      if (xc[--j] < yc[j]) {
+        for (i = j; i && !xc[--i]; xc[i] = b);
+        --xc[i];
+        xc[j] += BASE;
+      }
+
+      xc[j] -= yc[j];
+    }
+
+    // Remove leading zeros and adjust exponent accordingly.
+    for (; xc[0] == 0; xc.splice(0, 1), --ye);
+
+    // Zero?
+    if (!xc[0]) {
+
+      // Following IEEE 754 (2008) 6.3,
+      // n - n = +0  but  n - n = -0  when rounding towards -Infinity.
+      y.s = ROUNDING_MODE == 3 ? -1 : 1;
+      y.c = [y.e = 0];
+      return y;
+    }
+
+    // No need to check for Infinity as +x - +y != Infinity && -x - -y != Infinity
+    // for finite x and y.
+    return normalise(y, xc, ye);
+  };
+
+
+  /*
+   *   n % 0 =  N
+   *   n % N =  N
+   *   n % I =  n
+   *   0 % n =  0
+   *  -0 % n = -0
+   *   0 % 0 =  N
+   *   0 % N =  N
+   *   0 % I =  0
+   *   N % n =  N
+   *   N % 0 =  N
+   *   N % N =  N
+   *   N % I =  N
+   *   I % n =  N
+   *   I % 0 =  N
+   *   I % N =  N
+   *   I % I =  N
+   *
+   * Return a new BigNumber whose value is the value of this BigNumber modulo the value of
+   * BigNumber(y, b). The result depends on the value of MODULO_MODE.
+   */
+  P.modulo = P.mod = function (y, b) {
+    var q, s,
+      x = this;
+
+    y = new BigNumber(y, b);
+
+    // Return NaN if x is Infinity or NaN, or y is NaN or zero.
+    if (!x.c || !y.s || y.c && !y.c[0]) {
+      return new BigNumber(NaN);
+
+    // Return x if y is Infinity or x is zero.
+    } else if (!y.c || x.c && !x.c[0]) {
+      return new BigNumber(x);
+    }
+
+    if (MODULO_MODE == 9) {
+
+      // Euclidian division: q = sign(y) * floor(x / abs(y))
+      // r = x - qy    where  0 <= r < abs(y)
+      s = y.s;
+      y.s = 1;
+      q = div(x, y, 0, 3);
+      y.s = s;
+      q.s *= s;
+    } else {
+      q = div(x, y, 0, MODULO_MODE);
+    }
+
+    y = x.minus(q.times(y));
+
+    // To match JavaScript %, ensure sign of zero is sign of dividend.
+    if (!y.c[0] && MODULO_MODE == 1) y.s = x.s;
+
+    return y;
+  };
+
+
+  /*
+   *  n * 0 = 0
+   *  n * N = N
+   *  n * I = I
+   *  0 * n = 0
+   *  0 * 0 = 0
+   *  0 * N = N
+   *  0 * I = N
+   *  N * n = N
+   *  N * 0 = N
+   *  N * N = N
+   *  N * I = N
+   *  I * n = I
+   *  I * 0 = N
+   *  I * N = N
+   *  I * I = I
+   *
+   * Return a new BigNumber whose value is the value of this BigNumber multiplied by the value
+   * of BigNumber(y, b).
+   */
+  P.multipliedBy = P.times = function (y, b) {
+    var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc,
+      base, sqrtBase,
+      x = this,
+      xc = x.c,
+      yc = (y = new BigNumber(y, b)).c;
+
+    // Either NaN, ±Infinity or ±0?
+    if (!xc || !yc || !xc[0] || !yc[0]) {
+
+      // Return NaN if either is NaN, or one is 0 and the other is Infinity.
+      if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {
+        y.c = y.e = y.s = null;
+      } else {
+        y.s *= x.s;
+
+        // Return ±Infinity if either is ±Infinity.
+        if (!xc || !yc) {
+          y.c = y.e = null;
+
+        // Return ±0 if either is ±0.
+        } else {
+          y.c = [0];
+          y.e = 0;
+        }
+      }
+
+      return y;
+    }
+
+    e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);
+    y.s *= x.s;
+    xcL = xc.length;
+    ycL = yc.length;
+
+    // Ensure xc points to longer array and xcL to its length.
+    if (xcL < ycL) zc = xc, xc = yc, yc = zc, i = xcL, xcL = ycL, ycL = i;
+
+    // Initialise the result array with zeros.
+    for (i = xcL + ycL, zc = []; i--; zc.push(0));
+
+    base = BASE;
+    sqrtBase = SQRT_BASE;
+
+    for (i = ycL; --i >= 0;) {
+      c = 0;
+      ylo = yc[i] % sqrtBase;
+      yhi = yc[i] / sqrtBase | 0;
+
+      for (k = xcL, j = i + k; j > i;) {
+        xlo = xc[--k] % sqrtBase;
+        xhi = xc[k] / sqrtBase | 0;
+        m = yhi * xlo + xhi * ylo;
+        xlo = ylo * xlo + ((m % sqrtBase) * sqrtBase) + zc[j] + c;
+        c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;
+        zc[j--] = xlo % base;
+      }
+
+      zc[j] = c;
+    }
+
+    if (c) {
+      ++e;
+    } else {
+      zc.splice(0, 1);
+    }
+
+    return normalise(y, zc, e);
+  };
+
+
+  /*
+   * Return a new BigNumber whose value is the value of this BigNumber negated,
+   * i.e. multiplied by -1.
+   */
+  P.negated = function () {
+    var x = new BigNumber(this);
+    x.s = -x.s || null;
+    return x;
+  };
+
+
+  /*
+   *  n + 0 = n
+   *  n + N = N
+   *  n + I = I
+   *  0 + n = n
+   *  0 + 0 = 0
+   *  0 + N = N
+   *  0 + I = I
+   *  N + n = N
+   *  N + 0 = N
+   *  N + N = N
+   *  N + I = N
+   *  I + n = I
+   *  I + 0 = I
+   *  I + N = N
+   *  I + I = I
+   *
+   * Return a new BigNumber whose value is the value of this BigNumber plus the value of
+   * BigNumber(y, b).
+   */
+  P.plus = function (y, b) {
+    var t,
+      x = this,
+      a = x.s;
+
+    y = new BigNumber(y, b);
+    b = y.s;
+
+    // Either NaN?
+    if (!a || !b) return new BigNumber(NaN);
+
+    // Signs differ?
+     if (a != b) {
+      y.s = -b;
+      return x.minus(y);
+    }
+
+    var xe = x.e / LOG_BASE,
+      ye = y.e / LOG_BASE,
+      xc = x.c,
+      yc = y.c;
+
+    if (!xe || !ye) {
+
+      // Return ±Infinity if either ±Infinity.
+      if (!xc || !yc) return new BigNumber(a / 0);
+
+      // Either zero?
+      // Return y if y is non-zero, x if x is non-zero, or zero if both are zero.
+      if (!xc[0] || !yc[0]) return yc[0] ? y : new BigNumber(xc[0] ? x : a * 0);
+    }
+
+    xe = bitFloor(xe);
+    ye = bitFloor(ye);
+    xc = xc.slice();
+
+    // Prepend zeros to equalise exponents. Faster to use reverse then do unshifts.
+    if (a = xe - ye) {
+      if (a > 0) {
+        ye = xe;
+        t = yc;
+      } else {
+        a = -a;
+        t = xc;
+      }
+
+      t.reverse();
+      for (; a--; t.push(0));
+      t.reverse();
+    }
+
+    a = xc.length;
+    b = yc.length;
+
+    // Point xc to the longer array, and b to the shorter length.
+    if (a - b < 0) t = yc, yc = xc, xc = t, b = a;
+
+    // Only start adding at yc.length - 1 as the further digits of xc can be ignored.
+    for (a = 0; b;) {
+      a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;
+      xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;
+    }
+
+    if (a) {
+      xc = [a].concat(xc);
+      ++ye;
+    }
+
+    // No need to check for zero, as +x + +y != 0 && -x + -y != 0
+    // ye = MAX_EXP + 1 possible
+    return normalise(y, xc, ye);
+  };
+
+
+  /*
+   * If sd is undefined or null or true or false, return the number of significant digits of
+   * the value of this BigNumber, or null if the value of this BigNumber is ±Infinity or NaN.
+   * If sd is true include integer-part trailing zeros in the count.
+   *
+   * Otherwise, if sd is a number, return a new BigNumber whose value is the value of this
+   * BigNumber rounded to a maximum of sd significant digits using rounding mode rm, or
+   * ROUNDING_MODE if rm is omitted.
+   *
+   * sd {number|boolean} number: significant digits: integer, 1 to MAX inclusive.
+   *                     boolean: whether to count integer-part trailing zeros: true or false.
+   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+   *
+   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'
+   */
+  P.precision = P.sd = function (sd, rm) {
+    var c, n, v,
+      x = this;
+
+    if (sd != null && sd !== !!sd) {
+      intCheck(sd, 1, MAX);
+      if (rm == null) rm = ROUNDING_MODE;
+      else intCheck(rm, 0, 8);
+
+      return round(new BigNumber(x), sd, rm);
+    }
+
+    if (!(c = x.c)) return null;
+    v = c.length - 1;
+    n = v * LOG_BASE + 1;
+
+    if (v = c[v]) {
+
+      // Subtract the number of trailing zeros of the last element.
+      for (; v % 10 == 0; v /= 10, n--);
+
+      // Add the number of digits of the first element.
+      for (v = c[0]; v >= 10; v /= 10, n++);
+    }
+
+    if (sd && x.e + 1 > n) n = x.e + 1;
+
+    return n;
+  };
+
+
+  /*
+   * Return a new BigNumber whose value is the value of this BigNumber shifted by k places
+   * (powers of 10). Shift to the right if n > 0, and to the left if n < 0.
+   *
+   * k {number} Integer, -MAX_SAFE_INTEGER to MAX_SAFE_INTEGER inclusive.
+   *
+   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {k}'
+   */
+  P.shiftedBy = function (k) {
+    intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
+    return this.times('1e' + k);
+  };
+
+
+  /*
+   *  sqrt(-n) =  N
+   *  sqrt(N) =  N
+   *  sqrt(-I) =  N
+   *  sqrt(I) =  I
+   *  sqrt(0) =  0
+   *  sqrt(-0) = -0
+   *
+   * Return a new BigNumber whose value is the square root of the value of this BigNumber,
+   * rounded according to DECIMAL_PLACES and ROUNDING_MODE.
+   */
+  P.squareRoot = P.sqrt = function () {
+    var m, n, r, rep, t,
+      x = this,
+      c = x.c,
+      s = x.s,
+      e = x.e,
+      dp = DECIMAL_PLACES + 4,
+      half = new BigNumber('0.5');
+
+    // Negative/NaN/Infinity/zero?
+    if (s !== 1 || !c || !c[0]) {
+      return new BigNumber(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);
+    }
+
+    // Initial estimate.
+    s = Math.sqrt(+x);
+
+    // Math.sqrt underflow/overflow?
+    // Pass x to Math.sqrt as integer, then adjust the exponent of the result.
+    if (s == 0 || s == 1 / 0) {
+      n = coeffToString(c);
+      if ((n.length + e) % 2 == 0) n += '0';
+      s = Math.sqrt(n);
+      e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);
+
+      if (s == 1 / 0) {
+        n = '1e' + e;
+      } else {
+        n = s.toExponential();
+        n = n.slice(0, n.indexOf('e') + 1) + e;
+      }
+
+      r = new BigNumber(n);
+    } else {
+      r = new BigNumber(s + '');
+    }
+
+    // Check for zero.
+    // r could be zero if MIN_EXP is changed after the this value was created.
+    // This would cause a division by zero (x/t) and hence Infinity below, which would cause
+    // coeffToString to throw.
+    if (r.c[0]) {
+      e = r.e;
+      s = e + dp;
+      if (s < 3) s = 0;
+
+      // Newton-Raphson iteration.
+      for (; ;) {
+        t = r;
+        r = half.times(t.plus(div(x, t, dp, 1)));
+
+        if (coeffToString(t.c  ).slice(0, s) === (n =
+           coeffToString(r.c)).slice(0, s)) {
+
+          // The exponent of r may here be one less than the final result exponent,
+          // e.g 0.0009999 (e-4) --> 0.001 (e-3), so adjust s so the rounding digits
+          // are indexed correctly.
+          if (r.e < e) --s;
+          n = n.slice(s - 3, s + 1);
+
+          // The 4th rounding digit may be in error by -1 so if the 4 rounding digits
+          // are 9999 or 4999 (i.e. approaching a rounding boundary) continue the
+          // iteration.
+          if (n == '9999' || !rep && n == '4999') {
+
+            // On the first iteration only, check to see if rounding up gives the
+            // exact result as the nines may infinitely repeat.
+            if (!rep) {
+              round(t, t.e + DECIMAL_PLACES + 2, 0);
+
+              if (t.times(t).eq(x)) {
+                r = t;
+                break;
+              }
+            }
+
+            dp += 4;
+            s += 4;
+            rep = 1;
+          } else {
+
+            // If rounding digits are null, 0{0,4} or 50{0,3}, check for exact
+            // result. If not, then there are further digits and m will be truthy.
+            if (!+n || !+n.slice(1) && n.charAt(0) == '5') {
+
+              // Truncate to the first rounding digit.
+              round(r, r.e + DECIMAL_PLACES + 2, 1);
+              m = !r.times(r).eq(x);
+            }
+
+            break;
+          }
+        }
+      }
+    }
+
+    return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);
+  };
+
+
+  /*
+   * Return a string representing the value of this BigNumber in exponential notation and
+   * rounded using ROUNDING_MODE to dp fixed decimal places.
+   *
+   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.
+   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+   *
+   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'
+   */
+  P.toExponential = function (dp, rm) {
+    if (dp != null) {
+      intCheck(dp, 0, MAX);
+      dp++;
+    }
+    return format(this, dp, rm, 1);
+  };
+
+
+  /*
+   * Return a string representing the value of this BigNumber in fixed-point notation rounding
+   * to dp fixed decimal places using rounding mode rm, or ROUNDING_MODE if rm is omitted.
+   *
+   * Note: as with JavaScript's number type, (-0).toFixed(0) is '0',
+   * but e.g. (-0.00001).toFixed(0) is '-0'.
+   *
+   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.
+   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+   *
+   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'
+   */
+  P.toFixed = function (dp, rm) {
+    if (dp != null) {
+      intCheck(dp, 0, MAX);
+      dp = dp + this.e + 1;
+    }
+    return format(this, dp, rm);
+  };
+
+
+  /*
+   * Return a string representing the value of this BigNumber in fixed-point notation rounded
+   * using rm or ROUNDING_MODE to dp decimal places, and formatted according to the properties
+   * of the FORMAT object (see BigNumber.set).
+   *
+   * FORMAT = {
+   *      decimalSeparator : '.',
+   *      groupSeparator : ',',
+   *      groupSize : 3,
+   *      secondaryGroupSize : 0,
+   *      fractionGroupSeparator : '\xA0',    // non-breaking space
+   *      fractionGroupSize : 0
+   * };
+   *
+   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.
+   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+   *
+   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'
+   */
+  P.toFormat = function (dp, rm) {
+    var str = this.toFixed(dp, rm);
+
+    if (this.c) {
+      var i,
+        arr = str.split('.'),
+        g1 = +FORMAT.groupSize,
+        g2 = +FORMAT.secondaryGroupSize,
+        groupSeparator = FORMAT.groupSeparator,
+        intPart = arr[0],
+        fractionPart = arr[1],
+        isNeg = this.s < 0,
+        intDigits = isNeg ? intPart.slice(1) : intPart,
+        len = intDigits.length;
+
+      if (g2) i = g1, g1 = g2, g2 = i, len -= i;
+
+      if (g1 > 0 && len > 0) {
+        i = len % g1 || g1;
+        intPart = intDigits.substr(0, i);
+
+        for (; i < len; i += g1) {
+          intPart += groupSeparator + intDigits.substr(i, g1);
+        }
+
+        if (g2 > 0) intPart += groupSeparator + intDigits.slice(i);
+        if (isNeg) intPart = '-' + intPart;
+      }
+
+      str = fractionPart
+       ? intPart + FORMAT.decimalSeparator + ((g2 = +FORMAT.fractionGroupSize)
+        ? fractionPart.replace(new RegExp('\\d{' + g2 + '}\\B', 'g'),
+         '$&' + FORMAT.fractionGroupSeparator)
+        : fractionPart)
+       : intPart;
+    }
+
+    return str;
+  };
+
+
+  /*
+   * Return a string array representing the value of this BigNumber as a simple fraction with
+   * an integer numerator and an integer denominator. The denominator will be a positive
+   * non-zero value less than or equal to the specified maximum denominator. If a maximum
+   * denominator is not specified, the denominator will be the lowest value necessary to
+   * represent the number exactly.
+   *
+   * [md] {number|string|BigNumber} Integer >= 1, or Infinity. The maximum denominator.
+   *
+   * '[BigNumber Error] Argument {not an integer|out of range} : {md}'
+   */
+  P.toFraction = function (md) {
+    var arr, d, d0, d1, d2, e, exp, n, n0, n1, q, s,
+      x = this,
+      xc = x.c;
+
+    if (md != null) {
+      n = new BigNumber(md);
+
+      // Throw if md is less than one or is not an integer, unless it is Infinity.
+      if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {
+        throw Error
+          (bignumberError + 'Argument ' +
+            (n.isInteger() ? 'out of range: ' : 'not an integer: ') + md);
+      }
+    }
+
+    if (!xc) return x.toString();
+
+    d = new BigNumber(ONE);
+    n1 = d0 = new BigNumber(ONE);
+    d1 = n0 = new BigNumber(ONE);
+    s = coeffToString(xc);
+
+    // Determine initial denominator.
+    // d is a power of 10 and the minimum max denominator that specifies the value exactly.
+    e = d.e = s.length - x.e - 1;
+    d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];
+    md = !md || n.comparedTo(d) > 0 ? (e > 0 ? d : n1) : n;
+
+    exp = MAX_EXP;
+    MAX_EXP = 1 / 0;
+    n = new BigNumber(s);
+
+    // n0 = d1 = 0
+    n0.c[0] = 0;
+
+    for (; ;)  {
+      q = div(n, d, 0, 1);
+      d2 = d0.plus(q.times(d1));
+      if (d2.comparedTo(md) == 1) break;
+      d0 = d1;
+      d1 = d2;
+      n1 = n0.plus(q.times(d2 = n1));
+      n0 = d2;
+      d = n.minus(q.times(d2 = d));
+      n = d2;
+    }
+
+    d2 = div(md.minus(d0), d1, 0, 1);
+    n0 = n0.plus(d2.times(n1));
+    d0 = d0.plus(d2.times(d1));
+    n0.s = n1.s = x.s;
+    e *= 2;
+
+    // Determine which fraction is closer to x, n0/d0 or n1/d1
+    arr = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(
+       div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1
+        ? [n1.toString(), d1.toString()]
+        : [n0.toString(), d0.toString()];
+
+    MAX_EXP = exp;
+    return arr;
+  };
+
+
+  /*
+   * Return the value of this BigNumber converted to a number primitive.
+   */
+  P.toNumber = function () {
+    return +this;
+  };
+
+
+  /*
+   * Return a string representing the value of this BigNumber rounded to sd significant digits
+   * using rounding mode rm or ROUNDING_MODE. If sd is less than the number of digits
+   * necessary to represent the integer part of the value in fixed-point notation, then use
+   * exponential notation.
+   *
+   * [sd] {number} Significant digits. Integer, 1 to MAX inclusive.
+   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+   *
+   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {sd|rm}'
+   */
+  P.toPrecision = function (sd, rm) {
+    if (sd != null) intCheck(sd, 1, MAX);
+    return format(this, sd, rm, 2);
+  };
+
+
+  /*
+   * Return a string representing the value of this BigNumber in base b, or base 10 if b is
+   * omitted. If a base is specified, including base 10, round according to DECIMAL_PLACES and
+   * ROUNDING_MODE. If a base is not specified, and this BigNumber has a positive exponent
+   * that is equal to or greater than TO_EXP_POS, or a negative exponent equal to or less than
+   * TO_EXP_NEG, return exponential notation.
+   *
+   * [b] {number} Integer, 2 to ALPHABET.length inclusive.
+   *
+   * '[BigNumber Error] Base {not a primitive number|not an integer|out of range}: {b}'
+   */
+  P.toString = function (b) {
+    var str,
+      n = this,
+      s = n.s,
+      e = n.e;
+
+    // Infinity or NaN?
+    if (e === null) {
+
+      if (s) {
+        str = 'Infinity';
+        if (s < 0) str = '-' + str;
+      } else {
+        str = 'NaN';
+      }
+    } else {
+      str = coeffToString(n.c);
+
+      if (b == null) {
+        str = e <= TO_EXP_NEG || e >= TO_EXP_POS
+         ? toExponential(str, e)
+         : toFixedPoint(str, e, '0');
+      } else {
+        intCheck(b, 2, ALPHABET.length, 'Base');
+        str = convertBase(toFixedPoint(str, e, '0'), 10, b, s, true);
+      }
+
+      if (s < 0 && n.c[0]) str = '-' + str;
+    }
+
+    return str;
+  };
+
+
+  /*
+   * Return as toString, but do not accept a base argument, and include the minus sign for
+   * negative zero.
+   */
+  P.valueOf = P.toJSON = function () {
+    var str,
+      n = this,
+      e = n.e;
+
+    if (e === null) return n.toString();
+
+    str = coeffToString(n.c);
+
+    str = e <= TO_EXP_NEG || e >= TO_EXP_POS
+      ? toExponential(str, e)
+      : toFixedPoint(str, e, '0');
+
+    return n.s < 0 ? '-' + str : str;
+  };
+
+
+  P._isBigNumber = true;
+
+  if (configObject != null) BigNumber.set(configObject);
+
+  return BigNumber;
+}
+
+
+// PRIVATE HELPER FUNCTIONS
+
+
+function bitFloor(n) {
+  var i = n | 0;
+  return n > 0 || n === i ? i : i - 1;
+}
+
+
+// Return a coefficient array as a string of base 10 digits.
+function coeffToString(a) {
+  var s, z,
+    i = 1,
+    j = a.length,
+    r = a[0] + '';
+
+  for (; i < j;) {
+    s = a[i++] + '';
+    z = LOG_BASE - s.length;
+    for (; z--; s = '0' + s);
+    r += s;
+  }
+
+  // Determine trailing zeros.
+  for (j = r.length; r.charCodeAt(--j) === 48;);
+  return r.slice(0, j + 1 || 1);
+}
+
+
+// Compare the value of BigNumbers x and y.
+function compare(x, y) {
+  var a, b,
+    xc = x.c,
+    yc = y.c,
+    i = x.s,
+    j = y.s,
+    k = x.e,
+    l = y.e;
+
+  // Either NaN?
+  if (!i || !j) return null;
+
+  a = xc && !xc[0];
+  b = yc && !yc[0];
+
+  // Either zero?
+  if (a || b) return a ? b ? 0 : -j : i;
+
+  // Signs differ?
+  if (i != j) return i;
+
+  a = i < 0;
+  b = k == l;
+
+  // Either Infinity?
+  if (!xc || !yc) return b ? 0 : !xc ^ a ? 1 : -1;
+
+  // Compare exponents.
+  if (!b) return k > l ^ a ? 1 : -1;
+
+  j = (k = xc.length) < (l = yc.length) ? k : l;
+
+  // Compare digit by digit.
+  for (i = 0; i < j; i++) if (xc[i] != yc[i]) return xc[i] > yc[i] ^ a ? 1 : -1;
+
+  // Compare lengths.
+  return k == l ? 0 : k > l ^ a ? 1 : -1;
+}
+
+
+/*
+ * Check that n is a primitive number, an integer, and in range, otherwise throw.
+ */
+function intCheck(n, min, max, name) {
+  if (n < min || n > max || n !== (n < 0 ? mathceil(n) : mathfloor(n))) {
+    throw Error
+     (bignumberError + (name || 'Argument') + (typeof n == 'number'
+       ? n < min || n > max ? ' out of range: ' : ' not an integer: '
+       : ' not a primitive number: ') + n);
+  }
+}
+
+
+function isArray(obj) {
+  return Object.prototype.toString.call(obj) == '[object Array]';
+}
+
+
+// Assumes finite n.
+function isOdd(n) {
+  var k = n.c.length - 1;
+  return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;
+}
+
+
+function toExponential(str, e) {
+  return (str.length > 1 ? str.charAt(0) + '.' + str.slice(1) : str) +
+   (e < 0 ? 'e' : 'e+') + e;
+}
+
+
+function toFixedPoint(str, e, z) {
+  var len, zs;
+
+  // Negative exponent?
+  if (e < 0) {
+
+    // Prepend zeros.
+    for (zs = z + '.'; ++e; zs += z);
+    str = zs + str;
+
+  // Positive exponent
+  } else {
+    len = str.length;
+
+    // Append zeros.
+    if (++e > len) {
+      for (zs = z, e -= len; --e; zs += z);
+      str += zs;
+    } else if (e < len) {
+      str = str.slice(0, e) + '.' + str.slice(e);
+    }
+  }
+
+  return str;
+}
+
+
+// EXPORTS
+
+
+export var BigNumber = clone();
+
+export default BigNumber;

projet/node_modules/bignumber.js/bower.json

+{
+  "name": "bignumber.js",
+  "main": "bignumber.js",
+  "version": "7.2.1",
+  "homepage": "https://github.com/MikeMcl/bignumber.js",
+  "authors": [
+    "Michael Mclaughlin <M8ch88l@gmail.com>"
+  ],
+  "description": "A library for arbitrary-precision decimal and non-decimal arithmetic",
+  "moduleType": [
+    "amd",
+    "globals",
+    "node"
+  ],
+   "keywords": [
+    "arbitrary",
+    "precision",
+    "arithmetic",
+    "big",
+    "number",
+    "decimal",
+    "float",
+    "biginteger",
+    "bigdecimal",
+    "bignumber",
+    "bigint",
+    "bignum"
+  ],
+  "license": "MIT",
+  "ignore": [
+    ".*",
+    "*.json",
+    "test"
+  ]
+}
+

projet/node_modules/bignumber.js/doc/API.html

+<!DOCTYPE HTML>
+<html>
+<head>
+<meta charset="utf-8">
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+<meta name="Author" content="M Mclaughlin">
+<title>bignumber.js API</title>
+<style>
+html{font-size:100%}
+body{background:#fff;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:13px;
+  line-height:1.65em;min-height:100%;margin:0}
+body,i{color:#000}
+.nav{background:#fff;position:fixed;top:0;bottom:0;left:0;width:200px;overflow-y:auto;
+  padding:15px 0 30px 15px}
+div.container{width:600px;margin:50px 0 50px 240px}
+p{margin:0 0 1em;width:600px}
+pre,ul{margin:1em 0}
+h1,h2,h3,h4,h5{margin:0;padding:1.5em 0 0}
+h1,h2{padding:.75em 0}
+h1{font:400 3em Verdana,sans-serif;color:#000;margin-bottom:1em}
+h2{font-size:2.25em;color:#ff2a00}
+h3{font-size:1.75em;color:#4dc71f}
+h4{font-size:1.75em;color:#ff2a00;padding-bottom:.75em}
+h5{font-size:1.2em;margin-bottom:.4em}
+h6{font-size:1.1em;margin-bottom:0.8em;padding:0.5em 0}
+dd{padding-top:.35em}
+dt{padding-top:.5em}
+b{font-weight:700}
+dt b{font-size:1.3em}
+a,a:visited{color:#ff2a00;text-decoration:none}
+a:active,a:hover{outline:0;text-decoration:underline}
+.nav a,.nav b,.nav a:visited{display:block;color:#ff2a00;font-weight:700; margin-top:15px}
+.nav b{color:#4dc71f;margin-top:20px;cursor:default;width:auto}
+ul{list-style-type:none;padding:0 0 0 20px}
+.nav ul{line-height:14px;padding-left:0;margin:5px 0 0}
+.nav ul a,.nav ul a:visited,span{display:inline;color:#000;font-family:Verdana,Geneva,sans-serif;
+  font-size:11px;font-weight:400;margin:0}
+.inset,ul.inset{margin-left:20px}
+.inset{font-size:.9em}
+.nav li{width:auto;margin:0 0 3px}
+.alias{font-style:italic;margin-left:20px}
+table{border-collapse:collapse;border-spacing:0;border:2px solid #a7dbd8;margin:1.75em 0;padding:0}
+td,th{text-align:left;margin:0;padding:2px 5px;border:1px dotted #a7dbd8}
+th{border-top:2px solid #a7dbd8;border-bottom:2px solid #a7dbd8;color:#ff2a00}
+code,pre{font-family:Consolas, monaco, monospace;font-weight:400}
+pre{background:#f5f5f5;white-space:pre-wrap;word-wrap:break-word;border-left:5px solid #abef98;
+  padding:1px 0 1px 15px;margin:1.2em 0}
+code,.nav-title{color:#ff2a00}
+.end{margin-bottom:25px}
+.centre{text-align:center}
+.error-table{font-size:13px;width:100%}
+#faq{margin:3em 0 0}
+li span{float:right;margin-right:10px;color:#c0c0c0}
+#js{font:inherit;color:#4dc71f}
+</style>
+</head>
+<body>
+
+  <div class="nav">
+
+    <a class='nav-title' href="#">API</a>
+
+    <b> CONSTRUCTOR </b>
+    <ul>
+      <li><a href="#bignumber">BigNumber</a></li>
+    </ul>
+
+    <a href="#methods">Methods</a>
+    <ul>
+      <li><a href="#clone">clone</a></li>
+      <li><a href="#config" >config</a><span>set</span></li>
+      <li>
+        <ul class="inset">
+          <li><a href="#decimal-places">DECIMAL_PLACES</a></li>
+          <li><a href="#rounding-mode" >ROUNDING_MODE</a></li>
+          <li><a href="#exponential-at">EXPONENTIAL_AT</a></li>
+          <li><a href="#range"         >RANGE</a></li>
+          <li><a href="#crypto"        >CRYPTO</a></li>
+          <li><a href="#modulo-mode"   >MODULO_MODE</a></li>
+          <li><a href="#pow-precision" >POW_PRECISION</a></li>
+          <li><a href="#format"        >FORMAT</a></li>
+          <li><a href="#alphabet"      >ALPHABET</a></li>
+        </ul>
+      </li>
+      <li><a href="#isBigNumber">isBigNumber</a></li>
+      <li><a href="#max"        >maximum</a><span>max</span></li>
+      <li><a href="#min"        >minimum</a><span>min</span></li>
+      <li><a href="#random"     >random</a></li>
+    </ul>
+
+    <a href="#constructor-properties">Properties</a>
+    <ul>
+      <li><a href="#round-up"        >ROUND_UP</a></li>
+      <li><a href="#round-down"      >ROUND_DOWN</a></li>
+      <li><a href="#round-ceil"      >ROUND_CEIL</a></li>
+      <li><a href="#round-floor"     >ROUND_FLOOR</a></li>
+      <li><a href="#round-half-up"   >ROUND_HALF_UP</a></li>
+      <li><a href="#round-half-down" >ROUND_HALF_DOWN</a></li>
+      <li><a href="#round-half-even" >ROUND_HALF_EVEN</a></li>
+      <li><a href="#round-half-ceil" >ROUND_HALF_CEIL</a></li>
+      <li><a href="#round-half-floor">ROUND_HALF_FLOOR</a></li>
+    </ul>
+
+    <b> INSTANCE </b>
+
+    <a href="#prototype-methods">Methods</a>
+    <ul>
+      <li><a href="#abs"    >absoluteValue         </a><span>abs</span>  </li>
+      <li><a href="#cmp"    >comparedTo            </a>                  </li>
+      <li><a href="#dp"     >decimalPlaces         </a><span>dp</span>   </li>
+      <li><a href="#div"    >dividedBy             </a><span>div</span>  </li>
+      <li><a href="#divInt" >dividedToIntegerBy    </a><span>idiv</span> </li>
+      <li><a href="#pow"    >exponentiatedBy       </a><span>pow</span>  </li>
+      <li><a href="#int"    >integerValue          </a>                  </li>
+      <li><a href="#eq"     >isEqualTo             </a><span>eq</span>   </li>
+      <li><a href="#isF"    >isFinite              </a>                  </li>
+      <li><a href="#gt"     >isGreaterThan         </a><span>gt</span>   </li>
+      <li><a href="#gte"    >isGreaterThanOrEqualTo</a><span>gte</span>  </li>
+      <li><a href="#isInt"  >isInteger             </a>                  </li>
+      <li><a href="#lt"     >isLessThan            </a><span>lt</span>   </li>
+      <li><a href="#lte"    >isLessThanOrEqualTo   </a><span>lte</span>  </li>
+      <li><a href="#isNaN"  >isNaN                 </a>                  </li>
+      <li><a href="#isNeg"  >isNegative            </a>                  </li>
+      <li><a href="#isPos"  >isPositive            </a>                  </li>
+      <li><a href="#isZ"    >isZero                </a>                  </li>
+      <li><a href="#minus"  >minus                 </a>                  </li>
+      <li><a href="#mod"    >modulo                </a><span>mod</span>  </li>
+      <li><a href="#times"  >multipliedBy          </a><span>times</span></li>
+      <li><a href="#neg"    >negated               </a>                  </li>
+      <li><a href="#plus"   >plus                  </a>                  </li>
+      <li><a href="#sd"     >precision             </a><span>sd</span>   </li>
+      <li><a href="#shift"  >shiftedBy             </a>                  </li>
+      <li><a href="#sqrt"   >squareRoot            </a><span>sqrt</span> </li>
+      <li><a href="#toE"    >toExponential         </a>                  </li>
+      <li><a href="#toFix"  >toFixed               </a>                  </li>
+      <li><a href="#toFor"  >toFormat              </a>                  </li>
+      <li><a href="#toFr"   >toFraction            </a>                  </li>
+      <li><a href="#toJSON" >toJSON                </a>                  </li>
+      <li><a href="#toN"    >toNumber              </a>                  </li>
+      <li><a href="#toP"    >toPrecision           </a>                  </li>
+      <li><a href="#toS"    >toString              </a>                  </li>
+      <li><a href="#valueOf">valueOf               </a>                  </li>
+    </ul>
+
+    <a href="#instance-properties">Properties</a>
+    <ul>
+      <li><a href="#coefficient">c: coefficient</a></li>
+      <li><a href="#exponent"   >e: exponent</a></li>
+      <li><a href="#sign"       >s: sign</a></li>
+    </ul>
+
+    <a href="#zero-nan-infinity">Zero, NaN &amp; Infinity</a>
+    <a href="#Errors">Errors</a>
+    <a class='end' href="#faq">FAQ</a>
+
+  </div>
+
+  <div class="container">
+
+    <h1>bignumber<span id='js'>.js</span></h1>
+
+    <p>A JavaScript library for arbitrary-precision arithmetic.</p>
+    <p><a href="https://github.com/MikeMcl/bignumber.js">Hosted on GitHub</a>. </p>
+
+    <h2>API</h2>
+
+    <p>
+      See the <a href='https://github.com/MikeMcl/bignumber.js'>README</a> on GitHub for a
+      quick-start introduction.
+    </p>
+    <p>
+      In all examples below, <code>var</code> and semicolons are not shown, and if a commented-out
+      value is in quotes it means <code>toString</code> has been called on the preceding expression.
+    </p>
+
+
+    <h3>CONSTRUCTOR</h3>
+
+
+    <h5 id="bignumber">
+      BigNumber<code class='inset'>BigNumber(n [, base]) <i>&rArr; BigNumber</i></code>
+    </h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i>: integer, <code>2</code> to <code>36</code> inclusive. (See
+      <a href='#alphabet'><code>ALPHABET</code></a> to extend this range).
+    </p>
+    <p>
+      Returns a new instance of a BigNumber object with value <code>n</code>, where <code>n</code>
+      is a numeric value in the specified <code>base</code>, or base <code>10</code> if
+      <code>base</code> is omitted or is <code>null</code> or <code>undefined</code>.
+    </p>
+    <pre>
+x = new BigNumber(123.4567)                // '123.4567'
+// 'new' is optional
+y = BigNumber(x)                           // '123.4567'</pre>
+    <p>
+      If <code>n</code> is a base <code>10</code> value it can be in normal (fixed-point) or
+      exponential notation. Values in other bases must be in normal notation. Values in any base can
+      have fraction digits, i.e. digits after the decimal point.
+    </p>
+    <pre>
+new BigNumber(43210)                       // '43210'
+new BigNumber('4.321e+4')                  // '43210'
+new BigNumber('-735.0918e-430')            // '-7.350918e-428'
+new BigNumber('123412421.234324', 5)       // '607236.557696'</pre>
+    <p>
+      Signed <code>0</code>, signed <code>Infinity</code> and <code>NaN</code> are supported.
+    </p>
+    <pre>
+new BigNumber('-Infinity')                 // '-Infinity'
+new BigNumber(NaN)                         // 'NaN'
+new BigNumber(-0)                          // '0'
+new BigNumber('.5')                        // '0.5'
+new BigNumber('+2')                        // '2'</pre>
+    <p>
+      String values in hexadecimal literal form, e.g. <code>'0xff'</code>, are valid, as are
+      string values with the octal and binary prefixs <code>'0o'</code> and <code>'0b'</code>.
+      String values in octal literal form without the prefix will be interpreted as
+      decimals, e.g. <code>'011'</code> is interpreted as 11, not 9.
+    </p>
+    <pre>
+new BigNumber(-10110100.1, 2)              // '-180.5'
+new BigNumber('-0b10110100.1')             // '-180.5'
+new BigNumber('ff.8', 16)                  // '255.5'
+new BigNumber('0xff.8')                    // '255.5'</pre>
+    <p>
+      If a base is specified, <code>n</code> is rounded according to the current
+      <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
+      <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings. <em>This includes base
+      <code>10</code> so don't include a <code>base</code> parameter for decimal values unless
+      this behaviour is wanted.</em>
+    </p>
+    <pre>BigNumber.config({ DECIMAL_PLACES: 5 })
+new BigNumber(1.23456789)                  // '1.23456789'
+new BigNumber(1.23456789, 10)              // '1.23457'</pre>
+    <p>An error is thrown if <code>base</code> is invalid. See <a href='#Errors'>Errors</a>.</p>
+    <p>
+      There is no limit to the number of digits of a value of type <em>string</em> (other than
+      that of JavaScript's maximum array size). See <a href='#range'><code>RANGE</code></a> to set
+      the maximum and minimum possible exponent value of a BigNumber.
+    </p>
+    <pre>
+new BigNumber('5032485723458348569331745.33434346346912144534543')
+new BigNumber('4.321e10000000')</pre>
+    <p>BigNumber <code>NaN</code> is returned if <code>n</code> is invalid
+    (unless <code>BigNumber.DEBUG</code> is <code>true</code>, see below).</p>
+    <pre>
+new BigNumber('.1*')                       // 'NaN'
+new BigNumber('blurgh')                    // 'NaN'
+new BigNumber(9, 2)                        // 'NaN'</pre>
+    <p>
+      To aid in debugging, if <code>BigNumber.DEBUG</code> is <code>true</code> then an error will
+      be thrown on an invalid <code>n</code>. An error will also be thrown if <code>n</code> is of
+      type <em>number</em> with more than <code>15</code> significant digits, as calling
+      <code><a href='#toS'>toString</a></code> or <code><a href='#valueOf'>valueOf</a></code> on
+      these numbers may not result in the intended value.
+    </p>
+      <pre>
+console.log(823456789123456.3)            //  823456789123456.2
+new BigNumber(823456789123456.3)          // '823456789123456.2'
+BigNumber.DEBUG = true
+// '[BigNumber Error] Number primitive has more than 15 significant digits'
+new BigNumber(823456789123456.3)
+// '[BigNumber Error] Not a base 2 number'
+new BigNumber(9, 2)</pre>
+
+
+
+
+    <h4 id="methods">Methods</h4>
+     <p>The static methods of a BigNumber constructor.</p>
+
+
+
+
+    <h5 id="clone">clone
+      <code class='inset'>.clone([object]) <i>&rArr; BigNumber constructor</i></code>
+    </h5>
+    <p><code>object</code>: <i>object</i></p>
+    <p>
+      Returns a new independent BigNumber constructor with configuration as described by
+      <code>object</code> (see <a href='#config'><code>config</code></a>), or with the default
+      configuration if <code>object</code> is <code>null</code> or <code>undefined</code>.
+    </p>
+    <p>
+      Throws if <code>object</code> is not an object. See <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>BigNumber.config({ DECIMAL_PLACES: 5 })
+BN = BigNumber.clone({ DECIMAL_PLACES: 9 })
+
+x = new BigNumber(1)
+y = new BN(1)
+
+x.div(3)                        // 0.33333
+y.div(3)                        // 0.333333333
+
+// BN = BigNumber.clone({ DECIMAL_PLACES: 9 }) is equivalent to:
+BN = BigNumber.clone()
+BN.config({ DECIMAL_PLACES: 9 })</pre>
+
+
+
+    <h5 id="config">config<code class='inset'>set([object]) <i>&rArr; object</i></code></h5>
+    <p>
+      <code>object</code>: <i>object</i>: an object that contains some or all of the following
+      properties.
+    </p>
+    <p>Configures the settings for this particular BigNumber constructor.</p>
+
+    <dl class='inset'>
+      <dt id="decimal-places"><code><b>DECIMAL_PLACES</b></code></dt>
+      <dd>
+        <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
+        Default value: <code>20</code>
+      </dd>
+      <dd>
+        The <u>maximum</u> number of decimal places of the results of operations involving
+        division, i.e. division, square root and base conversion operations, and power
+        operations with negative exponents.<br />
+      </dd>
+      <dd>
+      <pre>BigNumber.config({ DECIMAL_PLACES: 5 })
+BigNumber.set({ DECIMAL_PLACES: 5 })    // equivalent</pre>
+      </dd>
+
+
+
+      <dt id="rounding-mode"><code><b>ROUNDING_MODE</b></code></dt>
+      <dd>
+        <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive<br />
+        Default value: <code>4</code> <a href="#round-half-up">(<code>ROUND_HALF_UP</code>)</a>
+      </dd>
+      <dd>
+        The rounding mode used in the above operations and the default rounding mode of
+        <a href='#dp'><code>decimalPlaces</code></a>,
+        <a href='#sd'><code>precision</code></a>,
+        <a href='#toE'><code>toExponential</code></a>,
+        <a href='#toFix'><code>toFixed</code></a>,
+        <a href='#toFor'><code>toFormat</code></a> and
+        <a href='#toP'><code>toPrecision</code></a>.
+      </dd>
+      <dd>The modes are available as enumerated properties of the BigNumber constructor.</dd>
+       <dd>
+      <pre>BigNumber.config({ ROUNDING_MODE: 0 })
+BigNumber.set({ ROUNDING_MODE: BigNumber.ROUND_UP })    // equivalent</pre>
+        </dd>
+
+
+
+      <dt id="exponential-at"><code><b>EXPONENTIAL_AT</b></code></dt>
+      <dd>
+        <i>number</i>: integer, magnitude <code>0</code> to <code>1e+9</code> inclusive, or
+        <br />
+        <i>number</i>[]: [ integer <code>-1e+9</code> to <code>0</code> inclusive, integer
+        <code>0</code> to <code>1e+9</code> inclusive ]<br />
+        Default value: <code>[-7, 20]</code>
+      </dd>
+      <dd>
+        The exponent value(s) at which <code>toString</code> returns exponential notation.
+      </dd>
+      <dd>
+        If a single number is assigned, the value is the exponent magnitude.<br />
+        If an array of two numbers is assigned then the first number is the negative exponent
+        value at and beneath which exponential notation is used, and the second number is the
+        positive exponent value at and above which the same.
+      </dd>
+      <dd>
+        For example, to emulate JavaScript numbers in terms of the exponent values at which they
+        begin to use exponential notation, use <code>[-7, 20]</code>.
+      </dd>
+      <dd>
+      <pre>BigNumber.config({ EXPONENTIAL_AT: 2 })
+new BigNumber(12.3)         // '12.3'        e is only 1
+new BigNumber(123)          // '1.23e+2'
+new BigNumber(0.123)        // '0.123'       e is only -1
+new BigNumber(0.0123)       // '1.23e-2'
+
+BigNumber.config({ EXPONENTIAL_AT: [-7, 20] })
+new BigNumber(123456789)    // '123456789'   e is only 8
+new BigNumber(0.000000123)  // '1.23e-7'
+
+// Almost never return exponential notation:
+BigNumber.config({ EXPONENTIAL_AT: 1e+9 })
+
+// Always return exponential notation:
+BigNumber.config({ EXPONENTIAL_AT: 0 })</pre>
+      </dd>
+      <dd>
+        Regardless of the value of <code>EXPONENTIAL_AT</code>, the <code>toFixed</code> method
+        will always return a value in normal notation and the <code>toExponential</code> method
+        will always return a value in exponential form.
+      </dd>
+      <dd>
+        Calling <code>toString</code> with a base argument, e.g. <code>toString(10)</code>, will
+        also always return normal notation.
+      </dd>
+
+
+
+      <dt id="range"><code><b>RANGE</b></code></dt>
+      <dd>
+        <i>number</i>: integer, magnitude <code>1</code> to <code>1e+9</code> inclusive, or
+        <br />
+        <i>number</i>[]: [ integer <code>-1e+9</code> to <code>-1</code> inclusive, integer
+        <code>1</code> to <code>1e+9</code> inclusive ]<br />
+        Default value: <code>[-1e+9, 1e+9]</code>
+      </dd>
+      <dd>
+        The exponent value(s) beyond which overflow to <code>Infinity</code> and underflow to
+        zero occurs.
+      </dd>
+      <dd>
+        If a single number is assigned, it is the maximum exponent magnitude: values wth a
+        positive exponent of greater magnitude become <code>Infinity</code> and those with a
+        negative exponent of greater magnitude become zero.
+      <dd>
+        If an array of two numbers is assigned then the first number is the negative exponent
+        limit and the second number is the positive exponent limit.
+      </dd>
+      <dd>
+        For example, to emulate JavaScript numbers in terms of the exponent values at which they
+        become zero and <code>Infinity</code>, use <code>[-324, 308]</code>.
+      </dd>
+      <dd>
+      <pre>BigNumber.config({ RANGE: 500 })
+BigNumber.config().RANGE     // [ -500, 500 ]
+new BigNumber('9.999e499')   // '9.999e+499'
+new BigNumber('1e500')       // 'Infinity'
+new BigNumber('1e-499')      // '1e-499'
+new BigNumber('1e-500')      // '0'
+
+BigNumber.config({ RANGE: [-3, 4] })
+new BigNumber(99999)         // '99999'      e is only 4
+new BigNumber(100000)        // 'Infinity'   e is 5
+new BigNumber(0.001)         // '0.01'       e is only -3
+new BigNumber(0.0001)        // '0'          e is -4</pre>
+      </dd>
+      <dd>
+        The largest possible magnitude of a finite BigNumber is
+        <code>9.999...e+1000000000</code>.<br />
+        The smallest possible magnitude of a non-zero BigNumber is <code>1e-1000000000</code>.
+      </dd>
+
+
+
+      <dt id="crypto"><code><b>CRYPTO</b></code></dt>
+      <dd>
+        <i>boolean</i>: <code>true</code> or <code>false</code>.<br />
+        Default value: <code>false</code>
+      </dd>
+      <dd>
+        The value that determines whether cryptographically-secure pseudo-random number
+        generation is used.
+      </dd>
+      <dd>
+        If <code>CRYPTO</code> is set to <code>true</code> then the
+        <a href='#random'><code>random</code></a> method will generate random digits using
+        <code>crypto.getRandomValues</code> in browsers that support it, or
+        <code>crypto.randomBytes</code> if using a version of Node.js that supports it.
+      </dd>
+      <dd>
+        If neither function is supported by the host environment then attempting to set
+        <code>CRYPTO</code> to <code>true</code> will fail and an exception will be thrown.
+      </dd>
+      <dd>
+        If <code>CRYPTO</code> is <code>false</code> then the source of randomness used will be
+        <code>Math.random</code> (which is assumed to generate at least <code>30</code> bits of
+        randomness).
+      </dd>
+      <dd>See <a href='#random'><code>random</code></a>.</dd>
+      <dd>
+      <pre>BigNumber.config({ CRYPTO: true })
+BigNumber.config().CRYPTO       // true
+BigNumber.random()              // 0.54340758610486147524</pre>
+      </dd>
+
+
+
+      <dt id="modulo-mode"><code><b>MODULO_MODE</b></code></dt>
+      <dd>
+        <i>number</i>: integer, <code>0</code> to <code>9</code> inclusive<br />
+        Default value: <code>1</code> (<a href="#round-down"><code>ROUND_DOWN</code></a>)
+      </dd>
+      <dd>The modulo mode used when calculating the modulus: <code>a mod n</code>.</dd>
+      <dd>
+        The quotient, <code>q = a / n</code>, is calculated according to the
+        <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> that corresponds to the chosen
+        <code>MODULO_MODE</code>.
+      </dd>
+      <dd>The remainder, <code>r</code>, is calculated as: <code>r = a - n * q</code>.</dd>
+      <dd>
+        The modes that are most commonly used for the modulus/remainder operation are shown in
+        the following table. Although the other rounding modes can be used, they may not give
+        useful results.
+      </dd>
+      <dd>
+        <table>
+          <tr><th>Property</th><th>Value</th><th>Description</th></tr>
+          <tr>
+            <td><b>ROUND_UP</b></td><td class='centre'>0</td>
+            <td>
+              The remainder is positive if the dividend is negative, otherwise it is negative.
+            </td>
+          </tr>
+          <tr>
+            <td><b>ROUND_DOWN</b></td><td class='centre'>1</td>
+            <td>
+              The remainder has the same sign as the dividend.<br />
+              This uses 'truncating division' and matches the behaviour of JavaScript's
+              remainder operator <code>%</code>.
+            </td>
+          </tr>
+          <tr>
+            <td><b>ROUND_FLOOR</b></td><td class='centre'>3</td>
+            <td>
+              The remainder has the same sign as the divisor.<br />
+              This matches Python's <code>%</code> operator.
+            </td>
+          </tr>
+          <tr>
+            <td><b>ROUND_HALF_EVEN</b></td><td class='centre'>6</td>
+            <td>The <i>IEEE 754</i> remainder function.</td>
+          </tr>
+           <tr>
+             <td><b>EUCLID</b></td><td class='centre'>9</td>
+             <td>
+               The remainder is always positive. Euclidian division: <br />
+               <code>q = sign(n) * floor(a / abs(n))</code>
+             </td>
+           </tr>
+        </table>
+      </dd>
+      <dd>
+        The rounding/modulo modes are available as enumerated properties of the BigNumber
+        constructor.
+      </dd>
+      <dd>See <a href='#mod'><code>modulo</code></a>.</dd>
+      <dd>
+        <pre>BigNumber.config({ MODULO_MODE: BigNumber.EUCLID })
+BigNumber.config({ MODULO_MODE: 9 })          // equivalent</pre>
+      </dd>
+
+
+
+      <dt id="pow-precision"><code><b>POW_PRECISION</b></code></dt>
+      <dd>
+        <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive.<br />
+        Default value: <code>0</code>
+      </dd>
+      <dd>
+        The <i>maximum</i> precision, i.e. number of significant digits, of the result of the power
+        operation (unless a modulus is specified).
+      </dd>
+      <dd>If set to <code>0</code>, the number of significant digits will not be limited.</dd>
+      <dd>See <a href='#pow'><code>exponentiatedBy</code></a>.</dd>
+      <dd><pre>BigNumber.config({ POW_PRECISION: 100 })</pre></dd>
+
+
+
+      <dt id="format"><code><b>FORMAT</b></code></dt>
+      <dd><i>object</i></dd>
+      <dd>
+        The <code>FORMAT</code> object configures the format of the string returned by the
+        <a href='#toFor'><code>toFormat</code></a> method.
+      </dd>
+      <dd>
+        The example below shows the properties of the <code>FORMAT</code> object that are
+        recognised, and their default values.
+      </dd>
+      <dd>
+         Unlike the other configuration properties, the values of the properties of the
+         <code>FORMAT</code> object will not be checked for validity. The existing
+         <code>FORMAT</code> object will simply be replaced by the object that is passed in.
+         The object can include any number of the properties shown below.
+      </dd>
+      <dd>See <a href='#toFor'><code>toFormat</code></a> for examples of usage.</dd>
+      <dd>
+      <pre>
+BigNumber.config({
+    FORMAT: {
+        // the decimal separator
+        decimalSeparator: '.',
+        // the grouping separator of the integer part
+        groupSeparator: ',',
+        // the primary grouping size of the integer part
+        groupSize: 3,
+        // the secondary grouping size of the integer part
+        secondaryGroupSize: 0,
+        // the grouping separator of the fraction part
+        fractionGroupSeparator: ' ',
+        // the grouping size of the fraction part
+        fractionGroupSize: 0
+    }
+});</pre>
+      </dd>
+
+
+
+      <dt id="alphabet"><code><b>ALPHABET</b></code></dt>
+      <dd>
+        <i>string</i><br />
+        Default value: <code>'0123456789abcdefghijklmnopqrstuvwxyz'</code>
+      </dd>
+      <dd>
+        The alphabet used for base conversion. The length of the alphabet corresponds to the
+        maximum value of the base argument that can be passed to the
+        <a href='#bignumber'><code>BigNumber</code></a> constructor or
+        <a href='#toS'><code>toString</code></a>.
+      </dd>
+      <dd>
+        There is no maximum length for the alphabet, but it must be at least 2 characters long, and
+        it must not contain a repeated character, or <code>'.'</code>, as that is used as the
+        decimal separator for all values whatever their base.
+      </dd>
+      <dd>
+        <pre>// duodecimal (base 12)
+BigNumber.config({ ALPHABET: '0123456789TE' })
+x = new BigNumber('T', 12)
+x.toString()                // '10'
+x.toString(12)              // 'T'</pre>
+      </dd>
+
+
+
+    </dl>
+    <br /><br />
+    <p>Returns an object with the above properties and their current values.</p>
+    <p>
+      Throws if <code>object</code> is not an object, or if an invalid value is assigned to
+      one or more of the above properties. See <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>
+BigNumber.config({
+    DECIMAL_PLACES: 40,
+    ROUNDING_MODE: BigNumber.ROUND_HALF_CEIL,
+    EXPONENTIAL_AT: [-10, 20],
+    RANGE: [-500, 500],
+    CRYPTO: true,
+    MODULO_MODE: BigNumber.ROUND_FLOOR,
+    POW_PRECISION: 80,
+    FORMAT: {
+        groupSize: 3,
+        groupSeparator: ' ',
+        decimalSeparator: ','
+    },
+    ALPHABET: '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
+});
+
+obj = BigNumber.config();
+obj.DECIMAL_PLACES        // 40
+obj.RANGE                 // [-500, 500]</pre>
+
+
+
+    <h5 id="isBigNumber">
+      isBigNumber<code class='inset'>.isBigNumber(value) <i>&rArr; boolean</i></code>
+    </h5>
+    <p><code>value</code>: <i>any</i><br /></p>
+    <p>
+      Returns <code>true</code> if <code>value</code> is a BigNumber instance, otherwise returns
+      <code>false</code>.
+    </p>
+      <pre>x = 42
+y = new BigNumber(x)
+
+BigNumber.isBigNumber(x)             // false
+y instanceof BigNumber               // true
+BigNumber.isBigNumber(y)             // true
+
+BN = BigNumber.clone();
+z = new BN(x)
+z instanceof BigNumber               // false
+BigNumber.isBigNumber(z)             // true</pre>
+
+
+
+    <h5 id="max">
+      maximum<code class='inset'>.max([arg1 [, arg2, ...]]) <i>&rArr; BigNumber</i></code>
+    </h5>
+    <p>
+      <code>arg1</code>, <code>arg2</code>, ...: <i>number|string|BigNumber</i><br />
+      <i>See <code><a href="#bignumber">BigNumber</a></code> for further parameter details.</i>
+    </p>
+    <p>
+      Returns a BigNumber whose value is the maximum of <code>arg1</code>,
+      <code>arg2</code>,... .
+    </p>
+    <p>The argument to this method can also be an array of values.</p>
+    <p>The return value is always exact and unrounded.</p>
+    <pre>x = new BigNumber('3257869345.0378653')
+BigNumber.maximum(4e9, x, '123456789.9')      // '4000000000'
+
+arr = [12, '13', new BigNumber(14)]
+BigNumber.max(arr)                            // '14'</pre>
+
+
+
+    <h5 id="min">
+      minimum<code class='inset'>.min([arg1 [, arg2, ...]]) <i>&rArr; BigNumber</i></code>
+    </h5>
+    <p>
+      <code>arg1</code>, <code>arg2</code>, ...: <i>number|string|BigNumber</i><br />
+      <i>See <code><a href="#bignumber">BigNumber</a></code> for further parameter details.</i>
+    </p>
+    <p>
+      Returns a BigNumber whose value is the minimum of <code>arg1</code>,
+      <code>arg2</code>,... .
+    </p>
+    <p>The argument to this method can also be an array of values.</p>
+    <p>The return value is always exact and unrounded.</p>
+    <pre>x = new BigNumber('3257869345.0378653')
+BigNumber.minimum(4e9, x, '123456789.9')      // '123456789.9'
+
+arr = [2, new BigNumber(-14), '-15.9999', -12]
+BigNumber.min(arr)                            // '-15.9999'</pre>
+
+
+
+    <h5 id="random">
+      random<code class='inset'>.random([dp]) <i>&rArr; BigNumber</i></code>
+    </h5>
+    <p><code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive</p>
+    <p>
+      Returns a new BigNumber with a pseudo-random value equal to or greater than <code>0</code> and
+      less than <code>1</code>.
+    </p>
+    <p>
+      The return value will have <code>dp</code> decimal places (or less if trailing zeros are
+      produced).<br />
+      If <code>dp</code> is omitted then the number of decimal places will default to the current
+      <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> setting.
+    </p>
+    <p>
+      Depending on the value of this BigNumber constructor's
+      <a href='#crypto'><code>CRYPTO</code></a> setting and the support for the
+      <code>crypto</code> object in the host environment, the random digits of the return value are
+      generated by either <code>Math.random</code> (fastest), <code>crypto.getRandomValues</code>
+      (Web Cryptography API in recent browsers) or <code>crypto.randomBytes</code> (Node.js).
+    </p>
+    <p>
+      If <a href='#crypto'><code>CRYPTO</code></a> is <code>true</code>, i.e. one of the
+      <code>crypto</code> methods is to be used, the value of a returned BigNumber should be
+      cryptographically-secure and statistically indistinguishable from a random value.
+    </p>
+    <p>
+      Throws if <code>dp</code> is invalid. See <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>BigNumber.config({ DECIMAL_PLACES: 10 })
+BigNumber.random()              // '0.4117936847'
+BigNumber.random(20)            // '0.78193327636914089009'</pre>
+
+
+
+    <h4 id="constructor-properties">Properties</h4>
+    <p>
+      The library's enumerated rounding modes are stored as properties of the constructor.<br />
+      (They are not referenced internally by the library itself.)
+    </p>
+    <p>
+      Rounding modes <code>0</code> to <code>6</code> (inclusive) are the same as those of Java's
+      BigDecimal class.
+    </p>
+    <table>
+      <tr>
+        <th>Property</th>
+        <th>Value</th>
+        <th>Description</th>
+      </tr>
+      <tr>
+        <td id="round-up"><b>ROUND_UP</b></td>
+        <td class='centre'>0</td>
+        <td>Rounds away from zero</td>
+      </tr>
+      <tr>
+        <td id="round-down"><b>ROUND_DOWN</b></td>
+        <td class='centre'>1</td>
+        <td>Rounds towards zero</td>
+      </tr>
+      <tr>
+        <td id="round-ceil"><b>ROUND_CEIL</b></td>
+        <td class='centre'>2</td>
+        <td>Rounds towards <code>Infinity</code></td>
+      </tr>
+      <tr>
+        <td id="round-floor"><b>ROUND_FLOOR</b></td>
+        <td class='centre'>3</td>
+        <td>Rounds towards <code>-Infinity</code></td>
+      </tr>
+      <tr>
+        <td id="round-half-up"><b>ROUND_HALF_UP</b></td>
+        <td class='centre'>4</td>
+        <td>
+          Rounds towards nearest neighbour.<br />
+          If equidistant, rounds away from zero
+        </td>
+      </tr>
+      <tr>
+        <td id="round-half-down"><b>ROUND_HALF_DOWN</b></td>
+        <td class='centre'>5</td>
+        <td>
+          Rounds towards nearest neighbour.<br />
+          If equidistant, rounds towards zero
+        </td>
+      </tr>
+      <tr>
+        <td id="round-half-even"><b>ROUND_HALF_EVEN</b></td>
+        <td class='centre'>6</td>
+        <td>
+          Rounds towards nearest neighbour.<br />
+          If equidistant, rounds towards even neighbour
+        </td>
+      </tr>
+      <tr>
+        <td id="round-half-ceil"><b>ROUND_HALF_CEIL</b></td>
+        <td class='centre'>7</td>
+        <td>
+          Rounds towards nearest neighbour.<br />
+          If equidistant, rounds towards <code>Infinity</code>
+        </td>
+      </tr>
+      <tr>
+        <td id="round-half-floor"><b>ROUND_HALF_FLOOR</b></td>
+        <td class='centre'>8</td>
+        <td>
+          Rounds towards nearest neighbour.<br />
+          If equidistant, rounds towards <code>-Infinity</code>
+        </td>
+      </tr>
+    </table>
+    <pre>
+BigNumber.config({ ROUNDING_MODE: BigNumber.ROUND_CEIL })
+BigNumber.config({ ROUNDING_MODE: 2 })     // equivalent</pre>
+
+
+    <h3>INSTANCE</h3>
+
+    <h4 id="prototype-methods">Methods</h4>
+    <p>The methods inherited by a BigNumber instance from its constructor's prototype object.</p>
+    <p>A BigNumber is immutable in the sense that it is not changed by its methods. </p>
+    <p>
+      The treatment of &plusmn;<code>0</code>, &plusmn;<code>Infinity</code> and <code>NaN</code> is
+      consistent with how JavaScript treats these values.
+    </p>
+    <p>Many method names have a shorter alias.</p>
+
+
+
+    <h5 id="abs">absoluteValue<code class='inset'>.abs() <i>&rArr; BigNumber</i></code></h5>
+    <p>
+      Returns a BigNumber whose value is the absolute value, i.e. the magnitude, of the value of
+      this BigNumber.
+    </p>
+    <p>The return value is always exact and unrounded.</p>
+    <pre>
+x = new BigNumber(-0.8)
+y = x.absoluteValue()           // '0.8'
+z = y.abs()                     // '0.8'</pre>
+
+
+
+    <h5 id="cmp">
+      comparedTo<code class='inset'>.comparedTo(n [, base]) <i>&rArr; number</i></code>
+    </h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <table>
+      <tr><th>Returns</th><th>&nbsp;</th></tr>
+      <tr>
+        <td class='centre'><code>1</code></td>
+        <td>If the value of this BigNumber is greater than the value of <code>n</code></td>
+      </tr>
+      <tr>
+        <td class='centre'><code>-1</code></td>
+        <td>If the value of this BigNumber is less than the value of <code>n</code></td>
+      </tr>
+      <tr>
+        <td class='centre'><code>0</code></td>
+        <td>If this BigNumber and <code>n</code> have the same value</td>
+      </tr>
+       <tr>
+        <td class='centre'><code>null</code></td>
+        <td>If the value of either this BigNumber or <code>n</code> is <code>NaN</code></td>
+      </tr>
+    </table>
+    <pre>
+x = new BigNumber(Infinity)
+y = new BigNumber(5)
+x.comparedTo(y)                 // 1
+x.comparedTo(x.minus(1))        // 0
+y.comparedTo(NaN)               // null
+y.comparedTo('110', 2)          // -1</pre>
+
+
+
+    <h5 id="dp">
+      decimalPlaces<code class='inset'>.dp([dp [, rm]]) <i>&rArr; BigNumber|number</i></code>
+    </h5>
+    <p>
+      <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
+      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
+    </p>
+    <p>
+      If <code>dp</code> is a number, returns a BigNumber whose value is the value of this BigNumber
+      rounded by rounding mode <code>rm</code> to a maximum of <code>dp</code> decimal places.
+    </p>
+    <p>
+      If <code>dp</code> is omitted, or is <code>null</code> or <code>undefined</code>, the return
+      value is the number of decimal places of the value of this BigNumber, or <code>null</code> if
+      the value of this BigNumber is &plusmn;<code>Infinity</code> or <code>NaN</code>.
+    </p>
+    <p>
+      If <code>rm</code> is omitted, or is <code>null</code> or <code>undefined</code>,
+      <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.
+    </p>
+    <p>
+      Throws if <code>dp</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>
+x = new BigNumber(1234.56)
+x.decimalPlaces(1)                     // '1234.6'
+x.dp()                                 // 2
+x.decimalPlaces(2)                     // '1234.56'
+x.dp(10)                               // '1234.56'
+x.decimalPlaces(0, 1)                  // '1234'
+x.dp(0, 6)                             // '1235'
+x.decimalPlaces(1, 1)                  // '1234.5'
+x.dp(1, BigNumber.ROUND_HALF_EVEN)     // '1234.6'
+x                                      // '1234.56'
+y = new BigNumber('9.9e-101')
+y.dp()                                 // 102</pre>
+
+
+
+    <h5 id="div">dividedBy<code class='inset'>.div(n [, base]) <i>&rArr; BigNumber</i></code>
+    </h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <p>
+      Returns a BigNumber whose value is the value of this BigNumber divided by
+      <code>n</code>, rounded according to the current
+      <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
+      <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
+    </p>
+    <pre>
+x = new BigNumber(355)
+y = new BigNumber(113)
+x.dividedBy(y)                  // '3.14159292035398230088'
+x.div(5)                        // '71'
+x.div(47, 16)                   // '5'</pre>
+
+
+
+    <h5 id="divInt">
+      dividedToIntegerBy<code class='inset'>.idiv(n [, base]) &rArr;
+      <i>BigNumber</i></code>
+    </h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <p>
+      Returns a BigNumber whose value is the integer part of dividing the value of this BigNumber by
+      <code>n</code>.
+    </p>
+    <pre>
+x = new BigNumber(5)
+y = new BigNumber(3)
+x.dividedToIntegerBy(y)         // '1'
+x.idiv(0.7)                     // '7'
+x.idiv('0.f', 16)               // '5'</pre>
+
+
+
+    <h5 id="pow">
+      exponentiatedBy<code class='inset'>.pow(n [, m]) <i>&rArr; BigNumber</i></code>
+    </h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i>: integer<br />
+      <code>m</code>: <i>number|string|BigNumber</i>
+    </p>
+    <p>
+      Returns a BigNumber whose value is the value of this BigNumber exponentiated by
+      <code>n</code>, i.e. raised to the power <code>n</code>, and optionally modulo a modulus
+      <code>m</code>.
+    </p>
+    <p>
+      Throws if <code>n</code> is not an integer. See <a href='#Errors'>Errors</a>.
+    </p>
+    <p>
+      If <code>n</code> is negative the result is rounded according to the current
+      <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
+      <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
+    </p>
+    <p>
+      As the number of digits of the result of the power operation can grow so large so quickly,
+      e.g. 123.456<sup>10000</sup> has over <code>50000</code> digits, the number of significant
+      digits calculated is limited to the value of the
+      <a href='#pow-precision'><code>POW_PRECISION</code></a> setting (unless a modulus
+      <code>m</code> is specified).
+    </p>
+    <p>
+      By default <a href='#pow-precision'><code>POW_PRECISION</code></a> is set to <code>0</code>.
+      This means that an unlimited number of significant digits will be calculated, and that the
+      method's performance will decrease dramatically for larger exponents.
+    </p>
+    <p>
+      If <code>m</code> is specified and the value of <code>m</code>, <code>n</code> and this
+      BigNumber are integers, and <code>n</code> is positive, then a fast modular exponentiation
+      algorithm is used, otherwise the operation will be performed as
+      <code>x.exponentiatedBy(n).modulo(m)</code> with a
+      <a href='#pow-precision'><code>POW_PRECISION</code></a> of <code>0</code>.
+    </p>
+    <pre>
+Math.pow(0.7, 2)                // 0.48999999999999994
+x = new BigNumber(0.7)
+x.exponentiatedBy(2)            // '0.49'
+BigNumber(3).pow(-2)            // '0.11111111111111111111'</pre>
+
+
+
+    <h5 id="int">
+      integerValue<code class='inset'>.integerValue([rm]) <i>&rArr; BigNumber</i></code>
+    </h5>
+    <p>
+      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
+    </p>
+   <p>
+      Returns a BigNumber whose value is the value of this BigNumber rounded to an integer using
+      rounding mode <code>rm</code>.
+    </p>
+    <p>
+      If <code>rm</code> is omitted, or is <code>null</code> or <code>undefined</code>,
+      <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.
+    </p>
+    <p>
+      Throws if <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>
+x = new BigNumber(123.456)
+x.integerValue()                        // '123'
+x.integerValue(BigNumber.ROUND_CEIL)    // '124'
+y = new BigNumber(-12.7)
+y.integerValue()                        // '-13'
+y.integerValue(BigNumber.ROUND_DOWN)    // '-12'</pre>
+    <p>
+      The following is an example of how to add a prototype method that emulates JavaScript's
+      <code>Math.round</code> function. <code>Math.ceil</code>, <code>Math.floor</code> and
+      <code>Math.trunc</code> can be emulated in the same way with
+      <code>BigNumber.ROUND_CEIL</code>, <code>BigNumber.ROUND_FLOOR</code> and
+      <code> BigNumber.ROUND_DOWN</code> respectively.
+    </p>
+    <pre>
+BigNumber.prototype.round = function (n) {
+  return n.integerValue(BigNumber.ROUND_HALF_CEIL);
+};
+x.round()                               // '123'</pre>
+
+
+
+    <h5 id="eq">isEqualTo<code class='inset'>.eq(n [, base]) <i>&rArr; boolean</i></code></h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <p>
+      Returns <code>true</code> if the value of this BigNumber is equal to the value of
+      <code>n</code>, otherwise returns <code>false</code>.<br />
+      As with JavaScript, <code>NaN</code> does not equal <code>NaN</code>.
+    </p>
+    <p>Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally.</p>
+    <pre>
+0 === 1e-324                    // true
+x = new BigNumber(0)
+x.isEqualTo('1e-324')           // false
+BigNumber(-0).eq(x)             // true  ( -0 === 0 )
+BigNumber(255).eq('ff', 16)     // true
+
+y = new BigNumber(NaN)
+y.isEqualTo(NaN)                // false</pre>
+
+
+
+    <h5 id="isF">isFinite<code class='inset'>.isFinite() <i>&rArr; boolean</i></code></h5>
+    <p>
+      Returns <code>true</code> if the value of this BigNumber is a finite number, otherwise
+      returns <code>false</code>.
+    </p>
+    <p>
+      The only possible non-finite values of a BigNumber are <code>NaN</code>, <code>Infinity</code>
+      and <code>-Infinity</code>.
+    </p>
+    <pre>
+x = new BigNumber(1)
+x.isFinite()                    // true
+y = new BigNumber(Infinity)
+y.isFinite()                    // false</pre>
+    <p>
+      Note: The native method <code>isFinite()</code> can be used if
+      <code>n &lt;= Number.MAX_VALUE</code>.
+    </p>
+
+
+
+    <h5 id="gt">isGreaterThan<code class='inset'>.gt(n [, base]) <i>&rArr; boolean</i></code></h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <p>
+      Returns <code>true</code> if the value of this BigNumber is greater than the value of
+      <code>n</code>, otherwise returns <code>false</code>.
+    </p>
+    <p>Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally.</p>
+    <pre>
+0.1 &gt; (0.3 - 0.2)                             // true
+x = new BigNumber(0.1)
+x.isGreaterThan(BigNumber(0.3).minus(0.2))    // false
+BigNumber(0).gt(x)                            // false
+BigNumber(11, 3).gt(11.1, 2)                  // true</pre>
+
+
+
+    <h5 id="gte">
+      isGreaterThanOrEqualTo<code class='inset'>.gte(n [, base]) <i>&rArr; boolean</i></code>
+    </h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <p>
+      Returns <code>true</code> if the value of this BigNumber is greater than or equal to the value
+      of <code>n</code>, otherwise returns <code>false</code>.
+    </p>
+    <p>Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally.</p>
+    <pre>
+(0.3 - 0.2) &gt;= 0.1                     // false
+x = new BigNumber(0.3).minus(0.2)
+x.isGreaterThanOrEqualTo(0.1)          // true
+BigNumber(1).gte(x)                    // true
+BigNumber(10, 18).gte('i', 36)         // true</pre>
+
+
+
+    <h5 id="isInt">isInteger<code class='inset'>.isInteger() <i>&rArr; boolean</i></code></h5>
+    <p>
+      Returns <code>true</code> if the value of this BigNumber is an integer, otherwise returns
+      <code>false</code>.
+    </p>
+    <pre>
+x = new BigNumber(1)
+x.isInteger()                   // true
+y = new BigNumber(123.456)
+y.isInteger()                   // false</pre>
+
+
+
+    <h5 id="lt">isLessThan<code class='inset'>.lt(n [, base]) <i>&rArr; boolean</i></code></h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <p>
+      Returns <code>true</code> if the value of this BigNumber is less than the value of
+      <code>n</code>, otherwise returns <code>false</code>.
+    </p>
+     <p>Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally.</p>
+    <pre>
+(0.3 - 0.2) &lt; 0.1                       // true
+x = new BigNumber(0.3).minus(0.2)
+x.isLessThan(0.1)                       // false
+BigNumber(0).lt(x)                      // true
+BigNumber(11.1, 2).lt(11, 3)            // true</pre>
+
+
+
+    <h5 id="lte">
+      isLessThanOrEqualTo<code class='inset'>.lte(n [, base]) <i>&rArr; boolean</i></code>
+    </h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <p>
+      Returns <code>true</code> if the value of this BigNumber is less than or equal to the value of
+      <code>n</code>, otherwise returns <code>false</code>.
+    </p>
+    <p>Note: This method uses the <a href='#cmp'><code>comparedTo</code></a> method internally.</p>
+    <pre>
+0.1 &lt;= (0.3 - 0.2)                                // false
+x = new BigNumber(0.1)
+x.isLessThanOrEqualTo(BigNumber(0.3).minus(0.2))  // true
+BigNumber(-1).lte(x)                              // true
+BigNumber(10, 18).lte('i', 36)                    // true</pre>
+
+
+
+    <h5 id="isNaN">isNaN<code class='inset'>.isNaN() <i>&rArr; boolean</i></code></h5>
+    <p>
+      Returns <code>true</code> if the value of this BigNumber is <code>NaN</code>, otherwise
+      returns <code>false</code>.
+    </p>
+    <pre>
+x = new BigNumber(NaN)
+x.isNaN()                       // true
+y = new BigNumber('Infinity')
+y.isNaN()                       // false</pre>
+    <p>Note: The native method <code>isNaN()</code> can also be used.</p>
+
+
+
+    <h5 id="isNeg">isNegative<code class='inset'>.isNegative() <i>&rArr; boolean</i></code></h5>
+    <p>
+      Returns <code>true</code> if the value of this BigNumber is negative, otherwise returns
+      <code>false</code>.
+    </p>
+    <pre>
+x = new BigNumber(-0)
+x.isNegative()                  // true
+y = new BigNumber(2)
+y.isNegative()                  // false</pre>
+    <p>Note: <code>n &lt; 0</code> can be used if <code>n &lt;= -Number.MIN_VALUE</code>.</p>
+
+
+
+    <h5 id="isPos">isPositive<code class='inset'>.isPositive() <i>&rArr; boolean</i></code></h5>
+    <p>
+      Returns <code>true</code> if the value of this BigNumber is positive, otherwise returns
+      <code>false</code>.
+    </p>
+    <pre>
+x = new BigNumber(-0)
+x.isPositive()                  // false
+y = new BigNumber(2)
+y.isPositive()                  // true</pre>
+
+
+
+    <h5 id="isZ">isZero<code class='inset'>.isZero() <i>&rArr; boolean</i></code></h5>
+    <p>
+      Returns <code>true</code> if the value of this BigNumber is zero or minus zero, otherwise
+      returns <code>false</code>.
+    </p>
+    <pre>
+x = new BigNumber(-0)
+x.isZero() && x.isneg()         // true
+y = new BigNumber(Infinity)
+y.isZero()                      // false</pre>
+    <p>Note: <code>n == 0</code> can be used if <code>n &gt;= Number.MIN_VALUE</code>.</p>
+
+
+
+    <h5 id="minus">
+      minus<code class='inset'>.minus(n [, base]) <i>&rArr; BigNumber</i></code>
+    </h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <p>Returns a BigNumber whose value is the value of this BigNumber minus <code>n</code>.</p>
+    <p>The return value is always exact and unrounded.</p>
+    <pre>
+0.3 - 0.1                       // 0.19999999999999998
+x = new BigNumber(0.3)
+x.minus(0.1)                    // '0.2'
+x.minus(0.6, 20)                // '0'</pre>
+
+
+
+    <h5 id="mod">modulo<code class='inset'>.mod(n [, base]) <i>&rArr; BigNumber</i></code></h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <p>
+      Returns a BigNumber whose value is the value of this BigNumber modulo <code>n</code>, i.e.
+      the integer remainder of dividing this BigNumber by <code>n</code>.
+    </p>
+    <p>
+      The value returned, and in particular its sign, is dependent on the value of the
+      <a href='#modulo-mode'><code>MODULO_MODE</code></a> setting of this BigNumber constructor.
+      If it is <code>1</code> (default value), the result will have the same sign as this BigNumber,
+      and it will match that of Javascript's <code>%</code> operator (within the limits of double
+      precision) and BigDecimal's <code>remainder</code> method.
+    </p>
+    <p>The return value is always exact and unrounded.</p>
+    <p>
+      See <a href='#modulo-mode'><code>MODULO_MODE</code></a> for a description of the other
+      modulo modes.
+    </p>
+    <pre>
+1 % 0.9                         // 0.09999999999999998
+x = new BigNumber(1)
+x.modulo(0.9)                   // '0.1'
+y = new BigNumber(33)
+y.mod('a', 33)                  // '3'</pre>
+
+
+
+    <h5 id="times">
+      multipliedBy<code class='inset'>.times(n [, base]) <i>&rArr; BigNumber</i></code>
+    </h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <p>
+      Returns a BigNumber whose value is the value of this BigNumber multiplied by <code>n</code>.
+    </p>
+    <p>The return value is always exact and unrounded.</p>
+    <pre>
+0.6 * 3                         // 1.7999999999999998
+x = new BigNumber(0.6)
+y = x.multipliedBy(3)           // '1.8'
+BigNumber('7e+500').times(y)    // '1.26e+501'
+x.multipliedBy('-a', 16)        // '-6'</pre>
+
+
+
+    <h5 id="neg">negated<code class='inset'>.negated() <i>&rArr; BigNumber</i></code></h5>
+    <p>
+      Returns a BigNumber whose value is the value of this BigNumber negated, i.e. multiplied by
+      <code>-1</code>.
+    </p>
+    <pre>
+x = new BigNumber(1.8)
+x.negated()                     // '-1.8'
+y = new BigNumber(-1.3)
+y.negated()                     // '1.3'</pre>
+
+
+
+    <h5 id="plus">plus<code class='inset'>.plus(n [, base]) <i>&rArr; BigNumber</i></code></h5>
+    <p>
+      <code>n</code>: <i>number|string|BigNumber</i><br />
+      <code>base</code>: <i>number</i><br />
+      <i>See <a href="#bignumber">BigNumber</a> for further parameter details.</i>
+    </p>
+    <p>Returns a BigNumber whose value is the value of this BigNumber plus <code>n</code>.</p>
+    <p>The return value is always exact and unrounded.</p>
+    <pre>
+0.1 + 0.2                       // 0.30000000000000004
+x = new BigNumber(0.1)
+y = x.plus(0.2)                 // '0.3'
+BigNumber(0.7).plus(x).plus(y)  // '1'
+x.plus('0.1', 8)                // '0.225'</pre>
+
+
+
+    <h5 id="sd">
+      precision<code class='inset'>.sd([d [, rm]]) <i>&rArr; BigNumber|number</i></code>
+    </h5>
+    <p>
+      <code>d</code>: <i>number|boolean</i>: integer, <code>1</code> to <code>1e+9</code>
+      inclusive, or <code>true</code> or <code>false</code><br />
+      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive.
+    </p>
+    <p>
+      If <code>d</code> is a number, returns a BigNumber whose value is the value of this BigNumber
+      rounded to a precision of <code>d</code> significant digits using rounding mode
+      <code>rm</code>.
+    </p>
+    <p>
+      If <code>d</code> is omitted or is <code>null</code> or <code>undefined</code>, the return
+      value is the number of significant digits of the value of this BigNumber, or <code>null</code>
+      if the value of this BigNumber is &plusmn;<code>Infinity</code> or <code>NaN</code>.</p>
+    </p>
+    <p>
+      If <code>d</code> is <code>true</code> then any trailing zeros of the integer
+      part of a number are counted as significant digits, otherwise they are not.
+    </p>
+    <p>
+      If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
+      <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> will be used.
+    </p>
+    <p>
+      Throws if <code>d</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>
+x = new BigNumber(9876.54321)
+x.precision(6)                         // '9876.54'
+x.sd()                                 // 9
+x.precision(6, BigNumber.ROUND_UP)     // '9876.55'
+x.sd(2)                                // '9900'
+x.precision(2, 1)                      // '9800'
+x                                      // '9876.54321'
+y = new BigNumber(987000)
+y.precision()                          // 3
+y.sd(true)                             // 6</pre>
+
+
+
+<h5 id="shift">shiftedBy<code class='inset'>.shiftedBy(n) <i>&rArr; BigNumber</i></code></h5>
+    <p>
+      <code>n</code>: <i>number</i>: integer,
+      <code>-9007199254740991</code> to <code>9007199254740991</code> inclusive
+    </p>
+    <p>
+      Returns a BigNumber whose value is the value of this BigNumber shifted by <code>n</code>
+      places.
+    <p>
+      The shift is of the decimal point, i.e. of powers of ten, and is to the left if <code>n</code>
+      is negative or to the right if <code>n</code> is positive.
+    </p>
+    <p>The return value is always exact and unrounded.</p>
+    <p>
+      Throws if <code>n</code> is invalid. See <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>
+x = new BigNumber(1.23)
+x.shiftedBy(3)                      // '1230'
+x.shiftedBy(-3)                     // '0.00123'</pre>
+
+
+
+    <h5 id="sqrt">squareRoot<code class='inset'>.sqrt() <i>&rArr; BigNumber</i></code></h5>
+    <p>
+      Returns a BigNumber whose value is the square root of the value of this BigNumber,
+      rounded according to the current
+      <a href='#decimal-places'><code>DECIMAL_PLACES</code></a> and
+      <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
+    </p>
+    <p>
+      The return value will be correctly rounded, i.e. rounded as if the result was first calculated
+      to an infinite number of correct digits before rounding.
+    </p>
+    <pre>
+x = new BigNumber(16)
+x.squareRoot()                  // '4'
+y = new BigNumber(3)
+y.sqrt()                        // '1.73205080756887729353'</pre>
+
+
+
+    <h5 id="toE">
+      toExponential<code class='inset'>.toExponential([dp [, rm]]) <i>&rArr; string</i></code>
+    </h5>
+    <p>
+      <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
+      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
+    </p>
+    <p>
+      Returns a string representing the value of this BigNumber in exponential notation rounded
+      using rounding mode <code>rm</code> to <code>dp</code> decimal places, i.e with one digit
+      before the decimal point and <code>dp</code> digits after it.
+    </p>
+    <p>
+      If the value of this BigNumber in exponential notation has fewer than <code>dp</code> fraction
+      digits, the return value will be appended with zeros accordingly.
+    </p>
+    <p>
+      If <code>dp</code> is omitted, or is <code>null</code> or <code>undefined</code>, the number
+      of digits after the decimal point defaults to the minimum number of digits necessary to
+      represent the value exactly.<br />
+      If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
+      <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.
+    </p>
+    <p>
+      Throws if <code>dp</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
+    </p>
+     <pre>
+x = 45.6
+y = new BigNumber(x)
+x.toExponential()               // '4.56e+1'
+y.toExponential()               // '4.56e+1'
+x.toExponential(0)              // '5e+1'
+y.toExponential(0)              // '5e+1'
+x.toExponential(1)              // '4.6e+1'
+y.toExponential(1)              // '4.6e+1'
+y.toExponential(1, 1)           // '4.5e+1'  (ROUND_DOWN)
+x.toExponential(3)              // '4.560e+1'
+y.toExponential(3)              // '4.560e+1'</pre>
+
+
+
+    <h5 id="toFix">
+      toFixed<code class='inset'>.toFixed([dp [, rm]]) <i>&rArr; string</i></code>
+    </h5>
+    <p>
+      <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
+      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
+    </p>
+    <p>
+      Returns a string representing the value of this BigNumber in normal (fixed-point) notation
+      rounded to <code>dp</code> decimal places using rounding mode <code>rm</code>.
+    </p>
+    <p>
+      If the value of this BigNumber in normal notation has fewer than <code>dp</code> fraction
+      digits, the return value will be appended with zeros accordingly.
+    </p>
+   <p>
+      Unlike <code>Number.prototype.toFixed</code>, which returns exponential notation if a number
+      is greater or equal to <code>10<sup>21</sup></code>, this method will always return normal
+      notation.
+    </p>
+    <p>
+      If <code>dp</code> is omitted or is <code>null</code> or <code>undefined</code>, the return
+      value will be unrounded and in normal notation. This is also unlike
+      <code>Number.prototype.toFixed</code>, which returns the value to zero decimal places.<br />
+      It is useful when fixed-point notation is required and the current
+      <a href="#exponential-at"><code>EXPONENTIAL_AT</code></a> setting causes
+      <code><a href='#toS'>toString</a></code> to return exponential notation.<br />
+      If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
+      <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.
+    </p>
+    <p>
+      Throws if <code>dp</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>
+x = 3.456
+y = new BigNumber(x)
+x.toFixed()                     // '3'
+y.toFixed()                     // '3.456'
+y.toFixed(0)                    // '3'
+x.toFixed(2)                    // '3.46'
+y.toFixed(2)                    // '3.46'
+y.toFixed(2, 1)                 // '3.45'  (ROUND_DOWN)
+x.toFixed(5)                    // '3.45600'
+y.toFixed(5)                    // '3.45600'</pre>
+
+
+
+    <h5 id="toFor">
+      toFormat<code class='inset'>.toFormat([dp [, rm]]) <i>&rArr; string</i></code>
+    </h5>
+    <p>
+      <code>dp</code>: <i>number</i>: integer, <code>0</code> to <code>1e+9</code> inclusive<br />
+      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
+    </p>
+    <p>
+      <p>
+      Returns a string representing the value of this BigNumber in normal (fixed-point) notation
+      rounded to <code>dp</code> decimal places using rounding mode <code>rm</code>, and formatted
+      according to the properties of the <a href='#format'><code>FORMAT</code></a> object.
+    </p>
+    <p>
+      See the examples below for the properties of the
+      <a href='#format'><code>FORMAT</code></a> object, their types and their usage.
+    </p>
+    <p>
+      If <code>dp</code> is omitted or is <code>null</code> or <code>undefined</code>, then the
+      return value is not rounded to a fixed number of decimal places.<br />
+      If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
+      <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.
+    </p>
+    <p>
+      Throws if <code>dp</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>
+format = {
+    decimalSeparator: '.',
+    groupSeparator: ',',
+    groupSize: 3,
+    secondaryGroupSize: 0,
+    fractionGroupSeparator: ' ',
+    fractionGroupSize: 0
+}
+BigNumber.config({ FORMAT: format })
+
+x = new BigNumber('123456789.123456789')
+x.toFormat()                    // '123,456,789.123456789'
+x.toFormat(1)                   // '123,456,789.1'
+
+// If a reference to the object assigned to FORMAT has been retained,
+// the format properties can be changed directly
+format.groupSeparator = ' '
+format.fractionGroupSize = 5
+x.toFormat()                    // '123 456 789.12345 6789'
+
+BigNumber.config({
+    FORMAT: {
+        decimalSeparator: ',',
+        groupSeparator: '.',
+        groupSize: 3,
+        secondaryGroupSize: 2
+    }
+})
+
+x.toFormat(6)                   // '12.34.56.789,123'</pre>
+
+
+
+    <h5 id="toFr">
+      toFraction<code class='inset'>.toFraction([max]) <i>&rArr; [string, string]</i></code>
+    </h5>
+    <p>
+      <code>max</code>: <i>number|string|BigNumber</i>: integer &gt;= <code>1</code> and &lt;=
+      <code>Infinity</code>
+    </p>
+    <p>
+      Returns a string array representing the value of this BigNumber as a simple fraction with an
+      integer numerator and an integer denominator. The denominator will be a positive non-zero
+      value less than or equal to <code>max</code>.
+    </p>
+    <p>
+      If a maximum denominator, <code>max</code>, is not specified, or is <code>null</code> or
+      <code>undefined</code>, the denominator will be the lowest value necessary to represent the
+      number exactly.
+    </p>
+    <p>
+      Throws if <code>max</code> is invalid. See <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>
+x = new BigNumber(1.75)
+x.toFraction()                  // '7, 4'
+
+pi = new BigNumber('3.14159265358')
+pi.toFraction()                 // '157079632679,50000000000'
+pi.toFraction(100000)           // '312689, 99532'
+pi.toFraction(10000)            // '355, 113'
+pi.toFraction(100)              // '311, 99'
+pi.toFraction(10)               // '22, 7'
+pi.toFraction(1)                // '3, 1'</pre>
+
+
+
+    <h5 id="toJSON">toJSON<code class='inset'>.toJSON() <i>&rArr; string</i></code></h5>
+    <p>As <code>valueOf</code>.</p>
+    <pre>
+x = new BigNumber('177.7e+457')
+y = new BigNumber(235.4325)
+z = new BigNumber('0.0098074')
+
+// Serialize an array of three BigNumbers
+str = JSON.stringify( [x, y, z] )
+// "["1.777e+459","235.4325","0.0098074"]"
+
+// Return an array of three BigNumbers
+JSON.parse(str, function (key, val) {
+    return key === '' ? val : new BigNumber(val)
+})</pre>
+
+
+
+    <h5 id="toN">toNumber<code class='inset'>.toNumber() <i>&rArr; number</i></code></h5>
+    <p>Returns the value of this BigNumber as a JavaScript number primitive.</p>
+    <p>
+      This method is identical to using type coercion with the unary plus operator.
+    </p>
+    <pre>
+x = new BigNumber(456.789)
+x.toNumber()                    // 456.789
++x                              // 456.789
+
+y = new BigNumber('45987349857634085409857349856430985')
+y.toNumber()                    // 4.598734985763409e+34
+
+z = new BigNumber(-0)
+1 / z.toNumber()                // -Infinity
+1 / +z                          // -Infinity</pre>
+
+
+
+    <h5 id="toP">
+      toPrecision<code class='inset'>.toPrecision([sd [, rm]]) <i>&rArr; string</i></code>
+    </h5>
+    <p>
+      <code>sd</code>: <i>number</i>: integer, <code>1</code> to <code>1e+9</code> inclusive<br />
+      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
+    </p>
+    <p>
+      Returns a string representing the value of this BigNumber rounded to <code>sd</code>
+      significant digits using rounding mode <code>rm</code>.
+    </p>
+    <p>
+      If <code>sd</code> is less than the number of digits necessary to represent the integer part
+      of the value in normal (fixed-point) notation, then exponential notation is used.
+    </p>
+    <p>
+      If <code>sd</code> is omitted, or is <code>null</code> or <code>undefined</code>, then the
+      return value is the same as <code>n.toString()</code>.<br />
+      If <code>rm</code> is omitted or is <code>null</code> or <code>undefined</code>,
+      <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> is used.
+    </p>
+    <p>
+      Throws if <code>sd</code> or <code>rm</code> is invalid. See <a href='#Errors'>Errors</a>.
+    </p>
+     <pre>
+x = 45.6
+y = new BigNumber(x)
+x.toPrecision()                 // '45.6'
+y.toPrecision()                 // '45.6'
+x.toPrecision(1)                // '5e+1'
+y.toPrecision(1)                // '5e+1'
+y.toPrecision(2, 0)             // '4.6e+1'  (ROUND_UP)
+y.toPrecision(2, 1)             // '4.5e+1'  (ROUND_DOWN)
+x.toPrecision(5)                // '45.600'
+y.toPrecision(5)                // '45.600'</pre>
+
+
+
+    <h5 id="toS">toString<code class='inset'>.toString([base]) <i>&rArr; string</i></code></h5>
+    <p>
+      <code>base</code>: <i>number</i>: integer, <code>2</code> to <code>ALPHABET.length</code>
+      inclusive (see <a href='#alphabet'><code>ALPHABET</code></a>).
+    </p>
+    <p>
+      Returns a string representing the value of this BigNumber in the specified base, or base
+      <code>10</code> if <code>base</code> is omitted or is <code>null</code> or
+      <code>undefined</code>.
+    </p>
+    <p>
+      For bases above <code>10</code>, and using the default base conversion alphabet
+      (see <a href='#alphabet'><code>ALPHABET</code></a>), values from <code>10</code> to
+      <code>35</code> are represented by <code>a-z</code>
+      (as with <code>Number.prototype.toString</code>).
+    </p>
+    <p>
+      If a base is specified the value is rounded according to the current
+      <a href='#decimal-places'><code>DECIMAL_PLACES</code></a>
+      and <a href='#rounding-mode'><code>ROUNDING_MODE</code></a> settings.
+    </p>
+    <p>
+      If a base is not specified, and this BigNumber has a positive
+      exponent that is equal to or greater than the positive component of the
+      current <a href="#exponential-at"><code>EXPONENTIAL_AT</code></a> setting,
+      or a negative exponent equal to or less than the negative component of the
+      setting, then exponential notation is returned.
+    </p>
+    <p>If <code>base</code> is <code>null</code> or <code>undefined</code> it is ignored.</p>
+    <p>
+      Throws if <code>base</code> is invalid. See <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>
+x = new BigNumber(750000)
+x.toString()                    // '750000'
+BigNumber.config({ EXPONENTIAL_AT: 5 })
+x.toString()                    // '7.5e+5'
+
+y = new BigNumber(362.875)
+y.toString(2)                   // '101101010.111'
+y.toString(9)                   // '442.77777777777777777778'
+y.toString(32)                  // 'ba.s'
+
+BigNumber.config({ DECIMAL_PLACES: 4 });
+z = new BigNumber('1.23456789')
+z.toString()                    // '1.23456789'
+z.toString(10)                  // '1.2346'</pre>
+
+
+
+    <h5 id="valueOf">valueOf<code class='inset'>.valueOf() <i>&rArr; string</i></code></h5>
+    <p>
+      As <code>toString</code>, but does not accept a base argument and includes the minus sign
+      for negative zero.
+    </p>
+    <pre>
+x = new BigNumber('-0')
+x.toString()                    // '0'
+x.valueOf()                     // '-0'
+y = new BigNumber('1.777e+457')
+y.valueOf()                     // '1.777e+457'</pre>
+
+
+
+    <h4 id="instance-properties">Properties</h4>
+    <p>The properties of a BigNumber instance:</p>
+    <table>
+      <tr>
+        <th>Property</th>
+        <th>Description</th>
+        <th>Type</th>
+        <th>Value</th>
+      </tr>
+      <tr>
+        <td class='centre' id='coefficient'><b>c</b></td>
+        <td>coefficient<sup>*</sup></td>
+        <td><i>number</i><code>[]</code></td>
+        <td> Array of base <code>1e14</code> numbers</td>
+      </tr>
+      <tr>
+        <td class='centre' id='exponent'><b>e</b></td>
+        <td>exponent</td>
+        <td><i>number</i></td>
+        <td>Integer, <code>-1000000000</code> to <code>1000000000</code> inclusive</td>
+      </tr>
+      <tr>
+        <td class='centre' id='sign'><b>s</b></td>
+        <td>sign</td>
+        <td><i>number</i></td>
+        <td><code>-1</code> or <code>1</code></td>
+      </tr>
+    </table>
+    <p><sup>*</sup>significand</p>
+    <p>
+      The value of any of the <code>c</code>, <code>e</code> and <code>s</code> properties may also
+      be <code>null</code>.
+    </p>
+    <p>
+      The above properties are best considered to be read-only. In early versions of this library it
+      was okay to change the exponent of a BigNumber by writing to its exponent property directly,
+      but this is no longer reliable as the value of the first element of the coefficient array is
+      now dependent on the exponent.
+    </p>
+    <p>
+      Note that, as with JavaScript numbers, the original exponent and fractional trailing zeros are
+      not necessarily preserved.
+    </p>
+    <pre>x = new BigNumber(0.123)              // '0.123'
+x.toExponential()                     // '1.23e-1'
+x.c                                   // '1,2,3'
+x.e                                   // -1
+x.s                                   // 1
+
+y = new Number(-123.4567000e+2)       // '-12345.67'
+y.toExponential()                     // '-1.234567e+4'
+z = new BigNumber('-123.4567000e+2')  // '-12345.67'
+z.toExponential()                     // '-1.234567e+4'
+z.c                                   // '1,2,3,4,5,6,7'
+z.e                                   // 4
+z.s                                   // -1</pre>
+
+
+
+    <h4 id="zero-nan-infinity">Zero, NaN and Infinity</h4>
+    <p>
+      The table below shows how &plusmn;<code>0</code>, <code>NaN</code> and
+      &plusmn;<code>Infinity</code> are stored.
+    </p>
+    <table>
+      <tr>
+        <th> </th>
+        <th class='centre'>c</th>
+        <th class='centre'>e</th>
+        <th class='centre'>s</th>
+      </tr>
+      <tr>
+        <td>&plusmn;0</td>
+        <td><code>[0]</code></td>
+        <td><code>0</code></td>
+        <td><code>&plusmn;1</code></td>
+      </tr>
+      <tr>
+        <td>NaN</td>
+        <td><code>null</code></td>
+        <td><code>null</code></td>
+        <td><code>null</code></td>
+      </tr>
+      <tr>
+        <td>&plusmn;Infinity</td>
+        <td><code>null</code></td>
+        <td><code>null</code></td>
+        <td><code>&plusmn;1</code></td>
+      </tr>
+    </table>
+    <pre>
+x = new Number(-0)              // 0
+1 / x == -Infinity              // true
+
+y = new BigNumber(-0)           // '0'
+y.c                             // '0' ( [0].toString() )
+y.e                             // 0
+y.s                             // -1</pre>
+
+
+
+    <h4 id='Errors'>Errors</h4>
+    <p>The table below shows the errors that are thrown.</p>
+    <p>
+      The errors are generic <code>Error</code> objects whose message begins
+      <code>'[BigNumber Error]'</code>.
+    </p>
+    <table class='error-table'>
+      <tr>
+        <th>Method</th>
+        <th>Throws</th>
+      </tr>
+      <tr>
+        <td rowspan=6>
+          <code>BigNumber</code><br />
+          <code>comparedTo</code><br />
+          <code>dividedBy</code><br />
+          <code>dividedToIntegerBy</code><br />
+          <code>isEqualTo</code><br />
+          <code>isGreaterThan</code><br />
+          <code>isGreaterThanOrEqualTo</code><br />
+          <code>isLessThan</code><br />
+          <code>isLessThanOrEqualTo</code><br />
+          <code>minus</code><br />
+          <code>modulo</code><br />
+          <code>plus</code><br />
+          <code>multipliedBy</code>
+        </td>
+        <td>Base not a primitive number</td>
+      </tr>
+      <tr>
+        <td>Base not an integer</td>
+      </tr>
+      <tr>
+        <td>Base out of range</td>
+      </tr>
+       <tr>
+        <td>Number primitive has more than 15 significant digits<sup>*</sup></td>
+      </tr>
+      <tr>
+        <td>Not a base... number<sup>*</sup></td>
+      </tr>
+      <tr>
+        <td>Not a number<sup>*</sup></td>
+      </tr>
+      <tr>
+        <td><code>clone</code></td>
+        <td>Object expected</td>
+      </tr>
+      <tr>
+        <td rowspan=24><code>config</code></td>
+        <td>Object expected</td>
+      </tr>
+      <tr>
+        <td><code>DECIMAL_PLACES</code> not a primitive number</td>
+      </tr>
+      <tr>
+        <td><code>DECIMAL_PLACES</code> not an integer</td>
+      </tr>
+      <tr>
+        <td><code>DECIMAL_PLACES</code> out of range</td>
+      </tr>
+      <tr>
+        <td><code>ROUNDING_MODE</code> not a primitive number</td>
+      </tr>
+      <tr>
+        <td><code>ROUNDING_MODE</code> not an integer</td>
+      </tr>
+      <tr>
+        <td><code>ROUNDING_MODE</code> out of range</td>
+      </tr>
+      <tr>
+        <td><code>EXPONENTIAL_AT</code> not a primitive number</td>
+      </tr>
+      <tr>
+        <td><code>EXPONENTIAL_AT</code> not an integer</td>
+      </tr>
+      <tr>
+        <td><code>EXPONENTIAL_AT</code> out of range</td>
+      </tr>
+      <tr>
+        <td><code>RANGE</code> not a primitive number</td>
+      </tr>
+      <tr>
+        <td><code>RANGE</code> not an integer</td>
+      </tr>
+      <tr>
+        <td><code>RANGE</code> cannot be zero</td>
+      </tr>
+      <tr>
+        <td><code>RANGE</code> cannot be zero</td>
+      </tr>
+      <tr>
+        <td><code>CRYPTO</code> not true or false</td>
+      </tr>
+      <tr>
+        <td><code>crypto</code> unavailable</td>
+      </tr>
+      <tr>
+        <td><code>MODULO_MODE</code> not a primitive number</td>
+      </tr>
+      <tr>
+        <td><code>MODULO_MODE</code> not an integer</td>
+      </tr>
+      <tr>
+        <td><code>MODULO_MODE</code> out of range</td>
+      </tr>
+      <tr>
+        <td><code>POW_PRECISION</code> not a primitive number</td>
+      </tr>
+      <tr>
+        <td><code>POW_PRECISION</code> not an integer</td>
+      </tr>
+      <tr>
+        <td><code>POW_PRECISION</code> out of range</td>
+      </tr>
+      <tr>
+        <td><code>FORMAT</code> not an object</td>
+      </tr>
+      <tr>
+        <td><code>ALPHABET</code> invalid</td>
+      </tr>
+      <tr>
+        <td rowspan=3>
+          <code>decimalPlaces</code><br />
+          <code>precision</code><br />
+          <code>random</code><br />
+          <code>shiftedBy</code><br />
+          <code>toExponential</code><br />
+          <code>toFixed</code><br />
+          <code>toFormat</code><br />
+          <code>toPrecision</code>
+        </td>
+        <td>Argument not a primitive number</td>
+      </tr>
+      <tr>
+        <td>Argument not an integer</td>
+      </tr>
+      <tr>
+        <td>Argument out of range</td>
+      </tr>
+      <tr>
+        <td>
+          <code>decimalPlaces</code><br />
+          <code>precision</code>
+        </td>
+        <td>Argument not true or false</td>
+      </tr>
+      <tr>
+        <td><code>exponentiatedBy</code></td>
+        <td>Argument not an integer</td>
+      </tr>
+      <tr>
+        <td>
+          <code>minimum</code><br />
+          <code>maximum</code>
+        </td>
+        <td>Not a number<sup>*</sup></td>
+      </tr>
+      <tr>
+        <td>
+          <code>random</code>
+        </td>
+        <td>crypto unavailable</td>
+      </tr>
+      <tr>
+        <td rowspan=2><code>toFraction</code></td>
+        <td>Argument not an integer</td>
+      </tr>
+      <tr>
+        <td>Argument out of range</td>
+      </tr>
+      <tr>
+        <td rowspan=3><code>toString</code></td>
+        <td>Base not a primitive number</td>
+      </tr>
+      <tr>
+        <td>Base not an integer</td>
+      </tr>
+      <tr>
+        <td>Base out of range</td>
+      </tr>
+    </table>
+    <p><sup>*</sup>Only thrown if <code>BigNumber.DEBUG</code> is <code>true</code>.</p>
+    <p>To determine if an exception is a BigNumber Error:</p>
+    <pre>
+try {
+    // ...
+} catch (e) {
+    if (e instanceof Error && e.message.indexOf('[BigNumber Error]') === 0) {
+        // ...
+    }
+}</pre>
+
+
+
+    <h4 id='faq'>FAQ</h4>
+
+    <h6>Why are trailing fractional zeros removed from BigNumbers?</h6>
+    <p>
+      Some arbitrary-precision libraries retain trailing fractional zeros as they can indicate the
+      precision of a value. This can be useful but the results of arithmetic operations can be
+      misleading.
+    </p>
+    <pre>
+x = new BigDecimal("1.0")
+y = new BigDecimal("1.1000")
+z = x.add(y)                      // 2.1000
+
+x = new BigDecimal("1.20")
+y = new BigDecimal("3.45000")
+z = x.multiply(y)                 // 4.1400000</pre>
+    <p>
+      To specify the precision of a value is to specify that the value lies
+      within a certain range.
+    </p>
+    <p>
+      In the first example, <code>x</code> has a value of <code>1.0</code>. The trailing zero shows
+      the precision of the value, implying that it is in the range <code>0.95</code> to
+      <code>1.05</code>. Similarly, the precision indicated by the trailing zeros of <code>y</code>
+      indicates that the value is in the range <code>1.09995</code> to <code>1.10005</code>.
+    </p>
+    <p>
+      If we  add the two lowest values in the ranges we have, <code>0.95 + 1.09995 = 2.04995</code>,
+      and if we add the two highest values we have, <code>1.05 + 1.10005 = 2.15005</code>, so the
+      range of the result of the addition implied by the precision of its operands is
+      <code>2.04995</code> to <code>2.15005</code>.
+    </p>
+    <p>
+      The result given by BigDecimal of <code>2.1000</code> however, indicates that the value is in
+      the range <code>2.09995</code> to <code>2.10005</code> and therefore the precision implied by
+      its trailing zeros may be misleading.
+    </p>
+    <p>
+      In the second example, the true range is <code>4.122744</code> to <code>4.157256</code> yet
+      the BigDecimal answer of <code>4.1400000</code> indicates a range of <code>4.13999995</code>
+      to  <code>4.14000005</code>. Again, the precision implied by the trailing zeros may be
+      misleading.
+    </p>
+    <p>
+      This library, like binary floating point and most calculators, does not retain trailing
+      fractional zeros. Instead, the <code>toExponential</code>, <code>toFixed</code> and
+      <code>toPrecision</code> methods enable trailing zeros to be added if and when required.<br />
+    </p>
+  </div>
+
+</body>
+</html>

projet/node_modules/bignumber.js/package.json

+{
+  "_args": [
+    [
+      "bignumber.js@7.2.1",
+      "/Users/klaus/Documents/Web/Back/2019_tp2/projet"
+    ]
+  ],
+  "_from": "bignumber.js@7.2.1",
+  "_id": "bignumber.js@7.2.1",
+  "_inBundle": false,
+  "_integrity": "sha512-S4XzBk5sMB+Rcb/LNcpzXr57VRTxgAvaAEDAl1AwRx27j00hT84O6OkteE7u8UB3NuaaygCRrEpqox4uDOrbdQ==",
+  "_location": "/bignumber.js",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "bignumber.js@7.2.1",
+    "name": "bignumber.js",
+    "escapedName": "bignumber.js",
+    "rawSpec": "7.2.1",
+    "saveSpec": null,
+    "fetchSpec": "7.2.1"
+  },
+  "_requiredBy": [
+    "/mysql"
+  ],
+  "_resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-7.2.1.tgz",
+  "_spec": "7.2.1",
+  "_where": "/Users/klaus/Documents/Web/Back/2019_tp2/projet",
+  "author": {
+    "name": "Michael Mclaughlin",
+    "email": "M8ch88l@gmail.com"
+  },
+  "browser": "bignumber.js",
+  "bugs": {
+    "url": "https://github.com/MikeMcl/bignumber.js/issues"
+  },
+  "description": "A library for arbitrary-precision decimal and non-decimal arithmetic",
+  "engines": {
+    "node": "*"
+  },
+  "homepage": "https://github.com/MikeMcl/bignumber.js#readme",
+  "keywords": [
+    "arbitrary",
+    "precision",
+    "arithmetic",
+    "big",
+    "number",
+    "decimal",
+    "float",
+    "biginteger",
+    "bigdecimal",
+    "bignumber",
+    "bigint",
+    "bignum"
+  ],
+  "license": "MIT",
+  "main": "bignumber",
+  "module": "bignumber.mjs",
+  "name": "bignumber.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MikeMcl/bignumber.js.git"
+  },
+  "scripts": {
+    "build": "uglifyjs bignumber.js --source-map bignumber.js.map -c -m -o bignumber.min.js --preamble \"/* bignumber.js v7.2.1 https://github.com/MikeMcl/bignumber.js/LICENCE */\"",
+    "test": "node test/test"
+  },
+  "types": "bignumber.d.ts",
+  "version": "7.2.1"
+}

projet/node_modules/body-parser/HISTORY.md

+1.19.0 / 2019-04-25
+===================
+
+  * deps: bytes@3.1.0
+    - Add petabyte (`pb`) support
+  * deps: http-errors@1.7.2
+    - Set constructor name when possible
+    - deps: setprototypeof@1.1.1
+    - deps: statuses@'>= 1.5.0 < 2'
+  * deps: iconv-lite@0.4.24
+    - Added encoding MIK
+  * deps: qs@6.7.0
+    - Fix parsing array brackets after index
+  * deps: raw-body@2.4.0
+    - deps: bytes@3.1.0
+    - deps: http-errors@1.7.2
+    - deps: iconv-lite@0.4.24
+  * deps: type-is@~1.6.17
+    - deps: mime-types@~2.1.24
+    - perf: prevent internal `throw` on invalid type
+
+1.18.3 / 2018-05-14
+===================
+
+  * Fix stack trace for strict json parse error
+  * deps: depd@~1.1.2
+    - perf: remove argument reassignment
+  * deps: http-errors@~1.6.3
+    - deps: depd@~1.1.2
+    - deps: setprototypeof@1.1.0
+    - deps: statuses@'>= 1.3.1 < 2'
+  * deps: iconv-lite@0.4.23
+    - Fix loading encoding with year appended
+    - Fix deprecation warnings on Node.js 10+
+  * deps: qs@6.5.2
+  * deps: raw-body@2.3.3
+    - deps: http-errors@1.6.3
+    - deps: iconv-lite@0.4.23
+  * deps: type-is@~1.6.16
+    - deps: mime-types@~2.1.18
+
+1.18.2 / 2017-09-22
+===================
+
+  * deps: debug@2.6.9
+  * perf: remove argument reassignment
+
+1.18.1 / 2017-09-12
+===================
+
+  * deps: content-type@~1.0.4
+    - perf: remove argument reassignment
+    - perf: skip parameter parsing when no parameters
+  * deps: iconv-lite@0.4.19
+    - Fix ISO-8859-1 regression
+    - Update Windows-1255
+  * deps: qs@6.5.1
+    - Fix parsing & compacting very deep objects
+  * deps: raw-body@2.3.2
+    - deps: iconv-lite@0.4.19
+
+1.18.0 / 2017-09-08
+===================
+
+  * Fix JSON strict violation error to match native parse error
+  * Include the `body` property on verify errors
+  * Include the `type` property on all generated errors
+  * Use `http-errors` to set status code on errors
+  * deps: bytes@3.0.0
+  * deps: debug@2.6.8
+  * deps: depd@~1.1.1
+    - Remove unnecessary `Buffer` loading
+  * deps: http-errors@~1.6.2
+    - deps: depd@1.1.1
+  * deps: iconv-lite@0.4.18
+    - Add support for React Native
+    - Add a warning if not loaded as utf-8
+    - Fix CESU-8 decoding in Node.js 8
+    - Improve speed of ISO-8859-1 encoding
+  * deps: qs@6.5.0
+  * deps: raw-body@2.3.1
+    - Use `http-errors` for standard emitted errors
+    - deps: bytes@3.0.0
+    - deps: iconv-lite@0.4.18
+    - perf: skip buffer decoding on overage chunk
+  * perf: prevent internal `throw` when missing charset
+
+1.17.2 / 2017-05-17
+===================
+
+  * deps: debug@2.6.7
+    - Fix `DEBUG_MAX_ARRAY_LENGTH`
+    - deps: ms@2.0.0
+  * deps: type-is@~1.6.15
+    - deps: mime-types@~2.1.15
+
+1.17.1 / 2017-03-06
+===================
+
+  * deps: qs@6.4.0
+    - Fix regression parsing keys starting with `[`
+
+1.17.0 / 2017-03-01
+===================
+
+  * deps: http-errors@~1.6.1
+    - Make `message` property enumerable for `HttpError`s
+    - deps: setprototypeof@1.0.3
+  * deps: qs@6.3.1
+    - Fix compacting nested arrays
+
+1.16.1 / 2017-02-10
+===================
+
+  * deps: debug@2.6.1
+    - Fix deprecation messages in WebStorm and other editors
+    - Undeprecate `DEBUG_FD` set to `1` or `2`
+
+1.16.0 / 2017-01-17
+===================
+
+  * deps: debug@2.6.0
+    - Allow colors in workers
+    - Deprecated `DEBUG_FD` environment variable
+    - Fix error when running under React Native
+    - Use same color for same namespace
+    - deps: ms@0.7.2
+  * deps: http-errors@~1.5.1
+    - deps: inherits@2.0.3
+    - deps: setprototypeof@1.0.2
+    - deps: statuses@'>= 1.3.1 < 2'
+  * deps: iconv-lite@0.4.15
+    - Added encoding MS-31J
+    - Added encoding MS-932
+    - Added encoding MS-936
+    - Added encoding MS-949
+    - Added encoding MS-950
+    - Fix GBK/GB18030 handling of Euro character
+  * deps: qs@6.2.1
+    - Fix array parsing from skipping empty values
+  * deps: raw-body@~2.2.0
+    - deps: iconv-lite@0.4.15
+  * deps: type-is@~1.6.14
+    - deps: mime-types@~2.1.13
+
+1.15.2 / 2016-06-19
+===================
+
+  * deps: bytes@2.4.0
+  * deps: content-type@~1.0.2
+    - perf: enable strict mode
+  * deps: http-errors@~1.5.0
+    - Use `setprototypeof` module to replace `__proto__` setting
+    - deps: statuses@'>= 1.3.0 < 2'
+    - perf: enable strict mode
+  * deps: qs@6.2.0
+  * deps: raw-body@~2.1.7
+    - deps: bytes@2.4.0
+    - perf: remove double-cleanup on happy path
+  * deps: type-is@~1.6.13
+    - deps: mime-types@~2.1.11
+
+1.15.1 / 2016-05-05
+===================
+
+  * deps: bytes@2.3.0
+    - Drop partial bytes on all parsed units
+    - Fix parsing byte string that looks like hex
+  * deps: raw-body@~2.1.6
+    - deps: bytes@2.3.0
+  * deps: type-is@~1.6.12
+    - deps: mime-types@~2.1.10
+
+1.15.0 / 2016-02-10
+===================
+
+  * deps: http-errors@~1.4.0
+    - Add `HttpError` export, for `err instanceof createError.HttpError`
+    - deps: inherits@2.0.1
+    - deps: statuses@'>= 1.2.1 < 2'
+  * deps: qs@6.1.0
+  * deps: type-is@~1.6.11
+    - deps: mime-types@~2.1.9
+
+1.14.2 / 2015-12-16
+===================
+
+  * deps: bytes@2.2.0
+  * deps: iconv-lite@0.4.13
+  * deps: qs@5.2.0
+  * deps: raw-body@~2.1.5
+    - deps: bytes@2.2.0
+    - deps: iconv-lite@0.4.13
+  * deps: type-is@~1.6.10
+    - deps: mime-types@~2.1.8
+
+1.14.1 / 2015-09-27
+===================
+
+  * Fix issue where invalid charset results in 400 when `verify` used
+  * deps: iconv-lite@0.4.12
+    - Fix CESU-8 decoding in Node.js 4.x
+  * deps: raw-body@~2.1.4
+    - Fix masking critical errors from `iconv-lite`
+    - deps: iconv-lite@0.4.12
+  * deps: type-is@~1.6.9
+    - deps: mime-types@~2.1.7
+
+1.14.0 / 2015-09-16
+===================
+
+  * Fix JSON strict parse error to match syntax errors
+  * Provide static `require` analysis in `urlencoded` parser
+  * deps: depd@~1.1.0
+    - Support web browser loading
+  * deps: qs@5.1.0
+  * deps: raw-body@~2.1.3
+    - Fix sync callback when attaching data listener causes sync read
+  * deps: type-is@~1.6.8
+    - Fix type error when given invalid type to match against
+    - deps: mime-types@~2.1.6
+
+1.13.3 / 2015-07-31
+===================
+
+  * deps: type-is@~1.6.6
+    - deps: mime-types@~2.1.4
+
+1.13.2 / 2015-07-05
+===================
+
+  * deps: iconv-lite@0.4.11
+  * deps: qs@4.0.0
+    - Fix dropping parameters like `hasOwnProperty`
+    - Fix user-visible incompatibilities from 3.1.0
+    - Fix various parsing edge cases
+  * deps: raw-body@~2.1.2
+    - Fix error stack traces to skip `makeError`
+    - deps: iconv-lite@0.4.11
+  * deps: type-is@~1.6.4
+    - deps: mime-types@~2.1.2
+    - perf: enable strict mode
+    - perf: remove argument reassignment
+
+1.13.1 / 2015-06-16
+===================
+
+  * deps: qs@2.4.2
+    - Downgraded from 3.1.0 because of user-visible incompatibilities
+
+1.13.0 / 2015-06-14
+===================
+
+  * Add `statusCode` property on `Error`s, in addition to `status`
+  * Change `type` default to `application/json` for JSON parser
+  * Change `type` default to `application/x-www-form-urlencoded` for urlencoded parser
+  * Provide static `require` analysis
+  * Use the `http-errors` module to generate errors
+  * deps: bytes@2.1.0
+    - Slight optimizations
+  * deps: iconv-lite@0.4.10
+    - The encoding UTF-16 without BOM now defaults to UTF-16LE when detection fails
+    - Leading BOM is now removed when decoding
+  * deps: on-finished@~2.3.0
+    - Add defined behavior for HTTP `CONNECT` requests
+    - Add defined behavior for HTTP `Upgrade` requests
+    - deps: ee-first@1.1.1
+  * deps: qs@3.1.0
+    - Fix dropping parameters like `hasOwnProperty`
+    - Fix various parsing edge cases
+    - Parsed object now has `null` prototype
+  * deps: raw-body@~2.1.1
+    - Use `unpipe` module for unpiping requests
+    - deps: iconv-lite@0.4.10
+  * deps: type-is@~1.6.3
+    - deps: mime-types@~2.1.1
+    - perf: reduce try block size
+    - perf: remove bitwise operations
+  * perf: enable strict mode
+  * perf: remove argument reassignment
+  * perf: remove delete call
+
+1.12.4 / 2015-05-10
+===================
+
+  * deps: debug@~2.2.0
+  * deps: qs@2.4.2
+    - Fix allowing parameters like `constructor`
+  * deps: on-finished@~2.2.1
+  * deps: raw-body@~2.0.1
+    - Fix a false-positive when unpiping in Node.js 0.8
+    - deps: bytes@2.0.1
+  * deps: type-is@~1.6.2
+    - deps: mime-types@~2.0.11
+
+1.12.3 / 2015-04-15
+===================
+
+  * Slight efficiency improvement when not debugging
+  * deps: depd@~1.0.1
+  * deps: iconv-lite@0.4.8
+    - Add encoding alias UNICODE-1-1-UTF-7
+  * deps: raw-body@1.3.4
+    - Fix hanging callback if request aborts during read
+    - deps: iconv-lite@0.4.8
+
+1.12.2 / 2015-03-16
+===================
+
+  * deps: qs@2.4.1
+    - Fix error when parameter `hasOwnProperty` is present
+
+1.12.1 / 2015-03-15
+===================
+
+  * deps: debug@~2.1.3
+    - Fix high intensity foreground color for bold
+    - deps: ms@0.7.0
+  * deps: type-is@~1.6.1
+    - deps: mime-types@~2.0.10
+
+1.12.0 / 2015-02-13
+===================
+
+  * add `debug` messages
+  * accept a function for the `type` option
+  * use `content-type` to parse `Content-Type` headers
+  * deps: iconv-lite@0.4.7
+    - Gracefully support enumerables on `Object.prototype`
+  * deps: raw-body@1.3.3
+    - deps: iconv-lite@0.4.7
+  * deps: type-is@~1.6.0
+    - fix argument reassignment
+    - fix false-positives in `hasBody` `Transfer-Encoding` check
+    - support wildcard for both type and subtype (`*/*`)
+    - deps: mime-types@~2.0.9
+
+1.11.0 / 2015-01-30
+===================
+
+  * make internal `extended: true` depth limit infinity
+  * deps: type-is@~1.5.6
+    - deps: mime-types@~2.0.8
+
+1.10.2 / 2015-01-20
+===================
+
+  * deps: iconv-lite@0.4.6
+    - Fix rare aliases of single-byte encodings
+  * deps: raw-body@1.3.2
+    - deps: iconv-lite@0.4.6
+
+1.10.1 / 2015-01-01
+===================
+
+  * deps: on-finished@~2.2.0
+  * deps: type-is@~1.5.5
+    - deps: mime-types@~2.0.7
+
+1.10.0 / 2014-12-02
+===================
+
+  * make internal `extended: true` array limit dynamic
+
+1.9.3 / 2014-11-21
+==================
+
+  * deps: iconv-lite@0.4.5
+    - Fix Windows-31J and X-SJIS encoding support
+  * deps: qs@2.3.3
+    - Fix `arrayLimit` behavior
+  * deps: raw-body@1.3.1
+    - deps: iconv-lite@0.4.5
+  * deps: type-is@~1.5.3
+    - deps: mime-types@~2.0.3
+
+1.9.2 / 2014-10-27
+==================
+
+  * deps: qs@2.3.2
+    - Fix parsing of mixed objects and values
+
+1.9.1 / 2014-10-22
+==================
+
+  * deps: on-finished@~2.1.1
+    - Fix handling of pipelined requests
+  * deps: qs@2.3.0
+    - Fix parsing of mixed implicit and explicit arrays
+  * deps: type-is@~1.5.2
+    - deps: mime-types@~2.0.2
+
+1.9.0 / 2014-09-24
+==================
+
+  * include the charset in "unsupported charset" error message
+  * include the encoding in "unsupported content encoding" error message
+  * deps: depd@~1.0.0
+
+1.8.4 / 2014-09-23
+==================
+
+  * fix content encoding to be case-insensitive
+
+1.8.3 / 2014-09-19
+==================
+
+  * deps: qs@2.2.4
+    - Fix issue with object keys starting with numbers truncated
+
+1.8.2 / 2014-09-15
+==================
+
+  * deps: depd@0.4.5
+
+1.8.1 / 2014-09-07
+==================
+
+  * deps: media-typer@0.3.0
+  * deps: type-is@~1.5.1
+
+1.8.0 / 2014-09-05
+==================
+
+  * make empty-body-handling consistent between chunked requests
+    - empty `json` produces `{}`
+    - empty `raw` produces `new Buffer(0)`
+    - empty `text` produces `''`
+    - empty `urlencoded` produces `{}`
+  * deps: qs@2.2.3
+    - Fix issue where first empty value in array is discarded
+  * deps: type-is@~1.5.0
+    - fix `hasbody` to be true for `content-length: 0`
+
+1.7.0 / 2014-09-01
+==================
+
+  * add `parameterLimit` option to `urlencoded` parser
+  * change `urlencoded` extended array limit to 100
+  * respond with 413 when over `parameterLimit` in `urlencoded`
+
+1.6.7 / 2014-08-29
+==================
+
+  * deps: qs@2.2.2
+    - Remove unnecessary cloning
+
+1.6.6 / 2014-08-27
+==================
+
+  * deps: qs@2.2.0
+    - Array parsing fix
+    - Performance improvements
+
+1.6.5 / 2014-08-16
+==================
+
+  * deps: on-finished@2.1.0
+
+1.6.4 / 2014-08-14
+==================
+
+  * deps: qs@1.2.2
+
+1.6.3 / 2014-08-10
+==================
+
+  * deps: qs@1.2.1
+
+1.6.2 / 2014-08-07
+==================
+
+  * deps: qs@1.2.0
+    - Fix parsing array of objects
+
+1.6.1 / 2014-08-06
+==================
+
+  * deps: qs@1.1.0
+    - Accept urlencoded square brackets
+    - Accept empty values in implicit array notation
+
+1.6.0 / 2014-08-05
+==================
+
+  * deps: qs@1.0.2
+    - Complete rewrite
+    - Limits array length to 20
+    - Limits object depth to 5
+    - Limits parameters to 1,000
+
+1.5.2 / 2014-07-27
+==================
+
+  * deps: depd@0.4.4
+    - Work-around v8 generating empty stack traces
+
+1.5.1 / 2014-07-26
+==================
+
+  * deps: depd@0.4.3
+    - Fix exception when global `Error.stackTraceLimit` is too low
+
+1.5.0 / 2014-07-20
+==================
+
+  * deps: depd@0.4.2
+    - Add `TRACE_DEPRECATION` environment variable
+    - Remove non-standard grey color from color output
+    - Support `--no-deprecation` argument
+    - Support `--trace-deprecation` argument
+  * deps: iconv-lite@0.4.4
+    - Added encoding UTF-7
+  * deps: raw-body@1.3.0
+    - deps: iconv-lite@0.4.4
+    - Added encoding UTF-7
+    - Fix `Cannot switch to old mode now` error on Node.js 0.10+
+  * deps: type-is@~1.3.2
+
+1.4.3 / 2014-06-19
+==================
+
+  * deps: type-is@1.3.1
+    - fix global variable leak
+
+1.4.2 / 2014-06-19
+==================
+
+  * deps: type-is@1.3.0
+    - improve type parsing
+
+1.4.1 / 2014-06-19
+==================
+
+  * fix urlencoded extended deprecation message
+
+1.4.0 / 2014-06-19
+==================
+
+  * add `text` parser
+  * add `raw` parser
+  * check accepted charset in content-type (accepts utf-8)
+  * check accepted encoding in content-encoding (accepts identity)
+  * deprecate `bodyParser()` middleware; use `.json()` and `.urlencoded()` as needed
+  * deprecate `urlencoded()` without provided `extended` option
+  * lazy-load urlencoded parsers
+  * parsers split into files for reduced mem usage
+  * support gzip and deflate bodies
+    - set `inflate: false` to turn off
+  * deps: raw-body@1.2.2
+    - Support all encodings from `iconv-lite`
+
+1.3.1 / 2014-06-11
+==================
+
+  * deps: type-is@1.2.1
+    - Switch dependency from mime to mime-types@1.0.0
+
+1.3.0 / 2014-05-31
+==================
+
+  * add `extended` option to urlencoded parser
+
+1.2.2 / 2014-05-27
+==================
+
+  * deps: raw-body@1.1.6
+    - assert stream encoding on node.js 0.8
+    - assert stream encoding on node.js < 0.10.6
+    - deps: bytes@1
+
+1.2.1 / 2014-05-26
+==================
+
+  * invoke `next(err)` after request fully read
+    - prevents hung responses and socket hang ups
+
+1.2.0 / 2014-05-11
+==================
+
+  * add `verify` option
+  * deps: type-is@1.2.0
+    - support suffix matching
+
+1.1.2 / 2014-05-11
+==================
+
+  * improve json parser speed
+
+1.1.1 / 2014-05-11
+==================
+
+  * fix repeated limit parsing with every request
+
+1.1.0 / 2014-05-10
+==================
+
+  * add `type` option
+  * deps: pin for safety and consistency
+
+1.0.2 / 2014-04-14
+==================
+
+  * use `type-is` module
+
+1.0.1 / 2014-03-20
+==================
+
+  * lower default limits to 100kb