bson 4.2.2 → 4.4.1

package/lib/parser/deserializer.js

@@ -1,45 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deserialize = void 0;
-const buffer_1 = require("buffer");
-const binary_1 = require("../binary");
-const code_1 = require("../code");
-const constants = require("../constants");
-const db_ref_1 = require("../db_ref");
-const decimal128_1 = require("../decimal128");
-const double_1 = require("../double");
-const int_32_1 = require("../int_32");
-const long_1 = require("../long");
-const max_key_1 = require("../max_key");
-const min_key_1 = require("../min_key");
-const objectid_1 = require("../objectid");
-const regexp_1 = require("../regexp");
-const symbol_1 = require("../symbol");
-const timestamp_1 = require("../timestamp");
-const validate_utf8_1 = require("../validate_utf8");
+var buffer_1 = require("buffer");
+var binary_1 = require("../binary");
+var code_1 = require("../code");
+var constants = require("../constants");
+var db_ref_1 = require("../db_ref");
+var decimal128_1 = require("../decimal128");
+var double_1 = require("../double");
+var int_32_1 = require("../int_32");
+var long_1 = require("../long");
+var max_key_1 = require("../max_key");
+var min_key_1 = require("../min_key");
+var objectid_1 = require("../objectid");
+var regexp_1 = require("../regexp");
+var symbol_1 = require("../symbol");
+var timestamp_1 = require("../timestamp");
+var validate_utf8_1 = require("../validate_utf8");
 // Internal long versions
-const JS_INT_MAX_LONG = long_1.Long.fromNumber(constants.JS_INT_MAX);
-const JS_INT_MIN_LONG = long_1.Long.fromNumber(constants.JS_INT_MIN);
-const functionCache = {};
+var JS_INT_MAX_LONG = long_1.Long.fromNumber(constants.JS_INT_MAX);
+var JS_INT_MIN_LONG = long_1.Long.fromNumber(constants.JS_INT_MIN);
+var functionCache = {};
 function deserialize(buffer, options, isArray) {
     options = options == null ? {} : options;
-    const index = options && options.index ? options.index : 0;
+    var index = options && options.index ? options.index : 0;
     // Read the document size
-    const size = buffer[index] |
+    var size = buffer[index] |
         (buffer[index + 1] << 8) |
         (buffer[index + 2] << 16) |
         (buffer[index + 3] << 24);
     if (size < 5) {
-        throw new Error(`bson size must be >= 5, is ${size}`);
+        throw new Error("bson size must be >= 5, is " + size);
     }
     if (options.allowObjectSmallerThanBufferSize && buffer.length < size) {
-        throw new Error(`buffer length ${buffer.length} must be >= bson size ${size}`);
+        throw new Error("buffer length " + buffer.length + " must be >= bson size " + size);
     }
     if (!options.allowObjectSmallerThanBufferSize && buffer.length !== size) {
-        throw new Error(`buffer length ${buffer.length} must === bson size ${size}`);
+        throw new Error("buffer length " + buffer.length + " must === bson size " + size);
     }
     if (size + index > buffer.byteLength) {
-        throw new Error(`(bson size ${size} + options.index ${index} must be <= buffer length ${buffer.byteLength})`);
+        throw new Error("(bson size " + size + " + options.index " + index + " must be <= buffer length " + buffer.byteLength + ")");
     }
     // Illegal end value
     if (buffer[index + size - 1] !== 0) {
@@ -49,42 +49,43 @@ function deserialize(buffer, options, isArray) {
     return deserializeObject(buffer, index, options, isArray);
 }
 exports.deserialize = deserialize;
-function deserializeObject(buffer, index, options, isArray = false) {
-    const evalFunctions = options['evalFunctions'] == null ? false : options['evalFunctions'];
-    const cacheFunctions = options['cacheFunctions'] == null ? false : options['cacheFunctions'];
-    const fieldsAsRaw = options['fieldsAsRaw'] == null ? null : options['fieldsAsRaw'];
+function deserializeObject(buffer, index, options, isArray) {
+    if (isArray === void 0) { isArray = false; }
+    var evalFunctions = options['evalFunctions'] == null ? false : options['evalFunctions'];
+    var cacheFunctions = options['cacheFunctions'] == null ? false : options['cacheFunctions'];
+    var fieldsAsRaw = options['fieldsAsRaw'] == null ? null : options['fieldsAsRaw'];
     // Return raw bson buffer instead of parsing it
-    const raw = options['raw'] == null ? false : options['raw'];
+    var raw = options['raw'] == null ? false : options['raw'];
     // Return BSONRegExp objects instead of native regular expressions
-    const bsonRegExp = typeof options['bsonRegExp'] === 'boolean' ? options['bsonRegExp'] : false;
+    var bsonRegExp = typeof options['bsonRegExp'] === 'boolean' ? options['bsonRegExp'] : false;
     // Controls the promotion of values vs wrapper classes
-    const promoteBuffers = options['promoteBuffers'] == null ? false : options['promoteBuffers'];
-    const promoteLongs = options['promoteLongs'] == null ? true : options['promoteLongs'];
-    const promoteValues = options['promoteValues'] == null ? true : options['promoteValues'];
+    var promoteBuffers = options['promoteBuffers'] == null ? false : options['promoteBuffers'];
+    var promoteLongs = options['promoteLongs'] == null ? true : options['promoteLongs'];
+    var promoteValues = options['promoteValues'] == null ? true : options['promoteValues'];
     // Set the start index
-    const startIndex = index;
+    var startIndex = index;
     // Validate that we have at least 4 bytes of buffer
     if (buffer.length < 5)
         throw new Error('corrupt bson message < 5 bytes long');
     // Read the document size
-    const size = buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
+    var size = buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
     // Ensure buffer is valid size
     if (size < 5 || size > buffer.length)
         throw new Error('corrupt bson message');
     // Create holding object
-    const object = isArray ? [] : {};
+    var object = isArray ? [] : {};
     // Used for arrays to skip having to perform utf8 decoding
-    let arrayIndex = 0;
-    const done = false;
+    var arrayIndex = 0;
+    var done = false;
     // While we have more left data left keep parsing
     while (!done) {
         // Read the type
-        const elementType = buffer[index++];
+        var elementType = buffer[index++];
         // If we get a zero it's the last byte, exit
         if (elementType === 0)
             break;
         // Get the start search index
-        let i = index;
+        var i = index;
         // Locate the end of the c string
         while (buffer[i] !== 0x00 && i < buffer.length) {
             i++;
@@ -92,10 +93,11 @@ function deserializeObject(buffer, index, options, isArray = false) {
         // If are at the end of the buffer there is a problem with the document
         if (i >= buffer.byteLength)
             throw new Error('Bad BSON Document: illegal CString');
-        const name = isArray ? arrayIndex++ : buffer.toString('utf8', index, i);
+        var name = isArray ? arrayIndex++ : buffer.toString('utf8', index, i);
+        var value = void 0;
         index = i + 1;
         if (elementType === constants.BSON_DATA_STRING) {
-            const stringSize = buffer[index++] |
+            var stringSize = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
@@ -106,53 +108,52 @@ function deserializeObject(buffer, index, options, isArray = false) {
             if (!validate_utf8_1.validateUtf8(buffer, index, index + stringSize - 1)) {
                 throw new Error('Invalid UTF-8 string in BSON document');
             }
-            const s = buffer.toString('utf8', index, index + stringSize - 1);
-            object[name] = s;
+            value = buffer.toString('utf8', index, index + stringSize - 1);
             index = index + stringSize;
         }
         else if (elementType === constants.BSON_DATA_OID) {
-            const oid = buffer_1.Buffer.alloc(12);
+            var oid = buffer_1.Buffer.alloc(12);
             buffer.copy(oid, 0, index, index + 12);
-            object[name] = new objectid_1.ObjectId(oid);
+            value = new objectid_1.ObjectId(oid);
             index = index + 12;
         }
         else if (elementType === constants.BSON_DATA_INT && promoteValues === false) {
-            object[name] = new int_32_1.Int32(buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24));
+            value = new int_32_1.Int32(buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24));
         }
         else if (elementType === constants.BSON_DATA_INT) {
-            object[name] =
+            value =
                 buffer[index++] |
                     (buffer[index++] << 8) |
                     (buffer[index++] << 16) |
                     (buffer[index++] << 24);
         }
         else if (elementType === constants.BSON_DATA_NUMBER && promoteValues === false) {
-            object[name] = new double_1.Double(buffer.readDoubleLE(index));
+            value = new double_1.Double(buffer.readDoubleLE(index));
             index = index + 8;
         }
         else if (elementType === constants.BSON_DATA_NUMBER) {
-            object[name] = buffer.readDoubleLE(index);
+            value = buffer.readDoubleLE(index);
             index = index + 8;
         }
         else if (elementType === constants.BSON_DATA_DATE) {
-            const lowBits = buffer[index++] |
+            var lowBits = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
-            const highBits = buffer[index++] |
+            var highBits = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
-            object[name] = new Date(new long_1.Long(lowBits, highBits).toNumber());
+            value = new Date(new long_1.Long(lowBits, highBits).toNumber());
         }
         else if (elementType === constants.BSON_DATA_BOOLEAN) {
             if (buffer[index] !== 0 && buffer[index] !== 1)
                 throw new Error('illegal boolean type value');
-            object[name] = buffer[index++] === 1;
+            value = buffer[index++] === 1;
         }
         else if (elementType === constants.BSON_DATA_OBJECT) {
-            const _index = index;
-            const objectSize = buffer[index] |
+            var _index = index;
+            var objectSize = buffer[index] |
                 (buffer[index + 1] << 8) |
                 (buffer[index + 2] << 16) |
                 (buffer[index + 3] << 24);
@@ -160,31 +161,31 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 throw new Error('bad embedded document length in bson');
             // We have a raw value
             if (raw) {
-                object[name] = buffer.slice(index, index + objectSize);
+                value = buffer.slice(index, index + objectSize);
             }
             else {
-                object[name] = deserializeObject(buffer, _index, options, false);
+                value = deserializeObject(buffer, _index, options, false);
             }
             index = index + objectSize;
         }
         else if (elementType === constants.BSON_DATA_ARRAY) {
-            const _index = index;
-            const objectSize = buffer[index] |
+            var _index = index;
+            var objectSize = buffer[index] |
                 (buffer[index + 1] << 8) |
                 (buffer[index + 2] << 16) |
                 (buffer[index + 3] << 24);
-            let arrayOptions = options;
+            var arrayOptions = options;
             // Stop index
-            const stopIndex = index + objectSize;
+            var stopIndex = index + objectSize;
             // All elements of array to be returned as raw bson
             if (fieldsAsRaw && fieldsAsRaw[name]) {
                 arrayOptions = {};
-                for (const n in options) {
+                for (var n in options) {
                     arrayOptions[n] = options[n];
                 }
                 arrayOptions['raw'] = true;
             }
-            object[name] = deserializeObject(buffer, _index, arrayOptions, true);
+            value = deserializeObject(buffer, _index, arrayOptions, true);
             index = index + objectSize;
             if (buffer[index - 1] !== 0)
                 throw new Error('invalid array terminator byte');
@@ -192,57 +193,57 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 throw new Error('corrupted array bson');
         }
         else if (elementType === constants.BSON_DATA_UNDEFINED) {
-            object[name] = undefined;
+            value = undefined;
         }
         else if (elementType === constants.BSON_DATA_NULL) {
-            object[name] = null;
+            value = null;
         }
         else if (elementType === constants.BSON_DATA_LONG) {
             // Unpack the low and high bits
-            const lowBits = buffer[index++] |
+            var lowBits = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
-            const highBits = buffer[index++] |
+            var highBits = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
-            const long = new long_1.Long(lowBits, highBits);
+            var long = new long_1.Long(lowBits, highBits);
             // Promote the long if possible
             if (promoteLongs && promoteValues === true) {
-                object[name] =
+                value =
                     long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG)
                         ? long.toNumber()
                         : long;
             }
             else {
-                object[name] = long;
+                value = long;
             }
         }
         else if (elementType === constants.BSON_DATA_DECIMAL128) {
             // Buffer to contain the decimal bytes
-            const bytes = buffer_1.Buffer.alloc(16);
+            var bytes = buffer_1.Buffer.alloc(16);
             // Copy the next 16 bytes into the bytes buffer
             buffer.copy(bytes, 0, index, index + 16);
             // Update index
             index = index + 16;
             // Assign the new Decimal128 value
-            const decimal128 = new decimal128_1.Decimal128(bytes);
+            var decimal128 = new decimal128_1.Decimal128(bytes);
             // If we have an alternative mapper use that
             if ('toObject' in decimal128 && typeof decimal128.toObject === 'function') {
-                object[name] = decimal128.toObject();
+                value = decimal128.toObject();
             }
             else {
-                object[name] = decimal128;
+                value = decimal128;
             }
         }
         else if (elementType === constants.BSON_DATA_BINARY) {
-            let binarySize = buffer[index++] |
+            var binarySize = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
-            const totalBinarySize = binarySize;
-            const subType = buffer[index++];
+            var totalBinarySize = binarySize;
+            var subType = buffer[index++];
             // Did we have a negative binary size, throw
             if (binarySize < 0)
                 throw new Error('Negative binary type element size found');
@@ -266,14 +267,14 @@ function deserializeObject(buffer, index, options, isArray = false) {
                         throw new Error('Binary type with subtype 0x02 contains too short binary size');
                 }
                 if (promoteBuffers && promoteValues) {
-                    object[name] = buffer.slice(index, index + binarySize);
+                    value = buffer.slice(index, index + binarySize);
                 }
                 else {
-                    object[name] = new binary_1.Binary(buffer.slice(index, index + binarySize), subType);
+                    value = new binary_1.Binary(buffer.slice(index, index + binarySize), subType);
                 }
             }
             else {
-                const _buffer = buffer_1.Buffer.alloc(binarySize);
+                var _buffer = buffer_1.Buffer.alloc(binarySize);
                 // If we have subtype 2 skip the 4 bytes for the size
                 if (subType === binary_1.Binary.SUBTYPE_BYTE_ARRAY) {
                     binarySize =
@@ -293,10 +294,10 @@ function deserializeObject(buffer, index, options, isArray = false) {
                     _buffer[i] = buffer[index + i];
                 }
                 if (promoteBuffers && promoteValues) {
-                    object[name] = _buffer;
+                    value = _buffer;
                 }
                 else {
-                    object[name] = new binary_1.Binary(_buffer, subType);
+                    value = new binary_1.Binary(_buffer, subType);
                 }
             }
             // Update the index
@@ -313,7 +314,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             if (i >= buffer.length)
                 throw new Error('Bad BSON Document: illegal CString');
             // Return the C string
-            const source = buffer.toString('utf8', index, i);
+            var source = buffer.toString('utf8', index, i);
             // Create the regexp
             index = i + 1;
             // Get the start search index
@@ -326,10 +327,10 @@ function deserializeObject(buffer, index, options, isArray = false) {
             if (i >= buffer.length)
                 throw new Error('Bad BSON Document: illegal CString');
             // Return the C string
-            const regExpOptions = buffer.toString('utf8', index, i);
+            var regExpOptions = buffer.toString('utf8', index, i);
             index = i + 1;
             // For each option add the corresponding one for javascript
-            const optionsArray = new Array(regExpOptions.length);
+            var optionsArray = new Array(regExpOptions.length);
             // Parse options
             for (i = 0; i < regExpOptions.length; i++) {
                 switch (regExpOptions[i]) {
@@ -344,7 +345,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                         break;
                 }
             }
-            object[name] = new RegExp(source, optionsArray.join(''));
+            value = new RegExp(source, optionsArray.join(''));
         }
         else if (elementType === constants.BSON_DATA_REGEXP && bsonRegExp === true) {
             // Get the start search index
@@ -357,7 +358,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
             if (i >= buffer.length)
                 throw new Error('Bad BSON Document: illegal CString');
             // Return the C string
-            const source = buffer.toString('utf8', index, i);
+            var source = buffer.toString('utf8', index, i);
             index = i + 1;
             // Get the start search index
             i = index;
@@ -369,13 +370,13 @@ function deserializeObject(buffer, index, options, isArray = false) {
             if (i >= buffer.length)
                 throw new Error('Bad BSON Document: illegal CString');
             // Return the C string
-            const regExpOptions = buffer.toString('utf8', index, i);
+            var regExpOptions = buffer.toString('utf8', index, i);
             index = i + 1;
             // Set the object
-            object[name] = new regexp_1.BSONRegExp(source, regExpOptions);
+            value = new regexp_1.BSONRegExp(source, regExpOptions);
         }
         else if (elementType === constants.BSON_DATA_SYMBOL) {
-            const stringSize = buffer[index++] |
+            var stringSize = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
@@ -383,29 +384,29 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 stringSize > buffer.length - index ||
                 buffer[index + stringSize - 1] !== 0)
                 throw new Error('bad string length in bson');
-            const symbol = buffer.toString('utf8', index, index + stringSize - 1);
-            object[name] = promoteValues ? symbol : new symbol_1.BSONSymbol(symbol);
+            var symbol = buffer.toString('utf8', index, index + stringSize - 1);
+            value = promoteValues ? symbol : new symbol_1.BSONSymbol(symbol);
             index = index + stringSize;
         }
         else if (elementType === constants.BSON_DATA_TIMESTAMP) {
-            const lowBits = buffer[index++] |
+            var lowBits = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
-            const highBits = buffer[index++] |
+            var highBits = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
-            object[name] = new timestamp_1.Timestamp(lowBits, highBits);
+            value = new timestamp_1.Timestamp(lowBits, highBits);
         }
         else if (elementType === constants.BSON_DATA_MIN_KEY) {
-            object[name] = new min_key_1.MinKey();
+            value = new min_key_1.MinKey();
         }
         else if (elementType === constants.BSON_DATA_MAX_KEY) {
-            object[name] = new max_key_1.MaxKey();
+            value = new max_key_1.MaxKey();
         }
         else if (elementType === constants.BSON_DATA_CODE) {
-            const stringSize = buffer[index++] |
+            var stringSize = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
@@ -413,26 +414,26 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 stringSize > buffer.length - index ||
                 buffer[index + stringSize - 1] !== 0)
                 throw new Error('bad string length in bson');
-            const functionString = buffer.toString('utf8', index, index + stringSize - 1);
+            var functionString = buffer.toString('utf8', index, index + stringSize - 1);
             // If we are evaluating the functions
             if (evalFunctions) {
                 // If we have cache enabled let's look for the md5 of the function in the cache
                 if (cacheFunctions) {
                     // Got to do this to avoid V8 deoptimizing the call due to finding eval
-                    object[name] = isolateEval(functionString, functionCache, object);
+                    value = isolateEval(functionString, functionCache, object);
                 }
                 else {
-                    object[name] = isolateEval(functionString);
+                    value = isolateEval(functionString);
                 }
             }
             else {
-                object[name] = new code_1.Code(functionString);
+                value = new code_1.Code(functionString);
             }
             // Update parse index position
             index = index + stringSize;
         }
         else if (elementType === constants.BSON_DATA_CODE_W_SCOPE) {
-            const totalSize = buffer[index++] |
+            var totalSize = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
@@ -441,7 +442,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 throw new Error('code_w_scope total size shorter minimum expected length');
             }
             // Get the code string size
-            const stringSize = buffer[index++] |
+            var stringSize = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
@@ -451,18 +452,18 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 buffer[index + stringSize - 1] !== 0)
                 throw new Error('bad string length in bson');
             // Javascript function
-            const functionString = buffer.toString('utf8', index, index + stringSize - 1);
+            var functionString = buffer.toString('utf8', index, index + stringSize - 1);
             // Update parse index position
             index = index + stringSize;
             // Parse the element
-            const _index = index;
+            var _index = index;
             // Decode the size of the object document
-            const objectSize = buffer[index] |
+            var objectSize = buffer[index] |
                 (buffer[index + 1] << 8) |
                 (buffer[index + 2] << 16) |
                 (buffer[index + 3] << 24);
             // Decode the scope object
-            const scopeObject = deserializeObject(buffer, _index, options, false);
+            var scopeObject = deserializeObject(buffer, _index, options, false);
             // Adjust the index
             index = index + objectSize;
             // Check if field length is too short
@@ -478,20 +479,20 @@ function deserializeObject(buffer, index, options, isArray = false) {
                 // If we have cache enabled let's look for the md5 of the function in the cache
                 if (cacheFunctions) {
                     // Got to do this to avoid V8 deoptimizing the call due to finding eval
-                    object[name] = isolateEval(functionString, functionCache, object);
+                    value = isolateEval(functionString, functionCache, object);
                 }
                 else {
-                    object[name] = isolateEval(functionString);
+                    value = isolateEval(functionString);
                 }
-                object[name].scope = scopeObject;
+                value.scope = scopeObject;
             }
             else {
-                object[name] = new code_1.Code(functionString, scopeObject);
+                value = new code_1.Code(functionString, scopeObject);
             }
         }
         else if (elementType === constants.BSON_DATA_DBPOINTER) {
             // Get the code string size
-            const stringSize = buffer[index++] |
+            var stringSize = buffer[index++] |
                 (buffer[index++] << 8) |
                 (buffer[index++] << 16) |
                 (buffer[index++] << 24);
@@ -504,21 +505,32 @@ function deserializeObject(buffer, index, options, isArray = false) {
             if (!validate_utf8_1.validateUtf8(buffer, index, index + stringSize - 1)) {
                 throw new Error('Invalid UTF-8 string in BSON document');
             }
-            const namespace = buffer.toString('utf8', index, index + stringSize - 1);
+            var namespace = buffer.toString('utf8', index, index + stringSize - 1);
             // Update parse index position
             index = index + stringSize;
             // Read the oid
-            const oidBuffer = buffer_1.Buffer.alloc(12);
+            var oidBuffer = buffer_1.Buffer.alloc(12);
             buffer.copy(oidBuffer, 0, index, index + 12);
-            const oid = new objectid_1.ObjectId(oidBuffer);
+            var oid = new objectid_1.ObjectId(oidBuffer);
             // Update the index
             index = index + 12;
             // Upgrade to DBRef type
-            object[name] = new db_ref_1.DBRef(namespace, oid);
+            value = new db_ref_1.DBRef(namespace, oid);
         }
         else {
             throw new Error('Detected unknown BSON type ' + elementType.toString(16) + ' for fieldname "' + name + '"');
         }
+        if (name === '__proto__') {
+            Object.defineProperty(object, name, {
+                value: value,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        }
+        else {
+            object[name] = value;
+        }
     }
     // Check if the deserialization was against a valid array/object
     if (size !== index - startIndex) {
@@ -527,9 +539,9 @@ function deserializeObject(buffer, index, options, isArray = false) {
         throw new Error('corrupt object bson');
     }
     // check if object's $ keys are those of a DBRef
-    const dollarKeys = Object.keys(object).filter(k => k.startsWith('$'));
-    let valid = true;
-    dollarKeys.forEach(k => {
+    var dollarKeys = Object.keys(object).filter(function (k) { return k.startsWith('$'); });
+    var valid = true;
+    dollarKeys.forEach(function (k) {
         if (['$ref', '$id', '$db'].indexOf(k) === -1)
             valid = false;
     });
@@ -537,7 +549,7 @@ function deserializeObject(buffer, index, options, isArray = false) {
     if (!valid)
         return object;
     if (db_ref_1.isDBRefLike(object)) {
-        const copy = Object.assign({}, object);
+        var copy = Object.assign({}, object);
         delete copy.$ref;
         delete copy.$id;
         delete copy.$db;