npm - @openclaw/diagnostics-otel - Versions diffs - 2026.7.2-beta.4 → 2026.7.2-beta.7 - Mend

@openclaw/diagnostics-otel 2026.7.2-beta.4 → 2026.7.2-beta.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10221) hide show

package/node_modules/@opentelemetry/sdk-node/node_modules/protobufjs/dist/protobuf.min.js.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"sources":["lib/prelude.js","../src/common.js","../src/converter.js","../src/decoder.js","../src/encoder.js","../src/enum.js","../src/field.js","../src/index-light.js","../src/index-minimal.js","../src/index","../src/mapfield.js","../src/message.js","../src/method.js","../src/namespace.js","../src/object.js","../src/oneof.js","../src/parse.js","../src/reader.js","../src/reader_buffer.js","../src/root.js","../src/roots.js","../src/rpc.js","../src/rpc/service.js","../src/service.js","../src/tokenize.js","../src/type.js","../src/types.js","../src/util.js","../src/util/aspromise.js","../src/util/base64.js","../src/util/codegen.js","../src/util/eventemitter.js","../src/util/fetch.js","../src/util/float.js","../src/util/fs.js","../src/util/longbits.js","../src/util/minimal.js","../src/util/path.js","../src/util/patterns.js","../src/util/pool.js","../src/util/utf8.js","../src/verifier.js","../src/wrappers.js","../src/writer.js","../src/writer_buffer.js"],"names":["undefined","modules","cache","protobuf","1","require","module","exports","common","commonRe","name","json","test","nested","google","Any","fields","type_url","type","id","value","Duration","timeType","seconds","nanos","Timestamp","Empty","Struct","keyType","Value","oneofs","kind","oneof","nullValue","protoName","numberValue","stringValue","boolValue","structValue","listValue","NullValue","values","NULL_VALUE","ListValue","rule","DoubleValue","FloatValue","Int64Value","UInt64Value","Int32Value","UInt32Value","BoolValue","StringValue","BytesValue","FieldMask","paths","get","file","Enum","types","util","genValuePartial_fromObject","gen","field","fieldIndex","prop","dstProp","resolvedType","dst","keys","Object","i","length","_features","enum_type","fullName","isUnsigned","genValuePartial_toObject","srcProp","converter","fromObject","mtype","fieldsArray","codegen","resolve","safeProp","implicitPresence","hasPresence","repeated","map","basic","typeDefault","long","toObject","slice","sort","compareFieldsById","repeatedFields","mapFields","normalFields","partOf","push","arrayDefault","valuesById","low","high","unsigned","toString","toNumber","bytes","Array","prototype","call","base64","encode","hasKs2","longKey","index","_fieldsArray","indexOf","isProto3Optional","hasMapField","needsValueVar","pfield","val","ref","closed","defaults","mapKey","stringMethod","genPreserveUnknown","packed","delimited","rfield","required","utf8_validation","wireType","genTypePartial","ReflectionObject","Namespace","create","constructor","writable","enumerable","configurable","className","options","comment","comments","valuesOptions","this","TypeError","_valuesFeatures","reserved","_resolveFeatures","edition","_edition","forEach","key","parentFeaturesCopy","merge","features","fromJSON","enm","_defaultEdition","toJSON","toJSONOptions","keepComments","Boolean","_editionToJSON","add","isString","isInteger","Error","isReservedId","isReservedName","allow_alias","remove","Field","Type","ruleRe","extend","isObject","toLowerCase","message","defaultValue","Long","extensionField","declaringField","jsonName","json_name","defineProperty","field_presence","message_encoding","repeated_field_encoding","setOption","ifNotSet","buf","resolved","parent","lookupTypeOrEnum","proto3_optional","fromNumber","freeze","decode","newBuffer","utf8","write","emptyObject","emptyArray","_ctor","_inferLegacyProtoFeatures","split","pop","group","getOption","d","fieldId","fieldType","fieldRule","decorateType","decorateEnum","fieldName","default","_configure","Type_","build","load","filename","root","callback","Root","loadSync","encoder","decoder","verifier","OneOf","MapField","Service","Method","Message","wrappers","configure","LongBits","Writer","BufferWriter","Reader","BufferReader","rpc","roots","tokenize","parse","resolvedKeyType","fieldKeyType","fieldValueType","properties","$type","writer","encodeDelimited","reader","decodeDelimited","verify","object","requestType","responseType","requestStream","responseStream","parsedOptions","path","resolvedRequestType","resolvedResponseType","serviceName","substring","lookupType","arrayToJSON","array","obj","_nestedArray","_lookupCache","_needsRecursiveFeatureResolution","_needsRecursiveResolve","clearCache","namespace","depth","recursionLimit","addJSON","toArray","nestedArray","nestedJson","names","methods","hasOwnProperty","getEnum","prev","setOptions","onAdd","onRemove","define","isArray","ptr","part","shift","resolveAll","_resolveFeaturesRecursive","lookup","filterTypes","parentAlreadyChecked","flatPath","join","found","_lookupImpl","_fullyQualifiedObjects","current","exact","lookupEnum","lookupService","Service_","Enum_","editions2024Defaults","json_format","enforce_naming_style","default_symbol_visibility","editions2023Defaults","proto2Defaults","proto3Defaults","_featuresResolved","defineProperties","unshift","_handleAdd","_handleRemove","protoFeatures","assign","lexicalParentFeaturesCopy","setProperty","setParsedOption","propName","opt","newOpt","find","newValue","Root_","fieldNames","addFieldsToParent","splice","arguments","oneofName","oneOfGetter","set","oneOfSetter","keepCase","base10Re","base10NegRe","base16Re","base16NegRe","base8Re","base8NegRe","numberRe","patterns","nameRe","typeRefRe","maxFieldId","maxEnumId","source","pkg","imports","weakImports","token","preferTrailingComment","tn","alternateCommentMode","next","peek","skip","cmnt","head","topLevelObjects","topLevelOptions","applyCase","camelCase","illegal","insideTryCatch","line","readString","readValue","acceptTypeRef","parseNumber","sign","Infinity","NaN","parseInt","parseFloat","e","readRanges","target","acceptStrings","max","acceptNegative","start","parseId","err","str","dummy","ifBlock","parseOption","parseInlineOptions","parseCommon","parseType","parseEnum","parseService","service","parseMethod","commentText","method","parseExtension","reference","parseField","fnIf","fnElse","trailingLine","nestingLimit","parseMapField","parseOneOf","extensions","parseGroup","lcFirst","ucFirst","endsWith","startsWith","valueType","isOption","parensValue","includes","tokens","option","concat","optionValue","parseOptionValue","lastValue","lastValueIsAggregate","objectResult","slash","lastIndexOf","prevValue","simpleValue","parseImport","whichImports","package","indexOutOfRange","writeLength","RangeError","pos","len","buffer","view","discardUnknown","create_array","Uint8Array","Buffer","isBuffer","readLongVarint","bits","lo","hi","readFixed32_end","end","readFixed64","raw","subarray","uint32","tag","int32","sint32","bool","b","fixed32","sfixed32","float","readFloatLE","double","readDoubleLE","uint32s","int32s","sint32s","bools","getLazyView","count","threshold","DataView","byteOffset","byteLength","fixed32s","dv","k","getUint32","j","sfixed32s","getInt32","floats","getFloat32","doubles","getFloat64","uint64s","uint64","int64s","int64","sint64s","sint64","fixed64s","fixed64","sfixed64s","sfixed64","string","read","stringVerify","readStrict","skipType","fieldNumber","nestedField","BufferReader_","fn","zzDecode","_slice","utf8Slice","deferred","files","SYNC","resolvePath","fetch","self","asPromise","sync","finish","cb","getBundledFileName","idx","altname","process","JSON","parsed","queued","weak","setTimeout","fs","readFileSync","isNode","exposeRe","tryHandleExtension","sisterField","extendedType","parse_","common_","rpcImpl","requestDelimited","responseDelimited","EventEmitter","rpcCall","requestCtor","responseCtor","request","response","emit","endedByRPC","off","_methodsArray","inherited","methodsArray","rpcService","replace","ctor","delimRe","stringDoubleRe","stringSingleRe","setCommentRe","setCommentAltRe","setCommentSplitRe","whitespaceRe","unescapeRe","unescapeMap","0","r","n","t","unescape","$0","$1","offset","lastCommentLine","stack","stringDelim","subject","charAt","setComment","isLeading","c","lineEmpty","leading","lookback","commentOffset","lines","trim","text","isDoubleSlashCommentLine","startOffset","endOffset","findEndOfLine","lineText","cursor","re","match","lastIndex","exec","repeat","curr","isDoc","nextLineIsComment","isLeadingComment","Math","min","expected","optional","actual","ret","_fieldsById","_oneofsArray","_fieldsByJsonName","fieldsById","oneofsArray","generateConstructor","ctorProperties","filter","setup","C","wrapper","wrapperThis","bind","apply","fork","ldelim","getTypeUrl","prefix","typeName","s","bake","o","reservedRe","camelCaseRe","isReserved","stringify","toUpperCase","decorateEnumIndex","result","upperNext","ch","a","decorateRoot","setProp","isUnsafeProperty","ctx","params","pending","Promise","reject","p","floor","b64","s64","parts","chunk","String","fromCharCode","invalidEncoding","base64Re","charCodeAt","base64UrlRe","base64UrlNoPaddingRe","functionParams","functionName","body","Codegen","formatStringOrScope","verbose","console","log","scopeKeys","scopeParams","scopeValues","scopeOffset","Function","formatParams","formatOffset","Number","functionNameOverride","_listeners","on","evt","listeners","args","xhr","readFile","contents","XMLHttpRequest","binary","onreadystatechange","readyState","status","responseText","overrideMimeType","open","send","factory","writeFloat_ieee754","writeUint","isNaN","round","exponent","LN2","pow","readFloat_ieee754","readUint","uint","mantissa","writeFloat_f32_cpy","f32","f8b","writeFloat_f32_rev","readFloat_f32_cpy","readFloat_f32_rev","f64","le","writeDouble_ieee754","off0","off1","readDouble_ieee754","writeDouble_f64_cpy","writeDouble_f64_rev","readDouble_f64_cpy","readDouble_f64_rev","Float32Array","writeFloatLE","writeFloatBE","readFloatBE","writeUintLE","writeUintBE","readUintLE","readUintBE","Float64Array","writeDoubleLE","writeDoubleBE","readDoubleBE","zero","zzEncode","zeroHash","from","fromString","toLong","fromHash","hash","toHash","mask","part0","part1","part2","Long_","limit","src","newError","CustomError","captureStackTrace","pool","global","versions","node","window","globalThis","isFinite","isset","isSet","utf8Write","sizeOrArray","allocUnsafe","rawField","data","out","dcodeIO","isLong","key2Re","key32Re","key64Re","longToHash","longFromHash","fromBits","longFromKey","boolFromKey","makeProp","ProtocolError","fieldMap","longs","enums","urlRe","isAbsolute","normalize","normalizedUrl","URL","href","firstTwoCharacters","uncPrefix","absolute","originPath","includePath","alreadyNormalized","resolvedUrl","alloc","size","SIZE","MAX","slab","strictDecoder","looseDecoder","TextDecoder","ignoreBOM","fatal","utf8_read_js","c3","c2","t2","utf8_read_decoder","c1","c4","c5","c6","c7","c8","seenFirstField","oneofProp","invalid","genVerifyValue","messageName","states","sizeVarint32","writeVarint32","writeVarint64","writeFixed32","_reserve","need","_delim","copyWithin","lenPos","writeStringAscii","setUint32","setFloat32","setFloat64","reset","vlen","shared","finishInto","BufferWriter_","writeStringBuffer","$require","$module","amd"],"mappings":"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","file":"protobuf.min.js","sourcesContent":["(function prelude(modules, cache, entries) {\n\n // This is the prelude used to bundle protobuf.js for the browser. Wraps up the CommonJS\n // sources through a conflict-free require shim and is again wrapped within an iife that\n // provides a minification-friendly `undefined` var plus a global \"use strict\" directive\n // so that minification can remove the directives of each module.\n\n function $require(name) {\n var $module = cache[name];\n if (!$module)\n modules[name][0].call($module = cache[name] = { exports: {} }, $require, $module, $module.exports);\n return $module.exports;\n }\n\n var protobuf = $require(entries[0]);\n\n // Expose globally\n protobuf.util.global.protobuf = protobuf;\n\n // Be nice to AMD\n if (typeof define === \"function\" && define.amd)\n define([\"long\"], function(Long) {\n if (Long && Long.isLong) {\n protobuf.util.Long = Long;\n protobuf.configure();\n }\n return protobuf;\n });\n\n // Be nice to CommonJS\n if (typeof module === \"object\" && module && module.exports)\n module.exports = protobuf;\n\n})/* end of prelude */","\"use strict\";\nmodule.exports = common;\n\nvar commonRe = /\\/|\\./;\n\n/**\n * Provides common type definitions.\n * Can also be used to provide additional google types or your own custom types.\n * @param {string} name Short name as in `google/protobuf/[name].proto` or full file name\n * @param {Object.<string,*>} json JSON definition within `google.protobuf` if a short name, otherwise the file's root definition\n * @returns {undefined}\n * @property {INamespace} google/protobuf/any.proto Any\n * @property {INamespace} google/protobuf/duration.proto Duration\n * @property {INamespace} google/protobuf/empty.proto Empty\n * @property {INamespace} google/protobuf/field_mask.proto FieldMask\n * @property {INamespace} google/protobuf/struct.proto Struct, Value, NullValue and ListValue\n * @property {INamespace} google/protobuf/timestamp.proto Timestamp\n * @property {INamespace} google/protobuf/wrappers.proto Wrappers\n * @example\n * // manually provides descriptor.proto (assumes google/protobuf/ namespace and .proto extension)\n * protobuf.common(\"descriptor\", descriptorJson);\n *\n * // manually provides a custom definition (uses my.foo namespace)\n * protobuf.common(\"my/foo/bar.proto\", myFooBarJson);\n */\nfunction common(name, json) {\n if (!commonRe.test(name)) {\n name = \"google/protobuf/\" + name + \".proto\";\n json = { nested: { google: { nested: { protobuf: { nested: json } } } } };\n }\n common[name] = json;\n}\n\n// Not provided because of limited use (feel free to discuss or to provide yourself):\n//\n// google/protobuf/descriptor.proto\n// google/protobuf/source_context.proto\n// google/protobuf/type.proto\n//\n// Stripped and pre-parsed versions of these non-bundled files are instead available as part of\n// the repository or package within the google/protobuf directory.\n\ncommon(\"any\", {\n\n /**\n * Properties of a google.protobuf.Any message.\n * @interface IAny\n * @type {Object}\n * @property {string} [typeUrl]\n * @property {Uint8Array} [bytes]\n * @memberof common\n */\n Any: {\n fields: {\n type_url: {\n type: \"string\",\n id: 1\n },\n value: {\n type: \"bytes\",\n id: 2\n }\n }\n }\n});\n\nvar timeType;\n\ncommon(\"duration\", {\n\n /**\n * Properties of a google.protobuf.Duration message.\n * @interface IDuration\n * @type {Object}\n * @property {number|Long} [seconds]\n * @property {number} [nanos]\n * @memberof common\n */\n Duration: timeType = {\n fields: {\n seconds: {\n type: \"int64\",\n id: 1\n },\n nanos: {\n type: \"int32\",\n id: 2\n }\n }\n }\n});\n\ncommon(\"timestamp\", {\n\n /**\n * Properties of a google.protobuf.Timestamp message.\n * @interface ITimestamp\n * @type {Object}\n * @property {number|Long} [seconds]\n * @property {number} [nanos]\n * @memberof common\n */\n Timestamp: timeType\n});\n\ncommon(\"empty\", {\n\n /**\n * Properties of a google.protobuf.Empty message.\n * @interface IEmpty\n * @memberof common\n */\n Empty: {\n fields: {}\n }\n});\n\ncommon(\"struct\", {\n\n /**\n * Properties of a google.protobuf.Struct message.\n * @interface IStruct\n * @type {Object}\n * @property {Object.<string,IValue>} [fields]\n * @memberof common\n */\n Struct: {\n fields: {\n fields: {\n keyType: \"string\",\n type: \"Value\",\n id: 1\n }\n }\n },\n\n /**\n * Properties of a google.protobuf.Value message.\n * @interface IValue\n * @type {Object}\n * @property {string} [kind]\n * @property {0} [nullValue]\n * @property {number} [numberValue]\n * @property {string} [stringValue]\n * @property {boolean} [boolValue]\n * @property {IStruct} [structValue]\n * @property {IListValue} [listValue]\n * @memberof common\n */\n Value: {\n oneofs: {\n kind: {\n oneof: [\n \"nullValue\",\n \"numberValue\",\n \"stringValue\",\n \"boolValue\",\n \"structValue\",\n \"listValue\"\n ]\n }\n },\n fields: {\n nullValue: {\n type: \"NullValue\",\n id: 1,\n protoName: \"null_value\"\n },\n numberValue: {\n type: \"double\",\n id: 2,\n protoName: \"number_value\"\n },\n stringValue: {\n type: \"string\",\n id: 3,\n protoName: \"string_value\"\n },\n boolValue: {\n type: \"bool\",\n id: 4,\n protoName: \"bool_value\"\n },\n structValue: {\n type: \"Struct\",\n id: 5,\n protoName: \"struct_value\"\n },\n listValue: {\n type: \"ListValue\",\n id: 6,\n protoName: \"list_value\"\n }\n }\n },\n\n NullValue: {\n values: {\n NULL_VALUE: 0\n }\n },\n\n /**\n * Properties of a google.protobuf.ListValue message.\n * @interface IListValue\n * @type {Object}\n * @property {Array.<IValue>} [values]\n * @memberof common\n */\n ListValue: {\n fields: {\n values: {\n rule: \"repeated\",\n type: \"Value\",\n id: 1\n }\n }\n }\n});\n\ncommon(\"wrappers\", {\n\n /**\n * Properties of a google.protobuf.DoubleValue message.\n * @interface IDoubleValue\n * @type {Object}\n * @property {number} [value]\n * @memberof common\n */\n DoubleValue: {\n fields: {\n value: {\n type: \"double\",\n id: 1\n }\n }\n },\n\n /**\n * Properties of a google.protobuf.FloatValue message.\n * @interface IFloatValue\n * @type {Object}\n * @property {number} [value]\n * @memberof common\n */\n FloatValue: {\n fields: {\n value: {\n type: \"float\",\n id: 1\n }\n }\n },\n\n /**\n * Properties of a google.protobuf.Int64Value message.\n * @interface IInt64Value\n * @type {Object}\n * @property {number|Long} [value]\n * @memberof common\n */\n Int64Value: {\n fields: {\n value: {\n type: \"int64\",\n id: 1\n }\n }\n },\n\n /**\n * Properties of a google.protobuf.UInt64Value message.\n * @interface IUInt64Value\n * @type {Object}\n * @property {number|Long} [value]\n * @memberof common\n */\n UInt64Value: {\n fields: {\n value: {\n type: \"uint64\",\n id: 1\n }\n }\n },\n\n /**\n * Properties of a google.protobuf.Int32Value message.\n * @interface IInt32Value\n * @type {Object}\n * @property {number} [value]\n * @memberof common\n */\n Int32Value: {\n fields: {\n value: {\n type: \"int32\",\n id: 1\n }\n }\n },\n\n /**\n * Properties of a google.protobuf.UInt32Value message.\n * @interface IUInt32Value\n * @type {Object}\n * @property {number} [value]\n * @memberof common\n */\n UInt32Value: {\n fields: {\n value: {\n type: \"uint32\",\n id: 1\n }\n }\n },\n\n /**\n * Properties of a google.protobuf.BoolValue message.\n * @interface IBoolValue\n * @type {Object}\n * @property {boolean} [value]\n * @memberof common\n */\n BoolValue: {\n fields: {\n value: {\n type: \"bool\",\n id: 1\n }\n }\n },\n\n /**\n * Properties of a google.protobuf.StringValue message.\n * @interface IStringValue\n * @type {Object}\n * @property {string} [value]\n * @memberof common\n */\n StringValue: {\n fields: {\n value: {\n type: \"string\",\n id: 1\n }\n }\n },\n\n /**\n * Properties of a google.protobuf.BytesValue message.\n * @interface IBytesValue\n * @type {Object}\n * @property {Uint8Array} [value]\n * @memberof common\n */\n BytesValue: {\n fields: {\n value: {\n type: \"bytes\",\n id: 1\n }\n }\n }\n});\n\ncommon(\"field_mask\", {\n\n /**\n * Properties of a google.protobuf.FieldMask message.\n * @interface IFieldMask\n * @type {Object}\n * @property {string[]} [paths]\n * @memberof common\n */\n FieldMask: {\n fields: {\n paths: {\n rule: \"repeated\",\n type: \"string\",\n id: 1\n }\n }\n }\n});\n\n/**\n * Gets the root definition of the specified common proto file.\n *\n * Bundled definitions are:\n * - google/protobuf/any.proto\n * - google/protobuf/duration.proto\n * - google/protobuf/empty.proto\n * - google/protobuf/field_mask.proto\n * - google/protobuf/struct.proto\n * - google/protobuf/timestamp.proto\n * - google/protobuf/wrappers.proto\n *\n * @param {string} file Proto file name\n * @returns {INamespace|null} Root definition or `null` if not defined\n */\ncommon.get = function get(file) {\n return common[file] || null;\n};\n","\"use strict\";\n/**\n * Runtime message from/to plain object converters.\n * @namespace\n */\nvar converter = exports;\n\nvar Enum = require(6),\n types = require(27),\n util = require(28);\n\n/**\n * Generates a partial value fromObject conveter.\n * @param {Codegen} gen Codegen instance\n * @param {Field} field Reflected field\n * @param {number} fieldIndex Field index\n * @param {string} prop Property reference\n * @param {string} [dstProp] Repeated destination property reference\n * @returns {Codegen} Codegen instance\n * @ignore\n */\nfunction genValuePartial_fromObject(gen, field, fieldIndex, prop, dstProp) {\n /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */\n if (field.resolvedType) {\n if (field.resolvedType instanceof Enum) {\n var dst = dstProp\n ? \"m\" + dstProp + \"[m\" + dstProp + \".length]\"\n : \"m\" + prop;\n gen\n (\"switch(d%s){\", prop);\n for (var values = field.resolvedType.values, keys = Object.keys(values), i = 0; i < keys.length; ++i) { gen\n (\"case%j:\", keys[i])\n (\"case %i:\", values[keys[i]])\n (\"%s=%j\", dst, values[keys[i]])\n (\"break\");\n }\n gen\n (\"default:\");\n if (field.resolvedType._features.enum_type !== \"CLOSED\") {\n gen\n (\"if(typeof d%s===\\\"number\\\"&&(d%s|0)===d%s)\", prop, prop, prop)\n (\"%s=d%s\", dst, prop);\n }\n gen\n (\"}\");\n } else gen\n (\"if(!util.isObject(d%s))\", prop)\n (\"throw TypeError(%j)\", field.fullName + \": object expected\")\n (\"m%s=types[%i].fromObject(d%s,q+1)\", prop, fieldIndex, prop);\n } else {\n var isUnsigned = false;\n switch (field.type) {\n case \"double\":\n case \"float\": gen\n (\"m%s=Number(d%s)\", prop, prop); // also catches \"NaN\", \"Infinity\"\n break;\n case \"uint32\":\n case \"fixed32\": gen\n (\"m%s=d%s>>>0\", prop, prop);\n break;\n case \"int32\":\n case \"sint32\":\n case \"sfixed32\": gen\n (\"m%s=d%s|0\", prop, prop);\n break;\n case \"uint64\":\n case \"fixed64\":\n isUnsigned = true;\n // eslint-disable-next-line no-fallthrough\n case \"int64\":\n case \"sint64\":\n case \"sfixed64\": gen\n (\"if(util.Long)\")\n (\"m%s=util.Long.fromValue(d%s,%j)\", prop, prop, isUnsigned)\n (\"else if(typeof d%s===\\\"string\\\")\", prop)\n (\"m%s=parseInt(d%s,10)\", prop, prop)\n (\"else if(typeof d%s===\\\"number\\\")\", prop)\n (\"m%s=d%s\", prop, prop)\n (\"else if(typeof d%s===\\\"object\\\")\", prop)\n (\"m%s=new util.LongBits(d%s.low>>>0,d%s.high>>>0).toNumber(%s)\", prop, prop, prop, isUnsigned ? \"true\" : \"\");\n break;\n case \"bytes\": gen\n (\"if(typeof d%s===\\\"string\\\")\", prop)\n (\"util.base64.decode(d%s,m%s=util.newBuffer(util.base64.length(d%s)),0)\", prop, prop, prop)\n (\"else if(d%s.length>=0)\", prop)\n (\"m%s=d%s\", prop, prop);\n break;\n case \"string\": gen\n (\"m%s=String(d%s)\", prop, prop);\n break;\n case \"bool\": gen\n (\"m%s=Boolean(d%s)\", prop, prop);\n break;\n /* default: gen\n (\"m%s=d%s\", prop, prop);\n break; */\n }\n }\n return gen;\n /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */\n}\n\n/**\n * Generates a plain object to runtime message converter specific to the specified message type.\n * @param {Type} mtype Message type\n * @returns {Codegen} Codegen instance\n */\nconverter.fromObject = function fromObject(mtype) {\n /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */\n var fields = mtype.fieldsArray;\n var gen = util.codegen([\"d\", \"q\"])\n (\"if(d instanceof C)\")\n (\"return d\")\n (\"if(!util.isObject(d))\")\n (\"throw TypeError(%j)\", mtype.fullName + \": object expected\")\n (\"if(q===undefined)q=0\")\n (\"if(q>util.recursionLimit)\")\n (\"throw Error(\\\"max depth exceeded\\\")\");\n if (!fields.length) return gen\n (\"return new C\");\n gen\n (\"var m=new C\");\n for (var i = 0; i < fields.length; ++i) {\n var field = fields[i].resolve(),\n prop = util.safeProp(field.name),\n implicitPresence = !field.hasPresence && !field.repeated && !field.map\n && (field.resolvedType instanceof Enum || types.basic[field.type] !== undefined);\n\n // Map fields\n if (field.map) { gen\n (\"if(d%s){\", prop)\n (\"if(!util.isObject(d%s))\", prop)\n (\"throw TypeError(%j)\", field.fullName + \": object expected\")\n (\"m%s={}\", prop)\n (\"for(var ks=Object.keys(d%s),i=0;i<ks.length;++i){\", prop);\n gen\n (\"if(ks[i]===\\\"__proto__\\\")\")\n (\"util.makeProp(m%s,ks[i])\", prop);\n genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + \"[ks[i]]\")\n (\"}\")\n (\"}\");\n\n // Repeated fields\n } else if (field.repeated) { gen\n (\"if(d%s){\", prop)\n (\"if(!Array.isArray(d%s))\", prop)\n (\"throw TypeError(%j)\", field.fullName + \": array expected\");\n if (field.resolvedType instanceof Enum) gen\n (\"m%s=[]\", prop);\n else gen\n (\"m%s=Array(d%s.length)\", prop, prop);\n gen\n (\"for(var i=0;i<d%s.length;++i){\", prop);\n genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + \"[i]\", field.resolvedType instanceof Enum ? prop : undefined)\n (\"}\")\n (\"}\");\n\n // Non-repeated fields\n } else {\n if (!(field.resolvedType instanceof Enum)) gen // no need to test for null/undefined if an enum (uses switch)\n (\"if(d%s!=null){\", prop); // !== undefined && !== null\n if (implicitPresence) {\n if (field.resolvedType instanceof Enum) gen\n (\"if(d%s!==%j&&(typeof d%s!==\\\"string\\\"||types[%i].values[d%s]!==%j)){\", prop, field.typeDefault, prop, i, prop, field.typeDefault);\n else if (field.type === \"string\") gen\n (\"if(typeof d%s!==\\\"string\\\"||d%s.length){\", prop, prop);\n else if (field.type === \"bytes\") gen\n (\"if(d%s.length){\", prop);\n else if (field.type === \"bool\") gen\n (\"if(d%s){\", prop);\n else if (field.type === \"double\" || field.type === \"float\") gen\n (\"if(!Object.is(Number(d%s),0)){\", prop);\n else if (types.long[field.type] !== undefined) gen\n (\"if(typeof d%s===\\\"object\\\"?d%s.low||d%s.high:Number(d%s)!==0){\", prop, prop, prop, prop);\n else gen\n (\"if(Number(d%s)!==0){\", prop);\n }\n genValuePartial_fromObject(gen, field, /* not sorted */ i, prop);\n if (implicitPresence) gen\n (\"}\");\n if (!(field.resolvedType instanceof Enum)) gen\n (\"}\");\n }\n } return gen\n (\"return m\");\n /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */\n};\n\n/**\n * Generates a partial value toObject converter.\n * @param {Codegen} gen Codegen instance\n * @param {Field} field Reflected field\n * @param {number} fieldIndex Field index\n * @param {string} dstProp Destination property reference\n * @param {string} [srcProp] Source property reference\n * @returns {Codegen} Codegen instance\n * @ignore\n */\nfunction genValuePartial_toObject(gen, field, fieldIndex, dstProp, srcProp) {\n /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */\n if (!srcProp)\n srcProp = dstProp;\n if (field.resolvedType) {\n if (field.resolvedType instanceof Enum) gen\n (\"d%s=o.enums===String?(types[%i].values[m%s]===undefined?m%s:types[%i].values[m%s]):m%s\", dstProp, fieldIndex, srcProp, srcProp, fieldIndex, srcProp, srcProp);\n else gen\n (\"d%s=types[%i].toObject(m%s,o,q+1)\", dstProp, fieldIndex, srcProp);\n } else {\n var isUnsigned = false;\n switch (field.type) {\n case \"double\":\n case \"float\": gen\n (\"d%s=o.json&&!isFinite(m%s)?String(m%s):m%s\", dstProp, srcProp, srcProp, srcProp);\n break;\n case \"uint64\":\n case \"fixed64\":\n isUnsigned = true;\n // eslint-disable-next-line no-fallthrough\n case \"int64\":\n case \"sint64\":\n case \"sfixed64\": gen\n (\"if(typeof BigInt!==\\\"undefined\\\"&&o.longs===BigInt)\")\n (\"d%s=typeof m%s===\\\"number\\\"?BigInt(m%s):util.Long.fromBits(m%s.low>>>0,m%s.high>>>0,%j).toBigInt()\", dstProp, srcProp, srcProp, srcProp, srcProp, isUnsigned)\n (\"else if(typeof m%s===\\\"number\\\")\", srcProp)\n (\"d%s=o.longs===String?String(m%s):m%s\", dstProp, srcProp, srcProp)\n (\"else\") // Long-like\n (\"d%s=o.longs===String?util.Long.prototype.toString.call(m%s):o.longs===Number?new util.LongBits(m%s.low>>>0,m%s.high>>>0).toNumber(%s):m%s\", dstProp, srcProp, srcProp, srcProp, isUnsigned ? \"true\": \"\", srcProp);\n break;\n case \"bytes\": gen\n (\"d%s=o.bytes===String?util.base64.encode(m%s,0,m%s.length):o.bytes===Array?Array.prototype.slice.call(m%s):m%s\", dstProp, srcProp, srcProp, srcProp, srcProp);\n break;\n default: gen\n (\"d%s=m%s\", dstProp, srcProp);\n break;\n }\n }\n return gen;\n /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */\n}\n\n/**\n * Generates a runtime message to plain object converter specific to the specified message type.\n * @param {Type} mtype Message type\n * @returns {Codegen} Codegen instance\n */\nconverter.toObject = function toObject(mtype) {\n /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */\n var fields = mtype.fieldsArray.slice().sort(util.compareFieldsById);\n if (!fields.length)\n return util.codegen()(\"return {}\");\n var gen = util.codegen([\"m\", \"o\", \"q\"])\n (\"if(!o)\")\n (\"o={}\")\n (\"if(q===undefined)q=0\")\n (\"if(q>util.recursionLimit)\")\n (\"throw Error(\\\"max depth exceeded\\\")\")\n (\"var d={}\");\n\n var repeatedFields = [],\n mapFields = [],\n normalFields = [],\n i = 0;\n for (; i < fields.length; ++i)\n if (!fields[i].partOf)\n ( fields[i].resolve().repeated ? repeatedFields\n : fields[i].map ? mapFields\n : normalFields).push(fields[i]);\n\n if (repeatedFields.length) { gen\n (\"if(o.arrays||o.defaults){\");\n for (i = 0; i < repeatedFields.length; ++i) gen\n (\"d%s=[]\", util.safeProp(repeatedFields[i].name));\n gen\n (\"}\");\n }\n\n if (mapFields.length) { gen\n (\"if(o.objects||o.defaults){\");\n for (i = 0; i < mapFields.length; ++i) gen\n (\"d%s={}\", util.safeProp(mapFields[i].name));\n gen\n (\"}\");\n }\n\n if (normalFields.length) { gen\n (\"if(o.defaults){\");\n for (i = 0; i < normalFields.length; ++i) {\n var field = normalFields[i],\n prop = util.safeProp(field.name);\n if (field.resolvedType instanceof Enum) gen\n (\"d%s=o.enums===String?%j:%j\", prop, field.resolvedType.valuesById[field.typeDefault], field.typeDefault);\n else if (field.long) gen\n (\"if(util.Long){\")\n (\"var n=new util.Long(%i,%i,%j)\", field.typeDefault.low, field.typeDefault.high, field.typeDefault.unsigned)\n (\"d%s=o.longs===String?n.toString():o.longs===Number?n.toNumber():typeof BigInt!==\\\"undefined\\\"&&o.longs===BigInt?n.toBigInt():n\", prop)\n (\"}else\")\n (\"d%s=o.longs===String?%j:typeof BigInt!==\\\"undefined\\\"&&o.longs===BigInt?BigInt(%j):%i\", prop, field.typeDefault.toString(), field.typeDefault.toString(), field.typeDefault.toNumber());\n else if (field.bytes) {\n var arrayDefault = Array.prototype.slice.call(field.typeDefault);\n gen\n (\"if(o.bytes===String)d%s=%j\", prop, util.base64.encode(field.typeDefault, 0, field.typeDefault.length))\n (\"else{\")\n (\"d%s=%j\", prop, arrayDefault)\n (\"if(o.bytes!==Array)d%s=util.newBuffer(d%s)\", prop, prop)\n (\"}\");\n } else gen\n (\"d%s=%j\", prop, field.typeDefault); // also messages (=null)\n } gen\n (\"}\");\n }\n var hasKs2 = false;\n for (i = 0; i < fields.length; ++i) {\n var field = fields[i],\n index = mtype._fieldsArray.indexOf(field),\n prop = util.safeProp(field.name);\n if (field.map) {\n if (!hasKs2) { hasKs2 = true; gen\n (\"var ks2\");\n } gen\n (\"if(m%s&&(ks2=Object.keys(m%s)).length){\", prop, prop)\n (\"d%s={}\", prop);\n var longKey = types.long[field.keyType] !== undefined,\n srcProp = prop + \"[ks2[j]]\";\n gen\n (\"for(var j=0;j<ks2.length;++j){\");\n if (longKey) gen\n (\"var k2=util.longFromKey(ks2[j],%j).toString()\", field.keyType === \"uint64\" || field.keyType === \"fixed64\");\n gen\n (\"if(ks2[j]===\\\"__proto__\\\")\")\n (\"util.makeProp(d%s,ks2[j])\", prop);\n genValuePartial_toObject(gen, field, /* sorted */ index, longKey ? prop + \"[k2]\" : srcProp, srcProp)\n (\"}\");\n } else if (field.repeated) { gen\n (\"if(m%s&&m%s.length){\", prop, prop)\n (\"d%s=Array(m%s.length)\", prop, prop)\n (\"for(var j=0;j<m%s.length;++j){\", prop);\n genValuePartial_toObject(gen, field, /* sorted */ index, prop + \"[j]\")\n (\"}\");\n } else { gen\n (\"if(m%s!=null&&Object.hasOwnProperty.call(m,%j)){\", prop, field.name); // !== undefined && !== null\n genValuePartial_toObject(gen, field, /* sorted */ index, prop);\n if (field.partOf && !field.partOf.isProto3Optional) gen\n (\"if(o.oneofs)\")\n (\"d%s=%j\", util.safeProp(field.partOf.name), field.name);\n }\n gen\n (\"}\");\n }\n return gen\n (\"return d\");\n /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */\n};\n","\"use strict\";\nmodule.exports = decoder;\n\nvar Enum = require(6),\n types = require(27),\n util = require(28);\n\nfunction missing(field) {\n return \"missing required '\" + field.name + \"'\";\n}\n\nfunction stringMethod(field) {\n return field._features.utf8_validation === \"VERIFY\" ? \"stringVerify\" : \"string\";\n}\n\nfunction genPreserveUnknown(gen, ref) {\n /* eslint-disable no-unexpected-multiline */\n return gen\n (\"if(!r.discardUnknown){\")\n (\"util.makeProp(m,\\\"$unknowns\\\",false);\")\n (\"(m.$unknowns||(m.$unknowns=[])).push(%s)\", ref)\n (\"}\");\n /* eslint-enable no-unexpected-multiline */\n}\n\n/**\n * Generates a decoder specific to the specified message type.\n * @param {Type} mtype Message type\n * @returns {Codegen} Codegen instance\n */\nfunction decoder(mtype) {\n /* eslint-disable no-unexpected-multiline */\n var hasMapField = false,\n needsValueVar = false,\n i = 0;\n for (; i < mtype.fieldsArray.length; ++i) {\n var pfield = mtype._fieldsArray[i];\n if (pfield.map)\n hasMapField = true;\n if (pfield.resolvedType instanceof Enum || !pfield.repeated && !pfield.map && !pfield.hasPresence)\n needsValueVar = true;\n }\n var gen = util.codegen([\"r\", \"l\", \"z\", \"q\", \"g\"])\n (\"if(!(r instanceof Reader))\")\n (\"r=Reader.create(r)\")\n (\"if(q===undefined)q=0\")\n (\"if(q>Reader.recursionLimit)\")\n (\"throw Error(\\\"max depth exceeded\\\")\")\n (\"var c=l===undefined?r.len:r.pos+l,m=g||new C\" + (hasMapField ? \",k,v\" : needsValueVar ? \",v\" : \"\"))\n (\"while(r.pos<c){\")\n (\"var s=r.pos\")\n (\"var t=r.tag()\")\n (\"if(t===z){\")\n (\"z=undefined\")\n (\"break\")\n (\"}\");\n if (mtype.fieldsArray.length) gen\n (\"var u=t&7\")\n (\"switch(t>>>=3){\");\n for (i = 0; i < /* initializes */ mtype.fieldsArray.length; ++i) {\n var field = mtype._fieldsArray[i].resolve(),\n type = field.resolvedType instanceof Enum ? \"int32\" : field.type,\n ref = \"m\" + util.safeProp(field.name),\n closed = field.resolvedType instanceof Enum && field.resolvedType._features.enum_type === \"CLOSED\";\n\n // Map fields\n if (field.map) {\n gen\n (\"case %i:{\", field.id)\n (\"if(u!==2)\")\n (\"break\");\n if (!closed) gen\n (\"if(%s===util.emptyObject)\", ref)\n (\"%s={}\", ref);\n gen\n (\"var c2=r.uint32()+r.pos\");\n\n if (types.defaults[field.keyType] !== undefined) gen\n (\"k=%j\", types.defaults[field.keyType]);\n else gen\n (\"k=null\");\n\n if (types.long[type] !== undefined) gen\n (\"v=util.Long?util.Long.fromNumber(0,%j):0\", type === \"uint64\" || type === \"fixed64\");\n else if (types.defaults[type] !== undefined) gen\n (\"v=%j\", types.defaults[type]);\n else gen\n (\"v=null\");\n\n gen\n (\"while(r.pos<c2){\")\n (\"var t2=r.tag()\")\n (\"u=t2&7\")\n (\"switch(t2>>>=3){\")\n (\"case 1:\")\n (\"if(u!==%i)\", types.mapKey[field.keyType])\n (\"break\")\n (\"k=r.%s()\", field.keyType === \"string\" ? stringMethod(field) : field.keyType)\n (\"continue\")\n (\"case 2:\")\n (\"if(u!==%i)\", types.basic[type] === undefined ? 2 : types.basic[type])\n (\"break\");\n\n if (types.basic[type] === undefined) gen\n (\"v=types[%i].decode(r,r.uint32(),undefined,q+1,v)\", i); // can't be groups\n else gen\n (\"v=r.%s()\", type === \"string\" ? stringMethod(field) : type);\n\n gen\n (\"continue\")\n (\"}\")\n (\"r.skipType(u,q,t2)\")\n (\"}\");\n\n if (closed) { gen\n (\"if(types[%i].valuesById[v]===undefined){\", i);\n genPreserveUnknown(gen, \"r.raw(s,r.pos)\")\n (\"continue\")\n (\"}\")\n (\"if(%s===util.emptyObject)\", ref)\n (\"%s={}\", ref);\n }\n\n var val = types.basic[type] === undefined ? \"v||new types[\" + i + \"].ctor\" : \"v\";\n if (types.long[field.keyType] !== undefined) gen\n (\"%s[typeof k===\\\"object\\\"?util.longToHash(k):k]=%s\", ref, val);\n else {\n if (field.keyType === \"string\") gen\n (\"if(k===\\\"__proto__\\\")\")\n (\"util.makeProp(%s,k)\", ref);\n gen\n (\"%s[k]=%s\", ref, val);\n }\n\n // Repeated fields\n } else if (field.repeated) { gen\n (\"case %i:\", field.id)\n (\"{\");\n\n // Packable (always check for forward and backward compatiblity)\n if (types.packed[type] !== undefined) {\n gen\n (\"if(u===2){\");\n if (closed) {\n gen\n (\"var c2=r.uint32()+r.pos\")\n (\"while(r.pos<c2){\")\n (\"s=r.pos\")\n (\"v=r.%s()\", type)\n (\"if(types[%i].valuesById[v]!==undefined){\", i)\n (\"if(!(%s&&%s.length))\", ref, ref)\n (\"%s=[]\", ref)\n (\"%s.push(v)\", ref)\n (\"}else\");\n genPreserveUnknown(gen, \"util.rawField(\" + field.id + \",0,r.raw(s,r.pos))\")\n (\"}\");\n } else gen\n (\"if(!(%s&&%s.length))\", ref, ref)\n (\"%s=[]\", ref)\n (\"r.%ss(%s)\", type, ref);\n gen\n (\"continue\")\n (\"}\");\n }\n\n // Non-packed\n gen\n (\"if(u!==%i)\", types.basic[type] === undefined ? field.delimited ? 3 : 2 : types.basic[type])\n (\"break\");\n if (!closed) gen\n (\"if(!(%s&&%s.length))\", ref, ref)\n (\"%s=[]\", ref);\n if (types.basic[type] === undefined) {\n if (field.delimited) gen\n (\"%s.push(types[%i].decode(r,undefined,%i,q+1))\", ref, i, field.id * 8 + 4);\n else gen\n (\"%s.push(types[%i].decode(r,r.uint32(),undefined,q+1))\", ref, i);\n } else if (closed) { gen\n (\"v=r.%s()\", type)\n (\"if(types[%i].valuesById[v]!==undefined){\", i)\n (\"if(!(%s&&%s.length))\", ref, ref)\n (\"%s=[]\", ref)\n (\"%s.push(v)\", ref)\n (\"}else\");\n genPreserveUnknown(gen, \"r.raw(s,r.pos)\");\n } else gen\n (\"%s.push(r.%s())\", ref, type === \"string\" ? stringMethod(field) : type);\n\n // Non-repeated\n } else if (types.basic[type] === undefined) {\n gen\n (\"case %i:{\", field.id)\n (\"if(u!==%i)\", field.delimited ? 3 : 2)\n (\"break\");\n if (field.delimited) gen\n (\"%s=types[%i].decode(r,undefined,%i,q+1,%s)\", ref, i, field.id * 8 + 4, ref);\n else gen\n (\"%s=types[%i].decode(r,r.uint32(),undefined,q+1,%s)\", ref, i, ref);\n }\n else if (field.hasPresence) {\n gen\n (\"case %i:{\", field.id)\n (\"if(u!==%i)\", types.basic[type])\n (\"break\");\n if (closed) { gen\n (\"v=r.%s()\", type)\n (\"if(types[%i].valuesById[v]!==undefined){\", i)\n (\"%s=v\", ref);\n if (field.partOf) gen\n (\"m%s=%j\", util.safeProp(field.partOf.name), field.name);\n gen\n (\"}else\");\n genPreserveUnknown(gen, \"r.raw(s,r.pos)\");\n } else gen\n (\"%s=r.%s()\", ref, type === \"string\" ? stringMethod(field) : type);\n } else {\n gen\n (\"case %i:{\", field.id)\n (\"if(u!==%i)\", types.basic[type])\n (\"break\");\n if (closed) { gen\n (\"v=r.%s()\", type)\n (\"if(types[%i].valuesById[v]!==undefined){\", i)\n (\"if(v!==%j)\", field.typeDefault)\n (\"%s=v\", ref)\n (\"else\")\n (\"delete %s\", ref)\n (\"}else{\");\n genPreserveUnknown(gen, \"r.raw(s,r.pos)\")\n (\"}\");\n } else {\n if (field.resolvedType instanceof Enum && field.typeDefault !== 0) gen\n // TODO: Protoc rejects open enums whose first value is not zero.\n // We should do the same, but for v8 this would be a regression.\n (\"if((v=r.%s())!==%j)\", type, field.typeDefault);\n else if (type === \"string\") gen\n (\"if((v=r.%s()).length)\", stringMethod(field));\n else if (type === \"bytes\") gen\n (\"if((v=r.%s()).length)\", type);\n else if (types.long[type] !== undefined) gen\n (\"if(typeof(v=r.%s())===\\\"object\\\"?v.low||v.high:v!==0)\", type);\n else if (type === \"double\" || type === \"float\") gen\n (\"if(!Object.is(v=r.%s(),0))\", type);\n else gen\n (\"if(v=r.%s())\", type);\n gen\n (\"%s=v\", ref)\n (\"else\")\n (\"delete %s\", ref); // rare/odd case: later default clears earlier non-default\n }\n }\n if (field.partOf && !closed) gen\n (\"m%s=%j\", util.safeProp(field.partOf.name), field.name);\n gen\n (\"continue\")\n (\"}\");\n }\n if (i) gen\n (\"}\");\n // Unknown fields\n gen\n (\"r.skipType(%s,q,t)\", i ? \"u\" : \"t&7\");\n genPreserveUnknown(gen, \"r.raw(s,r.pos)\")\n (\"}\")\n (\"if(z!==undefined)\")\n (\"throw Error(\\\"missing end group\\\")\");\n\n // Field presence\n for (i = 0; i < mtype._fieldsArray.length; ++i) {\n var rfield = mtype._fieldsArray[i];\n if (rfield.required) gen\n (\"if(!Object.hasOwnProperty.call(m,%j))\", rfield.name)\n (\"throw util.ProtocolError(%j,{instance:m})\", missing(rfield));\n }\n\n return gen\n (\"return m\");\n /* eslint-enable no-unexpected-multiline */\n}\n","\"use strict\";\nmodule.exports = encoder;\n\nvar Enum = require(6),\n types = require(27),\n util = require(28);\n\n/**\n * Generates a partial message type encoder.\n * @param {Codegen} gen Codegen instance\n * @param {Field} field Reflected field\n * @param {number} fieldIndex Field index\n * @param {string} ref Variable reference\n * @returns {Codegen} Codegen instance\n * @ignore\n */\nfunction genTypePartial(gen, field, fieldIndex, ref) {\n return field.delimited\n ? gen(\"types[%i].encode(%s,w.uint32(%i),q+1).uint32(%i)\", fieldIndex, ref, (field.id << 3 | 3) >>> 0, (field.id << 3 | 4) >>> 0)\n : gen(\"types[%i].encode(%s,w.uint32(%i).fork(),q+1).ldelim()\", fieldIndex, ref, (field.id << 3 | 2) >>> 0);\n}\n\n/**\n * Generates an encoder specific to the specified message type.\n * @param {Type} mtype Message type\n * @returns {Codegen} Codegen instance\n */\nfunction encoder(mtype) {\n /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */\n var gen = util.codegen([\"m\", \"w\", \"q\"])\n (\"if(!w)\")\n (\"w=Writer.create()\")\n (\"if(q===undefined)q=0\")\n (\"if(q>util.recursionLimit)\")\n (\"throw Error(\\\"max depth exceeded\\\")\");\n\n var i, ref;\n\n // \"when a message is serialized its known fields should be written sequentially by field number\"\n var fields = /* initializes */ mtype.fieldsArray.slice().sort(util.compareFieldsById);\n\n for (var i = 0; i < fields.length; ++i) {\n var field = fields[i].resolve(),\n index = mtype._fieldsArray.indexOf(field),\n type = field.resolvedType instanceof Enum ? \"int32\" : field.type,\n wireType = types.basic[type];\n ref = \"m\" + util.safeProp(field.name);\n\n // Map fields\n if (field.map) {\n gen\n (\"if(%s!=null&&Object.hasOwnProperty.call(m,%j)){\", ref, field.name) // !== undefined && !== null\n (\"for(var ks=Object.keys(%s),i=0;i<ks.length;++i){\", ref);\n if (field.keyType === \"bool\") gen\n (\"w.uint32(%i).fork().uint32(%i).bool(util.boolFromKey(ks[i]))\", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType]);\n else if (types.long[field.keyType] !== undefined) gen\n (\"w.uint32(%i).fork().uint32(%i).%s(util.longFromKey(ks[i],%j))\", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType], field.keyType, field.keyType === \"uint64\" || field.keyType === \"fixed64\");\n else gen\n (\"w.uint32(%i).fork().uint32(%i).%s(ks[i])\", (field.id << 3 | 2) >>> 0, 8 | types.mapKey[field.keyType], field.keyType);\n if (wireType === undefined) gen\n (\"types[%i].encode(%s[ks[i]],w.uint32(18).fork(),q+1).ldelim().ldelim()\", index, ref); // can't be groups\n else gen\n (\".uint32(%i).%s(%s[ks[i]]).ldelim()\", 16 | wireType, type, ref);\n gen\n (\"}\")\n (\"}\");\n\n // Repeated fields\n } else if (field.repeated) { gen\n (\"if(%s!=null&&%s.length){\", ref, ref); // !== undefined && !== null\n\n // Packed repeated\n if (field.packed && types.packed[type] !== undefined) { gen\n\n (\"w.uint32(%i).%ss(%s)\", (field.id << 3 | 2) >>> 0, type, ref);\n\n // Non-packed\n } else { gen\n\n (\"for(var i=0;i<%s.length;++i)\", ref);\n if (wireType === undefined)\n genTypePartial(gen, field, index, ref + \"[i]\");\n else gen\n (\"w.uint32(%i).%s(%s[i])\", (field.id << 3 | wireType) >>> 0, type, ref);\n\n } gen\n (\"}\");\n\n // Non-repeated\n } else {\n if (!field.required)\n if (field.hasPresence || !(field.resolvedType instanceof Enum || types.basic[type] !== undefined)) gen\n (\"if(%s!=null&&Object.hasOwnProperty.call(m,%j))\", ref, field.name); // !== undefined && !== null\n else if (field.resolvedType instanceof Enum) gen\n (\"if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==%j)\", ref, field.name, ref, field.typeDefault);\n else if (type === \"bool\") gen\n (\"if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==false)\", ref, field.name, ref);\n else if (type === \"string\") gen\n (\"if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==\\\"\\\")\", ref, field.name, ref);\n else if (type === \"bytes\") gen\n (\"if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s.length)\", ref, field.name, ref);\n else if (type === \"double\" || type === \"float\") gen\n (\"if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&!Object.is(%s,0))\", ref, field.name, ref);\n else if (types.long[type] !== undefined) gen\n (\"if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&(typeof %s===\\\"object\\\"?%s.low||%s.high:%s!==0))\", ref, field.name, ref, ref, ref, ref);\n else gen\n (\"if(%s!=null&&Object.hasOwnProperty.call(m,%j)&&%s!==0)\", ref, field.name, ref);\n\n if (wireType === undefined)\n genTypePartial(gen, field, index, ref);\n else gen\n (\"w.uint32(%i).%s(%s)\", (field.id << 3 | wireType) >>> 0, type, ref);\n\n }\n }\n\n return gen\n (\"if(m.$unknowns!=null&&Object.hasOwnProperty.call(m,\\\"$unknowns\\\"))\")\n (\"for(var i=0;i<m.$unknowns.length;++i)\")\n (\"w.raw(m.$unknowns[i])\")\n (\"return w\");\n /* eslint-enable no-unexpected-multiline, block-scoped-var, no-redeclare */\n}\n","\"use strict\";\nmodule.exports = Enum;\n\n// extends ReflectionObject\nvar ReflectionObject = require(15);\nEnum.prototype = Object.create(ReflectionObject.prototype, {\n constructor: {\n value: Enum,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\nEnum.className = \"Enum\";\n\nvar Namespace = require(14),\n util = require(28);\n\n/**\n * Constructs a new enum instance.\n * @classdesc Reflected enum.\n * @extends ReflectionObject\n * @constructor\n * @param {string} name Unique name within its namespace\n * @param {Object.<string,number>} [values] Enum values as an object, by name\n * @param {Object.<string,*>} [options] Declared options\n * @param {string} [comment] The comment for this enum\n * @param {Object.<string,string|null>} [comments] The value comments for this enum\n * @param {Object.<string,Object<string,*>>|undefined} [valuesOptions] The value options for this enum\n */\nfunction Enum(name, values, options, comment, comments, valuesOptions) {\n ReflectionObject.call(this, name, options);\n\n if (values && typeof values !== \"object\")\n throw TypeError(\"values must be an object\");\n\n /**\n * Enum values by id.\n * @type {Object.<number,string>}\n */\n this.valuesById = Object.create(null);\n\n /**\n * Enum values by name.\n * @type {Object.<string,number>}\n */\n this.values = Object.create(this.valuesById); // toJSON, marker\n\n /**\n * Enum comment text.\n * @type {string|null}\n */\n this.comment = comment;\n\n /**\n * Value comment texts, if any.\n * @type {Object.<string,string|null>}\n */\n this.comments = comments || {};\n\n /**\n * Values options, if any\n * @type {Object<string, Object<string, *>>|undefined}\n */\n this.valuesOptions = valuesOptions;\n\n /**\n * Resolved values features, if any\n * @type {Object<string, Object<string, *>>|undefined}\n */\n this._valuesFeatures = {};\n\n /**\n * Reserved ranges, if any.\n * @type {Array.<number[]|string>}\n */\n this.reserved = undefined; // toJSON\n\n // Note that values inherit valuesById on their prototype which makes them a TypeScript-\n // compatible enum. This is used by pbts to write actual enum definitions that work for\n // static and reflection code alike instead of emitting generic object definitions.\n\n if (values)\n for (var keys = Object.keys(values), i = 0; i < keys.length; ++i)\n if (keys[i] !== \"__proto__\" && typeof values[keys[i]] === \"number\") // use forward entries only\n this.valuesById[ this.values[keys[i]] = values[keys[i]] ] = keys[i];\n}\n\n/**\n * @override\n */\nEnum.prototype._resolveFeatures = function _resolveFeatures(edition) {\n edition = this._edition || edition;\n ReflectionObject.prototype._resolveFeatures.call(this, edition);\n\n Object.keys(this.values).forEach(key => {\n var parentFeaturesCopy = util.merge({}, this._features);\n this._valuesFeatures[key] = util.merge(parentFeaturesCopy, this.valuesOptions && this.valuesOptions[key] && this.valuesOptions[key].features || {});\n });\n\n return this;\n};\n\n/**\n * Enum descriptor.\n * @interface IEnum\n * @property {string} [edition] Edition\n * @property {Object.<string,number>} values Enum values\n * @property {Object.<string,*>} [options] Enum options\n * @property {Object.<string,Object.<string,*>>} [valuesOptions] Enum value options\n * @property {Array.<number[]|string>} [reserved] Reserved ranges\n * @property {string|null} [comment] Enum comment\n * @property {Object.<string,string|null>} [comments] Value comments\n */\n\n/**\n * Constructs an enum from an enum descriptor.\n * @param {string} name Enum name\n * @param {IEnum} json Enum descriptor\n * @returns {Enum} Created enum\n * @throws {TypeError} If arguments are invalid\n */\nEnum.fromJSON = function fromJSON(name, json) {\n var enm = new Enum(name, json.values, json.options, json.comment, json.comments, json.valuesOptions);\n enm.reserved = json.reserved;\n if (json.edition)\n enm._edition = json.edition;\n enm._defaultEdition = \"proto3\"; // For backwards-compatibility.\n return enm;\n};\n\n/**\n * Converts this enum to an enum descriptor.\n * @param {IToJSONOptions} [toJSONOptions] JSON conversion options\n * @returns {IEnum} Enum descriptor\n */\nEnum.prototype.toJSON = function toJSON(toJSONOptions) {\n var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;\n return util.toObject([\n \"edition\" , this._editionToJSON(),\n \"options\" , this.options,\n \"valuesOptions\" , this.valuesOptions,\n \"values\" , this.values,\n \"reserved\" , this.reserved && this.reserved.length ? this.reserved : undefined,\n \"comment\" , keepComments ? this.comment : undefined,\n \"comments\" , keepComments ? this.comments : undefined\n ]);\n};\n\n/**\n * Adds a value to this enum.\n * @param {string} name Value name\n * @param {number} id Value id\n * @param {string} [comment] Comment, if any\n * @param {Object.<string, *>|undefined} [options] Options, if any\n * @returns {Enum} `this`\n * @throws {TypeError} If arguments are invalid\n * @throws {Error} If there is already a value with this name or id\n */\nEnum.prototype.add = function add(name, id, comment, options) {\n // utilized by the parser but not by .fromJSON\n\n if (!util.isString(name))\n throw TypeError(\"name must be a string\");\n\n if (!util.isInteger(id))\n throw TypeError(\"id must be an integer\");\n\n if (name === \"__proto__\")\n return this;\n\n if (this.values[name] !== undefined)\n throw Error(\"duplicate name '\" + name + \"' in \" + this);\n\n if (this.isReservedId(id))\n throw Error(\"id \" + id + \" is reserved in \" + this);\n\n if (this.isReservedName(name))\n throw Error(\"name '\" + name + \"' is reserved in \" + this);\n\n if (this.valuesById[id] !== undefined) {\n if (!(this.options && this.options.allow_alias))\n throw Error(\"duplicate id \" + id + \" in \" + this);\n this.values[name] = id;\n } else\n this.valuesById[this.values[name] = id] = name;\n\n if (options) {\n if (this.valuesOptions === undefined)\n this.valuesOptions = {};\n this.valuesOptions[name] = options || null;\n }\n\n this.comments[name] = comment || null;\n return this;\n};\n\n/**\n * Removes a value from this enum\n * @param {string} name Value name\n * @returns {Enum} `this`\n * @throws {TypeError} If arguments are invalid\n * @throws {Error} If `name` is not a name of this enum\n */\nEnum.prototype.remove = function remove(name) {\n\n if (!util.isString(name))\n throw TypeError(\"name must be a string\");\n\n var val = this.values[name];\n if (val == null)\n throw Error(\"name '\" + name + \"' does not exist in \" + this);\n\n delete this.valuesById[val];\n delete this.values[name];\n delete this.comments[name];\n if (this.valuesOptions)\n delete this.valuesOptions[name];\n\n return this;\n};\n\n/**\n * Tests if the specified id is reserved.\n * @param {number} id Id to test\n * @returns {boolean} `true` if reserved, otherwise `false`\n */\nEnum.prototype.isReservedId = function isReservedId(id) {\n return Namespace.isReservedId(this.reserved, id);\n};\n\n/**\n * Tests if the specified name is reserved.\n * @param {string} name Name to test\n * @returns {boolean} `true` if reserved, otherwise `false`\n */\nEnum.prototype.isReservedName = function isReservedName(name) {\n return Namespace.isReservedName(this.reserved, name);\n};\n","\"use strict\";\nmodule.exports = Field;\n\n// extends ReflectionObject\nvar ReflectionObject = require(15);\nField.prototype = Object.create(ReflectionObject.prototype, {\n constructor: {\n value: Field,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\nField.className = \"Field\";\n\nvar Enum = require(6),\n types = require(27),\n util = require(28);\n\nvar Type; // cyclic\n\nvar ruleRe = /^(?:required|optional|repeated)$/;\n\n/**\n * Constructs a new message field instance. Note that {@link MapField|map fields} have their own class.\n * @name Field\n * @classdesc Reflected message field.\n * @extends FieldBase\n * @constructor\n * @param {string} name Unique name within its namespace\n * @param {number} id Unique id within its namespace\n * @param {string} type Value type\n * @param {string|Object.<string,*>} [rule=\"optional\"] Field rule\n * @param {string|Object.<string,*>} [extend] Extended type if different from parent\n * @param {Object.<string,*>} [options] Declared options\n */\n\n/**\n * Constructs a field from a field descriptor.\n * @param {string} name Field name\n * @param {IField} json Field descriptor\n * @returns {Field} Created field\n * @throws {TypeError} If arguments are invalid\n */\nField.fromJSON = function fromJSON(name, json) {\n var field = new Field(name, json.id, json.type, json.rule, json.extend, json.options, json.comment);\n if (json.edition)\n field._edition = json.edition;\n if (json.protoName)\n field.protoName = json.protoName;\n if (json.jsonName !== undefined)\n field.jsonName = json.jsonName;\n else if (json.options && json.options.json_name !== undefined)\n field.jsonName = json.options.json_name;\n field._defaultEdition = \"proto3\"; // For backwards-compatibility.\n return field;\n};\n\n/**\n * Not an actual constructor. Use {@link Field} instead.\n * @classdesc Base class of all reflected message fields. This is not an actual class but here for the sake of having consistent type definitions.\n * @exports FieldBase\n * @extends ReflectionObject\n * @constructor\n * @param {string} name Unique name within its namespace\n * @param {number} id Unique id within its namespace\n * @param {string} type Value type\n * @param {string|Object.<string,*>} [rule=\"optional\"] Field rule\n * @param {string|Object.<string,*>} [extend] Extended type if different from parent\n * @param {Object.<string,*>} [options] Declared options\n * @param {string} [comment] Comment associated with this field\n */\nfunction Field(name, id, type, rule, extend, options, comment) {\n\n if (util.isObject(rule)) {\n comment = extend;\n options = rule;\n rule = extend = undefined;\n } else if (util.isObject(extend)) {\n comment = options;\n options = extend;\n extend = undefined;\n }\n\n ReflectionObject.call(this, name, options);\n\n if (!util.isInteger(id) || id < 0)\n throw TypeError(\"id must be a non-negative integer\");\n\n if (!util.isString(type))\n throw TypeError(\"type must be a string\");\n\n if (rule !== undefined && !ruleRe.test(rule = rule.toString().toLowerCase()))\n throw TypeError(\"rule must be a string rule\");\n\n if (extend !== undefined && !util.isString(extend))\n throw TypeError(\"extend must be a string\");\n\n /**\n * Field rule, if any.\n * @type {string|undefined}\n */\n this.rule = rule && rule !== \"optional\" ? rule : undefined; // toJSON\n\n /**\n * Field type.\n * @type {string}\n */\n this.type = type; // toJSON\n\n /**\n * Unique field id.\n * @type {number}\n */\n this.id = id; // toJSON, marker\n\n /**\n * Extended type if different from parent.\n * @type {string|undefined}\n */\n this.extend = extend || undefined; // toJSON\n\n /**\n * Whether this field is repeated.\n * @type {boolean}\n */\n this.repeated = rule === \"repeated\";\n\n /**\n * Whether this field is a map or not.\n * @type {boolean}\n */\n this.map = false;\n\n /**\n * Message this field belongs to.\n * @type {Type|null}\n */\n this.message = null;\n\n /**\n * OneOf this field belongs to, if any,\n * @type {OneOf|null}\n */\n this.partOf = null;\n\n /**\n * The field type's default value.\n * @type {*}\n */\n this.typeDefault = null;\n\n /**\n * The field's default value on prototypes.\n * @type {*}\n */\n this.defaultValue = null;\n\n /**\n * Whether this field's value should be treated as a long.\n * @type {boolean}\n */\n this.long = util.Long ? types.long[type] !== undefined : /* istanbul ignore next */ false;\n\n /**\n * Whether this field's value is a buffer.\n * @type {boolean}\n */\n this.bytes = type === \"bytes\";\n\n /**\n * Resolved type if not a basic type.\n * @type {Type|Enum|null}\n */\n this.resolvedType = null;\n\n /**\n * Sister-field within the extended type if a declaring extension field.\n * @type {Field|null}\n */\n this.extensionField = null;\n\n /**\n * Sister-field within the declaring namespace if an extended field.\n * @type {Field|null}\n */\n this.declaringField = null;\n\n /**\n * Comment for this field.\n * @type {string|null}\n */\n this.comment = comment;\n\n /**\n * Field name as declared in the .proto source, if different from `name`.\n * @type {string|undefined}\n */\n this.protoName = undefined;\n\n /**\n * JSON name, if different from the derived default.\n * @type {string|undefined}\n */\n this.jsonName = undefined;\n}\n\n/**\n * Determines whether this field is required.\n * @name Field#required\n * @type {boolean}\n * @readonly\n */\nObject.defineProperty(Field.prototype, \"required\", {\n get: function() {\n return this._features.field_presence === \"LEGACY_REQUIRED\";\n }\n});\n\n/**\n * Determines whether this field is not required.\n * @name Field#optional\n * @type {boolean}\n * @readonly\n */\nObject.defineProperty(Field.prototype, \"optional\", {\n get: function() {\n return !this.required;\n }\n});\n\n/**\n * Determines whether this field uses tag-delimited encoding. In proto2 this\n * corresponded to group syntax.\n * @name Field#delimited\n * @type {boolean}\n * @readonly\n */\nObject.defineProperty(Field.prototype, \"delimited\", {\n get: function() {\n return this.resolvedType instanceof Type &&\n this._features.message_encoding === \"DELIMITED\";\n }\n});\n\n/**\n * Determines whether this field is packed. Only relevant when repeated.\n * @name Field#packed\n * @type {boolean}\n * @readonly\n */\nObject.defineProperty(Field.prototype, \"packed\", {\n get: function() {\n return this._features.repeated_field_encoding === \"PACKED\";\n }\n});\n\n/**\n * Determines whether this field tracks presence.\n * @name Field#hasPresence\n * @type {boolean}\n * @readonly\n */\nObject.defineProperty(Field.prototype, \"hasPresence\", {\n get: function() {\n if (this.repeated || this.map) {\n return false;\n }\n return this.partOf || // oneofs\n this.declaringField || this.extensionField || // extensions\n this._features.field_presence !== \"IMPLICIT\";\n }\n});\n\n/**\n * The field name as declared in the .proto source (snake_case). Populated on resolve,\n * falling back to `name`. Mirrors `FieldDescriptorProto.name`.\n * @name Field#protoName\n * @type {string}\n * @readonly\n */\n\n/**\n * The JSON name of this field (lowerCamelCase per protoc's `ToJsonName`, or an\n * explicit `[json_name]`). Populated on resolve. This is the key used on ProtoJSON output.\n * @name Field#jsonName\n * @type {string}\n * @readonly\n */\n\n/**\n * @override\n */\nField.prototype.setOption = function setOption(name, value, ifNotSet) {\n return ReflectionObject.prototype.setOption.call(this, name, value, ifNotSet);\n};\n\n/**\n * Field descriptor.\n * @interface IField\n * @property {string} [edition] Edition\n * @property {string} [rule=\"optional\"] Field rule\n * @property {string} type Field type\n * @property {number} id Field id\n * @property {Object.<string,*>} [options] Field options\n * @property {string|null} [comment] Field comment\n */\n\n/**\n * Extension field descriptor.\n * @interface IExtensionField\n * @extends IField\n * @property {string} extend Extended type\n */\n\n/**\n * Converts this field to a field descriptor.\n * @param {IToJSONOptions} [toJSONOptions] JSON conversion options\n * @returns {IField} Field descriptor\n */\nField.prototype.toJSON = function toJSON(toJSONOptions) {\n var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;\n return util.toObject([\n \"edition\" , this._editionToJSON(),\n \"rule\" , this.rule !== \"optional\" && this.rule || undefined,\n \"type\" , this.type,\n \"id\" , this.id,\n \"extend\" , this.extend,\n \"protoName\" , this.protoName !== this.name ? this.protoName : undefined,\n \"jsonName\" , this.jsonName !== util.jsonName(this.protoName || this.name) ? this.jsonName : undefined,\n \"options\" , this.options,\n \"comment\" , keepComments ? this.comment : undefined\n ]);\n};\n\n/**\n * Resolves this field's type references.\n * @returns {Field} `this`\n * @throws {Error} If any reference cannot be resolved\n */\nField.prototype.resolve = function resolve() {\n\n if (this.resolved)\n return this;\n\n if ((this.typeDefault = types.defaults[this.type]) === undefined) { // if not a basic type, resolve it\n this.resolvedType = (this.declaringField ? this.declaringField.parent : this.parent).lookupTypeOrEnum(this.type);\n if (this.resolvedType instanceof Type)\n this.typeDefault = null;\n else // instanceof Enum\n this.typeDefault = this.resolvedType.values[Object.keys(this.resolvedType.values)[0]]; // first defined\n } else if (this.options && this.options.proto3_optional) {\n // proto3 scalar value marked optional; should default to null\n this.typeDefault = null;\n }\n\n // use explicitly set default value if present\n if (this.options && this.options[\"default\"] != null) {\n this.typeDefault = this.options[\"default\"];\n if (this.resolvedType instanceof Enum && typeof this.typeDefault === \"string\")\n this.typeDefault = this.resolvedType.values[this.typeDefault];\n }\n\n // remove unnecessary options\n if (this.options) {\n if (this.options.packed !== undefined && this.resolvedType && !(this.resolvedType instanceof Enum))\n delete this.options.packed;\n if (!Object.keys(this.options).length)\n this.options = undefined;\n }\n\n // convert to internal data type if necesssary\n if (this.long) {\n this.typeDefault = util.Long.fromNumber(this.typeDefault, this.type === \"uint64\" || this.type === \"fixed64\");\n\n /* istanbul ignore else */\n if (Object.freeze)\n Object.freeze(this.typeDefault); // long instances are meant to be immutable anyway (i.e. use small int cache that even requires it)\n\n } else if (this.bytes && typeof this.typeDefault === \"string\") {\n var buf;\n if (util.base64.test(this.typeDefault))\n util.base64.decode(this.typeDefault, buf = util.newBuffer(util.base64.length(this.typeDefault)), 0);\n else\n util.utf8.write(this.typeDefault, buf = util.newBuffer(util.utf8.length(this.typeDefault)), 0);\n this.typeDefault = buf;\n }\n\n // take special care of maps and repeated fields\n if (this.map)\n this.defaultValue = util.emptyObject;\n else if (this.repeated)\n this.defaultValue = util.emptyArray;\n else\n this.defaultValue = this.typeDefault;\n\n // ensure proper value on prototype\n if (this.parent instanceof Type && this.parent._ctor)\n this.parent._ctor.prototype[this.name] = this.defaultValue;\n\n // derive the proto/JSON names\n if (this.protoName === undefined)\n this.protoName = this.name;\n if (this.jsonName === undefined)\n this.jsonName = util.jsonName(this.protoName);\n\n return ReflectionObject.prototype.resolve.call(this);\n};\n\n/**\n * Infers field features from legacy syntax that may have been specified differently.\n * in older editions.\n * @param {string|undefined} edition The edition this proto is on, or undefined if pre-editions\n * @returns {object} The feature values to override\n */\nField.prototype._inferLegacyProtoFeatures = function _inferLegacyProtoFeatures(edition) {\n if (edition !== \"proto2\" && edition !== \"proto3\") {\n return {};\n }\n\n var features = {};\n\n if (this.rule === \"required\") {\n features.field_presence = \"LEGACY_REQUIRED\";\n }\n if (this.parent && types.defaults[this.type] === undefined) {\n // We can't use resolvedType because types may not have been resolved yet. However,\n // legacy groups are always in the same scope as the field so we don't have to do a\n // full scan of the tree.\n var type = this.parent.get(this.type.split(\".\").pop());\n if (type && type instanceof Type && type.group) {\n features.message_encoding = \"DELIMITED\";\n }\n }\n if (this.getOption(\"packed\") === true) {\n features.repeated_field_encoding = \"PACKED\";\n } else if (this.getOption(\"packed\") === false) {\n features.repeated_field_encoding = \"EXPANDED\";\n }\n return features;\n};\n\n/**\n * @override\n */\nField.prototype._resolveFeatures = function _resolveFeatures(edition) {\n return ReflectionObject.prototype._resolveFeatures.call(this, this._edition || edition);\n};\n\n/**\n * Decorator function as returned by {@link Field.d} and {@link MapField.d} (TypeScript).\n * @typedef FieldDecorator\n * @type {function}\n * @param {Object} prototype Target prototype\n * @param {string} fieldName Field name\n * @returns {undefined}\n * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.\n */\n\n/**\n * Field decorator (TypeScript).\n * @name Field.d\n * @function\n * @param {number} fieldId Field id\n * @param {\"double\"|\"float\"|\"int32\"|\"uint32\"|\"sint32\"|\"fixed32\"|\"sfixed32\"|\"int64\"|\"uint64\"|\"sint64\"|\"fixed64\"|\"sfixed64\"|\"string\"|\"bool\"|\"bytes\"|Object} fieldType Field type\n * @param {\"optional\"|\"required\"|\"repeated\"} [fieldRule=\"optional\"] Field rule\n * @param {T} [defaultValue] Default value\n * @returns {FieldDecorator} Decorator function\n * @template T extends number | number[] | Long | Long[] | string | string[] | boolean | boolean[] | Uint8Array | Uint8Array[] | Buffer | Buffer[]\n * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.\n */\nField.d = function decorateField(fieldId, fieldType, fieldRule, defaultValue) {\n\n // submessage: decorate the submessage and use its name as the type\n if (typeof fieldType === \"function\")\n fieldType = util.decorateType(fieldType).name;\n\n // enum reference: create a reflected copy of the enum and keep reuseing it\n else if (fieldType && typeof fieldType === \"object\")\n fieldType = util.decorateEnum(fieldType).name;\n\n return function fieldDecorator(prototype, fieldName) {\n util.decorateType(prototype.constructor)\n .add(new Field(fieldName, fieldId, fieldType, fieldRule, { \"default\": defaultValue }));\n };\n};\n\n// Sets up cyclic dependencies (called in index-light)\nField._configure = function configure(Type_) {\n Type = Type_;\n};\n\n/**\n * Field decorator (TypeScript).\n * @name Field.d\n * @function\n * @param {number} fieldId Field id\n * @param {Constructor<T>|string} fieldType Field type\n * @param {\"optional\"|\"required\"|\"repeated\"} [fieldRule=\"optional\"] Field rule\n * @returns {FieldDecorator} Decorator function\n * @template T extends Message<T>\n * @variation 2\n * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.\n */\n// like Field.d but without a default value\n","\"use strict\";\nexports = module.exports = require(9);\n\nexports.build = \"light\";\n\n/**\n * A node-style callback as used by {@link load} and {@link Root#load}.\n * @typedef LoadCallback\n * @type {function}\n * @param {Error|null} error Error, if any, otherwise `null`\n * @param {Root} [root] Root, if there hasn't been an error\n * @returns {undefined}\n */\n\n/**\n * Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.\n * @param {string|string[]} filename One or multiple files to load\n * @param {Root} root Root namespace, defaults to create a new one if omitted.\n * @param {LoadCallback} callback Callback function\n * @returns {undefined}\n * @see {@link Root#load}\n */\nfunction load(filename, root, callback) {\n if (typeof root === \"function\") {\n callback = root;\n root = new exports.Root();\n } else if (!root)\n root = new exports.Root();\n return root.load(filename, callback);\n}\n\n/**\n * Loads one or multiple .proto or preprocessed .json files into a common root namespace and calls the callback.\n * @name load\n * @function\n * @param {string|string[]} filename One or multiple files to load\n * @param {LoadCallback} callback Callback function\n * @returns {undefined}\n * @see {@link Root#load}\n * @variation 2\n */\n// function load(filename:string, callback:LoadCallback):undefined\n\n/**\n * Loads one or multiple .proto or preprocessed .json files into a common root namespace and returns a promise.\n * @name load\n * @function\n * @param {string|string[]} filename One or multiple files to load\n * @param {Root} [root] Root namespace, defaults to create a new one if omitted.\n * @returns {Promise<Root>} Promise\n * @see {@link Root#load}\n * @variation 3\n */\n// function load(filename:string, [root:Root]):Promise<Root>\n\nexports.load = load;\n\n/**\n * Synchronously loads one or multiple .proto or preprocessed .json files into a common root namespace (node only).\n * @param {string|string[]} filename One or multiple files to load\n * @param {Root} [root] Root namespace, defaults to create a new one if omitted.\n * @returns {Root} Root namespace\n * @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invalid\n * @see {@link Root#loadSync}\n */\nfunction loadSync(filename, root) {\n if (!root)\n root = new exports.Root();\n return root.loadSync(filename);\n}\n\nexports.loadSync = loadSync;\n\n// Serialization\nexports.encoder = require(5);\nexports.decoder = require(4);\nexports.verifier = require(42);\nexports.converter = require(3);\n\n// Reflection\nexports.ReflectionObject = require(15);\nexports.Namespace = require(14);\nexports.Root = require(20);\nexports.Enum = require(6);\nexports.Type = require(26);\nexports.Field = require(7);\nexports.OneOf = require(16);\nexports.MapField = require(11);\nexports.Service = require(24);\nexports.Method = require(13);\n\n// Runtime\nexports.Message = require(12);\nexports.wrappers = require(43);\n\n// Utility\nexports.types = require(27);\nexports.util = require(28);\n\n// Set up possibly cyclic reflection dependencies\nexports.ReflectionObject._configure(exports.Root);\nexports.Namespace._configure(exports.Type, exports.Service, exports.Enum);\nexports.Root._configure(exports.Type, undefined, {});\nexports.Field._configure(exports.Type);\n","\"use strict\";\n\n/**\n * Build type, one of `\"full\"`, `\"light\"` or `\"minimal\"`.\n * @name build\n * @type {string}\n * @const\n */\nexports.build = \"minimal\";\n\n// Serialization\nexports.Writer = require(44);\nexports.BufferWriter = require(45);\nexports.Reader = require(18);\nexports.BufferReader = require(19);\n\n// Utility\nexports.util = require(37);\nexports.rpc = require(22);\nexports.roots = require(21);\nexports.configure = configure;\n\n/* istanbul ignore next */\n/**\n * Reconfigures the library according to the environment.\n * @returns {undefined}\n */\nfunction configure() {\n exports.util.LongBits._configure(exports.util.Long);\n exports.Writer._configure(exports.BufferWriter);\n exports.Reader._configure(exports.BufferReader);\n}\n\n// Set up buffer utility according to the environment\nconfigure();\n","\"use strict\";\nexports = module.exports = require(8);\n\nexports.build = \"full\";\n\n// Parser\nexports.tokenize = require(25);\nexports.parse = require(17);\nexports.common = require(2);\n\n// Configure parser\nexports.Root._configure(exports.Type, exports.parse, exports.common);\n","\"use strict\";\nmodule.exports = MapField;\n\n// extends Field\nvar Field = require(7);\nMapField.prototype = Object.create(Field.prototype, {\n constructor: {\n value: MapField,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\nMapField.className = \"MapField\";\n\nvar types = require(27),\n util = require(28);\n\n/**\n * Constructs a new map field instance.\n * @classdesc Reflected map field.\n * @extends FieldBase\n * @constructor\n * @param {string} name Unique name within its namespace\n * @param {number} id Unique id within its namespace\n * @param {string} keyType Key type\n * @param {string} type Value type\n * @param {Object.<string,*>} [options] Declared options\n * @param {string} [comment] Comment associated with this field\n */\nfunction MapField(name, id, keyType, type, options, comment) {\n Field.call(this, name, id, type, undefined, undefined, options, comment);\n\n /* istanbul ignore if */\n if (!util.isString(keyType))\n throw TypeError(\"keyType must be a string\");\n\n /**\n * Key type.\n * @type {string}\n */\n this.keyType = keyType; // toJSON, marker\n\n /**\n * Resolved key type if not a basic type.\n * @type {ReflectionObject|null}\n */\n this.resolvedKeyType = null;\n\n // Overrides Field#map\n this.map = true;\n}\n\n/**\n * Map field descriptor.\n * @interface IMapField\n * @extends {IField}\n * @property {string} keyType Key type\n */\n\n/**\n * Extension map field descriptor.\n * @interface IExtensionMapField\n * @extends IMapField\n * @property {string} extend Extended type\n */\n\n/**\n * Constructs a map field from a map field descriptor.\n * @param {string} name Field name\n * @param {IMapField} json Map field descriptor\n * @returns {MapField} Created map field\n * @throws {TypeError} If arguments are invalid\n */\nMapField.fromJSON = function fromJSON(name, json) {\n var field = new MapField(name, json.id, json.keyType, json.type, json.options, json.comment);\n if (json.protoName)\n field.protoName = json.protoName;\n if (json.jsonName !== undefined)\n field.jsonName = json.jsonName;\n else if (json.options && json.options.json_name !== undefined)\n field.jsonName = json.options.json_name;\n return field;\n};\n\n/**\n * Converts this map field to a map field descriptor.\n * @param {IToJSONOptions} [toJSONOptions] JSON conversion options\n * @returns {IMapField} Map field descriptor\n */\nMapField.prototype.toJSON = function toJSON(toJSONOptions) {\n var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;\n return util.toObject([\n \"keyType\" , this.keyType,\n \"type\" , this.type,\n \"id\" , this.id,\n \"extend\" , this.extend,\n \"protoName\" , this.protoName !== this.name ? this.protoName : undefined,\n \"jsonName\" , this.jsonName !== util.jsonName(this.protoName || this.name) ? this.jsonName : undefined,\n \"options\" , this.options,\n \"comment\" , keepComments ? this.comment : undefined\n ]);\n};\n\n/**\n * @override\n */\nMapField.prototype.resolve = function resolve() {\n if (this.resolved)\n return this;\n\n // Besides a value type, map fields have a key type that may be \"any scalar type except for floating point types and bytes\"\n if (types.mapKey[this.keyType] === undefined)\n throw Error(\"invalid key type: \" + this.keyType);\n\n return Field.prototype.resolve.call(this);\n};\n\n/**\n * Map field decorator (TypeScript).\n * @name MapField.d\n * @function\n * @param {number} fieldId Field id\n * @param {\"int32\"|\"uint32\"|\"sint32\"|\"fixed32\"|\"sfixed32\"|\"int64\"|\"uint64\"|\"sint64\"|\"fixed64\"|\"sfixed64\"|\"bool\"|\"string\"} fieldKeyType Field key type\n * @param {\"double\"|\"float\"|\"int32\"|\"uint32\"|\"sint32\"|\"fixed32\"|\"sfixed32\"|\"int64\"|\"uint64\"|\"sint64\"|\"fixed64\"|\"sfixed64\"|\"bool\"|\"string\"|\"bytes\"|Object|Constructor<{}>} fieldValueType Field value type\n * @returns {FieldDecorator} Decorator function\n * @template T extends { [key: string]: number | Long | string | boolean | Uint8Array | Buffer | number[] | Message<{}> }\n * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.\n */\nMapField.d = function decorateMapField(fieldId, fieldKeyType, fieldValueType) {\n\n // submessage value: decorate the submessage and use its name as the type\n if (typeof fieldValueType === \"function\")\n fieldValueType = util.decorateType(fieldValueType).name;\n\n // enum reference value: create a reflected copy of the enum and keep reuseing it\n else if (fieldValueType && typeof fieldValueType === \"object\")\n fieldValueType = util.decorateEnum(fieldValueType).name;\n\n return function mapFieldDecorator(prototype, fieldName) {\n util.decorateType(prototype.constructor)\n .add(new MapField(fieldName, fieldId, fieldKeyType, fieldValueType));\n };\n};\n","\"use strict\";\nmodule.exports = Message;\n\nvar util = require(37);\n\n/**\n * Constructs a new message instance.\n * @classdesc Abstract runtime message.\n * @constructor\n * @param {Properties<T>} [properties] Properties to set\n * @property {Array.<Uint8Array>} [$unknowns] Unknown fields preserved while decoding when enabled\n * @template T extends object = object\n */\nfunction Message(properties) {\n // not used internally\n if (properties)\n for (var keys = Object.keys(properties), i = 0; i < keys.length; ++i)\n if (properties[keys[i]] != null && keys[i] !== \"__proto__\")\n this[keys[i]] = properties[keys[i]];\n}\n\n/**\n * Reference to the reflected type.\n * @name Message.$type\n * @type {Type}\n * @readonly\n */\n\n/**\n * Reference to the reflected type.\n * @name Message#$type\n * @type {Type}\n * @readonly\n */\n\n/**\n * Creates a new message of this type using the specified properties.\n * @param {Object.<string,*>} [properties] Properties to set\n * @returns {T} Message instance\n * @template T extends Message<T>\n * @this Constructor<T>\n */\nMessage.create = function create(properties) {\n return this.$type.create(properties);\n};\n\n/**\n * Encodes a message of this type.\n * @param {T|Object.<string,*>} message Message to encode\n * @param {Writer} [writer] Writer to use\n * @returns {Writer} Writer\n * @template T extends Message<T>\n * @this Constructor<T>\n */\nMessage.encode = function encode(message, writer) {\n return this.$type.encode(message, writer);\n};\n\n/**\n * Encodes a message of this type preceeded by its length as a varint.\n * @param {T|Object.<string,*>} message Message to encode\n * @param {Writer} [writer] Writer to use\n * @returns {Writer} Writer\n * @template T extends Message<T>\n * @this Constructor<T>\n */\nMessage.encodeDelimited = function encodeDelimited(message, writer) {\n return this.$type.encodeDelimited(message, writer);\n};\n\n/**\n * Decodes a message of this type.\n * @name Message.decode\n * @function\n * @param {Reader|Uint8Array} reader Reader or buffer to decode\n * @returns {T} Decoded message\n * @template T extends Message<T>\n * @this Constructor<T>\n */\nMessage.decode = function decode(reader) {\n return this.$type.decode(reader);\n};\n\n/**\n * Decodes a message of this type preceeded by its length as a varint.\n * @name Message.decodeDelimited\n * @function\n * @param {Reader|Uint8Array} reader Reader or buffer to decode\n * @returns {T} Decoded message\n * @template T extends Message<T>\n * @this Constructor<T>\n */\nMessage.decodeDelimited = function decodeDelimited(reader) {\n return this.$type.decodeDelimited(reader);\n};\n\n/**\n * Verifies a message of this type.\n * @name Message.verify\n * @function\n * @param {Object.<string,*>} message Plain object to verify\n * @returns {string|null} `null` if valid, otherwise the reason why it is not\n */\nMessage.verify = function verify(message) {\n return this.$type.verify(message);\n};\n\n/**\n * Creates a new message of this type from a plain object. Also converts values to their respective internal types.\n * @param {Object.<string,*>} object Plain object\n * @returns {T} Message instance\n * @template T extends Message<T>\n * @this Constructor<T>\n */\nMessage.fromObject = function fromObject(object) {\n return this.$type.fromObject(object);\n};\n\n/**\n * Creates a plain object from a message of this type. Also converts values to other types if specified.\n * @param {T} message Message instance\n * @param {IConversionOptions} [options] Conversion options\n * @returns {Object.<string,*>} Plain object\n * @template T extends Message<T>\n * @this Constructor<T>\n */\nMessage.toObject = function toObject(message, options) {\n return this.$type.toObject(message, options);\n};\n\n/**\n * Converts this message to JSON.\n * @returns {Object.<string,*>} JSON object\n */\nMessage.prototype.toJSON = function toJSON() {\n return this.$type.toObject(this, util.toJSONOptions);\n};\n","\"use strict\";\nmodule.exports = Method;\n\n// extends ReflectionObject\nvar ReflectionObject = require(15);\nMethod.prototype = Object.create(ReflectionObject.prototype, {\n constructor: {\n value: Method,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\nMethod.className = \"Method\";\n\nvar util = require(28);\n\n/**\n * Constructs a new service method instance.\n * @classdesc Reflected service method.\n * @extends ReflectionObject\n * @constructor\n * @param {string} name Method name\n * @param {string|undefined} type Method type, usually `\"rpc\"`\n * @param {string} requestType Request message type\n * @param {string} responseType Response message type\n * @param {boolean|Object.<string,*>} [requestStream] Whether the request is streamed\n * @param {boolean|Object.<string,*>} [responseStream] Whether the response is streamed\n * @param {Object.<string,*>} [options] Declared options\n * @param {string} [comment] The comment for this method\n * @param {Array.<Object.<string,*>>} [parsedOptions] Declared options, properly parsed into objects\n */\nfunction Method(name, type, requestType, responseType, requestStream, responseStream, options, comment, parsedOptions) {\n\n /* istanbul ignore next */\n if (util.isObject(requestStream)) {\n options = requestStream;\n requestStream = responseStream = undefined;\n } else if (util.isObject(responseStream)) {\n options = responseStream;\n responseStream = undefined;\n }\n\n /* istanbul ignore if */\n if (!(type === undefined || util.isString(type)))\n throw TypeError(\"type must be a string\");\n\n /* istanbul ignore if */\n if (!util.isString(requestType))\n throw TypeError(\"requestType must be a string\");\n\n /* istanbul ignore if */\n if (!util.isString(responseType))\n throw TypeError(\"responseType must be a string\");\n\n ReflectionObject.call(this, name, options);\n\n /**\n * Method type.\n * @type {string}\n */\n this.type = type || \"rpc\"; // toJSON\n\n /**\n * Request type.\n * @type {string}\n */\n this.requestType = requestType; // toJSON, marker\n\n /**\n * Whether requests are streamed or not.\n * @type {true|undefined}\n */\n this.requestStream = requestStream ? true : undefined; // toJSON\n\n /**\n * Response type.\n * @type {string}\n */\n this.responseType = responseType; // toJSON\n\n /**\n * Whether responses are streamed or not.\n * @type {true|undefined}\n */\n this.responseStream = responseStream ? true : undefined; // toJSON\n\n /**\n * gRPC-style method path.\n * @type {string}\n */\n this.path = \"/\" + this.name;\n\n /**\n * Resolved request type.\n * @type {Type|null}\n */\n this.resolvedRequestType = null;\n\n /**\n * Resolved response type.\n * @type {Type|null}\n */\n this.resolvedResponseType = null;\n\n /**\n * Comment for this method\n * @type {string|null}\n */\n this.comment = comment;\n\n /**\n * Options properly parsed into objects\n * @type {Array.<Object.<string,*>>|undefined}\n */\n this.parsedOptions = parsedOptions;\n}\n\n/**\n * Method descriptor.\n * @interface IMethod\n * @property {string} [type=\"rpc\"] Method type\n * @property {string} requestType Request type\n * @property {string} responseType Response type\n * @property {boolean} [requestStream=false] Whether requests are streamed\n * @property {boolean} [responseStream=false] Whether responses are streamed\n * @property {Object.<string,*>} [options] Method options\n * @property {string|null} [comment] Method comment\n * @property {Array.<Object.<string,*>>} [parsedOptions] Method options properly parsed into objects\n */\n\n/**\n * Constructs a method from a method descriptor.\n * @param {string} name Method name\n * @param {IMethod} json Method descriptor\n * @returns {Method} Created method\n * @throws {TypeError} If arguments are invalid\n */\nMethod.fromJSON = function fromJSON(name, json) {\n return new Method(name, json.type, json.requestType, json.responseType, json.requestStream, json.responseStream, json.options, json.comment, json.parsedOptions);\n};\n\n/**\n * Converts this method to a method descriptor.\n * @param {IToJSONOptions} [toJSONOptions] JSON conversion options\n * @returns {IMethod} Method descriptor\n */\nMethod.prototype.toJSON = function toJSON(toJSONOptions) {\n var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;\n return util.toObject([\n \"type\" , this.type !== \"rpc\" && /* istanbul ignore next */ this.type || undefined,\n \"requestType\" , this.requestType,\n \"requestStream\" , this.requestStream,\n \"responseType\" , this.responseType,\n \"responseStream\" , this.responseStream,\n \"options\" , this.options,\n \"comment\" , keepComments ? this.comment : undefined,\n \"parsedOptions\" , this.parsedOptions,\n ]);\n};\n\n/**\n * @override\n */\nMethod.prototype.resolve = function resolve() {\n\n /* istanbul ignore if */\n if (this.resolved)\n return this;\n\n if (this.parent) {\n var serviceName = this.parent.fullName;\n if (serviceName.charAt(0) === \".\")\n serviceName = serviceName.substring(1);\n this.path = \"/\" + serviceName + \"/\" + this.name;\n } else\n this.path = \"/\" + this.name;\n\n this.resolvedRequestType = this.parent.lookupType(this.requestType);\n this.resolvedResponseType = this.parent.lookupType(this.responseType);\n\n return ReflectionObject.prototype.resolve.call(this);\n};\n","\"use strict\";\nmodule.exports = Namespace;\n\n// extends ReflectionObject\nvar ReflectionObject = require(15);\nNamespace.prototype = Object.create(ReflectionObject.prototype, {\n constructor: {\n value: Namespace,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\nNamespace.className = \"Namespace\";\n\nvar Field = require(7),\n util = require(28),\n OneOf = require(16);\n\nvar Type, // cyclic\n Service,\n Enum;\n\n/**\n * Constructs a new namespace instance.\n * @name Namespace\n * @classdesc Reflected namespace.\n * @extends NamespaceBase\n * @constructor\n * @param {string} name Namespace name\n * @param {Object.<string,*>} [options] Declared options\n */\n\n/**\n * Constructs a namespace from JSON.\n * @memberof Namespace\n * @function\n * @param {string} name Namespace name\n * @param {Object.<string,*>} json JSON object\n * @param {number} [depth] Current nesting depth, defaults to `0`\n * @returns {Namespace} Created namespace\n * @throws {TypeError} If arguments are invalid\n */\nNamespace.fromJSON = function fromJSON(name, json, depth) {\n if (depth === undefined)\n depth = 0;\n if (depth > util.recursionLimit)\n throw Error(\"max depth exceeded\");\n return new Namespace(name, json.options).addJSON(json.nested, depth);\n};\n\n/**\n * Converts an array of reflection objects to JSON.\n * @memberof Namespace\n * @param {ReflectionObject[]} array Object array\n * @param {IToJSONOptions} [toJSONOptions] JSON conversion options\n * @returns {Object.<string,*>|undefined} JSON object or `undefined` when array is empty\n */\nfunction arrayToJSON(array, toJSONOptions) {\n if (!(array && array.length))\n return undefined;\n var obj = {};\n for (var i = 0; i < array.length; ++i)\n obj[array[i].name] = array[i].toJSON(toJSONOptions);\n return obj;\n}\n\nNamespace.arrayToJSON = arrayToJSON;\n\n/**\n * Tests if the specified id is reserved.\n * @param {Array.<number[]|string>|undefined} reserved Array of reserved ranges and names\n * @param {number} id Id to test\n * @returns {boolean} `true` if reserved, otherwise `false`\n */\nNamespace.isReservedId = function isReservedId(reserved, id) {\n if (reserved)\n for (var i = 0; i < reserved.length; ++i)\n if (typeof reserved[i] !== \"string\" && reserved[i][0] <= id && reserved[i][1] >= id)\n return true;\n return false;\n};\n\n/**\n * Tests if the specified name is reserved.\n * @param {Array.<number[]|string>|undefined} reserved Array of reserved ranges and names\n * @param {string} name Name to test\n * @returns {boolean} `true` if reserved, otherwise `false`\n */\nNamespace.isReservedName = function isReservedName(reserved, name) {\n if (reserved)\n for (var i = 0; i < reserved.length; ++i)\n if (reserved[i] === name)\n return true;\n return false;\n};\n\n/**\n * Not an actual constructor. Use {@link Namespace} instead.\n * @classdesc Base class of all reflection objects containing nested objects. This is not an actual class but here for the sake of having consistent type definitions.\n * @exports NamespaceBase\n * @extends ReflectionObject\n * @abstract\n * @constructor\n * @param {string} name Namespace name\n * @param {Object.<string,*>} [options] Declared options\n * @see {@link Namespace}\n */\nfunction Namespace(name, options) {\n ReflectionObject.call(this, name, options);\n\n /**\n * Nested objects by name.\n * @type {Object.<string,ReflectionObject>|undefined}\n */\n this.nested = undefined; // toJSON\n\n /**\n * Cached nested objects as an array.\n * @type {ReflectionObject[]|null}\n * @private\n */\n this._nestedArray = null;\n\n /**\n * Cache lookup calls for any objects contains anywhere under this namespace.\n * This drastically speeds up resolve for large cross-linked protos where the same\n * types are looked up repeatedly.\n * @type {Object.<string,ReflectionObject|null>}\n * @private\n */\n this._lookupCache = Object.create(null);\n\n /**\n * Whether or not objects contained in this namespace need feature resolution.\n * @type {boolean}\n * @protected\n */\n this._needsRecursiveFeatureResolution = true;\n\n /**\n * Whether or not objects contained in this namespace need a resolve.\n * @type {boolean}\n * @protected\n */\n this._needsRecursiveResolve = true;\n}\n\nfunction clearCache(namespace) {\n namespace._nestedArray = null;\n namespace._lookupCache = Object.create(null);\n\n // Also clear parent caches, since they include nested lookups.\n var parent = namespace;\n while(parent = parent.parent) {\n parent._lookupCache = Object.create(null);\n }\n return namespace;\n}\n\n/**\n * Nested objects of this namespace as an array for iteration.\n * @name NamespaceBase#nestedArray\n * @type {ReflectionObject[]}\n * @readonly\n */\nObject.defineProperty(Namespace.prototype, \"nestedArray\", {\n get: function() {\n return this._nestedArray || (this._nestedArray = util.toArray(this.nested));\n }\n});\n\n/**\n * Namespace descriptor.\n * @interface INamespace\n * @property {Object.<string,*>} [options] Namespace options\n * @property {Object.<string,AnyNestedObject>} [nested] Nested object descriptors\n */\n\n/**\n * Any extension field descriptor.\n * @typedef AnyExtensionField\n * @type {IExtensionField|IExtensionMapField}\n */\n\n/**\n * Any nested object descriptor.\n * @typedef AnyNestedObject\n * @type {IEnum|IType|IService|AnyExtensionField|INamespace|IOneOf}\n */\n\n/**\n * Converts this namespace to a namespace descriptor.\n * @param {IToJSONOptions} [toJSONOptions] JSON conversion options\n * @returns {INamespace} Namespace descriptor\n */\nNamespace.prototype.toJSON = function toJSON(toJSONOptions) {\n return util.toObject([\n \"options\" , this.options,\n \"nested\" , arrayToJSON(this.nestedArray, toJSONOptions)\n ]);\n};\n\n/**\n * Adds nested objects to this namespace from nested object descriptors.\n * @param {Object.<string,AnyNestedObject>} nestedJson Any nested object descriptors\n * @param {number} [depth] Current nesting depth, defaults to `0`\n * @returns {Namespace} `this`\n */\nNamespace.prototype.addJSON = function addJSON(nestedJson, depth) {\n if (depth === undefined)\n depth = 0;\n if (depth > util.recursionLimit)\n throw Error(\"max depth exceeded\");\n var ns = this;\n /* istanbul ignore else */\n if (nestedJson) {\n for (var names = Object.keys(nestedJson), i = 0, nested; i < names.length; ++i) {\n nested = nestedJson[names[i]];\n ns.add( // most to least likely\n ( nested.fields !== undefined\n ? Type.fromJSON\n : nested.values !== undefined\n ? Enum.fromJSON\n : nested.methods !== undefined\n ? Service.fromJSON\n : nested.id !== undefined\n ? Field.fromJSON\n : Namespace.fromJSON )(names[i], nested, depth + 1)\n );\n }\n }\n return this;\n};\n\n/**\n * Gets the nested object of the specified name.\n * @param {string} name Nested object name\n * @returns {ReflectionObject|null} The reflection object or `null` if it doesn't exist\n */\nNamespace.prototype.get = function get(name) {\n return this.nested && Object.prototype.hasOwnProperty.call(this.nested, name)\n ? this.nested[name]\n : null;\n};\n\n/**\n * Gets the values of the nested {@link Enum|enum} of the specified name.\n * This methods differs from {@link Namespace#get|get} in that it returns an enum's values directly and throws instead of returning `null`.\n * @param {string} name Nested enum name\n * @returns {Object.<string,number>} Enum values\n * @throws {Error} If there is no such enum\n */\nNamespace.prototype.getEnum = function getEnum(name) {\n if (this.nested && Object.prototype.hasOwnProperty.call(this.nested, name) && this.nested[name] instanceof Enum)\n return this.nested[name].values;\n throw Error(\"no such enum: \" + name);\n};\n\n/**\n * Adds a nested object to this namespace.\n * @param {ReflectionObject} object Nested object to add\n * @returns {Namespace} `this`\n * @throws {TypeError} If arguments are invalid\n * @throws {Error} If there is already a nested object with this name\n */\nNamespace.prototype.add = function add(object) {\n\n if (!(object instanceof Field && object.extend !== undefined || object instanceof Type || object instanceof OneOf || object instanceof Enum || object instanceof Service || object instanceof Namespace))\n throw TypeError(\"object must be a valid nested object\");\n\n if (object.name === \"__proto__\")\n return this;\n\n if (!this.nested)\n this.nested = {};\n else {\n var prev = this.get(object.name);\n if (prev) {\n if (prev instanceof Namespace && object instanceof Namespace && !(prev instanceof Type || prev instanceof Service)) {\n // replace plain namespace but keep existing nested elements and options\n var nested = prev.nestedArray;\n for (var i = 0; i < nested.length; ++i)\n object.add(nested[i]);\n this.remove(prev);\n if (!this.nested)\n this.nested = {};\n object.setOptions(prev.options, true);\n\n } else\n throw Error(\"duplicate name '\" + object.name + \"' in \" + this);\n }\n }\n this.nested[object.name] = object;\n\n if (!(this instanceof Type || this instanceof Service || this instanceof Enum || this instanceof Field)) {\n // This is a package or a root namespace.\n if (!object._edition) {\n // Make sure that some edition is set if it hasn't already been specified.\n object._edition = object._defaultEdition;\n }\n }\n\n this._needsRecursiveFeatureResolution = true;\n this._needsRecursiveResolve = true;\n\n // Also clear parent caches, since they need to recurse down.\n var parent = this;\n while(parent = parent.parent) {\n parent._needsRecursiveFeatureResolution = true;\n parent._needsRecursiveResolve = true;\n }\n\n object.onAdd(this);\n return clearCache(this);\n};\n\n/**\n * Removes a nested object from this namespace.\n * @param {ReflectionObject} object Nested object to remove\n * @returns {Namespace} `this`\n * @throws {TypeError} If arguments are invalid\n * @throws {Error} If `object` is not a member of this namespace\n */\nNamespace.prototype.remove = function remove(object) {\n\n if (!(object instanceof ReflectionObject))\n throw TypeError(\"object must be a ReflectionObject\");\n if (object.parent !== this)\n throw Error(object + \" is not a member of \" + this);\n\n if (!util.remove(this.nested, object, object.name))\n throw Error(object + \" is not a member of \" + this);\n if (!Object.keys(this.nested).length)\n this.nested = undefined;\n\n object.onRemove(this);\n return clearCache(this);\n};\n\n/**\n * Defines additial namespaces within this one if not yet existing.\n * @param {string|string[]} path Path to create\n * @param {*} [json] Nested types to create from JSON\n * @returns {Namespace} Pointer to the last namespace created or `this` if path is empty\n */\nNamespace.prototype.define = function define(path, json) {\n\n if (util.isString(path))\n path = path.split(\".\");\n else if (!Array.isArray(path))\n throw TypeError(\"illegal path\");\n if (path && path.length && path[0] === \"\")\n throw Error(\"path must be relative\");\n if (path.length > util.recursionLimit)\n throw Error(\"max depth exceeded\");\n\n var ptr = this;\n while (path.length > 0) {\n var part = path.shift();\n if (ptr.nested && ptr.nested[part]) {\n ptr = ptr.nested[part];\n if (!(ptr instanceof Namespace))\n throw Error(\"path conflicts with non-namespace objects\");\n } else\n ptr.add(ptr = new Namespace(part));\n }\n if (json)\n ptr.addJSON(json);\n return ptr;\n};\n\n/**\n * Resolves this namespace's and all its nested objects' type references. Useful to validate a reflection tree, but comes at a cost.\n * @returns {Namespace} `this`\n */\nNamespace.prototype.resolveAll = function resolveAll() {\n if (!this._needsRecursiveResolve) return this;\n\n if (this._needsRecursiveFeatureResolution)\n this._resolveFeaturesRecursive(this._edition);\n\n var nested = this.nestedArray, i = 0;\n this.resolve();\n while (i < nested.length)\n if (nested[i] instanceof Namespace)\n nested[i++].resolveAll();\n else\n nested[i++].resolve();\n this._needsRecursiveResolve = false;\n return this;\n};\n\n/**\n * @override\n */\nNamespace.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursive(edition) {\n if (!this._needsRecursiveFeatureResolution) return this;\n this._needsRecursiveFeatureResolution = false;\n\n edition = this._edition || edition;\n\n ReflectionObject.prototype._resolveFeaturesRecursive.call(this, edition);\n this.nestedArray.forEach(nested => {\n nested._resolveFeaturesRecursive(edition);\n });\n return this;\n};\n\n/**\n * Recursively looks up the reflection object matching the specified path in the scope of this namespace.\n * @param {string|string[]} path Path to look up\n * @param {*|Array.<*>} filterTypes Filter types, any combination of the constructors of `protobuf.Type`, `protobuf.Enum`, `protobuf.Service` etc.\n * @param {boolean} [parentAlreadyChecked=false] If known, whether the parent has already been checked\n * @returns {ReflectionObject|null} Looked up object or `null` if none could be found\n */\nNamespace.prototype.lookup = function lookup(path, filterTypes, parentAlreadyChecked) {\n /* istanbul ignore next */\n if (typeof filterTypes === \"boolean\") {\n parentAlreadyChecked = filterTypes;\n filterTypes = undefined;\n } else if (filterTypes && !Array.isArray(filterTypes))\n filterTypes = [ filterTypes ];\n\n if (util.isString(path) && path.length) {\n if (path === \".\")\n return this.root;\n path = path.split(\".\");\n } else if (!path.length)\n return this;\n\n var flatPath = path.join(\".\");\n\n // Start at root if path is absolute\n if (path[0] === \"\")\n return this.root.lookup(path.slice(1), filterTypes);\n\n // Lookup at this namespace and below\n var found = this._lookupImpl(path, flatPath);\n if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {\n return found;\n }\n\n // Fall back to respective absolute path once relative scope has been checked (non-standard)\n found = this.root._fullyQualifiedObjects && this.root._fullyQualifiedObjects[\".\" + flatPath];\n if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {\n return found;\n }\n\n if (parentAlreadyChecked)\n return null;\n\n // If there hasn't been a match, walk up the tree and look more broadly\n var current = this;\n while (current.parent) {\n found = current.parent._lookupImpl(path, flatPath);\n if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {\n return found;\n }\n current = current.parent;\n }\n return null;\n};\n\n/**\n * Internal helper for lookup that handles searching just at this namespace and below along with caching.\n * @param {string[]} path Path to look up\n * @param {string} flatPath Flattened version of the path to use as a cache key\n * @returns {ReflectionObject|null} Looked up object or `null` if none could be found\n * @private\n */\nNamespace.prototype._lookupImpl = function lookup(path, flatPath) {\n if(Object.prototype.hasOwnProperty.call(this._lookupCache, flatPath)) {\n return this._lookupCache[flatPath];\n }\n\n // Test if the first part matches any nested object, and if so, traverse if path contains more\n var found = this.get(path[0]);\n var exact = null;\n if (found) {\n if (path.length === 1) {\n exact = found;\n } else if (found instanceof Namespace) {\n path = path.slice(1);\n exact = found._lookupImpl(path, path.join(\".\"));\n }\n\n // Otherwise try each nested namespace\n } else {\n for (var i = 0; i < this.nestedArray.length; ++i)\n if (this._nestedArray[i] instanceof Namespace && (found = this._nestedArray[i]._lookupImpl(path, flatPath))) {\n exact = found;\n break;\n }\n }\n\n // Set this even when null, so that when we walk up the tree we can quickly bail on repeated checks back down.\n this._lookupCache[flatPath] = exact;\n return exact;\n};\n\n/**\n * Looks up the reflection object at the specified path, relative to this namespace.\n * @name NamespaceBase#lookup\n * @function\n * @param {string|string[]} path Path to look up\n * @param {boolean} [parentAlreadyChecked=false] Whether the parent has already been checked\n * @returns {ReflectionObject|null} Looked up object or `null` if none could be found\n * @variation 2\n */\n// lookup(path: string, [parentAlreadyChecked: boolean])\n\n/**\n * Looks up the {@link Type|type} at the specified path, relative to this namespace.\n * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.\n * @param {string|string[]} path Path to look up\n * @returns {Type} Looked up type\n * @throws {Error} If `path` does not point to a type\n */\nNamespace.prototype.lookupType = function lookupType(path) {\n var found = this.lookup(path, [ Type ]);\n if (!found)\n throw Error(\"no such type: \" + path);\n return found;\n};\n\n/**\n * Looks up the values of the {@link Enum|enum} at the specified path, relative to this namespace.\n * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.\n * @param {string|string[]} path Path to look up\n * @returns {Enum} Looked up enum\n * @throws {Error} If `path` does not point to an enum\n */\nNamespace.prototype.lookupEnum = function lookupEnum(path) {\n var found = this.lookup(path, [ Enum ]);\n if (!found)\n throw Error(\"no such Enum '\" + path + \"' in \" + this);\n return found;\n};\n\n/**\n * Looks up the {@link Type|type} or {@link Enum|enum} at the specified path, relative to this namespace.\n * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.\n * @param {string|string[]} path Path to look up\n * @returns {Type} Looked up type or enum\n * @throws {Error} If `path` does not point to a type or enum\n */\nNamespace.prototype.lookupTypeOrEnum = function lookupTypeOrEnum(path) {\n var found = this.lookup(path, [ Type, Enum ]);\n if (!found)\n throw Error(\"no such Type or Enum '\" + path + \"' in \" + this);\n return found;\n};\n\n/**\n * Looks up the {@link Service|service} at the specified path, relative to this namespace.\n * Besides its signature, this methods differs from {@link Namespace#lookup|lookup} in that it throws instead of returning `null`.\n * @param {string|string[]} path Path to look up\n * @returns {Service} Looked up service\n * @throws {Error} If `path` does not point to a service\n */\nNamespace.prototype.lookupService = function lookupService(path) {\n var found = this.lookup(path, [ Service ]);\n if (!found)\n throw Error(\"no such Service '\" + path + \"' in \" + this);\n return found;\n};\n\n// Sets up cyclic dependencies (called in index-light)\nNamespace._configure = function(Type_, Service_, Enum_) {\n Type = Type_;\n Service = Service_;\n Enum = Enum_;\n};\n","\"use strict\";\nmodule.exports = ReflectionObject;\n\nReflectionObject.className = \"ReflectionObject\";\n\nconst OneOf = require(16);\nvar util = require(28);\n\nvar Root; // cyclic\n\n/* eslint-disable no-warning-comments */\n// TODO: Replace with embedded proto.\nvar editions2024Defaults = {enum_type: \"OPEN\", field_presence: \"EXPLICIT\", json_format: \"ALLOW\", message_encoding: \"LENGTH_PREFIXED\", repeated_field_encoding: \"PACKED\", utf8_validation: \"VERIFY\", enforce_naming_style: \"STYLE2024\", default_symbol_visibility: \"EXPORT_TOP_LEVEL\" };\nvar editions2023Defaults = {enum_type: \"OPEN\", field_presence: \"EXPLICIT\", json_format: \"ALLOW\", message_encoding: \"LENGTH_PREFIXED\", repeated_field_encoding: \"PACKED\", utf8_validation: \"VERIFY\", enforce_naming_style: \"STYLE_LEGACY\", default_symbol_visibility: \"EXPORT_ALL\" };\nvar proto2Defaults = {enum_type: \"CLOSED\", field_presence: \"EXPLICIT\", json_format: \"LEGACY_BEST_EFFORT\", message_encoding: \"LENGTH_PREFIXED\", repeated_field_encoding: \"EXPANDED\", utf8_validation: \"NONE\", enforce_naming_style: \"STYLE_LEGACY\", default_symbol_visibility: \"EXPORT_ALL\" };\nvar proto3Defaults = {enum_type: \"OPEN\", field_presence: \"IMPLICIT\", json_format: \"ALLOW\", message_encoding: \"LENGTH_PREFIXED\", repeated_field_encoding: \"PACKED\", utf8_validation: \"VERIFY\", enforce_naming_style: \"STYLE_LEGACY\", default_symbol_visibility: \"EXPORT_ALL\" };\n\n/**\n * Constructs a new reflection object instance.\n * @classdesc Base class of all reflection objects.\n * @constructor\n * @param {string} name Object name\n * @param {Object.<string,*>} [options] Declared options\n * @abstract\n */\nfunction ReflectionObject(name, options) {\n\n if (!util.isString(name))\n throw TypeError(\"name must be a string\");\n\n if (options && !util.isObject(options))\n throw TypeError(\"options must be an object\");\n\n /**\n * Options.\n * @type {Object.<string,*>|undefined}\n */\n this.options = options; // toJSON\n\n /**\n * Parsed Options.\n * @type {Array.<Object.<string,*>>|undefined}\n */\n this.parsedOptions = null;\n\n /**\n * Unique name within its namespace.\n * @type {string}\n */\n this.name = name;\n\n /**\n * The edition specified for this object. Only relevant for top-level objects.\n * @type {string}\n * @private\n */\n this._edition = null;\n\n /**\n * The default edition to use for this object if none is specified. For legacy reasons,\n * this is proto2 except in the JSON parsing case where it was proto3.\n * @type {string}\n * @private\n */\n this._defaultEdition = \"proto2\";\n\n /**\n * Resolved Features.\n * @type {object}\n * @private\n */\n this._features = {};\n\n /**\n * Whether or not features have been resolved.\n * @type {boolean}\n * @private\n */\n this._featuresResolved = false;\n\n /**\n * Parent namespace.\n * @type {Namespace|null}\n */\n this.parent = null;\n\n /**\n * Whether already resolved or not.\n * @type {boolean}\n */\n this.resolved = false;\n\n /**\n * Comment text, if any.\n * @type {string|null}\n */\n this.comment = null;\n\n /**\n * Defining file name.\n * @type {string|null}\n */\n this.filename = null;\n}\n\nObject.defineProperties(ReflectionObject.prototype, {\n\n /**\n * Reference to the root namespace.\n * @name ReflectionObject#root\n * @type {Root}\n * @readonly\n */\n root: {\n get: function() {\n var ptr = this;\n while (ptr.parent !== null)\n ptr = ptr.parent;\n return ptr;\n }\n },\n\n /**\n * Full name including leading dot.\n * @name ReflectionObject#fullName\n * @type {string}\n * @readonly\n */\n fullName: {\n get: function() {\n var path = [ this.name ],\n ptr = this.parent;\n while (ptr) {\n path.unshift(ptr.name);\n ptr = ptr.parent;\n }\n return path.join(\".\");\n }\n }\n});\n\n/**\n * Converts this reflection object to its descriptor representation.\n * @returns {Object.<string,*>} Descriptor\n */\nReflectionObject.prototype.toJSON = /* istanbul ignore next */ function toJSON() {\n throw Error(); // not implemented, shouldn't happen\n};\n\n/**\n * Called when this object is added to a parent.\n * @param {ReflectionObject} parent Parent added to\n * @returns {undefined}\n */\nReflectionObject.prototype.onAdd = function onAdd(parent) {\n if (this.parent && this.parent !== parent)\n this.parent.remove(this);\n this.parent = parent;\n this.resolved = false;\n var root = parent.root;\n if (root instanceof Root)\n root._handleAdd(this);\n};\n\n/**\n * Called when this object is removed from a parent.\n * @param {ReflectionObject} parent Parent removed from\n * @returns {undefined}\n */\nReflectionObject.prototype.onRemove = function onRemove(parent) {\n var root = parent.root;\n if (root instanceof Root)\n root._handleRemove(this);\n this.parent = null;\n this.resolved = false;\n};\n\n/**\n * Resolves this objects type references.\n * @returns {ReflectionObject} `this`\n */\nReflectionObject.prototype.resolve = function resolve() {\n if (this.resolved)\n return this;\n if (this.root instanceof Root)\n this.resolved = true; // only if part of a root\n return this;\n};\n\n/**\n * Resolves this objects editions features.\n * @param {string} edition The edition we're currently resolving for.\n * @returns {ReflectionObject} `this`\n */\nReflectionObject.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursive(edition) {\n return this._resolveFeatures(this._edition || edition);\n};\n\n/**\n * Resolves child features from parent features\n * @param {string} edition The edition we're currently resolving for.\n * @returns {undefined}\n */\nReflectionObject.prototype._resolveFeatures = function _resolveFeatures(edition) {\n if (this._featuresResolved) {\n return;\n }\n\n var defaults = {};\n\n /* istanbul ignore if */\n if (!edition) {\n throw new Error(\"Unknown edition for \" + this.fullName);\n }\n\n var protoFeatures = util.merge({}, this.options && this.options.features,\n this._inferLegacyProtoFeatures(edition));\n\n if (this._edition) {\n // For a namespace marked with a specific edition, reset defaults.\n /* istanbul ignore else */\n if (edition === \"proto2\") {\n defaults = Object.assign({}, proto2Defaults);\n } else if (edition === \"proto3\") {\n defaults = Object.assign({}, proto3Defaults);\n } else if (edition === \"2023\") {\n defaults = Object.assign({}, editions2023Defaults);\n } else if (edition === \"2024\") {\n defaults = Object.assign({}, editions2024Defaults);\n } else {\n throw new Error(\"Unknown edition: \" + edition);\n }\n this._features = util.merge(defaults, protoFeatures);\n } else {\n // fields in Oneofs aren't actually children of them, so we have to\n // special-case it\n /* istanbul ignore else */\n if (this.partOf instanceof OneOf) {\n var lexicalParentFeaturesCopy = util.merge({}, this.partOf._features);\n this._features = util.merge(lexicalParentFeaturesCopy, protoFeatures);\n } else if (this.declaringField) {\n // Skip feature resolution of sister fields.\n } else if (this.parent) {\n var parentFeaturesCopy = util.merge({}, this.parent._features);\n this._features = util.merge(parentFeaturesCopy, protoFeatures);\n } else {\n throw new Error(\"Unable to find a parent for \" + this.fullName);\n }\n }\n if (this.extensionField) {\n // Sister fields should have the same features as their extensions.\n this.extensionField._features = this._features;\n }\n this._featuresResolved = true;\n};\n\n/**\n * Infers features from legacy syntax that may have been specified differently.\n * in older editions.\n * @param {string|undefined} edition The edition this proto is on, or undefined if pre-editions\n * @returns {object} The feature values to override\n */\nReflectionObject.prototype._inferLegacyProtoFeatures = function _inferLegacyProtoFeatures(/*edition*/) {\n return {};\n};\n\n/**\n * Gets an option value.\n * @param {string} name Option name\n * @returns {*} Option value or `undefined` if not set\n */\nReflectionObject.prototype.getOption = function getOption(name) {\n if (this.options && Object.prototype.hasOwnProperty.call(this.options, name))\n return this.options[name];\n return undefined;\n};\n\n/**\n * Sets an option.\n * @param {string} name Option name\n * @param {*} value Option value\n * @param {boolean|undefined} [ifNotSet] Sets the option only if it isn't currently set\n * @returns {ReflectionObject} `this`\n */\nReflectionObject.prototype.setOption = function setOption(name, value, ifNotSet) {\n if (name === \"__proto__\")\n return this;\n if (!this.options)\n this.options = {};\n if (/^features\\./.test(name)) {\n util.setProperty(this.options, name, value, ifNotSet);\n } else {\n var prev = this.getOption(name);\n if (!ifNotSet || prev === undefined) {\n if (prev !== value) this.resolved = false;\n this.options[name] = value;\n }\n }\n\n return this;\n};\n\n/**\n * Sets a parsed option.\n * @param {string} name parsed Option name\n * @param {*} value Option value\n * @param {string} propName dot '.' delimited full path of property within the option to set. if undefined\\empty, will add a new option with that value\n * @returns {ReflectionObject} `this`\n */\nReflectionObject.prototype.setParsedOption = function setParsedOption(name, value, propName) {\n if (name === \"__proto__\")\n return this;\n if (!this.parsedOptions) {\n this.parsedOptions = [];\n }\n var parsedOptions = this.parsedOptions;\n if (propName) {\n // If setting a sub property of an option then try to merge it\n // with an existing option\n var opt = parsedOptions.find(function (opt) {\n return Object.prototype.hasOwnProperty.call(opt, name);\n });\n if (opt) {\n // If we found an existing option - just merge the property value\n // (If it's a feature, will just write over)\n var newValue = opt[name];\n util.setProperty(newValue, propName, value);\n } else {\n // otherwise, create a new option, set its property and add it to the list\n opt = {};\n opt[name] = util.setProperty({}, propName, value);\n parsedOptions.push(opt);\n }\n } else {\n // Always create a new option when setting the value of the option itself\n var newOpt = {};\n newOpt[name] = value;\n parsedOptions.push(newOpt);\n }\n\n return this;\n};\n\n/**\n * Sets multiple options.\n * @param {Object.<string,*>} options Options to set\n * @param {boolean} [ifNotSet] Sets an option only if it isn't currently set\n * @returns {ReflectionObject} `this`\n */\nReflectionObject.prototype.setOptions = function setOptions(options, ifNotSet) {\n if (options)\n for (var keys = Object.keys(options), i = 0; i < keys.length; ++i)\n this.setOption(keys[i], options[keys[i]], ifNotSet);\n return this;\n};\n\n/**\n * Converts this instance to its string representation.\n * @name ReflectionObject#toString\n * @function\n * @returns {string} Class name[, space, full name]\n */\nObject.defineProperty(ReflectionObject.prototype, \"toString\", {\n value: function toString() {\n var className = this.constructor.className,\n fullName = this.fullName;\n if (fullName.length)\n return className + \" \" + fullName;\n return className;\n },\n writable: true,\n enumerable: false,\n configurable: true\n});\n\n/**\n * Converts the edition this object is pinned to for JSON format.\n * @returns {string|undefined} The edition string for JSON representation\n */\nReflectionObject.prototype._editionToJSON = function _editionToJSON() {\n if (!this._edition || this._edition === \"proto3\") {\n // Avoid emitting proto3 since we need to default to it for backwards\n // compatibility anyway.\n return undefined;\n }\n return this._edition;\n};\n\n// Sets up cyclic dependencies (called in index-light)\nReflectionObject._configure = function(Root_) {\n Root = Root_;\n};\n","\"use strict\";\nmodule.exports = OneOf;\n\n// extends ReflectionObject\nvar ReflectionObject = require(15);\nOneOf.prototype = Object.create(ReflectionObject.prototype, {\n constructor: {\n value: OneOf,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\nOneOf.className = \"OneOf\";\n\nvar Field = require(7),\n util = require(28);\n\n/**\n * Constructs a new oneof instance.\n * @classdesc Reflected oneof.\n * @extends ReflectionObject\n * @constructor\n * @param {string} name Oneof name\n * @param {string[]|Object.<string,*>} [fieldNames] Field names\n * @param {Object.<string,*>} [options] Declared options\n * @param {string} [comment] Comment associated with this field\n */\nfunction OneOf(name, fieldNames, options, comment) {\n if (!Array.isArray(fieldNames)) {\n options = fieldNames;\n fieldNames = undefined;\n }\n ReflectionObject.call(this, name, options);\n\n /* istanbul ignore if */\n if (!(fieldNames === undefined || Array.isArray(fieldNames)))\n throw TypeError(\"fieldNames must be an Array\");\n\n /**\n * Field names that belong to this oneof.\n * @type {string[]}\n */\n this.oneof = fieldNames || []; // toJSON, marker\n\n /**\n * Fields that belong to this oneof as an array for iteration.\n * @type {Field[]}\n * @readonly\n */\n this.fieldsArray = []; // declared readonly for conformance, possibly not yet added to parent\n\n /**\n * Comment for this field.\n * @type {string|null}\n */\n this.comment = comment;\n}\n\n/**\n * Oneof descriptor.\n * @interface IOneOf\n * @property {Array.<string>} oneof Oneof field names\n * @property {Object.<string,*>} [options] Oneof options\n * @property {string|null} [comment] Oneof comment\n */\n\n/**\n * Constructs a oneof from a oneof descriptor.\n * @param {string} name Oneof name\n * @param {IOneOf} json Oneof descriptor\n * @returns {OneOf} Created oneof\n * @throws {TypeError} If arguments are invalid\n */\nOneOf.fromJSON = function fromJSON(name, json) {\n return new OneOf(name, json.oneof, json.options, json.comment);\n};\n\n/**\n * Converts this oneof to a oneof descriptor.\n * @param {IToJSONOptions} [toJSONOptions] JSON conversion options\n * @returns {IOneOf} Oneof descriptor\n */\nOneOf.prototype.toJSON = function toJSON(toJSONOptions) {\n var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;\n return util.toObject([\n \"options\" , this.options,\n \"oneof\" , this.oneof,\n \"comment\" , keepComments ? this.comment : undefined\n ]);\n};\n\n/**\n * Adds the fields of the specified oneof to the parent if not already done so.\n * @param {OneOf} oneof The oneof\n * @returns {undefined}\n * @inner\n * @ignore\n */\nfunction addFieldsToParent(oneof) {\n if (oneof.parent)\n for (var i = 0; i < oneof.fieldsArray.length; ++i)\n if (!oneof.fieldsArray[i].parent)\n oneof.parent.add(oneof.fieldsArray[i]);\n}\n\n/**\n * Adds a field to this oneof and removes it from its current parent, if any.\n * @param {Field} field Field to add\n * @returns {OneOf} `this`\n */\nOneOf.prototype.add = function add(field) {\n\n /* istanbul ignore if */\n if (!(field instanceof Field))\n throw TypeError(\"field must be a Field\");\n\n if (field.parent && field.parent !== this.parent)\n field.parent.remove(field);\n this.oneof.push(field.name);\n this.fieldsArray.push(field);\n field.partOf = this; // field.parent remains null\n addFieldsToParent(this);\n return this;\n};\n\n/**\n * Removes a field from this oneof and puts it back to the oneof's parent.\n * @param {Field} field Field to remove\n * @returns {OneOf} `this`\n */\nOneOf.prototype.remove = function remove(field) {\n\n /* istanbul ignore if */\n if (!(field instanceof Field))\n throw TypeError(\"field must be a Field\");\n\n var index = this.fieldsArray.indexOf(field);\n\n /* istanbul ignore if */\n if (index < 0)\n throw Error(field + \" is not a member of \" + this);\n\n this.fieldsArray.splice(index, 1);\n index = this.oneof.indexOf(field.name);\n\n /* istanbul ignore else */\n if (index > -1) // theoretical\n this.oneof.splice(index, 1);\n\n field.partOf = null;\n return this;\n};\n\n/**\n * @override\n */\nOneOf.prototype.onAdd = function onAdd(parent) {\n ReflectionObject.prototype.onAdd.call(this, parent);\n var self = this;\n // Collect present fields\n for (var i = 0; i < this.oneof.length; ++i) {\n var field = parent.get(this.oneof[i]);\n if (field && !field.partOf) {\n field.partOf = self;\n self.fieldsArray.push(field);\n }\n }\n // Add not yet present fields\n addFieldsToParent(this);\n};\n\n/**\n * @override\n */\nOneOf.prototype.onRemove = function onRemove(parent) {\n for (var i = 0, field; i < this.fieldsArray.length; ++i)\n if ((field = this.fieldsArray[i]).parent)\n field.parent.remove(field);\n ReflectionObject.prototype.onRemove.call(this, parent);\n};\n\n/**\n * Determines whether this field corresponds to a synthetic oneof created for\n * a proto3 optional field. No behavioral logic should depend on this, but it\n * can be relevant for reflection.\n * @name OneOf#isProto3Optional\n * @type {boolean}\n * @readonly\n */\nObject.defineProperty(OneOf.prototype, \"isProto3Optional\", {\n get: function() {\n if (this.fieldsArray == null || this.fieldsArray.length !== 1) {\n return false;\n }\n\n var field = this.fieldsArray[0];\n return field.options != null && field.options[\"proto3_optional\"] === true;\n }\n});\n\n/**\n * Decorator function as returned by {@link OneOf.d} (TypeScript).\n * @typedef OneOfDecorator\n * @type {function}\n * @param {Object} prototype Target prototype\n * @param {string} oneofName OneOf name\n * @returns {undefined}\n * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.\n */\n\n/**\n * OneOf decorator (TypeScript).\n * @function\n * @param {...string} fieldNames Field names\n * @returns {OneOfDecorator} Decorator function\n * @template T extends string\n * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.\n */\nOneOf.d = function decorateOneOf() {\n var fieldNames = new Array(arguments.length),\n index = 0;\n while (index < arguments.length)\n fieldNames[index] = arguments[index++];\n return function oneOfDecorator(prototype, oneofName) {\n util.decorateType(prototype.constructor)\n .add(new OneOf(oneofName, fieldNames));\n Object.defineProperty(prototype, oneofName, {\n get: util.oneOfGetter(fieldNames),\n set: util.oneOfSetter(fieldNames)\n });\n };\n};\n","\"use strict\";\nmodule.exports = parse;\n\nparse.filename = null;\nparse.defaults = { keepCase: false };\n\nvar tokenize = require(25),\n Root = require(20),\n Type = require(26),\n Field = require(7),\n MapField = require(11),\n OneOf = require(16),\n Enum = require(6),\n Service = require(24),\n Method = require(13),\n ReflectionObject = require(15),\n types = require(27),\n util = require(28);\n\nvar base10Re = /^[1-9][0-9]*$/,\n base10NegRe = /^-?[1-9][0-9]*$/,\n base16Re = /^0[x][0-9a-fA-F]+$/,\n base16NegRe = /^-?0[x][0-9a-fA-F]+$/,\n base8Re = /^0[0-7]+$/,\n base8NegRe = /^-?0[0-7]+$/,\n numberRe = util.patterns.numberRe,\n nameRe = /^[a-zA-Z_][a-zA-Z_0-9]*$/,\n typeRefRe = util.patterns.typeRefRe;\n\nvar maxFieldId = 536870911, // 2^29 - 1\n maxEnumId = 2147483647; // 2^31 - 1\n\n/**\n * Result object returned from {@link parse}.\n * @interface IParserResult\n * @property {string|undefined} package Package name, if declared\n * @property {string[]|undefined} imports Imports, if any\n * @property {string[]|undefined} weakImports Weak imports, if any\n * @property {Root} root Populated root instance\n */\n\n/**\n * Options modifying the behavior of {@link parse}.\n * @interface IParseOptions\n * @property {boolean} [keepCase=false] Keeps field casing instead of converting to camel case\n * @property {boolean} [alternateCommentMode=false] Recognize double-slash comments in addition to doc-block comments.\n * @property {boolean} [preferTrailingComment=false] Use trailing comment when both leading comment and trailing comment exist.\n */\n\n/**\n * Options modifying the behavior of JSON serialization.\n * @interface IToJSONOptions\n * @property {boolean} [keepComments=false] Serializes comments.\n */\n\n/**\n * Parses the given .proto source and returns an object with the parsed contents.\n * @param {string} source Source contents\n * @param {Root} root Root to populate\n * @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.\n * @returns {IParserResult} Parser result\n * @property {string} filename=null Currently processing file name for error reporting, if known\n * @property {IParseOptions} defaults Default {@link IParseOptions}\n */\nfunction parse(source, root, options) {\n /* eslint-disable callback-return */\n if (!(root instanceof Root)) {\n options = root;\n root = new Root();\n }\n if (!options)\n options = parse.defaults;\n\n var preferTrailingComment = options.preferTrailingComment || false;\n var tn = tokenize(source, options.alternateCommentMode || false),\n next = tn.next,\n push = tn.push,\n peek = tn.peek,\n skip = tn.skip,\n cmnt = tn.cmnt;\n\n var head = true,\n pkg,\n imports,\n weakImports,\n edition = \"proto2\";\n\n var ptr = root;\n\n var topLevelObjects = [];\n var topLevelOptions = {};\n\n var applyCase = options.keepCase ? function(name) { return name; } : util.camelCase;\n\n function resolveFileFeatures() {\n topLevelObjects.forEach(obj => {\n obj._edition = edition;\n Object.keys(topLevelOptions).forEach(opt => {\n if (obj.getOption(opt) !== undefined) return;\n obj.setOption(opt, topLevelOptions[opt], true);\n });\n });\n }\n\n /* istanbul ignore next */\n function illegal(token, name, insideTryCatch) {\n var filename = parse.filename;\n if (!insideTryCatch)\n parse.filename = null;\n return Error(\"illegal \" + (name || \"token\") + \" '\" + token + \"' (\" + (filename ? filename + \", \" : \"\") + \"line \" + tn.line + \")\");\n }\n\n function readString() {\n var values = [],\n token;\n do {\n /* istanbul ignore if */\n if ((token = next()) !== \"\\\"\" && token !== \"'\")\n throw illegal(token);\n\n values.push(next());\n skip(token);\n token = peek();\n } while (token === \"\\\"\" || token === \"'\");\n return values.join(\"\");\n }\n\n function readValue(acceptTypeRef) {\n var token = next();\n switch (token) {\n case \"'\":\n case \"\\\"\":\n push(token);\n return readString();\n case \"true\": case \"TRUE\":\n return true;\n case \"false\": case \"FALSE\":\n return false;\n }\n try {\n return parseNumber(token, /* insideTryCatch */ true);\n } catch (e) {\n /* istanbul ignore else */\n if (acceptTypeRef && typeRefRe.test(token))\n return token;\n\n /* istanbul ignore next */\n throw illegal(token, \"value\");\n }\n }\n\n function readRanges(target, acceptStrings, max, acceptNegative) {\n var token, start;\n do {\n if (acceptStrings && ((token = peek()) === \"\\\"\" || token === \"'\")) {\n var str = readString();\n target.push(str);\n if (edition >= 2023) {\n throw illegal(str, \"id\");\n }\n } else {\n try {\n target.push([ start = parseId(next(), acceptNegative, max), skip(\"to\", true) ? parseId(next(), acceptNegative, max) : start ]);\n } catch (err) {\n if (acceptStrings && typeRefRe.test(token) && edition >= 2023) {\n target.push(token);\n } else {\n throw err;\n }\n }\n }\n } while (skip(\",\", true));\n var dummy = {options: undefined};\n dummy.setOption = function(name, value) {\n if (this.options === undefined) this.options = {};\n this.options[name] = value;\n };\n ifBlock(\n dummy,\n function parseRange_block(token) {\n /* istanbul ignore else */\n if (token === \"option\") {\n parseOption(dummy, token); // skip\n skip(\";\");\n } else\n throw illegal(token);\n },\n function parseRange_line() {\n parseInlineOptions(dummy); // skip\n });\n }\n\n function parseNumber(token, insideTryCatch) {\n var sign = 1;\n if (token.charAt(0) === \"-\") {\n sign = -1;\n token = token.substring(1);\n }\n switch (token) {\n case \"inf\": case \"INF\": case \"Inf\":\n return sign * Infinity;\n case \"nan\": case \"NAN\": case \"Nan\": case \"NaN\":\n return NaN;\n case \"0\":\n return 0;\n }\n if (base10Re.test(token))\n return sign * parseInt(token, 10);\n if (base16Re.test(token))\n return sign * parseInt(token, 16);\n if (base8Re.test(token))\n return sign * parseInt(token, 8);\n\n /* istanbul ignore else */\n if (numberRe.test(token))\n return sign * parseFloat(token);\n\n /* istanbul ignore next */\n throw illegal(token, \"number\", insideTryCatch);\n }\n\n function parseId(token, acceptNegative, max) {\n if (token === null) {\n throw illegal(token, \"end of input\");\n }\n switch (token) {\n case \"max\": case \"MAX\": case \"Max\":\n return max || maxFieldId;\n case \"0\":\n return 0;\n }\n\n /* istanbul ignore if */\n if (!acceptNegative && token.charAt(0) === \"-\")\n throw illegal(token, \"id\");\n\n if (base10NegRe.test(token))\n return parseInt(token, 10);\n if (base16NegRe.test(token))\n return parseInt(token, 16);\n\n /* istanbul ignore else */\n if (base8NegRe.test(token))\n return parseInt(token, 8);\n\n /* istanbul ignore next */\n throw illegal(token, \"id\");\n }\n\n function parsePackage() {\n /* istanbul ignore if */\n if (pkg !== undefined)\n throw illegal(\"package\");\n\n pkg = next();\n\n /* istanbul ignore if */\n if (pkg === null || !typeRefRe.test(pkg))\n throw illegal(pkg, \"name\");\n\n ptr = ptr.define(pkg);\n\n skip(\";\");\n }\n\n function parseImport() {\n var token = peek();\n var whichImports;\n switch (token) {\n case \"option\":\n if (edition < \"2024\") {\n throw illegal(\"option\");\n }\n // Import options are only used for resolving options, which we don't\n // do. We can just throw them out.\n next();\n readString();\n skip(\";\");\n return;\n case \"weak\":\n whichImports = weakImports || (weakImports = []);\n next();\n break;\n case \"public\":\n next();\n // eslint-disable-next-line no-fallthrough\n default:\n whichImports = imports || (imports = []);\n break;\n }\n token = readString();\n skip(\";\");\n whichImports.push(token);\n }\n\n function parseSyntax() {\n skip(\"=\");\n edition = readString();\n\n /* istanbul ignore if */\n if (edition < 2023)\n throw illegal(edition, \"syntax\");\n\n skip(\";\");\n }\n\n function parseEdition() {\n skip(\"=\");\n edition = readString();\n const supportedEditions = [\"2023\", \"2024\"];\n\n /* istanbul ignore if */\n if (!supportedEditions.includes(edition))\n throw illegal(edition, \"edition\");\n\n skip(\";\");\n }\n\n\n function parseCommon(parent, token, depth) {\n if (depth === undefined)\n depth = 0;\n // depth is checked by dispatched functions\n switch (token) {\n\n case \"option\":\n parseOption(parent, token);\n skip(\";\");\n return true;\n\n case \"message\":\n parseType(parent, token, depth + 1);\n return true;\n\n case \"enum\":\n parseEnum(parent, token);\n return true;\n\n case \"export\":\n case \"local\":\n if (edition < \"2024\") {\n return false;\n }\n token = next();\n if (token === \"export\" || token === \"local\") {\n return false;\n }\n if (token !== \"message\" && token !== \"enum\") {\n return false;\n }\n /* eslint-disable no-warning-comments */\n // TODO: actually enforce visiblity modifiers like protoc does.\n return parseCommon(parent, token, depth);\n\n case \"service\":\n parseService(parent, token, depth + 1);\n return true;\n\n case \"extend\":\n parseExtension(parent, token, depth);\n return true;\n }\n return false;\n }\n\n function ifBlock(obj, fnIf, fnElse) {\n var trailingLine = tn.line;\n if (obj) {\n if(typeof obj.comment !== \"string\") {\n obj.comment = cmnt(); // try block-type comment\n }\n obj.filename = parse.filename;\n }\n if (skip(\"{\", true)) {\n var token;\n while ((token = next()) !== \"}\")\n fnIf(token);\n skip(\";\", true);\n } else {\n if (fnElse)\n fnElse();\n skip(\";\");\n if (obj && (typeof obj.comment !== \"string\" || preferTrailingComment))\n obj.comment = cmnt(trailingLine) || obj.comment; // try line-type comment\n }\n }\n\n function parseType(parent, token, depth) {\n if (depth === undefined)\n depth = 0;\n if (depth > util.nestingLimit)\n throw Error(\"max depth exceeded\");\n\n /* istanbul ignore if */\n if ((token = next()) === null || !nameRe.test(token))\n throw illegal(token, \"type name\");\n\n var type = new Type(token);\n ifBlock(type, function parseType_block(token) {\n if (parseCommon(type, token, depth))\n return;\n\n switch (token) {\n\n case \";\":\n break;\n\n case \"map\":\n parseMapField(type, token);\n break;\n\n case \"required\":\n if (edition !== \"proto2\")\n throw illegal(token);\n /* eslint-disable no-fallthrough */\n case \"repeated\":\n parseField(type, token, undefined, depth + 1);\n break;\n\n case \"optional\":\n /* istanbul ignore if */\n if (edition === \"proto3\") {\n parseField(type, \"proto3_optional\", undefined, depth + 1);\n } else if (edition !== \"proto2\") {\n throw illegal(token);\n } else {\n parseField(type, \"optional\", undefined, depth + 1);\n }\n break;\n\n case \"oneof\":\n parseOneOf(type, token, depth + 1);\n break;\n\n case \"extensions\":\n readRanges(type.extensions || (type.extensions = []));\n break;\n\n case \"reserved\":\n readRanges(type.reserved || (type.reserved = []), true);\n break;\n\n default:\n /* istanbul ignore if */\n if (edition === \"proto2\" || !typeRefRe.test(token)) {\n throw illegal(token);\n }\n\n push(token);\n parseField(type, \"optional\", undefined, depth + 1);\n break;\n }\n });\n parent.add(type);\n if (parent === ptr) {\n topLevelObjects.push(type);\n }\n }\n\n function parseField(parent, rule, extend, depth) {\n var type = next();\n if (type === null) {\n throw illegal(type, \"end of input\");\n }\n if (type === \"group\") {\n parseGroup(parent, rule, extend, depth);\n return;\n }\n // Type names can consume multiple tokens, in multiple variants:\n // package.subpackage field tokens: \"package.subpackage\" [TYPE NAME ENDS HERE] \"field\"\n // package . subpackage field tokens: \"package\" \".\" \"subpackage\" [TYPE NAME ENDS HERE] \"field\"\n // package. subpackage field tokens: \"package.\" \"subpackage\" [TYPE NAME ENDS HERE] \"field\"\n // package .subpackage field tokens: \"package\" \".subpackage\" [TYPE NAME ENDS HERE] \"field\"\n // Keep reading tokens until we get a type name with no period at the end,\n // and the next token does not start with a period.\n while (type.endsWith(\".\") || (peek() || \"\").startsWith(\".\")) {\n var part = next();\n if (part === null) {\n throw illegal(part, \"end of input\");\n }\n type += part;\n }\n\n /* istanbul ignore if */\n if (!typeRefRe.test(type))\n throw illegal(type, \"type\");\n\n var name = next();\n if (name === null) {\n throw illegal(name, \"end of input\");\n }\n\n /* istanbul ignore if */\n\n if (!nameRe.test(name))\n throw illegal(name, \"name\");\n\n var protoName = name;\n name = applyCase(name);\n skip(\"=\");\n\n var field = new Field(name, parseId(next()), type, rule === \"proto3_optional\" ? \"optional\" : rule, extend);\n if (protoName !== name)\n field.protoName = protoName;\n\n ifBlock(field, function parseField_block(token) {\n\n /* istanbul ignore else */\n if (token === \"option\") {\n parseOption(field, token);\n skip(\";\");\n } else\n throw illegal(token);\n\n }, function parseField_line() {\n parseInlineOptions(field);\n });\n\n if (rule === \"proto3_optional\") {\n // for proto3 optional fields, we create a single-member Oneof to mimic \"optional\" behavior\n var oneof = new OneOf(\"_\" + name);\n field.setOption(\"proto3_optional\", true);\n oneof.add(field);\n parent.add(oneof);\n } else {\n parent.add(field);\n }\n if (parent === ptr) {\n topLevelObjects.push(field);\n }\n }\n\n function parseGroup(parent, rule, extend, depth) {\n if (depth === undefined)\n depth = 0;\n if (depth > util.nestingLimit)\n throw Error(\"max depth exceeded\");\n if (edition >= 2023) {\n throw illegal(\"group\");\n }\n var name = next();\n\n /* istanbul ignore if */\n if (name === null || !nameRe.test(name))\n throw illegal(name, \"name\");\n\n var fieldName = util.lcFirst(name);\n if (name === fieldName)\n name = util.ucFirst(name);\n skip(\"=\");\n var id = parseId(next());\n var type = new Type(name);\n type.group = true;\n var field = new Field(fieldName, id, name, rule, extend);\n field.filename = parse.filename;\n ifBlock(type, function parseGroup_block(token) {\n switch (token) {\n\n case \";\":\n break;\n\n case \"map\":\n parseMapField(type);\n break;\n\n case \"option\":\n parseOption(type, token);\n skip(\";\");\n break;\n case \"required\":\n case \"repeated\":\n parseField(type, token, undefined, depth + 1);\n break;\n\n case \"optional\":\n /* istanbul ignore if */\n if (edition === \"proto3\") {\n parseField(type, \"proto3_optional\", undefined, depth + 1);\n } else {\n parseField(type, \"optional\", undefined, depth + 1);\n }\n break;\n\n case \"message\":\n parseType(type, token, depth + 1);\n break;\n\n case \"enum\":\n parseEnum(type, token);\n break;\n\n case \"reserved\":\n readRanges(type.reserved || (type.reserved = []), true);\n break;\n\n case \"export\":\n case \"local\":\n if (edition < \"2024\") {\n throw illegal(token);\n }\n token = next();\n switch (token) {\n case \"message\":\n parseType(type, token, depth + 1);\n break;\n case \"enum\":\n parseType(type, token, depth + 1);\n break;\n default:\n throw illegal(token);\n }\n break;\n\n /* istanbul ignore next */\n default:\n throw illegal(token); // there are no groups with proto3 semantics\n }\n });\n parent.add(type)\n .add(field);\n if (parent === ptr) {\n topLevelObjects.push(type);\n topLevelObjects.push(field);\n }\n }\n\n function parseMapField(parent) {\n skip(\"<\");\n var keyType = next();\n\n /* istanbul ignore if */\n if (types.mapKey[keyType] === undefined)\n throw illegal(keyType, \"type\");\n\n skip(\",\");\n var valueType = next();\n\n /* istanbul ignore if */\n if (!typeRefRe.test(valueType))\n throw illegal(valueType, \"type\");\n\n skip(\">\");\n var name = next();\n\n /* istanbul ignore if */\n if (name === null || !nameRe.test(name))\n throw illegal(name, \"name\");\n\n skip(\"=\");\n var protoName = name;\n name = applyCase(name);\n var field = new MapField(name, parseId(next()), keyType, valueType);\n if (protoName !== name)\n field.protoName = protoName;\n ifBlock(field, function parseMapField_block(token) {\n\n /* istanbul ignore else */\n if (token === \"option\") {\n parseOption(field, token);\n skip(\";\");\n } else\n throw illegal(token);\n\n }, function parseMapField_line() {\n parseInlineOptions(field);\n });\n parent.add(field);\n }\n\n function parseOneOf(parent, token, depth) {\n\n /* istanbul ignore if */\n if ((token = next()) === null || !nameRe.test(token))\n throw illegal(token, \"name\");\n\n var oneof = new OneOf(applyCase(token));\n ifBlock(oneof, function parseOneOf_block(token) {\n if (token === \"option\") {\n parseOption(oneof, token);\n skip(\";\");\n } else {\n push(token);\n parseField(oneof, \"optional\", undefined, depth);\n }\n });\n parent.add(oneof);\n }\n\n function parseEnum(parent, token) {\n\n /* istanbul ignore if */\n if ((token = next()) === null || !nameRe.test(token))\n throw illegal(token, \"name\");\n\n var enm = new Enum(token),\n values = [];\n ifBlock(enm, function parseEnum_block(token) {\n switch(token) {\n case \";\":\n break;\n\n case \"option\":\n parseOption(enm, token);\n skip(\";\");\n break;\n\n case \"reserved\":\n readRanges(enm.reserved || (enm.reserved = []), true, maxEnumId, true);\n if(enm.reserved === undefined) enm.reserved = [];\n break;\n\n default:\n values.push(parseEnumValue(token));\n }\n });\n for (var i = 0; i < values.length; ++i)\n enm.add(values[i].name, values[i].id, values[i].comment, values[i].options);\n parent.add(enm);\n if (parent === ptr) {\n topLevelObjects.push(enm);\n }\n }\n\n function parseEnumValue(token) {\n\n /* istanbul ignore if */\n if (!nameRe.test(token))\n throw illegal(token, \"name\");\n\n skip(\"=\");\n var value = parseId(next(), true),\n dummy = {\n options: undefined\n };\n dummy.getOption = function(name) {\n return this.options[name];\n };\n dummy.setOption = function(name, value) {\n ReflectionObject.prototype.setOption.call(dummy, name, value);\n };\n dummy.setParsedOption = function() {\n return undefined;\n };\n ifBlock(dummy, function parseEnumValue_block(token) {\n\n /* istanbul ignore else */\n if (token === \"option\") {\n parseOption(dummy, token); // skip\n skip(\";\");\n } else\n throw illegal(token);\n\n }, function parseEnumValue_line() {\n parseInlineOptions(dummy); // skip\n });\n return {\n name: token,\n id: value,\n comment: dummy.comment,\n options: dummy.parsedOptions || dummy.options\n };\n }\n\n function parseOption(parent, token) {\n var option;\n var propName;\n var isOption = true;\n if (token === \"option\") {\n token = next();\n }\n\n while (token !== \"=\") {\n if (token === null) {\n throw illegal(token, \"end of input\");\n }\n if (token === \"(\") {\n var parensValue = next();\n skip(\")\");\n token = \"(\" + parensValue + \")\";\n }\n if (isOption) {\n isOption = false;\n if (token.includes(\".\") && !token.includes(\"(\")) {\n var tokens = token.split(\".\");\n option = tokens[0] + \".\";\n token = tokens[1];\n continue;\n }\n option = token;\n } else {\n propName = propName ? propName += token : token;\n }\n token = next();\n }\n var name = propName ? option.concat(propName) : option;\n var optionValue = parseOptionValue(parent, name);\n propName = propName && propName[0] === \".\" ? propName.slice(1) : propName;\n option = option && option[option.length - 1] === \".\" ? option.slice(0, -1) : option;\n setParsedOption(parent, option, optionValue, propName);\n }\n\n function parseOptionValue(parent, name, depth) {\n if (depth === undefined)\n depth = 0;\n if (depth > util.recursionLimit)\n throw Error(\"max depth exceeded\");\n // { a: \"foo\" b { c: \"bar\" } }\n if (skip(\"{\", true)) {\n var objectResult = {};\n\n while (!skip(\"}\", true)) {\n token = next();\n var propName;\n if (token === null)\n throw illegal(token, \"end of input\");\n if (token === \"[\") {\n token = next();\n // Extension name or, for Any, a type URL: \"<prefix>/<fully.qualified.Type>\".\n var slash = token === null ? -1 : token.lastIndexOf(\"/\");\n if (token === null || !typeRefRe.test(slash < 0 ? token : token.slice(slash + 1)))\n throw illegal(token, \"name\");\n propName = \"[\" + token + \"]\";\n skip(\"]\");\n } else {\n /* istanbul ignore if */\n if (!nameRe.test(token)) {\n throw illegal(token, \"name\");\n }\n propName = token;\n }\n\n var value;\n\n skip(\":\", true);\n\n if (peek() === \"{\") {\n // option (my_option) = {\n // repeated_value: [ \"foo\", \"bar\" ]\n // };\n value = parseOptionValue(parent, name + \".\" + propName, depth + 1);\n } else if (peek() === \"[\") {\n value = [];\n var lastValue,\n lastValueIsAggregate;\n if (skip(\"[\", true)) {\n if (!skip(\"]\", true)) {\n do {\n lastValueIsAggregate = peek() === \"{\";\n lastValue = lastValueIsAggregate\n ? parseOptionValue(parent, name + \".\" + propName, depth + 1)\n : readValue(true);\n value.push(lastValue);\n } while (skip(\",\", true));\n skip(\"]\");\n if (typeof lastValue !== \"undefined\") {\n if (!lastValueIsAggregate)\n setOption(parent, name + \".\" + propName, lastValue);\n }\n }\n }\n } else {\n value = readValue(true);\n setOption(parent, name + \".\" + propName, value);\n }\n\n var prevValue = Object.prototype.hasOwnProperty.call(objectResult, propName)\n ? objectResult[propName]\n : undefined;\n\n if (prevValue)\n value = [].concat(prevValue).concat(value);\n\n if (propName !== \"__proto__\")\n objectResult[propName] = value;\n\n // Semicolons and commas can be optional\n skip(\",\", true);\n skip(\";\", true);\n }\n\n return objectResult;\n }\n\n var simpleValue = readValue(true);\n setOption(parent, name, simpleValue);\n return simpleValue;\n // Does not enforce a delimiter to be universal\n }\n\n function setOption(parent, name, value) {\n if (ptr === parent && /^features\\./.test(name)) {\n topLevelOptions[name] = value;\n return;\n }\n // lift json_name onto Field\n if (name === \"json_name\" && parent instanceof Field) {\n parent.jsonName = value;\n }\n if (parent.setOption)\n parent.setOption(name, value);\n }\n\n function setParsedOption(parent, name, value, propName) {\n if (parent.setParsedOption)\n parent.setParsedOption(name, value, propName);\n }\n\n function parseInlineOptions(parent) {\n if (skip(\"[\", true)) {\n do {\n parseOption(parent, \"option\");\n } while (skip(\",\", true));\n skip(\"]\");\n }\n return parent;\n }\n\n function parseService(parent, token, depth) {\n if (depth === undefined)\n depth = 0;\n if (depth > util.recursionLimit)\n throw Error(\"max depth exceeded\");\n\n /* istanbul ignore if */\n if ((token = next()) === null || !nameRe.test(token))\n throw illegal(token, \"service name\");\n\n var service = new Service(token);\n ifBlock(service, function parseService_block(token) {\n if (parseCommon(service, token, depth)) {\n return;\n }\n\n /* istanbul ignore else */\n if (token === \";\")\n return;\n if (token === \"rpc\")\n parseMethod(service, token);\n else\n throw illegal(token);\n });\n parent.add(service);\n if (parent === ptr) {\n topLevelObjects.push(service);\n }\n }\n\n function parseMethod(parent, token) {\n // Get the comment of the preceding line now (if one exists) in case the\n // method is defined across multiple lines.\n var commentText = cmnt();\n\n var type = token;\n\n /* istanbul ignore if */\n if (!nameRe.test(token = next()))\n throw illegal(token, \"name\");\n\n var name = token,\n requestType, requestStream,\n responseType, responseStream;\n\n skip(\"(\");\n if (skip(\"stream\", true))\n requestStream = true;\n\n /* istanbul ignore if */\n if (!typeRefRe.test(token = next()))\n throw illegal(token);\n\n requestType = token;\n skip(\")\"); skip(\"returns\"); skip(\"(\");\n if (skip(\"stream\", true))\n responseStream = true;\n\n /* istanbul ignore if */\n if (!typeRefRe.test(token = next()))\n throw illegal(token);\n\n responseType = token;\n skip(\")\");\n\n var method = new Method(name, type, requestType, responseType, requestStream, responseStream);\n method.comment = commentText;\n ifBlock(method, function parseMethod_block(token) {\n\n /* istanbul ignore else */\n if (token === \";\")\n return;\n if (token === \"option\") {\n parseOption(method, token);\n skip(\";\");\n } else\n throw illegal(token);\n\n });\n parent.add(method);\n }\n\n function parseExtension(parent, token, depth) {\n\n /* istanbul ignore if */\n if ((token = next()) === null || !typeRefRe.test(token))\n throw illegal(token, \"reference\");\n\n var reference = token;\n ifBlock(null, function parseExtension_block(token) {\n switch (token) {\n\n case \"required\":\n case \"repeated\":\n parseField(parent, token, reference, depth + 1);\n break;\n\n case \"optional\":\n /* istanbul ignore if */\n if (edition === \"proto3\") {\n parseField(parent, \"proto3_optional\", reference, depth + 1);\n } else {\n parseField(parent, \"optional\", reference, depth + 1);\n }\n break;\n\n default:\n /* istanbul ignore if */\n if (edition === \"proto2\" || !typeRefRe.test(token))\n throw illegal(token);\n push(token);\n parseField(parent, \"optional\", reference, depth + 1);\n break;\n }\n });\n }\n\n var token;\n while ((token = next()) !== null) {\n switch (token) {\n\n case \";\":\n break;\n\n case \"package\":\n\n /* istanbul ignore if */\n if (!head)\n throw illegal(token);\n\n parsePackage();\n break;\n\n case \"import\":\n\n parseImport();\n break;\n\n case \"syntax\":\n\n /* istanbul ignore if */\n if (!head)\n throw illegal(token);\n\n parseSyntax();\n break;\n\n case \"edition\":\n /* istanbul ignore if */\n if (!head)\n throw illegal(token);\n parseEdition();\n break;\n\n case \"option\":\n parseOption(ptr, token);\n skip(\";\", true);\n break;\n\n default:\n\n /* istanbul ignore else */\n if (parseCommon(ptr, token, 0)) {\n head = false;\n continue;\n }\n\n /* istanbul ignore next */\n throw illegal(token);\n }\n }\n\n resolveFileFeatures();\n\n parse.filename = null;\n return {\n \"package\" : pkg,\n \"imports\" : imports,\n weakImports : weakImports,\n root : root\n };\n}\n\n/**\n * Parses the given .proto source and returns an object with the parsed contents.\n * @name parse\n * @function\n * @param {string} source Source contents\n * @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.\n * @returns {IParserResult} Parser result\n * @property {string} filename=null Currently processing file name for error reporting, if known\n * @property {IParseOptions} defaults Default {@link IParseOptions}\n * @variation 2\n */\n","\"use strict\";\nmodule.exports = Reader;\n\nvar util = require(37);\n\nvar BufferReader; // cyclic\n\nvar LongBits = util.LongBits,\n utf8 = util.utf8;\n\n/* istanbul ignore next */\nfunction indexOutOfRange(reader, writeLength) {\n return RangeError(\"index out of range: \" + reader.pos + \" + \" + (writeLength || 1) + \" > \" + reader.len);\n}\n\n/**\n * Constructs a new reader instance using the specified buffer.\n * @classdesc Wire format reader using `Uint8Array`.\n * @constructor\n * @param {Uint8Array} buffer Buffer to read from\n */\nfunction Reader(buffer) {\n\n /**\n * Read buffer.\n * @type {Uint8Array}\n */\n this.buf = buffer;\n\n /**\n * Read buffer position.\n * @type {number}\n */\n this.pos = 0;\n\n /**\n * Read buffer length.\n * @type {number}\n */\n this.len = buffer.length;\n\n /**\n * Cached DataView for packed reads.\n * @type {DataView|null}\n */\n this.view = null;\n\n /**\n * Whether to discard unknown fields while decoding.\n * @type {boolean}\n */\n this.discardUnknown = Reader.discardUnknown;\n}\n\nfunction create_array(buffer) {\n // TODO: Remove plain array reader support in the next major release.\n if (Array.isArray(buffer))\n buffer = new Uint8Array(buffer);\n if (buffer instanceof Uint8Array)\n return new Reader(buffer);\n throw Error(\"illegal buffer\");\n}\n\nvar create = function create() {\n return util.Buffer\n ? function create_buffer_setup(buffer) {\n return (Reader.create = function create_buffer(buffer) {\n return util.Buffer.isBuffer(buffer)\n ? new BufferReader(buffer)\n /* istanbul ignore next */\n : create_array(buffer);\n })(buffer);\n }\n /* istanbul ignore next */\n : create_array;\n};\n\n/**\n * Creates a new reader using the specified buffer.\n * @function\n * @param {Uint8Array|Buffer} buffer Buffer to read from\n * @returns {Reader|BufferReader} A {@link BufferReader} if `buffer` is a Buffer, otherwise a {@link Reader}\n * @throws {Error} If `buffer` is not a valid buffer\n */\nReader.create = create();\n\n/**\n * Returns raw bytes from the backing buffer without advancing the reader.\n * @param {number} start Start offset\n * @param {number} end End offset\n * @returns {Uint8Array} Raw bytes\n */\nReader.prototype.raw = function read_raw(start, end) {\n return this.buf.subarray(start, end);\n};\n\n/**\n * Reads a varint as an unsigned 32 bit value.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.uint32 = function read_uint32() {\n var buf = this.buf,\n pos = this.pos,\n value = (buf[pos] & 127) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value | (buf[pos] & 127) << 7) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value | (buf[pos] & 127) << 14) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value | (buf[pos] & 127) << 21) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value | (buf[pos] & 15) << 28) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n\n for (var i = 0; i < 5; ++i) {\n /* istanbul ignore if */\n if (pos >= this.len) {\n this.pos = pos;\n throw indexOutOfRange(this);\n }\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n }\n /* istanbul ignore next */\n this.pos = pos;\n throw Error(\"invalid varint encoding\");\n};\n\n/**\n * Reads a field tag.\n * @function\n * @returns {number} Tag read\n */\nReader.prototype.tag = function read_tag() {\n var buf = this.buf,\n pos = this.pos,\n value = (buf[pos] & 127) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value | (buf[pos] & 127) << 7) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value | (buf[pos] & 127) << 14) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value | (buf[pos] & 127) << 21) >>> 0;\n if (buf[pos++] < 128) {\n this.pos = pos;\n return value;\n }\n value = (value | (buf[pos] & 15) << 28) >>> 0;\n if (buf[pos] < 128 && (buf[pos] & 112) === 0) {\n this.pos = pos + 1;\n return value;\n }\n\n this.pos = pos + 1;\n throw Error(\"invalid tag encoding\");\n};\n\n/**\n * Reads a varint as a signed 32 bit value.\n * @returns {number} Value read\n */\nReader.prototype.int32 = function read_int32() {\n return this.uint32() | 0;\n};\n\n/**\n * Reads a zig-zag encoded varint as a signed 32 bit value.\n * @returns {number} Value read\n */\nReader.prototype.sint32 = function read_sint32() {\n var value = this.uint32();\n return value >>> 1 ^ -(value & 1) | 0;\n};\n\n/* eslint-disable no-invalid-this */\n\nfunction readLongVarint() {\n // tends to deopt with local vars for octet etc.\n var bits = new LongBits(0, 0);\n var i = 0;\n if (this.len - this.pos > 4) { // fast route (lo)\n for (; i < 4; ++i) {\n // 1st..4th\n bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;\n if (this.buf[this.pos++] < 128)\n return bits;\n }\n // 5th\n bits.lo = (bits.lo | (this.buf[this.pos] & 127) << 28) >>> 0;\n bits.hi = (bits.hi | (this.buf[this.pos] & 127) >> 4) >>> 0;\n if (this.buf[this.pos++] < 128)\n return bits;\n i = 0;\n } else {\n for (; i < 4; ++i) {\n /* istanbul ignore if */\n if (this.pos >= this.len)\n throw indexOutOfRange(this);\n // 1st..4th\n bits.lo = (bits.lo | (this.buf[this.pos] & 127) << i * 7) >>> 0;\n if (this.buf[this.pos++] < 128)\n return bits;\n }\n throw indexOutOfRange(this);\n }\n if (this.len - this.pos > 4) { // fast route (hi)\n for (; i < 5; ++i) {\n // 6th..10th\n bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;\n if (this.buf[this.pos++] < 128)\n return bits;\n }\n } else {\n for (; i < 5; ++i) {\n /* istanbul ignore if */\n if (this.pos >= this.len)\n throw indexOutOfRange(this);\n // 6th..10th\n bits.hi = (bits.hi | (this.buf[this.pos] & 127) << i * 7 + 3) >>> 0;\n if (this.buf[this.pos++] < 128)\n return bits;\n }\n }\n /* istanbul ignore next */\n throw Error(\"invalid varint encoding\");\n}\n\n/* eslint-enable no-invalid-this */\n\n/**\n * Reads a varint as a signed 64 bit value.\n * @name Reader#int64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a varint as an unsigned 64 bit value.\n * @name Reader#uint64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a zig-zag encoded varint as a signed 64 bit value.\n * @name Reader#sint64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a varint as a boolean.\n * @returns {boolean} Value read\n */\nReader.prototype.bool = function read_bool() {\n var value = false,\n b;\n for (var i = 0; i < 10; ++i) {\n /* istanbul ignore if */\n if (this.pos >= this.len)\n throw indexOutOfRange(this);\n b = this.buf[this.pos++];\n if (b & 127)\n value = true;\n if (b < 128)\n return value;\n }\n /* istanbul ignore next */\n throw Error(\"invalid varint encoding\");\n};\n\nfunction readFixed32_end(buf, end) { // note that this uses `end`, not `pos`\n return (buf[end - 4]\n | buf[end - 3] << 8\n | buf[end - 2] << 16\n | buf[end - 1] << 24) >>> 0;\n}\n\n/**\n * Reads fixed 32 bits as an unsigned 32 bit integer.\n * @returns {number} Value read\n */\nReader.prototype.fixed32 = function read_fixed32() {\n\n /* istanbul ignore if */\n if (this.pos + 4 > this.len)\n throw indexOutOfRange(this, 4);\n\n return readFixed32_end(this.buf, this.pos += 4);\n};\n\n/**\n * Reads fixed 32 bits as a signed 32 bit integer.\n * @returns {number} Value read\n */\nReader.prototype.sfixed32 = function read_sfixed32() {\n\n /* istanbul ignore if */\n if (this.pos + 4 > this.len)\n throw indexOutOfRange(this, 4);\n\n return readFixed32_end(this.buf, this.pos += 4) | 0;\n};\n\n/* eslint-disable no-invalid-this */\n\nfunction readFixed64(/* this: Reader */) {\n\n /* istanbul ignore if */\n if (this.pos + 8 > this.len)\n throw indexOutOfRange(this, 8);\n\n return new LongBits(readFixed32_end(this.buf, this.pos += 4), readFixed32_end(this.buf, this.pos += 4));\n}\n\n/* eslint-enable no-invalid-this */\n\n/**\n * Reads fixed 64 bits.\n * @name Reader#fixed64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads zig-zag encoded fixed 64 bits.\n * @name Reader#sfixed64\n * @function\n * @returns {Long} Value read\n */\n\n/**\n * Reads a float (32 bit) as a number.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.float = function read_float() {\n\n /* istanbul ignore if */\n if (this.pos + 4 > this.len)\n throw indexOutOfRange(this, 4);\n\n var value = util.float.readFloatLE(this.buf, this.pos);\n this.pos += 4;\n return value;\n};\n\n/**\n * Reads a double (64 bit float) as a number.\n * @function\n * @returns {number} Value read\n */\nReader.prototype.double = function read_double() {\n\n /* istanbul ignore if */\n if (this.pos + 8 > this.len)\n throw indexOutOfRange(this, 4);\n\n var value = util.float.readDoubleLE(this.buf, this.pos);\n this.pos += 8;\n return value;\n};\n\n/**\n * Reads a packed repeated field of unsigned 32 bit varints.\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n */\nReader.prototype.uint32s = function read_uint32s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.uint32());\n return array;\n};\n\n/**\n * Reads a packed repeated field of signed 32 bit varints.\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n */\nReader.prototype.int32s = function read_int32s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.int32());\n return array;\n};\n\n/**\n * Reads a packed repeated field of zig-zag encoded signed 32 bit varints.\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n */\nReader.prototype.sint32s = function read_sint32s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.sint32());\n return array;\n};\n\n/**\n * Reads a packed repeated field of booleans.\n * @param {boolean[]} [array] Array to read into; a new one is created if omitted\n * @returns {boolean[]} Array read into\n */\nReader.prototype.bools = function read_bools(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.bool());\n return array;\n};\n\n// The view allocation only pays off when amortized over enough reads\nvar VIEW_THRESHOLD_FLOAT = 8,\n VIEW_THRESHOLD_INT = 128;\n\nfunction getLazyView(reader, count, threshold) {\n var view = reader.view;\n if (view || count < threshold)\n return view;\n var buf = reader.buf;\n return reader.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);\n}\n\n/**\n * Reads a packed repeated field of unsigned 32 bit fixed values.\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n */\nReader.prototype.fixed32s = function read_fixed32s(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len;\n /* istanbul ignore if */\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 2, i = array.length, pos = this.pos;\n array.length = i + count;\n var dv = getLazyView(this, count, VIEW_THRESHOLD_INT);\n if (dv)\n for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getUint32(pos, true);\n else {\n var buf = this.buf;\n for (var j = 0; j < count; ++j, pos += 4) array[i++] = readFixed32_end(buf, pos + 4);\n }\n this.pos = pos;\n if (pos !== end) throw indexOutOfRange(this, 4);\n return array;\n};\n\n/**\n * Reads a packed repeated field of signed 32 bit fixed values.\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n */\nReader.prototype.sfixed32s = function read_sfixed32s(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len;\n /* istanbul ignore if */\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 2, i = array.length, pos = this.pos;\n array.length = i + count;\n var dv = getLazyView(this, count, VIEW_THRESHOLD_INT);\n if (dv)\n for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getInt32(pos, true);\n else {\n var buf = this.buf;\n for (var j = 0; j < count; ++j, pos += 4) array[i++] = readFixed32_end(buf, pos + 4) | 0;\n }\n this.pos = pos;\n if (pos !== end) throw indexOutOfRange(this, 4);\n return array;\n};\n\n/**\n * Reads a packed repeated field of floats (32 bit).\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n */\nReader.prototype.floats = function read_floats(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len;\n /* istanbul ignore if */\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 2, i = array.length, pos = this.pos;\n array.length = i + count;\n var dv = getLazyView(this, count, VIEW_THRESHOLD_FLOAT);\n if (dv)\n for (var k = 0; k < count; ++k, pos += 4) array[i++] = dv.getFloat32(pos, true);\n else {\n var buf = this.buf;\n for (var j = 0; j < count; ++j, pos += 4) array[i++] = util.float.readFloatLE(buf, pos);\n }\n this.pos = pos;\n if (pos !== end) throw indexOutOfRange(this, 4);\n return array;\n};\n\n/**\n * Reads a packed repeated field of doubles (64 bit float).\n * @param {number[]} [array] Array to read into; a new one is created if omitted\n * @returns {number[]} Array read into\n */\nReader.prototype.doubles = function read_doubles(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len;\n /* istanbul ignore if */\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 3, i = array.length, pos = this.pos;\n array.length = i + count;\n var dv = getLazyView(this, count, VIEW_THRESHOLD_FLOAT);\n if (dv)\n for (var k = 0; k < count; ++k, pos += 8) array[i++] = dv.getFloat64(pos, true);\n else {\n var buf = this.buf;\n for (var j = 0; j < count; ++j, pos += 8) array[i++] = util.float.readDoubleLE(buf, pos);\n }\n this.pos = pos;\n if (pos !== end) throw indexOutOfRange(this, 8);\n return array;\n};\n\n/**\n * Reads a packed repeated field of unsigned 64 bit varints.\n * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted\n * @returns {Array.<Long|number>} Array read into\n */\nReader.prototype.uint64s = function read_uint64s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.uint64());\n return array;\n};\n\n/**\n * Reads a packed repeated field of signed 64 bit varints.\n * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted\n * @returns {Array.<Long|number>} Array read into\n */\nReader.prototype.int64s = function read_int64s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.int64());\n return array;\n};\n\n/**\n * Reads a packed repeated field of zig-zag encoded signed 64 bit varints.\n * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted\n * @returns {Array.<Long|number>} Array read into\n */\nReader.prototype.sint64s = function read_sint64s(array) {\n if (array === undefined) array = [];\n var end = this.uint32() + this.pos;\n while (this.pos < end)\n array.push(this.sint64());\n return array;\n};\n\n/**\n * Reads a packed repeated field of unsigned 64 bit fixed values.\n * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted\n * @returns {Array.<Long|number>} Array read into\n */\nReader.prototype.fixed64s = function read_fixed64s(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len, i = array.length;\n /* istanbul ignore if */\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 3;\n array.length = i + count; // 8 bytes per value, count is known\n for (var j = 0; j < count; ++j)\n array[i++] = this.fixed64();\n if (this.pos !== end) throw indexOutOfRange(this, 8);\n return array;\n};\n\n/**\n * Reads a packed repeated field of signed 64 bit fixed values.\n * @param {Array.<Long|number>} [array] Array to read into; a new one is created if omitted\n * @returns {Array.<Long|number>} Array read into\n */\nReader.prototype.sfixed64s = function read_sfixed64s(array) {\n if (array === undefined) array = [];\n var len = this.uint32(), end = this.pos + len, i = array.length;\n /* istanbul ignore if */\n if (end > this.len) throw indexOutOfRange(this, len);\n var count = len >>> 3;\n array.length = i + count; // 8 bytes per value, count is known\n for (var j = 0; j < count; ++j)\n array[i++] = this.sfixed64();\n if (this.pos !== end) throw indexOutOfRange(this, 8);\n return array;\n};\n\n/**\n * Reads a sequence of bytes preceeded by its length as a varint.\n * @returns {Uint8Array} Value read\n */\nReader.prototype.bytes = function read_bytes() {\n var length = this.uint32(),\n start = this.pos,\n end = this.pos + length;\n\n /* istanbul ignore if */\n if (end > this.len)\n throw indexOutOfRange(this, length);\n\n this.pos = end;\n return this.raw(start, end);\n};\n\n/**\n * Reads a string preceeded by its byte length as a varint.\n * @returns {string} Value read\n */\nReader.prototype.string = function read_string() {\n var length = this.uint32(),\n start = this.pos,\n end = this.pos + length;\n\n /* istanbul ignore if */\n if (end > this.len)\n throw indexOutOfRange(this, length);\n\n this.pos = end;\n return utf8.read(this.buf, start, end);\n};\n\n/**\n * Reads a string preceeded by its byte length as a varint, rejecting invalid UTF8.\n * @returns {string} Value read\n */\nReader.prototype.stringVerify = function read_string_verify() {\n var length = this.uint32(),\n start = this.pos,\n end = this.pos + length;\n\n /* istanbul ignore if */\n if (end > this.len)\n throw indexOutOfRange(this, length);\n\n this.pos = end;\n return utf8.readStrict(this.buf, start, end);\n};\n\n/**\n * Skips the specified number of bytes if specified, otherwise skips a varint.\n * @param {number} [length] Length if known, otherwise a varint is assumed\n * @returns {Reader} `this`\n */\nReader.prototype.skip = function skip(length) {\n if (typeof length === \"number\") {\n /* istanbul ignore if */\n if (this.pos + length > this.len)\n throw indexOutOfRange(this, length);\n this.pos += length;\n } else {\n do {\n /* istanbul ignore if */\n if (this.pos >= this.len)\n throw indexOutOfRange(this);\n } while (this.buf[this.pos++] & 128);\n }\n return this;\n};\n\n/**\n * Recursion limit.\n * @type {number}\n */\nReader.recursionLimit = util.recursionLimit;\n\n/**\n * Whether readers discard unknown fields while decoding.\n * @type {boolean}\n */\nReader.discardUnknown = true;\n\n/**\n * Skips the next element of the specified wire type.\n * @param {number} wireType Wire type received\n * @param {number} [depth] Depth of recursion to control nested calls; 0 if omitted\n * @param {number} [fieldNumber] Field number for validating group end tags\n * @returns {Reader} `this`\n */\nReader.prototype.skipType = function(wireType, depth, fieldNumber) {\n if (depth === undefined) depth = 0;\n if (depth > Reader.recursionLimit)\n throw Error(\"max depth exceeded\");\n if (fieldNumber === 0)\n throw Error(\"illegal tag: field number 0\");\n switch (wireType) {\n case 0:\n this.skip();\n break;\n case 1:\n this.skip(8);\n break;\n case 2:\n this.skip(this.uint32());\n break;\n case 3:\n while (true) {\n var tag = this.tag();\n var nestedField = tag >>> 3;\n wireType = tag & 7;\n if (!nestedField)\n throw Error(\"illegal tag: field number 0\");\n if (wireType === 4) {\n if (fieldNumber !== undefined && nestedField !== fieldNumber)\n throw Error(\"invalid end group tag\");\n break;\n }\n this.skipType(wireType, depth + 1, nestedField);\n }\n break;\n case 5:\n this.skip(4);\n break;\n\n /* istanbul ignore next */\n default:\n throw Error(\"invalid wire type \" + wireType + \" at offset \" + this.pos);\n }\n return this;\n};\n\nReader._configure = function(BufferReader_) {\n BufferReader = BufferReader_;\n Reader.create = create();\n BufferReader._configure();\n\n var fn = util.Long ? \"toLong\" : /* istanbul ignore next */ \"toNumber\";\n util.merge(Reader.prototype, {\n\n int64: function read_int64() {\n return readLongVarint.call(this)[fn](false);\n },\n\n uint64: function read_uint64() {\n return readLongVarint.call(this)[fn](true);\n },\n\n sint64: function read_sint64() {\n return readLongVarint.call(this).zzDecode()[fn](false);\n },\n\n fixed64: function read_fixed64() {\n return readFixed64.call(this)[fn](true);\n },\n\n sfixed64: function read_sfixed64() {\n return readFixed64.call(this)[fn](false);\n }\n\n });\n};\n","\"use strict\";\nmodule.exports = BufferReader;\n\n// extends Reader\nvar Reader = require(18);\nBufferReader.prototype = Object.create(Reader.prototype, {\n constructor: {\n value: BufferReader,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\n\nvar util = require(37);\n\n/**\n * Constructs a new buffer reader instance.\n * @classdesc Wire format reader using node buffers.\n * @extends Reader\n * @constructor\n * @param {Buffer} buffer Buffer to read from\n */\nfunction BufferReader(buffer) {\n Reader.call(this, buffer);\n\n /**\n * Read buffer.\n * @name BufferReader#buf\n * @type {Buffer}\n */\n}\n\nBufferReader._configure = function () {\n /* istanbul ignore else */\n if (util.Buffer)\n BufferReader.prototype._slice = util.Buffer.prototype.slice;\n};\n\n/**\n * Returns raw bytes from the backing buffer without advancing the reader.\n * @name BufferReader#raw\n * @function\n * @param {number} start Start offset\n * @param {number} end End offset\n * @returns {Buffer} Raw bytes\n */\nBufferReader.prototype.raw = function read_raw_buffer(start, end) {\n return this._slice.call(this.buf, start, end);\n};\n\n/**\n * @override\n */\nBufferReader.prototype.string = function read_string_buffer() {\n var len = this.uint32(), // modifies pos\n start = this.pos,\n end = this.pos + len;\n\n /* istanbul ignore if */\n if (end > this.len)\n throw RangeError(\"index out of range: \" + this.pos + \" + \" + len + \" > \" + this.len);\n\n this.pos = end;\n return this.buf.utf8Slice\n ? this.buf.utf8Slice(start, end)\n : this.buf.toString(\"utf-8\", start, end);\n};\n\n/**\n * Reads a sequence of bytes preceeded by its length as a varint.\n * @name BufferReader#bytes\n * @function\n * @returns {Buffer} Value read\n */\n\nBufferReader._configure();\n","\"use strict\";\nmodule.exports = Root;\n\n// extends Namespace\nvar Namespace = require(14);\nRoot.prototype = Object.create(Namespace.prototype, {\n constructor: {\n value: Root,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\nRoot.className = \"Root\";\n\nvar Field = require(7),\n Enum = require(6),\n OneOf = require(16),\n util = require(28);\n\nvar Type, // cyclic\n parse, // might be excluded\n common; // \"\n\n/**\n * Constructs a new root namespace instance.\n * @classdesc Root namespace wrapping all types, enums, services, sub-namespaces etc. that belong together.\n * @extends NamespaceBase\n * @constructor\n * @param {Object.<string,*>} [options] Top level options\n */\nfunction Root(options) {\n Namespace.call(this, \"\", options);\n\n /**\n * Deferred extension fields.\n * @type {Field[]}\n */\n this.deferred = [];\n\n /**\n * Resolved file names of loaded files.\n * @type {string[]}\n */\n this.files = [];\n\n /**\n * Edition, defaults to proto2 if unspecified.\n * @type {string}\n * @private\n */\n this._edition = \"proto2\";\n\n /**\n * Global lookup cache of fully qualified names.\n * @type {Object.<string,ReflectionObject>}\n * @private\n */\n this._fullyQualifiedObjects = {};\n}\n\n/**\n * Loads a namespace descriptor into a root namespace.\n * @param {INamespace} json Namespace descriptor\n * @param {Root} [root] Root namespace, defaults to create a new one if omitted\n * @param {number} [depth] Current nesting depth, defaults to `0`\n * @returns {Root} Root namespace\n */\nRoot.fromJSON = function fromJSON(json, root, depth) {\n if (depth === undefined)\n depth = 0;\n if (depth > util.recursionLimit)\n throw Error(\"max depth exceeded\");\n if (!root)\n root = new Root();\n if (json.options)\n root.setOptions(json.options);\n return root.addJSON(json.nested, depth).resolveAll();\n};\n\n/**\n * Resolves the path of an imported file, relative to the importing origin.\n * This method exists so you can override it with your own logic in case your imports are scattered over multiple directories.\n * @function\n * @param {string} origin The file name of the importing file\n * @param {string} target The file name being imported\n * @returns {string|null} Resolved path to `target` or `null` to skip the file\n */\nRoot.prototype.resolvePath = util.path.resolve;\n\n/**\n * Fetch content from file path or url\n * This method exists so you can override it with your own logic.\n * @function\n * @param {string} path File path or url\n * @param {FetchCallback} callback Callback function\n * @returns {undefined}\n */\nRoot.prototype.fetch = util.fetch;\n\n// A symbol-like function to safely signal synchronous loading\n/* istanbul ignore next */\nfunction SYNC() {} // eslint-disable-line no-empty-function\n\n/**\n * Loads one or multiple .proto or preprocessed .json files into this root namespace and calls the callback.\n * @param {string|string[]} filename Names of one or multiple files to load\n * @param {IParseOptions} options Parse options\n * @param {LoadCallback} callback Callback function\n * @returns {undefined}\n */\nRoot.prototype.load = function load(filename, options, callback) {\n if (typeof options === \"function\") {\n callback = options;\n options = undefined;\n }\n var self = this;\n if (!callback) {\n return util.asPromise(load, self, filename, options);\n }\n\n var sync = callback === SYNC; // undocumented\n\n // Finishes loading by calling the callback (exactly once)\n function finish(err, root) {\n /* istanbul ignore if */\n if (!callback) {\n return;\n }\n if (sync) {\n throw err;\n }\n if (root) {\n root.resolveAll();\n }\n var cb = callback;\n callback = null;\n cb(err, root);\n }\n\n // Bundled definition existence checking\n function getBundledFileName(filename) {\n var idx = filename.lastIndexOf(\"google/protobuf/\");\n if (idx > -1) {\n var altname = filename.substring(idx);\n if (Object.prototype.hasOwnProperty.call(common, altname)) return altname;\n }\n if (Object.prototype.hasOwnProperty.call(common, filename)) return filename;\n return null;\n }\n\n // Processes a single file\n function process(filename, source, depth) {\n if (depth === undefined)\n depth = 0;\n try {\n if (depth > util.recursionLimit)\n throw Error(\"max depth exceeded\");\n if (util.isString(source) && source.charAt(0) === \"{\")\n source = JSON.parse(source);\n if (!util.isString(source))\n self.setOptions(source.options).addJSON(source.nested);\n else {\n parse.filename = filename;\n var parsed = parse(source, self, options),\n resolved,\n i = 0;\n if (parsed.imports)\n for (; i < parsed.imports.length; ++i)\n if (resolved = getBundledFileName(parsed.imports[i]) || self.resolvePath(filename, parsed.imports[i]))\n fetch(resolved, false, depth + 1);\n if (parsed.weakImports)\n for (i = 0; i < parsed.weakImports.length; ++i)\n if (resolved = getBundledFileName(parsed.weakImports[i]) || self.resolvePath(filename, parsed.weakImports[i]))\n fetch(resolved, true, depth + 1);\n }\n } catch (err) {\n finish(err);\n }\n if (!sync && !queued) {\n finish(null, self); // only once anyway\n }\n }\n\n // Fetches a single file\n function fetch(filename, weak, depth) {\n if (depth === undefined)\n depth = 0;\n filename = getBundledFileName(filename) || filename;\n\n // Skip if already loaded / attempted\n if (self.files.indexOf(filename) > -1) {\n return;\n }\n self.files.push(filename);\n\n // Shortcut bundled definitions\n if (Object.prototype.hasOwnProperty.call(common, filename)) {\n if (sync) {\n process(filename, common[filename], depth);\n } else {\n ++queued;\n setTimeout(function() {\n --queued;\n process(filename, common[filename], depth);\n });\n }\n return;\n }\n\n // Otherwise fetch from disk or network\n if (sync) {\n var source;\n try {\n source = util.fs.readFileSync(filename).toString(\"utf8\");\n } catch (err) {\n if (!weak)\n finish(err);\n return;\n }\n process(filename, source, depth);\n } else {\n ++queued;\n self.fetch(filename, function(err, source) {\n --queued;\n /* istanbul ignore if */\n if (!callback) {\n return; // terminated meanwhile\n }\n if (err) {\n /* istanbul ignore else */\n if (!weak)\n finish(err);\n else if (!queued) // can't be covered reliably\n finish(null, self);\n return;\n }\n process(filename, source, depth);\n });\n }\n }\n var queued = 0;\n\n // Assembling the root namespace doesn't require working type\n // references anymore, so we can load everything in parallel\n if (util.isString(filename)) {\n filename = [ filename ];\n }\n for (var i = 0, resolved; i < filename.length; ++i)\n if (resolved = self.resolvePath(\"\", filename[i]))\n fetch(resolved);\n if (sync) {\n self.resolveAll();\n return self;\n }\n if (!queued) {\n finish(null, self);\n }\n\n return self;\n};\n// function load(filename:string, options:IParseOptions, callback:LoadCallback):undefined\n\n/**\n * Loads one or multiple .proto or preprocessed .json files into this root namespace and calls the callback.\n * @function Root#load\n * @param {string|string[]} filename Names of one or multiple files to load\n * @param {LoadCallback} callback Callback function\n * @returns {undefined}\n * @variation 2\n */\n// function load(filename:string, callback:LoadCallback):undefined\n\n/**\n * Loads one or multiple .proto or preprocessed .json files into this root namespace and returns a promise.\n * @function Root#load\n * @param {string|string[]} filename Names of one or multiple files to load\n * @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.\n * @returns {Promise<Root>} Promise\n * @variation 3\n */\n// function load(filename:string, [options:IParseOptions]):Promise<Root>\n\n/**\n * Synchronously loads one or multiple .proto or preprocessed .json files into this root namespace (node only).\n * @function Root#loadSync\n * @param {string|string[]} filename Names of one or multiple files to load\n * @param {IParseOptions} [options] Parse options. Defaults to {@link parse.defaults} when omitted.\n * @returns {Root} Root namespace\n * @throws {Error} If synchronous fetching is not supported (i.e. in browsers) or if a file's syntax is invalid\n */\nRoot.prototype.loadSync = function loadSync(filename, options) {\n if (!util.isNode)\n throw Error(\"not supported\");\n return this.load(filename, options, SYNC);\n};\n\n/**\n * @override\n */\nRoot.prototype.resolveAll = function resolveAll() {\n if (!this._needsRecursiveResolve) return this;\n\n if (this.deferred.length)\n throw Error(\"unresolvable extensions: \" + this.deferred.map(function(field) {\n return \"'extend \" + field.extend + \"' in \" + field.parent.fullName;\n }).join(\", \"));\n return Namespace.prototype.resolveAll.call(this);\n};\n\n// only uppercased (and thus conflict-free) children are exposed, see below\nvar exposeRe = /^[A-Z]/;\n\n/**\n * Handles a deferred declaring extension field by creating a sister field to represent it within its extended type.\n * @param {Root} root Root instance\n * @param {Field} field Declaring extension field witin the declaring type\n * @returns {boolean} `true` if successfully added to the extended type, `false` otherwise\n * @inner\n * @ignore\n */\nfunction tryHandleExtension(root, field) {\n var extendedType = field.parent.lookup(field.extend);\n if (extendedType) {\n var sisterField = new Field(field.fullName, field.id, field.type, field.rule, undefined, field.options);\n //do not allow to extend same field twice to prevent the error\n if (extendedType.get(sisterField.name)) {\n return true;\n }\n sisterField.declaringField = field;\n field.extensionField = sisterField;\n extendedType.add(sisterField);\n return true;\n }\n return false;\n}\n\n/**\n * Called when any object is added to this root or its sub-namespaces.\n * @param {ReflectionObject} object Object added\n * @returns {undefined}\n * @private\n */\nRoot.prototype._handleAdd = function _handleAdd(object) {\n if (object instanceof Field) {\n\n if (/* an extension field (implies not part of a oneof) */ object.extend !== undefined && /* not already handled */ !object.extensionField)\n if (!tryHandleExtension(this, object))\n this.deferred.push(object);\n\n } else if (object instanceof Enum) {\n\n if (exposeRe.test(object.name))\n object.parent[object.name] = object.values; // expose enum values as property of its parent\n\n } else if (!(object instanceof OneOf)) /* everything else is a namespace */ {\n\n if (object instanceof Type) // Try to handle any deferred extensions\n for (var i = 0; i < this.deferred.length;)\n if (tryHandleExtension(this, this.deferred[i]))\n this.deferred.splice(i, 1);\n else\n ++i;\n for (var j = 0; j < /* initializes */ object.nestedArray.length; ++j) // recurse into the namespace\n this._handleAdd(object._nestedArray[j]);\n if (exposeRe.test(object.name))\n object.parent[object.name] = object; // expose namespace as property of its parent\n }\n\n if (object instanceof Type || object instanceof Enum || object instanceof Field) {\n // Only store types and enums for quick lookup during resolve.\n this._fullyQualifiedObjects[object.fullName] = object;\n }\n\n // The above also adds uppercased (and thus conflict-free) nested types, services and enums as\n // properties of namespaces just like static code does. This allows using a .d.ts generated for\n // a static module with reflection-based solutions where the condition is met.\n};\n\n/**\n * Called when any object is removed from this root or its sub-namespaces.\n * @param {ReflectionObject} object Object removed\n * @returns {undefined}\n * @private\n */\nRoot.prototype._handleRemove = function _handleRemove(object) {\n if (object instanceof Field) {\n\n if (/* an extension field */ object.extend !== undefined) {\n if (/* already handled */ object.extensionField) { // remove its sister field\n object.extensionField.parent.remove(object.extensionField);\n object.extensionField = null;\n } else { // cancel the extension\n var index = this.deferred.indexOf(object);\n /* istanbul ignore else */\n if (index > -1)\n this.deferred.splice(index, 1);\n }\n }\n\n } else if (object instanceof Enum) {\n\n if (exposeRe.test(object.name))\n delete object.parent[object.name]; // unexpose enum values\n\n } else if (object instanceof Namespace) {\n\n for (var i = 0; i < /* initializes */ object.nestedArray.length; ++i) // recurse into the namespace\n this._handleRemove(object._nestedArray[i]);\n\n if (exposeRe.test(object.name))\n delete object.parent[object.name]; // unexpose namespaces\n\n }\n\n delete this._fullyQualifiedObjects[object.fullName];\n};\n\n// Sets up cyclic dependencies (called in index-light)\nRoot._configure = function(Type_, parse_, common_) {\n Type = Type_;\n parse = parse_;\n common = common_;\n};\n","\"use strict\";\nmodule.exports = Object.create(null);\n\n/**\n * Named roots.\n * This is where pbjs stores generated structures (the option `-r, --root` specifies a name).\n * Can also be used manually to make roots available across modules.\n * @name roots\n * @type {Object.<string,Root>}\n * @example\n * // pbjs -r myroot -o compiled.js ...\n *\n * // in another module:\n * require(\"./compiled.js\");\n *\n * // in any subsequent module:\n * var root = protobuf.roots[\"myroot\"];\n */\n","\"use strict\";\n\n/**\n * Streaming RPC helpers.\n * @namespace\n */\nvar rpc = exports;\n\n/**\n * RPC implementation passed to {@link Service#create} performing a service request on network level, i.e. by utilizing http requests or websockets.\n * @typedef RPCImpl\n * @type {function}\n * @param {Method|rpc.ServiceMethod<Message<{}>,Message<{}>>} method Reflected or static method being called\n * @param {Uint8Array} requestData Request data\n * @param {RPCImplCallback} callback Callback function\n * @returns {undefined}\n * @example\n * function rpcImpl(method, requestData, callback) {\n * if (protobuf.util.lcFirst(method.name) !== \"myMethod\") // compatible with static code\n * throw Error(\"no such method\");\n * asynchronouslyObtainAResponse(requestData, function(err, responseData) {\n * callback(err, responseData);\n * });\n * }\n */\n\n/**\n * Node-style callback as used by {@link RPCImpl}.\n * @typedef RPCImplCallback\n * @type {function}\n * @param {Error|null} error Error, if any, otherwise `null`\n * @param {Uint8Array|null} [response] Response data or `null` to signal end of stream, if there hasn't been an error\n * @returns {undefined}\n */\n\nrpc.Service = require(23);\n","\"use strict\";\nmodule.exports = Service;\n\nvar util = require(37);\n\n// Extends EventEmitter\nService.prototype = Object.create(util.EventEmitter.prototype, {\n constructor: {\n value: Service,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\n\n/**\n * A service method callback as used by {@link rpc.ServiceMethod|ServiceMethod}.\n *\n * Differs from {@link RPCImplCallback} in that it is an actual callback of a service method which may not return `response = null`.\n * @typedef rpc.ServiceMethodCallback\n * @template TRes extends Message<TRes>\n * @type {function}\n * @param {Error|null} error Error, if any\n * @param {TRes} [response] Response message\n * @returns {undefined}\n */\n\n/**\n * A service method part of a {@link rpc.Service} as created by {@link Service.create}.\n * @typedef rpc.ServiceMethod\n * @template TReq extends Message<TReq>\n * @template TRes extends Message<TRes>\n * @type {{\n * (request: TReq|Properties<TReq>, callback: rpc.ServiceMethodCallback<TRes>): void;\n * (request: TReq|Properties<TReq>): Promise<TRes>;\n * readonly name: string;\n * readonly path: string;\n * readonly requestType: string;\n * readonly responseType: string;\n * readonly requestStream: true|undefined;\n * readonly responseStream: true|undefined;\n * }}\n */\n\n/**\n * Constructs a new RPC service instance.\n * @classdesc An RPC service as returned by {@link Service#create}.\n * @exports rpc.Service\n * @extends util.EventEmitter\n * @constructor\n * @param {RPCImpl} rpcImpl RPC implementation\n * @param {boolean} [requestDelimited=false] Whether requests are length-delimited\n * @param {boolean} [responseDelimited=false] Whether responses are length-delimited\n */\nfunction Service(rpcImpl, requestDelimited, responseDelimited) {\n\n if (typeof rpcImpl !== \"function\")\n throw TypeError(\"rpcImpl must be a function\");\n\n util.EventEmitter.call(this);\n\n /**\n * RPC implementation. Becomes `null` once the service is ended.\n * @type {RPCImpl|null}\n */\n this.rpcImpl = rpcImpl;\n\n /**\n * Whether requests are length-delimited.\n * @type {boolean}\n */\n this.requestDelimited = Boolean(requestDelimited);\n\n /**\n * Whether responses are length-delimited.\n * @type {boolean}\n */\n this.responseDelimited = Boolean(responseDelimited);\n}\n\n/**\n * Calls a service method through {@link rpc.Service#rpcImpl|rpcImpl}.\n * @param {Method|rpc.ServiceMethod<TReq,TRes>} method Reflected or static method\n * @param {Constructor<TReq>} requestCtor Request constructor\n * @param {Constructor<TRes>} responseCtor Response constructor\n * @param {TReq|Properties<TReq>} request Request message or plain object\n * @param {rpc.ServiceMethodCallback<TRes>} callback Service callback\n * @returns {undefined}\n * @template TReq extends Message<TReq>\n * @template TRes extends Message<TRes>\n */\nService.prototype.rpcCall = function rpcCall(method, requestCtor, responseCtor, request, callback) {\n\n if (!request)\n throw TypeError(\"request must be specified\");\n\n var self = this;\n if (!callback)\n return util.asPromise(rpcCall, self, method, requestCtor, responseCtor, request);\n\n if (!self.rpcImpl) {\n setTimeout(function() { callback(Error(\"already ended\")); }, 0);\n return undefined;\n }\n\n try {\n return self.rpcImpl(\n method,\n requestCtor[self.requestDelimited ? \"encodeDelimited\" : \"encode\"](request).finish(),\n function rpcCallback(err, response) {\n\n if (err) {\n self.emit(\"error\", err, method);\n return callback(err);\n }\n\n if (response === null) {\n self.end(/* endedByRPC */ true);\n return undefined;\n }\n\n if (!(response instanceof responseCtor)) {\n try {\n response = responseCtor[self.responseDelimited ? \"decodeDelimited\" : \"decode\"](response);\n } catch (err) {\n self.emit(\"error\", err, method);\n return callback(err);\n }\n }\n\n self.emit(\"data\", response, method);\n return callback(null, response);\n }\n );\n } catch (err) {\n self.emit(\"error\", err, method);\n setTimeout(function() { callback(err); }, 0);\n return undefined;\n }\n};\n\n/**\n * Ends this service and emits the `end` event.\n * @param {boolean} [endedByRPC=false] Whether the service has been ended by the RPC implementation.\n * @returns {rpc.Service} `this`\n */\nService.prototype.end = function end(endedByRPC) {\n if (this.rpcImpl) {\n if (!endedByRPC) // signal end to rpcImpl\n this.rpcImpl(null, null, null);\n this.rpcImpl = null;\n this.emit(\"end\").off();\n }\n return this;\n};\n","\"use strict\";\nmodule.exports = Service;\n\n// extends Namespace\nvar Namespace = require(14);\nService.prototype = Object.create(Namespace.prototype, {\n constructor: {\n value: Service,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\nService.className = \"Service\";\n\nvar Method = require(13),\n util = require(28),\n rpc = require(22);\n\n/**\n * Constructs a new service instance.\n * @classdesc Reflected service.\n * @extends NamespaceBase\n * @constructor\n * @param {string} name Service name\n * @param {Object.<string,*>} [options] Service options\n * @throws {TypeError} If arguments are invalid\n */\nfunction Service(name, options) {\n Namespace.call(this, name, options);\n\n /**\n * Service methods.\n * @type {Object.<string,Method>}\n */\n this.methods = {}; // toJSON, marker\n\n /**\n * Cached methods as an array.\n * @type {Method[]|null}\n * @private\n */\n this._methodsArray = null;\n}\n\n/**\n * Service descriptor.\n * @interface IService\n * @extends INamespace\n * @property {string} [edition] Edition\n * @property {Object.<string,IMethod>} methods Method descriptors\n * @property {string|null} [comment] Service comment\n */\n\n/**\n * Constructs a service from a service descriptor.\n * @param {string} name Service name\n * @param {IService} json Service descriptor\n * @param {number} [depth] Current nesting depth, defaults to `0`\n * @returns {Service} Created service\n * @throws {TypeError} If arguments are invalid\n */\nService.fromJSON = function fromJSON(name, json, depth) {\n if (depth === undefined)\n depth = 0;\n if (depth > util.recursionLimit)\n throw Error(\"max depth exceeded\");\n var service = new Service(name, json.options);\n /* istanbul ignore else */\n if (json.methods)\n for (var names = Object.keys(json.methods), i = 0; i < names.length; ++i)\n service.add(Method.fromJSON(names[i], json.methods[names[i]]));\n if (json.nested)\n service.addJSON(json.nested, depth);\n if (json.edition)\n service._edition = json.edition;\n service.comment = json.comment;\n service._defaultEdition = \"proto3\"; // For backwards-compatibility.\n return service;\n};\n\n/**\n * Converts this service to a service descriptor.\n * @param {IToJSONOptions} [toJSONOptions] JSON conversion options\n * @returns {IService} Service descriptor\n */\nService.prototype.toJSON = function toJSON(toJSONOptions) {\n var inherited = Namespace.prototype.toJSON.call(this, toJSONOptions);\n var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;\n return util.toObject([\n \"edition\" , this._editionToJSON(),\n \"options\" , inherited && inherited.options || undefined,\n \"methods\" , Namespace.arrayToJSON(this.methodsArray, toJSONOptions) || /* istanbul ignore next */ {},\n \"nested\" , inherited && inherited.nested || undefined,\n \"comment\" , keepComments ? this.comment : undefined\n ]);\n};\n\n/**\n * Methods of this service as an array for iteration.\n * @name Service#methodsArray\n * @type {Method[]}\n * @readonly\n */\nObject.defineProperty(Service.prototype, \"methodsArray\", {\n get: function() {\n return this._methodsArray || (this._methodsArray = util.toArray(this.methods));\n }\n});\n\nfunction clearCache(service) {\n service._methodsArray = null;\n return service;\n}\n\n/**\n * @override\n */\nService.prototype.get = function get(name) {\n return Object.prototype.hasOwnProperty.call(this.methods, name)\n ? this.methods[name]\n : Namespace.prototype.get.call(this, name);\n};\n\n/**\n * @override\n */\nService.prototype.resolveAll = function resolveAll() {\n if (!this._needsRecursiveResolve) return this;\n\n Namespace.prototype.resolve.call(this);\n var methods = this.methodsArray;\n for (var i = 0; i < methods.length; ++i)\n methods[i].resolve();\n return this;\n};\n\n/**\n * @override\n */\nService.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursive(edition) {\n if (!this._needsRecursiveFeatureResolution) return this;\n\n edition = this._edition || edition;\n\n Namespace.prototype._resolveFeaturesRecursive.call(this, edition);\n this.methodsArray.forEach(method => {\n method._resolveFeaturesRecursive(edition);\n });\n return this;\n};\n\n/**\n * @override\n */\nService.prototype.add = function add(object) {\n /* istanbul ignore if */\n if (this.get(object.name))\n throw Error(\"duplicate name '\" + object.name + \"' in \" + this);\n\n if (object instanceof Method) {\n if (object.name === \"__proto__\")\n return this;\n this.methods[object.name] = object;\n object.parent = this;\n return clearCache(this);\n }\n return Namespace.prototype.add.call(this, object);\n};\n\n/**\n * @override\n */\nService.prototype.remove = function remove(object) {\n if (object instanceof Method) {\n\n /* istanbul ignore if */\n if (this.methods[object.name] !== object)\n throw Error(object + \" is not a member of \" + this);\n\n delete this.methods[object.name];\n object.parent = null;\n return clearCache(this);\n }\n return Namespace.prototype.remove.call(this, object);\n};\n\n/**\n * Creates a runtime service using the specified rpc implementation.\n * @param {RPCImpl} rpcImpl RPC implementation\n * @param {boolean} [requestDelimited=false] Whether requests are length-delimited\n * @param {boolean} [responseDelimited=false] Whether responses are length-delimited\n * @returns {rpc.Service} RPC service. Useful where requests and/or responses are streamed.\n */\nService.prototype.create = function create(rpcImpl, requestDelimited, responseDelimited) {\n var rpcService = new rpc.Service(rpcImpl, requestDelimited, responseDelimited);\n for (var i = 0, method; i < /* initializes */ this.methodsArray.length; ++i) {\n var methodName = util.lcFirst((method = this._methodsArray[i]).resolve().name).replace(/[^$\\w_]/g, \"\");\n rpcService[methodName] = (function(method, requestType, responseType) {\n return function rpcMethod(request, callback) {\n return rpc.Service.prototype.rpcCall.call(this, method, requestType, responseType, request, callback);\n };\n })(method, method.resolvedRequestType.ctor, method.resolvedResponseType.ctor);\n }\n return rpcService;\n};\n","\"use strict\";\nmodule.exports = tokenize;\n\nvar delimRe = /[\\s{}=;:[\\],'\"()<>]/g,\n stringDoubleRe = /(?:\"([^\"\\\\]*(?:\\\\.[^\"\\\\]*)*)\")/g,\n stringSingleRe = /(?:'([^'\\\\]*(?:\\\\.[^'\\\\]*)*)')/g;\n\nvar setCommentRe = /^ *[*/]+ */,\n setCommentAltRe = /^\\s*\\*?\\/*/,\n setCommentSplitRe = /\\n/g,\n whitespaceRe = /\\s/,\n unescapeRe = /\\\\(.?)/g;\n\nvar unescapeMap = {\n \"0\": \"\\0\",\n \"r\": \"\\r\",\n \"n\": \"\\n\",\n \"t\": \"\\t\"\n};\n\n/**\n * Unescapes a string.\n * @param {string} str String to unescape\n * @returns {string} Unescaped string\n * @property {Object.<string,string>} map Special characters map\n * @memberof tokenize\n */\nfunction unescape(str) {\n return str.replace(unescapeRe, function($0, $1) {\n switch ($1) {\n case \"\\\\\":\n case \"\":\n return $1;\n default:\n return unescapeMap[$1] || \"\";\n }\n });\n}\n\ntokenize.unescape = unescape;\n\n/**\n * Gets the next token and advances.\n * @typedef TokenizerHandleNext\n * @type {function}\n * @returns {string|null} Next token or `null` on eof\n */\n\n/**\n * Peeks for the next token.\n * @typedef TokenizerHandlePeek\n * @type {function}\n * @returns {string|null} Next token or `null` on eof\n */\n\n/**\n * Pushes a token back to the stack.\n * @typedef TokenizerHandlePush\n * @type {function}\n * @param {string} token Token\n * @returns {undefined}\n */\n\n/**\n * Skips the next token.\n * @typedef TokenizerHandleSkip\n * @type {function}\n * @param {string} expected Expected token\n * @param {boolean} [optional=false] If optional\n * @returns {boolean} Whether the token matched\n * @throws {Error} If the token didn't match and is not optional\n */\n\n/**\n * Gets the comment on the previous line or, alternatively, the line comment on the specified line.\n * @typedef TokenizerHandleCmnt\n * @type {function}\n * @param {number} [line] Line number\n * @returns {string|null} Comment text or `null` if none\n */\n\n/**\n * Handle object returned from {@link tokenize}.\n * @interface ITokenizerHandle\n * @property {TokenizerHandleNext} next Gets the next token and advances (`null` on eof)\n * @property {TokenizerHandlePeek} peek Peeks for the next token (`null` on eof)\n * @property {TokenizerHandlePush} push Pushes a token back to the stack\n * @property {TokenizerHandleSkip} skip Skips a token, returns its presence and advances or, if non-optional and not present, throws\n * @property {TokenizerHandleCmnt} cmnt Gets the comment on the previous line or the line comment on the specified line, if any\n * @property {number} line Current line number\n */\n\n/**\n * Tokenizes the given .proto source and returns an object with useful utility functions.\n * @param {string} source Source contents\n * @param {boolean} alternateCommentMode Whether we should activate alternate comment parsing mode.\n * @returns {ITokenizerHandle} Tokenizer handle\n */\nfunction tokenize(source, alternateCommentMode) {\n /* eslint-disable callback-return */\n source = source.toString();\n\n var offset = 0,\n length = source.length,\n line = 1,\n lastCommentLine = 0,\n comments = {};\n\n var stack = [];\n\n var stringDelim = null;\n\n /* istanbul ignore next */\n /**\n * Creates an error for illegal syntax.\n * @param {string} subject Subject\n * @returns {Error} Error created\n * @inner\n */\n function illegal(subject) {\n return Error(\"illegal \" + subject + \" (line \" + line + \")\");\n }\n\n /**\n * Reads a string till its end.\n * @returns {string} String read\n * @inner\n */\n function readString() {\n var re = stringDelim === \"'\" ? stringSingleRe : stringDoubleRe;\n re.lastIndex = offset - 1;\n var match = re.exec(source);\n if (!match)\n throw illegal(\"string\");\n offset = re.lastIndex;\n push(stringDelim);\n stringDelim = null;\n return unescape(match[1]);\n }\n\n /**\n * Gets the character at `pos` within the source.\n * @param {number} pos Position\n * @returns {string} Character\n * @inner\n */\n function charAt(pos) {\n return source.charAt(pos);\n }\n\n /**\n * Sets the current comment text.\n * @param {number} start Start offset\n * @param {number} end End offset\n * @param {boolean} isLeading set if a leading comment\n * @returns {undefined}\n * @inner\n */\n function setComment(start, end, isLeading) {\n var comment = {\n type: source.charAt(start++),\n lineEmpty: false,\n leading: isLeading,\n };\n var lookback;\n if (alternateCommentMode) {\n lookback = 2; // alternate comment parsing: \"//\" or \"/*\"\n } else {\n lookback = 3; // \"///\" or \"/**\"\n }\n var commentOffset = start - lookback,\n c;\n do {\n if (--commentOffset < 0 ||\n (c = source.charAt(commentOffset)) === \"\\n\") {\n comment.lineEmpty = true;\n break;\n }\n } while (c === \" \" || c === \"\\t\");\n var lines = source\n .substring(start, end)\n .split(setCommentSplitRe);\n for (var i = 0; i < lines.length; ++i)\n lines[i] = lines[i]\n .replace(alternateCommentMode ? setCommentAltRe : setCommentRe, \"\")\n .trim();\n comment.text = lines\n .join(\"\\n\")\n .trim();\n\n comments[line] = comment;\n lastCommentLine = line;\n }\n\n function isDoubleSlashCommentLine(startOffset) {\n var endOffset = findEndOfLine(startOffset);\n\n // see if remaining line matches comment pattern\n var lineText = source.substring(startOffset, endOffset);\n var isComment = /^\\s*\\/\\//.test(lineText);\n return isComment;\n }\n\n function findEndOfLine(cursor) {\n // find end of cursor's line\n var endOffset = cursor;\n while (endOffset < length && charAt(endOffset) !== \"\\n\") {\n endOffset++;\n }\n return endOffset;\n }\n\n /**\n * Obtains the next token.\n * @returns {string|null} Next token or `null` on eof\n * @inner\n */\n function next() {\n if (stack.length > 0)\n return stack.shift();\n if (stringDelim)\n return readString();\n var repeat,\n prev,\n curr,\n start,\n isDoc,\n nextLineIsComment,\n isLeadingComment = offset === 0;\n do {\n if (offset === length)\n return null;\n repeat = false;\n while (whitespaceRe.test(curr = charAt(offset))) {\n if (curr === \"\\n\") {\n isLeadingComment = true;\n ++line;\n }\n if (++offset === length)\n return null;\n }\n\n if (charAt(offset) === \"/\") {\n if (++offset === length) {\n throw illegal(\"comment\");\n }\n if (charAt(offset) === \"/\") { // Line\n if (!alternateCommentMode) {\n // check for triple-slash comment\n isDoc = charAt(start = offset + 1) === \"/\";\n\n while (charAt(++offset) !== \"\\n\") {\n if (offset === length) {\n return null;\n }\n }\n ++offset;\n if (isDoc) {\n setComment(start, offset - 1, isLeadingComment);\n // Trailing comment cannot not be multi-line,\n // so leading comment state should be reset to handle potential next comments\n isLeadingComment = true;\n }\n ++line;\n repeat = true;\n } else {\n // check for double-slash comments, consolidating consecutive lines\n start = offset;\n isDoc = false;\n if (isDoubleSlashCommentLine(offset - 1)) {\n isDoc = true;\n do {\n offset = findEndOfLine(offset);\n if (offset === length) {\n break;\n }\n offset++;\n if (!isLeadingComment) {\n // Trailing comment cannot not be multi-line\n break;\n }\n nextLineIsComment = isDoubleSlashCommentLine(offset);\n if (nextLineIsComment) {\n line++;\n }\n } while (nextLineIsComment);\n } else {\n offset = Math.min(length, findEndOfLine(offset) + 1);\n }\n if (isDoc) {\n setComment(start, offset, isLeadingComment);\n isLeadingComment = true;\n }\n line++;\n repeat = true;\n }\n } else if ((curr = charAt(offset)) === \"*\") { /* Block */\n // check for /** (regular comment mode) or /* (alternate comment mode)\n start = offset + 1;\n isDoc = alternateCommentMode || charAt(start) === \"*\";\n do {\n if (curr === \"\\n\") {\n ++line;\n }\n if (++offset === length) {\n throw illegal(\"comment\");\n }\n prev = curr;\n curr = charAt(offset);\n } while (prev !== \"*\" || curr !== \"/\");\n ++offset;\n if (isDoc) {\n setComment(start, offset - 2, isLeadingComment);\n isLeadingComment = true;\n }\n repeat = true;\n } else {\n return \"/\";\n }\n }\n } while (repeat);\n\n // offset !== length if we got here\n\n var end = offset;\n delimRe.lastIndex = 0;\n var delim = delimRe.test(charAt(end++));\n if (!delim)\n while (end < length && !delimRe.test(charAt(end)))\n ++end;\n var token = source.substring(offset, offset = end);\n if (token === \"\\\"\" || token === \"'\")\n stringDelim = token;\n return token;\n }\n\n /**\n * Pushes a token back to the stack.\n * @param {string} token Token\n * @returns {undefined}\n * @inner\n */\n function push(token) {\n stack.push(token);\n }\n\n /**\n * Peeks for the next token.\n * @returns {string|null} Token or `null` on eof\n * @inner\n */\n function peek() {\n if (!stack.length) {\n var token = next();\n if (token === null)\n return null;\n push(token);\n }\n return stack[0];\n }\n\n /**\n * Skips a token.\n * @param {string} expected Expected token\n * @param {boolean} [optional=false] Whether the token is optional\n * @returns {boolean} `true` when skipped, `false` if not\n * @throws {Error} When a required token is not present\n * @inner\n */\n function skip(expected, optional) {\n var actual = peek(),\n equals = actual === expected;\n if (equals) {\n next();\n return true;\n }\n if (!optional)\n throw illegal(\"token '\" + actual + \"', '\" + expected + \"' expected\");\n return false;\n }\n\n /**\n * Gets a comment.\n * @param {number} [trailingLine] Line number if looking for a trailing comment\n * @returns {string|null} Comment text\n * @inner\n */\n function cmnt(trailingLine) {\n var ret = null;\n var comment;\n if (trailingLine === undefined) {\n comment = comments[line - 1];\n delete comments[line - 1];\n if (comment && (alternateCommentMode || comment.type === \"*\" || comment.lineEmpty)) {\n ret = comment.leading ? comment.text : null;\n }\n } else {\n /* istanbul ignore else */\n if (lastCommentLine < trailingLine) {\n peek();\n }\n comment = comments[trailingLine];\n delete comments[trailingLine];\n if (comment && !comment.lineEmpty && (alternateCommentMode || comment.type === \"/\")) {\n ret = comment.leading ? null : comment.text;\n }\n }\n return ret;\n }\n\n return Object.defineProperty({\n next: next,\n peek: peek,\n push: push,\n skip: skip,\n cmnt: cmnt\n }, \"line\", {\n get: function() { return line; }\n });\n /* eslint-enable callback-return */\n}\n","\"use strict\";\nmodule.exports = Type;\n\n// extends Namespace\nvar Namespace = require(14);\nType.prototype = Object.create(Namespace.prototype, {\n constructor: {\n value: Type,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\nType.className = \"Type\";\n\nvar Enum = require(6),\n OneOf = require(16),\n Field = require(7),\n MapField = require(11),\n Service = require(24),\n Message = require(12),\n Reader = require(18),\n Writer = require(44),\n util = require(28),\n encoder = require(5),\n decoder = require(4),\n verifier = require(42),\n converter = require(3),\n wrappers = require(43);\n\n/**\n * Constructs a new reflected message type instance.\n * @classdesc Reflected message type.\n * @extends NamespaceBase\n * @constructor\n * @param {string} name Message name\n * @param {Object.<string,*>} [options] Declared options\n */\nfunction Type(name, options) {\n name = name.replace(/\\W/g, \"\");\n Namespace.call(this, name, options);\n\n /**\n * Message fields.\n * @type {Object.<string,Field>}\n */\n this.fields = {}; // toJSON, marker\n\n /**\n * Oneofs declared within this namespace, if any.\n * @type {Object.<string,OneOf>}\n */\n this.oneofs = undefined; // toJSON\n\n /**\n * Extension ranges, if any.\n * @type {number[][]}\n */\n this.extensions = undefined; // toJSON\n\n /**\n * Reserved ranges, if any.\n * @type {Array.<number[]|string>}\n */\n this.reserved = undefined; // toJSON\n\n /*?\n * Whether this type is a legacy group.\n * @type {boolean|undefined}\n */\n this.group = undefined; // toJSON\n\n /**\n * Cached fields by id.\n * @type {Object.<number,Field>|null}\n * @private\n */\n this._fieldsById = null;\n\n /**\n * Cached fields as an array.\n * @type {Field[]|null}\n * @private\n */\n this._fieldsArray = null;\n\n /**\n * Cached oneofs as an array.\n * @type {OneOf[]|null}\n * @private\n */\n this._oneofsArray = null;\n\n /**\n * Cached constructor.\n * @type {Constructor<{}>}\n * @private\n */\n this._ctor = null;\n\n /**\n * Cached fields by JSON name.\n * @type {Object.<string,Field>|null}\n * @private\n */\n this._fieldsByJsonName = null; // used by ext/protojson\n}\n\nObject.defineProperties(Type.prototype, {\n\n /**\n * Message fields by id.\n * @name Type#fieldsById\n * @type {Object.<number,Field>}\n * @readonly\n */\n fieldsById: {\n get: function() {\n\n /* istanbul ignore if */\n if (this._fieldsById)\n return this._fieldsById;\n\n this._fieldsById = {};\n for (var names = Object.keys(this.fields), i = 0; i < names.length; ++i) {\n var field = this.fields[names[i]],\n id = field.id;\n\n /* istanbul ignore if */\n if (this._fieldsById[id])\n throw Error(\"duplicate id \" + id + \" in \" + this);\n\n this._fieldsById[id] = field;\n }\n return this._fieldsById;\n }\n },\n\n /**\n * Fields of this message as an array for iteration.\n * @name Type#fieldsArray\n * @type {Field[]}\n * @readonly\n */\n fieldsArray: {\n get: function() {\n return this._fieldsArray || (this._fieldsArray = util.toArray(this.fields));\n }\n },\n\n /**\n * Oneofs of this message as an array for iteration.\n * @name Type#oneofsArray\n * @type {OneOf[]}\n * @readonly\n */\n oneofsArray: {\n get: function() {\n return this._oneofsArray || (this._oneofsArray = util.toArray(this.oneofs));\n }\n },\n\n /**\n * The registered constructor, if any registered, otherwise a generic constructor.\n * Assigning a function replaces the internal constructor. If the function does not extend {@link Message} yet, its prototype will be setup accordingly and static methods will be populated. If it already extends {@link Message}, it will just replace the internal constructor.\n * When assigning manually, add the type to its parent namespace/root first if fields reference other reflected types, because constructor setup resolves field defaults.\n * @name Type#ctor\n * @type {Constructor<{}>}\n */\n ctor: {\n get: function() {\n return this._ctor || (this.ctor = Type.generateConstructor(this)());\n },\n set: function(ctor) {\n\n // Ensure proper prototype\n var prototype = ctor.prototype;\n if (!(prototype instanceof Message)) {\n ctor.prototype = new Message();\n Object.defineProperty(ctor.prototype, \"constructor\", {\n value: ctor,\n writable: true,\n enumerable: false,\n configurable: true\n });\n util.merge(ctor.prototype, prototype);\n }\n\n // Classes and messages reference their reflected type\n ctor.$type = ctor.prototype.$type = this;\n\n // Mix in static methods\n util.merge(ctor, Message, true);\n\n this._ctor = ctor;\n delete this.decode;\n delete this.fromObject;\n\n // Messages have non-enumerable default values on their prototype\n var i = 0;\n for (var field; i < /* initializes */ this.fieldsArray.length; ++i) {\n field = this._fieldsArray[i].resolve(); // ensures a proper value\n ctor.prototype[field.name] = field.defaultValue;\n }\n\n // Messages have non-enumerable getters and setters for each virtual oneof field\n var ctorProperties = {};\n for (i = 0; i < /* initializes */ this.oneofsArray.length; ++i)\n ctorProperties[this._oneofsArray[i].resolve().name] = {\n get: util.oneOfGetter(this._oneofsArray[i].oneof),\n set: util.oneOfSetter(this._oneofsArray[i].oneof)\n };\n if (i)\n Object.defineProperties(ctor.prototype, ctorProperties);\n }\n }\n});\n\n/**\n * Generates a constructor function for the specified type.\n * @param {Type} mtype Message type\n * @returns {Codegen} Codegen instance\n */\nType.generateConstructor = function generateConstructor(mtype) {\n /* eslint-disable no-unexpected-multiline */\n var gen = util.codegen([\"p\"]);\n // explicitly initialize mutable object/array fields so that these aren't just inherited from the prototype\n for (var i = 0, field; i < mtype.fieldsArray.length; ++i)\n if ((field = mtype._fieldsArray[i]).map) gen\n (\"this%s={}\", util.safeProp(field.name));\n else if (field.repeated) gen\n (\"this%s=[]\", util.safeProp(field.name));\n return gen\n (\"if(p)for(var ks=Object.keys(p),i=0;i<ks.length;++i)if(p[ks[i]]!=null&&ks[i]!==\\\"__proto__\\\")\") // omit undefined or null\n (\"this[ks[i]]=p[ks[i]]\");\n /* eslint-enable no-unexpected-multiline */\n};\n\nfunction clearCache(type) {\n type._fieldsById = type._fieldsArray = type._oneofsArray = type._fieldsByJsonName = null;\n delete type.encode;\n delete type.decode;\n delete type.verify;\n return type;\n}\n\n/**\n * Message type descriptor.\n * @interface IType\n * @extends INamespace\n * @property {string} [edition] Edition\n * @property {Object.<string,IOneOf>} [oneofs] Oneof descriptors\n * @property {Object.<string,IField>} fields Field descriptors\n * @property {number[][]} [extensions] Extension ranges\n * @property {Array.<number[]|string>} [reserved] Reserved ranges\n * @property {boolean} [group=false] Whether a legacy group or not\n * @property {string|null} [comment] Message type comment\n */\n\n/**\n * Creates a message type from a message type descriptor.\n * @param {string} name Message name\n * @param {IType} json Message type descriptor\n * @param {number} [depth] Current nesting depth, defaults to `0`\n * @returns {Type} Created message type\n */\nType.fromJSON = function fromJSON(name, json, depth) {\n if (depth === undefined)\n depth = 0;\n if (depth > util.nestingLimit)\n throw Error(\"max depth exceeded\");\n var type = new Type(name, json.options);\n type.extensions = json.extensions;\n type.reserved = json.reserved;\n var names = Object.keys(json.fields),\n i = 0;\n for (; i < names.length; ++i)\n type.add(\n ( typeof json.fields[names[i]].keyType !== \"undefined\"\n ? MapField.fromJSON\n : Field.fromJSON )(names[i], json.fields[names[i]])\n );\n if (json.oneofs)\n for (names = Object.keys(json.oneofs), i = 0; i < names.length; ++i)\n type.add(OneOf.fromJSON(names[i], json.oneofs[names[i]]));\n if (json.nested)\n for (names = Object.keys(json.nested), i = 0; i < names.length; ++i) {\n var nested = json.nested[names[i]];\n type.add( // most to least likely\n ( nested.id !== undefined\n ? Field.fromJSON\n : nested.fields !== undefined\n ? Type.fromJSON\n : nested.values !== undefined\n ? Enum.fromJSON\n : nested.methods !== undefined\n ? Service.fromJSON\n : Namespace.fromJSON )(names[i], nested, depth + 1)\n );\n }\n if (json.extensions && json.extensions.length)\n type.extensions = json.extensions;\n if (json.reserved && json.reserved.length)\n type.reserved = json.reserved;\n if (json.group)\n type.group = true;\n if (json.comment)\n type.comment = json.comment;\n if (json.edition)\n type._edition = json.edition;\n type._defaultEdition = \"proto3\"; // For backwards-compatibility.\n return type;\n};\n\n/**\n * Converts this message type to a message type descriptor.\n * @param {IToJSONOptions} [toJSONOptions] JSON conversion options\n * @returns {IType} Message type descriptor\n */\nType.prototype.toJSON = function toJSON(toJSONOptions) {\n var inherited = Namespace.prototype.toJSON.call(this, toJSONOptions);\n var keepComments = toJSONOptions ? Boolean(toJSONOptions.keepComments) : false;\n return util.toObject([\n \"edition\" , this._editionToJSON(),\n \"options\" , inherited && inherited.options || undefined,\n \"oneofs\" , Namespace.arrayToJSON(this.oneofsArray, toJSONOptions),\n \"fields\" , Namespace.arrayToJSON(this.fieldsArray.filter(function(obj) { return !obj.declaringField; }), toJSONOptions) || {},\n \"extensions\" , this.extensions && this.extensions.length ? this.extensions : undefined,\n \"reserved\" , this.reserved && this.reserved.length ? this.reserved : undefined,\n \"group\" , this.group || undefined,\n \"nested\" , inherited && inherited.nested || undefined,\n \"comment\" , keepComments ? this.comment : undefined\n ]);\n};\n\n/**\n * @override\n */\nType.prototype.resolveAll = function resolveAll() {\n if (!this._needsRecursiveResolve) return this;\n\n Namespace.prototype.resolveAll.call(this);\n var oneofs = this.oneofsArray; i = 0;\n while (i < oneofs.length)\n oneofs[i++].resolve();\n var fields = this.fieldsArray, i = 0;\n while (i < fields.length)\n fields[i++].resolve();\n return this;\n};\n\n/**\n * @override\n */\nType.prototype._resolveFeaturesRecursive = function _resolveFeaturesRecursive(edition) {\n if (!this._needsRecursiveFeatureResolution) return this;\n\n edition = this._edition || edition;\n\n Namespace.prototype._resolveFeaturesRecursive.call(this, edition);\n this.oneofsArray.forEach(oneof => {\n oneof._resolveFeatures(edition);\n });\n this.fieldsArray.forEach(field => {\n field._resolveFeatures(edition);\n });\n return this;\n};\n\n/**\n * @override\n */\nType.prototype.get = function get(name) {\n if (Object.prototype.hasOwnProperty.call(this.fields, name))\n return this.fields[name];\n if (this.oneofs && Object.prototype.hasOwnProperty.call(this.oneofs, name))\n return this.oneofs[name];\n if (this.nested && Object.prototype.hasOwnProperty.call(this.nested, name))\n return this.nested[name];\n return null;\n};\n\n/**\n * Adds a nested object to this type.\n * @param {ReflectionObject} object Nested object to add\n * @returns {Type} `this`\n * @throws {TypeError} If arguments are invalid\n * @throws {Error} If there is already a nested object with this name or, if a field, when there is already a field with this id\n */\nType.prototype.add = function add(object) {\n if (this.get(object.name))\n throw Error(\"duplicate name '\" + object.name + \"' in \" + this);\n\n if (object instanceof Field && object.extend === undefined) {\n // NOTE: Extension fields aren't actual fields on the declaring type, but nested objects.\n // The root object takes care of adding distinct sister-fields to the respective extended\n // type instead.\n\n // avoids calling the getter if not absolutely necessary because it's called quite frequently\n if (this._fieldsById ? /* istanbul ignore next */ this._fieldsById[object.id] : this.fieldsById[object.id])\n throw Error(\"duplicate id \" + object.id + \" in \" + this);\n if (this.isReservedId(object.id))\n throw Error(\"id \" + object.id + \" is reserved in \" + this);\n if (this.isReservedName(object.name) || object.name.charAt(0) === \"$\")\n throw Error(\"name '\" + object.name + \"' is reserved in \" + this);\n if (object.name === \"__proto__\")\n return this;\n\n if (object.parent)\n object.parent.remove(object);\n this.fields[object.name] = object;\n object.message = this;\n object.onAdd(this);\n return clearCache(this);\n }\n if (object instanceof OneOf) {\n if (object.name.charAt(0) === \"$\")\n throw Error(\"name '\" + object.name + \"' is reserved in \" + this);\n if (object.name === \"__proto__\")\n return this;\n if (!this.oneofs)\n this.oneofs = {};\n this.oneofs[object.name] = object;\n object.onAdd(this);\n return clearCache(this);\n }\n return Namespace.prototype.add.call(this, object);\n};\n\n/**\n * Removes a nested object from this type.\n * @param {ReflectionObject} object Nested object to remove\n * @returns {Type} `this`\n * @throws {TypeError} If arguments are invalid\n * @throws {Error} If `object` is not a member of this type\n */\nType.prototype.remove = function remove(object) {\n if (object instanceof Field && object.extend === undefined) {\n // See Type#add for the reason why extension fields are excluded here.\n\n /* istanbul ignore if */\n if (!util.remove(this.fields, object, object.name))\n throw Error(object + \" is not a member of \" + this);\n\n object.parent = null;\n object.onRemove(this);\n return clearCache(this);\n }\n if (object instanceof OneOf) {\n\n /* istanbul ignore if */\n if (!util.remove(this.oneofs, object, object.name))\n throw Error(object + \" is not a member of \" + this);\n\n object.parent = null;\n object.onRemove(this);\n return clearCache(this);\n }\n return Namespace.prototype.remove.call(this, object);\n};\n\n/**\n * Tests if the specified id is reserved.\n * @param {number} id Id to test\n * @returns {boolean} `true` if reserved, otherwise `false`\n */\nType.prototype.isReservedId = function isReservedId(id) {\n return Namespace.isReservedId(this.reserved, id);\n};\n\n/**\n * Tests if the specified name is reserved.\n * @param {string} name Name to test\n * @returns {boolean} `true` if reserved, otherwise `false`\n */\nType.prototype.isReservedName = function isReservedName(name) {\n return Namespace.isReservedName(this.reserved, name);\n};\n\n/**\n * Creates a new message of this type using the specified properties.\n * @param {Object.<string,*>} [properties] Properties to set\n * @returns {ReflectedMessage} Message instance\n */\nType.prototype.create = function create(properties) {\n return new this.ctor(properties);\n};\n\n/**\n * Sets up {@link Type#encode|encode}, {@link Type#decode|decode} and {@link Type#verify|verify}.\n * @returns {Type} `this`\n */\nType.prototype.setup = function setup() {\n // Sets up everything at once so that the prototype chain does not have to be re-evaluated\n // multiple times (V8, soft-deopt prototype-check).\n\n // Resolve feature defaults incl. field presence before generating codecs\n var root = this.root;\n if (root && root._needsRecursiveFeatureResolution) {\n var edition = root._edition || this._edition;\n if (edition)\n root._resolveFeaturesRecursive(edition);\n }\n\n var fullName = this.fullName,\n types = [];\n for (var i = 0; i < /* initializes */ this.fieldsArray.length; ++i)\n types.push(this._fieldsArray[i].resolve().resolvedType);\n\n // Replace setup methods with type-specific generated functions\n this.encode = encoder(this)({\n Writer : Writer,\n types : types,\n util : util\n });\n this.decode = decoder(this)({\n Reader : Reader,\n types : types,\n util : util,\n C : this.ctor\n });\n this.verify = verifier(this)({\n types : types,\n util : util\n });\n this.fromObject = converter.fromObject(this)({\n types : types,\n util : util,\n C : this.ctor\n });\n this.toObject = converter.toObject(this)({\n types : types,\n util : util\n });\n\n // Inject custom wrappers for common types\n var wrapper = wrappers[fullName];\n if (wrapper) {\n var wrapperThis = Object.create(this);\n // Reuse this type's runtime constructor in wrapper fromObject/toObject\n wrapperThis._ctor = this.ctor;\n wrapperThis.fromObject = this.fromObject;\n this.fromObject = wrapper.fromObject.bind(wrapperThis);\n wrapperThis.toObject = this.toObject;\n this.toObject = wrapper.toObject.bind(wrapperThis);\n }\n\n return this;\n};\n\n/**\n * Encodes a message of this type. Does not implicitly {@link Type#verify|verify} messages.\n * @param {Message<{}>|Object.<string,*>} message Message instance or plain object\n * @param {Writer} [writer] Writer to encode to\n * @returns {Writer} writer\n */\nType.prototype.encode = function encode_setup(message, writer) { // eslint-disable-line no-unused-vars\n return this.setup().encode.apply(this, arguments); // overrides this method\n};\n\n/**\n * Encodes a message of this type preceeded by its byte length as a varint. Does not implicitly {@link Type#verify|verify} messages.\n * @param {Message<{}>|Object.<string,*>} message Message instance or plain object\n * @param {Writer} [writer] Writer to encode to\n * @returns {Writer} writer\n */\nType.prototype.encodeDelimited = function encodeDelimited(message, writer) {\n return this.encode(message, (writer || Writer.create()).fork()).ldelim();\n};\n\n/**\n * Decodes a message of this type.\n * @param {Reader|Uint8Array} reader Reader or buffer to decode from\n * @param {number} [length] Length of the message, if known beforehand\n * @returns {ReflectedMessage} Decoded message\n * @throws {Error} If the payload is not a reader or valid buffer\n * @throws {util.ProtocolError<{}>} If required fields are missing\n */\nType.prototype.decode = function decode_setup(reader, length) { // eslint-disable-line no-unused-vars\n return this.setup().decode.apply(this, arguments); // overrides this method\n};\n\n/**\n * Decodes a message of this type preceeded by its byte length as a varint.\n * @param {Reader|Uint8Array} reader Reader or buffer to decode from\n * @returns {ReflectedMessage} Decoded message\n * @throws {Error} If the payload is not a reader or valid buffer\n * @throws {util.ProtocolError} If required fields are missing\n */\nType.prototype.decodeDelimited = function decodeDelimited(reader) {\n if (!(reader instanceof Reader))\n reader = Reader.create(reader);\n return this.decode(reader, reader.uint32());\n};\n\n/**\n * Verifies that field values are valid and that required fields are present.\n * @param {Object.<string,*>} message Plain object to verify\n * @returns {null|string} `null` if valid, otherwise the reason why it is not\n */\nType.prototype.verify = function verify_setup(message) { // eslint-disable-line no-unused-vars\n return this.setup().verify.apply(this, arguments); // overrides this method\n};\n\n/**\n * Creates a new message of this type from a plain object. Also converts values to their respective internal types.\n * @param {Object.<string,*>} object Plain object to convert\n * @returns {ReflectedMessage} Message instance\n */\nType.prototype.fromObject = function fromObject(object) { // eslint-disable-line no-unused-vars\n return this.setup().fromObject.apply(this, arguments);\n};\n\n/**\n * Conversion options as used by {@link Type#toObject} and {@link Message.toObject}.\n * @interface IConversionOptions\n * @property {Function} [longs] Long conversion type.\n * Valid values are `BigInt`, `String` and `Number` (the global types).\n * Defaults to copy the present value, which is a possibly unsafe number without and a {@link Long} with a long library.\n * @property {Function} [enums] Enum value conversion type.\n * Only valid value is `String` (the global type).\n * Defaults to copy the present value, which is the numeric id.\n * @property {Function} [bytes] Bytes value conversion type.\n * Valid values are `Array` and (a base64 encoded) `String` (the global types).\n * Defaults to copy the present value, which usually is a Buffer under node and an Uint8Array in the browser.\n * @property {boolean} [defaults=false] Also sets default values on the resulting object\n * @property {boolean} [arrays=false] Sets empty arrays for missing repeated fields even if `defaults=false`\n * @property {boolean} [objects=false] Sets empty objects for missing map fields even if `defaults=false`\n * @property {boolean} [oneofs=false] Includes virtual oneof properties set to the present field's name, if any\n * @property {boolean} [json=false] Performs additional JSON compatibility conversions, i.e. NaN and Infinity to strings\n */\n\n/**\n * Creates a plain object from a message of this type. Also converts values to other types if specified.\n * @param {Message<{}>} message Message instance\n * @param {IConversionOptions} [options] Conversion options\n * @returns {Object.<string,*>} Plain object\n */\nType.prototype.toObject = function toObject(message, options) { // eslint-disable-line no-unused-vars\n return this.setup().toObject.apply(this, arguments);\n};\n\n/**\n * Gets the type url for this type.\n * @param {string} [prefix] Custom type url prefix, defaults to `\"type.googleapis.com\"`\n * @returns {string} The type url\n */\nType.prototype.getTypeUrl = function getTypeUrl(prefix) {\n if (prefix === undefined)\n prefix = \"type.googleapis.com\";\n var fullName = this.fullName;\n return prefix + \"/\" + (fullName.charAt(0) === \".\" ? fullName.substring(1) : fullName);\n};\n\n/**\n * Decorator function as returned by {@link Type.d} (TypeScript).\n * @typedef TypeDecorator\n * @type {function}\n * @param {Constructor<T>} target Target constructor\n * @returns {undefined}\n * @template T extends Message<T>\n * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.\n */\n\n/**\n * Type decorator (TypeScript).\n * @param {string} [typeName] Type name, defaults to the constructor's name\n * @returns {TypeDecorator<T>} Decorator function\n * @template T extends Message<T>\n * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.\n */\nType.d = function decorateType(typeName) {\n return function typeDecorator(target) {\n util.decorateType(target, typeName);\n };\n};\n","\"use strict\";\n\n/**\n * Common type constants.\n * @namespace\n */\nvar types = exports;\n\nvar util = require(28);\n\nvar s = [\n \"double\", // 0\n \"float\", // 1\n \"int32\", // 2\n \"uint32\", // 3\n \"sint32\", // 4\n \"fixed32\", // 5\n \"sfixed32\", // 6\n \"int64\", // 7\n \"uint64\", // 8\n \"sint64\", // 9\n \"fixed64\", // 10\n \"sfixed64\", // 11\n \"bool\", // 12\n \"string\", // 13\n \"bytes\" // 14\n];\n\nfunction bake(values, offset) {\n var i = 0, o = Object.create(null);\n offset |= 0;\n while (i < values.length) o[s[i + offset]] = values[i++];\n return o;\n}\n\n/**\n * Basic type wire types.\n * @type {Object.<string,number>}\n * @const\n * @property {number} double=1 Fixed64 wire type\n * @property {number} float=5 Fixed32 wire type\n * @property {number} int32=0 Varint wire type\n * @property {number} uint32=0 Varint wire type\n * @property {number} sint32=0 Varint wire type\n * @property {number} fixed32=5 Fixed32 wire type\n * @property {number} sfixed32=5 Fixed32 wire type\n * @property {number} int64=0 Varint wire type\n * @property {number} uint64=0 Varint wire type\n * @property {number} sint64=0 Varint wire type\n * @property {number} fixed64=1 Fixed64 wire type\n * @property {number} sfixed64=1 Fixed64 wire type\n * @property {number} bool=0 Varint wire type\n * @property {number} string=2 Ldelim wire type\n * @property {number} bytes=2 Ldelim wire type\n */\ntypes.basic = bake([\n /* double */ 1,\n /* float */ 5,\n /* int32 */ 0,\n /* uint32 */ 0,\n /* sint32 */ 0,\n /* fixed32 */ 5,\n /* sfixed32 */ 5,\n /* int64 */ 0,\n /* uint64 */ 0,\n /* sint64 */ 0,\n /* fixed64 */ 1,\n /* sfixed64 */ 1,\n /* bool */ 0,\n /* string */ 2,\n /* bytes */ 2\n]);\n\n/**\n * Basic type defaults.\n * @type {Object.<string,*>}\n * @const\n * @property {number} double=0 Double default\n * @property {number} float=0 Float default\n * @property {number} int32=0 Int32 default\n * @property {number} uint32=0 Uint32 default\n * @property {number} sint32=0 Sint32 default\n * @property {number} fixed32=0 Fixed32 default\n * @property {number} sfixed32=0 Sfixed32 default\n * @property {number} int64=0 Int64 default\n * @property {number} uint64=0 Uint64 default\n * @property {number} sint64=0 Sint32 default\n * @property {number} fixed64=0 Fixed64 default\n * @property {number} sfixed64=0 Sfixed64 default\n * @property {boolean} bool=false Bool default\n * @property {string} string=\"\" String default\n * @property {Array.<number>} bytes=Array(0) Bytes default\n * @property {null} message=null Message default\n */\ntypes.defaults = bake([\n /* double */ 0,\n /* float */ 0,\n /* int32 */ 0,\n /* uint32 */ 0,\n /* sint32 */ 0,\n /* fixed32 */ 0,\n /* sfixed32 */ 0,\n /* int64 */ 0,\n /* uint64 */ 0,\n /* sint64 */ 0,\n /* fixed64 */ 0,\n /* sfixed64 */ 0,\n /* bool */ false,\n /* string */ \"\",\n /* bytes */ util.emptyArray,\n /* message */ null\n]);\n\n/**\n * Basic long type wire types.\n * @type {Object.<string,number>}\n * @const\n * @property {number} int64=0 Varint wire type\n * @property {number} uint64=0 Varint wire type\n * @property {number} sint64=0 Varint wire type\n * @property {number} fixed64=1 Fixed64 wire type\n * @property {number} sfixed64=1 Fixed64 wire type\n */\ntypes.long = bake([\n /* int64 */ 0,\n /* uint64 */ 0,\n /* sint64 */ 0,\n /* fixed64 */ 1,\n /* sfixed64 */ 1\n], 7);\n\n/**\n * Allowed types for map keys with their associated wire type.\n * @type {Object.<string,number>}\n * @const\n * @property {number} int32=0 Varint wire type\n * @property {number} uint32=0 Varint wire type\n * @property {number} sint32=0 Varint wire type\n * @property {number} fixed32=5 Fixed32 wire type\n * @property {number} sfixed32=5 Fixed32 wire type\n * @property {number} int64=0 Varint wire type\n * @property {number} uint64=0 Varint wire type\n * @property {number} sint64=0 Varint wire type\n * @property {number} fixed64=1 Fixed64 wire type\n * @property {number} sfixed64=1 Fixed64 wire type\n * @property {number} bool=0 Varint wire type\n * @property {number} string=2 Ldelim wire type\n */\ntypes.mapKey = bake([\n /* int32 */ 0,\n /* uint32 */ 0,\n /* sint32 */ 0,\n /* fixed32 */ 5,\n /* sfixed32 */ 5,\n /* int64 */ 0,\n /* uint64 */ 0,\n /* sint64 */ 0,\n /* fixed64 */ 1,\n /* sfixed64 */ 1,\n /* bool */ 0,\n /* string */ 2\n], 2);\n\n/**\n * Allowed types for packed repeated fields with their associated wire type.\n * @type {Object.<string,number>}\n * @const\n * @property {number} double=1 Fixed64 wire type\n * @property {number} float=5 Fixed32 wire type\n * @property {number} int32=0 Varint wire type\n * @property {number} uint32=0 Varint wire type\n * @property {number} sint32=0 Varint wire type\n * @property {number} fixed32=5 Fixed32 wire type\n * @property {number} sfixed32=5 Fixed32 wire type\n * @property {number} int64=0 Varint wire type\n * @property {number} uint64=0 Varint wire type\n * @property {number} sint64=0 Varint wire type\n * @property {number} fixed64=1 Fixed64 wire type\n * @property {number} sfixed64=1 Fixed64 wire type\n * @property {number} bool=0 Varint wire type\n */\ntypes.packed = bake([\n /* double */ 1,\n /* float */ 5,\n /* int32 */ 0,\n /* uint32 */ 0,\n /* sint32 */ 0,\n /* fixed32 */ 5,\n /* sfixed32 */ 5,\n /* int64 */ 0,\n /* uint64 */ 0,\n /* sint64 */ 0,\n /* fixed64 */ 1,\n /* sfixed64 */ 1,\n /* bool */ 0\n]);\n","\"use strict\";\n\n/**\n * Various utility functions.\n * @namespace\n */\nvar util = module.exports = require(37);\n\nvar roots = require(21);\n\nvar Type, // cyclic\n Enum;\n\nutil.codegen = require(31);\nutil.fetch = require(33);\nutil.path = require(38);\nutil.patterns = require(39);\n\nvar reservedRe = util.patterns.reservedRe;\n\n/**\n * Node's fs module if available.\n * @type {Object.<string,*>}\n */\nutil.fs = require(35);\n\n/**\n * Converts an object's values to an array.\n * @param {Object.<string,*>} object Object to convert\n * @returns {Array.<*>} Converted array\n */\nutil.toArray = function toArray(object) {\n if (object) {\n var keys = Object.keys(object),\n array = new Array(keys.length),\n index = 0;\n while (index < keys.length)\n array[index] = object[keys[index++]];\n return array;\n }\n return [];\n};\n\n/**\n * Converts an array of keys immediately followed by their respective value to an object, omitting undefined values.\n * @param {Array.<*>} array Array to convert\n * @returns {Object.<string,*>} Converted object\n */\nutil.toObject = function toObject(array) {\n var object = {},\n index = 0;\n while (index < array.length) {\n var key = array[index++],\n val = array[index++];\n if (val !== undefined)\n object[key] = val;\n }\n return object;\n};\n\n/**\n * Removes the first matching value from an object.\n * @param {Object.<string,*>|undefined} object Object to remove from\n * @param {*} value Value to remove\n * @param {string} [key] Optional key for fast path removal\n * @returns {boolean} `true` if removed, otherwise `false`\n */\nutil.remove = function remove(object, value, key) {\n if (!object)\n return false;\n if (key !== undefined && Object.prototype.hasOwnProperty.call(object, key) && object[key] === value) {\n delete object[key];\n return true;\n }\n for (var names = Object.keys(object), i = 0; i < names.length; ++i)\n if (object[names[i]] === value) {\n delete object[names[i]];\n return true;\n }\n return false;\n};\n\n/**\n * Tests whether the specified name is a reserved word in JS.\n * @param {string} name Name to test\n * @returns {boolean} `true` if reserved, otherwise `false`\n */\nutil.isReserved = function isReserved(name) {\n return reservedRe.test(name);\n};\n\n/**\n * Returns a safe property accessor for the specified property name.\n * @param {string} prop Property name\n * @returns {string} Safe accessor\n */\nutil.safeProp = function safeProp(prop) {\n if (!/^[$\\w_]+$/.test(prop) || reservedRe.test(prop))\n return \"[\" + JSON.stringify(prop) + \"]\";\n return \".\" + prop;\n};\n\n/**\n * Converts the first character of a string to upper case.\n * @param {string} str String to convert\n * @returns {string} Converted string\n */\nutil.ucFirst = function ucFirst(str) {\n return str.charAt(0).toUpperCase() + str.substring(1);\n};\n\nvar camelCaseRe = /_([a-z])/g;\n\n/**\n * Converts a string to camel case.\n * @param {string} str String to convert\n * @returns {string} Converted string\n * @deprecated Use {@link util.jsonName} for protobuf field JSON names.\n */\nutil.camelCase = function camelCase(str) {\n return str.substring(0, 1)\n + str.substring(1)\n .replace(camelCaseRe, function($0, $1) { return $1.toUpperCase(); });\n};\n\n/**\n * Converts a proto field name to its protoc-compatible JSON name.\n * @param {string} str Proto field name\n * @returns {string} JSON name\n */\nutil.jsonName = function jsonName(str) {\n var result = \"\",\n upperNext = false,\n i = 0;\n for (; i < str.length; ++i) {\n var ch = str.charAt(i);\n if (ch === \"_\")\n upperNext = true;\n else if (upperNext) {\n result += ch.toUpperCase();\n upperNext = false;\n } else\n result += ch;\n }\n return result;\n};\n\n/**\n * Compares reflected fields by id.\n * @param {Field} a First field\n * @param {Field} b Second field\n * @returns {number} Comparison value\n */\nutil.compareFieldsById = function compareFieldsById(a, b) {\n return a.id - b.id;\n};\n\n/**\n * Decorator helper for types (TypeScript).\n * @param {Constructor<T>} ctor Constructor function\n * @param {string} [typeName] Type name, defaults to the constructor's name\n * @returns {Type} Reflected type\n * @template T extends Message<T>\n * @property {Root} root Decorators root\n * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.\n */\nutil.decorateType = function decorateType(ctor, typeName) {\n\n /* istanbul ignore if */\n if (ctor.$type) {\n if (typeName && ctor.$type.name !== typeName) {\n util.decorateRoot.remove(ctor.$type);\n ctor.$type.name = typeName;\n util.decorateRoot.add(ctor.$type);\n }\n return ctor.$type;\n }\n\n /* istanbul ignore next */\n if (!Type)\n Type = require(26);\n\n var type = new Type(typeName || ctor.name);\n util.decorateRoot.add(type);\n type.ctor = ctor; // sets up .encode, .decode etc.\n Object.defineProperty(ctor, \"$type\", { value: type, enumerable: false });\n Object.defineProperty(ctor.prototype, \"$type\", { value: type, enumerable: false });\n return type;\n};\n\nvar decorateEnumIndex = 0;\n\n/**\n * Decorator helper for enums (TypeScript).\n * @param {Object} object Enum object\n * @returns {Enum} Reflected enum\n * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.\n */\nutil.decorateEnum = function decorateEnum(object) {\n\n /* istanbul ignore if */\n if (object.$type)\n return object.$type;\n\n /* istanbul ignore next */\n if (!Enum)\n Enum = require(6);\n\n var enm = new Enum(\"Enum\" + decorateEnumIndex++, object);\n util.decorateRoot.add(enm);\n Object.defineProperty(object, \"$type\", { value: enm, enumerable: false });\n return enm;\n};\n\n\n/**\n * Sets the value of a property by property path. If a value already exists, it is turned to an array\n * @param {Object.<string,*>} dst Destination object\n * @param {string} path dot '.' delimited path of the property to set\n * @param {Object} value the value to set\n * @param {boolean|undefined} [ifNotSet] Sets the option only if it isn't currently set\n * @returns {Object.<string,*>} Destination object\n */\nutil.setProperty = function setProperty(dst, path, value, ifNotSet) {\n function setProp(dst, path, value) {\n var part = path.shift();\n if (util.isUnsafeProperty(part))\n return dst;\n if (path.length > 0) {\n dst[part] = setProp(dst[part] || {}, path, value);\n } else {\n var prevValue = dst[part];\n if (prevValue && ifNotSet)\n return dst;\n if (prevValue)\n value = [].concat(prevValue).concat(value);\n dst[part] = value;\n }\n return dst;\n }\n\n if (typeof dst !== \"object\")\n throw TypeError(\"dst must be an object\");\n if (!path)\n throw TypeError(\"path must be specified\");\n\n path = path.split(\".\");\n if (path.length > util.recursionLimit)\n throw Error(\"max depth exceeded\");\n return setProp(dst, path, value);\n};\n\n/**\n * Decorator root (TypeScript).\n * @name util.decorateRoot\n * @type {Root}\n * @readonly\n * @deprecated Legacy TypeScript decorator support. Will be removed in a future release.\n */\nObject.defineProperty(util, \"decorateRoot\", {\n get: function() {\n return roots[\"decorated\"] || (roots[\"decorated\"] = new (require(20))());\n }\n});\n","\"use strict\";\nmodule.exports = asPromise;\n\n/**\n * Callback as used by {@link util.asPromise}.\n * @typedef asPromiseCallback\n * @type {function}\n * @param {Error|null} error Error, if any\n * @param {...*} params Additional arguments\n * @returns {undefined}\n */\n\n/**\n * Returns a promise from a node-style callback function.\n * @memberof util\n * @param {asPromiseCallback} fn Function to call\n * @param {*} ctx Function context\n * @param {...*} params Function arguments\n * @returns {Promise<*>} Promisified function\n */\nfunction asPromise(fn, ctx/*, varargs */) {\n var params = new Array(arguments.length - 1),\n offset = 0,\n index = 2,\n pending = true;\n while (index < arguments.length)\n params[offset++] = arguments[index++];\n return new Promise(function executor(resolve, reject) {\n params[offset] = function callback(err/*, varargs */) {\n if (pending) {\n pending = false;\n if (err)\n reject(err);\n else {\n var params = new Array(arguments.length - 1),\n offset = 0;\n while (offset < params.length)\n params[offset++] = arguments[offset];\n resolve.apply(null, params);\n }\n }\n };\n try {\n fn.apply(ctx || null, params);\n } catch (err) {\n if (pending) {\n pending = false;\n reject(err);\n }\n }\n });\n}\n","\"use strict\";\n\n/**\n * A minimal base64 implementation for number arrays.\n * @memberof util\n * @namespace\n */\nvar base64 = exports;\n\n/**\n * Calculates the byte length of a base64 encoded string.\n * @param {string} string Base64 encoded string\n * @returns {number} Byte length\n */\nbase64.length = function length(string) {\n var p = string.length;\n if (!p)\n return 0;\n while (p > 0 && string.charAt(p - 1) === \"=\")\n --p;\n return Math.floor(p * 3 / 4);\n};\n\n// Base64 encoding table\nvar b64 = new Array(64);\n\n// Base64 decoding table\nvar s64 = new Array(123);\n\n// 65..90, 97..122, 48..57, 43, 47\nfor (var i = 0; i < 64;)\n s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;\n\ns64[45] = 62; // - -> +\ns64[95] = 63; // _ -> /\n\n/**\n * Encodes a buffer to a base64 encoded string.\n * @param {Uint8Array} buffer Source buffer\n * @param {number} start Source start\n * @param {number} end Source end\n * @returns {string} Base64 encoded string\n */\nbase64.encode = function encode(buffer, start, end) {\n var parts = null,\n chunk = [];\n var i = 0, // output index\n j = 0, // goto index\n t; // temporary\n while (start < end) {\n var b = buffer[start++];\n switch (j) {\n case 0:\n chunk[i++] = b64[b >> 2];\n t = (b & 3) << 4;\n j = 1;\n break;\n case 1:\n chunk[i++] = b64[t | b >> 4];\n t = (b & 15) << 2;\n j = 2;\n break;\n case 2:\n chunk[i++] = b64[t | b >> 6];\n chunk[i++] = b64[b & 63];\n j = 0;\n break;\n }\n if (i > 8191) {\n (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));\n i = 0;\n }\n }\n if (j) {\n chunk[i++] = b64[t];\n chunk[i++] = 61;\n if (j === 1)\n chunk[i++] = 61;\n }\n if (parts) {\n if (i)\n parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\n return parts.join(\"\");\n }\n return String.fromCharCode.apply(String, chunk.slice(0, i));\n};\n\nvar invalidEncoding = \"invalid encoding\";\n\n/**\n * Decodes a base64 encoded string to a buffer.\n * @param {string} string Source string\n * @param {Uint8Array} buffer Destination buffer\n * @param {number} offset Destination offset\n * @returns {number} Number of bytes written\n * @throws {Error} If encoding is invalid\n */\nbase64.decode = function decode(string, buffer, offset) {\n var start = offset;\n var j = 0, // goto index\n t; // temporary\n for (var i = 0; i < string.length;) {\n var c = string.charCodeAt(i++);\n if (c === 61 && j > 1)\n break;\n if ((c = s64[c]) === undefined)\n throw Error(invalidEncoding);\n switch (j) {\n case 0:\n t = c;\n j = 1;\n break;\n case 1:\n buffer[offset++] = t << 2 | (c & 48) >> 4;\n t = c;\n j = 2;\n break;\n case 2:\n buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;\n t = c;\n j = 3;\n break;\n case 3:\n buffer[offset++] = (t & 3) << 6 | c;\n j = 0;\n break;\n }\n }\n if (j === 1)\n throw Error(invalidEncoding);\n return offset - start;\n};\n\nvar base64Re = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/,\n base64UrlRe = /[-_]/,\n base64UrlNoPaddingRe = /^(?:[A-Za-z0-9_-]{4})*(?:[A-Za-z0-9_-]{2}(?:==)?|[A-Za-z0-9_-]{3}=?)?$/;\n\n/**\n * Tests if the specified string appears to be base64 encoded.\n * @param {string} string String to test\n * @returns {boolean} `true` if probably base64 encoded, otherwise false\n */\nbase64.test = function test(string) {\n return base64Re.test(string)\n || base64UrlRe.test(string) && base64UrlNoPaddingRe.test(string);\n};\n","\"use strict\";\nmodule.exports = codegen;\n\nvar patterns = require(39);\nvar reservedRe = patterns.reservedRe;\n\n/**\n * Begins generating a function.\n * @memberof util\n * @param {string[]} functionParams Function parameter names\n * @param {string} [functionName] Function name if not anonymous\n * @returns {Codegen} Appender that appends code to the function's body\n */\nfunction codegen(functionParams, functionName) {\n\n /* istanbul ignore if */\n if (typeof functionParams === \"string\") {\n functionName = functionParams;\n functionParams = undefined;\n }\n\n var body = [];\n\n /**\n * Appends code to the function's body or finishes generation.\n * @typedef Codegen\n * @type {function}\n * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any\n * @param {...*} [formatParams] Format parameters\n * @returns {Codegen|Function} Itself or the generated function if finished\n * @throws {Error} If format parameter counts do not match\n */\n\n function Codegen(formatStringOrScope) {\n // note that explicit array handling below makes this ~50% faster\n\n // finish the function\n if (typeof formatStringOrScope !== \"string\") {\n var source = toString();\n if (codegen.verbose)\n console.log(\"codegen: \" + source); // eslint-disable-line no-console\n source = \"return \" + source;\n if (formatStringOrScope) {\n var scopeKeys = Object.keys(formatStringOrScope),\n scopeParams = new Array(scopeKeys.length + 1),\n scopeValues = new Array(scopeKeys.length),\n scopeOffset = 0;\n while (scopeOffset < scopeKeys.length) {\n scopeParams[scopeOffset] = scopeKeys[scopeOffset];\n scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];\n }\n scopeParams[scopeOffset] = source;\n return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func\n }\n return Function(source)(); // eslint-disable-line no-new-func\n }\n\n // otherwise append to body\n var formatParams = new Array(arguments.length - 1),\n formatOffset = 0;\n while (formatOffset < formatParams.length)\n formatParams[formatOffset] = arguments[++formatOffset];\n formatOffset = 0;\n formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {\n var value = formatParams[formatOffset++];\n switch ($1) {\n case \"d\": case \"f\": return String(Number(value));\n case \"i\": return String(Math.floor(value));\n case \"j\": return JSON.stringify(value);\n case \"s\": return String(value);\n }\n return \"%\";\n });\n if (formatOffset !== formatParams.length)\n throw Error(\"parameter count mismatch\");\n body.push(formatStringOrScope);\n return Codegen;\n }\n\n function toString(functionNameOverride) {\n return \"function \" + safeFunctionName(functionNameOverride || functionName) + \"(\" + (functionParams && functionParams.join(\",\") || \"\") + \"){\\n \" + body.join(\"\\n \") + \"\\n}\";\n }\n\n Object.defineProperty(Codegen, \"toString\", {\n value: toString,\n writable: true,\n enumerable: true,\n configurable: true\n });\n return Codegen;\n}\n\n/**\n * Begins generating a function.\n * @memberof util\n * @function codegen\n * @param {string} [functionName] Function name if not anonymous\n * @returns {Codegen} Appender that appends code to the function's body\n * @variation 2\n */\n\n/**\n * When set to `true`, codegen will log generated code to console. Useful for debugging.\n * @name util.codegen.verbose\n * @type {boolean}\n */\ncodegen.verbose = false;\n\nfunction safeFunctionName(name) {\n if (!name)\n return \"\";\n name = String(name).replace(/[^\\w$]/g, \"\");\n if (!name)\n return \"\";\n if (/^\\d/.test(name))\n name = \"_\" + name;\n return reservedRe.test(name) ? name + \"_\" : name;\n}\n","\"use strict\";\nmodule.exports = EventEmitter;\n\n/**\n * Constructs a new event emitter instance.\n * @classdesc A minimal event emitter.\n * @memberof util\n * @constructor\n */\nfunction EventEmitter() {\n\n /**\n * Registered listeners.\n * @type {Object.<string,*>}\n * @private\n */\n this._listeners = Object.create(null);\n}\n\n/**\n * Event listener as used by {@link util.EventEmitter}.\n * @typedef EventEmitterListener\n * @type {function}\n * @param {...*} args Arguments\n * @returns {undefined}\n */\n\n/**\n * Registers an event listener.\n * @param {string} evt Event name\n * @param {EventEmitterListener} fn Listener\n * @param {*} [ctx] Listener context\n * @returns {this} `this`\n */\nEventEmitter.prototype.on = function on(evt, fn, ctx) {\n (this._listeners[evt] || (this._listeners[evt] = [])).push({\n fn : fn,\n ctx : ctx || this\n });\n return this;\n};\n\n/**\n * Removes an event listener or any matching listeners if arguments are omitted.\n * @param {string} [evt] Event name. Removes all listeners if omitted.\n * @param {EventEmitterListener} [fn] Listener to remove. Removes all listeners of `evt` if omitted.\n * @returns {this} `this`\n */\nEventEmitter.prototype.off = function off(evt, fn) {\n if (evt === undefined)\n this._listeners = Object.create(null);\n else {\n if (fn === undefined)\n this._listeners[evt] = [];\n else {\n var listeners = this._listeners[evt];\n if (!listeners)\n return this;\n for (var i = 0; i < listeners.length;)\n if (listeners[i].fn === fn)\n listeners.splice(i, 1);\n else\n ++i;\n }\n }\n return this;\n};\n\n/**\n * Emits an event by calling its listeners with the specified arguments.\n * @param {string} evt Event name\n * @param {...*} args Arguments\n * @returns {this} `this`\n */\nEventEmitter.prototype.emit = function emit(evt) {\n var listeners = this._listeners[evt];\n if (listeners) {\n var args = [],\n i = 1;\n for (; i < arguments.length;)\n args.push(arguments[i++]);\n for (i = 0; i < listeners.length;)\n listeners[i].fn.apply(listeners[i++].ctx, args);\n }\n return this;\n};\n","\"use strict\";\nmodule.exports = fetch;\n\nvar asPromise = require(29),\n fs = require(35);\n\n/**\n * Node-style callback as used by {@link util.fetch}.\n * @typedef FetchCallback\n * @type {function}\n * @param {?Error} error Error, if any, otherwise `null`\n * @param {string} [contents] File contents, if there hasn't been an error\n * @returns {undefined}\n */\n\n/**\n * Options as used by {@link util.fetch}.\n * @interface IFetchOptions\n * @property {boolean} [binary=false] Whether expecting a binary response\n * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest\n */\n\n/**\n * Fetches the contents of a file.\n * @memberof util\n * @param {string} filename File path or url\n * @param {IFetchOptions} options Fetch options\n * @param {FetchCallback} callback Callback function\n * @returns {undefined}\n */\nfunction fetch(filename, options, callback) {\n if (typeof options === \"function\") {\n callback = options;\n options = {};\n } else if (!options)\n options = {};\n\n if (!callback)\n return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this\n\n // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.\n if (!options.xhr && fs && fs.readFile)\n return fs.readFile(filename, function fetchReadFileCallback(err, contents) {\n return err && typeof XMLHttpRequest !== \"undefined\"\n ? fetch.xhr(filename, options, callback)\n : err\n ? callback(err)\n : callback(null, options.binary ? contents : contents.toString(\"utf8\"));\n });\n\n // use the XHR version otherwise.\n return fetch.xhr(filename, options, callback);\n}\n\n/**\n * Fetches the contents of a file.\n * @name util.fetch\n * @function\n * @param {string} path File path or url\n * @param {FetchCallback} callback Callback function\n * @returns {undefined}\n * @variation 2\n */\n\n/**\n * Fetches the contents of a file.\n * @name util.fetch\n * @function\n * @param {string} path File path or url\n * @param {IFetchOptions} [options] Fetch options\n * @returns {Promise<string|Uint8Array>} Promise\n * @variation 3\n */\n\n/**/\nfetch.xhr = function fetch_xhr(filename, options, callback) {\n var xhr = new XMLHttpRequest();\n xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {\n\n if (xhr.readyState !== 4)\n return undefined;\n\n // local cors security errors return status 0 / empty string, too. afaik this cannot be\n // reliably distinguished from an actually empty file for security reasons. feel free\n // to send a pull request if you are aware of a solution.\n if (xhr.status !== 0 && xhr.status !== 200)\n return callback(Error(\"status \" + xhr.status));\n\n // if binary data is expected, make sure that some sort of array is returned, even if\n // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.\n if (options.binary) {\n var buffer = xhr.response;\n if (!buffer) {\n buffer = [];\n for (var i = 0; i < xhr.responseText.length; ++i)\n buffer.push(xhr.responseText.charCodeAt(i) & 255);\n }\n return callback(null, typeof Uint8Array !== \"undefined\" ? new Uint8Array(buffer) : buffer);\n }\n return callback(null, xhr.responseText);\n };\n\n if (options.binary) {\n // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers\n if (\"overrideMimeType\" in xhr)\n xhr.overrideMimeType(\"text/plain; charset=x-user-defined\");\n xhr.responseType = \"arraybuffer\";\n }\n\n xhr.open(\"GET\", filename);\n xhr.send();\n};\n","\"use strict\";\n\nmodule.exports = factory(factory);\n\n/**\n * Reads / writes floats / doubles from / to buffers.\n * @name util.float\n * @namespace\n */\n\n/**\n * Writes a 32 bit float to a buffer using little endian byte order.\n * @name util.float.writeFloatLE\n * @function\n * @param {number} val Value to write\n * @param {Uint8Array} buf Target buffer\n * @param {number} pos Target buffer offset\n * @returns {undefined}\n */\n\n/**\n * Writes a 32 bit float to a buffer using big endian byte order.\n * @name util.float.writeFloatBE\n * @function\n * @param {number} val Value to write\n * @param {Uint8Array} buf Target buffer\n * @param {number} pos Target buffer offset\n * @returns {undefined}\n */\n\n/**\n * Reads a 32 bit float from a buffer using little endian byte order.\n * @name util.float.readFloatLE\n * @function\n * @param {Uint8Array} buf Source buffer\n * @param {number} pos Source buffer offset\n * @returns {number} Value read\n */\n\n/**\n * Reads a 32 bit float from a buffer using big endian byte order.\n * @name util.float.readFloatBE\n * @function\n * @param {Uint8Array} buf Source buffer\n * @param {number} pos Source buffer offset\n * @returns {number} Value read\n */\n\n/**\n * Writes a 64 bit double to a buffer using little endian byte order.\n * @name util.float.writeDoubleLE\n * @function\n * @param {number} val Value to write\n * @param {Uint8Array} buf Target buffer\n * @param {number} pos Target buffer offset\n * @returns {undefined}\n */\n\n/**\n * Writes a 64 bit double to a buffer using big endian byte order.\n * @name util.float.writeDoubleBE\n * @function\n * @param {number} val Value to write\n * @param {Uint8Array} buf Target buffer\n * @param {number} pos Target buffer offset\n * @returns {undefined}\n */\n\n/**\n * Reads a 64 bit double from a buffer using little endian byte order.\n * @name util.float.readDoubleLE\n * @function\n * @param {Uint8Array} buf Source buffer\n * @param {number} pos Source buffer offset\n * @returns {number} Value read\n */\n\n/**\n * Reads a 64 bit double from a buffer using big endian byte order.\n * @name util.float.readDoubleBE\n * @function\n * @param {Uint8Array} buf Source buffer\n * @param {number} pos Source buffer offset\n * @returns {number} Value read\n */\n\n// Factory function for the purpose of node-based testing in modified global environments\nfunction factory(exports) {\n\n // float: typed array\n if (typeof Float32Array !== \"undefined\") (function() {\n\n var f32 = new Float32Array([ -0 ]),\n f8b = new Uint8Array(f32.buffer),\n le = f8b[3] === 128;\n\n function writeFloat_f32_cpy(val, buf, pos) {\n f32[0] = val;\n buf[pos ] = f8b[0];\n buf[pos + 1] = f8b[1];\n buf[pos + 2] = f8b[2];\n buf[pos + 3] = f8b[3];\n }\n\n function writeFloat_f32_rev(val, buf, pos) {\n f32[0] = val;\n buf[pos ] = f8b[3];\n buf[pos + 1] = f8b[2];\n buf[pos + 2] = f8b[1];\n buf[pos + 3] = f8b[0];\n }\n\n /* istanbul ignore next */\n exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;\n /* istanbul ignore next */\n exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;\n\n function readFloat_f32_cpy(buf, pos) {\n f8b[0] = buf[pos ];\n f8b[1] = buf[pos + 1];\n f8b[2] = buf[pos + 2];\n f8b[3] = buf[pos + 3];\n return f32[0];\n }\n\n function readFloat_f32_rev(buf, pos) {\n f8b[3] = buf[pos ];\n f8b[2] = buf[pos + 1];\n f8b[1] = buf[pos + 2];\n f8b[0] = buf[pos + 3];\n return f32[0];\n }\n\n /* istanbul ignore next */\n exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;\n /* istanbul ignore next */\n exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;\n\n // float: ieee754\n })(); else (function() {\n\n function writeFloat_ieee754(writeUint, val, buf, pos) {\n var sign = val < 0 ? 1 : 0;\n if (sign)\n val = -val;\n if (val === 0)\n writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);\n else if (isNaN(val))\n writeUint(2143289344, buf, pos);\n else if (val > 3.4028234663852886e+38) // +-Infinity\n writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);\n else if (val < 1.1754943508222875e-38) // denormal\n writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);\n else {\n var exponent = Math.floor(Math.log(val) / Math.LN2),\n mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;\n writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);\n }\n }\n\n exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);\n exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);\n\n function readFloat_ieee754(readUint, buf, pos) {\n var uint = readUint(buf, pos),\n sign = (uint >> 31) * 2 + 1,\n exponent = uint >>> 23 & 255,\n mantissa = uint & 8388607;\n return exponent === 255\n ? mantissa\n ? NaN\n : sign * Infinity\n : exponent === 0 // denormal\n ? sign * 1.401298464324817e-45 * mantissa\n : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);\n }\n\n exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);\n exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);\n\n })();\n\n // double: typed array\n if (typeof Float64Array !== \"undefined\") (function() {\n\n var f64 = new Float64Array([-0]),\n f8b = new Uint8Array(f64.buffer),\n le = f8b[7] === 128;\n\n function writeDouble_f64_cpy(val, buf, pos) {\n f64[0] = val;\n buf[pos ] = f8b[0];\n buf[pos + 1] = f8b[1];\n buf[pos + 2] = f8b[2];\n buf[pos + 3] = f8b[3];\n buf[pos + 4] = f8b[4];\n buf[pos + 5] = f8b[5];\n buf[pos + 6] = f8b[6];\n buf[pos + 7] = f8b[7];\n }\n\n function writeDouble_f64_rev(val, buf, pos) {\n f64[0] = val;\n buf[pos ] = f8b[7];\n buf[pos + 1] = f8b[6];\n buf[pos + 2] = f8b[5];\n buf[pos + 3] = f8b[4];\n buf[pos + 4] = f8b[3];\n buf[pos + 5] = f8b[2];\n buf[pos + 6] = f8b[1];\n buf[pos + 7] = f8b[0];\n }\n\n /* istanbul ignore next */\n exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;\n /* istanbul ignore next */\n exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;\n\n function readDouble_f64_cpy(buf, pos) {\n f8b[0] = buf[pos ];\n f8b[1] = buf[pos + 1];\n f8b[2] = buf[pos + 2];\n f8b[3] = buf[pos + 3];\n f8b[4] = buf[pos + 4];\n f8b[5] = buf[pos + 5];\n f8b[6] = buf[pos + 6];\n f8b[7] = buf[pos + 7];\n return f64[0];\n }\n\n function readDouble_f64_rev(buf, pos) {\n f8b[7] = buf[pos ];\n f8b[6] = buf[pos + 1];\n f8b[5] = buf[pos + 2];\n f8b[4] = buf[pos + 3];\n f8b[3] = buf[pos + 4];\n f8b[2] = buf[pos + 5];\n f8b[1] = buf[pos + 6];\n f8b[0] = buf[pos + 7];\n return f64[0];\n }\n\n /* istanbul ignore next */\n exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;\n /* istanbul ignore next */\n exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;\n\n // double: ieee754\n })(); else (function() {\n\n function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {\n var sign = val < 0 ? 1 : 0;\n if (sign)\n val = -val;\n if (val === 0) {\n writeUint(0, buf, pos + off0);\n writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);\n } else if (isNaN(val)) {\n writeUint(0, buf, pos + off0);\n writeUint(2146959360, buf, pos + off1);\n } else if (val > 1.7976931348623157e+308) { // +-Infinity\n writeUint(0, buf, pos + off0);\n writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);\n } else {\n var mantissa;\n if (val < 2.2250738585072014e-308) { // denormal\n mantissa = val / 5e-324;\n writeUint(mantissa >>> 0, buf, pos + off0);\n writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);\n } else {\n var exponent = Math.floor(Math.log(val) / Math.LN2);\n if (exponent === 1024)\n exponent = 1023;\n mantissa = val * Math.pow(2, -exponent);\n writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);\n writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);\n }\n }\n }\n\n exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);\n exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);\n\n function readDouble_ieee754(readUint, off0, off1, buf, pos) {\n var lo = readUint(buf, pos + off0),\n hi = readUint(buf, pos + off1);\n var sign = (hi >> 31) * 2 + 1,\n exponent = hi >>> 20 & 2047,\n mantissa = 4294967296 * (hi & 1048575) + lo;\n return exponent === 2047\n ? mantissa\n ? NaN\n : sign * Infinity\n : exponent === 0 // denormal\n ? sign * 5e-324 * mantissa\n : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);\n }\n\n exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);\n exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);\n\n })();\n\n return exports;\n}\n\n// uint helpers\n\nfunction writeUintLE(val, buf, pos) {\n buf[pos ] = val & 255;\n buf[pos + 1] = val >>> 8 & 255;\n buf[pos + 2] = val >>> 16 & 255;\n buf[pos + 3] = val >>> 24;\n}\n\nfunction writeUintBE(val, buf, pos) {\n buf[pos ] = val >>> 24;\n buf[pos + 1] = val >>> 16 & 255;\n buf[pos + 2] = val >>> 8 & 255;\n buf[pos + 3] = val & 255;\n}\n\nfunction readUintLE(buf, pos) {\n return (buf[pos ]\n | buf[pos + 1] << 8\n | buf[pos + 2] << 16\n | buf[pos + 3] << 24) >>> 0;\n}\n\nfunction readUintBE(buf, pos) {\n return (buf[pos ] << 24\n | buf[pos + 1] << 16\n | buf[pos + 2] << 8\n | buf[pos + 3]) >>> 0;\n}\n","\"use strict\";\n\nvar fs = null;\ntry {\n fs = require(1);\n if (!fs || !fs.readFile || !fs.readFileSync)\n fs = null;\n} catch (e) {\n // `fs` is unavailable in browsers and browser-like bundles.\n}\nmodule.exports = fs;\n","\"use strict\";\nmodule.exports = LongBits;\n\nvar Long;\n\n/**\n * Constructs new long bits.\n * @classdesc Helper class for working with the low and high bits of a 64 bit value.\n * @memberof util\n * @constructor\n * @param {number} lo Low 32 bits, unsigned\n * @param {number} hi High 32 bits, unsigned\n */\nfunction LongBits(lo, hi) {\n\n // note that the casts below are theoretically unnecessary as of today, but older statically\n // generated converter code might still call the ctor with signed 32bits. kept for compat.\n\n /**\n * Low bits.\n * @type {number}\n */\n this.lo = lo >>> 0;\n\n /**\n * High bits.\n * @type {number}\n */\n this.hi = hi >>> 0;\n}\n\n/**\n * Zero bits.\n * @memberof util.LongBits\n * @type {util.LongBits}\n */\nvar zero = LongBits.zero = new LongBits(0, 0);\n\nzero.toNumber = function() { return 0; };\nzero.zzEncode = zero.zzDecode = function() { return this; };\nzero.length = function() { return 1; };\n\n/**\n * Zero hash.\n * @memberof util.LongBits\n * @type {string}\n */\nvar zeroHash = LongBits.zeroHash = \"\\0\\0\\0\\0\\0\\0\\0\\0\";\n\n/**\n * Constructs new long bits from the specified number.\n * @param {number} value Value\n * @returns {util.LongBits} Instance\n */\nLongBits.fromNumber = function fromNumber(value) {\n if (value === 0)\n return zero;\n var sign = value < 0;\n if (sign)\n value = -value;\n var lo = value >>> 0,\n hi = (value - lo) / 4294967296 >>> 0;\n if (sign) {\n hi = ~hi >>> 0;\n lo = ~lo >>> 0;\n if (++lo > 4294967295) {\n lo = 0;\n if (++hi > 4294967295)\n hi = 0;\n }\n }\n return new LongBits(lo, hi);\n};\n\n/**\n * Constructs new long bits from a number, long or string.\n * @param {Long|number|string} value Value\n * @returns {util.LongBits} Instance\n */\nLongBits.from = function from(value) {\n if (typeof value === \"number\")\n return LongBits.fromNumber(value);\n if (typeof value === \"string\" || value instanceof String) {\n /* istanbul ignore else */\n if (Long)\n value = Long.fromString(value);\n else\n return LongBits.fromNumber(parseInt(value, 10));\n }\n return value.low || value.high ? new LongBits(value.low >>> 0, value.high >>> 0) : zero;\n};\n\n/**\n * Converts this long bits to a possibly unsafe JavaScript number.\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {number} Possibly unsafe number\n */\nLongBits.prototype.toNumber = function toNumber(unsigned) {\n if (!unsigned && this.hi >>> 31) {\n var lo = ~this.lo + 1 >>> 0,\n hi = ~this.hi >>> 0;\n if (!lo)\n hi = hi + 1 >>> 0;\n return -(lo + hi * 4294967296);\n }\n return this.lo + this.hi * 4294967296;\n};\n\n/**\n * Converts this long bits to a long.\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {Long} Long\n */\nLongBits.prototype.toLong = function toLong(unsigned) {\n return Long\n ? new Long(this.lo | 0, this.hi | 0, Boolean(unsigned))\n /* istanbul ignore next */\n : { low: this.lo | 0, high: this.hi | 0, unsigned: Boolean(unsigned) };\n};\n\nvar charCodeAt = String.prototype.charCodeAt;\n\n/**\n * Constructs new long bits from the specified 8 characters long hash.\n * @param {string} hash Hash\n * @returns {util.LongBits} Bits\n */\nLongBits.fromHash = function fromHash(hash) {\n if (hash === zeroHash)\n return zero;\n return new LongBits(\n ( charCodeAt.call(hash, 0)\n | charCodeAt.call(hash, 1) << 8\n | charCodeAt.call(hash, 2) << 16\n | charCodeAt.call(hash, 3) << 24) >>> 0\n ,\n ( charCodeAt.call(hash, 4)\n | charCodeAt.call(hash, 5) << 8\n | charCodeAt.call(hash, 6) << 16\n | charCodeAt.call(hash, 7) << 24) >>> 0\n );\n};\n\n/**\n * Converts this long bits to a 8 characters long hash.\n * @returns {string} Hash\n */\nLongBits.prototype.toHash = function toHash() {\n return String.fromCharCode(\n this.lo & 255,\n this.lo >>> 8 & 255,\n this.lo >>> 16 & 255,\n this.lo >>> 24 ,\n this.hi & 255,\n this.hi >>> 8 & 255,\n this.hi >>> 16 & 255,\n this.hi >>> 24\n );\n};\n\n/**\n * Zig-zag encodes this long bits.\n * @returns {util.LongBits} `this`\n */\nLongBits.prototype.zzEncode = function zzEncode() {\n var mask = this.hi >> 31;\n this.hi = ((this.hi << 1 | this.lo >>> 31) ^ mask) >>> 0;\n this.lo = ( this.lo << 1 ^ mask) >>> 0;\n return this;\n};\n\n/**\n * Zig-zag decodes this long bits.\n * @returns {util.LongBits} `this`\n */\nLongBits.prototype.zzDecode = function zzDecode() {\n var mask = -(this.lo & 1);\n this.lo = ((this.lo >>> 1 | this.hi << 31) ^ mask) >>> 0;\n this.hi = ( this.hi >>> 1 ^ mask) >>> 0;\n return this;\n};\n\n/**\n * Calculates the length of this longbits when encoded as a varint.\n * @returns {number} Length\n */\nLongBits.prototype.length = function length() {\n var part0 = this.lo,\n part1 = (this.lo >>> 28 | this.hi << 4) >>> 0,\n part2 = this.hi >>> 24;\n return part2 === 0\n ? part1 === 0\n ? part0 < 16384\n ? part0 < 128 ? 1 : 2\n : part0 < 2097152 ? 3 : 4\n : part1 < 16384\n ? part1 < 128 ? 5 : 6\n : part1 < 2097152 ? 7 : 8\n : part2 < 128 ? 9 : 10;\n};\n\nLongBits._configure = function(Long_) {\n Long = Long_;\n};\n","\"use strict\";\n/* global globalThis */\nvar util = exports;\n\n// used to return a Promise where callback is omitted\nutil.asPromise = require(29);\n\n// converts to / from base64 encoded strings\nutil.base64 = require(30);\n\n// base class of rpc.Service\nutil.EventEmitter = require(32);\n\n// float handling accross browsers\nutil.float = require(34);\n\n// converts to / from utf8 encoded strings\nutil.utf8 = require(41);\n\n// provides a node-like buffer pool in the browser\nutil.pool = require(40);\n\n// utility to work with the low and high bits of a 64 bit value\nutil.LongBits = require(36);\n\n/**\n * Tests if the specified key can affect object prototypes.\n * @memberof util\n * @param {string} key Key to test\n * @returns {boolean} `true` if the key is unsafe\n */\nfunction isUnsafeProperty(key) {\n return key === \"__proto__\" || key === \"prototype\" || key === \"constructor\";\n}\n\nutil.isUnsafeProperty = isUnsafeProperty;\n\n/**\n * Whether running within node or not.\n * @memberof util\n * @type {boolean}\n */\nutil.isNode = Boolean(typeof global !== \"undefined\"\n && global\n && global.process\n && global.process.versions\n && global.process.versions.node);\n\n/**\n * Global object reference.\n * @memberof util\n * @type {Object}\n */\nutil.global = util.isNode && global\n || typeof window !== \"undefined\" && window\n || typeof self !== \"undefined\" && self\n || typeof globalThis !== \"undefined\" && globalThis\n || this; // eslint-disable-line no-invalid-this\n\n/**\n * An immuable empty array.\n * @memberof util\n * @type {Array.<*>}\n * @const\n */\nutil.emptyArray = Object.freeze ? Object.freeze([]) : /* istanbul ignore next */ []; // used on prototypes\n\n/**\n * An immutable empty object.\n * @type {Object}\n * @const\n */\nutil.emptyObject = Object.freeze ? Object.freeze({}) : /* istanbul ignore next */ {}; // used on prototypes\n\n/**\n * Tests if the specified value is an integer.\n * @function\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is an integer\n */\nutil.isInteger = Number.isInteger || /* istanbul ignore next */ function isInteger(value) {\n return typeof value === \"number\" && isFinite(value) && Math.floor(value) === value;\n};\n\n/**\n * Tests if the specified value is a string.\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is a string\n */\nutil.isString = function isString(value) {\n return typeof value === \"string\" || value instanceof String;\n};\n\n/**\n * Tests if the specified value is a non-null object.\n * @param {*} value Value to test\n * @returns {boolean} `true` if the value is a non-null object\n */\nutil.isObject = function isObject(value) {\n return value && typeof value === \"object\";\n};\n\n/**\n * Checks if a property on a message is considered to be present.\n * This is an alias of {@link util.isSet}.\n * @function\n * @param {Object} obj Plain object or message instance\n * @param {string} prop Property name\n * @returns {boolean} `true` if considered to be present, otherwise `false`\n */\nutil.isset =\n\n/**\n * Checks if a property on a message is considered to be present.\n * @param {Object} obj Plain object or message instance\n * @param {string} prop Property name\n * @returns {boolean} `true` if considered to be present, otherwise `false`\n */\nutil.isSet = function isSet(obj, prop) {\n var value = obj[prop];\n if (value != null && Object.hasOwnProperty.call(obj, prop)) // eslint-disable-line eqeqeq\n return typeof value !== \"object\" || (Array.isArray(value) ? value.length : Object.keys(value).length) > 0;\n return false;\n};\n\n/**\n * Any compatible Buffer instance.\n * This is a minimal stand-alone definition of a Buffer instance. The actual type is that exported by node's typings.\n * @interface Buffer\n * @extends Uint8Array\n */\n\n/**\n * Node's Buffer class if available.\n * @type {Constructor<Buffer>}\n */\nutil.Buffer = (function() {\n try {\n var Buffer = util.global.Buffer;\n // refuse to use non-node buffers if not explicitly assigned (perf reasons)\n return Buffer.prototype.utf8Write || util.isNode ? Buffer : /* istanbul ignore next */ null;\n } catch (e) {\n /* istanbul ignore next */\n return null;\n }\n})();\n\n/**\n * Creates a new buffer of whatever type supported by the environment.\n * @param {number|number[]} [sizeOrArray=0] Buffer size or number array\n * @returns {Uint8Array|Buffer} Buffer\n */\nutil.newBuffer = function newBuffer(sizeOrArray) {\n var Buffer = util.Buffer;\n /* istanbul ignore next */\n return typeof sizeOrArray === \"number\"\n ? Buffer\n ? Buffer.allocUnsafe(sizeOrArray)\n : new Uint8Array(sizeOrArray)\n : Buffer\n ? Buffer.from(sizeOrArray)\n : new Uint8Array(sizeOrArray);\n};\n\n/**\n * Prepends a raw field tag to raw field data.\n * @param {number} id Field id\n * @param {number} wireType Wire type\n * @param {Uint8Array} data Raw field data\n * @returns {Uint8Array|Buffer} Raw field bytes\n * @ignore\n */\nutil.rawField = function rawField(id, wireType, data) {\n var out = [],\n tag = id << 3 | wireType;\n tag >>>= 0;\n while (tag > 127) {\n out.push(tag & 127 | 128);\n tag >>>= 7;\n }\n out.push(tag);\n for (var i = 0; i < data.length; ++i)\n out.push(data[i]);\n return util.newBuffer(out);\n};\n\n/**\n * Array implementation used in the browser.\n * @type {Constructor<Uint8Array>}\n * @deprecated Use `Uint8Array` instead.\n */\nutil.Array = Uint8Array;\n\n/**\n * Any compatible Long instance.\n * This is a minimal stand-alone definition of a Long instance. The actual type is that exported by long.js.\n * @interface Long\n * @property {number} low Low bits\n * @property {number} high High bits\n * @property {boolean} unsigned Whether unsigned or not\n */\n\n/**\n * Long.js's Long class if available.\n * @type {Constructor<Long>}\n */\nutil.Long = /* istanbul ignore next */ util.global.dcodeIO && /* istanbul ignore next */ util.global.dcodeIO.Long\n || /* istanbul ignore next */ util.global.Long\n || (function() {\n try {\n var Long = require(\"long\");\n return Long && Long.isLong ? Long : null;\n } catch (e) {\n /* istanbul ignore next */\n return null;\n }\n })();\n\n/**\n * Regular expression used to verify 2 bit (`bool`) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key2Re = /^(?:true|false|0|1)$/;\n\n/**\n * Regular expression used to verify 32 bit (`int32` etc.) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key32Re = /^-?(?:0|[1-9][0-9]*)$/;\n\n/**\n * Regular expression used to verify 64 bit (`int64` etc.) map keys.\n * @type {RegExp}\n * @const\n */\nutil.key64Re = /^(?:[\\x00-\\xff]{8}|-?(?:0|[1-9][0-9]*))$/; // eslint-disable-line no-control-regex\n\n/**\n * Converts a number or long to an 8 characters long hash string.\n * @param {Long|number} value Value to convert\n * @returns {string} Hash\n */\nutil.longToHash = function longToHash(value) {\n return value\n ? util.LongBits.from(value).toHash()\n : util.LongBits.zeroHash;\n};\n\n/**\n * Converts an 8 characters long hash string to a long or number.\n * @param {string} hash Hash\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {Long|number} Original value\n */\nutil.longFromHash = function longFromHash(hash, unsigned) {\n var bits = util.LongBits.fromHash(hash);\n if (util.Long)\n return util.Long.fromBits(bits.lo, bits.hi, unsigned);\n return bits.toNumber(Boolean(unsigned));\n};\n\n/**\n * Converts a 64 bit key to a long or number if it is an 8 characters long hash string.\n * @param {string} key Map key\n * @param {boolean} [unsigned=false] Whether unsigned or not\n * @returns {Long|number|string} Original value\n */\nutil.longFromKey = function longFromKey(key, unsigned) {\n return util.key64Re.test(key) && !util.key32Re.test(key)\n ? util.longFromHash(key, unsigned)\n : key;\n};\n\n/**\n * Converts a boolean key to a boolean value.\n * @param {string} key Map key\n * @returns {boolean} Boolean value\n */\nutil.boolFromKey = function boolFromKey(key) {\n return key === \"true\" || key === \"1\";\n};\n\n/**\n * Merges the properties of the source object into the destination object.\n * @memberof util\n * @param {Object.<string,*>} dst Destination object\n * @param {...(Object.<string,*>|boolean)} src Source objects, optionally followed by an `ifNotSet` flag\n * @returns {Object.<string,*>} Destination object\n */\nfunction merge(dst) { // used by converters\n var ifNotSet = typeof arguments[arguments.length - 1] === \"boolean\",\n limit = ifNotSet ? arguments.length - 1 : arguments.length;\n ifNotSet = ifNotSet && arguments[arguments.length - 1];\n for (var a = 1; a < limit; ++a) {\n var src = arguments[a];\n if (!src)\n continue;\n for (var keys = Object.keys(src), i = 0; i < keys.length; ++i)\n if (!isUnsafeProperty(keys[i]) && (!ifNotSet || !Object.prototype.hasOwnProperty.call(dst, keys[i]) || dst[keys[i]] === undefined))\n dst[keys[i]] = src[keys[i]];\n }\n return dst;\n}\n\nutil.merge = merge;\n\n/**\n * Schema declaration nesting limit.\n * @memberof util\n * @type {number}\n */\nutil.nestingLimit = 32; // protoc: MaxMessageDeclarationNestingDepth\n\n/**\n * Recursion limit.\n * @memberof util\n * @type {number}\n */\nutil.recursionLimit = 100; // protoc: CodedInputStream::default_recursion_limit_\n\n/**\n * Makes a property safe for assignment as an own property.\n * @memberof util\n * @param {Object.<string,*>} obj Object\n * @param {string} key Property key\n * @param {boolean} [enumerable=true] Whether the property should be enumerable\n * @returns {undefined}\n */\nutil.makeProp = function makeProp(obj, key, enumerable) {\n if (Object.prototype.hasOwnProperty.call(obj, key))\n return;\n Object.defineProperty(obj, key, {\n enumerable: enumerable === undefined ? true : enumerable,\n configurable: true,\n writable: true\n });\n};\n\n/**\n * Converts the first character of a string to lower case.\n * @param {string} str String to convert\n * @returns {string} Converted string\n */\nutil.lcFirst = function lcFirst(str) {\n return str.charAt(0).toLowerCase() + str.substring(1);\n};\n\n/**\n * Creates a custom error constructor.\n * @memberof util\n * @param {string} name Error name\n * @returns {Constructor<Error>} Custom error constructor\n */\nfunction newError(name) {\n\n function CustomError(message, properties) {\n\n if (!(this instanceof CustomError))\n return new CustomError(message, properties);\n\n // Error.call(this, message);\n // ^ just returns a new error instance because the ctor can be called as a function\n\n Object.defineProperty(this, \"message\", { get: function() { return message; } });\n\n /* istanbul ignore next */\n if (Error.captureStackTrace) // node\n Error.captureStackTrace(this, CustomError);\n else\n Object.defineProperty(this, \"stack\", { value: new Error().stack || \"\" });\n\n if (properties)\n merge(this, properties);\n }\n\n CustomError.prototype = Object.create(Error.prototype, {\n constructor: {\n value: CustomError,\n writable: true,\n enumerable: false,\n configurable: true,\n },\n name: {\n get: function get() { return name; },\n set: undefined,\n enumerable: false,\n // configurable: false would accurately preserve the behavior of\n // the original, but I'm guessing that was not intentional.\n // For an actual error subclass, this property would\n // be configurable.\n configurable: true,\n },\n toString: {\n value: function value() { return this.name + \": \" + this.message; },\n writable: true,\n enumerable: false,\n configurable: true,\n },\n });\n\n return CustomError;\n}\n\nutil.newError = newError;\n\n/**\n * Constructs a new protocol error.\n * @classdesc Error subclass indicating a protocol specifc error.\n * @memberof util\n * @extends Error\n * @template T extends Message<T>\n * @constructor\n * @param {string} message Error message\n * @param {Object.<string,*>} [properties] Additional properties\n * @example\n * try {\n * MyMessage.decode(someBuffer); // throws if required fields are missing\n * } catch (e) {\n * if (e instanceof ProtocolError && e.instance)\n * console.log(\"decoded so far: \" + JSON.stringify(e.instance));\n * }\n */\nutil.ProtocolError = newError(\"ProtocolError\");\n\n/**\n * So far decoded message instance.\n * @name util.ProtocolError#instance\n * @type {Message<T>}\n */\n\n/**\n * A OneOf getter as returned by {@link util.oneOfGetter}.\n * @typedef OneOfGetter\n * @type {function}\n * @returns {string|undefined} Set field name, if any\n */\n\n/**\n * Builds a getter for a oneof's present field name.\n * @param {string[]} fieldNames Field names\n * @returns {OneOfGetter} Unbound getter\n */\nutil.oneOfGetter = function getOneOf(fieldNames) {\n var fieldMap = {};\n for (var i = 0; i < fieldNames.length; ++i)\n fieldMap[fieldNames[i]] = 1;\n\n /**\n * @returns {string|undefined} Set field name, if any\n * @this Object\n * @ignore\n */\n return function() { // eslint-disable-line consistent-return\n for (var keys = Object.keys(this), i = keys.length - 1; i > -1; --i)\n if (fieldMap[keys[i]] === 1 && this[keys[i]] !== undefined && this[keys[i]] !== null)\n return keys[i];\n };\n};\n\n/**\n * A OneOf setter as returned by {@link util.oneOfSetter}.\n * @typedef OneOfSetter\n * @type {function}\n * @param {string|undefined} value Field name\n * @returns {undefined}\n */\n\n/**\n * Builds a setter for a oneof's present field name.\n * @param {string[]} fieldNames Field names\n * @returns {OneOfSetter} Unbound setter\n */\nutil.oneOfSetter = function setOneOf(fieldNames) {\n\n /**\n * @param {string} name Field name\n * @returns {undefined}\n * @this Object\n * @ignore\n */\n return function(name) {\n for (var i = 0; i < fieldNames.length; ++i)\n if (fieldNames[i] !== name)\n delete this[fieldNames[i]];\n };\n};\n\n/**\n * Default conversion options used for {@link Message#toJSON} implementations.\n *\n * These options are close to proto3's JSON mapping with the exception that internal types like Any are handled just like messages. More precisely:\n *\n * - Longs become strings\n * - Enums become string keys\n * - Bytes become base64 encoded strings\n * - (Sub-)Messages become plain objects\n * - Maps become plain objects with all string keys\n * - Repeated fields become arrays\n * - NaN and Infinity for float and double fields become strings\n *\n * @type {IConversionOptions}\n * @see https://developers.google.com/protocol-buffers/docs/proto3?hl=en#json\n */\nutil.toJSONOptions = {\n longs: String,\n enums: String,\n bytes: String,\n json: true\n};\n","\"use strict\";\n\n/**\n * A minimal path module to resolve Unix, Windows and URL paths alike.\n * @memberof util\n * @namespace\n */\nvar path = exports;\n\nvar urlRe = /^[a-zA-Z][a-zA-Z0-9+.-]+:\\/\\//;\n\nfunction normalizeUrl(path) {\n if (typeof URL === \"undefined\" || !urlRe.test(path))\n return null;\n try {\n return new URL(path).href;\n } catch (e) {\n return null;\n }\n}\n\nfunction resolveUrl(originPath, includePath) {\n if (typeof URL === \"undefined\" || !urlRe.test(originPath) || urlRe.test(includePath))\n return null;\n try {\n return new URL(includePath, originPath).href;\n } catch (e) {\n return null;\n }\n}\n\nvar isAbsolute =\n/**\n * Tests if the specified path is absolute.\n * @param {string} path Path to test\n * @returns {boolean} `true` if path is absolute\n */\npath.isAbsolute = function isAbsolute(path) {\n return /^(?:\\/|\\w+:|\\\\\\\\\\w+)/.test(path);\n};\n\nvar normalize =\n/**\n * Normalizes the specified path.\n * @param {string} path Path to normalize\n * @returns {string} Normalized path\n */\npath.normalize = function normalize(path) {\n var normalizedUrl = normalizeUrl(path);\n if (normalizedUrl)\n return normalizedUrl;\n var firstTwoCharacters = path.substring(0,2);\n var uncPrefix = \"\";\n if (firstTwoCharacters === \"\\\\\\\\\") {\n uncPrefix = firstTwoCharacters;\n path = path.substring(2);\n }\n\n path = path.replace(/\\\\/g, \"/\")\n .replace(/\\/{2,}/g, \"/\");\n var parts = path.split(\"/\"),\n absolute = isAbsolute(path),\n prefix = \"\";\n if (absolute)\n prefix = parts.shift() + \"/\";\n for (var i = 0; i < parts.length;) {\n if (parts[i] === \"..\") {\n if (i > 0 && parts[i - 1] !== \"..\")\n parts.splice(--i, 2);\n else if (absolute)\n parts.splice(i, 1);\n else\n ++i;\n } else if (parts[i] === \".\")\n parts.splice(i, 1);\n else\n ++i;\n }\n return uncPrefix + prefix + parts.join(\"/\");\n};\n\n/**\n * Resolves the specified include path against the specified origin path.\n * @param {string} originPath Path to the origin file\n * @param {string} includePath Include path relative to origin path\n * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized\n * @returns {string} Path to the include file\n */\npath.resolve = function resolve(originPath, includePath, alreadyNormalized) {\n var resolvedUrl = resolveUrl(originPath, includePath);\n if (resolvedUrl)\n return resolvedUrl;\n if (!alreadyNormalized)\n includePath = normalize(includePath); // path or absolute url\n if (isAbsolute(includePath))\n return includePath;\n if (!alreadyNormalized)\n originPath = normalize(originPath);\n return (originPath = originPath.replace(/(?:\\/|^)[^/]+$/, \"\")).length ? normalize(originPath + \"/\" + includePath) : includePath;\n};\n","\"use strict\";\n\nvar patterns = exports;\n\npatterns.numberRe = /^(?![eE])[0-9]*(?:\\.[0-9]*)?(?:[eE][+-]?[0-9]+)?$/;\npatterns.typeRefRe = /^(?:\\.?[a-zA-Z_][a-zA-Z_0-9]*)(?:\\.[a-zA-Z_][a-zA-Z_0-9]*)*$/;\npatterns.reservedRe = /^(?:do|if|in|for|let|new|try|var|case|else|enum|eval|false|null|this|true|void|with|break|catch|class|const|super|throw|while|yield|delete|export|import|public|return|static|switch|typeof|default|extends|finally|package|private|continue|debugger|function|arguments|interface|protected|implements|instanceof)$/;\n","\"use strict\";\nmodule.exports = pool;\n\n/**\n * An allocator as used by {@link util.pool}.\n * @typedef PoolAllocator\n * @type {function}\n * @param {number} size Buffer size\n * @returns {Uint8Array} Buffer\n */\n\n/**\n * A slicer as used by {@link util.pool}.\n * @typedef PoolSlicer\n * @type {function}\n * @param {number} start Start offset\n * @param {number} end End offset\n * @returns {Uint8Array} Buffer slice\n * @this Uint8Array\n */\n\n/**\n * A general purpose buffer pool.\n * @memberof util\n * @function\n * @param {PoolAllocator} alloc Allocator\n * @param {PoolSlicer} slice Slicer\n * @param {number} [size=8192] Slab size\n * @returns {PoolAllocator} Pooled allocator\n */\nfunction pool(alloc, slice, size) {\n var SIZE = size || 8192;\n var MAX = SIZE >>> 1;\n var slab = null;\n var offset = SIZE;\n return function pool_alloc(size) {\n if (size < 1 || size > MAX)\n return alloc(size);\n if (offset + size > SIZE) {\n slab = alloc(SIZE);\n offset = 0;\n }\n var buf = slice.call(slab, offset, offset += size);\n if (offset & 7) // align to 32 bit\n offset = (offset | 7) + 1;\n return buf;\n };\n}\n","\"use strict\";\n\n/**\n * A minimal UTF8 implementation.\n * @memberof util\n * @namespace\n */\nvar utf8 = exports,\n replacementChar = \"\\ufffd\",\n looseDecoder = new TextDecoder(\"utf-8\", { ignoreBOM: true }),\n strictDecoder;\nvar TEXT_DECODER_MIN_LENGTH = 64;\n\ntry {\n strictDecoder = new TextDecoder(\"utf-8\", { fatal: true, ignoreBOM: true });\n} catch (err) {\n // \"fatal\" option is not supported on Node.js compiled without ICU\n strictDecoder = looseDecoder;\n}\n\n/**\n * Calculates the UTF8 byte length of a string.\n * @param {string} string String\n * @returns {number} Byte length\n */\nutf8.length = function utf8_length(string) {\n var len = 0,\n c = 0;\n for (var i = 0; i < string.length; ++i) {\n c = string.charCodeAt(i);\n if (c < 128)\n len += 1;\n else if (c < 2048)\n len += 2;\n else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {\n ++i;\n len += 4;\n } else\n len += 3;\n }\n return len;\n};\n\nfunction utf8_read_js(buffer, start, end, str) {\n for (var i = start; i < end;) {\n var t = buffer[i++];\n if (t <= 0x7F) {\n str += String.fromCharCode(t);\n } else if (t >= 0xC0 && t < 0xE0) {\n var c2 = (t & 0x1F) << 6 | buffer[i++] & 0x3F;\n str += c2 >= 0x80 ? String.fromCharCode(c2) : replacementChar;\n } else if (t >= 0xE0 && t < 0xF0) {\n var c3 = (t & 0xF) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;\n str += c3 >= 0x800 ? String.fromCharCode(c3) : replacementChar;\n } else if (t >= 0xF0) {\n var t2 = (t & 7) << 18 | (buffer[i++] & 0x3F) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;\n if (t2 < 0x10000 || t2 > 0x10FFFF)\n str += replacementChar;\n else {\n t2 -= 0x10000;\n str += String.fromCharCode(0xD800 + (t2 >> 10));\n str += String.fromCharCode(0xDC00 + (t2 & 0x3FF));\n }\n }\n }\n return str;\n}\n\nfunction utf8_read_decoder(decoder, buffer, start, end) {\n var source = start === 0 && end === buffer.length\n ? buffer\n : buffer.subarray(start, end);\n return decoder.decode(source);\n}\n\n/**\n * Reads UTF8 bytes as a string.\n * @param {Uint8Array} buffer Source buffer\n * @param {number} start Source start\n * @param {number} end Source end\n * @returns {string} String read\n */\nutf8.read = function utf8_read_loose(buffer, start, end) {\n if (end - start < 1)\n return \"\";\n if (end - start >= TEXT_DECODER_MIN_LENGTH)\n return utf8_read_decoder(looseDecoder, buffer, start, end);\n\n var str = \"\",\n i = start,\n c1, c2, c3, c4, c5, c6, c7, c8;\n\n for (; i + 7 < end; i += 8) {\n c1 = buffer[i];\n c2 = buffer[i + 1];\n c3 = buffer[i + 2];\n c4 = buffer[i + 3];\n c5 = buffer[i + 4];\n c6 = buffer[i + 5];\n c7 = buffer[i + 6];\n c8 = buffer[i + 7];\n if ((c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8) & 0x80)\n return utf8_read_js(buffer, i, end, str);\n str += String.fromCharCode(c1, c2, c3, c4, c5, c6, c7, c8);\n }\n\n for (; i < end; ++i) {\n c1 = buffer[i];\n if (c1 & 0x80)\n return utf8_read_js(buffer, i, end, str);\n str += String.fromCharCode(c1);\n }\n\n return str;\n};\n\n/**\n * Reads UTF8 bytes as a string, rejecting invalid UTF8.\n * @param {Uint8Array} buffer Source buffer\n * @param {number} start Source start\n * @param {number} end Source end\n * @returns {string} String read\n */\nutf8.readStrict = function utf8_read_strict(buffer, start, end) {\n if (end - start < 1)\n return \"\";\n if (end - start >= TEXT_DECODER_MIN_LENGTH)\n return utf8_read_decoder(strictDecoder, buffer, start, end);\n\n var str = \"\",\n i = start,\n c1, c2, c3, c4, c5, c6, c7, c8;\n\n for (; i + 7 < end; i += 8) {\n c1 = buffer[i];\n c2 = buffer[i + 1];\n c3 = buffer[i + 2];\n c4 = buffer[i + 3];\n c5 = buffer[i + 4];\n c6 = buffer[i + 5];\n c7 = buffer[i + 6];\n c8 = buffer[i + 7];\n if ((c1 | c2 | c3 | c4 | c5 | c6 | c7 | c8) & 0x80)\n return str + utf8_read_decoder(strictDecoder, buffer, i, end);\n str += String.fromCharCode(c1, c2, c3, c4, c5, c6, c7, c8);\n }\n\n for (; i < end; ++i) {\n c1 = buffer[i];\n if (c1 & 0x80)\n return str + utf8_read_decoder(strictDecoder, buffer, i, end);\n str += String.fromCharCode(c1);\n }\n\n return str;\n};\n\n/**\n * Writes a string as UTF8 bytes.\n * @param {string} string Source string\n * @param {Uint8Array} buffer Destination buffer\n * @param {number} offset Destination offset\n * @returns {number} Bytes written\n */\nutf8.write = function utf8_write(string, buffer, offset) {\n var start = offset,\n c1, // character 1\n c2; // character 2\n for (var i = 0; i < string.length; ++i) {\n c1 = string.charCodeAt(i);\n if (c1 < 128) {\n buffer[offset++] = c1;\n } else if (c1 < 2048) {\n buffer[offset++] = c1 >> 6 | 192;\n buffer[offset++] = c1 & 63 | 128;\n } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {\n c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);\n ++i;\n buffer[offset++] = c1 >> 18 | 240;\n buffer[offset++] = c1 >> 12 & 63 | 128;\n buffer[offset++] = c1 >> 6 & 63 | 128;\n buffer[offset++] = c1 & 63 | 128;\n } else {\n buffer[offset++] = c1 >> 12 | 224;\n buffer[offset++] = c1 >> 6 & 63 | 128;\n buffer[offset++] = c1 & 63 | 128;\n }\n }\n return offset - start;\n};\n","\"use strict\";\nmodule.exports = verifier;\n\nvar Enum = require(6),\n util = require(28);\n\nfunction invalid(field, expected) {\n return field.name + \": \" + expected + (field.repeated && expected !== \"array\" ? \"[]\" : field.map && expected !== \"object\" ? \"{k:\"+field.keyType+\"}\" : \"\") + \" expected\";\n}\n\n/**\n * Generates a partial value verifier.\n * @param {Codegen} gen Codegen instance\n * @param {Field} field Reflected field\n * @param {number} fieldIndex Field index\n * @param {string} ref Variable reference\n * @returns {Codegen} Codegen instance\n * @ignore\n */\nfunction genVerifyValue(gen, field, fieldIndex, ref) {\n /* eslint-disable no-unexpected-multiline */\n var resolvedType = field.resolvedType;\n if (resolvedType) {\n if (resolvedType instanceof Enum) {\n if (resolvedType._features.enum_type === \"CLOSED\") { gen\n (\"switch(%s){\", ref)\n (\"default:\")\n (\"return%j\", invalid(field, \"enum value\"));\n for (var keys = Object.keys(resolvedType.values), j = 0; j < keys.length; ++j) gen\n (\"case %i:\", resolvedType.values[keys[j]]);\n gen\n (\"break\")\n (\"}\");\n } else gen\n (\"if(typeof %s!==\\\"number\\\"||(%s|0)!==%s)\", ref, ref, ref)\n (\"return%j\", invalid(field, \"enum value\"));\n } else {\n gen\n (\"{\")\n (\"var e=types[%i].verify(%s,q+1);\", fieldIndex, ref)\n (\"if(e)\")\n (\"return%j+e\", field.name + \".\")\n (\"}\");\n }\n } else {\n switch (field.type) {\n case \"int32\":\n case \"uint32\":\n case \"sint32\":\n case \"fixed32\":\n case \"sfixed32\": gen\n (\"if(!util.isInteger(%s))\", ref)\n (\"return%j\", invalid(field, \"integer\"));\n break;\n case \"int64\":\n case \"uint64\":\n case \"sint64\":\n case \"fixed64\":\n case \"sfixed64\": gen\n (\"if(!util.isInteger(%s)&&!(%s&&util.isInteger(%s.low)&&util.isInteger(%s.high)))\", ref, ref, ref, ref)\n (\"return%j\", invalid(field, \"integer|Long\"));\n break;\n case \"float\":\n case \"double\": gen\n (\"if(typeof %s!==\\\"number\\\")\", ref)\n (\"return%j\", invalid(field, \"number\"));\n break;\n case \"bool\": gen\n (\"if(typeof %s!==\\\"boolean\\\")\", ref)\n (\"return%j\", invalid(field, \"boolean\"));\n break;\n case \"string\": gen\n (\"if(!util.isString(%s))\", ref)\n (\"return%j\", invalid(field, \"string\"));\n break;\n case \"bytes\": gen\n (\"if(!(%s&&typeof %s.length===\\\"number\\\"||util.isString(%s)))\", ref, ref, ref)\n (\"return%j\", invalid(field, \"buffer\"));\n break;\n }\n }\n return gen;\n /* eslint-enable no-unexpected-multiline */\n}\n\n/**\n * Generates a partial key verifier.\n * @param {Codegen} gen Codegen instance\n * @param {Field} field Reflected field\n * @param {string} ref Variable reference\n * @returns {Codegen} Codegen instance\n * @ignore\n */\nfunction genVerifyKey(gen, field, ref) {\n /* eslint-disable no-unexpected-multiline */\n switch (field.keyType) {\n case \"int32\":\n case \"uint32\":\n case \"sint32\":\n case \"fixed32\":\n case \"sfixed32\": gen\n (\"if(!util.key32Re.test(%s))\", ref)\n (\"return%j\", invalid(field, \"integer key\"));\n break;\n case \"int64\":\n case \"uint64\":\n case \"sint64\":\n case \"fixed64\":\n case \"sfixed64\": gen\n (\"if(!util.key64Re.test(%s))\", ref) // see comment above: x is ok, d is not\n (\"return%j\", invalid(field, \"integer|Long key\"));\n break;\n case \"bool\": gen\n (\"if(!util.key2Re.test(%s))\", ref)\n (\"return%j\", invalid(field, \"boolean key\"));\n break;\n }\n return gen;\n /* eslint-enable no-unexpected-multiline */\n}\n\n/**\n * Generates a verifier specific to the specified message type.\n * @param {Type} mtype Message type\n * @returns {Codegen} Codegen instance\n */\nfunction verifier(mtype) {\n /* eslint-disable no-unexpected-multiline */\n\n var gen = util.codegen([\"m\", \"q\"])\n (\"if(typeof m!==\\\"object\\\"||m===null)\")\n (\"return%j\", \"object expected\")\n (\"if(q===undefined)q=0\")\n (\"if(q>util.recursionLimit)\")\n (\"return%j\", \"max depth exceeded\");\n var oneofs = mtype.oneofsArray,\n seenFirstField = {};\n if (oneofs.length) gen\n (\"var p={}\");\n\n for (var i = 0; i < /* initializes */ mtype.fieldsArray.length; ++i) {\n var field = mtype._fieldsArray[i].resolve(),\n ref = \"m\" + util.safeProp(field.name);\n\n if (field.optional) gen\n (\"if(%s!=null&&Object.hasOwnProperty.call(m,%j)){\", ref, field.name); // !== undefined && !== null\n\n // map fields\n if (field.map) { gen\n (\"if(!util.isObject(%s))\", ref)\n (\"return%j\", invalid(field, \"object\"))\n (\"var k=Object.keys(%s)\", ref)\n (\"for(var i=0;i<k.length;++i){\");\n genVerifyKey(gen, field, \"k[i]\");\n genVerifyValue(gen, field, i, ref + \"[k[i]]\")\n (\"}\");\n\n // repeated fields\n } else if (field.repeated) { gen\n (\"if(!Array.isArray(%s))\", ref)\n (\"return%j\", invalid(field, \"array\"))\n (\"for(var i=0;i<%s.length;++i){\", ref);\n genVerifyValue(gen, field, i, ref + \"[i]\")\n (\"}\");\n\n // required or present fields\n } else {\n if (field.partOf) {\n var oneofProp = util.safeProp(field.partOf.name);\n if (seenFirstField[field.partOf.name] === 1) gen\n (\"if(p%s===1)\", oneofProp)\n (\"return%j\", field.partOf.name + \": multiple values\");\n seenFirstField[field.partOf.name] = 1;\n gen\n (\"p%s=1\", oneofProp);\n }\n genVerifyValue(gen, field, i, ref);\n }\n if (field.optional) gen\n (\"}\");\n }\n return gen\n (\"return null\");\n /* eslint-enable no-unexpected-multiline */\n}\n","\"use strict\";\n\n/**\n * Wrappers for common types.\n * @type {Object.<string,IWrapper>}\n * @const\n */\nvar wrappers = exports;\n\nvar Message = require(12),\n util = require(37);\n\n/**\n * From object converter part of an {@link IWrapper}.\n * @typedef WrapperFromObjectConverter\n * @type {function}\n * @param {Object.<string,*>} object Plain object\n * @returns {Message<{}>} Message instance\n * @this Type\n */\n\n/**\n * To object converter part of an {@link IWrapper}.\n * @typedef WrapperToObjectConverter\n * @type {function}\n * @param {Message<{}>} message Message instance\n * @param {IConversionOptions} [options] Conversion options\n * @returns {Object.<string,*>} Plain object\n * @this Type\n */\n\n/**\n * Common type wrapper part of {@link wrappers}.\n * @interface IWrapper\n * @property {WrapperFromObjectConverter} [fromObject] From object converter\n * @property {WrapperToObjectConverter} [toObject] To object converter\n */\n\n// Custom wrapper for Any\nwrappers[\".google.protobuf.Any\"] = {\n\n fromObject: function(object, depth) {\n\n // unwrap value type if mapped\n if (object && object[\"@type\"]) {\n // Only use fully qualified type name after the last '/'\n var name = object[\"@type\"].substring(object[\"@type\"].lastIndexOf(\"/\") + 1);\n var type = this.lookup(name, [ this.constructor ]);\n /* istanbul ignore else */\n if (type) {\n // type_url does not accept leading \".\"\n var type_url = object[\"@type\"].charAt(0) === \".\" ?\n object[\"@type\"].slice(1) : object[\"@type\"];\n // type_url prefix is optional, but path seperator is required\n if (type_url.indexOf(\"/\") === -1) {\n type_url = \"/\" + type_url;\n }\n return this.create({\n type_url: type_url,\n value: type.encode(type.fromObject(object, depth === undefined ? 1 : depth + 1)).finish()\n });\n }\n }\n\n return this.fromObject(object, depth);\n },\n\n toObject: function(message, options, depth) {\n if (depth === undefined)\n depth = 0;\n if (depth > util.recursionLimit)\n throw Error(\"max depth exceeded\");\n\n // Default prefix\n var googleApi = \"type.googleapis.com/\";\n var prefix = \"\";\n var name = \"\";\n // decode value if requested and unmapped\n if (options && options.json && message.type_url && message.value) {\n // Only use fully qualified type name after the last '/'\n name = message.type_url.substring(message.type_url.lastIndexOf(\"/\") + 1);\n // Separate the prefix used\n prefix = message.type_url.substring(0, message.type_url.lastIndexOf(\"/\") + 1);\n var type = this.lookup(name, [ this.constructor ]);\n /* istanbul ignore else */\n if (type)\n message = type.decode(message.value, undefined, undefined, depth + 1);\n }\n\n // wrap value if unmapped\n if (!(message instanceof this.ctor) && message instanceof Message) {\n var object = message.$type.toObject(message, options, depth + 1);\n var messageName = message.$type.fullName[0] === \".\" ?\n message.$type.fullName.slice(1) : message.$type.fullName;\n // Default to type.googleapis.com prefix if no prefix is used\n if (prefix === \"\") {\n prefix = googleApi;\n }\n name = prefix + messageName;\n object[\"@type\"] = name;\n return object;\n }\n\n return this.toObject(message, options, depth);\n }\n};\n","\"use strict\";\nmodule.exports = Writer;\n\nvar util = require(37);\n\nvar BufferWriter; // cyclic\n\nvar LongBits = util.LongBits,\n base64 = util.base64,\n utf8 = util.utf8;\n\n/**\n * Constructs a new writer instance.\n * @classdesc Wire format writer using `Uint8Array`.\n * @constructor\n */\nfunction Writer() {\n\n /**\n * Write cursor into {@link Writer#buf}.\n * @type {number}\n */\n this.pos = 0;\n\n /**\n * Backing buffer.\n * @type {Uint8Array}\n */\n this.buf = this.constructor.alloc(64);\n\n /**\n * Cached DataView over {@link Writer#buf}.\n * @type {DataView|null}\n */\n this.view = null;\n\n /**\n * Stack of forked length-prefix positions.\n * @type {Array<number>|null}\n */\n this.states = null;\n}\n\n/**\n * Current write position.\n * @name Writer#len\n * @type {number}\n * @deprecated Use {@link Writer#pos} instead.\n */\nObject.defineProperty(Writer.prototype, \"len\", {\n configurable: true,\n enumerable: true,\n get: function get_len() {\n return this.pos;\n }\n});\n\nvar create = function create() {\n return util.Buffer\n ? function create_buffer_setup() {\n return (Writer.create = function create_buffer() {\n return new BufferWriter();\n })();\n }\n /* istanbul ignore next */\n : function create_array() {\n return new Writer();\n };\n};\n\n/**\n * Creates a new writer.\n * @function\n * @returns {BufferWriter|Writer} A {@link BufferWriter} when Buffers are supported, otherwise a {@link Writer}\n */\nWriter.create = create();\n\n/**\n * Allocates a buffer of the specified size.\n * @param {number} size Buffer size\n * @returns {Uint8Array} Buffer\n */\nWriter.alloc = function alloc(size) {\n return new Uint8Array(size);\n};\n\n// Use Uint8Array buffer pool in the browser, just like node does with buffers\nWriter.alloc = util.pool(Writer.alloc, Uint8Array.prototype.subarray);\n\n/**\n * Calculates the number of bytes a value occupies as a varint.\n * @param {number} value Value to size (unsigned)\n * @returns {number} Byte length (1..5)\n * @ignore\n */\nfunction sizeVarint32(value) {\n return value < 128 ? 1\n : value < 16384 ? 2\n : value < 2097152 ? 3\n : value < 268435456 ? 4\n : 5;\n}\n\n/**\n * Ensures that at least `n` more bytes fit into the backing buffer, doubling it if not.\n * @param {number} n Number of additional bytes required\n * @returns {undefined}\n * @private\n */\nWriter.prototype._reserve = function _reserve(n) {\n var need = this.pos + n;\n if (need > this.buf.length) {\n var size = this.buf.length << 1;\n if (size < need)\n size = need;\n var buf = this.constructor.alloc(size);\n buf.set(this.buf.subarray(0, this.pos), 0);\n this.buf = buf;\n this.view = null; // invalidate\n }\n};\n\nfunction writeStringAscii(val, buf, pos) {\n for (var i = 0; i < val.length;)\n buf[pos++] = val.charCodeAt(i++);\n}\n\nfunction writeVarint32(val, buf, pos) {\n while (val > 127) {\n buf[pos++] = val & 127 | 128;\n val >>>= 7;\n }\n buf[pos] = val;\n return pos + 1;\n}\n\n/**\n * Writes an unsigned 32 bit value as a varint.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.uint32 = function write_uint32(value) {\n value = value >>> 0;\n this._reserve(5);\n var pos = this.pos;\n this.pos = writeVarint32(value, this.buf, pos);\n return this;\n};\n\n/**\n * Writes a signed 32 bit value as a varint.\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.int32 = function write_int32(value) {\n if ((value |= 0) < 0) { // 10 bytes per spec\n this._reserve(10);\n writeVarint64(LongBits.fromNumber(value), this.buf, this.pos);\n this.pos += 10;\n return this;\n }\n return this.uint32(value);\n};\n\n/**\n * Writes a 32 bit value as a varint, zig-zag encoded.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sint32 = function write_sint32(value) {\n return this.uint32((value << 1 ^ value >> 31) >>> 0);\n};\n\nfunction writeVarint64(val, buf, pos) {\n var lo = val.lo,\n hi = val.hi;\n while (hi) {\n buf[pos++] = lo & 127 | 128;\n lo = (lo >>> 7 | hi << 25) >>> 0;\n hi >>>= 7;\n }\n while (lo > 127) {\n buf[pos++] = lo & 127 | 128;\n lo = lo >>> 7;\n }\n buf[pos] = lo;\n return pos + 1;\n}\n\n/**\n * Writes an unsigned 64 bit value as a varint.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.uint64 = function write_uint64(value) {\n var bits = LongBits.from(value);\n this._reserve(10);\n var pos = this.pos;\n this.pos = writeVarint64(bits, this.buf, pos);\n return this;\n};\n\n/**\n * Writes a signed 64 bit value as a varint.\n * @function\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.int64 = Writer.prototype.uint64;\n\n/**\n * Writes a signed 64 bit value as a varint, zig-zag encoded.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.sint64 = function write_sint64(value) {\n var bits = LongBits.from(value).zzEncode();\n this._reserve(10);\n var pos = this.pos;\n this.pos = writeVarint64(bits, this.buf, pos);\n return this;\n};\n\n/**\n * Writes a boolish value as a varint.\n * @param {boolean} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.bool = function write_bool(value) {\n this._reserve(1);\n this.buf[this.pos++] = value ? 1 : 0;\n return this;\n};\n\nfunction writeFixed32(val, buf, pos) {\n buf[pos ] = val & 255;\n buf[pos + 1] = val >>> 8 & 255;\n buf[pos + 2] = val >>> 16 & 255;\n buf[pos + 3] = val >>> 24;\n}\n\n/**\n * Writes an unsigned 32 bit value as fixed 32 bits.\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.fixed32 = function write_fixed32(value) {\n this._reserve(4);\n writeFixed32(value >>> 0, this.buf, this.pos);\n this.pos += 4;\n return this;\n};\n\n/**\n * Writes a signed 32 bit value as fixed 32 bits.\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sfixed32 = Writer.prototype.fixed32;\n\n/**\n * Writes an unsigned 64 bit value as fixed 64 bits.\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.fixed64 = function write_fixed64(value) {\n var bits = LongBits.from(value);\n this._reserve(8);\n writeFixed32(bits.lo, this.buf, this.pos);\n writeFixed32(bits.hi, this.buf, this.pos + 4);\n this.pos += 8;\n return this;\n};\n\n/**\n * Writes a signed 64 bit value as fixed 64 bits.\n * @function\n * @param {Long|number|string} value Value to write\n * @returns {Writer} `this`\n * @throws {TypeError} If `value` is a string and no long library is present.\n */\nWriter.prototype.sfixed64 = Writer.prototype.fixed64;\n\n/**\n * Writes a float (32 bit).\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.float = function write_float(value) {\n this._reserve(4);\n util.float.writeFloatLE(value, this.buf, this.pos);\n this.pos += 4;\n return this;\n};\n\n/**\n * Writes a double (64 bit float).\n * @function\n * @param {number} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.double = function write_double(value) {\n this._reserve(8);\n util.float.writeDoubleLE(value, this.buf, this.pos);\n this.pos += 8;\n return this;\n};\n\n/**\n * Writes a sequence of bytes.\n * @param {Uint8Array|string} value Buffer or base64 encoded string to write\n * @returns {Writer} `this`\n */\nWriter.prototype.bytes = function write_bytes(value) {\n var len = value.length >>> 0;\n if (!len) {\n this._reserve(1);\n this.buf[this.pos++] = 0;\n return this;\n }\n if (util.isString(value)) {\n var buf = Writer.alloc(len = base64.length(value));\n base64.decode(value, buf, 0);\n value = buf;\n }\n this.uint32(len);\n this._reserve(len);\n this.buf.set(value, this.pos);\n this.pos += len;\n return this;\n};\n\n/**\n * Writes raw bytes without a tag or length prefix.\n * @param {Uint8Array} value Raw bytes\n * @returns {Writer} `this`\n */\nWriter.prototype.raw = function write_raw(value) {\n var len = value.length >>> 0;\n if (!len)\n return this;\n this._reserve(len);\n this.buf.set(value, this.pos);\n this.pos += len;\n return this;\n};\n\n/**\n * Backfills the length varint.\n * @param {number} pos Position of reserved length byte\n * @param {number} len Length of content after length varint\n * @returns {Writer} `this`\n * @private\n */\nWriter.prototype._delim = function _delim(pos, len) {\n var n = sizeVarint32(len);\n if (n > 1)\n this.buf.copyWithin(pos + n, pos + 1, pos + 1 + len);\n writeVarint32(len, this.buf, pos);\n this.pos = pos + n + len;\n return this;\n};\n\n/**\n * Writes a string.\n * @param {string} value Value to write\n * @returns {Writer} `this`\n */\nWriter.prototype.string = function write_string(value) {\n var n = value.length;\n if (!n) {\n this._reserve(1);\n this.buf[this.pos++] = 0;\n return this;\n }\n if (n < 0x80) {\n this._reserve(n * 3 + 5); // worst case\n var lenPos = this.pos;\n return this._delim(lenPos, utf8.write(value, this.buf, lenPos + 1));\n }\n var len = utf8.length(value);\n this.uint32(len);\n this._reserve(len);\n if (len === value.length)\n writeStringAscii(value, this.buf, this.pos);\n else\n utf8.write(value, this.buf, this.pos);\n this.pos += len;\n return this;\n};\n\n/**\n * Writes an array of unsigned 32 bit values as a packed repeated field.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.uint32s = function write_uint32s(value) {\n var n = value.length;\n this._reserve(n * 5 + 5); // worst case: 5 bytes per value + length varint\n var buf = this.buf, lenPos = this.pos, p = lenPos + 1;\n for (var i = 0; i < n; ++i)\n p = writeVarint32(value[i] >>> 0, buf, p);\n return this._delim(lenPos, p - lenPos - 1);\n};\n\n/**\n * Writes an array of signed 32 bit values as a packed repeated field.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.int32s = function write_int32s(value) {\n var n = value.length;\n this._reserve(n * 10 + 5); // worst case: 10 bytes per negative value + length varint\n var buf = this.buf, lenPos = this.pos, pos = lenPos + 1, val;\n for (var i = 0; i < n; ++i) {\n if ((val = value[i] | 0) < 0) { // negatives are 10 bytes per spec\n pos = writeVarint64(LongBits.fromNumber(val), buf, pos);\n } else {\n pos = writeVarint32(val, buf, pos);\n }\n }\n return this._delim(lenPos, pos - lenPos - 1);\n};\n\n/**\n * Writes an array of 32 bit values as packed, zig-zag encoded varints.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sint32s = function write_sint32s(value) {\n var n = value.length;\n this._reserve(n * 5 + 5);\n var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;\n for (var i = 0; i < n; ++i)\n pos = writeVarint32((value[i] << 1 ^ value[i] >> 31) >>> 0, buf, pos);\n return this._delim(lenPos, pos - lenPos - 1);\n};\n\n/**\n * Writes an array of unsigned 64 bit values as a packed repeated field.\n * @param {Array.<Long|number|string>} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.uint64s = function write_uint64s(value) {\n var n = value.length;\n this._reserve(n * 10 + 5);\n var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;\n for (var i = 0; i < n; ++i) {\n pos = writeVarint64(LongBits.from(value[i]), buf, pos);\n }\n return this._delim(lenPos, pos - lenPos - 1);\n};\n\n/**\n * Writes an array of signed 64 bit values as a packed repeated field.\n * @function\n * @param {Array.<Long|number|string>} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.int64s = Writer.prototype.uint64s;\n\n/**\n * Writes an array of 64 bit values as packed, zig-zag encoded varints.\n * @param {Array.<Long|number|string>} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sint64s = function write_sint64s(value) {\n var n = value.length;\n this._reserve(n * 10 + 5);\n var buf = this.buf, lenPos = this.pos, pos = lenPos + 1;\n for (var i = 0; i < n; ++i) {\n pos = writeVarint64(LongBits.from(value[i]).zzEncode(), buf, pos);\n }\n return this._delim(lenPos, pos - lenPos - 1);\n};\n\n/**\n * Writes an array of boolish values as a packed repeated field.\n * @param {boolean[]} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.bools = function write_bools(value) {\n var n = value.length;\n this.uint32(n); // one byte per value\n this._reserve(n);\n var buf = this.buf, p = this.pos;\n for (var i = 0; i < n; ++i)\n buf[p++] = value[i] ? 1 : 0;\n this.pos += n;\n return this;\n};\n\n// The view allocation only pays off when amortized over enough writes\nvar VIEW_THRESHOLD_FLOAT = 16,\n VIEW_THRESHOLD_INT = 128;\n\nfunction getLazyView(writer, count, threshold) {\n var view = writer.view;\n if (view || count < threshold)\n return view;\n var buf = writer.buf;\n return writer.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);\n}\n\n/**\n * Writes an array of unsigned 32 bit values as packed, fixed 32 bits.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.fixed32s = function write_fixed32s(value) {\n var n = value.length, bytes = n * 4;\n this.uint32(bytes); // length is known exactly\n this._reserve(bytes);\n var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_INT);\n if (dv)\n for (i = 0; i < n; ++i) { dv.setUint32(p, value[i] >>> 0, true); p += 4; }\n else {\n var buf = this.buf;\n for (i = 0; i < n; ++i) { writeFixed32(value[i] >>> 0, buf, p); p += 4; }\n }\n this.pos += bytes;\n return this;\n};\n\n/**\n * Writes an array of signed 32 bit values as packed, fixed 32 bits.\n * @function\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sfixed32s = Writer.prototype.fixed32s;\n\n/**\n * Writes an array of unsigned 64 bit values as packed, fixed 64 bits.\n * @param {Array.<Long|number|string>} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.fixed64s = function write_fixed64s(value) {\n var n = value.length, bytes = n * 8;\n this.uint32(bytes);\n this._reserve(bytes);\n var p = this.pos, i, bits, dv = getLazyView(this, n, VIEW_THRESHOLD_INT);\n if (dv)\n for (i = 0; i < n; ++i) { bits = LongBits.from(value[i]); dv.setUint32(p, bits.lo, true); dv.setUint32(p + 4, bits.hi, true); p += 8; }\n else {\n var buf = this.buf;\n for (i = 0; i < n; ++i) { bits = LongBits.from(value[i]); writeFixed32(bits.lo, buf, p); writeFixed32(bits.hi, buf, p + 4); p += 8; }\n }\n this.pos += bytes;\n return this;\n};\n\n/**\n * Writes an array of signed 64 bit values as packed, fixed 64 bits.\n * @function\n * @param {Array.<Long|number|string>} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.sfixed64s = Writer.prototype.fixed64s;\n\n/**\n * Writes an array of floats (32 bit) as a packed repeated field.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.floats = function write_floats(value) {\n var n = value.length, bytes = n * 4;\n this.uint32(bytes);\n this._reserve(bytes);\n var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_FLOAT);\n if (dv)\n for (i = 0; i < n; ++i) { dv.setFloat32(p, value[i], true); p += 4; }\n else {\n var buf = this.buf;\n for (i = 0; i < n; ++i) { util.float.writeFloatLE(value[i], buf, p); p += 4; }\n }\n this.pos += bytes;\n return this;\n};\n\n/**\n * Writes an array of doubles (64 bit float) as a packed repeated field.\n * @param {number[]} value Values to write\n * @returns {Writer} `this`\n */\nWriter.prototype.doubles = function write_doubles(value) {\n var n = value.length, bytes = n * 8;\n this.uint32(bytes);\n this._reserve(bytes);\n var p = this.pos, i, dv = getLazyView(this, n, VIEW_THRESHOLD_FLOAT);\n if (dv)\n for (i = 0; i < n; ++i) { dv.setFloat64(p, value[i], true); p += 8; }\n else {\n var buf = this.buf;\n for (i = 0; i < n; ++i) { util.float.writeDoubleLE(value[i], buf, p); p += 8; }\n }\n this.pos += bytes;\n return this;\n};\n\n/**\n * Forks this writer's state by pushing it to a stack.\n * @returns {Writer} `this`\n */\nWriter.prototype.fork = function fork() {\n this._reserve(1);\n (this.states || (this.states = [])).push(this.pos);\n this.pos += 1;\n return this;\n};\n\n/**\n * Resets this instance to the last state.\n * @returns {Writer} `this`\n */\nWriter.prototype.reset = function reset() {\n var states = this.states;\n if (states && states.length) {\n this.pos = states.pop();\n } else {\n this.pos = 0;\n }\n return this;\n};\n\n/**\n * Resets to the last state and prepends the fork state's current write length as a varint.\n * @returns {Writer} `this`\n */\nWriter.prototype.ldelim = function ldelim() {\n var states = this.states,\n len,\n vlen;\n if (states && states.length) {\n var lenPos = states.pop();\n len = this.pos - lenPos - 1;\n vlen = sizeVarint32(len);\n if (vlen > 1) { // grow the reserved single byte and shift content forward\n this._reserve(vlen - 1);\n this.buf.copyWithin(lenPos + vlen, lenPos + 1, lenPos + 1 + len);\n this.pos += vlen - 1;\n writeVarint32(len, this.buf, lenPos);\n } else {\n this.buf[lenPos] = len;\n }\n } else { // not forked: prefix the entire buffer with its length\n // TODO: Compatibility with older generated code.\n // Remove this branch in the next major release.\n len = this.pos;\n vlen = sizeVarint32(len);\n this._reserve(vlen);\n this.buf.copyWithin(vlen, 0, len);\n writeVarint32(len, this.buf, 0);\n this.pos += vlen;\n }\n return this;\n};\n\n/**\n * Finishes the write operation.\n * Returns a buffer sized to the written data by default.\n * @param {boolean} [shared=false] Whether to return a shared view instead of a unique copy\n * @returns {Uint8Array} Finished buffer\n */\nWriter.prototype.finish = function finish(shared) {\n if (shared)\n return this.buf.subarray(0, this.pos);\n var buf = this.constructor.alloc(this.pos);\n buf.set(this.buf.subarray(0, this.pos), 0);\n return buf;\n};\n\n/**\n * Finishes the write operation, writing into the provided buffer.\n * The caller must ensure that `buf` has enough space starting at `offset`\n * to hold {@link Writer#pos} bytes.\n * @param {T} buf Target buffer\n * @param {number} [offset=0] Offset to start writing at\n * @returns {T} The provided buffer\n * @template T extends Uint8Array\n */\nWriter.prototype.finishInto = function finishInto(buf, offset) {\n if (offset === undefined)\n offset = 0;\n buf.set(this.buf.subarray(0, this.pos), offset);\n return buf;\n};\n\nWriter._configure = function(BufferWriter_) {\n BufferWriter = BufferWriter_;\n Writer.create = create();\n BufferWriter._configure();\n};\n","\"use strict\";\nmodule.exports = BufferWriter;\n\n// extends Writer\nvar Writer = require(44);\nBufferWriter.prototype = Object.create(Writer.prototype, {\n constructor: {\n value: BufferWriter,\n writable: true,\n enumerable: false,\n configurable: true\n }\n});\n\nvar util = require(37);\n\n/**\n * Constructs a new buffer writer instance.\n * @classdesc Wire format writer using node buffers.\n * @extends Writer\n * @constructor\n */\nfunction BufferWriter() {\n Writer.call(this);\n}\n\nvar writeStringBuffer;\n\nBufferWriter._configure = function () {\n /**\n * Allocates a buffer of the specified size.\n * @function\n * @param {number} size Buffer size\n * @returns {Buffer} Buffer\n */\n BufferWriter.alloc = util.Buffer && util.Buffer.allocUnsafe;\n\n writeStringBuffer = util.Buffer && util.Buffer.prototype.utf8Write\n ? function writeStringBuffer_utf8Write(val, buf, pos) {\n return buf.utf8Write(val, pos);\n }\n : function writeStringBuffer_write(val, buf, pos) {\n return buf.write(val, pos);\n };\n};\n\n\n/**\n * @override\n */\nBufferWriter.prototype.bytes = function write_bytes_buffer(value) {\n if (util.isString(value))\n value = util.Buffer.from(value, \"base64\");\n var len = value.length >>> 0;\n this.uint32(len);\n if (len) {\n this._reserve(len);\n this.buf.set(value, this.pos);\n this.pos += len;\n }\n return this;\n};\n\n/**\n * @override\n */\nBufferWriter.prototype.string = function write_string_buffer(value) {\n var n = value.length;\n if (!n) {\n this._reserve(1);\n this.buf[this.pos++] = 0;\n return this;\n }\n if (n < 0x80) {\n this._reserve(n * 3 + 5); // worst case\n var pos = this.pos,\n buf = this.buf;\n return this._delim(pos,\n n < 40\n ? util.utf8.write(value, buf, pos + 1)\n : writeStringBuffer(value, buf, pos + 1)\n );\n }\n var len = util.Buffer.byteLength(value);\n this.uint32(len);\n this._reserve(len);\n writeStringBuffer(value, this.buf, this.pos);\n this.pos += len;\n return this;\n};\n\n\n/**\n * Finishes the write operation.\n * @name BufferWriter#finish\n * @function\n * @returns {Buffer} Finished buffer\n */\n\nBufferWriter._configure();\n"],"sourceRoot":"."}