bn.js 5.0.0 → 5.1.3

package/CHANGELOG.md

@@ -1,3 +1,30 @@
+5.1.3 / 2020-08-14
+------------------
+
+- Add support for defined but not implemented Symbol.for (#252)
+
+5.1.2 / 2020-05-20
+------------------
+
+- Fix BN v5/v4 interoperability issue (#249)
+
+5.1.1 / 2019-12-24
+------------------
+
+- Temporary workaround for BN#_move (#236)
+- Add eslintrc instead config in package.json (#237)
+
+5.1.0 / 2019-12-23
+------------------
+
+- Benchmark for BigInt (#226)
+- Add documentation for max/min (#232)
+- Update BN#inspect for Symbols (#225)
+- Improve performance of toArrayLike (#222)
+- temporary disable jumboMulTo in BN#mulTo (#221)
+- optimize toBitArray function (#212)
+- fix iaddn sign issue (#216)
+
 5.0.0 / 2019-07-04
 ------------------
 

package/README.md

@@ -84,6 +84,8 @@ either `le` (little-endian) or `be` (big-endian).
 * `a.toTwos(width)` - convert to two's complement representation, where `width` is bit width
 * `a.fromTwos(width)` - convert from two's complement representation, where `width` is the bit width
 * `BN.isBN(object)` - returns true if the supplied `object` is a BN.js instance
+* `BN.max(a, b)` - return `a` if `a` bigger than `b`
+* `BN.min(a, b)` - return `a` if `a` less than `b`
 
 ### Arithmetics
 

package/lib/bn.js

@@ -116,7 +116,7 @@
       number = -number;
     }
     if (number < 0x4000000) {
-      this.words = [ number & 0x3ffffff ];
+      this.words = [number & 0x3ffffff];
       this.length = 1;
     } else if (number < 0x10000000000000) {
       this.words = [
@@ -144,7 +144,7 @@
     // Perhaps a Uint8Array
     assert(typeof number.length === 'number');
     if (number.length <= 0) {
-      this.words = [ 0 ];
+      this.words = [0];
       this.length = 1;
       return this;
     }
@@ -274,7 +274,7 @@
 
   BN.prototype._parseBase = function _parseBase (number, base, start) {
     // Initialize as zero
-    this.words = [ 0 ];
+    this.words = [0];
     this.length = 1;
 
     // Find length of limb in base
@@ -327,11 +327,15 @@
     dest.red = this.red;
   };
 
+  function move (dest, src) {
+    dest.words = src.words;
+    dest.length = src.length;
+    dest.negative = src.negative;
+    dest.red = src.red;
+  }
+
   BN.prototype._move = function _move (dest) {
-    dest.words = this.words;
-    dest.length = this.length;
-    dest.negative = this.negative;
-    dest.red = this.red;
+    move(dest, this);
   };
 
   BN.prototype.clone = function clone () {
@@ -363,9 +367,21 @@
     return this;
   };
 
-  BN.prototype.inspect = function inspect () {
+  // Check Symbol.for because not everywhere where Symbol defined
+  // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol#Browser_compatibility
+  if (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function') {
+    try {
+      BN.prototype[Symbol.for('nodejs.util.inspect.custom')] = inspect;
+    } catch (e) {
+      BN.prototype.inspect = inspect;
+    }
+  } else {
+    BN.prototype.inspect = inspect;
+  }
+
+  function inspect () {
     return (this.red ? '<BN-R: ' : '<BN: ') + this.toString(16) + '>';
-  };
+  }
 
   /*
 
@@ -540,51 +556,97 @@
     return this.toArrayLike(Array, endian, length);
   };
 
+  var allocate = function allocate (ArrayType, size) {
+    if (ArrayType.allocUnsafe) {
+      return ArrayType.allocUnsafe(size);
+    }
+    return new ArrayType(size);
+  };
+
   BN.prototype.toArrayLike = function toArrayLike (ArrayType, endian, length) {
+    this._strip();
+
     var byteLength = this.byteLength();
     var reqLength = length || Math.max(1, byteLength);
     assert(byteLength <= reqLength, 'byte array longer than desired length');
     assert(reqLength > 0, 'Requested array length <= 0');
 
-    this._strip();
-    var littleEndian = endian === 'le';
     var res = allocate(ArrayType, reqLength);
+    var postfix = endian === 'le' ? 'LE' : 'BE';
+    this['_toArrayLike' + postfix](res, byteLength);
+    return res;
+  };
+
+  BN.prototype._toArrayLikeLE = function _toArrayLikeLE (res, byteLength) {
+    var position = 0;
+    var carry = 0;
+
+    for (var i = 0, shift = 0; i < this.length; i++) {
+      var word = (this.words[i] << shift) | carry;
 
-    var b, i;
-    var q = this.clone();
-    if (!littleEndian) {
-      // Assume big-endian
-      for (i = 0; i < reqLength - byteLength; i++) {
-        res[i] = 0;
+      res[position++] = word & 0xff;
+      if (position < res.length) {
+        res[position++] = (word >> 8) & 0xff;
       }
+      if (position < res.length) {
+        res[position++] = (word >> 16) & 0xff;
+      }
+
+      if (shift === 6) {
+        if (position < res.length) {
+          res[position++] = (word >> 24) & 0xff;
+        }
+        carry = 0;
+        shift = 0;
+      } else {
+        carry = word >>> 24;
+        shift += 2;
+      }
+    }
 
-      for (i = 0; !q.isZero(); i++) {
-        b = q.andln(0xff);
-        q.iushrn(8);
+    if (position < res.length) {
+      res[position++] = carry;
 
-        res[reqLength - i - 1] = b;
+      while (position < res.length) {
+        res[position++] = 0;
       }
-    } else {
-      for (i = 0; !q.isZero(); i++) {
-        b = q.andln(0xff);
-        q.iushrn(8);
+    }
+  };
+
+  BN.prototype._toArrayLikeBE = function _toArrayLikeBE (res, byteLength) {
+    var position = res.length - 1;
+    var carry = 0;
+
+    for (var i = 0, shift = 0; i < this.length; i++) {
+      var word = (this.words[i] << shift) | carry;
 
-        res[i] = b;
+      res[position--] = word & 0xff;
+      if (position >= 0) {
+        res[position--] = (word >> 8) & 0xff;
+      }
+      if (position >= 0) {
+        res[position--] = (word >> 16) & 0xff;
       }
 
-      for (; i < reqLength; i++) {
-        res[i] = 0;
+      if (shift === 6) {
+        if (position >= 0) {
+          res[position--] = (word >> 24) & 0xff;
+        }
+        carry = 0;
+        shift = 0;
+      } else {
+        carry = word >>> 24;
+        shift += 2;
       }
     }
 
-    return res;
-  };
+    if (position >= 0) {
+      res[position--] = carry;
 
-  var allocate = function allocate (ArrayType, size) {
-    if (ArrayType.allocUnsafe) {
-      return ArrayType.allocUnsafe(size);
+      while (position >= 0) {
+        res[position--] = 0;
+      }
     }
-    return new ArrayType(size);
   };
 
   if (Math.clz32) {
@@ -657,7 +719,7 @@
       var off = (bit / 26) | 0;
       var wbit = bit % 26;
 
-      w[bit] = (num.words[off] & (1 << wbit)) >>> wbit;
+      w[bit] = (num.words[off] >>> wbit) & 0x01;
     }
 
     return w;
@@ -1679,8 +1741,10 @@
   }
 
   function jumboMulTo (self, num, out) {
-    var fftm = new FFTM();
-    return fftm.mulp(self, num, out);
+    // Temporary disable, see https://github.com/indutny/bn.js/issues/211
+    // var fftm = new FFTM();
+    // return fftm.mulp(self, num, out);
+    return bigMulTo(self, num, out);
   }
 
   BN.prototype.mulTo = function mulTo (num, out) {
@@ -2160,7 +2224,7 @@
 
     // Possible sign change
     if (this.negative !== 0) {
-      if (this.length === 1 && (this.words[0] | 0) < num) {
+      if (this.length === 1 && (this.words[0] | 0) <= num) {
         this.words[0] = num - (this.words[0] | 0);
         this.negative = 0;
         return this;
@@ -2477,7 +2541,7 @@
     var cmp = mod.cmp(half);
 
     // Round down
-    if (cmp < 0 || r2 === 1 && cmp === 0) return dm.div;
+    if (cmp < 0 || (r2 === 1 && cmp === 0)) return dm.div;
 
     // Round up
     return dm.div.negative !== 0 ? dm.div.isubn(1) : dm.div.iaddn(1);
@@ -3013,7 +3077,13 @@
     } else if (cmp > 0) {
       r.isub(this.p);
     } else {
-      r._strip();
+      if (r.strip !== undefined) {
+        // r is a BN v4 instance
+        r.strip();
+      } else {
+        // r is a BN v5 instance
+        r._strip();
+      }
     }
 
     return r;
@@ -3187,7 +3257,7 @@
   Red.prototype.imod = function imod (a) {
     if (this.prime) return this.prime.ireduce(a)._forceRed(this);
 
-    a.umod(this.m)._forceRed(this)._move(a);
+    move(a, a.umod(this.m)._forceRed(this));
     return a;
   };
 

package/package.json

@@ -1,39 +1,42 @@
 {
   "name": "bn.js",
-  "version": "5.0.0",
+  "version": "5.1.3",
   "description": "Big number implementation in pure javascript",
-  "main": "lib/bn.js",
-  "scripts": {
-    "lint": "semistandard",
-    "unit": "mocha --reporter=spec test/*-test.js",
-    "test": "npm run lint && npm run unit"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git@github.com:indutny/bn.js"
-  },
   "keywords": [
     "BN",
-    "BigNum",
     "Big number",
+    "BigNum",
     "Modulo",
     "Montgomery"
   ],
-  "author": "Fedor Indutny <fedor@indutny.com>",
-  "license": "MIT",
+  "homepage": "https://github.com/indutny/bn.js",
   "bugs": {
     "url": "https://github.com/indutny/bn.js/issues"
   },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:indutny/bn.js"
+  },
+  "license": "MIT",
+  "author": "Fedor Indutny <fedor@indutny.com>",
   "files": [
-    "lib"
+    "lib/bn.js"
   ],
-  "homepage": "https://github.com/indutny/bn.js",
+  "main": "lib/bn.js",
   "browser": {
     "buffer": false
   },
+  "scripts": {
+    "lint": "standardx",
+    "test": "npm run lint && npm run unit",
+    "unit": "mocha --reporter=spec test/*-test.js"
+  },
   "devDependencies": {
-    "istanbul": "^0.3.5",
-    "mocha": "^2.1.0",
-    "semistandard": "^7.0.4"
+    "babel-eslint": "^10.0.3",
+    "mocha": "^7.0.1",
+    "standardx": "^5.0.0"
+  },
+  "standardx": {
+    "parser": "babel-eslint"
   }
 }