bson 4.2.2 → 4.4.1

package/src/extended_json.ts

@@ -1,7 +1,7 @@
 import { Binary } from './binary';
 import type { Document } from './bson';
 import { Code } from './code';
-import { DBRef } from './db_ref';
+import { DBRef, isDBRefLike } from './db_ref';
 import { Decimal128 } from './decimal128';
 import { Double } from './double';
 import { Int32 } from './int_32';
@@ -9,7 +9,7 @@ import { Long } from './long';
 import { MaxKey } from './max_key';
 import { MinKey } from './min_key';
 import { ObjectId } from './objectid';
-import { isObjectLike } from './parser/utils';
+import { isDate, isObjectLike, isRegExp } from './parser/utils';
 import { BSONRegExp } from './regexp';
 import { BSONSymbol } from './symbol';
 import { Timestamp } from './timestamp';
@@ -120,7 +120,7 @@ function deserializeValue(value: any, options: EJSON.Options = {}) {
     return Code.fromExtendedJSON(value);
   }
 
-  if (value.$ref != null || value.$dbPointer != null) {
+  if (isDBRefLike(value) || value.$dbPointer) {
     const v = value.$ref ? value : value.$dbPointer;
 
     // we run into this in a "degenerate EJSON" case (with $id and $ref order flipped)
@@ -140,9 +140,20 @@ function deserializeValue(value: any, options: EJSON.Options = {}) {
   return value;
 }
 
+type EJSONSerializeOptions = EJSON.Options & {
+  seenObjects: { obj: unknown; propertyName: string }[];
+};
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-function serializeArray(array: any[], options: EJSON.Options): any[] {
-  return array.map((v: unknown) => serializeValue(v, options));
+function serializeArray(array: any[], options: EJSONSerializeOptions): any[] {
+  return array.map((v: unknown, index: number) => {
+    options.seenObjects.push({ propertyName: `index ${index}`, obj: null });
+    try {
+      return serializeValue(v, options);
+    } finally {
+      options.seenObjects.pop();
+    }
+  });
 }
 
 function getISOString(date: Date) {
@@ -152,12 +163,42 @@ function getISOString(date: Date) {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-function serializeValue(value: any, options: EJSON.Options): any {
+function serializeValue(value: any, options: EJSONSerializeOptions): any {
+  if ((typeof value === 'object' || typeof value === 'function') && value !== null) {
+    const index = options.seenObjects.findIndex(entry => entry.obj === value);
+    if (index !== -1) {
+      const props = options.seenObjects.map(entry => entry.propertyName);
+      const leadingPart = props
+        .slice(0, index)
+        .map(prop => `${prop} -> `)
+        .join('');
+      const alreadySeen = props[index];
+      const circularPart =
+        ' -> ' +
+        props
+          .slice(index + 1, props.length - 1)
+          .map(prop => `${prop} -> `)
+          .join('');
+      const current = props[props.length - 1];
+      const leadingSpace = ' '.repeat(leadingPart.length + alreadySeen.length / 2);
+      const dashes = '-'.repeat(
+        circularPart.length + (alreadySeen.length + current.length) / 2 - 1
+      );
+
+      throw new TypeError(
+        'Converting circular structure to EJSON:\n' +
+          `    ${leadingPart}${alreadySeen}${circularPart}${current}\n` +
+          `    ${leadingSpace}\\${dashes}/`
+      );
+    }
+    options.seenObjects[options.seenObjects.length - 1].obj = value;
+  }
+
   if (Array.isArray(value)) return serializeArray(value, options);
 
   if (value === undefined) return null;
 
-  if (value instanceof Date) {
+  if (value instanceof Date || isDate(value)) {
     const dateNum = value.getTime(),
       // is it in year range 1970-9999?
       inRange = dateNum > -1 && dateNum < 253402318800000;
@@ -172,7 +213,7 @@ function serializeValue(value: any, options: EJSON.Options): any {
       : { $date: { $numberLong: value.getTime().toString() } };
   }
 
-  if (typeof value === 'number' && !options.relaxed) {
+  if (typeof value === 'number' && (!options.relaxed || !isFinite(value))) {
     // it's an integer
     if (Math.floor(value) === value) {
       const int32Range = value >= BSON_INT32_MIN && value <= BSON_INT32_MAX,
@@ -185,7 +226,7 @@ function serializeValue(value: any, options: EJSON.Options): any {
     return { $numberDouble: value.toString() };
   }
 
-  if (value instanceof RegExp) {
+  if (value instanceof RegExp || isRegExp(value)) {
     let flags = value.flags;
     if (flags === undefined) {
       const match = value.toString().match(/[gimuy]*$/);
@@ -232,7 +273,7 @@ const BSON_TYPE_MAPPINGS = {
 } as const;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-function serializeDocument(doc: any, options: EJSON.Options) {
+function serializeDocument(doc: any, options: EJSONSerializeOptions) {
   if (doc == null || typeof doc !== 'object') throw new Error('not an object instance');
 
   const bsontype: BSONType['_bsontype'] = doc._bsontype;
@@ -240,7 +281,12 @@ function serializeDocument(doc: any, options: EJSON.Options) {
     // It's a regular object. Recursively serialize its property values.
     const _doc: Document = {};
     for (const name in doc) {
-      _doc[name] = serializeValue(doc[name], options);
+      options.seenObjects.push({ propertyName: name, obj: null });
+      try {
+        _doc[name] = serializeValue(doc[name], options);
+      } finally {
+        options.seenObjects.pop();
+      }
     }
     return _doc;
   } else if (isBSONType(doc)) {
@@ -264,10 +310,10 @@ function serializeDocument(doc: any, options: EJSON.Options) {
       outDoc = new Code(outDoc.code, serializeValue(outDoc.scope, options));
     } else if (bsontype === 'DBRef' && outDoc.oid) {
       outDoc = new DBRef(
-        outDoc.collection,
+        serializeValue(outDoc.collection, options),
         serializeValue(outDoc.oid, options),
-        outDoc.db,
-        outDoc.fields
+        serializeValue(outDoc.db, options),
+        serializeValue(outDoc.fields, options)
       );
     }
 
@@ -365,9 +411,11 @@ export namespace EJSON {
       replacer = undefined;
       space = 0;
     }
-    options = Object.assign({}, { relaxed: true, legacy: false }, options);
+    const serializeOptions = Object.assign({ relaxed: true, legacy: false }, options, {
+      seenObjects: [{ propertyName: '(root)', obj: null }]
+    });
 
-    const doc = serializeValue(value, options);
+    const doc = serializeValue(value, serializeOptions);
     return JSON.stringify(doc, replacer as Parameters<JSON['stringify']>[1], space);
   }
 

package/src/int_32.ts

@@ -12,13 +12,15 @@ export interface Int32Extended {
 export class Int32 {
   _bsontype!: 'Int32';
 
-  value: number;
+  value!: number;
   /**
    * Create an Int32 type
    *
    * @param value - the number we want to represent as an int32.
    */
   constructor(value: number | string) {
+    if (!(this instanceof Int32)) return new Int32(value);
+
     if ((value as unknown) instanceof Number) {
       value = value.valueOf();
     }
@@ -57,7 +59,7 @@ export class Int32 {
   }
 
   inspect(): string {
-    return `Int32(${this.valueOf()})`;
+    return `new Int32(${this.valueOf()})`;
   }
 }
 

package/src/long.ts

@@ -82,29 +82,43 @@ export class Long {
   /**
    * The high 32 bits as a signed value.
    */
-  high: number;
+  high!: number;
 
   /**
    * The low 32 bits as a signed value.
    */
-  low: number;
+  low!: number;
 
   /**
    * Whether unsigned or not.
    */
-  unsigned: boolean;
+  unsigned!: boolean;
 
   /**
    * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.
    *  See the from* functions below for more convenient ways of constructing Longs.
+   *
+   * Acceptable signatures are:
+   * - Long(low, high, unsigned?)
+   * - Long(bigint, unsigned?)
+   * - Long(string, unsigned?)
+   *
    * @param low - The low (signed) 32 bits of the long
    * @param high - The high (signed) 32 bits of the long
    * @param unsigned - Whether unsigned or not, defaults to signed
    */
-  constructor(low = 0, high = 0, unsigned?: boolean) {
-    this.low = low | 0;
-    this.high = high | 0;
-    this.unsigned = !!unsigned;
+  constructor(low: number | bigint | string = 0, high?: number | boolean, unsigned?: boolean) {
+    if (!(this instanceof Long)) return new Long(low, high, unsigned);
+
+    if (typeof low === 'bigint') {
+      Object.assign(this, Long.fromBigInt(low, !!high));
+    } else if (typeof low === 'string') {
+      Object.assign(this, Long.fromString(low, !!high));
+    } else {
+      this.low = low | 0;
+      this.high = (high as number) | 0;
+      this.unsigned = !!unsigned;
+    }
 
     Object.defineProperty(this, '__isLong__', {
       value: true,
@@ -992,7 +1006,7 @@ export class Long {
   }
 
   inspect(): string {
-    return `Long("${this.toString()}")`;
+    return `new Long("${this.toString()}"${this.unsigned ? ', true' : ''})`;
   }
 }
 

package/src/max_key.ts

@@ -10,6 +10,10 @@ export interface MaxKeyExtended {
 export class MaxKey {
   _bsontype!: 'MaxKey';
 
+  constructor() {
+    if (!(this instanceof MaxKey)) return new MaxKey();
+  }
+
   /** @internal */
   toExtendedJSON(): MaxKeyExtended {
     return { $maxKey: 1 };
@@ -26,7 +30,7 @@ export class MaxKey {
   }
 
   inspect(): string {
-    return 'MaxKey()';
+    return 'new MaxKey()';
   }
 }
 

package/src/min_key.ts

@@ -10,6 +10,10 @@ export interface MinKeyExtended {
 export class MinKey {
   _bsontype!: 'MinKey';
 
+  constructor() {
+    if (!(this instanceof MinKey)) return new MinKey();
+  }
+
   /** @internal */
   toExtendedJSON(): MinKeyExtended {
     return { $minKey: 1 };
@@ -26,7 +30,7 @@ export class MinKey {
   }
 
   inspect(): string {
-    return 'MinKey()';
+    return 'new MinKey()';
   }
 }
 

package/src/objectid.ts

@@ -1,24 +1,12 @@
 import { Buffer } from 'buffer';
 import { ensureBuffer } from './ensure_buffer';
-import { deprecate, randomBytes } from './parser/utils';
-
-// constants
-const PROCESS_UNIQUE = randomBytes(5);
+import { deprecate, isUint8Array, randomBytes } from './parser/utils';
 
 // Regular expression that checks for hex value
 const checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');
 
-// Precomputed hex table enables speedy hex string conversion
-const hexTable: string[] = [];
-for (let i = 0; i < 256; i++) {
-  hexTable[i] = (i <= 15 ? '0' : '') + i.toString(16);
-}
-
-// Lookup tables
-const decodeLookup: number[] = [];
-let i = 0;
-while (i < 10) decodeLookup[0x30 + i] = i++;
-while (i < 16) decodeLookup[0x41 - 10 + i] = decodeLookup[0x61 - 10 + i] = i++;
+// Unique sequence for the current process (initialized on first use)
+let PROCESS_UNIQUE: Uint8Array | null = null;
 
 /** @public */
 export interface ObjectIdLike {
@@ -57,6 +45,8 @@ export class ObjectId {
    * @param id - Can be a 24 character hex string, 12 byte binary Buffer, or a number.
    */
   constructor(id?: string | Buffer | number | ObjectIdLike | ObjectId) {
+    if (!(this instanceof ObjectId)) return new ObjectId(id);
+
     // Duck-typing to support ObjectId from different npm packages
     if (id instanceof ObjectId) {
       this[kId] = id.id;
@@ -174,6 +164,11 @@ export class ObjectId {
     // 4-byte timestamp
     buffer.writeUInt32BE(time, 0);
 
+    // set PROCESS_UNIQUE if yet not initialized
+    if (PROCESS_UNIQUE === null) {
+      PROCESS_UNIQUE = randomBytes(5);
+    }
+
     // 5-byte process unique
     buffer[4] = PROCESS_UNIQUE[0];
     buffer[5] = PROCESS_UNIQUE[1];
@@ -227,9 +222,9 @@ export class ObjectId {
       typeof otherId === 'string' &&
       ObjectId.isValid(otherId) &&
       otherId.length === 12 &&
-      this.id instanceof Buffer
+      isUint8Array(this.id)
     ) {
-      return otherId === this.id.toString('binary');
+      return otherId === Buffer.prototype.toString.call(this.id, 'latin1');
     }
 
     if (typeof otherId === 'string' && ObjectId.isValid(otherId) && otherId.length === 24) {
@@ -298,7 +293,7 @@ export class ObjectId {
    *
    * @param id - ObjectId instance to validate.
    */
-  static isValid(id: number | string | ObjectId | Buffer | ObjectIdLike): boolean {
+  static isValid(id: number | string | ObjectId | Uint8Array | ObjectIdLike): boolean {
     if (id == null) return false;
 
     if (typeof id === 'number') {
@@ -313,7 +308,7 @@ export class ObjectId {
       return true;
     }
 
-    if (id instanceof Buffer && id.length === 12) {
+    if (isUint8Array(id) && id.length === 12) {
       return true;
     }
 
@@ -350,7 +345,7 @@ export class ObjectId {
   }
 
   inspect(): string {
-    return `ObjectId("${this.toHexString()}")`;
+    return `new ObjectId("${this.toHexString()}")`;
   }
 }
 

package/src/parser/calculate_size.ts

@@ -2,7 +2,7 @@ import { Buffer } from 'buffer';
 import { Binary } from '../binary';
 import type { Document } from '../bson';
 import * as constants from '../constants';
-import { isDate, normalizedFunctionString } from './utils';
+import { isAnyArrayBuffer, isDate, isRegExp, normalizedFunctionString } from './utils';
 
 export function calculateObjectSize(
   object: Document,
@@ -83,7 +83,11 @@ function calculateElement(
         return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (12 + 1);
       } else if (value instanceof Date || isDate(value)) {
         return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);
-      } else if (ArrayBuffer.isView(value) || value instanceof ArrayBuffer) {
+      } else if (
+        ArrayBuffer.isView(value) ||
+        value instanceof ArrayBuffer ||
+        isAnyArrayBuffer(value)
+      ) {
         return (
           (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (1 + 4 + 1) + value.byteLength
         );
@@ -156,10 +160,7 @@ function calculateElement(
           1 +
           calculateObjectSize(ordered_values, serializeFunctions, ignoreUndefined)
         );
-      } else if (
-        value instanceof RegExp ||
-        Object.prototype.toString.call(value) === '[object RegExp]'
-      ) {
+      } else if (value instanceof RegExp || isRegExp(value)) {
         return (
           (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
           1 +
@@ -188,11 +189,7 @@ function calculateElement(
       }
     case 'function':
       // WTF for 0.4.X where typeof /someregexp/ === 'function'
-      if (
-        value instanceof RegExp ||
-        Object.prototype.toString.call(value) === '[object RegExp]' ||
-        String.call(value) === '[object RegExp]'
-      ) {
+      if (value instanceof RegExp || isRegExp(value) || String.call(value) === '[object RegExp]') {
         return (
           (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
           1 +

package/src/parser/deserializer.ts

@@ -152,6 +152,7 @@ function deserializeObject(
     // 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);
+    let value;
 
     index = i + 1;
 
@@ -172,30 +173,29 @@ function deserializeObject(
         throw new Error('Invalid UTF-8 string in BSON document');
       }
 
-      const s = buffer.toString('utf8', index, index + stringSize - 1);
+      value = buffer.toString('utf8', index, index + stringSize - 1);
 
-      object[name] = s;
       index = index + stringSize;
     } else if (elementType === constants.BSON_DATA_OID) {
       const oid = Buffer.alloc(12);
       buffer.copy(oid, 0, index, index + 12);
-      object[name] = new ObjectId(oid);
+      value = new ObjectId(oid);
       index = index + 12;
     } else if (elementType === constants.BSON_DATA_INT && promoteValues === false) {
-      object[name] = new Int32(
+      value = new 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(buffer.readDoubleLE(index));
+      value = new 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 =
@@ -208,10 +208,10 @@ function deserializeObject(
         (buffer[index++] << 8) |
         (buffer[index++] << 16) |
         (buffer[index++] << 24);
-      object[name] = new Date(new Long(lowBits, highBits).toNumber());
+      value = new Date(new 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 =
@@ -224,9 +224,9 @@ function deserializeObject(
 
       // 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;
@@ -253,15 +253,15 @@ function deserializeObject(
         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');
       if (index !== stopIndex) 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 =
@@ -277,12 +277,12 @@ function deserializeObject(
       const long = new 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
@@ -295,9 +295,9 @@ function deserializeObject(
       const decimal128 = new Decimal128(bytes) as Decimal128 | { toObject(): unknown };
       // 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 =
@@ -333,9 +333,9 @@ function deserializeObject(
         }
 
         if (promoteBuffers && promoteValues) {
-          object[name] = buffer.slice(index, index + binarySize);
+          value = buffer.slice(index, index + binarySize);
         } else {
-          object[name] = new Binary(buffer.slice(index, index + binarySize), subType);
+          value = new Binary(buffer.slice(index, index + binarySize), subType);
         }
       } else {
         const _buffer = Buffer.alloc(binarySize);
@@ -360,9 +360,9 @@ function deserializeObject(
         }
 
         if (promoteBuffers && promoteValues) {
-          object[name] = _buffer;
+          value = _buffer;
         } else {
-          object[name] = new Binary(_buffer, subType);
+          value = new Binary(_buffer, subType);
         }
       }
 
@@ -412,7 +412,7 @@ function deserializeObject(
         }
       }
 
-      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
       i = index;
@@ -439,7 +439,7 @@ function deserializeObject(
       index = i + 1;
 
       // Set the object
-      object[name] = new BSONRegExp(source, regExpOptions);
+      value = new BSONRegExp(source, regExpOptions);
     } else if (elementType === constants.BSON_DATA_SYMBOL) {
       const stringSize =
         buffer[index++] |
@@ -453,7 +453,7 @@ function deserializeObject(
       )
         throw new Error('bad string length in bson');
       const symbol = buffer.toString('utf8', index, index + stringSize - 1);
-      object[name] = promoteValues ? symbol : new BSONSymbol(symbol);
+      value = promoteValues ? symbol : new BSONSymbol(symbol);
       index = index + stringSize;
     } else if (elementType === constants.BSON_DATA_TIMESTAMP) {
       const lowBits =
@@ -467,11 +467,11 @@ function deserializeObject(
         (buffer[index++] << 16) |
         (buffer[index++] << 24);
 
-      object[name] = new Timestamp(lowBits, highBits);
+      value = new Timestamp(lowBits, highBits);
     } else if (elementType === constants.BSON_DATA_MIN_KEY) {
-      object[name] = new MinKey();
+      value = new MinKey();
     } else if (elementType === constants.BSON_DATA_MAX_KEY) {
-      object[name] = new MaxKey();
+      value = new MaxKey();
     } else if (elementType === constants.BSON_DATA_CODE) {
       const stringSize =
         buffer[index++] |
@@ -491,12 +491,12 @@ function deserializeObject(
         // 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(functionString);
+        value = new Code(functionString);
       }
 
       // Update parse index position
@@ -559,14 +559,14 @@ function deserializeObject(
         // 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(functionString, scopeObject);
+        value = new Code(functionString, scopeObject);
       }
     } else if (elementType === constants.BSON_DATA_DBPOINTER) {
       // Get the code string size
@@ -599,12 +599,22 @@ function deserializeObject(
       index = index + 12;
 
       // Upgrade to DBRef type
-      object[name] = new DBRef(namespace, oid);
+      value = new 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,
+        writable: true,
+        enumerable: true,
+        configurable: true
+      });
+    } else {
+      object[name] = value;
+    }
   }
 
   // Check if the deserialization was against a valid array/object