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

package/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/private/message-type.js

@@ -0,0 +1,50 @@
+"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.makeMessageType = void 0;
+const message_js_1 = require("../message.js");
+/**
+ * Create a new message type using the given runtime.
+ */
+function makeMessageType(runtime, typeName, fields, opt) {
+    var _a;
+    const localName = (_a = opt === null || opt === void 0 ? void 0 : opt.localName) !== null && _a !== void 0 ? _a : typeName.substring(typeName.lastIndexOf(".") + 1);
+    const type = {
+        [localName]: function (data) {
+            runtime.util.initFields(this);
+            runtime.util.initPartial(data, this);
+        },
+    }[localName];
+    Object.setPrototypeOf(type.prototype, new message_js_1.Message());
+    Object.assign(type, {
+        runtime,
+        typeName,
+        fields: runtime.util.newFieldList(fields),
+        fromBinary(bytes, options) {
+            return new type().fromBinary(bytes, options);
+        },
+        fromJson(jsonValue, options) {
+            return new type().fromJson(jsonValue, options);
+        },
+        fromJsonString(jsonString, options) {
+            return new type().fromJsonString(jsonString, options);
+        },
+        equals(a, b) {
+            return runtime.util.equals(type, a, b);
+        },
+    });
+    return type;
+}
+exports.makeMessageType = makeMessageType;

package/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/private/names.d.ts

@@ -0,0 +1,43 @@
+import type { DescEnum, DescEnumValue, DescExtension, DescField, DescMessage, DescService } from "../descriptor-set.js";
+import type { DescMethod, DescOneof } from "../descriptor-set.js";
+/**
+ * Returns the name of a protobuf element in generated code.
+ *
+ * Field names - including oneofs - are converted to lowerCamelCase. For
+ * messages, enumerations and services, the package name is stripped from
+ * the type name. For nested messages and enumerations, the names are joined
+ * with an underscore. For methods, the first character is made lowercase.
+ */
+export declare function localName(desc: DescEnum | DescEnumValue | DescMessage | DescExtension | DescOneof | DescField | DescService | DescMethod): string;
+/**
+ * Returns the name of a field in generated code.
+ */
+export declare function localFieldName(protoName: string, inOneof: boolean): string;
+/**
+ * Returns the name of a oneof group in generated code.
+ */
+export declare function localOneofName(protoName: string): string;
+/**
+ * Returns the JSON name for a protobuf field, exactly like protoc does.
+ */
+export declare const fieldJsonName: typeof protoCamelCase;
+/**
+ * Finds a prefix shared by enum values, for example `MY_ENUM_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+export declare function findEnumSharedPrefix(enumName: string, valueNames: string[]): string | undefined;
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
+declare function protoCamelCase(snakeCase: string): string;
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+export declare const safeObjectProperty: (name: string) => string;
+/**
+ * Names that can be used for identifiers or class properties
+ */
+export declare const safeIdentifier: (name: string) => string;
+export {};

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

@@ -0,0 +1,278 @@
+"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.safeIdentifier = exports.safeObjectProperty = exports.findEnumSharedPrefix = exports.fieldJsonName = exports.localOneofName = exports.localFieldName = exports.localName = void 0;
+/**
+ * Returns the name of a protobuf element in generated code.
+ *
+ * Field names - including oneofs - are converted to lowerCamelCase. For
+ * messages, enumerations and services, the package name is stripped from
+ * the type name. For nested messages and enumerations, the names are joined
+ * with an underscore. For methods, the first character is made lowercase.
+ */
+function localName(desc) {
+    switch (desc.kind) {
+        case "field":
+            return localFieldName(desc.name, desc.oneof !== undefined);
+        case "oneof":
+            return localOneofName(desc.name);
+        case "enum":
+        case "message":
+        case "service":
+        case "extension": {
+            const pkg = desc.file.proto.package;
+            const offset = pkg === undefined ? 0 : pkg.length + 1;
+            const name = desc.typeName.substring(offset).replace(/\./g, "_");
+            // For services, we only care about safe identifiers, not safe object properties,
+            // but we have shipped v1 with a bug that respected object properties, and we
+            // do not want to introduce a breaking change, so we continue to escape for
+            // safe object properties.
+            // See https://github.com/bufbuild/protobuf-es/pull/391
+            return (0, exports.safeObjectProperty)((0, exports.safeIdentifier)(name));
+        }
+        case "enum_value": {
+            let name = desc.name;
+            const sharedPrefix = desc.parent.sharedPrefix;
+            if (sharedPrefix !== undefined) {
+                name = name.substring(sharedPrefix.length);
+            }
+            return (0, exports.safeObjectProperty)(name);
+        }
+        case "rpc": {
+            let name = desc.name;
+            if (name.length == 0) {
+                return name;
+            }
+            name = name[0].toLowerCase() + name.substring(1);
+            return (0, exports.safeObjectProperty)(name);
+        }
+    }
+}
+exports.localName = localName;
+/**
+ * Returns the name of a field in generated code.
+ */
+function localFieldName(protoName, inOneof) {
+    const name = protoCamelCase(protoName);
+    if (inOneof) {
+        // oneof member names are not properties, but values of the `case` property.
+        return name;
+    }
+    return (0, exports.safeObjectProperty)(safeMessageProperty(name));
+}
+exports.localFieldName = localFieldName;
+/**
+ * Returns the name of a oneof group in generated code.
+ */
+function localOneofName(protoName) {
+    return localFieldName(protoName, false);
+}
+exports.localOneofName = localOneofName;
+/**
+ * Returns the JSON name for a protobuf field, exactly like protoc does.
+ */
+exports.fieldJsonName = protoCamelCase;
+/**
+ * Finds a prefix shared by enum values, for example `MY_ENUM_` for
+ * `enum MyEnum {MY_ENUM_A=0; MY_ENUM_B=1;}`.
+ */
+function findEnumSharedPrefix(enumName, valueNames) {
+    const prefix = camelToSnakeCase(enumName) + "_";
+    for (const name of valueNames) {
+        if (!name.toLowerCase().startsWith(prefix)) {
+            return undefined;
+        }
+        const shortName = name.substring(prefix.length);
+        if (shortName.length == 0) {
+            return undefined;
+        }
+        if (/^\d/.test(shortName)) {
+            // identifiers must not start with numbers
+            return undefined;
+        }
+    }
+    return prefix;
+}
+exports.findEnumSharedPrefix = findEnumSharedPrefix;
+/**
+ * Converts lowerCamelCase or UpperCamelCase into lower_snake_case.
+ * This is used to find shared prefixes in an enum.
+ */
+function camelToSnakeCase(camel) {
+    return (camel.substring(0, 1) + camel.substring(1).replace(/[A-Z]/g, (c) => "_" + c)).toLowerCase();
+}
+/**
+ * Converts snake_case to protoCamelCase according to the convention
+ * used by protoc to convert a field name to a JSON name.
+ */
+function protoCamelCase(snakeCase) {
+    let capNext = false;
+    const b = [];
+    for (let i = 0; i < snakeCase.length; i++) {
+        let c = snakeCase.charAt(i);
+        switch (c) {
+            case "_":
+                capNext = true;
+                break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7":
+            case "8":
+            case "9":
+                b.push(c);
+                capNext = false;
+                break;
+            default:
+                if (capNext) {
+                    capNext = false;
+                    c = c.toUpperCase();
+                }
+                b.push(c);
+                break;
+        }
+    }
+    return b.join("");
+}
+/**
+ * Names that cannot be used for identifiers, such as class names,
+ * but _can_ be used for object properties.
+ */
+const reservedIdentifiers = new Set([
+    // ECMAScript 2015 keywords
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+    // ECMAScript 2015 future reserved keywords
+    "enum",
+    "implements",
+    "interface",
+    "let",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "static",
+    // Class name cannot be 'Object' when targeting ES5 with module CommonJS
+    "Object",
+    // TypeScript keywords that cannot be used for types (as opposed to variables)
+    "bigint",
+    "number",
+    "boolean",
+    "string",
+    "object",
+    // Identifiers reserved for the runtime, so we can generate legible code
+    "globalThis",
+    "Uint8Array",
+    "Partial",
+]);
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+const reservedObjectProperties = new Set([
+    // names reserved by JavaScript
+    "constructor",
+    "toString",
+    "toJSON",
+    "valueOf",
+]);
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by the runtime.
+ */
+const reservedMessageProperties = new Set([
+    // names reserved by the runtime
+    "getType",
+    "clone",
+    "equals",
+    "fromBinary",
+    "fromJson",
+    "fromJsonString",
+    "toBinary",
+    "toJson",
+    "toJsonString",
+    // names reserved by the runtime for the future
+    "toObject",
+]);
+const fallback = (name) => `${name}$`;
+/**
+ * Will wrap names that are Object prototype properties or names reserved
+ * for `Message`s.
+ */
+const safeMessageProperty = (name) => {
+    if (reservedMessageProperties.has(name)) {
+        return fallback(name);
+    }
+    return name;
+};
+/**
+ * Names that cannot be used for object properties because they are reserved
+ * by built-in JavaScript properties.
+ */
+const safeObjectProperty = (name) => {
+    if (reservedObjectProperties.has(name)) {
+        return fallback(name);
+    }
+    return name;
+};
+exports.safeObjectProperty = safeObjectProperty;
+/**
+ * Names that can be used for identifiers or class properties
+ */
+const safeIdentifier = (name) => {
+    if (reservedIdentifiers.has(name)) {
+        return fallback(name);
+    }
+    return name;
+};
+exports.safeIdentifier = safeIdentifier;

package/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/private/options-map.d.ts

@@ -0,0 +1,7 @@
+import type { JsonValue } from "../json-format.js";
+/**
+ *
+ */
+export type OptionsMap = {
+    readonly [extensionName: string]: JsonValue;
+};

package/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/private/options-map.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/private/proto-runtime.d.ts

@@ -0,0 +1,53 @@
+import type { JsonFormat } from "../json-format.js";
+import type { BinaryFormat } from "../binary-format.js";
+import type { AnyMessage } from "../message.js";
+import type { Message } from "../message.js";
+import type { EnumType, EnumValueInfo } from "../enum.js";
+import type { MessageType } from "../message-type.js";
+import type { FieldListSource } from "./field-list.js";
+import type { EnumObject } from "./enum.js";
+import type { Util } from "./util.js";
+import type { Extension } from "../extension.js";
+import type { ExtensionFieldSource } from "./extensions.js";
+/**
+ * A facade that provides serialization and other internal functionality.
+ */
+export interface ProtoRuntime {
+    readonly syntax: string;
+    readonly json: JsonFormat;
+    readonly bin: BinaryFormat;
+    readonly util: Util;
+    /**
+     * Create a message type at runtime, without generating code.
+     */
+    makeMessageType<T extends Message<T> = AnyMessage>(typeName: string, fields: FieldListSource, opt?: {
+        localName?: string;
+    }): MessageType<T>;
+    /**
+     * Create an enum object at runtime, without generating code.
+     *
+     * The object conforms to TypeScript enums, and comes with
+     * mapping from name to value, and from value to name.
+     *
+     * The type name and other reflection information is accessible
+     * via getEnumType().
+     */
+    makeEnum(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], opt?: {}): EnumObject;
+    /**
+     * Create an enum type at runtime, without generating code.
+     * Note that this only creates the reflection information, not an
+     * actual enum object.
+     */
+    makeEnumType(typeName: string, values: (EnumValueInfo | Omit<EnumValueInfo, "localName">)[], opt?: {}): EnumType;
+    /**
+     * Get reflection information - the EnumType - from an enum object.
+     * If this function is called on something other than a generated
+     * enum, or an enum constructed with makeEnum(), it raises an error.
+     */
+    getEnumType(enumObject: EnumObject): EnumType;
+    /**
+     * Create an extension at runtime, without generating code.
+     */
+    makeExtension<E extends Message<E> = AnyMessage, V = unknown>(typeName: string, extendee: MessageType<E>, field: ExtensionFieldSource): Extension<E, V>;
+}
+export declare function makeProtoRuntime(syntax: string, newFieldList: Util["newFieldList"], initFields: Util["initFields"]): ProtoRuntime;

package/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/private/proto-runtime.js

@@ -0,0 +1,41 @@
+"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.makeProtoRuntime = void 0;
+const enum_js_1 = require("./enum.js");
+const message_type_js_1 = require("./message-type.js");
+const extensions_js_1 = require("./extensions.js");
+const json_format_js_1 = require("./json-format.js");
+const binary_format_js_1 = require("./binary-format.js");
+const util_common_js_1 = require("./util-common.js");
+function makeProtoRuntime(syntax, newFieldList, initFields) {
+    return {
+        syntax,
+        json: (0, json_format_js_1.makeJsonFormat)(),
+        bin: (0, binary_format_js_1.makeBinaryFormat)(),
+        util: Object.assign(Object.assign({}, (0, util_common_js_1.makeUtilCommon)()), { newFieldList,
+            initFields }),
+        makeMessageType(typeName, fields, opt) {
+            return (0, message_type_js_1.makeMessageType)(this, typeName, fields, opt);
+        },
+        makeEnum: enum_js_1.makeEnum,
+        makeEnumType: enum_js_1.makeEnumType,
+        getEnumType: enum_js_1.getEnumType,
+        makeExtension(typeName, extendee, field) {
+            return (0, extensions_js_1.makeExtension)(this, typeName, extendee, field);
+        },
+    };
+}
+exports.makeProtoRuntime = makeProtoRuntime;

package/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/private/reflect.d.ts

@@ -0,0 +1,9 @@
+import type { FieldInfo } from "../field.js";
+/**
+ * Returns true if the field is set.
+ */
+export declare function isFieldSet(field: FieldInfo, target: Record<string, any>): boolean;
+/**
+ * Resets the field, so that isFieldSet() will return false.
+ */
+export declare function clearField(field: FieldInfo, target: Record<string, any>): void;

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

@@ -0,0 +1,79 @@
+"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.clearField = exports.isFieldSet = void 0;
+const scalars_js_1 = require("./scalars.js");
+/**
+ * Returns true if the field is set.
+ */
+function isFieldSet(field, target) {
+    const localName = field.localName;
+    if (field.repeated) {
+        return target[localName].length > 0;
+    }
+    if (field.oneof) {
+        return target[field.oneof.localName].case === localName; // eslint-disable-line @typescript-eslint/no-unsafe-member-access
+    }
+    switch (field.kind) {
+        case "enum":
+        case "scalar":
+            if (field.opt || field.req) {
+                // explicit presence
+                return target[localName] !== undefined;
+            }
+            // implicit presence
+            if (field.kind == "enum") {
+                return target[localName] !== field.T.values[0].no;
+            }
+            return !(0, scalars_js_1.isScalarZeroValue)(field.T, target[localName]);
+        case "message":
+            return target[localName] !== undefined;
+        case "map":
+            return Object.keys(target[localName]).length > 0; // eslint-disable-line @typescript-eslint/no-unsafe-argument
+    }
+}
+exports.isFieldSet = isFieldSet;
+/**
+ * Resets the field, so that isFieldSet() will return false.
+ */
+function clearField(field, target) {
+    const localName = field.localName;
+    const implicitPresence = !field.opt && !field.req;
+    if (field.repeated) {
+        target[localName] = [];
+    }
+    else if (field.oneof) {
+        target[field.oneof.localName] = { case: undefined };
+    }
+    else {
+        switch (field.kind) {
+            case "map":
+                target[localName] = {};
+                break;
+            case "enum":
+                target[localName] = implicitPresence ? field.T.values[0].no : undefined;
+                break;
+            case "scalar":
+                target[localName] = implicitPresence
+                    ? (0, scalars_js_1.scalarZeroValue)(field.T, field.L)
+                    : undefined;
+                break;
+            case "message":
+                target[localName] = undefined;
+                break;
+        }
+    }
+}
+exports.clearField = clearField;

package/cursor-sidecar/node_modules/@bufbuild/protobuf/dist/cjs/private/reify-wkt.d.ts

@@ -0,0 +1,102 @@
+import type { DescField, DescMessage, DescOneof } from "../descriptor-set.js";
+type DescWkt = {
+    typeName: "google.protobuf.Any";
+    typeUrl: DescField;
+    value: DescField;
+} | {
+    typeName: "google.protobuf.Timestamp";
+    seconds: DescField;
+    nanos: DescField;
+} | {
+    typeName: "google.protobuf.Duration";
+    seconds: DescField;
+    nanos: DescField;
+} | {
+    typeName: "google.protobuf.Struct";
+    fields: DescField & {
+        fieldKind: "map";
+    };
+} | {
+    typeName: "google.protobuf.Value";
+    kind: DescOneof;
+    nullValue: DescField & {
+        fieldKind: "enum";
+    };
+    numberValue: DescField;
+    stringValue: DescField;
+    boolValue: DescField;
+    structValue: DescField & {
+        fieldKind: "message";
+    };
+    listValue: DescField & {
+        fieldKind: "message";
+    };
+} | {
+    typeName: "google.protobuf.ListValue";
+    values: DescField & {
+        fieldKind: "message";
+    };
+} | {
+    typeName: "google.protobuf.FieldMask";
+    paths: DescField;
+} | {
+    typeName: "google.protobuf.DoubleValue";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.FloatValue";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.Int64Value";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.UInt64Value";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.Int32Value";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.UInt32Value";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.BoolValue";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.StringValue";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+} | {
+    typeName: "google.protobuf.BytesValue";
+    value: DescField & {
+        fieldKind: "scalar";
+    };
+};
+/**
+ * @deprecated please use reifyWkt from @bufbuild/protoplugin/ecmascript instead
+ *
+ * Reifies a given DescMessage into a more concrete object representing its
+ * respective well-known type.  The returned object will contain properties
+ * representing the WKT's defined fields.
+ *
+ * Useful during code generation when immediate access to a particular field
+ * is needed without having to search the object's typename and DescField list.
+ *
+ * Returns undefined if the WKT cannot be completely constructed via the
+ * DescMessage.
+ */
+export declare function reifyWkt(message: DescMessage): DescWkt | undefined;
+export {};