node

js/Office/Poll.js

@@ -185,7 +185,7 @@ U.MD.O.P.pollingAsyn = function (r) {
                     //     }
                     //    else 
                        if ($('#mindNetwork' + _message.messageInfo.docId).css('display') == 'block') {
-                            switch (_message.messageInfo.type) {// 判断消息种类
+                            switch (_message.messageInfo.type2) {// 判断消息种类
                                 case 'update':
                                     _contentWindow.postMessage({ info: _message.messageInfo, type: "mindNetwork_update" }, "*")
                                     break;

node/node_modules/bignumber.js/CHANGELOG.md

@@ -0,0 +1,266 @@
+#### 9.0.0
+* 27/05/2019
+* For compatibility with legacy browsers, remove `Symbol` references.
+
+#### 8.1.1
+* 24/02/2019
+* [BUGFIX] #222 Restore missing `var` to `export BigNumber`.
+* Allow any key in BigNumber.Instance in *bignumber.d.ts*.
+
+#### 8.1.0
+* 23/02/2019
+* [NEW FEATURE] #220 Create a BigNumber using `{s, e, c}`.
+* [NEW FEATURE] `isBigNumber`: if `BigNumber.DEBUG` is `true`, also check that the BigNumber instance is well-formed.
+* Remove `instanceof` checks; just use `_isBigNumber` to identify a BigNumber instance.
+* Add `_isBigNumber` to prototype in *bignumber.mjs*.
+* Add tests for BigNumber creation from object.
+* Update *API.html*.
+
+#### 8.0.2
+* 13/01/2019
+* #209 `toPrecision` without argument should follow `toString`.
+* Improve *Use* section of *README*.
+* Optimise `toString(10)`.
+* Add verson number to API doc.
+
+#### 8.0.1
+* 01/11/2018
+* Rest parameter must be array type in *bignumber.d.ts*.
+
+#### 8.0.0
+* 01/11/2018
+* [NEW FEATURE] Add `BigNumber.sum` method.
+* [NEW FEATURE]`toFormat`: add `prefix` and `suffix` options.
+* [NEW FEATURE] #178 Pass custom formatting to `toFormat`.
+* [BREAKING CHANGE] #184 `toFraction`: return array of BigNumbers not strings.
+* [NEW FEATURE] #185 Enable overwrite of `valueOf` to prevent accidental addition to string.
+* #183 Add Node.js `crypto` requirement to documentation.
+* [BREAKING CHANGE] #198 Disallow signs and whitespace in custom alphabet.
+* [NEW FEATURE] #188 Implement `util.inspect.custom` for Node.js REPL.
+* #170 Make `isBigNumber` a type guard in *bignumber.d.ts*.
+* [BREAKING CHANGE] `BigNumber.min` and `BigNumber.max`: don't accept an array.
+* Update *.travis.yml*.
+* Remove *bower.json*.
+
+#### 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

node/node_modules/bignumber.js/LICENCE

@@ -0,0 +1,23 @@
+The MIT Licence.
+
+Copyright (c) 2019 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.
+

node/node_modules/bignumber.js/README.md

@@ -0,0 +1,268 @@
+![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 bignumber.js
+```
+
+```javascript
+const BigNumber = require('bignumber.js');
+```
+
+ES6 module:
+
+```javascript
+import BigNumber from "./bignumber.mjs"
+```
+
+AMD loader libraries such as [requireJS](http://requirejs.org/):
+
+```javascript
+require(['bignumber'], function(BigNumber) {
+    // Use BigNumber here in local scope. No global BigNumber.
+});
+```
+
+## Use
+
+The library exports a single constructor function, [`BigNumber`](http://mikemcl.github.io/bignumber.js/#bignumber), which accepts a value of type Number, String or BigNumber,
+
+```javascript
+let x = new BigNumber(123.4567);
+let y = BigNumber('123456.7e-3');
+let z = new BigNumber(x);
+x.isEqualTo(y) && y.isEqualTo(z) && x.isEqualTo(z);      // true
+```
+
+To get the string value of a BigNumber use [`toString()`](http://mikemcl.github.io/bignumber.js/#toS) or [`toFixed()`](http://mikemcl.github.io/bignumber.js/#toFix). Using `toFixed()` prevents exponential notation being returned, no matter how large or small the value.
+
+```javascript
+let x = new BigNumber('1111222233334444555566');
+x.toString();                       // "1.111222233334444555566e+21"
+x.toFixed();                        // "1111222233334444555566"
+```
+
+If the limited precision of Number values is not well understood, it is recommended to create BigNumbers from String values rather than Number values to avoid a potential loss of precision.
+
+*In all further examples below, `let`, 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.*
+
+```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'
+```
+
+When creating a BigNumber from a Number, 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)
+```
+
+BigNumbers can be created from values in bases from 2 to 36. See [`ALPHABET`](http://mikemcl.github.io/bignumber.js/#alphabet) to extend this range.
+
+```javascript
+a = new BigNumber(1011, 2)          // "11"
+b = new BigNumber('zz.9', 36)       // "1295.25"
+c = a.plus(b)                       // "1306.25"
+```
+
+Performance is better if base 10 is NOT specified for decimal values. Only specify base 10 when it is desired that the number of decimal places of the input value be limited to the current [`DECIMAL_PLACES`](http://mikemcl.github.io/bignumber.js/#decimal-places) setting.
+
+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`](http://mikemcl.github.io/bignumber.js/#toE), [`toFixed`](http://mikemcl.github.io/bignumber.js/#toFix) and [`toPrecision`](http://mikemcl.github.io/bignumber.js/#toP) 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
+```
+
+ A base can be specified for [`toString`](http://mikemcl.github.io/bignumber.js/#toS). Performance is better if base 10 is NOT specified, i.e. use `toString()` not `toString(10)`. Only specify base 10 when it is desired that the number of decimal places be limited to the current [`DECIMAL_PLACES`](http://mikemcl.github.io/bignumber.js/#decimal-places) setting.
+
+ ```javascript
+ x.toString(16)                     // "ff.8"
+ ```
+
+There is a [`toFormat`](http://mikemcl.github.io/bignumber.js/#toFor) 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 `set` or `config` method of the `BigNumber` constructor.
+
+The other arithmetic operations always give the exact result.
+
+```javascript
+BigNumber.set({ 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`](http://mikemcl.github.io/bignumber.js/#toFr) 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`](http://mikemcl.github.io/bignumber.js/#isNaN) and [`isFinite`](http://mikemcl.github.io/bignumber.js/#isF) 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.
+
+```javascript
+// Set DECIMAL_PLACES for the original BigNumber constructor
+BigNumber.set({ 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 further 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*.
+
+## 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).

node/node_modules/bignumber.js/bignumber.d.ts

@@ -0,0 +1,1829 @@
+// Type definitions for bignumber.js >=8.1.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.ModuloMode
+//   type      BigNumber.RoundingMOde
+//   type      BigNumber.Value
+//   interface BigNumber.Config
+//   interface BigNumber.Format
+//   interface BigNumber.Instance
+//
+// Example:
+//
+//   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);
+//
+// The use of compiler option `--strictNullChecks` is recommended.
+
+export default BigNumber;
+
+export namespace BigNumber {
+
+  /** See `BigNumber.config` (alias `BigNumber.set`) and `BigNumber.clone`. */
+  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
+     * // Node.js
+     * global.crypto = require('crypto')
+     *
+     * 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: {
+     *     // string to prepend
+     *     prefix: '',
+     *     // 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,
+     *     // string to append
+     *     suffix: ''
+     *   }
+     * })
+     * ```
+     */
+    FORMAT?: BigNumber.Format;
+
+    /**
+     * 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 BigNumber constructor or `toString`.
+     *
+     * Default value: `'0123456789abcdefghijklmnopqrstuvwxyz'`.
+     *
+     * There is no maximum length for the alphabet, but it must be at least 2 characters long,
+     * and it must not contain whitespace or a repeated character, or the sign indicators '+' and
+     * '-', or the decimal separator '.'.
+     *
+     * ```ts
+     * // duodecimal (base 12)
+     * BigNumber.config({ ALPHABET: '0123456789TE' })
+     * x = new BigNumber('T', 12)
+     * x.toString()                // '10'
+     * x.toString(12)              // 'T'
+     * ```
+     */
+    ALPHABET?: string;
+  }
+
+  /** See `FORMAT` and `toFormat`. */
+  interface Format {
+
+    /** The string to prepend. */
+    prefix?: string;
+
+    /** 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;
+
+    /** The string to append. */
+    suffix?: string;
+  }
+
+  interface Instance {
+
+    /** The coefficient of the value of this BigNumber, an array of base 1e14 integer numbers, or null. */
+    readonly c: number[] | null;
+
+    /** The exponent of the value of this BigNumber, an integer number, -1000000000 to 1000000000, or null. */
+    readonly e: number | null;
+
+    /** The sign of the value of this BigNumber, -1, 1, or null. */
+    readonly s: number | null;
+
+    [key: string]: any;
+  }
+
+  type Constructor = typeof BigNumber;
+  type ModuloMode = 0 | 1 | 3 | 6 | 9;
+  type RoundingMode = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+  type Value = string | number | Instance;
+}
+
+export declare class BigNumber implements BigNumber.Instance {
+
+  /** Used internally to identify a BigNumber instance. */
+  private readonly _isBigNumber: true;
+
+  /** The coefficient of the value of this BigNumber, an array of base 1e14 integer numbers, or null. */
+  readonly c: number[] | null;
+
+  /** The exponent of the value of this BigNumber, an integer number, -1000000000 to 1000000000, or null. */
+  readonly e: number | null;
+
+  /** The sign of the value of this BigNumber, -1, 1, or null. */
+  readonly s: number | null;
+
+  /**
+   * 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)
+   * ```
+   *
+   * A BigNumber can also be created from an object literal.
+   * Use `isBigNumber` to check that it is well-formed.
+   *
+   * ```ts
+   * new BigNumber({ s: 1, e: 2, c: [ 777, 12300000000000 ], _isBigNumber: true })    // '777.123'
+   * ```
+   *
+   * @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: BigNumber.Value, m?: BigNumber.Value): BigNumber;
+  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: BigNumber.Value, m?: BigNumber.Value): BigNumber;
+  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;
+  toExponential(): 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;
+  toFixed(): 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` or `FORMAT` object.
+   *
+   * The formatting object may contain some or all of the properties 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.
+   *
+   * If `format` is omitted or is `null` or `undefined`, `FORMAT` is used.
+   *
+   * Throws if `decimalPlaces`, `roundingMode`, or `format` is invalid.
+   *
+   * ```ts
+   * fmt = {
+   *   decimalSeparator: '.',
+   *   groupSeparator: ',',
+   *   groupSize: 3,
+   *   secondaryGroupSize: 0,
+   *   fractionGroupSeparator: ' ',
+   *   fractionGroupSize: 0
+   * }
+   *
+   * x = new BigNumber('123456789.123456789')
+   *
+   * // Set the global formatting options
+   * BigNumber.config({ FORMAT: fmt })
+   *
+   * x.toFormat()                              // '123,456,789.123456789'
+   * x.toFormat(3)                             // '123,456,789.123'
+   *
+   * // If a reference to the object assigned to FORMAT has been retained,
+   * // the format properties can be changed directly
+   * fmt.groupSeparator = ' '
+   * fmt.fractionGroupSize = 5
+   * x.toFormat()                              // '123 456 789.12345 6789'
+   *
+   * // Alternatively, pass the formatting options as an argument
+   * fmt = {
+   *   decimalSeparator: ',',
+   *   groupSeparator: '.',
+   *   groupSize: 3,
+   *   secondaryGroupSize: 2
+   * }
+   *
+   * x.toFormat()                              // '123 456 789.12345 6789'
+   * x.toFormat(fmt)                           // '12.34.56.789,123456789'
+   * x.toFormat(2, fmt)                        // '12.34.56.789,12'
+   * x.toFormat(3, BigNumber.ROUND_UP, fmt)    // '12.34.56.789,124'
+   * ```
+   *
+   * @param [decimalPlaces] Decimal places, integer, 0 to 1e+9.
+   * @param [roundingMode] Rounding mode, integer, 0 to 8.
+   * @param [format] Formatting options object. See `BigNumber.Format`.
+   */
+  toFormat(decimalPlaces: number, roundingMode: BigNumber.RoundingMode, format?: BigNumber.Format): string;
+  toFormat(decimalPlaces: number, roundingMode?: BigNumber.RoundingMode): string;
+  toFormat(decimalPlaces?: number): string;
+  toFormat(decimalPlaces: number, format: BigNumber.Format): string;
+  toFormat(format: BigNumber.Format): string;
+
+  /**
+   * Returns an array of two BigNumbers 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, 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;
+  toPrecision(): 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;
+
+  /** 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
+   * if the BigNumber constructor receives an invalid `BigNumber.Value`, or if `BigNumber.isBigNumber`
+   * receives a BigNumber instance that is malformed.
+   *
+   * ```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'
+   * ```
+   *
+   * Check that a BigNumber instance is well-formed:
+   *
+   * ```ts
+   * x = new BigNumber(10)
+   *
+   * BigNumber.DEBUG = false
+   * // Change x.c to an illegitimate value.
+   * x.c = NaN
+   * // No error, as BigNumber.DEBUG is false.
+   * BigNumber.isBigNumber(x)    // true
+   *
+   * BigNumber.DEBUG = true
+   * BigNumber.isBigNumber(x)    // '[BigNumber Error] Invalid BigNumber'
+   * ```
+   */
+  static DEBUG?: boolean;
+
+  /**
+   * 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`.
+   *
+   * If `BigNumber.DEBUG` is `true`, throws if a BigNumber instance is not well-formed.
+   *
+   * ```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): value is BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the maximum of the arguments.
+   *
+   * 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.apply(null, arr)            // '14'
+   * ```
+   *
+   * @param n A numeric value.
+   */
+  static maximum(...n: BigNumber.Value[]): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the maximum of the arguments.
+   *
+   * 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.apply(null, arr)            // '14'
+   * ```
+   *
+   * @param n A numeric value.
+   */
+  static max(...n: BigNumber.Value[]): BigNumber;
+
+  /**
+   * Returns a BigNumber whose value is the minimum of the arguments.
+   *
+   * 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.apply(null, 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.
+   *
+   * 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.apply(null, 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).
+   *
+   * To be able to set `CRYPTO` to true when using Node.js, the `crypto` object must be available
+   * globally:
+   *
+   * ```ts
+   * global.crypto = require('crypto')
+   * ```
+   *
+   * 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;
+
+  /**
+   * Returns a BigNumber whose value is the sum of the arguments.
+   *
+   * The return value is always exact and unrounded.
+   *
+   * ```ts
+   * x = new BigNumber('3257869345.0378653')
+   * BigNumber.sum(4e9, x, '123456789.9')      // '7381326134.9378653'
+   *
+   * arr = [2, new BigNumber(14), '15.9999', 12]
+   * BigNumber.sum.apply(null, arr)            // '43.9999'
+   * ```
+   *
+   * @param n A numeric value.
+   */
+  static sum(...n: BigNumber.Value[]): 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;
+}

node/node_modules/bignumber.js/bignumber.js

@@ -0,0 +1,2902 @@
+;(function (globalObject) {
+  'use strict';
+
+/*
+ *      bignumber.js v9.0.0
+ *      A JavaScript library for arbitrary-precision arithmetic.
+ *      https://github.com/MikeMcl/bignumber.js
+ *      Copyright (c) 2019 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                      |  sum
+ *      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 = {
+        prefix: '',
+        groupSize: 3,
+        secondaryGroupSize: 0,
+        groupSeparator: ',',
+        decimalSeparator: '.',
+        fractionGroupSize: 0,
+        fractionGroupSeparator: '\xA0',      // non-breaking space
+        suffix: ''
+      },
+
+      // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',
+      // '-', '.', whitespace, or repeated character.
+      // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
+      ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+
+
+    //------------------------------------------------------------------------------------------
+
+
+    // CONSTRUCTOR
+
+
+    /*
+     * The BigNumber constructor and exported function.
+     * Create and return a new instance of a BigNumber object.
+     *
+     * v {number|string|BigNumber} A numeric value.
+     * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.
+     */
+    function BigNumber(v, b) {
+      var alphabet, c, caseChanged, e, i, isNum, len, str,
+        x = this;
+
+      // Enable constructor call without `new`.
+      if (!(x instanceof BigNumber)) return new BigNumber(v, b);
+
+      if (b == null) {
+
+        if (v && v._isBigNumber === true) {
+          x.s = v.s;
+
+          if (!v.c || v.e > MAX_EXP) {
+            x.c = x.e = null;
+          } else if (v.e < MIN_EXP) {
+            x.c = [x.e = 0];
+          } else {
+            x.e = v.e;
+            x.c = v.c.slice();
+          }
+
+          return;
+        }
+
+        if ((isNum = typeof v == 'number') && v * 0 == 0) {
+
+          // Use `1 / n` to handle minus zero also.
+          x.s = 1 / v < 0 ? (v = -v, -1) : 1;
+
+          // Fast path for integers, where n < 2147483648 (2**31).
+          if (v === ~~v) {
+            for (e = 0, i = v; i >= 10; i /= 10, e++);
+
+            if (e > MAX_EXP) {
+              x.c = x.e = null;
+            } else {
+              x.e = e;
+              x.c = [v];
+            }
+
+            return;
+          }
+
+          str = String(v);
+        } else {
+
+          if (!isNumeric.test(str = String(v))) 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');
+
+        // 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(v);
+          return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
+        }
+
+        str = String(v);
+
+        if (isNum = typeof v == 'number') {
+
+          // Avoid potential interpretation of Infinity and NaN as base 44+ values.
+          if (v * 0 != 0) return parseNumeric(x, str, isNum, b);
+
+          x.s = 1 / v < 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 + v);
+          }
+        } 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, String(v), isNum, b);
+          }
+        }
+
+        // Prevent later check for length on converted number.
+        isNum = false;
+        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;);
+
+      if (str = str.slice(i, ++len)) {
+        len -= i;
+
+        // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'
+        if (isNum && BigNumber.DEBUG &&
+          len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {
+            throw Error
+             (tooManyDigits + (x.s * v));
+        }
+
+         // Overflow?
+        if ((e = e - i - 1) > 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;  // i < 1
+
+          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));
+            }
+
+            i = LOG_BASE - (str = str.slice(i)).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:
+     *     prefix                 {string}
+     *     groupSize              {number}
+     *     secondaryGroupSize     {number}
+     *     groupSeparator         {string}
+     *     decimalSeparator       {string}
+     *     fractionGroupSize      {number}
+     *     fractionGroupSeparator {string}
+     *     suffix                 {string}
+     *
+     * (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 (v && v.pop) {
+              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 (v && v.pop) {
+              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 if it contains '+', '-', '.', whitespace, or a repeated character.
+            if (typeof v == 'string' && !/^.$|[+-.\s]|(.).*\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.
+     *
+     * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.
+     *
+     * v {any}
+     *
+     * '[BigNumber Error] Invalid BigNumber: {v}'
+     */
+    BigNumber.isBigNumber = function (v) {
+      if (!v || v._isBigNumber !== true) return false;
+      if (!BigNumber.DEBUG) return true;
+
+      var i, n,
+        c = v.c,
+        e = v.e,
+        s = v.s;
+
+      out: if ({}.toString.call(c) == '[object Array]') {
+
+        if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {
+
+          // If the first element is zero, the BigNumber value must be zero.
+          if (c[0] === 0) {
+            if (e === 0 && c.length === 1) return true;
+            break out;
+          }
+
+          // Calculate number of digits that c[0] should have, based on the exponent.
+          i = (e + 1) % LOG_BASE;
+          if (i < 1) i += LOG_BASE;
+
+          // Calculate number of digits of c[0].
+          //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {
+          if (String(c[0]).length == i) {
+
+            for (i = 0; i < c.length; i++) {
+              n = c[i];
+              if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;
+            }
+
+            // Last element cannot be zero, unless it is the only element.
+            if (n !== 0) return true;
+          }
+        }
+
+      // Infinity/NaN
+      } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {
+        return true;
+      }
+
+      throw Error
+        (bignumberError + 'Invalid BigNumber: ' + v);
+    };
+
+
+    /*
+     * 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;
+      };
+    })();
+
+
+    /*
+     * Return a BigNumber whose value is the sum of the arguments.
+     *
+     * arguments {number|string|BigNumber}
+     */
+    BigNumber.sum = function () {
+      var i = 1,
+        args = arguments,
+        sum = new BigNumber(args[0]);
+      for (; i < args.length;) sum = sum.plus(args[i++]);
+      return sum;
+    };
+
+
+    // 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 || ne >= TO_EXP_POS)
+         ? 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 n,
+        i = 1,
+        m = new BigNumber(args[0]);
+
+      for (; i < args.length; i++) {
+        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;
+        } 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.s = null;
+        }
+
+        x.c = x.e = 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;
+    }
+
+
+    function valueOf(n) {
+      var str,
+        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;
+    }
+
+
+    // 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, i, 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: ' + valueOf(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(+valueOf(x), nIsBig ? 2 - isOdd(n) : +valueOf(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);
+        if (nIsNeg) n.s = 1;
+        nIsOdd = isOdd(n);
+      } else {
+        i = Math.abs(+valueOf(n));
+        nIsOdd = i % 2;
+      }
+
+      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 (i) {
+          i = mathfloor(i / 2);
+          if (i === 0) break;
+          nIsOdd = i % 2;
+        } else {
+          n = n.times(half);
+          round(n, n.e + 1, 1);
+
+          if (n.e > 14) {
+            nIsOdd = isOdd(n);
+          } else {
+            i = +valueOf(n);
+            if (i === 0) break;
+            nIsOdd = i % 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(+valueOf(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 or FORMAT object (see BigNumber.set).
+     *
+     * The formatting object may contain some or all of the properties shown below.
+     *
+     * FORMAT = {
+     *   prefix: '',
+     *   groupSize: 3,
+     *   secondaryGroupSize: 0,
+     *   groupSeparator: ',',
+     *   decimalSeparator: '.',
+     *   fractionGroupSize: 0,
+     *   fractionGroupSeparator: '\xA0',      // non-breaking space
+     *   suffix: ''
+     * };
+     *
+     * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.
+     * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+     * [format] {object} Formatting options. See FORMAT pbject above.
+     *
+     * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'
+     * '[BigNumber Error] Argument not an object: {format}'
+     */
+    P.toFormat = function (dp, rm, format) {
+      var str,
+        x = this;
+
+      if (format == null) {
+        if (dp != null && rm && typeof rm == 'object') {
+          format = rm;
+          rm = null;
+        } else if (dp && typeof dp == 'object') {
+          format = dp;
+          dp = rm = null;
+        } else {
+          format = FORMAT;
+        }
+      } else if (typeof format != 'object') {
+        throw Error
+          (bignumberError + 'Argument not an object: ' + format);
+      }
+
+      str = x.toFixed(dp, rm);
+
+      if (x.c) {
+        var i,
+          arr = str.split('.'),
+          g1 = +format.groupSize,
+          g2 = +format.secondaryGroupSize,
+          groupSeparator = format.groupSeparator || '',
+          intPart = arr[0],
+          fractionPart = arr[1],
+          isNeg = x.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 (format.prefix || '') + str + (format.suffix || '');
+    };
+
+
+    /*
+     * Return an array of two BigNumbers 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 d, d0, d1, d2, e, exp, n, n0, n1, q, r, 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: ') + valueOf(n));
+        }
+      }
+
+      if (!xc) return new BigNumber(x);
+
+      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 = e * 2;
+
+      // Determine which fraction is closer to x, n0/d0 or n1/d1
+      r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(
+          div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];
+
+      MAX_EXP = exp;
+
+      return r;
+    };
+
+
+    /*
+     * Return the value of this BigNumber converted to a number primitive.
+     */
+    P.toNumber = function () {
+      return +valueOf(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 {
+        if (b == null) {
+          str = e <= TO_EXP_NEG || e >= TO_EXP_POS
+           ? toExponential(coeffToString(n.c), e)
+           : toFixedPoint(coeffToString(n.c), e, '0');
+        } else if (b === 10) {
+          n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);
+          str = toFixedPoint(coeffToString(n.c), n.e, '0');
+        } else {
+          intCheck(b, 2, ALPHABET.length, 'Base');
+          str = convertBase(toFixedPoint(coeffToString(n.c), 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 () {
+      return valueOf(this);
+    };
+
+
+    P._isBigNumber = true;
+
+    if (configObject != null) BigNumber.set(configObject);
+
+    return BigNumber;
+  }
+
+
+  // PRIVATE HELPER FUNCTIONS
+
+  // These functions don't need access to variables,
+  // e.g. DECIMAL_PLACES, in the scope of the `clone` function above.
+
+
+  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 !== mathfloor(n)) {
+      throw Error
+       (bignumberError + (name || 'Argument') + (typeof n == 'number'
+         ? n < min || n > max ? ' out of range: ' : ' not an integer: '
+         : ' not a primitive number: ') + String(n));
+    }
+  }
+
+
+  // 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);

node/node_modules/bignumber.js/bignumber.mjs

@@ -0,0 +1,2888 @@
+/*
+ *      bignumber.js v9.0.0
+ *      A JavaScript library for arbitrary-precision arithmetic.
+ *      https://github.com/MikeMcl/bignumber.js
+ *      Copyright (c) 2019 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                      |  sum
+ *      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 = {
+      prefix: '',
+      groupSize: 3,
+      secondaryGroupSize: 0,
+      groupSeparator: ',',
+      decimalSeparator: '.',
+      fractionGroupSize: 0,
+      fractionGroupSeparator: '\xA0',      // non-breaking space
+      suffix: ''
+    },
+
+    // The alphabet used for base conversion. It must be at least 2 characters long, with no '+',
+    // '-', '.', whitespace, or repeated character.
+    // '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_'
+    ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz';
+
+
+  //------------------------------------------------------------------------------------------
+
+
+  // CONSTRUCTOR
+
+
+  /*
+   * The BigNumber constructor and exported function.
+   * Create and return a new instance of a BigNumber object.
+   *
+   * v {number|string|BigNumber} A numeric value.
+   * [b] {number} The base of v. Integer, 2 to ALPHABET.length inclusive.
+   */
+  function BigNumber(v, b) {
+    var alphabet, c, caseChanged, e, i, isNum, len, str,
+      x = this;
+
+    // Enable constructor call without `new`.
+    if (!(x instanceof BigNumber)) return new BigNumber(v, b);
+
+    if (b == null) {
+
+      if (v && v._isBigNumber === true) {
+        x.s = v.s;
+
+        if (!v.c || v.e > MAX_EXP) {
+          x.c = x.e = null;
+        } else if (v.e < MIN_EXP) {
+          x.c = [x.e = 0];
+        } else {
+          x.e = v.e;
+          x.c = v.c.slice();
+        }
+
+        return;
+      }
+
+      if ((isNum = typeof v == 'number') && v * 0 == 0) {
+
+        // Use `1 / n` to handle minus zero also.
+        x.s = 1 / v < 0 ? (v = -v, -1) : 1;
+
+        // Fast path for integers, where n < 2147483648 (2**31).
+        if (v === ~~v) {
+          for (e = 0, i = v; i >= 10; i /= 10, e++);
+
+          if (e > MAX_EXP) {
+            x.c = x.e = null;
+          } else {
+            x.e = e;
+            x.c = [v];
+          }
+
+          return;
+        }
+
+        str = String(v);
+      } else {
+
+        if (!isNumeric.test(str = String(v))) 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');
+
+      // 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(v);
+        return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
+      }
+
+      str = String(v);
+
+      if (isNum = typeof v == 'number') {
+
+        // Avoid potential interpretation of Infinity and NaN as base 44+ values.
+        if (v * 0 != 0) return parseNumeric(x, str, isNum, b);
+
+        x.s = 1 / v < 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 + v);
+        }
+      } 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, String(v), isNum, b);
+        }
+      }
+
+      // Prevent later check for length on converted number.
+      isNum = false;
+      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;);
+
+    if (str = str.slice(i, ++len)) {
+      len -= i;
+
+      // '[BigNumber Error] Number primitive has more than 15 significant digits: {n}'
+      if (isNum && BigNumber.DEBUG &&
+        len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {
+          throw Error
+           (tooManyDigits + (x.s * v));
+      }
+
+       // Overflow?
+      if ((e = e - i - 1) > 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;  // i < 1
+
+        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));
+          }
+
+          i = LOG_BASE - (str = str.slice(i)).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:
+   *     prefix                 {string}
+   *     groupSize              {number}
+   *     secondaryGroupSize     {number}
+   *     groupSeparator         {string}
+   *     decimalSeparator       {string}
+   *     fractionGroupSize      {number}
+   *     fractionGroupSeparator {string}
+   *     suffix                 {string}
+   *
+   * (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 (v && v.pop) {
+            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 (v && v.pop) {
+            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 if it contains '+', '-', '.', whitespace, or a repeated character.
+          if (typeof v == 'string' && !/^.$|[+-.\s]|(.).*\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.
+   *
+   * If BigNumber.DEBUG is true, throw if a BigNumber instance is not well-formed.
+   *
+   * v {any}
+   *
+   * '[BigNumber Error] Invalid BigNumber: {v}'
+   */
+  BigNumber.isBigNumber = function (v) {
+    if (!v || v._isBigNumber !== true) return false;
+    if (!BigNumber.DEBUG) return true;
+
+    var i, n,
+      c = v.c,
+      e = v.e,
+      s = v.s;
+
+    out: if ({}.toString.call(c) == '[object Array]') {
+
+      if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {
+
+        // If the first element is zero, the BigNumber value must be zero.
+        if (c[0] === 0) {
+          if (e === 0 && c.length === 1) return true;
+          break out;
+        }
+
+        // Calculate number of digits that c[0] should have, based on the exponent.
+        i = (e + 1) % LOG_BASE;
+        if (i < 1) i += LOG_BASE;
+
+        // Calculate number of digits of c[0].
+        //if (Math.ceil(Math.log(c[0] + 1) / Math.LN10) == i) {
+        if (String(c[0]).length == i) {
+
+          for (i = 0; i < c.length; i++) {
+            n = c[i];
+            if (n < 0 || n >= BASE || n !== mathfloor(n)) break out;
+          }
+
+          // Last element cannot be zero, unless it is the only element.
+          if (n !== 0) return true;
+        }
+      }
+
+    // Infinity/NaN
+    } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {
+      return true;
+    }
+
+    throw Error
+      (bignumberError + 'Invalid BigNumber: ' + v);
+  };
+
+
+  /*
+   * 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;
+    };
+  })();
+
+
+   /*
+   * Return a BigNumber whose value is the sum of the arguments.
+   *
+   * arguments {number|string|BigNumber}
+   */
+  BigNumber.sum = function () {
+    var i = 1,
+      args = arguments,
+      sum = new BigNumber(args[0]);
+    for (; i < args.length;) sum = sum.plus(args[i++]);
+    return sum;
+  };
+
+
+  // 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 || ne >= TO_EXP_POS)
+       ? 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 n,
+      i = 1,
+      m = new BigNumber(args[0]);
+
+    for (; i < args.length; i++) {
+      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;
+      } 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.s = null;
+      }
+
+      x.c = x.e = 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;
+  }
+
+
+  function valueOf(n) {
+    var str,
+      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;
+  }
+
+
+  // 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, i, 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: ' + valueOf(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(+valueOf(x), nIsBig ? 2 - isOdd(n) : +valueOf(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);
+      if (nIsNeg) n.s = 1;
+      nIsOdd = isOdd(n);
+    } else {
+      i = Math.abs(+valueOf(n));
+      nIsOdd = i % 2;
+    }
+
+    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 (i) {
+        i = mathfloor(i / 2);
+        if (i === 0) break;
+        nIsOdd = i % 2;
+      } else {
+        n = n.times(half);
+        round(n, n.e + 1, 1);
+
+        if (n.e > 14) {
+          nIsOdd = isOdd(n);
+        } else {
+          i = +valueOf(n);
+          if (i === 0) break;
+          nIsOdd = i % 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(+valueOf(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 or FORMAT object (see BigNumber.set).
+   *
+   * The formatting object may contain some or all of the properties shown below.
+   *
+   * FORMAT = {
+   *   prefix: '',
+   *   groupSize: 3,
+   *   secondaryGroupSize: 0,
+   *   groupSeparator: ',',
+   *   decimalSeparator: '.',
+   *   fractionGroupSize: 0,
+   *   fractionGroupSeparator: '\xA0',      // non-breaking space
+   *   suffix: ''
+   * };
+   *
+   * [dp] {number} Decimal places. Integer, 0 to MAX inclusive.
+   * [rm] {number} Rounding mode. Integer, 0 to 8 inclusive.
+   * [format] {object} Formatting options. See FORMAT pbject above.
+   *
+   * '[BigNumber Error] Argument {not a primitive number|not an integer|out of range}: {dp|rm}'
+   * '[BigNumber Error] Argument not an object: {format}'
+   */
+  P.toFormat = function (dp, rm, format) {
+    var str,
+      x = this;
+
+    if (format == null) {
+      if (dp != null && rm && typeof rm == 'object') {
+        format = rm;
+        rm = null;
+      } else if (dp && typeof dp == 'object') {
+        format = dp;
+        dp = rm = null;
+      } else {
+        format = FORMAT;
+      }
+    } else if (typeof format != 'object') {
+      throw Error
+        (bignumberError + 'Argument not an object: ' + format);
+    }
+
+    str = x.toFixed(dp, rm);
+
+    if (x.c) {
+      var i,
+        arr = str.split('.'),
+        g1 = +format.groupSize,
+        g2 = +format.secondaryGroupSize,
+        groupSeparator = format.groupSeparator || '',
+        intPart = arr[0],
+        fractionPart = arr[1],
+        isNeg = x.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 (format.prefix || '') + str + (format.suffix || '');
+  };
+
+
+  /*
+   * Return an array of two BigNumbers 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 d, d0, d1, d2, e, exp, n, n0, n1, q, r, 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: ') + valueOf(n));
+      }
+    }
+
+    if (!xc) return new BigNumber(x);
+
+    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 = e * 2;
+
+    // Determine which fraction is closer to x, n0/d0 or n1/d1
+    r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(
+        div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];
+
+    MAX_EXP = exp;
+
+    return r;
+  };
+
+
+  /*
+   * Return the value of this BigNumber converted to a number primitive.
+   */
+  P.toNumber = function () {
+    return +valueOf(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 {
+      if (b == null) {
+        str = e <= TO_EXP_NEG || e >= TO_EXP_POS
+         ? toExponential(coeffToString(n.c), e)
+         : toFixedPoint(coeffToString(n.c), e, '0');
+      } else if (b === 10) {
+        n = round(new BigNumber(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);
+        str = toFixedPoint(coeffToString(n.c), n.e, '0');
+      } else {
+        intCheck(b, 2, ALPHABET.length, 'Base');
+        str = convertBase(toFixedPoint(coeffToString(n.c), 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 () {
+    return valueOf(this);
+  };
+
+
+  P._isBigNumber = true;
+
+  P[Symbol.toStringTag] = 'BigNumber';
+
+  // Node.js v10.12.0+
+  P[Symbol.for('nodejs.util.inspect.custom')] = P.valueOf;
+
+  if (configObject != null) BigNumber.set(configObject);
+
+  return BigNumber;
+}
+
+
+// PRIVATE HELPER FUNCTIONS
+
+// These functions don't need access to variables,
+// e.g. DECIMAL_PLACES, in the scope of the `clone` function above.
+
+
+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 !== mathfloor(n)) {
+    throw Error
+     (bignumberError + (name || 'Argument') + (typeof n == 'number'
+       ? n < min || n > max ? ' out of range: ' : ' not an integer: '
+       : ' not a primitive number: ') + String(n));
+  }
+}
+
+
+// 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
+
+
+export var BigNumber = clone();
+
+export default BigNumber;

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

@@ -0,0 +1,2237 @@
+<!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">
+
+    <b>v8.1.0</b>
+
+	<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>
+      <li><a href="#sum"        >sum</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>
+      <li><a href="#debug"           >DEBUG</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 href="#type-coercion">Type coercion</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>
+    <p>
+      A BigNumber can also be created from an object literal.
+      Use <code><a href='#isBigNumber'>isBigNumber</a></code> to check that it is well-formed.
+    </p>
+    <pre>new BigNumber({ s: 1, e: 2, c: [ 777, 12300000000000 ], _isBigNumber: true })    // '777.123'</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 Node.js.
+      </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>
+// Node.js
+global.crypto = require('crypto')
+
+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: {
+    // string to prepend
+    prefix: '',
+    // decimal separator
+    decimalSeparator: '.',
+    // grouping separator of the integer part
+    groupSeparator: ',',
+    // primary grouping size of the integer part
+    groupSize: 3,
+    // secondary grouping size of the integer part
+    secondaryGroupSize: 0,
+    // grouping separator of the fraction part
+    fractionGroupSeparator: ' ',
+    // grouping size of the fraction part
+    fractionGroupSize: 0,
+    // string to append
+    suffix: ''
+  }
+});</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 whitespace or a repeated character, or the sign indicators
+        <code>'+'</code> and <code>'-'</code>, or the decimal separator <code>'.'</code>.
+      </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>
+    <p>
+      If <code>value</code> is a BigNumber instance and <code>BigNumber.DEBUG</code> is <code>true</code>,
+      then this method will also check if <code>value</code> is well-formed, and throw if it is not.
+      See <a href='#Errors'>Errors</a>.
+    </p>
+    <p>
+      The check can be useful if creating a BigNumber from an object literal.
+      See <a href='#bignumber'>BigNumber</a>.
+    </p>
+    <pre>
+x = new BigNumber(10)
+
+// Change x.c to an illegitimate value.
+x.c = NaN
+
+BigNumber.DEBUG = false
+
+// No error.
+BigNumber.isBigNumber(x)    // true
+
+BigNumber.DEBUG = true
+
+// Error.
+BigNumber.isBigNumber(x)    // '[BigNumber Error] Invalid BigNumber'</pre>
+
+
+
+    <h5 id="max">maximum<code class='inset'>.max(n...) <i>&rArr; BigNumber</i></code></h5>
+    <p>
+      <code>n</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 the arguments.
+    </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.apply(null, arr)                // '14'</pre>
+
+
+
+    <h5 id="min">minimum<code class='inset'>.min(n...) <i>&rArr; BigNumber</i></code></h5>
+    <p>
+      <code>n</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 the arguments.
+    </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.apply(null, 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>
+      To be able to set <a href='#crypto'><code>CRYPTO</code></a> to <code>true</code> when using
+      Node.js, the <code>crypto</code> object must be available globally:
+    </p>
+    <pre>global.crypto = require('crypto')</pre>
+    <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>
+
+
+
+    <h5 id="sum">sum<code class='inset'>.sum(n...) <i>&rArr; BigNumber</i></code></h5>
+    <p>
+      <code>n</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 sum of the arguments.</p>
+    <p>The return value is always exact and unrounded.</p>
+    <pre>x = new BigNumber('3257869345.0378653')
+BigNumber.sum(4e9, x, '123456789.9')      // '7381326134.9378653'
+
+arr = [2, new BigNumber(14), '15.9999', 12]
+BigNumber.sum.apply(null, arr)            // '43.9999'</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>
+
+    <h5 id="debug">DEBUG</h5>
+    <p><i>undefined|false|true</i></p>
+    <p>
+      If <code>BigNumber.DEBUG</code> is set <code>true</code> then an error will be thrown
+      if this <a href='#bignumber'>BigNumber</a> constructor receives an invalid value, such as
+      a value of type <em>number</em> with more than <code>15</code> significant digits.
+      See <a href='#bignumber'>BigNumber</a>.
+    </p>
+    <p>
+      An error will also be thrown if the <code><a href='#isBigNumber'>isBigNumber</a></code>
+      method receives a BigNumber that is not well-formed.
+      See <code><a href='#isBigNumber'>isBigNumber</a></code>.
+    </p>
+    <pre>BigNumber.DEBUG = true</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 sign 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 sign 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.isNegative()         // 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[, format]]]) <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<br />
+      <code>format</code>: <i>object</i>: see <a href='#format'><code>FORMAT</code></a>
+    </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 <code>format</code> object.
+    </p>
+    <p>
+      See <a href='#format'><code>FORMAT</code></a> and the examples below for the properties of the
+      <code>format</code> object, their types, and their usage. A formatting object may contain
+      some or all of the recognised properties.
+    </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.<br />
+      If <code>format</code> is omitted or is <code>null</code> or <code>undefined</code>, the
+      <a href='#format'><code>FORMAT</code></a> object is used.
+    </p>
+    <p>
+      Throws if <code>dp</code>, <code>rm</code> or <code>format</code> is invalid. See
+      <a href='#Errors'>Errors</a>.
+    </p>
+    <pre>
+fmt = {
+  prefix = '',
+  decimalSeparator: '.',
+  groupSeparator: ',',
+  groupSize: 3,
+  secondaryGroupSize: 0,
+  fractionGroupSeparator: ' ',
+  fractionGroupSize: 0,
+  suffix = ''
+}
+
+x = new BigNumber('123456789.123456789')
+
+// Set the global formatting options
+BigNumber.config({ FORMAT: fmt })
+
+x.toFormat()                              // '123,456,789.123456789'
+x.toFormat(3)                             // '123,456,789.123'
+
+// If a reference to the object assigned to FORMAT has been retained,
+// the format properties can be changed directly
+fmt.groupSeparator = ' '
+fmt.fractionGroupSize = 5
+x.toFormat()                              // '123 456 789.12345 6789'
+
+// Alternatively, pass the formatting options as an argument
+fmt = {
+  prefix: '=> ',
+  decimalSeparator: ',',
+  groupSeparator: '.',
+  groupSize: 3,
+  secondaryGroupSize: 2
+}
+
+x.toFormat()                              // '123 456 789.12345 6789'
+x.toFormat(fmt)                           // '=> 12.34.56.789,123456789'
+x.toFormat(2, fmt)                        // '=> 12.34.56.789,12'
+x.toFormat(3, BigNumber.ROUND_UP, fmt)    // '=> 12.34.56.789,124'</pre>
+
+
+
+    <h5 id="toFr">
+      toFraction<code class='inset'>.toFraction([maximum_denominator])
+      <i>&rArr; [BigNumber, BigNumber]</i></code>
+    </h5>
+    <p>
+      <code>maximum_denominator</code>:
+      <i>number|string|BigNumber</i>: integer &gt;= <code>1</code> and &lt;=
+      <code>Infinity</code>
+    </p>
+    <p>
+      Returns an array of two BigNumbers 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>maximum_denominator</code>.
+    </p>
+    <p>
+      If a <code>maximum_denominator</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>maximum_denominator</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 <a href='#valueOf'><code>valueOf</code></a>.</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 <a href='#toS'><code>toString</code></a>, 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>isBigNumber</code></td>
+        <td>Invalid BigNumber<sup>*</sup></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>
+          <code>toFormat</code>
+        </td>
+        <td>Argument not an object</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="type-coercion">Type coercion</h4>
+    <p>
+      To prevent the accidental use of a BigNumber in primitive number operations, or the
+      accidental addition of a BigNumber to a string, the <code>valueOf</code> method can be safely
+      overwritten as shown below.
+    </p>
+    <p>
+      The <a href='#valueOf'><code>valueOf</code></a> method is the same as the
+      <a href='#toJSON'><code>toJSON</code></a> method, and both are the same as the
+      <a href='#toS'><code>toString</code></a> method except they do not take a <code>base</code>
+      argument and they include the minus sign for negative zero.
+    </p>
+    <pre>
+BigNumber.prototype.valueOf = function () {
+  throw Error('valueOf called!')
+}
+
+x = new BigNumber(1)
+x / 2                    // '[BigNumber Error] valueOf called!'
+x + 'abc'                // '[BigNumber Error] valueOf called!'
+</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>

node/node_modules/bignumber.js/package.json

@@ -0,0 +1,72 @@
+{
+  "_args": [
+    [
+      "bignumber.js@9.0.0",
+      "F:\\cocorobo\\CocoRoboDesktop\\node"
+    ]
+  ],
+  "_from": "bignumber.js@9.0.0",
+  "_id": "bignumber.js@9.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-t/OYhhJ2SD+YGBQcjY8GzzDHEk9f3nerxjtfa6tlMXfe7frs/WozhvCNoGvpM0P3bNf3Gq5ZRMlGr5f3r4/N8A==",
+  "_location": "/bignumber.js",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "bignumber.js@9.0.0",
+    "name": "bignumber.js",
+    "escapedName": "bignumber.js",
+    "rawSpec": "9.0.0",
+    "saveSpec": null,
+    "fetchSpec": "9.0.0"
+  },
+  "_requiredBy": [
+    "/mysql"
+  ],
+  "_resolved": "https://registry.npmmirror.com/bignumber.js/-/bignumber.js-9.0.0.tgz",
+  "_spec": "9.0.0",
+  "_where": "F:\\cocorobo\\CocoRoboDesktop\\node",
+  "author": {
+    "name": "Michael Mclaughlin",
+    "email": "M8ch88l@gmail.com"
+  },
+  "browser": "bignumber.js",
+  "bugs": {
+    "url": "https://github.com/MikeMcl/bignumber.js/issues"
+  },
+  "dependencies": {},
+  "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 -c -m -o bignumber.min.js",
+    "test": "node test/test"
+  },
+  "types": "bignumber.d.ts",
+  "version": "9.0.0"
+}

node/node_modules/boolbase/README.md

@@ -0,0 +1,10 @@
+#boolbase
+This very simple module provides two basic functions, one that always returns true (`trueFunc`) and one that always returns false (`falseFunc`).
+
+###WTF?
+
+By having only a single instance of these functions around, it's possible to do some nice optimizations. Eg. [`CSSselect`](https://github.com/fb55/CSSselect) uses these functions to determine whether a selector won't match any elements. If that's the case, the DOM doesn't even have to be touched.
+
+###And why is this a separate module?
+
+I'm trying to modularize `CSSselect` and most modules depend on these functions. IMHO, having a separate module is the easiest solution to this problem.

node/node_modules/boolbase/index.js

@@ -0,0 +1,8 @@
+module.exports = {
+	trueFunc: function trueFunc(){
+		return true;
+	},
+	falseFunc: function falseFunc(){
+		return false;
+	}
+};

node/node_modules/boolbase/package.json

@@ -0,0 +1,55 @@
+{
+  "_args": [
+    [
+      "boolbase@1.0.0",
+      "F:\\cocorobo\\CocoRoboDesktop\\node"
+    ]
+  ],
+  "_from": "boolbase@1.0.0",
+  "_id": "boolbase@1.0.0",
+  "_inBundle": false,
+  "_integrity": "sha512-JZOSA7Mo9sNGB8+UjSgzdLtokWAky1zbztM3WRLCbZ70/3cTANmQmOdR7y2g+J0e2WXywy1yS468tY+IruqEww==",
+  "_location": "/boolbase",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "boolbase@1.0.0",
+    "name": "boolbase",
+    "escapedName": "boolbase",
+    "rawSpec": "1.0.0",
+    "saveSpec": null,
+    "fetchSpec": "1.0.0"
+  },
+  "_requiredBy": [
+    "/css-select",
+    "/nth-check"
+  ],
+  "_resolved": "https://registry.npmmirror.com/boolbase/-/boolbase-1.0.0.tgz",
+  "_spec": "1.0.0",
+  "_where": "F:\\cocorobo\\CocoRoboDesktop\\node",
+  "author": {
+    "name": "Felix Boehm",
+    "email": "me@feedic.com"
+  },
+  "bugs": {
+    "url": "https://github.com/fb55/boolbase/issues"
+  },
+  "description": "two functions: One that returns true, one that returns false",
+  "homepage": "https://github.com/fb55/boolbase",
+  "keywords": [
+    "boolean",
+    "function"
+  ],
+  "license": "ISC",
+  "main": "index.js",
+  "name": "boolbase",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fb55/boolbase.git"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "version": "1.0.0"
+}

node/node_modules/cheerio-select/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) Felix Böhm
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

node/node_modules/cheerio-select/README.md

@@ -0,0 +1,18 @@
+# cheerio-select [![NPM version](http://img.shields.io/npm/v/cheerio-select.svg)](https://npmjs.org/package/cheerio-select) [![Build Status](https://travis-ci.org/cheeriojs/cheerio-select.svg?branch=master)](http://travis-ci.org/cheeriojs/cheerio-select) [![Downloads](https://img.shields.io/npm/dm/cheerio-select.svg)](https://npmjs.org/package/cheerio-select) [![Coverage](https://coveralls.io/repos/cheeriojs/cheerio-select/badge.svg?branch=master)](https://coveralls.io/r/cheeriojs/cheerio-select)
+
+CSS selector engine supporting jQuery selectors, based on [`css-select`](https://github.com/fb55/css-select).
+
+Supports all jQuery positional pseudo-selectors:
+
+-   `:first`
+-   `:last`
+-   `:eq`
+-   `:nth`
+-   `:gt`
+-   `:lt`
+-   `:even`
+-   `:odd`
+-   `:not(:positional)`, where `:positional` is any of the above.
+
+This library is a thin wrapper around [`css-select`](https://github.com/fb55/css-select).
+Only use this module if you will actually use jQuery positional selectors.

node/node_modules/cheerio-select/lib/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { Node } from "domhandler";
+import type { Selector } from "css-what";
+export declare function getDocumentRoot(node: Node): Node;
+export declare function groupSelectors(selectors: Selector[][]): [plain: Selector[][], filtered: Selector[][]];
+//# sourceMappingURL=helpers.d.ts.map

node/node_modules/cheerio-select/lib/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAGzC,wBAAgB,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAGhD;AAED,wBAAgB,cAAc,CAC1B,SAAS,EAAE,QAAQ,EAAE,EAAE,GACxB,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE,EAAE,QAAQ,EAAE,QAAQ,EAAE,EAAE,CAAC,CAa/C"}

node/node_modules/cheerio-select/lib/helpers.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.groupSelectors = exports.getDocumentRoot = void 0;
+var positionals_1 = require("./positionals");
+function getDocumentRoot(node) {
+    while (node.parent)
+        node = node.parent;
+    return node;
+}
+exports.getDocumentRoot = getDocumentRoot;
+function groupSelectors(selectors) {
+    var filteredSelectors = [];
+    var plainSelectors = [];
+    for (var _i = 0, selectors_1 = selectors; _i < selectors_1.length; _i++) {
+        var selector = selectors_1[_i];
+        if (selector.some(positionals_1.isFilter)) {
+            filteredSelectors.push(selector);
+        }
+        else {
+            plainSelectors.push(selector);
+        }
+    }
+    return [plainSelectors, filteredSelectors];
+}
+exports.groupSelectors = groupSelectors;

node/node_modules/cheerio-select/lib/index.d.ts

@@ -0,0 +1,12 @@
+import { Options as CSSSelectOptions } from "css-select";
+import type { Element, Node, Document } from "domhandler";
+export { filters, pseudos, aliases } from "css-select";
+export interface Options extends CSSSelectOptions<Node, Element> {
+    /** Optional reference to the root of the document. If not set, this will be computed when needed. */
+    root?: Document;
+}
+export declare function is(element: Element, selector: string | ((el: Element) => boolean), options?: Options): boolean;
+export declare function some(elements: Element[], selector: string | ((el: Element) => boolean), options?: Options): boolean;
+export declare function filter(selector: string, elements: Node[], options?: Options): Element[];
+export declare function select(selector: string | ((el: Element) => boolean), root: Node | Node[], options?: Options): Element[];
+//# sourceMappingURL=index.d.ts.map

node/node_modules/cheerio-select/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,EAEH,OAAO,IAAI,gBAAgB,EAE9B,MAAM,YAAY,CAAC;AAEpB,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAK1D,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAevD,MAAM,WAAW,OAAQ,SAAQ,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC;IAC5D,qGAAqG;IACrG,IAAI,CAAC,EAAE,QAAQ,CAAC;CACnB;AAED,wBAAgB,EAAE,CACd,OAAO,EAAE,OAAO,EAChB,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,EAC7C,OAAO,GAAE,OAAY,GACtB,OAAO,CAET;AAED,wBAAgB,IAAI,CAChB,QAAQ,EAAE,OAAO,EAAE,EACnB,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,EAC7C,OAAO,GAAE,OAAY,GACtB,OAAO,CAWT;AAsCD,wBAAgB,MAAM,CAClB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,IAAI,EAAE,EAChB,OAAO,GAAE,OAAY,GACtB,OAAO,EAAE,CAEX;AA6FD,wBAAgB,MAAM,CAClB,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,EAAE,OAAO,KAAK,OAAO,CAAC,EAC7C,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,EACnB,OAAO,GAAE,OAAY,GACtB,OAAO,EAAE,CA2BX"}

node/node_modules/cheerio-select/lib/index.js

@@ -0,0 +1,313 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.select = exports.filter = exports.some = exports.is = exports.aliases = exports.pseudos = exports.filters = void 0;
+var css_what_1 = require("css-what");
+var css_select_1 = require("css-select");
+var DomUtils = __importStar(require("domutils"));
+var helpers_1 = require("./helpers");
+var positionals_1 = require("./positionals");
+// Re-export pseudo extension points
+var css_select_2 = require("css-select");
+Object.defineProperty(exports, "filters", { enumerable: true, get: function () { return css_select_2.filters; } });
+Object.defineProperty(exports, "pseudos", { enumerable: true, get: function () { return css_select_2.pseudos; } });
+Object.defineProperty(exports, "aliases", { enumerable: true, get: function () { return css_select_2.aliases; } });
+/** Used to indicate a scope should be filtered. Might be ignored when filtering. */
+var SCOPE_PSEUDO = {
+    type: css_what_1.SelectorType.Pseudo,
+    name: "scope",
+    data: null,
+};
+/** Used for actually filtering for scope. */
+var CUSTOM_SCOPE_PSEUDO = __assign({}, SCOPE_PSEUDO);
+var UNIVERSAL_SELECTOR = {
+    type: css_what_1.SelectorType.Universal,
+    namespace: null,
+};
+function is(element, selector, options) {
+    if (options === void 0) { options = {}; }
+    return some([element], selector, options);
+}
+exports.is = is;
+function some(elements, selector, options) {
+    if (options === void 0) { options = {}; }
+    if (typeof selector === "function")
+        return elements.some(selector);
+    var _a = (0, helpers_1.groupSelectors)((0, css_what_1.parse)(selector)), plain = _a[0], filtered = _a[1];
+    return ((plain.length > 0 && elements.some((0, css_select_1._compileToken)(plain, options))) ||
+        filtered.some(function (sel) { return filterBySelector(sel, elements, options).length > 0; }));
+}
+exports.some = some;
+function filterByPosition(filter, elems, data, options) {
+    var num = typeof data === "string" ? parseInt(data, 10) : NaN;
+    switch (filter) {
+        case "first":
+        case "lt":
+            // Already done in `getLimit`
+            return elems;
+        case "last":
+            return elems.length > 0 ? [elems[elems.length - 1]] : elems;
+        case "nth":
+        case "eq":
+            return isFinite(num) && Math.abs(num) < elems.length
+                ? [num < 0 ? elems[elems.length + num] : elems[num]]
+                : [];
+        case "gt":
+            return isFinite(num) ? elems.slice(num + 1) : [];
+        case "even":
+            return elems.filter(function (_, i) { return i % 2 === 0; });
+        case "odd":
+            return elems.filter(function (_, i) { return i % 2 === 1; });
+        case "not": {
+            var filtered_1 = new Set(filterParsed(data, elems, options));
+            return elems.filter(function (e) { return !filtered_1.has(e); });
+        }
+    }
+}
+function filter(selector, elements, options) {
+    if (options === void 0) { options = {}; }
+    return filterParsed((0, css_what_1.parse)(selector), elements, options);
+}
+exports.filter = filter;
+/**
+ * Filter a set of elements by a selector.
+ *
+ * Will return elements in the original order.
+ *
+ * @param selector Selector to filter by.
+ * @param elements Elements to filter.
+ * @param options Options for selector.
+ */
+function filterParsed(selector, elements, options) {
+    if (elements.length === 0)
+        return [];
+    var _a = (0, helpers_1.groupSelectors)(selector), plainSelectors = _a[0], filteredSelectors = _a[1];
+    var found;
+    if (plainSelectors.length) {
+        var filtered = filterElements(elements, plainSelectors, options);
+        // If there are no filters, just return
+        if (filteredSelectors.length === 0) {
+            return filtered;
+        }
+        // Otherwise, we have to do some filtering
+        if (filtered.length) {
+            found = new Set(filtered);
+        }
+    }
+    for (var i = 0; i < filteredSelectors.length && (found === null || found === void 0 ? void 0 : found.size) !== elements.length; i++) {
+        var filteredSelector = filteredSelectors[i];
+        var missing = found
+            ? elements.filter(function (e) { return DomUtils.isTag(e) && !found.has(e); })
+            : elements;
+        if (missing.length === 0)
+            break;
+        var filtered = filterBySelector(filteredSelector, elements, options);
+        if (filtered.length) {
+            if (!found) {
+                /*
+                 * If we haven't found anything before the last selector,
+                 * just return what we found now.
+                 */
+                if (i === filteredSelectors.length - 1) {
+                    return filtered;
+                }
+                found = new Set(filtered);
+            }
+            else {
+                filtered.forEach(function (el) { return found.add(el); });
+            }
+        }
+    }
+    return typeof found !== "undefined"
+        ? (found.size === elements.length
+            ? elements
+            : // Filter elements to preserve order
+                elements.filter(function (el) {
+                    return found.has(el);
+                }))
+        : [];
+}
+function filterBySelector(selector, elements, options) {
+    var _a;
+    if (selector.some(css_what_1.isTraversal)) {
+        /*
+         * Get root node, run selector with the scope
+         * set to all of our nodes.
+         */
+        var root = (_a = options.root) !== null && _a !== void 0 ? _a : (0, helpers_1.getDocumentRoot)(elements[0]);
+        var sel = __spreadArray(__spreadArray([], selector, true), [CUSTOM_SCOPE_PSEUDO], false);
+        return findFilterElements(root, sel, options, true, elements);
+    }
+    // Performance optimization: If we don't have to traverse, just filter set.
+    return findFilterElements(elements, selector, options, false);
+}
+function select(selector, root, options) {
+    if (options === void 0) { options = {}; }
+    if (typeof selector === "function") {
+        return find(root, selector);
+    }
+    var _a = (0, helpers_1.groupSelectors)((0, css_what_1.parse)(selector)), plain = _a[0], filtered = _a[1];
+    var results = filtered.map(function (sel) {
+        return findFilterElements(root, sel, options, true);
+    });
+    // Plain selectors can be queried in a single go
+    if (plain.length) {
+        results.push(findElements(root, plain, options, Infinity));
+    }
+    if (results.length === 0) {
+        return [];
+    }
+    // If there was only a single selector, just return the result
+    if (results.length === 1) {
+        return results[0];
+    }
+    // Sort results, filtering for duplicates
+    return DomUtils.uniqueSort(results.reduce(function (a, b) { return __spreadArray(__spreadArray([], a, true), b, true); }));
+}
+exports.select = select;
+// Traversals that are treated differently in css-select.
+var specialTraversal = new Set([
+    css_what_1.SelectorType.Descendant,
+    css_what_1.SelectorType.Adjacent,
+]);
+function includesScopePseudo(t) {
+    return (t !== SCOPE_PSEUDO &&
+        t.type === "pseudo" &&
+        (t.name === "scope" ||
+            (Array.isArray(t.data) &&
+                t.data.some(function (data) { return data.some(includesScopePseudo); }))));
+}
+function addContextIfScope(selector, options, scopeContext) {
+    return scopeContext && selector.some(includesScopePseudo)
+        ? __assign(__assign({}, options), { context: scopeContext }) : options;
+}
+/**
+ *
+ * @param root Element(s) to search from.
+ * @param selector Selector to look for.
+ * @param options Options for querying.
+ * @param queryForSelector Query multiple levels deep for the initial selector, even if it doesn't contain a traversal.
+ * @param scopeContext Optional context for a :scope.
+ */
+function findFilterElements(root, selector, options, queryForSelector, scopeContext) {
+    var filterIndex = selector.findIndex(positionals_1.isFilter);
+    var sub = selector.slice(0, filterIndex);
+    var filter = selector[filterIndex];
+    /*
+     * Set the number of elements to retrieve.
+     * Eg. for :first, we only have to get a single element.
+     */
+    var limit = (0, positionals_1.getLimit)(filter.name, filter.data);
+    if (limit === 0)
+        return [];
+    var subOpts = addContextIfScope(sub, options, scopeContext);
+    /*
+     * Skip `findElements` call if our selector starts with a positional
+     * pseudo.
+     */
+    var elemsNoLimit = sub.length === 0 && !Array.isArray(root)
+        ? DomUtils.getChildren(root).filter(DomUtils.isTag)
+        : sub.length === 0 || (sub.length === 1 && sub[0] === SCOPE_PSEUDO)
+            ? (Array.isArray(root) ? root : [root]).filter(DomUtils.isTag)
+            : queryForSelector || sub.some(css_what_1.isTraversal)
+                ? findElements(root, [sub], subOpts, limit)
+                : filterElements(root, [sub], subOpts);
+    var elems = elemsNoLimit.slice(0, limit);
+    var result = filterByPosition(filter.name, elems, filter.data, options);
+    if (result.length === 0 || selector.length === filterIndex + 1) {
+        return result;
+    }
+    var remainingSelector = selector.slice(filterIndex + 1);
+    var remainingHasTraversal = remainingSelector.some(css_what_1.isTraversal);
+    var remainingOpts = addContextIfScope(remainingSelector, options, scopeContext);
+    if (remainingHasTraversal) {
+        /*
+         * Some types of traversals have special logic when they start a selector
+         * in css-select. If this is the case, add a universal selector in front of
+         * the selector to avoid this behavior.
+         */
+        if (specialTraversal.has(remainingSelector[0].type)) {
+            remainingSelector.unshift(UNIVERSAL_SELECTOR);
+        }
+        /*
+         * Add a scope token in front of the remaining selector,
+         * to make sure traversals don't match elements that aren't a
+         * part of the considered tree.
+         */
+        remainingSelector.unshift(SCOPE_PSEUDO);
+    }
+    /*
+     * If we have another filter, recursively call `findFilterElements`,
+     * with the `recursive` flag disabled. We only have to look for more
+     * elements when we see a traversal.
+     *
+     * Otherwise,
+     */
+    return remainingSelector.some(positionals_1.isFilter)
+        ? findFilterElements(result, remainingSelector, options, false, scopeContext)
+        : remainingHasTraversal
+            ? // Query existing elements to resolve traversal.
+                findElements(result, [remainingSelector], remainingOpts, Infinity)
+            : // If we don't have any more traversals, simply filter elements.
+                filterElements(result, [remainingSelector], remainingOpts);
+}
+function findElements(root, sel, options, limit) {
+    if (limit === 0)
+        return [];
+    var query = (0, css_select_1._compileToken)(sel, options, root);
+    return find(root, query, limit);
+}
+function find(root, query, limit) {
+    if (limit === void 0) { limit = Infinity; }
+    var elems = (0, css_select_1.prepareContext)(root, DomUtils, query.shouldTestNextSiblings);
+    return DomUtils.find(function (node) { return DomUtils.isTag(node) && query(node); }, elems, true, limit);
+}
+function filterElements(elements, sel, options) {
+    var els = (Array.isArray(elements) ? elements : [elements]).filter(DomUtils.isTag);
+    if (els.length === 0)
+        return els;
+    var query = (0, css_select_1._compileToken)(sel, options);
+    return els.filter(query);
+}

node/node_modules/cheerio-select/lib/positionals.d.ts

@@ -0,0 +1,10 @@
+import type { Selector, PseudoSelector } from "css-what";
+export declare type Filter = "first" | "last" | "eq" | "nth" | "gt" | "lt" | "even" | "odd" | "not";
+export declare const filterNames: Set<string>;
+export interface CheerioSelector extends PseudoSelector {
+    name: Filter;
+    data: string | null;
+}
+export declare function isFilter(s: Selector): s is CheerioSelector;
+export declare function getLimit(filter: Filter, data: string | null): number;
+//# sourceMappingURL=positionals.d.ts.map

node/node_modules/cheerio-select/lib/positionals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"positionals.d.ts","sourceRoot":"","sources":["../src/positionals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAEzD,oBAAY,MAAM,GACZ,OAAO,GACP,MAAM,GACN,IAAI,GACJ,KAAK,GACL,IAAI,GACJ,IAAI,GACJ,MAAM,GACN,KAAK,GACL,KAAK,CAAC;AACZ,eAAO,MAAM,WAAW,EAAE,GAAG,CAAC,MAAM,CASlC,CAAC;AAEH,MAAM,WAAW,eAAgB,SAAQ,cAAc;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;CACvB;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,QAAQ,GAAG,CAAC,IAAI,eAAe,CAS1D;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAgBpE"}

node/node_modules/cheerio-select/lib/positionals.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLimit = exports.isFilter = exports.filterNames = void 0;
+exports.filterNames = new Set([
+    "first",
+    "last",
+    "eq",
+    "gt",
+    "nth",
+    "lt",
+    "even",
+    "odd",
+]);
+function isFilter(s) {
+    if (s.type !== "pseudo")
+        return false;
+    if (exports.filterNames.has(s.name))
+        return true;
+    if (s.name === "not" && Array.isArray(s.data)) {
+        // Only consider `:not` with embedded filters
+        return s.data.some(function (s) { return s.some(isFilter); });
+    }
+    return false;
+}
+exports.isFilter = isFilter;
+function getLimit(filter, data) {
+    var num = data != null ? parseInt(data, 10) : NaN;
+    switch (filter) {
+        case "first":
+            return 1;
+        case "nth":
+        case "eq":
+            return isFinite(num) ? (num >= 0 ? num + 1 : Infinity) : 0;
+        case "lt":
+            return isFinite(num) ? (num >= 0 ? num : Infinity) : 0;
+        case "gt":
+            return isFinite(num) ? Infinity : 0;
+        default:
+            return Infinity;
+    }
+}
+exports.getLimit = getLimit;

node/node_modules/cheerio-select/package.json

@@ -0,0 +1,98 @@
+{
+  "_args": [
+    [
+      "cheerio-select@1.6.0",
+      "F:\\cocorobo\\CocoRoboDesktop\\node"
+    ]
+  ],
+  "_from": "cheerio-select@1.6.0",
+  "_id": "cheerio-select@1.6.0",
+  "_inBundle": false,
+  "_integrity": "sha512-eq0GdBvxVFbqWgmCm7M3XGs1I8oLy/nExUnh6oLqmBditPO9AqQJrkslDpMun/hZ0yyTs8L0m85OHp4ho6Qm9g==",
+  "_location": "/cheerio-select",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "cheerio-select@1.6.0",
+    "name": "cheerio-select",
+    "escapedName": "cheerio-select",
+    "rawSpec": "1.6.0",
+    "saveSpec": null,
+    "fetchSpec": "1.6.0"
+  },
+  "_requiredBy": [
+    "/cheerio"
+  ],
+  "_resolved": "https://registry.npmmirror.com/cheerio-select/-/cheerio-select-1.6.0.tgz",
+  "_spec": "1.6.0",
+  "_where": "F:\\cocorobo\\CocoRoboDesktop\\node",
+  "author": {
+    "name": "Felix Boehm",
+    "email": "me@feedic.com"
+  },
+  "bugs": {
+    "url": "https://github.com/cheeriojs/cheerio-select/issues"
+  },
+  "dependencies": {
+    "css-select": "^4.3.0",
+    "css-what": "^6.0.1",
+    "domelementtype": "^2.2.0",
+    "domhandler": "^4.3.1",
+    "domutils": "^2.8.0"
+  },
+  "description": "CSS selector engine supporting jQuery selectors",
+  "devDependencies": {
+    "@types/jest": "^27.4.1",
+    "@types/node": "^17.0.23",
+    "@typescript-eslint/eslint-plugin": "^5.16.0",
+    "@typescript-eslint/parser": "^5.16.0",
+    "eslint": "^8.12.0",
+    "eslint-config-prettier": "^8.5.0",
+    "htmlparser2": "^7.2.0",
+    "jest": "^27.5.1",
+    "prettier": "^2.6.1",
+    "ts-jest": "^27.1.3",
+    "typescript": "^4.6.3"
+  },
+  "directories": {
+    "lib": "lib/"
+  },
+  "files": [
+    "lib/**/*"
+  ],
+  "funding": {
+    "url": "https://github.com/sponsors/fb55"
+  },
+  "homepage": "https://github.com/cheeriojs/cheerio-select#readme",
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node"
+  },
+  "license": "BSD-2-Clause",
+  "main": "lib/index.js",
+  "name": "cheerio-select",
+  "prettier": {
+    "tabWidth": 4
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/cheeriojs/cheerio-select.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "format": "npm run format:es && npm run format:prettier",
+    "format:es": "npm run lint:es -- --fix",
+    "format:prettier": "npm run format:prettier:raw -- --write",
+    "format:prettier:raw": "prettier '**/*.{ts,md,json,yml}'",
+    "lint": "npm run lint:es && npm run lint:prettier",
+    "lint:es": "eslint src",
+    "lint:prettier": "npm run format:prettier:raw -- --check",
+    "prepare": "npm run build",
+    "test": "npm run test:jest && npm run lint",
+    "test:jest": "jest"
+  },
+  "sideEffects": false,
+  "types": "lib/index.d.ts",
+  "version": "1.6.0"
+}

node/node_modules/cheerio/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Matt Mueller
+
+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.

node/node_modules/cheerio/Readme.md

@@ -0,0 +1,319 @@
+<h1 align="center">cheerio</h1>
+
+<h5 align="center">Fast, flexible & lean implementation of core jQuery designed specifically for the server.</h5>
+
+<div align="center">
+  <a href="https://github.com/cheeriojs/cheerio/actions?query=workflow%3ACI+branch%3Amain">
+    <img src="https://img.shields.io/github/workflow/status/cheeriojs/cheerio/CI/main" alt="Build Status">
+  </a>
+  <a href="https://coveralls.io/github/cheeriojs/cheerio">
+    <img src="https://img.shields.io/coveralls/github/cheeriojs/cheerio/main" alt="Coverage">
+  </a>
+  <a href="#backers">
+    <img src="https://img.shields.io/opencollective/backers/cheerio" alt="OpenCollective backers">
+  </a>
+  <a href="#sponsors">
+    <img src="https://img.shields.io/opencollective/sponsors/cheerio" alt="OpenCollective sponsors">
+  </a>
+</div>
+
+<br>
+
+[中文文档 (Chinese Readme)](https://github.com/cheeriojs/cheerio/wiki/Chinese-README)
+
+```js
+const cheerio = require('cheerio');
+const $ = cheerio.load('<h2 class="title">Hello world</h2>');
+
+$('h2.title').text('Hello there!');
+$('h2').addClass('welcome');
+
+$.html();
+//=> <html><head></head><body><h2 class="title welcome">Hello there!</h2></body></html>
+```
+
+## Note
+
+We are currently working on the 1.0.0 release of cheerio on the `main` branch. The source code for the last published version, `0.22.0`, can be found [here](https://github.com/cheeriojs/cheerio/tree/aa90399c9c02f12432bfff97b8f1c7d8ece7c307).
+
+## Installation
+
+`npm install cheerio`
+
+## Features
+
+**&#10084; Familiar syntax:**
+Cheerio implements a subset of core jQuery. Cheerio removes all the DOM inconsistencies and browser cruft from the jQuery library, revealing its truly gorgeous API.
+
+**&#991; Blazingly fast:**
+Cheerio works with a very simple, consistent DOM model. As a result parsing, manipulating, and rendering are incredibly efficient.
+
+**&#10049; Incredibly flexible:**
+Cheerio wraps around [parse5](https://github.com/inikulin/parse5) parser and can optionally use @FB55's forgiving [htmlparser2](https://github.com/fb55/htmlparser2/). Cheerio can parse nearly any HTML or XML document.
+
+## Cheerio is not a web browser
+
+Cheerio parses markup and provides an API for traversing/manipulating the resulting data structure. It does not interpret the result as a web browser does. Specifically, it does _not_ produce a visual rendering, apply CSS, load external resources, or execute JavaScript. This makes Cheerio **much, much faster than other solutions**. If your use case requires any of this functionality, you should consider projects like [Puppeteer](https://github.com/puppeteer/puppeteer) or [JSDom](https://github.com/jsdom/jsdom).
+
+## API
+
+### Markup example we'll be using:
+
+```html
+<ul id="fruits">
+  <li class="apple">Apple</li>
+  <li class="orange">Orange</li>
+  <li class="pear">Pear</li>
+</ul>
+```
+
+This is the HTML markup we will be using in all of the API examples.
+
+### Loading
+
+First you need to load in the HTML. This step in jQuery is implicit, since jQuery operates on the one, baked-in DOM. With Cheerio, we need to pass in the HTML document.
+
+This is the _preferred_ method:
+
+```js
+// ES6 or TypeScript:
+import * as cheerio from 'cheerio';
+
+// In other environments:
+const cheerio = require('cheerio');
+
+const $ = cheerio.load('<ul id="fruits">...</ul>');
+
+$.html();
+//=> <html><head></head><body><ul id="fruits">...</ul></body></html>
+```
+
+Similar to web browser contexts, `load` will introduce `<html>`, `<head>`, and `<body>` elements if they are not already present. You can set `load`'s third argument to `false` to disable this.
+
+```js
+const $ = cheerio.load('<ul id="fruits">...</ul>', null, false);
+
+$.html();
+//=> '<ul id="fruits">...</ul>'
+```
+
+Optionally, you can also load in the HTML by passing the string as the context:
+
+```js
+$('ul', '<ul id="fruits">...</ul>');
+```
+
+Or as the root:
+
+```js
+$('li', 'ul', '<ul id="fruits">...</ul>');
+```
+
+If you need to modify parsing options for XML input, you may pass an extra
+object to `.load()`:
+
+```js
+const $ = cheerio.load('<ul id="fruits">...</ul>', {
+  xml: {
+    normalizeWhitespace: true,
+  },
+});
+```
+
+The options in the `xml` object are taken directly from [htmlparser2](https://github.com/fb55/htmlparser2/wiki/Parser-options), therefore any options that can be used in `htmlparser2` are valid in cheerio as well. When `xml` is set, the default options are:
+
+```js
+{
+    xmlMode: true,
+    decodeEntities: true, // Decode HTML entities.
+    withStartIndices: false, // Add a `startIndex` property to nodes.
+    withEndIndices: false, // Add an `endIndex` property to nodes.
+}
+```
+
+For a full list of options and their effects, see [domhandler](https://github.com/fb55/DomHandler) and
+[htmlparser2's options](https://github.com/fb55/htmlparser2/wiki/Parser-options).
+
+Some users may wish to parse markup with the `htmlparser2` library, and
+traverse/manipulate the resulting structure with Cheerio. This may be the case
+for those upgrading from pre-1.0 releases of Cheerio (which relied on
+`htmlparser2`), for those dealing with invalid markup (because `htmlparser2` is
+more forgiving), or for those operating in performance-critical situations
+(because `htmlparser2` may be faster in some cases). Note that "more forgiving"
+means `htmlparser2` has error-correcting mechanisms that aren't always a match
+for the standards observed by web browsers. This behavior may be useful when
+parsing non-HTML content.
+
+To support these cases, `load` also accepts a `htmlparser2`-compatible data
+structure as its first argument. Users may install `htmlparser2`, use it to
+parse input, and pass the result to `load`:
+
+```js
+// Usage as of htmlparser2 version 6:
+const htmlparser2 = require('htmlparser2');
+const dom = htmlparser2.parseDocument(document, options);
+
+const $ = cheerio.load(dom);
+```
+
+### Selectors
+
+Cheerio's selector implementation is nearly identical to jQuery's, so the API is very similar.
+
+#### \$( selector, [context], [root] )
+
+`selector` searches within the `context` scope which searches within the `root` scope. `selector` and `context` can be a string expression, DOM Element, array of DOM elements, or cheerio object. `root` is typically the HTML document string.
+
+This selector method is the starting point for traversing and manipulating the document. Like jQuery, it's the primary method for selecting elements in the document.
+
+```js
+$('.apple', '#fruits').text();
+//=> Apple
+
+$('ul .pear').attr('class');
+//=> pear
+
+$('li[class=orange]').html();
+//=> Orange
+```
+
+##### XML Namespaces
+
+You can select with XML Namespaces but [due to the CSS specification](https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#attribute-selectors), the colon (`:`) needs to be escaped for the selector to be valid.
+
+```js
+$('[xml\\:id="main"');
+```
+
+### Rendering
+
+When you're ready to render the document, you can call the `html` method on the "root" selection:
+
+```js
+$.root().html();
+//=>  <html>
+//      <head></head>
+//      <body>
+//        <ul id="fruits">
+//          <li class="apple">Apple</li>
+//          <li class="orange">Orange</li>
+//          <li class="pear">Pear</li>
+//        </ul>
+//      </body>
+//    </html>
+```
+
+If you want to render the [`outerHTML`](https://developer.mozilla.org/en-US/docs/Web/API/Element/outerHTML) of a selection, you can use the `html` utility functon:
+
+```js
+cheerio.html($('.pear'));
+//=> <li class="pear">Pear</li>
+```
+
+By default, `html` will leave some tags open. Sometimes you may instead want to render a valid XML document. For example, you might parse the following XML snippet:
+
+```js
+const $ = cheerio.load(
+  '<media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123"/>'
+);
+```
+
+... and later want to render to XML. To do this, you can use the 'xml' utility function:
+
+```js
+$.xml();
+//=> <media:thumbnail url="http://www.foo.com/keyframe.jpg" width="75" height="50" time="12:05:01.123"/>
+```
+
+You may also render the text content of a Cheerio object using the `text` static method:
+
+```js
+const $ = cheerio.load('This is <em>content</em>.');
+cheerio.text($('body'));
+//=> This is content.
+```
+
+### Plugins
+
+Once you have loaded a document, you may extend the prototype or the equivalent `fn` property with custom plugin methods:
+
+```js
+const $ = cheerio.load('<html><body>Hello, <b>world</b>!</body></html>');
+$.prototype.logHtml = function () {
+  console.log(this.html());
+};
+
+$('body').logHtml(); // logs "Hello, <b>world</b>!" to the console
+```
+
+If you're using TypeScript, you should also add a type definition for your new method:
+
+```ts
+declare module 'cheerio' {
+  interface Cheerio<T> {
+    logHtml(this: Cheerio<T>): void;
+  }
+}
+```
+
+### The "DOM Node" object
+
+Cheerio collections are made up of objects that bear some resemblance to [browser-based DOM nodes](https://developer.mozilla.org/en-US/docs/Web/API/Node). You can expect them to define the following properties:
+
+- `tagName`
+- `parentNode`
+- `previousSibling`
+- `nextSibling`
+- `nodeValue`
+- `firstChild`
+- `childNodes`
+- `lastChild`
+
+## Screencasts
+
+[https://vimeo.com/31950192](https://vimeo.com/31950192)
+
+> This video tutorial is a follow-up to Nettut's "How to Scrape Web Pages with Node.js and jQuery", using cheerio instead of JSDOM + jQuery. This video shows how easy it is to use cheerio and how much faster cheerio is than JSDOM + jQuery.
+
+## Cheerio in the real world
+
+Are you using cheerio in production? Add it to the [wiki](https://github.com/cheeriojs/cheerio/wiki/Cheerio-in-Production)!
+
+## Sponsors
+
+Does your company use Cheerio in production? Please consider [sponsoring this project](https://github.com/cheeriojs/cheerio?sponsor=1)! Your help will allow maintainers to dedicate more time and resources to its development and support.
+
+<!-- BEGIN SPONSORS: sponsor -->
+
+<a href="https://substack.com/" target="_blank">![Substack](https://avatars.githubusercontent.com/u/53023767?v=4&s=128)</a>
+<a href="https://www.airbnb.com/" target="_blank">![Airbnb](https://images.opencollective.com/airbnb/d327d66/logo.png)</a>
+
+<!-- END SPONSORS -->
+
+## Backers
+
+[Become a backer](https://github.com/cheeriojs/cheerio?sponsor=1) to show your support for Cheerio and help us maintain and improve this open source project.
+
+<!-- BEGIN SPONSORS: backer -->
+
+<a href="https://medium.com/norch" target="_blank">![Espen Klem](https://images.opencollective.com/espenklem/6075b19/avatar.png)</a>
+<a href="https://nishant-singh.com" target="_blank">![Nishant Singh](https://avatars.githubusercontent.com/u/10304344?u=9cd1389a1a8211b64979ca3693f96d90f5bf0be9&v=4&s=128)</a>
+
+<!-- END SPONSORS -->
+
+## Special Thanks
+
+This library stands on the shoulders of some incredible developers. A special thanks to:
+
+**&#8226; @FB55 for node-htmlparser2 & CSSSelect:**
+Felix has a knack for writing speedy parsing engines. He completely re-wrote both @tautologistic's `node-htmlparser` and @harry's `node-soupselect` from the ground up, making both of them much faster and more flexible. Cheerio would not be possible without his foundational work
+
+**&#8226; @jQuery team for jQuery:**
+The core API is the best of its class and despite dealing with all the browser inconsistencies the code base is extremely clean and easy to follow. Much of cheerio's implementation and documentation is from jQuery. Thanks guys.
+
+**&#8226; @visionmedia:**
+The style, the structure, the open-source"-ness" of this library comes from studying TJ's style and using many of his libraries. This dude consistently pumps out high-quality libraries and has always been more than willing to help or answer questions. You rock TJ.
+
+## License
+
+MIT

node/node_modules/cheerio/lib/api/attributes.d.ts

@@ -0,0 +1,317 @@
+/**
+ * Methods for getting and modifying attributes.
+ *
+ * @module cheerio/attributes
+ */
+import type { Node, Element } from 'domhandler';
+import type { Cheerio } from '../cheerio';
+/**
+ * Method for getting attributes. Gets the attribute value for only the first
+ * element in the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('ul').attr('id');
+ * //=> fruits
+ * ```
+ *
+ * @param name - Name of the attribute.
+ * @returns The attribute's value.
+ * @see {@link https://api.jquery.com/attr/}
+ */
+export declare function attr<T extends Node>(this: Cheerio<T>, name: string): string | undefined;
+/**
+ * Method for getting all attributes and their values of the first element in
+ * the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('ul').attr();
+ * //=> { id: 'fruits' }
+ * ```
+ *
+ * @returns The attribute's values.
+ * @see {@link https://api.jquery.com/attr/}
+ */
+export declare function attr<T extends Node>(this: Cheerio<T>): Record<string, string>;
+/**
+ * Method for setting attributes. Sets the attribute value for only the first
+ * element in the matched set. If you set an attribute's value to `null`, you
+ * remove that attribute. You may also pass a `map` and `function`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.apple').attr('id', 'favorite').html();
+ * //=> <li class="apple" id="favorite">Apple</li>
+ * ```
+ *
+ * @param name - Name of the attribute.
+ * @param value - The new value of the attribute.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/attr/}
+ */
+export declare function attr<T extends Node>(this: Cheerio<T>, name: string, value?: string | null | ((this: Element, i: number, attrib: string) => string | null)): Cheerio<T>;
+/**
+ * Method for setting multiple attributes at once. Sets the attribute value for
+ * only the first element in the matched set. If you set an attribute's value to
+ * `null`, you remove that attribute.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.apple').attr({ id: 'favorite' }).html();
+ * //=> <li class="apple" id="favorite">Apple</li>
+ * ```
+ *
+ * @param values - Map of attribute names and values.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/attr/}
+ */
+export declare function attr<T extends Node>(this: Cheerio<T>, values: Record<string, string | null>): Cheerio<T>;
+interface StyleProp {
+    length: number;
+    [key: string]: string | number;
+    [index: number]: string;
+}
+/**
+ * Method for getting and setting properties. Gets the property value for only
+ * the first element in the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('input[type="checkbox"]').prop('checked');
+ * //=> false
+ *
+ * $('input[type="checkbox"]').prop('checked', true).val();
+ * //=> ok
+ * ```
+ *
+ * @param name - Name of the property.
+ * @param value - If specified set the property to this.
+ * @returns If `value` is specified the instance itself, otherwise the prop's value.
+ * @see {@link https://api.jquery.com/prop/}
+ */
+export declare function prop<T extends Node>(this: Cheerio<T>, name: 'tagName' | 'nodeName'): T extends Element ? string : undefined;
+export declare function prop<T extends Node>(this: Cheerio<T>, name: 'innerHTML' | 'outerHTML'): string | null;
+export declare function prop<T extends Node>(this: Cheerio<T>, name: 'style'): StyleProp;
+export declare function prop<T extends Node, K extends keyof Element>(this: Cheerio<T>, name: K): Element[K];
+export declare function prop<T extends Node, K extends keyof Element>(this: Cheerio<T>, name: K, value: Element[K] | ((this: Element, i: number, prop: K) => Element[keyof Element])): Cheerio<T>;
+export declare function prop<T extends Node>(this: Cheerio<T>, name: Record<string, string | Element[keyof Element] | boolean>): Cheerio<T>;
+export declare function prop<T extends Node>(this: Cheerio<T>, name: string, value: string | boolean | null | ((this: Element, i: number, prop: string) => string | boolean)): Cheerio<T>;
+export declare function prop<T extends Node>(this: Cheerio<T>, name: string): string;
+/**
+ * Method for getting data attributes, for only the first element in the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('<div data-apple-color="red"></div>').data('apple-color');
+ * //=> 'red'
+ * ```
+ *
+ * @param name - Name of the data attribute.
+ * @returns The data attribute's value.
+ * @see {@link https://api.jquery.com/data/}
+ */
+export declare function data<T extends Node>(this: Cheerio<T>, name: string): unknown | undefined;
+/**
+ * Method for getting all of an element's data attributes, for only the first
+ * element in the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('<div data-apple-color="red"></div>').data();
+ * //=> { appleColor: 'red' }
+ * ```
+ *
+ * @returns The data attribute's values.
+ * @see {@link https://api.jquery.com/data/}
+ */
+export declare function data<T extends Node>(this: Cheerio<T>): Record<string, unknown>;
+/**
+ * Method for setting data attributes, for only the first element in the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * const apple = $('.apple').data('kind', 'mac');
+ *
+ * apple.data('kind');
+ * //=> 'mac'
+ * ```
+ *
+ * @param name - Name of the data attribute.
+ * @param value - The new value.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/data/}
+ */
+export declare function data<T extends Node>(this: Cheerio<T>, name: string, value: unknown): Cheerio<T>;
+/**
+ * Method for setting multiple data attributes at once, for only the first
+ * element in the matched set.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * const apple = $('.apple').data({ kind: 'mac' });
+ *
+ * apple.data('kind');
+ * //=> 'mac'
+ * ```
+ *
+ * @param values - Map of names to values.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/data/}
+ */
+export declare function data<T extends Node>(this: Cheerio<T>, values: Record<string, unknown>): Cheerio<T>;
+/**
+ * Method for getting the value of input, select, and textarea. Note: Support
+ * for `map`, and `function` has not been added yet.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('input[type="text"]').val();
+ * //=> input_text
+ * ```
+ *
+ * @returns The value.
+ * @see {@link https://api.jquery.com/val/}
+ */
+export declare function val<T extends Node>(this: Cheerio<T>): string | undefined | string[];
+/**
+ * Method for setting the value of input, select, and textarea. Note: Support
+ * for `map`, and `function` has not been added yet.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('input[type="text"]').val('test').html();
+ * //=> <input type="text" value="test"/>
+ * ```
+ *
+ * @param value - The new value.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/val/}
+ */
+export declare function val<T extends Node>(this: Cheerio<T>, value: string | string[]): Cheerio<T>;
+/**
+ * Method for removing attributes by `name`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').removeAttr('class').html();
+ * //=> <li>Pear</li>
+ *
+ * $('.apple').attr('id', 'favorite');
+ * $('.apple').removeAttr('id class').html();
+ * //=> <li>Apple</li>
+ * ```
+ *
+ * @param name - Name of the attribute.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/removeAttr/}
+ */
+export declare function removeAttr<T extends Node>(this: Cheerio<T>, name: string): Cheerio<T>;
+/**
+ * Check to see if *any* of the matched elements have the given `className`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').hasClass('pear');
+ * //=> true
+ *
+ * $('apple').hasClass('fruit');
+ * //=> false
+ *
+ * $('li').hasClass('pear');
+ * //=> true
+ * ```
+ *
+ * @param className - Name of the class.
+ * @returns Indicates if an element has the given `className`.
+ * @see {@link https://api.jquery.com/hasClass/}
+ */
+export declare function hasClass<T extends Node>(this: Cheerio<T>, className: string): boolean;
+/**
+ * Adds class(es) to all of the matched elements. Also accepts a `function`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').addClass('fruit').html();
+ * //=> <li class="pear fruit">Pear</li>
+ *
+ * $('.apple').addClass('fruit red').html();
+ * //=> <li class="apple fruit red">Apple</li>
+ * ```
+ *
+ * @param value - Name of new class.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/addClass/}
+ */
+export declare function addClass<T extends Node, R extends ArrayLike<T>>(this: R, value?: string | ((this: Element, i: number, className: string) => string | undefined)): R;
+/**
+ * Removes one or more space-separated classes from the selected elements. If no
+ * `className` is defined, all classes will be removed. Also accepts a `function`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').removeClass('pear').html();
+ * //=> <li class="">Pear</li>
+ *
+ * $('.apple').addClass('red').removeClass().html();
+ * //=> <li class="">Apple</li>
+ * ```
+ *
+ * @param name - Name of the class. If not specified, removes all elements.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/removeClass/}
+ */
+export declare function removeClass<T extends Node, R extends ArrayLike<T>>(this: R, name?: string | ((this: Element, i: number, className: string) => string | undefined)): R;
+/**
+ * Add or remove class(es) from the matched elements, depending on either the
+ * class's presence or the value of the switch argument. Also accepts a `function`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.apple.green').toggleClass('fruit green red').html();
+ * //=> <li class="apple fruit red">Apple</li>
+ *
+ * $('.apple.green').toggleClass('fruit green red', true).html();
+ * //=> <li class="apple green fruit red">Apple</li>
+ * ```
+ *
+ * @param value - Name of the class. Can also be a function.
+ * @param stateVal - If specified the state of the class.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/toggleClass/}
+ */
+export declare function toggleClass<T extends Node, R extends ArrayLike<T>>(this: R, value?: string | ((this: Element, i: number, className: string, stateVal?: boolean) => string), stateVal?: boolean): R;
+export {};
+//# sourceMappingURL=attributes.d.ts.map

node/node_modules/cheerio/lib/api/attributes.js

@@ -0,0 +1,591 @@
+"use strict";
+/**
+ * Methods for getting and modifying attributes.
+ *
+ * @module cheerio/attributes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toggleClass = exports.removeClass = exports.addClass = exports.hasClass = exports.removeAttr = exports.val = exports.data = exports.prop = exports.attr = void 0;
+var static_1 = require("../static");
+var utils_1 = require("../utils");
+var hasOwn = Object.prototype.hasOwnProperty;
+var rspace = /\s+/;
+var dataAttrPrefix = 'data-';
+/*
+ * Lookup table for coercing string data-* attributes to their corresponding
+ * JavaScript primitives
+ */
+var primitives = {
+    null: null,
+    true: true,
+    false: false,
+};
+// Attributes that are booleans
+var rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i;
+// Matches strings that look like JSON objects or arrays
+var rbrace = /^{[^]*}$|^\[[^]*]$/;
+function getAttr(elem, name, xmlMode) {
+    var _a;
+    if (!elem || !utils_1.isTag(elem))
+        return undefined;
+    (_a = elem.attribs) !== null && _a !== void 0 ? _a : (elem.attribs = {});
+    // Return the entire attribs object if no attribute specified
+    if (!name) {
+        return elem.attribs;
+    }
+    if (hasOwn.call(elem.attribs, name)) {
+        // Get the (decoded) attribute
+        return !xmlMode && rboolean.test(name) ? name : elem.attribs[name];
+    }
+    // Mimic the DOM and return text content as value for `option's`
+    if (elem.name === 'option' && name === 'value') {
+        return static_1.text(elem.children);
+    }
+    // Mimic DOM with default value for radios/checkboxes
+    if (elem.name === 'input' &&
+        (elem.attribs.type === 'radio' || elem.attribs.type === 'checkbox') &&
+        name === 'value') {
+        return 'on';
+    }
+    return undefined;
+}
+/**
+ * Sets the value of an attribute. The attribute will be deleted if the value is `null`.
+ *
+ * @private
+ * @param el - The element to set the attribute on.
+ * @param name - The attribute's name.
+ * @param value - The attribute's value.
+ */
+function setAttr(el, name, value) {
+    if (value === null) {
+        removeAttribute(el, name);
+    }
+    else {
+        el.attribs[name] = "" + value;
+    }
+}
+function attr(name, value) {
+    // Set the value (with attr map support)
+    if (typeof name === 'object' || value !== undefined) {
+        if (typeof value === 'function') {
+            if (typeof name !== 'string') {
+                {
+                    throw new Error('Bad combination of arguments.');
+                }
+            }
+            return utils_1.domEach(this, function (el, i) {
+                if (utils_1.isTag(el))
+                    setAttr(el, name, value.call(el, i, el.attribs[name]));
+            });
+        }
+        return utils_1.domEach(this, function (el) {
+            if (!utils_1.isTag(el))
+                return;
+            if (typeof name === 'object') {
+                Object.keys(name).forEach(function (objName) {
+                    var objValue = name[objName];
+                    setAttr(el, objName, objValue);
+                });
+            }
+            else {
+                setAttr(el, name, value);
+            }
+        });
+    }
+    return arguments.length > 1
+        ? this
+        : getAttr(this[0], name, this.options.xmlMode);
+}
+exports.attr = attr;
+/**
+ * Gets a node's prop.
+ *
+ * @private
+ * @category Attributes
+ * @param el - Elenent to get the prop of.
+ * @param name - Name of the prop.
+ * @returns The prop's value.
+ */
+function getProp(el, name, xmlMode) {
+    if (!el || !utils_1.isTag(el))
+        return;
+    return name in el
+        ? // @ts-expect-error TS doesn't like us accessing the value directly here.
+            el[name]
+        : !xmlMode && rboolean.test(name)
+            ? getAttr(el, name, false) !== undefined
+            : getAttr(el, name, xmlMode);
+}
+/**
+ * Sets the value of a prop.
+ *
+ * @private
+ * @param el - The element to set the prop on.
+ * @param name - The prop's name.
+ * @param value - The prop's value.
+ */
+function setProp(el, name, value, xmlMode) {
+    if (name in el) {
+        // @ts-expect-error Overriding value
+        el[name] = value;
+    }
+    else {
+        setAttr(el, name, !xmlMode && rboolean.test(name) ? (value ? '' : null) : "" + value);
+    }
+}
+function prop(name, value) {
+    var _this = this;
+    if (typeof name === 'string' && value === undefined) {
+        switch (name) {
+            case 'style': {
+                var property_1 = this.css();
+                var keys = Object.keys(property_1);
+                keys.forEach(function (p, i) {
+                    property_1[i] = p;
+                });
+                property_1.length = keys.length;
+                return property_1;
+            }
+            case 'tagName':
+            case 'nodeName': {
+                var el = this[0];
+                return utils_1.isTag(el) ? el.name.toUpperCase() : undefined;
+            }
+            case 'outerHTML':
+                return this.clone().wrap('<container />').parent().html();
+            case 'innerHTML':
+                return this.html();
+            default:
+                return getProp(this[0], name, this.options.xmlMode);
+        }
+    }
+    if (typeof name === 'object' || value !== undefined) {
+        if (typeof value === 'function') {
+            if (typeof name === 'object') {
+                throw new Error('Bad combination of arguments.');
+            }
+            return utils_1.domEach(this, function (el, i) {
+                if (utils_1.isTag(el))
+                    setProp(el, name, value.call(el, i, getProp(el, name, _this.options.xmlMode)), _this.options.xmlMode);
+            });
+        }
+        return utils_1.domEach(this, function (el) {
+            if (!utils_1.isTag(el))
+                return;
+            if (typeof name === 'object') {
+                Object.keys(name).forEach(function (key) {
+                    var val = name[key];
+                    setProp(el, key, val, _this.options.xmlMode);
+                });
+            }
+            else {
+                setProp(el, name, value, _this.options.xmlMode);
+            }
+        });
+    }
+    return undefined;
+}
+exports.prop = prop;
+/**
+ * Sets the value of a data attribute.
+ *
+ * @private
+ * @param el - The element to set the data attribute on.
+ * @param name - The data attribute's name.
+ * @param value - The data attribute's value.
+ */
+function setData(el, name, value) {
+    var _a;
+    var elem = el;
+    (_a = elem.data) !== null && _a !== void 0 ? _a : (elem.data = {});
+    if (typeof name === 'object')
+        Object.assign(elem.data, name);
+    else if (typeof name === 'string' && value !== undefined) {
+        elem.data[name] = value;
+    }
+}
+/**
+ * Read the specified attribute from the equivalent HTML5 `data-*` attribute,
+ * and (if present) cache the value in the node's internal data store. If no
+ * attribute name is specified, read *all* HTML5 `data-*` attributes in this manner.
+ *
+ * @private
+ * @category Attributes
+ * @param el - Elenent to get the data attribute of.
+ * @param name - Name of the data attribute.
+ * @returns The data attribute's value, or a map with all of the data attribute.
+ */
+function readData(el, name) {
+    var domNames;
+    var jsNames;
+    var value;
+    if (name == null) {
+        domNames = Object.keys(el.attribs).filter(function (attrName) {
+            return attrName.startsWith(dataAttrPrefix);
+        });
+        jsNames = domNames.map(function (domName) {
+            return utils_1.camelCase(domName.slice(dataAttrPrefix.length));
+        });
+    }
+    else {
+        domNames = [dataAttrPrefix + utils_1.cssCase(name)];
+        jsNames = [name];
+    }
+    for (var idx = 0; idx < domNames.length; ++idx) {
+        var domName = domNames[idx];
+        var jsName = jsNames[idx];
+        if (hasOwn.call(el.attribs, domName) &&
+            !hasOwn.call(el.data, jsName)) {
+            value = el.attribs[domName];
+            if (hasOwn.call(primitives, value)) {
+                value = primitives[value];
+            }
+            else if (value === String(Number(value))) {
+                value = Number(value);
+            }
+            else if (rbrace.test(value)) {
+                try {
+                    value = JSON.parse(value);
+                }
+                catch (e) {
+                    /* Ignore */
+                }
+            }
+            el.data[jsName] = value;
+        }
+    }
+    return name == null ? el.data : value;
+}
+function data(name, value) {
+    var _a;
+    var elem = this[0];
+    if (!elem || !utils_1.isTag(elem))
+        return;
+    var dataEl = elem;
+    (_a = dataEl.data) !== null && _a !== void 0 ? _a : (dataEl.data = {});
+    // Return the entire data object if no data specified
+    if (!name) {
+        return readData(dataEl);
+    }
+    // Set the value (with attr map support)
+    if (typeof name === 'object' || value !== undefined) {
+        utils_1.domEach(this, function (el) {
+            if (utils_1.isTag(el))
+                if (typeof name === 'object')
+                    setData(el, name);
+                else
+                    setData(el, name, value);
+        });
+        return this;
+    }
+    if (hasOwn.call(dataEl.data, name)) {
+        return dataEl.data[name];
+    }
+    return readData(dataEl, name);
+}
+exports.data = data;
+function val(value) {
+    var querying = arguments.length === 0;
+    var element = this[0];
+    if (!element || !utils_1.isTag(element))
+        return querying ? undefined : this;
+    switch (element.name) {
+        case 'textarea':
+            return this.text(value);
+        case 'select': {
+            var option = this.find('option:selected');
+            if (!querying) {
+                if (this.attr('multiple') == null && typeof value === 'object') {
+                    return this;
+                }
+                this.find('option').removeAttr('selected');
+                var values = typeof value !== 'object' ? [value] : value;
+                for (var i = 0; i < values.length; i++) {
+                    this.find("option[value=\"" + values[i] + "\"]").attr('selected', '');
+                }
+                return this;
+            }
+            return this.attr('multiple')
+                ? option.toArray().map(function (el) { return static_1.text(el.children); })
+                : option.attr('value');
+        }
+        case 'input':
+        case 'option':
+            return querying
+                ? this.attr('value')
+                : this.attr('value', value);
+    }
+    return undefined;
+}
+exports.val = val;
+/**
+ * Remove an attribute.
+ *
+ * @private
+ * @param elem - Node to remove attribute from.
+ * @param name - Name of the attribute to remove.
+ */
+function removeAttribute(elem, name) {
+    if (!elem.attribs || !hasOwn.call(elem.attribs, name))
+        return;
+    delete elem.attribs[name];
+}
+/**
+ * Splits a space-separated list of names to individual names.
+ *
+ * @category Attributes
+ * @param names - Names to split.
+ * @returns - Split names.
+ */
+function splitNames(names) {
+    return names ? names.trim().split(rspace) : [];
+}
+/**
+ * Method for removing attributes by `name`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').removeAttr('class').html();
+ * //=> <li>Pear</li>
+ *
+ * $('.apple').attr('id', 'favorite');
+ * $('.apple').removeAttr('id class').html();
+ * //=> <li>Apple</li>
+ * ```
+ *
+ * @param name - Name of the attribute.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/removeAttr/}
+ */
+function removeAttr(name) {
+    var attrNames = splitNames(name);
+    var _loop_1 = function (i) {
+        utils_1.domEach(this_1, function (elem) {
+            if (utils_1.isTag(elem))
+                removeAttribute(elem, attrNames[i]);
+        });
+    };
+    var this_1 = this;
+    for (var i = 0; i < attrNames.length; i++) {
+        _loop_1(i);
+    }
+    return this;
+}
+exports.removeAttr = removeAttr;
+/**
+ * Check to see if *any* of the matched elements have the given `className`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').hasClass('pear');
+ * //=> true
+ *
+ * $('apple').hasClass('fruit');
+ * //=> false
+ *
+ * $('li').hasClass('pear');
+ * //=> true
+ * ```
+ *
+ * @param className - Name of the class.
+ * @returns Indicates if an element has the given `className`.
+ * @see {@link https://api.jquery.com/hasClass/}
+ */
+function hasClass(className) {
+    return this.toArray().some(function (elem) {
+        var clazz = utils_1.isTag(elem) && elem.attribs.class;
+        var idx = -1;
+        if (clazz && className.length) {
+            while ((idx = clazz.indexOf(className, idx + 1)) > -1) {
+                var end = idx + className.length;
+                if ((idx === 0 || rspace.test(clazz[idx - 1])) &&
+                    (end === clazz.length || rspace.test(clazz[end]))) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    });
+}
+exports.hasClass = hasClass;
+/**
+ * Adds class(es) to all of the matched elements. Also accepts a `function`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').addClass('fruit').html();
+ * //=> <li class="pear fruit">Pear</li>
+ *
+ * $('.apple').addClass('fruit red').html();
+ * //=> <li class="apple fruit red">Apple</li>
+ * ```
+ *
+ * @param value - Name of new class.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/addClass/}
+ */
+function addClass(value) {
+    // Support functions
+    if (typeof value === 'function') {
+        return utils_1.domEach(this, function (el, i) {
+            if (utils_1.isTag(el)) {
+                var className = el.attribs.class || '';
+                addClass.call([el], value.call(el, i, className));
+            }
+        });
+    }
+    // Return if no value or not a string or function
+    if (!value || typeof value !== 'string')
+        return this;
+    var classNames = value.split(rspace);
+    var numElements = this.length;
+    for (var i = 0; i < numElements; i++) {
+        var el = this[i];
+        // If selected element isn't a tag, move on
+        if (!utils_1.isTag(el))
+            continue;
+        // If we don't already have classes — always set xmlMode to false here, as it doesn't matter for classes
+        var className = getAttr(el, 'class', false);
+        if (!className) {
+            setAttr(el, 'class', classNames.join(' ').trim());
+        }
+        else {
+            var setClass = " " + className + " ";
+            // Check if class already exists
+            for (var j = 0; j < classNames.length; j++) {
+                var appendClass = classNames[j] + " ";
+                if (!setClass.includes(" " + appendClass))
+                    setClass += appendClass;
+            }
+            setAttr(el, 'class', setClass.trim());
+        }
+    }
+    return this;
+}
+exports.addClass = addClass;
+/**
+ * Removes one or more space-separated classes from the selected elements. If no
+ * `className` is defined, all classes will be removed. Also accepts a `function`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.pear').removeClass('pear').html();
+ * //=> <li class="">Pear</li>
+ *
+ * $('.apple').addClass('red').removeClass().html();
+ * //=> <li class="">Apple</li>
+ * ```
+ *
+ * @param name - Name of the class. If not specified, removes all elements.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/removeClass/}
+ */
+function removeClass(name) {
+    // Handle if value is a function
+    if (typeof name === 'function') {
+        return utils_1.domEach(this, function (el, i) {
+            if (utils_1.isTag(el))
+                removeClass.call([el], name.call(el, i, el.attribs.class || ''));
+        });
+    }
+    var classes = splitNames(name);
+    var numClasses = classes.length;
+    var removeAll = arguments.length === 0;
+    return utils_1.domEach(this, function (el) {
+        if (!utils_1.isTag(el))
+            return;
+        if (removeAll) {
+            // Short circuit the remove all case as this is the nice one
+            el.attribs.class = '';
+        }
+        else {
+            var elClasses = splitNames(el.attribs.class);
+            var changed = false;
+            for (var j = 0; j < numClasses; j++) {
+                var index = elClasses.indexOf(classes[j]);
+                if (index >= 0) {
+                    elClasses.splice(index, 1);
+                    changed = true;
+                    /*
+                     * We have to do another pass to ensure that there are not duplicate
+                     * classes listed
+                     */
+                    j--;
+                }
+            }
+            if (changed) {
+                el.attribs.class = elClasses.join(' ');
+            }
+        }
+    });
+}
+exports.removeClass = removeClass;
+/**
+ * Add or remove class(es) from the matched elements, depending on either the
+ * class's presence or the value of the switch argument. Also accepts a `function`.
+ *
+ * @category Attributes
+ * @example
+ *
+ * ```js
+ * $('.apple.green').toggleClass('fruit green red').html();
+ * //=> <li class="apple fruit red">Apple</li>
+ *
+ * $('.apple.green').toggleClass('fruit green red', true).html();
+ * //=> <li class="apple green fruit red">Apple</li>
+ * ```
+ *
+ * @param value - Name of the class. Can also be a function.
+ * @param stateVal - If specified the state of the class.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/toggleClass/}
+ */
+function toggleClass(value, stateVal) {
+    // Support functions
+    if (typeof value === 'function') {
+        return utils_1.domEach(this, function (el, i) {
+            if (utils_1.isTag(el)) {
+                toggleClass.call([el], value.call(el, i, el.attribs.class || '', stateVal), stateVal);
+            }
+        });
+    }
+    // Return if no value or not a string or function
+    if (!value || typeof value !== 'string')
+        return this;
+    var classNames = value.split(rspace);
+    var numClasses = classNames.length;
+    var state = typeof stateVal === 'boolean' ? (stateVal ? 1 : -1) : 0;
+    var numElements = this.length;
+    for (var i = 0; i < numElements; i++) {
+        var el = this[i];
+        // If selected element isn't a tag, move on
+        if (!utils_1.isTag(el))
+            continue;
+        var elementClasses = splitNames(el.attribs.class);
+        // Check if class already exists
+        for (var j = 0; j < numClasses; j++) {
+            // Check if the class name is currently defined
+            var index = elementClasses.indexOf(classNames[j]);
+            // Add if stateValue === true or we are toggling and there is no value
+            if (state >= 0 && index < 0) {
+                elementClasses.push(classNames[j]);
+            }
+            else if (state <= 0 && index >= 0) {
+                // Otherwise remove but only if the item exists
+                elementClasses.splice(index, 1);
+            }
+        }
+        el.attribs.class = elementClasses.join(' ');
+    }
+    return this;
+}
+exports.toggleClass = toggleClass;

node/node_modules/cheerio/lib/api/css.d.ts

@@ -0,0 +1,41 @@
+import type { Element, Node } from 'domhandler';
+import type { Cheerio } from '../cheerio';
+/**
+ * Get the value of a style property for the first element in the set of matched elements.
+ *
+ * @category CSS
+ * @param names - Optionally the names of the property of interest.
+ * @returns A map of all of the style properties.
+ * @see {@link https://api.jquery.com/css/}
+ */
+export declare function css<T extends Node>(this: Cheerio<T>, names?: string[]): Record<string, string>;
+/**
+ * Get the value of a style property for the first element in the set of matched elements.
+ *
+ * @category CSS
+ * @param names - The name of the property.
+ * @returns The property value for the given name.
+ * @see {@link https://api.jquery.com/css/}
+ */
+export declare function css<T extends Node>(this: Cheerio<T>, name: string): string | undefined;
+/**
+ * Set one CSS property for every matched element.
+ *
+ * @category CSS
+ * @param prop - The name of the property.
+ * @param val - The new value.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/css/}
+ */
+export declare function css<T extends Node>(this: Cheerio<T>, prop: string, val: string | ((this: Element, i: number, style: string) => string | undefined)): Cheerio<T>;
+/**
+ * Set multiple CSS properties for every matched element.
+ *
+ * @category CSS
+ * @param prop - The name of the property.
+ * @param val - The new value.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/css/}
+ */
+export declare function css<T extends Node>(this: Cheerio<T>, prop: Record<string, string>): Cheerio<T>;
+//# sourceMappingURL=css.d.ts.map

node/node_modules/cheerio/lib/api/css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../src/api/css.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,IAAI,EAChC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAChB,KAAK,CAAC,EAAE,MAAM,EAAE,GACf,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAC1B;;;;;;;GAOG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,IAAI,EAChC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAChB,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,SAAS,CAAC;AACtB;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,IAAI,EAChC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAChB,IAAI,EAAE,MAAM,EACZ,GAAG,EACC,MAAM,GACN,CAAC,CAAC,IAAI,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC,GACpE,OAAO,CAAC,CAAC,CAAC,CAAC;AACd;;;;;;;;GAQG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,IAAI,EAChC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,EAChB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B,OAAO,CAAC,CAAC,CAAC,CAAC"}

node/node_modules/cheerio/lib/api/css.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.css = void 0;
+var utils_1 = require("../utils");
+function css(prop, val) {
+    if ((prop != null && val != null) ||
+        // When `prop` is a "plain" object
+        (typeof prop === 'object' && !Array.isArray(prop))) {
+        return utils_1.domEach(this, function (el, i) {
+            if (utils_1.isTag(el)) {
+                // `prop` can't be an array here anymore.
+                setCss(el, prop, val, i);
+            }
+        });
+    }
+    return getCss(this[0], prop);
+}
+exports.css = css;
+/**
+ * Set styles of all elements.
+ *
+ * @private
+ * @param el - Element to set style of.
+ * @param prop - Name of property.
+ * @param value - Value to set property to.
+ * @param idx - Optional index within the selection.
+ */
+function setCss(el, prop, value, idx) {
+    if (typeof prop === 'string') {
+        var styles = getCss(el);
+        var val = typeof value === 'function' ? value.call(el, idx, styles[prop]) : value;
+        if (val === '') {
+            delete styles[prop];
+        }
+        else if (val != null) {
+            styles[prop] = val;
+        }
+        el.attribs.style = stringify(styles);
+    }
+    else if (typeof prop === 'object') {
+        Object.keys(prop).forEach(function (k, i) {
+            setCss(el, k, prop[k], i);
+        });
+    }
+}
+function getCss(el, prop) {
+    if (!el || !utils_1.isTag(el))
+        return;
+    var styles = parse(el.attribs.style);
+    if (typeof prop === 'string') {
+        return styles[prop];
+    }
+    if (Array.isArray(prop)) {
+        var newStyles_1 = {};
+        prop.forEach(function (item) {
+            if (styles[item] != null) {
+                newStyles_1[item] = styles[item];
+            }
+        });
+        return newStyles_1;
+    }
+    return styles;
+}
+/**
+ * Stringify `obj` to styles.
+ *
+ * @private
+ * @category CSS
+ * @param obj - Object to stringify.
+ * @returns The serialized styles.
+ */
+function stringify(obj) {
+    return Object.keys(obj).reduce(function (str, prop) { return "" + str + (str ? ' ' : '') + prop + ": " + obj[prop] + ";"; }, '');
+}
+/**
+ * Parse `styles`.
+ *
+ * @private
+ * @category CSS
+ * @param styles - Styles to be parsed.
+ * @returns The parsed styles.
+ */
+function parse(styles) {
+    styles = (styles || '').trim();
+    if (!styles)
+        return {};
+    return styles.split(';').reduce(function (obj, str) {
+        var n = str.indexOf(':');
+        // Skip if there is no :, or if it is the first/last character
+        if (n < 1 || n === str.length - 1)
+            return obj;
+        obj[str.slice(0, n).trim()] = str.slice(n + 1).trim();
+        return obj;
+    }, {});
+}

node/node_modules/cheerio/lib/api/forms.d.ts

@@ -0,0 +1,31 @@
+import type { Node } from 'domhandler';
+import type { Cheerio } from '../cheerio';
+/**
+ * Encode a set of form elements as a string for submission.
+ *
+ * @category Forms
+ * @returns The serialized form.
+ * @see {@link https://api.jquery.com/serialize/}
+ */
+export declare function serialize<T extends Node>(this: Cheerio<T>): string;
+interface SerializedField {
+    name: string;
+    value: string;
+}
+/**
+ * Encode a set of form elements as an array of names and values.
+ *
+ * @category Forms
+ * @example
+ *
+ * ```js
+ * $('<form><input name="foo" value="bar" /></form>').serializeArray();
+ * //=> [ { name: 'foo', value: 'bar' } ]
+ * ```
+ *
+ * @returns The serialized form.
+ * @see {@link https://api.jquery.com/serializeArray/}
+ */
+export declare function serializeArray<T extends Node>(this: Cheerio<T>): SerializedField[];
+export {};
+//# sourceMappingURL=forms.d.ts.map

node/node_modules/cheerio/lib/api/forms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forms.d.ts","sourceRoot":"","sources":["../../src/api/forms.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAW1C;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAYlE;AAED,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,IAAI,EAC3C,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,GACf,eAAe,EAAE,CAsCnB"}

node/node_modules/cheerio/lib/api/forms.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeArray = exports.serialize = void 0;
+var utils_1 = require("../utils");
+/*
+ * https://github.com/jquery/jquery/blob/2.1.3/src/manipulation/var/rcheckableType.js
+ * https://github.com/jquery/jquery/blob/2.1.3/src/serialize.js
+ */
+var submittableSelector = 'input,select,textarea,keygen';
+var r20 = /%20/g;
+var rCRLF = /\r?\n/g;
+/**
+ * Encode a set of form elements as a string for submission.
+ *
+ * @category Forms
+ * @returns The serialized form.
+ * @see {@link https://api.jquery.com/serialize/}
+ */
+function serialize() {
+    // Convert form elements into name/value objects
+    var arr = this.serializeArray();
+    // Serialize each element into a key/value string
+    var retArr = arr.map(function (data) {
+        return encodeURIComponent(data.name) + "=" + encodeURIComponent(data.value);
+    });
+    // Return the resulting serialization
+    return retArr.join('&').replace(r20, '+');
+}
+exports.serialize = serialize;
+/**
+ * Encode a set of form elements as an array of names and values.
+ *
+ * @category Forms
+ * @example
+ *
+ * ```js
+ * $('<form><input name="foo" value="bar" /></form>').serializeArray();
+ * //=> [ { name: 'foo', value: 'bar' } ]
+ * ```
+ *
+ * @returns The serialized form.
+ * @see {@link https://api.jquery.com/serializeArray/}
+ */
+function serializeArray() {
+    var _this = this;
+    // Resolve all form elements from either forms or collections of form elements
+    return this.map(function (_, elem) {
+        var $elem = _this._make(elem);
+        if (utils_1.isTag(elem) && elem.name === 'form') {
+            return $elem.find(submittableSelector).toArray();
+        }
+        return $elem.filter(submittableSelector).toArray();
+    })
+        .filter(
+    // Verify elements have a name (`attr.name`) and are not disabled (`:enabled`)
+    '[name!=""]:enabled' +
+        // And cannot be clicked (`[type=submit]`) or are used in `x-www-form-urlencoded` (`[type=file]`)
+        ':not(:submit, :button, :image, :reset, :file)' +
+        // And are either checked/don't have a checkable state
+        ':matches([checked], :not(:checkbox, :radio))'
+    // Convert each of the elements to its value(s)
+    )
+        .map(function (_, elem) {
+        var _a;
+        var $elem = _this._make(elem);
+        var name = $elem.attr('name'); // We have filtered for elements with a name before.
+        // If there is no value set (e.g. `undefined`, `null`), then default value to empty
+        var value = (_a = $elem.val()) !== null && _a !== void 0 ? _a : '';
+        // If we have an array of values (e.g. `<select multiple>`), return an array of key/value pairs
+        if (Array.isArray(value)) {
+            return value.map(function (val) {
+                /*
+                 * We trim replace any line endings (e.g. `\r` or `\r\n` with `\r\n`) to guarantee consistency across platforms
+                 * These can occur inside of `<textarea>'s`
+                 */
+                return ({ name: name, value: val.replace(rCRLF, '\r\n') });
+            });
+        }
+        // Otherwise (e.g. `<input type="text">`, return only one key/value pair
+        return { name: name, value: value.replace(rCRLF, '\r\n') };
+    })
+        .toArray();
+}
+exports.serializeArray = serializeArray;

node/node_modules/cheerio/lib/api/manipulation.d.ts

@@ -0,0 +1,496 @@
+/**
+ * Methods for modifying the DOM structure.
+ *
+ * @module cheerio/manipulation
+ */
+import { Node } from 'domhandler';
+import type { Cheerio } from '../cheerio';
+import type { BasicAcceptedElems, AcceptedElems } from '../types';
+/**
+ * Create an array of nodes, recursing into arrays and parsing strings if necessary.
+ *
+ * @private
+ * @category Manipulation
+ * @param elem - Elements to make an array of.
+ * @param clone - Optionally clone nodes.
+ * @returns The array of nodes.
+ */
+export declare function _makeDomArray<T extends Node>(this: Cheerio<T>, elem?: BasicAcceptedElems<Node>, clone?: boolean): Node[];
+/**
+ * Insert every element in the set of matched elements to the end of the target.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('<li class="plum">Plum</li>').appendTo('#fruits');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //      <li class="plum">Plum</li>
+ * //    </ul>
+ * ```
+ *
+ * @param target - Element to append elements to.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/appendTo/}
+ */
+export declare function appendTo<T extends Node>(this: Cheerio<T>, target: BasicAcceptedElems<Node>): Cheerio<T>;
+/**
+ * Insert every element in the set of matched elements to the beginning of the target.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('<li class="plum">Plum</li>').prependTo('#fruits');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @param target - Element to prepend elements to.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/prependTo/}
+ */
+export declare function prependTo<T extends Node>(this: Cheerio<T>, target: BasicAcceptedElems<Node>): Cheerio<T>;
+/**
+ * Inserts content as the *last* child of each of the selected elements.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('ul').append('<li class="plum">Plum</li>');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //      <li class="plum">Plum</li>
+ * //    </ul>
+ * ```
+ *
+ * @see {@link https://api.jquery.com/append/}
+ */
+export declare const append: <T extends Node>(this: Cheerio<T>, ...elems: [(this: Node, i: number, html: string) => BasicAcceptedElems<Node>] | BasicAcceptedElems<Node>[]) => Cheerio<T>;
+/**
+ * Inserts content as the *first* child of each of the selected elements.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('ul').prepend('<li class="plum">Plum</li>');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @see {@link https://api.jquery.com/prepend/}
+ */
+export declare const prepend: <T extends Node>(this: Cheerio<T>, ...elems: [(this: Node, i: number, html: string) => BasicAcceptedElems<Node>] | BasicAcceptedElems<Node>[]) => Cheerio<T>;
+/**
+ * The .wrap() function can take any string or object that could be passed to
+ * the $() factory function to specify a DOM structure. This structure may be
+ * nested several levels deep, but should contain only one inmost element. A
+ * copy of this structure will be wrapped around each of the elements in the set
+ * of matched elements. This method returns the original set of elements for
+ * chaining purposes.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * const redFruit = $('<div class="red-fruit"></div>');
+ * $('.apple').wrap(redFruit);
+ *
+ * //=> <ul id="fruits">
+ * //     <div class="red-fruit">
+ * //      <li class="apple">Apple</li>
+ * //     </div>
+ * //     <li class="orange">Orange</li>
+ * //     <li class="plum">Plum</li>
+ * //   </ul>
+ *
+ * const healthy = $('<div class="healthy"></div>');
+ * $('li').wrap(healthy);
+ *
+ * //=> <ul id="fruits">
+ * //     <div class="healthy">
+ * //       <li class="apple">Apple</li>
+ * //     </div>
+ * //     <div class="healthy">
+ * //       <li class="orange">Orange</li>
+ * //     </div>
+ * //     <div class="healthy">
+ * //        <li class="plum">Plum</li>
+ * //     </div>
+ * //   </ul>
+ * ```
+ *
+ * @param wrapper - The DOM structure to wrap around each element in the selection.
+ * @see {@link https://api.jquery.com/wrap/}
+ */
+export declare const wrap: <T extends Node>(this: Cheerio<T>, wrapper: AcceptedElems<Node>) => Cheerio<T>;
+/**
+ * The .wrapInner() function can take any string or object that could be passed
+ * to the $() factory function to specify a DOM structure. This structure may be
+ * nested several levels deep, but should contain only one inmost element. The
+ * structure will be wrapped around the content of each of the elements in the
+ * set of matched elements.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * const redFruit = $('<div class="red-fruit"></div>');
+ * $('.apple').wrapInner(redFruit);
+ *
+ * //=> <ul id="fruits">
+ * //     <li class="apple">
+ * //       <div class="red-fruit">Apple</div>
+ * //     </li>
+ * //     <li class="orange">Orange</li>
+ * //     <li class="pear">Pear</li>
+ * //   </ul>
+ *
+ * const healthy = $('<div class="healthy"></div>');
+ * $('li').wrapInner(healthy);
+ *
+ * //=> <ul id="fruits">
+ * //     <li class="apple">
+ * //       <div class="healthy">Apple</div>
+ * //     </li>
+ * //     <li class="orange">
+ * //       <div class="healthy">Orange</div>
+ * //     </li>
+ * //     <li class="pear">
+ * //       <div class="healthy">Pear</div>
+ * //     </li>
+ * //   </ul>
+ * ```
+ *
+ * @param wrapper - The DOM structure to wrap around the content of each element
+ *   in the selection.
+ * @returns The instance itself, for chaining.
+ * @see {@link https://api.jquery.com/wrapInner/}
+ */
+export declare const wrapInner: <T extends Node>(this: Cheerio<T>, wrapper: AcceptedElems<Node>) => Cheerio<T>;
+/**
+ * The .unwrap() function, removes the parents of the set of matched elements
+ * from the DOM, leaving the matched elements in their place.
+ *
+ * @category Manipulation
+ * @example <caption>without selector</caption>
+ *
+ * ```js
+ * const $ = cheerio.load(
+ *   '<div id=test>\n  <div><p>Hello</p></div>\n  <div><p>World</p></div>\n</div>'
+ * );
+ * $('#test p').unwrap();
+ *
+ * //=> <div id=test>
+ * //     <p>Hello</p>
+ * //     <p>World</p>
+ * //   </div>
+ * ```
+ *
+ * @example <caption>with selector</caption>
+ *
+ * ```js
+ * const $ = cheerio.load(
+ *   '<div id=test>\n  <p>Hello</p>\n  <b><p>World</p></b>\n</div>'
+ * );
+ * $('#test p').unwrap('b');
+ *
+ * //=> <div id=test>
+ * //     <p>Hello</p>
+ * //     <p>World</p>
+ * //   </div>
+ * ```
+ *
+ * @param selector - A selector to check the parent element against. If an
+ *   element's parent does not match the selector, the element won't be unwrapped.
+ * @returns The instance itself, for chaining.
+ * @see {@link https://api.jquery.com/unwrap/}
+ */
+export declare function unwrap<T extends Node>(this: Cheerio<T>, selector?: string): Cheerio<T>;
+/**
+ * The .wrapAll() function can take any string or object that could be passed to
+ * the $() function to specify a DOM structure. This structure may be nested
+ * several levels deep, but should contain only one inmost element. The
+ * structure will be wrapped around all of the elements in the set of matched
+ * elements, as a single group.
+ *
+ * @category Manipulation
+ * @example <caption>With markup passed to `wrapAll`</caption>
+ *
+ * ```js
+ * const $ = cheerio.load(
+ *   '<div class="container"><div class="inner">First</div><div class="inner">Second</div></div>'
+ * );
+ * $('.inner').wrapAll("<div class='new'></div>");
+ *
+ * //=> <div class="container">
+ * //     <div class='new'>
+ * //       <div class="inner">First</div>
+ * //       <div class="inner">Second</div>
+ * //     </div>
+ * //   </div>
+ * ```
+ *
+ * @example <caption>With an existing cheerio instance</caption>
+ *
+ * ```js
+ * const $ = cheerio.load(
+ *   '<span>Span 1</span><strong>Strong</strong><span>Span 2</span>'
+ * );
+ * const wrap = $('<div><p><em><b></b></em></p></div>');
+ * $('span').wrapAll(wrap);
+ *
+ * //=> <div>
+ * //     <p>
+ * //       <em>
+ * //         <b>
+ * //           <span>Span 1</span>
+ * //           <span>Span 2</span>
+ * //         </b>
+ * //       </em>
+ * //     </p>
+ * //   </div>
+ * //   <strong>Strong</strong>
+ * ```
+ *
+ * @param wrapper - The DOM structure to wrap around all matched elements in the
+ *   selection.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/wrapAll/}
+ */
+export declare function wrapAll<T extends Node>(this: Cheerio<T>, wrapper: AcceptedElems<T>): Cheerio<T>;
+/**
+ * Insert content next to each element in the set of matched elements.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('.apple').after('<li class="plum">Plum</li>');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="plum">Plum</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @param content - HTML string, DOM element, array of DOM elements or Cheerio
+ *   to insert after each element in the set of matched elements.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/after/}
+ */
+export declare function after<T extends Node>(this: Cheerio<T>, ...elems: [(this: Node, i: number, html: string) => BasicAcceptedElems<Node>] | BasicAcceptedElems<Node>[]): Cheerio<T>;
+/**
+ * Insert every element in the set of matched elements after the target.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('<li class="plum">Plum</li>').insertAfter('.apple');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="plum">Plum</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @param target - Element to insert elements after.
+ * @returns The set of newly inserted elements.
+ * @see {@link https://api.jquery.com/insertAfter/}
+ */
+export declare function insertAfter<T extends Node>(this: Cheerio<T>, target: BasicAcceptedElems<Node>): Cheerio<T>;
+/**
+ * Insert content previous to each element in the set of matched elements.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('.apple').before('<li class="plum">Plum</li>');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @param content - HTML string, DOM element, array of DOM elements or Cheerio
+ *   to insert before each element in the set of matched elements.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/before/}
+ */
+export declare function before<T extends Node>(this: Cheerio<T>, ...elems: [(this: Node, i: number, html: string) => BasicAcceptedElems<Node>] | BasicAcceptedElems<Node>[]): Cheerio<T>;
+/**
+ * Insert every element in the set of matched elements before the target.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('<li class="plum">Plum</li>').insertBefore('.apple');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @param target - Element to insert elements before.
+ * @returns The set of newly inserted elements.
+ * @see {@link https://api.jquery.com/insertBefore/}
+ */
+export declare function insertBefore<T extends Node>(this: Cheerio<T>, target: BasicAcceptedElems<Node>): Cheerio<T>;
+/**
+ * Removes the set of matched elements from the DOM and all their children.
+ * `selector` filters the set of matched elements to be removed.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('.pear').remove();
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //    </ul>
+ * ```
+ *
+ * @param selector - Optional selector for elements to remove.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/remove/}
+ */
+export declare function remove<T extends Node>(this: Cheerio<T>, selector?: string): Cheerio<T>;
+/**
+ * Replaces matched elements with `content`.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * const plum = $('<li class="plum">Plum</li>');
+ * $('.pear').replaceWith(plum);
+ * $.html();
+ * //=> <ul id="fruits">
+ * //     <li class="apple">Apple</li>
+ * //     <li class="orange">Orange</li>
+ * //     <li class="plum">Plum</li>
+ * //   </ul>
+ * ```
+ *
+ * @param content - Replacement for matched elements.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/replaceWith/}
+ */
+export declare function replaceWith<T extends Node>(this: Cheerio<T>, content: AcceptedElems<Node>): Cheerio<T>;
+/**
+ * Empties an element, removing all its children.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('ul').empty();
+ * $.html();
+ * //=>  <ul id="fruits"></ul>
+ * ```
+ *
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/empty/}
+ */
+export declare function empty<T extends Node>(this: Cheerio<T>): Cheerio<T>;
+/**
+ * Gets an HTML content string from the first selected element. If `htmlString`
+ * is specified, each selected element's content is replaced by the new content.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('.orange').html();
+ * //=> Orange
+ *
+ * $('#fruits').html('<li class="mango">Mango</li>').html();
+ * //=> <li class="mango">Mango</li>
+ * ```
+ *
+ * @param str - If specified used to replace selection's contents.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/html/}
+ */
+export declare function html<T extends Node>(this: Cheerio<T>): string | null;
+export declare function html<T extends Node>(this: Cheerio<T>, str: string | Cheerio<T>): Cheerio<T>;
+/**
+ * Turns the collection to a string. Alias for `.html()`.
+ *
+ * @category Manipulation
+ * @returns The rendered document.
+ */
+export declare function toString<T extends Node>(this: Cheerio<T>): string;
+/**
+ * Get the combined text contents of each element in the set of matched
+ * elements, including their descendants. If `textString` is specified, each
+ * selected element's content is replaced by the new text content.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('.orange').text();
+ * //=> Orange
+ *
+ * $('ul').text();
+ * //=>  Apple
+ * //    Orange
+ * //    Pear
+ * ```
+ *
+ * @param str - If specified replacement for the selected element's contents.
+ * @returns The instance itself when setting text, otherwise the rendered document.
+ * @see {@link https://api.jquery.com/text/}
+ */
+export declare function text<T extends Node>(this: Cheerio<T>): string;
+export declare function text<T extends Node>(this: Cheerio<T>, str: string | ((this: Node, i: number, text: string) => string)): Cheerio<T>;
+/**
+ * Clone the cheerio object.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * const moreFruit = $('#fruits').clone();
+ * ```
+ *
+ * @returns The cloned object.
+ * @see {@link https://api.jquery.com/clone/}
+ */
+export declare function clone<T extends Node>(this: Cheerio<T>): Cheerio<T>;
+//# sourceMappingURL=manipulation.d.ts.map

node/node_modules/cheerio/lib/api/manipulation.js

@@ -0,0 +1,852 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone = exports.text = exports.toString = exports.html = exports.empty = exports.replaceWith = exports.remove = exports.insertBefore = exports.before = exports.insertAfter = exports.after = exports.wrapAll = exports.unwrap = exports.wrapInner = exports.wrap = exports.prepend = exports.append = exports.prependTo = exports.appendTo = exports._makeDomArray = void 0;
+var tslib_1 = require("tslib");
+var domhandler_1 = require("domhandler");
+/**
+ * Methods for modifying the DOM structure.
+ *
+ * @module cheerio/manipulation
+ */
+var domhandler_2 = require("domhandler");
+var parse_1 = tslib_1.__importStar(require("../parse"));
+var static_1 = require("../static");
+var utils_1 = require("../utils");
+var htmlparser2_1 = require("htmlparser2");
+/**
+ * Create an array of nodes, recursing into arrays and parsing strings if necessary.
+ *
+ * @private
+ * @category Manipulation
+ * @param elem - Elements to make an array of.
+ * @param clone - Optionally clone nodes.
+ * @returns The array of nodes.
+ */
+function _makeDomArray(elem, clone) {
+    var _this = this;
+    if (elem == null) {
+        return [];
+    }
+    if (utils_1.isCheerio(elem)) {
+        return clone ? utils_1.cloneDom(elem.get()) : elem.get();
+    }
+    if (Array.isArray(elem)) {
+        return elem.reduce(function (newElems, el) { return newElems.concat(_this._makeDomArray(el, clone)); }, []);
+    }
+    if (typeof elem === 'string') {
+        return parse_1.default(elem, this.options, false).children;
+    }
+    return clone ? utils_1.cloneDom([elem]) : [elem];
+}
+exports._makeDomArray = _makeDomArray;
+function _insert(concatenator) {
+    return function () {
+        var _this = this;
+        var elems = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            elems[_i] = arguments[_i];
+        }
+        var lastIdx = this.length - 1;
+        return utils_1.domEach(this, function (el, i) {
+            if (!domhandler_1.hasChildren(el))
+                return;
+            var domSrc = typeof elems[0] === 'function'
+                ? elems[0].call(el, i, static_1.html(el.children))
+                : elems;
+            var dom = _this._makeDomArray(domSrc, i < lastIdx);
+            concatenator(dom, el.children, el);
+        });
+    };
+}
+/**
+ * Modify an array in-place, removing some number of elements and adding new
+ * elements directly following them.
+ *
+ * @private
+ * @category Manipulation
+ * @param array - Target array to splice.
+ * @param spliceIdx - Index at which to begin changing the array.
+ * @param spliceCount - Number of elements to remove from the array.
+ * @param newElems - Elements to insert into the array.
+ * @param parent - The parent of the node.
+ * @returns The spliced array.
+ */
+function uniqueSplice(array, spliceIdx, spliceCount, newElems, parent) {
+    var _a, _b;
+    var spliceArgs = tslib_1.__spreadArray([
+        spliceIdx,
+        spliceCount
+    ], newElems);
+    var prev = array[spliceIdx - 1] || null;
+    var next = array[spliceIdx + spliceCount] || null;
+    /*
+     * Before splicing in new elements, ensure they do not already appear in the
+     * current array.
+     */
+    for (var idx = 0; idx < newElems.length; ++idx) {
+        var node = newElems[idx];
+        var oldParent = node.parent;
+        if (oldParent) {
+            var prevIdx = oldParent.children.indexOf(newElems[idx]);
+            if (prevIdx > -1) {
+                oldParent.children.splice(prevIdx, 1);
+                if (parent === oldParent && spliceIdx > prevIdx) {
+                    spliceArgs[0]--;
+                }
+            }
+        }
+        node.parent = parent;
+        if (node.prev) {
+            node.prev.next = (_a = node.next) !== null && _a !== void 0 ? _a : null;
+        }
+        if (node.next) {
+            node.next.prev = (_b = node.prev) !== null && _b !== void 0 ? _b : null;
+        }
+        node.prev = newElems[idx - 1] || prev;
+        node.next = newElems[idx + 1] || next;
+    }
+    if (prev) {
+        prev.next = newElems[0];
+    }
+    if (next) {
+        next.prev = newElems[newElems.length - 1];
+    }
+    return array.splice.apply(array, spliceArgs);
+}
+/**
+ * Insert every element in the set of matched elements to the end of the target.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('<li class="plum">Plum</li>').appendTo('#fruits');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //      <li class="plum">Plum</li>
+ * //    </ul>
+ * ```
+ *
+ * @param target - Element to append elements to.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/appendTo/}
+ */
+function appendTo(target) {
+    var appendTarget = utils_1.isCheerio(target) ? target : this._make(target);
+    appendTarget.append(this);
+    return this;
+}
+exports.appendTo = appendTo;
+/**
+ * Insert every element in the set of matched elements to the beginning of the target.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('<li class="plum">Plum</li>').prependTo('#fruits');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @param target - Element to prepend elements to.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/prependTo/}
+ */
+function prependTo(target) {
+    var prependTarget = utils_1.isCheerio(target) ? target : this._make(target);
+    prependTarget.prepend(this);
+    return this;
+}
+exports.prependTo = prependTo;
+/**
+ * Inserts content as the *last* child of each of the selected elements.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('ul').append('<li class="plum">Plum</li>');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //      <li class="plum">Plum</li>
+ * //    </ul>
+ * ```
+ *
+ * @see {@link https://api.jquery.com/append/}
+ */
+exports.append = _insert(function (dom, children, parent) {
+    uniqueSplice(children, children.length, 0, dom, parent);
+});
+/**
+ * Inserts content as the *first* child of each of the selected elements.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('ul').prepend('<li class="plum">Plum</li>');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @see {@link https://api.jquery.com/prepend/}
+ */
+exports.prepend = _insert(function (dom, children, parent) {
+    uniqueSplice(children, 0, 0, dom, parent);
+});
+function _wrap(insert) {
+    return function (wrapper) {
+        var lastIdx = this.length - 1;
+        var lastParent = this.parents().last();
+        for (var i = 0; i < this.length; i++) {
+            var el = this[i];
+            var wrap_1 = typeof wrapper === 'function'
+                ? wrapper.call(el, i, el)
+                : typeof wrapper === 'string' && !utils_1.isHtml(wrapper)
+                    ? lastParent.find(wrapper).clone()
+                    : wrapper;
+            var wrapperDom = this._makeDomArray(wrap_1, i < lastIdx)[0];
+            if (!wrapperDom || !htmlparser2_1.DomUtils.hasChildren(wrapperDom))
+                continue;
+            var elInsertLocation = wrapperDom;
+            /*
+             * Find the deepest child. Only consider the first tag child of each node
+             * (ignore text); stop if no children are found.
+             */
+            var j = 0;
+            while (j < elInsertLocation.children.length) {
+                var child = elInsertLocation.children[j];
+                if (utils_1.isTag(child)) {
+                    elInsertLocation = child;
+                    j = 0;
+                }
+                else {
+                    j++;
+                }
+            }
+            insert(el, elInsertLocation, [wrapperDom]);
+        }
+        return this;
+    };
+}
+/**
+ * The .wrap() function can take any string or object that could be passed to
+ * the $() factory function to specify a DOM structure. This structure may be
+ * nested several levels deep, but should contain only one inmost element. A
+ * copy of this structure will be wrapped around each of the elements in the set
+ * of matched elements. This method returns the original set of elements for
+ * chaining purposes.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * const redFruit = $('<div class="red-fruit"></div>');
+ * $('.apple').wrap(redFruit);
+ *
+ * //=> <ul id="fruits">
+ * //     <div class="red-fruit">
+ * //      <li class="apple">Apple</li>
+ * //     </div>
+ * //     <li class="orange">Orange</li>
+ * //     <li class="plum">Plum</li>
+ * //   </ul>
+ *
+ * const healthy = $('<div class="healthy"></div>');
+ * $('li').wrap(healthy);
+ *
+ * //=> <ul id="fruits">
+ * //     <div class="healthy">
+ * //       <li class="apple">Apple</li>
+ * //     </div>
+ * //     <div class="healthy">
+ * //       <li class="orange">Orange</li>
+ * //     </div>
+ * //     <div class="healthy">
+ * //        <li class="plum">Plum</li>
+ * //     </div>
+ * //   </ul>
+ * ```
+ *
+ * @param wrapper - The DOM structure to wrap around each element in the selection.
+ * @see {@link https://api.jquery.com/wrap/}
+ */
+exports.wrap = _wrap(function (el, elInsertLocation, wrapperDom) {
+    var parent = el.parent;
+    if (!parent)
+        return;
+    var siblings = parent.children;
+    var index = siblings.indexOf(el);
+    parse_1.update([el], elInsertLocation);
+    /*
+     * The previous operation removed the current element from the `siblings`
+     * array, so the `dom` array can be inserted without removing any
+     * additional elements.
+     */
+    uniqueSplice(siblings, index, 0, wrapperDom, parent);
+});
+/**
+ * The .wrapInner() function can take any string or object that could be passed
+ * to the $() factory function to specify a DOM structure. This structure may be
+ * nested several levels deep, but should contain only one inmost element. The
+ * structure will be wrapped around the content of each of the elements in the
+ * set of matched elements.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * const redFruit = $('<div class="red-fruit"></div>');
+ * $('.apple').wrapInner(redFruit);
+ *
+ * //=> <ul id="fruits">
+ * //     <li class="apple">
+ * //       <div class="red-fruit">Apple</div>
+ * //     </li>
+ * //     <li class="orange">Orange</li>
+ * //     <li class="pear">Pear</li>
+ * //   </ul>
+ *
+ * const healthy = $('<div class="healthy"></div>');
+ * $('li').wrapInner(healthy);
+ *
+ * //=> <ul id="fruits">
+ * //     <li class="apple">
+ * //       <div class="healthy">Apple</div>
+ * //     </li>
+ * //     <li class="orange">
+ * //       <div class="healthy">Orange</div>
+ * //     </li>
+ * //     <li class="pear">
+ * //       <div class="healthy">Pear</div>
+ * //     </li>
+ * //   </ul>
+ * ```
+ *
+ * @param wrapper - The DOM structure to wrap around the content of each element
+ *   in the selection.
+ * @returns The instance itself, for chaining.
+ * @see {@link https://api.jquery.com/wrapInner/}
+ */
+exports.wrapInner = _wrap(function (el, elInsertLocation, wrapperDom) {
+    if (!domhandler_1.hasChildren(el))
+        return;
+    parse_1.update(el.children, elInsertLocation);
+    parse_1.update(wrapperDom, el);
+});
+/**
+ * The .unwrap() function, removes the parents of the set of matched elements
+ * from the DOM, leaving the matched elements in their place.
+ *
+ * @category Manipulation
+ * @example <caption>without selector</caption>
+ *
+ * ```js
+ * const $ = cheerio.load(
+ *   '<div id=test>\n  <div><p>Hello</p></div>\n  <div><p>World</p></div>\n</div>'
+ * );
+ * $('#test p').unwrap();
+ *
+ * //=> <div id=test>
+ * //     <p>Hello</p>
+ * //     <p>World</p>
+ * //   </div>
+ * ```
+ *
+ * @example <caption>with selector</caption>
+ *
+ * ```js
+ * const $ = cheerio.load(
+ *   '<div id=test>\n  <p>Hello</p>\n  <b><p>World</p></b>\n</div>'
+ * );
+ * $('#test p').unwrap('b');
+ *
+ * //=> <div id=test>
+ * //     <p>Hello</p>
+ * //     <p>World</p>
+ * //   </div>
+ * ```
+ *
+ * @param selector - A selector to check the parent element against. If an
+ *   element's parent does not match the selector, the element won't be unwrapped.
+ * @returns The instance itself, for chaining.
+ * @see {@link https://api.jquery.com/unwrap/}
+ */
+function unwrap(selector) {
+    var _this = this;
+    this.parent(selector)
+        .not('body')
+        .each(function (_, el) {
+        _this._make(el).replaceWith(el.children);
+    });
+    return this;
+}
+exports.unwrap = unwrap;
+/**
+ * The .wrapAll() function can take any string or object that could be passed to
+ * the $() function to specify a DOM structure. This structure may be nested
+ * several levels deep, but should contain only one inmost element. The
+ * structure will be wrapped around all of the elements in the set of matched
+ * elements, as a single group.
+ *
+ * @category Manipulation
+ * @example <caption>With markup passed to `wrapAll`</caption>
+ *
+ * ```js
+ * const $ = cheerio.load(
+ *   '<div class="container"><div class="inner">First</div><div class="inner">Second</div></div>'
+ * );
+ * $('.inner').wrapAll("<div class='new'></div>");
+ *
+ * //=> <div class="container">
+ * //     <div class='new'>
+ * //       <div class="inner">First</div>
+ * //       <div class="inner">Second</div>
+ * //     </div>
+ * //   </div>
+ * ```
+ *
+ * @example <caption>With an existing cheerio instance</caption>
+ *
+ * ```js
+ * const $ = cheerio.load(
+ *   '<span>Span 1</span><strong>Strong</strong><span>Span 2</span>'
+ * );
+ * const wrap = $('<div><p><em><b></b></em></p></div>');
+ * $('span').wrapAll(wrap);
+ *
+ * //=> <div>
+ * //     <p>
+ * //       <em>
+ * //         <b>
+ * //           <span>Span 1</span>
+ * //           <span>Span 2</span>
+ * //         </b>
+ * //       </em>
+ * //     </p>
+ * //   </div>
+ * //   <strong>Strong</strong>
+ * ```
+ *
+ * @param wrapper - The DOM structure to wrap around all matched elements in the
+ *   selection.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/wrapAll/}
+ */
+function wrapAll(wrapper) {
+    var el = this[0];
+    if (el) {
+        var wrap_2 = this._make(typeof wrapper === 'function' ? wrapper.call(el, 0, el) : wrapper).insertBefore(el);
+        // If html is given as wrapper, wrap may contain text elements
+        var elInsertLocation = void 0;
+        for (var i = 0; i < wrap_2.length; i++) {
+            if (wrap_2[i].type === 'tag')
+                elInsertLocation = wrap_2[i];
+        }
+        var j = 0;
+        /*
+         * Find the deepest child. Only consider the first tag child of each node
+         * (ignore text); stop if no children are found.
+         */
+        while (elInsertLocation && j < elInsertLocation.children.length) {
+            var child = elInsertLocation.children[j];
+            if (child.type === 'tag') {
+                elInsertLocation = child;
+                j = 0;
+            }
+            else {
+                j++;
+            }
+        }
+        if (elInsertLocation)
+            this._make(elInsertLocation).append(this);
+    }
+    return this;
+}
+exports.wrapAll = wrapAll;
+/* eslint-disable jsdoc/check-param-names*/
+/**
+ * Insert content next to each element in the set of matched elements.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('.apple').after('<li class="plum">Plum</li>');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="plum">Plum</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @param content - HTML string, DOM element, array of DOM elements or Cheerio
+ *   to insert after each element in the set of matched elements.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/after/}
+ */
+function after() {
+    var _this = this;
+    var elems = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        elems[_i] = arguments[_i];
+    }
+    var lastIdx = this.length - 1;
+    return utils_1.domEach(this, function (el, i) {
+        var parent = el.parent;
+        if (!htmlparser2_1.DomUtils.hasChildren(el) || !parent) {
+            return;
+        }
+        var siblings = parent.children;
+        var index = siblings.indexOf(el);
+        // If not found, move on
+        /* istanbul ignore next */
+        if (index < 0)
+            return;
+        var domSrc = typeof elems[0] === 'function'
+            ? elems[0].call(el, i, static_1.html(el.children))
+            : elems;
+        var dom = _this._makeDomArray(domSrc, i < lastIdx);
+        // Add element after `this` element
+        uniqueSplice(siblings, index + 1, 0, dom, parent);
+    });
+}
+exports.after = after;
+/* eslint-enable jsdoc/check-param-names*/
+/**
+ * Insert every element in the set of matched elements after the target.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('<li class="plum">Plum</li>').insertAfter('.apple');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="plum">Plum</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @param target - Element to insert elements after.
+ * @returns The set of newly inserted elements.
+ * @see {@link https://api.jquery.com/insertAfter/}
+ */
+function insertAfter(target) {
+    var _this = this;
+    if (typeof target === 'string') {
+        target = this._make(target);
+    }
+    this.remove();
+    var clones = [];
+    this._makeDomArray(target).forEach(function (el) {
+        var clonedSelf = _this.clone().toArray();
+        var parent = el.parent;
+        if (!parent) {
+            return;
+        }
+        var siblings = parent.children;
+        var index = siblings.indexOf(el);
+        // If not found, move on
+        /* istanbul ignore next */
+        if (index < 0)
+            return;
+        // Add cloned `this` element(s) after target element
+        uniqueSplice(siblings, index + 1, 0, clonedSelf, parent);
+        clones.push.apply(clones, clonedSelf);
+    });
+    return this._make(clones);
+}
+exports.insertAfter = insertAfter;
+/* eslint-disable jsdoc/check-param-names*/
+/**
+ * Insert content previous to each element in the set of matched elements.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('.apple').before('<li class="plum">Plum</li>');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @param content - HTML string, DOM element, array of DOM elements or Cheerio
+ *   to insert before each element in the set of matched elements.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/before/}
+ */
+function before() {
+    var _this = this;
+    var elems = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        elems[_i] = arguments[_i];
+    }
+    var lastIdx = this.length - 1;
+    return utils_1.domEach(this, function (el, i) {
+        var parent = el.parent;
+        if (!htmlparser2_1.DomUtils.hasChildren(el) || !parent) {
+            return;
+        }
+        var siblings = parent.children;
+        var index = siblings.indexOf(el);
+        // If not found, move on
+        /* istanbul ignore next */
+        if (index < 0)
+            return;
+        var domSrc = typeof elems[0] === 'function'
+            ? elems[0].call(el, i, static_1.html(el.children))
+            : elems;
+        var dom = _this._makeDomArray(domSrc, i < lastIdx);
+        // Add element before `el` element
+        uniqueSplice(siblings, index, 0, dom, parent);
+    });
+}
+exports.before = before;
+/* eslint-enable jsdoc/check-param-names*/
+/**
+ * Insert every element in the set of matched elements before the target.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('<li class="plum">Plum</li>').insertBefore('.apple');
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="plum">Plum</li>
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //      <li class="pear">Pear</li>
+ * //    </ul>
+ * ```
+ *
+ * @param target - Element to insert elements before.
+ * @returns The set of newly inserted elements.
+ * @see {@link https://api.jquery.com/insertBefore/}
+ */
+function insertBefore(target) {
+    var _this = this;
+    var targetArr = this._make(target);
+    this.remove();
+    var clones = [];
+    utils_1.domEach(targetArr, function (el) {
+        var clonedSelf = _this.clone().toArray();
+        var parent = el.parent;
+        if (!parent) {
+            return;
+        }
+        var siblings = parent.children;
+        var index = siblings.indexOf(el);
+        // If not found, move on
+        /* istanbul ignore next */
+        if (index < 0)
+            return;
+        // Add cloned `this` element(s) after target element
+        uniqueSplice(siblings, index, 0, clonedSelf, parent);
+        clones.push.apply(clones, clonedSelf);
+    });
+    return this._make(clones);
+}
+exports.insertBefore = insertBefore;
+/**
+ * Removes the set of matched elements from the DOM and all their children.
+ * `selector` filters the set of matched elements to be removed.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('.pear').remove();
+ * $.html();
+ * //=>  <ul id="fruits">
+ * //      <li class="apple">Apple</li>
+ * //      <li class="orange">Orange</li>
+ * //    </ul>
+ * ```
+ *
+ * @param selector - Optional selector for elements to remove.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/remove/}
+ */
+function remove(selector) {
+    // Filter if we have selector
+    var elems = selector ? this.filter(selector) : this;
+    utils_1.domEach(elems, function (el) {
+        htmlparser2_1.DomUtils.removeElement(el);
+        el.prev = el.next = el.parent = null;
+    });
+    return this;
+}
+exports.remove = remove;
+/**
+ * Replaces matched elements with `content`.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * const plum = $('<li class="plum">Plum</li>');
+ * $('.pear').replaceWith(plum);
+ * $.html();
+ * //=> <ul id="fruits">
+ * //     <li class="apple">Apple</li>
+ * //     <li class="orange">Orange</li>
+ * //     <li class="plum">Plum</li>
+ * //   </ul>
+ * ```
+ *
+ * @param content - Replacement for matched elements.
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/replaceWith/}
+ */
+function replaceWith(content) {
+    var _this = this;
+    return utils_1.domEach(this, function (el, i) {
+        var parent = el.parent;
+        if (!parent) {
+            return;
+        }
+        var siblings = parent.children;
+        var cont = typeof content === 'function' ? content.call(el, i, el) : content;
+        var dom = _this._makeDomArray(cont);
+        /*
+         * In the case that `dom` contains nodes that already exist in other
+         * structures, ensure those nodes are properly removed.
+         */
+        parse_1.update(dom, null);
+        var index = siblings.indexOf(el);
+        // Completely remove old element
+        uniqueSplice(siblings, index, 1, dom, parent);
+        if (!dom.includes(el)) {
+            el.parent = el.prev = el.next = null;
+        }
+    });
+}
+exports.replaceWith = replaceWith;
+/**
+ * Empties an element, removing all its children.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * $('ul').empty();
+ * $.html();
+ * //=>  <ul id="fruits"></ul>
+ * ```
+ *
+ * @returns The instance itself.
+ * @see {@link https://api.jquery.com/empty/}
+ */
+function empty() {
+    return utils_1.domEach(this, function (el) {
+        if (!htmlparser2_1.DomUtils.hasChildren(el))
+            return;
+        el.children.forEach(function (child) {
+            child.next = child.prev = child.parent = null;
+        });
+        el.children.length = 0;
+    });
+}
+exports.empty = empty;
+function html(str) {
+    if (str === undefined) {
+        var el = this[0];
+        if (!el || !htmlparser2_1.DomUtils.hasChildren(el))
+            return null;
+        return static_1.html(el.children, this.options);
+    }
+    // Keep main options unchanged
+    var opts = tslib_1.__assign(tslib_1.__assign({}, this.options), { context: null });
+    return utils_1.domEach(this, function (el) {
+        if (!htmlparser2_1.DomUtils.hasChildren(el))
+            return;
+        el.children.forEach(function (child) {
+            child.next = child.prev = child.parent = null;
+        });
+        opts.context = el;
+        var content = utils_1.isCheerio(str)
+            ? str.toArray()
+            : parse_1.default("" + str, opts, false).children;
+        parse_1.update(content, el);
+    });
+}
+exports.html = html;
+/**
+ * Turns the collection to a string. Alias for `.html()`.
+ *
+ * @category Manipulation
+ * @returns The rendered document.
+ */
+function toString() {
+    return static_1.html(this, this.options);
+}
+exports.toString = toString;
+function text(str) {
+    var _this = this;
+    // If `str` is undefined, act as a "getter"
+    if (str === undefined) {
+        return static_1.text(this);
+    }
+    if (typeof str === 'function') {
+        // Function support
+        return utils_1.domEach(this, function (el, i) {
+            text.call(_this._make(el), str.call(el, i, static_1.text([el])));
+        });
+    }
+    // Append text node to each selected elements
+    return utils_1.domEach(this, function (el) {
+        if (!htmlparser2_1.DomUtils.hasChildren(el))
+            return;
+        el.children.forEach(function (child) {
+            child.next = child.prev = child.parent = null;
+        });
+        var textNode = new domhandler_2.Text(str);
+        parse_1.update(textNode, el);
+    });
+}
+exports.text = text;
+/**
+ * Clone the cheerio object.
+ *
+ * @category Manipulation
+ * @example
+ *
+ * ```js
+ * const moreFruit = $('#fruits').clone();
+ * ```
+ *
+ * @returns The cloned object.
+ * @see {@link https://api.jquery.com/clone/}
+ */
+function clone() {
+    return this._make(utils_1.cloneDom(this.get()));
+}
+exports.clone = clone;

node/node_modules/cheerio/lib/api/traversing.d.ts

@@ -0,0 +1,644 @@
+/**
+ * Methods for traversing the DOM structure.
+ *
+ * @module cheerio/traversing
+ */
+import { Node, Element, Document } from 'domhandler';
+import type { Cheerio } from '../cheerio';
+import type { AcceptedFilters } from '../types';
+/**
+ * Get the descendants of each element in the current set of matched elements,
+ * filtered by a selector, jQuery object, or element.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('#fruits').find('li').length;
+ * //=> 3
+ * $('#fruits').find($('.apple')).length;
+ * //=> 1
+ * ```
+ *
+ * @param selectorOrHaystack - Element to look for.
+ * @returns The found elements.
+ * @see {@link https://api.jquery.com/find/}
+ */
+export declare function find<T extends Node>(this: Cheerio<T>, selectorOrHaystack?: string | Cheerio<Element> | Element): Cheerio<Element>;
+/**
+ * Get the parent of each element in the current set of matched elements,
+ * optionally filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.pear').parent().attr('id');
+ * //=> fruits
+ * ```
+ *
+ * @param selector - If specified filter for parent.
+ * @returns The parents.
+ * @see {@link https://api.jquery.com/parent/}
+ */
+export declare const parent: <T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | undefined) => Cheerio<Element>;
+/**
+ * Get a set of parents filtered by `selector` of each element in the current
+ * set of match elements.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.orange').parents().length;
+ * //=> 2
+ * $('.orange').parents('#fruits').length;
+ * //=> 1
+ * ```
+ *
+ * @param selector - If specified filter for parents.
+ * @returns The parents.
+ * @see {@link https://api.jquery.com/parents/}
+ */
+export declare const parents: <T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | undefined) => Cheerio<Element>;
+/**
+ * Get the ancestors of each element in the current set of matched elements, up
+ * to but not including the element matched by the selector, DOM node, or cheerio object.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.orange').parentsUntil('#food').length;
+ * //=> 1
+ * ```
+ *
+ * @param selector - Selector for element to stop at.
+ * @param filterSelector - Optional filter for parents.
+ * @returns The parents.
+ * @see {@link https://api.jquery.com/parentsUntil/}
+ */
+export declare const parentsUntil: <T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | null | undefined, filterSelector?: AcceptedFilters<Element> | undefined) => Cheerio<Element>;
+/**
+ * For each element in the set, get the first element that matches the selector
+ * by testing the element itself and traversing up through its ancestors in the DOM tree.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.orange').closest();
+ * //=> []
+ *
+ * $('.orange').closest('.apple');
+ * // => []
+ *
+ * $('.orange').closest('li');
+ * //=> [<li class="orange">Orange</li>]
+ *
+ * $('.orange').closest('#fruits');
+ * //=> [<ul id="fruits"> ... </ul>]
+ * ```
+ *
+ * @param selector - Selector for the element to find.
+ * @returns The closest nodes.
+ * @see {@link https://api.jquery.com/closest/}
+ */
+export declare function closest<T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Node>): Cheerio<Node>;
+/**
+ * Gets the next sibling of the first selected element, optionally filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.apple').next().hasClass('orange');
+ * //=> true
+ * ```
+ *
+ * @param selector - If specified filter for sibling.
+ * @returns The next nodes.
+ * @see {@link https://api.jquery.com/next/}
+ */
+export declare const next: <T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | undefined) => Cheerio<Element>;
+/**
+ * Gets all the following siblings of the first selected element, optionally
+ * filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.apple').nextAll();
+ * //=> [<li class="orange">Orange</li>, <li class="pear">Pear</li>]
+ * $('.apple').nextAll('.orange');
+ * //=> [<li class="orange">Orange</li>]
+ * ```
+ *
+ * @param selector - If specified filter for siblings.
+ * @returns The next nodes.
+ * @see {@link https://api.jquery.com/nextAll/}
+ */
+export declare const nextAll: <T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | undefined) => Cheerio<Element>;
+/**
+ * Gets all the following siblings up to but not including the element matched
+ * by the selector, optionally filtered by another selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.apple').nextUntil('.pear');
+ * //=> [<li class="orange">Orange</li>]
+ * ```
+ *
+ * @param selector - Selector for element to stop at.
+ * @param filterSelector - If specified filter for siblings.
+ * @returns The next nodes.
+ * @see {@link https://api.jquery.com/nextUntil/}
+ */
+export declare const nextUntil: <T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | null | undefined, filterSelector?: AcceptedFilters<Element> | undefined) => Cheerio<Element>;
+/**
+ * Gets the previous sibling of the first selected element optionally filtered
+ * by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.orange').prev().hasClass('apple');
+ * //=> true
+ * ```
+ *
+ * @param selector - If specified filter for siblings.
+ * @returns The previous nodes.
+ * @see {@link https://api.jquery.com/prev/}
+ */
+export declare const prev: <T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | undefined) => Cheerio<Element>;
+/**
+ * Gets all the preceding siblings of the first selected element, optionally
+ * filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.pear').prevAll();
+ * //=> [<li class="orange">Orange</li>, <li class="apple">Apple</li>]
+ *
+ * $('.pear').prevAll('.orange');
+ * //=> [<li class="orange">Orange</li>]
+ * ```
+ *
+ * @param selector - If specified filter for siblings.
+ * @returns The previous nodes.
+ * @see {@link https://api.jquery.com/prevAll/}
+ */
+export declare const prevAll: <T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | undefined) => Cheerio<Element>;
+/**
+ * Gets all the preceding siblings up to but not including the element matched
+ * by the selector, optionally filtered by another selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.pear').prevUntil('.apple');
+ * //=> [<li class="orange">Orange</li>]
+ * ```
+ *
+ * @param selector - Selector for element to stop at.
+ * @param filterSelector - If specified filter for siblings.
+ * @returns The previous nodes.
+ * @see {@link https://api.jquery.com/prevUntil/}
+ */
+export declare const prevUntil: <T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | null | undefined, filterSelector?: AcceptedFilters<Element> | undefined) => Cheerio<Element>;
+/**
+ * Get the siblings of each element (excluding the element) in the set of
+ * matched elements, optionally filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.pear').siblings().length;
+ * //=> 2
+ *
+ * $('.pear').siblings('.orange').length;
+ * //=> 1
+ * ```
+ *
+ * @param selector - If specified filter for siblings.
+ * @returns The siblings.
+ * @see {@link https://api.jquery.com/siblings/}
+ */
+export declare const siblings: <T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | undefined) => Cheerio<Element>;
+/**
+ * Gets the children of the first selected element.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('#fruits').children().length;
+ * //=> 3
+ *
+ * $('#fruits').children('.pear').text();
+ * //=> Pear
+ * ```
+ *
+ * @param selector - If specified filter for children.
+ * @returns The children.
+ * @see {@link https://api.jquery.com/children/}
+ */
+export declare const children: <T extends Node>(this: Cheerio<T>, selector?: AcceptedFilters<Element> | undefined) => Cheerio<Element>;
+/**
+ * Gets the children of each element in the set of matched elements, including
+ * text and comment nodes.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('#fruits').contents().length;
+ * //=> 3
+ * ```
+ *
+ * @returns The children.
+ * @see {@link https://api.jquery.com/contents/}
+ */
+export declare function contents<T extends Node>(this: Cheerio<T>): Cheerio<Node>;
+/**
+ * Iterates over a cheerio object, executing a function for each matched
+ * element. When the callback is fired, the function is fired in the context of
+ * the DOM element, so `this` refers to the current element, which is equivalent
+ * to the function parameter `element`. To break out of the `each` loop early,
+ * return with `false`.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * const fruits = [];
+ *
+ * $('li').each(function (i, elem) {
+ *   fruits[i] = $(this).text();
+ * });
+ *
+ * fruits.join(', ');
+ * //=> Apple, Orange, Pear
+ * ```
+ *
+ * @param fn - Function to execute.
+ * @returns The instance itself, useful for chaining.
+ * @see {@link https://api.jquery.com/each/}
+ */
+export declare function each<T>(this: Cheerio<T>, fn: (this: T, i: number, el: T) => void | boolean): Cheerio<T>;
+/**
+ * Pass each element in the current matched set through a function, producing a
+ * new Cheerio object containing the return values. The function can return an
+ * individual data item or an array of data items to be inserted into the
+ * resulting set. If an array is returned, the elements inside the array are
+ * inserted into the set. If the function returns null or undefined, no element
+ * will be inserted.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li')
+ *   .map(function (i, el) {
+ *     // this === el
+ *     return $(this).text();
+ *   })
+ *   .toArray()
+ *   .join(' ');
+ * //=> "apple orange pear"
+ * ```
+ *
+ * @param fn - Function to execute.
+ * @returns The mapped elements, wrapped in a Cheerio collection.
+ * @see {@link https://api.jquery.com/map/}
+ */
+export declare function map<T, M>(this: Cheerio<T>, fn: (this: T, i: number, el: T) => M[] | M | null | undefined): Cheerio<M>;
+/**
+ * Iterates over a cheerio object, reducing the set of selector elements to
+ * those that match the selector or pass the function's test.
+ *
+ * This is the definition for using type guards; have a look below for other
+ * ways to invoke this method. The function is executed in the context of the
+ * selected element, so `this` refers to the current element.
+ *
+ * @category Traversing
+ * @example <caption>Function</caption>
+ *
+ * ```js
+ * $('li')
+ *   .filter(function (i, el) {
+ *     // this === el
+ *     return $(this).attr('class') === 'orange';
+ *   })
+ *   .attr('class'); //=> orange
+ * ```
+ *
+ * @param match - Value to look for, following the rules above.
+ * @returns The filtered collection.
+ * @see {@link https://api.jquery.com/filter/}
+ */
+export declare function filter<T, S extends T>(this: Cheerio<T>, match: (this: T, index: number, value: T) => value is S): Cheerio<S>;
+/**
+ * Iterates over a cheerio object, reducing the set of selector elements to
+ * those that match the selector or pass the function's test.
+ *
+ * - When a Cheerio selection is specified, return only the elements contained in
+ *   that selection.
+ * - When an element is specified, return only that element (if it is contained in
+ *   the original selection).
+ * - If using the function method, the function is executed in the context of the
+ *   selected element, so `this` refers to the current element.
+ *
+ * @category Traversing
+ * @example <caption>Selector</caption>
+ *
+ * ```js
+ * $('li').filter('.orange').attr('class');
+ * //=> orange
+ * ```
+ *
+ * @example <caption>Function</caption>
+ *
+ * ```js
+ * $('li')
+ *   .filter(function (i, el) {
+ *     // this === el
+ *     return $(this).attr('class') === 'orange';
+ *   })
+ *   .attr('class'); //=> orange
+ * ```
+ *
+ * @param match - Value to look for, following the rules above. See
+ *   {@link AcceptedFilters}.
+ * @returns The filtered collection.
+ * @see {@link https://api.jquery.com/filter/}
+ */
+export declare function filter<T, S extends AcceptedFilters<T>>(this: Cheerio<T>, match: S): Cheerio<S extends string ? Element : T>;
+export declare function filterArray<T>(nodes: T[], match: AcceptedFilters<T>, xmlMode?: boolean, root?: Document): Element[] | T[];
+/**
+ * Checks the current list of elements and returns `true` if *any* of the
+ * elements match the selector. If using an element or Cheerio selection,
+ * returns `true` if *any* of the elements match. If using a predicate function,
+ * the function is executed in the context of the selected element, so `this`
+ * refers to the current element.
+ *
+ * @category Attributes
+ * @param selector - Selector for the selection.
+ * @returns Whether or not the selector matches an element of the instance.
+ * @see {@link https://api.jquery.com/is/}
+ */
+export declare function is<T>(this: Cheerio<T>, selector?: AcceptedFilters<T>): boolean;
+/**
+ * Remove elements from the set of matched elements. Given a Cheerio object that
+ * represents a set of DOM elements, the `.not()` method constructs a new
+ * Cheerio object from a subset of the matching elements. The supplied selector
+ * is tested against each element; the elements that don't match the selector
+ * will be included in the result.
+ *
+ * The `.not()` method can take a function as its argument in the same way that
+ * `.filter()` does. Elements for which the function returns `true` are excluded
+ * from the filtered set; all other elements are included.
+ *
+ * @category Traversing
+ * @example <caption>Selector</caption>
+ *
+ * ```js
+ * $('li').not('.apple').length;
+ * //=> 2
+ * ```
+ *
+ * @example <caption>Function</caption>
+ *
+ * ```js
+ * $('li').not(function (i, el) {
+ *   // this === el
+ *   return $(this).attr('class') === 'orange';
+ * }).length; //=> 2
+ * ```
+ *
+ * @param match - Value to look for, following the rules above.
+ * @param container - Optional node to filter instead.
+ * @returns The filtered collection.
+ * @see {@link https://api.jquery.com/not/}
+ */
+export declare function not<T extends Node>(this: Cheerio<T>, match: AcceptedFilters<T>): Cheerio<T>;
+/**
+ * Filters the set of matched elements to only those which have the given DOM
+ * element as a descendant or which have a descendant that matches the given
+ * selector. Equivalent to `.filter(':has(selector)')`.
+ *
+ * @category Traversing
+ * @example <caption>Selector</caption>
+ *
+ * ```js
+ * $('ul').has('.pear').attr('id');
+ * //=> fruits
+ * ```
+ *
+ * @example <caption>Element</caption>
+ *
+ * ```js
+ * $('ul').has($('.pear')[0]).attr('id');
+ * //=> fruits
+ * ```
+ *
+ * @param selectorOrHaystack - Element to look for.
+ * @returns The filtered collection.
+ * @see {@link https://api.jquery.com/has/}
+ */
+export declare function has(this: Cheerio<Node | Element>, selectorOrHaystack: string | Cheerio<Element> | Element): Cheerio<Node | Element>;
+/**
+ * Will select the first element of a cheerio object.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('#fruits').children().first().text();
+ * //=> Apple
+ * ```
+ *
+ * @returns The first element.
+ * @see {@link https://api.jquery.com/first/}
+ */
+export declare function first<T extends Node>(this: Cheerio<T>): Cheerio<T>;
+/**
+ * Will select the last element of a cheerio object.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('#fruits').children().last().text();
+ * //=> Pear
+ * ```
+ *
+ * @returns The last element.
+ * @see {@link https://api.jquery.com/last/}
+ */
+export declare function last<T>(this: Cheerio<T>): Cheerio<T>;
+/**
+ * Reduce the set of matched elements to the one at the specified index. Use
+ * `.eq(-i)` to count backwards from the last selected element.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li').eq(0).text();
+ * //=> Apple
+ *
+ * $('li').eq(-1).text();
+ * //=> Pear
+ * ```
+ *
+ * @param i - Index of the element to select.
+ * @returns The element at the `i`th position.
+ * @see {@link https://api.jquery.com/eq/}
+ */
+export declare function eq<T>(this: Cheerio<T>, i: number): Cheerio<T>;
+/**
+ * Retrieve one of the elements matched by the Cheerio object, at the `i`th position.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li').get(0).tagName;
+ * //=> li
+ * ```
+ *
+ * @param i - Element to retrieve.
+ * @returns The element at the `i`th position.
+ * @see {@link https://api.jquery.com/get/}
+ */
+export declare function get<T>(this: Cheerio<T>, i: number): T;
+/**
+ * Retrieve all elements matched by the Cheerio object, as an array.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li').get().length;
+ * //=> 3
+ * ```
+ *
+ * @returns All elements matched by the Cheerio object.
+ * @see {@link https://api.jquery.com/get/}
+ */
+export declare function get<T>(this: Cheerio<T>): T[];
+/**
+ * Retrieve all the DOM elements contained in the jQuery set as an array.
+ *
+ * @example
+ *
+ * ```js
+ * $('li').toArray();
+ * //=> [ {...}, {...}, {...} ]
+ * ```
+ *
+ * @returns The contained items.
+ */
+export declare function toArray<T>(this: Cheerio<T>): T[];
+/**
+ * Search for a given element from among the matched elements.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.pear').index();
+ * //=> 2 $('.orange').index('li');
+ * //=> 1
+ * $('.apple').index($('#fruit, li'));
+ * //=> 1
+ * ```
+ *
+ * @param selectorOrNeedle - Element to look for.
+ * @returns The index of the element.
+ * @see {@link https://api.jquery.com/index/}
+ */
+export declare function index<T extends Node>(this: Cheerio<T>, selectorOrNeedle?: string | Cheerio<Node> | Node): number;
+/**
+ * Gets the elements matching the specified range (0-based position).
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li').slice(1).eq(0).text();
+ * //=> 'Orange'
+ *
+ * $('li').slice(1, 2).length;
+ * //=> 1
+ * ```
+ *
+ * @param start - An position at which the elements begin to be selected. If
+ *   negative, it indicates an offset from the end of the set.
+ * @param end - An position at which the elements stop being selected. If
+ *   negative, it indicates an offset from the end of the set. If omitted, the
+ *   range continues until the end of the set.
+ * @returns The elements matching the specified range.
+ * @see {@link https://api.jquery.com/slice/}
+ */
+export declare function slice<T>(this: Cheerio<T>, start?: number, end?: number): Cheerio<T>;
+/**
+ * End the most recent filtering operation in the current chain and return the
+ * set of matched elements to its previous state.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li').eq(0).end().length;
+ * //=> 3
+ * ```
+ *
+ * @returns The previous state of the set of matched elements.
+ * @see {@link https://api.jquery.com/end/}
+ */
+export declare function end<T>(this: Cheerio<T>): Cheerio<Node>;
+/**
+ * Add elements to the set of matched elements.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.apple').add('.orange').length;
+ * //=> 2
+ * ```
+ *
+ * @param other - Elements to add.
+ * @param context - Optionally the context of the new selection.
+ * @returns The combined set.
+ * @see {@link https://api.jquery.com/add/}
+ */
+export declare function add<S extends Node, T extends Node>(this: Cheerio<T>, other: string | Cheerio<S> | S | S[], context?: Cheerio<S> | string): Cheerio<S | T>;
+/**
+ * Add the previous set of elements on the stack to the current set, optionally
+ * filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li').eq(0).addBack('.orange').length;
+ * //=> 2
+ * ```
+ *
+ * @param selector - Selector for the elements to add.
+ * @returns The combined set.
+ * @see {@link https://api.jquery.com/addBack/}
+ */
+export declare function addBack<T extends Node>(this: Cheerio<T>, selector?: string): Cheerio<Node>;
+//# sourceMappingURL=traversing.d.ts.map

node/node_modules/cheerio/lib/api/traversing.js

@@ -0,0 +1,866 @@
+"use strict";
+/**
+ * Methods for traversing the DOM structure.
+ *
+ * @module cheerio/traversing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addBack = exports.add = exports.end = exports.slice = exports.index = exports.toArray = exports.get = exports.eq = exports.last = exports.first = exports.has = exports.not = exports.is = exports.filterArray = exports.filter = exports.map = exports.each = exports.contents = exports.children = exports.siblings = exports.prevUntil = exports.prevAll = exports.prev = exports.nextUntil = exports.nextAll = exports.next = exports.closest = exports.parentsUntil = exports.parents = exports.parent = exports.find = void 0;
+var tslib_1 = require("tslib");
+var domhandler_1 = require("domhandler");
+var select = tslib_1.__importStar(require("cheerio-select"));
+var utils_1 = require("../utils");
+var static_1 = require("../static");
+var htmlparser2_1 = require("htmlparser2");
+var uniqueSort = htmlparser2_1.DomUtils.uniqueSort;
+var reSiblingSelector = /^\s*[~+]/;
+/**
+ * Get the descendants of each element in the current set of matched elements,
+ * filtered by a selector, jQuery object, or element.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('#fruits').find('li').length;
+ * //=> 3
+ * $('#fruits').find($('.apple')).length;
+ * //=> 1
+ * ```
+ *
+ * @param selectorOrHaystack - Element to look for.
+ * @returns The found elements.
+ * @see {@link https://api.jquery.com/find/}
+ */
+function find(selectorOrHaystack) {
+    var _a;
+    if (!selectorOrHaystack) {
+        return this._make([]);
+    }
+    var context = this.toArray();
+    if (typeof selectorOrHaystack !== 'string') {
+        var haystack = utils_1.isCheerio(selectorOrHaystack)
+            ? selectorOrHaystack.toArray()
+            : [selectorOrHaystack];
+        return this._make(haystack.filter(function (elem) { return context.some(function (node) { return static_1.contains(node, elem); }); }));
+    }
+    var elems = reSiblingSelector.test(selectorOrHaystack)
+        ? context
+        : this.children().toArray();
+    var options = {
+        context: context,
+        root: (_a = this._root) === null || _a === void 0 ? void 0 : _a[0],
+        xmlMode: this.options.xmlMode,
+    };
+    return this._make(select.select(selectorOrHaystack, elems, options));
+}
+exports.find = find;
+/**
+ * Creates a matcher, using a particular mapping function. Matchers provide a
+ * function that finds elements using a generating function, supporting filtering.
+ *
+ * @private
+ * @param matchMap - Mapping function.
+ * @returns - Function for wrapping generating functions.
+ */
+function _getMatcher(matchMap) {
+    return function (fn) {
+        var postFns = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            postFns[_i - 1] = arguments[_i];
+        }
+        return function (selector) {
+            var _a;
+            var matched = matchMap(fn, this);
+            if (selector) {
+                matched = filterArray(matched, selector, this.options.xmlMode, (_a = this._root) === null || _a === void 0 ? void 0 : _a[0]);
+            }
+            return this._make(
+            // Post processing is only necessary if there is more than one element.
+            this.length > 1 && matched.length > 1
+                ? postFns.reduce(function (elems, fn) { return fn(elems); }, matched)
+                : matched);
+        };
+    };
+}
+/** Matcher that adds multiple elements for each entry in the input. */
+var _matcher = _getMatcher(function (fn, elems) {
+    var _a;
+    var ret = [];
+    for (var i = 0; i < elems.length; i++) {
+        var value = fn(elems[i]);
+        ret.push(value);
+    }
+    return (_a = new Array()).concat.apply(_a, ret);
+});
+/** Matcher that adds at most one element for each entry in the input. */
+var _singleMatcher = _getMatcher(function (fn, elems) {
+    var ret = [];
+    for (var i = 0; i < elems.length; i++) {
+        var value = fn(elems[i]);
+        if (value !== null) {
+            ret.push(value);
+        }
+    }
+    return ret;
+});
+/**
+ * Matcher that supports traversing until a condition is met.
+ *
+ * @returns A function usable for `*Until` methods.
+ */
+function _matchUntil(nextElem) {
+    var postFns = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        postFns[_i - 1] = arguments[_i];
+    }
+    // We use a variable here that is used from within the matcher.
+    var matches = null;
+    var innerMatcher = _getMatcher(function (nextElem, elems) {
+        var matched = [];
+        utils_1.domEach(elems, function (elem) {
+            for (var next_1; (next_1 = nextElem(elem)); elem = next_1) {
+                // FIXME: `matched` might contain duplicates here and the index is too large.
+                if (matches === null || matches === void 0 ? void 0 : matches(next_1, matched.length))
+                    break;
+                matched.push(next_1);
+            }
+        });
+        return matched;
+    }).apply(void 0, tslib_1.__spreadArray([nextElem], postFns));
+    return function (selector, filterSelector) {
+        var _this = this;
+        // Override `matches` variable with the new target.
+        matches =
+            typeof selector === 'string'
+                ? function (elem) { return select.is(elem, selector, _this.options); }
+                : selector
+                    ? getFilterFn(selector)
+                    : null;
+        var ret = innerMatcher.call(this, filterSelector);
+        // Set `matches` to `null`, so we don't waste memory.
+        matches = null;
+        return ret;
+    };
+}
+function _removeDuplicates(elems) {
+    return Array.from(new Set(elems));
+}
+/**
+ * Get the parent of each element in the current set of matched elements,
+ * optionally filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.pear').parent().attr('id');
+ * //=> fruits
+ * ```
+ *
+ * @param selector - If specified filter for parent.
+ * @returns The parents.
+ * @see {@link https://api.jquery.com/parent/}
+ */
+exports.parent = _singleMatcher(function (_a) {
+    var parent = _a.parent;
+    return (parent && !domhandler_1.isDocument(parent) ? parent : null);
+}, _removeDuplicates);
+/**
+ * Get a set of parents filtered by `selector` of each element in the current
+ * set of match elements.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.orange').parents().length;
+ * //=> 2
+ * $('.orange').parents('#fruits').length;
+ * //=> 1
+ * ```
+ *
+ * @param selector - If specified filter for parents.
+ * @returns The parents.
+ * @see {@link https://api.jquery.com/parents/}
+ */
+exports.parents = _matcher(function (elem) {
+    var matched = [];
+    while (elem.parent && !domhandler_1.isDocument(elem.parent)) {
+        matched.push(elem.parent);
+        elem = elem.parent;
+    }
+    return matched;
+}, uniqueSort, function (elems) { return elems.reverse(); });
+/**
+ * Get the ancestors of each element in the current set of matched elements, up
+ * to but not including the element matched by the selector, DOM node, or cheerio object.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.orange').parentsUntil('#food').length;
+ * //=> 1
+ * ```
+ *
+ * @param selector - Selector for element to stop at.
+ * @param filterSelector - Optional filter for parents.
+ * @returns The parents.
+ * @see {@link https://api.jquery.com/parentsUntil/}
+ */
+exports.parentsUntil = _matchUntil(function (_a) {
+    var parent = _a.parent;
+    return (parent && !domhandler_1.isDocument(parent) ? parent : null);
+}, uniqueSort, function (elems) { return elems.reverse(); });
+/**
+ * For each element in the set, get the first element that matches the selector
+ * by testing the element itself and traversing up through its ancestors in the DOM tree.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.orange').closest();
+ * //=> []
+ *
+ * $('.orange').closest('.apple');
+ * // => []
+ *
+ * $('.orange').closest('li');
+ * //=> [<li class="orange">Orange</li>]
+ *
+ * $('.orange').closest('#fruits');
+ * //=> [<ul id="fruits"> ... </ul>]
+ * ```
+ *
+ * @param selector - Selector for the element to find.
+ * @returns The closest nodes.
+ * @see {@link https://api.jquery.com/closest/}
+ */
+function closest(selector) {
+    var _this = this;
+    var set = [];
+    if (!selector) {
+        return this._make(set);
+    }
+    utils_1.domEach(this, function (elem) {
+        var _a;
+        while (elem && elem.type !== 'root') {
+            if (!selector ||
+                filterArray([elem], selector, _this.options.xmlMode, (_a = _this._root) === null || _a === void 0 ? void 0 : _a[0])
+                    .length) {
+                // Do not add duplicate elements to the set
+                if (elem && !set.includes(elem)) {
+                    set.push(elem);
+                }
+                break;
+            }
+            elem = elem.parent;
+        }
+    });
+    return this._make(set);
+}
+exports.closest = closest;
+/**
+ * Gets the next sibling of the first selected element, optionally filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.apple').next().hasClass('orange');
+ * //=> true
+ * ```
+ *
+ * @param selector - If specified filter for sibling.
+ * @returns The next nodes.
+ * @see {@link https://api.jquery.com/next/}
+ */
+exports.next = _singleMatcher(function (elem) { return htmlparser2_1.DomUtils.nextElementSibling(elem); });
+/**
+ * Gets all the following siblings of the first selected element, optionally
+ * filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.apple').nextAll();
+ * //=> [<li class="orange">Orange</li>, <li class="pear">Pear</li>]
+ * $('.apple').nextAll('.orange');
+ * //=> [<li class="orange">Orange</li>]
+ * ```
+ *
+ * @param selector - If specified filter for siblings.
+ * @returns The next nodes.
+ * @see {@link https://api.jquery.com/nextAll/}
+ */
+exports.nextAll = _matcher(function (elem) {
+    var matched = [];
+    while (elem.next) {
+        elem = elem.next;
+        if (utils_1.isTag(elem))
+            matched.push(elem);
+    }
+    return matched;
+}, _removeDuplicates);
+/**
+ * Gets all the following siblings up to but not including the element matched
+ * by the selector, optionally filtered by another selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.apple').nextUntil('.pear');
+ * //=> [<li class="orange">Orange</li>]
+ * ```
+ *
+ * @param selector - Selector for element to stop at.
+ * @param filterSelector - If specified filter for siblings.
+ * @returns The next nodes.
+ * @see {@link https://api.jquery.com/nextUntil/}
+ */
+exports.nextUntil = _matchUntil(function (el) { return htmlparser2_1.DomUtils.nextElementSibling(el); }, _removeDuplicates);
+/**
+ * Gets the previous sibling of the first selected element optionally filtered
+ * by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.orange').prev().hasClass('apple');
+ * //=> true
+ * ```
+ *
+ * @param selector - If specified filter for siblings.
+ * @returns The previous nodes.
+ * @see {@link https://api.jquery.com/prev/}
+ */
+exports.prev = _singleMatcher(function (elem) { return htmlparser2_1.DomUtils.prevElementSibling(elem); });
+/**
+ * Gets all the preceding siblings of the first selected element, optionally
+ * filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.pear').prevAll();
+ * //=> [<li class="orange">Orange</li>, <li class="apple">Apple</li>]
+ *
+ * $('.pear').prevAll('.orange');
+ * //=> [<li class="orange">Orange</li>]
+ * ```
+ *
+ * @param selector - If specified filter for siblings.
+ * @returns The previous nodes.
+ * @see {@link https://api.jquery.com/prevAll/}
+ */
+exports.prevAll = _matcher(function (elem) {
+    var matched = [];
+    while (elem.prev) {
+        elem = elem.prev;
+        if (utils_1.isTag(elem))
+            matched.push(elem);
+    }
+    return matched;
+}, _removeDuplicates);
+/**
+ * Gets all the preceding siblings up to but not including the element matched
+ * by the selector, optionally filtered by another selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.pear').prevUntil('.apple');
+ * //=> [<li class="orange">Orange</li>]
+ * ```
+ *
+ * @param selector - Selector for element to stop at.
+ * @param filterSelector - If specified filter for siblings.
+ * @returns The previous nodes.
+ * @see {@link https://api.jquery.com/prevUntil/}
+ */
+exports.prevUntil = _matchUntil(function (el) { return htmlparser2_1.DomUtils.prevElementSibling(el); }, _removeDuplicates);
+/**
+ * Get the siblings of each element (excluding the element) in the set of
+ * matched elements, optionally filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.pear').siblings().length;
+ * //=> 2
+ *
+ * $('.pear').siblings('.orange').length;
+ * //=> 1
+ * ```
+ *
+ * @param selector - If specified filter for siblings.
+ * @returns The siblings.
+ * @see {@link https://api.jquery.com/siblings/}
+ */
+exports.siblings = _matcher(function (elem) {
+    return htmlparser2_1.DomUtils.getSiblings(elem).filter(function (el) { return utils_1.isTag(el) && el !== elem; });
+}, uniqueSort);
+/**
+ * Gets the children of the first selected element.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('#fruits').children().length;
+ * //=> 3
+ *
+ * $('#fruits').children('.pear').text();
+ * //=> Pear
+ * ```
+ *
+ * @param selector - If specified filter for children.
+ * @returns The children.
+ * @see {@link https://api.jquery.com/children/}
+ */
+exports.children = _matcher(function (elem) { return htmlparser2_1.DomUtils.getChildren(elem).filter(utils_1.isTag); }, _removeDuplicates);
+/**
+ * Gets the children of each element in the set of matched elements, including
+ * text and comment nodes.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('#fruits').contents().length;
+ * //=> 3
+ * ```
+ *
+ * @returns The children.
+ * @see {@link https://api.jquery.com/contents/}
+ */
+function contents() {
+    var elems = this.toArray().reduce(function (newElems, elem) {
+        return domhandler_1.hasChildren(elem) ? newElems.concat(elem.children) : newElems;
+    }, []);
+    return this._make(elems);
+}
+exports.contents = contents;
+/**
+ * Iterates over a cheerio object, executing a function for each matched
+ * element. When the callback is fired, the function is fired in the context of
+ * the DOM element, so `this` refers to the current element, which is equivalent
+ * to the function parameter `element`. To break out of the `each` loop early,
+ * return with `false`.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * const fruits = [];
+ *
+ * $('li').each(function (i, elem) {
+ *   fruits[i] = $(this).text();
+ * });
+ *
+ * fruits.join(', ');
+ * //=> Apple, Orange, Pear
+ * ```
+ *
+ * @param fn - Function to execute.
+ * @returns The instance itself, useful for chaining.
+ * @see {@link https://api.jquery.com/each/}
+ */
+function each(fn) {
+    var i = 0;
+    var len = this.length;
+    while (i < len && fn.call(this[i], i, this[i]) !== false)
+        ++i;
+    return this;
+}
+exports.each = each;
+/**
+ * Pass each element in the current matched set through a function, producing a
+ * new Cheerio object containing the return values. The function can return an
+ * individual data item or an array of data items to be inserted into the
+ * resulting set. If an array is returned, the elements inside the array are
+ * inserted into the set. If the function returns null or undefined, no element
+ * will be inserted.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li')
+ *   .map(function (i, el) {
+ *     // this === el
+ *     return $(this).text();
+ *   })
+ *   .toArray()
+ *   .join(' ');
+ * //=> "apple orange pear"
+ * ```
+ *
+ * @param fn - Function to execute.
+ * @returns The mapped elements, wrapped in a Cheerio collection.
+ * @see {@link https://api.jquery.com/map/}
+ */
+function map(fn) {
+    var elems = [];
+    for (var i = 0; i < this.length; i++) {
+        var el = this[i];
+        var val = fn.call(el, i, el);
+        if (val != null) {
+            elems = elems.concat(val);
+        }
+    }
+    return this._make(elems);
+}
+exports.map = map;
+/**
+ * Creates a function to test if a filter is matched.
+ *
+ * @param match - A filter.
+ * @returns A function that determines if a filter has been matched.
+ */
+function getFilterFn(match) {
+    if (typeof match === 'function') {
+        return function (el, i) { return match.call(el, i, el); };
+    }
+    if (utils_1.isCheerio(match)) {
+        return function (el) { return Array.prototype.includes.call(match, el); };
+    }
+    return function (el) {
+        return match === el;
+    };
+}
+function filter(match) {
+    var _a;
+    return this._make(filterArray(this.toArray(), match, this.options.xmlMode, (_a = this._root) === null || _a === void 0 ? void 0 : _a[0]));
+}
+exports.filter = filter;
+function filterArray(nodes, match, xmlMode, root) {
+    return typeof match === 'string'
+        ? select.filter(match, nodes, { xmlMode: xmlMode, root: root })
+        : nodes.filter(getFilterFn(match));
+}
+exports.filterArray = filterArray;
+/**
+ * Checks the current list of elements and returns `true` if *any* of the
+ * elements match the selector. If using an element or Cheerio selection,
+ * returns `true` if *any* of the elements match. If using a predicate function,
+ * the function is executed in the context of the selected element, so `this`
+ * refers to the current element.
+ *
+ * @category Attributes
+ * @param selector - Selector for the selection.
+ * @returns Whether or not the selector matches an element of the instance.
+ * @see {@link https://api.jquery.com/is/}
+ */
+function is(selector) {
+    var nodes = this.toArray();
+    return typeof selector === 'string'
+        ? select.some(nodes.filter(utils_1.isTag), selector, this.options)
+        : selector
+            ? nodes.some(getFilterFn(selector))
+            : false;
+}
+exports.is = is;
+/**
+ * Remove elements from the set of matched elements. Given a Cheerio object that
+ * represents a set of DOM elements, the `.not()` method constructs a new
+ * Cheerio object from a subset of the matching elements. The supplied selector
+ * is tested against each element; the elements that don't match the selector
+ * will be included in the result.
+ *
+ * The `.not()` method can take a function as its argument in the same way that
+ * `.filter()` does. Elements for which the function returns `true` are excluded
+ * from the filtered set; all other elements are included.
+ *
+ * @category Traversing
+ * @example <caption>Selector</caption>
+ *
+ * ```js
+ * $('li').not('.apple').length;
+ * //=> 2
+ * ```
+ *
+ * @example <caption>Function</caption>
+ *
+ * ```js
+ * $('li').not(function (i, el) {
+ *   // this === el
+ *   return $(this).attr('class') === 'orange';
+ * }).length; //=> 2
+ * ```
+ *
+ * @param match - Value to look for, following the rules above.
+ * @param container - Optional node to filter instead.
+ * @returns The filtered collection.
+ * @see {@link https://api.jquery.com/not/}
+ */
+function not(match) {
+    var nodes = this.toArray();
+    if (typeof match === 'string') {
+        var matches_1 = new Set(select.filter(match, nodes, this.options));
+        nodes = nodes.filter(function (el) { return !matches_1.has(el); });
+    }
+    else {
+        var filterFn_1 = getFilterFn(match);
+        nodes = nodes.filter(function (el, i) { return !filterFn_1(el, i); });
+    }
+    return this._make(nodes);
+}
+exports.not = not;
+/**
+ * Filters the set of matched elements to only those which have the given DOM
+ * element as a descendant or which have a descendant that matches the given
+ * selector. Equivalent to `.filter(':has(selector)')`.
+ *
+ * @category Traversing
+ * @example <caption>Selector</caption>
+ *
+ * ```js
+ * $('ul').has('.pear').attr('id');
+ * //=> fruits
+ * ```
+ *
+ * @example <caption>Element</caption>
+ *
+ * ```js
+ * $('ul').has($('.pear')[0]).attr('id');
+ * //=> fruits
+ * ```
+ *
+ * @param selectorOrHaystack - Element to look for.
+ * @returns The filtered collection.
+ * @see {@link https://api.jquery.com/has/}
+ */
+function has(selectorOrHaystack) {
+    var _this = this;
+    return this.filter(typeof selectorOrHaystack === 'string'
+        ? // Using the `:has` selector here short-circuits searches.
+            ":has(" + selectorOrHaystack + ")"
+        : function (_, el) { return _this._make(el).find(selectorOrHaystack).length > 0; });
+}
+exports.has = has;
+/**
+ * Will select the first element of a cheerio object.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('#fruits').children().first().text();
+ * //=> Apple
+ * ```
+ *
+ * @returns The first element.
+ * @see {@link https://api.jquery.com/first/}
+ */
+function first() {
+    return this.length > 1 ? this._make(this[0]) : this;
+}
+exports.first = first;
+/**
+ * Will select the last element of a cheerio object.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('#fruits').children().last().text();
+ * //=> Pear
+ * ```
+ *
+ * @returns The last element.
+ * @see {@link https://api.jquery.com/last/}
+ */
+function last() {
+    return this.length > 0 ? this._make(this[this.length - 1]) : this;
+}
+exports.last = last;
+/**
+ * Reduce the set of matched elements to the one at the specified index. Use
+ * `.eq(-i)` to count backwards from the last selected element.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li').eq(0).text();
+ * //=> Apple
+ *
+ * $('li').eq(-1).text();
+ * //=> Pear
+ * ```
+ *
+ * @param i - Index of the element to select.
+ * @returns The element at the `i`th position.
+ * @see {@link https://api.jquery.com/eq/}
+ */
+function eq(i) {
+    var _a;
+    i = +i;
+    // Use the first identity optimization if possible
+    if (i === 0 && this.length <= 1)
+        return this;
+    if (i < 0)
+        i = this.length + i;
+    return this._make((_a = this[i]) !== null && _a !== void 0 ? _a : []);
+}
+exports.eq = eq;
+function get(i) {
+    if (i == null) {
+        return this.toArray();
+    }
+    return this[i < 0 ? this.length + i : i];
+}
+exports.get = get;
+/**
+ * Retrieve all the DOM elements contained in the jQuery set as an array.
+ *
+ * @example
+ *
+ * ```js
+ * $('li').toArray();
+ * //=> [ {...}, {...}, {...} ]
+ * ```
+ *
+ * @returns The contained items.
+ */
+function toArray() {
+    return Array.prototype.slice.call(this);
+}
+exports.toArray = toArray;
+/**
+ * Search for a given element from among the matched elements.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.pear').index();
+ * //=> 2 $('.orange').index('li');
+ * //=> 1
+ * $('.apple').index($('#fruit, li'));
+ * //=> 1
+ * ```
+ *
+ * @param selectorOrNeedle - Element to look for.
+ * @returns The index of the element.
+ * @see {@link https://api.jquery.com/index/}
+ */
+function index(selectorOrNeedle) {
+    var $haystack;
+    var needle;
+    if (selectorOrNeedle == null) {
+        $haystack = this.parent().children();
+        needle = this[0];
+    }
+    else if (typeof selectorOrNeedle === 'string') {
+        $haystack = this._make(selectorOrNeedle);
+        needle = this[0];
+    }
+    else {
+        $haystack = this;
+        needle = utils_1.isCheerio(selectorOrNeedle)
+            ? selectorOrNeedle[0]
+            : selectorOrNeedle;
+    }
+    return Array.prototype.indexOf.call($haystack, needle);
+}
+exports.index = index;
+/**
+ * Gets the elements matching the specified range (0-based position).
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li').slice(1).eq(0).text();
+ * //=> 'Orange'
+ *
+ * $('li').slice(1, 2).length;
+ * //=> 1
+ * ```
+ *
+ * @param start - An position at which the elements begin to be selected. If
+ *   negative, it indicates an offset from the end of the set.
+ * @param end - An position at which the elements stop being selected. If
+ *   negative, it indicates an offset from the end of the set. If omitted, the
+ *   range continues until the end of the set.
+ * @returns The elements matching the specified range.
+ * @see {@link https://api.jquery.com/slice/}
+ */
+function slice(start, end) {
+    return this._make(Array.prototype.slice.call(this, start, end));
+}
+exports.slice = slice;
+/**
+ * End the most recent filtering operation in the current chain and return the
+ * set of matched elements to its previous state.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li').eq(0).end().length;
+ * //=> 3
+ * ```
+ *
+ * @returns The previous state of the set of matched elements.
+ * @see {@link https://api.jquery.com/end/}
+ */
+function end() {
+    var _a;
+    return (_a = this.prevObject) !== null && _a !== void 0 ? _a : this._make([]);
+}
+exports.end = end;
+/**
+ * Add elements to the set of matched elements.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('.apple').add('.orange').length;
+ * //=> 2
+ * ```
+ *
+ * @param other - Elements to add.
+ * @param context - Optionally the context of the new selection.
+ * @returns The combined set.
+ * @see {@link https://api.jquery.com/add/}
+ */
+function add(other, context) {
+    var selection = this._make(other, context);
+    var contents = uniqueSort(tslib_1.__spreadArray(tslib_1.__spreadArray([], this.get()), selection.get()));
+    return this._make(contents);
+}
+exports.add = add;
+/**
+ * Add the previous set of elements on the stack to the current set, optionally
+ * filtered by a selector.
+ *
+ * @category Traversing
+ * @example
+ *
+ * ```js
+ * $('li').eq(0).addBack('.orange').length;
+ * //=> 2
+ * ```
+ *
+ * @param selector - Selector for the elements to add.
+ * @returns The combined set.
+ * @see {@link https://api.jquery.com/addBack/}
+ */
+function addBack(selector) {
+    return this.prevObject
+        ? this.add(selector ? this.prevObject.filter(selector) : this.prevObject)
+        : this;
+}
+exports.addBack = addBack;

node/node_modules/cheerio/lib/cheerio.d.ts

@@ -0,0 +1,53 @@
+import { InternalOptions } from './options';
+import type { Node, Document } from 'domhandler';
+import { BasicAcceptedElems } from './types';
+import * as Attributes from './api/attributes';
+import * as Traversing from './api/traversing';
+import * as Manipulation from './api/manipulation';
+import * as Css from './api/css';
+import * as Forms from './api/forms';
+declare type AttributesType = typeof Attributes;
+declare type TraversingType = typeof Traversing;
+declare type ManipulationType = typeof Manipulation;
+declare type CssType = typeof Css;
+declare type FormsType = typeof Forms;
+export declare class Cheerio<T> implements ArrayLike<T> {
+    length: number;
+    [index: number]: T;
+    options: InternalOptions;
+    /**
+     * The root of the document. Can be set by using the `root` argument of the constructor.
+     *
+     * @private
+     */
+    _root: Cheerio<Document> | undefined;
+    /** @function */
+    find: typeof Traversing.find;
+    /**
+     * Instance of cheerio. Methods are specified in the modules. Usage of this
+     * constructor is not recommended. Please use $.load instead.
+     *
+     * @private
+     * @param selector - The new selection.
+     * @param context - Context of the selection.
+     * @param root - Sets the root node.
+     * @param options - Options for the instance.
+     */
+    constructor(selector?: T extends Node ? BasicAcceptedElems<T> : Cheerio<T> | T[], context?: BasicAcceptedElems<Node> | null, root?: BasicAcceptedElems<Document> | null, options?: InternalOptions);
+    prevObject: Cheerio<Node> | undefined;
+    /**
+     * Make a cheerio object.
+     *
+     * @private
+     * @param dom - The contents of the new object.
+     * @param context - The context of the new object.
+     * @returns The new cheerio object.
+     */
+    _make<T>(dom: Cheerio<T> | T[] | T | string, context?: BasicAcceptedElems<Node>): Cheerio<T>;
+}
+export interface Cheerio<T> extends AttributesType, TraversingType, ManipulationType, CssType, FormsType, Iterable<T> {
+    cheerio: '[cheerio object]';
+    splice: typeof Array.prototype.slice;
+}
+export {};
+//# sourceMappingURL=cheerio.d.ts.map

node/node_modules/cheerio/lib/cheerio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cheerio.d.ts","sourceRoot":"","sources":["../src/cheerio.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAA6B,MAAM,WAAW,CAAC;AAEvE,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE7C,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,UAAU,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,YAAY,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,GAAG,MAAM,WAAW,CAAC;AACjC,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AAErC,aAAK,cAAc,GAAG,OAAO,UAAU,CAAC;AACxC,aAAK,cAAc,GAAG,OAAO,UAAU,CAAC;AACxC,aAAK,gBAAgB,GAAG,OAAO,YAAY,CAAC;AAC5C,aAAK,OAAO,GAAG,OAAO,GAAG,CAAC;AAC1B,aAAK,SAAS,GAAG,OAAO,KAAK,CAAC;AAE9B,qBAAa,OAAO,CAAC,CAAC,CAAE,YAAW,SAAS,CAAC,CAAC,CAAC;IAC7C,MAAM,SAAK;IACX,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,CAAC;IAEnB,OAAO,EAAE,eAAe,CAAC;IACzB;;;;OAIG;IACH,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,SAAS,CAAC;IACrC,gBAAgB;IAChB,IAAI,EAAG,OAAO,UAAU,CAAC,IAAI,CAAC;IAE9B;;;;;;;;;OASG;gBAED,QAAQ,CAAC,EAAE,CAAC,SAAS,IAAI,GAAG,kBAAkB,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EACpE,OAAO,CAAC,EAAE,kBAAkB,CAAC,IAAI,CAAC,GAAG,IAAI,EACzC,IAAI,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,GAAG,IAAI,EAC1C,OAAO,GAAE,eAAgC;IAsE3C,UAAU,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IACtC;;;;;;;OAOG;IACH,KAAK,CAAC,CAAC,EACL,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,GAAG,MAAM,EAClC,OAAO,CAAC,EAAE,kBAAkB,CAAC,IAAI,CAAC,GACjC,OAAO,CAAC,CAAC,CAAC;CAWd;AAED,MAAM,WAAW,OAAO,CAAC,CAAC,CACxB,SAAQ,cAAc,EACpB,cAAc,EACd,gBAAgB,EAChB,OAAO,EACP,SAAS,EACT,QAAQ,CAAC,CAAC,CAAC;IACb,OAAO,EAAE,kBAAkB,CAAC;IAE5B,MAAM,EAAE,OAAO,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC;CACtC"}

node/node_modules/cheerio/lib/cheerio.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cheerio = void 0;
+var tslib_1 = require("tslib");
+var parse_1 = tslib_1.__importDefault(require("./parse"));
+var options_1 = tslib_1.__importDefault(require("./options"));
+var utils_1 = require("./utils");
+var Attributes = tslib_1.__importStar(require("./api/attributes"));
+var Traversing = tslib_1.__importStar(require("./api/traversing"));
+var Manipulation = tslib_1.__importStar(require("./api/manipulation"));
+var Css = tslib_1.__importStar(require("./api/css"));
+var Forms = tslib_1.__importStar(require("./api/forms"));
+var Cheerio = /** @class */ (function () {
+    /**
+     * Instance of cheerio. Methods are specified in the modules. Usage of this
+     * constructor is not recommended. Please use $.load instead.
+     *
+     * @private
+     * @param selector - The new selection.
+     * @param context - Context of the selection.
+     * @param root - Sets the root node.
+     * @param options - Options for the instance.
+     */
+    function Cheerio(selector, context, root, options) {
+        var _this = this;
+        if (options === void 0) { options = options_1.default; }
+        this.length = 0;
+        this.options = options;
+        // $(), $(null), $(undefined), $(false)
+        if (!selector)
+            return this;
+        if (root) {
+            if (typeof root === 'string')
+                root = parse_1.default(root, this.options, false);
+            this._root = new this.constructor(root, null, null, this.options);
+            // Add a cyclic reference, so that calling methods on `_root` never fails.
+            this._root._root = this._root;
+        }
+        // $($)
+        if (utils_1.isCheerio(selector))
+            return selector;
+        var elements = typeof selector === 'string' && utils_1.isHtml(selector)
+            ? // $(<html>)
+                parse_1.default(selector, this.options, false).children
+            : isNode(selector)
+                ? // $(dom)
+                    [selector]
+                : Array.isArray(selector)
+                    ? // $([dom])
+                        selector
+                    : null;
+        if (elements) {
+            elements.forEach(function (elem, idx) {
+                _this[idx] = elem;
+            });
+            this.length = elements.length;
+            return this;
+        }
+        // We know that our selector is a string now.
+        var search = selector;
+        var searchContext = !context
+            ? // If we don't have a context, maybe we have a root, from loading
+                this._root
+            : typeof context === 'string'
+                ? utils_1.isHtml(context)
+                    ? // $('li', '<ul>...</ul>')
+                        this._make(parse_1.default(context, this.options, false))
+                    : // $('li', 'ul')
+                        ((search = context + " " + search), this._root)
+                : utils_1.isCheerio(context)
+                    ? // $('li', $)
+                        context
+                    : // $('li', node), $('li', [nodes])
+                        this._make(context);
+        // If we still don't have a context, return
+        if (!searchContext)
+            return this;
+        /*
+         * #id, .class, tag
+         */
+        // @ts-expect-error No good way to type this — we will always return `Cheerio<Element>` here.
+        return searchContext.find(search);
+    }
+    /**
+     * Make a cheerio object.
+     *
+     * @private
+     * @param dom - The contents of the new object.
+     * @param context - The context of the new object.
+     * @returns The new cheerio object.
+     */
+    Cheerio.prototype._make = function (dom, context) {
+        var cheerio = new this.constructor(dom, context, this._root, this.options);
+        cheerio.prevObject = this;
+        return cheerio;
+    };
+    return Cheerio;
+}());
+exports.Cheerio = Cheerio;
+/** Set a signature of the object. */
+Cheerio.prototype.cheerio = '[cheerio object]';
+/*
+ * Make cheerio an array-like object
+ */
+Cheerio.prototype.splice = Array.prototype.splice;
+// Support for (const element of $(...)) iteration:
+Cheerio.prototype[Symbol.iterator] = Array.prototype[Symbol.iterator];
+// Plug in the API
+Object.assign(Cheerio.prototype, Attributes, Traversing, Manipulation, Css, Forms);
+function isNode(obj) {
+    return (!!obj.name ||
+        obj.type === 'root' ||
+        obj.type === 'text' ||
+        obj.type === 'comment');
+}

node/node_modules/cheerio/lib/index.d.ts

@@ -0,0 +1,91 @@
+/**
+ * The main types of Cheerio objects.
+ *
+ * @category Cheerio
+ */
+export type { Cheerio } from './cheerio';
+/**
+ * Types used in signatures of Cheerio methods.
+ *
+ * @category Cheerio
+ */
+export * from './types';
+export type { CheerioOptions, HTMLParser2Options, Parse5Options, } from './options';
+/**
+ * Re-exporting all of the node types.
+ *
+ * @category DOM Node
+ */
+export type { Node, NodeWithChildren, Element, Document } from 'domhandler';
+export * from './load';
+declare const _default: import("./load").CheerioAPI;
+/**
+ * The default cheerio instance.
+ *
+ * @deprecated Use the function returned by `load` instead.
+ */
+export default _default;
+import * as staticMethods from './static';
+/**
+ * In order to promote consistency with the jQuery library, users are encouraged
+ * to instead use the static method of the same name.
+ *
+ * @deprecated
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('<div><p></p></div>');
+ *
+ * $.contains($('div').get(0), $('p').get(0));
+ * //=> true
+ *
+ * $.contains($('p').get(0), $('div').get(0));
+ * //=> false
+ * ```
+ *
+ * @returns {boolean}
+ */
+export declare const contains: typeof staticMethods.contains;
+/**
+ * In order to promote consistency with the jQuery library, users are encouraged
+ * to instead use the static method of the same name.
+ *
+ * @deprecated
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('');
+ *
+ * $.merge([1, 2], [3, 4]);
+ * //=> [1, 2, 3, 4]
+ * ```
+ */
+export declare const merge: typeof staticMethods.merge;
+/**
+ * In order to promote consistency with the jQuery library, users are encouraged
+ * to instead use the static method of the same name as it is defined on the
+ * "loaded" Cheerio factory function.
+ *
+ * @deprecated See {@link static/parseHTML}.
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('');
+ * $.parseHTML('<b>markup</b>');
+ * ```
+ */
+export declare const parseHTML: typeof staticMethods.parseHTML;
+/**
+ * Users seeking to access the top-level element of a parsed document should
+ * instead use the `root` static method of a "loaded" Cheerio function.
+ *
+ * @deprecated
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('');
+ * $.root();
+ * ```
+ */
+export declare const root: typeof staticMethods.root;
+//# sourceMappingURL=index.d.ts.map

node/node_modules/cheerio/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,YAAY,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC;;;;GAIG;AACH,cAAc,SAAS,CAAC;AACxB,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,aAAa,GACd,MAAM,WAAW,CAAC;AACnB;;;;GAIG;AACH,YAAY,EAAE,IAAI,EAAE,gBAAgB,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE5E,cAAc,QAAQ,CAAC;;AAGvB;;;;GAIG;AACH,wBAAwB;AAExB,OAAO,KAAK,aAAa,MAAM,UAAU,CAAC;AAE1C;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAQ,QAAQ,+BAAkB,CAAC;AAE1C;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAQ,KAAK,4BAAkB,CAAC;AAEvC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAQ,SAAS,gCAAkB,CAAC;AAE3C;;;;;;;;;;;GAWG;AACH,eAAO,MAAQ,IAAI,2BAAkB,CAAC"}

node/node_modules/cheerio/lib/index.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.root = exports.parseHTML = exports.merge = exports.contains = void 0;
+var tslib_1 = require("tslib");
+/**
+ * Types used in signatures of Cheerio methods.
+ *
+ * @category Cheerio
+ */
+tslib_1.__exportStar(require("./types"), exports);
+tslib_1.__exportStar(require("./load"), exports);
+var load_1 = require("./load");
+/**
+ * The default cheerio instance.
+ *
+ * @deprecated Use the function returned by `load` instead.
+ */
+exports.default = load_1.load([]);
+var staticMethods = tslib_1.__importStar(require("./static"));
+/**
+ * In order to promote consistency with the jQuery library, users are encouraged
+ * to instead use the static method of the same name.
+ *
+ * @deprecated
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('<div><p></p></div>');
+ *
+ * $.contains($('div').get(0), $('p').get(0));
+ * //=> true
+ *
+ * $.contains($('p').get(0), $('div').get(0));
+ * //=> false
+ * ```
+ *
+ * @returns {boolean}
+ */
+exports.contains = staticMethods.contains;
+/**
+ * In order to promote consistency with the jQuery library, users are encouraged
+ * to instead use the static method of the same name.
+ *
+ * @deprecated
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('');
+ *
+ * $.merge([1, 2], [3, 4]);
+ * //=> [1, 2, 3, 4]
+ * ```
+ */
+exports.merge = staticMethods.merge;
+/**
+ * In order to promote consistency with the jQuery library, users are encouraged
+ * to instead use the static method of the same name as it is defined on the
+ * "loaded" Cheerio factory function.
+ *
+ * @deprecated See {@link static/parseHTML}.
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('');
+ * $.parseHTML('<b>markup</b>');
+ * ```
+ */
+exports.parseHTML = staticMethods.parseHTML;
+/**
+ * Users seeking to access the top-level element of a parsed document should
+ * instead use the `root` static method of a "loaded" Cheerio function.
+ *
+ * @deprecated
+ * @example
+ *
+ * ```js
+ * const $ = cheerio.load('');
+ * $.root();
+ * ```
+ */
+exports.root = staticMethods.root;

node/node_modules/cheerio/lib/load.d.ts

@@ -0,0 +1,73 @@
+/// <reference types="node" />
+import { CheerioOptions, InternalOptions } from './options';
+import * as staticMethods from './static';
+import { Cheerio } from './cheerio';
+import type { Node, Document, Element } from 'domhandler';
+import type * as Load from './load';
+import { SelectorType, BasicAcceptedElems } from './types';
+declare type StaticType = typeof staticMethods;
+declare type LoadType = typeof Load;
+/**
+ * A querying function, bound to a document created from the provided markup.
+ *
+ * Also provides several helper methods for dealing with the document as a whole.
+ */
+export interface CheerioAPI extends StaticType, LoadType {
+    /**
+     * This selector method is the starting point for traversing and manipulating
+     * the document. Like jQuery, it's the primary method for selecting elements
+     * in the document.
+     *
+     * `selector` searches within the `context` scope which searches within the
+     * `root` scope.
+     *
+     * @example
+     *
+     * ```js
+     * $('.apple', '#fruits').text();
+     * //=> Apple
+     *
+     * $('ul .pear').attr('class');
+     * //=> pear
+     *
+     * $('li[class=orange]').html();
+     * //=> Orange
+     * ```
+     *
+     * @param selector - Either a selector to look for within the document, or the
+     *   contents of a new Cheerio instance.
+     * @param context - Either a selector to look for within the root, or the
+     *   contents of the document to query.
+     * @param root - Optional HTML document string.
+     */
+    <T extends Node, S extends string>(selector?: S | BasicAcceptedElems<T>, context?: BasicAcceptedElems<Node> | null, root?: BasicAcceptedElems<Document>, options?: CheerioOptions): Cheerio<S extends SelectorType ? Element : T>;
+    /**
+     * The root the document was originally loaded with.
+     *
+     * @private
+     */
+    _root: Document;
+    /**
+     * The options the document was originally loaded with.
+     *
+     * @private
+     */
+    _options: InternalOptions;
+    /** Mimic jQuery's prototype alias for plugin authors. */
+    fn: typeof Cheerio.prototype;
+}
+/**
+ * Create a querying function, bound to a document created from the provided
+ * markup. Note that similar to web browser contexts, this operation may
+ * introduce `<html>`, `<head>`, and `<body>` elements; set `isDocument` to
+ * `false` to switch to fragment mode and disable this.
+ *
+ * @param content - Markup to be loaded.
+ * @param options - Options for the created instance.
+ * @param isDocument - Allows parser to be switched to fragment mode.
+ * @returns The loaded document.
+ * @see {@link https://cheerio.js.org#loading} for additional usage information.
+ */
+export declare function load(content: string | Node | Node[] | Buffer, options?: CheerioOptions | null, isDocument?: boolean): CheerioAPI;
+export {};
+//# sourceMappingURL=load.d.ts.map

node/node_modules/cheerio/lib/load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load.d.ts","sourceRoot":"","sources":["../src/load.ts"],"names":[],"mappings":";AAAA,OAAO,EACL,cAAc,EACd,eAAe,EAGhB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,aAAa,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAC1D,OAAO,KAAK,KAAK,IAAI,MAAM,QAAQ,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE3D,aAAK,UAAU,GAAG,OAAO,aAAa,CAAC;AACvC,aAAK,QAAQ,GAAG,OAAO,IAAI,CAAC;AAE5B;;;;GAIG;AACH,MAAM,WAAW,UAAW,SAAQ,UAAU,EAAE,QAAQ;IACtD;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,CAAC,CAAC,SAAS,IAAI,EAAE,CAAC,SAAS,MAAM,EAC/B,QAAQ,CAAC,EAAE,CAAC,GAAG,kBAAkB,CAAC,CAAC,CAAC,EACpC,OAAO,CAAC,EAAE,kBAAkB,CAAC,IAAI,CAAC,GAAG,IAAI,EACzC,IAAI,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,EACnC,OAAO,CAAC,EAAE,cAAc,GACvB,OAAO,CAAC,CAAC,SAAS,YAAY,GAAG,OAAO,GAAG,CAAC,CAAC,CAAC;IAEjD;;;;OAIG;IACH,KAAK,EAAE,QAAQ,CAAC;IAEhB;;;;OAIG;IACH,QAAQ,EAAE,eAAe,CAAC;IAE1B,yDAAyD;IACzD,EAAE,EAAE,OAAO,OAAO,CAAC,SAAS,CAAC;CAC9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,IAAI,CAClB,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,EAAE,GAAG,MAAM,EACxC,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,EAC/B,UAAU,UAAO,GAChB,UAAU,CAsCZ"}

node/node_modules/cheerio/lib/load.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.load = void 0;
+var tslib_1 = require("tslib");
+var options_1 = tslib_1.__importStar(require("./options"));
+var staticMethods = tslib_1.__importStar(require("./static"));
+var cheerio_1 = require("./cheerio");
+var parse_1 = tslib_1.__importDefault(require("./parse"));
+/**
+ * Create a querying function, bound to a document created from the provided
+ * markup. Note that similar to web browser contexts, this operation may
+ * introduce `<html>`, `<head>`, and `<body>` elements; set `isDocument` to
+ * `false` to switch to fragment mode and disable this.
+ *
+ * @param content - Markup to be loaded.
+ * @param options - Options for the created instance.
+ * @param isDocument - Allows parser to be switched to fragment mode.
+ * @returns The loaded document.
+ * @see {@link https://cheerio.js.org#loading} for additional usage information.
+ */
+function load(content, options, isDocument) {
+    if (isDocument === void 0) { isDocument = true; }
+    if (content == null) {
+        throw new Error('cheerio.load() expects a string');
+    }
+    var internalOpts = tslib_1.__assign(tslib_1.__assign({}, options_1.default), options_1.flatten(options));
+    var root = parse_1.default(content, internalOpts, isDocument);
+    /** Create an extended class here, so that extensions only live on one instance. */
+    var LoadedCheerio = /** @class */ (function (_super) {
+        tslib_1.__extends(LoadedCheerio, _super);
+        function LoadedCheerio() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
+        return LoadedCheerio;
+    }(cheerio_1.Cheerio));
+    function initialize(selector, context, r, opts) {
+        if (r === void 0) { r = root; }
+        return new LoadedCheerio(selector, context, r, tslib_1.__assign(tslib_1.__assign({}, internalOpts), options_1.flatten(opts)));
+    }
+    // Add in static methods & properties
+    Object.assign(initialize, staticMethods, {
+        load: load,
+        // `_root` and `_options` are used in static methods.
+        _root: root,
+        _options: internalOpts,
+        // Add `fn` for plugins
+        fn: LoadedCheerio.prototype,
+        // Add the prototype here to maintain `instanceof` behavior.
+        prototype: LoadedCheerio.prototype,
+    });
+    return initialize;
+}
+exports.load = load;

node/node_modules/cheerio/lib/options.d.ts

@@ -0,0 +1,31 @@
+import type { DomHandlerOptions } from 'domhandler';
+import type { ParserOptions } from 'htmlparser2';
+/** Options accepted by htmlparser2, the default parser for XML. */
+export interface HTMLParser2Options extends DomHandlerOptions, ParserOptions {
+}
+/** Options for parse5, the default parser for HTML. */
+export interface Parse5Options {
+    /** Disable scripting in parse5, so noscript tags would be parsed. */
+    scriptingEnabled?: boolean;
+    /** Enable location support for parse5. */
+    sourceCodeLocationInfo?: boolean;
+}
+/** Internal options for Cheerio. */
+export interface InternalOptions extends HTMLParser2Options, Parse5Options {
+    _useHtmlParser2?: boolean;
+}
+/**
+ * Options accepted by Cheerio.
+ *
+ * Please note that parser-specific options are *only recognized* if the
+ * relevant parser is used.
+ */
+export interface CheerioOptions extends HTMLParser2Options, Parse5Options {
+    /** Suggested way of configuring htmlparser2 when wanting to parse XML. */
+    xml?: HTMLParser2Options | boolean;
+}
+declare const defaultOpts: CheerioOptions;
+/** Cheerio default options. */
+export default defaultOpts;
+export declare function flatten(options?: CheerioOptions | null): InternalOptions | undefined;
+//# sourceMappingURL=options.d.ts.map

node/node_modules/cheerio/lib/options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,mEAAmE;AACnE,MAAM,WAAW,kBAAmB,SAAQ,iBAAiB,EAAE,aAAa;CAAG;AAC/E,uDAAuD;AACvD,MAAM,WAAW,aAAa;IAC5B,qEAAqE;IACrE,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,0CAA0C;IAC1C,sBAAsB,CAAC,EAAE,OAAO,CAAC;CAClC;AAED,oCAAoC;AACpC,MAAM,WAAW,eAAgB,SAAQ,kBAAkB,EAAE,aAAa;IACxE,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAe,SAAQ,kBAAkB,EAAE,aAAa;IACvE,0EAA0E;IAC1E,GAAG,CAAC,EAAE,kBAAkB,GAAG,OAAO,CAAC;CACpC;AAED,QAAA,MAAM,WAAW,EAAE,cAGlB,CAAC;AAEF,+BAA+B;AAC/B,eAAe,WAAW,CAAC;AAO3B,wBAAgB,OAAO,CACrB,OAAO,CAAC,EAAE,cAAc,GAAG,IAAI,GAC9B,eAAe,GAAG,SAAS,CAM7B"}

node/node_modules/cheerio/lib/options.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatten = void 0;
+var tslib_1 = require("tslib");
+var defaultOpts = {
+    xml: false,
+    decodeEntities: true,
+};
+/** Cheerio default options. */
+exports.default = defaultOpts;
+var xmlModeDefault = {
+    _useHtmlParser2: true,
+    xmlMode: true,
+};
+function flatten(options) {
+    return (options === null || options === void 0 ? void 0 : options.xml)
+        ? typeof options.xml === 'boolean'
+            ? xmlModeDefault
+            : tslib_1.__assign(tslib_1.__assign({}, xmlModeDefault), options.xml)
+        : options !== null && options !== void 0 ? options : undefined;
+}
+exports.flatten = flatten;

node/node_modules/cheerio/lib/parse.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { Node, Document, NodeWithChildren } from 'domhandler';
+import type { InternalOptions } from './options';
+export default function parse(content: string | Document | Node | Node[] | Buffer, options: InternalOptions, isDocument: boolean): Document;
+/**
+ * Update the dom structure, for one changed layer.
+ *
+ * @param newChilds - The new children.
+ * @param parent - The new parent.
+ * @returns The parent node.
+ */
+export declare function update(newChilds: Node[] | Node, parent: NodeWithChildren | null): Node | null;
+//# sourceMappingURL=parse.d.ts.map

node/node_modules/cheerio/lib/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../src/parse.ts"],"names":[],"mappings":";AAGA,OAAO,EACL,IAAI,EACJ,QAAQ,EACR,gBAAgB,EAEjB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAKjD,MAAM,CAAC,OAAO,UAAU,KAAK,CAC3B,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI,GAAG,IAAI,EAAE,GAAG,MAAM,EACnD,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,OAAO,GAClB,QAAQ,CAyBV;AAED;;;;;;GAMG;AACH,wBAAgB,MAAM,CACpB,SAAS,EAAE,IAAI,EAAE,GAAG,IAAI,EACxB,MAAM,EAAE,gBAAgB,GAAG,IAAI,GAC9B,IAAI,GAAG,IAAI,CA+Bb"}

node/node_modules/cheerio/lib/parse.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.update = void 0;
+var htmlparser2_1 = require("htmlparser2");
+var htmlparser2_adapter_1 = require("./parsers/htmlparser2-adapter");
+var parse5_adapter_1 = require("./parsers/parse5-adapter");
+var domhandler_1 = require("domhandler");
+/*
+ * Parser
+ */
+function parse(content, options, isDocument) {
+    if (typeof Buffer !== 'undefined' && Buffer.isBuffer(content)) {
+        content = content.toString();
+    }
+    if (typeof content === 'string') {
+        return options.xmlMode || options._useHtmlParser2
+            ? htmlparser2_adapter_1.parse(content, options)
+            : parse5_adapter_1.parse(content, options, isDocument);
+    }
+    var doc = content;
+    if (!Array.isArray(doc) && domhandler_1.isDocument(doc)) {
+        // If `doc` is already a root, just return it
+        return doc;
+    }
+    // Add conent to new root element
+    var root = new domhandler_1.Document([]);
+    // Update the DOM using the root
+    update(doc, root);
+    return root;
+}
+exports.default = parse;
+/**
+ * Update the dom structure, for one changed layer.
+ *
+ * @param newChilds - The new children.
+ * @param parent - The new parent.
+ * @returns The parent node.
+ */
+function update(newChilds, parent) {
+    // Normalize
+    var arr = Array.isArray(newChilds) ? newChilds : [newChilds];
+    // Update parent
+    if (parent) {
+        parent.children = arr;
+    }
+    else {
+        parent = null;
+    }
+    // Update neighbors
+    for (var i = 0; i < arr.length; i++) {
+        var node = arr[i];
+        // Cleanly remove existing nodes from their previous structures.
+        if (node.parent && node.parent.children !== arr) {
+            htmlparser2_1.DomUtils.removeElement(node);
+        }
+        if (parent) {
+            node.prev = arr[i - 1] || null;
+            node.next = arr[i + 1] || null;
+        }
+        else {
+            node.prev = node.next = null;
+        }
+        node.parent = parent;
+    }
+    return parent;
+}
+exports.update = update;

node/node_modules/cheerio/lib/parsers/htmlparser2-adapter.d.ts

@@ -0,0 +1,3 @@
+export { parseDocument as parse } from 'htmlparser2';
+export { default as render } from 'dom-serializer';
+//# sourceMappingURL=htmlparser2-adapter.d.ts.map

node/node_modules/cheerio/lib/parsers/htmlparser2-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"htmlparser2-adapter.d.ts","sourceRoot":"","sources":["../../src/parsers/htmlparser2-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,IAAI,KAAK,EAAE,MAAM,aAAa,CAAC;AACrD,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,gBAAgB,CAAC"}

node/node_modules/cheerio/lib/parsers/htmlparser2-adapter.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = exports.parse = void 0;
+var htmlparser2_1 = require("htmlparser2");
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return htmlparser2_1.parseDocument; } });
+var dom_serializer_1 = require("dom-serializer");
+Object.defineProperty(exports, "render", { enumerable: true, get: function () { return __importDefault(dom_serializer_1).default; } });

node/node_modules/cheerio/lib/parsers/parse5-adapter.d.ts

@@ -0,0 +1,9 @@
+import { Node, Document } from 'domhandler';
+import type { InternalOptions } from '../options';
+interface Parse5Options extends InternalOptions {
+    context?: Node;
+}
+export declare function parse(content: string, options: Parse5Options, isDocument?: boolean): Document;
+export declare function render(dom: Node | ArrayLike<Node>): string;
+export {};
+//# sourceMappingURL=parse5-adapter.d.ts.map

node/node_modules/cheerio/lib/parsers/parse5-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse5-adapter.d.ts","sourceRoot":"","sources":["../../src/parsers/parse5-adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAc,MAAM,YAAY,CAAC;AAGxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD,UAAU,aAAc,SAAQ,eAAe;IAC7C,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB;AAED,wBAAgB,KAAK,CACnB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,aAAa,EACtB,UAAU,CAAC,EAAE,OAAO,GACnB,QAAQ,CAiBV;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,IAAI,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,MAAM,CAgB1D"}

node/node_modules/cheerio/lib/parsers/parse5-adapter.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = exports.parse = void 0;
+var tslib_1 = require("tslib");
+var domhandler_1 = require("domhandler");
+var parse5_1 = require("parse5");
+var parse5_htmlparser2_tree_adapter_1 = tslib_1.__importDefault(require("parse5-htmlparser2-tree-adapter"));
+function parse(content, options, isDocument) {
+    var opts = {
+        scriptingEnabled: typeof options.scriptingEnabled === 'boolean'
+            ? options.scriptingEnabled
+            : true,
+        treeAdapter: parse5_htmlparser2_tree_adapter_1.default,
+        sourceCodeLocationInfo: options.sourceCodeLocationInfo,
+    };
+    var context = options.context;
+    // @ts-expect-error The tree adapter unfortunately doesn't return the exact types.
+    return isDocument
+        ? parse5_1.parse(content, opts)
+        : // @ts-expect-error Same issue again.
+            parse5_1.parseFragment(context, content, opts);
+}
+exports.parse = parse;
+function render(dom) {
+    var _a;
+    /*
+     * `dom-serializer` passes over the special "root" node and renders the
+     * node's children in its place. To mimic this behavior with `parse5`, an
+     * equivalent operation must be applied to the input array.
+     */
+    var nodes = 'length' in dom ? dom : [dom];
+    for (var index = 0; index < nodes.length; index += 1) {
+        var node = nodes[index];
+        if (domhandler_1.isDocument(node)) {
+            (_a = Array.prototype.splice).call.apply(_a, tslib_1.__spreadArray([nodes, index, 1], node.children));
+        }
+    }
+    // @ts-expect-error Types don't align here either.
+    return parse5_1.serialize({ children: nodes }, { treeAdapter: parse5_htmlparser2_tree_adapter_1.default });
+}
+exports.render = render;

node/node_modules/cheerio/lib/static.d.ts

@@ -0,0 +1,88 @@
+import type { CheerioAPI, Cheerio } from '.';
+import { Node, Document } from 'domhandler';
+import { CheerioOptions } from './options';
+/**
+ * Renders the document.
+ *
+ * @param options - Options for the renderer.
+ * @returns The rendered document.
+ */
+export declare function html(this: CheerioAPI | void, options?: CheerioOptions): string;
+/**
+ * Renders the document.
+ *
+ * @param dom - Element to render.
+ * @param options - Options for the renderer.
+ * @returns The rendered document.
+ */
+export declare function html(this: CheerioAPI | void, dom?: string | ArrayLike<Node> | Node, options?: CheerioOptions): string;
+/**
+ * Render the document as XML.
+ *
+ * @param dom - Element to render.
+ * @returns THe rendered document.
+ */
+export declare function xml(this: CheerioAPI, dom?: string | ArrayLike<Node> | Node): string;
+/**
+ * Render the document as text.
+ *
+ * @param elements - Elements to render.
+ * @returns The rendered document.
+ */
+export declare function text(this: CheerioAPI | void, elements?: ArrayLike<Node>): string;
+/**
+ * Parses a string into an array of DOM nodes. The `context` argument has no
+ * meaning for Cheerio, but it is maintained for API compatibility with jQuery.
+ *
+ * @param data - Markup that will be parsed.
+ * @param context - Will be ignored. If it is a boolean it will be used as the
+ *   value of `keepScripts`.
+ * @param keepScripts - If false all scripts will be removed.
+ * @returns The parsed DOM.
+ * @alias Cheerio.parseHTML
+ * @see {@link https://api.jquery.com/jQuery.parseHTML/}
+ */
+export declare function parseHTML(this: CheerioAPI, data: string, context?: unknown | boolean, keepScripts?: boolean): Node[];
+export declare function parseHTML(this: CheerioAPI, data?: '' | null): null;
+/**
+ * Sometimes you need to work with the top-level root element. To query it, you
+ * can use `$.root()`.
+ *
+ * @example
+ *
+ * ```js
+ * $.root().append('<ul id="vegetables"></ul>').html();
+ * //=> <ul id="fruits">...</ul><ul id="vegetables"></ul>
+ * ```
+ *
+ * @returns Cheerio instance wrapping the root node.
+ * @alias Cheerio.root
+ */
+export declare function root(this: CheerioAPI): Cheerio<Document>;
+/**
+ * Checks to see if the `contained` DOM element is a descendant of the
+ * `container` DOM element.
+ *
+ * @param container - Potential parent node.
+ * @param contained - Potential child node.
+ * @returns Indicates if the nodes contain one another.
+ * @alias Cheerio.contains
+ * @see {@link https://api.jquery.com/jQuery.contains/}
+ */
+export declare function contains(container: Node, contained: Node): boolean;
+interface WritableArrayLike<T> extends ArrayLike<T> {
+    length: number;
+    [n: number]: T;
+}
+/**
+ * $.merge().
+ *
+ * @param arr1 - First array.
+ * @param arr2 - Second array.
+ * @returns `arr1`, with elements of `arr2` inserted.
+ * @alias Cheerio.merge
+ * @see {@link https://api.jquery.com/jQuery.merge/}
+ */
+export declare function merge<T>(arr1: WritableArrayLike<T>, arr2: ArrayLike<T>): ArrayLike<T> | undefined;
+export {};
+//# sourceMappingURL=static.d.ts.map

node/node_modules/cheerio/lib/static.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static.d.ts","sourceRoot":"","sources":["../src/static.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAEL,cAAc,EAGf,MAAM,WAAW,CAAC;AAiDnB;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC;AAChF;;;;;;GAMG;AACH,wBAAgB,IAAI,CAClB,IAAI,EAAE,UAAU,GAAG,IAAI,EACvB,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,EACrC,OAAO,CAAC,EAAE,cAAc,GACvB,MAAM,CAAC;AAkCV;;;;;GAKG;AACH,wBAAgB,GAAG,CACjB,IAAI,EAAE,UAAU,EAChB,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,GAAG,IAAI,GACpC,MAAM,CAIR;AAED;;;;;GAKG;AACH,wBAAgB,IAAI,CAClB,IAAI,EAAE,UAAU,GAAG,IAAI,EACvB,QAAQ,CAAC,EAAE,SAAS,CAAC,IAAI,CAAC,GACzB,MAAM,CAmBR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,OAAO,GAAG,OAAO,EAC3B,WAAW,CAAC,EAAE,OAAO,GACpB,IAAI,EAAE,CAAC;AACV,wBAAgB,SAAS,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI,CAAC;AA8BpE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,QAAQ,CAAC,CAExD;AAED;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,GAAG,OAAO,CAmBlE;AAED,UAAU,iBAAiB,CAAC,CAAC,CAAE,SAAQ,SAAS,CAAC,CAAC,CAAC;IACjD,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC;CAChB;AAED;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,CAAC,EACrB,IAAI,EAAE,iBAAiB,CAAC,CAAC,CAAC,EAC1B,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,GACjB,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAY1B"}

node/node_modules/cheerio/lib/static.js

@@ -0,0 +1,207 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = exports.contains = exports.root = exports.parseHTML = exports.text = exports.xml = exports.html = void 0;
+var tslib_1 = require("tslib");
+var options_1 = tslib_1.__importStar(require("./options"));
+var cheerio_select_1 = require("cheerio-select");
+var htmlparser2_1 = require("htmlparser2");
+var parse5_adapter_1 = require("./parsers/parse5-adapter");
+var htmlparser2_adapter_1 = require("./parsers/htmlparser2-adapter");
+/**
+ * Helper function to render a DOM.
+ *
+ * @param that - Cheerio instance to render.
+ * @param dom - The DOM to render. Defaults to `that`'s root.
+ * @param options - Options for rendering.
+ * @returns The rendered document.
+ */
+function render(that, dom, options) {
+    var _a;
+    var toRender = dom
+        ? typeof dom === 'string'
+            ? cheerio_select_1.select(dom, (_a = that === null || that === void 0 ? void 0 : that._root) !== null && _a !== void 0 ? _a : [], options)
+            : dom
+        : that === null || that === void 0 ? void 0 : that._root.children;
+    if (!toRender)
+        return '';
+    return options.xmlMode || options._useHtmlParser2
+        ? htmlparser2_adapter_1.render(toRender, options)
+        : parse5_adapter_1.render(toRender);
+}
+/**
+ * Checks if a passed object is an options object.
+ *
+ * @param dom - Object to check if it is an options object.
+ * @returns Whether the object is an options object.
+ */
+function isOptions(dom) {
+    return (typeof dom === 'object' &&
+        dom != null &&
+        !('length' in dom) &&
+        !('type' in dom));
+}
+function html(dom, options) {
+    /*
+     * Be flexible about parameters, sometimes we call html(),
+     * with options as only parameter
+     * check dom argument for dom element specific properties
+     * assume there is no 'length' or 'type' properties in the options object
+     */
+    if (!options && isOptions(dom)) {
+        options = dom;
+        dom = undefined;
+    }
+    /*
+     * Sometimes `$.html()` is used without preloading html,
+     * so fallback non-existing options to the default ones.
+     */
+    var opts = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, options_1.default), (this ? this._options : {})), options_1.flatten(options !== null && options !== void 0 ? options : {}));
+    return render(this || undefined, dom, opts);
+}
+exports.html = html;
+/**
+ * Render the document as XML.
+ *
+ * @param dom - Element to render.
+ * @returns THe rendered document.
+ */
+function xml(dom) {
+    var options = tslib_1.__assign(tslib_1.__assign({}, this._options), { xmlMode: true });
+    return render(this, dom, options);
+}
+exports.xml = xml;
+/**
+ * Render the document as text.
+ *
+ * @param elements - Elements to render.
+ * @returns The rendered document.
+ */
+function text(elements) {
+    var elems = elements ? elements : this ? this.root() : [];
+    var ret = '';
+    for (var i = 0; i < elems.length; i++) {
+        var elem = elems[i];
+        if (htmlparser2_1.DomUtils.isText(elem))
+            ret += elem.data;
+        else if (htmlparser2_1.DomUtils.hasChildren(elem) &&
+            elem.type !== htmlparser2_1.ElementType.Comment &&
+            elem.type !== htmlparser2_1.ElementType.Script &&
+            elem.type !== htmlparser2_1.ElementType.Style) {
+            ret += text(elem.children);
+        }
+    }
+    return ret;
+}
+exports.text = text;
+function parseHTML(data, context, keepScripts) {
+    if (keepScripts === void 0) { keepScripts = typeof context === 'boolean' ? context : false; }
+    if (!data || typeof data !== 'string') {
+        return null;
+    }
+    if (typeof context === 'boolean') {
+        keepScripts = context;
+    }
+    var parsed = this.load(data, options_1.default, false);
+    if (!keepScripts) {
+        parsed('script').remove();
+    }
+    /*
+     * The `children` array is used by Cheerio internally to group elements that
+     * share the same parents. When nodes created through `parseHTML` are
+     * inserted into previously-existing DOM structures, they will be removed
+     * from the `children` array. The results of `parseHTML` should remain
+     * constant across these operations, so a shallow copy should be returned.
+     */
+    return parsed.root()[0].children.slice();
+}
+exports.parseHTML = parseHTML;
+/**
+ * Sometimes you need to work with the top-level root element. To query it, you
+ * can use `$.root()`.
+ *
+ * @example
+ *
+ * ```js
+ * $.root().append('<ul id="vegetables"></ul>').html();
+ * //=> <ul id="fruits">...</ul><ul id="vegetables"></ul>
+ * ```
+ *
+ * @returns Cheerio instance wrapping the root node.
+ * @alias Cheerio.root
+ */
+function root() {
+    return this(this._root);
+}
+exports.root = root;
+/**
+ * Checks to see if the `contained` DOM element is a descendant of the
+ * `container` DOM element.
+ *
+ * @param container - Potential parent node.
+ * @param contained - Potential child node.
+ * @returns Indicates if the nodes contain one another.
+ * @alias Cheerio.contains
+ * @see {@link https://api.jquery.com/jQuery.contains/}
+ */
+function contains(container, contained) {
+    // According to the jQuery API, an element does not "contain" itself
+    if (contained === container) {
+        return false;
+    }
+    /*
+     * Step up the descendants, stopping when the root element is reached
+     * (signaled by `.parent` returning a reference to the same object)
+     */
+    var next = contained;
+    while (next && next !== next.parent) {
+        next = next.parent;
+        if (next === container) {
+            return true;
+        }
+    }
+    return false;
+}
+exports.contains = contains;
+/**
+ * $.merge().
+ *
+ * @param arr1 - First array.
+ * @param arr2 - Second array.
+ * @returns `arr1`, with elements of `arr2` inserted.
+ * @alias Cheerio.merge
+ * @see {@link https://api.jquery.com/jQuery.merge/}
+ */
+function merge(arr1, arr2) {
+    if (!isArrayLike(arr1) || !isArrayLike(arr2)) {
+        return;
+    }
+    var newLength = arr1.length;
+    var len = +arr2.length;
+    for (var i = 0; i < len; i++) {
+        arr1[newLength++] = arr2[i];
+    }
+    arr1.length = newLength;
+    return arr1;
+}
+exports.merge = merge;
+/**
+ * @param item - Item to check.
+ * @returns Indicates if the item is array-like.
+ */
+function isArrayLike(item) {
+    if (Array.isArray(item)) {
+        return true;
+    }
+    if (typeof item !== 'object' ||
+        !Object.prototype.hasOwnProperty.call(item, 'length') ||
+        typeof item.length !== 'number' ||
+        item.length < 0) {
+        return false;
+    }
+    for (var i = 0; i < item.length; i++) {
+        if (!(i in item)) {
+            return false;
+        }
+    }
+    return true;
+}

node/node_modules/cheerio/lib/types.d.ts

@@ -0,0 +1,20 @@
+declare type LowercaseLetters = 'a' | 'b' | 'c' | 'd' | 'e' | 'f' | 'g' | 'h' | 'i' | 'j' | 'k' | 'l' | 'm' | 'n' | 'o' | 'p' | 'q' | 'r' | 's' | 't' | 'u' | 'v' | 'w' | 'x' | 'y' | 'z';
+declare type AlphaNumeric = LowercaseLetters | Uppercase<LowercaseLetters> | `${number}`;
+declare type SelectorSpecial = '.' | '#' | ':' | '|' | '>' | '+' | '~' | '[';
+/**
+ * Type for identifying selectors. Allows us to "upgrade" queries using
+ * selectors to return `Element`s.
+ */
+export declare type SelectorType = `${SelectorSpecial}${AlphaNumeric}${string}` | `${AlphaNumeric}${string}`;
+import type { Cheerio } from './cheerio';
+import type { Node } from 'domhandler';
+/** Elements that can be passed to manipulation methods. */
+export declare type BasicAcceptedElems<T extends Node> = Cheerio<T> | T[] | T | string;
+/** Elements that can be passed to manipulation methods, including functions. */
+export declare type AcceptedElems<T extends Node> = BasicAcceptedElems<T> | ((this: T, i: number, el: T) => BasicAcceptedElems<T>);
+/** Function signature, for traversal methods. */
+export declare type FilterFunction<T> = (this: T, i: number, el: T) => boolean;
+/** Supported filter types, for traversal methods. */
+export declare type AcceptedFilters<T> = string | FilterFunction<T> | T | Cheerio<T>;
+export {};
+//# sourceMappingURL=types.d.ts.map

node/node_modules/cheerio/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,aAAK,gBAAgB,GACjB,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,GACH,GAAG,CAAC;AAER,aAAK,YAAY,GACb,gBAAgB,GAChB,SAAS,CAAC,gBAAgB,CAAC,GAC3B,GAAG,MAAM,EAAE,CAAC;AAEhB,aAAK,eAAe,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AACrE;;;GAGG;AACH,oBAAY,YAAY,GACpB,GAAG,eAAe,GAAG,YAAY,GAAG,MAAM,EAAE,GAC5C,GAAG,YAAY,GAAG,MAAM,EAAE,CAAC;AAE/B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,2DAA2D;AAC3D,oBAAY,kBAAkB,CAAC,CAAC,SAAS,IAAI,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC;AAC/E,gFAAgF;AAChF,oBAAY,aAAa,CAAC,CAAC,SAAS,IAAI,IACpC,kBAAkB,CAAC,CAAC,CAAC,GACrB,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,KAAK,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3D,iDAAiD;AACjD,oBAAY,cAAc,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,KAAK,OAAO,CAAC;AACvE,qDAAqD;AACrD,oBAAY,eAAe,CAAC,CAAC,IAAI,MAAM,GAAG,cAAc,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC"}

node/node_modules/cheerio/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node/node_modules/cheerio/lib/utils.d.ts

@@ -0,0 +1,73 @@
+import { DomUtils } from 'htmlparser2';
+import { Node } from 'domhandler';
+import type { Cheerio } from './cheerio';
+/**
+ * Check if the DOM element is a tag.
+ *
+ * `isTag(type)` includes `<script>` and `<style>` tags.
+ *
+ * @private
+ * @category Utils
+ * @param type - DOM node to check.
+ * @returns Whether the node is a tag.
+ */
+export declare const isTag: typeof DomUtils.isTag;
+/**
+ * Checks if an object is a Cheerio instance.
+ *
+ * @category Utils
+ * @param maybeCheerio - The object to check.
+ * @returns Whether the object is a Cheerio instance.
+ */
+export declare function isCheerio<T>(maybeCheerio: any): maybeCheerio is Cheerio<T>;
+/**
+ * Convert a string to camel case notation.
+ *
+ * @private
+ * @category Utils
+ * @param str - String to be converted.
+ * @returns String in camel case notation.
+ */
+export declare function camelCase(str: string): string;
+/**
+ * Convert a string from camel case to "CSS case", where word boundaries are
+ * described by hyphens ("-") and all characters are lower-case.
+ *
+ * @private
+ * @category Utils
+ * @param str - String to be converted.
+ * @returns String in "CSS case".
+ */
+export declare function cssCase(str: string): string;
+/**
+ * Iterate over each DOM element without creating intermediary Cheerio instances.
+ *
+ * This is indented for use internally to avoid otherwise unnecessary memory
+ * pressure introduced by _make.
+ *
+ * @category Utils
+ * @param array - Array to iterate over.
+ * @param fn - Function to call.
+ * @returns The original instance.
+ */
+export declare function domEach<T extends Node, Arr extends ArrayLike<T> = Cheerio<T>>(array: Arr, fn: (elem: T, index: number) => void): Arr;
+/**
+ * Create a deep copy of the given DOM structure. Sets the parents of the copies
+ * of the passed nodes to `null`.
+ *
+ * @private
+ * @category Utils
+ * @param dom - The htmlparser2-compliant DOM structure.
+ * @returns - The cloned DOM.
+ */
+export declare function cloneDom<T extends Node>(dom: T | T[]): T[];
+/**
+ * Check if string is HTML.
+ *
+ * @private
+ * @category Utils
+ * @param str - String to check.
+ * @returns Indicates if `str` is HTML.
+ */
+export declare function isHtml(str: string): boolean;
+//# sourceMappingURL=utils.d.ts.map

node/node_modules/cheerio/lib/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,IAAI,EAAuB,MAAM,YAAY,CAAC;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;;;;;;GASG;AACH,eAAO,MAAQ,KAAK,uBAAa,CAAC;AAElC;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,YAAY,EAAE,GAAG,GAAG,YAAY,IAAI,OAAO,CAAC,CAAC,CAAC,CAE1E;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE7C;AAED;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,IAAI,EAAE,GAAG,SAAS,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC3E,KAAK,EAAE,GAAG,EACV,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GACnC,GAAG,CAIL;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,IAAI,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,EAAE,CAa1D;AAUD;;;;;;;GAOG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAG3C"}

node/node_modules/cheerio/lib/utils.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHtml = exports.cloneDom = exports.domEach = exports.cssCase = exports.camelCase = exports.isCheerio = exports.isTag = void 0;
+var htmlparser2_1 = require("htmlparser2");
+var domhandler_1 = require("domhandler");
+/**
+ * Check if the DOM element is a tag.
+ *
+ * `isTag(type)` includes `<script>` and `<style>` tags.
+ *
+ * @private
+ * @category Utils
+ * @param type - DOM node to check.
+ * @returns Whether the node is a tag.
+ */
+exports.isTag = htmlparser2_1.DomUtils.isTag;
+/**
+ * Checks if an object is a Cheerio instance.
+ *
+ * @category Utils
+ * @param maybeCheerio - The object to check.
+ * @returns Whether the object is a Cheerio instance.
+ */
+function isCheerio(maybeCheerio) {
+    return maybeCheerio.cheerio != null;
+}
+exports.isCheerio = isCheerio;
+/**
+ * Convert a string to camel case notation.
+ *
+ * @private
+ * @category Utils
+ * @param str - String to be converted.
+ * @returns String in camel case notation.
+ */
+function camelCase(str) {
+    return str.replace(/[_.-](\w|$)/g, function (_, x) { return x.toUpperCase(); });
+}
+exports.camelCase = camelCase;
+/**
+ * Convert a string from camel case to "CSS case", where word boundaries are
+ * described by hyphens ("-") and all characters are lower-case.
+ *
+ * @private
+ * @category Utils
+ * @param str - String to be converted.
+ * @returns String in "CSS case".
+ */
+function cssCase(str) {
+    return str.replace(/[A-Z]/g, '-$&').toLowerCase();
+}
+exports.cssCase = cssCase;
+/**
+ * Iterate over each DOM element without creating intermediary Cheerio instances.
+ *
+ * This is indented for use internally to avoid otherwise unnecessary memory
+ * pressure introduced by _make.
+ *
+ * @category Utils
+ * @param array - Array to iterate over.
+ * @param fn - Function to call.
+ * @returns The original instance.
+ */
+function domEach(array, fn) {
+    var len = array.length;
+    for (var i = 0; i < len; i++)
+        fn(array[i], i);
+    return array;
+}
+exports.domEach = domEach;
+/**
+ * Create a deep copy of the given DOM structure. Sets the parents of the copies
+ * of the passed nodes to `null`.
+ *
+ * @private
+ * @category Utils
+ * @param dom - The htmlparser2-compliant DOM structure.
+ * @returns - The cloned DOM.
+ */
+function cloneDom(dom) {
+    var clone = 'length' in dom
+        ? Array.prototype.map.call(dom, function (el) { return domhandler_1.cloneNode(el, true); })
+        : [domhandler_1.cloneNode(dom, true)];
+    // Add a root node around the cloned nodes
+    var root = new domhandler_1.Document(clone);
+    clone.forEach(function (node) {
+        node.parent = root;
+    });
+    return clone;
+}
+exports.cloneDom = cloneDom;
+/**
+ * A simple way to check for HTML strings. Tests for a `<` within a string,
+ * immediate followed by a letter and eventually followed by a `>`.
+ *
+ * @private
+ */
+var quickExpr = /<[a-zA-Z][^]*>/;
+/**
+ * Check if string is HTML.
+ *
+ * @private
+ * @category Utils
+ * @param str - String to check.
+ * @returns Indicates if `str` is HTML.
+ */
+function isHtml(str) {
+    // Run the regex
+    return quickExpr.test(str);
+}
+exports.isHtml = isHtml;

node/node_modules/cheerio/package.json

@@ -0,0 +1,148 @@
+{
+  "_args": [
+    [
+      "cheerio@1.0.0-rc.10",
+      "F:\\cocorobo\\CocoRoboDesktop\\node"
+    ]
+  ],
+  "_from": "cheerio@1.0.0-rc.10",
+  "_id": "cheerio@1.0.0-rc.10",
+  "_inBundle": false,
+  "_integrity": "sha512-g0J0q/O6mW8z5zxQ3A8E8J1hUgp4SMOvEoW/x84OwyHKe/Zccz83PVT4y5Crcr530FV6NgmKI1qvGTKVl9XXVw==",
+  "_location": "/cheerio",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "cheerio@1.0.0-rc.10",
+    "name": "cheerio",
+    "escapedName": "cheerio",
+    "rawSpec": "1.0.0-rc.10",
+    "saveSpec": null,
+    "fetchSpec": "1.0.0-rc.10"
+  },
+  "_requiredBy": [
+    "/"
+  ],
+  "_resolved": "https://registry.npmmirror.com/cheerio/-/cheerio-1.0.0-rc.10.tgz",
+  "_spec": "1.0.0-rc.10",
+  "_where": "F:\\cocorobo\\CocoRoboDesktop\\node",
+  "author": {
+    "name": "Matt Mueller",
+    "email": "mattmuelle@gmail.com"
+  },
+  "bugs": {
+    "url": "https://github.com/cheeriojs/cheerio/issues"
+  },
+  "dependencies": {
+    "cheerio-select": "^1.5.0",
+    "dom-serializer": "^1.3.2",
+    "domhandler": "^4.2.0",
+    "htmlparser2": "^6.1.0",
+    "parse5": "^6.0.1",
+    "parse5-htmlparser2-tree-adapter": "^6.0.1",
+    "tslib": "^2.2.0"
+  },
+  "description": "Tiny, fast, and elegant implementation of core jQuery designed specifically for the server",
+  "devDependencies": {
+    "@octokit/graphql": "^4.6.2",
+    "@types/benchmark": "^2.1.0",
+    "@types/jest": "^26.0.23",
+    "@types/jsdom": "^16.2.10",
+    "@types/node": "^15.12.1",
+    "@types/node-fetch": "^2.5.10",
+    "@types/parse5": "^6.0.0",
+    "@types/parse5-htmlparser2-tree-adapter": "^6.0.0",
+    "@typescript-eslint/eslint-plugin": "^4.26.0",
+    "@typescript-eslint/parser": "^4.26.0",
+    "benchmark": "^2.1.4",
+    "eslint": "^7.28.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-jest": "^24.3.6",
+    "eslint-plugin-jsdoc": "^35.1.3",
+    "eslint-plugin-node": "^11.1.0",
+    "husky": "^4.3.8",
+    "jest": "^27.0.4",
+    "jquery": "^3.6.0",
+    "jsdom": "^16.6.0",
+    "lint-staged": "^11.0.0",
+    "node-fetch": "^2.6.1",
+    "prettier": "^2.3.1",
+    "prettier-plugin-jsdoc": "0.3.22",
+    "ts-jest": "^27.0.3",
+    "ts-node": "^10.0.0",
+    "typedoc": "^0.20.36",
+    "typescript": "^4.2.4"
+  },
+  "engines": {
+    "node": ">= 6"
+  },
+  "files": [
+    "lib"
+  ],
+  "funding": "https://github.com/cheeriojs/cheerio?sponsor=1",
+  "homepage": "https://cheerio.js.org/",
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "testPathIgnorePatterns": [
+      "/__fixtures__/"
+    ]
+  },
+  "keywords": [
+    "htmlparser",
+    "jquery",
+    "selector",
+    "scraper",
+    "parser",
+    "html"
+  ],
+  "license": "MIT",
+  "lint-staged": {
+    "*.js": [
+      "prettier --write",
+      "npm run test:lint -- --fix"
+    ],
+    "*.{json,md,ts,yml}": [
+      "prettier --write"
+    ]
+  },
+  "main": "lib/index.js",
+  "maintainers": [
+    {
+      "name": "Felix Boehm",
+      "email": "me@feedic.com"
+    }
+  ],
+  "name": "cheerio",
+  "prettier": {
+    "singleQuote": true,
+    "tabWidth": 2,
+    "tsdoc": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/cheeriojs/cheerio.git"
+  },
+  "scripts": {
+    "bench": "npm run benchmark",
+    "benchmark": "ts-node benchmark/benchmark.ts --regex \"^(?!.*highmem)\"",
+    "build": "tsc",
+    "build:docs": "typedoc --hideGenerator src/index.ts",
+    "format": "npm run format:es && npm run format:prettier",
+    "format:es": "npm run lint:es -- --fix",
+    "format:prettier": "npm run format:prettier:raw -- --write",
+    "format:prettier:raw": "prettier \"**/*.{js,ts,md,json,yml}\" --ignore-path .gitignore",
+    "lint": "npm run lint:es && npm run lint:prettier",
+    "lint:es": "eslint --ignore-path .gitignore .",
+    "lint:prettier": "npm run format:prettier:raw -- --check",
+    "pre-commit": "lint-staged",
+    "prepublishOnly": "npm run build",
+    "test": "npm run lint && npm run test:jest",
+    "test:jest": "jest",
+    "test:jest:cov": "npm run test:jest -- --coverage",
+    "update-sponsors": "ts-node scripts/fetch-sponsors.ts"
+  },
+  "types": "lib/index.d.ts",
+  "version": "1.0.0-rc.10"
+}

node/node_modules/core-util-is/LICENSE

@@ -0,0 +1,19 @@
+Copyright Node.js contributors. All rights reserved.
+
+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.

node/node_modules/core-util-is/README.md

@@ -0,0 +1,3 @@
+# core-util-is
+
+The `util.is*` functions introduced in Node v0.12.

node/node_modules/core-util-is/lib/util.js

@@ -0,0 +1,107 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// 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.
+
+// NOTE: These type checking functions intentionally don't use `instanceof`
+// because it is fragile and can be easily faked with `Object.create()`.
+
+function isArray(arg) {
+  if (Array.isArray) {
+    return Array.isArray(arg);
+  }
+  return objectToString(arg) === '[object Array]';
+}
+exports.isArray = isArray;
+
+function isBoolean(arg) {
+  return typeof arg === 'boolean';
+}
+exports.isBoolean = isBoolean;
+
+function isNull(arg) {
+  return arg === null;
+}
+exports.isNull = isNull;
+
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+exports.isNullOrUndefined = isNullOrUndefined;
+
+function isNumber(arg) {
+  return typeof arg === 'number';
+}
+exports.isNumber = isNumber;
+
+function isString(arg) {
+  return typeof arg === 'string';
+}
+exports.isString = isString;
+
+function isSymbol(arg) {
+  return typeof arg === 'symbol';
+}
+exports.isSymbol = isSymbol;
+
+function isUndefined(arg) {
+  return arg === void 0;
+}
+exports.isUndefined = isUndefined;
+
+function isRegExp(re) {
+  return objectToString(re) === '[object RegExp]';
+}
+exports.isRegExp = isRegExp;
+
+function isObject(arg) {
+  return typeof arg === 'object' && arg !== null;
+}
+exports.isObject = isObject;
+
+function isDate(d) {
+  return objectToString(d) === '[object Date]';
+}
+exports.isDate = isDate;
+
+function isError(e) {
+  return (objectToString(e) === '[object Error]' || e instanceof Error);
+}
+exports.isError = isError;
+
+function isFunction(arg) {
+  return typeof arg === 'function';
+}
+exports.isFunction = isFunction;
+
+function isPrimitive(arg) {
+  return arg === null ||
+         typeof arg === 'boolean' ||
+         typeof arg === 'number' ||
+         typeof arg === 'string' ||
+         typeof arg === 'symbol' ||  // ES6 symbol
+         typeof arg === 'undefined';
+}
+exports.isPrimitive = isPrimitive;
+
+exports.isBuffer = require('buffer').Buffer.isBuffer;
+
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}

node/node_modules/core-util-is/package.json

@@ -0,0 +1,71 @@
+{
+  "_args": [
+    [
+      "core-util-is@1.0.3",
+      "F:\\cocorobo\\CocoRoboDesktop\\node"
+    ]
+  ],
+  "_from": "core-util-is@1.0.3",
+  "_id": "core-util-is@1.0.3",
+  "_inBundle": false,
+  "_integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+  "_location": "/core-util-is",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "core-util-is@1.0.3",
+    "name": "core-util-is",
+    "escapedName": "core-util-is",
+    "rawSpec": "1.0.3",
+    "saveSpec": null,
+    "fetchSpec": "1.0.3"
+  },
+  "_requiredBy": [
+    "/readable-stream"
+  ],
+  "_resolved": "https://registry.npmmirror.com/core-util-is/-/core-util-is-1.0.3.tgz",
+  "_spec": "1.0.3",
+  "_where": "F:\\cocorobo\\CocoRoboDesktop\\node",
+  "author": {
+    "name": "Isaac Z. Schlueter",
+    "email": "i@izs.me",
+    "url": "http://blog.izs.me/"
+  },
+  "bugs": {
+    "url": "https://github.com/isaacs/core-util-is/issues"
+  },
+  "description": "The `util.is*` functions introduced in Node v0.12.",
+  "devDependencies": {
+    "tap": "^15.0.9"
+  },
+  "files": [
+    "lib"
+  ],
+  "homepage": "https://github.com/isaacs/core-util-is#readme",
+  "keywords": [
+    "util",
+    "isBuffer",
+    "isArray",
+    "isNumber",
+    "isString",
+    "isRegExp",
+    "isThis",
+    "isThat",
+    "polyfill"
+  ],
+  "license": "MIT",
+  "main": "lib/util.js",
+  "name": "core-util-is",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/isaacs/core-util-is.git"
+  },
+  "scripts": {
+    "postversion": "npm publish",
+    "prepublishOnly": "git push origin --follow-tags",
+    "preversion": "npm test",
+    "test": "tap test.js"
+  },
+  "version": "1.0.3"
+}

node/node_modules/css-select/LICENSE

@@ -0,0 +1,11 @@
+Copyright (c) Felix Böhm
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

node/node_modules/css-select/README.md

@@ -0,0 +1,255 @@
+# css-select [![NPM version](http://img.shields.io/npm/v/css-select.svg)](https://npmjs.org/package/css-select) [![Build Status](https://travis-ci.com/fb55/css-select.svg?branch=master)](http://travis-ci.com/fb55/css-select) [![Downloads](https://img.shields.io/npm/dm/css-select.svg)](https://npmjs.org/package/css-select) [![Coverage](https://coveralls.io/repos/fb55/css-select/badge.svg?branch=master)](https://coveralls.io/r/fb55/css-select)
+
+A CSS selector compiler and engine
+
+## What?
+
+As a **compiler**, css-select turns CSS selectors into functions that tests if
+elements match them.
+
+As an **engine**, css-select looks through a DOM tree, searching for elements.
+Elements are tested "from the top", similar to how browsers execute CSS
+selectors.
+
+In its default configuration, css-select queries the DOM structure of the
+[`domhandler`](https://github.com/fb55/domhandler) module (also known as
+htmlparser2 DOM). To query alternative DOM structures, see [`Options`](#options)
+below.
+
+**Features:**
+
+-   🔬 Full implementation of CSS3 selectors, as well as most CSS4 selectors
+-   🧪 Partial implementation of jQuery/Sizzle extensions (see
+    [cheerio-select](https://github.com/cheeriojs/cheerio-select) for the
+    remaining selectors)
+-   🧑‍🔬 High test coverage, including the full test suites from Sizzle, Qwery and
+    NWMatcher.
+-   🥼 Reliably great performance
+
+## Why?
+
+Most CSS engines written in JavaScript execute selectors left-to-right. That
+means thet execute every component of the selector in order, from left to right
+_(duh)_. As an example: For the selector `a b`, these engines will first query
+for `a` elements, then search these for `b` elements. (That's the approach of
+eg. [`Sizzle`](https://github.com/jquery/sizzle),
+[`nwmatcher`](https://github.com/dperini/nwmatcher/) and
+[`qwery`](https://github.com/ded/qwery).)
+
+While this works, it has some downsides: Children of `a`s will be checked
+multiple times; first, to check if they are also `a`s, then, for every superior
+`a` once, if they are `b`s. Using
+[Big O notation](http://en.wikipedia.org/wiki/Big_O_notation), that would be
+`O(n^(k+1))`, where `k` is the number of descendant selectors (that's the space
+in the example above).
+
+The far more efficient approach is to first look for `b` elements, then check if
+they have superior `a` elements: Using big O notation again, that would be
+`O(n)`. That's called right-to-left execution.
+
+And that's what css-select does – and why it's quite performant.
+
+## How does it work?
+
+By building a stack of functions.
+
+_Wait, what?_
+
+Okay, so let's suppose we want to compile the selector `a b`, for right-to-left
+execution. We start by _parsing_ the selector. This turns the selector into an
+array of the building blocks. That's what the
+[`css-what`](https://github.com/fb55/css-what) module is for, if you want to
+have a look.
+
+Anyway, after parsing, we end up with an array like this one:
+
+```js
+[
+    { type: "tag", name: "a" },
+    { type: "descendant" },
+    { type: "tag", name: "b" },
+];
+```
+
+(Actually, this array is wrapped in another array, but that's another story,
+involving commas in selectors.)
+
+Now that we know the meaning of every part of the selector, we can compile it.
+That is where things become interesting.
+
+The basic idea is to turn every part of the selector into a function, which
+takes an element as its only argument. The function checks whether a passed
+element matches its part of the selector: If it does, the element is passed to
+the next function representing the next part of the selector. That function does
+the same. If an element is accepted by all parts of the selector, it _matches_
+the selector and double rainbow ALL THE WAY.
+
+As said before, we want to do right-to-left execution with all the big O
+improvements. That means elements are passed from the rightmost part of the
+selector (`b` in our example) to the leftmost (~~which would be `c`~~ of course
+`a`).
+
+For traversals, such as the _descendant_ operating the space between `a` and
+`b`, we walk up the DOM tree, starting from the element passed as argument.
+
+_//TODO: More in-depth description. Implementation details. Build a spaceship._
+
+## API
+
+```js
+const CSSselect = require("css-select");
+```
+
+**Note:** css-select throws errors when invalid selectors are passed to it.This
+is done to aid with writing css selectors, but can be unexpected when processing
+arbitrary strings.
+
+#### `CSSselect.selectAll(query, elems, options)`
+
+Queries `elems`, returns an array containing all matches.
+
+-   `query` can be either a CSS selector or a function.
+-   `elems` can be either an array of elements, or a single element. If it is an
+    element, its children will be queried.
+-   `options` is described below.
+
+Aliases: `default` export, `CSSselect.iterate(query, elems)`.
+
+#### `CSSselect.compile(query, options)`
+
+Compiles the query, returns a function.
+
+#### `CSSselect.is(elem, query, options)`
+
+Tests whether or not an element is matched by `query`. `query` can be either a
+CSS selector or a function.
+
+#### `CSSselect.selectOne(query, elems, options)`
+
+Arguments are the same as for `CSSselect.selectAll(query, elems)`. Only returns
+the first match, or `null` if there was no match.
+
+### Options
+
+All options are optional.
+
+-   `xmlMode`: When enabled, tag names will be case-sensitive. Default: `false`.
+-   `rootFunc`: The last function in the stack, will be called with the last
+    element that's looked at.
+-   `adapter`: The adapter to use when interacting with the backing DOM
+    structure. By default it uses the `domutils` module.
+-   `context`: The context of the current query. Used to limit the scope of
+    searches. Can be matched directly using the `:scope` pseudo-selector.
+-   `cacheResults`: Allow css-select to cache results for some selectors,
+    sometimes greatly improving querying performance. Disable this if your
+    document can change in between queries with the same compiled selector.
+    Default: `true`.
+
+#### Custom Adapters
+
+A custom adapter must match the interface described
+[here](https://github.com/fb55/css-select/blob/1aa44bdd64aaf2ebdfd7f338e2e76bed36521957/src/types.ts#L6-L96).
+
+You may want to have a look at [`domutils`](https://github.com/fb55/domutils) to
+see the default implementation, or at
+[`css-select-browser-adapter`](https://github.com/nrkn/css-select-browser-adapter/blob/master/index.js)
+for an implementation backed by the DOM.
+
+## Supported selectors
+
+_As defined by CSS 4 and / or jQuery._
+
+-   [Selector lists](https://developer.mozilla.org/en-US/docs/Web/CSS/Selector_list)
+    (`,`)
+-   [Universal](https://developer.mozilla.org/en-US/docs/Web/CSS/Universal_selectors)
+    (`*`)
+-   [Type](https://developer.mozilla.org/en-US/docs/Web/CSS/Type_selectors)
+    (`<tagname>`)
+-   [Descendant](https://developer.mozilla.org/en-US/docs/Web/CSS/Descendant_combinator)
+    (` `)
+-   [Child](https://developer.mozilla.org/en-US/docs/Web/CSS/Child_combinator)
+    (`>`)
+-   Parent (`<`)
+-   [Adjacent sibling](https://developer.mozilla.org/en-US/docs/Web/CSS/Adjacent_sibling_combinator)
+    (`+`)
+-   [General sibling](https://developer.mozilla.org/en-US/docs/Web/CSS/General_sibling_combinator)
+    (`~`)
+-   [Attribute](https://developer.mozilla.org/en-US/docs/Web/CSS/Attribute_selectors)
+    (`[attr=foo]`), with supported comparisons:
+    -   `[attr]` (existential)
+    -   `=`
+    -   `~=`
+    -   `|=`
+    -   `*=`
+    -   `^=`
+    -   `$=`
+    -   `!=`
+    -   `i` and `s` can be added after the comparison to make the comparison
+        case-insensitive or case-sensitive (eg. `[attr=foo i]`). If neither is
+        supplied, css-select will follow the HTML spec's
+        [case-sensitivity rules](https://html.spec.whatwg.org/multipage/semantics-other.html#case-sensitivity-of-selectors).
+-   Pseudos:
+    -   [`:not`](https://developer.mozilla.org/en-US/docs/Web/CSS/:not)
+    -   [`:contains`](https://api.jquery.com/contains-selector)
+    -   `:icontains` (case-insensitive version of `:contains`)
+    -   [`:has`](https://developer.mozilla.org/en-US/docs/Web/CSS/:has)
+    -   [`:root`](https://developer.mozilla.org/en-US/docs/Web/CSS/:root)
+    -   [`:empty`](https://developer.mozilla.org/en-US/docs/Web/CSS/:empty)
+    -   [`:parent`](https://api.jquery.com/parent-selector)
+    -   [`:first-child`](https://developer.mozilla.org/en-US/docs/Web/CSS/:first-child),
+        [`:last-child`](https://developer.mozilla.org/en-US/docs/Web/CSS/:last-child),
+        [`:first-of-type`](https://developer.mozilla.org/en-US/docs/Web/CSS/:first-of-type),
+        [`:last-of-type`](https://developer.mozilla.org/en-US/docs/Web/CSS/:last-of-type)
+    -   [`:only-of-type`](https://developer.mozilla.org/en-US/docs/Web/CSS/:only-of-type),
+        [`:only-child`](https://developer.mozilla.org/en-US/docs/Web/CSS/:only-child)
+    -   [`:nth-child`](https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-child),
+        [`:nth-last-child`](https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-last-child),
+        [`:nth-of-type`](https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-of-type),
+        [`:nth-last-of-type`](https://developer.mozilla.org/en-US/docs/Web/CSS/:nth-last-of-type),
+    -   [`:link`](https://developer.mozilla.org/en-US/docs/Web/CSS/:link),
+        [`:any-link`](https://developer.mozilla.org/en-US/docs/Web/CSS/:any-link)
+    -   [`:visited`](https://developer.mozilla.org/en-US/docs/Web/CSS/:visited),
+        [`:hover`](https://developer.mozilla.org/en-US/docs/Web/CSS/:hover),
+        [`:active`](https://developer.mozilla.org/en-US/docs/Web/CSS/:active)
+        (these depend on optional `Adapter` methods, so these will only match
+        elements if implemented in `Adapter`)
+    -   [`:selected`](https://api.jquery.com/selected-selector),
+        [`:checked`](https://developer.mozilla.org/en-US/docs/Web/CSS/:checked)
+    -   [`:enabled`](https://developer.mozilla.org/en-US/docs/Web/CSS/:enabled),
+        [`:disabled`](https://developer.mozilla.org/en-US/docs/Web/CSS/:disabled)
+    -   [`:required`](https://developer.mozilla.org/en-US/docs/Web/CSS/:required),
+        [`:optional`](https://developer.mozilla.org/en-US/docs/Web/CSS/:optional)
+    -   [`:header`](https://api.jquery.com/header-selector),
+        [`:button`](https://api.jquery.com/button-selector),
+        [`:input`](https://api.jquery.com/input-selector),
+        [`:text`](https://api.jquery.com/text-selector),
+        [`:checkbox`](https://api.jquery.com/checkbox-selector),
+        [`:file`](https://api.jquery.com/file-selector),
+        [`:password`](https://api.jquery.com/password-selector),
+        [`:reset`](https://api.jquery.com/reset-selector),
+        [`:radio`](https://api.jquery.com/radio-selector) etc.
+    -   [`:is`](https://developer.mozilla.org/en-US/docs/Web/CSS/:is), plus its
+        legacy alias `:matches`
+    -   [`:scope`](https://developer.mozilla.org/en-US/docs/Web/CSS/:scope)
+        (uses the context from the passed options)
+
+---
+
+License: BSD-2-Clause
+
+## Security contact information
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security). Tidelift will
+coordinate the fix and disclosure.
+
+## `css-select` for enterprise
+
+Available as part of the Tidelift Subscription
+
+The maintainers of `css-select` and thousands of other packages are working with
+Tidelift to deliver commercial support and maintenance for the open source
+dependencies you use to build your applications. Save time, reduce risk, and
+improve code health, while paying the maintainers of the exact dependencies you
+use.
+[Learn more.](https://tidelift.com/subscription/pkg/npm-css-select?utm_source=npm-css-select&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)

node/node_modules/css-select/lib/attributes.d.ts

@@ -0,0 +1,7 @@
+import { CompiledQuery, InternalOptions } from "./types";
+import type { AttributeSelector, AttributeAction } from "css-what";
+/**
+ * Attribute selectors
+ */
+export declare const attributeRules: Record<AttributeAction, <Node, ElementNode extends Node>(next: CompiledQuery<ElementNode>, data: AttributeSelector, options: InternalOptions<Node, ElementNode>) => CompiledQuery<ElementNode>>;
+//# sourceMappingURL=attributes.d.ts.map

node/node_modules/css-select/lib/attributes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../src/attributes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AA+EnE;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,MAAM,CAC/B,eAAe,EACf,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EAC3B,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,EAChC,IAAI,EAAE,iBAAiB,EACvB,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,KAC1C,aAAa,CAAC,WAAW,CAAC,CAsLlC,CAAC"}

node/node_modules/css-select/lib/attributes.js

@@ -0,0 +1,232 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attributeRules = void 0;
+var boolbase_1 = require("boolbase");
+/**
+ * All reserved characters in a regex, used for escaping.
+ *
+ * Taken from XRegExp, (c) 2007-2020 Steven Levithan under the MIT license
+ * https://github.com/slevithan/xregexp/blob/95eeebeb8fac8754d54eafe2b4743661ac1cf028/src/xregexp.js#L794
+ */
+var reChars = /[-[\]{}()*+?.,\\^$|#\s]/g;
+function escapeRegex(value) {
+    return value.replace(reChars, "\\$&");
+}
+/**
+ * Attributes that are case-insensitive in HTML.
+ *
+ * @private
+ * @see https://html.spec.whatwg.org/multipage/semantics-other.html#case-sensitivity-of-selectors
+ */
+var caseInsensitiveAttributes = new Set([
+    "accept",
+    "accept-charset",
+    "align",
+    "alink",
+    "axis",
+    "bgcolor",
+    "charset",
+    "checked",
+    "clear",
+    "codetype",
+    "color",
+    "compact",
+    "declare",
+    "defer",
+    "dir",
+    "direction",
+    "disabled",
+    "enctype",
+    "face",
+    "frame",
+    "hreflang",
+    "http-equiv",
+    "lang",
+    "language",
+    "link",
+    "media",
+    "method",
+    "multiple",
+    "nohref",
+    "noresize",
+    "noshade",
+    "nowrap",
+    "readonly",
+    "rel",
+    "rev",
+    "rules",
+    "scope",
+    "scrolling",
+    "selected",
+    "shape",
+    "target",
+    "text",
+    "type",
+    "valign",
+    "valuetype",
+    "vlink",
+]);
+function shouldIgnoreCase(selector, options) {
+    return typeof selector.ignoreCase === "boolean"
+        ? selector.ignoreCase
+        : selector.ignoreCase === "quirks"
+            ? !!options.quirksMode
+            : !options.xmlMode && caseInsensitiveAttributes.has(selector.name);
+}
+/**
+ * Attribute selectors
+ */
+exports.attributeRules = {
+    equals: function (next, data, options) {
+        var adapter = options.adapter;
+        var name = data.name;
+        var value = data.value;
+        if (shouldIgnoreCase(data, options)) {
+            value = value.toLowerCase();
+            return function (elem) {
+                var attr = adapter.getAttributeValue(elem, name);
+                return (attr != null &&
+                    attr.length === value.length &&
+                    attr.toLowerCase() === value &&
+                    next(elem));
+            };
+        }
+        return function (elem) {
+            return adapter.getAttributeValue(elem, name) === value && next(elem);
+        };
+    },
+    hyphen: function (next, data, options) {
+        var adapter = options.adapter;
+        var name = data.name;
+        var value = data.value;
+        var len = value.length;
+        if (shouldIgnoreCase(data, options)) {
+            value = value.toLowerCase();
+            return function hyphenIC(elem) {
+                var attr = adapter.getAttributeValue(elem, name);
+                return (attr != null &&
+                    (attr.length === len || attr.charAt(len) === "-") &&
+                    attr.substr(0, len).toLowerCase() === value &&
+                    next(elem));
+            };
+        }
+        return function hyphen(elem) {
+            var attr = adapter.getAttributeValue(elem, name);
+            return (attr != null &&
+                (attr.length === len || attr.charAt(len) === "-") &&
+                attr.substr(0, len) === value &&
+                next(elem));
+        };
+    },
+    element: function (next, data, options) {
+        var adapter = options.adapter;
+        var name = data.name, value = data.value;
+        if (/\s/.test(value)) {
+            return boolbase_1.falseFunc;
+        }
+        var regex = new RegExp("(?:^|\\s)".concat(escapeRegex(value), "(?:$|\\s)"), shouldIgnoreCase(data, options) ? "i" : "");
+        return function element(elem) {
+            var attr = adapter.getAttributeValue(elem, name);
+            return (attr != null &&
+                attr.length >= value.length &&
+                regex.test(attr) &&
+                next(elem));
+        };
+    },
+    exists: function (next, _a, _b) {
+        var name = _a.name;
+        var adapter = _b.adapter;
+        return function (elem) { return adapter.hasAttrib(elem, name) && next(elem); };
+    },
+    start: function (next, data, options) {
+        var adapter = options.adapter;
+        var name = data.name;
+        var value = data.value;
+        var len = value.length;
+        if (len === 0) {
+            return boolbase_1.falseFunc;
+        }
+        if (shouldIgnoreCase(data, options)) {
+            value = value.toLowerCase();
+            return function (elem) {
+                var attr = adapter.getAttributeValue(elem, name);
+                return (attr != null &&
+                    attr.length >= len &&
+                    attr.substr(0, len).toLowerCase() === value &&
+                    next(elem));
+            };
+        }
+        return function (elem) {
+            var _a;
+            return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.startsWith(value)) &&
+                next(elem);
+        };
+    },
+    end: function (next, data, options) {
+        var adapter = options.adapter;
+        var name = data.name;
+        var value = data.value;
+        var len = -value.length;
+        if (len === 0) {
+            return boolbase_1.falseFunc;
+        }
+        if (shouldIgnoreCase(data, options)) {
+            value = value.toLowerCase();
+            return function (elem) {
+                var _a;
+                return ((_a = adapter
+                    .getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.substr(len).toLowerCase()) === value && next(elem);
+            };
+        }
+        return function (elem) {
+            var _a;
+            return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.endsWith(value)) &&
+                next(elem);
+        };
+    },
+    any: function (next, data, options) {
+        var adapter = options.adapter;
+        var name = data.name, value = data.value;
+        if (value === "") {
+            return boolbase_1.falseFunc;
+        }
+        if (shouldIgnoreCase(data, options)) {
+            var regex_1 = new RegExp(escapeRegex(value), "i");
+            return function anyIC(elem) {
+                var attr = adapter.getAttributeValue(elem, name);
+                return (attr != null &&
+                    attr.length >= value.length &&
+                    regex_1.test(attr) &&
+                    next(elem));
+            };
+        }
+        return function (elem) {
+            var _a;
+            return !!((_a = adapter.getAttributeValue(elem, name)) === null || _a === void 0 ? void 0 : _a.includes(value)) &&
+                next(elem);
+        };
+    },
+    not: function (next, data, options) {
+        var adapter = options.adapter;
+        var name = data.name;
+        var value = data.value;
+        if (value === "") {
+            return function (elem) {
+                return !!adapter.getAttributeValue(elem, name) && next(elem);
+            };
+        }
+        else if (shouldIgnoreCase(data, options)) {
+            value = value.toLowerCase();
+            return function (elem) {
+                var attr = adapter.getAttributeValue(elem, name);
+                return ((attr == null ||
+                    attr.length !== value.length ||
+                    attr.toLowerCase() !== value) &&
+                    next(elem));
+            };
+        }
+        return function (elem) {
+            return adapter.getAttributeValue(elem, name) !== value && next(elem);
+        };
+    },
+};

node/node_modules/css-select/lib/compile.d.ts

@@ -0,0 +1,14 @@
+import { InternalSelector } from "./types";
+import { Selector } from "css-what";
+import type { CompiledQuery, InternalOptions } from "./types";
+/**
+ * Compiles a selector to an executable function.
+ *
+ * @param selector Selector to compile.
+ * @param options Compilation options.
+ * @param context Optional context for the selector.
+ */
+export declare function compile<Node, ElementNode extends Node>(selector: string | Selector[][], options: InternalOptions<Node, ElementNode>, context?: Node[] | Node): CompiledQuery<Node>;
+export declare function compileUnsafe<Node, ElementNode extends Node>(selector: string | Selector[][], options: InternalOptions<Node, ElementNode>, context?: Node[] | Node): CompiledQuery<ElementNode>;
+export declare function compileToken<Node, ElementNode extends Node>(token: InternalSelector[][], options: InternalOptions<Node, ElementNode>, context?: Node[] | Node): CompiledQuery<ElementNode>;
+//# sourceMappingURL=compile.d.ts.map

node/node_modules/css-select/lib/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAC3C,OAAO,EAAS,QAAQ,EAAgB,MAAM,UAAU,CAAC;AASzD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE9D;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EAClD,QAAQ,EAAE,MAAM,GAAG,QAAQ,EAAE,EAAE,EAC/B,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,EAC3C,OAAO,CAAC,EAAE,IAAI,EAAE,GAAG,IAAI,GACxB,aAAa,CAAC,IAAI,CAAC,CAGrB;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EACxD,QAAQ,EAAE,MAAM,GAAG,QAAQ,EAAE,EAAE,EAC/B,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,EAC3C,OAAO,CAAC,EAAE,IAAI,EAAE,GAAG,IAAI,GACxB,aAAa,CAAC,WAAW,CAAC,CAG5B;AAiDD,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EACvD,KAAK,EAAE,gBAAgB,EAAE,EAAE,EAC3B,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,EAC3C,OAAO,CAAC,EAAE,IAAI,EAAE,GAAG,IAAI,GACxB,aAAa,CAAC,WAAW,CAAC,CA2C5B"}

node/node_modules/css-select/lib/compile.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileToken = exports.compileUnsafe = exports.compile = void 0;
+var css_what_1 = require("css-what");
+var boolbase_1 = require("boolbase");
+var sort_1 = __importDefault(require("./sort"));
+var procedure_1 = require("./procedure");
+var general_1 = require("./general");
+var subselects_1 = require("./pseudo-selectors/subselects");
+/**
+ * Compiles a selector to an executable function.
+ *
+ * @param selector Selector to compile.
+ * @param options Compilation options.
+ * @param context Optional context for the selector.
+ */
+function compile(selector, options, context) {
+    var next = compileUnsafe(selector, options, context);
+    return (0, subselects_1.ensureIsTag)(next, options.adapter);
+}
+exports.compile = compile;
+function compileUnsafe(selector, options, context) {
+    var token = typeof selector === "string" ? (0, css_what_1.parse)(selector) : selector;
+    return compileToken(token, options, context);
+}
+exports.compileUnsafe = compileUnsafe;
+function includesScopePseudo(t) {
+    return (t.type === "pseudo" &&
+        (t.name === "scope" ||
+            (Array.isArray(t.data) &&
+                t.data.some(function (data) { return data.some(includesScopePseudo); }))));
+}
+var DESCENDANT_TOKEN = { type: css_what_1.SelectorType.Descendant };
+var FLEXIBLE_DESCENDANT_TOKEN = {
+    type: "_flexibleDescendant",
+};
+var SCOPE_TOKEN = {
+    type: css_what_1.SelectorType.Pseudo,
+    name: "scope",
+    data: null,
+};
+/*
+ * CSS 4 Spec (Draft): 3.3.1. Absolutizing a Scope-relative Selector
+ * http://www.w3.org/TR/selectors4/#absolutizing
+ */
+function absolutize(token, _a, context) {
+    var adapter = _a.adapter;
+    // TODO Use better check if the context is a document
+    var hasContext = !!(context === null || context === void 0 ? void 0 : context.every(function (e) {
+        var parent = adapter.isTag(e) && adapter.getParent(e);
+        return e === subselects_1.PLACEHOLDER_ELEMENT || (parent && adapter.isTag(parent));
+    }));
+    for (var _i = 0, token_1 = token; _i < token_1.length; _i++) {
+        var t = token_1[_i];
+        if (t.length > 0 && (0, procedure_1.isTraversal)(t[0]) && t[0].type !== "descendant") {
+            // Don't continue in else branch
+        }
+        else if (hasContext && !t.some(includesScopePseudo)) {
+            t.unshift(DESCENDANT_TOKEN);
+        }
+        else {
+            continue;
+        }
+        t.unshift(SCOPE_TOKEN);
+    }
+}
+function compileToken(token, options, context) {
+    var _a;
+    token = token.filter(function (t) { return t.length > 0; });
+    token.forEach(sort_1.default);
+    context = (_a = options.context) !== null && _a !== void 0 ? _a : context;
+    var isArrayContext = Array.isArray(context);
+    var finalContext = context && (Array.isArray(context) ? context : [context]);
+    absolutize(token, options, finalContext);
+    var shouldTestNextSiblings = false;
+    var query = token
+        .map(function (rules) {
+        if (rules.length >= 2) {
+            var first = rules[0], second = rules[1];
+            if (first.type !== "pseudo" || first.name !== "scope") {
+                // Ignore
+            }
+            else if (isArrayContext && second.type === "descendant") {
+                rules[1] = FLEXIBLE_DESCENDANT_TOKEN;
+            }
+            else if (second.type === "adjacent" ||
+                second.type === "sibling") {
+                shouldTestNextSiblings = true;
+            }
+        }
+        return compileRules(rules, options, finalContext);
+    })
+        .reduce(reduceRules, boolbase_1.falseFunc);
+    query.shouldTestNextSiblings = shouldTestNextSiblings;
+    return query;
+}
+exports.compileToken = compileToken;
+function compileRules(rules, options, context) {
+    var _a;
+    return rules.reduce(function (previous, rule) {
+        return previous === boolbase_1.falseFunc
+            ? boolbase_1.falseFunc
+            : (0, general_1.compileGeneralSelector)(previous, rule, options, context, compileToken);
+    }, (_a = options.rootFunc) !== null && _a !== void 0 ? _a : boolbase_1.trueFunc);
+}
+function reduceRules(a, b) {
+    if (b === boolbase_1.falseFunc || a === boolbase_1.trueFunc) {
+        return a;
+    }
+    if (a === boolbase_1.falseFunc || b === boolbase_1.trueFunc) {
+        return b;
+    }
+    return function combine(elem) {
+        return a(elem) || b(elem);
+    };
+}

node/node_modules/css-select/lib/general.d.ts

@@ -0,0 +1,3 @@
+import type { CompiledQuery, InternalOptions, InternalSelector, CompileToken } from "./types";
+export declare function compileGeneralSelector<Node, ElementNode extends Node>(next: CompiledQuery<ElementNode>, selector: InternalSelector, options: InternalOptions<Node, ElementNode>, context: Node[] | undefined, compileToken: CompileToken<Node, ElementNode>): CompiledQuery<ElementNode>;
+//# sourceMappingURL=general.d.ts.map

node/node_modules/css-select/lib/general.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"general.d.ts","sourceRoot":"","sources":["../src/general.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACR,aAAa,EACb,eAAe,EACf,gBAAgB,EAChB,YAAY,EACf,MAAM,SAAS,CAAC;AAOjB,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EACjE,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,EAChC,QAAQ,EAAE,gBAAgB,EAC1B,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,EAC3C,OAAO,EAAE,IAAI,EAAE,GAAG,SAAS,EAC3B,YAAY,EAAE,YAAY,CAAC,IAAI,EAAE,WAAW,CAAC,GAC9C,aAAa,CAAC,WAAW,CAAC,CAiK5B"}

node/node_modules/css-select/lib/general.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileGeneralSelector = void 0;
+var attributes_1 = require("./attributes");
+var pseudo_selectors_1 = require("./pseudo-selectors");
+var css_what_1 = require("css-what");
+/*
+ * All available rules
+ */
+function compileGeneralSelector(next, selector, options, context, compileToken) {
+    var adapter = options.adapter, equals = options.equals;
+    switch (selector.type) {
+        case css_what_1.SelectorType.PseudoElement: {
+            throw new Error("Pseudo-elements are not supported by css-select");
+        }
+        case css_what_1.SelectorType.ColumnCombinator: {
+            throw new Error("Column combinators are not yet supported by css-select");
+        }
+        case css_what_1.SelectorType.Attribute: {
+            if (selector.namespace != null) {
+                throw new Error("Namespaced attributes are not yet supported by css-select");
+            }
+            if (!options.xmlMode || options.lowerCaseAttributeNames) {
+                selector.name = selector.name.toLowerCase();
+            }
+            return attributes_1.attributeRules[selector.action](next, selector, options);
+        }
+        case css_what_1.SelectorType.Pseudo: {
+            return (0, pseudo_selectors_1.compilePseudoSelector)(next, selector, options, context, compileToken);
+        }
+        // Tags
+        case css_what_1.SelectorType.Tag: {
+            if (selector.namespace != null) {
+                throw new Error("Namespaced tag names are not yet supported by css-select");
+            }
+            var name_1 = selector.name;
+            if (!options.xmlMode || options.lowerCaseTags) {
+                name_1 = name_1.toLowerCase();
+            }
+            return function tag(elem) {
+                return adapter.getName(elem) === name_1 && next(elem);
+            };
+        }
+        // Traversal
+        case css_what_1.SelectorType.Descendant: {
+            if (options.cacheResults === false ||
+                typeof WeakSet === "undefined") {
+                return function descendant(elem) {
+                    var current = elem;
+                    while ((current = adapter.getParent(current))) {
+                        if (adapter.isTag(current) && next(current)) {
+                            return true;
+                        }
+                    }
+                    return false;
+                };
+            }
+            // @ts-expect-error `ElementNode` is not extending object
+            var isFalseCache_1 = new WeakSet();
+            return function cachedDescendant(elem) {
+                var current = elem;
+                while ((current = adapter.getParent(current))) {
+                    if (!isFalseCache_1.has(current)) {
+                        if (adapter.isTag(current) && next(current)) {
+                            return true;
+                        }
+                        isFalseCache_1.add(current);
+                    }
+                }
+                return false;
+            };
+        }
+        case "_flexibleDescendant": {
+            // Include element itself, only used while querying an array
+            return function flexibleDescendant(elem) {
+                var current = elem;
+                do {
+                    if (adapter.isTag(current) && next(current))
+                        return true;
+                } while ((current = adapter.getParent(current)));
+                return false;
+            };
+        }
+        case css_what_1.SelectorType.Parent: {
+            return function parent(elem) {
+                return adapter
+                    .getChildren(elem)
+                    .some(function (elem) { return adapter.isTag(elem) && next(elem); });
+            };
+        }
+        case css_what_1.SelectorType.Child: {
+            return function child(elem) {
+                var parent = adapter.getParent(elem);
+                return parent != null && adapter.isTag(parent) && next(parent);
+            };
+        }
+        case css_what_1.SelectorType.Sibling: {
+            return function sibling(elem) {
+                var siblings = adapter.getSiblings(elem);
+                for (var i = 0; i < siblings.length; i++) {
+                    var currentSibling = siblings[i];
+                    if (equals(elem, currentSibling))
+                        break;
+                    if (adapter.isTag(currentSibling) && next(currentSibling)) {
+                        return true;
+                    }
+                }
+                return false;
+            };
+        }
+        case css_what_1.SelectorType.Adjacent: {
+            if (adapter.prevElementSibling) {
+                return function adjacent(elem) {
+                    var previous = adapter.prevElementSibling(elem);
+                    return previous != null && next(previous);
+                };
+            }
+            return function adjacent(elem) {
+                var siblings = adapter.getSiblings(elem);
+                var lastElement;
+                for (var i = 0; i < siblings.length; i++) {
+                    var currentSibling = siblings[i];
+                    if (equals(elem, currentSibling))
+                        break;
+                    if (adapter.isTag(currentSibling)) {
+                        lastElement = currentSibling;
+                    }
+                }
+                return !!lastElement && next(lastElement);
+            };
+        }
+        case css_what_1.SelectorType.Universal: {
+            if (selector.namespace != null && selector.namespace !== "*") {
+                throw new Error("Namespaced universal selectors are not yet supported by css-select");
+            }
+            return next;
+        }
+    }
+}
+exports.compileGeneralSelector = compileGeneralSelector;

node/node_modules/css-select/lib/index.d.ts

@@ -0,0 +1,49 @@
+import type { CompiledQuery, Options, Query, Adapter } from "./types";
+export type { Options };
+/**
+ * Compiles the query, returns a function.
+ */
+export declare const compile: <Node_1, ElementNode extends Node_1>(selector: string | import("css-what").Selector[][], options?: Options<Node_1, ElementNode> | undefined, context?: Node_1 | Node_1[] | undefined) => CompiledQuery<Node_1>;
+export declare const _compileUnsafe: <Node_1, ElementNode extends Node_1>(selector: string | import("css-what").Selector[][], options?: Options<Node_1, ElementNode> | undefined, context?: Node_1 | Node_1[] | undefined) => CompiledQuery<ElementNode>;
+export declare const _compileToken: <Node_1, ElementNode extends Node_1>(selector: import("./types").InternalSelector[][], options?: Options<Node_1, ElementNode> | undefined, context?: Node_1 | Node_1[] | undefined) => CompiledQuery<ElementNode>;
+export declare function prepareContext<Node, ElementNode extends Node>(elems: Node | Node[], adapter: Adapter<Node, ElementNode>, shouldTestNextSiblings?: boolean): Node[];
+/**
+ * @template Node The generic Node type for the DOM adapter being used.
+ * @template ElementNode The Node type for elements for the DOM adapter being used.
+ * @param elems Elements to query. If it is an element, its children will be queried..
+ * @param query can be either a CSS selector string or a compiled query function.
+ * @param [options] options for querying the document.
+ * @see compile for supported selector queries.
+ * @returns All matching elements.
+ *
+ */
+export declare const selectAll: <Node_1, ElementNode extends Node_1>(query: Query<ElementNode>, elements: Node_1 | Node_1[], options?: Options<Node_1, ElementNode> | undefined) => ElementNode[];
+/**
+ * @template Node The generic Node type for the DOM adapter being used.
+ * @template ElementNode The Node type for elements for the DOM adapter being used.
+ * @param elems Elements to query. If it is an element, its children will be queried..
+ * @param query can be either a CSS selector string or a compiled query function.
+ * @param [options] options for querying the document.
+ * @see compile for supported selector queries.
+ * @returns the first match, or null if there was no match.
+ */
+export declare const selectOne: <Node_1, ElementNode extends Node_1>(query: Query<ElementNode>, elements: Node_1 | Node_1[], options?: Options<Node_1, ElementNode> | undefined) => ElementNode | null;
+/**
+ * Tests whether or not an element is matched by query.
+ *
+ * @template Node The generic Node type for the DOM adapter being used.
+ * @template ElementNode The Node type for elements for the DOM adapter being used.
+ * @param elem The element to test if it matches the query.
+ * @param query can be either a CSS selector string or a compiled query function.
+ * @param [options] options for querying the document.
+ * @see compile for supported selector queries.
+ * @returns
+ */
+export declare function is<Node, ElementNode extends Node>(elem: ElementNode, query: Query<ElementNode>, options?: Options<Node, ElementNode>): boolean;
+/**
+ * Alias for selectAll(query, elems, options).
+ * @see [compile] for supported selector queries.
+ */
+export default selectAll;
+export { filters, pseudos, aliases } from "./pseudo-selectors";
+//# sourceMappingURL=index.d.ts.map

node/node_modules/css-select/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACR,aAAa,EACb,OAAO,EAEP,KAAK,EACL,OAAO,EAEV,MAAM,SAAS,CAAC;AAGjB,YAAY,EAAE,OAAO,EAAE,CAAC;AA0CxB;;GAEG;AACH,eAAO,MAAM,OAAO,gNAA0B,CAAC;AAC/C,eAAO,MAAM,cAAc,qNAA6B,CAAC;AACzD,eAAO,MAAM,aAAa,mNAA4B,CAAC;AA6BvD,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EACzD,KAAK,EAAE,IAAI,GAAG,IAAI,EAAE,EACpB,OAAO,EAAE,OAAO,CAAC,IAAI,EAAE,WAAW,CAAC,EACnC,sBAAsB,UAAQ,GAC/B,IAAI,EAAE,CAYR;AAiBD;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,mKASrB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,wKASrB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,wBAAgB,EAAE,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EAC7C,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,EACzB,OAAO,CAAC,EAAE,OAAO,CAAC,IAAI,EAAE,WAAW,CAAC,GACrC,OAAO,CAKT;AAED;;;GAGG;AACH,eAAe,SAAS,CAAC;AAGzB,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC"}

node/node_modules/css-select/lib/index.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aliases = exports.pseudos = exports.filters = exports.is = exports.selectOne = exports.selectAll = exports.prepareContext = exports._compileToken = exports._compileUnsafe = exports.compile = void 0;
+var DomUtils = __importStar(require("domutils"));
+var boolbase_1 = require("boolbase");
+var compile_1 = require("./compile");
+var subselects_1 = require("./pseudo-selectors/subselects");
+var defaultEquals = function (a, b) { return a === b; };
+var defaultOptions = {
+    adapter: DomUtils,
+    equals: defaultEquals,
+};
+function convertOptionFormats(options) {
+    var _a, _b, _c, _d;
+    /*
+     * We force one format of options to the other one.
+     */
+    // @ts-expect-error Default options may have incompatible `Node` / `ElementNode`.
+    var opts = options !== null && options !== void 0 ? options : defaultOptions;
+    // @ts-expect-error Same as above.
+    (_a = opts.adapter) !== null && _a !== void 0 ? _a : (opts.adapter = DomUtils);
+    // @ts-expect-error `equals` does not exist on `Options`
+    (_b = opts.equals) !== null && _b !== void 0 ? _b : (opts.equals = (_d = (_c = opts.adapter) === null || _c === void 0 ? void 0 : _c.equals) !== null && _d !== void 0 ? _d : defaultEquals);
+    return opts;
+}
+function wrapCompile(func) {
+    return function addAdapter(selector, options, context) {
+        var opts = convertOptionFormats(options);
+        return func(selector, opts, context);
+    };
+}
+/**
+ * Compiles the query, returns a function.
+ */
+exports.compile = wrapCompile(compile_1.compile);
+exports._compileUnsafe = wrapCompile(compile_1.compileUnsafe);
+exports._compileToken = wrapCompile(compile_1.compileToken);
+function getSelectorFunc(searchFunc) {
+    return function select(query, elements, options) {
+        var opts = convertOptionFormats(options);
+        if (typeof query !== "function") {
+            query = (0, compile_1.compileUnsafe)(query, opts, elements);
+        }
+        var filteredElements = prepareContext(elements, opts.adapter, query.shouldTestNextSiblings);
+        return searchFunc(query, filteredElements, opts);
+    };
+}
+function prepareContext(elems, adapter, shouldTestNextSiblings) {
+    if (shouldTestNextSiblings === void 0) { shouldTestNextSiblings = false; }
+    /*
+     * Add siblings if the query requires them.
+     * See https://github.com/fb55/css-select/pull/43#issuecomment-225414692
+     */
+    if (shouldTestNextSiblings) {
+        elems = appendNextSiblings(elems, adapter);
+    }
+    return Array.isArray(elems)
+        ? adapter.removeSubsets(elems)
+        : adapter.getChildren(elems);
+}
+exports.prepareContext = prepareContext;
+function appendNextSiblings(elem, adapter) {
+    // Order matters because jQuery seems to check the children before the siblings
+    var elems = Array.isArray(elem) ? elem.slice(0) : [elem];
+    var elemsLength = elems.length;
+    for (var i = 0; i < elemsLength; i++) {
+        var nextSiblings = (0, subselects_1.getNextSiblings)(elems[i], adapter);
+        elems.push.apply(elems, nextSiblings);
+    }
+    return elems;
+}
+/**
+ * @template Node The generic Node type for the DOM adapter being used.
+ * @template ElementNode The Node type for elements for the DOM adapter being used.
+ * @param elems Elements to query. If it is an element, its children will be queried..
+ * @param query can be either a CSS selector string or a compiled query function.
+ * @param [options] options for querying the document.
+ * @see compile for supported selector queries.
+ * @returns All matching elements.
+ *
+ */
+exports.selectAll = getSelectorFunc(function (query, elems, options) {
+    return query === boolbase_1.falseFunc || !elems || elems.length === 0
+        ? []
+        : options.adapter.findAll(query, elems);
+});
+/**
+ * @template Node The generic Node type for the DOM adapter being used.
+ * @template ElementNode The Node type for elements for the DOM adapter being used.
+ * @param elems Elements to query. If it is an element, its children will be queried..
+ * @param query can be either a CSS selector string or a compiled query function.
+ * @param [options] options for querying the document.
+ * @see compile for supported selector queries.
+ * @returns the first match, or null if there was no match.
+ */
+exports.selectOne = getSelectorFunc(function (query, elems, options) {
+    return query === boolbase_1.falseFunc || !elems || elems.length === 0
+        ? null
+        : options.adapter.findOne(query, elems);
+});
+/**
+ * Tests whether or not an element is matched by query.
+ *
+ * @template Node The generic Node type for the DOM adapter being used.
+ * @template ElementNode The Node type for elements for the DOM adapter being used.
+ * @param elem The element to test if it matches the query.
+ * @param query can be either a CSS selector string or a compiled query function.
+ * @param [options] options for querying the document.
+ * @see compile for supported selector queries.
+ * @returns
+ */
+function is(elem, query, options) {
+    var opts = convertOptionFormats(options);
+    return (typeof query === "function" ? query : (0, compile_1.compile)(query, opts))(elem);
+}
+exports.is = is;
+/**
+ * Alias for selectAll(query, elems, options).
+ * @see [compile] for supported selector queries.
+ */
+exports.default = exports.selectAll;
+// Export filters, pseudos and aliases to allow users to supply their own.
+var pseudo_selectors_1 = require("./pseudo-selectors");
+Object.defineProperty(exports, "filters", { enumerable: true, get: function () { return pseudo_selectors_1.filters; } });
+Object.defineProperty(exports, "pseudos", { enumerable: true, get: function () { return pseudo_selectors_1.pseudos; } });
+Object.defineProperty(exports, "aliases", { enumerable: true, get: function () { return pseudo_selectors_1.aliases; } });

node/node_modules/css-select/lib/procedure.d.ts

@@ -0,0 +1,5 @@
+import type { Traversal } from "css-what";
+import type { InternalSelector } from "./types";
+export declare const procedure: Record<InternalSelector["type"], number>;
+export declare function isTraversal(t: InternalSelector): t is Traversal;
+//# sourceMappingURL=procedure.d.ts.map

node/node_modules/css-select/lib/procedure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedure.d.ts","sourceRoot":"","sources":["../src/procedure.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC,EAAE,MAAM,CAa9D,CAAC;AAEF,wBAAgB,WAAW,CAAC,CAAC,EAAE,gBAAgB,GAAG,CAAC,IAAI,SAAS,CAE/D"}

node/node_modules/css-select/lib/procedure.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTraversal = exports.procedure = void 0;
+exports.procedure = {
+    universal: 50,
+    tag: 30,
+    attribute: 1,
+    pseudo: 0,
+    "pseudo-element": 0,
+    "column-combinator": -1,
+    descendant: -1,
+    child: -1,
+    parent: -1,
+    sibling: -1,
+    adjacent: -1,
+    _flexibleDescendant: -1,
+};
+function isTraversal(t) {
+    return exports.procedure[t.type] < 0;
+}
+exports.isTraversal = isTraversal;

node/node_modules/css-select/lib/pseudo-selectors/aliases.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Aliases are pseudos that are expressed as selectors.
+ */
+export declare const aliases: Record<string, string>;
+//# sourceMappingURL=aliases.d.ts.map

node/node_modules/css-select/lib/pseudo-selectors/aliases.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aliases.d.ts","sourceRoot":"","sources":["../../src/pseudo-selectors/aliases.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAwC1C,CAAC"}

node/node_modules/css-select/lib/pseudo-selectors/aliases.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aliases = void 0;
+/**
+ * Aliases are pseudos that are expressed as selectors.
+ */
+exports.aliases = {
+    // Links
+    "any-link": ":is(a, area, link)[href]",
+    link: ":any-link:not(:visited)",
+    // Forms
+    // https://html.spec.whatwg.org/multipage/scripting.html#disabled-elements
+    disabled: ":is(\n        :is(button, input, select, textarea, optgroup, option)[disabled],\n        optgroup[disabled] > option,\n        fieldset[disabled]:not(fieldset[disabled] legend:first-of-type *)\n    )",
+    enabled: ":not(:disabled)",
+    checked: ":is(:is(input[type=radio], input[type=checkbox])[checked], option:selected)",
+    required: ":is(input, select, textarea)[required]",
+    optional: ":is(input, select, textarea):not([required])",
+    // JQuery extensions
+    // https://html.spec.whatwg.org/multipage/form-elements.html#concept-option-selectedness
+    selected: "option:is([selected], select:not([multiple]):not(:has(> option[selected])) > :first-of-type)",
+    checkbox: "[type=checkbox]",
+    file: "[type=file]",
+    password: "[type=password]",
+    radio: "[type=radio]",
+    reset: "[type=reset]",
+    image: "[type=image]",
+    submit: "[type=submit]",
+    parent: ":not(:empty)",
+    header: ":is(h1, h2, h3, h4, h5, h6)",
+    button: ":is(button, input[type=button])",
+    input: ":is(input, textarea, select, button)",
+    text: "input:is(:not([type!='']), [type=text])",
+};

node/node_modules/css-select/lib/pseudo-selectors/filters.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledQuery, InternalOptions } from "../types";
+export declare type Filter = <Node, ElementNode extends Node>(next: CompiledQuery<ElementNode>, text: string, options: InternalOptions<Node, ElementNode>, context?: Node[]) => CompiledQuery<ElementNode>;
+export declare const filters: Record<string, Filter>;
+//# sourceMappingURL=filters.d.ts.map

node/node_modules/css-select/lib/pseudo-selectors/filters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filters.d.ts","sourceRoot":"","sources":["../../src/pseudo-selectors/filters.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAW,MAAM,UAAU,CAAC;AAExE,oBAAY,MAAM,GAAG,CAAC,IAAI,EAAE,WAAW,SAAS,IAAI,EAChD,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,EAChC,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,eAAe,CAAC,IAAI,EAAE,WAAW,CAAC,EAC3C,OAAO,CAAC,EAAE,IAAI,EAAE,KACf,aAAa,CAAC,WAAW,CAAC,CAAC;AAYhC,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA2I1C,CAAC"}