pi-cursor-sdk 0.1.12 → 0.1.13

package/node_modules/@bufbuild/protobuf/dist/cjs/private/util-common.js

@@ -1,237 +0,0 @@
-"use strict";
-// Copyright 2021-2024 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.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeUtilCommon = void 0;
-const enum_js_1 = require("./enum.js");
-const scalars_js_1 = require("./scalars.js");
-const scalar_js_1 = require("../scalar.js");
-const is_message_js_1 = require("../is-message.js");
-/* eslint-disable @typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-argument,no-case-declarations */
-function makeUtilCommon() {
-    return {
-        setEnumType: enum_js_1.setEnumType,
-        initPartial(source, target) {
-            if (source === undefined) {
-                return;
-            }
-            const type = target.getType();
-            for (const member of type.fields.byMember()) {
-                const localName = member.localName, t = target, s = source;
-                if (s[localName] == null) {
-                    // TODO if source is a Message instance, we should use isFieldSet() here to support future field presence
-                    continue;
-                }
-                switch (member.kind) {
-                    case "oneof":
-                        const sk = s[localName].case;
-                        if (sk === undefined) {
-                            continue;
-                        }
-                        const sourceField = member.findField(sk);
-                        let val = s[localName].value;
-                        if (sourceField &&
-                            sourceField.kind == "message" &&
-                            !(0, is_message_js_1.isMessage)(val, sourceField.T)) {
-                            val = new sourceField.T(val);
-                        }
-                        else if (sourceField &&
-                            sourceField.kind === "scalar" &&
-                            sourceField.T === scalar_js_1.ScalarType.BYTES) {
-                            val = toU8Arr(val);
-                        }
-                        t[localName] = { case: sk, value: val };
-                        break;
-                    case "scalar":
-                    case "enum":
-                        let copy = s[localName];
-                        if (member.T === scalar_js_1.ScalarType.BYTES) {
-                            copy = member.repeated
-                                ? copy.map(toU8Arr)
-                                : toU8Arr(copy);
-                        }
-                        t[localName] = copy;
-                        break;
-                    case "map":
-                        switch (member.V.kind) {
-                            case "scalar":
-                            case "enum":
-                                if (member.V.T === scalar_js_1.ScalarType.BYTES) {
-                                    for (const [k, v] of Object.entries(s[localName])) {
-                                        t[localName][k] = toU8Arr(v);
-                                    }
-                                }
-                                else {
-                                    Object.assign(t[localName], s[localName]);
-                                }
-                                break;
-                            case "message":
-                                const messageType = member.V.T;
-                                for (const k of Object.keys(s[localName])) {
-                                    let val = s[localName][k];
-                                    if (!messageType.fieldWrapper) {
-                                        // We only take partial input for messages that are not a wrapper type.
-                                        // For those messages, we recursively normalize the partial input.
-                                        val = new messageType(val);
-                                    }
-                                    t[localName][k] = val;
-                                }
-                                break;
-                        }
-                        break;
-                    case "message":
-                        const mt = member.T;
-                        if (member.repeated) {
-                            t[localName] = s[localName].map((val) => (0, is_message_js_1.isMessage)(val, mt) ? val : new mt(val));
-                        }
-                        else {
-                            const val = s[localName];
-                            if (mt.fieldWrapper) {
-                                if (
-                                // We can't use BytesValue.typeName as that will create a circular import
-                                mt.typeName === "google.protobuf.BytesValue") {
-                                    t[localName] = toU8Arr(val);
-                                }
-                                else {
-                                    t[localName] = val;
-                                }
-                            }
-                            else {
-                                t[localName] = (0, is_message_js_1.isMessage)(val, mt) ? val : new mt(val);
-                            }
-                        }
-                        break;
-                }
-            }
-        },
-        // TODO use isFieldSet() here to support future field presence
-        equals(type, a, b) {
-            if (a === b) {
-                return true;
-            }
-            if (!a || !b) {
-                return false;
-            }
-            return type.fields.byMember().every((m) => {
-                const va = a[m.localName];
-                const vb = b[m.localName];
-                if (m.repeated) {
-                    if (va.length !== vb.length) {
-                        return false;
-                    }
-                    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- repeated fields are never "map"
-                    switch (m.kind) {
-                        case "message":
-                            return va.every((a, i) => m.T.equals(a, vb[i]));
-                        case "scalar":
-                            return va.every((a, i) => (0, scalars_js_1.scalarEquals)(m.T, a, vb[i]));
-                        case "enum":
-                            return va.every((a, i) => (0, scalars_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, a, vb[i]));
-                    }
-                    throw new Error(`repeated cannot contain ${m.kind}`);
-                }
-                switch (m.kind) {
-                    case "message":
-                        return m.T.equals(va, vb);
-                    case "enum":
-                        return (0, scalars_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, va, vb);
-                    case "scalar":
-                        return (0, scalars_js_1.scalarEquals)(m.T, va, vb);
-                    case "oneof":
-                        if (va.case !== vb.case) {
-                            return false;
-                        }
-                        const s = m.findField(va.case);
-                        if (s === undefined) {
-                            return true;
-                        }
-                        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- oneof fields are never "map"
-                        switch (s.kind) {
-                            case "message":
-                                return s.T.equals(va.value, vb.value);
-                            case "enum":
-                                return (0, scalars_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, va.value, vb.value);
-                            case "scalar":
-                                return (0, scalars_js_1.scalarEquals)(s.T, va.value, vb.value);
-                        }
-                        throw new Error(`oneof cannot contain ${s.kind}`);
-                    case "map":
-                        const keys = Object.keys(va).concat(Object.keys(vb));
-                        switch (m.V.kind) {
-                            case "message":
-                                const messageType = m.V.T;
-                                return keys.every((k) => messageType.equals(va[k], vb[k]));
-                            case "enum":
-                                return keys.every((k) => (0, scalars_js_1.scalarEquals)(scalar_js_1.ScalarType.INT32, va[k], vb[k]));
-                            case "scalar":
-                                const scalarType = m.V.T;
-                                return keys.every((k) => (0, scalars_js_1.scalarEquals)(scalarType, va[k], vb[k]));
-                        }
-                        break;
-                }
-            });
-        },
-        // TODO use isFieldSet() here to support future field presence
-        clone(message) {
-            const type = message.getType(), target = new type(), any = target;
-            for (const member of type.fields.byMember()) {
-                const source = message[member.localName];
-                let copy;
-                if (member.repeated) {
-                    copy = source.map(cloneSingularField);
-                }
-                else if (member.kind == "map") {
-                    copy = any[member.localName];
-                    for (const [key, v] of Object.entries(source)) {
-                        copy[key] = cloneSingularField(v);
-                    }
-                }
-                else if (member.kind == "oneof") {
-                    const f = member.findField(source.case);
-                    copy = f
-                        ? { case: source.case, value: cloneSingularField(source.value) }
-                        : { case: undefined };
-                }
-                else {
-                    copy = cloneSingularField(source);
-                }
-                any[member.localName] = copy;
-            }
-            for (const uf of type.runtime.bin.listUnknownFields(message)) {
-                type.runtime.bin.onUnknownField(any, uf.no, uf.wireType, uf.data);
-            }
-            return target;
-        },
-    };
-}
-exports.makeUtilCommon = makeUtilCommon;
-// clone a single field value - i.e. the element type of repeated fields, the value type of maps
-function cloneSingularField(value) {
-    if (value === undefined) {
-        return value;
-    }
-    if ((0, is_message_js_1.isMessage)(value)) {
-        return value.clone();
-    }
-    if (value instanceof Uint8Array) {
-        const c = new Uint8Array(value.byteLength);
-        c.set(value);
-        return c;
-    }
-    return value;
-}
-// converts any ArrayLike<number> to Uint8Array if necessary.
-function toU8Arr(input) {
-    return input instanceof Uint8Array ? input : new Uint8Array(input);
-}

package/node_modules/@bufbuild/protobuf/dist/cjs/private/util.d.ts

@@ -1,38 +0,0 @@
-import type { FieldListSource } from "./field-list.js";
-import type { FieldList } from "../field-list.js";
-import type { EnumObject } from "./enum.js";
-import type { Message, PartialMessage, PlainMessage } from "../message.js";
-import type { MessageType } from "../message-type.js";
-import type { EnumValueInfo } from "../enum.js";
-/**
- * Provides utilities used by generated code.
- * All methods are internal and are not safe to use, they may break with a
- * future release.
- */
-export interface Util {
-    /**
-     * Create a field list
-     */
-    newFieldList(fields: FieldListSource): FieldList;
-    /**
-     * Sets reflection information on a generated enum.
-     */
-    setEnumType(enumObject: EnumObject, typeName: string, values: Omit<EnumValueInfo, "localName">[], opt?: {}): void;
-    /**
-     * Set default field values on the target message.
-     */
-    initFields(target: Message): void;
-    /**
-     * Set specified field values on the target message, recursively.
-     */
-    initPartial<T extends Message<T>>(source: PartialMessage<T> | undefined, target: T): void;
-    /**
-     * Compares two messages of the same type recursively.
-     * Will also return true if both messages are `undefined` or `null`.
-     */
-    equals<T extends Message<T>>(type: MessageType<T>, a: T | PlainMessage<T> | undefined | null, b: T | PlainMessage<T> | undefined | null): boolean;
-    /**
-     * Create a deep copy.
-     */
-    clone<T extends Message<T>>(message: T): T;
-}

package/node_modules/@bufbuild/protobuf/dist/cjs/private/util.js

@@ -1,15 +0,0 @@
-"use strict";
-// Copyright 2021-2024 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.
-Object.defineProperty(exports, "__esModule", { value: true });

package/node_modules/@bufbuild/protobuf/dist/cjs/proto-base64.d.ts

@@ -1,18 +0,0 @@
-export declare const protoBase64: {
-    /**
-     * 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
-     */
-    readonly dec: (base64Str: string) => Uint8Array;
-    /**
-     * Encode a byte array to a base64 string.
-     */
-    readonly enc: (bytes: Uint8Array) => string;
-};

package/node_modules/@bufbuild/protobuf/dist/cjs/proto-base64.js

@@ -1,128 +0,0 @@
-"use strict";
-// Copyright 2021-2024 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.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.protoBase64 = void 0;
-/* 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("/");
-exports.protoBase64 = {
-    /**
-     * 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
-     */
-    dec(base64Str) {
-        // estimate byte size, not accounting for inner padding and whitespace
-        let es = (base64Str.length * 3) / 4;
-        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);
-    },
-    /**
-     * Encode a byte array to a base64 string.
-     */
-    enc(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;
-            }
-        }
-        // add output padding
-        if (groupPos) {
-            base64 += encTable[p];
-            base64 += "=";
-            if (groupPos == 1)
-                base64 += "=";
-        }
-        return base64;
-    },
-};

package/node_modules/@bufbuild/protobuf/dist/cjs/proto-delimited.d.ts

@@ -1,54 +0,0 @@
-import type { BinaryReadOptions, BinaryWriteOptions } from "./binary-format.js";
-import type { Message } from "./message.js";
-import type { MessageType } from "./message-type.js";
-/**
- * protoDelimited provides functions to serialize and parse size-delimited
- * messages.
- *
- * A size-delimited message is a varint size in bytes, followed by exactly
- * that many bytes of a message serialized with the binary format.
- *
- * This size-delimited format is compatible with other implementations.
- * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
- */
-export declare const protoDelimited: {
-    /**
-     * Serialize a message, prefixing it with its size.
-     */
-    enc(message: Message, options?: BinaryWriteOptions): Uint8Array;
-    /**
-     * Parse a size-delimited message, ignoring extra bytes.
-     */
-    dec<T extends Message<T>>(type: MessageType<T>, bytes: Uint8Array, options?: BinaryReadOptions): T;
-    /**
-     * Parse a stream of size-delimited messages.
-     */
-    decStream<T_1 extends Message<T_1>>(type: MessageType<T_1>, iterable: AsyncIterable<Uint8Array>): AsyncGenerator<T_1, void, unknown>;
-    /**
-     * Decodes the size from the given size-delimited message, which may be
-     * incomplete.
-     *
-     * Returns an object with the following properties:
-     * - size: The size of the delimited message in bytes
-     * - offset: The offset in the given byte array where the message starts
-     * - eof: true
-     *
-     * If the size-delimited data does not include all bytes of the varint size,
-     * the following object is returned:
-     * - size: null
-     * - offset: null
-     * - eof: false
-     *
-     * This function can be used to implement parsing of size-delimited messages
-     * from a stream.
-     */
-    peekSize(data: Uint8Array): {
-        readonly eof: false;
-        readonly size: number;
-        readonly offset: number;
-    } | {
-        readonly eof: true;
-        readonly size: null;
-        readonly offset: null;
-    };
-};

package/node_modules/@bufbuild/protobuf/dist/cjs/proto-delimited.js

@@ -1,155 +0,0 @@
-"use strict";
-// Copyright 2021-2024 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.
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.protoDelimited = void 0;
-const binary_encoding_js_1 = require("./binary-encoding.js");
-/**
- * protoDelimited provides functions to serialize and parse size-delimited
- * messages.
- *
- * A size-delimited message is a varint size in bytes, followed by exactly
- * that many bytes of a message serialized with the binary format.
- *
- * This size-delimited format is compatible with other implementations.
- * For details, see https://github.com/protocolbuffers/protobuf/issues/10229
- */
-exports.protoDelimited = {
-    /**
-     * Serialize a message, prefixing it with its size.
-     */
-    enc(message, options) {
-        const opt = message.getType().runtime.bin.makeWriteOptions(options);
-        return opt.writerFactory().bytes(message.toBinary(opt)).finish();
-    },
-    /**
-     * Parse a size-delimited message, ignoring extra bytes.
-     */
-    dec(type, bytes, options) {
-        const opt = type.runtime.bin.makeReadOptions(options);
-        return type.fromBinary(opt.readerFactory(bytes).bytes(), opt);
-    },
-    /**
-     * Parse a stream of size-delimited messages.
-     */
-    decStream(type, iterable) {
-        return __asyncGenerator(this, arguments, function* decStream_1() {
-            var _a, e_1, _b, _c;
-            // append chunk to buffer, returning updated buffer
-            function append(buffer, chunk) {
-                const n = new Uint8Array(buffer.byteLength + chunk.byteLength);
-                n.set(buffer);
-                n.set(chunk, buffer.length);
-                return n;
-            }
-            let buffer = new Uint8Array(0);
-            try {
-                for (var _d = true, iterable_1 = __asyncValues(iterable), iterable_1_1; iterable_1_1 = yield __await(iterable_1.next()), _a = iterable_1_1.done, !_a; _d = true) {
-                    _c = iterable_1_1.value;
-                    _d = false;
-                    const chunk = _c;
-                    buffer = append(buffer, chunk);
-                    for (;;) {
-                        const size = exports.protoDelimited.peekSize(buffer);
-                        if (size.eof) {
-                            // size is incomplete, buffer more data
-                            break;
-                        }
-                        if (size.offset + size.size > buffer.byteLength) {
-                            // message is incomplete, buffer more data
-                            break;
-                        }
-                        yield yield __await(exports.protoDelimited.dec(type, buffer));
-                        buffer = buffer.subarray(size.offset + size.size);
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = iterable_1.return)) yield __await(_b.call(iterable_1));
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            if (buffer.byteLength > 0) {
-                throw new Error("incomplete data");
-            }
-        });
-    },
-    /**
-     * Decodes the size from the given size-delimited message, which may be
-     * incomplete.
-     *
-     * Returns an object with the following properties:
-     * - size: The size of the delimited message in bytes
-     * - offset: The offset in the given byte array where the message starts
-     * - eof: true
-     *
-     * If the size-delimited data does not include all bytes of the varint size,
-     * the following object is returned:
-     * - size: null
-     * - offset: null
-     * - eof: false
-     *
-     * This function can be used to implement parsing of size-delimited messages
-     * from a stream.
-     */
-    peekSize(data) {
-        const sizeEof = { eof: true, size: null, offset: null };
-        for (let i = 0; i < 10; i++) {
-            if (i > data.byteLength) {
-                return sizeEof;
-            }
-            if ((data[i] & 0x80) == 0) {
-                const reader = new binary_encoding_js_1.BinaryReader(data);
-                let size;
-                try {
-                    size = reader.uint32();
-                }
-                catch (e) {
-                    if (e instanceof RangeError) {
-                        return sizeEof;
-                    }
-                    throw e;
-                }
-                return {
-                    eof: false,
-                    size,
-                    offset: reader.pos,
-                };
-            }
-        }
-        throw new Error("invalid varint");
-    },
-};

package/node_modules/@bufbuild/protobuf/dist/cjs/proto-double.d.ts

@@ -1,5 +0,0 @@
-export declare const protoDouble: {
-    readonly NaN: number;
-    readonly POSITIVE_INFINITY: number;
-    readonly NEGATIVE_INFINITY: number;
-};