@openclaw/whatsapp 2026.7.2-beta.7 → 2026.7.33

package/node_modules/baileys/node_modules/protobufjs/src/rpc/service.js

@@ -4,14 +4,7 @@ module.exports = Service;
 var util = require("../util/minimal");
 
 // Extends EventEmitter
-Service.prototype = Object.create(util.EventEmitter.prototype, {
-    constructor: {
-        value: Service,
-        writable: true,
-        enumerable: false,
-        configurable: true
-    }
-});
+(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;
 
 /**
  * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.
@@ -30,16 +23,10 @@ Service.prototype = Object.create(util.EventEmitter.prototype, {
  * @typedef rpc.ServiceMethod
  * @template TReq extends Message<TReq>
  * @template TRes extends Message<TRes>
- * @type {{
- *   (request: TReq|Properties<TReq>, callback: rpc.ServiceMethodCallback<TRes>): void;
- *   (request: TReq|Properties<TReq>): Promise<TRes>;
- *   readonly name: string;
- *   readonly path: string;
- *   readonly requestType: string;
- *   readonly responseType: string;
- *   readonly requestStream: true|undefined;
- *   readonly responseStream: true|undefined;
- * }}
+ * @type {function}
+ * @param {TReq|Properties<TReq>} request Request message or plain object
+ * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message
+ * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`
  */
 
 /**

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

@@ -3,15 +3,7 @@ module.exports = Service;
 
 // extends Namespace
 var Namespace = require("./namespace");
-Service.prototype = Object.create(Namespace.prototype, {
-    constructor: {
-        value: Service,
-        writable: true,
-        enumerable: false,
-        configurable: true
-    }
-});
-Service.className = "Service";
+((Service.prototype = Object.create(Namespace.prototype)).constructor = Service).className = "Service";
 
 var Method = require("./method"),
     util   = require("./util"),
@@ -47,9 +39,7 @@ function Service(name, options) {
  * Service descriptor.
  * @interface IService
  * @extends INamespace
- * @property {string} [edition] Edition
  * @property {Object.<string,IMethod>} methods Method descriptors
- * @property {string|null} [comment] Service comment
  */
 
 /**
@@ -61,10 +51,7 @@ function Service(name, options) {
  * @throws {TypeError} If arguments are invalid
  */
 Service.fromJSON = function fromJSON(name, json, depth) {
-    if (depth === undefined)
-        depth = 0;
-    if (depth > util.recursionLimit)
-        throw Error("max depth exceeded");
+    depth = util.checkDepth(depth);
     var service = new Service(name, json.options);
     /* istanbul ignore else */
     if (json.methods)

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

@@ -225,7 +225,6 @@ function tokenize(source, alternateCommentMode) {
             curr,
             start,
             isDoc,
-            nextLineIsComment,
             isLeadingComment = offset === 0;
         do {
             if (offset === length)
@@ -279,11 +278,7 @@ function tokenize(source, alternateCommentMode) {
                                     // Trailing comment cannot not be multi-line
                                     break;
                                 }
-                                nextLineIsComment = isDoubleSlashCommentLine(offset);
-                                if (nextLineIsComment) {
-                                    line++;
-                                }
-                            } while (nextLineIsComment);
+                            } while (isDoubleSlashCommentLine(offset));
                         } else {
                             offset = Math.min(length, findEndOfLine(offset) + 1);
                         }

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

@@ -3,15 +3,7 @@ module.exports = Type;
 
 // extends Namespace
 var Namespace = require("./namespace");
-Type.prototype = Object.create(Namespace.prototype, {
-    constructor: {
-        value: Type,
-        writable: true,
-        enumerable: false,
-        configurable: true
-    }
-});
-Type.className = "Type";
+((Type.prototype = Object.create(Namespace.prototype)).constructor = Type).className = "Type";
 
 var Enum      = require("./enum"),
     OneOf     = require("./oneof"),
@@ -97,13 +89,6 @@ function Type(name, options) {
      * @private
      */
     this._ctor = null;
-
-    /**
-     * Cached fields by JSON name.
-     * @type {Object.<string,Field>|null}
-     * @private
-     */
-    this._fieldsByJsonName = null; // used by ext/protojson
 }
 
 Object.defineProperties(Type.prototype, {
@@ -163,7 +148,6 @@ Object.defineProperties(Type.prototype, {
     /**
      * The registered constructor, if any registered, otherwise a generic constructor.
      * Assigning a function replaces the internal constructor. If the function does not extend {@link Message} yet, its prototype will be setup accordingly and static methods will be populated. If it already extends {@link Message}, it will just replace the internal constructor.
-     * When assigning manually, add the type to its parent namespace/root first if fields reference other reflected types, because constructor setup resolves field defaults.
      * @name Type#ctor
      * @type {Constructor<{}>}
      */
@@ -176,13 +160,7 @@ Object.defineProperties(Type.prototype, {
             // Ensure proper prototype
             var prototype = ctor.prototype;
             if (!(prototype instanceof Message)) {
-                ctor.prototype = new Message();
-                Object.defineProperty(ctor.prototype, "constructor", {
-                    value: ctor,
-                    writable: true,
-                    enumerable: false,
-                    configurable: true
-                });
+                (ctor.prototype = new Message()).constructor = ctor;
                 util.merge(ctor.prototype, prototype);
             }
 
@@ -193,15 +171,11 @@ Object.defineProperties(Type.prototype, {
             util.merge(ctor, Message, true);
 
             this._ctor = ctor;
-            delete this.decode;
-            delete this.fromObject;
 
             // Messages have non-enumerable default values on their prototype
             var i = 0;
-            for (var field; i < /* initializes */ this.fieldsArray.length; ++i) {
-                field = this._fieldsArray[i].resolve(); // ensures a proper value
-                ctor.prototype[field.name] = field.defaultValue;
-            }
+            for (; i < /* initializes */ this.fieldsArray.length; ++i)
+                this._fieldsArray[i].resolve(); // ensures a proper value
 
             // Messages have non-enumerable getters and setters for each virtual oneof field
             var ctorProperties = {};
@@ -223,7 +197,7 @@ Object.defineProperties(Type.prototype, {
  */
 Type.generateConstructor = function generateConstructor(mtype) {
     /* eslint-disable no-unexpected-multiline */
-    var gen = util.codegen(["p"]);
+    var gen = util.codegen(["p"], mtype.name);
     // explicitly initialize mutable object/array fields so that these aren't just inherited from the prototype
     for (var i = 0, field; i < mtype.fieldsArray.length; ++i)
         if ((field = mtype._fieldsArray[i]).map) gen
@@ -237,7 +211,7 @@ Type.generateConstructor = function generateConstructor(mtype) {
 };
 
 function clearCache(type) {
-    type._fieldsById = type._fieldsArray = type._oneofsArray = type._fieldsByJsonName = null;
+    type._fieldsById = type._fieldsArray = type._oneofsArray = null;
     delete type.encode;
     delete type.decode;
     delete type.verify;
@@ -248,13 +222,11 @@ function clearCache(type) {
  * Message type descriptor.
  * @interface IType
  * @extends INamespace
- * @property {string} [edition] Edition
  * @property {Object.<string,IOneOf>} [oneofs] Oneof descriptors
  * @property {Object.<string,IField>} fields Field descriptors
  * @property {number[][]} [extensions] Extension ranges
  * @property {Array.<number[]|string>} [reserved] Reserved ranges
  * @property {boolean} [group=false] Whether a legacy group or not
- * @property {string|null} [comment] Message type comment
  */
 
 /**
@@ -439,9 +411,10 @@ Type.prototype.remove = function remove(object) {
         // See Type#add for the reason why extension fields are excluded here.
 
         /* istanbul ignore if */
-        if (!util.remove(this.fields, object, object.name))
+        if (!this.fields || this.fields[object.name] !== object)
             throw Error(object + " is not a member of " + this);
 
+        delete this.fields[object.name];
         object.parent = null;
         object.onRemove(this);
         return clearCache(this);
@@ -449,9 +422,10 @@ Type.prototype.remove = function remove(object) {
     if (object instanceof OneOf) {
 
         /* istanbul ignore if */
-        if (!util.remove(this.oneofs, object, object.name))
+        if (!this.oneofs || this.oneofs[object.name] !== object)
             throw Error(object + " is not a member of " + this);
 
+        delete this.oneofs[object.name];
         object.parent = null;
         object.onRemove(this);
         return clearCache(this);
@@ -480,7 +454,7 @@ Type.prototype.isReservedName = function isReservedName(name) {
 /**
  * Creates a new message of this type using the specified properties.
  * @param {Object.<string,*>} [properties] Properties to set
- * @returns {ReflectedMessage} Message instance
+ * @returns {Message<{}>} Message instance
  */
 Type.prototype.create = function create(properties) {
     return new this.ctor(properties);
@@ -494,14 +468,6 @@ Type.prototype.setup = function setup() {
     // Sets up everything at once so that the prototype chain does not have to be re-evaluated
     // multiple times (V8, soft-deopt prototype-check).
 
-    // Resolve feature defaults incl. field presence before generating codecs
-    var root = this.root;
-    if (root && root._needsRecursiveFeatureResolution) {
-        var edition = root._edition || this._edition;
-        if (edition)
-            root._resolveFeaturesRecursive(edition);
-    }
-
     var fullName = this.fullName,
         types    = [];
     for (var i = 0; i < /* initializes */ this.fieldsArray.length; ++i)
@@ -516,8 +482,7 @@ Type.prototype.setup = function setup() {
     this.decode = decoder(this)({
         Reader : Reader,
         types  : types,
-        util   : util,
-        C      : this.ctor
+        util   : util
     });
     this.verify = verifier(this)({
         types : types,
@@ -525,8 +490,7 @@ Type.prototype.setup = function setup() {
     });
     this.fromObject = converter.fromObject(this)({
         types : types,
-        util  : util,
-        C     : this.ctor
+        util  : util
     });
     this.toObject = converter.toObject(this)({
         types : types,
@@ -536,13 +500,15 @@ Type.prototype.setup = function setup() {
     // Inject custom wrappers for common types
     var wrapper = wrappers[fullName];
     if (wrapper) {
-        var wrapperThis = Object.create(this);
-        // Reuse this type's runtime constructor in wrapper fromObject/toObject
-        wrapperThis._ctor = this.ctor;
-        wrapperThis.fromObject = this.fromObject;
-        this.fromObject = wrapper.fromObject.bind(wrapperThis);
-        wrapperThis.toObject = this.toObject;
-        this.toObject = wrapper.toObject.bind(wrapperThis);
+        var originalThis = Object.create(this);
+        // if (wrapper.fromObject) {
+            originalThis.fromObject = this.fromObject;
+            this.fromObject = wrapper.fromObject.bind(originalThis);
+        // }
+        // if (wrapper.toObject) {
+            originalThis.toObject = this.toObject;
+            this.toObject = wrapper.toObject.bind(originalThis);
+        // }
     }
 
     return this;
@@ -565,25 +531,27 @@ Type.prototype.encode = function encode_setup(message, writer) { // eslint-disab
  * @returns {Writer} writer
  */
 Type.prototype.encodeDelimited = function encodeDelimited(message, writer) {
-    return this.encode(message, (writer || Writer.create()).fork()).ldelim();
+    return this.encode(message, writer && writer.len ? writer.fork() : writer).ldelim();
 };
 
 /**
  * Decodes a message of this type.
  * @param {Reader|Uint8Array} reader Reader or buffer to decode from
  * @param {number} [length] Length of the message, if known beforehand
- * @returns {ReflectedMessage} Decoded message
+ * @param {number} [end] Expected group end tag, if decoding a group
+ * @param {number} [depth] Current nesting depth
+ * @returns {Message<{}>} Decoded message
  * @throws {Error} If the payload is not a reader or valid buffer
  * @throws {util.ProtocolError<{}>} If required fields are missing
  */
-Type.prototype.decode = function decode_setup(reader, length) { // eslint-disable-line no-unused-vars
-    return this.setup().decode.apply(this, arguments); // overrides this method
+Type.prototype.decode = function decode_setup(reader, length, end, depth) {
+    return this.setup().decode(reader, length, end, depth); // overrides this method
 };
 
 /**
  * Decodes a message of this type preceeded by its byte length as a varint.
  * @param {Reader|Uint8Array} reader Reader or buffer to decode from
- * @returns {ReflectedMessage} Decoded message
+ * @returns {Message<{}>} Decoded message
  * @throws {Error} If the payload is not a reader or valid buffer
  * @throws {util.ProtocolError} If required fields are missing
  */
@@ -596,19 +564,21 @@ Type.prototype.decodeDelimited = function decodeDelimited(reader) {
 /**
  * Verifies that field values are valid and that required fields are present.
  * @param {Object.<string,*>} message Plain object to verify
+ * @param {number} [depth] Current nesting depth
  * @returns {null|string} `null` if valid, otherwise the reason why it is not
  */
-Type.prototype.verify = function verify_setup(message) { // eslint-disable-line no-unused-vars
-    return this.setup().verify.apply(this, arguments); // overrides this method
+Type.prototype.verify = function verify_setup(message, depth) {
+    return this.setup().verify(message, depth); // overrides this method
 };
 
 /**
  * Creates a new message of this type from a plain object. Also converts values to their respective internal types.
  * @param {Object.<string,*>} object Plain object to convert
- * @returns {ReflectedMessage} Message instance
+ * @param {number} [depth] Current nesting depth
+ * @returns {Message<{}>} Message instance
  */
-Type.prototype.fromObject = function fromObject(object) { // eslint-disable-line no-unused-vars
-    return this.setup().fromObject.apply(this, arguments);
+Type.prototype.fromObject = function fromObject(object, depth) {
+    return this.setup().fromObject(object, depth);
 };
 
 /**
@@ -640,18 +610,6 @@ Type.prototype.toObject = function toObject(message, options) { // eslint-disabl
     return this.setup().toObject.apply(this, arguments);
 };
 
-/**
- * Gets the type url for this type.
- * @param {string} [prefix] Custom type url prefix, defaults to `"type.googleapis.com"`
- * @returns {string} The type url
- */
-Type.prototype.getTypeUrl = function getTypeUrl(prefix) {
-    if (prefix === undefined)
-        prefix = "type.googleapis.com";
-    var fullName = this.fullName;
-    return prefix + "/" + (fullName.charAt(0) === "." ? fullName.substring(1) : fullName);
-};
-
 /**
  * Decorator function as returned by {@link Type.d} (TypeScript).
  * @typedef TypeDecorator
@@ -659,7 +617,6 @@ Type.prototype.getTypeUrl = function getTypeUrl(prefix) {
  * @param {Constructor<T>} target Target constructor
  * @returns {undefined}
  * @template T extends Message<T>
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 
 /**
@@ -667,7 +624,6 @@ Type.prototype.getTypeUrl = function getTypeUrl(prefix) {
  * @param {string} [typeName] Type name, defaults to the constructor's name
  * @returns {TypeDecorator<T>} Decorator function
  * @template T extends Message<T>
- * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.
  */
 Type.d = function decorateType(typeName) {
     return function typeDecorator(target) {

package/node_modules/baileys/node_modules/protobufjs/src/typescript.jsdoc

@@ -0,0 +1,15 @@
+/**
+ * Constructor type.
+ * @interface Constructor
+ * @extends Function
+ * @template T
+ * @tstype new(...params: any[]): T; prototype: T;
+ */
+
+/**
+ * Properties type.
+ * @typedef Properties
+ * @template T
+ * @type {Object.<string,*>}
+ * @tstype { [P in keyof T]?: T[P] }
+ */

package/node_modules/baileys/node_modules/protobufjs/src/util/longbits.js

@@ -1,7 +1,7 @@
 "use strict";
 module.exports = LongBits;
 
-var Long;
+var util = require("../util/minimal");
 
 /**
  * Constructs new long bits.
@@ -80,10 +80,10 @@ LongBits.fromNumber = function fromNumber(value) {
 LongBits.from = function from(value) {
     if (typeof value === "number")
         return LongBits.fromNumber(value);
-    if (typeof value === "string" || value instanceof String) {
+    if (util.isString(value)) {
         /* istanbul ignore else */
-        if (Long)
-            value = Long.fromString(value);
+        if (util.Long)
+            value = util.Long.fromString(value);
         else
             return LongBits.fromNumber(parseInt(value, 10));
     }
@@ -112,8 +112,8 @@ LongBits.prototype.toNumber = function toNumber(unsigned) {
  * @returns {Long} Long
  */
 LongBits.prototype.toLong = function toLong(unsigned) {
-    return Long
-        ? new Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
+    return util.Long
+        ? new util.Long(this.lo | 0, this.hi | 0, Boolean(unsigned))
         /* istanbul ignore next */
         : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };
 };
@@ -198,7 +198,3 @@ LongBits.prototype.length = function length() {
              : part1 < 2097152 ? 7 : 8
          : part2 < 128 ? 9 : 10;
 };
-
-LongBits._configure = function(Long_) {
-    Long = Long_;
-};

package/node_modules/baileys/node_modules/protobufjs/src/util/minimal.js

@@ -1,24 +1,26 @@
 "use strict";
-/* global globalThis */
 var util = exports;
 
 // used to return a Promise where callback is omitted
-util.asPromise = require("./aspromise");
+util.asPromise = require("@protobufjs/aspromise");
 
 // converts to / from base64 encoded strings
-util.base64 = require("./base64");
+util.base64 = require("@protobufjs/base64");
 
 // base class of rpc.Service
-util.EventEmitter = require("./eventemitter");
+util.EventEmitter = require("@protobufjs/eventemitter");
 
 // float handling accross browsers
-util.float = require("./float");
+util.float = require("@protobufjs/float");
+
+// requires modules optionally and hides the call from bundlers
+util.inquire = require("@protobufjs/inquire");
 
 // converts to / from utf8 encoded strings
-util.utf8 = require("./utf8");
+util.utf8 = require("@protobufjs/utf8");
 
 // provides a node-like buffer pool in the browser
-util.pool = require("./pool");
+util.pool = require("@protobufjs/pool");
 
 // utility to work with the low and high bits of a 64 bit value
 util.LongBits = require("./longbits");
@@ -54,7 +56,6 @@ 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
 
 /**
@@ -137,59 +138,43 @@ util.isSet = function isSet(obj, prop) {
 util.Buffer = (function() {
     try {
         var Buffer = util.global.Buffer;
-        // refuse to use non-node buffers if not explicitly assigned (perf reasons)
-        return Buffer.prototype.utf8Write || util.isNode ? Buffer : /* istanbul ignore next */ null;
+        // refuse to use non-node buffers if not explicitly assigned (perf reasons):
+        return Buffer.prototype.utf8Write ? Buffer : /* istanbul ignore next */ null;
     } catch (e) {
         /* istanbul ignore next */
         return null;
     }
 })();
 
+// Internal alias of or polyfull for Buffer.from.
+util._Buffer_from = null;
+
+// Internal alias of or polyfill for Buffer.allocUnsafe.
+util._Buffer_allocUnsafe = null;
+
 /**
  * Creates a new buffer of whatever type supported by the environment.
  * @param {number|number[]} [sizeOrArray=0] Buffer size or number array
  * @returns {Uint8Array|Buffer} Buffer
  */
 util.newBuffer = function newBuffer(sizeOrArray) {
-    var Buffer = util.Buffer;
     /* istanbul ignore next */
     return typeof sizeOrArray === "number"
-        ? Buffer
-            ? Buffer.allocUnsafe(sizeOrArray)
-            : new Uint8Array(sizeOrArray)
-        : Buffer
-            ? Buffer.from(sizeOrArray)
-            : new Uint8Array(sizeOrArray);
+        ? util.Buffer
+            ? util._Buffer_allocUnsafe(sizeOrArray)
+            : new util.Array(sizeOrArray)
+        : util.Buffer
+            ? util._Buffer_from(sizeOrArray)
+            : typeof Uint8Array === "undefined"
+                ? 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.
+ * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.
  * @type {Constructor<Uint8Array>}
- * @deprecated Use `Uint8Array` instead.
  */
-util.Array = Uint8Array;
+util.Array = typeof Uint8Array !== "undefined" ? Uint8Array /* istanbul ignore next */ : Array;
 
 /**
  * Any compatible Long instance.
@@ -221,7 +206,7 @@ util.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore
  * @type {RegExp}
  * @const
  */
-util.key2Re = /^(?:true|false|0|1)$/;
+util.key2Re = /^true|false|0|1$/;
 
 /**
  * Regular expression used to verify 32 bit (`int32` etc.) map keys.
@@ -235,7 +220,7 @@ util.key32Re = /^-?(?:0|[1-9][0-9]*)$/;
  * @type {RegExp}
  * @const
  */
-util.key64Re = /^(?:[\x00-\xff]{8}|-?(?:0|[1-9][0-9]*))$/; // eslint-disable-line no-control-regex
+util.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/;
 
 /**
  * Converts a number or long to an 8 characters long hash string.
@@ -261,27 +246,6 @@ util.longFromHash = function longFromHash(hash, unsigned) {
     return bits.toNumber(Boolean(unsigned));
 };
 
-/**
- * Converts a 64 bit key to a long or number if it is an 8 characters long hash string.
- * @param {string} key Map key
- * @param {boolean} [unsigned=false] Whether unsigned or not
- * @returns {Long|number|string} Original value
- */
-util.longFromKey = function longFromKey(key, unsigned) {
-    return util.key64Re.test(key) && !util.key32Re.test(key)
-        ? util.longFromHash(key, unsigned)
-        : key;
-};
-
-/**
- * Converts a boolean key to a boolean value.
- * @param {string} key Map key
- * @returns {boolean} Boolean value
- */
-util.boolFromKey = function boolFromKey(key) {
-    return key === "true" || key === "1";
-};
-
 /**
  * Merges the properties of the source object into the destination object.
  * @memberof util
@@ -298,7 +262,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]) && (!ifNotSet || !Object.prototype.hasOwnProperty.call(dst, keys[i]) || dst[keys[i]] === undefined))
+            if (!isUnsafeProperty(keys[i]) && (dst[keys[i]] === undefined || !ifNotSet))
                 dst[keys[i]] = src[keys[i]];
     }
     return dst;
@@ -325,14 +289,11 @@ util.recursionLimit = 100; // protoc: CodedInputStream::default_recursion_limit_
  * @memberof util
  * @param {Object.<string,*>} obj Object
  * @param {string} key Property key
- * @param {boolean} [enumerable=true] Whether the property should be enumerable
  * @returns {undefined}
  */
-util.makeProp = function makeProp(obj, key, enumerable) {
-    if (Object.prototype.hasOwnProperty.call(obj, key))
-        return;
+util.makeProp = function makeProp(obj, key) {
     Object.defineProperty(obj, key, {
-        enumerable: enumerable === undefined ? true : enumerable,
+        enumerable: true,
         configurable: true,
         writable: true
     });
@@ -509,3 +470,25 @@ util.toJSONOptions = {
     bytes: String,
     json: true
 };
+
+// Sets up buffer utility according to the environment (called in index-minimal)
+util._configure = function() {
+    var Buffer = util.Buffer;
+    /* istanbul ignore if */
+    if (!Buffer) {
+        util._Buffer_from = util._Buffer_allocUnsafe = null;
+        return;
+    }
+    // because node 4.x buffers are incompatible & immutable
+    // see: https://github.com/dcodeIO/protobuf.js/pull/665
+    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||
+        /* istanbul ignore next */
+        function Buffer_from(value, encoding) {
+            return new Buffer(value, encoding);
+        };
+    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||
+        /* istanbul ignore next */
+        function Buffer_allocUnsafe(size) {
+            return new Buffer(size);
+        };
+};