@bufbuild/protobuf 0.0.1-alpha.1

package/dist/esm/google/varint.js

@@ -0,0 +1,265 @@
+// Copyright 2008 Google Inc.  All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+// Code generated by the Protocol Buffer compiler is owned by the owner
+// of the input file used when generating it.  This code is not
+// standalone and requires a support library to be linked with it.  This
+// support library is itself covered by the above license.
+/* eslint-disable prefer-const,@typescript-eslint/restrict-plus-operands */
+/**
+ * Read a 64 bit varint as two JS numbers.
+ *
+ * Returns tuple:
+ * [0]: low bits
+ * [1]: high bits
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L175
+ */
+export function varint64read() {
+  let lowBits = 0;
+  let highBits = 0;
+  for (let shift = 0; shift < 28; shift += 7) {
+    let b = this.buf[this.pos++];
+    lowBits |= (b & 0x7f) << shift;
+    if ((b & 0x80) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  let middleByte = this.buf[this.pos++];
+  // last four bits of the first 32 bit number
+  lowBits |= (middleByte & 0x0f) << 28;
+  // 3 upper bits are part of the next 32 bit number
+  highBits = (middleByte & 0x70) >> 4;
+  if ((middleByte & 0x80) == 0) {
+    this.assertBounds();
+    return [lowBits, highBits];
+  }
+  for (let shift = 3; shift <= 31; shift += 7) {
+    let b = this.buf[this.pos++];
+    highBits |= (b & 0x7f) << shift;
+    if ((b & 0x80) == 0) {
+      this.assertBounds();
+      return [lowBits, highBits];
+    }
+  }
+  throw new Error("invalid varint");
+}
+/**
+ * Write a 64 bit varint, given as two JS numbers, to the given bytes array.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/writer.js#L344
+ */
+export function varint64write(lo, hi, bytes) {
+  for (let i = 0; i < 28; i = i + 7) {
+    const shift = lo >>> i;
+    const hasNext = !(shift >>> 7 == 0 && hi == 0);
+    const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+    bytes.push(byte);
+    if (!hasNext) {
+      return;
+    }
+  }
+  const splitBits = ((lo >>> 28) & 0x0f) | ((hi & 0x07) << 4);
+  const hasMoreBits = !(hi >> 3 == 0);
+  bytes.push((hasMoreBits ? splitBits | 0x80 : splitBits) & 0xff);
+  if (!hasMoreBits) {
+    return;
+  }
+  for (let i = 3; i < 31; i = i + 7) {
+    const shift = hi >>> i;
+    const hasNext = !(shift >>> 7 == 0);
+    const byte = (hasNext ? shift | 0x80 : shift) & 0xff;
+    bytes.push(byte);
+    if (!hasNext) {
+      return;
+    }
+  }
+  bytes.push((hi >>> 31) & 0x01);
+}
+// constants for binary math
+const TWO_PWR_32_DBL = (1 << 16) * (1 << 16);
+/**
+ * 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.
+ */
+export function int64fromString(dec) {
+  // Check for minus sign.
+  let 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.
+  const base = 1e6;
+  let lowBits = 0;
+  let highBits = 0;
+  function add1e6digit(begin, end) {
+    // Note: Number('') is 0.
+    const digit1e6 = Number(dec.slice(begin, end));
+    highBits *= base;
+    lowBits = lowBits * base + digit1e6;
+    // Carry bits from lowBits to
+    if (lowBits >= TWO_PWR_32_DBL) {
+      highBits = highBits + ((lowBits / TWO_PWR_32_DBL) | 0);
+      lowBits = lowBits % TWO_PWR_32_DBL;
+    }
+  }
+  add1e6digit(-24, -18);
+  add1e6digit(-18, -12);
+  add1e6digit(-12, -6);
+  add1e6digit(-6);
+  return [minus, lowBits, highBits];
+}
+/**
+ * Format 64 bit integer value (as two JS numbers) to decimal string.
+ *
+ * Copyright 2008 Google Inc.
+ */
+export function int64toString(bitsLow, bitsHigh) {
+  // 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);
+  }
+  // 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
+  // only 3 (very large) digits. Those digits are then trivial to convert to
+  // a base-10 string.
+  // The magic numbers used here are -
+  // 2^24 = 16777216 = (1,6777216) in base-1e7.
+  // 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;
+  // 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;
+  // Apply carries from A to B and from B to C.
+  let base = 10000000;
+  if (digitA >= base) {
+    digitB += Math.floor(digitA / base);
+    digitA %= base;
+  }
+  if (digitB >= base) {
+    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;
+  }
+  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)
+  );
+}
+/**
+ * Write a 32 bit varint, signed or unsigned. Same as `varint64write(0, value, bytes)`
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/1b18833f4f2a2f681f4e4a25cdf3b0a43115ec26/js/binary/encoder.js#L144
+ */
+export function varint32write(value, bytes) {
+  if (value >= 0) {
+    // write value as varint 32
+    while (value > 0x7f) {
+      bytes.push((value & 0x7f) | 0x80);
+      value = value >>> 7;
+    }
+    bytes.push(value);
+  } else {
+    for (let i = 0; i < 9; i++) {
+      bytes.push((value & 127) | 128);
+      value = value >> 7;
+    }
+    bytes.push(1);
+  }
+}
+/**
+ * Read an unsigned 32 bit varint.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+ */
+export function varint32read() {
+  let b = this.buf[this.pos++];
+  let result = b & 0x7f;
+  if ((b & 0x80) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 0x7f) << 7;
+  if ((b & 0x80) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 0x7f) << 14;
+  if ((b & 0x80) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  b = this.buf[this.pos++];
+  result |= (b & 0x7f) << 21;
+  if ((b & 0x80) == 0) {
+    this.assertBounds();
+    return result;
+  }
+  // Extract only last 4 bits
+  b = this.buf[this.pos++];
+  result |= (b & 0x0f) << 28;
+  for (let readBytes = 5; (b & 0x80) !== 0 && readBytes < 10; readBytes++)
+    b = this.buf[this.pos++];
+  if ((b & 0x80) != 0) throw new Error("invalid varint");
+  this.assertBounds();
+  // Result can have 32 bits, convert it to unsigned
+  return result >>> 0;
+}

package/dist/esm/index.js

@@ -0,0 +1,24 @@
+export { proto3 } from "./proto3.js";
+export { proto2 } from "./proto2.js";
+export { protoInt64 } from "./proto-int64.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";
+// 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";
+export * from "./google/protobuf/any_pb.js";
+export * from "./google/protobuf/descriptor_pb.js";
+export * from "./google/protobuf/duration_pb.js";
+export * from "./google/protobuf/empty_pb.js";
+export * from "./google/protobuf/field_mask_pb.js";
+export * from "./google/protobuf/source_context_pb.js";
+export * from "./google/protobuf/struct_pb.js";
+export * from "./google/protobuf/timestamp_pb.js";
+export * from "./google/protobuf/type_pb.js";
+export * from "./google/protobuf/wrappers_pb.js";

package/dist/esm/json-format.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/message-type.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/message.js

@@ -0,0 +1,94 @@
+/**
+ * Message is the base class of every message, generated, or created at
+ * runtime.
+ *
+ * It is _not_ safe to extend this class. If you want to create a message at
+ * run time, use proto3.makeMessageType().
+ */
+export class Message {
+  /**
+   * Compare with a message of the same type.
+   */
+  equals(other) {
+    return this.getType().runtime.util.equals(this.getType(), this, other);
+  }
+  /**
+   * Create a deep copy.
+   */
+  clone() {
+    // return this.getType().runtime.util.clone(this);
+    return this.getType().runtime.util.clone(this);
+  }
+  /**
+   * Parse from binary data, merging fields.
+   *
+   * Repeated fields are appended. Map entries are added, overwriting
+   * existing keys.
+   *
+   * If a message field is already present, it will be merged with the
+   * new data.
+   */
+  fromBinary(bytes, options) {
+    const type = this.getType(),
+      format = type.runtime.bin,
+      opt = format.makeReadOptions(options);
+    format.readMessage(this, opt.readerFactory(bytes), bytes.byteLength, opt);
+    return this;
+  }
+  /**
+   * Parse a message from a JSON value.
+   */
+  fromJson(jsonValue, options) {
+    const type = this.getType(),
+      format = type.runtime.json,
+      opt = format.makeReadOptions(options);
+    format.readMessage(type, jsonValue, opt, this);
+    return this;
+  }
+  /**
+   * Parse a message from a JSON string.
+   */
+  fromJsonString(jsonString, options) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- assigning to JsonValue is safe here
+    return this.fromJson(JSON.parse(jsonString), options);
+  }
+  /**
+   * Serialize the message to binary data.
+   */
+  toBinary(options) {
+    const type = this.getType(),
+      bin = type.runtime.bin,
+      opt = bin.makeWriteOptions(options),
+      writer = opt.writerFactory();
+    bin.writeMessage(this, writer, opt);
+    return writer.finish();
+  }
+  /**
+   * Serialize the message to a JSON value, a JavaScript value that can be
+   * passed to JSON.stringify().
+   */
+  toJson(options) {
+    const type = this.getType(),
+      json = type.runtime.json,
+      opt = json.makeWriteOptions(options);
+    return json.writeMessage(this, opt);
+  }
+  /**
+   * Serialize the message to a JSON string.
+   */
+  toJsonString(options) {
+    const value = this.toJson(options);
+    return JSON.stringify(value, null, options?.prettySpaces ?? 0);
+  }
+  /**
+   * Retrieve the MessageType of this message - a singleton that represents
+   * the protobuf message declaration and provides metadata for reflection-
+   * based operations.
+   */
+  getType() {
+    // Any class that extends Message _must_ provide a complete static
+    // implementation of MessageType.
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return
+    return Object.getPrototypeOf(this).constructor;
+  }
+}

package/dist/esm/private/assert.js

@@ -0,0 +1,41 @@
+/**
+ * Assert that condition is truthy or throw error (with message)
+ */
+export function assert(condition, msg) {
+  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- we want the implicit conversion to boolean
+  if (!condition) {
+    throw new Error(msg);
+  }
+}
+const FLOAT32_MAX = 3.4028234663852886e38,
+  FLOAT32_MIN = -3.4028234663852886e38,
+  UINT32_MAX = 0xffffffff,
+  INT32_MAX = 0x7fffffff,
+  INT32_MIN = -0x80000000;
+/**
+ * Assert a valid signed protobuf 32-bit integer.
+ */
+export function assertInt32(arg) {
+  if (typeof arg !== "number") throw new Error("invalid int 32: " + typeof arg);
+  if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN)
+    throw new Error("invalid int 32: " + arg); // eslint-disable-line @typescript-eslint/restrict-plus-operands -- we want the implicit conversion to string
+}
+/**
+ * Assert a valid unsigned protobuf 32-bit integer.
+ */
+export function assertUInt32(arg) {
+  if (typeof arg !== "number")
+    throw new Error("invalid uint 32: " + typeof arg);
+  if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0)
+    throw new Error("invalid uint 32: " + arg); // eslint-disable-line @typescript-eslint/restrict-plus-operands -- we want the implicit conversion to string
+}
+/**
+ * Assert a valid protobuf float value.
+ */
+export function assertFloat32(arg) {
+  if (typeof arg !== "number")
+    throw new Error("invalid float 32: " + typeof arg);
+  if (!Number.isFinite(arg)) return;
+  if (arg > FLOAT32_MAX || arg < FLOAT32_MIN)
+    throw new Error("invalid float 32: " + arg); // eslint-disable-line @typescript-eslint/restrict-plus-operands -- we want the implicit conversion to string
+}

package/dist/esm/private/base64.js

@@ -0,0 +1,113 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment, @typescript-eslint/no-unnecessary-condition, prefer-const */
+// lookup table from base64 character to byte
+let encTable =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+// lookup table from base64 character *code* to byte because lookup by number is fast
+let decTable = [];
+for (let i = 0; i < encTable.length; i++)
+  decTable[encTable[i].charCodeAt(0)] = i;
+// support base64url variants
+decTable["-".charCodeAt(0)] = encTable.indexOf("+");
+decTable["_".charCodeAt(0)] = encTable.indexOf("/");
+/**
+ * Decodes a base64 string to a byte array.
+ *
+ * - ignores white-space, including line breaks and tabs
+ * - allows inner padding (can decode concatenated base64 strings)
+ * - does not require padding
+ * - understands base64url encoding:
+ *   "-" instead of "+",
+ *   "_" instead of "/",
+ *   no padding
+ */
+export function base64decode(base64Str) {
+  // estimate byte size, not accounting for inner padding and whitespace
+  let es = (base64Str.length * 3) / 4;
+  // if (es % 3 !== 0)
+  // throw new Error("invalid base64 string");
+  if (base64Str[base64Str.length - 2] == "=") es -= 2;
+  else if (base64Str[base64Str.length - 1] == "=") es -= 1;
+  let bytes = new Uint8Array(es),
+    bytePos = 0, // position in byte array
+    groupPos = 0, // position in base64 group
+    b, // current byte
+    p = 0; // previous byte
+  for (let i = 0; i < base64Str.length; i++) {
+    b = decTable[base64Str.charCodeAt(i)];
+    if (b === undefined) {
+      switch (base64Str[i]) {
+        // @ts-ignore TS7029: Fallthrough case in switch
+        case "=":
+          groupPos = 0; // reset state when padding found
+        // @ts-ignore TS7029: Fallthrough case in switch
+        case "\n":
+        case "\r":
+        case "\t":
+        case " ":
+          continue; // skip white-space, and padding
+        default:
+          throw Error("invalid base64 string.");
+      }
+    }
+    switch (groupPos) {
+      case 0:
+        p = b;
+        groupPos = 1;
+        break;
+      case 1:
+        bytes[bytePos++] = (p << 2) | ((b & 48) >> 4);
+        p = b;
+        groupPos = 2;
+        break;
+      case 2:
+        bytes[bytePos++] = ((p & 15) << 4) | ((b & 60) >> 2);
+        p = b;
+        groupPos = 3;
+        break;
+      case 3:
+        bytes[bytePos++] = ((p & 3) << 6) | b;
+        groupPos = 0;
+        break;
+    }
+  }
+  if (groupPos == 1) throw Error("invalid base64 string.");
+  return bytes.subarray(0, bytePos);
+}
+/**
+ * Encodes a byte array to a base64 string.
+ * Adds padding at the end.
+ * Does not insert newlines.
+ */
+export function base64encode(bytes) {
+  let base64 = "",
+    groupPos = 0, // position in base64 group
+    b, // current byte
+    p = 0; // carry over from previous byte
+  for (let i = 0; i < bytes.length; i++) {
+    b = bytes[i];
+    switch (groupPos) {
+      case 0:
+        base64 += encTable[b >> 2];
+        p = (b & 3) << 4;
+        groupPos = 1;
+        break;
+      case 1:
+        base64 += encTable[p | (b >> 4)];
+        p = (b & 15) << 2;
+        groupPos = 2;
+        break;
+      case 2:
+        base64 += encTable[p | (b >> 6)];
+        base64 += encTable[b & 63];
+        groupPos = 0;
+        break;
+    }
+  }
+  // padding required?
+  if (groupPos) {
+    base64 += encTable[p];
+    base64 += "=";
+    if (groupPos == 1) base64 += "=";
+  }
+  return base64;
+}