@aptre/protobuf-es-lite 0.2.7 → 0.2.9

package/dist/util.js

@@ -15,8 +15,10 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFieldZeroValueExpression = exports.getFieldDefaultValueExpression = exports.getFieldTypeInfo = void 0;
-const protobuf_1 = require("@bufbuild/protobuf");
-const ecmascript_1 = require("@bufbuild/protoplugin/ecmascript");
+const descriptor_pb_js_1 = require("./google/protobuf/descriptor.pb.js");
+const codegen_info_js_1 = require("./codegen-info.js");
+const scalar_js_1 = require("./scalar.js");
+const names_js_1 = require("./names.js");
 function getFieldTypeInfo(field) {
     const typing = [];
     let typingInferrableFromZeroValue;
@@ -26,13 +28,13 @@ function getFieldTypeInfo(field) {
             typing.push(scalarTypeScriptType(field.scalar, field.longType));
             optional =
                 field.optional ||
-                    field.proto.label === protobuf_1.FieldDescriptorProto_Label.REQUIRED;
+                    field.proto.label === descriptor_pb_js_1.FieldDescriptorProto_Label.REQUIRED;
             typingInferrableFromZeroValue = true;
             break;
         case "message": {
-            const baseType = protobuf_1.codegenInfo.getUnwrappedFieldType(field);
+            const baseType = codegen_info_js_1.codegenInfo.getUnwrappedFieldType(field);
             if (baseType !== undefined) {
-                typing.push(scalarTypeScriptType(baseType, protobuf_1.LongType.BIGINT));
+                typing.push(scalarTypeScriptType(baseType, scalar_js_1.LongType.BIGINT));
             }
             else {
                 typing.push({
@@ -53,17 +55,17 @@ function getFieldTypeInfo(field) {
             });
             optional =
                 field.optional ||
-                    field.proto.label === protobuf_1.FieldDescriptorProto_Label.REQUIRED;
+                    field.proto.label === descriptor_pb_js_1.FieldDescriptorProto_Label.REQUIRED;
             typingInferrableFromZeroValue = true;
             break;
         case "map": {
             let keyType;
             switch (field.mapKey) {
-                case protobuf_1.ScalarType.INT32:
-                case protobuf_1.ScalarType.FIXED32:
-                case protobuf_1.ScalarType.UINT32:
-                case protobuf_1.ScalarType.SFIXED32:
-                case protobuf_1.ScalarType.SINT32:
+                case scalar_js_1.ScalarType.INT32:
+                case scalar_js_1.ScalarType.FIXED32:
+                case scalar_js_1.ScalarType.UINT32:
+                case scalar_js_1.ScalarType.SFIXED32:
+                case scalar_js_1.ScalarType.SINT32:
                     keyType = "number";
                     break;
                 default:
@@ -73,7 +75,7 @@ function getFieldTypeInfo(field) {
             let valueType;
             switch (field.mapValue.kind) {
                 case "scalar":
-                    valueType = scalarTypeScriptType(field.mapValue.scalar, protobuf_1.LongType.BIGINT);
+                    valueType = scalarTypeScriptType(field.mapValue.scalar, scalar_js_1.LongType.BIGINT);
                     break;
                 case "message":
                     valueType = {
@@ -161,7 +163,7 @@ function getFieldZeroValueExpression(field, enumAs = "enum_value_as_is") {
             return literalEnumValue(zeroValue, enumAs);
         }
         case "scalar": {
-            const defaultValue = protobuf_1.codegenInfo.scalarZeroValue(field.scalar, field.longType);
+            const defaultValue = codegen_info_js_1.codegenInfo.scalarZeroValue(field.scalar, field.longType);
             return literalScalarValue(defaultValue, field);
         }
     }
@@ -169,39 +171,39 @@ function getFieldZeroValueExpression(field, enumAs = "enum_value_as_is") {
 exports.getFieldZeroValueExpression = getFieldZeroValueExpression;
 function literalScalarValue(value, field) {
     switch (field.scalar) {
-        case protobuf_1.ScalarType.DOUBLE:
-        case protobuf_1.ScalarType.FLOAT:
-        case protobuf_1.ScalarType.INT32:
-        case protobuf_1.ScalarType.FIXED32:
-        case protobuf_1.ScalarType.UINT32:
-        case protobuf_1.ScalarType.SFIXED32:
-        case protobuf_1.ScalarType.SINT32:
+        case scalar_js_1.ScalarType.DOUBLE:
+        case scalar_js_1.ScalarType.FLOAT:
+        case scalar_js_1.ScalarType.INT32:
+        case scalar_js_1.ScalarType.FIXED32:
+        case scalar_js_1.ScalarType.UINT32:
+        case scalar_js_1.ScalarType.SFIXED32:
+        case scalar_js_1.ScalarType.SINT32:
             if (typeof value != "number") {
-                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
+                throw new Error(`Unexpected value for ${scalar_js_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
             }
             return value;
-        case protobuf_1.ScalarType.BOOL:
+        case scalar_js_1.ScalarType.BOOL:
             if (typeof value != "boolean") {
-                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
+                throw new Error(`Unexpected value for ${scalar_js_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
             }
             return value;
-        case protobuf_1.ScalarType.STRING:
+        case scalar_js_1.ScalarType.STRING:
             if (typeof value != "string") {
-                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
+                throw new Error(`Unexpected value for ${scalar_js_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
             }
             return { kind: "es_string", value };
-        case protobuf_1.ScalarType.BYTES:
+        case scalar_js_1.ScalarType.BYTES:
             if (!(value instanceof Uint8Array)) {
-                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
+                throw new Error(`Unexpected value for ${scalar_js_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
             }
             return value;
-        case protobuf_1.ScalarType.INT64:
-        case protobuf_1.ScalarType.SINT64:
-        case protobuf_1.ScalarType.SFIXED64:
-        case protobuf_1.ScalarType.UINT64:
-        case protobuf_1.ScalarType.FIXED64:
+        case scalar_js_1.ScalarType.INT64:
+        case scalar_js_1.ScalarType.SINT64:
+        case scalar_js_1.ScalarType.SFIXED64:
+        case scalar_js_1.ScalarType.UINT64:
+        case scalar_js_1.ScalarType.FIXED64:
             if (typeof value != "bigint" && typeof value != "string") {
-                throw new Error(`Unexpected value for ${protobuf_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
+                throw new Error(`Unexpected value for ${scalar_js_1.ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`);
             }
             return {
                 kind: "es_proto_int64",
@@ -217,7 +219,7 @@ function literalEnumValue(value, enumAs) {
             return [
                 { kind: "es_ref_enum", type: value.parent, typeOnly: false },
                 ".",
-                (0, ecmascript_1.localName)(value),
+                (0, names_js_1.localName)(value),
             ];
         case "enum_value_as_integer":
             return [
@@ -234,26 +236,26 @@ function literalEnumValue(value, enumAs) {
                 " as ",
                 { kind: "es_ref_enum", type: value.parent, typeOnly: true },
                 ".",
-                (0, ecmascript_1.localName)(value),
+                (0, names_js_1.localName)(value),
             ];
     }
 }
 function scalarTypeScriptType(type, longType) {
     switch (type) {
-        case protobuf_1.ScalarType.STRING:
+        case scalar_js_1.ScalarType.STRING:
             return "string";
-        case protobuf_1.ScalarType.BOOL:
+        case scalar_js_1.ScalarType.BOOL:
             return "boolean";
-        case protobuf_1.ScalarType.UINT64:
-        case protobuf_1.ScalarType.SFIXED64:
-        case protobuf_1.ScalarType.FIXED64:
-        case protobuf_1.ScalarType.SINT64:
-        case protobuf_1.ScalarType.INT64:
-            if (longType === protobuf_1.LongType.STRING) {
+        case scalar_js_1.ScalarType.UINT64:
+        case scalar_js_1.ScalarType.SFIXED64:
+        case scalar_js_1.ScalarType.FIXED64:
+        case scalar_js_1.ScalarType.SINT64:
+        case scalar_js_1.ScalarType.INT64:
+            if (longType === scalar_js_1.LongType.STRING) {
                 return "string";
             }
             return "bigint";
-        case protobuf_1.ScalarType.BYTES:
+        case scalar_js_1.ScalarType.BYTES:
             return "Uint8Array";
         default:
             return "number";

package/dist/varint.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 declare function varint64read(this: ReaderLike): [number, number];
+/**
+ * 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 declare function varint64write(lo: number, hi: number, bytes: number[]): void;
+/**
+ * Parse decimal string of 64 bit integer value as two JS numbers.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+export declare function int64FromString(dec: string): {
+    lo: number;
+    hi: number;
+};
+/**
+ * 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 declare function int64ToString(lo: number, hi: number): string;
+/**
+ * Losslessly converts a 64-bit unsigned 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 declare function uInt64ToString(lo: number, hi: number): string;
+/**
+ * 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 declare function varint32write(value: number, bytes: number[]): void;
+/**
+ * Read an unsigned 32 bit varint.
+ *
+ * See https://github.com/protocolbuffers/protobuf/blob/8a71927d74a4ce34efe2d8769fda198f52d20d12/js/experimental/runtime/kernel/buffer_decoder.js#L220
+ */
+export declare function varint32read(this: ReaderLike): number;
+type ReaderLike = {
+    buf: Uint8Array;
+    pos: number;
+    len: number;
+    assertBounds(): void;
+};
+export {};

package/dist/varint.js

@@ -0,0 +1,324 @@
+"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.uInt64ToString = 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 = 0x100000000;
+/**
+ * Parse decimal string of 64 bit integer value as two JS numbers.
+ *
+ * Copyright 2008 Google Inc.  All rights reserved.
+ *
+ * See https://github.com/protocolbuffers/protobuf-javascript/blob/a428c58273abad07c66071d9753bc4d1289de426/experimental/runtime/int64.js#L10
+ */
+function int64FromString(dec) {
+    // Check for minus sign.
+    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.
+    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 ? negate(lowBits, highBits) : newBits(lowBits, highBits);
+}
+exports.int64FromString = int64FromString;
+/**
+ * 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
+ */
+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;
+}
+exports.int64ToString = int64ToString;
+/**
+ * Losslessly converts a 64-bit unsigned 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
+ */
+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.
+    // 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
+    // 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.
+    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;
+    // Apply carries from A to B and from B to C.
+    const base = 10000000;
+    if (digitA >= base) {
+        digitB += Math.floor(digitA / base);
+        digitA %= base;
+    }
+    if (digitB >= base) {
+        digitC += Math.floor(digitB / base);
+        digitB %= base;
+    }
+    // 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));
+}
+exports.uInt64ToString = uInt64ToString;
+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 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)`
+ *
+ * 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/example/example.pb.ts

@@ -0,0 +1,87 @@
+//
+
+// @generated by protoc-gen-es-lite unknown with parameter "target=ts,ts_nocheck=false"
+// @generated from file example/example.proto (package example, syntax proto3)
+/* eslint-disable */
+
+//
+
+import type { MessageType, PartialFieldInfo } from "@aptre/protobuf-es-lite";
+import { createEnumType, createMessageType, Message, Timestamp } from "../src/";
+
+export const protobufPackage = "example";
+
+/**
+ * ExampleEnum is an example enumeration.
+ *
+ *
+ * @generated from enum example.ExampleEnum
+ */
+export enum ExampleEnum {
+  /**
+   * @generated from enum value: UNKNOWN = 0;
+   */
+  UNKNOWN = 0,
+
+  /**
+   * @generated from enum value: FIRST = 1;
+   */
+  FIRST = 1,
+
+  /**
+   * @generated from enum value: SECOND = 2;
+   */
+  SECOND = 2,
+}
+
+// ExampleEnum_Enum is the enum type for ExampleEnum.
+export const ExampleEnum_Enum = createEnumType("example.ExampleEnum", [
+  { no: 0, name: "UNKNOWN" },
+  { no: 1, name: "FIRST" },
+  { no: 2, name: "SECOND" },
+]);
+
+/**
+ * EchoMsg is the message body for Echo.
+ *
+ *
+ * @generated from message example.EchoMsg
+ */
+export type EchoMsg = Message<{
+  /**
+   * @generated from field: string body = 1 [packed = false, default = "", jstype = JS_NORMAL];
+   */
+  body?: string;
+  /**
+   * @generated from field: google.protobuf.Timestamp ts = 2 [packed = false, default = , jstype = JS_NORMAL];
+   */
+  ts?: Timestamp;
+  /**
+   * @generated from field: example.ExampleEnum example_enum = 3 [packed = false, default = , jstype = JS_NORMAL];
+   */
+  exampleEnum?: ExampleEnum;
+  /**
+   * @generated from field: string example_string = 4 [packed = false, default = "", jstype = JS_NORMAL];
+   */
+  exampleString?: string;
+  /**
+   * @generated from field: repeated google.protobuf.Timestamp timestamps = 5 [packed = false, default = , jstype = JS_NORMAL];
+   */
+  timestamps?: Timestamp[];
+
+}>;
+
+export const EchoMsg: MessageType<EchoMsg> = createMessageType(
+  {
+    typeName: "example.EchoMsg",
+    fields: [
+        { no: 1, name: "body", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 2, name: "ts", kind: "message", T: () => Timestamp },
+        { no: 3, name: "example_enum", kind: "enum", T: ExampleEnum_Enum },
+        { no: 4, name: "example_string", kind: "scalar", T: 9 /* ScalarType.STRING */ },
+        { no: 5, name: "timestamps", kind: "message", T: () => Timestamp, repeated: true },
+    ] as readonly PartialFieldInfo[],
+    packedByDefault: true,
+  },
+);
+

package/example/example.proto

@@ -30,4 +30,5 @@ message EchoMsg {
     ExampleEnum example_enum = 3;
     string example_string = 4;
   }
+  repeated google.protobuf.Timestamp timestamps = 5;
 }

package/example/tsconfig.json

@@ -1,7 +1,13 @@
 {
   "extends": "../tsconfig.json",
-  "files": ["example_pb.ts"],
+  "files": ["example.pb.ts"],
   "compilerOptions": {
-    "paths": {"@aptre/protobuf-es-lite": ["../", "../dist"]}
+    "paths": {
+      "@aptre/protobuf-es-lite": [
+        "../",
+        "../dist"
+      ],
+      "@aptre/protobuf-es-lite/google": ["../src/google", "../dist/google"],
+    }
   }
 }