bson 6.0.0-alpha.1 → 6.1.0

package/lib/bson.cjs

@@ -1421,6 +1421,12 @@ 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;
@@ -1541,44 +1547,117 @@ class Decimal128 extends BSONValue {
             }
             exponent = exponent - 1;
         }
-        while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
-            if (lastDigit === 0) {
-                if (significantDigits === 0) {
+        if (options.allowRounding) {
+            while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
+                if (lastDigit === 0 && significantDigits < nDigitsStored) {
                     exponent = EXPONENT_MIN;
+                    significantDigits = 0;
                     break;
                 }
-                invalidErr(representation, 'exponent underflow');
-            }
-            if (nDigitsStored < nDigits) {
-                if (representation[nDigits - 1 + Number(sawSign) + Number(sawRadix)] !== '0' &&
-                    significantDigits !== 0) {
-                    invalidErr(representation, 'inexact rounding');
+                if (nDigitsStored < nDigits) {
+                    nDigits = nDigits - 1;
                 }
-                nDigits = nDigits - 1;
-            }
-            else {
-                if (digits[lastDigit] !== 0) {
-                    invalidErr(representation, 'inexact rounding');
+                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');
                 }
-                lastDigit = lastDigit - 1;
-            }
-            if (exponent < EXPONENT_MAX) {
-                exponent = exponent + 1;
             }
-            else {
-                invalidErr(representation, 'overflow');
+            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;
+                            }
+                        }
+                    }
+                }
+                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;
+                        }
+                    }
+                }
             }
         }
-        if (lastDigit + 1 < significantDigits) {
-            if (sawRadix) {
-                firstNonZero = firstNonZero + 1;
-            }
-            if (sawSign) {
-                firstNonZero = firstNonZero + 1;
+        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');
+                }
             }
-            const roundDigit = parseInt(representation[firstNonZero + lastDigit + 1], 10);
-            if (roundDigit !== 0) {
-                invalidErr(representation, 'inexact rounding');
+            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');
+                }
             }
         }
         significandHigh = Long.fromNumber(0);
@@ -3089,13 +3168,16 @@ function serializeObjectId(buffer, key, value, index) {
     const numberOfWrittenBytes = ByteUtils.encodeUTF8Into(buffer, key, index);
     index = index + numberOfWrittenBytes;
     buffer[index++] = 0;
-    if (isUint8Array(value.id)) {
-        buffer.set(value.id.subarray(0, 12), index);
+    const idValue = value.id;
+    if (isUint8Array(idValue)) {
+        for (let i = 0; i < 12; i++) {
+            buffer[index++] = idValue[i];
+        }
     }
     else {
         throw new BSONError('object [' + JSON.stringify(value) + '] is not a valid ObjectId');
     }
-    return index + 12;
+    return index;
 }
 function serializeBuffer(buffer, key, value, index) {
     buffer[index++] = BSON_DATA_BINARY;