bson 5.3.0 → 6.0.0-alpha

package/lib/bson.cjs

@@ -16,7 +16,7 @@ function isDate(d) {
     return Object.prototype.toString.call(d) === '[object Date]';
 }
 
-const BSON_MAJOR_VERSION = 5;
+const BSON_MAJOR_VERSION = 6;
 const BSON_INT32_MAX = 0x7fffffff;
 const BSON_INT32_MIN = -0x80000000;
 const BSON_INT64_MAX = Math.pow(2, 63) - 1;
@@ -165,8 +165,8 @@ const nodeJsByteUtils = {
     fromUTF8(text) {
         return Buffer.from(text, 'utf8');
     },
-    toUTF8(buffer) {
-        return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8');
+    toUTF8(buffer, start, end) {
+        return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);
     },
     utf8ByteLength(input) {
         return Buffer.byteLength(input, 'utf8');
@@ -276,8 +276,8 @@ const webByteUtils = {
     fromUTF8(text) {
         return new TextEncoder().encode(text);
     },
-    toUTF8(uint8array) {
-        return new TextDecoder('utf8', { fatal: false }).decode(uint8array);
+    toUTF8(uint8array, start, end) {
+        return new TextDecoder('utf8', { fatal: false }).decode(uint8array.slice(start, end));
     },
     utf8ByteLength(input) {
         return webByteUtils.fromUTF8(input).byteLength;
@@ -311,11 +311,11 @@ class Binary extends BSONValue {
     constructor(buffer, subType) {
         super();
         if (!(buffer == null) &&
-            !(typeof buffer === 'string') &&
+            typeof buffer === 'string' &&
             !ArrayBuffer.isView(buffer) &&
-            !(buffer instanceof ArrayBuffer) &&
+            !isAnyArrayBuffer(buffer) &&
             !Array.isArray(buffer)) {
-            throw new BSONError('Binary can only be constructed from string, Buffer, TypedArray, or Array<number>');
+            throw new BSONError('Binary can only be constructed from Uint8Array or number[]');
         }
         this.sub_type = subType ?? Binary.BSON_BINARY_SUBTYPE_DEFAULT;
         if (buffer == null) {
@@ -323,15 +323,9 @@ class Binary extends BSONValue {
             this.position = 0;
         }
         else {
-            if (typeof buffer === 'string') {
-                this.buffer = ByteUtils.fromISO88591(buffer);
-            }
-            else if (Array.isArray(buffer)) {
-                this.buffer = ByteUtils.fromNumberArray(buffer);
-            }
-            else {
-                this.buffer = ByteUtils.toLocalBufferType(buffer);
-            }
+            this.buffer = Array.isArray(buffer)
+                ? ByteUtils.fromNumberArray(buffer)
+                : ByteUtils.toLocalBufferType(buffer);
             this.position = this.buffer.byteLength;
         }
     }
@@ -377,25 +371,17 @@ class Binary extends BSONValue {
                 offset + sequence.byteLength > this.position ? offset + sequence.length : this.position;
         }
         else if (typeof sequence === 'string') {
-            const bytes = ByteUtils.fromISO88591(sequence);
-            this.buffer.set(bytes, offset);
-            this.position =
-                offset + sequence.length > this.position ? offset + sequence.length : this.position;
+            throw new BSONError('input cannot be string');
         }
     }
     read(position, length) {
         length = length && length > 0 ? length : this.position;
         return this.buffer.slice(position, position + length);
     }
-    value(asRaw) {
-        asRaw = !!asRaw;
-        if (asRaw && this.buffer.length === this.position) {
-            return this.buffer;
-        }
-        if (asRaw) {
-            return this.buffer.slice(0, this.position);
-        }
-        return ByteUtils.toISO88591(this.buffer.subarray(0, this.position));
+    value() {
+        return this.buffer.length === this.position
+            ? this.buffer
+            : this.buffer.subarray(0, this.position);
     }
     length() {
         return this.position;
@@ -409,8 +395,8 @@ class Binary extends BSONValue {
         if (encoding === 'base64')
             return ByteUtils.toBase64(this.buffer);
         if (encoding === 'utf8' || encoding === 'utf-8')
-            return ByteUtils.toUTF8(this.buffer);
-        return ByteUtils.toUTF8(this.buffer);
+            return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
+        return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
     }
     toExtendedJSON(options) {
         options = options || {};
@@ -596,7 +582,6 @@ class UUID extends Binary {
         return `new UUID("${this.toHexString()}")`;
     }
 }
-UUID.cacheHexString = false;
 
 class Code extends BSONValue {
     get _bsontype() {
@@ -627,7 +612,7 @@ class Code extends BSONValue {
     }
     inspect() {
         const codeJson = this.toJSON();
-        return `new Code("${String(codeJson.code)}"${codeJson.scope != null ? `, ${JSON.stringify(codeJson.scope)}` : ''})`;
+        return `new Code(${JSON.stringify(String(codeJson.code))}${codeJson.scope != null ? `, ${JSON.stringify(codeJson.scope)}` : ''})`;
     }
 }
 
@@ -1437,6 +1422,7 @@ class Decimal128 extends BSONValue {
     }
     static fromString(representation) {
         let isNegative = false;
+        let sawSign = false;
         let sawRadix = false;
         let foundNonZero = false;
         let significantDigits = 0;
@@ -1447,10 +1433,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 +1462,7 @@ class Decimal128 extends BSONValue {
             }
         }
         if (representation[index] === '+' || representation[index] === '-') {
+            sawSign = true;
             isNegative = representation[index++] === '-';
         }
         if (!isDigit(representation[index]) && representation[index] !== '.') {
@@ -1496,7 +1481,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 +1509,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 +1519,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 +1532,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;
                 }
@@ -1561,69 +1542,43 @@ 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 (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 {
-                const digitsString = digits.join('');
-                if (digitsString.match(/^0+$/)) {
-                    exponent = EXPONENT_MAX;
-                    break;
-                }
                 invalidErr(representation, 'overflow');
             }
         }
-        if (lastDigit - firstDigit + 1 < significantDigits) {
-            let endOfString = nDigitsRead;
+        if (lastDigit + 1 < significantDigits) {
             if (sawRadix) {
                 firstNonZero = firstNonZero + 1;
-                endOfString = endOfString + 1;
             }
-            if (isNegative) {
+            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 (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);
-                            }
-                        }
-                    }
-                }
+            if (roundDigit !== 0) {
+                invalidErr(representation, 'inexact rounding');
             }
         }
         significandHigh = Long.fromNumber(0);
@@ -1632,8 +1587,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 +1597,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));
@@ -1990,20 +1945,11 @@ class ObjectId extends BSONValue {
             this[kId] = ByteUtils.toLocalBufferType(workingId);
         }
         else if (typeof workingId === 'string') {
-            if (workingId.length === 12) {
-                const bytes = ByteUtils.fromUTF8(workingId);
-                if (bytes.byteLength === 12) {
-                    this[kId] = bytes;
-                }
-                else {
-                    throw new BSONError('Argument passed in must be a string of 12 bytes');
-                }
-            }
-            else if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
+            if (workingId.length === 24 && checkForHexRegExp.test(workingId)) {
                 this[kId] = ByteUtils.fromHex(workingId);
             }
             else {
-                throw new BSONError('Argument passed in must be a string of 12 bytes or a string of 24 hex characters or an integer');
+                throw new BSONError('input must be a 24 character hex string, 12 byte Uint8Array, or an integer');
             }
         }
         else {
@@ -2065,30 +2011,25 @@ class ObjectId extends BSONValue {
     toJSON() {
         return this.toHexString();
     }
+    static is(variable) {
+        return (variable != null &&
+            typeof variable === 'object' &&
+            '_bsontype' in variable &&
+            variable._bsontype === 'ObjectId');
+    }
     equals(otherId) {
         if (otherId === undefined || otherId === null) {
             return false;
         }
-        if (otherId instanceof ObjectId) {
+        if (ObjectId.is(otherId)) {
             return this[kId][11] === otherId[kId][11] && ByteUtils.equals(this[kId], otherId[kId]);
         }
-        if (typeof otherId === 'string' &&
-            ObjectId.isValid(otherId) &&
-            otherId.length === 12 &&
-            isUint8Array(this.id)) {
-            return ByteUtils.equals(this.id, ByteUtils.fromISO88591(otherId));
-        }
-        if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 24) {
+        if (typeof otherId === 'string') {
             return otherId.toLowerCase() === this.toHexString();
         }
-        if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 12) {
-            return ByteUtils.equals(ByteUtils.fromUTF8(otherId), this.id);
-        }
-        if (typeof otherId === 'object' &&
-            'toHexString' in otherId &&
-            typeof otherId.toHexString === 'function') {
+        if (typeof otherId === 'object' && typeof otherId.toHexString === 'function') {
             const otherIdString = otherId.toHexString();
-            const thisIdString = this.toHexString().toLowerCase();
+            const thisIdString = this.toHexString();
             return typeof otherIdString === 'string' && otherIdString.toLowerCase() === thisIdString;
         }
         return false;
@@ -2378,7 +2319,7 @@ class BSONSymbol extends BSONValue {
         return this.value;
     }
     inspect() {
-        return `new BSONSymbol("${this.value}")`;
+        return `new BSONSymbol(${JSON.stringify(this.value)})`;
     }
     toJSON() {
         return this.value;
@@ -2416,19 +2357,21 @@ class Timestamp extends LongWithoutOverridesClass {
             if (typeof low.i !== 'number' && (typeof low.i !== 'object' || low.i._bsontype !== 'Int32')) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide i as a number');
             }
-            if (low.t < 0) {
+            const t = Number(low.t);
+            const i = Number(low.i);
+            if (t < 0 || Number.isNaN(t)) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide a positive t');
             }
-            if (low.i < 0) {
+            if (i < 0 || Number.isNaN(i)) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide a positive i');
             }
-            if (low.t > 4294967295) {
+            if (t > 4294967295) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide t equal or less than uint32 max');
             }
-            if (low.i > 4294967295) {
+            if (i > 4294967295) {
                 throw new BSONError('Timestamp constructed from { t, i } must provide i equal or less than uint32 max');
             }
-            super(low.i.valueOf(), low.t.valueOf(), true);
+            super(i, t, true);
         }
         else {
             throw new BSONError('A Timestamp can only be constructed with: bigint, Long, or { t: number; i: number }');
@@ -2600,7 +2543,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
         }
         if (i >= buffer.byteLength)
             throw new BSONError('Bad BSON Document: illegal CString');
-        const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer.subarray(index, i));
+        const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer, index, i);
         let shouldValidateKey = true;
         if (globalUTFValidation || utf8KeysSet.has(name)) {
             shouldValidateKey = validationSetting;
@@ -2815,7 +2758,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const source = ByteUtils.toUTF8(buffer.subarray(index, i));
+            const source = ByteUtils.toUTF8(buffer, index, i);
             index = i + 1;
             i = index;
             while (buffer[i] !== 0x00 && i < buffer.length) {
@@ -2823,7 +2766,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const regExpOptions = ByteUtils.toUTF8(buffer.subarray(index, i));
+            const regExpOptions = ByteUtils.toUTF8(buffer, index, i);
             index = i + 1;
             const optionsArray = new Array(regExpOptions.length);
             for (i = 0; i < regExpOptions.length; i++) {
@@ -2848,7 +2791,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const source = ByteUtils.toUTF8(buffer.subarray(index, i));
+            const source = ByteUtils.toUTF8(buffer, index, i);
             index = i + 1;
             i = index;
             while (buffer[i] !== 0x00 && i < buffer.length) {
@@ -2856,7 +2799,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             }
             if (i >= buffer.length)
                 throw new BSONError('Bad BSON Document: illegal CString');
-            const regExpOptions = ByteUtils.toUTF8(buffer.subarray(index, i));
+            const regExpOptions = ByteUtils.toUTF8(buffer, index, i);
             index = i + 1;
             value = new BSONRegExp(source, regExpOptions);
         }
@@ -2953,7 +2896,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                     throw new BSONError('Invalid UTF-8 string in BSON document');
                 }
             }
-            const namespace = ByteUtils.toUTF8(buffer.subarray(index, index + stringSize - 1));
+            const namespace = ByteUtils.toUTF8(buffer, index, index + stringSize - 1);
             index = index + stringSize;
             const oidBuffer = ByteUtils.allocate(12);
             oidBuffer.set(buffer.subarray(index, index + 12), 0);
@@ -2993,7 +2936,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
     return object;
 }
 function getValidatedString(buffer, start, end, shouldValidateUtf8) {
-    const value = ByteUtils.toUTF8(buffer.subarray(start, end));
+    const value = ByteUtils.toUTF8(buffer, start, end);
     if (shouldValidateUtf8) {
         for (let i = 0; i < value.length; i++) {
             if (value.charCodeAt(i) === 0xfffd) {