protobufjs 8.7.2 → 8.8.1

package/ext/descriptor.generated.d.ts

@@ -215,6 +215,9 @@ export interface IDescriptorProto {
 
     /** Reserved names */
     reservedName?: string[];
+
+    /** Declared symbol visibility */
+    visibility?: number;
 }
 
 /** Properties of a MessageOptions message. */
@@ -311,6 +314,9 @@ export interface IEnumDescriptorProto {
 
     /** Enum options */
     options?: IEnumOptions;
+
+    /** Declared symbol visibility */
+    visibility?: number;
 }
 
 /** Properties of an EnumValueDescriptorProto message. */
@@ -353,6 +359,7 @@ export interface IFeatureSet {
     jsonFormat?: number;
     enforceNamingStyle?: number;
     defaultSymbolVisibility?: number;
+    enforceProtoLimits?: number;
 }
 
 /** Properties of a OneofDescriptorProto message. */

package/ext/descriptor.js

@@ -1,6 +1,7 @@
 "use strict";
 var $protobuf = require("../light");
 module.exports = exports = $protobuf.descriptor = $protobuf.Root.fromJSON(require("../google/protobuf/descriptor.json")).lookup(".google.protobuf");
+exports.root.define("pb").addJSON(require("../google/protobuf/json_enumvalue_options.json").nested.pb.nested);
 
 var Namespace = $protobuf.Namespace,
     Root      = $protobuf.Root,
@@ -52,6 +53,7 @@ var integerRe = /^[+-]?[0-9]+$/,
  * @property {number} EDITION_PROTO3=999
  * @property {number} EDITION_2023=1000
  * @property {number} EDITION_2024=1001
+ * @property {number} EDITION_2026=1002
  * @property {number} EDITION_1_TEST_ONLY=1
  * @property {number} EDITION_2_TEST_ONLY=2
  * @property {number} EDITION_99997_TEST_ONLY=99997
@@ -208,6 +210,7 @@ function Root_toDescriptorRecursive(ns, files, edition) {
  * @property {IMessageOptions} [options] Not supported
  * @property {IDescriptorProtoReservedRange[]} [reservedRange] Reserved ranges
  * @property {string[]} [reservedName] Reserved names
+ * @property {number} [visibility] Declared symbol visibility
  */
 
 /**
@@ -252,6 +255,7 @@ function Type_fromDescriptor(descriptor, ctx, nested, depth) {
     var type = new Type(descriptor.name.length ? descriptor.name : "Type" + unnamedMessageIndex++, fromDescriptorOptions(descriptor.options, exports.MessageOptions)),
         i,
         mapEntries = Object.create(null);
+    type.visibility = visibilityFromDescriptor(descriptor.visibility);
 
     if (!nested) {
         type._edition = ctx.edition;
@@ -317,6 +321,9 @@ Type.prototype.toDescriptor = function toDescriptor(edition) {
     var descriptor = exports.DescriptorProto.create({ name: this.name }),
         i;
 
+    if (this.visibility)
+        descriptor.visibility = visibilityToDescriptor(this.visibility);
+
     /* Fields */ for (i = 0; i < this.fieldsArray.length; ++i) {
         var fieldDescriptor;
         descriptor.field.push(fieldDescriptor = this._fieldsArray[i].toDescriptor(edition));
@@ -655,6 +662,7 @@ Field.prototype.toDescriptor = function toDescriptor(edition) {
  * @property {string} [name] Enum name
  * @property {IEnumValueDescriptorProto[]} [value] Enum values
  * @property {IEnumOptions} [options] Enum options
+ * @property {number} [visibility] Declared symbol visibility
  */
 
 /**
@@ -693,6 +701,7 @@ Field.prototype.toDescriptor = function toDescriptor(edition) {
  * @property {number} [jsonFormat]
  * @property {number} [enforceNamingStyle]
  * @property {number} [defaultSymbolVisibility]
+ * @property {number} [enforceProtoLimits]
  */
 
 var unnamedEnumIndex = 0;
@@ -735,6 +744,7 @@ function Enum_fromDescriptor(descriptor, ctx, nested) {
         undefined,
         valuesOptions
     );
+    enm.visibility = visibilityFromDescriptor(descriptor.visibility);
 
     if (!nested) {
         enm._edition = ctx.edition;
@@ -776,6 +786,8 @@ Enum.prototype.toDescriptor = function toDescriptor() {
         value: values,
         options: toDescriptorOptions(this.options, exports.EnumOptions)
     });
+    if (this.visibility)
+        descriptor.visibility = visibilityToDescriptor(this.visibility);
 
     /* Reserved... */ if (this.reserved)
         for (i = 0; i < this.reserved.length; ++i)
@@ -1000,6 +1012,14 @@ function applyContextFeatures(object, ctx) {
     return object;
 }
 
+function visibilityFromDescriptor(visibility) {
+    return visibility === 1 ? "local" : visibility === 2 ? "export" : undefined;
+}
+
+function visibilityToDescriptor(visibility) {
+    return visibility === "local" ? 1 : visibility === "export" ? 2 : 0;
+}
+
 // Converts a descriptor type to a protobuf.js basic type
 function fromDescriptorType(type) {
     switch (type) {
@@ -1072,6 +1092,10 @@ function fromDescriptorOptionsRecursive(obj, type) {
         if ((key = (field = type._fieldsArray[i]).name) === "uninterpretedOption") continue;
         if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
 
+        if (key === ".pb.enumvalue.json") {
+            val["(pb.enumvalue.json).string"] = obj[key].string === undefined ? "" : obj[key].string;
+            continue;
+        }
         var newKey = underScore(key);
         if (field.resolvedType instanceof Type) {
             val[newKey] = fromDescriptorOptionsRecursive(obj[key], field.resolvedType);
@@ -1096,6 +1120,10 @@ function toDescriptorOptionsRecursive(obj, type) {
     var keys = Object.keys(obj);
     for (var i = 0; i < keys.length; ++i) {
         var key = keys[i];
+        if (type === exports.EnumValueOptions && key === "(pb.enumvalue.json).string") {
+            val[".pb.enumvalue.json"] = { string: obj[key] };
+            continue;
+        }
         var newKey = $protobuf.util.camelCase(key);
         if (!Object.prototype.hasOwnProperty.call(type.fields, newKey)) continue;
         var field = type.fields[newKey];
@@ -1158,6 +1186,8 @@ function editionFromDescriptor(fileDescriptor) {
                 return "2023";
             case exports.Edition.EDITION_2024:
                 return "2024";
+            case exports.Edition.EDITION_2026:
+                return "2026";
             default:
                 throw new Error("Unsupported edition " + fileDescriptor.edition);
         }
@@ -1181,6 +1211,9 @@ function editionToDescriptor(edition, fileDescriptor) {
             case "2024":
                 fileDescriptor.edition = exports.Edition.EDITION_2024;
                 break;
+            case "2026":
+                fileDescriptor.edition = exports.Edition.EDITION_2026;
+                break;
             default:
                 throw new Error("Unsupported edition " + edition);
         }

package/ext/protojson.js

@@ -91,6 +91,15 @@ function invalid(name, value, what) {
     return Error(name + ": " + what + ": " + JSON.stringify(value));
 }
 
+function normalizeIntegerString(str, name, what) {
+    str = str.replace(/^\+/, "").replace(/^(-?)0+(?=\d)/, "$1");
+    if (str === "-0")
+        str = "0";
+    if (str.length > 20) // max uint64 and min int64
+        throw Error(name + ": out of range for " + what);
+    return str;
+}
+
 function parseIntegerString(value, type, name) {
     var str;
     if (typeof value === "number") {
@@ -113,6 +122,7 @@ function parseIntegerString(value, type, name) {
         throw invalid(name, value, "expected integer (number or string)");
 
     var range = INT_RANGE[type];
+    str = normalizeIntegerString(str, name, type);
     if (LONG_TYPE[type]) {
         if (hasBigInt) {
             var big = BigInt(str);
@@ -128,17 +138,17 @@ function parseMapIntegerKey(key, type, name) {
     var unsigned = type === "uint32" || type === "fixed32" || type === "uint64" || type === "fixed64";
     if (!(unsigned ? /^[0-9]+$/ : /^-?[0-9]+$/).test(key))
         throw invalid(name, key, "invalid " + type + " map key");
+    var range = INT_RANGE[type];
+    key = normalizeIntegerString(key, name, type + " map key");
     if (hasBigInt) {
-        var big = BigInt(key),
-            range = INT_RANGE[type];
+        var big = BigInt(key);
         if (big < BigInt(range[0]) || big > BigInt(range[1]))
             throw invalid(name, key, "out of range for " + type + " map key");
         return big.toString();
     }
     parseIntegerString(key, type, name);
     if (LONG_TYPE[type]) {
-        var normalized = key.replace(/^-?0+(?=\d)/, key.charAt(0) === "-" ? "-" : "");
-        return normalized === "-0" ? "0" : normalized;
+        return key;
     }
     return String(Number(key));
 }
@@ -231,11 +241,19 @@ function readScalar(type, value, name) {
     }
 }
 
+function enumJsonName(enm, name) {
+    var options = hasOwn(enm.valuesOptions, name) && enm.valuesOptions[name];
+    return hasOwn(options, "(pb.enumvalue.json).string") ? options["(pb.enumvalue.json).string"] : undefined;
+}
+
 function readEnum(enm, value, name, options) {
     if (typeof value === "string") {
-        var num = enm.values[value];
-        if (num !== undefined)
-            return num;
+        if (hasOwn(enm.values, value))
+            return enm.values[value];
+        if (enm.valuesOptions)
+            for (var names = Object.keys(enm.valuesOptions), i = 0; i < names.length; ++i)
+                if (hasOwn(enm.values, names[i]) && enumJsonName(enm, names[i]) === value)
+                    return enm.values[names[i]];
         if (options.ignoreUnknownFields)
             return SKIP;
         throw invalid(name, value, "unknown enum value");
@@ -438,7 +456,10 @@ function writeSingular(field, value, options, depth) {
         if (field.resolvedType.fullName === ".google.protobuf.NullValue")
             return null;
         var name = field.resolvedType.valuesById[value];
-        return name === undefined ? value : name;
+        if (name === undefined)
+            return value;
+        var jsonName = enumJsonName(field.resolvedType, name);
+        return jsonName === undefined ? name : jsonName;
     }
     return writeScalar(field.type, value);
 }

package/ext/textformat.js

@@ -586,14 +586,14 @@ Parser.prototype.parseScalar = function parseScalar(field) {
 };
 
 Parser.prototype.readStringBytes = function readStringBytes() {
-    var token = this.tn.next(),
-        bytes = [];
+    var token = this.tn.next();
     if (!token || token.type !== "string")
         this.error("expected string");
-    Array.prototype.push.apply(bytes, token.value);
+    var bytes = token.value;
     while ((token = this.tn.peek()) && token.type === "string") {
         token = this.tn.next();
-        Array.prototype.push.apply(bytes, token.value);
+        for (var i = 0; i < token.value.length; ++i)
+            bytes.push(token.value[i]);
     }
     return bytes;
 };
@@ -842,6 +842,10 @@ function parseInteger(token, sign, unsigned, bits) {
     } else if (!/^(?:0|[1-9][0-9]*)$/.test(raw))
         throw Error("integer value expected");
 
+    digits = digits.replace(/^0+(?=.)/, "");
+    if (digits.length > Math.ceil(bits / 3)) // 3 bits per octal digit
+        throw Error((unsigned ? "unsigned " : "") + "integer value out of range");
+
     if (typeof util.global.BigInt === "function")
         return parseIntegerBigInt(digits, radix, sign, unsigned, bits);
 

package/google/protobuf/descriptor.json

@@ -29,6 +29,7 @@
                 "EDITION_PROTO3": 999,
                 "EDITION_2023": 1000,
                 "EDITION_2024": 1001,
+                "EDITION_2026": 1002,
                 "EDITION_1_TEST_ONLY": 1,
                 "EDITION_2_TEST_ONLY": 2,
                 "EDITION_99997_TEST_ONLY": 99997,
@@ -970,6 +971,10 @@
                 }
               },
               "extensions": [
+                [
+                  990,
+                  998
+                ],
                 [
                   1000,
                   536870911
@@ -1199,6 +1204,11 @@
                     "edition_defaults.edition": "EDITION_2024",
                     "edition_defaults.value": "EXPORT_TOP_LEVEL"
                   }
+                },
+                "enforceProtoLimits": {
+                  "type": "ProtoLimitsFeature.EnforceProtoLimits",
+                  "id": 9,
+                  "protoName": "enforce_proto_limits"
                 }
               },
               "extensions": [
@@ -1269,7 +1279,8 @@
                   "values": {
                     "ENFORCE_NAMING_STYLE_UNKNOWN": 0,
                     "STYLE2024": 1,
-                    "STYLE_LEGACY": 2
+                    "STYLE_LEGACY": 2,
+                    "STYLE2026": 3
                   }
                 },
                 "VisibilityFeature": {
@@ -1291,6 +1302,18 @@
                       }
                     }
                   }
+                },
+                "ProtoLimitsFeature": {
+                  "fields": {},
+                  "nested": {
+                    "EnforceProtoLimits": {
+                      "values": {
+                        "PROTO_LIMITS_UNKNOWN": 0,
+                        "LEGACY_NO_EXPLICIT_LIMITS": 1,
+                        "PROTO_LIMITS2026": 2
+                      }
+                    }
+                  }
                 }
               }
             },

package/google/protobuf/descriptor.proto

@@ -17,6 +17,7 @@ enum Edition {
     EDITION_PROTO3 = 999;
     EDITION_2023 = 1000;
     EDITION_2024 = 1001;
+    EDITION_2026 = 1002;
     EDITION_1_TEST_ONLY = 1;
     EDITION_2_TEST_ONLY = 2;
     EDITION_99997_TEST_ONLY = 99997;
@@ -340,6 +341,7 @@ message EnumValueOptions {
     optional FieldOptions.FeatureSupport feature_support = 4;
     repeated UninterpretedOption uninterpreted_option = 999;
 
+    extensions 990 to 998;
     extensions 1000 to max;
 }
 
@@ -396,6 +398,7 @@ message FeatureSet {
     optional JsonFormat json_format = 6 [retention="RETENTION_RUNTIME", targets="TARGET_TYPE_FILE", feature_support.edition_introduced="EDITION_2023", edition_defaults.edition="EDITION_PROTO3", edition_defaults.value="ALLOW"];
     optional EnforceNamingStyle enforce_naming_style = 7 [retention="RETENTION_SOURCE", targets="TARGET_TYPE_METHOD", feature_support.edition_introduced="EDITION_2024", edition_defaults.edition="EDITION_2024", edition_defaults.value="STYLE2024"];
     optional VisibilityFeature.DefaultSymbolVisibility default_symbol_visibility = 8 [retention="RETENTION_SOURCE", targets="TARGET_TYPE_FILE", feature_support.edition_introduced="EDITION_2024", edition_defaults.edition="EDITION_2024", edition_defaults.value="EXPORT_TOP_LEVEL"];
+    optional ProtoLimitsFeature.EnforceProtoLimits enforce_proto_limits = 9;
 
     enum FieldPresence {
 
@@ -445,6 +448,7 @@ message FeatureSet {
         ENFORCE_NAMING_STYLE_UNKNOWN = 0;
         STYLE2024 = 1;
         STYLE_LEGACY = 2;
+        STYLE2026 = 3;
     }
 
     message VisibilityFeature {
@@ -461,6 +465,16 @@ message FeatureSet {
         reserved 1 to max;
     }
 
+    message ProtoLimitsFeature {
+
+        enum EnforceProtoLimits {
+
+            PROTO_LIMITS_UNKNOWN = 0;
+            LEGACY_NO_EXPLICIT_LIMITS = 1;
+            PROTO_LIMITS2026 = 2;
+        }
+    }
+
     extensions 1000 to 9994, 9995 to 9999, 10000;
 
     reserved 999;
@@ -524,4 +538,4 @@ enum SymbolVisibility {
     VISIBILITY_UNSET = 0;
     VISIBILITY_LOCAL = 1;
     VISIBILITY_EXPORT = 2;
-}
+}

package/google/protobuf/json_enumvalue_options.json

@@ -0,0 +1,56 @@
+{
+  "nested": {
+    "pb": {
+      "nested": {
+        "enumvalue": {
+          "options": {
+            "java_package": "com.google.protobuf.util"
+          },
+          "nested": {
+            "JsonEnumValueOptions": {
+              "edition": "2024",
+              "fields": {
+                "string": {
+                  "type": "string",
+                  "id": 1
+                }
+              },
+              "visibility": "local"
+            },
+            "json": {
+              "edition": "2024",
+              "type": "JsonEnumValueOptions",
+              "id": 998,
+              "extend": "google.protobuf.EnumValueOptions",
+              "options": {
+                "feature_support.edition_introduced": "EDITION_2026"
+              }
+            }
+          }
+        }
+      }
+    },
+    "google": {
+      "nested": {
+        "protobuf": {
+          "nested": {
+            "EnumValueOptions": {
+              "edition": "proto2",
+              "fields": {},
+              "extensions": [
+                [
+                  990,
+                  998
+                ],
+                [
+                  1000,
+                  536870911
+                ]
+              ]
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/google/protobuf/json_enumvalue_options.proto

@@ -0,0 +1,31 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2026 Google LLC.  All rights reserved.
+//
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file or at
+// https://developers.google.com/open-source/licenses/bsd
+
+edition = "2024";
+
+package pb.enumvalue;
+
+import "google/protobuf/descriptor.proto";
+
+option java_package = "com.google.protobuf.util";
+
+local message JsonEnumValueOptions {
+  // Allows user to specify a custom string to use when serializing an enum
+  // value to JSON.
+  //
+  // Sample usage:
+  // enum Foo {
+  //   ...
+  //   FOO_BAR = 42 [(pb.enumvalue.json).string = "my_custom_name"];
+  // }
+  string string = 1;
+}
+
+extend google.protobuf.EnumValueOptions {
+  JsonEnumValueOptions json = 998
+      [feature_support = { edition_introduced: EDITION_2026 }];
+}

package/index.d.ts

@@ -190,6 +190,9 @@ export class Enum extends ReflectionObject {
     /** Reserved ranges, if any. */
     reserved: (number[]|string)[];
 
+    /** Declared symbol visibility, if any. */
+    visibility?: ("local"|"export");
+
     /**
      * Constructs an enum from an enum descriptor.
      * @param name Enum name
@@ -260,6 +263,9 @@ export interface IEnum {
     /** Reserved ranges */
     reserved?: (number[]|string)[];
 
+    /** Declared symbol visibility */
+    visibility?: ("local"|"export");
+
     /** Enum comment */
     comment?: (string|null);
 
@@ -1264,6 +1270,12 @@ export class Reader {
      */
     tag(): number;
 
+    /**
+     * Reads a varint length prefix within signed 32 bit range.
+     * @returns Length read
+     */
+    size(): number;
+
     /**
      * Reads a varint as a signed 32 bit value.
      * @returns Value read
@@ -1804,6 +1816,9 @@ export class Type extends NamespaceBase {
     /** Reserved ranges, if any. */
     reserved: (number[]|string)[];
 
+    /** Declared symbol visibility, if any. */
+    visibility?: ("local"|"export");
+
     /** Message fields by id. */
     readonly fieldsById: { [k: number]: Field };
 
@@ -1982,6 +1997,9 @@ export interface IType extends INamespace {
     /** Whether a legacy group or not */
     group?: boolean;
 
+    /** Declared symbol visibility */
+    visibility?: ("local"|"export");
+
     /** Message type comment */
     comment?: (string|null);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "protobufjs",
-  "version": "8.7.2",
+  "version": "8.8.1",
   "description": "Protocol Buffers for JavaScript & TypeScript.",
   "author": "Daniel Wirtz <dcode+protobufjs@dcode.io>",
   "license": "BSD-3-Clause",

package/src/decoder.js

@@ -46,7 +46,17 @@ 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" : needsValueVar ? ",v" : ""))
+    ("var c,m" + (hasMapField ? ",k,v" : needsValueVar ? ",v" : ""))
+    ("if(l===undefined)")
+        ("c=r.len")
+    ("else{")
+        ("c=r.pos+l")
+        ("if(c>r.len)")
+            ("throw RangeError(\"index out of range\")")
+        ("l=r.len")
+        ("r.len=c")
+    ("}")
+    ("m=g||new C")
     ("while(r.pos<c){")
         ("var s=r.pos")
         ("var t=r.tag()")
@@ -73,7 +83,10 @@ function decoder(mtype) {
                 ("if(%s===util.emptyObject)", ref)
                     ("%s={}", ref);
             gen
-                ("var c2=r.uint32()+r.pos");
+                ("var c2=r.size()+r.pos")
+                ("if(c2>r.len)")
+                    ("throw RangeError(\"index out of range\")")
+                ("r.len=c2");
 
             if (types.defaults[field.keyType] !== undefined) gen
                 ("k=%j", types.defaults[field.keyType]);
@@ -102,7 +115,7 @@ function decoder(mtype) {
                                 ("break");
 
             if (types.basic[type] === undefined) gen
-                            ("v=types[%i].decode(r,r.uint32(),undefined,q+1,v)", i); // can't be groups
+                            ("v=types[%i].decode(r,r.size(),undefined,q+1,v)", i); // can't be groups
             else gen
                             ("v=r.%s()", type === "string" ? stringMethod(field) : type);
 
@@ -111,6 +124,10 @@ function decoder(mtype) {
                     ("}")
                     ("r.skipType(u,q,t2)")
                 ("}");
+            gen
+                ("if(r.pos!==c2)")
+                    ("throw RangeError(\"index out of range\")")
+                ("r.len=c");
 
             if (closed) { gen
                 ("if(types[%i].valuesById[v]===undefined){", i);
@@ -143,7 +160,10 @@ function decoder(mtype) {
                 ("if(u===2){");
                 if (closed) {
                     gen
-                    ("var c2=r.uint32()+r.pos")
+                    ("var c2=r.size()+r.pos")
+                    ("if(c2>r.len)")
+                        ("throw RangeError(\"index out of range\")")
+                    ("r.len=c2")
                     ("while(r.pos<c2){")
                         ("s=r.pos")
                         ("v=r.%s()", type)
@@ -154,6 +174,10 @@ function decoder(mtype) {
                         ("}else");
                             genPreserveUnknown(gen, "util.rawField(" + field.id + ",0,r.raw(s,r.pos))")
                     ("}");
+                    gen
+                    ("if(r.pos!==c2)")
+                        ("throw RangeError(\"index out of range\")")
+                    ("r.len=c");
                 } else gen
                     ("if(!(%s&&%s.length))", ref, ref)
                         ("%s=[]", ref)
@@ -174,7 +198,7 @@ function decoder(mtype) {
                 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);
+                    ("%s.push(types[%i].decode(r,r.size(),undefined,q+1))", ref, i);
             } else if (closed) { gen
                     ("v=r.%s()", type)
                     ("if(types[%i].valuesById[v]!==undefined){", i)
@@ -195,7 +219,7 @@ function decoder(mtype) {
             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);
+                ("%s=types[%i].decode(r,r.size(),undefined,q+1,%s)", ref, i, ref);
         }
         else if (field.hasPresence) {
             gen
@@ -262,6 +286,11 @@ function decoder(mtype) {
         ("r.skipType(%s,q,t)", i ? "u" : "t&7");
     genPreserveUnknown(gen, "r.raw(s,r.pos)")
     ("}")
+    ("if(l!==undefined){")
+        ("if(r.pos!==c)")
+            ("throw RangeError(\"index out of range\")")
+        ("r.len=l")
+    ("}")
     ("if(z!==undefined)")
         ("throw Error(\"missing end group\")");
 

package/src/enum.js

@@ -76,6 +76,12 @@ function Enum(name, values, options, comment, comments, valuesOptions) {
      */
     this.reserved = undefined; // toJSON
 
+    /**
+     * Declared symbol visibility, if any.
+     * @type {"local"|"export"|undefined}
+     */
+    this.visibility = undefined; // toJSON
+
     // Note that values inherit valuesById on their prototype which makes them a TypeScript-
     // compatible enum. This is used by pbts to write actual enum definitions that work for
     // static and reflection code alike instead of emitting generic object definitions.
@@ -112,6 +118,7 @@ Enum.prototype._resolveFeatures = function _resolveFeatures(edition) {
  * @property {Object.<string,*>} [options] Enum options
  * @property {Object.<string,Object.<string,*>>} [valuesOptions] Enum value options
  * @property {Array.<number[]|string>} [reserved] Reserved ranges
+ * @property {"local"|"export"} [visibility] Declared symbol visibility
  * @property {string|null} [comment] Enum comment
  * @property {Object.<string,string|null>} [comments] Value comments
  */
@@ -126,6 +133,8 @@ Enum.prototype._resolveFeatures = function _resolveFeatures(edition) {
 Enum.fromJSON = function fromJSON(name, json) {
     var enm = new Enum(name, json.values, json.options, json.comment, json.comments, json.valuesOptions);
     enm.reserved = json.reserved;
+    if (json.visibility)
+        enm.visibility = json.visibility;
     if (json.edition)
         enm._edition = json.edition;
     enm._defaultEdition = "proto3";  // For backwards-compatibility.
@@ -145,6 +154,7 @@ Enum.prototype.toJSON = function toJSON(toJSONOptions) {
         "valuesOptions" , this.valuesOptions,
         "values"        , this.values,
         "reserved"      , this.reserved && this.reserved.length ? this.reserved : undefined,
+        "visibility"    , this.visibility,
         "comment"       , keepComments ? this.comment : undefined,
         "comments"      , keepComments ? this.comments : undefined
     ]);