protobufjs 3.6.0 → 3.8.2

package/dist/ProtoBuf.noparse.js

@@ -38,7 +38,7 @@
          * @const
          * @expose
          */
-        ProtoBuf.VERSION = "3.6.0";
+        ProtoBuf.VERSION = "3.8.2";
 
         /**
          * Wire types.
@@ -234,138 +234,138 @@
          */
         ProtoBuf.populateAccessors = true;
 
-        /**
-         * @alias ProtoBuf.Util
-         * @expose
-         */
-        ProtoBuf.Util = (function() {
-            "use strict";
-
-            // Object.create polyfill
-            // ref: https://developer.mozilla.org/de/docs/JavaScript/Reference/Global_Objects/Object/create
-            if (!Object.create)
-                /** @expose */
-                Object.create = function (o) {
-                    if (arguments.length > 1)
-                        throw Error('Object.create polyfill only accepts the first parameter.');
-                    function F() {}
-                    F.prototype = o;
-                    return new F();
-                };
-
-            /**
-             * ProtoBuf utilities.
-             * @exports ProtoBuf.Util
-             * @namespace
-             */
-            var Util = {};
-
-            /**
-             * Flag if running in node (fs is available) or not.
-             * @type {boolean}
-             * @const
-             * @expose
-             */
-            Util.IS_NODE = false;
-            try {
-                // There is no reliable way to detect node.js as an environment, so our
-                // best bet is to feature-detect what we actually need.
-                Util.IS_NODE =
-                    typeof require === 'function' &&
-                    typeof require("fs").readFileSync === 'function' &&
-                    typeof require("path").resolve === 'function';
-            } catch (e) {}
-
-            /**
-             * Constructs a XMLHttpRequest object.
-             * @return {XMLHttpRequest}
-             * @throws {Error} If XMLHttpRequest is not supported
-             * @expose
-             */
-            Util.XHR = function() {
-                // No dependencies please, ref: http://www.quirksmode.org/js/xmlhttp.html
-                var XMLHttpFactories = [
-                    function () {return new XMLHttpRequest()},
-                    function () {return new ActiveXObject("Msxml2.XMLHTTP")},
-                    function () {return new ActiveXObject("Msxml3.XMLHTTP")},
-                    function () {return new ActiveXObject("Microsoft.XMLHTTP")}
-                ];
-                /** @type {?XMLHttpRequest} */
-                var xhr = null;
-                for (var i=0;i<XMLHttpFactories.length;i++) {
-                    try { xhr = XMLHttpFactories[i](); }
-                    catch (e) { continue; }
-                    break;
-                }
-                if (!xhr)
-                    throw Error("XMLHttpRequest is not supported");
-                return xhr;
-            };
-
-            /**
-             * Fetches a resource.
-             * @param {string} path Resource path
-             * @param {function(?string)=} callback Callback receiving the resource's contents. If omitted the resource will
-             *   be fetched synchronously. If the request failed, contents will be null.
-             * @return {?string|undefined} Resource contents if callback is omitted (null if the request failed), else undefined.
-             * @expose
-             */
-            Util.fetch = function(path, callback) {
-                if (callback && typeof callback != 'function')
-                    callback = null;
-                if (Util.IS_NODE) {
-                    if (callback) {
-                        require("fs").readFile(path, function(err, data) {
-                            if (err)
-                                callback(null);
-                            else
-                                callback(""+data);
-                        });
-                    } else
-                        try {
-                            return require("fs").readFileSync(path);
-                        } catch (e) {
-                            return null;
-                        }
-                } else {
-                    var xhr = Util.XHR();
-                    xhr.open('GET', path, callback ? true : false);
-                    // xhr.setRequestHeader('User-Agent', 'XMLHTTP/1.0');
-                    xhr.setRequestHeader('Accept', 'text/plain');
-                    if (typeof xhr.overrideMimeType === 'function') xhr.overrideMimeType('text/plain');
-                    if (callback) {
-                        xhr.onreadystatechange = function() {
-                            if (xhr.readyState != 4) return;
-                            if (/* remote */ xhr.status == 200 || /* local */ (xhr.status == 0 && typeof xhr.responseText === 'string'))
-                                callback(xhr.responseText);
-                            else
-                                callback(null);
-                        };
-                        if (xhr.readyState == 4)
-                            return;
-                        xhr.send(null);
-                    } else {
-                        xhr.send(null);
-                        if (/* remote */ xhr.status == 200 || /* local */ (xhr.status == 0 && typeof xhr.responseText === 'string'))
-                            return xhr.responseText;
-                        return null;
-                    }
-                }
-            };
-
-            /**
-             * Tests if an object is an array.
-             * @function
-             * @param {*} obj Object to test
-             * @returns {boolean} true if it is an array, else false
-             * @expose
-             */
-            Util.isArray = Array.isArray || function(obj) {
-                return Object.prototype.toString.call(obj) === "[object Array]";
-            };
-
-            return Util;
-        })();
+        /**
+         * @alias ProtoBuf.Util
+         * @expose
+         */
+        ProtoBuf.Util = (function() {
+            "use strict";
+
+            // Object.create polyfill
+            // ref: https://developer.mozilla.org/de/docs/JavaScript/Reference/Global_Objects/Object/create
+            if (!Object.create)
+                /** @expose */
+                Object.create = function (o) {
+                    if (arguments.length > 1)
+                        throw Error('Object.create polyfill only accepts the first parameter.');
+                    function F() {}
+                    F.prototype = o;
+                    return new F();
+                };
+
+            /**
+             * ProtoBuf utilities.
+             * @exports ProtoBuf.Util
+             * @namespace
+             */
+            var Util = {};
+
+            /**
+             * Flag if running in node (fs is available) or not.
+             * @type {boolean}
+             * @const
+             * @expose
+             */
+            Util.IS_NODE = false;
+            try {
+                // There is no reliable way to detect node.js as an environment, so our
+                // best bet is to feature-detect what we actually need.
+                Util.IS_NODE =
+                    typeof require === 'function' &&
+                    typeof require("fs").readFileSync === 'function' &&
+                    typeof require("path").resolve === 'function';
+            } catch (e) {}
+
+            /**
+             * Constructs a XMLHttpRequest object.
+             * @return {XMLHttpRequest}
+             * @throws {Error} If XMLHttpRequest is not supported
+             * @expose
+             */
+            Util.XHR = function() {
+                // No dependencies please, ref: http://www.quirksmode.org/js/xmlhttp.html
+                var XMLHttpFactories = [
+                    function () {return new XMLHttpRequest()},
+                    function () {return new ActiveXObject("Msxml2.XMLHTTP")},
+                    function () {return new ActiveXObject("Msxml3.XMLHTTP")},
+                    function () {return new ActiveXObject("Microsoft.XMLHTTP")}
+                ];
+                /** @type {?XMLHttpRequest} */
+                var xhr = null;
+                for (var i=0;i<XMLHttpFactories.length;i++) {
+                    try { xhr = XMLHttpFactories[i](); }
+                    catch (e) { continue; }
+                    break;
+                }
+                if (!xhr)
+                    throw Error("XMLHttpRequest is not supported");
+                return xhr;
+            };
+
+            /**
+             * Fetches a resource.
+             * @param {string} path Resource path
+             * @param {function(?string)=} callback Callback receiving the resource's contents. If omitted the resource will
+             *   be fetched synchronously. If the request failed, contents will be null.
+             * @return {?string|undefined} Resource contents if callback is omitted (null if the request failed), else undefined.
+             * @expose
+             */
+            Util.fetch = function(path, callback) {
+                if (callback && typeof callback != 'function')
+                    callback = null;
+                if (Util.IS_NODE) {
+                    if (callback) {
+                        require("fs").readFile(path, function(err, data) {
+                            if (err)
+                                callback(null);
+                            else
+                                callback(""+data);
+                        });
+                    } else
+                        try {
+                            return require("fs").readFileSync(path);
+                        } catch (e) {
+                            return null;
+                        }
+                } else {
+                    var xhr = Util.XHR();
+                    xhr.open('GET', path, callback ? true : false);
+                    // xhr.setRequestHeader('User-Agent', 'XMLHTTP/1.0');
+                    xhr.setRequestHeader('Accept', 'text/plain');
+                    if (typeof xhr.overrideMimeType === 'function') xhr.overrideMimeType('text/plain');
+                    if (callback) {
+                        xhr.onreadystatechange = function() {
+                            if (xhr.readyState != 4) return;
+                            if (/* remote */ xhr.status == 200 || /* local */ (xhr.status == 0 && typeof xhr.responseText === 'string'))
+                                callback(xhr.responseText);
+                            else
+                                callback(null);
+                        };
+                        if (xhr.readyState == 4)
+                            return;
+                        xhr.send(null);
+                    } else {
+                        xhr.send(null);
+                        if (/* remote */ xhr.status == 200 || /* local */ (xhr.status == 0 && typeof xhr.responseText === 'string'))
+                            return xhr.responseText;
+                        return null;
+                    }
+                }
+            };
+
+            /**
+             * Tests if an object is an array.
+             * @function
+             * @param {*} obj Object to test
+             * @returns {boolean} true if it is an array, else false
+             * @expose
+             */
+            Util.isArray = Array.isArray || function(obj) {
+                return Object.prototype.toString.call(obj) === "[object Array]";
+            };
+
+            return Util;
+        })();
 
         /**
          * Language expressions.
@@ -402,7 +402,7 @@
             ID: /^(?:[1-9][0-9]*|0|0x[0-9a-fA-F]+|0[0-7]+)$/,
             NEGID: /^\-?(?:[1-9][0-9]*|0|0x[0-9a-fA-F]+|0[0-7]+)$/,
             WHITESPACE: /\s/,
-            STRING: /['"]([^'"\\]*(\\.[^"\\]*)*)['"]/g,
+            STRING: /(?:"([^"\\]*(?:\\.[^"\\]*)*)")|(?:'([^'\\]*(?:\\.[^'\\]*)*)')/g,
             BOOL: /^(?:true|false)$/i
         };
 
@@ -426,14 +426,22 @@
              * @exports ProtoBuf.Reflect.T
              * @constructor
              * @abstract
-             * @param {ProtoBuf.Reflect.T} parent Parent object
+             * @param {!ProtoBuf.Builder} builder Builder reference
+             * @param {?ProtoBuf.Reflect.T} parent Parent object
              * @param {string} name Object name
              */
-            var T = function(parent, name) {
+            var T = function(builder, parent, name) {
+
+                /**
+                 * Builder reference.
+                 * @type {!ProtoBuf.Builder}
+                 * @expose
+                 */
+                this.builder = builder;
 
                 /**
                  * Parent object.
-                 * @type {ProtoBuf.Reflect.T|null}
+                 * @type {?ProtoBuf.Reflect.T}
                  * @expose
                  */
                 this.parent = parent;
@@ -453,12 +461,18 @@
                 this.className;
             };
 
+            /**
+             * @alias ProtoBuf.Reflect.T.prototype
+             * @inner
+             */
+            var TPrototype = T.prototype;
+
             /**
              * Returns the fully qualified name of this object.
              * @returns {string} Fully qualified name as of ".PATH.TO.THIS"
              * @expose
              */
-            T.prototype.fqn = function() {
+            TPrototype.fqn = function() {
                 var name = this.name,
                     ptr = this;
                 do {
@@ -476,7 +490,7 @@
              * @return String representation
              * @expose
              */
-            T.prototype.toString = function(includeClass) {
+            TPrototype.toString = function(includeClass) {
                 return (includeClass ? this.className + " " : "") + this.fqn();
             };
 
@@ -485,7 +499,7 @@
              * @throws {Error} If this type cannot be built directly
              * @expose
              */
-            T.prototype.build = function() {
+            TPrototype.build = function() {
                 throw Error(this.toString(true)+" cannot be built directly");
             };
 
@@ -498,14 +512,15 @@
             /**
              * Constructs a new Namespace.
              * @exports ProtoBuf.Reflect.Namespace
-             * @param {ProtoBuf.Reflect.Namespace|null} parent Namespace parent
+             * @param {!ProtoBuf.Builder} builder Builder reference
+             * @param {?ProtoBuf.Reflect.Namespace} parent Namespace parent
              * @param {string} name Namespace name
-             * @param {Object.<string,*>} options Namespace options
+             * @param {Object.<string,*>=} options Namespace options
              * @constructor
              * @extends ProtoBuf.Reflect.T
              */
-            var Namespace = function(parent, name, options) {
-                T.call(this, parent, name);
+            var Namespace = function(builder, parent, name, options) {
+                T.call(this, builder, parent, name);
 
                 /**
                  * @override
@@ -514,19 +529,22 @@
 
                 /**
                  * Children inside the namespace.
-                 * @type {Array.<ProtoBuf.Reflect.T>}
+                 * @type {!Array.<ProtoBuf.Reflect.T>}
                  */
                 this.children = [];
 
                 /**
                  * Options.
-                 * @type {Object.<string, *>}
+                 * @type {!Object.<string, *>}
                  */
                 this.options = options || {};
             };
 
-            // Extends T
-            Namespace.prototype = Object.create(T.prototype);
+            /**
+             * @alias ProtoBuf.Reflect.Namespace.prototype
+             * @inner
+             */
+            var NamespacePrototype = Namespace.prototype = Object.create(T.prototype);
 
             /**
              * Returns an array of the namespace's children.
@@ -534,7 +552,7 @@
              * @return {Array.<ProtoBuf.Reflect.T>}
              * @expose
              */
-            Namespace.prototype.getChildren = function(type) {
+            NamespacePrototype.getChildren = function(type) {
                 type = type || null;
                 if (type == null)
                     return this.children.slice();
@@ -551,7 +569,7 @@
              * @throws {Error} If the child cannot be added (duplicate)
              * @expose
              */
-            Namespace.prototype.addChild = function(child) {
+            NamespacePrototype.addChild = function(child) {
                 var other;
                 if (other = this.getChild(child.name)) {
                     // Try to revert camelcase transformation on collision
@@ -571,7 +589,7 @@
              * @return {?ProtoBuf.Reflect.T} The child or null if not found
              * @expose
              */
-            Namespace.prototype.getChild = function(nameOrId) {
+            NamespacePrototype.getChild = function(nameOrId) {
                 var key = typeof nameOrId === 'number' ? 'id' : 'name';
                 for (var i=0, k=this.children.length; i<k; ++i)
                     if (this.children[i][key] === nameOrId)
@@ -586,7 +604,7 @@
              * @return {?ProtoBuf.Reflect.Namespace} The resolved type or null if not found
              * @expose
              */
-            Namespace.prototype.resolve = function(qn, excludeFields) {
+            NamespacePrototype.resolve = function(qn, excludeFields) {
                 var part = qn.split("."),
                     ptr = this,
                     i = 0;
@@ -620,7 +638,7 @@
              * @return {Object.<string,Function|Object>} Runtime namespace
              * @expose
              */
-            Namespace.prototype.build = function() {
+            NamespacePrototype.build = function() {
                 /** @dict */
                 var ns = {};
                 var children = this.children;
@@ -638,7 +656,7 @@
              * Builds the namespace's '$options' property.
              * @return {Object.<string,*>}
              */
-            Namespace.prototype.buildOpt = function() {
+            NamespacePrototype.buildOpt = function() {
                 var opt = {},
                     keys = Object.keys(this.options);
                 for (var i=0, k=keys.length; i<k; ++i) {
@@ -659,7 +677,7 @@
              * @param {string=} name Returns the option value if specified, otherwise all options are returned.
              * @return {*|Object.<string,*>}null} Option value or NULL if there is no such option
              */
-            Namespace.prototype.getOption = function(name) {
+            NamespacePrototype.getOption = function(name) {
                 if (typeof name === 'undefined')
                     return this.options;
                 return typeof this.options[name] !== 'undefined' ? this.options[name] : null;
@@ -674,15 +692,16 @@
             /**
              * Constructs a new Message.
              * @exports ProtoBuf.Reflect.Message
-             * @param {ProtoBuf.Reflect.Namespace} parent Parent message or namespace
+             * @param {!ProtoBuf.Builder} builder Builder reference
+             * @param {!ProtoBuf.Reflect.Namespace} parent Parent message or namespace
              * @param {string} name Message name
-             * @param {Object.<string,*>} options Message options
+             * @param {Object.<string,*>=} options Message options
              * @param {boolean=} isGroup `true` if this is a legacy group
              * @constructor
              * @extends ProtoBuf.Reflect.Namespace
              */
-            var Message = function(parent, name, options, isGroup) {
-                Namespace.call(this, parent, name, options);
+            var Message = function(builder, parent, name, options, isGroup) {
+                Namespace.call(this, builder, parent, name, options);
 
                 /**
                  * @override
@@ -725,10 +744,20 @@
                  * @private
                  */
                 this._fieldsById = null;
+
+                /**
+                 * Cached fields by name.
+                 * @type {?Object.<string,!ProtoBuf.Reflect.Message.Field>}
+                 * @private
+                 */
+                this._fieldsByName = null;
             };
 
-            // Extends Namespace
-            Message.prototype = Object.create(Namespace.prototype);
+            /**
+             * @alias ProtoBuf.Reflect.Message.prototype
+             * @inner
+             */
+            var MessagePrototype = Message.prototype = Object.create(Namespace.prototype);
 
             /**
              * Builds the message and returns the runtime counterpart, which is a fully functional class.
@@ -738,14 +767,15 @@
              * @throws {Error} If the message cannot be built
              * @expose
              */
-            Message.prototype.build = function(rebuild) {
+            MessagePrototype.build = function(rebuild) {
                 if (this.clazz && !rebuild)
                     return this.clazz;
 
                 // Create the runtime Message class in its own scope
                 var clazz = (function(ProtoBuf, T) {
 
-                    var fields = T.getChildren(ProtoBuf.Reflect.Message.Field);
+                    var fields = T.getChildren(ProtoBuf.Reflect.Message.Field),
+                        oneofs = T.getChildren(ProtoBuf.Reflect.Message.OneOf);
 
                     /**
                      * Constructs a new runtime Message.
@@ -759,9 +789,13 @@
                     var Message = function(values, var_args) {
                         ProtoBuf.Builder.Message.call(this);
 
-                        // Create fields on the object itself and set default values
-                        for (var i=0, k=fields.length, field; i<k; ++i) {
-                            this[(field = fields[i]).name] = field.repeated ? [] : null;
+                        // Create virtual oneof properties
+                        for (var i=0, k=oneofs.length; i<k; ++i)
+                            this[oneofs[i].name] = null;
+                        // Create fields and set default values
+                        for (i=0, k=fields.length; i<k; ++i) {
+                            var field = fields[i];
+                            this[field.name] = field.repeated ? [] : null;
                             if (field.required && field.defaultValue !== null)
                                 this[field.name] = field.defaultValue;
                         }
@@ -777,21 +811,17 @@
                                 var keys = Object.keys(values);
                                 for (i=0, k=keys.length; i<k; ++i)
                                     this.$set(keys[i], values[keys[i]]); // May throw
-                            } else // set field values from arguments, in declaration order
+                            } else // Set field values from arguments, in declaration order
                                 for (i=0, k=arguments.length; i<k; ++i)
                                     this.$set(fields[i].name, arguments[i]); // May throw
                         }
                     };
 
                     /**
-                     * The message's reflection type.
-                     * @name ProtoBuf.Builder.Message#$type
-                     * @type {!ProtoBuf.Reflect.Message}
-                     * @expose
+                     * @alias ProtoBuf.Builder.Message.prototype
+                     * @inner
                      */
-
-                    // Extends ProtoBuf.Builder.Message
-                    Message.prototype = Object.create(ProtoBuf.Builder.Message.prototype);
+                    var MessagePrototype = Message.prototype = Object.create(ProtoBuf.Builder.Message.prototype);
 
                     /**
                      * Adds a value to a repeated field.
@@ -803,14 +833,16 @@
                      * @throws {Error} If the value cannot be added
                      * @expose
                      */
-                    Message.prototype.add = function(key, value, noAssert) {
-                        var field = T.getChild(key);
-                        if (!field)
-                            throw Error(this+"#"+key+" is undefined");
-                        if (!(field instanceof ProtoBuf.Reflect.Message.Field))
-                            throw Error(this+"#"+key+" is not a field: "+field.toString(true)); // May throw if it's an enum or embedded message
-                        if (!field.repeated)
-                            throw Error(this+"#"+key+" is not a repeated field");
+                    MessagePrototype.add = function(key, value, noAssert) {
+                        var field = T._fieldsByName[key];
+                        if (!noAssert) {
+                            if (!field)
+                                throw Error(this+"#"+key+" is undefined");
+                            if (!(field instanceof ProtoBuf.Reflect.Message.Field))
+                                throw Error(this+"#"+key+" is not a field: "+field.toString(true)); // May throw if it's an enum or embedded message
+                            if (!field.repeated)
+                                throw Error(this+"#"+key+" is not a repeated field");
+                        }
                         if (this[field.name] === null)
                             this[field.name] = [];
                         this[field.name].push(noAssert ? value : field.verifyValue(value, true));
@@ -826,7 +858,7 @@
                      * @throws {Error} If the value cannot be added
                      * @expose
                      */
-                    Message.prototype.$add = Message.prototype.add;
+                    MessagePrototype.$add = MessagePrototype.add;
 
                     /**
                      * Sets a field's value.
@@ -839,23 +871,31 @@
                      * @throws {Error} If the value cannot be set
                      * @expose
                      */
-                    Message.prototype.set = function(key, value, noAssert) {
+                    MessagePrototype.set = function(key, value, noAssert) {
                         if (key && typeof key === 'object') {
                             for (var i in key)
                                 if (key.hasOwnProperty(i))
                                     this.$set(i, key[i], noAssert);
                             return this;
                         }
-                        if (noAssert) {
-                            this[key] = value;
-                            return this;
+                        var field = T._fieldsByName[key];
+                        if (!noAssert) {
+                            if (!field)
+                                throw Error(this+"#"+key+" is not a field: undefined");
+                            if (!(field instanceof ProtoBuf.Reflect.Message.Field))
+                                throw Error(this+"#"+key+" is not a field: "+field.toString(true));
+                            this[field.name] = (value = field.verifyValue(value)); // May throw
+                        } else {
+                            this[field.name] = value;
+                        }
+                        if (field.oneof) {
+                            if (value !== null) {
+                                if (this[field.oneof.name] !== null)
+                                    this[this[field.oneof.name]] = null; // Unset the previous (field name is the oneof field's value)
+                                this[field.oneof.name] = field.name;
+                            } else if (field.oneof.name === key)
+                                this[field.oneof.name] = null;
                         }
-                        var field = T.getChild(key);
-                        if (!field)
-                            throw Error(this+"#"+key+" is not a field: undefined");
-                        if (!(field instanceof ProtoBuf.Reflect.Message.Field))
-                            throw Error(this+"#"+key+" is not a field: "+field.toString(true));
-                        this[field.name] = field.verifyValue(value); // May throw
                         return this;
                     };
 
@@ -865,26 +905,26 @@
                      * @function
                      * @param {string} key Key
                      * @param {*} value Value to set
-                     * @param {boolean=} noAssert Whether to assert the value or not (asserts by default)
+                     * @param {boolean=} noAssert Whether to not assert the value, defaults to `false`
                      * @throws {Error} If the value cannot be set
                      * @expose
                      */
-                    Message.prototype.$set = Message.prototype.set;
+                    MessagePrototype.$set = MessagePrototype.set;
 
                     /**
                      * Gets a field's value.
                      * @name ProtoBuf.Builder.Message#get
                      * @function
                      * @param {string} key Key
-                     * @param {boolean=} noAssert Whether to no assert for an actual field, defaults to `false`
+                     * @param {boolean=} noAssert Whether to not assert for an actual field, defaults to `false`
                      * @return {*} Value
                      * @throws {Error} If there is no such field
                      * @expose
                      */
-                    Message.prototype.get = function(key, noAssert) {
+                    MessagePrototype.get = function(key, noAssert) {
                         if (noAssert)
                             return this[key];
-                        var field = T.getChild(key);
+                        var field = T._fieldsByName[key];
                         if (!field || !(field instanceof ProtoBuf.Reflect.Message.Field))
                             throw Error(this+"#"+key+" is not a field: undefined");
                         if (!(field instanceof ProtoBuf.Reflect.Message.Field))
@@ -901,7 +941,7 @@
                      * @throws {Error} If there is no such field
                      * @expose
                      */
-                    Message.prototype.$get = Message.prototype.get;
+                    MessagePrototype.$get = MessagePrototype.get;
 
                     // Getters and setters
 
@@ -911,72 +951,91 @@
                         if (field instanceof ProtoBuf.Reflect.Message.ExtensionField)
                             continue;
 
-                        if (ProtoBuf.populateAccessors)
+                        if (T.builder.options['populateAccessors'])
                             (function(field) {
                                 // set/get[SomeValue]
                                 var Name = field.originalName.replace(/(_[a-zA-Z])/g, function(match) {
                                     return match.toUpperCase().replace('_','');
                                 });
-                                Name = Name.substring(0,1).toUpperCase()+Name.substring(1);
+                                Name = Name.substring(0,1).toUpperCase() + Name.substring(1);
 
-                                // set/get_[some_value]
+                                // set/get_[some_value] FIXME: Do we really need these?
                                 var name = field.originalName.replace(/([A-Z])/g, function(match) {
                                     return "_"+match;
                                 });
 
+                                /**
+                                 * The current field's unbound setter function.
+                                 * @function
+                                 * @param {*} value
+                                 * @param {boolean=} noAssert
+                                 * @returns {!ProtoBuf.Builder.Message}
+                                 * @inner
+                                 */
+                                var setter = function(value, noAssert) {
+                                    this[field.name] = noAssert ? value : field.verifyValue(value);
+                                    return this;
+                                };
+
+                                /**
+                                 * The current field's unbound getter function.
+                                 * @function
+                                 * @returns {*}
+                                 * @inner
+                                 */
+                                var getter = function() {
+                                    return this[field.name];
+                                };
+
                                 /**
                                  * Sets a value. This method is present for each field, but only if there is no name conflict with
-                                 * another field.
+                                 *  another field.
                                  * @name ProtoBuf.Builder.Message#set[SomeField]
                                  * @function
                                  * @param {*} value Value to set
+                                 * @param {boolean=} noAssert Whether to not assert the value, defaults to `false`
+                                 * @returns {!ProtoBuf.Builder.Message} this
                                  * @abstract
                                  * @throws {Error} If the value cannot be set
                                  */
                                 if (T.getChild("set"+Name) === null)
-                                    Message.prototype["set"+Name] = function(value) {
-                                        this.$set(field.name, value);
-                                    };
+                                    MessagePrototype["set"+Name] = setter;
 
                                 /**
                                  * Sets a value. This method is present for each field, but only if there is no name conflict with
-                                 * another field.
+                                 *  another field.
                                  * @name ProtoBuf.Builder.Message#set_[some_field]
                                  * @function
                                  * @param {*} value Value to set
+                                 * @param {boolean=} noAssert Whether to not assert the value, defaults to `false`
+                                 * @returns {!ProtoBuf.Builder.Message} this
                                  * @abstract
                                  * @throws {Error} If the value cannot be set
                                  */
                                 if (T.getChild("set_"+name) === null)
-                                    Message.prototype["set_"+name] = function(value) {
-                                        this.$set(field.name, value);
-                                    };
+                                    MessagePrototype["set_"+name] = setter;
 
                                 /**
                                  * Gets a value. This method is present for each field, but only if there is no name conflict with
-                                 * another field.
+                                 *  another field.
                                  * @name ProtoBuf.Builder.Message#get[SomeField]
                                  * @function
                                  * @abstract
                                  * @return {*} The value
                                  */
                                 if (T.getChild("get"+Name) === null)
-                                    Message.prototype["get"+Name] = function() {
-                                        return this.$get(field.name); // Does not throw, field exists
-                                    };
+                                    MessagePrototype["get"+Name] = getter;
 
                                 /**
                                  * Gets a value. This method is present for each field, but only if there is no name conflict with
-                                 * another field.
+                                 *  another field.
                                  * @name ProtoBuf.Builder.Message#get_[some_field]
                                  * @function
                                  * @return {*} The value
                                  * @abstract
                                  */
                                 if (T.getChild("get_"+name) === null)
-                                    Message.prototype["get_"+name] = function() {
-                                        return this.$get(field.name); // Does not throw, field exists
-                                    };
+                                    MessagePrototype["get_"+name] = getter;
 
                             })(field);
                     }
@@ -997,7 +1056,7 @@
                      * @see ProtoBuf.Builder.Message#encodeHex
                      * @see ProtoBuf.Builder.Message#encodeAB
                      */
-                    Message.prototype.encode = function(buffer, noVerify) {
+                    MessagePrototype.encode = function(buffer, noVerify) {
                         if (typeof buffer === 'boolean')
                             noVerify = buffer,
                             buffer = undefined;
@@ -1023,7 +1082,7 @@
                      * @throws {Error} If the message cannot be calculated or if required fields are missing.
                      * @expose
                      */
-                    Message.prototype.calculate = function() {
+                    MessagePrototype.calculate = function() {
                         return T.calculate(this);
                     };
 
@@ -1037,7 +1096,7 @@
                      *  returns the encoded ByteBuffer in the `encoded` property on the error.
                      * @expose
                      */
-                    Message.prototype.encodeDelimited = function(buffer) {
+                    MessagePrototype.encodeDelimited = function(buffer) {
                         var isNew = false;
                         if (!buffer)
                             buffer = new ByteBuffer(),
@@ -1058,7 +1117,7 @@
                      *  returns the encoded ArrayBuffer in the `encoded` property on the error.
                      * @expose
                      */
-                    Message.prototype.encodeAB = function() {
+                    MessagePrototype.encodeAB = function() {
                         try {
                             return this.encode().toArrayBuffer();
                         } catch (e) {
@@ -1076,7 +1135,7 @@
                      *  returns the encoded ArrayBuffer in the `encoded` property on the error.
                      * @expose
                      */
-                    Message.prototype.toArrayBuffer = Message.prototype.encodeAB;
+                    MessagePrototype.toArrayBuffer = MessagePrototype.encodeAB;
 
                     /**
                      * Directly encodes the message to a node Buffer.
@@ -1087,7 +1146,7 @@
                      *  missing. The later still returns the encoded node Buffer in the `encoded` property on the error.
                      * @expose
                      */
-                    Message.prototype.encodeNB = function() {
+                    MessagePrototype.encodeNB = function() {
                         try {
                             return this.encode().toBuffer();
                         } catch (e) {
@@ -1105,7 +1164,7 @@
                      *  returns the encoded node Buffer in the `encoded` property on the error.
                      * @expose
                      */
-                    Message.prototype.toBuffer = Message.prototype.encodeNB;
+                    MessagePrototype.toBuffer = MessagePrototype.encodeNB;
 
                     /**
                      * Directly encodes the message to a base64 encoded string.
@@ -1116,7 +1175,7 @@
                      *  still returns the encoded base64 string in the `encoded` property on the error.
                      * @expose
                      */
-                    Message.prototype.encode64 = function() {
+                    MessagePrototype.encode64 = function() {
                         try {
                             return this.encode().toBase64();
                         } catch (e) {
@@ -1134,7 +1193,7 @@
                      *  returns the encoded base64 string in the `encoded` property on the error.
                      * @expose
                      */
-                    Message.prototype.toBase64 = Message.prototype.encode64;
+                    MessagePrototype.toBase64 = MessagePrototype.encode64;
 
                     /**
                      * Directly encodes the message to a hex encoded string.
@@ -1145,7 +1204,7 @@
                      *  still returns the encoded hex string in the `encoded` property on the error.
                      * @expose
                      */
-                    Message.prototype.encodeHex = function() {
+                    MessagePrototype.encodeHex = function() {
                         try {
                             return this.encode().toHex();
                         } catch (e) {
@@ -1163,38 +1222,38 @@
                      *  returns the encoded hex string in the `encoded` property on the error.
                      * @expose
                      */
-                    Message.prototype.toHex = Message.prototype.encodeHex;
+                    MessagePrototype.toHex = MessagePrototype.encodeHex;
 
                     /**
                      * Clones a message object to a raw object.
                      * @param {*} obj Object to clone
-                     * @param {boolean} includeBuffers Whether to include native buffer data or not
+                     * @param {boolean} includeBinaryAsBase64 Whether to include binary data as base64 strings or not
                      * @returns {*} Cloned object
                      * @inner
                      */
-                    function cloneRaw(obj, includeBuffers) {
+                    function cloneRaw(obj, includeBinaryAsBase64) {
                         var clone = {};
                         for (var i in obj)
                             if (obj.hasOwnProperty(i)) {
                                 if (obj[i] === null || typeof obj[i] !== 'object')
                                     clone[i] = obj[i];
                                 else if (obj[i] instanceof ByteBuffer) {
-                                    if (includeBuffers)
-                                        clone[i] = obj.toBuffer();
+                                    if (includeBinaryAsBase64)
+                                        clone[i] = obj[i].toBase64();
                                 } else // is a non-null object
-                                    clone[i] = cloneRaw(obj[i], includeBuffers);
+                                    clone[i] = cloneRaw(obj[i], includeBinaryAsBase64);
                             }
                         return clone;
                     }
 
                     /**
                      * Returns the message's raw payload.
-                     * @param {boolean=} includeBuffers Whether to include native buffer data or not, defaults to `false`
+                     * @param {boolean=} includeBinaryAsBase64 Whether to include binary data as base64 strings or not, defaults to `false`
                      * @returns {Object.<string,*>} Raw payload
                      * @expose
                      */
-                    Message.prototype.toRaw = function(includeBuffers) {
-                        return cloneRaw(this, !!includeBuffers);
+                    MessagePrototype.toRaw = function(includeBinaryAsBase64) {
+                        return cloneRaw(this, !!includeBinaryAsBase64);
                     };
 
                     /**
@@ -1295,7 +1354,7 @@
                      * @return {string} String representation as of ".Fully.Qualified.MessageName"
                      * @expose
                      */
-                    Message.prototype.toString = function() {
+                    MessagePrototype.toString = function() {
                         return T.toString();
                     };
 
@@ -1319,7 +1378,7 @@
 
                     if (Object.defineProperty)
                         Object.defineProperty(Message, '$options', { "value": T.buildOpt() }),
-                        Object.defineProperty(Message.prototype, "$type", {
+                        Object.defineProperty(MessagePrototype, "$type", {
                             get: function() { return T; }
                         });
 
@@ -1329,20 +1388,20 @@
 
                 // Static enums and prototyped sub-messages / cached collections
                 this._fields = [];
-                this._fieldsById = [];
+                this._fieldsById = {};
+                this._fieldsByName = {};
                 for (var i=0, k=this.children.length, child; i<k; i++) {
                     child = this.children[i];
                     if (child instanceof Enum)
-                        clazz[child['name']] = child.build();
+                        clazz[child.name] = child.build();
                     else if (child instanceof Message)
-                        clazz[child['name']] = child.build();
+                        clazz[child.name] = child.build();
                     else if (child instanceof Message.Field)
                         child.build(),
                         this._fields.push(child),
-                        this._fieldsById[child.id] = child;
-                    else if (child instanceof Extension) {
-                        // Ignore
-                    } else
+                        this._fieldsById[child.id] = child,
+                        this._fieldsByName[child.name] = child;
+                    else if (!(child instanceof Message.OneOf) && !(child instanceof Extension)) // Not built
                         throw Error("Illegal reflect child of "+this.toString(true)+": "+children[i].toString(true));
                 }
 
@@ -1358,11 +1417,11 @@
              * @throws {Error} If required fields are missing or the message cannot be encoded for another reason
              * @expose
              */
-            Message.prototype.encode = function(message, buffer, noVerify) {
+            MessagePrototype.encode = function(message, buffer, noVerify) {
                 var fieldMissing = null,
                     field;
                 for (var i=0, k=this._fields.length, val; i<k; ++i) {
-                    field = this.children[i];
+                    field = this._fields[i];
                     val = message[field.name];
                     if (field.required && val === null) {
                         if (fieldMissing === null)
@@ -1385,7 +1444,7 @@
              * @throws {Error} If required fields are missing or the message cannot be calculated for another reason
              * @expose
              */
-            Message.prototype.calculate = function(message) {
+            MessagePrototype.calculate = function(message) {
                 for (var n=0, i=0, k=this._fields.length, field, val; i<k; ++i) {
                     field = this._fields[i];
                     val = message[field.name];
@@ -1447,7 +1506,7 @@
              * @throws {Error} If the message cannot be decoded
              * @expose
              */
-            Message.prototype.decode = function(buffer, length, expectedGroupEndId) {
+            MessagePrototype.decode = function(buffer, length, expectedGroupEndId) {
                 length = typeof length === 'number' ? length : -1;
                 var start = buffer.offset,
                     msg = new (this.clazz)(),
@@ -1487,8 +1546,14 @@
                     }
                     if (field.repeated && !field.options["packed"])
                         msg[field.name].push(field.decode(wireType, buffer));
-                    else
+                    else {
                         msg[field.name] = field.decode(wireType, buffer);
+                        if (field.oneof) {
+                            if (this[field.oneof.name] !== null)
+                                this[this[field.oneof.name]] = null;
+                            msg[field.oneof.name] = field.name;
+                        }
+                    }
                 }
 
                 // Check if all required fields are present and set default values for optional fields that are not
@@ -1514,17 +1579,19 @@
             /**
              * Constructs a new Message Field.
              * @exports ProtoBuf.Reflect.Message.Field
-             * @param {ProtoBuf.Reflect.Message} message Message reference
+             * @param {!ProtoBuf.Builder} builder Builder reference
+             * @param {!ProtoBuf.Reflect.Message} message Message reference
              * @param {string} rule Rule, one of requried, optional, repeated
              * @param {string} type Data type, e.g. int32
              * @param {string} name Field name
              * @param {number} id Unique field id
              * @param {Object.<string,*>=} options Options
+             * @param {!ProtoBuf.Reflect.Message.OneOf=} oneof Enclosing OneOf
              * @constructor
              * @extends ProtoBuf.Reflect.T
              */
-            var Field = function(message, rule, type, name, id, options) {
-                T.call(this, message, name);
+            var Field = function(builder, message, rule, type, name, id, options, oneof) {
+                T.call(this, builder, message, name);
 
                 /**
                  * @override
@@ -1581,6 +1648,13 @@
                  */
                 this.defaultValue = null;
 
+                /**
+                 * Enclosing OneOf.
+                 * @type {?ProtoBuf.Reflect.Message.OneOf}
+                 * @expose
+                 */
+                this.oneof = oneof || null;
+
                 /**
                  * Original field name.
                  * @type {string}
@@ -1589,22 +1663,34 @@
                 this.originalName = this.name; // Used to revert camelcase transformation on naming collisions
 
                 // Convert field names to camel case notation if the override is set
-                if (ProtoBuf.convertFieldsToCamelCase && !(this instanceof Message.ExtensionField)) {
-                    this.name = this.name.replace(/_([a-zA-Z])/g, function($0, $1) {
-                        return $1.toUpperCase();
-                    });
-                }
+                if (this.builder.options['convertFieldsToCamelCase'] && !(this instanceof Message.ExtensionField))
+                    this.name = Field._toCamelCase(this.name);
             };
 
-            // Extends T
-            Field.prototype = Object.create(T.prototype);
+            /**
+             * Converts a field name to camel case.
+             * @param {string} name Likely underscore notated name
+             * @returns {string} Camel case notated name
+             * @private
+             */
+            Field._toCamelCase = function(name) {
+                return name.replace(/_([a-zA-Z])/g, function($0, $1) {
+                    return $1.toUpperCase();
+                });
+            };
+
+            /**
+             * @alias ProtoBuf.Reflect.Message.Field.prototype
+             * @inner
+             */
+            var FieldPrototype = Field.prototype = Object.create(T.prototype);
 
             /**
              * Builds the field.
              * @override
              * @expose
              */
-            Field.prototype.build = function() {
+            FieldPrototype.build = function() {
                 this.defaultValue = typeof this.options['default'] !== 'undefined'
                     ? this.verifyValue(this.options['default']) : null;
             };
@@ -1637,7 +1723,7 @@
              * @throws {Error} If the value cannot be set for this field
              * @expose
              */
-            Field.prototype.verifyValue = function(value, skipRepeated) {
+            FieldPrototype.verifyValue = function(value, skipRepeated) {
                 skipRepeated = skipRepeated || false;
                 var fail = function(val, msg) {
                     throw Error("Illegal value for "+this.toString(true)+" of type "+this.type.name+": "+val+" ("+msg+")");
@@ -1725,20 +1811,18 @@
 
                     // Length-delimited bytes
                     case ProtoBuf.TYPES["bytes"]:
-                        return value && value instanceof ByteBuffer
-                            ? value
-                            : ByteBuffer.wrap(value);
+                        if (ByteBuffer.isByteBuffer(value))
+                            return value;
+                        return ByteBuffer.wrap(value, "base64");
 
                     // Constant enum value
                     case ProtoBuf.TYPES["enum"]: {
                         var values = this.resolvedType.getChildren(Enum.Value);
-                        for (i=0; i<values.length; i++) {
-                            if (values[i].name == value) {
+                        for (i=0; i<values.length; i++)
+                            if (values[i].name == value)
                                 return values[i].id;
-                            } else if (values[i].id == value) {
+                            else if (values[i].id == value)
                                 return values[i].id;
-                            }
-                        }
                         fail(value, "not a valid enum value");
                     }
                     // Embedded message
@@ -1773,7 +1857,7 @@
              * @throws {Error} If the field cannot be encoded
              * @expose
              */
-            Field.prototype.encode = function(value, buffer) {
+            FieldPrototype.encode = function(value, buffer) {
                 if (this.type === null || typeof this.type !== 'object')
                     throw Error("[INTERNAL] Unresolved type in "+this.toString(true)+": "+this.type);
                 if (value === null || (this.repeated && value.length == 0))
@@ -1825,7 +1909,7 @@
              * @throws {Error} If the value cannot be encoded
              * @expose
              */
-            Field.prototype.encodeValue = function(value, buffer) {
+            FieldPrototype.encodeValue = function(value, buffer) {
                 if (value === null) return buffer; // Nothing to encode
                 // Tag has already been written
 
@@ -1946,7 +2030,7 @@
              * @returns {number} Byte length
              * @expose
              */
-            Field.prototype.calculate = function(value) {
+            FieldPrototype.calculate = function(value) {
                 value = this.verifyValue(value); // May throw
                 if (this.type === null || typeof this.type !== 'object')
                     throw Error("[INTERNAL] Unresolved type in "+this.toString(true)+": "+this.type);
@@ -1985,7 +2069,7 @@
              * @throws {Error} If the value cannot be calculated
              * @expose
              */
-            Field.prototype.calculateValue = function(value) {
+            FieldPrototype.calculateValue = function(value) {
                 if (value === null) return 0; // Nothing to encode
                 // Tag has already been written
                 var n;
@@ -2041,7 +2125,7 @@
              * @throws {Error} If the field cannot be decoded
              * @expose
              */
-            Field.prototype.decode = function(wireType, buffer, skipRepeated) {
+            FieldPrototype.decode = function(wireType, buffer, skipRepeated) {
                 var value, nBytes;
                 if (wireType != this.type.wireType && (skipRepeated || (wireType != ProtoBuf.WIRE_TYPES.LDELIM || !this.repeated)))
                     throw Error("Illegal wire type for field "+this.toString(true)+": "+wireType+" ("+this.type.wireType+" expected)");
@@ -2141,7 +2225,7 @@
 
                 // We should never end here
                 throw Error("[INTERNAL] Illegal wire type for "+this.toString(true)+": "+wireType);
-            }
+            };
 
             /**
              * @alias ProtoBuf.Reflect.Message.Field
@@ -2152,7 +2236,8 @@
             /**
              * Constructs a new Message ExtensionField.
              * @exports ProtoBuf.Reflect.Message.ExtensionField
-             * @param {ProtoBuf.Reflect.Message} message Message reference
+             * @param {!ProtoBuf.Builder} builder Builder reference
+             * @param {!ProtoBuf.Reflect.Message} message Message reference
              * @param {string} rule Rule, one of requried, optional, repeated
              * @param {string} type Data type, e.g. int32
              * @param {string} name Field name
@@ -2161,8 +2246,8 @@
              * @constructor
              * @extends ProtoBuf.Reflect.Message.Field
              */
-            var ExtensionField = function(message, rule, type, name, id, options) {
-                Field.call(this, message, rule, type, name, id, options);
+            var ExtensionField = function(builder, message, rule, type, name, id, options) {
+                Field.call(this, builder, message, rule, type, name, id, options);
 
                 /**
                  * Extension reference.
@@ -2181,17 +2266,44 @@
              */
             Reflect.Message.ExtensionField = ExtensionField;
 
+            /**
+             * Constructs a new Message OneOf.
+             * @exports ProtoBuf.Reflect.Message.OneOf
+             * @param {!ProtoBuf.Builder} builder Builder reference
+             * @param {!ProtoBuf.Reflect.Message} message Message reference
+             * @param {string} name OneOf name
+             * @constructor
+             * @extends ProtoBuf.Reflect.T
+             */
+            var OneOf = function(builder, message, name) {
+                T.call(this, builder, message, name);
+
+                /**
+                 * Enclosed fields.
+                 * @type {!Array.<!ProtoBuf.Reflect.Message.Field>}
+                 * @expose
+                 */
+                this.fields = [];
+            };
+
+            /**
+             * @alias ProtoBuf.Reflect.Message.OneOf
+             * @expose
+             */
+            Reflect.Message.OneOf = OneOf;
+
             /**
              * Constructs a new Enum.
              * @exports ProtoBuf.Reflect.Enum
+             * @param {!ProtoBuf.Builder} builder Builder reference
              * @param {!ProtoBuf.Reflect.T} parent Parent Reflect object
              * @param {string} name Enum name
              * @param {Object.<string,*>=} options Enum options
              * @constructor
              * @extends ProtoBuf.Reflect.Namespace
              */
-            var Enum = function(parent, name, options) {
-                Namespace.call(this, parent, name, options);
+            var Enum = function(builder, parent, name, options) {
+                Namespace.call(this, builder, parent, name, options);
 
                 /**
                  * @override
@@ -2206,15 +2318,18 @@
                 this.object = null;
             };
 
-            // Extends Namespace
-            Enum.prototype = Object.create(Namespace.prototype);
+            /**
+             * @alias ProtoBuf.Reflect.Enum.prototype
+             * @inner
+             */
+            var EnumPrototype = Enum.prototype = Object.create(Namespace.prototype);
 
             /**
              * Builds this enum and returns the runtime counterpart.
              * @return {Object<string,*>}
              * @expose
              */
-            Enum.prototype.build = function() {
+            EnumPrototype.build = function() {
                 var enm = {},
                     values = this.getChildren(Enum.Value);
                 for (var i=0, k=values.length; i<k; ++i)
@@ -2233,14 +2348,15 @@
             /**
              * Constructs a new Enum Value.
              * @exports ProtoBuf.Reflect.Enum.Value
+             * @param {!ProtoBuf.Builder} builder Builder reference
              * @param {!ProtoBuf.Reflect.Enum} enm Enum reference
              * @param {string} name Field name
              * @param {number} id Unique field id
              * @constructor
              * @extends ProtoBuf.Reflect.T
              */
-            var Value = function(enm, name, id) {
-                T.call(this, enm, name);
+            var Value = function(builder, enm, name, id) {
+                T.call(this, builder, enm, name);
 
                 /**
                  * @override
@@ -2268,12 +2384,13 @@
              * An extension (field).
              * @exports ProtoBuf.Reflect.Extension
              * @constructor
-             * @param {ProtoBuf.Reflect.T} parent Parent object
+             * @param {!ProtoBuf.Builder} builder Builder reference
+             * @param {!ProtoBuf.Reflect.T} parent Parent object
              * @param {string} name Object name
              * @param {!ProtoBuf.Reflect.Message.Field} field Extension field
              */
-            var Extension = function(parent, name, field) {
-                T.call(this, parent, name);
+            var Extension = function(builder, parent, name, field) {
+                T.call(this, builder, parent, name);
 
                 /**
                  * Extended message field.
@@ -2295,14 +2412,15 @@
             /**
              * Constructs a new Service.
              * @exports ProtoBuf.Reflect.Service
+             * @param {!ProtoBuf.Builder} builder Builder reference
              * @param {!ProtoBuf.Reflect.Namespace} root Root
              * @param {string} name Service name
              * @param {Object.<string,*>=} options Options
              * @constructor
              * @extends ProtoBuf.Reflect.Namespace
              */
-            var Service = function(root, name, options) {
-                Namespace.call(this, root, name, options);
+            var Service = function(builder, root, name, options) {
+                Namespace.call(this, builder, root, name, options);
 
                 /**
                  * @override
@@ -2316,8 +2434,11 @@
                 this.clazz = null;
             };
 
-            // Extends Namespace
-            Service.prototype = Object.create(Namespace.prototype);
+            /**
+             * @alias ProtoBuf.Reflect.Service.prototype
+             * @inner
+             */
+            var ServicePrototype = Service.prototype = Object.create(Namespace.prototype);
 
             /**
              * Builds the service and returns the runtime counterpart, which is a fully functional class.
@@ -2327,7 +2448,7 @@
              * @throws {Error} If the message cannot be built
              * @expose
              */
-            Service.prototype.build = function(rebuild) {
+            ServicePrototype.build = function(rebuild) {
                 if (this.clazz && !rebuild)
                     return this.clazz;
 
@@ -2359,12 +2480,15 @@
                         };
                     };
 
-                    // Extends ProtoBuf.Builder.Service
-                    Service.prototype = Object.create(ProtoBuf.Builder.Service.prototype);
+                    /**
+                     * @alias ProtoBuf.Builder.Service.prototype
+                     * @inner
+                     */
+                    var ServicePrototype = Service.prototype = Object.create(ProtoBuf.Builder.Service.prototype);
 
                     if (Object.defineProperty)
                         Object.defineProperty(Service, "$options", { "value": T.buildOpt() }),
-                        Object.defineProperty(Service.prototype, "$options", { "value": Service["$options"] });
+                        Object.defineProperty(ServicePrototype, "$options", { "value": Service["$options"] });
 
                     /**
                      * Asynchronously performs an RPC call using the given RPC implementation.
@@ -2392,7 +2516,7 @@
                         (function(method) {
 
                             // service#Method(message, callback)
-                            Service.prototype[method.name] = function(req, callback) {
+                            ServicePrototype[method.name] = function(req, callback) {
                                 try {
                                     if (!req || !(req instanceof method.resolvedRequestType.clazz)) {
                                         setTimeout(callback.bind(this, Error("Illegal request type provided to service method "+T.name+"#"+method.name)), 0);
@@ -2422,7 +2546,7 @@
 
                             if (Object.defineProperty)
                                 Object.defineProperty(Service[method.name], "$options", { "value": method.buildOpt() }),
-                                Object.defineProperty(Service.prototype[method.name], "$options", { "value": Service[method.name]["$options"] });
+                                Object.defineProperty(ServicePrototype[method.name], "$options", { "value": Service[method.name]["$options"] });
                         })(rpc[i]);
                     }
 
@@ -2440,14 +2564,15 @@
             /**
              * Abstract service method.
              * @exports ProtoBuf.Reflect.Service.Method
+             * @param {!ProtoBuf.Builder} builder Builder reference
              * @param {!ProtoBuf.Reflect.Service} svc Service
              * @param {string} name Method name
              * @param {Object.<string,*>=} options Options
              * @constructor
              * @extends ProtoBuf.Reflect.T
              */
-            var Method = function(svc, name, options) {
-                T.call(this, svc, name);
+            var Method = function(builder, svc, name, options) {
+                T.call(this, builder, svc, name);
 
                 /**
                  * @override
@@ -2462,8 +2587,11 @@
                 this.options = options || {};
             };
 
-            // Extends T
-            Method.prototype = Object.create(T.prototype);
+            /**
+             * @alias ProtoBuf.Reflect.Service.Method.prototype
+             * @inner
+             */
+            var MethodPrototype = Method.prototype = Object.create(T.prototype);
 
             /**
              * Builds the method's '$options' property.
@@ -2471,7 +2599,7 @@
              * @function
              * @return {Object.<string,*>}
              */
-            Method.prototype.buildOpt = Namespace.prototype.buildOpt;
+            MethodPrototype.buildOpt = NamespacePrototype.buildOpt;
 
             /**
              * @alias ProtoBuf.Reflect.Service.Method
@@ -2482,6 +2610,7 @@
             /**
              * RPC service method.
              * @exports ProtoBuf.Reflect.Service.RPCMethod
+             * @param {!ProtoBuf.Builder} builder Builder reference
              * @param {!ProtoBuf.Reflect.Service} svc Service
              * @param {string} name Method name
              * @param {string} request Request message name
@@ -2490,8 +2619,8 @@
              * @constructor
              * @extends ProtoBuf.Reflect.Service.Method
              */
-            var RPCMethod = function(svc, name, request, response, options) {
-                Method.call(this, svc, name, options);
+            var RPCMethod = function(builder, svc, name, request, response, options) {
+                Method.call(this, builder, svc, name, options);
 
                 /**
                  * @override
@@ -2537,6 +2666,7 @@
             Reflect.Service.RPCMethod = RPCMethod;
 
             return Reflect;
+
         })(ProtoBuf);
 
         /**
@@ -2550,16 +2680,17 @@
              * Constructs a new Builder.
              * @exports ProtoBuf.Builder
              * @class Provides the functionality to build protocol messages.
+             * @param {Object.<string,*>=} options Options
              * @constructor
              */
-            var Builder = function() {
+            var Builder = function(options) {
 
                 /**
                  * Namespace.
                  * @type {ProtoBuf.Reflect.Namespace}
                  * @expose
                  */
-                this.ns = new Reflect.Namespace(null, ""); // Global namespace
+                this.ns = new Reflect.Namespace(this, null, ""); // Global namespace
 
                 /**
                  * Namespace pointer.
@@ -2595,13 +2726,26 @@
                  * @expose
                  */
                 this.importRoot = null;
+
+                /**
+                 * Options.
+                 * @type {!Object.<string, *>}
+                 * @expose
+                 */
+                this.options = options || {};
             };
 
+            /**
+             * @alias ProtoBuf.Builder.prototype
+             * @inner
+             */
+            var BuilderPrototype = Builder.prototype;
+
             /**
              * Resets the pointer to the root namespace.
              * @expose
              */
-            Builder.prototype.reset = function() {
+            BuilderPrototype.reset = function() {
                 this.ptr = this.ns;
             };
 
@@ -2613,7 +2757,7 @@
              * @throws {Error} If the package name is invalid
              * @expose
              */
-            Builder.prototype.define = function(pkg, options) {
+            BuilderPrototype.define = function(pkg, options) {
                 if (typeof pkg !== 'string' || !Lang.TYPEREF.test(pkg))
                     throw Error("Illegal package: "+pkg);
                 var part = pkg.split("."), i;
@@ -2622,7 +2766,7 @@
                         throw Error("Illegal package: "+part[i]);
                 for (i=0; i<part.length; i++) {
                     if (this.ptr.getChild(part[i]) === null) // Keep existing namespace
-                        this.ptr.addChild(new Reflect.Namespace(this.ptr, part[i], options));
+                        this.ptr.addChild(new Reflect.Namespace(this, this.ptr, part[i], options));
                     this.ptr = this.ptr.getChild(part[i]);
                 }
                 return this;
@@ -2736,7 +2880,7 @@
              * @throws {Error} If a message definition is invalid
              * @expose
              */
-            Builder.prototype.create = function(defs) {
+            BuilderPrototype.create = function(defs) {
                 if (!defs)
                     return this; // Nothing to create
                 if (!ProtoBuf.Util.isArray(defs))
@@ -2745,35 +2889,51 @@
                     return this;
 
                 // It's quite hard to keep track of scopes and memory here, so let's do this iteratively.
-                var stack = [], def, obj, subObj, i, j;
+                var stack = [];
                 stack.push(defs); // One level [a, b, c]
                 while (stack.length > 0) {
                     defs = stack.pop();
                     if (ProtoBuf.Util.isArray(defs)) { // Stack always contains entire namespaces
                         while (defs.length > 0) {
-                            def = defs.shift(); // Namespace always contains an array of messages, enums and services
+                            var def = defs.shift(); // Namespace always contains an array of messages, enums and services
                             if (Builder.isValidMessage(def)) {
-                                obj = new Reflect.Message(this.ptr, def["name"], def["options"], def["isGroup"]);
+                                var obj = new Reflect.Message(this, this.ptr, def["name"], def["options"], def["isGroup"]);
+                                // Create OneOfs
+                                var oneofs = {};
+                                if (def["oneofs"]) {
+                                    var keys = Object.keys(def["oneofs"]);
+                                    for (var i=0, k=keys.length; i<k; ++i)
+                                        obj.addChild(oneofs[keys[i]] = new Reflect.Message.OneOf(this, obj, keys[i]));
+                                }
                                 // Create fields
                                 if (def["fields"] && def["fields"].length > 0) {
-                                    for (i=0; i<def["fields"].length; i++) { // i=Fields
-                                        if (obj.getChild(def['fields'][i]['id']) !== null)
-                                            throw Error("Duplicate field id in message "+obj.name+": "+def['fields'][i]['id']);
-                                        if (def["fields"][i]["options"]) {
-                                            subObj = Object.keys(def["fields"][i]["options"]);
-                                            for (j=0; j<subObj.length; j++) { // j=Option names
-                                                if (typeof subObj[j] !== 'string')
-                                                    throw Error("Illegal field option name in message "+obj.name+"#"+def["fields"][i]["name"]+": "+subObj[j]);
-                                                if (typeof def["fields"][i]["options"][subObj[j]] !== 'string' && typeof def["fields"][i]["options"][subObj[j]] !== 'number' && typeof def["fields"][i]["options"][subObj[j]] !== 'boolean')
-                                                    throw Error("Illegal field option value in message "+obj.name+"#"+def["fields"][i]["name"]+"#"+subObj[j]+": "+def["fields"][i]["options"][subObj[j]]);
+                                    for (i=0, k=def["fields"].length; i<k; ++i) { // i:k=Fields
+                                        var fld = def['fields'][i];
+                                        if (obj.getChild(fld['id']) !== null)
+                                            throw Error("Duplicate field id in message "+obj.name+": "+fld['id']);
+                                        if (fld["options"]) {
+                                            var opts = Object.keys(fld["options"]);
+                                            for (var j= 0,l=opts.length; j<l; ++j) { // j:l=Option names
+                                                if (typeof opts[j] !== 'string')
+                                                    throw Error("Illegal field option name in message "+obj.name+"#"+fld["name"]+": "+opts[j]);
+                                                if (typeof fld["options"][opts[j]] !== 'string' && typeof fld["options"][opts[j]] !== 'number' && typeof fld["options"][opts[j]] !== 'boolean')
+                                                    throw Error("Illegal field option value in message "+obj.name+"#"+fld["name"]+"#"+opts[j]+": "+fld["options"][opts[j]]);
                                             }
-                                            subObj = null;
                                         }
-                                        obj.addChild(new Reflect.Message.Field(obj, def["fields"][i]["rule"], def["fields"][i]["type"], def["fields"][i]["name"], def["fields"][i]["id"], def["fields"][i]["options"]));
+                                        var oneof = null;
+                                        if (typeof fld["oneof"] === 'string') {
+                                            oneof = oneofs[fld["oneof"]];
+                                            if (typeof oneof === 'undefined')
+                                                throw Error("Illegal oneof in message "+obj.name+"#"+fld["name"]+": "+fld["oneof"]);
+                                        }
+                                        fld = new Reflect.Message.Field(this, obj, fld["rule"], fld["type"], fld["name"], fld["id"], fld["options"], oneof);
+                                        if (oneof)
+                                            oneof.fields.push(fld);
+                                        obj.addChild(fld);
                                     }
                                 }
                                 // Push enums and messages to stack
-                                subObj = [];
+                                var subObj = [];
                                 if (typeof def["enums"] !== 'undefined' && def['enums'].length > 0)
                                     for (i=0; i<def["enums"].length; i++)
                                         subObj.push(def["enums"][i]);
@@ -2800,16 +2960,16 @@
                                 subObj = null;
                                 obj = null;
                             } else if (Builder.isValidEnum(def)) {
-                                obj = new Reflect.Enum(this.ptr, def["name"], def["options"]);
+                                obj = new Reflect.Enum(this, this.ptr, def["name"], def["options"]);
                                 for (i=0; i<def["values"].length; i++)
-                                    obj.addChild(new Reflect.Enum.Value(obj, def["values"][i]["name"], def["values"][i]["id"]));
+                                    obj.addChild(new Reflect.Enum.Value(this, obj, def["values"][i]["name"], def["values"][i]["id"]));
                                 this.ptr.addChild(obj);
                                 obj = null;
                             } else if (Builder.isValidService(def)) {
-                                obj = new Reflect.Service(this.ptr, def["name"], def["options"]);
+                                obj = new Reflect.Service(this, this.ptr, def["name"], def["options"]);
                                 for (i in def["rpc"])
                                     if (def["rpc"].hasOwnProperty(i))
-                                        obj.addChild(new Reflect.Service.RPCMethod(obj, i, def["rpc"][i]["request"], def["rpc"][i]["response"], def["rpc"][i]["options"]));
+                                        obj.addChild(new Reflect.Service.RPCMethod(this, obj, i, def["rpc"][i]["request"], def["rpc"][i]["response"], def["rpc"][i]["options"]));
                                 this.ptr.addChild(obj);
                                 obj = null;
                             } else if (Builder.isValidExtend(def)) {
@@ -2820,10 +2980,16 @@
                                             throw Error("Duplicate extended field id in message "+obj.name+": "+def['fields'][i]['id']);
                                         if (def['fields'][i]['id'] < obj.extensions[0] || def['fields'][i]['id'] > obj.extensions[1])
                                             throw Error("Illegal extended field id in message "+obj.name+": "+def['fields'][i]['id']+" ("+obj.extensions.join(' to ')+" expected)");
+                                        // Convert extension field names to camel case notation if the override is set
+                                        var name = def["fields"][i]["name"];
+                                        if (this.options['convertFieldsToCamelCase'])
+                                            name = Reflect.Message.Field._toCamelCase(def["fields"][i]["name"]);
                                         // see #161: Extensions use their fully qualified name as their runtime key and...
-                                        var fld = new Reflect.Message.ExtensionField(obj, def["fields"][i]["rule"], def["fields"][i]["type"], this.ptr.fqn()+'.'+def["fields"][i]["name"], def["fields"][i]["id"], def["fields"][i]["options"]);
-                                        // ...are added on top of the current namespace as an extension which is used for resolving their type later on
-                                        var ext = new Reflect.Extension(this.ptr, def["fields"][i]["name"], fld);
+                                        fld = new Reflect.Message.ExtensionField(this, obj, def["fields"][i]["rule"], def["fields"][i]["type"], this.ptr.fqn()+'.'+name, def["fields"][i]["id"], def["fields"][i]["options"]);
+                                        // ...are added on top of the current namespace as an extension which is used for
+                                        // resolving their type later on (the extension always keeps the original name to
+                                        // prevent naming collisions)
+                                        var ext = new Reflect.Extension(this, this.ptr, def["fields"][i]["name"], fld);
                                         fld.extension = ext;
                                         this.ptr.addChild(ext);
                                         obj.addChild(fld);
@@ -2853,7 +3019,7 @@
              * @throws {Error} If the definition or file cannot be imported
              * @expose
              */
-            Builder.prototype["import"] = function(json, filename) {
+            BuilderPrototype["import"] = function(json, filename) {
                 if (typeof filename === 'string') {
                     if (ProtoBuf.Util.IS_NODE)
                         filename = require("path")['resolve'](filename);
@@ -2987,7 +3153,7 @@
              * @throws {Error} If a type cannot be resolved
              * @expose
              */
-            Builder.prototype.resolveAll = function() {
+            BuilderPrototype.resolveAll = function() {
                 // Resolve all reflected objects
                 var res;
                 if (this.ptr == null || typeof this.ptr.type === 'object')
@@ -3030,9 +3196,7 @@
                         // Should not happen as nothing else is implemented
                         throw Error("Illegal service type in "+this.ptr.toString(true));
                     }
-                } else if (this.ptr instanceof ProtoBuf.Reflect.Extension) {
-                    // There are no runtime counterparts to extensions
-                } else
+                } else if (!(this.ptr instanceof ProtoBuf.Reflect.Message.OneOf) && !(this.ptr instanceof ProtoBuf.Reflect.Extension))
                     throw Error("Illegal object in namespace: "+typeof(this.ptr)+":"+this.ptr);
                 this.reset();
             };
@@ -3045,7 +3209,7 @@
              * @throws {Error} If a type could not be resolved
              * @expose
              */
-            Builder.prototype.build = function(path) {
+            BuilderPrototype.build = function(path) {
                 this.reset();
                 if (!this.resolved)
                     this.resolveAll(),
@@ -3074,7 +3238,7 @@
              * @param {string=} path Specifies what to return. If omitted, the entire namespace wiil be returned.
              * @return {ProtoBuf.Reflect.T} Reflection descriptor or `null` if not found
              */
-            Builder.prototype.lookup = function(path) {
+            BuilderPrototype.lookup = function(path) {
                 return path ? this.ns.resolve(path) : this.ns;
             };
 
@@ -3083,7 +3247,7 @@
              * @return {string} String representation as of "Builder"
              * @expose
              */
-            Builder.prototype.toString = function() {
+            BuilderPrototype.toString = function() {
                 return "Builder";
             };
 
@@ -3098,18 +3262,18 @@
 
 
         /**
-         * Constructs a new Builder with the specified package defined.
-         * @param {string=} pkg Package name as fully qualified name, e.g. "My.Game". If no package is specified, the
-         * builder will only contain a global namespace.
-         * @param {Object.<string,*>=} options Top level options
-         * @return {ProtoBuf.Builder} New Builder
+         * Constructs a new empty Builder.
+         * @param {Object.<string,*>=} options Builder options, defaults to global options set on ProtoBuf
+         * @return {!ProtoBuf.Builder} Builder
          * @expose
          */
-        ProtoBuf.newBuilder = function(pkg, options) {
-            var builder = new ProtoBuf.Builder();
-            if (typeof pkg !== 'undefined' && pkg !== null)
-                builder.define(pkg, options);
-            return builder;
+        ProtoBuf.newBuilder = function(options) {
+            options = options || {};
+            if (typeof options['convertFieldsToCamelCase'] === 'undefined')
+                options['convertFieldsToCamelCase'] = ProtoBuf.convertFieldsToCamelCase;
+            if (typeof options['populateAccessors'] === 'undefined')
+                options['populateAccessors'] = ProtoBuf.populateAccessors;
+            return new ProtoBuf.Builder(options);
         };
 
         /**
@@ -3131,7 +3295,6 @@
                 json = JSON.parse(json);
             builder["import"](json, filename);
             builder.resolveAll();
-            builder.build();
             return builder;
         };
 
@@ -3172,8 +3335,8 @@
         return ProtoBuf;
     }
 
-    /* CommonJS */ if (typeof module !== 'undefined' && module["exports"])
-        module["exports"] = init(require("bytebuffer"));
+    /* CommonJS */ if (typeof require === 'function' && typeof module === 'object' && module && typeof exports === 'object' && exports)
+        module['exports'] = init(require("bytebuffer"));
     /* AMD */ else if (typeof define === 'function' && define["amd"])
         define(["ByteBuffer"], init);
     /* Global */ else