bson 6.1.0 → 6.3.0

package/lib/bson.mjs

@@ -13,6 +13,26 @@ function isMap(d) {
 function isDate(d) {
     return Object.prototype.toString.call(d) === '[object Date]';
 }
+function defaultInspect(x, _options) {
+    return JSON.stringify(x, (k, v) => {
+        if (typeof v === 'bigint') {
+            return { $numberLong: `${v}` };
+        }
+        else if (isMap(v)) {
+            return Object.fromEntries(v);
+        }
+        return v;
+    });
+}
+function getStylizeFunction(options) {
+    const stylizeExists = options != null &&
+        typeof options === 'object' &&
+        'stylize' in options &&
+        typeof options.stylize === 'function';
+    if (stylizeExists) {
+        return options.stylize;
+    }
+}
 
 const BSON_MAJOR_VERSION = 6;
 const BSON_INT32_MAX = 0x7fffffff;
@@ -75,8 +95,8 @@ class BSONError extends Error {
     get name() {
         return 'BSONError';
     }
-    constructor(message) {
-        super(message);
+    constructor(message, options) {
+        super(message, options);
     }
     static isBSONError(value) {
         return (value != null &&
@@ -93,7 +113,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 {
@@ -105,6 +125,79 @@ class BSONRuntimeError extends BSONError {
     }
 }
 
+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;
+        }
+        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;
+            }
+        }
+    }
+    return !continuation;
+}
+
+function tryLatin(uint8array, start, end) {
+    if (uint8array.length === 0) {
+        return '';
+    }
+    const stringByteLength = end - start;
+    if (stringByteLength === 0) {
+        return '';
+    }
+    if (stringByteLength > 20) {
+        return null;
+    }
+    if (stringByteLength === 1 && uint8array[start] < 128) {
+        return String.fromCharCode(uint8array[start]);
+    }
+    if (stringByteLength === 2 && uint8array[start] < 128 && uint8array[start + 1] < 128) {
+        return String.fromCharCode(uint8array[start]) + String.fromCharCode(uint8array[start + 1]);
+    }
+    if (stringByteLength === 3 &&
+        uint8array[start] < 128 &&
+        uint8array[start + 1] < 128 &&
+        uint8array[start + 2] < 128) {
+        return (String.fromCharCode(uint8array[start]) +
+            String.fromCharCode(uint8array[start + 1]) +
+            String.fromCharCode(uint8array[start + 2]));
+    }
+    const latinBytes = [];
+    for (let i = start; i < end; i++) {
+        const byte = uint8array[i];
+        if (byte > 127) {
+            return null;
+        }
+        latinBytes.push(byte);
+    }
+    return String.fromCharCode(...latinBytes);
+}
+
 function nodejsMathRandomBytes(byteLength) {
     return nodeJsByteUtils.fromNumberArray(Array.from({ length: byteLength }, () => Math.floor(Math.random() * 256)));
 }
@@ -163,8 +256,23 @@ const nodeJsByteUtils = {
     fromUTF8(text) {
         return Buffer.from(text, 'utf8');
     },
-    toUTF8(buffer, start, end) {
-        return nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);
+    toUTF8(buffer, start, end, fatal) {
+        const basicLatin = end - start <= 20 ? tryLatin(buffer, start, end) : null;
+        if (basicLatin != null) {
+            return basicLatin;
+        }
+        const string = nodeJsByteUtils.toLocalBufferType(buffer).toString('utf8', start, end);
+        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');
+                    }
+                    break;
+                }
+            }
+        }
+        return string;
     },
     utf8ByteLength(input) {
         return Buffer.byteLength(input, 'utf8');
@@ -274,8 +382,20 @@ const webByteUtils = {
     fromUTF8(text) {
         return new TextEncoder().encode(text);
     },
-    toUTF8(uint8array, start, end) {
-        return new TextDecoder('utf8', { fatal: false }).decode(uint8array.slice(start, end));
+    toUTF8(uint8array, start, end, fatal) {
+        const basicLatin = end - start <= 20 ? tryLatin(uint8array, start, end) : null;
+        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));
     },
     utf8ByteLength(input) {
         return webByteUtils.fromUTF8(input).byteLength;
@@ -300,6 +420,9 @@ class BSONValue {
     get [Symbol.for('@@mdb.bson.version')]() {
         return BSON_MAJOR_VERSION;
     }
+    [Symbol.for('nodejs.util.inspect.custom')](depth, options, inspect) {
+        return this.inspect(depth, options, inspect);
+    }
 }
 
 class Binary extends BSONValue {
@@ -393,8 +516,8 @@ class Binary extends BSONValue {
         if (encoding === 'base64')
             return ByteUtils.toBase64(this.buffer);
         if (encoding === 'utf8' || encoding === 'utf-8')
-            return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
-        return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength);
+            return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength, false);
+        return ByteUtils.toUTF8(this.buffer, 0, this.buffer.byteLength, false);
     }
     toExtendedJSON(options) {
         options = options || {};
@@ -450,12 +573,12 @@ class Binary extends BSONValue {
         }
         return type === BSON_BINARY_SUBTYPE_UUID_NEW ? new UUID(data) : new Binary(data, type);
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
-    inspect() {
+    inspect(depth, options, inspect) {
+        inspect ??= defaultInspect;
         const base64 = ByteUtils.toBase64(this.buffer.subarray(0, this.position));
-        return `Binary.createFromBase64("${base64}", ${this.sub_type})`;
+        const base64Arg = inspect(base64, options);
+        const subTypeArg = inspect(this.sub_type, options);
+        return `Binary.createFromBase64(${base64Arg}, ${subTypeArg})`;
     }
 }
 Binary.BSON_BINARY_SUBTYPE_DEFAULT = 0;
@@ -573,11 +696,9 @@ class UUID extends Binary {
     static isValidUUIDString(representation) {
         return UUID_WITHOUT_DASHES.test(representation) || UUID_WITH_DASHES.test(representation);
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
-    inspect() {
-        return `new UUID("${this.toHexString()}")`;
+    inspect(depth, options, inspect) {
+        inspect ??= defaultInspect;
+        return `new UUID(${inspect(this.toHexString(), options)})`;
     }
 }
 
@@ -605,12 +726,15 @@ class Code extends BSONValue {
     static fromExtendedJSON(doc) {
         return new Code(doc.$code, doc.$scope);
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
-    inspect() {
-        const codeJson = this.toJSON();
-        return `new Code(${JSON.stringify(String(codeJson.code))}${codeJson.scope != null ? `, ${JSON.stringify(codeJson.scope)}` : ''})`;
+    inspect(depth, options, inspect) {
+        inspect ??= defaultInspect;
+        let parametersString = inspect(this.code, options);
+        const multiLineFn = parametersString.includes('\n');
+        if (this.scope != null) {
+            parametersString += `,${multiLineFn ? '\n' : ' '}${inspect(this.scope, options)}`;
+        }
+        const endingNewline = multiLineFn && this.scope === null;
+        return `new Code(${multiLineFn ? '\n' : ''}${parametersString}${endingNewline ? '\n' : ''})`;
     }
 }
 
@@ -675,12 +799,16 @@ class DBRef extends BSONValue {
         delete copy.$db;
         return new DBRef(doc.$ref, doc.$id, doc.$db, copy);
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
-    inspect() {
-        const oid = this.oid === undefined || this.oid.toString === undefined ? this.oid : this.oid.toString();
-        return `new DBRef("${this.namespace}", new ObjectId("${String(oid)}")${this.db ? `, "${this.db}"` : ''})`;
+    inspect(depth, options, inspect) {
+        inspect ??= defaultInspect;
+        const args = [
+            inspect(this.namespace, options),
+            inspect(this.oid, options),
+            ...(this.db ? [inspect(this.db, options)] : []),
+            ...(Object.keys(this.fields).length > 0 ? [inspect(this.fields, options)] : [])
+        ];
+        args[1] = inspect === defaultInspect ? `new ObjectId(${args[1]})` : args[1];
+        return `new DBRef(${args.join(', ')})`;
     }
 }
 
@@ -1307,11 +1435,11 @@ class Long extends BSONValue {
         }
         return longResult;
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
-    inspect() {
-        return `new Long("${this.toString()}"${this.unsigned ? ', true' : ''})`;
+    inspect(depth, options, inspect) {
+        inspect ??= defaultInspect;
+        const longVal = inspect(this.toString(), options);
+        const unsignedVal = this.unsigned ? `, ${inspect(this.unsigned, options)}` : '';
+        return `new Long(${longVal}${unsignedVal})`;
     }
 }
 Long.TWO_PWR_24 = Long.fromInt(TWO_PWR_24_DBL);
@@ -1867,11 +1995,10 @@ class Decimal128 extends BSONValue {
     static fromExtendedJSON(doc) {
         return Decimal128.fromString(doc.$numberDecimal);
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
-    inspect() {
-        return `new Decimal128("${this.toString()}")`;
+    inspect(depth, options, inspect) {
+        inspect ??= defaultInspect;
+        const d128string = inspect(this.toString(), options);
+        return `new Decimal128(${d128string})`;
     }
 }
 
@@ -1910,12 +2037,9 @@ class Double extends BSONValue {
         const doubleValue = parseFloat(doc.$numberDouble);
         return options && options.relaxed ? doubleValue : new Double(doubleValue);
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
-    inspect() {
-        const eJSON = this.toExtendedJSON();
-        return `new Double(${eJSON.$numberDouble})`;
+    inspect(depth, options, inspect) {
+        inspect ??= defaultInspect;
+        return `new Double(${inspect(this.value, options)})`;
     }
 }
 
@@ -1947,11 +2071,9 @@ class Int32 extends BSONValue {
     static fromExtendedJSON(doc, options) {
         return options && options.relaxed ? parseInt(doc.$numberInt, 10) : new Int32(doc.$numberInt);
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
-    inspect() {
-        return `new Int32(${this.valueOf()})`;
+    inspect(depth, options, inspect) {
+        inspect ??= defaultInspect;
+        return `new Int32(${inspect(this.value, options)})`;
     }
 }
 
@@ -1965,9 +2087,6 @@ class MaxKey extends BSONValue {
     static fromExtendedJSON() {
         return new MaxKey();
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
     inspect() {
         return 'new MaxKey()';
     }
@@ -1983,9 +2102,6 @@ class MinKey extends BSONValue {
     static fromExtendedJSON() {
         return new MinKey();
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
     inspect() {
         return 'new MinKey()';
     }
@@ -2156,11 +2272,9 @@ class ObjectId extends BSONValue {
     static fromExtendedJSON(doc) {
         return new ObjectId(doc.$oid);
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
-    inspect() {
-        return `new ObjectId("${this.toHexString()}")`;
+    inspect(depth, options, inspect) {
+        inspect ??= defaultInspect;
+        return `new ObjectId(${inspect(this.toHexString(), options)})`;
     }
 }
 ObjectId.index = Math.floor(Math.random() * 0xffffff);
@@ -2373,11 +2487,12 @@ class BSONRegExp extends BSONValue {
         }
         throw new BSONError(`Unexpected BSONRegExp EJSON object form: ${JSON.stringify(doc)}`);
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
-    inspect() {
-        return `new BSONRegExp(${JSON.stringify(this.pattern)}, ${JSON.stringify(this.options)})`;
+    inspect(depth, options, inspect) {
+        const stylize = getStylizeFunction(options) ?? (v => v);
+        inspect ??= defaultInspect;
+        const pattern = stylize(inspect(this.pattern), 'regexp');
+        const flags = stylize(inspect(this.options), 'regexp');
+        return `new BSONRegExp(${pattern}, ${flags})`;
     }
 }
 
@@ -2395,9 +2510,6 @@ class BSONSymbol extends BSONValue {
     toString() {
         return this.value;
     }
-    inspect() {
-        return `new BSONSymbol(${JSON.stringify(this.value)})`;
-    }
     toJSON() {
         return this.value;
     }
@@ -2407,8 +2519,9 @@ class BSONSymbol extends BSONValue {
     static fromExtendedJSON(doc) {
         return new BSONSymbol(doc.$symbol);
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
+    inspect(depth, options, inspect) {
+        inspect ??= defaultInspect;
+        return `new BSONSymbol(${inspect(this.value, options)})`;
     }
 }
 
@@ -2483,52 +2596,15 @@ class Timestamp extends LongWithoutOverridesClass {
             : doc.$timestamp.t;
         return new Timestamp({ t, i });
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
-    inspect() {
-        return `new Timestamp({ t: ${this.getHighBits()}, i: ${this.getLowBits()} })`;
+    inspect(depth, options, inspect) {
+        inspect ??= defaultInspect;
+        const t = inspect(this.high >>> 0, options);
+        const i = inspect(this.low >>> 0, options);
+        return `new Timestamp({ t: ${t}, i: ${i} })`;
     }
 }
 Timestamp.MAX_VALUE = Long.MAX_UNSIGNED_VALUE;
 
-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;
-        }
-        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;
-            }
-        }
-    }
-    return !continuation;
-}
-
 const JS_INT_MAX_LONG = Long.fromNumber(JS_INT_MAX);
 const JS_INT_MIN_LONG = Long.fromNumber(JS_INT_MIN);
 function internalDeserialize(buffer, options, isArray) {
@@ -2620,7 +2696,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, index, i);
+        const name = isArray ? arrayIndex++ : ByteUtils.toUTF8(buffer, index, i, false);
         let shouldValidateKey = true;
         if (globalUTFValidation || utf8KeysSet.has(name)) {
             shouldValidateKey = validationSetting;
@@ -2643,7 +2719,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 buffer[index + stringSize - 1] !== 0) {
                 throw new BSONError('bad string length in bson');
             }
-            value = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
+            value = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, shouldValidateKey);
             index = index + stringSize;
         }
         else if (elementType === BSON_DATA_OID) {
@@ -2835,7 +2911,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, index, i);
+            const source = ByteUtils.toUTF8(buffer, index, i, false);
             index = i + 1;
             i = index;
             while (buffer[i] !== 0x00 && i < buffer.length) {
@@ -2843,7 +2919,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, index, i);
+            const regExpOptions = ByteUtils.toUTF8(buffer, index, i, false);
             index = i + 1;
             const optionsArray = new Array(regExpOptions.length);
             for (i = 0; i < regExpOptions.length; i++) {
@@ -2868,7 +2944,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, index, i);
+            const source = ByteUtils.toUTF8(buffer, index, i, false);
             index = i + 1;
             i = index;
             while (buffer[i] !== 0x00 && i < buffer.length) {
@@ -2876,7 +2952,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, index, i);
+            const regExpOptions = ByteUtils.toUTF8(buffer, index, i, false);
             index = i + 1;
             value = new BSONRegExp(source, regExpOptions);
         }
@@ -2890,7 +2966,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 buffer[index + stringSize - 1] !== 0) {
                 throw new BSONError('bad string length in bson');
             }
-            const symbol = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
+            const symbol = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, shouldValidateKey);
             value = promoteValues ? symbol : new BSONSymbol(symbol);
             index = index + stringSize;
         }
@@ -2921,7 +2997,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 buffer[index + stringSize - 1] !== 0) {
                 throw new BSONError('bad string length in bson');
             }
-            const functionString = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
+            const functionString = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, shouldValidateKey);
             value = new Code(functionString);
             index = index + stringSize;
         }
@@ -2942,7 +3018,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 buffer[index + stringSize - 1] !== 0) {
                 throw new BSONError('bad string length in bson');
             }
-            const functionString = getValidatedString(buffer, index, index + stringSize - 1, shouldValidateKey);
+            const functionString = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, shouldValidateKey);
             index = index + stringSize;
             const _index = index;
             const objectSize = buffer[index] |
@@ -2973,7 +3049,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                     throw new BSONError('Invalid UTF-8 string in BSON document');
                 }
             }
-            const namespace = ByteUtils.toUTF8(buffer, index, index + stringSize - 1);
+            const namespace = ByteUtils.toUTF8(buffer, index, index + stringSize - 1, false);
             index = index + stringSize;
             const oidBuffer = ByteUtils.allocate(12);
             oidBuffer.set(buffer.subarray(index, index + 12), 0);
@@ -3012,20 +3088,6 @@ function deserializeObject(buffer, index, options, isArray = false) {
     }
     return object;
 }
-function getValidatedString(buffer, start, end, shouldValidateUtf8) {
-    const value = ByteUtils.toUTF8(buffer, start, end);
-    if (shouldValidateUtf8) {
-        for (let i = 0; i < value.length; i++) {
-            if (value.charCodeAt(i) === 0xfffd) {
-                if (!validateUtf8(buffer, start, end)) {
-                    throw new BSONError('Invalid UTF-8 string in BSON document');
-                }
-                break;
-            }
-        }
-    }
-    return value;
-}
 
 const regexp = /\x00/;
 const ignoreKeys = new Set(['$db', '$ref', '$id', '$clusterTime']);