protobufjs 8.1.6-experimental → 8.2.0

package/package.json

@@ -1,24 +1,15 @@
 {
   "name": "protobufjs",
-  "version": "8.1.6-experimental",
+  "version": "8.2.0",
   "versionScheme": "~",
-  "description": "Protocol Buffers for JavaScript (& TypeScript).",
+  "description": "Protocol Buffers for JavaScript & TypeScript.",
   "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
   "license": "BSD-3-Clause",
   "repository": "protobufjs/protobuf.js",
   "bugs": "https://github.com/protobufjs/protobuf.js/issues",
-  "homepage": "https://protobufjs.github.io/protobuf.js/",
   "engines": {
     "node": ">=12.0.0"
   },
-  "eslintConfig": {
-    "env": {
-      "es6": true
-    },
-    "parserOptions": {
-      "ecmaVersion": 6
-    }
-  },
   "keywords": [
     "protobuf",
     "protocol-buffers",
@@ -26,74 +17,68 @@
     "typescript"
   ],
   "main": "index.js",
+  "type": "commonjs",
   "types": "index.d.ts",
+  "browser": {
+    "fs": false
+  },
   "scripts": {
     "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/ lib/aspromise/index.js lib/base64/index.js lib/codegen/index.js lib/eventemitter/index.js lib/float/index.js lib/fetch/index.js lib/inquire/index.js lib/path/index.js lib/pool/index.js lib/utf8/index.js",
-    "changelog": "node scripts/changelog -w",
+    "build:types": "node cli/bin/pbts --main --global protobuf --out index.d.ts src/",
     "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",
-    "docs": "jsdoc -c config/jsdoc.json -R README.md --verbose --pedantic",
+    "docs": "npm run docs:build",
+    "docs:build": "jsdoc -c config/jsdoc.json -R README.md --verbose --pedantic",
+    "docs:publish": "npm run docs:build && node scripts/pages",
     "lint": "npm run lint:sources && npm run lint:types",
-    "lint:sources": "eslint \"**/*.js\" -c config/eslint.json",
+    "lint:sources": "eslint \"**/*.js\"",
     "lint:types": "tslint \"**/*.d.ts\" -e \"**/node_modules/**\" -t stylish -c config/tslint.json",
-    "pages": "node scripts/pages",
     "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 --lib es2015 --esModuleInterop --strictNullChecks --experimentalDecorators --emitDecoratorMetadata && tsc tests/data/test.js.ts --lib es2015 --esModuleInterop --noEmit --strictNullChecks && tsc tests/data/*.ts --lib es2015 --esModuleInterop --noEmit --strictNullChecks",
+    "test:types": "tsc tests/comp_typescript.ts --types node --lib es2015 --esModuleInterop --strictNullChecks --experimentalDecorators --emitDecoratorMetadata && tsc tests/comp_descriptor.ts --types node --lib es2015 --esModuleInterop --noEmit --strictNullChecks && tsc tests/comp_textformat.ts --types node --lib es2015 --esModuleInterop --noEmit --strictNullChecks && tsc tests/data/test.js.ts --types node --lib es2015 --esModuleInterop --noEmit --strictNullChecks && tsc tests/data/*.ts --types node --lib es2015 --esModuleInterop --noEmit --strictNullChecks",
     "make": "npm run lint:sources && npm run build && npm run lint:types && node ./scripts/gentests.js && npm test"
   },
   "dependencies": {
-    "@protobufjs/aspromise": "^1.1.2",
-    "@protobufjs/base64": "^1.1.2",
-    "@protobufjs/codegen": "^2.0.4",
-    "@protobufjs/eventemitter": "^1.1.0",
-    "@protobufjs/fetch": "^1.1.0",
-    "@protobufjs/float": "^1.0.2",
-    "@protobufjs/inquire": "^1.1.0",
-    "@protobufjs/path": "^1.1.2",
-    "@protobufjs/pool": "^1.1.0",
-    "@protobufjs/utf8": "^1.1.0",
     "@types/node": ">=13.7.0",
     "long": "^5.0.0"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.0",
     "benchmark": "^2.1.4",
     "browserify": "^17.0.0",
     "browserify-wrap": "^1.0.2",
     "bundle-collapser": "^1.3.0",
     "chalk": "^4.0.0",
     "escodegen": "^1.13.0",
-    "eslint": "^8.15.0",
+    "eslint": "^10.0.0",
+    "eslint-plugin-jsdoc": "^62.9.0",
     "espree": "^9.0.0",
     "estraverse": "^5.1.0",
-    "gh-pages": "^4.0.0",
-    "git-raw-commits": "^2.0.3",
-    "git-semver-tags": "^4.0.0",
-    "google-protobuf": "^3.11.3",
-    "gulp": "^4.0.2",
+    "gh-pages": "^6.0.0",
+    "globals": "^17.0.0",
+    "google-protobuf": "^4.0.0",
+    "gulp": "^5.0.0",
     "gulp-header": "^2.0.9",
     "gulp-if": "^3.0.0",
     "gulp-sourcemaps": "^3.0.0",
     "gulp-uglify": "^3.0.2",
-    "jaguarjs-jsdoc": "github:dcodeIO/jaguarjs-jsdoc",
     "jsdoc": "^4.0.0",
-    "minimist": "^1.2.0",
-    "nyc": "^15.0.0",
-    "reflect-metadata": "^0.1.13",
+    "minimist": "^1.2.8",
+    "nyc": "^18.0.0",
+    "reflect-metadata": "^0.2.0",
     "tape": "^5.0.0",
     "tslint": "^6.0.0",
     "typescript": "^3.7.5",
     "uglify-js": "^3.7.7",
     "vinyl-buffer": "^1.0.1",
-    "vinyl-fs": "^3.0.3",
+    "vinyl-fs": "^4.0.0",
     "vinyl-source-stream": "^2.0.0"
   },
   "files": [

package/src/converter.js

@@ -5,8 +5,9 @@
  */
 var converter = exports;
 
-var Enum = require("./enum"),
-    util = require("./util");
+var Enum  = require("./enum"),
+    types = require("./types"),
+    util  = require("./util");
 
 /**
  * Generates a partial value fromObject conveter.
@@ -27,7 +28,7 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
                 // enum unknown values passthrough
                 if (values[keys[i]] === field.typeDefault && !defaultAlreadyEmitted) { gen
                     ("default:")
-                        ("if(typeof(d%s)===\"number\"){m%s=d%s;break}", prop, prop, prop);
+                        ("if(typeof d%s===\"number\"){m%s=d%s;break}", prop, prop, prop);
                     if (!field.repeated) gen // fallback to default value only for
                                              // arrays, to avoid leaving holes.
                         ("break");           // for non-repeated fields, just ignore
@@ -43,7 +44,7 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
         } else gen
             ("if(typeof d%s!==\"object\")", prop)
                 ("throw TypeError(%j)", field.fullName + ": object expected")
-            ("m%s=types[%i].fromObject(d%s)", prop, fieldIndex, prop);
+            ("m%s=types[%i].fromObject(d%s,q+1)", prop, fieldIndex, prop);
     } else {
         var isUnsigned = false;
         switch (field.type) {
@@ -79,7 +80,7 @@ function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
             case "bytes": gen
                 ("if(typeof d%s===\"string\")", prop)
                     ("util.base64.decode(d%s,m%s=util.newBuffer(util.base64.length(d%s)),0)", prop, prop, prop)
-                ("else if(d%s.length >= 0)", prop)
+                ("else if(d%s.length>=0)", prop)
                     ("m%s=d%s", prop, prop);
                 break;
             case "string": gen
@@ -105,16 +106,21 @@ 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"], mtype.name + "$fromObject")
+    var gen = util.codegen(["d", "q"], mtype.name + "$fromObject")
     ("if(d instanceof this.ctor)")
-        ("return d");
+        ("return d")
+    ("if(q===undefined)q=0")
+    ("if(q>util.recursionLimit)")
+        ("throw Error(\"max depth exceeded\")");
     if (!fields.length) return gen
     ("return new this.ctor");
     gen
     ("var m=new this.ctor");
     for (var i = 0; i < fields.length; ++i) {
         var field  = fields[i].resolve(),
-            prop   = util.safeProp(field.name);
+            prop   = util.safeProp(field.name),
+            implicitPresence = !field.hasPresence && !field.repeated && !field.map
+                && (field.resolvedType instanceof Enum || types.basic[field.type] !== undefined);
 
         // Map fields
         if (field.map) { gen
@@ -123,6 +129,9 @@ converter.fromObject = function fromObject(mtype) {
             ("throw TypeError(%j)", field.fullName + ": object expected")
         ("m%s={}", prop)
         ("for(var ks=Object.keys(d%s),i=0;i<ks.length;++i){", prop);
+            gen
+        ("if(ks[i]===\"__proto__\")")
+            ("util.makeProp(m%s,ks[i])", prop);
             genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[ks[i]]")
         ("}")
     ("}");
@@ -132,7 +141,7 @@ converter.fromObject = function fromObject(mtype) {
     ("if(d%s){", prop)
         ("if(!Array.isArray(d%s))", prop)
             ("throw TypeError(%j)", field.fullName + ": array expected")
-        ("m%s=[]", prop)
+        ("m%s=Array(d%s.length)", prop, prop)
         ("for(var i=0;i<d%s.length;++i){", prop);
             genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[i]")
         ("}")
@@ -142,7 +151,23 @@ converter.fromObject = function fromObject(mtype) {
         } else {
             if (!(field.resolvedType instanceof Enum)) gen // no need to test for null/undefined if an enum (uses switch)
     ("if(d%s!=null){", prop); // !== undefined && !== null
+            if (implicitPresence) {
+                if (field.resolvedType instanceof Enum) gen
+    ("if(d%s!==%j&&(typeof d%s!==\"string\"||types[%i].values[d%s]!==%j)){", prop, field.typeDefault, prop, i, prop, field.typeDefault);
+                else if (field.type === "string") gen
+    ("if(typeof d%s!==\"string\"||d%s.length){", prop, prop);
+                else if (field.type === "bytes") gen
+    ("if(d%s.length){", prop);
+                else if (field.type === "bool") gen
+    ("if(d%s){", prop);
+                else if (types.long[field.type] !== undefined) gen
+    ("if(typeof d%s===\"object\"?d%s.low||d%s.high:Number(d%s)!==0){", prop, prop, prop, prop);
+                else gen
+    ("if(Number(d%s)!==0){", prop);
+            }
         genValuePartial_fromObject(gen, field, /* not sorted */ i, prop);
+            if (implicitPresence) gen
+    ("}");
             if (!(field.resolvedType instanceof Enum)) gen
     ("}");
         }
@@ -156,23 +181,26 @@ converter.fromObject = function fromObject(mtype) {
  * @param {Codegen} gen Codegen instance
  * @param {Field} field Reflected field
  * @param {number} fieldIndex Field index
- * @param {string} prop Property reference
+ * @param {string} dstProp Destination property reference
+ * @param {string} [srcProp] Source property reference
  * @returns {Codegen} Codegen instance
  * @ignore
  */
-function genValuePartial_toObject(gen, field, fieldIndex, prop) {
+function genValuePartial_toObject(gen, field, fieldIndex, dstProp, srcProp) {
     /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
+    if (!srcProp)
+        srcProp = dstProp;
     if (field.resolvedType) {
         if (field.resolvedType instanceof Enum) gen
-            ("d%s=o.enums===String?(types[%i].values[m%s]===undefined?m%s:types[%i].values[m%s]):m%s", prop, fieldIndex, prop, prop, fieldIndex, prop, prop);
+            ("d%s=o.enums===String?(types[%i].values[m%s]===undefined?m%s:types[%i].values[m%s]):m%s", dstProp, fieldIndex, srcProp, srcProp, fieldIndex, srcProp, srcProp);
         else gen
-            ("d%s=types[%i].toObject(m%s,o)", prop, fieldIndex, prop);
+            ("d%s=types[%i].toObject(m%s,o)", dstProp, fieldIndex, srcProp);
     } else {
         var isUnsigned = false;
         switch (field.type) {
             case "double":
             case "float": gen
-            ("d%s=o.json&&!isFinite(m%s)?String(m%s):m%s", prop, prop, prop, prop);
+            ("d%s=o.json&&!isFinite(m%s)?String(m%s):m%s", dstProp, srcProp, srcProp, srcProp);
                 break;
             case "uint64":
                 isUnsigned = true;
@@ -181,16 +209,16 @@ function genValuePartial_toObject(gen, field, fieldIndex, prop) {
             case "sint64":
             case "fixed64":
             case "sfixed64": gen
-            ("if(typeof m%s===\"number\")", prop)
-                ("d%s=o.longs===String?String(m%s):m%s", prop, prop, prop)
+            ("if(typeof m%s===\"number\")", srcProp)
+                ("d%s=o.longs===String?String(m%s):m%s", dstProp, srcProp, srcProp)
             ("else") // Long-like
-                ("d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low>>>0,m%s.high>>>0).toNumber(%s):m%s", prop, prop, prop, prop, isUnsigned ? "true": "", prop);
+                ("d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low>>>0,m%s.high>>>0).toNumber(%s):m%s", dstProp, srcProp, srcProp, srcProp, isUnsigned ? "true": "", srcProp);
                 break;
             case "bytes": gen
-            ("d%s=o.bytes===String?util.base64.encode(m%s,0,m%s.length):o.bytes===Array?Array.prototype.slice.call(m%s):m%s", prop, prop, prop, prop, prop);
+            ("d%s=o.bytes===String?util.base64.encode(m%s,0,m%s.length):o.bytes===Array?Array.prototype.slice.call(m%s):m%s", dstProp, srcProp, srcProp, srcProp, srcProp);
                 break;
             default: gen
-            ("d%s=m%s", prop, prop);
+            ("d%s=m%s", dstProp, srcProp);
                 break;
         }
     }
@@ -253,11 +281,11 @@ converter.toObject = function toObject(mtype) {
         ("}else")
             ("d%s=o.longs===String?%j:%i", prop, field.typeDefault.toString(), field.typeDefault.toNumber());
             else if (field.bytes) {
-                var arrayDefault = "[" + Array.prototype.slice.call(field.typeDefault).join(",") + "]";
+                var arrayDefault = Array.prototype.slice.call(field.typeDefault);
                 gen
         ("if(o.bytes===String)d%s=%j", prop, String.fromCharCode.apply(String, field.typeDefault))
         ("else{")
-            ("d%s=%s", prop, arrayDefault)
+            ("d%s=%j", prop, arrayDefault)
             ("if(o.bytes!==Array)d%s=util.newBuffer(d%s)", prop, prop)
         ("}");
             } else gen
@@ -275,13 +303,21 @@ converter.toObject = function toObject(mtype) {
     ("var ks2");
             } gen
     ("if(m%s&&(ks2=Object.keys(m%s)).length){", prop, prop)
-        ("d%s={}", prop)
+        ("d%s={}", prop);
+            var longKey = types.long[field.keyType] !== undefined,
+                srcProp = prop + "[ks2[j]]";
+            gen
         ("for(var j=0;j<ks2.length;++j){");
-            genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[ks2[j]]")
+            if (longKey) gen
+            ("var k2=util.longFromKey(ks2[j],%j).toString()", field.keyType === "uint64" || field.keyType === "fixed64");
+            gen
+        ("if(ks2[j]===\"__proto__\")")
+            ("util.makeProp(d%s,ks2[j])", prop);
+            genValuePartial_toObject(gen, field, /* sorted */ index, longKey ? prop + "[k2]" : srcProp, srcProp)
         ("}");
         } else if (field.repeated) { gen
     ("if(m%s&&m%s.length){", prop, prop)
-        ("d%s=[]", prop)
+        ("d%s=Array(m%s.length)", prop, prop)
         ("for(var j=0;j<m%s.length;++j){", prop);
             genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[j]")
         ("}");

package/src/decoder.js

@@ -16,28 +16,47 @@ function missing(field) {
  */
 function decoder(mtype) {
     /* eslint-disable no-unexpected-multiline */
-    var gen = util.codegen(["r", "l", "e"], mtype.name + "$decode")
+    var hasMapField = false,
+        hasImplicitPresenceField = false,
+        i = 0;
+    for (; i < mtype.fieldsArray.length; ++i) {
+        var pfield = mtype._fieldsArray[i];
+        if (pfield.map)
+            hasMapField = true;
+        if (!pfield.repeated && !pfield.map && !pfield.hasPresence)
+            hasImplicitPresenceField = true;
+    }
+    var gen = util.codegen(["r", "l", "z", "q", "g"], mtype.name + "$decode")
     ("if(!(r instanceof Reader))")
         ("r=Reader.create(r)")
-    ("var c=l===undefined?r.len:r.pos+l,m=new this.ctor" + (mtype.fieldsArray.filter(function(field) { return field.map; }).length ? ",k,value" : ""))
+    ("if(q===undefined)q=0")
+    ("if(q>Reader.recursionLimit)")
+        ("throw Error(\"max depth exceeded\")")
+    ("var c=l===undefined?r.len:r.pos+l,m=g||new this.ctor" + (hasMapField ? ",k,v" : hasImplicitPresenceField ? ",v" : ""))
     ("while(r.pos<c){")
-        ("var t=r.uint32()")
-        ("if(t===e)")
+        ("var s=r.pos")
+        ("var t=r.tag()")
+        ("if(t===z){")
+            ("z=undefined")
             ("break")
-        ("switch(t>>>3){");
-
-    var i = 0;
-    for (; i < /* initializes */ mtype.fieldsArray.length; ++i) {
+        ("}");
+    if (mtype.fieldsArray.length) gen
+        ("var u=t&7")
+        ("switch(t>>>=3){");
+    for (i = 0; i < /* initializes */ mtype.fieldsArray.length; ++i) {
         var field = mtype._fieldsArray[i].resolve(),
             type  = field.resolvedType instanceof Enum ? "int32" : field.type,
-            ref   = "m" + util.safeProp(field.name); gen
-            ("case %i: {", field.id);
+            ref   = "m" + util.safeProp(field.name);
 
         // Map fields
-        if (field.map) { gen
+        if (field.map) {
+            gen
+            ("case %i:{", field.id)
+                ("if(u!==2)")
+                    ("break")
                 ("if(%s===util.emptyObject)", ref)
                     ("%s={}", ref)
-                ("var c2 = r.uint32()+r.pos");
+                ("var c2=r.uint32()+r.pos");
 
             if (types.defaults[field.keyType] !== undefined) gen
                 ("k=%j", types.defaults[field.keyType]);
@@ -45,73 +64,127 @@ function decoder(mtype) {
                 ("k=null");
 
             if (types.defaults[type] !== undefined) gen
-                ("value=%j", types.defaults[type]);
+                ("v=%j", types.defaults[type]);
             else gen
-                ("value=null");
+                ("v=null");
 
             gen
                 ("while(r.pos<c2){")
-                    ("var tag2=r.uint32()")
-                    ("switch(tag2>>>3){")
-                        ("case 1: k=r.%s(); break", field.keyType)
-                        ("case 2:");
+                    ("var t2=r.tag()")
+                    ("u=t2&7")
+                    ("switch(t2>>>=3){")
+                        ("case 1:")
+                            ("if(u!==%i)", types.mapKey[field.keyType])
+                                ("break")
+                            ("k=r.%s()", field.keyType)
+                            ("continue")
+                        ("case 2:")
+                            ("if(u!==%i)", types.basic[type] === undefined ? 2 : types.basic[type])
+                                ("break");
 
             if (types.basic[type] === undefined) gen
-                            ("value=types[%i].decode(r,r.uint32())", i); // can't be groups
+                            ("v=types[%i].decode(r,r.uint32(),undefined,q+1)", i); // can't be groups
             else gen
-                            ("value=r.%s()", type);
+                            ("v=r.%s()", type);
 
             gen
-                            ("break")
-                        ("default:")
-                            ("r.skipType(tag2&7)")
-                            ("break")
+                            ("continue")
                     ("}")
+                    ("r.skipType(u,q,t2)")
                 ("}");
 
+            var val = types.basic[type] === undefined ? "v||new types[" + i + "].ctor" : "v";
             if (types.long[field.keyType] !== undefined) gen
-                ("%s[typeof k===\"object\"?util.longToHash(k):k]=value", ref);
-            else gen
-                ("%s[k]=value", ref);
+                ("%s[typeof k===\"object\"?util.longToHash(k):k]=%s", ref, val);
+            else {
+                if (field.keyType === "string") gen
+                ("if(k===\"__proto__\")")
+                    ("util.makeProp(%s,k)", ref);
+                gen
+                ("%s[k]=%s", ref, val);
+            }
 
         // Repeated fields
         } else if (field.repeated) { gen
-
-                ("if(!(%s&&%s.length))", ref, ref)
-                    ("%s=[]", ref);
+            ("case %i:", field.id)
+            ("{");
 
             // Packable (always check for forward and backward compatiblity)
             if (types.packed[type] !== undefined) gen
-                ("if((t&7)===2){")
+                ("if(u===2){")
+                    ("if(!(%s&&%s.length))", ref, ref)
+                        ("%s=[]", ref)
                     ("var c2=r.uint32()+r.pos")
                     ("while(r.pos<c2)")
                         ("%s.push(r.%s())", ref, type)
-                ("}else");
+                    ("continue")
+                ("}");
 
             // Non-packed
-            if (types.basic[type] === undefined) gen(field.delimited
-                    ? "%s.push(types[%i].decode(r,undefined,((t&~7)|4)))"
-                    : "%s.push(types[%i].decode(r,r.uint32()))", ref, i);
-            else gen
+            gen
+                ("if(u!==%i)", types.basic[type] === undefined ? field.delimited ? 3 : 2 : types.basic[type])
+                    ("break")
+                ("if(!(%s&&%s.length))", ref, ref)
+                    ("%s=[]", ref);
+            if (types.basic[type] === undefined) {
+                if (field.delimited) gen
+                    ("%s.push(types[%i].decode(r,undefined,%i,q+1))", ref, i, field.id * 8 + 4);
+                else gen
+                    ("%s.push(types[%i].decode(r,r.uint32(),undefined,q+1))", ref, i);
+            } else gen
                     ("%s.push(r.%s())", ref, type);
 
         // Non-repeated
-        } else if (types.basic[type] === undefined) gen(field.delimited
-                ? "%s=types[%i].decode(r,undefined,((t&~7)|4))"
-                : "%s=types[%i].decode(r,r.uint32())", ref, i);
-        else gen
+        } else if (types.basic[type] === undefined) {
+            gen
+            ("case %i:{", field.id)
+                ("if(u!==%i)", field.delimited ? 3 : 2)
+                    ("break");
+            if (field.delimited) gen
+                ("%s=types[%i].decode(r,undefined,%i,q+1,%s)", ref, i, field.id * 8 + 4, ref);
+            else gen
+                ("%s=types[%i].decode(r,r.uint32(),undefined,q+1,%s)", ref, i, ref);
+        }
+        else if (field.hasPresence) {
+            gen
+            ("case %i:{", field.id)
+                ("if(u!==%i)", types.basic[type])
+                    ("break")
                 ("%s=r.%s()", ref, type);
+        } else {
+            gen
+            ("case %i:{", field.id)
+                ("if(u!==%i)", types.basic[type])
+                    ("break");
+            if (type === "string" || type === "bytes") gen
+                ("if((v=r.%s()).length)", type);
+            else if (types.long[type] !== undefined) gen
+                ("if(typeof(v=r.%s())===\"object\"?v.low||v.high:v!==0)", type);
+            else if (type === "double" || type === "float") gen
+                ("if((v=r.%s())!==0)", type);
+            else gen
+                ("if(v=r.%s())", type);
+            gen
+                    ("%s=v", ref)
+                ("else")
+                    ("delete %s", ref); // rare/odd case: later default clears earlier non-default
+        }
+        if (field.partOf) gen
+                ("m%s=%j", util.safeProp(field.partOf.name), field.name);
         gen
-                ("break")
+                ("continue")
             ("}");
-        // Unknown fields
-    } gen
-            ("default:")
-                ("r.skipType(t&7)")
-                ("break")
-
-        ("}")
-    ("}");
+    }
+    if (i) gen
+        ("}");
+    // 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(z!==undefined)")
+        ("throw Error(\"missing end group\")");
 
     // Field presence
     for (i = 0; i < mtype._fieldsArray.length; ++i) {

package/src/encoder.js

@@ -47,7 +47,12 @@ function encoder(mtype) {
         if (field.map) {
             gen
     ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)){", ref, field.name) // !== undefined && !== null
-        ("for(var ks=Object.keys(%s),i=0;i<ks.length;++i){", ref)
+        ("for(var ks=Object.keys(%s),i=0;i<ks.length;++i){", ref);
+            if (field.keyType === "bool") gen
+            ("w.uint32(%i).fork().uint32(%i).bool(util.boolFromKey(ks[i]))", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType]);
+            else if (types.long[field.keyType] !== undefined) gen
+            ("w.uint32(%i).fork().uint32(%i).%s(util.longFromKey(ks[i],%j))", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType], field.keyType, field.keyType === "uint64" || field.keyType === "fixed64");
+            else gen
             ("w.uint32(%i).fork().uint32(%i).%s(ks[i])", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType], field.keyType);
             if (wireType === undefined) gen
             ("types[%i].encode(%s[ks[i]],w.uint32(18).fork()).ldelim().ldelim()", index, ref); // can't be groups
@@ -83,7 +88,7 @@ function encoder(mtype) {
 
         // Non-repeated
         } else {
-            if (field.optional) gen
+            if (!field.required) gen
     ("if(%s!=null&&Object.hasOwnProperty.call(m,%j))", ref, field.name); // !== undefined && !== null
 
             if (wireType === undefined)
@@ -95,6 +100,9 @@ function encoder(mtype) {
     }
 
     return gen
+    ("if(m.$unknowns!=null&&Object.hasOwnProperty.call(m,\"$unknowns\"))")
+        ("for(var i=0;i<m.$unknowns.length;++i)")
+            ("w.raw(m.$unknowns[i])")
     ("return w");
     /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
 }

package/src/enum.js

@@ -74,7 +74,7 @@ function Enum(name, values, options, comment, comments, valuesOptions) {
 
     if (values)
         for (var keys = Object.keys(values), i = 0; i < keys.length; ++i)
-            if (typeof values[keys[i]] === "number") // use forward entries only
+            if (keys[i] !== "__proto__" && typeof values[keys[i]] === "number") // use forward entries only
                 this.valuesById[ this.values[keys[i]] = values[keys[i]] ] = keys[i];
 }
 
@@ -153,6 +153,9 @@ Enum.prototype.add = function add(name, id, comment, options) {
     if (!util.isInteger(id))
         throw TypeError("id must be an integer");
 
+    if (name === "__proto__")
+        return this;
+
     if (this.values[name] !== undefined)
         throw Error("duplicate name '" + name + "' in " + this);
 

package/src/field.js

@@ -352,8 +352,8 @@ Field.prototype.resolve = function resolve() {
         this.defaultValue = this.typeDefault;
 
     // ensure proper value on prototype
-    if (this.parent instanceof Type)
-        this.parent.ctor.prototype[this.name] = this.defaultValue;
+    if (this.parent instanceof Type && this.parent._ctor)
+        this.parent._ctor.prototype[this.name] = this.defaultValue;
 
     return ReflectionObject.prototype.resolve.call(this);
 };
@@ -405,6 +405,7 @@ Field.prototype._resolveFeatures = function _resolveFeatures(edition) {
  * @param {Object} prototype Target prototype
  * @param {string} fieldName Field name
  * @returns {undefined}
+ * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 
 /**
@@ -417,6 +418,7 @@ Field.prototype._resolveFeatures = function _resolveFeatures(edition) {
  * @param {T} [defaultValue] Default value
  * @returns {FieldDecorator} Decorator function
  * @template T extends number | number[] | Long | Long[] | string | string[] | boolean | boolean[] | Uint8Array | Uint8Array[] | Buffer | Buffer[]
+ * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 Field.d = function decorateField(fieldId, fieldType, fieldRule, defaultValue) {
 
@@ -434,6 +436,11 @@ Field.d = function decorateField(fieldId, fieldType, fieldRule, defaultValue) {
     };
 };
 
+// Sets up cyclic dependencies (called in index-light)
+Field._configure = function configure(Type_) {
+    Type = Type_;
+};
+
 /**
  * Field decorator (TypeScript).
  * @name Field.d
@@ -444,10 +451,6 @@ Field.d = function decorateField(fieldId, fieldType, fieldRule, defaultValue) {
  * @returns {FieldDecorator} Decorator function
  * @template T extends Message<T>
  * @variation 2
+ * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 // like Field.d but without a default value
-
-// Sets up cyclic dependencies (called in index-light)
-Field._configure = function configure(Type_) {
-    Type = Type_;
-};