@bufbuild/protobuf 0.0.1-alpha.1 → 0.0.2-alpha.2

package/dist/esm/private/assert.js

@@ -1,41 +1,52 @@
+// Copyright 2021-2022 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.
 /**
  * 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);
-  }
+    // 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;
+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
+    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
+    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
+    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

@@ -1,11 +1,23 @@
+// Copyright 2021-2022 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.
 /* 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("");
+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;
+    decTable[encTable[i].charCodeAt(0)] = i;
 // support base64url variants
 decTable["-".charCodeAt(0)] = encTable.indexOf("+");
 decTable["_".charCodeAt(0)] = encTable.indexOf("/");
@@ -21,57 +33,59 @@ decTable["_".charCodeAt(0)] = encTable.indexOf("/");
  *   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
+    // 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.");
-      }
+    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;
+        }
     }
-    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);
+    if (groupPos == 1)
+        throw Error("invalid base64 string.");
+    return bytes.subarray(0, bytePos);
 }
 /**
  * Encodes a byte array to a base64 string.
@@ -79,35 +93,35 @@ export function base64decode(base64Str) {
  * Does not insert newlines.
  */
 export function base64encode(bytes) {
-  let base64 = "",
-    groupPos = 0, // position in base64 group
+    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;
+    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 += "=";
     }
-  }
-  // padding required?
-  if (groupPos) {
-    base64 += encTable[p];
-    base64 += "=";
-    if (groupPos == 1) base64 += "=";
-  }
-  return base64;
+    return base64;
 }