@openclaw/diagnostics-otel 2026.6.8 → 2026.6.9

package/node_modules/protobufjs/package.json

@@ -1,15 +1,24 @@
 {
   "name": "protobufjs",
-  "version": "8.4.1",
+  "version": "7.6.3",
   "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",
@@ -17,65 +26,80 @@
     "typescript"
   ],
   "main": "index.js",
-  "type": "commonjs",
   "types": "index.d.ts",
   "browser": {
     "fs": false
   },
+  "publishConfig": {
+    "tag": "latest-7"
+  },
   "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/ && 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: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",
     "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": "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",
+    "docs": "jsdoc -c config/jsdoc.json -R README.md --verbose --pedantic",
     "lint": "npm run lint:sources && npm run lint:types",
-    "lint:sources": "eslint \"**/*.js\"",
+    "lint:sources": "eslint \"**/*.js\" -c config/eslint.json",
     "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 --target es2019 --module commonjs --types node --lib es2019 --esModuleInterop --strictNullChecks --experimentalDecorators --emitDecoratorMetadata && tsc -p tsconfig.test-types.json",
+    "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",
     "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.5",
+    "@protobufjs/eventemitter": "^1.1.1",
+    "@protobufjs/fetch": "^1.1.1",
+    "@protobufjs/float": "^1.0.2",
+    "@protobufjs/inquire": "^1.1.2",
+    "@protobufjs/path": "^1.1.2",
+    "@protobufjs/pool": "^1.1.0",
+    "@protobufjs/utf8": "^1.1.1",
+    "@types/node": ">=13.7.0",
     "long": "^5.3.2"
   },
   "devDependencies": {
-    "@eslint/js": "^10.0.0",
-    "@types/node": ">=13.7.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": "^10.0.0",
-    "eslint-plugin-jsdoc": "^62.9.0",
+    "eslint": "^8.15.0",
     "espree": "^9.0.0",
     "estraverse": "^5.1.0",
-    "gh-pages": "^6.0.0",
-    "globals": "^17.0.0",
-    "gulp": "^5.0.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",
     "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.8",
-    "nyc": "^18.0.0",
-    "reflect-metadata": "^0.2.0",
+    "minimist": "^1.2.0",
+    "nyc": "^15.0.0",
+    "reflect-metadata": "^0.1.13",
     "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-fs": "^3.0.3",
     "vinyl-source-stream": "^2.0.0"
   },
   "files": [

package/node_modules/protobufjs/src/converter.js

@@ -5,9 +5,8 @@
  */
 var converter = exports;
 
-var Enum  = require("./enum"),
-    types = require("./types"),
-    util  = require("./util");
+var Enum = require("./enum"),
+    util = require("./util");
 
 /**
  * Generates a partial value fromObject conveter.
@@ -28,7 +27,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
@@ -42,9 +41,9 @@ 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);
+            ("m%s=types[%i].fromObject(d%s,n+1)", prop, fieldIndex, prop);
     } else {
         var isUnsigned = false;
         switch (field.type) {
@@ -80,7 +79,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
@@ -106,26 +105,27 @@ 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")
-    ("if(d instanceof C)")
-        ("return d")
-    ("if(q===undefined)q=0")
-    ("if(q>util.recursionLimit)")
-        ("throw Error(\"max depth exceeded\")");
+    var gen = util.codegen(["d", "n"], mtype.name + "$fromObject")
+    ("if(d instanceof this.ctor)")
+        ("return d");
     if (!fields.length) return gen
-    ("return new C");
+    ("return new this.ctor");
+    gen
+    ("if(!util.isObject(d))")
+        ("throw TypeError(%j)", mtype.fullName + ": object expected")
+    ("if(n===undefined)n=0")
+    ("if(n>util.recursionLimit)")
+        ("throw Error(\"maximum nesting depth exceeded\")");
     gen
-    ("var m=new C");
+    ("var m=new this.ctor");
     for (var i = 0; i < fields.length; ++i) {
         var field  = fields[i].resolve(),
-            prop   = util.safeProp(field.name),
-            implicitPresence = !field.hasPresence && !field.repeated && !field.map
-                && (field.resolvedType instanceof Enum || types.basic[field.type] !== undefined);
+            prop   = util.safeProp(field.name);
 
         // 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);
@@ -141,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=Array(d%s.length)", prop, prop)
+        ("m%s=[]", prop)
         ("for(var i=0;i<d%s.length;++i){", prop);
             genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[i]")
         ("}")
@@ -151,23 +151,7 @@ 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
     ("}");
         }
@@ -181,26 +165,23 @@ converter.fromObject = function fromObject(mtype) {
  * @param {Codegen} gen Codegen instance
  * @param {Field} field Reflected field
  * @param {number} fieldIndex Field index
- * @param {string} dstProp Destination property reference
- * @param {string} [srcProp] Source property reference
+ * @param {string} prop Property reference
  * @returns {Codegen} Codegen instance
  * @ignore
  */
-function genValuePartial_toObject(gen, field, fieldIndex, dstProp, srcProp) {
+function genValuePartial_toObject(gen, field, fieldIndex, prop) {
     /* 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", dstProp, fieldIndex, srcProp, srcProp, fieldIndex, srcProp, srcProp);
+            ("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);
         else gen
-            ("d%s=types[%i].toObject(m%s,o,q+1)", dstProp, fieldIndex, srcProp);
+            ("d%s=types[%i].toObject(m%s,o,q+1)", prop, fieldIndex, prop);
     } else {
         var isUnsigned = false;
         switch (field.type) {
             case "double":
             case "float": gen
-            ("d%s=o.json&&!isFinite(m%s)?String(m%s):m%s", dstProp, srcProp, srcProp, srcProp);
+            ("d%s=o.json&&!isFinite(m%s)?String(m%s):m%s", prop, prop, prop, prop);
                 break;
             case "uint64":
             case "fixed64":
@@ -210,17 +191,17 @@ function genValuePartial_toObject(gen, field, fieldIndex, dstProp, srcProp) {
             case "sint64":
             case "sfixed64": gen
             ("if(typeof BigInt!==\"undefined\"&&o.longs===BigInt)")
-                ("d%s=typeof m%s===\"number\"?BigInt(m%s):util.Long.fromBits(m%s.low>>>0,m%s.high>>>0,%j).toBigInt()", dstProp, srcProp, srcProp, srcProp, srcProp, isUnsigned)
-            ("else if(typeof m%s===\"number\")", srcProp)
-                ("d%s=o.longs===String?String(m%s):m%s", dstProp, srcProp, srcProp)
+                ("d%s=typeof m%s===\"number\"?BigInt(m%s):util.Long.fromBits(m%s.low>>>0,m%s.high>>>0,%j).toBigInt()", prop, prop, prop, prop, prop, isUnsigned)
+            ("else if(typeof m%s===\"number\")", prop)
+                ("d%s=o.longs===String?String(m%s):m%s", prop, prop, prop)
             ("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", dstProp, srcProp, srcProp, srcProp, isUnsigned ? "true": "", srcProp);
+                ("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);
                 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", dstProp, srcProp, srcProp, srcProp, srcProp);
+            ("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);
                 break;
             default: gen
-            ("d%s=m%s", dstProp, srcProp);
+            ("d%s=m%s", prop, prop);
                 break;
         }
     }
@@ -308,28 +289,23 @@ converter.toObject = function toObject(mtype) {
     ("var ks2");
             } gen
     ("if(m%s&&(ks2=Object.keys(m%s)).length){", prop, prop)
-        ("d%s={}", prop);
-            var longKey = types.long[field.keyType] !== undefined,
-                srcProp = prop + "[ks2[j]]";
-            gen
+        ("d%s={}", prop)
         ("for(var j=0;j<ks2.length;++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)
+            genValuePartial_toObject(gen, field, /* sorted */ index, prop + "[ks2[j]]")
         ("}");
         } else if (field.repeated) { gen
     ("if(m%s&&m%s.length){", prop, prop)
-        ("d%s=Array(m%s.length)", prop, prop)
+        ("d%s=[]", prop)
         ("for(var j=0;j<m%s.length;++j){", prop);
             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 (field.partOf) gen
         ("if(o.oneofs)")
             ("d%s=%j", util.safeProp(field.partOf.name), field.name);
         }

package/node_modules/protobufjs/src/decoder.js

@@ -16,187 +16,116 @@ function missing(field) {
  */
 function decoder(mtype) {
     /* eslint-disable no-unexpected-multiline */
-    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")
+    var gen = util.codegen(["r", "l", "e", "n"], mtype.name + "$decode")
     ("if(!(r instanceof Reader))")
         ("r=Reader.create(r)")
-    ("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 C" + (hasMapField ? ",k,v" : hasImplicitPresenceField ? ",v" : ""))
+    ("if(n===undefined)n=0")
+    ("if(n>Reader.recursionLimit)")
+        ("throw Error(\"maximum nesting depth exceeded\")")
+    ("var c=l===undefined?r.len:r.pos+l,m=new this.ctor" + (mtype.fieldsArray.filter(function(field) { return field.map; }).length ? ",k,value" : ""))
     ("while(r.pos<c){")
-        ("var s=r.pos")
-        ("var t=r.tag()")
-        ("if(t===z){")
-            ("z=undefined")
+        ("var t=r.uint32()")
+        ("if(t===e)")
             ("break")
-        ("}");
-    if (mtype.fieldsArray.length) gen
-        ("var u=t&7")
-        ("switch(t>>>=3){");
-    for (i = 0; i < /* initializes */ mtype.fieldsArray.length; ++i) {
+        ("switch(t>>>3){");
+
+    var i = 0;
+    for (; 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);
+            ref   = "m" + util.safeProp(field.name); gen
+            ("case %i: {", field.id);
 
         // Map fields
-        if (field.map) {
-            gen
-            ("case %i:{", field.id)
-                ("if(u!==2)")
-                    ("break")
+        if (field.map) { gen
                 ("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]);
             else gen
                 ("k=null");
 
-            if (types.long[type] !== undefined) gen
-                ("v=util.Long?util.Long.fromNumber(0,%j):0", type === "uint64" || type === "fixed64");
-            else if (types.defaults[type] !== undefined) gen
-                ("v=%j", types.defaults[type]);
+            if (types.defaults[type] !== undefined) gen
+                ("value=%j", types.defaults[type]);
             else gen
-                ("v=null");
+                ("value=null");
 
             gen
                 ("while(r.pos<c2){")
-                    ("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");
+                    ("var tag2=r.uint32()")
+                    ("switch(tag2>>>3){")
+                        ("case 1: k=r.%s(); break", field.keyType)
+                        ("case 2:");
 
             if (types.basic[type] === undefined) gen
-                            ("v=types[%i].decode(r,r.uint32(),undefined,q+1)", i); // can't be groups
+                            ("value=types[%i].decode(r,r.uint32(),undefined,n+1)", i); // can't be groups
             else gen
-                            ("v=r.%s()", type);
+                            ("value=r.%s()", type);
 
             gen
-                            ("continue")
+                            ("break")
+                        ("default:")
+                            ("r.skipType(tag2&7,n)")
+                            ("break")
                     ("}")
-                    ("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]=%s", ref, val);
+                ("%s[typeof k===\"object\"?util.longToHash(k):k]=value", ref);
             else {
                 if (field.keyType === "string") gen
                 ("if(k===\"__proto__\")")
                     ("util.makeProp(%s,k)", ref);
                 gen
-                ("%s[k]=%s", ref, val);
+                ("%s[k]=value", ref);
             }
 
         // Repeated fields
         } else if (field.repeated) { gen
-            ("case %i:", field.id)
-            ("{");
+
+                ("if(!(%s&&%s.length))", ref, ref)
+                    ("%s=[]", ref);
 
             // Packable (always check for forward and backward compatiblity)
             if (types.packed[type] !== undefined) gen
-                ("if(u===2){")
-                    ("if(!(%s&&%s.length))", ref, ref)
-                        ("%s=[]", ref)
+                ("if((t&7)===2){")
                     ("var c2=r.uint32()+r.pos")
                     ("while(r.pos<c2)")
                         ("%s.push(r.%s())", ref, type)
-                    ("continue")
-                ("}");
+                ("}else");
 
             // Non-packed
-            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
+            if (types.basic[type] === undefined) gen(field.delimited
+                    ? "%s.push(types[%i].decode(r,undefined,((t&~7)|4),n+1))"
+                    : "%s.push(types[%i].decode(r,r.uint32(),undefined,n+1))", ref, i);
+            else gen
                     ("%s.push(r.%s())", ref, type);
 
         // Non-repeated
-        } 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")
+        } else if (types.basic[type] === undefined) gen(field.delimited
+                ? "%s=types[%i].decode(r,undefined,((t&~7)|4),n+1)"
+                : "%s=types[%i].decode(r,r.uint32(),undefined,n+1)", ref, i);
+        else gen
                 ("%s=r.%s()", ref, type);
-        } else {
-            gen
-            ("case %i:{", field.id)
-                ("if(u!==%i)", types.basic[type])
-                    ("break");
-            if (field.resolvedType instanceof Enum && field.typeDefault !== 0) gen
-                // TODO: Protoc rejects open enums whose first value is not zero.
-                // We should do the same, but for v8 this would be a regression.
-                ("if((v=r.%s())!==%j)", type, field.typeDefault);
-            else 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
-                ("continue")
+                ("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\")");
+        // Unknown fields
+    } gen
+            ("default:")
+                ("r.skipType(t&7,n)")
+                ("break")
+
+        ("}")
+    ("}");
 
     // Field presence
     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/node_modules/protobufjs/src/encoder.js

@@ -50,12 +50,7 @@ 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);
-            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
+        ("for(var ks=Object.keys(%s),i=0;i<ks.length;++i){", ref)
             ("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(),q+1).ldelim().ldelim()", index, ref); // can't be groups
@@ -91,7 +86,7 @@ function encoder(mtype) {
 
         // Non-repeated
         } else {
-            if (!field.required) gen
+            if (field.optional) gen
     ("if(%s!=null&&Object.hasOwnProperty.call(m,%j))", ref, field.name); // !== undefined && !== null
 
             if (wireType === undefined)
@@ -103,9 +98,6 @@ 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/node_modules/protobufjs/src/enum.js

@@ -17,7 +17,7 @@ var Namespace = require("./namespace"),
  * @param {Object.<string,number>} [values] Enum values as an object, by name
  * @param {Object.<string,*>} [options] Declared options
  * @param {string} [comment] The comment for this enum
- * @param {Object.<string,string|null>} [comments] The value comments for this enum
+ * @param {Object.<string,string>} [comments] The value comments for this enum
  * @param {Object.<string,Object<string,*>>|undefined} [valuesOptions] The value options for this enum
  */
 function Enum(name, values, options, comment, comments, valuesOptions) {
@@ -46,7 +46,7 @@ function Enum(name, values, options, comment, comments, valuesOptions) {
 
     /**
      * Value comment texts, if any.
-     * @type {Object.<string,string|null>}
+     * @type {Object.<string,string>}
      */
     this.comments = comments || {};
 
@@ -96,13 +96,8 @@ Enum.prototype._resolveFeatures = function _resolveFeatures(edition) {
 /**
  * Enum descriptor.
  * @interface IEnum
- * @property {string} [edition] Edition
  * @property {Object.<string,number>} values Enum values
  * @property {Object.<string,*>} [options] Enum options
- * @property {Object.<string,Object.<string,*>>} [valuesOptions] Enum value options
- * @property {Array.<number[]|string>} [reserved] Reserved ranges
- * @property {string|null} [comment] Enum comment
- * @property {Object.<string,string|null>} [comments] Value comments
  */
 
 /**
@@ -113,7 +108,7 @@ Enum.prototype._resolveFeatures = function _resolveFeatures(edition) {
  * @throws {TypeError} If arguments are invalid
  */
 Enum.fromJSON = function fromJSON(name, json) {
-    var enm = new Enum(name, json.values, json.options, json.comment, json.comments, json.valuesOptions);
+    var enm = new Enum(name, json.values, json.options, json.comment, json.comments);
     enm.reserved = json.reserved;
     if (json.edition)
         enm._edition = json.edition;