basant307/AI_Governance_Project

1"use strict";2var $protobuf = require("../..");3module.exports = exports = $protobuf.descriptor = $protobuf.Root.fromJSON(require("../../google/protobuf/descriptor.json")).lookup(".google.protobuf");4 5var Namespace = $protobuf.Namespace,6    Root      = $protobuf.Root,7    Enum      = $protobuf.Enum,8    Type      = $protobuf.Type,9    Field     = $protobuf.Field,10    MapField  = $protobuf.MapField,11    OneOf     = $protobuf.OneOf,12    Service   = $protobuf.Service,13    Method    = $protobuf.Method,14    patterns  = $protobuf.util.patterns;15 16var numberRe  = patterns.numberRe,17    typeRefRe = patterns.typeRefRe;18 19// --- Root ---20 21/**22 * Properties of a FileDescriptorSet message.23 * @interface IFileDescriptorSet24 * @property {IFileDescriptorProto[]} file Files25 */26 27/**28 * Properties of a FileDescriptorProto message.29 * @interface IFileDescriptorProto30 * @property {string} [name] File name31 * @property {string} [package] Package32 * @property {*} [dependency] Not supported33 * @property {*} [publicDependency] Not supported34 * @property {*} [weakDependency] Not supported35 * @property {IDescriptorProto[]} [messageType] Nested message types36 * @property {IEnumDescriptorProto[]} [enumType] Nested enums37 * @property {IServiceDescriptorProto[]} [service] Nested services38 * @property {IFieldDescriptorProto[]} [extension] Nested extension fields39 * @property {IFileOptions} [options] Options40 * @property {*} [sourceCodeInfo] Not supported41 * @property {string} [syntax="proto2"] Syntax42 * @property {IEdition} [edition] Edition43 */44 45/**46 * Values of the Edition enum.47 * @typedef IEdition48 * @type {number}49 * @property {number} EDITION_UNKNOWN=050 * @property {number} EDITION_LEGACY=90051 * @property {number} EDITION_PROTO2=99852 * @property {number} EDITION_PROTO3=99953 * @property {number} EDITION_2023=100054 * @property {number} EDITION_2024=100155 * @property {number} EDITION_1_TEST_ONLY=156 * @property {number} EDITION_2_TEST_ONLY=257 * @property {number} EDITION_99997_TEST_ONLY=9999758 * @property {number} EDITION_99998_TEST_ONLY=9999859 * @property {number} EDITION_99998_TEST_ONLY=9999960 * @property {number} EDITION_MAX=214748364761 */62 63/**64 * Properties of a FileOptions message.65 * @interface IFileOptions66 * @property {string} [javaPackage]67 * @property {string} [javaOuterClassname]68 * @property {boolean} [javaMultipleFiles]69 * @property {boolean} [javaGenerateEqualsAndHash]70 * @property {boolean} [javaStringCheckUtf8]71 * @property {IFileOptionsOptimizeMode} [optimizeFor=1]72 * @property {string} [goPackage]73 * @property {boolean} [ccGenericServices]74 * @property {boolean} [javaGenericServices]75 * @property {boolean} [pyGenericServices]76 * @property {boolean} [deprecated]77 * @property {boolean} [ccEnableArenas]78 * @property {string} [objcClassPrefix]79 * @property {string} [csharpNamespace]80 */81 82/**83 * Values of he FileOptions.OptimizeMode enum.84 * @typedef IFileOptionsOptimizeMode85 * @type {number}86 * @property {number} SPEED=187 * @property {number} CODE_SIZE=288 * @property {number} LITE_RUNTIME=389 */90 91/**92 * Creates a root from a descriptor set.93 * @param {IFileDescriptorSet|Reader|Uint8Array} descriptor Descriptor94 * @returns {Root} Root instance95 */96Root.fromDescriptor = function fromDescriptor(descriptor) {97 98    // Decode the descriptor message if specified as a buffer:99    if (typeof descriptor.length === "number")100        descriptor = exports.FileDescriptorSet.decode(descriptor);101 102    var root = new Root();103 104    if (descriptor.file) {105        var fileDescriptor,106            filePackage;107        for (var j = 0, i; j < descriptor.file.length; ++j) {108            filePackage = root;109            if ((fileDescriptor = descriptor.file[j])["package"] && fileDescriptor["package"].length)110                filePackage = root.define(fileDescriptor["package"]);111            var edition = editionFromDescriptor(fileDescriptor);112            if (fileDescriptor.name && fileDescriptor.name.length)113                root.files.push(filePackage.filename = fileDescriptor.name);114            if (fileDescriptor.messageType)115                for (i = 0; i < fileDescriptor.messageType.length; ++i)116                    filePackage.add(Type.fromDescriptor(fileDescriptor.messageType[i], edition));117            if (fileDescriptor.enumType)118                for (i = 0; i < fileDescriptor.enumType.length; ++i)119                    filePackage.add(Enum.fromDescriptor(fileDescriptor.enumType[i], edition));120            if (fileDescriptor.extension)121                for (i = 0; i < fileDescriptor.extension.length; ++i)122                    filePackage.add(Field.fromDescriptor(fileDescriptor.extension[i], edition));123            if (fileDescriptor.service)124                for (i = 0; i < fileDescriptor.service.length; ++i)125                    filePackage.add(Service.fromDescriptor(fileDescriptor.service[i], edition));126            var opts = fromDescriptorOptions(fileDescriptor.options, exports.FileOptions);127            if (opts) {128                var ks = Object.keys(opts);129                for (i = 0; i < ks.length; ++i)130                    filePackage.setOption(ks[i], opts[ks[i]]);131            }132        }133    }134 135    return root.resolveAll();136};137 138/**139 * Converts a root to a descriptor set.140 * @returns {Message<IFileDescriptorSet>} Descriptor141 * @param {string} [edition="proto2"] The syntax or edition to use142 */143Root.prototype.toDescriptor = function toDescriptor(edition) {144    var set = exports.FileDescriptorSet.create();145    Root_toDescriptorRecursive(this, set.file, edition);146    return set;147};148 149// Traverses a namespace and assembles the descriptor set150function Root_toDescriptorRecursive(ns, files, edition) {151 152    // Create a new file153    var file = exports.FileDescriptorProto.create({ name: ns.filename || (ns.fullName.substring(1).replace(/\./g, "_") || "root") + ".proto" });154    editionToDescriptor(edition, file);155    if (!(ns instanceof Root))156        file["package"] = ns.fullName.substring(1);157 158    // Add nested types159    for (var i = 0, nested; i < ns.nestedArray.length; ++i)160        if ((nested = ns._nestedArray[i]) instanceof Type)161            file.messageType.push(nested.toDescriptor(edition));162        else if (nested instanceof Enum)163            file.enumType.push(nested.toDescriptor());164        else if (nested instanceof Field)165            file.extension.push(nested.toDescriptor(edition));166        else if (nested instanceof Service)167            file.service.push(nested.toDescriptor());168        else if (nested instanceof /* plain */ Namespace)169            Root_toDescriptorRecursive(nested, files, edition); // requires new file170 171    // Keep package-level options172    file.options = toDescriptorOptions(ns.options, exports.FileOptions);173 174    // And keep the file only if there is at least one nested object175    if (file.messageType.length + file.enumType.length + file.extension.length + file.service.length)176        files.push(file);177}178 179// --- Type ---180 181/**182 * Properties of a DescriptorProto message.183 * @interface IDescriptorProto184 * @property {string} [name] Message type name185 * @property {IFieldDescriptorProto[]} [field] Fields186 * @property {IFieldDescriptorProto[]} [extension] Extension fields187 * @property {IDescriptorProto[]} [nestedType] Nested message types188 * @property {IEnumDescriptorProto[]} [enumType] Nested enums189 * @property {IDescriptorProtoExtensionRange[]} [extensionRange] Extension ranges190 * @property {IOneofDescriptorProto[]} [oneofDecl] Oneofs191 * @property {IMessageOptions} [options] Not supported192 * @property {IDescriptorProtoReservedRange[]} [reservedRange] Reserved ranges193 * @property {string[]} [reservedName] Reserved names194 */195 196/**197 * Properties of a MessageOptions message.198 * @interface IMessageOptions199 * @property {boolean} [mapEntry=false] Whether this message is a map entry200 */201 202/**203 * Properties of an ExtensionRange message.204 * @interface IDescriptorProtoExtensionRange205 * @property {number} [start] Start field id206 * @property {number} [end] End field id207 */208 209/**210 * Properties of a ReservedRange message.211 * @interface IDescriptorProtoReservedRange212 * @property {number} [start] Start field id213 * @property {number} [end] End field id214 */215 216var unnamedMessageIndex = 0;217 218/**219 * Creates a type from a descriptor.220 *221 * Warning: this is not safe to use with editions protos, since it discards relevant file context.222 *223 * @param {IDescriptorProto|Reader|Uint8Array} descriptor Descriptor224 * @param {string} [edition="proto2"] The syntax or edition to use225 * @param {boolean} [nested=false] Whether or not this is a nested object226 * @param {number} [depth] Current nesting depth, defaults to `0`227 * @returns {Type} Type instance228 */229Type.fromDescriptor = function fromDescriptor(descriptor, edition, nested, depth) {230    if (depth === undefined)231        depth = 0;232    if (depth > $protobuf.util.nestingLimit)233        throw Error("max depth exceeded");234    // Decode the descriptor message if specified as a buffer:235    if (typeof descriptor.length === "number")236        descriptor = exports.DescriptorProto.decode(descriptor);237 238    // Create the message type239    var type = new Type(descriptor.name.length ? descriptor.name : "Type" + unnamedMessageIndex++, fromDescriptorOptions(descriptor.options, exports.MessageOptions)),240        i;241 242    if (!nested)243        type._edition = edition;244 245    /* Oneofs */ if (descriptor.oneofDecl)246        for (i = 0; i < descriptor.oneofDecl.length; ++i)247            type.add(OneOf.fromDescriptor(descriptor.oneofDecl[i]));248    /* Fields */ if (descriptor.field)249        for (i = 0; i < descriptor.field.length; ++i) {250            var field = Field.fromDescriptor(descriptor.field[i], edition, true);251            type.add(field);252            if (descriptor.field[i].hasOwnProperty("oneofIndex")) // eslint-disable-line no-prototype-builtins253                type.oneofsArray[descriptor.field[i].oneofIndex].add(field);254        }255    /* Extension fields */ if (descriptor.extension)256        for (i = 0; i < descriptor.extension.length; ++i)257            type.add(Field.fromDescriptor(descriptor.extension[i], edition, true));258    /* Nested types */ if (descriptor.nestedType)259        for (i = 0; i < descriptor.nestedType.length; ++i) {260            type.add(Type.fromDescriptor(descriptor.nestedType[i], edition, true, depth + 1));261            if (descriptor.nestedType[i].options && descriptor.nestedType[i].options.mapEntry)262                type.setOption("map_entry", true);263        }264    /* Nested enums */ if (descriptor.enumType)265        for (i = 0; i < descriptor.enumType.length; ++i)266            type.add(Enum.fromDescriptor(descriptor.enumType[i], edition, true));267    /* Extension ranges */ if (descriptor.extensionRange && descriptor.extensionRange.length) {268        type.extensions = [];269        for (i = 0; i < descriptor.extensionRange.length; ++i)270            type.extensions.push([ descriptor.extensionRange[i].start, descriptor.extensionRange[i].end ]);271    }272    /* Reserved... */ if (descriptor.reservedRange && descriptor.reservedRange.length || descriptor.reservedName && descriptor.reservedName.length) {273        type.reserved = [];274        /* Ranges */ if (descriptor.reservedRange)275            for (i = 0; i < descriptor.reservedRange.length; ++i)276                type.reserved.push([ descriptor.reservedRange[i].start, descriptor.reservedRange[i].end ]);277        /* Names */ if (descriptor.reservedName)278            for (i = 0; i < descriptor.reservedName.length; ++i)279                type.reserved.push(descriptor.reservedName[i]);280    }281 282    return type;283};284 285/**286 * Converts a type to a descriptor.287 * @returns {Message<IDescriptorProto>} Descriptor288 * @param {string} [edition="proto2"] The syntax or edition to use289 */290Type.prototype.toDescriptor = function toDescriptor(edition) {291    var descriptor = exports.DescriptorProto.create({ name: this.name }),292        i;293 294    /* Fields */ for (i = 0; i < this.fieldsArray.length; ++i) {295        var fieldDescriptor;296        descriptor.field.push(fieldDescriptor = this._fieldsArray[i].toDescriptor(edition));297        if (this._fieldsArray[i] instanceof MapField) { // map fields are repeated FieldNameEntry298            var keyType = toDescriptorType(this._fieldsArray[i].keyType, this._fieldsArray[i].resolvedKeyType, false),299                valueType = toDescriptorType(this._fieldsArray[i].type, this._fieldsArray[i].resolvedType, false),300                valueTypeName = valueType === /* type */ 11 || valueType === /* enum */ 14301                    ? this._fieldsArray[i].resolvedType && shortname(this.parent, this._fieldsArray[i].resolvedType) || this._fieldsArray[i].type302                    : undefined;303            descriptor.nestedType.push(exports.DescriptorProto.create({304                name: fieldDescriptor.typeName,305                field: [306                    exports.FieldDescriptorProto.create({ name: "key", number: 1, label: 1, type: keyType }), // can't reference a type or enum307                    exports.FieldDescriptorProto.create({ name: "value", number: 2, label: 1, type: valueType, typeName: valueTypeName })308                ],309                options: exports.MessageOptions.create({ mapEntry: true })310            }));311        }312    }313    /* Oneofs */ for (i = 0; i < this.oneofsArray.length; ++i)314        descriptor.oneofDecl.push(this._oneofsArray[i].toDescriptor());315    /* Nested... */ for (i = 0; i < this.nestedArray.length; ++i) {316        /* Extension fields */ if (this._nestedArray[i] instanceof Field)317            descriptor.field.push(this._nestedArray[i].toDescriptor(edition));318        /* Types */ else if (this._nestedArray[i] instanceof Type)319            descriptor.nestedType.push(this._nestedArray[i].toDescriptor(edition));320        /* Enums */ else if (this._nestedArray[i] instanceof Enum)321            descriptor.enumType.push(this._nestedArray[i].toDescriptor());322        // plain nested namespaces become packages instead in Root#toDescriptor323    }324    /* Extension ranges */ if (this.extensions)325        for (i = 0; i < this.extensions.length; ++i)326            descriptor.extensionRange.push(exports.DescriptorProto.ExtensionRange.create({ start: this.extensions[i][0], end: this.extensions[i][1] }));327    /* Reserved... */ if (this.reserved)328        for (i = 0; i < this.reserved.length; ++i)329            /* Names */ if (typeof this.reserved[i] === "string")330                descriptor.reservedName.push(this.reserved[i]);331            /* Ranges */ else332                descriptor.reservedRange.push(exports.DescriptorProto.ReservedRange.create({ start: this.reserved[i][0], end: this.reserved[i][1] }));333 334    descriptor.options = toDescriptorOptions(this.options, exports.MessageOptions);335 336    return descriptor;337};338 339// --- Field ---340 341/**342 * Properties of a FieldDescriptorProto message.343 * @interface IFieldDescriptorProto344 * @property {string} [name] Field name345 * @property {number} [number] Field id346 * @property {IFieldDescriptorProtoLabel} [label] Field rule347 * @property {IFieldDescriptorProtoType} [type] Field basic type348 * @property {string} [typeName] Field type name349 * @property {string} [extendee] Extended type name350 * @property {string} [defaultValue] Literal default value351 * @property {number} [oneofIndex] Oneof index if part of a oneof352 * @property {*} [jsonName] Not supported353 * @property {IFieldOptions} [options] Field options354 */355 356/**357 * Values of the FieldDescriptorProto.Label enum.358 * @typedef IFieldDescriptorProtoLabel359 * @type {number}360 * @property {number} LABEL_OPTIONAL=1361 * @property {number} LABEL_REQUIRED=2362 * @property {number} LABEL_REPEATED=3363 */364 365/**366 * Values of the FieldDescriptorProto.Type enum.367 * @typedef IFieldDescriptorProtoType368 * @type {number}369 * @property {number} TYPE_DOUBLE=1370 * @property {number} TYPE_FLOAT=2371 * @property {number} TYPE_INT64=3372 * @property {number} TYPE_UINT64=4373 * @property {number} TYPE_INT32=5374 * @property {number} TYPE_FIXED64=6375 * @property {number} TYPE_FIXED32=7376 * @property {number} TYPE_BOOL=8377 * @property {number} TYPE_STRING=9378 * @property {number} TYPE_GROUP=10379 * @property {number} TYPE_MESSAGE=11380 * @property {number} TYPE_BYTES=12381 * @property {number} TYPE_UINT32=13382 * @property {number} TYPE_ENUM=14383 * @property {number} TYPE_SFIXED32=15384 * @property {number} TYPE_SFIXED64=16385 * @property {number} TYPE_SINT32=17386 * @property {number} TYPE_SINT64=18387 */388 389/**390 * Properties of a FieldOptions message.391 * @interface IFieldOptions392 * @property {boolean} [packed] Whether packed or not (defaults to `false` for proto2 and `true` for proto3)393 * @property {IFieldOptionsJSType} [jstype] JavaScript value type (not used by protobuf.js)394 */395 396/**397 * Values of the FieldOptions.JSType enum.398 * @typedef IFieldOptionsJSType399 * @type {number}400 * @property {number} JS_NORMAL=0401 * @property {number} JS_STRING=1402 * @property {number} JS_NUMBER=2403 */404 405/**406 * Creates a field from a descriptor.407 *408 * Warning: this is not safe to use with editions protos, since it discards relevant file context.409 *410 * @param {IFieldDescriptorProto|Reader|Uint8Array} descriptor Descriptor411 * @param {string} [edition="proto2"] The syntax or edition to use412 * @param {boolean} [nested=false] Whether or not this is a top-level object413 * @returns {Field} Field instance414 */415Field.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {416 417    // Decode the descriptor message if specified as a buffer:418    if (typeof descriptor.length === "number")419        descriptor = exports.DescriptorProto.decode(descriptor);420 421    if (typeof descriptor.number !== "number")422        throw Error("missing field id");423 424    // Rewire field type425    var typeName = descriptor.typeName,426        fieldType;427    if (typeName != null && typeName !== "") {428        if (typeof typeName !== "string" || !typeRefRe.test(typeName))429            throw Error("illegal type name: " + typeName);430        fieldType = typeName;431    } else432        fieldType = fromDescriptorType(descriptor.type);433 434    // Rewire field rule435    var fieldRule;436    switch (descriptor.label) {437        // 0 is reserved for errors438        case 1: fieldRule = undefined; break;439        case 2: fieldRule = "required"; break;440        case 3: fieldRule = "repeated"; break;441        default: throw Error("illegal label: " + descriptor.label);442    }443 444    var extendee = descriptor.extendee;445    if (extendee != null && extendee !== "") {446        if (typeof extendee !== "string" || !typeRefRe.test(extendee))447            throw Error("illegal type name: " + extendee);448    } else449        extendee = undefined;450    var field = new Field(451        descriptor.name.length ? descriptor.name : "field" + descriptor.number,452        descriptor.number,453        fieldType,454        fieldRule,455        extendee456    );457 458    if (!nested)459        field._edition = edition;460 461    field.options = fromDescriptorOptions(descriptor.options, exports.FieldOptions);462    if (descriptor.proto3_optional)463        field.options.proto3_optional = true;464 465    if (descriptor.defaultValue && descriptor.defaultValue.length) {466        var defaultValue = descriptor.defaultValue;467        switch (defaultValue) {468            case "true": case "TRUE":469                defaultValue = true;470                break;471            case "false": case "FALSE":472                defaultValue = false;473                break;474            default:475                var match = numberRe.exec(defaultValue);476                if (match)477                    defaultValue = parseInt(defaultValue); // eslint-disable-line radix478                break;479        }480        field.setOption("default", defaultValue);481    }482 483    if (packableDescriptorType(descriptor.type)) {484        if (edition === "proto3") { // defaults to packed=true (internal preset is packed=true)485            if (descriptor.options && !descriptor.options.packed)486                field.setOption("packed", false);487        } else if ((!edition || edition === "proto2") && descriptor.options && descriptor.options.packed) // defaults to packed=false488            field.setOption("packed", true);489    }490 491    return field;492};493 494/**495 * Converts a field to a descriptor.496 * @returns {Message<IFieldDescriptorProto>} Descriptor497 * @param {string} [edition="proto2"] The syntax or edition to use498 */499Field.prototype.toDescriptor = function toDescriptor(edition) {500    var descriptor = exports.FieldDescriptorProto.create({ name: this.name, number: this.id });501 502    if (this.map) {503 504        descriptor.type = 11; // message505        descriptor.typeName = $protobuf.util.ucFirst(this.name); // fieldName -> FieldNameEntry (built in Type#toDescriptor)506        descriptor.label = 3; // repeated507 508    } else {509 510        // Rewire field type511        switch (descriptor.type = toDescriptorType(this.type, this.resolve().resolvedType, this.delimited)) {512            case 10: // group513            case 11: // type514            case 14: // enum515                descriptor.typeName = this.resolvedType ? shortname(this.parent, this.resolvedType) : this.type;516                break;517        }518 519        // Rewire field rule520        if (this.rule === "repeated") {521            descriptor.label = 3;522        } else if (this.required && edition === "proto2") {523            descriptor.label = 2;524        } else {525            descriptor.label = 1;526        }527    }528 529    // Handle extension field530    descriptor.extendee = this.extensionField ? this.extensionField.parent.fullName : this.extend;531 532    // Handle part of oneof (only meaningful for message types)533    if (this.partOf && this.parent instanceof Type) {534        if ((descriptor.oneofIndex = this.parent.oneofsArray.indexOf(this.partOf)) < 0)535            throw Error("missing oneof");536    }537 538    if (this.options) {539        descriptor.options = toDescriptorOptions(this.options, exports.FieldOptions);540        if (this.options["default"] != null)541            descriptor.defaultValue = String(this.options["default"]);542        if (this.options.proto3_optional)543            descriptor.proto3_optional = true;544    }545 546    if (edition === "proto3") { // defaults to packed=true547        if (!this.packed)548            (descriptor.options || (descriptor.options = exports.FieldOptions.create())).packed = false;549    } else if ((!edition || edition === "proto2") && this.packed) // defaults to packed=false550        (descriptor.options || (descriptor.options = exports.FieldOptions.create())).packed = true;551 552    return descriptor;553};554 555// --- Enum ---556 557/**558 * Properties of an EnumDescriptorProto message.559 * @interface IEnumDescriptorProto560 * @property {string} [name] Enum name561 * @property {IEnumValueDescriptorProto[]} [value] Enum values562 * @property {IEnumOptions} [options] Enum options563 */564 565/**566 * Properties of an EnumValueDescriptorProto message.567 * @interface IEnumValueDescriptorProto568 * @property {string} [name] Name569 * @property {number} [number] Value570 * @property {*} [options] Not supported571 */572 573/**574 * Properties of an EnumOptions message.575 * @interface IEnumOptions576 * @property {boolean} [allowAlias] Whether aliases are allowed577 * @property {boolean} [deprecated]578 */579 580var unnamedEnumIndex = 0;581 582/**583 * Creates an enum from a descriptor.584 *585 * Warning: this is not safe to use with editions protos, since it discards relevant file context.586 *587 * @param {IEnumDescriptorProto|Reader|Uint8Array} descriptor Descriptor588 * @param {string} [edition="proto2"] The syntax or edition to use589 * @param {boolean} [nested=false] Whether or not this is a top-level object590 * @returns {Enum} Enum instance591 */592Enum.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {593 594    // Decode the descriptor message if specified as a buffer:595    if (typeof descriptor.length === "number")596        descriptor = exports.EnumDescriptorProto.decode(descriptor);597 598    // Construct values object599    var values = {};600    if (descriptor.value)601        for (var i = 0; i < descriptor.value.length; ++i) {602            var name  = descriptor.value[i].name,603                value = descriptor.value[i].number || 0;604            values[name && name.length ? name : "NAME" + value] = value;605        }606 607    var enm = new Enum(608        descriptor.name && descriptor.name.length ? descriptor.name : "Enum" + unnamedEnumIndex++,609        values,610        fromDescriptorOptions(descriptor.options, exports.EnumOptions)611    );612 613    if (!nested)614        enm._edition = edition;615 616    return enm;617};618 619/**620 * Converts an enum to a descriptor.621 * @returns {Message<IEnumDescriptorProto>} Descriptor622 */623Enum.prototype.toDescriptor = function toDescriptor() {624 625    // Values626    var values = [];627    for (var i = 0, ks = Object.keys(this.values); i < ks.length; ++i)628        values.push(exports.EnumValueDescriptorProto.create({ name: ks[i], number: this.values[ks[i]] }));629 630    return exports.EnumDescriptorProto.create({631        name: this.name,632        value: values,633        options: toDescriptorOptions(this.options, exports.EnumOptions)634    });635};636 637// --- OneOf ---638 639/**640 * Properties of a OneofDescriptorProto message.641 * @interface IOneofDescriptorProto642 * @property {string} [name] Oneof name643 * @property {*} [options] Not supported644 */645 646var unnamedOneofIndex = 0;647 648/**649 * Creates a oneof from a descriptor.650 *651 * Warning: this is not safe to use with editions protos, since it discards relevant file context.652 *653 * @param {IOneofDescriptorProto|Reader|Uint8Array} descriptor Descriptor654 * @returns {OneOf} OneOf instance655 */656OneOf.fromDescriptor = function fromDescriptor(descriptor) {657 658    // Decode the descriptor message if specified as a buffer:659    if (typeof descriptor.length === "number")660        descriptor = exports.OneofDescriptorProto.decode(descriptor);661 662    return new OneOf(663        // unnamedOneOfIndex is global, not per type, because we have no ref to a type here664        descriptor.name && descriptor.name.length ? descriptor.name : "oneof" + unnamedOneofIndex++665        // fromDescriptorOptions(descriptor.options, exports.OneofOptions) - only uninterpreted_option666    );667};668 669/**670 * Converts a oneof to a descriptor.671 * @returns {Message<IOneofDescriptorProto>} Descriptor672 */673OneOf.prototype.toDescriptor = function toDescriptor() {674    return exports.OneofDescriptorProto.create({675        name: this.name676        // options: toDescriptorOptions(this.options, exports.OneofOptions) - only uninterpreted_option677    });678};679 680// --- Service ---681 682/**683 * Properties of a ServiceDescriptorProto message.684 * @interface IServiceDescriptorProto685 * @property {string} [name] Service name686 * @property {IMethodDescriptorProto[]} [method] Methods687 * @property {IServiceOptions} [options] Options688 */689 690/**691 * Properties of a ServiceOptions message.692 * @interface IServiceOptions693 * @property {boolean} [deprecated]694 */695 696var unnamedServiceIndex = 0;697 698/**699 * Creates a service from a descriptor.700 *701 * Warning: this is not safe to use with editions protos, since it discards relevant file context.702 *703 * @param {IServiceDescriptorProto|Reader|Uint8Array} descriptor Descriptor704 * @param {string} [edition="proto2"] The syntax or edition to use705 * @param {boolean} [nested=false] Whether or not this is a top-level object706 * @returns {Service} Service instance707 */708Service.fromDescriptor = function fromDescriptor(descriptor, edition, nested) {709 710    // Decode the descriptor message if specified as a buffer:711    if (typeof descriptor.length === "number")712        descriptor = exports.ServiceDescriptorProto.decode(descriptor);713 714    var service = new Service(descriptor.name && descriptor.name.length ? descriptor.name : "Service" + unnamedServiceIndex++, fromDescriptorOptions(descriptor.options, exports.ServiceOptions));715    if (!nested)716        service._edition = edition;717    if (descriptor.method)718        for (var i = 0; i < descriptor.method.length; ++i)719            service.add(Method.fromDescriptor(descriptor.method[i]));720 721    return service;722};723 724/**725 * Converts a service to a descriptor.726 * @returns {Message<IServiceDescriptorProto>} Descriptor727 */728Service.prototype.toDescriptor = function toDescriptor() {729 730    // Methods731    var methods = [];732    for (var i = 0; i < this.methodsArray.length; ++i)733        methods.push(this._methodsArray[i].toDescriptor());734 735    return exports.ServiceDescriptorProto.create({736        name: this.name,737        method: methods,738        options: toDescriptorOptions(this.options, exports.ServiceOptions)739    });740};741 742// --- Method ---743 744/**745 * Properties of a MethodDescriptorProto message.746 * @interface IMethodDescriptorProto747 * @property {string} [name] Method name748 * @property {string} [inputType] Request type name749 * @property {string} [outputType] Response type name750 * @property {IMethodOptions} [options] Not supported751 * @property {boolean} [clientStreaming=false] Whether requests are streamed752 * @property {boolean} [serverStreaming=false] Whether responses are streamed753 */754 755/**756 * Properties of a MethodOptions message.757 *758 * Warning: this is not safe to use with editions protos, since it discards relevant file context.759 *760 * @interface IMethodOptions761 * @property {boolean} [deprecated]762 */763 764var unnamedMethodIndex = 0;765 766/**767 * Creates a method from a descriptor.768 * @param {IMethodDescriptorProto|Reader|Uint8Array} descriptor Descriptor769 * @returns {Method} Reflected method instance770 */771Method.fromDescriptor = function fromDescriptor(descriptor) {772 773    // Decode the descriptor message if specified as a buffer:774    if (typeof descriptor.length === "number")775        descriptor = exports.MethodDescriptorProto.decode(descriptor);776 777    var inputType = descriptor.inputType,778        outputType = descriptor.outputType;779 780    if (inputType != null && inputType !== "") {781        if (typeof inputType !== "string" || !typeRefRe.test(inputType))782            throw Error("illegal type name: " + inputType);783    }784    if (outputType != null && outputType !== "") {785        if (typeof outputType !== "string" || !typeRefRe.test(outputType))786            throw Error("illegal type name: " + outputType);787    }788 789    return new Method(790        // unnamedMethodIndex is global, not per service, because we have no ref to a service here791        descriptor.name && descriptor.name.length ? descriptor.name : "Method" + unnamedMethodIndex++,792        "rpc",793        inputType,794        outputType,795        Boolean(descriptor.clientStreaming),796        Boolean(descriptor.serverStreaming),797        fromDescriptorOptions(descriptor.options, exports.MethodOptions)798    );799};800 801/**802 * Converts a method to a descriptor.803 * @returns {Message<IMethodDescriptorProto>} Descriptor804 */805Method.prototype.toDescriptor = function toDescriptor() {806    return exports.MethodDescriptorProto.create({807        name: this.name,808        inputType: this.resolvedRequestType ? this.resolvedRequestType.fullName : this.requestType,809        outputType: this.resolvedResponseType ? this.resolvedResponseType.fullName : this.responseType,810        clientStreaming: this.requestStream,811        serverStreaming: this.responseStream,812        options: toDescriptorOptions(this.options, exports.MethodOptions)813    });814};815 816// --- utility ---817 818// Converts a descriptor type to a protobuf.js basic type819function fromDescriptorType(type) {820    switch (type) {821        // 0 is reserved for errors822        case 1: return "double";823        case 2: return "float";824        case 3: return "int64";825        case 4: return "uint64";826        case 5: return "int32";827        case 6: return "fixed64";828        case 7: return "fixed32";829        case 8: return "bool";830        case 9: return "string";831        case 12: return "bytes";832        case 13: return "uint32";833        case 15: return "sfixed32";834        case 16: return "sfixed64";835        case 17: return "sint32";836        case 18: return "sint64";837    }838    throw Error("illegal type: " + type);839}840 841// Tests if a descriptor type is packable842function packableDescriptorType(type) {843    switch (type) {844        case 1: // double845        case 2: // float846        case 3: // int64847        case 4: // uint64848        case 5: // int32849        case 6: // fixed64850        case 7: // fixed32851        case 8: // bool852        case 13: // uint32853        case 14: // enum (!)854        case 15: // sfixed32855        case 16: // sfixed64856        case 17: // sint32857        case 18: // sint64858            return true;859    }860    return false;861}862 863// Converts a protobuf.js basic type to a descriptor type864function toDescriptorType(type, resolvedType, delimited) {865    switch (type) {866        // 0 is reserved for errors867        case "double": return 1;868        case "float": return 2;869        case "int64": return 3;870        case "uint64": return 4;871        case "int32": return 5;872        case "fixed64": return 6;873        case "fixed32": return 7;874        case "bool": return 8;875        case "string": return 9;876        case "bytes": return 12;877        case "uint32": return 13;878        case "sfixed32": return 15;879        case "sfixed64": return 16;880        case "sint32": return 17;881        case "sint64": return 18;882    }883    if (resolvedType instanceof Enum)884        return 14;885    if (resolvedType instanceof Type)886        return delimited ? 10 : 11;887    throw Error("illegal type: " + type);888}889 890function fromDescriptorOptionsRecursive(obj, type) {891    var val = {};892    for (var i = 0, field, key; i < type.fieldsArray.length; ++i) {893        if ((key = (field = type._fieldsArray[i]).name) === "uninterpretedOption") continue;894        if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;895 896        var newKey = underScore(key);897        if (field.resolvedType instanceof Type) {898            val[newKey] = fromDescriptorOptionsRecursive(obj[key], field.resolvedType);899        } else if(field.resolvedType instanceof Enum) {900            val[newKey] = field.resolvedType.valuesById[obj[key]];901        } else {902            val[newKey] = obj[key];903        }904    }905    return val;906}907 908// Converts descriptor options to an options object909function fromDescriptorOptions(options, type) {910    if (!options)911        return undefined;912    return fromDescriptorOptionsRecursive(type.toObject(options), type);913}914 915function toDescriptorOptionsRecursive(obj, type) {916    var val = {};917    var keys = Object.keys(obj);918    for (var i = 0; i < keys.length; ++i) {919        var key = keys[i];920        var newKey = $protobuf.util.camelCase(key);921        if (!Object.prototype.hasOwnProperty.call(type.fields, newKey)) continue;922        var field = type.fields[newKey];923        if (field.resolvedType instanceof Type) {924            val[newKey] = toDescriptorOptionsRecursive(obj[key], field.resolvedType);925        } else {926            val[newKey] = obj[key];927        }928        if (field.repeated && !Array.isArray(val[newKey])) {929            val[newKey] = [val[newKey]];930        }931    }932    return val;933}934 935// Converts an options object to descriptor options936function toDescriptorOptions(options, type) {937    if (!options)938        return undefined;939    return type.fromObject(toDescriptorOptionsRecursive(options, type));940}941 942// Calculates the shortest relative path from `from` to `to`.943function shortname(from, to) {944    var fromPath = from.fullName.split("."),945        toPath = to.fullName.split("."),946        i = 0,947        j = 0,948        k = toPath.length - 1;949    if (!(from instanceof Root) && to instanceof Namespace)950        while (i < fromPath.length && j < k && fromPath[i] === toPath[j]) {951            var other = to.lookup(fromPath[i++], true);952            if (other !== null && other !== to)953                break;954            ++j;955        }956    else957        for (; i < fromPath.length && j < k && fromPath[i] === toPath[j]; ++i, ++j);958    return toPath.slice(j).join(".");959}960 961// copied here from cli/targets/proto.js962function underScore(str) {963    return str.substring(0,1)964         + str.substring(1)965               .replace(/([A-Z])(?=[a-z]|$)/g, function($0, $1) { return "_" + $1.toLowerCase(); });966}967 968function editionFromDescriptor(fileDescriptor) {969    if (fileDescriptor.syntax === "editions") {970        switch(fileDescriptor.edition) {971            case exports.Edition.EDITION_2023:972                return "2023";973            default:974                throw new Error("Unsupported edition " + fileDescriptor.edition);975        }976    }977    if (fileDescriptor.syntax === "proto3") {978        return "proto3";979    }980    return "proto2";981}982 983function editionToDescriptor(edition, fileDescriptor) {984    if (!edition) return;985    if (edition === "proto2" || edition === "proto3") {986        fileDescriptor.syntax = edition;987    } else {988        fileDescriptor.syntax = "editions";989        switch(edition) {990            case "2023":991                fileDescriptor.edition = exports.Edition.EDITION_2023;992                break;993            default:994                throw new Error("Unsupported edition " + edition);995        }996    }997}998 999// --- exports ---1000 1001/**1002 * Reflected file descriptor set.1003 * @name FileDescriptorSet1004 * @type {Type}1005 * @const1006 * @tstype $protobuf.Type1007 */1008 1009/**1010 * Reflected file descriptor proto.1011 * @name FileDescriptorProto1012 * @type {Type}1013 * @const1014 * @tstype $protobuf.Type1015 */1016 1017/**1018 * Reflected descriptor proto.1019 * @name DescriptorProto1020 * @type {Type}1021 * @property {Type} ExtensionRange1022 * @property {Type} ReservedRange1023 * @const1024 * @tstype $protobuf.Type & {1025 *     ExtensionRange: $protobuf.Type,1026 *     ReservedRange: $protobuf.Type1027 * }1028 */1029 1030/**1031 * Reflected field descriptor proto.1032 * @name FieldDescriptorProto1033 * @type {Type}1034 * @property {Enum} Label1035 * @property {Enum} Type1036 * @const1037 * @tstype $protobuf.Type & {1038 *     Label: $protobuf.Enum,1039 *     Type: $protobuf.Enum1040 * }1041 */1042 1043/**1044 * Reflected oneof descriptor proto.1045 * @name OneofDescriptorProto1046 * @type {Type}1047 * @const1048 * @tstype $protobuf.Type1049 */1050 1051/**1052 * Reflected enum descriptor proto.1053 * @name EnumDescriptorProto1054 * @type {Type}1055 * @const1056 * @tstype $protobuf.Type1057 */1058 1059/**1060 * Reflected service descriptor proto.1061 * @name ServiceDescriptorProto1062 * @type {Type}1063 * @const1064 * @tstype $protobuf.Type1065 */1066 1067/**1068 * Reflected enum value descriptor proto.1069 * @name EnumValueDescriptorProto1070 * @type {Type}1071 * @const1072 * @tstype $protobuf.Type1073 */1074 1075/**1076 * Reflected method descriptor proto.1077 * @name MethodDescriptorProto1078 * @type {Type}1079 * @const1080 * @tstype $protobuf.Type1081 */1082 1083/**1084 * Reflected file options.1085 * @name FileOptions1086 * @type {Type}1087 * @property {Enum} OptimizeMode1088 * @const1089 * @tstype $protobuf.Type & {1090 *     OptimizeMode: $protobuf.Enum1091 * }1092 */1093 1094/**1095 * Reflected message options.1096 * @name MessageOptions1097 * @type {Type}1098 * @const1099 * @tstype $protobuf.Type1100 */1101 1102/**1103 * Reflected field options.1104 * @name FieldOptions1105 * @type {Type}1106 * @property {Enum} CType1107 * @property {Enum} JSType1108 * @const1109 * @tstype $protobuf.Type & {1110 *     CType: $protobuf.Enum,1111 *     JSType: $protobuf.Enum1112 * }1113 */1114 1115/**1116 * Reflected oneof options.1117 * @name OneofOptions1118 * @type {Type}1119 * @const1120 * @tstype $protobuf.Type1121 */1122 1123/**1124 * Reflected enum options.1125 * @name EnumOptions1126 * @type {Type}1127 * @const1128 * @tstype $protobuf.Type1129 */1130 1131/**1132 * Reflected enum value options.1133 * @name EnumValueOptions1134 * @type {Type}1135 * @const1136 * @tstype $protobuf.Type1137 */1138 1139/**1140 * Reflected service options.1141 * @name ServiceOptions1142 * @type {Type}1143 * @const1144 * @tstype $protobuf.Type1145 */1146 1147/**1148 * Reflected method options.1149 * @name MethodOptions1150 * @type {Type}1151 * @const1152 * @tstype $protobuf.Type1153 */1154 1155/**1156 * Reflected uninterpretet option.1157 * @name UninterpretedOption1158 * @type {Type}1159 * @property {Type} NamePart1160 * @const1161 * @tstype $protobuf.Type & {1162 *     NamePart: $protobuf.Type1163 * }1164 */1165 1166/**1167 * Reflected source code info.1168 * @name SourceCodeInfo1169 * @type {Type}1170 * @property {Type} Location1171 * @const1172 * @tstype $protobuf.Type & {1173 *     Location: $protobuf.Type1174 * }1175 */1176 1177/**1178 * Reflected generated code info.1179 * @name GeneratedCodeInfo1180 * @type {Type}1181 * @property {Type} Annotation1182 * @const1183 * @tstype $protobuf.Type & {1184 *     Annotation: $protobuf.Type1185 * }1186 */1187