@bufbuild/protobuf 1.4.1 → 1.5.0

package/dist/esm/google/protobuf/descriptor_pb.js

@@ -11,8 +11,88 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-import { Message } from "../../message.js";
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// The messages in this file describe the definitions found in .proto files.
+// A valid .proto file can be translated directly to a FileDescriptorProto
+// without any other information (e.g. without reading its imports).
+// @generated by protoc-gen-es v1.5.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated from file google/protobuf/descriptor.proto (package google.protobuf, syntax proto2)
+/* eslint-disable */
 import { proto2 } from "../../proto2.js";
+import { Message } from "../../message.js";
+/**
+ * The full set of known editions.
+ *
+ * @generated from enum google.protobuf.Edition
+ */
+export var Edition;
+(function (Edition) {
+    /**
+     * A placeholder for an unknown edition value.
+     *
+     * @generated from enum value: EDITION_UNKNOWN = 0;
+     */
+    Edition[Edition["EDITION_UNKNOWN"] = 0] = "EDITION_UNKNOWN";
+    /**
+     * Legacy syntax "editions".  These pre-date editions, but behave much like
+     * distinct editions.  These can't be used to specify the edition of proto
+     * files, but feature definitions must supply proto2/proto3 defaults for
+     * backwards compatibility.
+     *
+     * @generated from enum value: EDITION_PROTO2 = 998;
+     */
+    Edition[Edition["EDITION_PROTO2"] = 998] = "EDITION_PROTO2";
+    /**
+     * @generated from enum value: EDITION_PROTO3 = 999;
+     */
+    Edition[Edition["EDITION_PROTO3"] = 999] = "EDITION_PROTO3";
+    /**
+     * Editions that have been released.  The specific values are arbitrary and
+     * should not be depended on, but they will always be time-ordered for easy
+     * comparison.
+     *
+     * @generated from enum value: EDITION_2023 = 1000;
+     */
+    Edition[Edition["EDITION_2023"] = 1000] = "EDITION_2023";
+    /**
+     * Placeholder editions for testing feature resolution.  These should not be
+     * used or relyed on outside of tests.
+     *
+     * @generated from enum value: EDITION_1_TEST_ONLY = 1;
+     */
+    Edition[Edition["EDITION_1_TEST_ONLY"] = 1] = "EDITION_1_TEST_ONLY";
+    /**
+     * @generated from enum value: EDITION_2_TEST_ONLY = 2;
+     */
+    Edition[Edition["EDITION_2_TEST_ONLY"] = 2] = "EDITION_2_TEST_ONLY";
+    /**
+     * @generated from enum value: EDITION_99997_TEST_ONLY = 99997;
+     */
+    Edition[Edition["EDITION_99997_TEST_ONLY"] = 99997] = "EDITION_99997_TEST_ONLY";
+    /**
+     * @generated from enum value: EDITION_99998_TEST_ONLY = 99998;
+     */
+    Edition[Edition["EDITION_99998_TEST_ONLY"] = 99998] = "EDITION_99998_TEST_ONLY";
+    /**
+     * @generated from enum value: EDITION_99999_TEST_ONLY = 99999;
+     */
+    Edition[Edition["EDITION_99999_TEST_ONLY"] = 99999] = "EDITION_99999_TEST_ONLY";
+})(Edition || (Edition = {}));
+// Retrieve enum metadata with: proto2.getEnumType(Edition)
+proto2.util.setEnumType(Edition, "google.protobuf.Edition", [
+    { no: 0, name: "EDITION_UNKNOWN" },
+    { no: 998, name: "EDITION_PROTO2" },
+    { no: 999, name: "EDITION_PROTO3" },
+    { no: 1000, name: "EDITION_2023" },
+    { no: 1, name: "EDITION_1_TEST_ONLY" },
+    { no: 2, name: "EDITION_2_TEST_ONLY" },
+    { no: 99997, name: "EDITION_99997_TEST_ONLY" },
+    { no: 99998, name: "EDITION_99998_TEST_ONLY" },
+    { no: 99999, name: "EDITION_99999_TEST_ONLY" },
+]);
 /**
  * The protocol compiler can output a FileDescriptorSet containing the .proto
  * files it parses.
@@ -121,7 +201,7 @@ FileDescriptorProto.fields = proto2.util.newFieldList(() => [
     { no: 8, name: "options", kind: "message", T: FileOptions, opt: true },
     { no: 9, name: "source_code_info", kind: "message", T: SourceCodeInfo, opt: true },
     { no: 12, name: "syntax", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
-    { no: 13, name: "edition", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 14, name: "edition", kind: "enum", T: proto2.getEnumType(Edition), opt: true },
 ]);
 /**
  * Describes a message type.
@@ -440,9 +520,10 @@ export var FieldDescriptorProto_Type;
     FieldDescriptorProto_Type[FieldDescriptorProto_Type["STRING"] = 9] = "STRING";
     /**
      * Tag-delimited aggregate.
-     * Group type is deprecated and not supported in proto3. However, Proto3
+     * Group type is deprecated and not supported after google.protobuf. However, Proto3
      * implementations should still be able to parse the group wire format and
-     * treat group fields as unknown fields.
+     * treat group fields as unknown fields.  In Editions, the group wire format
+     * can be enabled via the `message_encoding` feature.
      *
      * @generated from enum value: TYPE_GROUP = 10;
      */
@@ -520,20 +601,24 @@ export var FieldDescriptorProto_Label;
      * @generated from enum value: LABEL_OPTIONAL = 1;
      */
     FieldDescriptorProto_Label[FieldDescriptorProto_Label["OPTIONAL"] = 1] = "OPTIONAL";
-    /**
-     * @generated from enum value: LABEL_REQUIRED = 2;
-     */
-    FieldDescriptorProto_Label[FieldDescriptorProto_Label["REQUIRED"] = 2] = "REQUIRED";
     /**
      * @generated from enum value: LABEL_REPEATED = 3;
      */
     FieldDescriptorProto_Label[FieldDescriptorProto_Label["REPEATED"] = 3] = "REPEATED";
+    /**
+     * The required label is only allowed in google.protobuf.  In proto3 and Editions
+     * it's explicitly prohibited.  In Editions, the `field_presence` feature
+     * can be used to get this behavior.
+     *
+     * @generated from enum value: LABEL_REQUIRED = 2;
+     */
+    FieldDescriptorProto_Label[FieldDescriptorProto_Label["REQUIRED"] = 2] = "REQUIRED";
 })(FieldDescriptorProto_Label || (FieldDescriptorProto_Label = {}));
 // Retrieve enum metadata with: proto2.getEnumType(FieldDescriptorProto_Label)
 proto2.util.setEnumType(FieldDescriptorProto_Label, "google.protobuf.FieldDescriptorProto.Label", [
     { no: 1, name: "LABEL_OPTIONAL" },
-    { no: 2, name: "LABEL_REQUIRED" },
     { no: 3, name: "LABEL_REPEATED" },
+    { no: 2, name: "LABEL_REQUIRED" },
 ]);
 /**
  * Describes a oneof.
@@ -1103,7 +1188,7 @@ export class FieldOptions_EditionDefault extends Message {
 FieldOptions_EditionDefault.runtime = proto2;
 FieldOptions_EditionDefault.typeName = "google.protobuf.FieldOptions.EditionDefault";
 FieldOptions_EditionDefault.fields = proto2.util.newFieldList(() => [
-    { no: 1, name: "edition", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
+    { no: 3, name: "edition", kind: "enum", T: proto2.getEnumType(Edition), opt: true },
     { no: 2, name: "value", kind: "scalar", T: 9 /* ScalarType.STRING */, opt: true },
 ]);
 /**
@@ -1388,7 +1473,7 @@ UninterpretedOption_NamePart.fields = proto2.util.newFieldList(() => [
     { no: 2, name: "is_extension", kind: "scalar", T: 8 /* ScalarType.BOOL */ },
 ]);
 /**
- * TODO(b/274655146) Enums in C++ gencode (and potentially other languages) are
+ * TODO Enums in C++ gencode (and potentially other languages) are
  * not well scoped.  This means that each of the feature enums below can clash
  * with each other.  The short names we've chosen maximize call-site
  * readability, but leave us very open to this scenario.  A future feature will
@@ -1421,10 +1506,9 @@ FeatureSet.fields = proto2.util.newFieldList(() => [
     { no: 1, name: "field_presence", kind: "enum", T: proto2.getEnumType(FeatureSet_FieldPresence), opt: true },
     { no: 2, name: "enum_type", kind: "enum", T: proto2.getEnumType(FeatureSet_EnumType), opt: true },
     { no: 3, name: "repeated_field_encoding", kind: "enum", T: proto2.getEnumType(FeatureSet_RepeatedFieldEncoding), opt: true },
-    { no: 4, name: "string_field_validation", kind: "enum", T: proto2.getEnumType(FeatureSet_StringFieldValidation), opt: true },
+    { no: 4, name: "utf8_validation", kind: "enum", T: proto2.getEnumType(FeatureSet_Utf8Validation), opt: true },
     { no: 5, name: "message_encoding", kind: "enum", T: proto2.getEnumType(FeatureSet_MessageEncoding), opt: true },
     { no: 6, name: "json_format", kind: "enum", T: proto2.getEnumType(FeatureSet_JsonFormat), opt: true },
-    { no: 999, name: "raw_features", kind: "message", T: FeatureSet, opt: true },
 ]);
 /**
  * @generated from enum google.protobuf.FeatureSet.FieldPresence
@@ -1504,33 +1588,28 @@ proto2.util.setEnumType(FeatureSet_RepeatedFieldEncoding, "google.protobuf.Featu
     { no: 2, name: "EXPANDED" },
 ]);
 /**
- * @generated from enum google.protobuf.FeatureSet.StringFieldValidation
+ * @generated from enum google.protobuf.FeatureSet.Utf8Validation
  */
-export var FeatureSet_StringFieldValidation;
-(function (FeatureSet_StringFieldValidation) {
+export var FeatureSet_Utf8Validation;
+(function (FeatureSet_Utf8Validation) {
     /**
-     * @generated from enum value: STRING_FIELD_VALIDATION_UNKNOWN = 0;
+     * @generated from enum value: UTF8_VALIDATION_UNKNOWN = 0;
      */
-    FeatureSet_StringFieldValidation[FeatureSet_StringFieldValidation["STRING_FIELD_VALIDATION_UNKNOWN"] = 0] = "STRING_FIELD_VALIDATION_UNKNOWN";
+    FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["UTF8_VALIDATION_UNKNOWN"] = 0] = "UTF8_VALIDATION_UNKNOWN";
     /**
-     * @generated from enum value: MANDATORY = 1;
+     * @generated from enum value: NONE = 1;
      */
-    FeatureSet_StringFieldValidation[FeatureSet_StringFieldValidation["MANDATORY"] = 1] = "MANDATORY";
+    FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["NONE"] = 1] = "NONE";
     /**
-     * @generated from enum value: HINT = 2;
+     * @generated from enum value: VERIFY = 2;
      */
-    FeatureSet_StringFieldValidation[FeatureSet_StringFieldValidation["HINT"] = 2] = "HINT";
-    /**
-     * @generated from enum value: NONE = 3;
-     */
-    FeatureSet_StringFieldValidation[FeatureSet_StringFieldValidation["NONE"] = 3] = "NONE";
-})(FeatureSet_StringFieldValidation || (FeatureSet_StringFieldValidation = {}));
-// Retrieve enum metadata with: proto2.getEnumType(FeatureSet_StringFieldValidation)
-proto2.util.setEnumType(FeatureSet_StringFieldValidation, "google.protobuf.FeatureSet.StringFieldValidation", [
-    { no: 0, name: "STRING_FIELD_VALIDATION_UNKNOWN" },
-    { no: 1, name: "MANDATORY" },
-    { no: 2, name: "HINT" },
-    { no: 3, name: "NONE" },
+    FeatureSet_Utf8Validation[FeatureSet_Utf8Validation["VERIFY"] = 2] = "VERIFY";
+})(FeatureSet_Utf8Validation || (FeatureSet_Utf8Validation = {}));
+// Retrieve enum metadata with: proto2.getEnumType(FeatureSet_Utf8Validation)
+proto2.util.setEnumType(FeatureSet_Utf8Validation, "google.protobuf.FeatureSet.Utf8Validation", [
+    { no: 0, name: "UTF8_VALIDATION_UNKNOWN" },
+    { no: 1, name: "NONE" },
+    { no: 2, name: "VERIFY" },
 ]);
 /**
  * @generated from enum google.protobuf.FeatureSet.MessageEncoding
@@ -1580,6 +1659,75 @@ proto2.util.setEnumType(FeatureSet_JsonFormat, "google.protobuf.FeatureSet.JsonF
     { no: 1, name: "ALLOW" },
     { no: 2, name: "LEGACY_BEST_EFFORT" },
 ]);
+/**
+ * A compiled specification for the defaults of a set of features.  These
+ * messages are generated from FeatureSet extensions and can be used to seed
+ * feature resolution. The resolution with this object becomes a simple search
+ * for the closest matching edition, followed by proto merges.
+ *
+ * @generated from message google.protobuf.FeatureSetDefaults
+ */
+export class FeatureSetDefaults extends Message {
+    constructor(data) {
+        super();
+        /**
+         * @generated from field: repeated google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault defaults = 1;
+         */
+        this.defaults = [];
+        proto2.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new FeatureSetDefaults().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new FeatureSetDefaults().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new FeatureSetDefaults().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto2.util.equals(FeatureSetDefaults, a, b);
+    }
+}
+FeatureSetDefaults.runtime = proto2;
+FeatureSetDefaults.typeName = "google.protobuf.FeatureSetDefaults";
+FeatureSetDefaults.fields = proto2.util.newFieldList(() => [
+    { no: 1, name: "defaults", kind: "message", T: FeatureSetDefaults_FeatureSetEditionDefault, repeated: true },
+    { no: 4, name: "minimum_edition", kind: "enum", T: proto2.getEnumType(Edition), opt: true },
+    { no: 5, name: "maximum_edition", kind: "enum", T: proto2.getEnumType(Edition), opt: true },
+]);
+/**
+ * A map from every known edition with a unique set of defaults to its
+ * defaults. Not all editions may be contained here.  For a given edition,
+ * the defaults at the closest matching edition ordered at or before it should
+ * be used.  This field must be in strict ascending order by edition.
+ *
+ * @generated from message google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault
+ */
+export class FeatureSetDefaults_FeatureSetEditionDefault extends Message {
+    constructor(data) {
+        super();
+        proto2.util.initPartial(data, this);
+    }
+    static fromBinary(bytes, options) {
+        return new FeatureSetDefaults_FeatureSetEditionDefault().fromBinary(bytes, options);
+    }
+    static fromJson(jsonValue, options) {
+        return new FeatureSetDefaults_FeatureSetEditionDefault().fromJson(jsonValue, options);
+    }
+    static fromJsonString(jsonString, options) {
+        return new FeatureSetDefaults_FeatureSetEditionDefault().fromJsonString(jsonString, options);
+    }
+    static equals(a, b) {
+        return proto2.util.equals(FeatureSetDefaults_FeatureSetEditionDefault, a, b);
+    }
+}
+FeatureSetDefaults_FeatureSetEditionDefault.runtime = proto2;
+FeatureSetDefaults_FeatureSetEditionDefault.typeName = "google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault";
+FeatureSetDefaults_FeatureSetEditionDefault.fields = proto2.util.newFieldList(() => [
+    { no: 3, name: "edition", kind: "enum", T: proto2.getEnumType(Edition), opt: true },
+    { no: 2, name: "features", kind: "message", T: FeatureSet, opt: true },
+]);
 /**
  * Encapsulates information about the original source file from which a
  * FileDescriptorProto was generated.

package/dist/esm/google/protobuf/struct_pb.js

@@ -11,7 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-// @generated by protoc-gen-es v1.4.1 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es v1.5.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
 // @generated from file google/protobuf/struct.proto (package google.protobuf, syntax proto3)
 /* eslint-disable */
 import { proto3 } from "../../proto3.js";

package/dist/esm/google/protobuf/type_pb.js

@@ -11,7 +11,7 @@
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
-// @generated by protoc-gen-es v1.4.1 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es v1.5.0 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
 // @generated from file google/protobuf/type.proto (package google.protobuf, syntax proto3)
 /* eslint-disable */
 import { proto3 } from "../../proto3.js";

package/dist/esm/private/feature-set.d.ts

@@ -0,0 +1,21 @@
+import { Edition, FeatureSet, FeatureSetDefaults } from "../google/protobuf/descriptor_pb.js";
+/**
+ * Static edition feature defaults supported by @bufbuild/protobuf.
+ */
+export declare const featureSetDefaults: FeatureSetDefaults;
+/**
+ * A merged google.protobuf.FeaturesSet, with all fields guaranteed to be set.
+ */
+export type MergedFeatureSet = FeatureSet & Required<FeatureSet>;
+/**
+ * A function that resolves features for the given edition.
+ *
+ * If no feature set is provided, the default feature set for the edition is
+ * returned. If features are provided, they are merged into the edition default
+ * features.
+ */
+export type FeatureResolverFn = (edition: Edition, a?: FeatureSet, b?: FeatureSet) => MergedFeatureSet;
+/**
+ * Create an edition feature resolver with the given feature set defaults.
+ */
+export declare function createFeatureResolver(compiledFeatureSetDefaults: FeatureSetDefaults): FeatureResolverFn;

package/dist/esm/private/feature-set.js

@@ -0,0 +1,103 @@
+// Copyright 2021-2023 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { Edition, FeatureSet, FeatureSetDefaults, } from "../google/protobuf/descriptor_pb.js";
+import { protoBase64 } from "../proto-base64.js";
+/**
+ * Static edition feature defaults supported by @bufbuild/protobuf.
+ */
+export const featureSetDefaults = FeatureSetDefaults.fromBinary(protoBase64.dec(
+/*upstream-inject-feature-defaults-start*/ "ChESDAgBEAIYAiABKAEwAhjmBwoREgwIAhABGAEgAigBMAEY5wcKERIMCAEQARgBIAIoATABGOgHIOYHKOgH" /*upstream-inject-feature-defaults-end*/));
+/**
+ * Create an edition feature resolver with the given feature set defaults.
+ */
+export function createFeatureResolver(compiledFeatureSetDefaults) {
+    const min = compiledFeatureSetDefaults.minimumEdition;
+    const max = compiledFeatureSetDefaults.maximumEdition;
+    if (min === undefined ||
+        max === undefined ||
+        compiledFeatureSetDefaults.defaults.some((d) => d.edition === undefined)) {
+        throw new Error("Invalid FeatureSetDefaults");
+    }
+    const defaultsBinByEdition = new Map();
+    return (edition, ...rest) => {
+        var _a, _b;
+        let defaultsBin = defaultsBinByEdition.get(edition);
+        if (defaultsBin === undefined) {
+            if (edition < min) {
+                throw new Error(`Edition ${Edition[edition]} is earlier than the minimum supported edition ${Edition[min]}`);
+            }
+            if (max < edition) {
+                throw new Error(`Edition ${Edition[edition]} is later than the maximum supported edition ${Edition[max]}`);
+            }
+            let highestMatch = undefined;
+            for (const c of compiledFeatureSetDefaults.defaults) {
+                const e = (_a = c.edition) !== null && _a !== void 0 ? _a : 0;
+                if (e > edition) {
+                    continue;
+                }
+                if (highestMatch !== undefined && highestMatch.e > e) {
+                    continue;
+                }
+                highestMatch = {
+                    e,
+                    f: (_b = c.features) !== null && _b !== void 0 ? _b : new FeatureSet(),
+                };
+            }
+            if (highestMatch === undefined) {
+                throw new Error(`No valid default found for edition ${Edition[edition]}`);
+            }
+            defaultsBin = highestMatch.f.toBinary();
+            defaultsBinByEdition.set(edition, defaultsBin);
+        }
+        const f = FeatureSet.fromBinary(defaultsBin);
+        for (const c of rest) {
+            if (c !== undefined) {
+                f.fromBinary(c.toBinary());
+            }
+        }
+        if (!validateMergedFeatures(f)) {
+            throw new Error(`Invalid FeatureSet for edition ${Edition[edition]}`);
+        }
+        return f;
+    };
+}
+// When protoc generates google.protobuf.FeatureSetDefaults, it ensures that
+// fields are not repeated or required, do not use oneof, and have a default
+// value.
+//
+// When features for an element are resolved, features of the element and its
+// parents are merged into the default FeatureSet for the edition. Because unset
+// fields in the FeatureSet of an element do not unset the default FeatureSet
+// values, a resolved FeatureSet is guaranteed to have all fields set. This is
+// also the case for extensions to FeatureSet that a user might provide, and for
+// features from the future.
+//
+// We cannot exhaustively validate correctness of FeatureSetDefaults at runtime
+// without knowing the schema: If no value for a feature is provided, we do not
+// know that it exists at all.
+//
+// As a sanity check, we validate that all fields known to our version of
+// FeatureSet are set.
+function validateMergedFeatures(featureSet) {
+    for (const fi of FeatureSet.fields.list()) {
+        const v = featureSet[fi.localName];
+        if (v === undefined) {
+            return false;
+        }
+        if (fi.kind == "enum" && v === 0) {
+            return false;
+        }
+    }
+    return true;
+}

package/dist/esm/private/text-format.d.ts

@@ -0,0 +1,4 @@
+import type { DescEnum } from "../descriptor-set.js";
+import { ScalarType } from "../field.js";
+export declare function parseTextFormatEnumValue(descEnum: DescEnum, value: string): number;
+export declare function parseTextFormatScalarValue(type: ScalarType, value: string): number | boolean | string | bigint | Uint8Array;

package/dist/esm/private/text-format.js

@@ -0,0 +1,184 @@
+// Copyright 2021-2023 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import { assert } from "./assert.js";
+import { ScalarType } from "../field.js";
+import { protoInt64 } from "../proto-int64.js";
+export function parseTextFormatEnumValue(descEnum, value) {
+    const enumValue = descEnum.values.find((v) => v.name === value);
+    assert(enumValue, `cannot parse ${descEnum.name} default value: ${value}`);
+    return enumValue.number;
+}
+export function parseTextFormatScalarValue(type, value) {
+    switch (type) {
+        case ScalarType.STRING:
+            return value;
+        case ScalarType.BYTES: {
+            const u = unescapeBytesDefaultValue(value);
+            if (u === false) {
+                throw new Error(`cannot parse ${ScalarType[type]} default value: ${value}`);
+            }
+            return u;
+        }
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+            return protoInt64.parse(value);
+        case ScalarType.UINT64:
+        case ScalarType.FIXED64:
+            return protoInt64.uParse(value);
+        case ScalarType.DOUBLE:
+        case ScalarType.FLOAT:
+            switch (value) {
+                case "inf":
+                    return Number.POSITIVE_INFINITY;
+                case "-inf":
+                    return Number.NEGATIVE_INFINITY;
+                case "nan":
+                    return Number.NaN;
+                default:
+                    return parseFloat(value);
+            }
+        case ScalarType.BOOL:
+            return value === "true";
+        case ScalarType.INT32:
+        case ScalarType.UINT32:
+        case ScalarType.SINT32:
+        case ScalarType.FIXED32:
+        case ScalarType.SFIXED32:
+            return parseInt(value, 10);
+    }
+}
+/**
+ * Parses a text-encoded default value (proto2) of a BYTES field.
+ */
+function unescapeBytesDefaultValue(str) {
+    const b = [];
+    const input = {
+        tail: str,
+        c: "",
+        next() {
+            if (this.tail.length == 0) {
+                return false;
+            }
+            this.c = this.tail[0];
+            this.tail = this.tail.substring(1);
+            return true;
+        },
+        take(n) {
+            if (this.tail.length >= n) {
+                const r = this.tail.substring(0, n);
+                this.tail = this.tail.substring(n);
+                return r;
+            }
+            return false;
+        },
+    };
+    while (input.next()) {
+        switch (input.c) {
+            case "\\":
+                if (input.next()) {
+                    switch (input.c) {
+                        case "\\":
+                            b.push(input.c.charCodeAt(0));
+                            break;
+                        case "b":
+                            b.push(0x08);
+                            break;
+                        case "f":
+                            b.push(0x0c);
+                            break;
+                        case "n":
+                            b.push(0x0a);
+                            break;
+                        case "r":
+                            b.push(0x0d);
+                            break;
+                        case "t":
+                            b.push(0x09);
+                            break;
+                        case "v":
+                            b.push(0x0b);
+                            break;
+                        case "0":
+                        case "1":
+                        case "2":
+                        case "3":
+                        case "4":
+                        case "5":
+                        case "6":
+                        case "7": {
+                            const s = input.c;
+                            const t = input.take(2);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 8);
+                            if (isNaN(n)) {
+                                return false;
+                            }
+                            b.push(n);
+                            break;
+                        }
+                        case "x": {
+                            const s = input.c;
+                            const t = input.take(2);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 16);
+                            if (isNaN(n)) {
+                                return false;
+                            }
+                            b.push(n);
+                            break;
+                        }
+                        case "u": {
+                            const s = input.c;
+                            const t = input.take(4);
+                            if (t === false) {
+                                return false;
+                            }
+                            const n = parseInt(s + t, 16);
+                            if (isNaN(n)) {
+                                return false;
+                            }
+                            const chunk = new Uint8Array(4);
+                            const view = new DataView(chunk.buffer);
+                            view.setInt32(0, n, true);
+                            b.push(chunk[0], chunk[1], chunk[2], chunk[3]);
+                            break;
+                        }
+                        case "U": {
+                            const s = input.c;
+                            const t = input.take(8);
+                            if (t === false) {
+                                return false;
+                            }
+                            const tc = protoInt64.uEnc(s + t);
+                            const chunk = new Uint8Array(8);
+                            const view = new DataView(chunk.buffer);
+                            view.setInt32(0, tc.lo, true);
+                            view.setInt32(4, tc.hi, true);
+                            b.push(chunk[0], chunk[1], chunk[2], chunk[3], chunk[4], chunk[5], chunk[6], chunk[7]);
+                            break;
+                        }
+                    }
+                }
+                break;
+            default:
+                b.push(input.c.charCodeAt(0));
+        }
+    }
+    return new Uint8Array(b);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bufbuild/protobuf",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "license": "(Apache-2.0 AND BSD-3-Clause)",
   "description": "A complete implementation of Protocol Buffers in TypeScript, suitable for web browsers and Node.js.",
   "repository": {
@@ -14,10 +14,10 @@
     "build:cjs": "../../node_modules/typescript/bin/tsc --project tsconfig.json --module commonjs --outDir ./dist/cjs --declaration --declarationDir ./dist/cjs && echo >./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
     "build:esm": "../../node_modules/typescript/bin/tsc --project tsconfig.json --module ES2015 --verbatimModuleSyntax --outDir ./dist/esm --declaration --declarationDir ./dist/esm",
     "build:proxy": "node ../../scripts/gen-esm-proxy.mjs .",
-    "prebootstrap": "rm -rf .tmp && mkdir -p .tmp/google/protobuf && cp -rp src/google/protobuf/* .tmp/google/protobuf",
-    "bootstrap": "protoc --es_out=src --es_opt=bootstrap_wkt=true,ts_nocheck=false,target=ts --proto_path $(upstream-include wkt) $(upstream-files wkt)",
-    "postbootstrap": "license-header src/google/protobuf",
-    "bootstrap-diff": "diff >/dev/null -r .tmp/google/protobuf src/google/protobuf && cp -rp .tmp/google/protobuf/* src/google/protobuf",
+    "bootstrap:featureset-defaults": "upstream-inject-feature-defaults src/private/feature-set.ts",
+    "prebootstrap:wkt": "rm -rf .tmp && mkdir -p .tmp/google/protobuf && cp -rp src/google/protobuf/* .tmp/google/protobuf",
+    "bootstrap:wkt": "protoc --es_out=src --es_opt=bootstrap_wkt=true,ts_nocheck=false,target=ts --proto_path $(upstream-include wkt) $(upstream-files wkt) && license-header src/google/protobuf",
+    "postbootstrap:wkt": "diff >/dev/null -r .tmp/google/protobuf src/google/protobuf && cp -rp .tmp/google/protobuf/* src/google/protobuf || true",
     "attw": "attw --pack"
   },
   "type": "module",