bson 6.0.0 → 6.2.0

package/lib/bson.cjs

@@ -15,6 +15,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;
@@ -95,7 +115,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 {
@@ -302,6 +322,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 {
@@ -452,12 +475,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;
@@ -575,11 +598,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)})`;
     }
 }
 
@@ -607,12 +628,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' : ''})`;
     }
 }
 
@@ -677,12 +701,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(', ')})`;
     }
 }
 
@@ -1309,11 +1337,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);
@@ -1421,6 +1449,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 +1575,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);
@@ -1790,11 +1897,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})`;
     }
 }
 
@@ -1833,12 +1939,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)})`;
     }
 }
 
@@ -1870,11 +1973,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)})`;
     }
 }
 
@@ -1888,9 +1989,6 @@ class MaxKey extends BSONValue {
     static fromExtendedJSON() {
         return new MaxKey();
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
     inspect() {
         return 'new MaxKey()';
     }
@@ -1906,9 +2004,6 @@ class MinKey extends BSONValue {
     static fromExtendedJSON() {
         return new MinKey();
     }
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return this.inspect();
-    }
     inspect() {
         return 'new MinKey()';
     }
@@ -2079,11 +2174,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);
@@ -2296,11 +2389,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})`;
     }
 }
 
@@ -2318,9 +2412,6 @@ class BSONSymbol extends BSONValue {
     toString() {
         return this.value;
     }
-    inspect() {
-        return `new BSONSymbol(${JSON.stringify(this.value)})`;
-    }
     toJSON() {
         return this.value;
     }
@@ -2330,8 +2421,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)})`;
     }
 }
 
@@ -2406,11 +2498,11 @@ 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;
@@ -3089,13 +3181,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;