protobufjs 8.7.1 → 8.8.0

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

@@ -13,7 +13,7 @@ var Namespace = $protobuf.Namespace,
     Method    = $protobuf.Method,
     patterns  = $protobuf.util.patterns;
 
-var numberRe  = patterns.numberRe,
+var integerRe = /^[+-]?[0-9]+$/,
     typeRefRe = patterns.typeRefRe;
 
 // --- Root ---
@@ -52,6 +52,7 @@ var numberRe  = patterns.numberRe,
  * @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 +209,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 +254,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 +320,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));
@@ -519,17 +525,33 @@ function Field_fromDescriptor(descriptor, ctx, nested) {
 
     if (descriptor.defaultValue && descriptor.defaultValue.length) {
         var defaultValue = descriptor.defaultValue;
-        switch (defaultValue) {
-            case "true": case "TRUE":
-                defaultValue = true;
+        switch (fieldType) {
+            case "double": case "float":
+                switch (defaultValue.toLowerCase()) {
+                    case "inf": defaultValue = Infinity; break;
+                    case "-inf": defaultValue = -Infinity; break;
+                    case "nan": case "-nan": defaultValue = NaN; break;
+                    default:
+                        defaultValue = Number(defaultValue);
+                        if (Number.isNaN(defaultValue))
+                            throw Error("illegal default value for " + fieldType);
+                        break;
+                }
                 break;
-            case "false": case "FALSE":
-                defaultValue = false;
+            case "int32": case "uint32": case "sint32": case "fixed32": case "sfixed32":
+                if (!integerRe.test(defaultValue))
+                    throw Error("illegal default value for " + fieldType);
+                defaultValue = parseInt(defaultValue, 10);
                 break;
-            default:
-                var match = numberRe.exec(defaultValue);
-                if (match)
-                    defaultValue = parseInt(defaultValue); // eslint-disable-line radix
+            case "int64": case "uint64": case "sint64": case "fixed64": case "sfixed64":
+                if (!integerRe.test(defaultValue))
+                    throw Error("illegal default value for " + fieldType);
+                break;
+            case "bool":
+                switch (defaultValue) {
+                    case "true": case "TRUE": defaultValue = true; break;
+                    case "false": case "FALSE": defaultValue = false; break;
+                }
                 break;
         }
         field.setOption("default", defaultValue);
@@ -639,6 +661,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
  */
 
 /**
@@ -677,6 +700,7 @@ Field.prototype.toDescriptor = function toDescriptor(edition) {
  * @property {number} [jsonFormat]
  * @property {number} [enforceNamingStyle]
  * @property {number} [defaultSymbolVisibility]
+ * @property {number} [enforceProtoLimits]
  */
 
 var unnamedEnumIndex = 0;
@@ -719,6 +743,7 @@ function Enum_fromDescriptor(descriptor, ctx, nested) {
         undefined,
         valuesOptions
     );
+    enm.visibility = visibilityFromDescriptor(descriptor.visibility);
 
     if (!nested) {
         enm._edition = ctx.edition;
@@ -760,6 +785,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)
@@ -984,6 +1011,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) {
@@ -1142,6 +1177,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);
         }
@@ -1165,6 +1202,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));
 }

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,
@@ -1199,6 +1200,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 +1275,8 @@
                   "values": {
                     "ENFORCE_NAMING_STYLE_UNKNOWN": 0,
                     "STYLE2024": 1,
-                    "STYLE_LEGACY": 2
+                    "STYLE_LEGACY": 2,
+                    "STYLE2026": 3
                   }
                 },
                 "VisibilityFeature": {
@@ -1291,6 +1298,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;
@@ -396,6 +397,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 +447,7 @@ message FeatureSet {
         ENFORCE_NAMING_STYLE_UNKNOWN = 0;
         STYLE2024 = 1;
         STYLE_LEGACY = 2;
+        STYLE2026 = 3;
     }
 
     message VisibilityFeature {
@@ -461,6 +464,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 +537,4 @@ enum SymbolVisibility {
     VISIBILITY_UNSET = 0;
     VISIBILITY_LOCAL = 1;
     VISIBILITY_EXPORT = 2;
-}
+}

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);
 
@@ -1804,6 +1810,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 +1991,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);
 }
@@ -2918,6 +2930,9 @@ export class Writer {
     /** Stack of forked length-prefix positions. */
     states: (number[]|null);
 
+    /** Initial backing buffer size in bytes. Defaults to 128. */
+    static initialBufferSize: number;
+
     /**
      * Current write position.
      * @deprecated Use {@link Writer#pos} instead.

package/package.json

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

package/src/converter.js

@@ -303,7 +303,11 @@ converter.toObject = function toObject(mtype) {
             ("d%s=%j", prop, arrayDefault)
             ("if(o.bytes!==Array)d%s=util.newBuffer(d%s)", prop, prop)
         ("}");
-            } else gen
+            } else if ((field.type === "double" || field.type === "float") && typeof field.typeDefault === "number"
+                    && (!isFinite(field.typeDefault) || Object.is(field.typeDefault, -0))) gen
+        ("d%s=%f", prop, field.typeDefault)
+        ("if(o.json&&!isFinite(d%s))d%s=String(d%s)", prop, prop, prop);
+            else gen
         ("d%s=%j", prop, field.typeDefault); // also messages (=null)
         } gen
     ("}");

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.uint32()+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]);
@@ -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);
@@ -144,6 +161,9 @@ function decoder(mtype) {
                 if (closed) {
                     gen
                     ("var c2=r.uint32()+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)
@@ -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,14 +76,23 @@ 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.
 
     if (values)
         for (var keys = Object.keys(values), i = 0; i < keys.length; ++i)
-            if (keys[i] !== "__proto__" && typeof values[keys[i]] === "number") // use forward entries only
-                this.valuesById[ this.values[keys[i]] = values[keys[i]] ] = keys[i];
+            if (keys[i] !== "__proto__" && typeof values[keys[i]] === "number") { // use forward entries only
+                this.values[keys[i]] = values[keys[i]];
+                if (this.valuesById[values[keys[i]]] === undefined)
+                    this.valuesById[values[keys[i]]] = keys[i];
+            }
 }
 
 /**
@@ -109,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
  */
@@ -123,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.
@@ -142,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
     ]);

package/src/field.js

@@ -371,12 +371,17 @@ Field.prototype.resolve = function resolve() {
 
     // convert to internal data type if necesssary
     if (this.long) {
-        this.typeDefault = util.Long.fromNumber(this.typeDefault, this.type === "uint64" || this.type === "fixed64");
+        var unsigned = this.type === "uint64" || this.type === "fixed64";
+        this.typeDefault = typeof this.typeDefault === "string"
+            ? util.Long.fromString(this.typeDefault, unsigned)
+            : util.Long.fromNumber(this.typeDefault, unsigned);
 
         /* istanbul ignore else */
         if (Object.freeze)
             Object.freeze(this.typeDefault); // long instances are meant to be immutable anyway (i.e. use small int cache that even requires it)
 
+    } else if (types.long[this.type] !== undefined && typeof this.typeDefault === "string") {
+        this.typeDefault = parseInt(this.typeDefault, 10);
     } else if (this.bytes && typeof this.typeDefault === "string") {
         var buf;
         if (util.base64.test(this.typeDefault))

package/src/object.js

@@ -10,10 +10,11 @@ var Root; // cyclic
 
 /* eslint-disable no-warning-comments */
 // TODO: Replace with embedded proto.
-var editions2024Defaults = {enum_type: "OPEN", field_presence: "EXPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY", enforce_naming_style: "STYLE2024", default_symbol_visibility: "EXPORT_TOP_LEVEL" };
-var editions2023Defaults = {enum_type: "OPEN", field_presence: "EXPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY", enforce_naming_style: "STYLE_LEGACY", default_symbol_visibility: "EXPORT_ALL" };
 var proto2Defaults = {enum_type: "CLOSED", field_presence: "EXPLICIT", json_format: "LEGACY_BEST_EFFORT", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "EXPANDED", utf8_validation: "NONE", enforce_naming_style: "STYLE_LEGACY", default_symbol_visibility: "EXPORT_ALL" };
 var proto3Defaults = {enum_type: "OPEN", field_presence: "IMPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY", enforce_naming_style: "STYLE_LEGACY", default_symbol_visibility: "EXPORT_ALL" };
+var editions2023Defaults = {enum_type: "OPEN", field_presence: "EXPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY", enforce_naming_style: "STYLE_LEGACY", default_symbol_visibility: "EXPORT_ALL" };
+var editions2024Defaults = {enum_type: "OPEN", field_presence: "EXPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY", enforce_naming_style: "STYLE2024", default_symbol_visibility: "EXPORT_TOP_LEVEL" };
+var editions2026Defaults = {enum_type: "OPEN", field_presence: "EXPLICIT", json_format: "ALLOW", message_encoding: "LENGTH_PREFIXED", repeated_field_encoding: "PACKED", utf8_validation: "VERIFY", enforce_naming_style: "STYLE2026", default_symbol_visibility: "STRICT", enforce_proto_limits: "PROTO_LIMITS2026" };
 
 /**
  * Constructs a new reflection object instance.
@@ -227,6 +228,8 @@ ReflectionObject.prototype._resolveFeatures = function _resolveFeatures(edition)
             defaults = Object.assign({}, editions2023Defaults);
         } else if (edition === "2024") {
             defaults = Object.assign({}, editions2024Defaults);
+        } else if (edition === "2026") {
+            defaults = Object.assign({}, editions2026Defaults);
         } else {
             throw new Error("Unknown edition: " + edition);
         }