locutus 2.0.31 → 2.0.34

package/php/_helpers/_bc.js

@@ -1,4 +1,6 @@
-'use strict';
+// SPDX-License-Identifier: LGPL-2.1-or-later
+// NOTE: This file is LGPL licensed, not MIT like the rest of locutus.
+// See LICENSE file for details.
 
 module.exports = function _bc() {
   //  discuss at: https://locutus.io/php/_helpers/_bc
@@ -9,7 +11,7 @@ module.exports = function _bc() {
   //   returns 1: '+'
 
   /**
-   * BC Math Library for Javascript
+   * BC Math Library for Javascript (LGPL-2.1)
    * Ported from the PHP5 bcmath extension source code,
    * which uses the Libbcmath package...
    *    Copyright (C) 1991, 1992, 1993, 1994, 1997 Free Software Foundation, Inc.
@@ -23,10 +25,9 @@ module.exports = function _bc() {
    *               Western Washington University
    *               Bellingham, WA 98226-9062
    *
-   * bcmath-js homepage:
+   * bcmath-js homepage: https://sourceforge.net/projects/bcmath-js/
    *
-   * This code is covered under the LGPL licence, and can be used however you want :)
-   * Be kind and share any decent code changes.
+   * This code is covered under the LGPL-2.1 license.
    */
 
   /**
@@ -54,7 +55,7 @@ module.exports = function _bc() {
    *               Bellingham, WA 98226-9062
    */
 
-  var Libbcmath = {
+  const Libbcmath = {
     PLUS: '+',
     MINUS: '-',
     BASE: 10,
@@ -64,27 +65,27 @@ module.exports = function _bc() {
     /**
      * Basic number structure
      */
-    bc_num: function bc_num() {
-      this.n_sign = null; // sign
-      this.n_len = null; // (int) The number of digits before the decimal point.
-      this.n_scale = null; // (int) The number of digits after the decimal point.
+    bc_num: function () {
+      this.n_sign = null // sign
+      this.n_len = null // (int) The number of digits before the decimal point.
+      this.n_scale = null // (int) The number of digits after the decimal point.
       // this.n_refs = null; // (int) The number of pointers to this number.
       // this.n_text = null; // ?? Linked list for available list.
-      this.n_value = null; // array as value, where 1.23 = [1,2,3]
+      this.n_value = null // array as value, where 1.23 = [1,2,3]
       this.toString = function () {
-        var r = void 0,
-            tmp = void 0;
-        tmp = this.n_value.join('');
+        let r
+        let tmp
+        tmp = this.n_value.join('')
 
         // add minus sign (if applicable) then add the integer part
-        r = (this.n_sign === Libbcmath.PLUS ? '' : this.n_sign) + tmp.substr(0, this.n_len);
+        r = (this.n_sign === Libbcmath.PLUS ? '' : this.n_sign) + tmp.substr(0, this.n_len)
 
         // if decimal places, add a . and the decimal part
         if (this.n_scale > 0) {
-          r += '.' + tmp.substr(this.n_len, this.n_scale);
+          r += '.' + tmp.substr(this.n_len, this.n_scale)
         }
-        return r;
-      };
+        return r
+      }
     },
 
     /**
@@ -99,38 +100,38 @@ module.exports = function _bc() {
      * @param {int} scaleMin
      * @return bc_num
      */
-    bc_add: function bc_add(n1, n2, scaleMin) {
-      var sum = void 0,
-          cmpRes = void 0,
-          resScale = void 0;
+    bc_add: function (n1, n2, scaleMin) {
+      let sum
+      let cmpRes
+      let resScale
 
       if (n1.n_sign === n2.n_sign) {
-        sum = Libbcmath._bc_do_add(n1, n2, scaleMin);
-        sum.n_sign = n1.n_sign;
+        sum = Libbcmath._bc_do_add(n1, n2, scaleMin)
+        sum.n_sign = n1.n_sign
       } else {
         // subtraction must be done.
-        cmpRes = Libbcmath._bc_do_compare(n1, n2, false, false); // Compare magnitudes.
+        cmpRes = Libbcmath._bc_do_compare(n1, n2, false, false) // Compare magnitudes.
         switch (cmpRes) {
           case -1:
             // n1 is less than n2, subtract n1 from n2.
-            sum = Libbcmath._bc_do_sub(n2, n1, scaleMin);
-            sum.n_sign = n2.n_sign;
-            break;
+            sum = Libbcmath._bc_do_sub(n2, n1, scaleMin)
+            sum.n_sign = n2.n_sign
+            break
 
           case 0:
             // They are equal! return zero with the correct scale!
-            resScale = Libbcmath.MAX(scaleMin, Libbcmath.MAX(n1.n_scale, n2.n_scale));
-            sum = Libbcmath.bc_new_num(1, resScale);
-            Libbcmath.memset(sum.n_value, 0, 0, resScale + 1);
-            break;
+            resScale = Libbcmath.MAX(scaleMin, Libbcmath.MAX(n1.n_scale, n2.n_scale))
+            sum = Libbcmath.bc_new_num(1, resScale)
+            Libbcmath.memset(sum.n_value, 0, 0, resScale + 1)
+            break
 
           case 1:
             // n2 is less than n1, subtract n2 from n1.
-            sum = Libbcmath._bc_do_sub(n1, n2, scaleMin);
-            sum.n_sign = n1.n_sign;
+            sum = Libbcmath._bc_do_sub(n1, n2, scaleMin)
+            sum.n_sign = n1.n_sign
         }
       }
-      return sum;
+      return sum
     },
 
     /**
@@ -139,72 +140,72 @@ module.exports = function _bc() {
      * @param {bc_num} n2
      * @return int -1, 0, 1  (n1 < n2, ===, n1 > n2)
      */
-    bc_compare: function bc_compare(n1, n2) {
-      return Libbcmath._bc_do_compare(n1, n2, true, false);
+    bc_compare: function (n1, n2) {
+      return Libbcmath._bc_do_compare(n1, n2, true, false)
     },
 
-    _one_mult: function _one_mult(num, nPtr, size, digit, result, rPtr) {
-      var carry = void 0,
-          value = void 0; // int
-      var nptr = void 0,
-          rptr = void 0; // int pointers
+    _one_mult: function (num, nPtr, size, digit, result, rPtr) {
+      let carry
+      let value // int
+      let nptr
+      let rptr // int pointers
       if (digit === 0) {
-        Libbcmath.memset(result, 0, 0, size); // memset (result, 0, size);
+        Libbcmath.memset(result, 0, 0, size) // memset (result, 0, size);
       } else {
         if (digit === 1) {
-          Libbcmath.memcpy(result, rPtr, num, nPtr, size); // memcpy (result, num, size);
+          Libbcmath.memcpy(result, rPtr, num, nPtr, size) // memcpy (result, num, size);
         } else {
           // Initialize
-          nptr = nPtr + size - 1; // nptr = (unsigned char *) (num+size-1);
-          rptr = rPtr + size - 1; // rptr = (unsigned char *) (result+size-1);
-          carry = 0;
+          nptr = nPtr + size - 1 // nptr = (unsigned char *) (num+size-1);
+          rptr = rPtr + size - 1 // rptr = (unsigned char *) (result+size-1);
+          carry = 0
 
           while (size-- > 0) {
-            value = num[nptr--] * digit + carry; // value = *nptr-- * digit + carry;
-            result[rptr--] = value % Libbcmath.BASE; // @CHECK cint //*rptr-- = value % BASE;
-            carry = Math.floor(value / Libbcmath.BASE); // @CHECK cint //carry = value / BASE;
+            value = num[nptr--] * digit + carry // value = *nptr-- * digit + carry;
+            result[rptr--] = value % Libbcmath.BASE // @CHECK cint //*rptr-- = value % BASE;
+            carry = Math.floor(value / Libbcmath.BASE) // @CHECK cint //carry = value / BASE;
           }
 
           if (carry !== 0) {
-            result[rptr] = carry;
+            result[rptr] = carry
           }
         }
       }
     },
 
-    bc_divide: function bc_divide(n1, n2, scale) {
+    bc_divide: function (n1, n2, scale) {
       // var quot // bc_num return
-      var qval = void 0; // bc_num
-      var num1 = void 0,
-          num2 = void 0; // string
-      var ptr1 = void 0,
-          ptr2 = void 0,
-          n2ptr = void 0,
-          qptr = void 0; // int pointers
-      var scale1 = void 0,
-          val = void 0; // int
-      var len1 = void 0,
-          len2 = void 0,
-          scale2 = void 0,
-          qdigits = void 0,
-          extra = void 0,
-          count = void 0; // int
-      var qdig = void 0,
-          qguess = void 0,
-          borrow = void 0,
-          carry = void 0; // int
-      var mval = void 0; // string
-      var zero = void 0; // char
-      var norm = void 0; // int
+      let qval // bc_num
+      let num1
+      let num2 // string
+      let ptr1
+      let ptr2
+      let n2ptr
+      let qptr // int pointers
+      let scale1
+      let val // int
+      let len1
+      let len2
+      let scale2
+      let qdigits
+      let extra
+      let count // int
+      let qdig
+      let qguess
+      let borrow
+      let carry // int
+      let mval // string
+      let zero // char
+      let norm // int
       // var ptrs // return object from one_mul
       // Test for divide by zero. (return failure)
       if (Libbcmath.bc_is_zero(n2)) {
-        return -1;
+        return -1
       }
 
       // Test for zero divide by anything (return zero)
       if (Libbcmath.bc_is_zero(n1)) {
-        return Libbcmath.bc_new_num(1, scale);
+        return Libbcmath.bc_new_num(1, scale)
       }
 
       /* Test for n1 equals n2 (return 1 as n1 nor n2 are zero)
@@ -220,12 +221,12 @@ module.exports = function _bc() {
       // (ie bc_is_zero - add bc_is_one function)
       if (n2.n_scale === 0) {
         if (n2.n_len === 1 && n2.n_value[0] === 1) {
-          qval = Libbcmath.bc_new_num(n1.n_len, scale); // qval = bc_new_num (n1->n_len, scale);
-          qval.n_sign = n1.n_sign === n2.n_sign ? Libbcmath.PLUS : Libbcmath.MINUS;
+          qval = Libbcmath.bc_new_num(n1.n_len, scale) // qval = bc_new_num (n1->n_len, scale);
+          qval.n_sign = n1.n_sign === n2.n_sign ? Libbcmath.PLUS : Libbcmath.MINUS
           // memset (&qval->n_value[n1->n_len],0,scale):
-          Libbcmath.memset(qval.n_value, n1.n_len, 0, scale);
+          Libbcmath.memset(qval.n_value, n1.n_len, 0, scale)
           // memcpy (qval->n_value, n1->n_value, n1->n_len + MIN(n1->n_scale,scale)):
-          Libbcmath.memcpy(qval.n_value, 0, n1.n_value, 0, n1.n_len + Libbcmath.MIN(n1.n_scale, scale));
+          Libbcmath.memcpy(qval.n_value, 0, n1.n_value, 0, n1.n_len + Libbcmath.MIN(n1.n_scale, scale))
           // can we return here? not in c src, but can't see why-not.
           // return qval;
         }
@@ -233,71 +234,71 @@ module.exports = function _bc() {
 
       /* Set up the divide.  Move the decimal point on n1 by n2's scale.
        Remember, zeros on the end of num2 are wasted effort for dividing. */
-      scale2 = n2.n_scale; // scale2 = n2->n_scale;
-      n2ptr = n2.n_len + scale2 - 1; // n2ptr = (unsigned char *) n2.n_value+n2.n_len+scale2-1;
+      scale2 = n2.n_scale // scale2 = n2->n_scale;
+      n2ptr = n2.n_len + scale2 - 1 // n2ptr = (unsigned char *) n2.n_value+n2.n_len+scale2-1;
       while (scale2 > 0 && n2.n_value[n2ptr--] === 0) {
-        scale2--;
+        scale2--
       }
 
-      len1 = n1.n_len + scale2;
-      scale1 = n1.n_scale - scale2;
+      len1 = n1.n_len + scale2
+      scale1 = n1.n_scale - scale2
       if (scale1 < scale) {
-        extra = scale - scale1;
+        extra = scale - scale1
       } else {
-        extra = 0;
+        extra = 0
       }
 
       // num1 = (unsigned char *) safe_emalloc (1, n1.n_len+n1.n_scale, extra+2):
-      num1 = Libbcmath.safe_emalloc(1, n1.n_len + n1.n_scale, extra + 2);
+      num1 = Libbcmath.safe_emalloc(1, n1.n_len + n1.n_scale, extra + 2)
       if (num1 === null) {
-        Libbcmath.bc_out_of_memory();
+        Libbcmath.bc_out_of_memory()
       }
       // memset (num1, 0, n1->n_len+n1->n_scale+extra+2):
-      Libbcmath.memset(num1, 0, 0, n1.n_len + n1.n_scale + extra + 2);
+      Libbcmath.memset(num1, 0, 0, n1.n_len + n1.n_scale + extra + 2)
       // memcpy (num1+1, n1.n_value, n1.n_len+n1.n_scale):
-      Libbcmath.memcpy(num1, 1, n1.n_value, 0, n1.n_len + n1.n_scale);
+      Libbcmath.memcpy(num1, 1, n1.n_value, 0, n1.n_len + n1.n_scale)
       // len2 = n2->n_len + scale2:
-      len2 = n2.n_len + scale2;
+      len2 = n2.n_len + scale2
       // num2 = (unsigned char *) safe_emalloc (1, len2, 1):
-      num2 = Libbcmath.safe_emalloc(1, len2, 1);
+      num2 = Libbcmath.safe_emalloc(1, len2, 1)
       if (num2 === null) {
-        Libbcmath.bc_out_of_memory();
+        Libbcmath.bc_out_of_memory()
       }
       // memcpy (num2, n2.n_value, len2):
-      Libbcmath.memcpy(num2, 0, n2.n_value, 0, len2);
+      Libbcmath.memcpy(num2, 0, n2.n_value, 0, len2)
       // *(num2+len2) = 0:
-      num2[len2] = 0;
+      num2[len2] = 0
       // n2ptr = num2:
-      n2ptr = 0;
+      n2ptr = 0
       // while (*n2ptr === 0):
       while (num2[n2ptr] === 0) {
-        n2ptr++;
-        len2--;
+        n2ptr++
+        len2--
       }
 
       // Calculate the number of quotient digits.
       if (len2 > len1 + scale) {
-        qdigits = scale + 1;
-        zero = true;
+        qdigits = scale + 1
+        zero = true
       } else {
-        zero = false;
+        zero = false
         if (len2 > len1) {
-          qdigits = scale + 1; // One for the zero integer part.
+          qdigits = scale + 1 // One for the zero integer part.
         } else {
-          qdigits = len1 - len2 + scale + 1;
+          qdigits = len1 - len2 + scale + 1
         }
       }
 
       // Allocate and zero the storage for the quotient.
       // qval = bc_new_num (qdigits-scale,scale);
-      qval = Libbcmath.bc_new_num(qdigits - scale, scale);
+      qval = Libbcmath.bc_new_num(qdigits - scale, scale)
       // memset (qval->n_value, 0, qdigits);
-      Libbcmath.memset(qval.n_value, 0, 0, qdigits);
+      Libbcmath.memset(qval.n_value, 0, 0, qdigits)
       // Allocate storage for the temporary storage mval.
       // mval = (unsigned char *) safe_emalloc (1, len2, 1);
-      mval = Libbcmath.safe_emalloc(1, len2, 1);
+      mval = Libbcmath.safe_emalloc(1, len2, 1)
       if (mval === null) {
-        Libbcmath.bc_out_of_memory();
+        Libbcmath.bc_out_of_memory()
       }
 
       // Now for the full divide algorithm.
@@ -305,121 +306,127 @@ module.exports = function _bc() {
         // Normalize
         // norm = Libbcmath.cint(10 / (Libbcmath.cint(n2.n_value[n2ptr]) + 1));
         // norm =  10 / ((int)*n2ptr + 1)
-        norm = Math.floor(10 / (n2.n_value[n2ptr] + 1)); // norm =  10 / ((int)*n2ptr + 1);
+        norm = Math.floor(10 / (n2.n_value[n2ptr] + 1)) // norm =  10 / ((int)*n2ptr + 1);
         if (norm !== 1) {
           // Libbcmath._one_mult(num1, len1+scale1+extra+1, norm, num1);
-          Libbcmath._one_mult(num1, 0, len1 + scale1 + extra + 1, norm, num1, 0);
+          Libbcmath._one_mult(num1, 0, len1 + scale1 + extra + 1, norm, num1, 0)
           // Libbcmath._one_mult(n2ptr, len2, norm, n2ptr);
-          Libbcmath._one_mult(n2.n_value, n2ptr, len2, norm, n2.n_value, n2ptr);
+          Libbcmath._one_mult(n2.n_value, n2ptr, len2, norm, n2.n_value, n2ptr)
           // @todo: Check: Is the pointer affected by the call? if so,
           // maybe need to adjust points on return?
         }
 
         // Initialize divide loop.
-        qdig = 0;
+        qdig = 0
         if (len2 > len1) {
-          qptr = len2 - len1; // qptr = (unsigned char *) qval.n_value+len2-len1;
+          qptr = len2 - len1 // qptr = (unsigned char *) qval.n_value+len2-len1;
         } else {
-          qptr = 0; // qptr = (unsigned char *) qval.n_value;
+          qptr = 0 // qptr = (unsigned char *) qval.n_value;
         }
 
         // Loop
         while (qdig <= len1 + scale - len2) {
           // Calculate the quotient digit guess.
           if (n2.n_value[n2ptr] === num1[qdig]) {
-            qguess = 9;
+            qguess = 9
           } else {
-            qguess = Math.floor((num1[qdig] * 10 + num1[qdig + 1]) / n2.n_value[n2ptr]);
+            qguess = Math.floor((num1[qdig] * 10 + num1[qdig + 1]) / n2.n_value[n2ptr])
           }
           // Test qguess.
 
-          if (n2.n_value[n2ptr + 1] * qguess > (num1[qdig] * 10 + num1[qdig + 1] - n2.n_value[n2ptr] * qguess) * 10 + num1[qdig + 2]) {
-            qguess--;
+          if (
+            n2.n_value[n2ptr + 1] * qguess >
+            (num1[qdig] * 10 + num1[qdig + 1] - n2.n_value[n2ptr] * qguess) * 10 + num1[qdig + 2]
+          ) {
+            qguess--
             // And again.
-            if (n2.n_value[n2ptr + 1] * qguess > (num1[qdig] * 10 + num1[qdig + 1] - n2.n_value[n2ptr] * qguess) * 10 + num1[qdig + 2]) {
-              qguess--;
+            if (
+              n2.n_value[n2ptr + 1] * qguess >
+              (num1[qdig] * 10 + num1[qdig + 1] - n2.n_value[n2ptr] * qguess) * 10 + num1[qdig + 2]
+            ) {
+              qguess--
             }
           }
 
           // Multiply and subtract.
-          borrow = 0;
+          borrow = 0
           if (qguess !== 0) {
-            mval[0] = 0; //* mval = 0; // @CHECK is this to fix ptr2 < 0?
+            mval[0] = 0 //* mval = 0; // @CHECK is this to fix ptr2 < 0?
             // _one_mult (n2ptr, len2, qguess, mval+1); // @CHECK
-            Libbcmath._one_mult(n2.n_value, n2ptr, len2, qguess, mval, 1);
-            ptr1 = qdig + len2; // (unsigned char *) num1+qdig+len2;
-            ptr2 = len2; // (unsigned char *) mval+len2;
+            Libbcmath._one_mult(n2.n_value, n2ptr, len2, qguess, mval, 1)
+            ptr1 = qdig + len2 // (unsigned char *) num1+qdig+len2;
+            ptr2 = len2 // (unsigned char *) mval+len2;
             // @todo: CHECK: Does a negative pointer return null?
             // ptr2 can be < 0 here as ptr1 = len2, thus count < len2+1 will always fail ?
             for (count = 0; count < len2 + 1; count++) {
               if (ptr2 < 0) {
                 // val = Libbcmath.cint(num1[ptr1]) - 0 - borrow;
                 // val = (int) *ptr1 - (int) *ptr2-- - borrow;
-                val = num1[ptr1] - 0 - borrow; // val = (int) *ptr1 - (int) *ptr2-- - borrow;
+                val = num1[ptr1] - 0 - borrow // val = (int) *ptr1 - (int) *ptr2-- - borrow;
               } else {
                 // val = Libbcmath.cint(num1[ptr1]) - Libbcmath.cint(mval[ptr2--]) - borrow;
                 // val = (int) *ptr1 - (int) *ptr2-- - borrow;
                 // val = (int) *ptr1 - (int) *ptr2-- - borrow;
-                val = num1[ptr1] - mval[ptr2--] - borrow;
+                val = num1[ptr1] - mval[ptr2--] - borrow
               }
               if (val < 0) {
-                val += 10;
-                borrow = 1;
+                val += 10
+                borrow = 1
               } else {
-                borrow = 0;
+                borrow = 0
               }
-              num1[ptr1--] = val;
+              num1[ptr1--] = val
             }
           }
 
           // Test for negative result.
           if (borrow === 1) {
-            qguess--;
-            ptr1 = qdig + len2; // (unsigned char *) num1+qdig+len2;
-            ptr2 = len2 - 1; // (unsigned char *) n2ptr+len2-1;
-            carry = 0;
+            qguess--
+            ptr1 = qdig + len2 // (unsigned char *) num1+qdig+len2;
+            ptr2 = len2 - 1 // (unsigned char *) n2ptr+len2-1;
+            carry = 0
             for (count = 0; count < len2; count++) {
               if (ptr2 < 0) {
                 // val = Libbcmath.cint(num1[ptr1]) + 0 + carry;
                 // val = (int) *ptr1 + (int) *ptr2-- + carry;
                 // val = (int) *ptr1 + (int) *ptr2-- + carry;
-                val = num1[ptr1] + 0 + carry;
+                val = num1[ptr1] + 0 + carry
               } else {
                 // val = Libbcmath.cint(num1[ptr1]) + Libbcmath.cint(n2.n_value[ptr2--]) + carry;
                 // val = (int) *ptr1 + (int) *ptr2-- + carry;
                 // val = (int) *ptr1 + (int) *ptr2-- + carry;
-                val = num1[ptr1] + n2.n_value[ptr2--] + carry;
+                val = num1[ptr1] + n2.n_value[ptr2--] + carry
               }
               if (val > 9) {
-                val -= 10;
-                carry = 1;
+                val -= 10
+                carry = 1
               } else {
-                carry = 0;
+                carry = 0
               }
-              num1[ptr1--] = val; //* ptr1-- = val;
+              num1[ptr1--] = val //* ptr1-- = val;
             }
             if (carry === 1) {
               // num1[ptr1] = Libbcmath.cint((num1[ptr1] + 1) % 10);
               // *ptr1 = (*ptr1 + 1) % 10; // @CHECK
               // *ptr1 = (*ptr1 + 1) % 10; // @CHECK
-              num1[ptr1] = (num1[ptr1] + 1) % 10;
+              num1[ptr1] = (num1[ptr1] + 1) % 10
             }
           }
 
           // We now know the quotient digit.
-          qval.n_value[qptr++] = qguess; //* qptr++ =  qguess;
-          qdig++;
+          qval.n_value[qptr++] = qguess //* qptr++ =  qguess;
+          qdig++
         }
       }
 
       // Clean up and return the number.
-      qval.n_sign = n1.n_sign === n2.n_sign ? Libbcmath.PLUS : Libbcmath.MINUS;
+      qval.n_sign = n1.n_sign === n2.n_sign ? Libbcmath.PLUS : Libbcmath.MINUS
       if (Libbcmath.bc_is_zero(qval)) {
-        qval.n_sign = Libbcmath.PLUS;
+        qval.n_sign = Libbcmath.PLUS
       }
-      Libbcmath._bc_rm_leading_zeros(qval);
+      Libbcmath._bc_rm_leading_zeros(qval)
 
-      return qval;
+      return qval
 
       // return 0;    // Everything is OK.
     },
@@ -429,161 +436,159 @@ module.exports = function _bc() {
     // #define MUL_SMALL_DIGITS mul_base_digits/4
 
     /* The multiply routine.  N2 times N1 is put int PROD with the scale of
-    the result being MIN(N2 scale+N1 scale, MAX (SCALE, N2 scale, N1 scale)).
-    */
+   the result being MIN(N2 scale+N1 scale, MAX (SCALE, N2 scale, N1 scale)).
+   */
     /**
      * @param n1 bc_num
      * @param n2 bc_num
      * @param scale [int] optional
      */
-    bc_multiply: function bc_multiply(n1, n2, scale) {
-      var pval = void 0; // bc_num
-      var len1 = void 0,
-          len2 = void 0; // int
-      var fullScale = void 0,
-          prodScale = void 0; // int
+    bc_multiply: function (n1, n2, scale) {
+      let pval // bc_num
+      let len1
+      let len2 // int
+      let fullScale
+      let prodScale // int
       // Initialize things.
-      len1 = n1.n_len + n1.n_scale;
-      len2 = n2.n_len + n2.n_scale;
-      fullScale = n1.n_scale + n2.n_scale;
-      prodScale = Libbcmath.MIN(fullScale, Libbcmath.MAX(scale, Libbcmath.MAX(n1.n_scale, n2.n_scale)));
+      len1 = n1.n_len + n1.n_scale
+      len2 = n2.n_len + n2.n_scale
+      fullScale = n1.n_scale + n2.n_scale
+      prodScale = Libbcmath.MIN(fullScale, Libbcmath.MAX(scale, Libbcmath.MAX(n1.n_scale, n2.n_scale)))
 
       // pval = Libbcmath.bc_init_num(); // allow pass by ref
       // Do the multiply
-      pval = Libbcmath._bc_rec_mul(n1, len1, n2, len2, fullScale);
+      pval = Libbcmath._bc_rec_mul(n1, len1, n2, len2, fullScale)
 
       // Assign to prod and clean up the number.
-      pval.n_sign = n1.n_sign === n2.n_sign ? Libbcmath.PLUS : Libbcmath.MINUS;
+      pval.n_sign = n1.n_sign === n2.n_sign ? Libbcmath.PLUS : Libbcmath.MINUS
       // pval.n_value = pval.nPtr;
-      pval.n_len = len2 + len1 + 1 - fullScale;
-      pval.n_scale = prodScale;
-      Libbcmath._bc_rm_leading_zeros(pval);
+      pval.n_len = len2 + len1 + 1 - fullScale
+      pval.n_scale = prodScale
+      Libbcmath._bc_rm_leading_zeros(pval)
       if (Libbcmath.bc_is_zero(pval)) {
-        pval.n_sign = Libbcmath.PLUS;
+        pval.n_sign = Libbcmath.PLUS
       }
       // bc_free_num (prod);
-      return pval;
+      return pval
     },
 
-    new_sub_num: function new_sub_num(length, scale, value) {
-      var ptr = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
-
-      var temp = new Libbcmath.bc_num(); // eslint-disable-line new-cap
-      temp.n_sign = Libbcmath.PLUS;
-      temp.n_len = length;
-      temp.n_scale = scale;
-      temp.n_value = Libbcmath.safe_emalloc(1, length + scale, 0);
-      Libbcmath.memcpy(temp.n_value, 0, value, ptr, length + scale);
-      return temp;
+    new_sub_num: function (length, scale, value, ptr = 0) {
+      const temp = new Libbcmath.bc_num()
+      temp.n_sign = Libbcmath.PLUS
+      temp.n_len = length
+      temp.n_scale = scale
+      temp.n_value = Libbcmath.safe_emalloc(1, length + scale, 0)
+      Libbcmath.memcpy(temp.n_value, 0, value, ptr, length + scale)
+      return temp
     },
 
-    _bc_simp_mul: function _bc_simp_mul(n1, n1len, n2, n2len, fullScale) {
-      var prod = void 0; // bc_num
-      var n1ptr = void 0,
-          n2ptr = void 0,
-          pvptr = void 0; // char *n1ptr, *n2ptr, *pvptr;
-      var n1end = void 0,
-          n2end = void 0; // char *n1end, *n2end;        // To the end of n1 and n2.
-      var indx = void 0,
-          sum = void 0,
-          prodlen = void 0; // int indx, sum, prodlen;
-      prodlen = n1len + n2len + 1;
-
-      prod = Libbcmath.bc_new_num(prodlen, 0);
-
-      n1end = n1len - 1; // (char *) (n1->n_value + n1len - 1);
-      n2end = n2len - 1; // (char *) (n2->n_value + n2len - 1);
-      pvptr = prodlen - 1; // (char *) ((*prod)->n_value + prodlen - 1);
-      sum = 0;
+    _bc_simp_mul: function (n1, n1len, n2, n2len, fullScale) {
+      let prod // bc_num
+      let n1ptr
+      let n2ptr
+      let pvptr // char *n1ptr, *n2ptr, *pvptr;
+      let n1end
+      let n2end // char *n1end, *n2end;        // To the end of n1 and n2.
+      let indx
+      let sum
+      let prodlen // int indx, sum, prodlen;
+      prodlen = n1len + n2len + 1
+
+      prod = Libbcmath.bc_new_num(prodlen, 0)
+
+      n1end = n1len - 1 // (char *) (n1->n_value + n1len - 1);
+      n2end = n2len - 1 // (char *) (n2->n_value + n2len - 1);
+      pvptr = prodlen - 1 // (char *) ((*prod)->n_value + prodlen - 1);
+      sum = 0
 
       // Here is the loop...
       for (indx = 0; indx < prodlen - 1; indx++) {
         // (char *) (n1end - MAX(0, indx-n2len+1));
-        n1ptr = n1end - Libbcmath.MAX(0, indx - n2len + 1);
+        n1ptr = n1end - Libbcmath.MAX(0, indx - n2len + 1)
         // (char *) (n2end - MIN(indx, n2len-1));
-        n2ptr = n2end - Libbcmath.MIN(indx, n2len - 1);
+        n2ptr = n2end - Libbcmath.MIN(indx, n2len - 1)
         while (n1ptr >= 0 && n2ptr <= n2end) {
           // sum += *n1ptr-- * *n2ptr++;
-          sum += n1.n_value[n1ptr--] * n2.n_value[n2ptr++];
+          sum += n1.n_value[n1ptr--] * n2.n_value[n2ptr++]
         }
         //* pvptr-- = sum % BASE;
-        prod.n_value[pvptr--] = Math.floor(sum % Libbcmath.BASE);
-        sum = Math.floor(sum / Libbcmath.BASE); // sum = sum / BASE;
+        prod.n_value[pvptr--] = Math.floor(sum % Libbcmath.BASE)
+        sum = Math.floor(sum / Libbcmath.BASE) // sum = sum / BASE;
       }
-      prod.n_value[pvptr] = sum; //* pvptr = sum;
-      return prod;
+      prod.n_value[pvptr] = sum //* pvptr = sum;
+      return prod
     },
 
     /* A special adder/subtractor for the recursive divide and conquer
        multiply algorithm.  Note: if sub is called, accum must
        be larger that what is being subtracted.  Also, accum and val
        must have n_scale = 0.  (e.g. they must look like integers. *) */
-    _bc_shift_addsub: function _bc_shift_addsub(accum, val, shift, sub) {
-      var accp = void 0,
-          valp = void 0; // signed char *accp, *valp;
-      var count = void 0,
-          carry = void 0; // int  count, carry;
-      count = val.n_len;
+    _bc_shift_addsub: function (accum, val, shift, sub) {
+      let accp
+      let valp // signed char *accp, *valp;
+      let count
+      let carry // int  count, carry;
+      count = val.n_len
       if (val.n_value[0] === 0) {
-        count--;
+        count--
       }
 
       // assert (accum->n_len+accum->n_scale >= shift+count);
       if (accum.n_len + accum.n_scale < shift + count) {
-        throw new Error('len + scale < shift + count'); // ?? I think that's what assert does :)
+        throw new Error('len + scale < shift + count') // ?? I think that's what assert does :)
       }
 
       // Set up pointers and others
       // (signed char *)(accum->n_value + accum->n_len + accum->n_scale - shift - 1);
-      accp = accum.n_len + accum.n_scale - shift - 1;
-      valp = val.n_len - 1; // (signed char *)(val->n_value + val->n_len - 1);
-      carry = 0;
+      accp = accum.n_len + accum.n_scale - shift - 1
+      valp = val.n_len - 1 // (signed char *)(val->n_value + val->n_len - 1);
+      carry = 0
       if (sub) {
         // Subtraction, carry is really borrow.
         while (count--) {
-          accum.n_value[accp] -= val.n_value[valp--] + carry; //* accp -= *valp-- + carry;
+          accum.n_value[accp] -= val.n_value[valp--] + carry //* accp -= *valp-- + carry;
           if (accum.n_value[accp] < 0) {
             // if (*accp < 0)
-            carry = 1;
-            accum.n_value[accp--] += Libbcmath.BASE; //* accp-- += BASE;
+            carry = 1
+            accum.n_value[accp--] += Libbcmath.BASE //* accp-- += BASE;
           } else {
-            carry = 0;
-            accp--;
+            carry = 0
+            accp--
           }
         }
         while (carry) {
-          accum.n_value[accp] -= carry; //* accp -= carry;
+          accum.n_value[accp] -= carry //* accp -= carry;
           if (accum.n_value[accp] < 0) {
             // if (*accp < 0)
-            accum.n_value[accp--] += Libbcmath.BASE; //    *accp-- += BASE;
+            accum.n_value[accp--] += Libbcmath.BASE //    *accp-- += BASE;
           } else {
-            carry = 0;
+            carry = 0
           }
         }
       } else {
         // Addition
         while (count--) {
-          accum.n_value[accp] += val.n_value[valp--] + carry; //* accp += *valp-- + carry;
+          accum.n_value[accp] += val.n_value[valp--] + carry //* accp += *valp-- + carry;
           if (accum.n_value[accp] > Libbcmath.BASE - 1) {
             // if (*accp > (BASE-1))
-            carry = 1;
-            accum.n_value[accp--] -= Libbcmath.BASE; //* accp-- -= BASE;
+            carry = 1
+            accum.n_value[accp--] -= Libbcmath.BASE //* accp-- -= BASE;
           } else {
-            carry = 0;
-            accp--;
+            carry = 0
+            accp--
           }
         }
         while (carry) {
-          accum.n_value[accp] += carry; //* accp += carry;
+          accum.n_value[accp] += carry //* accp += carry;
           if (accum.n_value[accp] > Libbcmath.BASE - 1) {
             // if (*accp > (BASE-1))
-            accum.n_value[accp--] -= Libbcmath.BASE; //* accp-- -= BASE;
+            accum.n_value[accp--] -= Libbcmath.BASE //* accp-- -= BASE;
           } else {
-            carry = 0;
+            carry = 0
           }
         }
       }
-      return true; // accum is the pass-by-reference return
+      return true // accum is the pass-by-reference return
     },
 
     /* Recursive divide and conquer multiply algorithm.
@@ -591,101 +596,106 @@ module.exports = function _bc() {
        Let u = u0 + u1*(b^n)
        Let v = v0 + v1*(b^n)
        Then uv = (B^2n+B^n)*u1*v1 + B^n*(u1-u0)*(v0-v1) + (B^n+1)*u0*v0
-        B is the base of storage, number of digits in u1,u0 close to equal.
+
+       B is the base of storage, number of digits in u1,u0 close to equal.
     */
-    _bc_rec_mul: function _bc_rec_mul(u, ulen, v, vlen, fullScale) {
-      var prod = void 0; // @return
-      var u0 = void 0,
-          u1 = void 0,
-          v0 = void 0,
-          v1 = void 0; // bc_num
+    _bc_rec_mul: function (u, ulen, v, vlen, fullScale) {
+      let prod // @return
+      let u0
+      let u1
+      let v0
+      let v1 // bc_num
       // var u0len,
       // var v0len // int
-      var m1 = void 0,
-          m2 = void 0,
-          m3 = void 0,
-          d1 = void 0,
-          d2 = void 0; // bc_num
-      var n = void 0,
-          prodlen = void 0,
-          m1zero = void 0; // int
-      var d1len = void 0,
-          d2len = void 0; // int
+      let m1
+      let m2
+      let m3
+      let d1
+      let d2 // bc_num
+      let n
+      let prodlen
+      let m1zero // int
+      let d1len
+      let d2len // int
       // Base case?
-      if (ulen + vlen < Libbcmath.MUL_BASE_DIGITS || ulen < Libbcmath.MUL_SMALL_DIGITS || vlen < Libbcmath.MUL_SMALL_DIGITS) {
-        return Libbcmath._bc_simp_mul(u, ulen, v, vlen, fullScale);
+      if (
+        ulen + vlen < Libbcmath.MUL_BASE_DIGITS ||
+        ulen < Libbcmath.MUL_SMALL_DIGITS ||
+        vlen < Libbcmath.MUL_SMALL_DIGITS
+      ) {
+        return Libbcmath._bc_simp_mul(u, ulen, v, vlen, fullScale)
       }
 
       // Calculate n -- the u and v split point in digits.
-      n = Math.floor((Libbcmath.MAX(ulen, vlen) + 1) / 2);
+      n = Math.floor((Libbcmath.MAX(ulen, vlen) + 1) / 2)
 
       // Split u and v.
       if (ulen < n) {
-        u1 = Libbcmath.bc_init_num(); // u1 = bc_copy_num (BCG(_zero_));
-        u0 = Libbcmath.new_sub_num(ulen, 0, u.n_value);
+        u1 = Libbcmath.bc_init_num() // u1 = bc_copy_num (BCG(_zero_));
+        u0 = Libbcmath.new_sub_num(ulen, 0, u.n_value)
       } else {
-        u1 = Libbcmath.new_sub_num(ulen - n, 0, u.n_value);
-        u0 = Libbcmath.new_sub_num(n, 0, u.n_value, ulen - n);
+        u1 = Libbcmath.new_sub_num(ulen - n, 0, u.n_value)
+        u0 = Libbcmath.new_sub_num(n, 0, u.n_value, ulen - n)
       }
       if (vlen < n) {
-        v1 = Libbcmath.bc_init_num(); // bc_copy_num (BCG(_zero_));
-        v0 = Libbcmath.new_sub_num(vlen, 0, v.n_value);
+        v1 = Libbcmath.bc_init_num() // bc_copy_num (BCG(_zero_));
+        v0 = Libbcmath.new_sub_num(vlen, 0, v.n_value)
       } else {
-        v1 = Libbcmath.new_sub_num(vlen - n, 0, v.n_value);
-        v0 = Libbcmath.new_sub_num(n, 0, v.n_value, vlen - n);
+        v1 = Libbcmath.new_sub_num(vlen - n, 0, v.n_value)
+        v0 = Libbcmath.new_sub_num(n, 0, v.n_value, vlen - n)
       }
-      Libbcmath._bc_rm_leading_zeros(u1);
-      Libbcmath._bc_rm_leading_zeros(u0);
+      Libbcmath._bc_rm_leading_zeros(u1)
+      Libbcmath._bc_rm_leading_zeros(u0)
       // var u0len = u0.n_len
-      Libbcmath._bc_rm_leading_zeros(v1);
-      Libbcmath._bc_rm_leading_zeros(v0);
+      Libbcmath._bc_rm_leading_zeros(v1)
+      Libbcmath._bc_rm_leading_zeros(v0)
       // var v0len = v0.n_len
 
-      m1zero = Libbcmath.bc_is_zero(u1) || Libbcmath.bc_is_zero(v1);
+      m1zero = Libbcmath.bc_is_zero(u1) || Libbcmath.bc_is_zero(v1)
 
       // Calculate sub results ...
-      d1 = Libbcmath.bc_init_num(); // needed?
-      d2 = Libbcmath.bc_init_num(); // needed?
-      d1 = Libbcmath.bc_sub(u1, u0, 0);
-      d1len = d1.n_len;
+      d1 = Libbcmath.bc_init_num() // needed?
+      d2 = Libbcmath.bc_init_num() // needed?
+      d1 = Libbcmath.bc_sub(u1, u0, 0)
+      d1len = d1.n_len
 
-      d2 = Libbcmath.bc_sub(v0, v1, 0);
-      d2len = d2.n_len;
+      d2 = Libbcmath.bc_sub(v0, v1, 0)
+      d2len = d2.n_len
 
       // Do recursive multiplies and shifted adds.
       if (m1zero) {
-        m1 = Libbcmath.bc_init_num(); // bc_copy_num (BCG(_zero_));
+        m1 = Libbcmath.bc_init_num() // bc_copy_num (BCG(_zero_));
       } else {
         // m1 = Libbcmath.bc_init_num(); //allow pass-by-ref
-        m1 = Libbcmath._bc_rec_mul(u1, u1.n_len, v1, v1.n_len, 0);
+        m1 = Libbcmath._bc_rec_mul(u1, u1.n_len, v1, v1.n_len, 0)
       }
       if (Libbcmath.bc_is_zero(d1) || Libbcmath.bc_is_zero(d2)) {
-        m2 = Libbcmath.bc_init_num(); // bc_copy_num (BCG(_zero_));
+        m2 = Libbcmath.bc_init_num() // bc_copy_num (BCG(_zero_));
       } else {
         // m2 = Libbcmath.bc_init_num(); //allow pass-by-ref
-        m2 = Libbcmath._bc_rec_mul(d1, d1len, d2, d2len, 0);
+        m2 = Libbcmath._bc_rec_mul(d1, d1len, d2, d2len, 0)
       }
 
       if (Libbcmath.bc_is_zero(u0) || Libbcmath.bc_is_zero(v0)) {
-        m3 = Libbcmath.bc_init_num(); // bc_copy_num (BCG(_zero_));
+        m3 = Libbcmath.bc_init_num() // bc_copy_num (BCG(_zero_));
       } else {
         // m3 = Libbcmath.bc_init_num(); //allow pass-by-ref
-        m3 = Libbcmath._bc_rec_mul(u0, u0.n_len, v0, v0.n_len, 0);
+        m3 = Libbcmath._bc_rec_mul(u0, u0.n_len, v0, v0.n_len, 0)
       }
 
       // Initialize product
-      prodlen = ulen + vlen + 1;
-      prod = Libbcmath.bc_new_num(prodlen, 0);
+      prodlen = ulen + vlen + 1
+      prod = Libbcmath.bc_new_num(prodlen, 0)
 
       if (!m1zero) {
-        Libbcmath._bc_shift_addsub(prod, m1, 2 * n, 0);
-        Libbcmath._bc_shift_addsub(prod, m1, n, 0);
+        Libbcmath._bc_shift_addsub(prod, m1, 2 * n, 0)
+        Libbcmath._bc_shift_addsub(prod, m1, n, 0)
       }
-      Libbcmath._bc_shift_addsub(prod, m3, n, 0);
-      Libbcmath._bc_shift_addsub(prod, m3, 0, 0);
-      Libbcmath._bc_shift_addsub(prod, m2, n, d1.n_sign !== d2.n_sign);
+      Libbcmath._bc_shift_addsub(prod, m3, n, 0)
+      Libbcmath._bc_shift_addsub(prod, m3, 0, 0)
+      Libbcmath._bc_shift_addsub(prod, m2, n, d1.n_sign !== d2.n_sign)
 
-      return prod;
+      return prod
       // Now clean up!
       // bc_free_num (&u1);
       // bc_free_num (&u0);
@@ -706,17 +716,17 @@ module.exports = function _bc() {
      * @param {boolean} ignoreLast
      * @return -1, 0, 1 (see bc_compare)
      */
-    _bc_do_compare: function _bc_do_compare(n1, n2, useSign, ignoreLast) {
-      var n1ptr = void 0,
-          n2ptr = void 0; // int
-      var count = void 0; // int
+    _bc_do_compare: function (n1, n2, useSign, ignoreLast) {
+      let n1ptr
+      let n2ptr // int
+      let count // int
       // First, compare signs.
       if (useSign && n1.n_sign !== n2.n_sign) {
         if (n1.n_sign === Libbcmath.PLUS) {
-          return 1; // Positive N1 > Negative N2
+          return 1 // Positive N1 > Negative N2
         } else {
-            return -1; // Negative N1 < Positive N1
-          }
+          return -1 // Negative N1 < Positive N1
+        }
       }
 
       // Now compare the magnitude.
@@ -724,50 +734,50 @@ module.exports = function _bc() {
         if (n1.n_len > n2.n_len) {
           // Magnitude of n1 > n2.
           if (!useSign || n1.n_sign === Libbcmath.PLUS) {
-            return 1;
+            return 1
           } else {
-            return -1;
+            return -1
           }
         } else {
           // Magnitude of n1 < n2.
           if (!useSign || n1.n_sign === Libbcmath.PLUS) {
-            return -1;
+            return -1
           } else {
-            return 1;
+            return 1
           }
         }
       }
 
       /* If we get here, they have the same number of integer digits.
-      check the integer part and the equal length part of the fraction. */
-      count = n1.n_len + Math.min(n1.n_scale, n2.n_scale);
-      n1ptr = 0;
-      n2ptr = 0;
+     check the integer part and the equal length part of the fraction. */
+      count = n1.n_len + Math.min(n1.n_scale, n2.n_scale)
+      n1ptr = 0
+      n2ptr = 0
 
       while (count > 0 && n1.n_value[n1ptr] === n2.n_value[n2ptr]) {
-        n1ptr++;
-        n2ptr++;
-        count--;
+        n1ptr++
+        n2ptr++
+        count--
       }
 
       if (ignoreLast && count === 1 && n1.n_scale === n2.n_scale) {
-        return 0;
+        return 0
       }
 
       if (count !== 0) {
         if (n1.n_value[n1ptr] > n2.n_value[n2ptr]) {
           // Magnitude of n1 > n2.
           if (!useSign || n1.n_sign === Libbcmath.PLUS) {
-            return 1;
+            return 1
           } else {
-            return -1;
+            return -1
           }
         } else {
           // Magnitude of n1 < n2.
           if (!useSign || n1.n_sign === Libbcmath.PLUS) {
-            return -1;
+            return -1
           } else {
-            return 1;
+            return 1
           }
         }
       }
@@ -779,9 +789,9 @@ module.exports = function _bc() {
             if (n1.n_value[n1ptr++] !== 0) {
               // Magnitude of n1 > n2.
               if (!useSign || n1.n_sign === Libbcmath.PLUS) {
-                return 1;
+                return 1
               } else {
-                return -1;
+                return -1
               }
             }
           }
@@ -790,9 +800,9 @@ module.exports = function _bc() {
             if (n2.n_value[n2ptr++] !== 0) {
               // Magnitude of n1 < n2.
               if (!useSign || n1.n_sign === Libbcmath.PLUS) {
-                return -1;
+                return -1
               } else {
-                return 1;
+                return 1
               }
             }
           }
@@ -800,72 +810,72 @@ module.exports = function _bc() {
       }
 
       // They must be equal!
-      return 0;
+      return 0
     },
 
     /* Here is the full subtract routine that takes care of negative numbers.
-    N2 is subtracted from N1 and the result placed in RESULT.  SCALE_MIN
-    is the minimum scale for the result. */
-    bc_sub: function bc_sub(n1, n2, scaleMin) {
-      var diff = void 0; // bc_num
-      var cmpRes = void 0,
-          resScale = void 0; // int
+   N2 is subtracted from N1 and the result placed in RESULT.  SCALE_MIN
+   is the minimum scale for the result. */
+    bc_sub: function (n1, n2, scaleMin) {
+      let diff // bc_num
+      let cmpRes
+      let resScale // int
       if (n1.n_sign !== n2.n_sign) {
-        diff = Libbcmath._bc_do_add(n1, n2, scaleMin);
-        diff.n_sign = n1.n_sign;
+        diff = Libbcmath._bc_do_add(n1, n2, scaleMin)
+        diff.n_sign = n1.n_sign
       } else {
         // subtraction must be done.
         // Compare magnitudes.
-        cmpRes = Libbcmath._bc_do_compare(n1, n2, false, false);
+        cmpRes = Libbcmath._bc_do_compare(n1, n2, false, false)
         switch (cmpRes) {
           case -1:
             // n1 is less than n2, subtract n1 from n2.
-            diff = Libbcmath._bc_do_sub(n2, n1, scaleMin);
-            diff.n_sign = n2.n_sign === Libbcmath.PLUS ? Libbcmath.MINUS : Libbcmath.PLUS;
-            break;
+            diff = Libbcmath._bc_do_sub(n2, n1, scaleMin)
+            diff.n_sign = n2.n_sign === Libbcmath.PLUS ? Libbcmath.MINUS : Libbcmath.PLUS
+            break
           case 0:
             // They are equal! return zero!
-            resScale = Libbcmath.MAX(scaleMin, Libbcmath.MAX(n1.n_scale, n2.n_scale));
-            diff = Libbcmath.bc_new_num(1, resScale);
-            Libbcmath.memset(diff.n_value, 0, 0, resScale + 1);
-            break;
+            resScale = Libbcmath.MAX(scaleMin, Libbcmath.MAX(n1.n_scale, n2.n_scale))
+            diff = Libbcmath.bc_new_num(1, resScale)
+            Libbcmath.memset(diff.n_value, 0, 0, resScale + 1)
+            break
           case 1:
             // n2 is less than n1, subtract n2 from n1.
-            diff = Libbcmath._bc_do_sub(n1, n2, scaleMin);
-            diff.n_sign = n1.n_sign;
-            break;
+            diff = Libbcmath._bc_do_sub(n1, n2, scaleMin)
+            diff.n_sign = n1.n_sign
+            break
         }
       }
 
       // Clean up and return.
       // bc_free_num (result);
       //* result = diff;
-      return diff;
+      return diff
     },
 
-    _bc_do_add: function _bc_do_add(n1, n2, scaleMin) {
-      var sum = void 0; // bc_num
-      var sumScale = void 0,
-          sumDigits = void 0; // int
-      var n1ptr = void 0,
-          n2ptr = void 0,
-          sumptr = void 0; // int
-      var carry = void 0,
-          n1bytes = void 0,
-          n2bytes = void 0; // int
-      var tmp = void 0; // int
+    _bc_do_add: function (n1, n2, scaleMin) {
+      let sum // bc_num
+      let sumScale
+      let sumDigits // int
+      let n1ptr
+      let n2ptr
+      let sumptr // int
+      let carry
+      let n1bytes
+      let n2bytes // int
+      let tmp // int
 
       // Prepare sum.
-      sumScale = Libbcmath.MAX(n1.n_scale, n2.n_scale);
-      sumDigits = Libbcmath.MAX(n1.n_len, n2.n_len) + 1;
-      sum = Libbcmath.bc_new_num(sumDigits, Libbcmath.MAX(sumScale, scaleMin));
+      sumScale = Libbcmath.MAX(n1.n_scale, n2.n_scale)
+      sumDigits = Libbcmath.MAX(n1.n_len, n2.n_len) + 1
+      sum = Libbcmath.bc_new_num(sumDigits, Libbcmath.MAX(sumScale, scaleMin))
 
       // Start with the fraction part.  Initialize the pointers.
-      n1bytes = n1.n_scale;
-      n2bytes = n2.n_scale;
-      n1ptr = n1.n_len + n1bytes - 1;
-      n2ptr = n2.n_len + n2bytes - 1;
-      sumptr = sumScale + sumDigits - 1;
+      n1bytes = n1.n_scale
+      n2bytes = n2.n_scale
+      n1ptr = n1.n_len + n1bytes - 1
+      n2ptr = n2.n_len + n2bytes - 1
+      sumptr = sumScale + sumDigits - 1
 
       // Add the fraction part.  First copy the longer fraction
       // (ie when adding 1.2345 to 1 we know .2345 is correct already) .
@@ -873,79 +883,79 @@ module.exports = function _bc() {
         if (n1bytes > n2bytes) {
           // n1 has more dp then n2
           while (n1bytes > n2bytes) {
-            sum.n_value[sumptr--] = n1.n_value[n1ptr--];
+            sum.n_value[sumptr--] = n1.n_value[n1ptr--]
             // *sumptr-- = *n1ptr--;
-            n1bytes--;
+            n1bytes--
           }
         } else {
           // n2 has more dp then n1
           while (n2bytes > n1bytes) {
-            sum.n_value[sumptr--] = n2.n_value[n2ptr--];
+            sum.n_value[sumptr--] = n2.n_value[n2ptr--]
             // *sumptr-- = *n2ptr--;
-            n2bytes--;
+            n2bytes--
           }
         }
       }
 
       // Now add the remaining fraction part and equal size integer parts.
-      n1bytes += n1.n_len;
-      n2bytes += n2.n_len;
-      carry = 0;
+      n1bytes += n1.n_len
+      n2bytes += n2.n_len
+      carry = 0
       while (n1bytes > 0 && n2bytes > 0) {
         // add the two numbers together
-        tmp = n1.n_value[n1ptr--] + n2.n_value[n2ptr--] + carry;
+        tmp = n1.n_value[n1ptr--] + n2.n_value[n2ptr--] + carry
         // *sumptr = *n1ptr-- + *n2ptr-- + carry;
         // check if they are >= 10 (impossible to be more then 18)
         if (tmp >= Libbcmath.BASE) {
-          carry = 1;
-          tmp -= Libbcmath.BASE; // yep, subtract 10, add a carry
+          carry = 1
+          tmp -= Libbcmath.BASE // yep, subtract 10, add a carry
         } else {
-          carry = 0;
+          carry = 0
         }
-        sum.n_value[sumptr] = tmp;
-        sumptr--;
-        n1bytes--;
-        n2bytes--;
+        sum.n_value[sumptr] = tmp
+        sumptr--
+        n1bytes--
+        n2bytes--
       }
 
       // Now add carry the [rest of the] longer integer part.
       if (n1bytes === 0) {
         // n2 is a bigger number then n1
         while (n2bytes-- > 0) {
-          tmp = n2.n_value[n2ptr--] + carry;
+          tmp = n2.n_value[n2ptr--] + carry
           // *sumptr = *n2ptr-- + carry;
           if (tmp >= Libbcmath.BASE) {
-            carry = 1;
-            tmp -= Libbcmath.BASE;
+            carry = 1
+            tmp -= Libbcmath.BASE
           } else {
-            carry = 0;
+            carry = 0
           }
-          sum.n_value[sumptr--] = tmp;
+          sum.n_value[sumptr--] = tmp
         }
       } else {
         // n1 is bigger then n2..
         while (n1bytes-- > 0) {
-          tmp = n1.n_value[n1ptr--] + carry;
+          tmp = n1.n_value[n1ptr--] + carry
           // *sumptr = *n1ptr-- + carry;
           if (tmp >= Libbcmath.BASE) {
-            carry = 1;
-            tmp -= Libbcmath.BASE;
+            carry = 1
+            tmp -= Libbcmath.BASE
           } else {
-            carry = 0;
+            carry = 0
           }
-          sum.n_value[sumptr--] = tmp;
+          sum.n_value[sumptr--] = tmp
         }
       }
 
       // Set final carry.
       if (carry === 1) {
-        sum.n_value[sumptr] += 1;
+        sum.n_value[sumptr] += 1
         // *sumptr += 1;
       }
 
       // Adjust sum and return.
-      Libbcmath._bc_rm_leading_zeros(sum);
-      return sum;
+      Libbcmath._bc_rm_leading_zeros(sum)
+      return sum
     },
 
     /**
@@ -967,24 +977,24 @@ module.exports = function _bc() {
      * @param {int} scaleMin
      * @return bc_num
      */
-    _bc_do_sub: function _bc_do_sub(n1, n2, scaleMin) {
-      var diff = void 0; // bc_num
-      var diffScale = void 0,
-          diffLen = void 0; // int
-      var minScale = void 0,
-          minLen = void 0; // int
-      var n1ptr = void 0,
-          n2ptr = void 0,
-          diffptr = void 0; // int
-      var borrow = void 0,
-          count = void 0,
-          val = void 0; // int
+    _bc_do_sub: function (n1, n2, scaleMin) {
+      let diff // bc_num
+      let diffScale
+      let diffLen // int
+      let minScale
+      let minLen // int
+      let n1ptr
+      let n2ptr
+      let diffptr // int
+      let borrow
+      let count
+      let val // int
       // Allocate temporary storage.
-      diffLen = Libbcmath.MAX(n1.n_len, n2.n_len);
-      diffScale = Libbcmath.MAX(n1.n_scale, n2.n_scale);
-      minLen = Libbcmath.MIN(n1.n_len, n2.n_len);
-      minScale = Libbcmath.MIN(n1.n_scale, n2.n_scale);
-      diff = Libbcmath.bc_new_num(diffLen, Libbcmath.MAX(diffScale, scaleMin));
+      diffLen = Libbcmath.MAX(n1.n_len, n2.n_len)
+      diffScale = Libbcmath.MAX(n1.n_scale, n2.n_scale)
+      minLen = Libbcmath.MIN(n1.n_len, n2.n_len)
+      minScale = Libbcmath.MIN(n1.n_scale, n2.n_scale)
+      diff = Libbcmath.bc_new_num(diffLen, Libbcmath.MAX(diffScale, scaleMin))
 
       /* Not needed?
       // Zero extra digits made by scaleMin.
@@ -997,68 +1007,68 @@ module.exports = function _bc() {
       */
 
       // Initialize the subtract.
-      n1ptr = n1.n_len + n1.n_scale - 1;
-      n2ptr = n2.n_len + n2.n_scale - 1;
-      diffptr = diffLen + diffScale - 1;
+      n1ptr = n1.n_len + n1.n_scale - 1
+      n2ptr = n2.n_len + n2.n_scale - 1
+      diffptr = diffLen + diffScale - 1
 
       // Subtract the numbers.
-      borrow = 0;
+      borrow = 0
 
       // Take care of the longer scaled number.
       if (n1.n_scale !== minScale) {
         // n1 has the longer scale
         for (count = n1.n_scale - minScale; count > 0; count--) {
-          diff.n_value[diffptr--] = n1.n_value[n1ptr--];
+          diff.n_value[diffptr--] = n1.n_value[n1ptr--]
           // *diffptr-- = *n1ptr--;
         }
       } else {
         // n2 has the longer scale
         for (count = n2.n_scale - minScale; count > 0; count--) {
-          val = 0 - n2.n_value[n2ptr--] - borrow;
+          val = 0 - n2.n_value[n2ptr--] - borrow
           // val = - *n2ptr-- - borrow;
           if (val < 0) {
-            val += Libbcmath.BASE;
-            borrow = 1;
+            val += Libbcmath.BASE
+            borrow = 1
           } else {
-            borrow = 0;
+            borrow = 0
           }
-          diff.n_value[diffptr--] = val;
+          diff.n_value[diffptr--] = val
           //* diffptr-- = val;
         }
       }
 
       // Now do the equal length scale and integer parts.
       for (count = 0; count < minLen + minScale; count++) {
-        val = n1.n_value[n1ptr--] - n2.n_value[n2ptr--] - borrow;
+        val = n1.n_value[n1ptr--] - n2.n_value[n2ptr--] - borrow
         // val = *n1ptr-- - *n2ptr-- - borrow;
         if (val < 0) {
-          val += Libbcmath.BASE;
-          borrow = 1;
+          val += Libbcmath.BASE
+          borrow = 1
         } else {
-          borrow = 0;
+          borrow = 0
         }
-        diff.n_value[diffptr--] = val;
+        diff.n_value[diffptr--] = val
         //* diffptr-- = val;
       }
 
       // If n1 has more digits then n2, we now do that subtract.
       if (diffLen !== minLen) {
         for (count = diffLen - minLen; count > 0; count--) {
-          val = n1.n_value[n1ptr--] - borrow;
+          val = n1.n_value[n1ptr--] - borrow
           // val = *n1ptr-- - borrow;
           if (val < 0) {
-            val += Libbcmath.BASE;
-            borrow = 1;
+            val += Libbcmath.BASE
+            borrow = 1
           } else {
-            borrow = 0;
+            borrow = 0
           }
-          diff.n_value[diffptr--] = val;
+          diff.n_value[diffptr--] = val
         }
       }
 
       // Clean up and return.
-      Libbcmath._bc_rm_leading_zeros(diff);
-      return diff;
+      Libbcmath._bc_rm_leading_zeros(diff)
+      return diff
     },
 
     /**
@@ -1067,162 +1077,162 @@ module.exports = function _bc() {
      * @param {int} scale
      * @return bc_num
      */
-    bc_new_num: function bc_new_num(length, scale) {
-      var temp = void 0; // bc_num
-      temp = new Libbcmath.bc_num(); // eslint-disable-line new-cap
-      temp.n_sign = Libbcmath.PLUS;
-      temp.n_len = length;
-      temp.n_scale = scale;
-      temp.n_value = Libbcmath.safe_emalloc(1, length + scale, 0);
-      Libbcmath.memset(temp.n_value, 0, 0, length + scale);
-      return temp;
+    bc_new_num: function (length, scale) {
+      let temp // bc_num
+      temp = new Libbcmath.bc_num()
+      temp.n_sign = Libbcmath.PLUS
+      temp.n_len = length
+      temp.n_scale = scale
+      temp.n_value = Libbcmath.safe_emalloc(1, length + scale, 0)
+      Libbcmath.memset(temp.n_value, 0, 0, length + scale)
+      return temp
     },
 
-    safe_emalloc: function safe_emalloc(size, len, extra) {
-      return Array(size * len + extra);
+    safe_emalloc: function (size, len, extra) {
+      return new Array(size * len + extra)
     },
 
     /**
      * Create a new number
      */
-    bc_init_num: function bc_init_num() {
-      return new Libbcmath.bc_new_num(1, 0); // eslint-disable-line new-cap
+    bc_init_num: function () {
+      return new Libbcmath.bc_new_num(1, 0)
     },
 
-    _bc_rm_leading_zeros: function _bc_rm_leading_zeros(num) {
+    _bc_rm_leading_zeros: function (num) {
       // We can move n_value to point to the first non zero digit!
       while (num.n_value[0] === 0 && num.n_len > 1) {
-        num.n_value.shift();
-        num.n_len--;
+        num.n_value.shift()
+        num.n_len--
       }
     },
 
     /**
      * Convert to bc_num detecting scale
      */
-    php_str2num: function php_str2num(str) {
-      var p = void 0;
-      p = str.indexOf('.');
+    php_str2num: function (str) {
+      let p
+      p = str.indexOf('.')
       if (p === -1) {
-        return Libbcmath.bc_str2num(str, 0);
+        return Libbcmath.bc_str2num(str, 0)
       } else {
-        return Libbcmath.bc_str2num(str, str.length - p);
+        return Libbcmath.bc_str2num(str, str.length - p)
       }
     },
 
-    CH_VAL: function CH_VAL(c) {
-      return c - '0'; // ??
+    CH_VAL: function (c) {
+      return c - '0' // ??
     },
 
-    BCD_CHAR: function BCD_CHAR(d) {
-      return d + '0'; // ??
+    BCD_CHAR: function (d) {
+      return d + '0' // ??
     },
 
-    isdigit: function isdigit(c) {
-      return isNaN(parseInt(c, 10));
+    isdigit: function (c) {
+      return isNaN(parseInt(c, 10))
     },
 
-    bc_str2num: function bc_str2num(strIn, scale) {
-      var str = void 0,
-          num = void 0,
-          ptr = void 0,
-          digits = void 0,
-          strscale = void 0,
-          zeroInt = void 0,
-          nptr = void 0;
+    bc_str2num: function (strIn, scale) {
+      let str
+      let num
+      let ptr
+      let digits
+      let strscale
+      let zeroInt
+      let nptr
       // remove any non-expected characters
       // Check for valid number and count digits.
 
-      str = strIn.split(''); // convert to array
-      ptr = 0; // str
-      digits = 0;
-      strscale = 0;
-      zeroInt = false;
+      str = strIn.split('') // convert to array
+      ptr = 0 // str
+      digits = 0
+      strscale = 0
+      zeroInt = false
       if (str[ptr] === '+' || str[ptr] === '-') {
-        ptr++; // Sign
+        ptr++ // Sign
       }
       while (str[ptr] === '0') {
-        ptr++; // Skip leading zeros.
+        ptr++ // Skip leading zeros.
       }
       // while (Libbcmath.isdigit(str[ptr])) {
       while (str[ptr] % 1 === 0) {
         // Libbcmath.isdigit(str[ptr])) {
-        ptr++;
-        digits++; // digits
+        ptr++
+        digits++ // digits
       }
 
       if (str[ptr] === '.') {
-        ptr++; // decimal point
+        ptr++ // decimal point
       }
       // while (Libbcmath.isdigit(str[ptr])) {
       while (str[ptr] % 1 === 0) {
         // Libbcmath.isdigit(str[ptr])) {
-        ptr++;
-        strscale++; // digits
+        ptr++
+        strscale++ // digits
       }
 
       if (str[ptr] || digits + strscale === 0) {
         // invalid number, return 0
-        return Libbcmath.bc_init_num();
+        return Libbcmath.bc_init_num()
         //* num = bc_copy_num (BCG(_zero_));
       }
 
       // Adjust numbers and allocate storage and initialize fields.
-      strscale = Libbcmath.MIN(strscale, scale);
+      strscale = Libbcmath.MIN(strscale, scale)
       if (digits === 0) {
-        zeroInt = true;
-        digits = 1;
+        zeroInt = true
+        digits = 1
       }
 
-      num = Libbcmath.bc_new_num(digits, strscale);
+      num = Libbcmath.bc_new_num(digits, strscale)
 
       // Build the whole number.
-      ptr = 0; // str
+      ptr = 0 // str
       if (str[ptr] === '-') {
-        num.n_sign = Libbcmath.MINUS;
+        num.n_sign = Libbcmath.MINUS
         // (*num)->n_sign = MINUS;
-        ptr++;
+        ptr++
       } else {
-        num.n_sign = Libbcmath.PLUS;
+        num.n_sign = Libbcmath.PLUS
         // (*num)->n_sign = PLUS;
         if (str[ptr] === '+') {
-          ptr++;
+          ptr++
         }
       }
       while (str[ptr] === '0') {
-        ptr++; // Skip leading zeros.
+        ptr++ // Skip leading zeros.
       }
 
-      nptr = 0; // (*num)->n_value;
+      nptr = 0 // (*num)->n_value;
       if (zeroInt) {
-        num.n_value[nptr++] = 0;
-        digits = 0;
+        num.n_value[nptr++] = 0
+        digits = 0
       }
       for (; digits > 0; digits--) {
-        num.n_value[nptr++] = Libbcmath.CH_VAL(str[ptr++]);
+        num.n_value[nptr++] = Libbcmath.CH_VAL(str[ptr++])
         //* nptr++ = CH_VAL(*ptr++);
       }
 
       // Build the fractional part.
       if (strscale > 0) {
-        ptr++; // skip the decimal point!
+        ptr++ // skip the decimal point!
         for (; strscale > 0; strscale--) {
-          num.n_value[nptr++] = Libbcmath.CH_VAL(str[ptr++]);
+          num.n_value[nptr++] = Libbcmath.CH_VAL(str[ptr++])
         }
       }
 
-      return num;
+      return num
     },
 
-    cint: function cint(v) {
+    cint: function (v) {
       if (typeof v === 'undefined') {
-        v = 0;
+        v = 0
       }
-      var x = parseInt(v, 10);
+      let x = parseInt(v, 10)
       if (isNaN(x)) {
-        x = 0;
+        x = 0
       }
-      return x;
+      return x
     },
 
     /**
@@ -1230,8 +1240,8 @@ module.exports = function _bc() {
      * @param {int} a
      * @param {int} b
      */
-    MIN: function MIN(a, b) {
-      return a > b ? b : a;
+    MIN: function (a, b) {
+      return a > b ? b : a
     },
 
     /**
@@ -1239,16 +1249,16 @@ module.exports = function _bc() {
      * @param {int} a
      * @param {int} b
      */
-    MAX: function MAX(a, b) {
-      return a > b ? a : b;
+    MAX: function (a, b) {
+      return a > b ? a : b
     },
 
     /**
      * Basic odd function
      * @param {int} a
      */
-    ODD: function ODD(a) {
-      return a & 1;
+    ODD: function (a) {
+      return a & 1
     },
 
     /**
@@ -1258,10 +1268,10 @@ module.exports = function _bc() {
      * @param {string} chr    char to fill
      * @param {int} len       length to fill
      */
-    memset: function memset(r, ptr, chr, len) {
-      var i = void 0;
+    memset: function (r, ptr, chr, len) {
+      let i
       for (i = 0; i < len; i++) {
-        r[ptr + i] = chr;
+        r[ptr + i] = chr
       }
     },
 
@@ -1271,12 +1281,12 @@ module.exports = function _bc() {
      * param so you could do memcpy(dest+1, src, len) as memcpy(dest, 1, src, len)
      * Also only works on arrays
      */
-    memcpy: function memcpy(dest, ptr, src, srcptr, len) {
-      var i = void 0;
+    memcpy: function (dest, ptr, src, srcptr, len) {
+      let i
       for (i = 0; i < len; i++) {
-        dest[ptr + i] = src[srcptr + i];
+        dest[ptr + i] = src[srcptr + i]
       }
-      return true;
+      return true
     },
 
     /**
@@ -1284,30 +1294,29 @@ module.exports = function _bc() {
      * @param {bc_num} num    number to check
      * @return boolean      true when zero, false when not zero.
      */
-    bc_is_zero: function bc_is_zero(num) {
-      var count = void 0; // int
-      var nptr = void 0; // int
+    bc_is_zero: function (num) {
+      let count // int
+      let nptr // int
       // Quick check.
       // if (num === BCG(_zero_)) return TRUE;
       // Initialize
-      count = num.n_len + num.n_scale;
-      nptr = 0; // num->n_value;
+      count = num.n_len + num.n_scale
+      nptr = 0 // num->n_value;
       // The check
       while (count > 0 && num.n_value[nptr++] === 0) {
-        count--;
+        count--
       }
 
       if (count !== 0) {
-        return false;
+        return false
       } else {
-        return true;
+        return true
       }
     },
 
-    bc_out_of_memory: function bc_out_of_memory() {
-      throw new Error('(BC) Out of memory');
-    }
-  };
-  return Libbcmath;
-};
-//# sourceMappingURL=_bc.js.map
+    bc_out_of_memory: function () {
+      throw new Error('(BC) Out of memory')
+    },
+  }
+  return Libbcmath
+}