protobufjs 8.6.4 → 8.6.5

package/dist/protobuf.js

@@ -1,6 +1,6 @@
 /*!
- * protobuf.js v8.6.4 (c) 2016, daniel wirtz
- * compiled tue, 16 jun 2026 14:35:46 utc
+ * protobuf.js v8.6.5 (c) 2016, daniel wirtz
+ * compiled tue, 23 jun 2026 14:36:35 utc
  * licensed under the bsd-3-clause license
  * see: https://github.com/dcodeio/protobuf.js for details
  */
@@ -458,31 +458,33 @@ var Enum  = require(6),
  * @param {Field} field Reflected field
  * @param {number} fieldIndex Field index
  * @param {string} prop Property reference
+ * @param {string} [dstProp] Repeated destination property reference
  * @returns {Codegen} Codegen instance
  * @ignore
  */
-function genValuePartial_fromObject(gen, field, fieldIndex, prop) {
-    var defaultAlreadyEmitted = false;
+function genValuePartial_fromObject(gen, field, fieldIndex, prop, dstProp) {
     /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
     if (field.resolvedType) {
-        if (field.resolvedType instanceof Enum) { gen
+        if (field.resolvedType instanceof Enum) {
+            var dst = dstProp
+                ? "m" + dstProp + "[m" + dstProp + ".length]"
+                : "m" + prop;
+            gen
             ("switch(d%s){", prop);
-            for (var values = field.resolvedType.values, keys = Object.keys(values), i = 0; i < keys.length; ++i) {
-                // 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 (!field.repeated) gen // fallback to default value only for
-                                             // arrays, to avoid leaving holes.
-                        ("break");           // for non-repeated fields, just ignore
-                    defaultAlreadyEmitted = true;
-                }
-                gen
+            for (var values = field.resolvedType.values, keys = Object.keys(values), i = 0; i < keys.length; ++i) { gen
                 ("case%j:", keys[i])
                 ("case %i:", values[keys[i]])
-                    ("m%s=%j", prop, values[keys[i]])
+                    ("%s=%j", dst, values[keys[i]])
                     ("break");
-            } gen
+            }
+            gen
+                ("default:");
+            if (field.resolvedType._features.enum_type !== "CLOSED") {
+                gen
+                    ("if(typeof d%s===\"number\"&&(d%s|0)===d%s)", prop, prop, prop)
+                        ("%s=d%s", dst, prop);
+            }
+            gen
             ("}");
         } else gen
             ("if(!util.isObject(d%s))", prop)
@@ -585,10 +587,14 @@ converter.fromObject = function fromObject(mtype) {
         } else if (field.repeated) { gen
     ("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)
+            ("throw TypeError(%j)", field.fullName + ": array expected");
+            if (field.resolvedType instanceof Enum) gen
+        ("m%s=[]", prop);
+            else gen
+        ("m%s=Array(d%s.length)", prop, prop);
+            gen
         ("for(var i=0;i<d%s.length;++i){", prop);
-            genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[i]")
+            genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[i]", field.resolvedType instanceof Enum ? prop : undefined)
         ("}")
     ("}");
 
@@ -605,6 +611,8 @@ converter.fromObject = function fromObject(mtype) {
     ("if(d%s.length){", prop);
                 else if (field.type === "bool") gen
     ("if(d%s){", prop);
+                else if (field.type === "double" || field.type === "float") gen
+    ("if(!Object.is(Number(d%s),0)){", 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
@@ -802,6 +810,16 @@ function stringMethod(field) {
     return field._features.utf8_validation === "VERIFY" ? "stringVerify" : "string";
 }
 
+function genPreserveUnknown(gen, ref) {
+    /* eslint-disable no-unexpected-multiline */
+    return gen
+        ("if(!r.discardUnknown){")
+            ("util.makeProp(m,\"$unknowns\",false);")
+            ("(m.$unknowns||(m.$unknowns=[])).push(%s)", ref)
+        ("}");
+    /* eslint-enable no-unexpected-multiline */
+}
+
 /**
  * Generates a decoder specific to the specified message type.
  * @param {Type} mtype Message type
@@ -810,14 +828,14 @@ function stringMethod(field) {
 function decoder(mtype) {
     /* eslint-disable no-unexpected-multiline */
     var hasMapField = false,
-        hasImplicitPresenceField = false,
+        needsValueVar = 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;
+        if (pfield.resolvedType instanceof Enum || !pfield.repeated && !pfield.map && !pfield.hasPresence)
+            needsValueVar = true;
     }
     var gen = util.codegen(["r", "l", "z", "q", "g"])
     ("if(!(r instanceof Reader))")
@@ -825,7 +843,7 @@ function decoder(mtype) {
     ("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" : ""))
+    ("var c=l===undefined?r.len:r.pos+l,m=g||new C" + (hasMapField ? ",k,v" : needsValueVar ? ",v" : ""))
     ("while(r.pos<c){")
         ("var s=r.pos")
         ("var t=r.tag()")
@@ -837,18 +855,21 @@ function decoder(mtype) {
         ("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);
+        var field  = mtype._fieldsArray[i].resolve(),
+            type   = field.resolvedType instanceof Enum ? "int32" : field.type,
+            ref    = "m" + util.safeProp(field.name),
+            closed = field.resolvedType instanceof Enum && field.resolvedType._features.enum_type === "CLOSED";
 
         // Map fields
         if (field.map) {
             gen
             ("case %i:{", field.id)
                 ("if(u!==2)")
-                    ("break")
+                    ("break");
+            if (!closed) gen
                 ("if(%s===util.emptyObject)", ref)
-                    ("%s={}", ref)
+                    ("%s={}", ref);
+            gen
                 ("var c2=r.uint32()+r.pos");
 
             if (types.defaults[field.keyType] !== undefined) gen
@@ -888,6 +909,15 @@ function decoder(mtype) {
                     ("r.skipType(u,q,t2)")
                 ("}");
 
+            if (closed) { gen
+                ("if(types[%i].valuesById[v]===undefined){", i);
+                    genPreserveUnknown(gen, "r.raw(s,r.pos)")
+                    ("continue")
+                ("}")
+                ("if(%s===util.emptyObject)", ref)
+                    ("%s={}", ref);
+            }
+
             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);
@@ -905,20 +935,39 @@ function decoder(mtype) {
             ("{");
 
             // Packable (always check for forward and backward compatiblity)
-            if (types.packed[type] !== undefined) gen
-                ("if(u===2){")
+            if (types.packed[type] !== undefined) {
+                gen
+                ("if(u===2){");
+                if (!closed) gen
                     ("if(!(%s&&%s.length))", ref, ref)
-                        ("%s=[]", ref)
-                    ("var c2=r.uint32()+r.pos")
+                        ("%s=[]", ref);
+                gen
+                    ("var c2=r.uint32()+r.pos");
+                if (closed) {
+                    gen
+                    ("while(r.pos<c2){")
+                        ("s=r.pos")
+                        ("v=r.%s()", type)
+                        ("if(types[%i].valuesById[v]!==undefined){", i)
+                            ("if(!(%s&&%s.length))", ref, ref)
+                                ("%s=[]", ref)
+                            ("%s.push(v)", ref)
+                        ("}else");
+                            genPreserveUnknown(gen, "util.rawField(" + field.id + ",0,r.raw(s,r.pos))")
+                    ("}");
+                } else gen
                     ("while(r.pos<c2)")
-                        ("%s.push(r.%s())", ref, type)
+                        ("%s.push(r.%s())", ref, type);
+                gen
                     ("continue")
                 ("}");
+            }
 
             // Non-packed
             gen
                 ("if(u!==%i)", types.basic[type] === undefined ? field.delimited ? 3 : 2 : types.basic[type])
-                    ("break")
+                    ("break");
+            if (!closed) gen
                 ("if(!(%s&&%s.length))", ref, ref)
                     ("%s=[]", ref);
             if (types.basic[type] === undefined) {
@@ -926,6 +975,14 @@ function decoder(mtype) {
                     ("%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 if (closed) { gen
+                    ("v=r.%s()", type)
+                    ("if(types[%i].valuesById[v]!==undefined){", i)
+                        ("if(!(%s&&%s.length))", ref, ref)
+                            ("%s=[]", ref)
+                        ("%s.push(v)", ref)
+                    ("}else");
+                        genPreserveUnknown(gen, "r.raw(s,r.pos)");
             } else gen
                     ("%s.push(r.%s())", ref, type === "string" ? stringMethod(field) : type);
 
@@ -944,33 +1001,55 @@ function decoder(mtype) {
             gen
             ("case %i:{", field.id)
                 ("if(u!==%i)", types.basic[type])
-                    ("break")
+                    ("break");
+            if (closed) { gen
+                ("v=r.%s()", type)
+                ("if(types[%i].valuesById[v]!==undefined){", i)
+                    ("%s=v", ref);
+                if (field.partOf) gen
+                    ("m%s=%j", util.safeProp(field.partOf.name), field.name);
+                gen
+                ("}else");
+                    genPreserveUnknown(gen, "r.raw(s,r.pos)");
+            } else gen
                 ("%s=r.%s()", ref, type === "string" ? stringMethod(field) : 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") gen
-                ("if((v=r.%s()).length)", stringMethod(field));
-            else if (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 (closed) { gen
+                ("v=r.%s()", type)
+                ("if(types[%i].valuesById[v]!==undefined){", i)
+                    ("if(v!==%j)", field.typeDefault)
+                        ("%s=v", ref)
+                    ("else")
+                        ("delete %s", ref)
+                ("}else{");
+                    genPreserveUnknown(gen, "r.raw(s,r.pos)")
+                ("}");
+            } else {
+                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") gen
+                    ("if((v=r.%s()).length)", stringMethod(field));
+                else if (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(!Object.is(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
+        if (field.partOf && !closed) gen
                 ("m%s=%j", util.safeProp(field.partOf.name), field.name);
         gen
                 ("continue")
@@ -980,11 +1059,8 @@ function decoder(mtype) {
         ("}");
     // Unknown fields
     gen
-        ("r.skipType(%s,q,t)", i ? "u" : "t&7")
-        ("if(!r.discardUnknown){")
-            ("util.makeProp(m,\"$unknowns\",false);")
-            ("(m.$unknowns||(m.$unknowns=[])).push(r.raw(s,r.pos))")
-        ("}")
+        ("r.skipType(%s,q,t)", i ? "u" : "t&7");
+    genPreserveUnknown(gen, "r.raw(s,r.pos)")
     ("}")
     ("if(z!==undefined)")
         ("throw Error(\"missing end group\")");
@@ -1096,8 +1172,23 @@ function encoder(mtype) {
 
         // Non-repeated
         } else {
-            if (!field.required) gen
+            if (!field.required)
+                if (field.hasPresence || !(field.resolvedType instanceof Enum || types.basic[type] !== undefined)) gen
     ("if(%s!=null&&Object.hasOwnProperty.call(m,%j))", ref, field.name); // !== undefined && !== null
+                else if (field.resolvedType instanceof Enum) gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==%j)", ref, field.name, ref, field.typeDefault);
+                else if (type === "bool") gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==false)", ref, field.name, ref);
+                else if (type === "string") gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==\"\")", ref, field.name, ref);
+                else if (type === "bytes") gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s.length)", ref, field.name, ref);
+                else if (type === "double" || type === "float") gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&!Object.is(%s,0))", ref, field.name, ref);
+                else if (types.long[type] !== undefined) gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&(typeof %s===\"object\"?%s.low||%s.high:%s!==0))", ref, field.name, ref, ref, ref, ref);
+                else gen
+    ("if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==0)", ref, field.name, ref);
 
             if (wireType === undefined)
         genTypePartial(gen, field, index, ref);
@@ -1121,7 +1212,15 @@ module.exports = Enum;
 
 // extends ReflectionObject
 var ReflectionObject = require(15);
-((Enum.prototype = Object.create(ReflectionObject.prototype)).constructor = Enum).className = "Enum";
+Enum.prototype = Object.create(ReflectionObject.prototype, {
+    constructor: {
+        value: Enum,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Enum.className = "Enum";
 
 var Namespace = require(14),
     util = require(28);
@@ -1148,7 +1247,7 @@ function Enum(name, values, options, comment, comments, valuesOptions) {
      * Enum values by id.
      * @type {Object.<number,string>}
      */
-    this.valuesById = {};
+    this.valuesById = Object.create(null);
 
     /**
      * Enum values by name.
@@ -1354,7 +1453,15 @@ module.exports = Field;
 
 // extends ReflectionObject
 var ReflectionObject = require(15);
-((Field.prototype = Object.create(ReflectionObject.prototype)).constructor = Field).className = "Field";
+Field.prototype = Object.create(ReflectionObject.prototype, {
+    constructor: {
+        value: Field,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Field.className = "Field";
 
 var Enum  = require(6),
     types = require(27),
@@ -2010,7 +2117,15 @@ module.exports = MapField;
 
 // extends Field
 var Field = require(7);
-((MapField.prototype = Object.create(Field.prototype)).constructor = MapField).className = "MapField";
+MapField.prototype = Object.create(Field.prototype, {
+    constructor: {
+        value: MapField,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+MapField.className = "MapField";
 
 var types   = require(27),
     util    = require(28);
@@ -2287,7 +2402,15 @@ module.exports = Method;
 
 // extends ReflectionObject
 var ReflectionObject = require(15);
-((Method.prototype = Object.create(ReflectionObject.prototype)).constructor = Method).className = "Method";
+Method.prototype = Object.create(ReflectionObject.prototype, {
+    constructor: {
+        value: Method,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Method.className = "Method";
 
 var util = require(28);
 
@@ -2464,7 +2587,15 @@ module.exports = Namespace;
 
 // extends ReflectionObject
 var ReflectionObject = require(15);
-((Namespace.prototype = Object.create(ReflectionObject.prototype)).constructor = Namespace).className = "Namespace";
+Namespace.prototype = Object.create(ReflectionObject.prototype, {
+    constructor: {
+        value: Namespace,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Namespace.className = "Namespace";
 
 var Field    = require(7),
     util     = require(28),
@@ -3299,7 +3430,7 @@ ReflectionObject.prototype._inferLegacyProtoFeatures = function _inferLegacyProt
  * @returns {*} Option value or `undefined` if not set
  */
 ReflectionObject.prototype.getOption = function getOption(name) {
-    if (this.options)
+    if (this.options && Object.prototype.hasOwnProperty.call(this.options, name))
         return this.options[name];
     return undefined;
 };
@@ -3318,9 +3449,12 @@ ReflectionObject.prototype.setOption = function setOption(name, value, ifNotSet)
         this.options = {};
     if (/^features\./.test(name)) {
         util.setProperty(this.options, name, value, ifNotSet);
-    } else if (!ifNotSet || this.options[name] === undefined) {
-        if (this.getOption(name) !== value) this.resolved = false;
-        this.options[name] = value;
+    } else {
+        var prev = this.getOption(name);
+        if (!ifNotSet || prev === undefined) {
+            if (prev !== value) this.resolved = false;
+            this.options[name] = value;
+        }
     }
 
     return this;
@@ -3382,15 +3516,22 @@ ReflectionObject.prototype.setOptions = function setOptions(options, ifNotSet) {
 
 /**
  * Converts this instance to its string representation.
+ * @name ReflectionObject#toString
+ * @function
  * @returns {string} Class name[, space, full name]
  */
-ReflectionObject.prototype.toString = function toString() {
-    var className = this.constructor.className,
-        fullName  = this.fullName;
-    if (fullName.length)
-        return className + " " + fullName;
-    return className;
-};
+Object.defineProperty(ReflectionObject.prototype, "toString", {
+    value: function toString() {
+        var className = this.constructor.className,
+            fullName  = this.fullName;
+        if (fullName.length)
+            return className + " " + fullName;
+        return className;
+    },
+    writable: true,
+    enumerable: false,
+    configurable: true
+});
 
 /**
  * Converts the edition this object is pinned to for JSON format.
@@ -3416,7 +3557,15 @@ module.exports = OneOf;
 
 // extends ReflectionObject
 var ReflectionObject = require(15);
-((OneOf.prototype = Object.create(ReflectionObject.prototype)).constructor = OneOf).className = "OneOf";
+OneOf.prototype = Object.create(ReflectionObject.prototype, {
+    constructor: {
+        value: OneOf,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+OneOf.className = "OneOf";
 
 var Field = require(7),
     util  = require(28);
@@ -4459,7 +4608,9 @@ function parse(source, root, options) {
                     setOption(parent, name + "." + token, value);
                 }
 
-                var prevValue = objectResult[propName];
+                var prevValue = Object.prototype.hasOwnProperty.call(objectResult, propName)
+                    ? objectResult[propName]
+                    : undefined;
 
                 if (prevValue)
                     value = [].concat(prevValue).concat(value);
@@ -5273,7 +5424,14 @@ module.exports = BufferReader;
 
 // extends Reader
 var Reader = require(18);
-(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
+BufferReader.prototype = Object.create(Reader.prototype, {
+    constructor: {
+        value: BufferReader,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
 
 var util = require(37);
 
@@ -5347,7 +5505,15 @@ module.exports = Root;
 
 // extends Namespace
 var Namespace = require(14);
-((Root.prototype = Object.create(Namespace.prototype)).constructor = Root).className = "Root";
+Root.prototype = Object.create(Namespace.prototype, {
+    constructor: {
+        value: Root,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Root.className = "Root";
 
 var Field   = require(7),
     Enum    = require(6),
@@ -5824,7 +5990,14 @@ module.exports = Service;
 var util = require(37);
 
 // Extends EventEmitter
-(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
+Service.prototype = Object.create(util.EventEmitter.prototype, {
+    constructor: {
+        value: Service,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
 
 /**
  * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
@@ -5973,7 +6146,15 @@ module.exports = Service;
 
 // extends Namespace
 var Namespace = require(14);
-((Service.prototype = Object.create(Namespace.prototype)).constructor = Service).className = "Service";
+Service.prototype = Object.create(Namespace.prototype, {
+    constructor: {
+        value: Service,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Service.className = "Service";
 
 var Method = require(13),
     util   = require(28),
@@ -6596,7 +6777,15 @@ module.exports = Type;
 
 // extends Namespace
 var Namespace = require(14);
-((Type.prototype = Object.create(Namespace.prototype)).constructor = Type).className = "Type";
+Type.prototype = Object.create(Namespace.prototype, {
+    constructor: {
+        value: Type,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
+Type.className = "Type";
 
 var Enum      = require(6),
     OneOf     = require(16),
@@ -6761,7 +6950,13 @@ Object.defineProperties(Type.prototype, {
             // Ensure proper prototype
             var prototype = ctor.prototype;
             if (!(prototype instanceof Message)) {
-                (ctor.prototype = new Message()).constructor = ctor;
+                ctor.prototype = new Message();
+                Object.defineProperty(ctor.prototype, "constructor", {
+                    value: ctor,
+                    writable: true,
+                    enumerable: false,
+                    configurable: true
+                });
                 util.merge(ctor.prototype, prototype);
             }
 
@@ -7996,7 +8191,12 @@ function codegen(functionParams, functionName) {
         return "function " + safeFunctionName(functionNameOverride || functionName) + "(" + (functionParams && functionParams.join(",") || "") + "){\n  " + body.join("\n  ") + "\n}";
     }
 
-    Codegen.toString = toString;
+    Object.defineProperty(Codegen, "toString", {
+        value: toString,
+        writable: true,
+        enumerable: true,
+        configurable: true
+    });
     return Codegen;
 }
 
@@ -8783,6 +8983,7 @@ LongBits.prototype.length = function length() {
 
 },{"37":37}],37:[function(require,module,exports){
 "use strict";
+/* global globalThis */
 var util = exports;
 
 // used to return a Promise where callback is omitted
@@ -8837,6 +9038,7 @@ util.isNode = Boolean(typeof global !== "undefined"
 util.global = util.isNode && global
            || typeof window !== "undefined" && window
            || typeof self   !== "undefined" && self
+           || typeof globalThis !== "undefined" && globalThis
            || this; // eslint-disable-line no-invalid-this
 
 /**
@@ -8951,6 +9153,28 @@ util.newBuffer = function newBuffer(sizeOrArray) {
                 : new Uint8Array(sizeOrArray);
 };
 
+/**
+ * Prepends a raw field tag to raw field data.
+ * @param {number} id Field id
+ * @param {number} wireType Wire type
+ * @param {Uint8Array} data Raw field data
+ * @returns {Uint8Array|Buffer} Raw field bytes
+ * @ignore
+ */
+util.rawField = function rawField(id, wireType, data) {
+    var out = [],
+        tag = id << 3 | wireType;
+    tag >>>= 0;
+    while (tag > 127) {
+        out.push(tag & 127 | 128);
+        tag >>>= 7;
+    }
+    out.push(tag);
+    for (var i = 0; i < data.length; ++i)
+        out.push(data[i]);
+    return util.newBuffer(out);
+};
+
 /**
  * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
  * @type {Constructor<Uint8Array>}
@@ -9064,7 +9288,7 @@ function merge(dst) { // used by converters
         if (!src)
             continue;
         for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)
-            if (!isUnsafeProperty(keys[i]) && (dst[keys[i]] === undefined || !ifNotSet))
+            if (!isUnsafeProperty(keys[i]) && (!ifNotSet || !Object.prototype.hasOwnProperty.call(dst, keys[i]) || dst[keys[i]] === undefined))
                 dst[keys[i]] = src[keys[i]];
     }
     return dst;
@@ -9671,16 +9895,21 @@ function invalid(field, expected) {
  */
 function genVerifyValue(gen, field, fieldIndex, ref) {
     /* eslint-disable no-unexpected-multiline */
-    if (field.resolvedType) {
-        if (field.resolvedType instanceof Enum) { gen
-            ("switch(%s){", ref)
-                ("default:")
+    var resolvedType = field.resolvedType;
+    if (resolvedType) {
+        if (resolvedType instanceof Enum) {
+            if (resolvedType._features.enum_type === "CLOSED") { gen
+                ("switch(%s){", ref)
+                    ("default:")
+                        ("return%j", invalid(field, "enum value"));
+                for (var keys = Object.keys(resolvedType.values), j = 0; j < keys.length; ++j) gen
+                    ("case %i:", resolvedType.values[keys[j]]);
+                gen
+                        ("break")
+                ("}");
+            } else gen
+                ("if(typeof %s!==\"number\"||(%s|0)!==%s)", ref, ref, ref)
                     ("return%j", invalid(field, "enum value"));
-            for (var keys = Object.keys(field.resolvedType.values), j = 0; j < keys.length; ++j) gen
-                ("case %i:", field.resolvedType.values[keys[j]]);
-            gen
-                    ("break")
-            ("}");
         } else {
             gen
             ("{")
@@ -10442,7 +10671,14 @@ module.exports = BufferWriter;
 
 // extends Writer
 var Writer = require(44);
-(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;
+BufferWriter.prototype = Object.create(Writer.prototype, {
+    constructor: {
+        value: BufferWriter,
+        writable: true,
+        enumerable: false,
+        configurable: true
+    }
+});
 
 var util = require(37);