{"version":3,"sources":["jsdelivr-header.js","/npm/@grpc/proto-loader@0.8.0/build/src/index.js"],"names":[],"mappings":"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","file":"/npm/@grpc/proto-loader@0.8.0/build/src/index.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@grpc/proto-loader@0.8.0/build/src/index.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","\"use strict\";\n/**\n * @license\n * Copyright 2018 gRPC authors.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.loadFileDescriptorSetFromObject = exports.loadFileDescriptorSetFromBuffer = exports.fromJSON = exports.loadSync = exports.load = exports.IdempotencyLevel = exports.isAnyExtension = exports.Long = void 0;\nconst camelCase = require(\"lodash.camelcase\");\nconst Protobuf = require(\"protobufjs\");\nconst descriptor = require(\"protobufjs/ext/descriptor\");\nconst util_1 = require(\"./util\");\nconst Long = require(\"long\");\nexports.Long = Long;\nfunction isAnyExtension(obj) {\n    return ('@type' in obj) && (typeof obj['@type'] === 'string');\n}\nexports.isAnyExtension = isAnyExtension;\nvar IdempotencyLevel;\n(function (IdempotencyLevel) {\n    IdempotencyLevel[\"IDEMPOTENCY_UNKNOWN\"] = \"IDEMPOTENCY_UNKNOWN\";\n    IdempotencyLevel[\"NO_SIDE_EFFECTS\"] = \"NO_SIDE_EFFECTS\";\n    IdempotencyLevel[\"IDEMPOTENT\"] = \"IDEMPOTENT\";\n})(IdempotencyLevel = exports.IdempotencyLevel || (exports.IdempotencyLevel = {}));\nconst descriptorOptions = {\n    longs: String,\n    enums: String,\n    bytes: String,\n    defaults: true,\n    oneofs: true,\n    json: true,\n};\nfunction joinName(baseName, name) {\n    if (baseName === '') {\n        return name;\n    }\n    else {\n        return baseName + '.' + name;\n    }\n}\nfunction isHandledReflectionObject(obj) {\n    return (obj instanceof Protobuf.Service ||\n        obj instanceof Protobuf.Type ||\n        obj instanceof Protobuf.Enum);\n}\nfunction isNamespaceBase(obj) {\n    return obj instanceof Protobuf.Namespace || obj instanceof Protobuf.Root;\n}\nfunction getAllHandledReflectionObjects(obj, parentName) {\n    const objName = joinName(parentName, obj.name);\n    if (isHandledReflectionObject(obj)) {\n        return [[objName, obj]];\n    }\n    else {\n        if (isNamespaceBase(obj) && typeof obj.nested !== 'undefined') {\n            return Object.keys(obj.nested)\n                .map(name => {\n                return getAllHandledReflectionObjects(obj.nested[name], objName);\n            })\n                .reduce((accumulator, currentValue) => accumulator.concat(currentValue), []);\n        }\n    }\n    return [];\n}\nfunction createDeserializer(cls, options) {\n    return function deserialize(argBuf) {\n        return cls.toObject(cls.decode(argBuf), options);\n    };\n}\nfunction createSerializer(cls) {\n    return function serialize(arg) {\n        if (Array.isArray(arg)) {\n            throw new Error(`Failed to serialize message: expected object with ${cls.name} structure, got array instead`);\n        }\n        const message = cls.fromObject(arg);\n        return cls.encode(message).finish();\n    };\n}\nfunction mapMethodOptions(options) {\n    return (options || []).reduce((obj, item) => {\n        for (const [key, value] of Object.entries(item)) {\n            switch (key) {\n                case 'uninterpreted_option':\n                    obj.uninterpreted_option.push(item.uninterpreted_option);\n                    break;\n                default:\n                    obj[key] = value;\n            }\n        }\n        return obj;\n    }, {\n        deprecated: false,\n        idempotency_level: IdempotencyLevel.IDEMPOTENCY_UNKNOWN,\n        uninterpreted_option: [],\n    });\n}\nfunction createMethodDefinition(method, serviceName, options, fileDescriptors) {\n    /* This is only ever called after the corresponding root.resolveAll(), so we\n     * can assume that the resolved request and response types are non-null */\n    const requestType = method.resolvedRequestType;\n    const responseType = method.resolvedResponseType;\n    return {\n        path: '/' + serviceName + '/' + method.name,\n        requestStream: !!method.requestStream,\n        responseStream: !!method.responseStream,\n        requestSerialize: createSerializer(requestType),\n        requestDeserialize: createDeserializer(requestType, options),\n        responseSerialize: createSerializer(responseType),\n        responseDeserialize: createDeserializer(responseType, options),\n        // TODO(murgatroid99): Find a better way to handle this\n        originalName: camelCase(method.name),\n        requestType: createMessageDefinition(requestType, options, fileDescriptors),\n        responseType: createMessageDefinition(responseType, options, fileDescriptors),\n        options: mapMethodOptions(method.parsedOptions),\n    };\n}\nfunction createServiceDefinition(service, name, options, fileDescriptors) {\n    const def = {};\n    for (const method of service.methodsArray) {\n        def[method.name] = createMethodDefinition(method, name, options, fileDescriptors);\n    }\n    return def;\n}\nfunction createMessageDefinition(message, options, fileDescriptors) {\n    const messageDescriptor = message.toDescriptor('proto3');\n    return {\n        format: 'Protocol Buffer 3 DescriptorProto',\n        type: messageDescriptor.$type.toObject(messageDescriptor, descriptorOptions),\n        fileDescriptorProtos: fileDescriptors,\n        serialize: createSerializer(message),\n        deserialize: createDeserializer(message, options)\n    };\n}\nfunction createEnumDefinition(enumType, fileDescriptors) {\n    const enumDescriptor = enumType.toDescriptor('proto3');\n    return {\n        format: 'Protocol Buffer 3 EnumDescriptorProto',\n        type: enumDescriptor.$type.toObject(enumDescriptor, descriptorOptions),\n        fileDescriptorProtos: fileDescriptors,\n    };\n}\n/**\n * function createDefinition(obj: Protobuf.Service, name: string, options:\n * Options): ServiceDefinition; function createDefinition(obj: Protobuf.Type,\n * name: string, options: Options): MessageTypeDefinition; function\n * createDefinition(obj: Protobuf.Enum, name: string, options: Options):\n * EnumTypeDefinition;\n */\nfunction createDefinition(obj, name, options, fileDescriptors) {\n    if (obj instanceof Protobuf.Service) {\n        return createServiceDefinition(obj, name, options, fileDescriptors);\n    }\n    else if (obj instanceof Protobuf.Type) {\n        return createMessageDefinition(obj, options, fileDescriptors);\n    }\n    else if (obj instanceof Protobuf.Enum) {\n        return createEnumDefinition(obj, fileDescriptors);\n    }\n    else {\n        throw new Error('Type mismatch in reflection object handling');\n    }\n}\nfunction createPackageDefinition(root, options) {\n    const def = {};\n    root.resolveAll();\n    const descriptorList = root.toDescriptor('proto3').file;\n    const bufferList = descriptorList.map(value => Buffer.from(descriptor.FileDescriptorProto.encode(value).finish()));\n    for (const [name, obj] of getAllHandledReflectionObjects(root, '')) {\n        def[name] = createDefinition(obj, name, options, bufferList);\n    }\n    return def;\n}\nfunction createPackageDefinitionFromDescriptorSet(decodedDescriptorSet, options) {\n    options = options || {};\n    const root = Protobuf.Root.fromDescriptor(decodedDescriptorSet);\n    root.resolveAll();\n    return createPackageDefinition(root, options);\n}\n/**\n * Load a .proto file with the specified options.\n * @param filename One or multiple file paths to load. Can be an absolute path\n *     or relative to an include path.\n * @param options.keepCase Preserve field names. The default is to change them\n *     to camel case.\n * @param options.longs The type that should be used to represent `long` values.\n *     Valid options are `Number` and `String`. Defaults to a `Long` object type\n *     from a library.\n * @param options.enums The type that should be used to represent `enum` values.\n *     The only valid option is `String`. Defaults to the numeric value.\n * @param options.bytes The type that should be used to represent `bytes`\n *     values. Valid options are `Array` and `String`. The default is to use\n *     `Buffer`.\n * @param options.defaults Set default values on output objects. Defaults to\n *     `false`.\n * @param options.arrays Set empty arrays for missing array values even if\n *     `defaults` is `false`. Defaults to `false`.\n * @param options.objects Set empty objects for missing object values even if\n *     `defaults` is `false`. Defaults to `false`.\n * @param options.oneofs Set virtual oneof properties to the present field's\n *     name\n * @param options.json Represent Infinity and NaN as strings in float fields,\n *     and automatically decode google.protobuf.Any values.\n * @param options.includeDirs Paths to search for imported `.proto` files.\n */\nfunction load(filename, options) {\n    return (0, util_1.loadProtosWithOptions)(filename, options).then(loadedRoot => {\n        return createPackageDefinition(loadedRoot, options);\n    });\n}\nexports.load = load;\nfunction loadSync(filename, options) {\n    const loadedRoot = (0, util_1.loadProtosWithOptionsSync)(filename, options);\n    return createPackageDefinition(loadedRoot, options);\n}\nexports.loadSync = loadSync;\nfunction fromJSON(json, options) {\n    options = options || {};\n    const loadedRoot = Protobuf.Root.fromJSON(json);\n    loadedRoot.resolveAll();\n    return createPackageDefinition(loadedRoot, options);\n}\nexports.fromJSON = fromJSON;\nfunction loadFileDescriptorSetFromBuffer(descriptorSet, options) {\n    const decodedDescriptorSet = descriptor.FileDescriptorSet.decode(descriptorSet);\n    return createPackageDefinitionFromDescriptorSet(decodedDescriptorSet, options);\n}\nexports.loadFileDescriptorSetFromBuffer = loadFileDescriptorSetFromBuffer;\nfunction loadFileDescriptorSetFromObject(descriptorSet, options) {\n    const decodedDescriptorSet = descriptor.FileDescriptorSet.fromObject(descriptorSet);\n    return createPackageDefinitionFromDescriptorSet(decodedDescriptorSet, options);\n}\nexports.loadFileDescriptorSetFromObject = loadFileDescriptorSetFromObject;\n(0, util_1.addCommonProtos)();\n"]}