v10.4.3

Remove toStringTag declaration for type compatibility

.travis.yml

@@ -1,6 +1,9 @@
 language: node_js
 node_js:
   - "node"
+  - "18"
+  - "17"
+  - "16"
   - "15"
   - "14"
   - "13"

CHANGELOG.md

@@ -1,3 +1,25 @@
+#### 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.

LICENCE.md

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

README.md

@@ -19,6 +19,7 @@ An arbitrary-precision Decimal type for JavaScript.
   - No dependencies
   - Wide platform compatibility: uses JavaScript 1.5 (ECMAScript 3) features only
   - 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)
@@ -43,12 +44,10 @@ Browser:
 
 ```html
 <script src='path/to/decimal.js'></script>
-```
+
-or
-```html
 <script type="module">
-import Decimal from './path/to/decimal.mjs';
+  import Decimal from './path/to/decimal.mjs';
-...
+  ...
 </script>
 ```
 
@@ -58,25 +57,19 @@ import Decimal from './path/to/decimal.mjs';
 npm install decimal.js
 ```
 ```js
-var Decimal = require('decimal.js');
+const Decimal = require('decimal.js');
-```
+
-or
-```js
 import Decimal from 'decimal.js';
-```
+
-or
-```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.
+The library exports a single constructor function, `Decimal`, which expects a single argument that is a number, string or Decimal instance.
-
-It accepts a value of type number, string or Decimal.
 
 ```js
 x = new Decimal(123.4567)
@@ -85,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'
@@ -94,15 +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`:
+// Using binary exponential notation to create a Decimal with the value of `Number.MAX_VALUE`.
-
-```js
 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
@@ -115,33 +128,34 @@ The methods that return a Decimal can be chained.
 
 ```js
 x.dividedBy(y).plus(z).times(9).floor()
-x.times('1.23456780123456789e+9').plus(9876.5432321).dividedBy('4_444_562_598.111772').ceil()
+x.times('1.23456780123456789e+9').plus(9876.5432321).dividedBy('4444562598.111772').ceil()
 ```
 
 Many method names have a shorter alias.
 
 ```js
-x.squareRoot().dividedBy(y).toPower(3).equals(x.sqrt().div(y).pow(3))         // true
+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.toExponential(5)                       // '2.55500e+2'
-x.toFixed(5)                    // '255.50000'
+x.toFixed(5)                             // '255.50000'
-x.toPrecision(5)                // '255.50'
+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'
@@ -149,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)
@@ -169,16 +183,16 @@ configuration which applies to all Decimal numbers created from it.
 Decimal.set({ precision: 5, rounding: 4 })
 
 // Create another Decimal constructor, optionally passing in a configuration object
-Decimal9 = Decimal.clone({ precision: 9, rounding: 1 })
+Dec = Decimal.clone({ precision: 9, rounding: 1 })
 
 x = new Decimal(5)
-y = new Decimal9(5)
+y = new Dec(5)
 
 x.div(3)                           // '1.6667'
 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);
@@ -191,41 +205,32 @@ 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.
+To run the tests using Node.js from the root directory:
-
-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
 
 ```bash
 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
 
-The minified version of *decimal.js* and its associated source map found in this repository was created with
+Two minification examples:
-[uglify-js](https://github.com/mishoo/UglifyJS) using
+
+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 --compress --mangle --output decimal.min.js
+uglifyjs decimal.js --source-map url=decimal.min.js.map -c -m -o decimal.min.js
 ```
 
-The minified version of *decimal.mjs* and its associated source map found in this repository was created with
+Using [terser](https://github.com/terser/terser) to minify the ES module version, *decimal.mjs*:
-[terser](https://github.com/terser/terser) using
 
 ```bash
 npm install terser -g
@@ -238,6 +243,4 @@ import Decimal from './decimal.min.mjs';
 
 ## Licence
 
-MIT.
+[The MIT Licence (Expat).](LICENCE.md)
-
-See *LICENCE.md*

decimal.d.ts

@@ -56,7 +56,6 @@ export declare class Decimal {
   readonly d: number[];
   readonly e: number;
   readonly s: number;
-  private readonly toStringTag: string;
 
   constructor(n: Decimal.Value);
 
@@ -251,7 +250,7 @@ export declare class Decimal {
   static exp(n: Decimal.Value): Decimal;
   static floor(n: Decimal.Value): Decimal;
   static hypot(...n: Decimal.Value[]): Decimal;
-  static isDecimal(object: any): boolean
+  static isDecimal(object: any): object is Decimal;
   static ln(n: Decimal.Value): Decimal;
   static log(n: Decimal.Value, base?: Decimal.Value): Decimal;
   static log2(n: Decimal.Value): Decimal;
@@ -265,7 +264,7 @@ export declare class Decimal {
   static random(significantDigits?: number): Decimal;
   static round(n: Decimal.Value): Decimal;
   static set(object: Decimal.Config): Decimal.Constructor;
-  static sign(n: Decimal.Value): Decimal;
+  static sign(n: Decimal.Value): number;
   static sin(n: Decimal.Value): Decimal;
   static sinh(n: Decimal.Value): Decimal;
   static sqrt(n: Decimal.Value): Decimal;

decimal.global.d.ts

@@ -77,7 +77,6 @@ export declare class Decimal {
   readonly d: number[];
   readonly e: number;
   readonly s: number;
-  private readonly toStringTag: string;
 
   constructor(n: DecimalValue);
 
@@ -272,7 +271,7 @@ export declare class Decimal {
   static exp(n: DecimalValue): Decimal;
   static floor(n: DecimalValue): Decimal;
   static hypot(...n: DecimalValue[]): Decimal;
-  static isDecimal(object: any): boolean
+  static isDecimal(object: any): object is Decimal;
   static ln(n: DecimalValue): Decimal;
   static log(n: DecimalValue, base?: DecimalValue): Decimal;
   static log2(n: DecimalValue): Decimal;
@@ -286,7 +285,7 @@ export declare class Decimal {
   static random(significantDigits?: number): Decimal;
   static round(n: DecimalValue): Decimal;
   static set(object: DecimalConfig): DecimalConstructor;
-  static sign(n: DecimalValue): Decimal;
+  static sign(n: DecimalValue): number;
   static sin(n: DecimalValue): Decimal;
   static sinh(n: DecimalValue): Decimal;
   static sqrt(n: DecimalValue): Decimal;

decimal.js

@@ -2,11 +2,11 @@
   'use strict';
 
 
-  /*
+  /*!
-   *  decimal.js v10.3.0
+   *  decimal.js v10.4.3
    *  An arbitrary-precision Decimal type for JavaScript.
    *  https://github.com/MikeMcl/decimal.js
-   *  Copyright (c) 2021 Michael Mclaughlin <M8ch88l@gmail.com>
+   *  Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>
    *  MIT Licence
    */
 

decimal.mjs

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

doc/API.html

@@ -1009,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>

package.json

@@ -1,7 +1,7 @@
 {
   "name": "decimal.js",
   "description": "An arbitrary-precision Decimal type for JavaScript.",
-  "version": "10.3.0",
+  "version": "10.4.3",
   "keywords": [
     "arbitrary",
     "precision",
@@ -23,6 +23,21 @@
   "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"