bson 6.5.0 → 6.7.0

package/lib/bson.rn.cjs

@@ -144,47 +144,27 @@ class BSONOffsetError extends BSONError {
     get name() {
         return 'BSONOffsetError';
     }
-    constructor(message, offset) {
-        super(`${message}. offset: ${offset}`);
+    constructor(message, offset, options) {
+        super(`${message}. offset: ${offset}`, options);
         this.offset = offset;
     }
 }
 
-const FIRST_BIT = 0x80;
-const FIRST_TWO_BITS = 0xc0;
-const FIRST_THREE_BITS = 0xe0;
-const FIRST_FOUR_BITS = 0xf0;
-const FIRST_FIVE_BITS = 0xf8;
-const TWO_BIT_CHAR = 0xc0;
-const THREE_BIT_CHAR = 0xe0;
-const FOUR_BIT_CHAR = 0xf0;
-const CONTINUING_CHAR = 0x80;
-function validateUtf8(bytes, start, end) {
-    let continuation = 0;
-    for (let i = start; i < end; i += 1) {
-        const byte = bytes[i];
-        if (continuation) {
-            if ((byte & FIRST_TWO_BITS) !== CONTINUING_CHAR) {
-                return false;
-            }
-            continuation -= 1;
+const { TextDecoder } = require('../vendor/text-encoding');
+let TextDecoderFatal;
+let TextDecoderNonFatal;
+function parseUtf8(buffer, start, end, fatal) {
+    if (fatal) {
+        TextDecoderFatal ??= new TextDecoder('utf8', { fatal: true });
+        try {
+            return TextDecoderFatal.decode(buffer.subarray(start, end));
         }
-        else if (byte & FIRST_BIT) {
-            if ((byte & FIRST_THREE_BITS) === TWO_BIT_CHAR) {
-                continuation = 1;
-            }
-            else if ((byte & FIRST_FOUR_BITS) === THREE_BIT_CHAR) {
-                continuation = 2;
-            }
-            else if ((byte & FIRST_FIVE_BITS) === FOUR_BIT_CHAR) {
-                continuation = 3;
-            }
-            else {
-                return false;
-            }
+        catch (cause) {
+            throw new BSONError('Invalid UTF-8 string in BSON document', { cause });
         }
     }
-    return !continuation;
+    TextDecoderNonFatal ??= new TextDecoder('utf8', { fatal: false });
+    return TextDecoderNonFatal.decode(buffer.subarray(start, end));
 }
 
 function tryReadBasicLatin(uint8array, start, end) {
@@ -305,9 +285,7 @@ const nodeJsByteUtils = {
         if (fatal) {
             for (let i = 0; i < string.length; i++) {
                 if (string.charCodeAt(i) === 0xfffd) {
-                    if (!validateUtf8(buffer, start, end)) {
-                        throw new BSONError('Invalid UTF-8 string in BSON document');
-                    }
+                    parseUtf8(buffer, start, end, true);
                     break;
                 }
             }
@@ -327,7 +305,7 @@ const nodeJsByteUtils = {
     randomBytes: nodejsRandomBytes
 };
 
-const { TextEncoder, TextDecoder } = require('../vendor/text-encoding');
+const { TextEncoder } = require('../vendor/text-encoding');
 const { encode: btoa, decode: atob } = require('../vendor/base64');
 function isReactNative() {
     const { navigator } = globalThis;
@@ -433,15 +411,7 @@ const webByteUtils = {
         if (basicLatin != null) {
             return basicLatin;
         }
-        if (fatal) {
-            try {
-                return new TextDecoder('utf8', { fatal }).decode(uint8array.slice(start, end));
-            }
-            catch (cause) {
-                throw new BSONError('Invalid UTF-8 string in BSON document', { cause });
-            }
-        }
-        return new TextDecoder('utf8', { fatal }).decode(uint8array.slice(start, end));
+        return parseUtf8(uint8array, start, end, fatal);
     },
     utf8ByteLength(input) {
         return new TextEncoder().encode(input).byteLength;
@@ -549,16 +519,16 @@ class Binary extends BSONValue {
         return this.position;
     }
     toJSON() {
-        return ByteUtils.toBase64(this.buffer);
+        return ByteUtils.toBase64(this.buffer.subarray(0, this.position));
     }
     toString(encoding) {
         if (encoding === 'hex')
-            return ByteUtils.toHex(this.buffer);
+            return ByteUtils.toHex(this.buffer.subarray(0, this.position));
         if (encoding === 'base64')
-            return ByteUtils.toBase64(this.buffer);
+            return ByteUtils.toBase64(this.buffer.subarray(0, this.position));
         if (encoding === 'utf8' || encoding === 'utf-8')
-            return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength, false);
-        return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength, false);
+            return ByteUtils.toUTF8(this.buffer, 0, this.position, false);
+        return ByteUtils.toUTF8(this.buffer, 0, this.position, false);
     }
     toExtendedJSON(options) {
         options = options || {};
@@ -854,6 +824,32 @@ class DBRef extends BSONValue {
     }
 }
 
+function removeLeadingZerosAndExplicitPlus(str) {
+    if (str === '') {
+        return str;
+    }
+    let startIndex = 0;
+    const isNegative = str[startIndex] === '-';
+    const isExplicitlyPositive = str[startIndex] === '+';
+    if (isExplicitlyPositive || isNegative) {
+        startIndex += 1;
+    }
+    let foundInsignificantZero = false;
+    for (; startIndex < str.length && str[startIndex] === '0'; ++startIndex) {
+        foundInsignificantZero = true;
+    }
+    if (!foundInsignificantZero) {
+        return isExplicitlyPositive ? str.slice(1) : str;
+    }
+    return `${isNegative ? '-' : ''}${str.length === startIndex ? '0' : str.slice(startIndex)}`;
+}
+function validateStringCharacters(str, radix) {
+    radix = radix ?? 10;
+    const validCharacters = '0123456789abcdefghijklmnopqrstuvwxyz'.slice(0, radix);
+    const regex = new RegExp(`[^-+${validCharacters}]`, 'i');
+    return regex.test(str) ? false : str;
+}
+
 let wasm = undefined;
 try {
     wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11])), {}).exports;
@@ -942,25 +938,16 @@ class Long extends BSONValue {
     static fromBigInt(value, unsigned) {
         return Long.fromString(value.toString(), unsigned);
     }
-    static fromString(str, unsigned, radix) {
+    static _fromString(str, unsigned, radix) {
         if (str.length === 0)
             throw new BSONError('empty string');
-        if (str === 'NaN' || str === 'Infinity' || str === '+Infinity' || str === '-Infinity')
-            return Long.ZERO;
-        if (typeof unsigned === 'number') {
-            (radix = unsigned), (unsigned = false);
-        }
-        else {
-            unsigned = !!unsigned;
-        }
-        radix = radix || 10;
         if (radix < 2 || 36 < radix)
             throw new BSONError('radix');
         let p;
         if ((p = str.indexOf('-')) > 0)
             throw new BSONError('interior hyphen');
         else if (p === 0) {
-            return Long.fromString(str.substring(1), unsigned, radix).neg();
+            return Long._fromString(str.substring(1), unsigned, radix).neg();
         }
         const radixToPower = Long.fromNumber(Math.pow(radix, 8));
         let result = Long.ZERO;
@@ -978,6 +965,45 @@ class Long extends BSONValue {
         result.unsigned = unsigned;
         return result;
     }
+    static fromStringStrict(str, unsignedOrRadix, radix) {
+        let unsigned = false;
+        if (typeof unsignedOrRadix === 'number') {
+            (radix = unsignedOrRadix), (unsignedOrRadix = false);
+        }
+        else {
+            unsigned = !!unsignedOrRadix;
+        }
+        radix ??= 10;
+        if (str.trim() !== str) {
+            throw new BSONError(`Input: '${str}' contains leading and/or trailing whitespace`);
+        }
+        if (!validateStringCharacters(str, radix)) {
+            throw new BSONError(`Input: '${str}' contains invalid characters for radix: ${radix}`);
+        }
+        const cleanedStr = removeLeadingZerosAndExplicitPlus(str);
+        const result = Long._fromString(cleanedStr, unsigned, radix);
+        if (result.toString(radix).toLowerCase() !== cleanedStr.toLowerCase()) {
+            throw new BSONError(`Input: ${str} is not representable as ${result.unsigned ? 'an unsigned' : 'a signed'} 64-bit Long ${radix != null ? `with radix: ${radix}` : ''}`);
+        }
+        return result;
+    }
+    static fromString(str, unsignedOrRadix, radix) {
+        let unsigned = false;
+        if (typeof unsignedOrRadix === 'number') {
+            (radix = unsignedOrRadix), (unsignedOrRadix = false);
+        }
+        else {
+            unsigned = !!unsignedOrRadix;
+        }
+        radix ??= 10;
+        if (str === 'NaN' && radix < 24) {
+            return Long.ZERO;
+        }
+        else if ((str === 'Infinity' || str === '+Infinity' || str === '-Infinity') && radix < 35) {
+            return Long.ZERO;
+        }
+        return Long._fromString(str, unsigned, radix);
+    }
     static fromBytes(bytes, unsigned, le) {
         return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);
     }
@@ -2055,6 +2081,28 @@ class Double extends BSONValue {
         }
         this.value = +value;
     }
+    static fromString(value) {
+        const coercedValue = Number(value);
+        if (value === 'NaN')
+            return new Double(NaN);
+        if (value === 'Infinity')
+            return new Double(Infinity);
+        if (value === '-Infinity')
+            return new Double(-Infinity);
+        if (!Number.isFinite(coercedValue)) {
+            throw new BSONError(`Input: ${value} is not representable as a Double`);
+        }
+        if (value.trim() !== value) {
+            throw new BSONError(`Input: '${value}' contains whitespace`);
+        }
+        if (value === '') {
+            throw new BSONError(`Input is an empty string`);
+        }
+        if (/[^-0-9.+eE]/.test(value)) {
+            throw new BSONError(`Input: '${value}' is not in decimal or exponential notation`);
+        }
+        return new Double(coercedValue);
+    }
     valueOf() {
         return this.value;
     }
@@ -2096,6 +2144,23 @@ class Int32 extends BSONValue {
         }
         this.value = +value | 0;
     }
+    static fromString(value) {
+        const cleanedValue = removeLeadingZerosAndExplicitPlus(value);
+        const coercedValue = Number(value);
+        if (BSON_INT32_MAX < coercedValue) {
+            throw new BSONError(`Input: '${value}' is larger than the maximum value for Int32`);
+        }
+        else if (BSON_INT32_MIN > coercedValue) {
+            throw new BSONError(`Input: '${value}' is smaller than the minimum value for Int32`);
+        }
+        else if (!Number.isSafeInteger(coercedValue)) {
+            throw new BSONError(`Input: '${value}' is not a safe integer`);
+        }
+        else if (coercedValue.toString() !== cleanedValue) {
+            throw new BSONError(`Input: '${value}' is not a valid Int32 string`);
+        }
+        return new Int32(coercedValue);
+    }
     valueOf() {
         return this.value;
     }
@@ -2154,6 +2219,15 @@ const FLOAT_BYTES = new Uint8Array(FLOAT.buffer, 0, 8);
 FLOAT[0] = -1;
 const isBigEndian = FLOAT_BYTES[7] === 0;
 const NumberUtils = {
+    getNonnegativeInt32LE(source, offset) {
+        if (source[offset + 3] > 127) {
+            throw new RangeError(`Size cannot be negative at offset: ${offset}`);
+        }
+        return (source[offset] |
+            (source[offset + 1] << 8) |
+            (source[offset + 2] << 16) |
+            (source[offset + 3] << 24));
+    },
     getInt32LE(source, offset) {
         return (source[offset] |
             (source[offset + 1] << 8) |
@@ -3174,12 +3248,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 stringSize > buffer.length - index ||
                 buffer[index + stringSize - 1] !== 0)
                 throw new BSONError('bad string length in bson');
-            if (validation != null && validation.utf8) {
-                if (!validateUtf8(buffer, index, index + stringSize - 1)) {
-                    throw new BSONError('Invalid UTF-8 string in BSON document');
-                }
-            }
-            const namespace = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, false);
+            const namespace = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, shouldValidateKey);
             index = index + stringSize;
             const oidBuffer = ByteUtils.allocateUnsafe(12);
             for (let i = 0; i < 12; i++)
@@ -4143,13 +4212,12 @@ EJSON.deserialize = EJSONdeserialize;
 Object.freeze(EJSON);
 
 function getSize(source, offset) {
-    if (source[offset + 3] > 127) {
-        throw new BSONOffsetError('BSON size cannot be negative', offset);
+    try {
+        return NumberUtils.getNonnegativeInt32LE(source, offset);
+    }
+    catch (cause) {
+        throw new BSONOffsetError('BSON size cannot be negative', offset, { cause });
     }
-    return (source[offset] |
-        (source[offset + 1] << 8) |
-        (source[offset + 2] << 16) |
-        (source[offset + 3] << 24));
 }
 function findNull(bytes, offset) {
     let nullTerminatorOffset = offset;
@@ -4161,6 +4229,7 @@ function findNull(bytes, offset) {
     return nullTerminatorOffset;
 }
 function parseToElements(bytes, startOffset = 0) {
+    startOffset ??= 0;
     if (bytes.length < 5) {
         throw new BSONOffsetError(`Input must be at least 5 bytes, got ${bytes.length} bytes`, startOffset);
     }
@@ -4186,7 +4255,10 @@ function parseToElements(bytes, startOffset = 0) {
         const nameLength = findNull(bytes, offset) - nameOffset;
         offset += nameLength + 1;
         let length;
-        if (type === 1 || type === 18 || type === 9 || type === 17) {
+        if (type === 1 ||
+            type === 18 ||
+            type === 9 ||
+            type === 17) {
             length = 8;
         }
         else if (type === 16) {
@@ -4201,13 +4273,18 @@ function parseToElements(bytes, startOffset = 0) {
         else if (type === 8) {
             length = 1;
         }
-        else if (type === 10 || type === 6 || type === 127 || type === 255) {
+        else if (type === 10 ||
+            type === 6 ||
+            type === 127 ||
+            type === 255) {
             length = 0;
         }
         else if (type === 11) {
             length = findNull(bytes, findNull(bytes, offset) + 1) + 1 - offset;
         }
-        else if (type === 3 || type === 4 || type === 15) {
+        else if (type === 3 ||
+            type === 4 ||
+            type === 15) {
             length = getSize(bytes, offset);
         }
         else if (type === 2 ||
@@ -4237,7 +4314,8 @@ function parseToElements(bytes, startOffset = 0) {
 
 const onDemand = Object.create(null);
 onDemand.parseToElements = parseToElements;
-onDemand.BSONOffsetError = BSONOffsetError;
+onDemand.ByteUtils = ByteUtils;
+onDemand.NumberUtils = NumberUtils;
 Object.freeze(onDemand);
 
 const MAXSIZE = 1024 * 1024 * 17;
@@ -4294,6 +4372,7 @@ function deserializeStream(data, startIndex, numberOfDocuments, documents, docSt
 var bson = /*#__PURE__*/Object.freeze({
     __proto__: null,
     BSONError: BSONError,
+    BSONOffsetError: BSONOffsetError,
     BSONRegExp: BSONRegExp,
     BSONRuntimeError: BSONRuntimeError,
     BSONSymbol: BSONSymbol,
@@ -4324,6 +4403,7 @@ var bson = /*#__PURE__*/Object.freeze({
 
 exports.BSON = bson;
 exports.BSONError = BSONError;
+exports.BSONOffsetError = BSONOffsetError;
 exports.BSONRegExp = BSONRegExp;
 exports.BSONRuntimeError = BSONRuntimeError;
 exports.BSONSymbol = BSONSymbol;