bson 5.4.0 → 5.5.1

package/lib/bson.cjs

@@ -95,7 +95,7 @@ class BSONVersionError extends BSONError {
         return 'BSONVersionError';
     }
     constructor() {
-        super(`Unsupported BSON version, bson types must be from bson ${BSON_MAJOR_VERSION}.0 or later`);
+        super(`Unsupported BSON version, bson types must be from bson ${BSON_MAJOR_VERSION}.x.x`);
     }
 }
 class BSONRuntimeError extends BSONError {
@@ -1436,7 +1436,14 @@ class Decimal128 extends BSONValue {
         }
     }
     static fromString(representation) {
+        return Decimal128._fromString(representation, { allowRounding: false });
+    }
+    static fromStringWithRounding(representation) {
+        return Decimal128._fromString(representation, { allowRounding: true });
+    }
+    static _fromString(representation, options) {
         let isNegative = false;
+        let sawSign = false;
         let sawRadix = false;
         let foundNonZero = false;
         let significantDigits = 0;
@@ -1447,10 +1454,8 @@ class Decimal128 extends BSONValue {
         const digits = [0];
         let nDigitsStored = 0;
         let digitsInsert = 0;
-        let firstDigit = 0;
         let lastDigit = 0;
         let exponent = 0;
-        let i = 0;
         let significandHigh = new Long(0, 0);
         let significandLow = new Long(0, 0);
         let biasedExponent = 0;
@@ -1478,6 +1483,7 @@ class Decimal128 extends BSONValue {
             }
         }
         if (representation[index] === '+' || representation[index] === '-') {
+            sawSign = true;
             isNegative = representation[index++] === '-';
         }
         if (!isDigit(representation[index]) && representation[index] !== '.') {
@@ -1496,7 +1502,7 @@ class Decimal128 extends BSONValue {
                 index = index + 1;
                 continue;
             }
-            if (nDigitsStored < 34) {
+            if (nDigitsStored < MAX_DIGITS) {
                 if (representation[index] !== '0' || foundNonZero) {
                     if (!foundNonZero) {
                         firstNonZero = nDigitsRead;
@@ -1524,10 +1530,7 @@ class Decimal128 extends BSONValue {
         }
         if (representation[index])
             return new Decimal128(NAN_BUFFER);
-        firstDigit = 0;
         if (!nDigitsStored) {
-            firstDigit = 0;
-            lastDigit = 0;
             digits[0] = 0;
             nDigits = 1;
             nDigitsStored = 1;
@@ -1537,12 +1540,12 @@ class Decimal128 extends BSONValue {
             lastDigit = nDigitsStored - 1;
             significantDigits = nDigits;
             if (significantDigits !== 1) {
-                while (digits[firstNonZero + significantDigits - 1] === 0) {
+                while (representation[firstNonZero + significantDigits - 1 + Number(sawSign) + Number(sawRadix)] === '0') {
                     significantDigits = significantDigits - 1;
                 }
             }
         }
-        if (exponent <= radixPosition && radixPosition - exponent > 1 << 14) {
+        if (exponent <= radixPosition && radixPosition > exponent + (1 << 14)) {
             exponent = EXPONENT_MIN;
         }
         else {
@@ -1550,9 +1553,8 @@ class Decimal128 extends BSONValue {
         }
         while (exponent > EXPONENT_MAX) {
             lastDigit = lastDigit + 1;
-            if (lastDigit - firstDigit > MAX_DIGITS) {
-                const digitsString = digits.join('');
-                if (digitsString.match(/^0+$/)) {
+            if (lastDigit >= MAX_DIGITS) {
+                if (significantDigits === 0) {
                     exponent = EXPONENT_MAX;
                     break;
                 }
@@ -1560,69 +1562,116 @@ class Decimal128 extends BSONValue {
             }
             exponent = exponent - 1;
         }
-        while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
-            if (lastDigit === 0 && significantDigits < nDigitsStored) {
-                exponent = EXPONENT_MIN;
-                significantDigits = 0;
-                break;
-            }
-            if (nDigitsStored < nDigits) {
-                nDigits = nDigits - 1;
-            }
-            else {
-                lastDigit = lastDigit - 1;
-            }
-            if (exponent < EXPONENT_MAX) {
-                exponent = exponent + 1;
-            }
-            else {
-                const digitsString = digits.join('');
-                if (digitsString.match(/^0+$/)) {
-                    exponent = EXPONENT_MAX;
+        if (options.allowRounding) {
+            while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
+                if (lastDigit === 0 && significantDigits < nDigitsStored) {
+                    exponent = EXPONENT_MIN;
+                    significantDigits = 0;
                     break;
                 }
-                invalidErr(representation, 'overflow');
-            }
-        }
-        if (lastDigit - firstDigit + 1 < significantDigits) {
-            let endOfString = nDigitsRead;
-            if (sawRadix) {
-                firstNonZero = firstNonZero + 1;
-                endOfString = endOfString + 1;
-            }
-            if (isNegative) {
-                firstNonZero = firstNonZero + 1;
-                endOfString = endOfString + 1;
-            }
-            const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);
-            let roundBit = 0;
-            if (roundDigit >= 5) {
-                roundBit = 1;
-                if (roundDigit === 5) {
-                    roundBit = digits[lastDigit] % 2 === 1 ? 1 : 0;
-                    for (i = firstNonZero + lastDigit + 2; i < endOfString; i++) {
-                        if (parseInt(representation[i], 10)) {
-                            roundBit = 1;
-                            break;
-                        }
+                if (nDigitsStored < nDigits) {
+                    nDigits = nDigits - 1;
+                }
+                else {
+                    lastDigit = lastDigit - 1;
+                }
+                if (exponent < EXPONENT_MAX) {
+                    exponent = exponent + 1;
+                }
+                else {
+                    const digitsString = digits.join('');
+                    if (digitsString.match(/^0+$/)) {
+                        exponent = EXPONENT_MAX;
+                        break;
                     }
+                    invalidErr(representation, 'overflow');
                 }
             }
-            if (roundBit) {
-                let dIdx = lastDigit;
-                for (; dIdx >= 0; dIdx--) {
-                    if (++digits[dIdx] > 9) {
-                        digits[dIdx] = 0;
-                        if (dIdx === 0) {
-                            if (exponent < EXPONENT_MAX) {
-                                exponent = exponent + 1;
-                                digits[dIdx] = 1;
+            if (lastDigit + 1 < significantDigits) {
+                let endOfString = nDigitsRead;
+                if (sawRadix) {
+                    firstNonZero = firstNonZero + 1;
+                    endOfString = endOfString + 1;
+                }
+                if (sawSign) {
+                    firstNonZero = firstNonZero + 1;
+                    endOfString = endOfString + 1;
+                }
+                const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);
+                let roundBit = 0;
+                if (roundDigit >= 5) {
+                    roundBit = 1;
+                    if (roundDigit === 5) {
+                        roundBit = digits[lastDigit] % 2 === 1 ? 1 : 0;
+                        for (let i = firstNonZero + lastDigit + 2; i < endOfString; i++) {
+                            if (parseInt(representation[i], 10)) {
+                                roundBit = 1;
+                                break;
                             }
-                            else {
-                                return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
+                        }
+                    }
+                }
+                if (roundBit) {
+                    let dIdx = lastDigit;
+                    for (; dIdx >= 0; dIdx--) {
+                        if (++digits[dIdx] > 9) {
+                            digits[dIdx] = 0;
+                            if (dIdx === 0) {
+                                if (exponent < EXPONENT_MAX) {
+                                    exponent = exponent + 1;
+                                    digits[dIdx] = 1;
+                                }
+                                else {
+                                    return new Decimal128(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER);
+                                }
                             }
                         }
+                        else {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        else {
+            while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
+                if (lastDigit === 0) {
+                    if (significantDigits === 0) {
+                        exponent = EXPONENT_MIN;
+                        break;
                     }
+                    invalidErr(representation, 'exponent underflow');
+                }
+                if (nDigitsStored < nDigits) {
+                    if (representation[nDigits - 1 + Number(sawSign) + Number(sawRadix)] !== '0' &&
+                        significantDigits !== 0) {
+                        invalidErr(representation, 'inexact rounding');
+                    }
+                    nDigits = nDigits - 1;
+                }
+                else {
+                    if (digits[lastDigit] !== 0) {
+                        invalidErr(representation, 'inexact rounding');
+                    }
+                    lastDigit = lastDigit - 1;
+                }
+                if (exponent < EXPONENT_MAX) {
+                    exponent = exponent + 1;
+                }
+                else {
+                    invalidErr(representation, 'overflow');
+                }
+            }
+            if (lastDigit + 1 < significantDigits) {
+                if (sawRadix) {
+                    firstNonZero = firstNonZero + 1;
+                }
+                if (sawSign) {
+                    firstNonZero = firstNonZero + 1;
+                }
+                const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);
+                if (roundDigit !== 0) {
+                    invalidErr(representation, 'inexact rounding');
                 }
             }
         }
@@ -1632,8 +1681,8 @@ class Decimal128 extends BSONValue {
             significandHigh = Long.fromNumber(0);
             significandLow = Long.fromNumber(0);
         }
-        else if (lastDigit - firstDigit < 17) {
-            let dIdx = firstDigit;
+        else if (lastDigit < 17) {
+            let dIdx = 0;
             significandLow = Long.fromNumber(digits[dIdx++]);
             significandHigh = new Long(0, 0);
             for (; dIdx <= lastDigit; dIdx++) {
@@ -1642,7 +1691,7 @@ class Decimal128 extends BSONValue {
             }
         }
         else {
-            let dIdx = firstDigit;
+            let dIdx = 0;
             significandHigh = Long.fromNumber(digits[dIdx++]);
             for (; dIdx <= lastDigit - 17; dIdx++) {
                 significandHigh = significandHigh.multiply(Long.fromNumber(10));