protobufjs 7.5.0 → 7.5.1

package/dist/minimal/protobuf.js

@@ -1,6 +1,6 @@
 /*!
- * protobuf.js v7.5.0 (c) 2016, daniel wirtz
- * compiled tue, 15 apr 2025 17:05:18 utc
+ * protobuf.js v7.5.1 (c) 2016, daniel wirtz
+ * compiled thu, 08 may 2025 17:34:56 utc
  * licensed under the bsd-3-clause license
  * see: https://github.com/dcodeio/protobuf.js for details
  */

package/dist/minimal/protobuf.min.js

@@ -1,6 +1,6 @@
 /*!
- * protobuf.js v7.5.0 (c) 2016, daniel wirtz
- * compiled tue, 15 apr 2025 17:05:18 utc
+ * protobuf.js v7.5.1 (c) 2016, daniel wirtz
+ * compiled thu, 08 may 2025 17:34:56 utc
  * licensed under the bsd-3-clause license
  * see: https://github.com/dcodeio/protobuf.js for details
  */

package/dist/protobuf.js

@@ -1,6 +1,6 @@
 /*!
- * protobuf.js v7.5.0 (c) 2016, daniel wirtz
- * compiled tue, 15 apr 2025 17:05:18 utc
+ * protobuf.js v7.5.1 (c) 2016, daniel wirtz
+ * compiled thu, 08 may 2025 17:34:56 utc
  * licensed under the bsd-3-clause license
  * see: https://github.com/dcodeio/protobuf.js for details
  */
@@ -2641,12 +2641,18 @@ Field.prototype._inferLegacyProtoFeatures = function _inferLegacyProtoFeatures(e
     }
 
     var features = {};
-    this.resolve();
+
     if (this.rule === "required") {
         features.field_presence = "LEGACY_REQUIRED";
     }
-    if (this.resolvedType instanceof Type && this.resolvedType.group) {
-        features.message_encoding = "DELIMITED";
+    if (this.parent && types.defaults[this.type] === undefined) {
+        // We can't use resolvedType because types may not have been resolved yet.  However,
+        // legacy groups are always in the same scope as the field so we don't have to do a
+        // full scan of the tree.
+        var type = this.parent.get(this.type.split(".").pop());
+        if (type && type instanceof Type && type.group) {
+            features.message_encoding = "DELIMITED";
+        }
     }
     if (this.getOption("packed") === true) {
         features.repeated_field_encoding = "PACKED";
@@ -3416,10 +3422,33 @@ function Namespace(name, options) {
      * @private
      */
     this._nestedArray = null;
+
+    /**
+     * Cache lookup calls for any objects contains anywhere under this namespace.
+     * This drastically speeds up resolve for large cross-linked protos where the same
+     * types are looked up repeatedly.
+     * @type {Object.<string,ReflectionObject|null>}
+     * @private
+     */
+    this._lookupCache = {};
+
+    /**
+     * Whether or not objects contained in this namespace need feature resolution.
+     * @type {boolean}
+     * @protected
+     */
+    this._needsRecursiveFeatureResolution = true;
 }
 
 function clearCache(namespace) {
     namespace._nestedArray = null;
+    namespace._lookupCache = {};
+
+    // Also clear parent caches, since they include nested lookups.
+    var parent = namespace;
+    while(parent = parent.parent) {
+        parent._lookupCache = {};
+    }
     return namespace;
 }
 
@@ -3557,6 +3586,14 @@ Namespace.prototype.add = function add(object) {
         }
     }
 
+    this._needsRecursiveFeatureResolution = true;
+
+    // Also clear parent caches, since they need to recurse down.
+    var parent = this;
+    while(parent = parent.parent) {
+        parent._needsRecursiveFeatureResolution = true;
+    }
+
     object.onAdd(this);
     return clearCache(this);
 };
@@ -3632,6 +3669,9 @@ Namespace.prototype.resolveAll = function resolveAll() {
  * @override
  */
 Namespace.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursive(edition) {
+    if (!this._needsRecursiveFeatureResolution) return this;
+    this._needsRecursiveFeatureResolution = false;
+
     edition = this._edition || edition;
 
     ReflectionObject.prototype._resolveFeaturesRecursive.call(this, edition);
@@ -3649,7 +3689,6 @@ Namespace.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursi
  * @returns {ReflectionObject|null} Looked up object or `null` if none could be found
  */
 Namespace.prototype.lookup = function lookup(path, filterTypes, parentAlreadyChecked) {
-
     /* istanbul ignore next */
     if (typeof filterTypes === "boolean") {
         parentAlreadyChecked = filterTypes;
@@ -3668,25 +3707,48 @@ Namespace.prototype.lookup = function lookup(path, filterTypes, parentAlreadyChe
     if (path[0] === "")
         return this.root.lookup(path.slice(1), filterTypes);
 
+    var found = this._lookupImpl(path);
+    if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {
+        return found;
+    }
+
+    // If there hasn't been a match, try again at the parent
+    if (this.parent === null || parentAlreadyChecked)
+        return null;
+    return this.parent.lookup(path, filterTypes);
+};
+
+/**
+ * Internal helper for lookup that handles searching just at this namespace and below along with caching.
+ * @param {string[]} path Path to look up
+ * @returns {ReflectionObject|null} Looked up object or `null` if none could be found
+ * @private
+ */
+Namespace.prototype._lookupImpl = function lookup(path) {
+    var flatPath = path.join(".");
+    if(Object.prototype.hasOwnProperty.call(this._lookupCache, flatPath)) {
+        return this._lookupCache[flatPath];
+    }
+
     // Test if the first part matches any nested object, and if so, traverse if path contains more
     var found = this.get(path[0]);
+    var exact = null;
     if (found) {
         if (path.length === 1) {
-            if (!filterTypes || filterTypes.indexOf(found.constructor) > -1)
-                return found;
-        } else if (found instanceof Namespace && (found = found.lookup(path.slice(1), filterTypes, true)))
-            return found;
+            exact = found;
+        } else if (found instanceof Namespace && (found = found._lookupImpl(path.slice(1))))
+            exact = found;
 
     // Otherwise try each nested namespace
-    } else
+    } else {
         for (var i = 0; i < this.nestedArray.length; ++i)
-            if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i].lookup(path, filterTypes, true)))
-                return found;
+            if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i]._lookupImpl(path)))
+                exact = found;
+    }
 
-    // If there hasn't been a match, try again at the parent
-    if (this.parent === null || parentAlreadyChecked)
-        return null;
-    return this.parent.lookup(path, filterTypes);
+    // Set this even when null, so that when we walk up the tree we can quickly bail on repeated checks back down.
+    this._lookupCache[flatPath] = exact;
+    return exact;
 };
 
 /**
@@ -3833,6 +3895,12 @@ function ReflectionObject(name, options) {
      */
     this._features = {};
 
+    /**
+     * Whether or not features have been resolved.
+     * @type {boolean}
+     */
+    this._featuresResolved = false;
+
     /**
      * Parent namespace.
      * @type {Namespace|null}
@@ -3938,10 +4006,8 @@ ReflectionObject.prototype.onRemove = function onRemove(parent) {
 ReflectionObject.prototype.resolve = function resolve() {
     if (this.resolved)
         return this;
-    if (this instanceof Root) {
-        this._resolveFeaturesRecursive(this._edition);
-        this.resolved = true;
-    }
+    if (this.root instanceof Root)
+        this.resolved = true; // only if part of a root
     return this;
 };
 
@@ -3960,6 +4026,10 @@ ReflectionObject.prototype._resolveFeaturesRecursive = function _resolveFeatures
  * @returns {undefined}
  */
 ReflectionObject.prototype._resolveFeatures = function _resolveFeatures(edition) {
+    if (this._featuresResolved) {
+        return;
+    }
+
     var defaults = {};
 
     /* istanbul ignore if */
@@ -3983,6 +4053,7 @@ ReflectionObject.prototype._resolveFeatures = function _resolveFeatures(edition)
             throw new Error("Unknown edition: " + edition);
         }
         this._features = Object.assign(defaults, protoFeatures || {});
+        this._featuresResolved = true;
         return;
     }
 
@@ -4004,6 +4075,7 @@ ReflectionObject.prototype._resolveFeatures = function _resolveFeatures(edition)
         // Sister fields should have the same features as their extensions.
         this.extensionField._features = this._features;
     }
+    this._featuresResolved = true;
 };
 
 /**
@@ -4879,6 +4951,10 @@ function parse(source, root, options) {
                     parseEnum(type, token);
                     break;
 
+                case "reserved":
+                    readRanges(type.reserved || (type.reserved = []), true);
+                    break;
+
                 /* istanbul ignore next */
                 default:
                     throw illegal(token); // there are no groups with proto3 semantics
@@ -5845,7 +5921,7 @@ Root.fromJSON = function fromJSON(json, root) {
         root = new Root();
     if (json.options)
         root.setOptions(json.options);
-    return root.addJSON(json.nested).resolveAll();
+    return root.addJSON(json.nested)._resolveFeaturesRecursive();
 };
 
 /**
@@ -5893,6 +5969,9 @@ Root.prototype.load = function load(filename, options, callback) {
 
     // Finishes loading by calling the callback (exactly once)
     function finish(err, root) {
+        if (root) {
+            root._resolveFeaturesRecursive();
+        }
         /* istanbul ignore if */
         if (!callback) {
             return;
@@ -5902,9 +5981,6 @@ Root.prototype.load = function load(filename, options, callback) {
         }
         var cb = callback;
         callback = null;
-        if (root) {
-            root.resolveAll();
-        }
         cb(err, root);
     }
 
@@ -6012,8 +6088,8 @@ Root.prototype.load = function load(filename, options, callback) {
     for (var i = 0, resolved; i < filename.length; ++i)
         if (resolved = self.resolvePath("", filename[i]))
             fetch(resolved);
-    self.resolveAll();
     if (sync) {
+        self._resolveFeaturesRecursive();
         return self;
     }
     if (!queued) {
@@ -6066,6 +6142,7 @@ Root.prototype.resolveAll = function resolveAll() {
         throw Error("unresolvable extensions: " + this.deferred.map(function(field) {
             return "'extend " + field.extend + "' in " + field.parent.fullName;
         }).join(", "));
+    this._resolveFeaturesRecursive(this._edition);
     return Namespace.prototype.resolveAll.call(this);
 };
 
@@ -6503,6 +6580,8 @@ Service.prototype.resolveAll = function resolveAll() {
  * @override
  */
 Service.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursive(edition) {
+    if (!this._needsRecursiveFeatureResolution) return this;
+
     edition = this._edition || edition;
 
     Namespace.prototype._resolveFeaturesRecursive.call(this, edition);
@@ -7304,6 +7383,8 @@ Type.prototype.resolveAll = function resolveAll() {
  * @override
  */
 Type.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursive(edition) {
+    if (!this._needsRecursiveFeatureResolution) return this;
+
     edition = this._edition || edition;
 
     Namespace.prototype._resolveFeaturesRecursive.call(this, edition);