protocolbuffers · Jan 23, 2025 · Jan 23, 2025 · Jan 23, 2025 · Jan 24, 2025 · Jan 24, 2025
diff --git a/.bazelversion b/.bazelversion
@@ -0,0 +1 @@
+7.2.1
diff --git a/asserts.d.ts b/asserts.d.ts
@@ -0,0 +1,63 @@
+/**
+ * Throws an exception with the given message and "Assertion failed" prefixed
+ * onto it.
+ * @param defaultMessage The message to use if givenMessage is empty.
+ * @param defaultArgs The substitution arguments for defaultMessage.
+ * @param givenMessage Message supplied by the caller.
+ * @param givenArgs The substitution arguments for givenMessage.
+ */
+export declare function doAssertFailure(defaultMessage: string, defaultArgs: any[] | null, givenMessage: string | undefined, givenArgs: any[]): void;
+/**
+ * Checks if the condition evaluates to true.
+ * @param condition The condition to check.
+ * @param opt_message Error message in case of failure.
+ * @param args The items to substitute into the failure message.
+ * @return The value of the condition.
+ */
+export declare function assert<T = any>(condition: T | null, opt_message?: string, ...args: any[]): T | null;
+/**
+ * Checks if the value is a string.
+ * @param value The value to check.
+ * @param opt_message Error message in case of failure.
+ * @param args The items to substitute into the failure message.
+ * @return The value, guaranteed to be a string when asserts enabled.
+ */
+export declare function assertString(value: any, opt_message?: string, ...args: any[]): string;
+/**
+ * Checks if the value is an Array.
+ * @param value The value to check.
+ * @param opt_message Error message in case of failure.
+ * @param args The items to substitute into the failure message.
+ * @return The value, guaranteed to be a non-null array.
+ */
+export declare function assertArray(value: any, opt_message?: string, ...args: any[]): any[];
+/**
+ * Triggers a failure. This function is useful in case when we want to add a
+ * check in the unreachable area like switch-case statement:
+ *
+ * <pre>
+ * switch(type) {
+ * case FOO: doSomething(); break;
+ * case BAR: doSomethingElse(); break;
+ * default: JspbFail('Unrecognized type: ' + type);
+ * // We have only 2 types - "default:" section is unreachable code.
+ * }
+ * </pre>
+ * @param opt_message Error message in case of failure.
+ * @param args The items to substitute into the failure message.
+ */
+export declare function fail(opt_message?: string, ...args: any[]): void;
+/**
+ * Checks if the value is an instance of the user-defined type.
+ *
+ * Do not use this to ensure a value is an HTMLElement or a subclass! Cross-
+ * document DOM inherits from separate - though identical - browser classes, and
+ * such a check will unexpectedly fail.
+ * @param value The value to check.
+ * @param type A user-defined constructor.
+ * @param opt_message Error message in case of failure.
+ * @param args The items to substitute into the failure message.
+ */
+export declare function assertInstanceof<T = any>(value: any, type: {
+    new (): T | null;
+}, opt_message?: string, ...args: any[]): T | null;
diff --git a/asserts.js b/asserts.js
@@ -9,8 +9,6 @@
  * invariants runtime.
  */
 
-goog.provide('jspb.asserts');
-
 /**
  * Throws an exception with the given message and "Assertion failed" prefixed
  * onto it.
@@ -20,7 +18,7 @@ goog.provide('jspb.asserts');
  * @param {!Array<*>} givenArgs The substitution arguments for givenMessage.
  * @throws {Error} When the value is not a number.
  */
-jspb.asserts.doAssertFailure = function(defaultMessage, defaultArgs, givenMessage, givenArgs) {
+export function doAssertFailure(defaultMessage, defaultArgs, givenMessage, givenArgs) {
   let message = 'Assertion failed';
   let args;
   if (givenMessage) {
@@ -45,14 +43,15 @@ jspb.asserts.doAssertFailure = function(defaultMessage, defaultArgs, givenMessag
  * @param {...*} args The items to substitute into the failure message.
  * @return {T} The value of the condition.
  * @throws {Error} When the condition evaluates to false.
+ * @closurePrimitive {asserts.truthy}
  */
 
-jspb.asserts.assert = function(condition, opt_message, ...args) {
+export function assert(condition, opt_message, ...args) {
   if (!condition) {
-    jspb.asserts.doAssertFailure('', null, opt_message, args);
+    doAssertFailure('', null, opt_message, args);
   }
   return condition;
-};
+}
 
 
 /**
@@ -63,14 +62,14 @@ jspb.asserts.assert = function(condition, opt_message, ...args) {
  * @return {string} The value, guaranteed to be a string when asserts enabled.
  * @throws {Error} When the value is not a string.
  */
-jspb.asserts.assertString = function(value, opt_message, ...args) {
+export function assertString(value, opt_message, ...args) {
   if (typeof value !== 'string') {
-    jspb.asserts.doAssertFailure(
+    doAssertFailure(
         'Expected string but got %s: %s.', [goog.typeOf(value), value],
         opt_message, args);
   }
   return /** @type {string} */ (value);
-};
+}
 
 
 /**
@@ -81,14 +80,14 @@ jspb.asserts.assertString = function(value, opt_message, ...args) {
  * @return {!Array<?>} The value, guaranteed to be a non-null array.
  * @throws {Error} When the value is not an array.
  */
-jspb.asserts.assertArray = function(value, opt_message, ...args) {
+export function assertArray(value, opt_message, ...args) {
   if (!Array.isArray(value)) {
-    jspb.asserts.doAssertFailure(
+    doAssertFailure(
         'Expected array but got %s: %s.', [goog.typeOf(value), value],
         opt_message, args);
   }
   return /** @type {!Array<?>} */ (value);
-};
+}
 
 /**
  * Triggers a failure. This function is useful in case when we want to add a
@@ -98,7 +97,7 @@ jspb.asserts.assertArray = function(value, opt_message, ...args) {
  *  switch(type) {
  *    case FOO: doSomething(); break;
  *    case BAR: doSomethingElse(); break;
- *    default: jspb.asserts.JspbFail('Unrecognized type: ' + type);
+ *    default: JspbFail('Unrecognized type: ' + type);
  *      // We have only 2 types - "default:" section is unreachable code.
  *  }
  * </pre>
@@ -108,11 +107,11 @@ jspb.asserts.assertArray = function(value, opt_message, ...args) {
  * @return {void}
  * @throws {Error} Failure.
  */
-jspb.asserts.fail = function(opt_message, ...args) {
+export function fail(opt_message, ...args) {
   throw new Error(
       'Failure' + (opt_message ? ': ' + opt_message : ''),
       args);
-};
+}
 
 /**
  * Checks if the value is an instance of the user-defined type.
@@ -130,15 +129,15 @@ jspb.asserts.fail = function(opt_message, ...args) {
  * @return {T}
  * @template T
  */
-jspb.asserts.assertInstanceof = function(value, type, opt_message, ...args) {
+export function assertInstanceof(value, type, opt_message, ...args) {
   if (!(value instanceof type)) {
-    jspb.asserts.doAssertFailure(
+    doAssertFailure(
         'Expected instanceof %s but got %s.',
-        [jspb.asserts.getType(type), jspb.asserts.getType(value)],
+        [getType(type), getType(value)],
         opt_message, args);
   }
   return value;
-};
+}
 
 /**
  * Returns the type of a value. If a constructor is passed, and a suitable
@@ -147,7 +146,7 @@ jspb.asserts.assertInstanceof = function(value, type, opt_message, ...args) {
  * @return {string} The best display name for the value, or 'unknown type name'.
  * @private
  */
-jspb.asserts.getType = function(value) {
+function getType(value) {
   if (value instanceof Function) {
     return value.displayName || value.name || 'unknown type name';
   } else if (value instanceof Object) {

diff --git a/binary/arith.d.ts b/binary/arith.d.ts
@@ -0,0 +1,143 @@
+/**
+ * UInt64 implements some 64-bit arithmetic routines necessary for properly
+ * handling 64-bit integer fields. It implements lossless integer arithmetic on
+ * top of JavaScript's number type, which has only 53 bits of precision, by
+ * representing 64-bit integers as two 32-bit halves.
+ */
+export declare class UInt64 {
+    /**
+     * UInt64 implements some 64-bit arithmetic routines necessary for properly
+     * handling 64-bit integer fields. It implements lossless integer arithmetic on
+     * top of JavaScript's number type, which has only 53 bits of precision, by
+     * representing 64-bit integers as two 32-bit halves.
+     * @param lo The low 32 bits.
+     * @param hi The high 32 bits.
+     */
+    constructor(lo: number, hi: number);
+    private noStructuralTyping____protobuf_javascript_binary_arith_UInt64;
+    /**
+     * The low 32 bits.
+     */
+    lo: number;
+    /**
+     * The high 32 bits.
+     */
+    hi: number;
+    /**
+     * Compare two 64-bit numbers. Returns -1 if the first is
+     * less, +1 if the first is greater, or 0 if both are equal.
+     */
+    cmp(other: UInt64): number;
+    /**
+     * Right-shift this number by one bit.
+     */
+    rightShift(): UInt64;
+    /**
+     * Left-shift this number by one bit.
+     */
+    leftShift(): UInt64;
+    /**
+     * Test the MSB.
+     */
+    msb(): boolean;
+    /**
+     * Test the LSB.
+     */
+    lsb(): boolean;
+    /**
+     * Test whether this number is zero.
+     */
+    zero(): boolean;
+    /**
+     * Add two 64-bit numbers to produce a 64-bit number.
+     */
+    add(other: UInt64): UInt64;
+    /**
+     * Subtract two 64-bit numbers to produce a 64-bit number.
+     */
+    sub(other: UInt64): UInt64;
+    /**
+     * Multiply two 32-bit numbers to produce a 64-bit number.
+     * @param a The first integer:  must be in [0, 2^32-1).
+     * @param b The second integer: must be in [0, 2^32-1).
+     */
+    static mul32x32(a: number, b: number): UInt64;
+    /**
+     * Multiply this number by a 32-bit number, producing a 96-bit number, then
+     * truncate the top 32 bits.
+     * @param a The multiplier.
+     */
+    mul(a: number): UInt64;
+    /**
+     * Divide a 64-bit number by a 32-bit number to produce a
+     * 64-bit quotient and a 32-bit remainder.
+     * @return array of [quotient, remainder], unless divisor is 0, in which case an empty array is returned.
+     */
+    div(_divisor: number): (UInt64 | null)[] | null;
+    /**
+     * Convert a 64-bit number to a string.
+     */
+    toString(): string;
+    /**
+     * Parse a string into a 64-bit number. Returns `null` on a parse error.
+     */
+    static fromString(s: string): UInt64 | null;
+    /**
+     * Make a copy of the uint64.
+     */
+    clone(): UInt64;
+}
+/**
+ * Int64 is like UInt64, but modifies string conversions to interpret the stored
+ * 64-bit value as a twos-complement-signed integer. It does *not* support the
+ * full range of operations that UInt64 does: only add, subtract, and string
+ * conversions.
+ *
+ * N.B. that multiply and divide routines are *NOT* supported. They will throw
+ * exceptions. (They are not necessary to implement string conversions, which
+ * are the only operations we really need in jspb.)
+ */
+export declare class Int64 {
+    /**
+     * Int64 is like UInt64, but modifies string conversions to interpret the stored
+     * 64-bit value as a twos-complement-signed integer. It does *not* support the
+     * full range of operations that UInt64 does: only add, subtract, and string
+     * conversions.
+     *
+     * N.B. that multiply and divide routines are *NOT* supported. They will throw
+     * exceptions. (They are not necessary to implement string conversions, which
+     * are the only operations we really need in jspb.)
+     * @param lo The low 32 bits.
+     * @param hi The high 32 bits.
+     */
+    constructor(lo: number, hi: number);
+    private noStructuralTyping____protobuf_javascript_binary_arith_Int64;
+    /**
+     * The low 32 bits.
+     */
+    lo: number;
+    /**
+     * The high 32 bits.
+     */
+    hi: number;
+    /**
+     * Add two 64-bit numbers to produce a 64-bit number.
+     */
+    add(other: Int64): Int64;
+    /**
+     * Subtract two 64-bit numbers to produce a 64-bit number.
+     */
+    sub(other: Int64): Int64;
+    /**
+     * Make a copy of the int64.
+     */
+    clone(): Int64;
+    /**
+     * Convert a 64-bit number to a string.
+     */
+    toString(): string;
+    /**
+     * Parse a string into a 64-bit number. Returns `null` on a parse error.
+     */
+    static fromString(s: string): Int64 | null;
+}