@bufbuild/protobuf 0.0.8 → 0.1.0

package/dist/esm/descriptor-set.js

@@ -11,437 +11,4 @@
 // 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 { FieldDescriptorProto_Label, FieldDescriptorProto_Type, MethodOptions_IdempotencyLevel, } from "./google/protobuf/descriptor_pb.js";
-import { assert } from "./private/assert.js";
-import { ScalarType } from "./field.js";
-import { MethodIdempotency, MethodKind } from "./service-type.js";
-/**
- * DescriptorSet wraps a set of google.protobuf.FileDescriptorProto,
- * asserting basic expectations and providing hierarchical information.
- *
- * Note that all types are kept by their fully qualified type name
- * with a leading dot.
- */
-export class DescriptorSet {
-    constructor() {
-        this.enums = {};
-        this.messages = {};
-        this.services = {};
-    }
-    /**
-     * May raise an error on invalid descriptors.
-     */
-    add(...files) {
-        for (const file of files) {
-            newFile(file, this);
-        }
-    }
-    listEnums() {
-        return Object.values(this.enums).filter(isDefined);
-    }
-    listMessages() {
-        return Object.values(this.messages).filter(isDefined);
-    }
-    listServices() {
-        return Object.values(this.services).filter(isDefined);
-    }
-}
-function isDefined(v) {
-    return v !== undefined;
-}
-const fieldTypeToScalarType = {
-    [FieldDescriptorProto_Type.DOUBLE]: ScalarType.DOUBLE,
-    [FieldDescriptorProto_Type.FLOAT]: ScalarType.FLOAT,
-    [FieldDescriptorProto_Type.INT64]: ScalarType.INT64,
-    [FieldDescriptorProto_Type.UINT64]: ScalarType.UINT64,
-    [FieldDescriptorProto_Type.INT32]: ScalarType.INT32,
-    [FieldDescriptorProto_Type.FIXED64]: ScalarType.FIXED64,
-    [FieldDescriptorProto_Type.FIXED32]: ScalarType.FIXED32,
-    [FieldDescriptorProto_Type.BOOL]: ScalarType.BOOL,
-    [FieldDescriptorProto_Type.STRING]: ScalarType.STRING,
-    [FieldDescriptorProto_Type.GROUP]: undefined,
-    [FieldDescriptorProto_Type.MESSAGE]: undefined,
-    [FieldDescriptorProto_Type.BYTES]: ScalarType.BYTES,
-    [FieldDescriptorProto_Type.UINT32]: ScalarType.UINT32,
-    [FieldDescriptorProto_Type.ENUM]: undefined,
-    [FieldDescriptorProto_Type.SFIXED32]: ScalarType.SFIXED32,
-    [FieldDescriptorProto_Type.SFIXED64]: ScalarType.SFIXED64,
-    [FieldDescriptorProto_Type.SINT32]: ScalarType.SINT32,
-    [FieldDescriptorProto_Type.SINT64]: ScalarType.SINT64,
-};
-function newFile(proto, ds) {
-    assert(proto.name, `missing file descriptor name`);
-    if (proto.syntax !== undefined && proto.syntax !== "proto3") {
-        throw new Error(`invalid descriptor: unsupported syntax: ${proto.syntax}`);
-    }
-    const file = {
-        proto,
-        syntax: proto.syntax === "proto3" ? "proto3" : "proto2",
-        name: proto.name.endsWith(".proto")
-            ? proto.name.substring(-".proto".length)
-            : proto.name,
-        toString() {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
-            return `file ${this.proto.name}`;
-        },
-    };
-    for (const messageType of proto.messageType) {
-        newMessage(messageType, undefined, file, ds);
-    }
-    for (const enumType of proto.enumType) {
-        newEnum(enumType, undefined, file, ds);
-    }
-    for (const extension of proto.extension) {
-        newExtension(extension, undefined, file, ds);
-    }
-    for (const service of proto.service) {
-        newService(service, file, ds);
-    }
-    return file;
-}
-function newEnum(proto, parent, file, us) {
-    assert(proto.name, `invalid descriptor: missing enum descriptor name`);
-    let protoTypeName;
-    if (parent) {
-        protoTypeName = `${parent.protoTypeName}.${proto.name}`;
-    }
-    else if (file.proto.package !== undefined) {
-        protoTypeName = `.${file.proto.package}.${proto.name}`;
-    }
-    else {
-        protoTypeName = `.${proto.name}`;
-    }
-    const values = [];
-    const enumT = {
-        proto,
-        file,
-        parent,
-        name: proto.name,
-        protoTypeName,
-        typeName: protoTypeName.startsWith(".")
-            ? protoTypeName.substring(1)
-            : protoTypeName,
-        values,
-        toString() {
-            return `enum ${this.typeName}`;
-        },
-    };
-    us.enums[enumT.protoTypeName] = enumT;
-    for (const value of proto.value) {
-        values.push(newEnumValue(value, enumT));
-    }
-    return enumT;
-}
-function newEnumValue(proto, parent) {
-    assert(proto.name, `invalid descriptor: missing enum value descriptor name`);
-    assert(proto.number !== undefined, `invalid descriptor: missing enum value descriptor number`);
-    return {
-        proto,
-        name: proto.name,
-        number: proto.number,
-        parent,
-        toString() {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
-            return `enum value ${this.parent.typeName}.${this.proto.name}`;
-        },
-    };
-}
-function newMessage(proto, parent, file, us) {
-    var _a;
-    assert(proto.name, `invalid descriptor: missing name`);
-    const nestedMessages = [];
-    const fields = [];
-    const oneofs = [];
-    const nestedEnums = [];
-    const nestedExtensions = [];
-    let protoTypeName;
-    if (parent) {
-        protoTypeName = `${parent.protoTypeName}.${proto.name}`;
-    }
-    else if (file.proto.package !== undefined) {
-        protoTypeName = `.${file.proto.package}.${proto.name}`;
-    }
-    else {
-        protoTypeName = `.${proto.name}`;
-    }
-    const message = {
-        proto,
-        file,
-        parent,
-        name: proto.name,
-        typeName: protoTypeName.startsWith(".")
-            ? protoTypeName.substring(1)
-            : protoTypeName,
-        protoTypeName,
-        fields,
-        oneofs,
-        nestedEnums,
-        nestedMessages,
-        nestedExtensions,
-        toString() {
-            return `message ${this.typeName}`;
-        },
-    };
-    us.messages[message.protoTypeName] = message;
-    for (const nestedType of proto.nestedType) {
-        nestedMessages.push(newMessage(nestedType, message, file, us));
-    }
-    for (const oneofDecl of proto.oneofDecl) {
-        oneofs.push(newOneof(oneofDecl, message, file));
-    }
-    for (const field of proto.field) {
-        let oneof = undefined;
-        if (field.oneofIndex !== undefined) {
-            oneof = oneofs[field.oneofIndex];
-            assert(oneof, `invalid descriptor: oneof declaration index ${field.oneofIndex} specified by field #${(_a = field.number) !== null && _a !== void 0 ? _a : -1} not found`);
-        }
-        fields.push(newField(field, message, oneof));
-    }
-    for (const enumType of proto.enumType) {
-        nestedEnums.push(newEnum(enumType, message, file, us));
-    }
-    for (const extension of proto.extension) {
-        nestedExtensions.push(newExtension(extension, message, file, us));
-    }
-    return message;
-}
-function newField(proto, parent, oneof) {
-    var _a;
-    assert(proto.name, `invalid descriptor: missing name`);
-    assert(proto.number, `invalid descriptor: missing number`);
-    assert(proto.type, `invalid descriptor: missing type`);
-    let optional = false;
-    let packed = ((_a = proto.options) === null || _a === void 0 ? void 0 : _a.packed) === true;
-    switch (parent.file.syntax) {
-        case "proto2":
-            optional =
-                oneof === undefined &&
-                    proto.label === FieldDescriptorProto_Label.OPTIONAL;
-            break;
-        case "proto3":
-            optional = proto.proto3Optional === true;
-            switch (proto.type) {
-                case FieldDescriptorProto_Type.DOUBLE:
-                case FieldDescriptorProto_Type.FLOAT:
-                case FieldDescriptorProto_Type.INT64:
-                case FieldDescriptorProto_Type.UINT64:
-                case FieldDescriptorProto_Type.INT32:
-                case FieldDescriptorProto_Type.FIXED64:
-                case FieldDescriptorProto_Type.FIXED32:
-                case FieldDescriptorProto_Type.UINT32:
-                case FieldDescriptorProto_Type.SFIXED32:
-                case FieldDescriptorProto_Type.SFIXED64:
-                case FieldDescriptorProto_Type.SINT32:
-                case FieldDescriptorProto_Type.SINT64:
-                case FieldDescriptorProto_Type.BOOL:
-                case FieldDescriptorProto_Type.ENUM:
-                    // From the proto3 language guide:
-                    // > In proto3, repeated fields of scalar numeric types are packed by default.
-                    // This information is incomplete - according to the conformance tests, BOOL
-                    // and ENUM are packed by default as well. This means only STRING and BYTES
-                    // are not packed by default, which makes sense because they are length-delimited.
-                    packed = true;
-                    break;
-                case FieldDescriptorProto_Type.STRING:
-                case FieldDescriptorProto_Type.GROUP:
-                case FieldDescriptorProto_Type.MESSAGE:
-                case FieldDescriptorProto_Type.BYTES:
-                    assert(!packed, `invalid descriptor: ${FieldDescriptorProto_Type[proto.type]} cannot be packed`);
-                    break;
-            }
-            break;
-    }
-    const field = {
-        proto,
-        name: proto.name,
-        number: proto.number,
-        type: proto.type,
-        parent,
-        oneof: proto.proto3Optional === true ? undefined : oneof,
-        optional,
-        packed,
-        toString() {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
-            return `field ${parent.typeName}.${proto.name}`;
-        },
-        resolve(us) {
-            return resolveField(this, us);
-        },
-    };
-    if (oneof) {
-        oneof.fields.push(field);
-    }
-    return field;
-}
-function resolveField(u, us) {
-    var _a;
-    const repeated = u.proto.label === FieldDescriptorProto_Label.REPEATED;
-    switch (u.type) {
-        case FieldDescriptorProto_Type.MESSAGE:
-        case FieldDescriptorProto_Type.GROUP: {
-            assert(u.proto.typeName, `invalid descriptor: ${u.toString()} has type ${FieldDescriptorProto_Type[u.type]}, but type_name is unset`);
-            const refMessage = us.messages[u.proto.typeName];
-            assert(refMessage, `invalid descriptor: cannot find type_name "${u.proto.typeName}" specified by ${u.toString()}`);
-            if (((_a = refMessage.proto.options) === null || _a === void 0 ? void 0 : _a.mapEntry) !== undefined) {
-                return Object.assign(Object.assign({}, u), { repeated: false, scalarType: undefined, message: undefined, enum: undefined, map: resolveMap(refMessage, us) });
-            }
-            return Object.assign(Object.assign({}, u), { repeated, scalarType: undefined, message: refMessage, enum: undefined, map: undefined });
-        }
-        case FieldDescriptorProto_Type.ENUM: {
-            assert(u.proto.typeName, `invalid descriptor: ${u.toString()} has type ${FieldDescriptorProto_Type[u.type]}, but type_name is unset`);
-            const refEnum = us.enums[u.proto.typeName];
-            assert(refEnum, `invalid descriptor: cannot find type_name "${u.proto.typeName}" specified by ${u.toString()}`);
-            return Object.assign(Object.assign({}, u), { repeated, scalarType: undefined, message: undefined, enum: refEnum, map: undefined });
-        }
-        default: {
-            const scalarType = fieldTypeToScalarType[u.type];
-            assert(scalarType, `invalid descriptor: unable to convert google.protobuf.FieldDescriptorProto.Type ${FieldDescriptorProto_Type[u.type]} to ScalarType`);
-            return Object.assign(Object.assign({}, u), { repeated,
-                scalarType, message: undefined, enum: undefined, map: undefined });
-        }
-    }
-}
-function resolveMap(mapEntry, us) {
-    var _a;
-    assert((_a = mapEntry.proto.options) === null || _a === void 0 ? void 0 : _a.mapEntry, `invalid descriptor: expected ${mapEntry.toString()} to be a map entry`);
-    assert(mapEntry.fields.length === 2, `invalid descriptor: map entry ${mapEntry.toString()} has ${mapEntry.fields.length} fields`);
-    const uKeyField = mapEntry.fields.find((f) => f.proto.number === 1);
-    assert(uKeyField, `invalid descriptor: map entry ${mapEntry.toString()} is missing key field`);
-    const keyField = resolveField(uKeyField, us);
-    assert(keyField.scalarType !== undefined &&
-        keyField.scalarType !== ScalarType.BYTES &&
-        keyField.scalarType !== ScalarType.FLOAT &&
-        keyField.scalarType !== ScalarType.DOUBLE, `invalid descriptor: map entry ${mapEntry.toString()} has unexpected key type ${FieldDescriptorProto_Type[keyField.type]}`);
-    const uValueField = mapEntry.fields.find((f) => f.proto.number === 2);
-    assert(uValueField, `invalid descriptor: map entry ${mapEntry.toString()} is missing value field`);
-    const valueField = resolveField(uValueField, us);
-    if (valueField.scalarType !== undefined) {
-        return {
-            key: keyField.scalarType,
-            value: {
-                scalarType: valueField.scalarType,
-                enum: undefined,
-                message: undefined,
-            },
-        };
-    }
-    if (valueField.enum !== undefined) {
-        return {
-            key: keyField.scalarType,
-            value: { scalar: undefined, enum: valueField.enum, message: undefined },
-        };
-    }
-    if (valueField.message !== undefined) {
-        return {
-            key: keyField.scalarType,
-            value: {
-                scalar: undefined,
-                enum: undefined,
-                message: valueField.message,
-            },
-        };
-    }
-    throw new Error(`invalid descriptor: map entry ${mapEntry.toString()} has unexpected value type ${FieldDescriptorProto_Type[keyField.type]}`);
-}
-function newOneof(proto, parent, file) {
-    assert(proto.name, `invalid descriptor: missing oneof descriptor name`);
-    return {
-        proto,
-        parent,
-        file,
-        fields: [],
-        name: proto.name,
-        toString() {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
-            return `oneof ${parent.typeName}.${proto.name}`;
-        },
-    };
-}
-function newExtension(proto, parent, file, us // eslint-disable-line @typescript-eslint/no-unused-vars
-) {
-    assert(proto.name, `invalid descriptor: missing field descriptor name`);
-    return {
-        proto,
-        file,
-        parent,
-    };
-}
-function newService(proto, file, us) {
-    assert(proto.name, `invalid descriptor: missing service descriptor name`);
-    let protoTypeName;
-    if (file.proto.package !== undefined) {
-        protoTypeName = `.${file.proto.package}.${proto.name}`;
-    }
-    else {
-        protoTypeName = `.${proto.name}`;
-    }
-    const methods = [];
-    const service = {
-        proto,
-        file,
-        typeName: protoTypeName.startsWith(".")
-            ? protoTypeName.substring(1)
-            : protoTypeName,
-        protoTypeName,
-        methods,
-        toString() {
-            return `service ${this.typeName}`;
-        },
-    };
-    for (const method of proto.method) {
-        methods.push(newMethod(method, service));
-    }
-    us.services[service.protoTypeName] = service;
-    return service;
-}
-function newMethod(proto, parent) {
-    var _a;
-    assert(proto.name, `invalid descriptor: missing method descriptor name`);
-    assert(proto.inputType, `invalid descriptor: missing method input type`);
-    assert(proto.outputType, `invalid descriptor: missing method output type`);
-    let kind;
-    if (proto.clientStreaming === true && proto.serverStreaming === true) {
-        kind = MethodKind.BiDiStreaming;
-    }
-    else if (proto.clientStreaming === true) {
-        kind = MethodKind.ClientStreaming;
-    }
-    else if (proto.serverStreaming === true) {
-        kind = MethodKind.ServerStreaming;
-    }
-    else {
-        kind = MethodKind.Unary;
-    }
-    let idempotency;
-    switch ((_a = proto.options) === null || _a === void 0 ? void 0 : _a.idempotencyLevel) {
-        case MethodOptions_IdempotencyLevel.IDEMPOTENT:
-            idempotency = MethodIdempotency.Idempotent;
-            break;
-        case MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS:
-            idempotency = MethodIdempotency.NoSideEffects;
-            break;
-        case MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN:
-        case undefined:
-            idempotency = undefined;
-            break;
-    }
-    const inputTypeName = proto.inputType.startsWith(".")
-        ? proto.inputType.substring(1)
-        : proto.inputType;
-    const outputTypeName = proto.outputType.startsWith(".")
-        ? proto.outputType.substring(1)
-        : proto.outputType;
-    return {
-        proto,
-        parent,
-        name: proto.name,
-        kind,
-        idempotency,
-        inputTypeName,
-        outputTypeName,
-        toString() {
-            // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
-            return `rpc ${this.parent.typeName}.${proto.name}`;
-        },
-    };
-}
+export {};

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

@@ -1144,8 +1144,8 @@ UninterpretedOption.fields = proto2.util.newFieldList(() => [
  * The name of the uninterpreted option.  Each string represents a segment in
  * a dot-separated name.  is_extension is true iff a segment represents an
  * extension (denoted with parentheses in options specs in .proto files).
- * E.g.,{ ["foo", false], ["bar.baz", true], ["qux", false] } represents
- * "foo.(bar.baz).qux".
+ * E.g.,{ ["foo", false], ["bar.baz", true], ["moo", false] } represents
+ * "foo.(bar.baz).moo".
  *
  * @generated from message google.protobuf.UninterpretedOption.NamePart
  */

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

@@ -22,7 +22,6 @@ import { proto3 } from "../../proto3.js";
  *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
  *     }
  *
- * The JSON representation for `Empty` is empty JSON object `{}`.
  *
  * @generated from message google.protobuf.Empty
  */

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 v0.0.8 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es v0.1.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 v0.0.8 with parameter "bootstrap_wkt=true,ts_nocheck=false,target=ts"
+// @generated by protoc-gen-es v0.1.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/google/varint.js

@@ -107,22 +107,20 @@ export function varint64write(lo, hi, bytes) {
     bytes.push((hi >>> 31) & 0x01);
 }
 // constants for binary math
-const TWO_PWR_32_DBL = (1 << 16) * (1 << 16);
+const TWO_PWR_32_DBL = 0x100000000;
 /**
  * Parse decimal string of 64 bit integer value as two JS numbers.
  *
- * Returns tuple:
- * [0]: minus sign?
- * [1]: low bits
- * [2]: high bits
+ * Copyright 2008 Google Inc.  All rights reserved.
  *
- * Copyright 2008 Google Inc.
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
  */
-export function int64fromString(dec) {
+export function int64FromString(dec) {
     // Check for minus sign.
-    let minus = dec[0] == "-";
-    if (minus)
+    const minus = dec[0] === "-";
+    if (minus) {
         dec = dec.slice(1);
+    }
     // Work 6 decimal digits at a time, acting like we're converting base 1e6
     // digits to binary. This is safe to do with floating point math because
     // Number.isSafeInteger(ALL_32_BITS * 1e6) == true.
@@ -144,18 +142,45 @@ export function int64fromString(dec) {
     add1e6digit(-18, -12);
     add1e6digit(-12, -6);
     add1e6digit(-6);
-    return [minus, lowBits, highBits];
+    return minus ? negate(lowBits, highBits) : newBits(lowBits, highBits);
 }
 /**
- * Format 64 bit integer value (as two JS numbers) to decimal string.
+ * Losslessly converts a 64-bit signed integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export function int64ToString(lo, hi) {
+    let bits = newBits(lo, hi);
+    // If we're treating the input as a signed value and the high bit is set, do
+    // a manual two's complement conversion before the decimal conversion.
+    const negative = (bits.hi & 0x80000000);
+    if (negative) {
+        bits = negate(bits.lo, bits.hi);
+    }
+    const result = uInt64ToString(bits.lo, bits.hi);
+    return negative ? "-" + result : result;
+}
+/**
+ * Losslessly converts a 64-bit unsigned integer in 32:32 split representation
+ * into a decimal string.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
  *
- * Copyright 2008 Google Inc.
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
  */
-export function int64toString(bitsLow, bitsHigh) {
+export function uInt64ToString(lo, hi) {
+    ({ lo, hi } = toUnsigned(lo, hi));
     // Skip the expensive conversion if the number is small enough to use the
     // built-in conversions.
-    if (bitsHigh <= 0x1fffff) {
-        return "" + (TWO_PWR_32_DBL * bitsHigh + bitsLow);
+    // Number.MAX_SAFE_INTEGER = 0x001FFFFF FFFFFFFF, thus any number with
+    // highBits <= 0x1FFFFF can be safely expressed with a double and retain
+    // integer precision.
+    // Proven by: Number.isSafeInteger(0x1FFFFF * 2**32 + 0xFFFFFFFF) == true.
+    if (hi <= 0x1FFFFF) {
+        return String(TWO_PWR_32_DBL * hi + lo);
     }
     // What this code is doing is essentially converting the input number from
     // base-2 to base-1e7, which allows us to represent the 64-bit range with
@@ -166,17 +191,17 @@ export function int64toString(bitsLow, bitsHigh) {
     // 2^48 = 281474976710656 = (2,8147497,6710656) in base-1e7.
     // Split 32:32 representation into 16:24:24 representation so our
     // intermediate digits don't overflow.
-    let low = bitsLow & 0xffffff;
-    let mid = (((bitsLow >>> 24) | (bitsHigh << 8)) >>> 0) & 0xffffff;
-    let high = (bitsHigh >> 16) & 0xffff;
+    const low = lo & 0xFFFFFF;
+    const mid = ((lo >>> 24) | (hi << 8)) & 0xFFFFFF;
+    const high = (hi >> 16) & 0xFFFF;
     // Assemble our three base-1e7 digits, ignoring carries. The maximum
     // value in a digit at this step is representable as a 48-bit integer, which
     // can be stored in a 64-bit floating point number.
-    let digitA = low + mid * 6777216 + high * 6710656;
-    let digitB = mid + high * 8147497;
-    let digitC = high * 2;
+    let digitA = low + (mid * 6777216) + (high * 6710656);
+    let digitB = mid + (high * 8147497);
+    let digitC = (high * 2);
     // Apply carries from A to B and from B to C.
-    let base = 10000000;
+    const base = 10000000;
     if (digitA >= base) {
         digitB += Math.floor(digitA / base);
         digitA %= base;
@@ -185,20 +210,42 @@ export function int64toString(bitsLow, bitsHigh) {
         digitC += Math.floor(digitB / base);
         digitB %= base;
     }
-    // Convert base-1e7 digits to base-10, with optional leading zeroes.
-    function decimalFrom1e7(digit1e7, needLeadingZeros) {
-        let partial = digit1e7 ? String(digit1e7) : "";
-        if (needLeadingZeros) {
-            return "0000000".slice(partial.length) + partial;
-        }
-        return partial;
+    // If digitC is 0, then we should have returned in the trivial code path
+    // at the top for non-safe integers. Given this, we can assume both digitB
+    // and digitA need leading zeros.
+    return digitC.toString() + decimalFrom1e7WithLeadingZeros(digitB) +
+        decimalFrom1e7WithLeadingZeros(digitA);
+}
+function toUnsigned(lo, hi) {
+    return { lo: lo >>> 0, hi: hi >>> 0 };
+}
+function newBits(lo, hi) {
+    return { lo: lo | 0, hi: hi | 0 };
+}
+/**
+ * Returns two's compliment negation of input.
+ * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Signed_32-bit_integers
+ */
+function negate(lowBits, highBits) {
+    highBits = ~highBits;
+    if (lowBits) {
+        lowBits = ~lowBits + 1;
+    }
+    else {
+        // If lowBits is 0, then bitwise-not is 0xFFFFFFFF,
+        // adding 1 to that, results in 0x100000000, which leaves
+        // the low bits 0x0 and simply adds one to the high bits.
+        highBits += 1;
     }
-    return (decimalFrom1e7(digitC, /*needLeadingZeros=*/ 0) +
-        decimalFrom1e7(digitB, /*needLeadingZeros=*/ digitC) +
-        // If the final 1e7 digit didn't need leading zeros, we would have
-        // returned via the trivial code path at the top.
-        decimalFrom1e7(digitA, /*needLeadingZeros=*/ 1));
+    return newBits(lowBits, highBits);
 }
+/**
+ * Returns decimal representation of digit1e7 with leading zeros.
+ */
+const decimalFrom1e7WithLeadingZeros = (digit1e7) => {
+    const partial = String(digit1e7);
+    return "0000000".slice(partial.length) + partial;
+};
 /**
  * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
  *

package/dist/esm/index.js

@@ -15,14 +15,17 @@ export { proto3 } from "./proto3.js";
 export { proto2 } from "./proto2.js";
 export { protoInt64 } from "./proto-int64.js";
 export { protoBase64 } from "./proto-base64.js";
+export { codegenInfo } from "./codegen-info.js";
 export { Message, } from "./message.js";
 export { ScalarType } from "./field.js";
 export { MethodKind, MethodIdempotency } from "./service-type.js";
-export { TypeRegistry } from "./type-registry.js";
-export { DescriptorRegistry } from "./descriptor-registry.js";
-export { DescriptorSet } from "./descriptor-set.js";
 export { WireType, BinaryWriter, BinaryReader } from "./binary-encoding.js";
 export {} from "./json-format.js";
+export {} from "./descriptor-set.js";
+export { createDescriptorSet } from "./create-descriptor-set.js";
+export {} from "./type-registry.js";
+export { createRegistry } from "./create-registry.js";
+export { createRegistryFromDescriptors } from "./create-registry-from-desc.js";
 // ideally, we would export these types with sub-path exports:
 export * from "./google/protobuf/compiler/plugin_pb.js";
 export * from "./google/protobuf/api_pb.js";