@bufbuild/protobuf 0.0.1-alpha.1

package/dist/cjs/google/varint.js

@@ -0,0 +1,280 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.varint32read =
+  exports.varint32write =
+  exports.int64toString =
+  exports.int64fromString =
+  exports.varint64write =
+  exports.varint64read =
+    void 0;
+/* 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
+ */
+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");
+}
+exports.varint64read = varint64read;
+/**
+ * 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
+ */
+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);
+}
+exports.varint64write = varint64write;
+// 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.
+ */
+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];
+}
+exports.int64fromString = int64fromString;
+/**
+ * Format 64 bit integer value (as two JS numbers) to decimal string.
+ *
+ * Copyright 2008 Google Inc.
+ */
+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)
+  );
+}
+exports.int64toString = int64toString;
+/**
+ * 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
+ */
+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);
+  }
+}
+exports.varint32write = varint32write;
+/**
+ * Read an unsigned 32 bit varint.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+ */
+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;
+}
+exports.varint32read = varint32read;

package/dist/cjs/index.js

@@ -0,0 +1,148 @@
+"use strict";
+var __createBinding =
+  (this && this.__createBinding) ||
+  (Object.create
+    ? function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (
+          !desc ||
+          ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)
+        ) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
+      }
+    : function (o, m, k, k2) {
+        if (k2 === undefined) k2 = k;
+        o[k2] = m[k];
+      });
+var __exportStar =
+  (this && this.__exportStar) ||
+  function (m, exports) {
+    for (var p in m)
+      if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p))
+        __createBinding(exports, m, p);
+  };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryReader =
+  exports.BinaryWriter =
+  exports.WireType =
+  exports.DescriptorSet =
+  exports.DescriptorRegistry =
+  exports.TypeRegistry =
+  exports.MethodIdempotency =
+  exports.MethodKind =
+  exports.ScalarType =
+  exports.Message =
+  exports.protoInt64 =
+  exports.proto2 =
+  exports.proto3 =
+    void 0;
+var proto3_js_1 = require("./proto3.js");
+Object.defineProperty(exports, "proto3", {
+  enumerable: true,
+  get: function () {
+    return proto3_js_1.proto3;
+  },
+});
+var proto2_js_1 = require("./proto2.js");
+Object.defineProperty(exports, "proto2", {
+  enumerable: true,
+  get: function () {
+    return proto2_js_1.proto2;
+  },
+});
+var proto_int64_js_1 = require("./proto-int64.js");
+Object.defineProperty(exports, "protoInt64", {
+  enumerable: true,
+  get: function () {
+    return proto_int64_js_1.protoInt64;
+  },
+});
+var message_js_1 = require("./message.js");
+Object.defineProperty(exports, "Message", {
+  enumerable: true,
+  get: function () {
+    return message_js_1.Message;
+  },
+});
+var field_js_1 = require("./field.js");
+Object.defineProperty(exports, "ScalarType", {
+  enumerable: true,
+  get: function () {
+    return field_js_1.ScalarType;
+  },
+});
+var service_type_js_1 = require("./service-type.js");
+Object.defineProperty(exports, "MethodKind", {
+  enumerable: true,
+  get: function () {
+    return service_type_js_1.MethodKind;
+  },
+});
+Object.defineProperty(exports, "MethodIdempotency", {
+  enumerable: true,
+  get: function () {
+    return service_type_js_1.MethodIdempotency;
+  },
+});
+var type_registry_js_1 = require("./type-registry.js");
+Object.defineProperty(exports, "TypeRegistry", {
+  enumerable: true,
+  get: function () {
+    return type_registry_js_1.TypeRegistry;
+  },
+});
+var descriptor_registry_js_1 = require("./descriptor-registry.js");
+Object.defineProperty(exports, "DescriptorRegistry", {
+  enumerable: true,
+  get: function () {
+    return descriptor_registry_js_1.DescriptorRegistry;
+  },
+});
+var descriptor_set_js_1 = require("./descriptor-set.js");
+Object.defineProperty(exports, "DescriptorSet", {
+  enumerable: true,
+  get: function () {
+    return descriptor_set_js_1.DescriptorSet;
+  },
+});
+var binary_encoding_js_1 = require("./binary-encoding.js");
+Object.defineProperty(exports, "WireType", {
+  enumerable: true,
+  get: function () {
+    return binary_encoding_js_1.WireType;
+  },
+});
+Object.defineProperty(exports, "BinaryWriter", {
+  enumerable: true,
+  get: function () {
+    return binary_encoding_js_1.BinaryWriter;
+  },
+});
+Object.defineProperty(exports, "BinaryReader", {
+  enumerable: true,
+  get: function () {
+    return binary_encoding_js_1.BinaryReader;
+  },
+});
+var json_format_js_1 = require("./json-format.js");
+// ideally, we would export these types with sub-path exports:
+__exportStar(require("./google/protobuf/compiler/plugin_pb.js"), exports);
+__exportStar(require("./google/protobuf/api_pb.js"), exports);
+__exportStar(require("./google/protobuf/any_pb.js"), exports);
+__exportStar(require("./google/protobuf/descriptor_pb.js"), exports);
+__exportStar(require("./google/protobuf/duration_pb.js"), exports);
+__exportStar(require("./google/protobuf/empty_pb.js"), exports);
+__exportStar(require("./google/protobuf/field_mask_pb.js"), exports);
+__exportStar(require("./google/protobuf/source_context_pb.js"), exports);
+__exportStar(require("./google/protobuf/struct_pb.js"), exports);
+__exportStar(require("./google/protobuf/timestamp_pb.js"), exports);
+__exportStar(require("./google/protobuf/type_pb.js"), exports);
+__exportStar(require("./google/protobuf/wrappers_pb.js"), exports);

package/dist/cjs/json-format.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/message-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/message.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+/**
+ * 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().
+ */
+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;
+  }
+}
+exports.Message = Message;

package/dist/cjs/private/assert.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertFloat32 =
+  exports.assertUInt32 =
+  exports.assertInt32 =
+  exports.assert =
+    void 0;
+/**
+ * Assert that condition is truthy or throw error (with message)
+ */
+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);
+  }
+}
+exports.assert = assert;
+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.
+ */
+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
+}
+exports.assertInt32 = assertInt32;
+/**
+ * Assert a valid unsigned protobuf 32-bit integer.
+ */
+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
+}
+exports.assertUInt32 = assertUInt32;
+/**
+ * Assert a valid protobuf float value.
+ */
+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
+}
+exports.assertFloat32 = assertFloat32;