@openclaw/whatsapp 2026.7.2-beta.4 → 2026.7.2-beta.7

package/node_modules/baileys/node_modules/protobufjs/src/converter.js

@@ -0,0 +1,352 @@
+"use strict";
+/**
+ * Runtime message from/to plain object converters.
+ * @namespace
+ */
+var converter = exports;
+
+var Enum  = require("./enum"),
+    types = require("./types"),
+    util  = require("./util");
+
+/**
+ * Generates a partial value fromObject conveter.
+ * @param {Codegen} gen Codegen instance
+ * @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, dstProp) {
+    /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
+    if (field.resolvedType) {
+        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) { gen
+                ("case%j:", keys[i])
+                ("case %i:", values[keys[i]])
+                    ("%s=%j", dst, values[keys[i]])
+                    ("break");
+            }
+            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)
+                ("throw TypeError(%j)", field.fullName + ": object expected")
+            ("m%s=types[%i].fromObject(d%s,q+1)", prop, fieldIndex, prop);
+    } else {
+        var isUnsigned = false;
+        switch (field.type) {
+            case "double":
+            case "float": gen
+                ("m%s=Number(d%s)", prop, prop); // also catches "NaN", "Infinity"
+                break;
+            case "uint32":
+            case "fixed32": gen
+                ("m%s=d%s>>>0", prop, prop);
+                break;
+            case "int32":
+            case "sint32":
+            case "sfixed32": gen
+                ("m%s=d%s|0", prop, prop);
+                break;
+            case "uint64":
+            case "fixed64":
+                isUnsigned = true;
+                // eslint-disable-next-line no-fallthrough
+            case "int64":
+            case "sint64":
+            case "sfixed64": gen
+                ("if(util.Long)")
+                    ("m%s=util.Long.fromValue(d%s,%j)", prop, prop, isUnsigned)
+                ("else if(typeof d%s===\"string\")", prop)
+                    ("m%s=parseInt(d%s,10)", prop, prop)
+                ("else if(typeof d%s===\"number\")", prop)
+                    ("m%s=d%s", prop, prop)
+                ("else if(typeof d%s===\"object\")", prop)
+                    ("m%s=new util.LongBits(d%s.low>>>0,d%s.high>>>0).toNumber(%s)", prop, prop, prop, isUnsigned ? "true" : "");
+                break;
+            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)
+                    ("m%s=d%s", prop, prop);
+                break;
+            case "string": gen
+                ("m%s=String(d%s)", prop, prop);
+                break;
+            case "bool": gen
+                ("m%s=Boolean(d%s)", prop, prop);
+                break;
+            /* default: gen
+                ("m%s=d%s", prop, prop);
+                break; */
+        }
+    }
+    return gen;
+    /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
+}
+
+/**
+ * Generates a plain object to runtime message converter specific to the specified message type.
+ * @param {Type} mtype Message type
+ * @returns {Codegen} Codegen instance
+ */
+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"])
+    ("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\")");
+    if (!fields.length) return gen
+    ("return new C");
+    gen
+    ("var m=new C");
+    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);
+
+        // Map fields
+        if (field.map) { gen
+    ("if(d%s){", 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);
+            gen
+        ("if(ks[i]===\"__proto__\")")
+            ("util.makeProp(m%s,ks[i])", prop);
+            genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + "[ks[i]]")
+        ("}")
+    ("}");
+
+        // Repeated fields
+        } else if (field.repeated) { gen
+    ("if(d%s){", prop)
+        ("if(!Array.isArray(d%s))", 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]", field.resolvedType instanceof Enum ? prop : undefined)
+        ("}")
+    ("}");
+
+        // Non-repeated fields
+        } 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 (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
+    ("if(Number(d%s)!==0){", prop);
+            }
+        genValuePartial_fromObject(gen, field, /* not sorted */ i, prop);
+            if (implicitPresence) gen
+    ("}");
+            if (!(field.resolvedType instanceof Enum)) gen
+    ("}");
+        }
+    } return gen
+    ("return m");
+    /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
+};
+
+/**
+ * Generates a partial value toObject converter.
+ * @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
+ * @returns {Codegen} Codegen instance
+ * @ignore
+ */
+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", dstProp, fieldIndex, srcProp, srcProp, fieldIndex, srcProp, srcProp);
+        else gen
+            ("d%s=types[%i].toObject(m%s,o,q+1)", 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", dstProp, srcProp, srcProp, srcProp);
+                break;
+            case "uint64":
+            case "fixed64":
+                isUnsigned = true;
+                // eslint-disable-next-line no-fallthrough
+            case "int64":
+            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)
+            ("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);
+                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);
+                break;
+            default: gen
+            ("d%s=m%s", dstProp, srcProp);
+                break;
+        }
+    }
+    return gen;
+    /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
+}
+
+/**
+ * Generates a runtime message to plain object converter specific to the specified message type.
+ * @param {Type} mtype Message type
+ * @returns {Codegen} Codegen instance
+ */
+converter.toObject = function toObject(mtype) {
+    /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */
+    var fields = mtype.fieldsArray.slice().sort(util.compareFieldsById);
+    if (!fields.length)
+        return util.codegen()("return {}");
+    var gen = util.codegen(["m", "o", "q"])
+    ("if(!o)")
+        ("o={}")
+    ("if(q===undefined)q=0")
+    ("if(q>util.recursionLimit)")
+        ("throw Error(\"max depth exceeded\")")
+    ("var d={}");
+
+    var repeatedFields = [],
+        mapFields = [],
+        normalFields = [],
+        i = 0;
+    for (; i < fields.length; ++i)
+        if (!fields[i].partOf)
+            ( fields[i].resolve().repeated ? repeatedFields
+            : fields[i].map ? mapFields
+            : normalFields).push(fields[i]);
+
+    if (repeatedFields.length) { gen
+    ("if(o.arrays||o.defaults){");
+        for (i = 0; i < repeatedFields.length; ++i) gen
+        ("d%s=[]", util.safeProp(repeatedFields[i].name));
+        gen
+    ("}");
+    }
+
+    if (mapFields.length) { gen
+    ("if(o.objects||o.defaults){");
+        for (i = 0; i < mapFields.length; ++i) gen
+        ("d%s={}", util.safeProp(mapFields[i].name));
+        gen
+    ("}");
+    }
+
+    if (normalFields.length) { gen
+    ("if(o.defaults){");
+        for (i = 0; i < normalFields.length; ++i) {
+            var field = normalFields[i],
+                prop  = util.safeProp(field.name);
+            if (field.resolvedType instanceof Enum) gen
+        ("d%s=o.enums===String?%j:%j", prop, field.resolvedType.valuesById[field.typeDefault], field.typeDefault);
+            else if (field.long) gen
+        ("if(util.Long){")
+            ("var n=new util.Long(%i,%i,%j)", field.typeDefault.low, field.typeDefault.high, field.typeDefault.unsigned)
+            ("d%s=o.longs===String?n.toString():o.longs===Number?n.toNumber():typeof BigInt!==\"undefined\"&&o.longs===BigInt?n.toBigInt():n", prop)
+        ("}else")
+            ("d%s=o.longs===String?%j:typeof BigInt!==\"undefined\"&&o.longs===BigInt?BigInt(%j):%i", prop, field.typeDefault.toString(), field.typeDefault.toString(), field.typeDefault.toNumber());
+            else if (field.bytes) {
+                var arrayDefault = Array.prototype.slice.call(field.typeDefault);
+                gen
+        ("if(o.bytes===String)d%s=%j", prop, util.base64.encode(field.typeDefault, 0, field.typeDefault.length))
+        ("else{")
+            ("d%s=%j", prop, arrayDefault)
+            ("if(o.bytes!==Array)d%s=util.newBuffer(d%s)", prop, prop)
+        ("}");
+            } else gen
+        ("d%s=%j", prop, field.typeDefault); // also messages (=null)
+        } gen
+    ("}");
+    }
+    var hasKs2 = false;
+    for (i = 0; i < fields.length; ++i) {
+        var field = fields[i],
+            index = mtype._fieldsArray.indexOf(field),
+            prop  = util.safeProp(field.name);
+        if (field.map) {
+            if (!hasKs2) { hasKs2 = true; gen
+    ("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
+        ("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)
+        ("}");
+        } else if (field.repeated) { gen
+    ("if(m%s&&m%s.length){", prop, 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]")
+        ("}");
+        } else { gen
+    ("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)")
+            ("d%s=%j", util.safeProp(field.partOf.name), field.name);
+        }
+        gen
+    ("}");
+    }
+    return gen
+    ("return d");
+    /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */
+};

package/node_modules/baileys/node_modules/protobufjs/src/decoder.js

@@ -0,0 +1,279 @@
+"use strict";
+module.exports = decoder;
+
+var Enum    = require("./enum"),
+    types   = require("./types"),
+    util    = require("./util");
+
+function missing(field) {
+    return "missing required '" + field.name + "'";
+}
+
+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
+ * @returns {Codegen} Codegen instance
+ */
+function decoder(mtype) {
+    /* eslint-disable no-unexpected-multiline */
+    var hasMapField = false,
+        needsValueVar = false,
+        i = 0;
+    for (; i < mtype.fieldsArray.length; ++i) {
+        var pfield = mtype._fieldsArray[i];
+        if (pfield.map)
+            hasMapField = 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))")
+        ("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" : needsValueVar ? ",v" : ""))
+    ("while(r.pos<c){")
+        ("var s=r.pos")
+        ("var t=r.tag()")
+        ("if(t===z){")
+            ("z=undefined")
+            ("break")
+        ("}");
+    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),
+            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");
+            if (!closed) gen
+                ("if(%s===util.emptyObject)", ref)
+                    ("%s={}", ref);
+            gen
+                ("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]);
+            else gen
+                ("v=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 === "string" ? stringMethod(field) : field.keyType)
+                            ("continue")
+                        ("case 2:")
+                            ("if(u!==%i)", types.basic[type] === undefined ? 2 : types.basic[type])
+                                ("break");
+
+            if (types.basic[type] === undefined) gen
+                            ("v=types[%i].decode(r,r.uint32(),undefined,q+1,v)", i); // can't be groups
+            else gen
+                            ("v=r.%s()", type === "string" ? stringMethod(field) : type);
+
+            gen
+                            ("continue")
+                    ("}")
+                    ("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);
+            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
+            ("case %i:", field.id)
+            ("{");
+
+            // Packable (always check for forward and backward compatiblity)
+            if (types.packed[type] !== undefined) {
+                gen
+                ("if(u===2){");
+                if (closed) {
+                    gen
+                    ("var c2=r.uint32()+r.pos")
+                    ("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
+                    ("if(!(%s&&%s.length))", ref, ref)
+                        ("%s=[]", ref)
+                    ("r.%ss(%s)", type, ref);
+                gen
+                    ("continue")
+                ("}");
+            }
+
+            // Non-packed
+            gen
+                ("if(u!==%i)", types.basic[type] === undefined ? field.delimited ? 3 : 2 : types.basic[type])
+                    ("break");
+            if (!closed) gen
+                ("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 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);
+
+        // 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");
+            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 (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 && !closed) gen
+                ("m%s=%j", util.safeProp(field.partOf.name), field.name);
+        gen
+                ("continue")
+            ("}");
+    }
+    if (i) gen
+        ("}");
+    // Unknown fields
+    gen
+        ("r.skipType(%s,q,t)", i ? "u" : "t&7");
+    genPreserveUnknown(gen, "r.raw(s,r.pos)")
+    ("}")
+    ("if(z!==undefined)")
+        ("throw Error(\"missing end group\")");
+
+    // Field presence
+    for (i = 0; i < mtype._fieldsArray.length; ++i) {
+        var rfield = mtype._fieldsArray[i];
+        if (rfield.required) gen
+    ("if(!Object.hasOwnProperty.call(m,%j))", rfield.name)
+        ("throw util.ProtocolError(%j,{instance:m})", missing(rfield));
+    }
+
+    return gen
+    ("return m");
+    /* eslint-enable no-unexpected-multiline */
+}