.travis.yml

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

CHANGELOG.md

@@ -1,25 +1,3 @@
-#### 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) 2022 Michael Mclaughlin
+Copyright (c) 2021 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,7 +19,6 @@ 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)
@@ -44,10 +43,12 @@ 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>
 ```
 
@@ -57,19 +58,25 @@ Browser:
 npm install decimal.js
 ```
 ```js
-const Decimal = require('decimal.js');
-
+var Decimal = require('decimal.js');
+```
+or
+```js
 import Decimal from 'decimal.js';
-
+```
+or
+```js
 import {Decimal} from 'decimal.js';
 ```
 
 ## Use
 
-*In all examples below, semicolons and `toString` calls are not shown.
+*In all examples below, `var`, semicolons and `toString` calls are not shown.
 If a commented-out value is in quotes it means `toString` has been called on the preceding expression.*
 
-The library exports a single constructor function, `Decimal`, which expects a single argument that is a number, string or Decimal instance.
+The library exports a single function object, `Decimal`, the constructor of Decimal instances.
+
+It accepts a value of type number, string or Decimal.
 
 ```js
 x = new Decimal(123.4567)
@@ -78,29 +85,7 @@ z = new Decimal(x)
 x.equals(y) && y.equals(z) && x.equals(z)        // true
 ```
 
-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.
+A value can also be in binary, hexadecimal or octal if the appropriate prefix is included.
 
 ```js
 x = new Decimal('0xff.f')            // '255.9375'
@@ -109,13 +94,15 @@ 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'
 ```
 
-Decimal instances are immutable in the sense that they are not changed by their methods.
+Using binary exponential notation to create a Decimal with the value of `Number.MAX_VALUE`:
+
+```js
+x = new Decimal('0b1.1111111111111111111111111111111111111111111111111111p+1023')
+```
+
+A Decimal is immutable in the sense that it is not changed by its methods.
 
 ```js
 0.3 - 0.1                     // 0.19999999999999998
@@ -128,34 +115,33 @@ 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('4444562598.111772').ceil()
+x.times('1.23456780123456789e+9').plus(9876.5432321).dividedBy('4_444_562_598.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.comparedTo(y.modulo(z).negated() === x.cmp(y.mod(z).neg())              // 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
 ```
 
-Most of the methods of JavaScript's `Number.prototype` and `Math` objects are replicated.
+Like JavaScript's Number type, there are `toExponential`, `toFixed` and `toPrecision` methods,
 
 ```js
 x = new Decimal(255.5)
-x.toExponential(5)                       // '2.55500e+2'
-x.toFixed(5)                             // '255.50000'
-x.toPrecision(5)                         // '255.50'
-
-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'
+x.toExponential(5)              // '2.55500e+2'
+x.toFixed(5)                    // '255.50000'
+x.toPrecision(5)                // '255.50'
 ```
 
-And there are `isNaN` and `isFinite` methods, as `NaN` and `Infinity` are valid `Decimal` values.
+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'
+```
+
+There are `isNaN` and `isFinite` methods, as `NaN` and `Infinity` are valid `Decimal` values,
 
 ```js
 x = new Decimal(NaN)                                           // 'NaN'
@@ -163,7 +149,7 @@ y = new Decimal(Infinity)                                      // 'Infinity'
 x.isNaN() && !y.isNaN() && !x.isFinite() && !y.isFinite()      // true
 ```
 
-There is also a `toFraction` method with an optional *maximum denominator* argument.
+and a `toFraction` method with an optional *maximum denominator* argument
 
 ```js
 z = new Decimal(355)
@@ -183,16 +169,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
-Dec = Decimal.clone({ precision: 9, rounding: 1 })
+Decimal9 = Decimal.clone({ precision: 9, rounding: 1 })
 
 x = new Decimal(5)
-y = new Dec(5)
+y = new Decimal9(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, but these properties should be considered read-only.
+The value of a Decimal is stored in a floating point format in terms of its digits, exponent and sign.
 
 ```js
 x = new Decimal(-12345.67);
@@ -205,32 +191,41 @@ For further information see the [API](http://mikemcl.github.io/decimal.js/) refe
 
 ## Test
 
-To run the tests using Node.js from the root directory:
+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
 
 ```bash
 npm test
 ```
 
-Each separate test module can also be executed individually, for example:
+or at the *test* directory using Node
 
 ```bash
-node test/modules/toFraction
+node test
 ```
 
-To run the tests in a browser, open *test/test.html*.
+Each separate test module can also be executed individually, for example, at the *test/modules* directory
+
+```bash
+node toFraction
+```
 
 ## Minify
 
-Two minification examples:
-
-Using [uglify-js](https://github.com/mishoo/UglifyJS) to minify the *decimal.js* file:
+The minified version of *decimal.js* and its associated source map found in this repository was created with
+[uglify-js](https://github.com/mishoo/UglifyJS) using
 
 ```bash
 npm install uglify-js -g
-uglifyjs decimal.js --source-map url=decimal.min.js.map -c -m -o decimal.min.js
+uglifyjs decimal.js --source-map url=decimal.min.js.map --compress --mangle --output decimal.min.js
 ```
 
-Using [terser](https://github.com/terser/terser) to minify the ES module version, *decimal.mjs*:
+The minified version of *decimal.mjs* and its associated source map found in this repository was created with
+[terser](https://github.com/terser/terser) using
 
 ```bash
 npm install terser -g
@@ -243,4 +238,6 @@ import Decimal from './decimal.min.mjs';
 
 ## Licence
 
-[The MIT Licence (Expat).](LICENCE.md)
+MIT.
+
+See *LICENCE.md*

decimal.d.ts

@@ -56,6 +56,7 @@ export declare class Decimal {
   readonly d: number[];
   readonly e: number;
   readonly s: number;
+  private readonly toStringTag: string;
 
   constructor(n: Decimal.Value);
 
@@ -250,7 +251,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): object is Decimal;
+  static isDecimal(object: any): boolean
   static ln(n: Decimal.Value): Decimal;
   static log(n: Decimal.Value, base?: Decimal.Value): Decimal;
   static log2(n: Decimal.Value): Decimal;
@@ -264,7 +265,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): number;
+  static sign(n: Decimal.Value): Decimal;
   static sin(n: Decimal.Value): Decimal;
   static sinh(n: Decimal.Value): Decimal;
   static sqrt(n: Decimal.Value): Decimal;

decimal.global.d.ts

@@ -77,6 +77,7 @@ export declare class Decimal {
   readonly d: number[];
   readonly e: number;
   readonly s: number;
+  private readonly toStringTag: string;
 
   constructor(n: DecimalValue);
 
@@ -271,7 +272,7 @@ export declare class Decimal {
   static exp(n: DecimalValue): Decimal;
   static floor(n: DecimalValue): Decimal;
   static hypot(...n: DecimalValue[]): Decimal;
-  static isDecimal(object: any): object is Decimal;
+  static isDecimal(object: any): boolean
   static ln(n: DecimalValue): Decimal;
   static log(n: DecimalValue, base?: DecimalValue): Decimal;
   static log2(n: DecimalValue): Decimal;
@@ -285,7 +286,7 @@ export declare class Decimal {
   static random(significantDigits?: number): Decimal;
   static round(n: DecimalValue): Decimal;
   static set(object: DecimalConfig): DecimalConstructor;
-  static sign(n: DecimalValue): number;
+  static sign(n: DecimalValue): Decimal;
   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.4.3
+  /*
+   *  decimal.js v10.3.0
    *  An arbitrary-precision Decimal type for JavaScript.
    *  https://github.com/MikeMcl/decimal.js
-   *  Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>
+   *  Copyright (c) 2021 Michael Mclaughlin <M8ch88l@gmail.com>
    *  MIT Licence
    */
 

decimal.mjs

@@ -1,8 +1,8 @@
-/*!
- *  decimal.js v10.4.3
+/*
+ *  decimal.js v10.3.0
  *  An arbitrary-precision Decimal type for JavaScript.
  *  https://github.com/MikeMcl/decimal.js
- *  Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>
+ *  Copyright (c) 2021 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.001'       e is -3
+new Decimal(0.001)                 // '0.01'       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.4.3",
+  "version": "10.3.0",
   "keywords": [
     "arbitrary",
     "precision",
@@ -23,21 +23,6 @@
   "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"