v10.4.3

Merge pull request #211 from jon-ressio/feature/no-toStringTag
Remove toStringTag declaration for type compatibility
2024-10-27 20:34:12 +00:00 · 2022-12-04 13:02:11 +00:00 · 2022-12-04 12:56:21 +00:00 · 2022-11-29 22:45:58 -06:00 · 2022-10-12 21:18:09 +01:00 · 2022-10-07 18:09:07 +01:00
22 changed files with 1475 additions and 438 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -1,6 +1,16 @@
 language: node_js
 node_js:
  - "node"
+  - "18"
+  - "17"
+  - "16"
+  - "15"
+  - "14"
+  - "13"
+  - "12"
+  - "11"
+  - "10"
+  - "9"
  - "8"
  - "7"
  - "6"
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,6 +1,103 @@
+#### 10.4.3
+* 04/12/2022
+* #211 Remove `toStringTag` declaration for type compatibility.
+
+#### 10.4.2
+* 12/10/2022
+* #209 Correct return type.
+
+#### 10.4.1
+* 16/09/2022
+* #205 Add './decimal' subpath to *package.json* `exports`.
+
+#### 10.4.0
+* 14/08/2022
+* #201 Add `exports` field to *package.json*.
+* #203 Preserve license comment after bundling.
+* #198 Use type predicate on `isDecimal`.
+
+#### 10.3.1
+* 25/06/2021
+* Remove minified versions. Refresh *README*.
+
+#### 10.3.0
+* 22/06/2021
+* Support underscores as separators.
+* #101 Add `Decimal.clamp` method.
+* #161 Fix Decimal instances deemed plain objects.
+* #100 Add `Decimal.sum` method.
+* #146 `Symbol.for` to `Symbol['for']` for IE8.
+* #132 Fix possible infinite loop when `minE` is very low.
+* #180 Accept Decimals of different origin.
+* Update Typescript definitions.
+* Update minification examples in *README*.
+* Add minified versions for both *decimal.js* and *decimal.mjs*.
+* Add *files* field to *package.json*, and remove build script.
+
+#### 10.2.1
+* 28/09/2020
+* Correct `sqrt` initial estimate.
+
+#### 10.2.0
+* 08/05/2019
+* #128 Workaround V8 `Math.pow` change.
+* #93 Accept `+` prefix when parsing string values.
+* #129 Fix typo.
+
+#### 10.1.1
+* 27/02/2019
+* Check `Symbol` properly.
+
+#### 10.1.0
+* 26/02/2019
+* #122 Add custom `util.inspect()` function.
+* Add `Symbol.toStringTag`.
+* #121 Constructor: add range check for arguments of type number and Decimal.
+* Remove premable from uglifyjs build script.
+* Move *decimal.min.js.map* to root directory.
+
+#### 10.0.2
+* 13/12/2018
+* #114 Remove soureMappingURL from *decimal.min.js*.
+* Remove *bower.json*.
+
+#### 10.0.1
+* 24/05/2018
+* Add `browser` field to *package.json*.
+
+#### 10.0.0
+* 10/03/2018
+* #88 `toNearest` to return the nearest multiple in the direction of the rounding mode.
+* #82 #91 `const` to `var`.
+* Add trigonometric precision limit explanantion to documentation.
+* Put global ts definitions in separate file (see *bignumber.js* #143).
+
+#### 9.0.1
+* 15/12/2017
+* #80 Typings: correct return type.
+
+#### 9.0.0
+* 14/12/2017
+* #78 Typings: remove `toFormat`.
+
+#### 8.0.0
+* 10/12/2017
+* Correct typings: `toFraction` returns `Decimal[]`.
+* Type-checking: add `Decimal.isDecimal` method.
+* Enable configuration reset with `defaults: true`.
+* Add named export, Decimal, to *decimal.mjs*.
+
+#### 7.5.1
+* 03/12/2017
+* Remove typo.
+
+#### 7.5.0
+* 03/12/2017
+* Use TypeScript declarations outside modules.
+
 #### 7.4.0
 * 25/11/2017
-* Add Typescript typings.
+* Add TypeScript typings.

 #### 7.3.0
 * 26/09/2017
--- a/LICENCE.md
+++ b/LICENCE.md
@ -1,6 +1,6 @@
 The MIT Licence.

-Copyright (c) 2016, 2017 Michael Mclaughlin
+Copyright (c) 2022 Michael Mclaughlin

 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
--- a/README.md
+++ b/README.md
@ -2,6 +2,8 @@

 An arbitrary-precision Decimal type for JavaScript.

+[![npm version](https://img.shields.io/npm/v/decimal.js.svg)](https://www.npmjs.com/package/decimal.js)
+[![npm downloads](https://img.shields.io/npm/dw/decimal.js)](https://www.npmjs.com/package/decimal.js)
 [![Build Status](https://travis-ci.org/MikeMcl/decimal.js.svg)](https://travis-ci.org/MikeMcl/decimal.js)
 [![CDNJS](https://img.shields.io/cdnjs/v/decimal.js.svg)](https://cdnjs.com/libraries/decimal.js)

@ -16,7 +18,9 @@ An arbitrary-precision Decimal type for JavaScript.
  - Faster, smaller, and perhaps easier to use than JavaScript versions of Java's BigDecimal
  - No dependencies
  - Wide platform compatibility: uses JavaScript 1.5 (ECMAScript 3) features only
-  - Comprehensive [documentation](http://mikemcl.github.io/decimal.js/) and test set
+  - Comprehensive [documentation](https://mikemcl.github.io/decimal.js/) and test set
+  - Used under the hood by [math.js](https://github.com/josdejong/mathjs)
+  - Includes a TypeScript declaration file: *decimal.d.ts*

 ![API](https://raw.githubusercontent.com/MikeMcl/decimal.js/gh-pages/API.png)

@ -29,47 +33,43 @@ This library also adds the trigonometric functions, among others, and supports n
 which makes it a significantly larger library than *bignumber.js* and the even smaller
 [big.js](https://github.com/MikeMcl/big.js/).

-For a lighter version of this library without the trigonometric functions see the
-[v4.x.x](https://github.com/MikeMcl/decimal.js/tree/v4.x.x) branch where version 4 continues to be supported, or better, see [decimal.js-light](https://github.com/MikeMcl/decimal.js-light/), which is lighter still.
+For a lighter version of this library without the trigonometric functions see
+[decimal.js-light](https://github.com/MikeMcl/decimal.js-light/).

 ## Load

-The library is the single JavaScript file *decimal.js* (or minified, *decimal.min.js*).
+The library is the single JavaScript file *decimal.js* or ES module *decimal.mjs*.

-It can be loaded using a script tag in an HTML document for the browser
+Browser:

 ```html
 <script src='path/to/decimal.js'></script>
+
+<script type="module">
+  import Decimal from './path/to/decimal.mjs';
+  ...
+</script>
 ```

-or as a [Node.js](http://nodejs.org) module using `require`.
-
-```js
-var Decimal = require('decimal.js');
-```
-
-For Node, the library is available from the [npm](https://npmjs.org/) registry
+[Node.js](https://nodejs.org):

 ```bash
-$ npm install decimal.js
+npm install decimal.js
 ```
-
-To load with AMD loader libraries such as [requireJS](http://requirejs.org/):
-
 ```js
-require(['decimal'], function(Decimal) {
-    // Use Decimal here in local scope. No global Decimal.
-});
+const Decimal = require('decimal.js');
+
+import Decimal from 'decimal.js';
+
+import {Decimal} from 'decimal.js';
 ```

 ## Use

-*In all examples below, `var`, semicolons and `toString` calls are not shown.
+*In all examples below, semicolons and `toString` calls are not shown.
 If a commented-out value is in quotes it means `toString` has been called on the preceding expression.*

-The library exports a single function object, `Decimal`, the constructor of Decimal instances.
-
-It accepts a value of type number, string or Decimal.
+The library exports a single constructor function, `Decimal`, which expects a single argument that is a number, string or Decimal instance.

 ```js
 x = new Decimal(123.4567)
@ -78,7 +78,29 @@ z = new Decimal(x)
 x.equals(y) && y.equals(z) && x.equals(z)        // true
 ```

-A value can also be in binary, hexadecimal or octal if the appropriate prefix is included.
+If using values with more than a few digits, it is recommended to pass strings rather than numbers to avoid a potential loss of precision.
+
+```js
+// Precision loss from using numeric literals with more than 15 significant digits.
+new Decimal(1.0000000000000001)         // '1'
+new Decimal(88259496234518.57)          // '88259496234518.56'
+new Decimal(99999999999999999999)       // '100000000000000000000'
+
+// Precision loss from using numeric literals outside the range of Number values.
+new Decimal(2e+308)                     // 'Infinity'
+new Decimal(1e-324)                     // '0'
+
+// Precision loss from the unexpected result of arithmetic with Number values.
+new Decimal(0.7 + 0.1)                  // '0.7999999999999999'
+```
+
+As with JavaScript numbers, strings can contain underscores as separators to improve readability.
+
+```js
+x = new Decimal('2_147_483_647')
+```
+
+String values in binary, hexadecimal or octal notation are also accepted if the appropriate prefix is included.

 ```js
 x = new Decimal('0xff.f')            // '255.9375'
@ -87,9 +109,13 @@ z = x.plus(y)                        // '427.9375'

 z.toBinary()                         // '0b110101011.1111'
 z.toBinary(13)                       // '0b1.101010111111p+8'
+
+// Using binary exponential notation to create a Decimal with the value of `Number.MAX_VALUE`.
+x = new Decimal('0b1.1111111111111111111111111111111111111111111111111111p+1023')
+// '1.7976931348623157081e+308'
 ```

-A Decimal is immutable in the sense that it is not changed by its methods.
+Decimal instances are immutable in the sense that they are not changed by their methods.

 ```js
 0.3 - 0.1                     // 0.19999999999999998
@ -109,26 +135,27 @@ Many method names have a shorter alias.

 ```js
 x.squareRoot().dividedBy(y).toPower(3).equals(x.sqrt().div(y).pow(3))     // true
-x.cmp(y.mod(z).neg()) == 1 && x.comparedTo(y.modulo(z).negated()) == 1        // true
+x.comparedTo(y.modulo(z).negated() === x.cmp(y.mod(z).neg())              // true
 ```

-Like JavaScript's Number type, there are `toExponential`, `toFixed` and `toPrecision` methods,
+Most of the methods of JavaScript's `Number.prototype` and `Math` objects are replicated.

 ```js
 x = new Decimal(255.5)
 x.toExponential(5)                       // '2.55500e+2'
 x.toFixed(5)                             // '255.50000'
 x.toPrecision(5)                         // '255.50'
-```

-and almost all of the methods of JavaScript's Math object are also replicated.
-
-```js
 Decimal.sqrt('6.98372465832e+9823')      // '8.3568682281821340204e+4911'
 Decimal.pow(2, 0.0979843)                // '1.0702770511687781839'
+
+// Using `toFixed()` to avoid exponential notation:
+x = new Decimal('0.0000001')
+x.toString()                             // '1e-7'
+x.toFixed()                              // '0.0000001'
 ```

-There are `isNaN` and `isFinite` methods, as `NaN` and `Infinity` are valid `Decimal` values,
+And there are `isNaN` and `isFinite` methods, as `NaN` and `Infinity` are valid `Decimal` values.

 ```js
 x = new Decimal(NaN)                                           // 'NaN'
@ -136,7 +163,7 @@ y = new Decimal(Infinity)                                      // 'Infinity'
 x.isNaN() && !y.isNaN() && !x.isFinite() && !y.isFinite()      // true
 ```

-and a `toFraction` method with an optional *maximum denominator* argument
+There is also a `toFraction` method with an optional *maximum denominator* argument.

 ```js
 z = new Decimal(355)
@ -145,27 +172,27 @@ pi.toFraction()              // [ '7853982301', '2500000000' ]
 pi.toFraction(1000)          // [ '355', '113' ]
 ```

-All calculations are rounded according to the number of significant digits and rounding mode
-specified by the `precision` and `rounding` properties of the Decimal constructor.
+All calculations are rounded according to the number of significant digits and rounding mode specified
+by the `precision` and `rounding` properties of the Decimal constructor.

-Multiple Decimal constructors can be created, each with their own independent configuration which
-applies to all Decimal numbers created from it.
+For advanced usage, multiple Decimal constructors can be created, each with their own independent
+configuration which applies to all Decimal numbers created from it.

 ```js
 // Set the precision and rounding of the default Decimal constructor
 Decimal.set({ precision: 5, rounding: 4 })

 // Create another Decimal constructor, optionally passing in a configuration object
-Decimal10 = Decimal.clone({ precision: 10, rounding: 1 })
+Dec = Decimal.clone({ precision: 9, rounding: 1 })

 x = new Decimal(5)
-y = new Decimal10(5)
+y = new Dec(5)

 x.div(3)                           // '1.6667'
-y.div(3)                           // '1.666666666'
+y.div(3)                           // '1.66666666'
 ```

-The value of a Decimal is stored in a floating point format in terms of its digits, exponent and sign.
+The value of a Decimal is stored in a floating point format in terms of its digits, exponent and sign, but these properties should be considered read-only.

 ```js
 x = new Decimal(-12345.67);
@ -178,54 +205,42 @@ For further information see the [API](http://mikemcl.github.io/decimal.js/) refe

 ## Test

-The library can be tested using Node.js or a browser.
-
-The *test* directory contains the file *test.js* which runs all the tests when executed by Node,
-and the file *test.html* which runs all the tests when opened in a browser.
-
-To run all the tests, from a command-line at the root directory using npm
+To run the tests using Node.js from the root directory:

 ```bash
-$ npm test
+npm test
 ```

-or at the *test* directory using Node
+Each separate test module can also be executed individually, for example:

 ```bash
-$ node test
+node test/modules/toFraction
 ```

-Each separate test module can also be executed individually, for example, at the *test/modules* directory
+To run the tests in a browser, open *test/test.html*.

-```bash
-$ node toFraction
-```
+## Minify

-## Build
+Two minification examples:

-For Node, if [uglify-js](https://github.com/mishoo/UglifyJS2) is installed
+Using [uglify-js](https://github.com/mishoo/UglifyJS) to minify the *decimal.js* file:

 ```bash
 npm install uglify-js -g
+uglifyjs decimal.js --source-map url=decimal.min.js.map -c -m -o decimal.min.js
 ```

-then
+Using [terser](https://github.com/terser/terser) to minify the ES module version, *decimal.mjs*:

 ```bash
-npm run build
+npm install terser -g
+terser decimal.mjs --source-map url=decimal.min.mjs.map -c -m --toplevel -o decimal.min.mjs
 ```

-will create *decimal.min.js*, and a source map will also be added to the *doc* directory.
-
-
-## Feedback
-
-<a href='mailto:M8ch88l@gmail.com'>M8ch88l@gmail.com</a>
-
-**BTC** 16MjxmTB5EZxY5Uk9xyhfsu4n9gYxEJYkY
+```js
+import Decimal from './decimal.min.mjs';
+```

 ## Licence

-MIT.
-
-See *LICENCE.md*
+[The MIT Licence (Expat).](LICENCE.md)
--- a/bower.json
+++ b/bower.json
@ -1,33 +0,0 @@
-{
-  "name": "decimal.js",
-  "main": "decimal.js",
-  "version": "7.4.0",
-  "homepage": "https://github.com/MikeMcl/decimal.js",
-  "authors": [
-    "Michael Mclaughlin <M8ch88l@gmail.com>"
-  ],
-  "description": "An arbitrary-precision Decimal type for JavaScript",
-  "moduleType": [
-    "amd",
-    "globals",
-    "node"
-  ],
-  "keywords": [
-    "arbitrary",
-    "precision",
-    "arithmetic",
-    "bignumber",
-    "decimal",
-    "float",
-    "biginteger",
-    "bigdecimal",
-    "bignum",
-    "math"
-  ],
-  "license": "MIT",
-  "ignore": [
-    ".*",
-    "*.json",
-    "test"
-  ]
-}
--- a/decimal.d.ts
+++ b/decimal.d.ts
@ -7,35 +7,39 @@
 //
 // Exports:
 //
-//   class     Decimal (default)
+//   class     Decimal (default export)
 //   type      Decimal.Constructor
-//   type      Decimal.Value
-//   type      Decimal.Rounding
+//   type      Decimal.Instance
 //   type      Decimal.Modulo
+//   type      Decimal.Rounding
+//   type      Decimal.Value
 //   interface Decimal.Config
-//   interface Decimal.Format
 //
-// Example:
+// Example (alternative syntax commented-out):
 //
-//   import Decimal from "decimal.js"
+//   import {Decimal} from "decimal.js"
+//   //import Decimal from "decimal.js"
 //
 //   let r: Decimal.Rounding = Decimal.ROUND_UP;
 //   let c: Decimal.Configuration = {precision: 4, rounding: r};
 //   Decimal.set(c);
 //   let v: Decimal.Value = '12345.6789';
 //   let d: Decimal = new Decimal(v);
-
+//   //let d: Decimal.Instance = new Decimal(v);
+//
+// The use of compiler option `--strictNullChecks` is recommended.

 export default Decimal;

 export namespace Decimal {
  export type Constructor = typeof Decimal;
-  export type Value = string | number | Decimal;
+  export type Instance = Decimal;
  export type Rounding = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
  export type Modulo = Rounding | 9;
+  export type Value = string | number | Decimal;

  // http://mikemcl.github.io/decimal.js/#constructor-properties
-  export interface Configuration {
+  export interface Config {
    precision?: number;
    rounding?: Rounding;
    toExpNeg?: number;
@ -44,19 +48,7 @@ export namespace Decimal {
    maxE?: number;
    crypto?: boolean;
    modulo?: Modulo;
-
-    // Requires 'toFormat' <https://github.com/MikeMcl/toFormat>.
-    format?: Format;
-  }
-
-  // Requires 'toFormat'.
-  export interface Format {
-    decimalSeparator?: string;
-    groupSeparator?: string;
-    groupSize?: number;
-    secondaryGroupSize?: number;
-    fractionGroupSeparator?: string;
-    fractionGroupSize?: number;
+    defaults?: boolean;
  }
 }

@ -72,6 +64,9 @@ export declare class Decimal {

  ceil(): Decimal;
  
+  clampedTo(min: Decimal.Value, max: Decimal.Value): Decimal;
+  clamp(min: Decimal.Value, max: Decimal.Value): Decimal;
+
  comparedTo(n: Decimal.Value): number;
  cmp(n: Decimal.Value): number;

@ -187,8 +182,8 @@ export declare class Decimal {
  times(n: Decimal.Value): Decimal;
  mul(n: Decimal.Value) : Decimal;

-  toBinary(significantDigits?: number): Decimal;
-  toBinary(significantDigits: number, rounding: Decimal.Rounding): Decimal;
+  toBinary(significantDigits?: number): string;
+  toBinary(significantDigits: number, rounding: Decimal.Rounding): string;

  toDecimalPlaces(decimalPlaces?: number): Decimal;
  toDecimalPlaces(decimalPlaces: number, rounding: Decimal.Rounding): Decimal;
@ -201,15 +196,12 @@ export declare class Decimal {
  toFixed(decimalPlaces?: number): string;
  toFixed(decimalPlaces: number, rounding: Decimal.Rounding): string;

-  // Requires 'toFormat'.
-  toFormat?(decimalPlaces: number, rounding: Decimal.Rounding): string;
+  toFraction(max_denominator?: Decimal.Value): Decimal[];

-  toFraction(max_denominator?: Decimal.Value): string[];
-
-  toHexadecimal(significantDigits?: number): Decimal;
-  toHexadecimal(significantDigits: number, rounding: Decimal.Rounding): Decimal;
-  toHex(significantDigits?: number): Decimal;
-  toHex(significantDigits: number, rounding: Decimal.Rounding): Decimal;
+  toHexadecimal(significantDigits?: number): string;
+  toHexadecimal(significantDigits: number, rounding: Decimal.Rounding): string;
+  toHex(significantDigits?: number): string;
+  toHex(significantDigits: number, rounding?: Decimal.Rounding): string;

  toJSON(): string;

@ -217,8 +209,8 @@ export declare class Decimal {

  toNumber(): number;

-  toOctal(significantDigits?: number): Decimal;
-  toOctal(significantDigits: number, rounding: Decimal.Rounding): Decimal;
+  toOctal(significantDigits?: number): string;
+  toOctal(significantDigits: number, rounding: Decimal.Rounding): string;

  toPower(n: Decimal.Value): Decimal;
  pow(n: Decimal.Value): Decimal;
@ -249,41 +241,41 @@ export declare class Decimal {
  static atan2(y: Decimal.Value, x: Decimal.Value): Decimal;
  static cbrt(n: Decimal.Value): Decimal;
  static ceil(n: Decimal.Value): Decimal;
-  static clone(object?: Decimal.Configuration): Decimal.Constructor;
-  static config(object: Decimal.Configuration): Decimal.Constructor;
+  static clamp(n: Decimal.Value, min: Decimal.Value, max: Decimal.Value): Decimal;
+  static clone(object?: Decimal.Config): Decimal.Constructor;
+  static config(object: Decimal.Config): Decimal.Constructor;
  static cos(n: Decimal.Value): Decimal;
  static cosh(n: Decimal.Value): Decimal;
  static div(x: Decimal.Value, y: Decimal.Value): Decimal;
  static exp(n: Decimal.Value): Decimal;
  static floor(n: Decimal.Value): Decimal;
  static hypot(...n: Decimal.Value[]): Decimal;
+  static isDecimal(object: any): object is Decimal;
  static ln(n: Decimal.Value): Decimal;
-  static log(n: Decimal.Value, base?: number): Decimal;
+  static log(n: Decimal.Value, base?: Decimal.Value): Decimal;
  static log2(n: Decimal.Value): Decimal;
  static log10(n: Decimal.Value): Decimal;
  static max(...n: Decimal.Value[]): Decimal;
  static min(...n: Decimal.Value[]): Decimal;
  static mod(x: Decimal.Value, y: Decimal.Value): Decimal;
  static mul(x: Decimal.Value, y: Decimal.Value): Decimal;
-
-  // Browser only
-  static noConflict(): Decimal.Constructor;
-
+  static noConflict(): Decimal.Constructor;   // Browser only
  static pow(base: Decimal.Value, exponent: Decimal.Value): Decimal;
  static random(significantDigits?: number): Decimal;
  static round(n: Decimal.Value): Decimal;
-  static set(object: Decimal.Configuration): Decimal.Constructor;
-  static sign(n: Decimal.Value): Decimal;
+  static set(object: Decimal.Config): Decimal.Constructor;
+  static sign(n: Decimal.Value): number;
  static sin(n: Decimal.Value): Decimal;
  static sinh(n: Decimal.Value): Decimal;
  static sqrt(n: Decimal.Value): Decimal;
  static sub(x: Decimal.Value, y: Decimal.Value): Decimal;
+  static sum(...n: Decimal.Value[]): Decimal;
  static tan(n: Decimal.Value): Decimal;
  static tanh(n: Decimal.Value): Decimal;
  static trunc(n: Decimal.Value): Decimal;

-  static readonly default: Decimal.Constructor;
-  static readonly Decimal: Decimal.Constructor;
+  static readonly default?: Decimal.Constructor;
+  static readonly Decimal?: Decimal.Constructor;

  static readonly precision: number;
  static readonly rounding: Decimal.Rounding;
@ -294,9 +286,6 @@ export declare class Decimal {
  static readonly crypto: boolean;
  static readonly modulo: Decimal.Modulo;

-  // Requires 'toFormat'.
-  static readonly format?: Decimal.Format;
-
  static readonly ROUND_UP: 0;
  static readonly ROUND_DOWN: 1;
  static readonly ROUND_CEIL: 2;
--- a/decimal.global.d.ts
+++ b/decimal.global.d.ts
@ -0,0 +1,320 @@
+// Type definitions for decimal.js >=7.0.0
+// Project: https://github.com/MikeMcl/decimal.js
+// Definitions by: Michael Mclaughlin <https://github.com/MikeMcl>
+// Definitions: https://github.com/MikeMcl/decimal.js
+//
+// Documentation: http://mikemcl.github.io/decimal.js/
+//
+// Exports (available globally or when using import):
+//
+//   class     Decimal (default export)
+//   type      Decimal.Constructor
+//   type      Decimal.Instance
+//   type      Decimal.Modulo
+//   type      Decimal.Rounding
+//   type      Decimal.Value
+//   interface Decimal.Config
+//
+// Example (alternative syntax commented-out):
+//
+//   import {Decimal} from "decimal.js"
+//   //import Decimal from "decimal.js"
+//
+//   let r: Decimal.Rounding = Decimal.ROUND_UP;
+//   let c: Decimal.Configuration = {precision: 4, rounding: r};
+//   Decimal.set(c);
+//   let v: Decimal.Value = '12345.6789';
+//   let d: Decimal = new Decimal(v);
+//   //let d: Decimal.Instance = new Decimal(v);
+//
+// The use of compiler option `--strictNullChecks` is recommended.
+
+export default Decimal;
+
+export namespace Decimal {
+  export type Config = DecimalConfig;
+  export type Constructor = DecimalConstructor;
+  export type Instance = DecimalInstance;
+  export type Modulo = DecimalModulo;
+  export type Rounding = DecimalRounding;
+  export type Value = DecimalValue;
+}
+
+declare global {
+  const Decimal: DecimalConstructor;
+  type Decimal = DecimalInstance;
+
+  namespace Decimal {
+    type Config = DecimalConfig;
+    type Constructor = DecimalConstructor;
+    type Instance = DecimalInstance;
+    type Modulo = DecimalModulo;
+    type Rounding = DecimalRounding;
+    type Value = DecimalValue;
+  }
+}
+
+type DecimalInstance = Decimal;
+type DecimalConstructor = typeof Decimal;
+type DecimalValue = string | number | Decimal;
+type DecimalRounding = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+type DecimalModulo = DecimalRounding | 9;
+
+// http://mikemcl.github.io/decimal.js/#constructor-properties
+interface DecimalConfig {
+  precision?: number;
+  rounding?: DecimalRounding;
+  toExpNeg?: number;
+  toExpPos?: number;
+  minE?: number;
+  maxE?: number;
+  crypto?: boolean;
+  modulo?: DecimalModulo;
+  defaults?: boolean;
+}
+
+export declare class Decimal {
+  readonly d: number[];
+  readonly e: number;
+  readonly s: number;
+
+  constructor(n: DecimalValue);
+
+  absoluteValue(): Decimal;
+  abs(): Decimal;
+
+  ceil(): Decimal;
+  
+  clampedTo(min: Decimal.Value, max: Decimal.Value): Decimal;
+  clamp(min: Decimal.Value, max: Decimal.Value): Decimal;
+
+  comparedTo(n: DecimalValue): number;
+  cmp(n: DecimalValue): number;
+
+  cosine(): Decimal;
+  cos(): Decimal;
+
+  cubeRoot(): Decimal;
+  cbrt(): Decimal;
+
+  decimalPlaces(): number;
+  dp(): number;
+
+  dividedBy(n: DecimalValue): Decimal;
+  div(n: DecimalValue): Decimal;
+
+  dividedToIntegerBy(n: DecimalValue): Decimal;
+  divToInt(n: DecimalValue): Decimal;
+
+  equals(n: DecimalValue): boolean;
+  eq(n: DecimalValue): boolean;
+
+  floor(): Decimal;
+
+  greaterThan(n: DecimalValue): boolean;
+  gt(n: DecimalValue): boolean;
+
+  greaterThanOrEqualTo(n: DecimalValue): boolean;
+  gte(n: DecimalValue): boolean;
+
+  hyperbolicCosine(): Decimal;
+  cosh(): Decimal;
+
+  hyperbolicSine(): Decimal;
+  sinh(): Decimal;
+
+  hyperbolicTangent(): Decimal;
+  tanh(): Decimal;
+
+  inverseCosine(): Decimal;
+  acos(): Decimal;
+
+  inverseHyperbolicCosine(): Decimal;
+  acosh(): Decimal;
+
+  inverseHyperbolicSine(): Decimal;
+  asinh(): Decimal;
+
+  inverseHyperbolicTangent(): Decimal;
+  atanh(): Decimal;
+
+  inverseSine(): Decimal;
+  asin(): Decimal;
+
+  inverseTangent(): Decimal;
+  atan(): Decimal;
+
+  isFinite(): boolean;
+
+  isInteger(): boolean;
+  isInt(): boolean;
+
+  isNaN(): boolean;
+
+  isNegative(): boolean;
+  isNeg(): boolean;
+
+  isPositive(): boolean;
+  isPos(): boolean;
+
+  isZero(): boolean;
+
+  lessThan(n: DecimalValue): boolean;
+  lt(n: DecimalValue): boolean;
+
+  lessThanOrEqualTo(n: DecimalValue): boolean;
+  lte(n: DecimalValue): boolean;
+
+  logarithm(n?: DecimalValue): Decimal;
+  log(n?: DecimalValue): Decimal;
+
+  minus(n: DecimalValue): Decimal;
+  sub(n: DecimalValue): Decimal;
+
+  modulo(n: DecimalValue): Decimal;
+  mod(n: DecimalValue): Decimal;
+
+  naturalExponential(): Decimal;
+  exp(): Decimal;
+
+  naturalLogarithm(): Decimal;
+  ln(): Decimal;
+
+  negated(): Decimal;
+  neg(): Decimal;
+
+  plus(n: DecimalValue): Decimal;
+  add(n: DecimalValue): Decimal;
+
+  precision(includeZeros?: boolean): number;
+  sd(includeZeros?: boolean): number;
+
+  round(): Decimal;
+
+  sine() : Decimal;
+  sin() : Decimal;
+
+  squareRoot(): Decimal;
+  sqrt(): Decimal;
+
+  tangent() : Decimal;
+  tan() : Decimal;
+
+  times(n: DecimalValue): Decimal;
+  mul(n: DecimalValue) : Decimal;
+
+  toBinary(significantDigits?: number): string;
+  toBinary(significantDigits: number, rounding: DecimalRounding): string;
+
+  toDecimalPlaces(decimalPlaces?: number): Decimal;
+  toDecimalPlaces(decimalPlaces: number, rounding: DecimalRounding): Decimal;
+  toDP(decimalPlaces?: number): Decimal;
+  toDP(decimalPlaces: number, rounding: DecimalRounding): Decimal;
+
+  toExponential(decimalPlaces?: number): string;
+  toExponential(decimalPlaces: number, rounding: DecimalRounding): string;
+
+  toFixed(decimalPlaces?: number): string;
+  toFixed(decimalPlaces: number, rounding: DecimalRounding): string;
+
+  toFraction(max_denominator?: DecimalValue): Decimal[];
+
+  toHexadecimal(significantDigits?: number): string;
+  toHexadecimal(significantDigits: number, rounding: DecimalRounding): string;
+  toHex(significantDigits?: number): string;
+  toHex(significantDigits: number, rounding?: DecimalRounding): string;
+
+  toJSON(): string;
+
+  toNearest(n: DecimalValue, rounding?: DecimalRounding): Decimal;
+
+  toNumber(): number;
+
+  toOctal(significantDigits?: number): string;
+  toOctal(significantDigits: number, rounding: DecimalRounding): string;
+
+  toPower(n: DecimalValue): Decimal;
+  pow(n: DecimalValue): Decimal;
+
+  toPrecision(significantDigits?: number): string;
+  toPrecision(significantDigits: number, rounding: DecimalRounding): string;
+
+  toSignificantDigits(significantDigits?: number): Decimal;
+  toSignificantDigits(significantDigits: number, rounding: DecimalRounding): Decimal;
+  toSD(significantDigits?: number): Decimal;
+  toSD(significantDigits: number, rounding: DecimalRounding): Decimal;
+
+  toString(): string;
+
+  truncated(): Decimal;
+  trunc(): Decimal;
+
+  valueOf(): string;
+
+  static abs(n: DecimalValue): Decimal;
+  static acos(n: DecimalValue): Decimal;
+  static acosh(n: DecimalValue): Decimal;
+  static add(x: DecimalValue, y: DecimalValue): Decimal;
+  static asin(n: DecimalValue): Decimal;
+  static asinh(n: DecimalValue): Decimal;
+  static atan(n: DecimalValue): Decimal;
+  static atanh(n: DecimalValue): Decimal;
+  static atan2(y: DecimalValue, x: DecimalValue): Decimal;
+  static cbrt(n: DecimalValue): Decimal;
+  static ceil(n: DecimalValue): Decimal;
+  static clamp(n: Decimal.Value, min: Decimal.Value, max: Decimal.Value): Decimal;
+  static clone(object?: DecimalConfig): DecimalConstructor;
+  static config(object: DecimalConfig): DecimalConstructor;
+  static cos(n: DecimalValue): Decimal;
+  static cosh(n: DecimalValue): Decimal;
+  static div(x: DecimalValue, y: DecimalValue): Decimal;
+  static exp(n: DecimalValue): Decimal;
+  static floor(n: DecimalValue): Decimal;
+  static hypot(...n: DecimalValue[]): Decimal;
+  static isDecimal(object: any): object is Decimal;
+  static ln(n: DecimalValue): Decimal;
+  static log(n: DecimalValue, base?: DecimalValue): Decimal;
+  static log2(n: DecimalValue): Decimal;
+  static log10(n: DecimalValue): Decimal;
+  static max(...n: DecimalValue[]): Decimal;
+  static min(...n: DecimalValue[]): Decimal;
+  static mod(x: DecimalValue, y: DecimalValue): Decimal;
+  static mul(x: DecimalValue, y: DecimalValue): Decimal;
+  static noConflict(): DecimalConstructor;   // Browser only
+  static pow(base: DecimalValue, exponent: DecimalValue): Decimal;
+  static random(significantDigits?: number): Decimal;
+  static round(n: DecimalValue): Decimal;
+  static set(object: DecimalConfig): DecimalConstructor;
+  static sign(n: DecimalValue): number;
+  static sin(n: DecimalValue): Decimal;
+  static sinh(n: DecimalValue): Decimal;
+  static sqrt(n: DecimalValue): Decimal;
+  static sub(x: DecimalValue, y: DecimalValue): Decimal;
+  static sum(...n: Decimal.Value[]): Decimal;
+  static tan(n: DecimalValue): Decimal;
+  static tanh(n: DecimalValue): Decimal;
+  static trunc(n: DecimalValue): Decimal;
+
+  static readonly default?: DecimalConstructor;
+  static readonly Decimal?: DecimalConstructor;
+
+  static readonly precision: number;
+  static readonly rounding: DecimalRounding;
+  static readonly toExpNeg: number;
+  static readonly toExpPos: number;
+  static readonly minE: number;
+  static readonly maxE: number;
+  static readonly crypto: boolean;
+  static readonly modulo: DecimalModulo;
+
+  static readonly ROUND_UP: 0;
+  static readonly ROUND_DOWN: 1;
+  static readonly ROUND_CEIL: 2;
+  static readonly ROUND_FLOOR: 3;
+  static readonly ROUND_HALF_UP: 4;
+  static readonly ROUND_HALF_DOWN: 5;
+  static readonly ROUND_HALF_EVEN: 6;
+  static readonly ROUND_HALF_CEIL: 7;
+  static readonly ROUND_HALF_FLOOR: 8;
+  static readonly EUCLID: 9;
+}
--- a/decimal.js
+++ b/decimal.js
@ -1,13 +1,12 @@
-/*! decimal.js v7.4.0 https://github.com/MikeMcl/decimal.js/LICENCE */
 ;(function (globalScope) {
  'use strict';


-  /*
-   *  decimal.js v7.4.0
+  /*!
+   *  decimal.js v10.4.3
   *  An arbitrary-precision Decimal type for JavaScript.
   *  https://github.com/MikeMcl/decimal.js
-   *  Copyright (c) 2017 Michael Mclaughlin <M8ch88l@gmail.com>
+   *  Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>
   *  MIT Licence
   */

@ -34,7 +33,7 @@


    // The initial configuration properties of the Decimal constructor.
-    Decimal = {
+    DEFAULTS = {

      // These values must be integers within the stated ranges (inclusive).
      // Most of these values can be changed at run-time using the `Decimal.config` method.
@ -99,13 +98,14 @@
  // ----------------------------------- END OF EDITABLE DEFAULTS ------------------------------- //


-    inexact, noConflict, quadrant,
+    Decimal, inexact, noConflict, quadrant,
    external = true,

    decimalError = '[DecimalError] ',
    invalidArgument = decimalError + 'Invalid argument: ',
    precisionLimitExceeded = decimalError + 'Precision limit exceeded',
    cryptoUnavailable = decimalError + 'crypto unavailable',
+    tag = '[object Decimal]',

    mathfloor = Math.floor,
    mathpow = Math.pow,
@ -123,7 +123,7 @@
    PI_PRECISION = PI.length - 1,

    // Decimal.prototype object
-    P = {};
+    P = { toStringTag: tag };


  // Decimal prototype methods
@ -132,6 +132,7 @@
  /*
   *  absoluteValue             abs
   *  ceil
+   *  clampedTo                 clamp
   *  comparedTo                cmp
   *  cosine                    cos
   *  cubeRoot                  cbrt
@ -213,6 +214,27 @@
  };


+  /*
+   * Return a new Decimal whose value is the value of this Decimal clamped to the range
+   * delineated by `min` and `max`.
+   *
+   * min {number|string|Decimal}
+   * max {number|string|Decimal}
+   *
+   */
+  P.clampedTo = P.clamp = function (min, max) {
+    var k,
+      x = this,
+      Ctor = x.constructor;
+    min = new Ctor(min);
+    max = new Ctor(max);
+    if (!min.s || !max.s) return new Ctor(NaN);
+    if (min.gt(max)) throw Error(invalidArgument + max);
+    k = x.cmp(min);
+    return k < 0 ? min : x.cmp(max) > 0 ? max : new Ctor(x);
+  };
+
+
  /*
   * Return
   *   1    if the value of this Decimal is greater than the value of `y`,
@ -318,7 +340,7 @@
    external = false;

    // Initial estimate.
-    s = x.s * Math.pow(x.s * x, 1 / 3);
+    s = x.s * mathpow(x.s * x, 1 / 3);

     // Math.cbrt underflow/overflow?
     // Pass x to Math.pow as integer, then adjust the exponent of the result.
@ -328,7 +350,7 @@

      // Adjust n exponent so it is a multiple of 3 away from x exponent.
      if (s = (e - n.length + 1) % 3) n += (s == 1 || s == -2 ? '0' : '00');
-      s = Math.pow(n, 1 / 3);
+      s = mathpow(n, 1 / 3);

      // Rarely, e may be one less than the result exponent value.
      e = mathfloor((e + 1) / 3) - (e % 3 == (e < 0 ? -1 : 2));
@ -547,7 +569,7 @@
    // TODO? Estimation reused from cosine() and may not be optimal here.
    if (len < 32) {
      k = Math.ceil(len / 3);
-      n = Math.pow(4, -k).toString();
+      n = (1 / tinyPow(4, k)).toString();
    } else {
      k = 16;
      n = '2.3283064365386962890625e-10';
@ -627,8 +649,7 @@
      k = 1.4 * Math.sqrt(len);
      k = k > 16 ? 16 : k | 0;

-      x = x.times(Math.pow(5, -k));
-
+      x = x.times(1 / tinyPow(5, k));
      x = taylorSeries(Ctor, 2, x, x, true);

      // Reverse argument reduction
@ -1730,7 +1751,7 @@
      e = mathfloor((e + 1) / 2) - (e < 0 || e % 2);

      if (s == 1 / 0) {
-        n = '1e' + e;
+        n = '5e' + e;
      } else {
        n = s.toExponential();
        n = n.slice(0, n.indexOf('e') + 1) + e;
@ -2112,16 +2133,9 @@
  };


-
  /*
-   * Returns a new Decimal whose value is the nearest multiple of the magnitude of `y` to the value
-   * of this Decimal.
-   *
-   * If the value of this Decimal is equidistant from two multiples of `y`, the rounding mode `rm`,
-   * or `Decimal.rounding` if `rm` is omitted, determines the direction of the nearest multiple.
-   *
-   * In the context of this method, rounding mode 4 (ROUND_HALF_UP) is the same as rounding mode 0
-   * (ROUND_UP), and so on.
+   * Returns a new Decimal whose value is the nearest multiple of `y` in the direction of rounding
+   * mode `rm`, or `Decimal.rounding` if `rm` is omitted, to the value of this Decimal.
   *
   * The return value will always have the same sign as this Decimal, unless either this Decimal
   * or `y` is NaN, in which case the return value will be also be NaN.
@ -2150,7 +2164,11 @@
      rm = Ctor.rounding;
    } else {
      y = new Ctor(y);
-      if (rm !== void 0) checkInt32(rm, 0, 8);
+      if (rm === void 0) {
+        rm = Ctor.rounding;
+      } else {
+        checkInt32(rm, 0, 8);
+      }

      // If x is not finite, return x if y is not NaN, else NaN.
      if (!x.d) return y.s ? x : y;
@ -2165,7 +2183,6 @@
    // If y is not zero, calculate the nearest multiple of y to x.
    if (y.d[0]) {
      external = false;
-      if (rm < 4) rm = [4, 5, 7, 8][rm];
      x = divide(x, y, 0, rm, 1).times(y);
      external = true;
      finalise(x);
@ -2451,18 +2468,6 @@
  };


-  /*
-  // Add aliases to match BigDecimal method names.
-  // P.add = P.plus;
-  P.subtract = P.minus;
-  P.multiply = P.times;
-  P.divide = P.div;
-  P.remainder = P.mod;
-  P.compareTo = P.cmp;
-  P.negate = P.neg;
-   */
-
-
  // Helper functions for Decimal.prototype (P) and/or Decimal methods, and their callers.


@ -2634,16 +2639,18 @@
   *
   */
  function cosine(Ctor, x) {
-    var k, y,
-      len = x.d.length;
+    var k, len, y;
+
+    if (x.isZero()) return x;

    // Argument reduction: cos(4x) = 8*(cos^4(x) - cos^2(x)) + 1
    // i.e. cos(x) = 8*(cos^4(x/4) - cos^2(x/4)) + 1

    // Estimate the optimum number of times to use the argument reduction.
+    len = x.d.length;
    if (len < 32) {
      k = Math.ceil(len / 3);
-      y = Math.pow(4, -k).toString();
+      y = (1 / tinyPow(4, k)).toString();
    } else {
      k = 16;
      y = '2.3283064365386962890625e-10';
@ -3592,7 +3599,10 @@
  function parseOther(x, str) {
    var base, Ctor, divisor, i, isFloat, len, p, xd, xe;

-    if (str === 'Infinity' || str === 'NaN') {
+    if (str.indexOf('_') > -1) {
+      str = str.replace(/(\d)_(?=\d)/g, '$1');
+      if (isDecimal.test(str)) return parseDecimal(x, str);
+    } else if (str === 'Infinity' || str === 'NaN') {
      if (!+str) x.s = NaN;
      x.e = NaN;
      x.d = null;
@ -3654,7 +3664,7 @@
    if (isFloat) x = divide(x, divisor, len * 4);

    // Multiply by the binary exponent part if present.
-    if (p) x = x.times(Math.abs(p) < 54 ? Math.pow(2, p) : Decimal.pow(2, p));
+    if (p) x = x.times(Math.abs(p) < 54 ? mathpow(2, p) : Decimal.pow(2, p));
    external = true;

    return x;
@ -3670,7 +3680,9 @@
    var k,
      len = x.d.length;

-    if (len < 3) return taylorSeries(Ctor, 2, x, x);
+    if (len < 3) {
+      return x.isZero() ? x : taylorSeries(Ctor, 2, x, x);
+    }

    // Argument reduction: sin(5x) = 16*sin^5(x) - 20*sin^3(x) + 5*sin(x)
    // i.e. sin(x) = 16*sin^5(x/5) - 20*sin^3(x/5) + 5*sin(x/5)
@ -3680,8 +3692,7 @@
    k = 1.4 * Math.sqrt(len);
    k = k > 16 ? 16 : k | 0;

-    // Max k before Math.pow precision loss is 22
-    x = x.times(Math.pow(5, -k));
+    x = x.times(1 / tinyPow(5, k));
    x = taylorSeries(Ctor, 2, x, x);

    // Reverse argument reduction
@ -3734,6 +3745,14 @@
  }


+  // Exponent e must be positive and non-zero.
+  function tinyPow(b, e) {
+    var n = b;
+    while (--e) n *= b;
+    return n;
+  }
+
+
  // Return the absolute value of `x` reduced to less than or equal to half pi.
  function toLessThanHalfPi(Ctor, x) {
    var t,
@ -3929,6 +3948,7 @@
   *  atan2
   *  cbrt
   *  ceil
+   *  clamp
   *  clone
   *  config
   *  cos
@ -3954,6 +3974,7 @@
   *  sinh
   *  sqrt
   *  sub
+   *  sum
   *  tan
   *  tanh
   *  trunc
@ -4147,6 +4168,19 @@
  }


+  /*
+   * Return a new Decimal whose value is `x` clamped to the range delineated by `min` and `max`.
+   *
+   * x {number|string|Decimal}
+   * min {number|string|Decimal}
+   * max {number|string|Decimal}
+   *
+   */
+  function clamp(x, min, max) {
+    return new this(x).clamp(min, max);
+  }
+
+
  /*
   * Configure global settings for a Decimal constructor.
   *
@ -4160,6 +4194,7 @@
   *   minE       {number}
   *   modulo     {number}
   *   crypto     {boolean|number}
+   *   defaults   {true}
   *
   * E.g. Decimal.config({ precision: 20, rounding: 4 })
   *
@ -4167,6 +4202,7 @@
  function config(obj) {
    if (!obj || typeof obj !== 'object') throw Error(decimalError + 'Object expected');
    var i, p, v,
+      useDefaults = obj.defaults === true,
      ps = [
        'precision', 1, MAX_DIGITS,
        'rounding', 0, 8,
@ -4178,13 +4214,15 @@
      ];

    for (i = 0; i < ps.length; i += 3) {
-      if ((v = obj[p = ps[i]]) !== void 0) {
+      if (p = ps[i], useDefaults) this[p] = DEFAULTS[p];
+      if ((v = obj[p]) !== void 0) {
        if (mathfloor(v) === v && v >= ps[i + 1] && v <= ps[i + 2]) this[p] = v;
        else throw Error(invalidArgument + p + ': ' + v);
      }
    }

-    if ((v = obj[p = 'crypto']) !== void 0) {
+    if (p = 'crypto', useDefaults) this[p] = DEFAULTS[p];
+    if ((v = obj[p]) !== void 0) {
      if (v === true || v === false || v === 0 || v === 1) {
        if (v) {
          if (typeof crypto != 'undefined' && crypto &&
@ -4256,10 +4294,29 @@
      x.constructor = Decimal;

      // Duplicate.
-      if (v instanceof Decimal) {
+      if (isDecimalInstance(v)) {
        x.s = v.s;
+
+        if (external) {
+          if (!v.d || v.e > Decimal.maxE) {
+
+            // Infinity.
+            x.e = NaN;
+            x.d = null;
+          } else if (v.e < Decimal.minE) {
+
+            // Zero.
+            x.e = 0;
+            x.d = [0];
+          } else {
            x.e = v.e;
-        x.d = (v = v.d) ? v.slice() : v;
+            x.d = v.d.slice();
+          }
+        } else {
+          x.e = v.e;
+          x.d = v.d ? v.d.slice() : v.d;
+        }
+
        return;
      }

@ -4283,8 +4340,23 @@
        // Fast path for small integers.
        if (v === ~~v && v < 1e7) {
          for (e = 0, i = v; i >= 10; i /= 10) e++;
+
+          if (external) {
+            if (e > Decimal.maxE) {
+              x.e = NaN;
+              x.d = null;
+            } else if (e < Decimal.minE) {
+              x.e = 0;
+              x.d = [0];
+            } else {
              x.e = e;
              x.d = [v];
+            }
+          } else {
+            x.e = e;
+            x.d = [v];
+          }
+
          return;

        // Infinity, NaN.
@ -4302,10 +4374,12 @@
      }

      // Minus sign?
-      if (v.charCodeAt(0) === 45) {
+      if ((i = v.charCodeAt(0)) === 45) {
        v = v.slice(1);
        x.s = -1;
      } else {
+        // Plus sign?
+        if (i === 43) v = v.slice(1);
        x.s = 1;
      }

@ -4327,6 +4401,7 @@

    Decimal.config = Decimal.set = config;
    Decimal.clone = clone;
+    Decimal.isDecimal = isDecimalInstance;

    Decimal.abs = abs;
    Decimal.acos = acos;
@ -4339,6 +4414,7 @@
    Decimal.atan2 = atan2;
    Decimal.cbrt = cbrt;          // ES6
    Decimal.ceil = ceil;
+    Decimal.clamp = clamp;
    Decimal.cos = cos;
    Decimal.cosh = cosh;          // ES6
    Decimal.div = div;
@ -4361,15 +4437,18 @@
    Decimal.sinh = sinh;          // ES6
    Decimal.sqrt = sqrt;
    Decimal.sub = sub;
+    Decimal.sum = sum;
    Decimal.tan = tan;
    Decimal.tanh = tanh;          // ES6
    Decimal.trunc = trunc;        // ES6

    if (obj === void 0) obj = {};
    if (obj) {
+      if (obj.defaults !== true) {
        ps = ['precision', 'rounding', 'toExpNeg', 'toExpPos', 'maxE', 'minE', 'modulo', 'crypto'];
        for (i = 0; i < ps.length;) if (!obj.hasOwnProperty(p = ps[i++])) obj[p] = this[p];
      }
+    }

    Decimal.config(obj);

@ -4419,6 +4498,8 @@
   *
   * hypot(a, b, ...) = sqrt(a^2 + b^2 + ...)
   *
+   * arguments {number|string|Decimal}
+   *
   */
  function hypot() {
    var i, n,
@ -4445,6 +4526,16 @@
  }


+  /*
+   * Return true if object is a Decimal instance (where Decimal is any Decimal constructor),
+   * otherwise return false.
+   *
+   */
+  function isDecimalInstance(obj) {
+    return obj instanceof Decimal || obj && obj.toStringTag === tag || false;
+  }
+
+
  /*
   * Return a new Decimal whose value is the natural logarithm of `x`, rounded to `precision`
   * significant digits using rounding mode `rounding`.
@ -4683,6 +4774,8 @@
   *  -0    if x is -0,
   *   NaN  otherwise
   *
+   * x {number|string|Decimal}
+   *
   */
  function sign(x) {
    x = new this(x);
@ -4739,6 +4832,28 @@
  }


+  /*
+   * Return a new Decimal whose value is the sum of the arguments, rounded to `precision`
+   * significant digits using rounding mode `rounding`.
+   *
+   * Only the result is rounded, not the intermediate calculations.
+   *
+   * arguments {number|string|Decimal}
+   *
+   */
+  function sum() {
+    var i = 0,
+      args = arguments,
+      x = new this(args[i]);
+
+    external = false;
+    for (; x.s && ++i < args.length;) x = x.plus(args[i]);
+    external = true;
+
+    return finalise(x, this.precision, this.rounding);
+  }
+
+
  /*
   * Return a new Decimal whose value is the tangent of `x`, rounded to `precision` significant
   * digits using rounding mode `rounding`.
@ -4775,8 +4890,8 @@


  // Create and configure initial Decimal constructor.
-  Decimal = clone(Decimal);
-
+  Decimal = clone(DEFAULTS);
+  Decimal.prototype.constructor = Decimal;
  Decimal['default'] = Decimal.Decimal = Decimal;

  // Create the internal constants from their string values.
@ -4795,13 +4910,17 @@

  // Node and other environments that support module.exports.
  } else if (typeof module != 'undefined' && module.exports) {
+    if (typeof Symbol == 'function' && typeof Symbol.iterator == 'symbol') {
+      P[Symbol['for']('nodejs.util.inspect.custom')] = P.toString;
+      P[Symbol.toStringTag] = 'Decimal';
+    }
+
    module.exports = Decimal;

  // Browser.
  } else {
    if (!globalScope) {
-      globalScope = typeof self != 'undefined' && self && self.self == self
-        ? self : Function('return this')();
+      globalScope = typeof self != 'undefined' && self && self.self == self ? self : window;
    }

    noConflict = globalScope.Decimal;
--- a/decimal.min.js
+++ b/decimal.min.js
--- a/decimal.mjs
+++ b/decimal.mjs
@ -1,12 +1,9 @@
-/*
- *
- *  decimal.js v7.4.0
+/*!
+ *  decimal.js v10.4.3
 *  An arbitrary-precision Decimal type for JavaScript.
 *  https://github.com/MikeMcl/decimal.js
- *  Copyright (c) 2017 Michael Mclaughlin <M8ch88l@gmail.com>
+ *  Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>
 *  MIT Licence
- *  https://github.com/MikeMcl/decimal.js/LICENCE
- *
 */


@ -25,14 +22,14 @@ var EXP_LIMIT = 9e15,                      // 0 to 9e15
  NUMERALS = '0123456789abcdef',

  // The natural logarithm of 10 (1025 digits).
-  ln10 = '2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058',
+  LN10 = '2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058',

  // Pi (1025 digits).
-  pi = '3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789',
+  PI = '3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789',


  // The initial configuration properties of the Decimal constructor.
-  defaults = {
+  DEFAULTS = {

    // These values must be integers within the stated ranges (inclusive).
    // Most of these values can be changed at run-time using the `Decimal.config` method.
@ -97,13 +94,14 @@ var EXP_LIMIT = 9e15,                      // 0 to 9e15
 // ----------------------------------- END OF EDITABLE DEFAULTS ------------------------------- //


-  Decimal, LN10, PI, inexact, quadrant,
+  inexact, quadrant,
  external = true,

  decimalError = '[DecimalError] ',
  invalidArgument = decimalError + 'Invalid argument: ',
  precisionLimitExceeded = decimalError + 'Precision limit exceeded',
  cryptoUnavailable = decimalError + 'crypto unavailable',
+  tag = '[object Decimal]',

  mathfloor = Math.floor,
  mathpow = Math.pow,
@ -117,11 +115,11 @@ var EXP_LIMIT = 9e15,                      // 0 to 9e15
  LOG_BASE = 7,
  MAX_SAFE_INTEGER = 9007199254740991,

-  LN10_PRECISION = ln10.length - 1,
-  PI_PRECISION = pi.length - 1,
+  LN10_PRECISION = LN10.length - 1,
+  PI_PRECISION = PI.length - 1,

  // Decimal.prototype object
-  P = {};
+  P = { toStringTag: tag };


 // Decimal prototype methods
@ -130,6 +128,7 @@ var EXP_LIMIT = 9e15,                      // 0 to 9e15
 /*
 *  absoluteValue             abs
 *  ceil
+ *  clampedTo                 clamp
 *  comparedTo                cmp
 *  cosine                    cos
 *  cubeRoot                  cbrt
@ -211,6 +210,27 @@ P.ceil = function () {
 };


+/*
+ * Return a new Decimal whose value is the value of this Decimal clamped to the range
+ * delineated by `min` and `max`.
+ *
+ * min {number|string|Decimal}
+ * max {number|string|Decimal}
+ *
+ */
+P.clampedTo = P.clamp = function (min, max) {
+  var k,
+    x = this,
+    Ctor = x.constructor;
+  min = new Ctor(min);
+  max = new Ctor(max);
+  if (!min.s || !max.s) return new Ctor(NaN);
+  if (min.gt(max)) throw Error(invalidArgument + max);
+  k = x.cmp(min);
+  return k < 0 ? min : x.cmp(max) > 0 ? max : new Ctor(x);
+};
+
+
 /*
 * Return
 *   1    if the value of this Decimal is greater than the value of `y`,
@ -316,7 +336,7 @@ P.cubeRoot = P.cbrt = function () {
  external = false;

  // Initial estimate.
-  s = x.s * Math.pow(x.s * x, 1 / 3);
+  s = x.s * mathpow(x.s * x, 1 / 3);

   // Math.cbrt underflow/overflow?
   // Pass x to Math.pow as integer, then adjust the exponent of the result.
@ -326,7 +346,7 @@ P.cubeRoot = P.cbrt = function () {

    // Adjust n exponent so it is a multiple of 3 away from x exponent.
    if (s = (e - n.length + 1) % 3) n += (s == 1 || s == -2 ? '0' : '00');
-    s = Math.pow(n, 1 / 3);
+    s = mathpow(n, 1 / 3);

    // Rarely, e may be one less than the result exponent value.
    e = mathfloor((e + 1) / 3) - (e % 3 == (e < 0 ? -1 : 2));
@ -545,7 +565,7 @@ P.hyperbolicCosine = P.cosh = function () {
  // TODO? Estimation reused from cosine() and may not be optimal here.
  if (len < 32) {
    k = Math.ceil(len / 3);
-    n = Math.pow(4, -k).toString();
+    n = (1 / tinyPow(4, k)).toString();
  } else {
    k = 16;
    n = '2.3283064365386962890625e-10';
@ -625,8 +645,7 @@ P.hyperbolicSine = P.sinh = function () {
    k = 1.4 * Math.sqrt(len);
    k = k > 16 ? 16 : k | 0;

-    x = x.times(Math.pow(5, -k));
-
+    x = x.times(1 / tinyPow(5, k));
    x = taylorSeries(Ctor, 2, x, x, true);

    // Reverse argument reduction
@ -1728,7 +1747,7 @@ P.squareRoot = P.sqrt = function () {
    e = mathfloor((e + 1) / 2) - (e < 0 || e % 2);

    if (s == 1 / 0) {
-      n = '1e' + e;
+      n = '5e' + e;
    } else {
      n = s.toExponential();
      n = n.slice(0, n.indexOf('e') + 1) + e;
@ -2110,16 +2129,9 @@ P.toHexadecimal = P.toHex = function (sd, rm) {
 };


-
 /*
- * Returns a new Decimal whose value is the nearest multiple of the magnitude of `y` to the value
- * of this Decimal.
- *
- * If the value of this Decimal is equidistant from two multiples of `y`, the rounding mode `rm`,
- * or `Decimal.rounding` if `rm` is omitted, determines the direction of the nearest multiple.
- *
- * In the context of this method, rounding mode 4 (ROUND_HALF_UP) is the same as rounding mode 0
- * (ROUND_UP), and so on.
+ * Returns a new Decimal whose value is the nearest multiple of `y` in the direction of rounding
+ * mode `rm`, or `Decimal.rounding` if `rm` is omitted, to the value of this Decimal.
 *
 * The return value will always have the same sign as this Decimal, unless either this Decimal
 * or `y` is NaN, in which case the return value will be also be NaN.
@ -2148,7 +2160,11 @@ P.toNearest = function (y, rm) {
    rm = Ctor.rounding;
  } else {
    y = new Ctor(y);
-    if (rm !== void 0) checkInt32(rm, 0, 8);
+    if (rm === void 0) {
+      rm = Ctor.rounding;
+    } else {
+      checkInt32(rm, 0, 8);
+    }

    // If x is not finite, return x if y is not NaN, else NaN.
    if (!x.d) return y.s ? x : y;
@ -2163,7 +2179,6 @@ P.toNearest = function (y, rm) {
  // If y is not zero, calculate the nearest multiple of y to x.
  if (y.d[0]) {
    external = false;
-    if (rm < 4) rm = [4, 5, 7, 8][rm];
    x = divide(x, y, 0, rm, 1).times(y);
    external = true;
    finalise(x);
@ -2449,18 +2464,6 @@ P.valueOf = P.toJSON = function () {
 };


-/*
-// Add aliases to match BigDecimal method names.
-// P.add = P.plus;
-P.subtract = P.minus;
-P.multiply = P.times;
-P.divide = P.div;
-P.remainder = P.mod;
-P.compareTo = P.cmp;
-P.negate = P.neg;
- */
-
-
 // Helper functions for Decimal.prototype (P) and/or Decimal methods, and their callers.


@ -2632,16 +2635,18 @@ function convertBase(str, baseIn, baseOut) {
 *
 */
 function cosine(Ctor, x) {
-  var k, y,
-    len = x.d.length;
+  var k, len, y;
+
+  if (x.isZero()) return x;

  // Argument reduction: cos(4x) = 8*(cos^4(x) - cos^2(x)) + 1
  // i.e. cos(x) = 8*(cos^4(x/4) - cos^2(x/4)) + 1

  // Estimate the optimum number of times to use the argument reduction.
+  len = x.d.length;
  if (len < 32) {
    k = Math.ceil(len / 3);
-    y = Math.pow(4, -k).toString();
+    y = (1 / tinyPow(4, k)).toString();
  } else {
    k = 16;
    y = '2.3283064365386962890625e-10';
@ -3590,7 +3595,10 @@ function parseDecimal(x, str) {
 function parseOther(x, str) {
  var base, Ctor, divisor, i, isFloat, len, p, xd, xe;

-  if (str === 'Infinity' || str === 'NaN') {
+  if (str.indexOf('_') > -1) {
+    str = str.replace(/(\d)_(?=\d)/g, '$1');
+    if (isDecimal.test(str)) return parseDecimal(x, str);
+  } else if (str === 'Infinity' || str === 'NaN') {
    if (!+str) x.s = NaN;
    x.e = NaN;
    x.d = null;
@ -3652,7 +3660,7 @@ function parseOther(x, str) {
  if (isFloat) x = divide(x, divisor, len * 4);

  // Multiply by the binary exponent part if present.
-  if (p) x = x.times(Math.abs(p) < 54 ? Math.pow(2, p) : Decimal.pow(2, p));
+  if (p) x = x.times(Math.abs(p) < 54 ? mathpow(2, p) : Decimal.pow(2, p));
  external = true;

  return x;
@ -3668,7 +3676,9 @@ function sine(Ctor, x) {
  var k,
    len = x.d.length;

-  if (len < 3) return taylorSeries(Ctor, 2, x, x);
+  if (len < 3) {
+    return x.isZero() ? x : taylorSeries(Ctor, 2, x, x);
+  }

  // Argument reduction: sin(5x) = 16*sin^5(x) - 20*sin^3(x) + 5*sin(x)
  // i.e. sin(x) = 16*sin^5(x/5) - 20*sin^3(x/5) + 5*sin(x/5)
@ -3678,8 +3688,7 @@ function sine(Ctor, x) {
  k = 1.4 * Math.sqrt(len);
  k = k > 16 ? 16 : k | 0;

-  // Max k before Math.pow precision loss is 22
-  x = x.times(Math.pow(5, -k));
+  x = x.times(1 / tinyPow(5, k));
  x = taylorSeries(Ctor, 2, x, x);

  // Reverse argument reduction
@ -3732,6 +3741,14 @@ function taylorSeries(Ctor, n, x, y, isHyperbolic) {
 }


+// Exponent e must be positive and non-zero.
+function tinyPow(b, e) {
+  var n = b;
+  while (--e) n *= b;
+  return n;
+}
+
+
 // Return the absolute value of `x` reduced to less than or equal to half pi.
 function toLessThanHalfPi(Ctor, x) {
  var t,
@ -3927,6 +3944,7 @@ function truncate(arr, len) {
 *  atan2
 *  cbrt
 *  ceil
+ *  clamp
 *  clone
 *  config
 *  cos
@ -3952,6 +3970,7 @@ function truncate(arr, len) {
 *  sinh
 *  sqrt
 *  sub
+ *  sum
 *  tan
 *  tanh
 *  trunc
@ -4145,6 +4164,19 @@ function ceil(x) {
 }


+/*
+ * Return a new Decimal whose value is `x` clamped to the range delineated by `min` and `max`.
+ *
+ * x {number|string|Decimal}
+ * min {number|string|Decimal}
+ * max {number|string|Decimal}
+ *
+ */
+function clamp(x, min, max) {
+  return new this(x).clamp(min, max);
+}
+
+
 /*
 * Configure global settings for a Decimal constructor.
 *
@ -4158,6 +4190,7 @@ function ceil(x) {
 *   minE       {number}
 *   modulo     {number}
 *   crypto     {boolean|number}
+ *   defaults   {true}
 *
 * E.g. Decimal.config({ precision: 20, rounding: 4 })
 *
@ -4165,6 +4198,7 @@ function ceil(x) {
 function config(obj) {
  if (!obj || typeof obj !== 'object') throw Error(decimalError + 'Object expected');
  var i, p, v,
+    useDefaults = obj.defaults === true,
    ps = [
      'precision', 1, MAX_DIGITS,
      'rounding', 0, 8,
@ -4176,13 +4210,15 @@ function config(obj) {
    ];

  for (i = 0; i < ps.length; i += 3) {
-    if ((v = obj[p = ps[i]]) !== void 0) {
+    if (p = ps[i], useDefaults) this[p] = DEFAULTS[p];
+    if ((v = obj[p]) !== void 0) {
      if (mathfloor(v) === v && v >= ps[i + 1] && v <= ps[i + 2]) this[p] = v;
      else throw Error(invalidArgument + p + ': ' + v);
    }
  }

-  if ((v = obj[p = 'crypto']) !== void 0) {
+  if (p = 'crypto', useDefaults) this[p] = DEFAULTS[p];
+  if ((v = obj[p]) !== void 0) {
    if (v === true || v === false || v === 0 || v === 1) {
      if (v) {
        if (typeof crypto != 'undefined' && crypto &&
@ -4254,10 +4290,29 @@ function clone(obj) {
    x.constructor = Decimal;

    // Duplicate.
-    if (v instanceof Decimal) {
+    if (isDecimalInstance(v)) {
      x.s = v.s;
+
+      if (external) {
+        if (!v.d || v.e > Decimal.maxE) {
+
+          // Infinity.
+          x.e = NaN;
+          x.d = null;
+        } else if (v.e < Decimal.minE) {
+
+          // Zero.
+          x.e = 0;
+          x.d = [0];
+        } else {
          x.e = v.e;
-      x.d = (v = v.d) ? v.slice() : v;
+          x.d = v.d.slice();
+        }
+      } else {
+        x.e = v.e;
+        x.d = v.d ? v.d.slice() : v.d;
+      }
+
      return;
    }

@ -4281,8 +4336,23 @@ function clone(obj) {
      // Fast path for small integers.
      if (v === ~~v && v < 1e7) {
        for (e = 0, i = v; i >= 10; i /= 10) e++;
+
+        if (external) {
+          if (e > Decimal.maxE) {
+            x.e = NaN;
+            x.d = null;
+          } else if (e < Decimal.minE) {
+            x.e = 0;
+            x.d = [0];
+          } else {
            x.e = e;
            x.d = [v];
+          }
+        } else {
+          x.e = e;
+          x.d = [v];
+        }
+
        return;

      // Infinity, NaN.
@ -4300,10 +4370,12 @@ function clone(obj) {
    }

    // Minus sign?
-    if (v.charCodeAt(0) === 45) {
+    if ((i = v.charCodeAt(0)) === 45) {
      v = v.slice(1);
      x.s = -1;
    } else {
+      // Plus sign?
+      if (i === 43) v = v.slice(1);
      x.s = 1;
    }

@ -4325,6 +4397,7 @@ function clone(obj) {

  Decimal.config = Decimal.set = config;
  Decimal.clone = clone;
+  Decimal.isDecimal = isDecimalInstance;

  Decimal.abs = abs;
  Decimal.acos = acos;
@ -4337,6 +4410,7 @@ function clone(obj) {
  Decimal.atan2 = atan2;
  Decimal.cbrt = cbrt;          // ES6
  Decimal.ceil = ceil;
+  Decimal.clamp = clamp;
  Decimal.cos = cos;
  Decimal.cosh = cosh;          // ES6
  Decimal.div = div;
@ -4359,15 +4433,18 @@ function clone(obj) {
  Decimal.sinh = sinh;          // ES6
  Decimal.sqrt = sqrt;
  Decimal.sub = sub;
+  Decimal.sum = sum;
  Decimal.tan = tan;
  Decimal.tanh = tanh;          // ES6
  Decimal.trunc = trunc;        // ES6

  if (obj === void 0) obj = {};
  if (obj) {
+    if (obj.defaults !== true) {
      ps = ['precision', 'rounding', 'toExpNeg', 'toExpPos', 'maxE', 'minE', 'modulo', 'crypto'];
      for (i = 0; i < ps.length;) if (!obj.hasOwnProperty(p = ps[i++])) obj[p] = this[p];
    }
+  }

  Decimal.config(obj);

@ -4417,6 +4494,8 @@ function floor(x) {
 *
 * hypot(a, b, ...) = sqrt(a^2 + b^2 + ...)
 *
+ * arguments {number|string|Decimal}
+ *
 */
 function hypot() {
  var i, n,
@ -4443,6 +4522,16 @@ function hypot() {
 }


+/*
+ * Return true if object is a Decimal instance (where Decimal is any Decimal constructor),
+ * otherwise return false.
+ *
+ */
+function isDecimalInstance(obj) {
+  return obj instanceof Decimal || obj && obj.toStringTag === tag || false;
+}
+
+
 /*
 * Return a new Decimal whose value is the natural logarithm of `x`, rounded to `precision`
 * significant digits using rounding mode `rounding`.
@ -4681,6 +4770,8 @@ function round(x) {
 *  -0    if x is -0,
 *   NaN  otherwise
 *
+ * x {number|string|Decimal}
+ *
 */
 function sign(x) {
  x = new this(x);
@ -4737,6 +4828,28 @@ function sub(x, y) {
 }


+/*
+ * Return a new Decimal whose value is the sum of the arguments, rounded to `precision`
+ * significant digits using rounding mode `rounding`.
+ *
+ * Only the result is rounded, not the intermediate calculations.
+ *
+ * arguments {number|string|Decimal}
+ *
+ */
+function sum() {
+  var i = 0,
+    args = arguments,
+    x = new this(args[i]);
+
+  external = false;
+  for (; x.s && ++i < args.length;) x = x.plus(args[i]);
+  external = true;
+
+  return finalise(x, this.precision, this.rounding);
+}
+
+
 /*
 * Return a new Decimal whose value is the tangent of `x`, rounded to `precision` significant
 * digits using rounding mode `rounding`.
@ -4772,13 +4885,14 @@ function trunc(x) {
 }


-// Create and configure initial Decimal constructor.
-Decimal = clone(defaults);
+P[Symbol.for('nodejs.util.inspect.custom')] = P.toString;
+P[Symbol.toStringTag] = 'Decimal';

-Decimal['default'] = Decimal.Decimal = Decimal;
+// Create and configure initial Decimal constructor.
+export var Decimal = P.constructor = clone(DEFAULTS);

 // Create the internal constants from their string values.
-LN10 = new Decimal(ln10);
-PI = new Decimal(pi);
+LN10 = new Decimal(LN10);
+PI = new Decimal(PI);

 export default Decimal;
--- a/doc/API.html
+++ b/doc/API.html
@ -76,6 +76,7 @@ li span{float:right;margin-right:10px;color:#c0c0c0}
      <li><a href="#Datan2"     >atan2</a></li>
      <li><a href="#Dcbrt"      >cbrt</a></li>
      <li><a href="#Dceil"      >ceil</a></li>
+      <li><a href="#Dclamp"     >clamp</a></li>
      <li><a href="#Dclone"     >clone</a></li>
      <li><a href="#Dcos"       >cos</a></li>
      <li><a href="#Dcosh"      >cosh</a></li>
@ -83,6 +84,7 @@ li span{float:right;margin-right:10px;color:#c0c0c0}
      <li><a href="#Dexp"       >exp</a></li>
      <li><a href="#Dfloor"     >floor</a></li>
      <li><a href="#Dhypot"     >hypot</a></li>
+      <li><a href="#DisDecimal" >isDecimal</a></li>
      <li><a href="#Dln"        >ln</a></li>
      <li><a href="#Dlog"       >log</a></li>
      <li><a href="#Dlog2"      >log2</a></li>
@ -101,6 +103,7 @@ li span{float:right;margin-right:10px;color:#c0c0c0}
      <li><a href="#Dsinh"      >sinh</a></li>
      <li><a href="#Dsqrt"      >sqrt</a></li>
      <li><a href="#Dsub"       >sub</a></li>
+      <li><a href="#Dsum"       >sum</a></li>
      <li><a href="#Dtan"       >tan</a></li>
      <li><a href="#Dtanh"      >tanh</a></li>
      <li><a href="#Dtrunc"     >trunc</a></li>
@ -136,6 +139,7 @@ li span{float:right;margin-right:10px;color:#c0c0c0}
      <li><a href="#abs"          >absoluteValue           </a><span>abs</span>     </li>
      <li><a href="#ceil"         >ceil                    </a>                     </li>
      <li><a href="#cmp"          >comparedTo              </a><span>cmp</span>     </li>
+      <li><a href="#clamp"        >clampedTo               </a><span>clamp</span>   </li>
      <li><a href="#cos"          >cosine                  </a><span>cos</span>     </li>
      <li><a href="#cbrt"         >cubeRoot                </a><span>cbrt</span>    </li>
      <li><a href="#dp"           >decimalPlaces           </a><span>dp</span>      </li>
@ -196,7 +200,7 @@ li span{float:right;margin-right:10px;color:#c0c0c0}
    <a href="#instance-properties">Properties</a>
    <ul>
      <li><a href="#digits"   >d</a><span>digits</span></li>
-      <li><a href="#exponent">e</a><span>exponent</span></li>
+      <li><a href="#exponent" >e</a><span>exponent</span></li>
      <li><a href="#sign"     >s</a><span>sign</span></li>
    </ul>

@ -297,6 +301,7 @@ new Decimal('0xff.8')                    // '255.5'

 new Decimal(0.046875)                    // '0.046875'
 new Decimal('0.046875000000')            // '0.046875'
+new Decimal('0.046_875_000_000')         // '0.046875'

 new Decimal(4.6875e-2)                   // '0.046875'
 new Decimal('468.75e-4')                 // '0.046875'
@ -435,6 +440,16 @@ a.equals(b)                    // true</pre>



+    <h5 id="Dclamp">clamp<code class='inset'>.clamp(min, max) <i>&rArr; Decimal</i></code></h5>
+    <p>
+      <code>min</code>: <i>number|string|Decimal</i><br />
+      <code>max</code>: <i>number|string|Decimal</i>
+    </p>
+    <p>See <code><a href='#clamp'>clampedTo</a></code>.</p>
+    <pre>Decimal.clamp(10.1, 0, 10)     // '10'</pre>
+
+
+
    <h5 id="Dclone">
      clone
      <code class='inset'>.clone([object]) <i>&rArr; Decimal constructor</i></code>
@ -446,24 +461,32 @@ a.equals(b)                    // true</pre>
      settings as <code>this</code> Decimal constructor if <code>object</code> is omitted.
    </p>
    <pre>Decimal.set({ precision: 5 })
-D9 = Decimal.clone({ precision: 9 })
+Decimal9 = Decimal.clone({ precision: 9 })

 a = new Decimal(1)
-b = new D9(1)
+b = new Decimal9(1)

 a.div(3)                           // 0.33333
 b.div(3)                           // 0.333333333

-// D9 = Decimal.clone({ precision: 9 }) is equivalent to:
-D9 = Decimal.clone()
-D9.set({ precision: 9 })</pre>
+// Decimal9 = Decimal.clone({ precision: 9 }) is equivalent to:
+Decimal9 = Decimal.clone()
+Decimal9.set({ precision: 9 })</pre>
+    <p>
+      If <code>object</code> has a <code>'defaults'</code> property with value <code>true</code>
+      then the new constructor will use the default configuration.
+    </p>
+    <pre>
+D1 = Decimal.clone({ defaults: true })
+
+// Use the defaults except for precision
+D2 = Decimal.clone({ defaults: true, precision: 50 })</pre>
    <p>
      It is not inefficient in terms of memory usage to use multiple Decimal constructors as
      functions are shared between them.
    </p>


-
    <h5 id="Dcos">cos<code class='inset'>.cos(x) <i>&rArr; Decimal</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>See <code><a href='#cos'>cosine</a></code>.</p>
@ -537,6 +560,22 @@ a.equals(b)                    // true</pre>



+    <h5 id="DisDecimal">
+      isDecimal<code class='inset'>.isDecimal(object) <i>&rArr; boolean</i></code>
+    </h5>
+    <p><code>object</code>: <i>any</i></p>
+    <p>
+      Returns <code>true</code> if <code>object</code> is a Decimal instance (where Decimal is any
+      Decimal constructor), or <code>false</code> if it is not.
+    </p>
+    <pre>a = new Decimal(1)
+b = {}
+a instanceof Decimal           // true
+Decimal.isDecimal(a)           // true
+Decimal.isDecimal(b)           // false</pre>
+
+
+
    <h5 id="Dlog">log<code class='inset'>.log(x [, base]) <i>&rArr; Decimal</i></code></h5>
    <p>
      <code>x</code>: <i>number|string|Decimal</i><br />
@ -576,7 +615,7 @@ a.equals(b)                    // true</pre>


    <h5 id="Dmax">
-      max<code class='inset'>.max([x [, y, ...]]) <i>&rArr; Decimal</i></code>
+      max<code class='inset'>.max(x [, y, ...]) <i>&rArr; Decimal</i></code>
    </h5>
    <p>
      <code>x</code>: <i>number|string|Decimal</i><br />
@ -588,7 +627,7 @@ a.equals(b)                    // true</pre>


    <h5 id="Dmin">
-      min<code class='inset'>.min([x [, y, ...]]) <i>&rArr; Decimal</i></code>
+      min<code class='inset'>.min(x [, y, ...]) <i>&rArr; Decimal</i></code>
    </h5>
    <p>
      <code>x</code>: <i>number|string|Decimal</i><br />
@ -720,6 +759,10 @@ a.equals(b)                    // true</pre>
      The values of the configuration object properties are checked for validity and then stored as
      equivalently-named properties of <code>this</code> Decimal constructor.
    </p>
+    <p>
+      If <code>object</code> has a <code>'defaults'</code> property with value <code>true</code>
+      then any unspecified properties will be reset to their default values.
+    </p>
    <p>Throws on an invalid <code>object</code> or configuration property value.</p>
    <pre>
 // Defaults
@ -732,7 +775,13 @@ Decimal.set({
    minE: -9e15,
    modulo: 1,
    crypto: false
-})</pre>
+})
+
+// Reset all properties to their default values
+Decimal.set({ defaults: true })
+
+// Set precision to 50 and all other properties to their default values
+Decimal.set({ precision: 50, defaults: true })</pre>
    <p>
      The properties of a Decimal constructor can also be set by direct assignment, but that will
      by-pass the validity checking that this method performs - this is not a problem if the user
@ -810,6 +859,25 @@ a.equals(b)                    // true</pre>



+    <h5 id="Dsum">sum<code class='inset'>.sum(x [, y, ...]) <i>&rArr; Decimal</i></code></h5>
+    <p>
+      <code>x</code>: <i>number|string|Decimal</i><br />
+      <code>y</code>: <i>number|string|Decimal</i>
+    </p>
+    <p>
+      Returns a new Decimal whose value is the sum of the <code>arguments</code>,
+      rounded to <a href='#precision'><code>precision</code></a> significant digits using
+      rounding mode <a href='#rounding'><code>rounding</code></a>.<br />
+      Only the result is rounded, not the intermediate summations.
+    </p>
+    <pre>
+x = 5
+y = '16'
+z = new Decimal(-11)
+Decimal.sum(x, y, z)           // '10'</pre>
+
+
+
    <h5 id="Dtan">tan<code class='inset'>.tan(x) <i>&rArr; Decimal</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <p>See <code><a href='#tan'>tangent</a></code>.</p>
@ -875,12 +943,18 @@ Decimal.precision = 0
      All functions which return a Decimal will round the return value to <code>precision</code>
      significant digits except <a href='#decimal'><code>Decimal</code></a>,
      <a href='#abs'><code>absoluteValue</code></a>,
-      <a href='#ceil'><code>ceil</code></a>, <a href='#floor'><code>floor</code></a>,
-      <a href='#neg'><code>negated</code></a>, <a href='#round'><code>round</code></a>,
+      <a href='#ceil'><code>ceil</code></a>,
+      <a href='#clamp'><code>clampedTo</code></a>,
+      <a href='#floor'><code>floor</code></a>,
+      <a href='#neg'><code>negated</code></a>,
+      <a href='#round'><code>round</code></a>,
      <a href='#toDP'><code>toDecimalPlaces</code></a>,
      <a href='#toNearest'><code>toNearest</code></a> and
      <a href='#trunc'><code>truncated</code></a>.
    </p>
+    <p>
+      See <code><a href='#Pi'>Pi</a></code> for the precision limit of the trigonometric methods.
+    </p>
    <pre>Decimal.set({ precision: 5 })
 Decimal.precision                  // 5</pre>

@ -935,7 +1009,7 @@ new Decimal('1e-500')              // '1e-500'
 new Decimal('9.9e-501')            // '0'

 Decimal.set({ minE: -3 })
-new Decimal(0.001)                 // '0.01'       e is -3
+new Decimal(0.001)                 // '0.001'       e is -3
 new Decimal(0.0001)                // '0'          e is -4</pre>
    <p>
      The smallest possible magnitude of a non-zero Decimal is <code>1e-9000000000000000</code>
@ -1206,6 +1280,28 @@ y.ceil()                      // '-1'</pre>



+    <h5 id="clamp">clampedTo<code class='inset'>.clamp(min, max) <i>&rArr; Decimal</i></code></h5>
+    <p>
+      <code>min</code>: <i>number|string|Decimal</i><br />
+      <code>max</code>: <i>number|string|Decimal</i>
+    </p>
+    <p>
+      Returns a new Decimal whose value is the value of this Decimal clamped to the range
+      delineated by <code>min</code> and <code>max</code>.
+    </p>
+    <p>
+      The return value is not affected by the value of the
+      <a href='#precision'><code>precision</code></a> setting.
+    </p>
+    <pre>
+x = new Decimal(5)
+min = new Decimal(100)
+max = new Decimal(Infinity)
+x.clampedTo(min, max)         // '100'
+x.clamp(-10, -0.1)            // '-0.1'</pre>
+
+
+
    <h5 id="cmp">comparedTo<code class='inset'>.cmp(x) <i>&rArr; number</i></code></h5>
    <p><code>x</code>: <i>number|string|Decimal</i></p>
    <table>
@ -1246,7 +1342,7 @@ y.cmp(NaN)                     // NaN</pre>
      Domain: [<code>-Infinity, Infinity</code>]<br />
      Range: [<code>-1, 1</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(0.25)
 x.cosine()                      // '0.96891242171064478414'
@ -1396,7 +1492,7 @@ new Decimal(1).gte(x)                    // true</pre>
      Domain: [<code>-Infinity, Infinity</code>]<br />
      Range: [<code>1, Infinity</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(1)
 x.hyperbolicCosine()                     // '1.5430806348152437785'
@ -1415,7 +1511,7 @@ y.cosh()                                 // '1.1276259652063807852'</pre>
      Domain: [<code>-Infinity, Infinity</code>]<br />
      Range: [<code>-Infinity, Infinity</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(1)
 x.hyperbolicSine()                       // '1.1752011936438014569'
@ -1434,7 +1530,7 @@ y.sinh()                                 // '0.52109530549374736162'</pre>
      Domain: [<code>-Infinity, Infinity</code>]<br />
      Range: [<code>-1, 1</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(1)
 x.hyperbolicTangent()                    // '0.76159415595576488812'
@ -1453,7 +1549,7 @@ y.tanh()                                 // '0.4621171572600097585'</pre>
      Domain: [<code>-1, 1</code>]<br />
      Range: [<code>0, pi</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(0)
 x.inverseCosine()                        // '1.5707963267948966192'
@ -1474,7 +1570,7 @@ y.acos()                                 // '1.0471975511965977462'</pre>
      Domain: [<code>1, Infinity</code>]<br />
      Range: [<code>0, Infinity</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(5)
 x.inverseHyperbolicCosine()              // '2.2924316695611776878'
@ -1495,7 +1591,7 @@ y.acosh()                                // '4.6050701709847571595'</pre>
      Domain: [<code>-Infinity, Infinity</code>]<br />
      Range: [<code>-Infinity, Infinity</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(5)
 x.inverseHyperbolicSine()                // '2.3124383412727526203'
@ -1516,7 +1612,7 @@ y.asinh()                                // '4.6052701709914238266'</pre>
      Domain: [<code>-1, 1</code>]<br />
      Range: [<code>-Infinity, Infinity</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(0.5)
 x.inverseHyperbolicTangent()             // '0.5493061443340548457'
@ -1535,7 +1631,7 @@ y.atanh()                                // '0.97295507452765665255'</pre>
      Domain: [<code>-1, 1</code>]<br />
      Range: [<code>-pi/2, pi/2</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(0.5)
 x.inverseSine()                          // '0.52359877559829887308'
@ -1554,7 +1650,7 @@ y.asin()                                 // '0.84806207898148100805'</pre>
      Domain: [<code>-Infinity, Infinity</code>]<br />
      Range: [<code>-pi/2, pi/2</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(0.5)
 x.inverseTangent()                       // '0.46364760900080611621'
@ -1575,10 +1671,6 @@ x = new Decimal(1)
 x.isFinite()                             // true
 y = new Decimal(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>



@ -1605,7 +1697,6 @@ x = new Decimal(NaN)
 x.isNaN()                                // true
 y = new Decimal('Infinity')
 y.isNaN()                                // false</pre>
-    <p>Note: The native method <code>isNaN()</code> can also be used.</p>



@ -1619,7 +1710,14 @@ x = new Decimal(-0)
 x.isNegative()                           // true
 y = new Decimal(2)
 y.isNeg                                  // false</pre>
-    <p>Note: <code>n &lt; 0</code> can be used if <code>n &lt;= -Number.MIN_VALUE</code>.</p>
+    <p>Note that zero is signed.</p>
+    <pre>
+new Decimal(0).valueOf()                 // '0'
+new Decimal(0).isNegative()              // false
+new Decimal(0).negated().valueOf()       // '-0'
+new Decimal(0).negated().isNegative()    // true
+new Decimal(-0).isNegative()             // true
+    </pre>



@ -1633,7 +1731,6 @@ x = new Decimal(0)
 x.isPositive()                           // true
 y = new Decimal(-2)
 y.isPos                                  // false</pre>
-    <p>Note: <code>n &lt; 0</code> can be used if <code>n &lt;= -Number.MIN_VALUE</code>.</p>



@ -1647,7 +1744,6 @@ x = new Decimal(-0)
 x.isZero() && x.isNeg()                  // true
 y = new Decimal(Infinity)
 y.isZero()                               // false</pre>
-    <p>Note: <code>n == 0</code> can be used if <code>n &gt;= Number.MIN_VALUE</code>.</p>



@ -1706,7 +1802,8 @@ y.log(2)                                 // '8'</pre>
    <p>Logarithms to base <code>2</code> or <code>10</code> will always be correctly rounded.</p>
    <p>
      See <a href='#pow'><code>toPower</code></a> for the circumstances in which this method may
-      return an incorrectly rounded result.
+      return an incorrectly rounded result, and see <a href='#ln'><code>naturalLogarithm</code></a>
+      for the precision limit.
    </p>
    <p>The performance of this method degrades exponentially with increasing digits.</p>

@ -1893,7 +1990,7 @@ x                                        // '1234.5'</pre>
      Domain: [<code>-Infinity, Infinity</code>]<br />
      Range: [<code>-1, 1</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(0.5)
 x.sine()                                 // '0.47942553860420300027'
@ -1935,7 +2032,7 @@ y.sqrt().eq( y.pow(0.5) )                // true</pre>
      Domain: [<code>-Infinity, Infinity</code>]<br />
      Range: [<code>-Infinity, Infinity</code>]
    </p>
-    <p>See <a href='#Pi'><code>Pi</code></a>.</p>
+    <p>See <a href='#Pi'><code>Pi</code></a> for the precision limit of this method.</p>
    <pre>
 x = new Decimal(0.5)
 x.tangent()                              // '0.54630248984379051326'
@ -2009,9 +2106,9 @@ x.toBinary(1)                            // '0b1p+8'</pre>
    </p>
    <p>Throws on an invalid <code>dp</code> or <code>rm</code> value.</p>
    <pre>
-x = new Decimal(12.24567)
+x = new Decimal(12.34567)
 x.toDecimalPlaces(0)                      // '12'
-x.toDecimalPlaces(1, 0)             // '12.3'
+x.toDecimalPlaces(1, Decimal.ROUND_UP)    // '12.4'

 y = new Decimal(9876.54321)
 y.toDP(3)                           // '9876.543'
@ -2047,14 +2144,14 @@ y.toDP(1, Decimal.ROUND_DOWN)       // '9876.5'</pre>
    <p>Throws on an invalid <code>dp</code> or <code>rm</code> value.</p>
    <pre>
 x = 45.6
-b = new Decimal(x)
+y = new Decimal(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)
+y.toExponential(1, Decimal.ROUND_DOWN)   // '4.5e+1'
 x.toExponential(3)                       // '4.560e+1'
 y.toExponential(3)                       // '4.560e+1'</pre>

@ -2095,13 +2192,13 @@ y.toExponential(3)             // '4.560e+1'</pre>
    <p>Throws on an invalid <code>dp</code> or <code>rm</code> value.</p>
    <pre>
 x = 3.456
-b = new Decimal(x)
+y = new Decimal(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)
+y.toFixed(2, Decimal.ROUND_DOWN)  // '3.45'
 x.toFixed(5)                      // '3.45600'
 y.toFixed(5)                      // '3.45600'</pre>

@ -2175,25 +2272,16 @@ x.toHex(1)                               // '0x1p+8'</pre>


    <h5 id="toNearest">
-      toNearest<code class='inset'>.toNearest(n [, rm]) <i>&rArr; Decimal</i></code>
+      toNearest<code class='inset'>.toNearest(x [, rm]) <i>&rArr; Decimal</i></code>
    </h5>
    <p>
      <code>x</code>: <i>number|string|Decimal</i><br />
      <code>rm</code>: <i>number</i>: integer, <code>0</code> to <code>8</code> inclusive
    </p>
    <p>
-      Returns a new Decimal whose value is the nearest multiple of <code>x</code> to the value of
-      this Decimal.
-    </p>
-     <p>
-      If the value of this Decimal is equidistant from two multiples of <code>x</code>, the rounding
-      mode <code>rm</code>, or <a href='#rounding'><code>rounding</code></a> if <code>rm</code> is
-      omitted, determines the direction of the nearest.
-    </p>
-    <p>
-      In this context, rounding mode <a href='#rounding'><code>ROUND_HALF_UP</code></a> is
-      interpreted the same as rounding mode <a href='#rounding'><code>ROUND_UP</code></a>, and so
-      on, i.e. the rounding is either up, down, to ceil, to floor or to even.
+      Returns a new Decimal whose value is the nearest multiple of <code>x</code> in the direction
+      of rounding mode <code>rm</code>, or <a href='#rounding'><code>rounding</code></a> if
+      <code>rm</code> is omitted, to the value of this Decimal.
    </p>
    <p>
      The return value will always have the same sign as this Decimal, unless either this Decimal
@ -2208,9 +2296,9 @@ x.toHex(1)                               // '0x1p+8'</pre>
 x = new Decimal(1.39)
 x.toNearest(0.25)                        // '1.5'

-y = new Decimal(0.75)          // equidistant from 0.5 and 1
-y.toNearest(0.5, 0)            // '1'    (ROUND_UP)
-y.toNearest(0.5, 1)            // '0.5'  (ROUND_DOWN)</pre>
+y = new Decimal(9.499)
+y.toNearest(0.5, Decimal.ROUND_UP)       // '9.5'
+y.toNearest(0.5, Decimal.ROUND_DOWN)     // '9'</pre>



@ -2353,13 +2441,13 @@ new Decimal(28).pow('6.166675020000903537297764507632802193308677149')
    <p>Throws on an invalid <code>sd</code> or <code>rm</code> value.</p>
    <pre>
 x = 45.6
-b = new Decimal(x)
+y = new Decimal(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)
+y.toPrecision(2, Decimal.ROUND_UP)       // '46'
+y.toPrecision(2, Decimal.ROUND_DOWN)     // '45'
 x.toPrecision(5)                         // '45.600'
 y.toPrecision(5)                         // '45.600'</pre>

@ -2478,9 +2566,9 @@ x.valueOf()                              // '-0'</pre>
        <td><code>-1</code>, <code>1</code>, or <code>NaN</code></td>
      </tr>
    </table>
-    <p>The properties are best considered to be read-only.</p>
+    <p>All the properties are best considered to be read-only.</p>
    <p>
-      As with JavaScript numbers, the original exponent and fractional trailing zeros of a number
+      As with JavaScript numbers, the original exponent and fractional trailing zeros of a value
      are not preserved.
    </p>
    <pre>
@ -2568,13 +2656,27 @@ try {
    </p>
    <p>
      It has a precision of <code>1025</code> digits, meaning that the trigonometric methods
-      can accurately calculate up to at least <code>1000</code> digits.
+      can calculate up to just over <code>1000</code> digits, but the actual figure depends on the
+      precision of the argument passed to them. To calculate the actual figure use:
+    </p>
+    <p><b>maximum_result_precision = 1000 - argument_precision</b></p>
+      For example, the following both work fine:
+    <pre>
+Decimal.set({precision: 991}).tan(123456789)
+Decimal.set({precision: 9}).tan(991_digit_number)</pre>
+    <p>
+      as, for each, the result precision plus the argument precision, i.e. <code>991 + 9</code> and
+      <code>9 + 991</code>, is less than or equal to <code>1000</code>.
    </p>
    <p>
      If greater precision is required then the value of <code>PI</code> will need to be extended to
-      about <code>25</code> digits more than the precision required.
+      about <code>25</code> digits more than the precision required. The time taken by the methods
+      will then be the limiting factor.
+    </p>
+    <p>
+      The value can also be shortened to reduce the size of the source file if such high precision
+      is not required.
    </p>
-    <p>The value can also be shortened to reduce the size of the source file.</p>
    <p>To get the value of pi:</p>
    <pre>
 pi = Decimal.acos(-1)</pre>
--- a/doc/decimal.js.map
+++ b/doc/decimal.js.map
--- a/package.json
+++ b/package.json
@ -1,7 +1,7 @@
 {
  "name": "decimal.js",
  "description": "An arbitrary-precision Decimal type for JavaScript.",
-  "version": "7.4.0",
+  "version": "10.4.3",
  "keywords": [
    "arbitrary",
    "precision",
@ -20,16 +20,36 @@
    "type": "git",
    "url": "https://github.com/MikeMcl/decimal.js.git"
  },
-  "main": "decimal.js",
+  "main": "decimal",
  "module": "decimal.mjs",
+  "browser": "decimal.js",
+  "exports": {
+    ".": {
+      "types": "./decimal.d.ts",
+      "import": "./decimal.mjs",
+      "require": "./decimal.js"
+    },
+    "./decimal.mjs": "./decimal.mjs",
+    "./decimal.js": "./decimal.js",
+    "./package.json": "./package.json",
+    "./decimal": {
+      "types": "./decimal.d.ts",
+      "import": "./decimal.mjs",
+      "require": "./decimal.js"
+    }
+  },
  "author": {
    "name": "Michael Mclaughlin",
    "email": "M8ch88l@gmail.com"
  },
  "license": "MIT",
  "scripts": {
-    "test": "node ./test/test.js",
-    "build": "uglifyjs decimal.js --source-map doc/decimal.js.map -c -m -o decimal.min.js --preamble \"/* decimal.js v7.4.0 https://github.com/MikeMcl/decimal.js/LICENCE */\""
+    "test": "node ./test/test.js"
  },
-  "types": "decimal.d.ts"
+  "types": "decimal.d.ts",
+  "files": [
+    "decimal.js",
+    "decimal.mjs",
+    "decimal.d.ts"
+  ]
 }
--- a/test/modules/Decimal.js
+++ b/test/modules/Decimal.js
@ -124,6 +124,7 @@ T('Decimal', function () {
  t('0', '0b0');
  t('0', '0B0');
  t('-5', '-0b101');
+  t('5', '+0b101');
  t('1.5', '0b1.1');
  t('-1.5', '-0b1.1');

@ -139,6 +140,7 @@ T('Decimal', function () {
  // Octal.
  t('8', '0o10');
  t('-8.5', '-0O010.4');
+  t('8.5', '+0O010.4');
  t('-262144.000000059604644775390625', '-0o1000000.00000001');
  t('572315667420.390625', '0o10250053005734.31');

@ -146,6 +148,7 @@ T('Decimal', function () {
  t('1', '0x00001');
  t('255', '0xff');
  t('-15.5', '-0Xf.8');
+  t('15.5', '+0Xf.8');
  t('-16777216.00000000023283064365386962890625', '-0x1000000.00000001');
  t('325927753012307620476767402981591827744994693483231017778102969592507', '0xc16de7aa5bf90c3755ef4dea45e982b351b6e00cd25a82dcfe0646abb');

@ -156,14 +159,18 @@ T('Decimal', function () {
  }

  t('NaN', NaN);
+  t('NaN', -NaN);
  t('NaN', 'NaN');
  t('NaN', '-NaN');
+  t('NaN', '+NaN');

  tx(function () {new Decimal(' NaN')}, "' NaN'");
  tx(function () {new Decimal('NaN ')}, "'NaN '");
  tx(function () {new Decimal(' NaN ')}, "' NaN '");
-  tx(function () {new Decimal('+NaN')}, "'+NaN'");
+  tx(function () {new Decimal(' -NaN')}, "' -NaN'");
  tx(function () {new Decimal(' +NaN')}, "' +NaN'");
+  tx(function () {new Decimal('-NaN ')}, "'-NaN '");
+  tx(function () {new Decimal('+NaN ')}, "'+NaN '");
  tx(function () {new Decimal('.NaN')}, "'.NaN'");
  tx(function () {new Decimal('NaN.')}, "'NaN.'");

@ -171,11 +178,12 @@ T('Decimal', function () {
  t('-Infinity', -Infinity);
  t('Infinity', 'Infinity');
  t('-Infinity', '-Infinity');
+  t('Infinity', '+Infinity');

  tx(function () {new Decimal(' Infinity')}, "' Infinity '");
  tx(function () {new Decimal('Infinity ')}, "'Infinity '");
  tx(function () {new Decimal(' Infinity ')}, "' Infinity '");
-  tx(function () {new Decimal('+Infinity')}, "'+Infinity'");
+  tx(function () {new Decimal(' -Infinity')}, "' -Infinity'");
  tx(function () {new Decimal(' +Infinity')}, "' +Infinity'");
  tx(function () {new Decimal('.Infinity')}, "'.Infinity'");
  tx(function () {new Decimal('Infinity.')}, "'Infinity.'");
@ -197,7 +205,7 @@ T('Decimal', function () {
  tx(function () {new Decimal('0-')}, "'0-'");
  tx(function () {new Decimal(' -0')}, "' -0'");
  tx(function () {new Decimal('-0 ')}, "'-0 '");
-  tx(function () {new Decimal('+0')}, "'+0'");
+  tx(function () {new Decimal('+0 ')}, "'+0 '");
  tx(function () {new Decimal(' +0')}, "' +0'");
  tx(function () {new Decimal(' .0')}, "' .0'");
  tx(function () {new Decimal('0. ')}, "'0. '");
@ -222,12 +230,16 @@ T('Decimal', function () {
  t('0.1', '.1');
  t('0.1', '.1');
  t('-0.1', '-.1');
+  t('0.1', '+.1');
  t('1', '1.');
  t('1', '1.0');
  t('-1', '-1.');
+  t('1', '+1.');
  t('-1', '-1.0000');
+  t('1', '1.0000');
  t('1', '1.00000000');
  t('-1', '-1.000000000000000000000000');
+  t('1', '+1.000000000000000000000000');

  tx(function () {new Decimal(' 1')}, "' 1'");
  tx(function () {new Decimal('1 ')}, "'1 '");
@ -235,8 +247,8 @@ T('Decimal', function () {
  tx(function () {new Decimal('1-')}, "'1-'");
  tx(function () {new Decimal(' -1')}, "' -1'");
  tx(function () {new Decimal('-1 ')}, "'-1 '");
-  tx(function () {new Decimal('+1')}, "'+1'");
  tx(function () {new Decimal(' +1')}, "' +1'");
+  tx(function () {new Decimal('+1 ')}, "'+1'");
  tx(function () {new Decimal('.1.')}, "'.1.'");
  tx(function () {new Decimal('+-1')}, "'+-1'");
  tx(function () {new Decimal('-+1')}, "'-+1'");
@ -262,8 +274,9 @@ T('Decimal', function () {

  t('123.456789', 123.456789);
  t('-123.456789', -123.456789);
-  t('123.456789', '123.456789');
  t('-123.456789', '-123.456789');
+  t('123.456789', '123.456789');
+  t('123.456789', '+123.456789');

  tx(function () {new Decimal(void 0)}, "void 0");
  tx(function () {new Decimal('undefined')}, "'undefined'");
@ -282,7 +295,9 @@ T('Decimal', function () {
  tx(function () {new Decimal('ff')}, "'ff'");
  tx(function () {new Decimal('0xg')}, "'oxg'");
  tx(function () {new Decimal('0Xfi')}, "'0Xfi'");
+  tx(function () {new Decimal('++45')}, "'++45'");
  tx(function () {new Decimal('--45')}, "'--45'");
  tx(function () {new Decimal('9.99--')}, "'9.99--'");
+  tx(function () {new Decimal('9.99++')}, "'9.99++'");
  tx(function () {new Decimal('0 0')}, "'0 0'");
 });
--- a/test/modules/clamp.js
+++ b/test/modules/clamp.js
@ -0,0 +1,45 @@
+if (typeof T === 'undefined') require('../setup');
+
+T('clamp', function () {
+
+  function t(x, min, max, expected) {
+    //T.assertEqual(expected, new Decimal(x).clampedTo(min, max).valueOf());
+    T.assertEqual(expected, new Decimal(x).clamp(min, max).valueOf());
+    //T.assertEqual(expected, Decimal.clamp(x, min, max).valueOf());
+  }
+
+  t('-0', '0', '0', '-0');
+  t('-0', '-0', '0', '-0');
+  t('-0', '0', '-0', '-0');
+  t('-0', '-0', '-0', '-0');
+  
+  t('0', '0', '0', '0');
+  t('0', '-0', '0', '0');
+  t('0', '0', '-0', '0');
+  t('0', '-0', '-0', '0');
+  
+  t(0, 0, 1, '0');
+  t(-1, 0, 1, '0');
+  t(-2, 0, 1, '0');
+  t(1, 0, 1, '1');
+  t(2, 0, 1, '1');
+  
+  t(1, 1, 1, '1');
+  t(-1, 1, 1, '1');
+  t(-1, -1, 1, '-1');
+  t(2, 1, 2, '2');
+  t(3, 1, 2, '2');
+  t(1, 0, 1, '1');
+  t(2, 0, 1, '1');
+  
+  t(Infinity, 0, 1, '1');
+  t(0, -Infinity, 0, '0');
+  t(-Infinity, 0, 1, '0');
+  t(-Infinity, -Infinity, Infinity, '-Infinity');
+  t(Infinity, -Infinity, Infinity, 'Infinity');
+  t(0, 1, Infinity, '1');
+  
+  t(0, NaN, 1, 'NaN');
+  t(0, 0, NaN, 'NaN');
+  t(NaN, 0, 1, 'NaN');
+});
--- a/test/modules/clone.js
+++ b/test/modules/clone.js
@ -105,5 +105,40 @@ T('clone', function () {
  t(new D8(1).constructor !== new D9(1).constructor);

  T.assertException(function () { Decimal.clone(null) }, "Decimal.clone(null)");
+
+  // defaults: true
+
+  Decimal.config({
+    precision: 100,
+    rounding: 2,
+    toExpNeg: -100,
+    toExpPos: 200,
+    defaults: true
+  });
+
+  t(Decimal.precision === 100);
+  t(Decimal.rounding === 2);
+  t(Decimal.toExpNeg === -100);
+  t(Decimal.toExpPos === 200);
+  t(Decimal.defaults === undefined);
+
+  D1 = Decimal.clone({ defaults: true });
+
+  t(D1.precision === 20);
+  t(D1.rounding === 4);
+  t(D1.toExpNeg === -7);
+  t(D1.toExpPos === 21);
+  t(D1.defaults === undefined);
+
+  D2 = Decimal.clone({ defaults: true, rounding: 5 });
+
+  t(D2.precision === 20);
+  t(D2.rounding === 5);
+  t(D2.toExpNeg === -7);
+  t(D2.toExpPos === 21);
+
+  D3 = Decimal.clone({ defaults: false });
+
+  t(D3.rounding === 2);
 });

--- a/test/modules/config.js
+++ b/test/modules/config.js
@ -338,5 +338,36 @@ T('config', function () {

  t(9, {modulo: void 0});

+  // defaults
+
+  t = function (actual) {
+    T.assert(actual);
+  }
+
+  Decimal.config({
+    precision: 100,
+    rounding: 2,
+    toExpNeg: -100,
+    toExpPos: 200,
+  });
+
+  t(Decimal.precision === 100);
+
+  Decimal.config({ defaults: true });
+
+  t(Decimal.precision === 20);
+  t(Decimal.rounding === 4);
+  t(Decimal.toExpNeg === -7);
+  t(Decimal.toExpPos === 21);
+  t(Decimal.defaults === undefined);
+
+  Decimal.rounding = 3;
+
+  Decimal.config({ precision: 50, defaults: true });
+
+  t(Decimal.precision === 50);
+  t(Decimal.rounding === 4);
+
+  // Decimal.set is an alias for Decimal.config
  T.assertEqual(Decimal.set, Decimal.config);
 });
--- a/test/modules/isFiniteEtc.js
+++ b/test/modules/isFiniteEtc.js
@ -1,6 +1,6 @@
 if (typeof T === 'undefined') require('../setup');

-T('isFinite, isInteger, isNaN, isNegative, isZero', function () {
+T('isFinite, isInteger, isNaN, isNegative, isZero, isDecimal', function () {

  function t(actual) {
    T.assert(actual);
@ -257,4 +257,22 @@ T('isFinite, isInteger, isNaN, isNegative, isZero', function () {
  t(!new Decimal('0.999999999999999999999').isInteger());
  t(new Decimal('4e4').isInteger());
  t(new Decimal('-4e4').isInteger());
+
+  // Decimal.isDecimal
+
+  t(Decimal.isDecimal(new Decimal(1)));
+  t(Decimal.isDecimal(new Decimal('-2.3')));
+  t(Decimal.isDecimal(new Decimal(NaN)));
+  t(Decimal.isDecimal(new Decimal('Infinity')));
+
+  t(!Decimal.isDecimal());
+  t(!Decimal.isDecimal(0));
+  t(!Decimal.isDecimal(1));
+  t(!Decimal.isDecimal('-2.3'));
+  t(!Decimal.isDecimal(NaN));
+  t(!Decimal.isDecimal(Infinity));
+  t(!Decimal.isDecimal(undefined));
+  t(!Decimal.isDecimal({}));
+  t(!Decimal.isDecimal({isDecimal: true}));
+  t(!Decimal.isDecimal(new Number(4)));
 });
--- a/test/modules/sum.js
+++ b/test/modules/sum.js
@ -0,0 +1,64 @@
+if (typeof T === 'undefined') require('../setup');
+
+T('sum', function () {
+  var expected;
+
+  function t() {
+    T.assertEqualDecimal(expected, Decimal.sum.apply(Decimal, arguments));
+  }
+
+  expected = new Decimal(0);
+
+  t('0');
+  t('0', new Decimal(0));
+  t(1, 0, '-1');
+  t(0, new Decimal('-10'), 0, 0, 0, 0, 0, 10);
+  t(11, -11);
+  t(1, '2', new Decimal(3), new Decimal('4'), -10);
+  t(new Decimal(-10), '9', new Decimal(0.01), 0.99);
+  
+  expected = new Decimal(10);
+
+  t('10');
+  t('0', new Decimal('10'));
+  t(10, 0);
+  t(0, 0, 0, 0, 0, 0, 10);
+  t(11, -1);
+  t(1, '2', new Decimal(3), new Decimal('4'));
+  t('9', new Decimal(0.01), 0.99);
+
+  expected = new Decimal(600);
+
+  t(100, 200, 300);
+  t('100', '200', '300');
+  t(new Decimal(100), new Decimal(200), new Decimal(300));
+  t(100, '200', new Decimal(300));
+  t(99.9, 200.05, 300.05);
+
+  expected = new Decimal(NaN);
+
+  t(NaN);
+  t('1', NaN);
+  t(100, 200, NaN);
+  t(NaN, 0, '9', new Decimal(0), 11, Infinity);
+  t(0, new Decimal('-Infinity'), '9', new Decimal(NaN), 11);
+  t(4, '-Infinity', 0, '9', new Decimal(0), Infinity, 2);
+
+  expected = new Decimal(Infinity);
+
+  t(Infinity);
+  t(1, '1e10000000000000000000000000000000000000000', '4');
+  t(100, 200, 'Infinity');
+  t(0, new Decimal('Infinity'), '9', new Decimal(0), 11);
+  t(0, '9', new Decimal(0), 11, Infinity);
+  t(4, new Decimal(Infinity), 0, '9', new Decimal(0), Infinity, 2);
+
+  expected = new Decimal(-Infinity);
+
+  t(-Infinity);
+  t(1, '-1e10000000000000000000000000000000000000000', '4');
+  t(100, 200, '-Infinity');
+  t(0, new Decimal('-Infinity'), '9', new Decimal(0), 11);
+  t(0, '9', new Decimal(0), 11, -Infinity);
+  t(4, new Decimal(-Infinity), 0, '9', new Decimal(0), -Infinity, 2);
+});
--- a/test/modules/toNearest.js
+++ b/test/modules/toNearest.js
@ -27,8 +27,7 @@ T('toNearest', function () {
  t(!isMinusZero(new Decimal(1).toNearest(-3)));
  t( isMinusZero(new Decimal(-1).toNearest(-3)));

-  t = function (expected, n, v, sd, rm) {
-    if (sd) Decimal.precision = sd;
+  t = function (expected, n, v, rm) {
    T.assertEqual(expected, new Decimal(n).toNearest(v, rm).valueOf());
  }

@ -67,9 +66,9 @@ T('toNearest', function () {

  t('0', 1, -3);
  t('-0', -1, -3);
-  t('3', 1.5, -3, 20, 0);
-  t('-0', -1.5, -3, 20, 1);
-  t('-3', -1.5, -3, 20, 2);
+  t('3', 1.5, -3, 0);
+  t('-0', -1.5, -3, 1);
+  t('-3', -1.5, -3, 2);

  t('123', 123.456);
  t('123', 123.456, 1);
@ -87,68 +86,145 @@ T('toNearest', function () {
  t('123.46', 123.456, '-0.02');
  t('123.456', 123.456, '-0.002');

-  t('83105511540', '83105511539.5', 1, 11, 4);
-  t('83105511539', '83105511539.499999999999999999999999999999', 1, 11, 4);
-  t('83105511539', '83105511539.5', '1', 11, 5);
-  t('83105511540', '83105511539.5000000000000000000001', 1, 11, 5);
+  t('83105511540', '83105511539.5', 1, 4);
+  t('83105511539', '83105511539.499999999999999999999999999999', 1, 4);
+  t('83105511539', '83105511539.5', '1', 5);
+  t('83105511540', '83105511539.5000000000000000000001', 1, 5);

-  t('83105511540', '83105511539.5', new Decimal(1), 3, 4);
-  t('83105511539', '83105511539.499999999999999999999999999999', 1, 3, 4);
-  t('83105511539', '83105511539.5', new Decimal('1'), 3, 5);
-  t('83105511540', '83105511539.5000000000000000000001', 1, 3, 5);
+  Decimal.precision = 3;

-  t('83105511540', '83105511539.5', Decimal.ONE, 30, 4);
-  t('83105511539', '83105511539.499999999999999999999999999999', 1, 30, 4);
-  t('83105511539', '83105511539.5', 1, 30, 5);
-  t('83105511540', '83105511539.5000000000000000000001', 1, 30, 5);
+  t('83105511540', '83105511539.5', new Decimal(1), 4);
+  t('83105511539', '83105511539.499999999999999999999999999999', 1, 4);
+  t('83105511539', '83105511539.5', new Decimal('1'), 5);
+  t('83105511540', '83105511539.5000000000000000000001', 1, 5);

-  t('83105511540', '83105511539.5', -1, 11, 4);
-  t('83105511539', '83105511539.499999999999999999999999999999', -1, 11, 4);
-  t('83105511539', '83105511539.5', '-1', 11, 5);
-  t('83105511540', '83105511539.5000000000000000000001', -1, 11, 5);
+  Decimal.precision = 20;

-  t('83105511540', '83105511539.5', new Decimal(-1), 3, 4);
-  t('83105511539', '83105511539.499999999999999999999999999999', 1, 3, 4);
-  t('83105511539', '83105511539.5', new Decimal('-1'), 3, 5);
-  t('83105511540', '83105511539.5000000000000000000001', -1, 3, 5);
+  t('83105511540', '83105511539.5', -1, 4);
+  t('83105511539', '83105511539.499999999999999999999999999999', -1, 4);
+  t('83105511539', '83105511539.5', '-1', 5);
+  t('83105511540', '83105511539.5000000000000000000001', -1, 5);

-  t('83105511540', '83105511539.5', 1, 30, 0);
-  t('83105511539', '83105511539.5', 1, 30, 1);
-  t('83105511540', '83105511539.5', 1, 30, 2);
-  t('83105511539', '83105511539.5', 1, 30, 3);
-  t('83105511540', '83105511539.5', 1, 30, 4);
-  t('83105511539', '83105511539.5', 1, 30, 5);
-  t('83105511540', '83105511539.5', 1, 30, 6);
-  t('83105511540', '83105511539.5', 1, 30, 7);
-  t('83105511539', '83105511539.5', 1, 30, 8);
-  t('83105511539', '83105511539.499999999999999999999999999999', void 0, 30, 0);
-  t('83105511539', '83105511539.499999999999999999999999999999', 1, 30, 1);
-  t('83105511539', '83105511539.499999999999999999999999999999', void 0, 30, 2);
-  t('83105511539', '83105511539.499999999999999999999999999999', 1, 30, 3);
-  t('83105511539', '83105511539.499999999999999999999999999999', void 0, 30, 4);
-  t('83105511539', '83105511539.499999999999999999999999999999', 1, 30, 5);
-  t('83105511539', '83105511539.499999999999999999999999999999', void 0, 30, 6);
-  t('83105511539', '83105511539.499999999999999999999999999999', 1, 30, 7);
-  t('83105511539', '83105511539.499999999999999999999999999999', void 0, 30, 8);
-  t('83105511540', '83105511539.5000000000000000000001', void 0, 30, 0);
-  t('83105511540', '83105511539.5000000000000000000001', 1, 30, 1);
-  t('83105511540', '83105511539.5000000000000000000001', void 0, 30, 2);
-  t('83105511540', '83105511539.5000000000000000000001', 1, 30, 3);
-  t('83105511540', '83105511539.5000000000000000000001', void 0, 30, 4);
-  t('83105511540', '83105511539.5000000000000000000001', 1, 30, 5);
-  t('83105511540', '83105511539.5000000000000000000001', void 0, 30, 6);
-  t('83105511540', '83105511539.5000000000000000000001', 1, 30, 7);
-  t('83105511540', '83105511539.5000000000000000000001', void 0, 30, 8);
+  t('-83105511540', '-83105511539.5', new Decimal(-1), 4);
+  t('-83105511539', '-83105511539.499999999999999999999999999999', 1, 4);
+  t('-83105511539', '-83105511539.5', new Decimal('-1'), 5);
+  t('-83105511540', '-83105511539.5000000000000000000001', -1, 5);
+
+  t('83105511540', '83105511539.5', 1, 0);
+  t('83105511539', '83105511539.5', 1, 1);
+  t('83105511540', '83105511539.5', 1, 2);
+  t('83105511539', '83105511539.5', 1, 3);
+  t('83105511540', '83105511539.5', 1, 4);
+  t('83105511539', '83105511539.5', 1, 5);
+  t('83105511540', '83105511539.5', 1, 6);
+  t('83105511540', '83105511539.5', 1, 7);
+  t('83105511539', '83105511539.5', 1, 8);
+  t('83105511539', '83105511539.499999999999999999999999999999', void 0, 0);
+  t('83105511539', '83105511539.499999999999999999999999999999', 1, 1);
+  t('83105511539', '83105511539.499999999999999999999999999999', void 0, 2);
+  t('83105511539', '83105511539.499999999999999999999999999999', 1, 3);
+  t('83105511539', '83105511539.499999999999999999999999999999', void 0, 4);
+  t('83105511539', '83105511539.499999999999999999999999999999', 1, 5);
+  t('83105511539', '83105511539.499999999999999999999999999999', void 0, 6);
+  t('83105511539', '83105511539.499999999999999999999999999999', 1, 7);
+  t('83105511539', '83105511539.499999999999999999999999999999', void 0, 8);
+  t('83105511540', '83105511539.5000000000000000000001', void 0, 0);
+  t('83105511539', '83105511539.5000000000000000000001', 1, 1);
+  t('83105511540', '83105511539.5000000000000000000001', void 0, 2);
+  t('83105511539', '83105511539.5000000000000000000001', 1, 3);
+  t('83105511540', '83105511539.5000000000000000000001', void 0, 4);
+  t('83105511540', '83105511539.5000000000000000000001', 1, 5);
+  t('83105511540', '83105511539.5000000000000000000001', void 0, 6);
+  t('83105511540', '83105511539.5000000000000000000001', 1, 7);
+  t('83105511540', '83105511539.5000000000000000000001', void 0, 8);

  Decimal.rounding = 0;
-  t('83105511540', '83105511539.5', void 0, 11);
+  t('83105511540', '83105511539.5');

  Decimal.rounding = 1;
-  t('83105511539', '83105511539.5', void 0, 11);
+  t('83105511539', '83105511539.5');

-  t('3847560', '3847561.00000749', 10, 11, 0);
-  t('42840000000000000', '42835000000000001', '1e+13', 2, 0);
-  t('42840000000000000', '42835000000000001', '1e+13', 2, 1);
-  t('42840000000000000', '42835000000000000.0002', '1e+13', 200, 0);
-  t('42840000000000000', '42835000000000000.0002', '1e+13', 200, 1);
+  t('3847570', '3847561.00000749', 10, 0);
+  t('42840000000000000', '42835000000000001', '1e+13', 0);
+  t('42830000000000000', '42835000000000001', '1e+13', 1);
+  t('42840000000000000', '42835000000000000.0002', '1e+13', 0);
+  t('42830000000000000', '42835000000000000.0002', '1e+13', 1);
+
+  t('500', '449.999', 100, 0);
+  t('400', '449.999', 100, 1);
+  t('500', '449.999', 100, 2);
+  t('400', '449.999', 100, 3);
+  t('400', '449.999', 100, 4);
+  t('400', '449.999', 100, 5);
+  t('400', '449.999', 100, 6);
+  t('400', '449.999', 100, 7);
+  t('400', '449.999', 100, 8);
+
+  t('-500', '-449.999', 100, 0);
+  t('-400', '-449.999', 100, 1);
+  t('-400', '-449.999', 100, 2);
+  t('-500', '-449.999', 100, 3);
+  t('-400', '-449.999', 100, 4);
+  t('-400', '-449.999', 100, 5);
+  t('-400', '-449.999', 100, 6);
+  t('-400', '-449.999', 100, 7);
+  t('-400', '-449.999', 100, 8);
+
+  t('500', '450', 100, 0);
+  t('400', '450', 100, 1);
+  t('500', '450', 100, 2);
+  t('400', '450', 100, 3);
+  t('500', '450', 100, 4);
+  t('400', '450', 100, 5);
+  t('400', '450', 100, 6);
+  t('500', '450', 100, 7);
+  t('400', '450', 100, 8);
+
+  t('-500', '-450', 100, 0);
+  t('-400', '-450', 100, 1);
+  t('-400', '-450', 100, 2);
+  t('-500', '-450', 100, 3);
+  t('-500', '-450', 100, 4);
+  t('-400', '-450', 100, 5);
+  t('-400', '-450', 100, 6);
+  t('-400', '-450', 100, 7);
+  t('-500', '-450', 100, 8);
+
+  Decimal.rounding = 0;
+  t('500', '450.001', 100);
+  Decimal.rounding = 1;
+  t('400', '450.001', 100);
+  Decimal.rounding = 2;
+  t('500', '450.001', 100);
+  Decimal.rounding = 3;
+  t('400', '450.001', 100);
+  Decimal.rounding = 4;
+  t('500', '450.001', 100);
+  Decimal.rounding = 5;
+  t('500', '450.001', 100);
+  Decimal.rounding = 6;
+  t('500', '450.001', 100);
+  Decimal.rounding = 7;
+  t('500', '450.001', 100);
+  Decimal.rounding = 8;
+  t('500', '450.001', 100);
+
+  Decimal.rounding = 0;
+  t('-500', '-450.001', 100);
+  Decimal.rounding = 1;
+  t('-400', '-450.001', 100);
+  Decimal.rounding = 2;
+  t('-400', '-450.001', 100);
+  Decimal.rounding = 3;
+  t('-500', '-450.001', 100);
+  Decimal.rounding = 4;
+  t('-500', '-450.001', 100);
+  Decimal.rounding = 5;
+  t('-500', '-450.001', 100);
+  Decimal.rounding = 6;
+  t('-500', '-450.001', 100);
+  Decimal.rounding = 7;
+  t('-500', '-450.001', 100);
+  Decimal.rounding = 8;
+  t('-500', '-450.001', 100);
 });
--- a/test/test.html
+++ b/test/test.html
@ -28,6 +28,7 @@
    'atanh',
    'cbrt',
    'ceil',
+    'clamp',
    'clone',
    'cmp',
    'config',
@ -59,6 +60,7 @@
    'sin',
    'sinh',
    'sqrt',
+    'sum',
    'tan',
    'tanh',
    'times',
--- a/test/test.js
+++ b/test/test.js
@ -15,6 +15,7 @@ console.log('\n Testing decimal.js\n');
  'atanh',
  'cbrt',
  'ceil',
+  'clamp',
  'clone',
  'cmp',
  'config',
@ -46,6 +47,7 @@ console.log('\n Testing decimal.js\n');
  'sin',
  'sinh',
  'sqrt',
+  'sum',
  'tan',
  'tanh',
  'times',
Author	SHA1	Message	Date
Michael Mclaughlin	7f01abd83d	v10.4.3	2022-12-04 13:02:11 +00:00
Michael M	0f148f9787	Merge pull request #211 from jon-ressio/feature/no-toStringTag Remove toStringTag declaration for type compatibility	2022-12-04 12:56:21 +00:00
Jon Stelly	858501020d	Remove toStringTag declaration for type compatibility - Allows Decimal to be type compatible with multiple Decimal.js imports - Resolves: https://github.com/prisma/prisma/issues/16397	2022-11-29 22:45:58 -06:00
Michael Mclaughlin	25c4a107aa	v10.4.2	2022-10-12 21:18:09 +01:00
Michael M	063e5fb7e9	#209 Correct return type	2022-10-07 18:09:07 +01:00
Michael M	65e63cedc4	#209 Correct return type	2022-10-07 18:08:28 +01:00
Michael Mclaughlin	3dcadc7351	v10.4.1	2022-09-16 23:02:17 +01:00
Michael M	d2e36c6524	#205 Add './decimal' subpath to exports	2022-09-16 22:57:34 +01:00
Michael Mclaughlin	f8b93e0bfa	v10.4.0	2022-08-14 18:25:23 +01:00
Michael M	f03f8686b6	Merge pull request #201 from UPONU-GmbH/master Fix typescript 4.7 / node16 import/type resolution	2022-08-14 18:09:19 +01:00
Michael M	61eef6711d	Merge pull request #203 from mhmdanas/preserve-license-comment--with-bundler Preserve license comment after bundling	2022-08-02 21:14:59 +01:00
mhmdanas	1e72c7b1f8	Preserve license comment after bundling The `/!* ... */` syntax is widely recognized by bundlers, and such comments are preserved in the bundle, which is important for license comments such at these ones.	2022-07-21 01:28:34 +03:00
Marcel Link	0bc3fdbdaa	Fix typescript 4.7 / node16 import/type resolution	2022-06-01 01:58:01 +02:00
Michael M	edadaf8f93	Correct typo	2022-05-23 21:42:54 +01:00
Michael M	31ebcc8250	Merge pull request #198 from dmarkow/master Use type predicate on isDecimal	2022-04-08 17:15:43 +01:00
Dylan Markow	a699f6b256	Use type predicate on isDecimal	2022-04-08 08:38:17 -05:00
Michael Mclaughlin	1bcf067429	v10.3.1	2021-06-25 12:55:36 +01:00
Michael Mclaughlin	00d5e300d7	Remove minified. Refresh README	2021-06-25 12:46:39 +01:00
Michael Mclaughlin	220f11c498	v10.3.0	2021-06-22 19:20:14 +01:00
Michael Mclaughlin	c29c80c6e3	Support underscores as separators	2021-06-22 13:22:53 +01:00
Michael Mclaughlin	69e91fecd2	Update definitions with sum and clamp	2021-06-22 12:50:27 +01:00
Michael Mclaughlin	d102ead7af	#101 Add clamp method	2021-06-22 12:15:13 +01:00
Michael Mclaughlin	ac0711318f	#161 Fix Decimal instances deemed plain objects	2021-06-22 10:53:21 +01:00
Michael Mclaughlin	66a21ee9d1	#100 Add Decimal.sum method	2021-06-22 10:13:28 +01:00
Michael Mclaughlin	0e0dcaec27	#146 Symbol.for to Symbol['for']	2021-06-21 18:31:41 +01:00
Michael Mclaughlin	04c6c6f115	#132 Fix possible infinite loop when minE is very low	2021-06-21 18:17:53 +01:00
Michael M	6e5a599fcc	Merge pull request #180 from m93a/patch-isdecimal Make the constructor accept different instances of Decimal	2021-06-09 18:43:39 +01:00
Michal Grno	498327d8d4	Decimal(v) now works even if v is from a different instance of Decimal	2021-06-09 16:19:34 +02:00
Michael M	6545e24c24	Merge pull request #169 from 2color/patch-1 Use https in links	2021-02-16 17:26:58 +00:00
Daniel Norman	26b348f383	Use https in links	2021-02-16 13:37:43 +01:00
Michael Mclaughlin	be7d6b05ab	v10.2.1	2020-09-28 22:28:15 +01:00
Michael Mclaughlin	e70384ea7e	Correct sqrt initial estimate	2020-09-28 21:58:18 +01:00
Michael M	11699c1d1c	Merge pull request #149 from Mazuh/patch-2 update api docs to warn about isNegative pitfall	2020-05-26 20:39:41 +01:00
Michael M	023981df23	Merge pull request #150 from MikeMcl/revert-148-patch-1 Revert "advice about negative zeroes on README"	2020-05-26 20:39:20 +01:00
Michael M	24726f5950	Revert "advice about negative zeroes on README"	2020-05-26 20:39:05 +01:00
Michael M	b53a593401	Merge pull request #148 from Mazuh/patch-1 Advice about negative zero	2020-05-26 20:37:45 +01:00
Marcell Guilherme Costa da Silva	39991b8249	update api docs to warn about isNegative pitfall	2020-05-24 17:06:11 -03:00
Marcell Guilherme Costa da Silva	a56f15f374	advice about negative zeroes on README	2020-05-07 01:01:50 -03:00
Michael M	5a6e1384d8	Merge pull request #135 from eliottvincent/master #134 Correct documentation examples	2019-07-25 10:40:28 +01:00
Eliott Vincent	b75e2fdc45	#134 Correct documentation examples	2019-07-25 09:31:07 +02:00
Michael Mclaughlin	30828c01a6	v10.2.0	2019-05-08 17:05:51 +01:00
Michael Mclaughlin	3f9eeb0897	#128 Accept `+` prefix	2019-05-08 17:05:12 +01:00
Michael Mclaughlin	f468de8e79	#128 Add tinyPow to workaround V8 Math.pow change	2019-05-08 16:16:42 +01:00
Michael M	fe487dc39e	Merge pull request #129 from zgayjjf/patch-1 docs: typo fixed	2019-05-08 15:58:12 +01:00
jeffjing	0a81a6758a	docs: typo fixed Related to [#73](https://github.com/MikeMcl/decimal.js/pull/73/files)	2019-05-08 21:13:01 +08:00
Michael M	f0dc751067	Merge pull request #127 from harrysarson/patch-1 Check node 12 in CI	2019-04-29 23:17:42 +01:00
Harry Sarson	6c6fbe7cac	Check node 12 in CI	2019-04-29 16:42:27 +01:00
Michael Mclaughlin	b041339e2a	v10.1.1	2019-02-27 10:10:12 +00:00
Michael Mclaughlin	8262235084	Check Symbol properly	2019-02-27 10:06:46 +00:00
Michael Mclaughlin	7818dff1ca	v10.1.0 #122 Add custom `util.inspect()` function. Add `Symbol.toStringTag`. #121 Constructor: add range check for arguments of type number and Decimal. Remove premable from uglifyjs build script. Move decimal.min.js.map to root directory.	2019-02-26 23:27:35 +00:00
Michael M	50dc74c3cb	Merge pull request #122 from adrianhara/master Added custom util.inspect() function	2019-02-26 23:23:55 +00:00
Adrian Hara	bc2979c96a	Added custom util.inspect() function that just prints out the "toString()" result of the decimal.	2019-02-25 17:06:47 +01:00
Michael Mclaughlin	9106f0a010	v10.0.2	2018-12-13 18:29:06 +00:00
Michael Mclaughlin	0c83e6a804	Remove bower.json	2018-12-13 18:28:37 +00:00
Michael M	846b9e6c57	#114 Remove sourceMappingURL	2018-12-13 18:16:16 +00:00
Michael Mclaughlin	bf504624f8	v10.0.1	2018-05-24 16:45:53 +01:00
Michael Mclaughlin	c6fb6a87b3	Add browser field to package.json	2018-05-24 16:41:43 +01:00
Michael Mclaughlin	903b98877d	Avoid Content Security Policy unsafe-eval issue	2018-04-26 17:54:17 +01:00
Michael Mclaughlin	2e75623cc3	v10.0.0	2018-03-10 22:10:08 +00:00
Michael Mclaughlin	93930f8a23	Put global ts definitions in separate file (see bignumber.js #143 )	2018-03-10 22:00:51 +00:00
Michael Mclaughlin	a821788a7c	Explain trig precision limits	2018-03-10 21:57:13 +00:00
Michael Mclaughlin	ba99e657d2	#82 #91 const to var	2018-03-10 19:46:08 +00:00
Michael Mclaughlin	6016146ef7	#88 Update doc and .mjs after toNearest change	2018-03-10 19:43:59 +00:00
Michael M	c99bdef459	Merge pull request #88 from luciavelasco/fix-toNearest-rounding Fix toNearest rounding	2018-03-05 22:52:28 +00:00
Lucia Velasco	caed629d5a	Code Review Changes: Updates test file and void check Also removes superfluous line that the tests now cater for.	2018-03-05 09:10:46 +00:00
Lucia Velasco	2c3198d555	Fixes pre-existing test to successfully round up	2018-03-02 22:11:22 +00:00
Lucia Velasco	4949869b5e	Allows round up and round ceil to work in the toNearest function. This makes the new tests in the previous commit work. A value of less than half of the first parameter of toNearest will now round up to the nearest multiplication of that first parameter.	2018-03-02 22:07:56 +00:00
Lucia Velasco	caaba6d513	Adds toNearest tests for numbers to round that are less-than-even This will test numbers that are less than half the first argument (y) of the toNearest function. If the y value is ten, the decimal value on which toNearest is tested will be a multiplication of ten plus less than 5.	2018-03-02 21:55:54 +00:00
Michael Mclaughlin	875f6d0f7a	v9.0.1	2017-12-15 10:38:51 +00:00
Michael Mclaughlin	8a7b6a3068	#80 Typings: correct return type	2017-12-15 10:37:01 +00:00
Michael Mclaughlin	dbba3d5b18	v9.0.0	2017-12-14 10:30:42 +00:00
Michael Mclaughlin	eb2efa06fb	#78 Typings: remove toFormat	2017-12-14 10:28:30 +00:00
Michael Mclaughlin	dbf681be4a	v8.0.0	2017-12-10 18:32:38 +00:00
Michael Mclaughlin	fd668fea70	Add Decimal.isDecimal and config reset	2017-12-09 22:05:28 +00:00
Michael Mclaughlin	17a358f2f4	Correct typings: toFraction returns Decimal[]	2017-12-09 11:51:25 +00:00
Michael Mclaughlin	1cbf5ffb44	v7.5.1	2017-12-03 22:21:41 +00:00
Michael M	84bf971160	Merge pull request #75 from chrisguttandin/fix-type-definition remove abandoned character	2017-12-03 22:15:13 +00:00
chrisguttandin	6e91027ee0	remove abandoned character	2017-12-03 22:55:11 +01:00
Michael Mclaughlin	35a8cddde9	v7.5.0	2017-12-03 18:09:41 +00:00
Michael Mclaughlin	244138f8c2	Merge branch 'master' of https://github.com/MikeMcl/decimal.js	2017-12-03 18:09:04 +00:00
Michael Mclaughlin	d477d566ea	Use TypeScript delarations outside modules	2017-12-03 17:42:48 +00:00
Michael M	1a552b2d6c	Merge pull request #73 from mkutny/doc docs: typos fixed	2017-11-29 23:22:05 +00:00
Max Kutny	074a97d06a	docs: typos fixed	2017-11-29 16:25:43 +02:00