bson 0.4.19 → 0.4.23

package/HISTORY

@@ -1,3 +1,22 @@
+0.4.23 2016-04-08
+-----------------
+- Allow for proper detection of ObjectId or objects that look like ObjectId, improving compatibility across third party libraries.
+- Remove one package from dependency due to having been pulled from NPM.
+
+0.4.22 2016-03-04
+-----------------
+- Fix "TypeError: data.copy is not a function" in Electron (Issue #170, https://github.com/kangas).
+- Fixed issue with undefined type on deserializing.
+
+0.4.21 2016-01-12
+-----------------
+- Minor optimizations to avoid non needed object creation.
+
+0.4.20 2015-10-15
+-----------------
+- Added bower file to repository.
+- Fixed browser pid sometimes set greater than 0xFFFF on browsers (Issue #155, https://github.com/rahatarmanahmed)
+
 0.4.19 2015-10-15
 -----------------
 - Remove all support for bson-ext.

package/bower.json

@@ -0,0 +1,25 @@
+{
+  "name": "bson",
+  "description": "A bson parser for node.js and the browser",
+  "keywords": [
+    "mongodb",
+    "bson",
+    "parser"
+  ],
+  "author": "Christian Amor Kvalheim <christkv@gmail.com>",
+  "main": "./browser_build/bson.js",
+  "license": "Apache-2.0",
+  "moduleType": [
+    "globals",
+    "node"
+  ],
+  "ignore": [
+    "**/.*",
+    "alternate_parsers",
+    "benchmarks",
+    "bower_components",
+    "node_modules",
+    "test",
+    "tools"
+  ]
+}

package/deserializer_bak.js

@@ -0,0 +1,357 @@
+"use strict"
+
+var writeIEEE754 = require('../float_parser').writeIEEE754,
+	readIEEE754 = require('../float_parser').readIEEE754,
+	f = require('util').format,
+	Long = require('../long').Long,
+  Double = require('../double').Double,
+  Timestamp = require('../timestamp').Timestamp,
+  ObjectID = require('../objectid').ObjectID,
+  Symbol = require('../symbol').Symbol,
+  Code = require('../code').Code,
+  MinKey = require('../min_key').MinKey,
+  MaxKey = require('../max_key').MaxKey,
+  DBRef = require('../db_ref').DBRef,
+  BSONRegExp = require('../regexp').BSONRegExp,
+  Binary = require('../binary').Binary;
+
+var BSON = {};
+
+/**
+ * Contains the function cache if we have that enable to allow for avoiding the eval step on each deserialization, comparison is by md5
+ *
+ * @ignore
+ * @api private
+ */
+var functionCache = BSON.functionCache = {};
+
+/**
+ * Number BSON Type
+ *
+ * @classconstant BSON_DATA_NUMBER
+ **/
+BSON.BSON_DATA_NUMBER = 1;
+/**
+ * String BSON Type
+ *
+ * @classconstant BSON_DATA_STRING
+ **/
+BSON.BSON_DATA_STRING = 2;
+/**
+ * Object BSON Type
+ *
+ * @classconstant BSON_DATA_OBJECT
+ **/
+BSON.BSON_DATA_OBJECT = 3;
+/**
+ * Array BSON Type
+ *
+ * @classconstant BSON_DATA_ARRAY
+ **/
+BSON.BSON_DATA_ARRAY = 4;
+/**
+ * Binary BSON Type
+ *
+ * @classconstant BSON_DATA_BINARY
+ **/
+BSON.BSON_DATA_BINARY = 5;
+/**
+ * ObjectID BSON Type
+ *
+ * @classconstant BSON_DATA_OID
+ **/
+BSON.BSON_DATA_OID = 7;
+/**
+ * Boolean BSON Type
+ *
+ * @classconstant BSON_DATA_BOOLEAN
+ **/
+BSON.BSON_DATA_BOOLEAN = 8;
+/**
+ * Date BSON Type
+ *
+ * @classconstant BSON_DATA_DATE
+ **/
+BSON.BSON_DATA_DATE = 9;
+/**
+ * null BSON Type
+ *
+ * @classconstant BSON_DATA_NULL
+ **/
+BSON.BSON_DATA_NULL = 10;
+/**
+ * RegExp BSON Type
+ *
+ * @classconstant BSON_DATA_REGEXP
+ **/
+BSON.BSON_DATA_REGEXP = 11;
+/**
+ * Code BSON Type
+ *
+ * @classconstant BSON_DATA_CODE
+ **/
+BSON.BSON_DATA_CODE = 13;
+/**
+ * Symbol BSON Type
+ *
+ * @classconstant BSON_DATA_SYMBOL
+ **/
+BSON.BSON_DATA_SYMBOL = 14;
+/**
+ * Code with Scope BSON Type
+ *
+ * @classconstant BSON_DATA_CODE_W_SCOPE
+ **/
+BSON.BSON_DATA_CODE_W_SCOPE = 15;
+/**
+ * 32 bit Integer BSON Type
+ *
+ * @classconstant BSON_DATA_INT
+ **/
+BSON.BSON_DATA_INT = 16;
+/**
+ * Timestamp BSON Type
+ *
+ * @classconstant BSON_DATA_TIMESTAMP
+ **/
+BSON.BSON_DATA_TIMESTAMP = 17;
+/**
+ * Long BSON Type
+ *
+ * @classconstant BSON_DATA_LONG
+ **/
+BSON.BSON_DATA_LONG = 18;
+/**
+ * MinKey BSON Type
+ *
+ * @classconstant BSON_DATA_MIN_KEY
+ **/
+BSON.BSON_DATA_MIN_KEY = 0xff;
+/**
+ * MaxKey BSON Type
+ *
+ * @classconstant BSON_DATA_MAX_KEY
+ **/
+BSON.BSON_DATA_MAX_KEY = 0x7f;
+
+/**
+ * Binary Default Type
+ *
+ * @classconstant BSON_BINARY_SUBTYPE_DEFAULT
+ **/
+BSON.BSON_BINARY_SUBTYPE_DEFAULT = 0;
+/**
+ * Binary Function Type
+ *
+ * @classconstant BSON_BINARY_SUBTYPE_FUNCTION
+ **/
+BSON.BSON_BINARY_SUBTYPE_FUNCTION = 1;
+/**
+ * Binary Byte Array Type
+ *
+ * @classconstant BSON_BINARY_SUBTYPE_BYTE_ARRAY
+ **/
+BSON.BSON_BINARY_SUBTYPE_BYTE_ARRAY = 2;
+/**
+ * Binary UUID Type
+ *
+ * @classconstant BSON_BINARY_SUBTYPE_UUID
+ **/
+BSON.BSON_BINARY_SUBTYPE_UUID = 3;
+/**
+ * Binary MD5 Type
+ *
+ * @classconstant BSON_BINARY_SUBTYPE_MD5
+ **/
+BSON.BSON_BINARY_SUBTYPE_MD5 = 4;
+/**
+ * Binary User Defined Type
+ *
+ * @classconstant BSON_BINARY_SUBTYPE_USER_DEFINED
+ **/
+BSON.BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
+
+// BSON MAX VALUES
+BSON.BSON_INT32_MAX = 0x7FFFFFFF;
+BSON.BSON_INT32_MIN = -0x80000000;
+
+BSON.BSON_INT64_MAX = Math.pow(2, 63) - 1;
+BSON.BSON_INT64_MIN = -Math.pow(2, 63);
+
+// JS MAX PRECISE VALUES
+BSON.JS_INT_MAX = 0x20000000000000;  // Any integer up to 2^53 can be precisely represented by a double.
+BSON.JS_INT_MIN = -0x20000000000000;  // Any integer down to -2^53 can be precisely represented by a double.
+
+// Internal long versions
+var JS_INT_MAX_LONG = Long.fromNumber(0x20000000000000);  // Any integer up to 2^53 can be precisely represented by a double.
+var JS_INT_MIN_LONG = Long.fromNumber(-0x20000000000000);  // Any integer down to -2^53 can be precisely represented by a double.
+
+var deserialize = function(buffer, options, isArray) {
+	var index = 0;
+	// Read the document size
+  var size = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
+
+	// Ensure buffer is valid size
+  if(size < 5 || buffer.length < size) {
+		throw new Error("corrupt bson message");
+	}
+
+	// Illegal end value
+	if(buffer[size - 1] != 0) {
+		throw new Error("One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00");
+	}
+
+	// Start deserializtion
+	return deserializeObject(buffer, options, isArray);
+}
+
+// // Reads in a C style string
+// var readCStyleStringSpecial = function(buffer, index) {
+// 	// Get the start search index
+// 	var i = index;
+// 	// Locate the end of the c string
+// 	while(buffer[i] !== 0x00 && i < buffer.length) {
+// 		i++
+// 	}
+// 	// If are at the end of the buffer there is a problem with the document
+// 	if(i >= buffer.length) throw new Error("Bad BSON Document: illegal CString")
+// 	// Grab utf8 encoded string
+// 	var string = buffer.toString('utf8', index, i);
+// 	// Update index position
+// 	index = i + 1;
+// 	// Return string
+// 	return {s: string, i: index};
+// }
+
+// Reads in a C style string
+var readCStyleStringSpecial = function(buffer, index) {
+	// Get the start search index
+	var i = index;
+	// Locate the end of the c string
+	while(buffer[i] !== 0x00 && i < buffer.length) {
+		i++
+	}
+	// If are at the end of the buffer there is a problem with the document
+	if(i >= buffer.length) throw new Error("Bad BSON Document: illegal CString")
+	// Grab utf8 encoded string
+	return buffer.toString('utf8', index, i);
+}
+
+var DeserializationMethods = {}
+DeserializationMethods[BSON.BSON_DATA_OID] = function(name, object, buffer, index) {
+	var string = buffer.toString('binary', index, index + 12);
+	object[name] = new ObjectID(string);
+	return index + 12;
+}
+
+DeserializationMethods[BSON.BSON_DATA_NUMBER] = function(name, object, buffer, index) {
+	object[name] = buffer.readDoubleLE(index);
+  return index + 8;
+}
+
+DeserializationMethods[BSON.BSON_DATA_INT] = function(name, object, buffer, index) {
+	object[name] = buffer.readInt32LE(index);
+	return index + 4;
+}
+
+DeserializationMethods[BSON.BSON_DATA_TIMESTAMP] = function(name, object, buffer, index) {
+  var lowBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
+  var highBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
+  object[name] = new Timestamp(lowBits, highBits);
+	return index;
+}
+
+DeserializationMethods[BSON.BSON_DATA_STRING] = function(name, object, buffer, index) {
+  var stringSize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
+	if(stringSize <= 0 || stringSize > (buffer.length - index) || buffer[index + stringSize - 1] != 0) throw new Error("bad string length in bson");
+  object[name] = buffer.toString('utf8', index, index + stringSize - 1);
+  return index + stringSize;
+}
+
+DeserializationMethods[BSON.BSON_DATA_BOOLEAN] = function(name, object, buffer, index) {
+  object[name] = buffer[index++] == 1;
+	return index;
+}
+
+var deserializeObject = function(buffer, options, isArray) {
+  // Options
+  options = options == null ? {} : options;
+  var evalFunctions = options['evalFunctions'] == null ? false : options['evalFunctions'];
+  var cacheFunctions = options['cacheFunctions'] == null ? false : options['cacheFunctions'];
+  var cacheFunctionsCrc32 = options['cacheFunctionsCrc32'] == null ? false : options['cacheFunctionsCrc32'];
+  var promoteLongs = options['promoteLongs'] == null ? true : options['promoteLongs'];
+	var fieldsAsRaw = options['fieldsAsRaw'] == null ? {} : options['fieldsAsRaw'];
+  // Return BSONRegExp objects instead of native regular expressions
+  var bsonRegExp = typeof options['bsonRegExp'] == 'boolean' ? options['bsonRegExp'] : false;
+  var promoteBuffers = options['promoteBuffers'] == null ? false : options['promoteBuffers'];
+
+  // Validate that we have at least 4 bytes of buffer
+  if(buffer.length < 5) throw new Error("corrupt bson message < 5 bytes long");
+
+  // Set up index
+  var index = typeof options['index'] == 'number' ? options['index'] : 0;
+
+	// Read the document size
+  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
+  var object = isArray ? [] : {};
+
+  // While we have more left data left keep parsing
+  while(true) {
+    // Read the type
+    var elementType = buffer[index++];
+    // If we get a zero it's the last byte, exit
+    if(elementType == 0) break;
+    var name = readCStyleStringSpecial(buffer, index);
+		index = index + name.length + 1;
+
+		// console.log("----------- 0 " + elementType + " :: " + name)
+		index = DeserializationMethods[elementType](name, object, buffer, index);
+		// console.log('--------------- 1')
+  }
+
+  // Check if we have a db ref object
+  if(object['$id'] != null) object = new DBRef(object['$ref'], object['$id'], object['$db']);
+
+  // Return the final objects
+  return object;
+}
+
+/**
+ * Ensure eval is isolated.
+ *
+ * @ignore
+ * @api private
+ */
+var isolateEvalWithHash = function(functionCache, hash, functionString, object) {
+  // Contains the value we are going to set
+  var value = null;
+
+  // Check for cache hit, eval if missing and return cached function
+  if(functionCache[hash] == null) {
+    eval("value = " + functionString);
+    functionCache[hash] = value;
+  }
+  // Set the object
+  return functionCache[hash].bind(object);
+}
+
+/**
+ * Ensure eval is isolated.
+ *
+ * @ignore
+ * @api private
+ */
+var isolateEval = function(functionString) {
+  // Contains the value we are going to set
+  var value = null;
+  // Eval the function
+  eval("value = " + functionString);
+  return value;
+}
+
+module.exports = deserialize

package/lib/bson/binary.js

@@ -2,7 +2,10 @@
  * Module dependencies.
  * @ignore
  */
-if(typeof window === 'undefined') {
+
+// Test if we're in Node via presence of "global" not absence of "window"
+// to support hybrid environments like Electron
+if(typeof global !== 'undefined') {
   var Buffer = require('buffer').Buffer; // TODO just use global Buffer
 }
 

package/lib/bson/index.js

@@ -17,7 +17,7 @@ try {
   , './symbol'
   , './timestamp'
   , './long'].forEach(function (path) {
-  	var module = require('./' + path);
+  	var module = require(path);
   	for (var i in module) {
   		exports[i] = module[i];
     }
@@ -40,8 +40,8 @@ exports.pure = function() {
     , './symbol'
     , './timestamp'
     , './long'
-    , '././bson'].forEach(function (path) {
-    	var module = require('./' + path);
+    , './bson'].forEach(function (path) {
+    	var module = require(path);
     	for (var i in module) {
     		classes[i] = module[i];
       }
@@ -68,7 +68,7 @@ exports.native = function() {
     , './timestamp'
     , './long'
   ].forEach(function (path) {
-      var module = require('./' + path);
+      var module = require(path);
       for (var i in module) {
         classes[i] = module[i];
       }

package/lib/bson/objectid.js

@@ -27,7 +27,8 @@ var checkForHexRegExp = new RegExp("^[0-9a-fA-F]{24}$");
 */
 var ObjectID = function ObjectID(id) {
   if(!(this instanceof ObjectID)) return new ObjectID(id);
-  if((id instanceof ObjectID)) return id;
+  // Duck-typing to support ObjectId from different npm packages
+  if((id instanceof ObjectID) || (id && id.toHexString)) return id;
 
   this._bsontype = 'ObjectID';
   var __id = null;
@@ -114,7 +115,7 @@ ObjectID.prototype.generate = function(time) {
   var time4Bytes = BinaryParser.encodeInt(time, 32, true, true);
   /* for time-based ObjectID the bytes following the time will be zeroed */
   var machine3Bytes = BinaryParser.encodeInt(MACHINE_ID, 24, false);
-  var pid2Bytes = BinaryParser.fromShort(typeof process === 'undefined' ? Math.floor(Math.random() * 100000) : process.pid % 0xFFFF);
+  var pid2Bytes = BinaryParser.fromShort((typeof process === 'undefined' ? Math.floor(Math.random() * 100000) : process.pid) % 0xFFFF);
   var index3Bytes = BinaryParser.encodeInt(this.get_inc(), 24, false, true);
 
   return time4Bytes + machine3Bytes + pid2Bytes + index3Bytes;
@@ -251,6 +252,13 @@ ObjectID.isValid = function isValid(id) {
   if(typeof id == 'string') {
     return id.length == 12 || (id.length == 24 && checkForHexRegExp.test(id));
   }
+  if(id instanceof ObjectID) {
+    return true;
+  }
+  // Duck-Typing detection of ObjectId like objects
+  if(id.toHexString) {
+    return id.id.length == 12 || (id.id.length == 24 && checkForHexRegExp.test(id.id));
+  }
   return false;
 };
 

package/lib/bson/parser/deserializer.js

@@ -1,7 +1,6 @@
 "use strict"
 
-var writeIEEE754 = require('../float_parser').writeIEEE754,
-	readIEEE754 = require('../float_parser').readIEEE754,
+var readIEEE754 = require('../float_parser').readIEEE754,
 	f = require('util').format,
 	Long = require('../long').Long,
   Double = require('../double').Double,
@@ -16,9 +15,10 @@ var writeIEEE754 = require('../float_parser').writeIEEE754,
   Binary = require('../binary').Binary;
 
 var deserialize = function(buffer, options, isArray) {
-	var index = 0;
+	options = options == null ? {} : options;
+	var index = options && options.index ? options.index : 0;
 	// Read the document size
-  var size = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
+  var size = buffer[index] | buffer[index+1] << 8 | buffer[index+2] << 16 | buffer[index+3] << 24;
 
 	// Ensure buffer is valid size
   if(size < 5 || buffer.length < size) {
@@ -26,40 +26,21 @@ var deserialize = function(buffer, options, isArray) {
 	}
 
 	// Illegal end value
-	if(buffer[size - 1] != 0) {
+	if(buffer[index + size - 1] != 0) {
 		throw new Error("One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00");
 	}
 
 	// Start deserializtion
-	return deserializeObject(buffer, options, isArray);
-}
-
-// Reads in a C style string
-var readCStyleStringSpecial = function(buffer, index) {
-	// Get the start search index
-	var i = index;
-	// Locate the end of the c string
-	while(buffer[i] !== 0x00 && i < buffer.length) {
-		i++
-	}
-	// If are at the end of the buffer there is a problem with the document
-	if(i >= buffer.length) throw new Error("Bad BSON Document: illegal CString")
-	// Grab utf8 encoded string
-	var string = buffer.toString('utf8', index, i);
-	// Update index position
-	index = i + 1;
-	// Return string
-	return {s: string, i: index};
+	return deserializeObject(buffer, index, options, isArray);
 }
 
-var deserializeObject = function(buffer, options, isArray) {
-  // Options
-  options = options == null ? {} : options;
-  var evalFunctions = options['evalFunctions'] == null ? false : options['evalFunctions'];
+var deserializeObject = function(buffer, index, options, isArray) {
+	var evalFunctions = options['evalFunctions'] == null ? false : options['evalFunctions'];
   var cacheFunctions = options['cacheFunctions'] == null ? false : options['cacheFunctions'];
   var cacheFunctionsCrc32 = options['cacheFunctionsCrc32'] == null ? false : options['cacheFunctionsCrc32'];
   var promoteLongs = options['promoteLongs'] == null ? true : options['promoteLongs'];
-	var fieldsAsRaw = options['fieldsAsRaw'] == null ? {} : options['fieldsAsRaw'];
+	var fieldsAsRaw = options['fieldsAsRaw'] == null ? null : options['fieldsAsRaw'];
+	var raw = options['raw'] == null ? false : options['raw'];
   // Return BSONRegExp objects instead of native regular expressions
   var bsonRegExp = typeof options['bsonRegExp'] == 'boolean' ? options['bsonRegExp'] : false;
   var promoteBuffers = options['promoteBuffers'] == null ? false : options['promoteBuffers'];
@@ -67,9 +48,6 @@ var deserializeObject = function(buffer, options, isArray) {
   // Validate that we have at least 4 bytes of buffer
   if(buffer.length < 5) throw new Error("corrupt bson message < 5 bytes long");
 
-  // Set up index
-  var index = typeof options['index'] == 'number' ? options['index'] : 0;
-
 	// Read the document size
   var size = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
 
@@ -85,51 +63,82 @@ var deserializeObject = function(buffer, options, isArray) {
     var elementType = buffer[index++];
     // If we get a zero it's the last byte, exit
     if(elementType == 0) break;
-    // Read the name of the field
-    var r = readCStyleStringSpecial(buffer, index);
-		var name = r.s;
-		index = r.i;
 
-		// Switch on the type
-		if(elementType == BSON.BSON_DATA_OID) {
-      var string = buffer.toString('binary', index, index + 12);
-      // Decode the oid
-      object[name] = new ObjectID(string);
-      // Update index
-      index = index + 12;
-		} else if(elementType == BSON.BSON_DATA_STRING) {
-      // Read the content of the field
+		// Get the start search index
+		var i = index;
+		// Locate the end of the c string
+		while(buffer[i] !== 0x00 && i < buffer.length) {
+			i++
+		}
+
+		// If are at the end of the buffer there is a problem with the document
+		if(i >= buffer.length) throw new Error("Bad BSON Document: illegal CString")
+		var name = buffer.toString('utf8', index, i);
+
+		index = i + 1;
+
+		if(elementType == BSON.BSON_DATA_STRING) {
       var stringSize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
-			// Validate if string Size is larger than the actual provided buffer
 			if(stringSize <= 0 || stringSize > (buffer.length - index) || buffer[index + stringSize - 1] != 0) throw new Error("bad string length in bson");
-      // Add string to object
       object[name] = buffer.toString('utf8', index, index + stringSize - 1);
-      // Update parse index position
       index = index + stringSize;
+		} else if(elementType == BSON.BSON_DATA_OID) {
+      var string = buffer.toString('binary', index, index + 12);
+      object[name] = new ObjectID(string);
+      index = index + 12;
 		} else if(elementType == BSON.BSON_DATA_INT) {
-      // Decode the 32bit value
       object[name] = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
 		} else if(elementType == BSON.BSON_DATA_NUMBER) {
-      // Decode the double value
-      object[name] = readIEEE754(buffer, index, 'little', 52, 8);
-      // Update the index
+			object[name] = buffer.readDoubleLE(index);
       index = index + 8;
 		} else if(elementType == BSON.BSON_DATA_DATE) {
-      // Unpack the low and high bits
       var lowBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
       var highBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
-      // Set date object
       object[name] = new Date(new Long(lowBits, highBits).toNumber());
 		} else if(elementType == BSON.BSON_DATA_BOOLEAN) {
-      // Parse the boolean value
       object[name] = buffer[index++] == 1;
+		} else if(elementType == BSON.BSON_DATA_OBJECT) {
+			var _index = index;
+      var objectSize = buffer[index] | buffer[index + 1] << 8 | buffer[index + 2] << 16 | buffer[index + 3] << 24;
+			if(objectSize <= 0 || objectSize > (buffer.length - index)) throw new Error("bad embedded document length in bson");
+
+			// We have a raw value
+			if(raw) {
+	      object[name] = buffer.slice(index, index + objectSize);
+			} else {
+	      object[name] = deserializeObject(buffer, _index, options, false);
+			}
+
+      index = index + objectSize;
+		} else if(elementType == BSON.BSON_DATA_ARRAY) {
+			var _index = index;
+      var objectSize = buffer[index] | buffer[index + 1] << 8 | buffer[index + 2] << 16 | buffer[index + 3] << 24;
+			var arrayOptions = options;
+
+			// All elements of array to be returned as raw bson
+			if(fieldsAsRaw && fieldsAsRaw[name]) {
+				arrayOptions = {};
+				for(var n in options) arrayOptions[n] = options[n];
+				arrayOptions['raw'] = true;
+			}
+
+      object[name] = deserializeObject(buffer, _index, arrayOptions, true);
+      index = index + objectSize;
 		} else if(elementType == BSON.BSON_DATA_UNDEFINED || elementType == BSON.BSON_DATA_NULL) {
-      // Parse the boolean value
       object[name] = null;
+		} else if(elementType == BSON.BSON_DATA_LONG) {
+      // Unpack the low and high bits
+      var lowBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
+      var highBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
+      var long = new Long(lowBits, highBits);
+      // Promote the long if possible
+      if(promoteLongs) {
+        object[name] = long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG) ? long.toNumber() : long;
+      } else {
+        object[name] = long;
+      }
 		} else if(elementType == BSON.BSON_DATA_BINARY) {
-      // Decode the size of the binary blob
       var binarySize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
-      // Decode the subtype
       var subType = buffer[index++];
       // Decode as raw Buffer object if options specifies it
       if(buffer['slice'] != null) {
@@ -138,10 +147,8 @@ var deserializeObject = function(buffer, options, isArray) {
           binarySize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
         }
         if(promoteBuffers) {
-          // assign reference to sliced Buffer object
           object[name] = buffer.slice(index, index + binarySize);
         } else {
-          // Slice the data
           object[name] = new Binary(buffer.slice(index, index + binarySize), subType);
         }
       } else {
@@ -155,59 +162,38 @@ var deserializeObject = function(buffer, options, isArray) {
           _buffer[i] = buffer[index + i];
         }
         if(promoteBuffers) {
-          // assign reference to Buffer object
           object[name] = _buffer;
         } else {
-          // Create the binary object
           object[name] = new Binary(_buffer, subType);
         }
       }
       // Update the index
       index = index + binarySize;
-		} else if(elementType == BSON.BSON_DATA_ARRAY) {
-      options['index'] = index;
-      // Decode the size of the array document
-      var objectSize = buffer[index] | buffer[index + 1] << 8 | buffer[index + 2] << 16 | buffer[index + 3] << 24;
-			var arrayOptions = options;
-
-			// All elements of array to be returned as raw bson
-			if(fieldsAsRaw[name]) {
-				arrayOptions = {};
-				for(var n in options) arrayOptions[n] = options[n];
-				arrayOptions['raw'] = true;
-			}
-
-      // Set the array to the object
-      object[name] = deserializeObject(buffer, arrayOptions, true);
-      // Adjust the index
-      index = index + objectSize;
-		} else if(elementType == BSON.BSON_DATA_OBJECT) {
-      options['index'] = index;
-      // Decode the size of the object document
-      var objectSize = buffer[index] | buffer[index + 1] << 8 | buffer[index + 2] << 16 | buffer[index + 3] << 24;
-			// Validate if string Size is larger than the actual provided buffer
-			if(objectSize <= 0 || objectSize > (buffer.length - index)) throw new Error("bad embedded document length in bson");
-
-			// We have a raw value
-			if(options['raw']) {
-				// Set the array to the object
-	      object[name] = buffer.slice(index, index + objectSize);
-			} else {
-				// Set the array to the object
-	      object[name] = deserializeObject(buffer, options, false);
-			}
-
-      // Adjust the index
-      index = index + objectSize;
 		} else if(elementType == BSON.BSON_DATA_REGEXP && bsonRegExp == false) {
+			// Get the start search index
+			var i = index;
+			// Locate the end of the c string
+			while(buffer[i] !== 0x00 && i < buffer.length) {
+				i++
+			}
+			// If are at the end of the buffer there is a problem with the document
+			if(i >= buffer.length) throw new Error("Bad BSON Document: illegal CString")
+			// Return the C string
+			var source = buffer.toString('utf8', index, i);
       // Create the regexp
-			var r = readCStyleStringSpecial(buffer, index);
-			var source = r.s;
-			index = r.i;
+			index = i + 1;
 
-			var r = readCStyleStringSpecial(buffer, index);
-			var regExpOptions = r.s;
-			index = r.i;
+			// Get the start search index
+			var i = index;
+			// Locate the end of the c string
+			while(buffer[i] !== 0x00 && i < buffer.length) {
+				i++
+			}
+			// If are at the end of the buffer there is a problem with the document
+			if(i >= buffer.length) throw new Error("Bad BSON Document: illegal CString")
+			// Return the C string
+			var regExpOptions = buffer.toString('utf8', index, i);
+			index = i + 1;
 
       // For each option add the corresponding one for javascript
       var optionsArray = new Array(regExpOptions.length);
@@ -229,61 +215,52 @@ var deserializeObject = function(buffer, options, isArray) {
 
       object[name] = new RegExp(source, optionsArray.join(''));
     } else if(elementType == BSON.BSON_DATA_REGEXP && bsonRegExp == true) {
-      // Create the regexp
-      var r = readCStyleStringSpecial(buffer, index);
-      var source = r.s;
-      index = r.i;
-
-      var r = readCStyleStringSpecial(buffer, index);
-      var regExpOptions = r.s;
-      index = r.i;
+			// Get the start search index
+			var i = index;
+			// Locate the end of the c string
+			while(buffer[i] !== 0x00 && i < buffer.length) {
+				i++
+			}
+			// If are at the end of the buffer there is a problem with the document
+			if(i >= buffer.length) throw new Error("Bad BSON Document: illegal CString")
+			// Return the C string
+			var source = buffer.toString('utf8', index, i);
+      index = i + 1;
+
+			// Get the start search index
+			var i = index;
+			// Locate the end of the c string
+			while(buffer[i] !== 0x00 && i < buffer.length) {
+				i++
+			}
+			// If are at the end of the buffer there is a problem with the document
+			if(i >= buffer.length) throw new Error("Bad BSON Document: illegal CString")
+			// Return the C string
+			var regExpOptions = buffer.toString('utf8', index, i);
+      index = i + 1;
 
       // Set the object
-      object[name] = new BSONRegExp(source, regExpOptions);      
-		} else if(elementType == BSON.BSON_DATA_LONG) {
-      // Unpack the low and high bits
-      var lowBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
-      var highBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
-      // Create long object
-      var long = new Long(lowBits, highBits);
-      // Promote the long if possible
-      if(promoteLongs) {
-        object[name] = long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG) ? long.toNumber() : long;
-      } else {
-        object[name] = long;
-      }
+      object[name] = new BSONRegExp(source, regExpOptions);
 		} else if(elementType == BSON.BSON_DATA_SYMBOL) {
-      // Read the content of the field
       var stringSize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
-			// Validate if string Size is larger than the actual provided buffer
 			if(stringSize <= 0 || stringSize > (buffer.length - index) || buffer[index + stringSize - 1] != 0) throw new Error("bad string length in bson");
-      // Add string to object
       object[name] = new Symbol(buffer.toString('utf8', index, index + stringSize - 1));
-      // Update parse index position
       index = index + stringSize;
 		} else if(elementType == BSON.BSON_DATA_TIMESTAMP) {
-      // Unpack the low and high bits
       var lowBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
       var highBits = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
-      // Set the object
       object[name] = new Timestamp(lowBits, highBits);
 		} else if(elementType == BSON.BSON_DATA_MIN_KEY) {
-      // Parse the object
       object[name] = new MinKey();
 		} else if(elementType == BSON.BSON_DATA_MAX_KEY) {
-      // Parse the object
       object[name] = new MaxKey();
 		} else if(elementType == BSON.BSON_DATA_CODE) {
-      // Read the content of the field
       var stringSize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
-			// Validate if string Size is larger than the actual provided buffer
 			if(stringSize <= 0 || stringSize > (buffer.length - index) || buffer[index + stringSize - 1] != 0) throw new Error("bad string length in bson");
-      // Function string
       var functionString = buffer.toString('utf8', index, index + stringSize - 1);
 
       // If we are evaluating the functions
       if(evalFunctions) {
-        // Contains the value we are going to set
         var value = null;
         // If we have cache enabled let's look for the md5 of the function in the cache
         if(cacheFunctions) {
@@ -291,7 +268,6 @@ var deserializeObject = function(buffer, options, isArray) {
           // Got to do this to avoid V8 deoptimizing the call due to finding eval
           object[name] = isolateEvalWithHash(functionCache, hash, functionString, object);
         } else {
-          // Set directly
           object[name] = isolateEval(functionString);
         }
       } else {
@@ -301,21 +277,19 @@ var deserializeObject = function(buffer, options, isArray) {
       // Update parse index position
       index = index + stringSize;
 		} else if(elementType == BSON.BSON_DATA_CODE_W_SCOPE) {
-      // Read the content of the field
       var totalSize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
       var stringSize = buffer[index++] | buffer[index++] << 8 | buffer[index++] << 16 | buffer[index++] << 24;
-			// Validate if string Size is larger than the actual provided buffer
 			if(stringSize <= 0 || stringSize > (buffer.length - index) || buffer[index + stringSize - 1] != 0) throw new Error("bad string length in bson");
       // Javascript function
       var functionString = buffer.toString('utf8', index, index + stringSize - 1);
       // Update parse index position
       index = index + stringSize;
       // Parse the element
-      options['index'] = index;
+			var _index = index;
       // Decode the size of the object document
       var objectSize = buffer[index] | buffer[index + 1] << 8 | buffer[index + 2] << 16 | buffer[index + 3] << 24;
       // Decode the scope object
-      var scopeObject = deserializeObject(buffer, options, false);
+      var scopeObject = deserializeObject(buffer, _index, options, false);
       // Adjust the index
       index = index + objectSize;
 
@@ -329,11 +303,9 @@ var deserializeObject = function(buffer, options, isArray) {
           // Got to do this to avoid V8 deoptimizing the call due to finding eval
           object[name] = isolateEvalWithHash(functionCache, hash, functionString, object);
         } else {
-          // Set directly
           object[name] = isolateEval(functionString);
         }
 
-        // Set the scope on the object
         object[name].scope = scopeObject;
       } else {
         object[name]  = new Code(functionString, scopeObject);
@@ -343,8 +315,6 @@ var deserializeObject = function(buffer, options, isArray) {
 
   // Check if we have a db ref object
   if(object['$id'] != null) object = new DBRef(object['$ref'], object['$id'], object['$db']);
-
-  // Return the final objects
   return object;
 }
 
@@ -421,6 +391,12 @@ BSON.BSON_DATA_ARRAY = 4;
  * @classconstant BSON_DATA_BINARY
  **/
 BSON.BSON_DATA_BINARY = 5;
+/**
+ * Binary BSON Type
+ *
+ * @classconstant BSON_DATA_UNDEFINED
+ **/
+BSON.BSON_DATA_UNDEFINED = 7;
 /**
  * ObjectID BSON Type
  *

package/lib/bson/parser/serializer.js

@@ -285,7 +285,7 @@ var serializeObject = function(buffer, key, value, index, checkKeys, depth, seri
 
 var serializeLong = function(buffer, key, value, index) {
   // Write the type
-  buffer[index++] = value instanceof Long ? BSON.BSON_DATA_LONG : BSON.BSON_DATA_TIMESTAMP;
+  buffer[index++] = value._bsontype == 'Long' ? BSON.BSON_DATA_LONG : BSON.BSON_DATA_TIMESTAMP;
   // Number of written bytes
   var numberOfWrittenBytes = buffer.write(key, index, 'utf8');
   // Encode the name
@@ -564,7 +564,7 @@ var serializeInto = function serializeInto(buffer, object, checkKeys, startingIn
       } else if(value['_bsontype'] == 'DBRef') {
         index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions);
       } else if(value['_bsontype'] == 'BSONRegExp') {
-        index = serializeBSONRegExp(buffer, key, value, index);        
+        index = serializeBSONRegExp(buffer, key, value, index);
       } else if(value['_bsontype'] == 'MinKey' || value['_bsontype'] == 'MaxKey') {
         index = serializeMinMax(buffer, key, value, index);
       }
@@ -603,7 +603,7 @@ var serializeInto = function serializeInto(buffer, object, checkKeys, startingIn
           }
         }
       }
-      
+
       // console.log("---------------------------------------------------")
       // console.dir("key = " + key)
       // console.dir("value = " + value)
@@ -642,7 +642,7 @@ var serializeInto = function serializeInto(buffer, object, checkKeys, startingIn
       } else if(value['_bsontype'] == 'DBRef') {
         index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions);
       } else if(value['_bsontype'] == 'BSONRegExp') {
-        index = serializeBSONRegExp(buffer, key, value, index);        
+        index = serializeBSONRegExp(buffer, key, value, index);
       } else if(value['_bsontype'] == 'MinKey' || value['_bsontype'] == 'MaxKey') {
         index = serializeMinMax(buffer, key, value, index);
       }
@@ -718,7 +718,7 @@ var serializeInto = function serializeInto(buffer, object, checkKeys, startingIn
       } else if(value['_bsontype'] == 'DBRef') {
         index = serializeDBRef(buffer, key, value, index, depth, serializeFunctions);
       } else if(value['_bsontype'] == 'BSONRegExp') {
-        index = serializeBSONRegExp(buffer, key, value, index);        
+        index = serializeBSONRegExp(buffer, key, value, index);
       } else if(value['_bsontype'] == 'MinKey' || value['_bsontype'] == 'MaxKey') {
         index = serializeMinMax(buffer, key, value, index);
       }

package/package.json

@@ -1,7 +1,7 @@
 { "name" :            "bson"
 , "description" :     "A bson parser for node.js and the browser"
 , "keywords" :        ["mongodb", "bson", "parser"]
-, "version" :         "0.4.19"
+, "version" :         "0.4.23"
 , "author" :          "Christian Amor Kvalheim <christkv@gmail.com>"
 , "contributors" :  []
 
@@ -12,7 +12,6 @@
 , "devDependencies": {
       "nodeunit": "0.9.0"
 	  , "gleak": "0.2.3"
-    , "one": "2.X.X"
     , "benchmark": "1.0.0"
     , "colors": "1.1.0"
   }