protobufjs 8.4.2 → 8.6.0

package/ext/textformat.d.ts

@@ -10,10 +10,10 @@ declare module ".." {
     }
 
     interface Type {
-        /** Parses this type from protobuf text format. */
+        /** Installed by `textformat.install()`. Parses this type from protobuf text format. */
         fromText(text: string): $protobuf.Message<{}>;
 
-        /** Formats a message of this type as protobuf text format. */
+        /** Installed by `textformat.install()`. Formats a message of this type as protobuf text format. */
         toText(message: ($protobuf.Message<{}>|{ [k: string]: any }), options?: ITextFormatOptions): string;
     }
 }

package/ext/textformat.generated.d.ts

@@ -1,5 +1,7 @@
 // DO NOT EDIT! This is a generated file. Edit the source file instead and regenerate.
 
+import * as $protobuf from "..";
+
 /** Maximum recursion depth for formatting length-delimited unknown fields. */
 export let unknownRecursionLimit: number;
 
@@ -9,3 +11,23 @@ export interface ITextFormatOptions {
     /** Also includes and formats unknown fields. */
     unknowns?: boolean;
 }
+
+/**
+ * Parses a message from protobuf text format using the specified reflected type.
+ * @param type Reflected message type
+ * @param text Text format input
+ * @returns Message instance
+ */
+export function fromText(type: $protobuf.Type, text: string): $protobuf.Message<{}>;
+
+/**
+ * Formats a message as protobuf text format using the specified reflected type.
+ * @param type Reflected message type
+ * @param message Message instance or plain object
+ * @param [options] Text format options
+ * @returns Text format output
+ */
+export function toText(type: $protobuf.Type, message: ($protobuf.Message<{}>|{ [k: string]: any }), options?: ITextFormatOptions): string;
+
+/** Installs reflected {@link Type} convenience methods. */
+export function install(): void;

package/ext/textformat.js

@@ -68,40 +68,61 @@ function parseText(type, text) {
  * @property {boolean} [unknowns=false] Also includes and formats unknown fields.
  */
 
+/**
+ * Parses a message from protobuf text format using the specified reflected type.
+ * @function fromText
+ * @name fromText
+ * @param {$protobuf.Type} type Reflected message type
+ * @param {string} text Text format input
+ * @returns {$protobuf.Message<{}>} Message instance
+ */
+textformat.fromText = function fromText(type, text) {
+    return parseText(type, text);
+};
+
 /**
  * Formats a message as protobuf text format using the specified reflected type.
- * @param {Type} type Reflected message type
- * @param {Message<{}>|Object.<string,*>} message Message instance or plain object
+ * @function toText
+ * @name toText
+ * @param {$protobuf.Type} type Reflected message type
+ * @param {$protobuf.Message<{}>|Object.<string,*>} message Message instance or plain object
  * @param {ITextFormatOptions} [options] Text format options
  * @returns {string} Text format output
- * @private
  */
-function formatText(type, message, options) {
+textformat.toText = function toText(type, message, options) {
     if (!(type instanceof Type))
         throw TypeError("type must be a Type");
     type.root.resolveAll();
     var lines = [];
     writeMessage(type, message, lines, 0, options || {}, 0);
     return lines.join("\n");
-}
-
-/**
- * Parses this type from protobuf text format.
- * @param {string} text Text format input
- * @returns {Message<{}>} Message instance
- */
-Type.prototype.fromText = function fromText(text) {
-    return parseText(this, text);
 };
 
 /**
- * Formats a message of this type as protobuf text format.
- * @param {Message<{}>|Object.<string,*>} message Message instance or plain object
- * @param {ITextFormatOptions} [options] Text format options
- * @returns {string} Text format output
+ * Installs reflected {@link Type} convenience methods.
+ * @function install
+ * @name install
+ * @returns {undefined}
  */
-Type.prototype.toText = function toText(message, options) {
-    return formatText(this, message, options);
+textformat.install = function install() {
+    /**
+     * Parses a message of this type from protobuf text format. Convenience for {@link textformat.fromText}.
+     * @param {string} text Text format input
+     * @returns {Message<{}>} Message instance
+     */
+    Type.prototype.fromText = function fromText(text) {
+        return textformat.fromText(this, text);
+    };
+
+    /**
+     * Formats a message of this type as protobuf text format. Convenience for {@link textformat.toText}.
+     * @param {Message<{}>|Object.<string,*>} message Message instance or plain object
+     * @param {ITextFormatOptions} [options] Text format options
+     * @returns {string} Text format output
+     */
+    Type.prototype.toText = function toText(message, options) {
+        return textformat.toText(this, message, options);
+    };
 };
 
 function Tokenizer(source) {

package/index.d.ts

@@ -313,6 +313,18 @@ export class Field extends FieldBase {
     /** Determines whether this field tracks presence. */
     readonly hasPresence: boolean;
 
+    /**
+     * The field name as declared in the .proto source (snake_case). Populated on resolve,
+     * falling back to `name`. Mirrors `FieldDescriptorProto.name`.
+     */
+    readonly protoName: string;
+
+    /**
+     * The JSON name of this field (lowerCamelCase per protoc's `ToJsonName`, or an
+     * explicit `[json_name]`). Populated on resolve. This is the key used on ProtoJSON output.
+     */
+    readonly jsonName: string;
+
     /**
      * Field decorator (TypeScript).
      * @param fieldId Field id
@@ -388,6 +400,12 @@ export class FieldBase extends ReflectionObject {
     /** Comment for this field. */
     comment: (string|null);
 
+    /** Field name as declared in the .proto source, if different from `name`. */
+    protoName?: string;
+
+    /** JSON name, if different from the derived default. */
+    jsonName?: string;
+
     /**
      * Converts this field to a field descriptor.
      * @param [toJSONOptions] JSON conversion options
@@ -666,13 +684,16 @@ export class Method extends ReflectionObject {
     requestType: string;
 
     /** Whether requests are streamed or not. */
-    requestStream?: boolean;
+    requestStream?: true;
 
     /** Response type. */
     responseType: string;
 
     /** Whether responses are streamed or not. */
-    responseStream?: boolean;
+    responseStream?: true;
+
+    /** gRPC-style method path. */
+    path: string;
 
     /** Resolved request type. */
     resolvedRequestType: (Type|null);
@@ -1204,6 +1225,9 @@ export class Reader {
     /** Read buffer length. */
     len: number;
 
+    /** Whether to discard unknown fields while decoding. */
+    discardUnknown: boolean;
+
     /**
      * Creates a new reader using the specified buffer.
      * @param buffer Buffer to read from
@@ -1326,6 +1350,9 @@ export class Reader {
     /** Recursion limit. */
     static recursionLimit: number;
 
+    /** Whether readers discard unknown fields while decoding. */
+    static discardUnknown: boolean;
+
     /**
      * Skips the next element of the specified wire type.
      * @param wireType Wire type received
@@ -1453,13 +1480,17 @@ export namespace rpc {
      */
     type ServiceMethodCallback<TRes extends Message<TRes>> = (error: (Error|null), response?: TRes) => void;
 
-    /**
-     * A service method part of a {@link rpc.Service} as created by {@link Service.create}.
-     * @param request Request message or plain object
-     * @param [callback] Node-style callback called with the error, if any, and the response message
-     * @returns Promise if `callback` has been omitted, otherwise `undefined`
-     */
-    type ServiceMethod<TReq extends Message<TReq>, TRes extends Message<TRes>> = (request: (TReq|Properties<TReq>), callback?: rpc.ServiceMethodCallback<TRes>) => Promise<Message<TRes>>;
+    /** A service method part of a {@link rpc.Service} as created by {@link Service.create}. */
+    type ServiceMethod<TReq extends Message<TReq>, TRes extends Message<TRes>> = {
+  (request: TReq|Properties<TReq>, callback: rpc.ServiceMethodCallback<TRes>): void;
+  (request: TReq|Properties<TReq>): Promise<TRes>;
+  readonly name: string;
+  readonly path: string;
+  readonly requestType: string;
+  readonly responseType: string;
+  readonly requestStream: true|undefined;
+  readonly responseStream: true|undefined;
+};
 
     /** An RPC service as returned by {@link Service#create}. */
     class Service extends util.EventEmitter {
@@ -2662,9 +2693,17 @@ export namespace util {
      * Converts a string to camel case.
      * @param str String to convert
      * @returns Converted string
+     * @deprecated Use {@link util.jsonName} for protobuf field JSON names.
      */
     function camelCase(str: string): string;
 
+    /**
+     * Converts a proto field name to its protoc-compatible JSON name.
+     * @param str Proto field name
+     * @returns JSON name
+     */
+    function jsonName(str: string): string;
+
     /**
      * Compares reflected fields by id.
      * @param a First field

package/package.json

@@ -1,7 +1,6 @@
 {
   "name": "protobufjs",
-  "version": "8.4.2",
-  "versionScheme": "~",
+  "version": "8.6.0",
   "description": "Protocol Buffers for JavaScript & TypeScript.",
   "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
   "license": "BSD-3-Clause",
@@ -26,7 +25,8 @@
     "bench": "node bench",
     "build": "npm run build:bundle && npm run build:types",
     "build:bundle": "gulp --gulpfile scripts/gulpfile.js",
-    "build:types": "node cli/bin/pbts --main --global protobuf --out index.d.ts src/ && node cli/bin/pbts --main --import \"\\$protobuf=..\" --out ext/descriptor.generated.d.ts ext/descriptor.js && node cli/bin/pbts --main --out ext/textformat.generated.d.ts ext/textformat.js",
+    "build:tests": "node ./scripts/gentests.js",
+    "build:types": "node cli/bin/pbts --main --global protobuf --out index.d.ts src/ && node cli/bin/pbts --main --import \"\\$protobuf=..\" --out ext/descriptor.generated.d.ts ext/descriptor.js && node cli/bin/pbts --main --import \"\\$protobuf=..\" --out ext/textformat.generated.d.ts ext/textformat.js && node cli/bin/pbts --main --import \"\\$protobuf=..\" --out ext/protojson.generated.d.ts ext/protojson.js",
     "coverage": "npm run coverage:test && npm run coverage:report",
     "coverage:test": "nyc --silent tape -r ./lib/tape-adapter tests/*.js tests/node/*.js",
     "coverage:report": "nyc report --reporter=lcov --reporter=text",
@@ -38,12 +38,11 @@
     "lint:types": "tslint \"**/*.d.ts\" -e \"**/node_modules/**\" -t stylish -c config/tslint.json",
     "prepublish": "cd cli && npm install && cd .. && npm run build",
     "prepublishOnly": "cd cli && npm install && cd .. && npm run build",
-    "postinstall": "node scripts/postinstall",
     "prof": "node bench/prof",
     "test": "npm run test:sources && npm run test:types",
     "test:sources": "tape -r ./lib/tape-adapter tests/*.js tests/node/*.js",
     "test:types": "tsc tests/comp_typescript.ts --target es2019 --module commonjs --types node --lib es2019 --esModuleInterop --strictNullChecks --experimentalDecorators --emitDecoratorMetadata && tsc -p tsconfig.test-types.json",
-    "make": "npm run lint:sources && npm run build && npm run lint:types && node ./scripts/gentests.js && npm test"
+    "make": "npm run lint:sources && npm run build && npm run lint:types && npm run build:tests && npm test"
   },
   "dependencies": {
     "long": "^5.3.2"
@@ -73,7 +72,6 @@
     "tape": "^5.0.0",
     "tslint": "^6.0.0",
     "typescript": "^3.7.5",
-    "uglify-js": "^3.7.7",
     "vinyl-buffer": "^1.0.1",
     "vinyl-fs": "^4.0.0",
     "vinyl-source-stream": "^2.0.0"
@@ -87,7 +85,6 @@
     "minimal.js",
     "package-lock.json",
     "tsconfig.json",
-    "scripts/postinstall.js",
     "dist/**",
     "ext/**",
     "google/**",

package/src/converter.js

@@ -42,7 +42,7 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
             } gen
             ("}");
         } else gen
-            ("if(typeof d%s!==\"object\")", prop)
+            ("if(!util.isObject(d%s))", prop)
                 ("throw TypeError(%j)", field.fullName + ": object expected")
             ("m%s=types[%i].fromObject(d%s,q+1)", prop, fieldIndex, prop);
     } else {
@@ -106,9 +106,11 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
 converter.fromObject = function fromObject(mtype) {
     /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
     var fields = mtype.fieldsArray;
-    var gen = util.codegen(["d", "q"], mtype.name + "$fromObject")
+    var gen = util.codegen(["d", "q"])
     ("if(d instanceof C)")
         ("return d")
+    ("if(!util.isObject(d))")
+        ("throw TypeError(%j)", mtype.fullName + ": object expected")
     ("if(q===undefined)q=0")
     ("if(q>util.recursionLimit)")
         ("throw Error(\"max depth exceeded\")");
@@ -125,7 +127,7 @@ converter.fromObject = function fromObject(mtype) {
         // Map fields
         if (field.map) { gen
     ("if(d%s){", prop)
-        ("if(typeof d%s!==\"object\")", prop)
+        ("if(!util.isObject(d%s))", prop)
             ("throw TypeError(%j)", field.fullName + ": object expected")
         ("m%s={}", prop)
         ("for(var ks=Object.keys(d%s),i=0;i<ks.length;++i){", prop);
@@ -238,7 +240,7 @@ converter.toObject = function toObject(mtype) {
     var fields = mtype.fieldsArray.slice().sort(util.compareFieldsById);
     if (!fields.length)
         return util.codegen()("return {}");
-    var gen = util.codegen(["m", "o", "q"], mtype.name + "$toObject")
+    var gen = util.codegen(["m", "o", "q"])
     ("if(!o)")
         ("o={}")
     ("if(q===undefined)q=0")
@@ -327,7 +329,7 @@ converter.toObject = function toObject(mtype) {
             genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[j]")
         ("}");
         } else { gen
-    ("if(m%s!=null&&m.hasOwnProperty(%j)){", prop, field.name); // !== undefined && !== null
+    ("if(m%s!=null&&Object.hasOwnProperty.call(m,%j)){", prop, field.name); // !== undefined && !== null
         genValuePartial_toObject(gen, field, /* sorted */ index, prop);
         if (field.partOf && !field.partOf.isProto3Optional) gen
         ("if(o.oneofs)")

package/src/decoder.js

@@ -26,7 +26,7 @@ function decoder(mtype) {
         if (!pfield.repeated && !pfield.map && !pfield.hasPresence)
             hasImplicitPresenceField = true;
     }
-    var gen = util.codegen(["r", "l", "z", "q", "g"], mtype.name + "$decode")
+    var gen = util.codegen(["r", "l", "z", "q", "g"])
     ("if(!(r instanceof Reader))")
         ("r=Reader.create(r)")
     ("if(q===undefined)q=0")
@@ -186,8 +186,10 @@ function decoder(mtype) {
     // Unknown fields
     gen
         ("r.skipType(%s,q,t)", i ? "u" : "t&7")
-        ("util.makeProp(m,\"$unknowns\",false);")
-        ("(m.$unknowns||(m.$unknowns=[])).push(r.raw(s,r.pos))")
+        ("if(!r.discardUnknown){")
+            ("util.makeProp(m,\"$unknowns\",false);")
+            ("(m.$unknowns||(m.$unknowns=[])).push(r.raw(s,r.pos))")
+        ("}")
     ("}")
     ("if(z!==undefined)")
         ("throw Error(\"missing end group\")");
@@ -196,7 +198,7 @@ function decoder(mtype) {
     for (i = 0; i < mtype._fieldsArray.length; ++i) {
         var rfield = mtype._fieldsArray[i];
         if (rfield.required) gen
-    ("if(!m.hasOwnProperty(%j))", rfield.name)
+    ("if(!Object.hasOwnProperty.call(m,%j))", rfield.name)
         ("throw util.ProtocolError(%j,{instance:m})", missing(rfield));
     }
 

package/src/encoder.js

@@ -27,7 +27,7 @@ function genTypePartial(gen, field, fieldIndex, ref) {
  */
 function encoder(mtype) {
     /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
-    var gen = util.codegen(["m", "w", "q"], mtype.name + "$encode")
+    var gen = util.codegen(["m", "w", "q"])
     ("if(!w)")
         ("w=Writer.create()")
     ("if(q===undefined)q=0")

package/src/field.js

@@ -38,6 +38,12 @@ Field.fromJSON = function fromJSON(name, json) {
     var field = new Field(name, json.id, json.type, json.rule, json.extend, json.options, json.comment);
     if (json.edition)
         field._edition = json.edition;
+    if (json.protoName)
+        field.protoName = json.protoName;
+    if (json.jsonName !== undefined)
+        field.jsonName = json.jsonName;
+    else if (json.options && json.options.json_name !== undefined)
+        field.jsonName = json.options.json_name;
     field._defaultEdition = "proto3";  // For backwards-compatibility.
     return field;
 };
@@ -177,6 +183,18 @@ function Field(name, id, type, rule, extend, options, comment) {
      * @type {string|null}
      */
     this.comment = comment;
+
+    /**
+     * Field name as declared in the .proto source, if different from `name`.
+     * @type {string|undefined}
+     */
+    this.protoName = undefined;
+
+    /**
+     * JSON name, if different from the derived default.
+     * @type {string|undefined}
+     */
+    this.jsonName = undefined;
 }
 
 /**
@@ -246,6 +264,22 @@ Object.defineProperty(Field.prototype, "hasPresence", {
     }
 });
 
+/**
+ * The field name as declared in the .proto source (snake_case). Populated on resolve,
+ * falling back to `name`. Mirrors `FieldDescriptorProto.name`.
+ * @name Field#protoName
+ * @type {string}
+ * @readonly
+ */
+
+/**
+ * The JSON name of this field (lowerCamelCase per protoc's `ToJsonName`, or an
+ * explicit `[json_name]`). Populated on resolve. This is the key used on ProtoJSON output.
+ * @name Field#jsonName
+ * @type {string}
+ * @readonly
+ */
+
 /**
  * @override
  */
@@ -279,13 +313,15 @@ Field.prototype.setOption = function setOption(name, value, ifNotSet) {
 Field.prototype.toJSON = function toJSON(toJSONOptions) {
     var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
     return util.toObject([
-        "edition" , this._editionToJSON(),
-        "rule"    , this.rule !== "optional" && this.rule || undefined,
-        "type"    , this.type,
-        "id"      , this.id,
-        "extend"  , this.extend,
-        "options" , this.options,
-        "comment" , keepComments ? this.comment : undefined
+        "edition"      , this._editionToJSON(),
+        "rule"         , this.rule !== "optional" && this.rule || undefined,
+        "type"         , this.type,
+        "id"           , this.id,
+        "extend"       , this.extend,
+        "protoName"    , this.protoName !== this.name ? this.protoName : undefined,
+        "jsonName"     , this.jsonName !== util.jsonName(this.protoName || this.name) ? this.jsonName : undefined,
+        "options"      , this.options,
+        "comment"      , keepComments ? this.comment : undefined
     ]);
 };
 
@@ -354,6 +390,12 @@ Field.prototype.resolve = function resolve() {
     if (this.parent instanceof Type && this.parent._ctor)
         this.parent._ctor.prototype[this.name] = this.defaultValue;
 
+    // derive the proto/JSON names
+    if (this.protoName === undefined)
+        this.protoName = this.name;
+    if (this.jsonName === undefined)
+        this.jsonName = util.jsonName(this.protoName);
+
     return ReflectionObject.prototype.resolve.call(this);
 };
 

package/src/mapfield.js

@@ -65,7 +65,14 @@ function MapField(name, id, keyType, type, options, comment) {
  * @throws {TypeError} If arguments are invalid
  */
 MapField.fromJSON = function fromJSON(name, json) {
-    return new MapField(name, json.id, json.keyType, json.type, json.options, json.comment);
+    var field = new MapField(name, json.id, json.keyType, json.type, json.options, json.comment);
+    if (json.protoName)
+        field.protoName = json.protoName;
+    if (json.jsonName !== undefined)
+        field.jsonName = json.jsonName;
+    else if (json.options && json.options.json_name !== undefined)
+        field.jsonName = json.options.json_name;
+    return field;
 };
 
 /**
@@ -76,12 +83,14 @@ MapField.fromJSON = function fromJSON(name, json) {
 MapField.prototype.toJSON = function toJSON(toJSONOptions) {
     var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;
     return util.toObject([
-        "keyType" , this.keyType,
-        "type"    , this.type,
-        "id"      , this.id,
-        "extend"  , this.extend,
-        "options" , this.options,
-        "comment" , keepComments ? this.comment : undefined
+        "keyType"      , this.keyType,
+        "type"         , this.type,
+        "id"           , this.id,
+        "extend"       , this.extend,
+        "protoName"    , this.protoName !== this.name ? this.protoName : undefined,
+        "jsonName"     , this.jsonName !== util.jsonName(this.protoName || this.name) ? this.jsonName : undefined,
+        "options"      , this.options,
+        "comment"      , keepComments ? this.comment : undefined
     ]);
 };
 

package/src/method.js

@@ -61,7 +61,7 @@ function Method(name, type, requestType, responseType, requestStream, responseSt
 
     /**
      * Whether requests are streamed or not.
-     * @type {boolean|undefined}
+     * @type {true|undefined}
      */
     this.requestStream = requestStream ? true : undefined; // toJSON
 
@@ -73,10 +73,16 @@ function Method(name, type, requestType, responseType, requestStream, responseSt
 
     /**
      * Whether responses are streamed or not.
-     * @type {boolean|undefined}
+     * @type {true|undefined}
      */
     this.responseStream = responseStream ? true : undefined; // toJSON
 
+    /**
+     * gRPC-style method path.
+     * @type {string}
+     */
+    this.path = "/" + this.name;
+
     /**
      * Resolved request type.
      * @type {Type|null}
@@ -154,6 +160,14 @@ Method.prototype.resolve = function resolve() {
     if (this.resolved)
         return this;
 
+    if (this.parent) {
+        var serviceName = this.parent.fullName;
+        if (serviceName.charAt(0) === ".")
+            serviceName = serviceName.substring(1);
+        this.path = "/" + serviceName + "/" + this.name;
+    } else
+        this.path = "/" + this.name;
+
     this.resolvedRequestType = this.parent.lookupType(this.requestType);
     this.resolvedResponseType = this.parent.lookupType(this.responseType);
 

package/src/namespace.js

@@ -426,14 +426,14 @@ Namespace.prototype.lookup = function lookup(path, filterTypes, parentAlreadyChe
     if (path[0] === "")
         return this.root.lookup(path.slice(1), filterTypes);
 
-    // Early bailout for objects with matching absolute paths
-    var found = this.root._fullyQualifiedObjects && this.root._fullyQualifiedObjects["." + flatPath];
+    // Lookup at this namespace and below
+    var found = this._lookupImpl(path, flatPath);
     if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {
         return found;
     }
 
-    // Do a regular lookup at this namespace and below
-    found = this._lookupImpl(path, flatPath);
+    // Fall back to respective absolute path once relative scope has been checked (non-standard)
+    found = this.root._fullyQualifiedObjects && this.root._fullyQualifiedObjects["." + flatPath];
     if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {
         return found;
     }

package/src/parse.js

@@ -482,10 +482,13 @@ function parse(source, root, options) {
         if (!nameRe.test(name))
             throw illegal(name, "name");
 
+        var protoName = name;
         name = applyCase(name);
         skip("=");
 
         var field = new Field(name, parseId(next()), type, rule === "proto3_optional" ? "optional" : rule, extend);
+        if (protoName !== name)
+            field.protoName = protoName;
 
         ifBlock(field, function parseField_block(token) {
 
@@ -627,7 +630,11 @@ function parse(source, root, options) {
             throw illegal(name, "name");
 
         skip("=");
-        var field = new MapField(applyCase(name), parseId(next()), keyType, valueType);
+        var protoName = name;
+        name = applyCase(name);
+        var field = new MapField(name, parseId(next()), keyType, valueType);
+        if (protoName !== name)
+            field.protoName = protoName;
         ifBlock(field, function parseMapField_block(token) {
 
             /* istanbul ignore else */
@@ -839,11 +846,18 @@ function parse(source, root, options) {
             topLevelOptions[name] = value;
             return;
         }
+        // lift json_name onto Field
+        if (name === "json_name" && parent instanceof Field) {
+            parent.jsonName = value;
+            return;
+        }
         if (parent.setOption)
             parent.setOption(name, value);
     }
 
     function setParsedOption(parent, name, value, propName) {
+        if (name === "json_name" && parent instanceof Field)
+            return; // lifted onto Field#jsonName above
         if (parent.setParsedOption)
             parent.setParsedOption(name, value, propName);
     }

package/src/reader.js

@@ -38,6 +38,12 @@ function Reader(buffer) {
      * @type {number}
      */
     this.len = buffer.length;
+
+    /**
+     * Whether to discard unknown fields while decoding.
+     * @type {boolean}
+     */
+    this.discardUnknown = Reader.discardUnknown;
 }
 
 var create_array = typeof Uint8Array !== "undefined"
@@ -450,6 +456,12 @@ Reader.prototype.skip = function skip(length) {
  */
 Reader.recursionLimit = util.recursionLimit;
 
+/**
+ * Whether readers discard unknown fields while decoding.
+ * @type {boolean}
+ */
+Reader.discardUnknown = false;
+
 /**
  * Skips the next element of the specified wire type.
  * @param {number} wireType Wire type received

package/src/roots.js

@@ -1,5 +1,5 @@
 "use strict";
-module.exports = {};
+module.exports = Object.create(null);
 
 /**
  * Named roots.