@mangostudio/cli-darwin-arm64 0.1.0 → 0.1.1-canary.00a342c

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

@@ -0,0 +1,237 @@
+"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/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/private/util.d.ts

@@ -0,0 +1,38 @@
+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/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/private/util.js

@@ -0,0 +1,15 @@
+"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/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/proto-base64.d.ts

@@ -0,0 +1,18 @@
+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/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/proto-base64.js

@@ -0,0 +1,128 @@
+"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/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/proto-delimited.d.ts

@@ -0,0 +1,54 @@
+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/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/proto-delimited.js

@@ -0,0 +1,155 @@
+"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/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/proto-double.d.ts

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