{"version":3,"sources":["lib/prelude.js","../node_modules/@protobufjs/aspromise/index.js","../node_modules/@protobufjs/base64/index.js","../node_modules/@protobufjs/codegen/index.js","../node_modules/@protobufjs/eventemitter/index.js","../node_modules/@protobufjs/fetch/index.js","../node_modules/@protobufjs/fetch/util/fs.js","../node_modules/@protobufjs/float/index.js","../node_modules/@protobufjs/path/index.js","../node_modules/@protobufjs/pool/index.js","../node_modules/@protobufjs/utf8/index.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/fs.js","../src/util/longbits.js","../src/util/minimal.js","../src/util/patterns.js","../src/verifier.js","../src/wrappers.js","../src/writer.js","../src/writer_buffer.js"],"names":["undefined","modules","cache","protobuf","1","require","module","exports","fn","ctx","params","Array","arguments","length","offset","index","pending","Promise","resolve","reject","err","apply","base64","string","p","n","Math","ceil","b64","s64","i","encode","buffer","start","end","t","parts","chunk","j","b","push","String","fromCharCode","slice","join","invalidEncoding","decode","c","charCodeAt","Error","test","codegen","reservedRe","functionParams","functionName","body","Codegen","formatStringOrScope","source","toString","verbose","console","log","scopeKeys","Object","keys","scopeParams","scopeValues","scopeOffset","Function","formatParams","formatOffset","replace","$0","$1","value","Number","floor","JSON","stringify","functionNameOverride","name","EventEmitter","this","_listeners","create","prototype","on","evt","off","listeners","splice","emit","args","fetch","asPromise","fs","filename","options","callback","xhr","readFile","contents","XMLHttpRequest","binary","onreadystatechange","readyState","status","response","responseText","Uint8Array","overrideMimeType","responseType","open","send","readFileSync","e","factory","writeFloat_ieee754","writeUint","val","buf","pos","sign","isNaN","round","exponent","LN2","pow","readFloat_ieee754","readUint","uint","mantissa","NaN","Infinity","writeFloat_f32_cpy","f32","f8b","writeFloat_f32_rev","readFloat_f32_cpy","readFloat_f32_rev","f64","le","writeDouble_ieee754","off0","off1","readDouble_ieee754","lo","hi","writeDouble_f64_cpy","writeDouble_f64_rev","readDouble_f64_cpy","readDouble_f64_rev","Float32Array","writeFloatLE","writeFloatBE","readFloatLE","readFloatBE","bind","writeUintLE","writeUintBE","readUintLE","readUintBE","Float64Array","writeDoubleLE","writeDoubleBE","readDoubleLE","readDoubleBE","isAbsolute","path","normalize","split","absolute","prefix","shift","originPath","includePath","alreadyNormalized","alloc","size","SIZE","MAX","slab","call","utf8","len","read","str","c3","c2","t2","write","c1","common","commonRe","json","nested","google","Any","fields","type_url","type","id","Duration","timeType","seconds","nanos","Timestamp","Empty","Struct","keyType","Value","oneofs","kind","oneof","nullValue","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","util","genValuePartial_fromObject","gen","field","fieldIndex","prop","defaultAlreadyEmitted","resolvedType","typeDefault","repeated","fullName","isUnsigned","genValuePartial_toObject","converter","fromObject","mtype","fieldsArray","safeProp","map","toObject","sort","compareFieldsById","repeatedFields","mapFields","normalFields","partOf","arrayDefault","valuesById","long","low","high","unsigned","toNumber","bytes","hasKs2","_fieldsArray","indexOf","filter","ref","types","defaults","basic","packed","delimited","rfield","required","wireType","mapKey","genTypePartial","optional","ReflectionObject","Namespace","constructor","className","comment","comments","valuesOptions","TypeError","_valuesFeatures","reserved","_resolveFeatures","edition","_edition","forEach","key","parentFeaturesCopy","merge","_features","features","fromJSON","enm","_defaultEdition","toJSON","toJSONOptions","keepComments","Boolean","_editionToJSON","add","isString","isInteger","isReservedId","isReservedName","allow_alias","remove","Field","Type","ruleRe","extend","isObject","toLowerCase","message","defaultValue","Long","extensionField","declaringField","defineProperty","field_presence","message_encoding","repeated_field_encoding","setOption","ifNotSet","resolved","parent","lookupTypeOrEnum","proto3_optional","fromNumber","freeze","newBuffer","emptyObject","emptyArray","ctor","_inferLegacyProtoFeatures","pop","group","getOption","d","fieldId","fieldType","fieldRule","decorateType","decorateEnum","fieldName","default","_configure","Type_","build","load","root","Root","loadSync","encoder","decoder","verifier","OneOf","MapField","Service","Method","Message","wrappers","configure","Writer","BufferWriter","Reader","BufferReader","rpc","roots","tokenize","parse","resolvedKeyType","fieldKeyType","fieldValueType","properties","$type","writer","encodeDelimited","reader","decodeDelimited","verify","object","requestType","requestStream","responseStream","parsedOptions","resolvedRequestType","resolvedResponseType","lookupType","arrayToJSON","array","obj","_nestedArray","_lookupCache","_needsRecursiveFeatureResolution","_needsRecursiveResolve","clearCache","namespace","depth","checkDepth","addJSON","toArray","nestedArray","nestedJson","names","methods","hasOwnProperty","getEnum","prev","setOptions","onAdd","onRemove","define","isArray","recursionLimit","ptr","part","resolveAll","_resolveFeaturesRecursive","lookup","filterTypes","parentAlreadyChecked","flatPath","found","_fullyQualifiedObjects","_lookupImpl","current","exact","lookupEnum","lookupService","Service_","Enum_","editions2023Defaults","enum_type","json_format","utf8_validation","proto2Defaults","proto3Defaults","_featuresResolved","defineProperties","unshift","_handleAdd","_handleRemove","protoFeatures","assign","lexicalParentFeaturesCopy","setProperty","setParsedOption","propName","opt","newOpt","find","newValue","Root_","fieldNames","addFieldsToParent","oneofName","oneOfGetter","set","oneOfSetter","keepCase","base10Re","base10NegRe","base16Re","base16NegRe","base8Re","base8NegRe","numberRe","patterns","nameRe","typeRefRe","pkg","imports","weakImports","token","whichImports","preferTrailingComment","tn","alternateCommentMode","next","peek","skip","cmnt","head","topLevelObjects","topLevelOptions","applyCase","camelCase","illegal","insideTryCatch","line","readString","readValue","acceptTypeRef","parseNumber","substring","parseInt","parseFloat","readRanges","target","acceptStrings","parseId","dummy","ifBlock","parseOption","parseInlineOptions","acceptNegative","parseCommon","parseType","parseEnum","parseService","service","parseMethod","commentText","method","parseExtension","reference","parseField","fnIf","fnElse","trailingLine","nestingLimit","parseMapField","valueType","parseOneOf","extensions","parseGroup","lcFirst","ucFirst","endsWith","startsWith","parseEnumValue","isOption","parensValue","includes","tokens","option","concat","optionValue","parseOptionValue","objectResult","lastValue","prevValue","simpleValue","package","LongBits","indexOutOfRange","writeLength","RangeError","Buffer","isBuffer","create_array","readLongVarint","bits","readFixed32_end","readFixed64","_slice","subarray","uint32","readVarint32NearEnd","int32","sint32","bool","fixed32","sfixed32","float","double","nativeBuffer","skipType","BufferReader_","int64","uint64","sint64","zzDecode","fixed64","sfixed64","utf8Slice","min","deferred","files","SYNC","resolvePath","self","sync","finish","cb","getBundledFileName","idx","lastIndexOf","altname","process","parsed","queued","weak","setTimeout","isNode","exposeRe","tryHandleExtension","sisterField","extendedType","parse_","common_","rpcImpl","requestDelimited","responseDelimited","rpcCall","requestCtor","responseCtor","request","endedByRPC","_methodsArray","inherited","methodsArray","rpcService","delimRe","stringDoubleRe","stringSingleRe","setCommentRe","setCommentAltRe","setCommentSplitRe","whitespaceRe","unescapeRe","unescapeMap","0","r","unescape","lastCommentLine","stack","stringDelim","subject","charAt","setComment","isLeading","lineEmpty","leading","lookback","commentOffset","lines","trim","text","isDoubleSlashCommentLine","startOffset","endOffset","findEndOfLine","lineText","cursor","re","match","lastIndex","exec","repeat","curr","isDoc","isLeadingComment","expected","actual","ret","_fieldsById","_oneofsArray","_ctor","fieldsById","oneofsArray","generateConstructor","ctorProperties","setup","originalThis","wrapper","fork","ldelim","typeName","s","bake","o","camelCaseRe","isReserved","toUpperCase","decorateEnumIndex","a","decorateRoot","enumerable","dst","setProp","isUnsafeProperty","zero","zzEncode","zeroHash","from","fromString","toLong","fromHash","hash","toHash","mask","part0","part1","part2","limit","src","newError","CustomError","captureStackTrace","writable","configurable","pool","global","versions","node","window","isFinite","isset","isSet","utf8Write","_Buffer_from","_Buffer_allocUnsafe","sizeOrArray","dcodeIO","isLong","key2Re","key32Re","key64Re","longToHash","longFromHash","fromBits","makeProp","ProtocolError","fieldMap","longs","enums","encoding","allocUnsafe","seenFirstField","oneofProp","invalid","genVerifyValue","messageName","Op","noop","State","tail","states","writeByte","VarintOp","writeVarint64","writeFixed32","_push","writeBytes","reset","BufferWriter_","writeStringBuffer","writeBytesBuffer","copy","byteLength","$require","$module","amd"],"mappings":";;;;;;AAAA,CAAA,SAAAA,IAAA,aAAA,IAAAC,EAAAC,EAcAC,EAdAF,EAiCA,CAAAG,EAAA,CAAA,SAAAC,EAAAC,EAAAC,GChCAD,EAAAC,QAmBA,SAAAC,EAAAC,GACA,IAAAC,EAAAC,MAAAC,UAAAC,OAAA,CAAA,EACAC,EAAA,EACAC,EAAA,EACAC,EAAA,CAAA,EACA,KAAAD,EAAAH,UAAAC,QACAH,EAAAI,CAAA,IAAAF,UAAAG,CAAA,IACA,OAAA,IAAAE,QAAA,SAAAC,EAAAC,GACAT,EAAAI,GAAA,SAAAM,GACA,GAAAJ,EAEA,GADAA,EAAA,CAAA,EACAI,EACAD,EAAAC,CAAA,MACA,CAGA,IAFA,IAAAV,EAAAC,MAAAC,UAAAC,OAAA,CAAA,EACAC,EAAA,EACAA,EAAAJ,EAAAG,QACAH,EAAAI,CAAA,IAAAF,UAAAE,GACAI,EAAAG,MAAA,KAAAX,CAAA,CACA,CAEA,EACA,IACAF,EAAAa,MAAAZ,GAAA,KAAAC,CAAA,CAMA,CALA,MAAAU,GACAJ,IACAA,EAAA,CAAA,EACAG,EAAAC,CAAA,EAEA,CACA,CAAA,CACA,C,yBCrCAE,EAAAT,OAAA,SAAAU,GACA,IAAAC,EAAAD,EAAAV,OACA,GAAA,CAAAW,EACA,OAAA,EAEA,IADA,IAAAC,EAAA,EACA,EAAA,EAAAD,EAAA,GAAA,MAAAD,EAAAA,EAAAC,IAAAD,KACA,EAAAE,EACA,OAAAC,KAAAC,KAAA,EAAAJ,EAAAV,MAAA,EAAA,EAAAY,CACA,EASA,IAxBA,IAkBAG,EAAAjB,MAAA,EAAA,EAGAkB,EAAAlB,MAAA,GAAA,EAGAmB,EAAA,EAAAA,EAAA,IACAD,EAAAD,EAAAE,GAAAA,EAAA,GAAAA,EAAA,GAAAA,EAAA,GAAAA,EAAA,GAAAA,EAAA,GAAAA,EAAA,EAAAA,EAAA,GAAA,IAAAA,CAAA,GASAR,EAAAS,OAAA,SAAAC,EAAAC,EAAAC,GAMA,IALA,IAIAC,EAJAC,EAAA,KACAC,EAAA,GACAP,EAAA,EACAQ,EAAA,EAEAL,EAAAC,GAAA,CACA,IAAAK,EAAAP,EAAAC,CAAA,IACA,OAAAK,GACA,KAAA,EACAD,EAAAP,CAAA,IAAAF,EAAAW,GAAA,GACAJ,GAAA,EAAAI,IAAA,EACAD,EAAA,EACA,MACA,KAAA,EACAD,EAAAP,CAAA,IAAAF,EAAAO,EAAAI,GAAA,GACAJ,GAAA,GAAAI,IAAA,EACAD,EAAA,EACA,MACA,KAAA,EACAD,EAAAP,CAAA,IAAAF,EAAAO,EAAAI,GAAA,GACAF,EAAAP,CAAA,IAAAF,EAAA,GAAAW,GACAD,EAAA,CAEA,CACA,KAAAR,KACAM,EAAAA,GAAA,IAAAI,KAAAC,OAAAC,aAAArB,MAAAoB,OAAAJ,CAAA,CAAA,EACAP,EAAA,EAEA,CAOA,OANAQ,IACAD,EAAAP,CAAA,IAAAF,EAAAO,GACAE,EAAAP,CAAA,IAAA,GACA,IAAAQ,IACAD,EAAAP,CAAA,IAAA,KAEAM,GACAN,GACAM,EAAAI,KAAAC,OAAAC,aAAArB,MAAAoB,OAAAJ,EAAAM,MAAA,EAAAb,CAAA,CAAA,CAAA,EACAM,EAAAQ,KAAA,EAAA,GAEAH,OAAAC,aAAArB,MAAAoB,OAAAJ,EAAAM,MAAA,EAAAb,CAAA,CAAA,CACA,EAEA,IAAAe,EAAA,mBAUAvB,EAAAwB,OAAA,SAAAvB,EAAAS,EAAAlB,GAIA,IAHA,IAEAqB,EAFAF,EAAAnB,EACAwB,EAAA,EAEAR,EAAA,EAAAA,EAAAP,EAAAV,QAAA,CACA,IAAAkC,EAAAxB,EAAAyB,WAAAlB,CAAA,EAAA,EACA,GAAA,IAAAiB,GAAA,EAAAT,EACA,MACA,IAAAS,EAAAlB,EAAAkB,MAAA/C,GACA,MAAAiD,MAAAJ,CAAA,EACA,OAAAP,GACA,KAAA,EACAH,EAAAY,EACAT,EAAA,EACA,MACA,KAAA,EACAN,EAAAlB,CAAA,IAAAqB,GAAA,GAAA,GAAAY,IAAA,EACAZ,EAAAY,EACAT,EAAA,EACA,MACA,KAAA,EACAN,EAAAlB,CAAA,KAAA,GAAAqB,IAAA,GAAA,GAAAY,IAAA,EACAZ,EAAAY,EACAT,EAAA,EACA,MACA,KAAA,EACAN,EAAAlB,CAAA,KAAA,EAAAqB,IAAA,EAAAY,EACAT,EAAA,CAEA,CACA,CACA,GAAA,IAAAA,EACA,MAAAW,MAAAJ,CAAA,EACA,OAAA/B,EAAAmB,CACA,EAOAX,EAAA4B,KAAA,SAAA3B,GACA,MAAA,mEAAA2B,KAAA3B,CAAA,CACA,C,yBCzIAjB,EAAAC,QAAA4C,EAEA,IAAAC,EAAA,uTASA,SAAAD,EAAAE,EAAAC,GAGA,UAAA,OAAAD,IACAC,EAAAD,EACAA,EAAArD,IAGA,IAAAuD,EAAA,GAYA,SAAAC,EAAAC,GAIA,GAAA,UAAA,OAAAA,EAAA,CACA,IAAAC,EAAAC,EAAA,EAIA,GAHAR,EAAAS,SACAC,QAAAC,IAAA,YAAAJ,CAAA,EACAA,EAAA,UAAAA,EACAD,EAAA,CAKA,IAJA,IAAAM,EAAAC,OAAAC,KAAAR,CAAA,EACAS,EAAAvD,MAAAoD,EAAAlD,OAAA,CAAA,EACAsD,EAAAxD,MAAAoD,EAAAlD,MAAA,EACAuD,EAAA,EACAA,EAAAL,EAAAlD,QACAqD,EAAAE,GAAAL,EAAAK,GACAD,EAAAC,GAAAX,EAAAM,EAAAK,CAAA,KAGA,OADAF,EAAAE,GAAAV,EACAW,SAAAhD,MAAA,KAAA6C,CAAA,EAAA7C,MAAA,KAAA8C,CAAA,CACA,CACA,OAAAE,SAAAX,CAAA,EAAA,CACA,CAKA,IAFA,IAAAY,EAAA3D,MAAAC,UAAAC,OAAA,CAAA,EACA0D,EAAA,EACAA,EAAAD,EAAAzD,QACAyD,EAAAC,GAAA3D,UAAA,EAAA2D,GAYA,GAXAA,EAAA,EACAd,EAAAA,EAAAe,QAAA,eAAA,SAAAC,EAAAC,GACA,IAAAC,EAAAL,EAAAC,CAAA,IACA,OAAAG,GACA,IAAA,IAAA,IAAA,IAAA,MAAAjC,IAAAmC,EAAAA,GAAAD,GACA,IAAA,IAAA,MAAAlC,GAAAf,KAAAmD,MAAAF,CAAA,EACA,IAAA,IAAA,OAAAG,KAAAC,UAAAJ,CAAA,EACA,IAAA,IAAA,MAAAlC,GAAAkC,CACA,CACA,MAAA,GACA,CAAA,EACAJ,IAAAD,EAAAzD,OACA,MAAAoC,MAAA,0BAAA,EAEA,OADAM,EAAAf,KAAAiB,CAAA,EACAD,CACA,CAEA,SAAAG,EAAAqB,GACA,MAAA,YAuBA,SAAAC,GACA,GAAA,CAAAA,EACA,MAAA,GAEA,GAAA,EADAA,GAAAxC,GAAAwC,GAAAT,QAAA,UAAA,EAAA,GAEA,MAAA,GACA,MAAAtB,KAAA+B,CAAA,IACAA,EAAA,IAAAA,GACA,OAAA7B,EAAAF,KAAA+B,CAAA,EAAAA,EAAA,IAAAA,CACA,EAhCAD,GAAA1B,CAAA,EAAA,KAAAD,GAAAA,EAAAT,KAAA,GAAA,GAAA,IAAA,SAAAW,EAAAX,KAAA,MAAA,EAAA,KACA,CAGA,OADAY,EAAAG,SAAAA,EACAH,CACA,CAgBAL,EAAAS,QAAA,CAAA,C,yBC3FA,SAAAsB,IAOAC,KAAAC,EAAApB,OAAAqB,OAAA,IAAA,CACA,EAhBA/E,EAAAC,QAAA2E,GAiCAI,UAAAC,GAAA,SAAAC,EAAAhF,EAAAC,GAKA,OAJA0E,KAAAC,EAAAI,KAAAL,KAAAC,EAAAI,GAAA,KAAAhD,KAAA,CACAhC,GAAAA,EACAC,IAAAA,GAAA0E,IACA,CAAA,EACAA,IACA,EAQAD,EAAAI,UAAAG,IAAA,SAAAD,EAAAhF,GACA,GAAAgF,IAAAxF,GACAmF,KAAAC,EAAApB,OAAAqB,OAAA,IAAA,OAEA,GAAA7E,IAAAR,GACAmF,KAAAC,EAAAI,GAAA,OACA,CACA,IAAAE,EAAAP,KAAAC,EAAAI,GACA,GAAA,CAAAE,EACA,OAAAP,KACA,IAAA,IAAArD,EAAA,EAAAA,EAAA4D,EAAA7E,QACA6E,EAAA5D,GAAAtB,KAAAA,EACAkF,EAAAC,OAAA7D,EAAA,CAAA,EAEA,EAAAA,CACA,CAEA,OAAAqD,IACA,EAQAD,EAAAI,UAAAM,KAAA,SAAAJ,GACA,IAAAE,EAAAP,KAAAC,EAAAI,GACA,GAAAE,EAAA,CAGA,IAFA,IAAAG,EAAA,GACA/D,EAAA,EACAA,EAAAlB,UAAAC,QACAgF,EAAArD,KAAA5B,UAAAkB,CAAA,GAAA,EACA,IAAAA,EAAA,EAAAA,EAAA4D,EAAA7E,QACA6E,EAAA5D,GAAAtB,GAAAa,MAAAqE,EAAA5D,CAAA,IAAArB,IAAAoF,CAAA,CACA,CACA,OAAAV,IACA,C,yBCpFA7E,EAAAC,QAAAuF,EAEA,IAAAC,EAAA1F,EAAA,CAAA,EACA2F,EAAA3F,EAAA,CAAA,EA0BA,SAAAyF,EAAAG,EAAAC,EAAAC,GAOA,OAJAD,EAFA,YAAA,OAAAA,GACAC,EAAAD,EACA,IACAA,GACA,GAEAC,EAIA,CAAAD,EAAAE,KAAAJ,GAAAA,EAAAK,SACAL,EAAAK,SAAAJ,EAAA,SAAA7E,EAAAkF,GACA,OAAAlF,GAAA,aAAA,OAAAmF,eACAT,EAAAM,IAAAH,EAAAC,EAAAC,CAAA,EACA/E,EACA+E,EAAA/E,CAAA,EACA+E,EAAA,KAAAD,EAAAM,OAAAF,EAAAA,EAAA3C,SAAA,MAAA,CAAA,CACA,CAAA,EAGAmC,EAAAM,IAAAH,EAAAC,EAAAC,CAAA,EAbAJ,EAAAD,EAAAX,KAAAc,EAAAC,CAAA,CAcA,CAuBAJ,EAAAM,IAAA,SAAAH,EAAAC,EAAAC,GACA,IAAAC,EAAA,IAAAG,eACAH,EAAAK,mBAAA,WAEA,GAAA,IAAAL,EAAAM,WACA,OAAA1G,GAKA,GAAA,IAAAoG,EAAAO,QAAA,MAAAP,EAAAO,OACA,OAAAR,EAAAlD,MAAA,UAAAmD,EAAAO,MAAA,CAAA,EAIA,GAAAT,EAAAM,OAAA,CAEA,GAAA,EAAAxE,EADAoE,EAAAQ,UAGA,IAAA,IADA5E,EAAA,GACAF,EAAA,EAAAA,EAAAsE,EAAAS,aAAAhG,OAAA,EAAAiB,EACAE,EAAAQ,KAAA,IAAA4D,EAAAS,aAAA7D,WAAAlB,CAAA,CAAA,EAEA,OAAAqE,EAAA,KAAA,aAAA,OAAAW,WAAA,IAAAA,WAAA9E,CAAA,EAAAA,CAAA,CACA,CACA,OAAAmE,EAAA,KAAAC,EAAAS,YAAA,CACA,EAEAX,EAAAM,SAEA,qBAAAJ,GACAA,EAAAW,iBAAA,oCAAA,EACAX,EAAAY,aAAA,eAGAZ,EAAAa,KAAA,MAAAhB,CAAA,EACAG,EAAAc,KAAA,CACA,C,gCC7GA,IAAAlB,EAAA,KACA,KACAA,EAAA3F,EAAA,EAAA,IACA2F,EAAAK,UAAAL,EAAAmB,eACAnB,EAAA,KAGA,CAFA,MAAAoB,IAGA9G,EAAAC,QAAAyF,C,8BC6EA,SAAAqB,EAAA9G,GAsDA,SAAA+G,EAAAC,EAAAC,EAAAC,EAAAC,GACA,IAAAC,EAAAH,EAAA,EAAA,EAAA,EAIAD,EADA,KADAC,EADAG,EACA,CAAAH,EACAA,GACA,EAAA,EAAAA,EAAA,EAAA,WACAI,MAAAJ,CAAA,EACA,WACA,qBAAAA,GACAG,GAAA,GAAA,cAAA,EACAH,EAAA,uBACAG,GAAA,GAAAjG,KAAAmG,MAAAL,EAAA,oBAAA,KAAA,GAIAG,GAAA,GAAA,KAFAG,EAAApG,KAAAmD,MAAAnD,KAAAoC,IAAA0D,CAAA,EAAA9F,KAAAqG,GAAA,IAEA,GADA,QAAArG,KAAAmG,MAAAL,EAAA9F,KAAAsG,IAAA,EAAA,CAAAF,CAAA,EAAA,OAAA,KACA,EAVAL,EAAAC,CAAA,CAYA,CAKA,SAAAO,EAAAC,EAAAT,EAAAC,GACAS,EAAAD,EAAAT,EAAAC,CAAA,EACAC,EAAA,GAAAQ,GAAA,IAAA,EACAL,EAAAK,IAAA,GAAA,IACAC,GAAA,QACA,OAAA,KAAAN,EACAM,EACAC,IACAC,EAAAA,EAAAX,EACA,GAAAG,EACA,qBAAAH,EAAAS,EACAT,EAAAjG,KAAAsG,IAAA,EAAAF,EAAA,GAAA,GAAA,QAAAM,EACA,CA/EA,SAAAG,EAAAf,EAAAC,EAAAC,GACAc,EAAA,GAAAhB,EACAC,EAAAC,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,EACA,CAEA,SAAAC,EAAAlB,EAAAC,EAAAC,GACAc,EAAA,GAAAhB,EACAC,EAAAC,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,EACA,CAOA,SAAAE,EAAAlB,EAAAC,GAKA,OAJAe,EAAA,GAAAhB,EAAAC,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAc,EAAA,EACA,CAEA,SAAAI,EAAAnB,EAAAC,GAKA,OAJAe,EAAA,GAAAhB,EAAAC,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAc,EAAA,EACA,CAzCA,IAEAA,EACAC,EA4FAI,EACAJ,EACAK,EA+DA,SAAAC,EAAAxB,EAAAyB,EAAAC,EAAAzB,EAAAC,EAAAC,GACA,IAaAU,EAbAT,EAAAH,EAAA,EAAA,EAAA,EAGA,KADAA,EADAG,EACA,CAAAH,EACAA,IACAD,EAAA,EAAAE,EAAAC,EAAAsB,CAAA,EACAzB,EAAA,EAAA,EAAAC,EAAA,EAAA,WAAAC,EAAAC,EAAAuB,CAAA,GACArB,MAAAJ,CAAA,GACAD,EAAA,EAAAE,EAAAC,EAAAsB,CAAA,EACAzB,EAAA,WAAAE,EAAAC,EAAAuB,CAAA,GACA,sBAAAzB,GACAD,EAAA,EAAAE,EAAAC,EAAAsB,CAAA,EACAzB,GAAAI,GAAA,GAAA,cAAA,EAAAF,EAAAC,EAAAuB,CAAA,GAGAzB,EAAA,wBAEAD,GADAa,EAAAZ,EAAA,UACA,EAAAC,EAAAC,EAAAsB,CAAA,EACAzB,GAAAI,GAAA,GAAAS,EAAA,cAAA,EAAAX,EAAAC,EAAAuB,CAAA,IAMA1B,EAAA,kBADAa,EAAAZ,EAAA9F,KAAAsG,IAAA,EAAA,EADAF,EADA,QADAA,EAAApG,KAAAmD,MAAAnD,KAAAoC,IAAA0D,CAAA,EAAA9F,KAAAqG,GAAA,GAEA,KACAD,EAAA,KACA,EAAAL,EAAAC,EAAAsB,CAAA,EACAzB,GAAAI,GAAA,GAAAG,EAAA,MAAA,GAAA,QAAAM,EAAA,WAAA,EAAAX,EAAAC,EAAAuB,CAAA,EAGA,CAKA,SAAAC,EAAAhB,EAAAc,EAAAC,EAAAxB,EAAAC,GACAyB,EAAAjB,EAAAT,EAAAC,EAAAsB,CAAA,EACAI,EAAAlB,EAAAT,EAAAC,EAAAuB,CAAA,EACAtB,EAAA,GAAAyB,GAAA,IAAA,EACAtB,EAAAsB,IAAA,GAAA,KACAhB,EAAA,YAAA,QAAAgB,GAAAD,EACA,OAAA,MAAArB,EACAM,EACAC,IACAC,EAAAA,EAAAX,EACA,GAAAG,EACA,OAAAH,EAAAS,EACAT,EAAAjG,KAAAsG,IAAA,EAAAF,EAAA,IAAA,GAAAM,EAAA,iBACA,CA3GA,SAAAiB,EAAA7B,EAAAC,EAAAC,GACAmB,EAAA,GAAArB,EACAC,EAAAC,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,EACA,CAEA,SAAAa,EAAA9B,EAAAC,EAAAC,GACAmB,EAAA,GAAArB,EACAC,EAAAC,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,GACAhB,EAAAC,EAAA,GAAAe,EAAA,EACA,CAOA,SAAAc,EAAA9B,EAAAC,GASA,OARAe,EAAA,GAAAhB,EAAAC,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAmB,EAAA,EACA,CAEA,SAAAW,EAAA/B,EAAAC,GASA,OARAe,EAAA,GAAAhB,EAAAC,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAe,EAAA,GAAAhB,EAAAC,EAAA,GACAmB,EAAA,EACA,CA+DA,MArNA,aAAA,OAAAY,cAEAjB,EAAA,IAAAiB,aAAA,CAAA,CAAA,EAAA,EACAhB,EAAA,IAAA3B,WAAA0B,EAAAxG,MAAA,EACA8G,EAAA,MAAAL,EAAA,GAmBAlI,EAAAmJ,aAAAZ,EAAAP,EAAAG,EAEAnI,EAAAoJ,aAAAb,EAAAJ,EAAAH,EAmBAhI,EAAAqJ,YAAAd,EAAAH,EAAAC,EAEArI,EAAAsJ,YAAAf,EAAAF,EAAAD,IAwBApI,EAAAmJ,aAAApC,EAAAwC,KAAA,KAAAC,CAAA,EACAxJ,EAAAoJ,aAAArC,EAAAwC,KAAA,KAAAE,CAAA,EAgBAzJ,EAAAqJ,YAAA3B,EAAA6B,KAAA,KAAAG,CAAA,EACA1J,EAAAsJ,YAAA5B,EAAA6B,KAAA,KAAAI,CAAA,GAKA,aAAA,OAAAC,cAEAtB,EAAA,IAAAsB,aAAA,CAAA,CAAA,EAAA,EACA1B,EAAA,IAAA3B,WAAA+B,EAAA7G,MAAA,EACA8G,EAAA,MAAAL,EAAA,GA2BAlI,EAAA6J,cAAAtB,EAAAO,EAAAC,EAEA/I,EAAA8J,cAAAvB,EAAAQ,EAAAD,EA2BA9I,EAAA+J,aAAAxB,EAAAS,EAAAC,EAEAjJ,EAAAgK,aAAAzB,EAAAU,EAAAD,IAmCAhJ,EAAA6J,cAAArB,EAAAe,KAAA,KAAAC,EAAA,EAAA,CAAA,EACAxJ,EAAA8J,cAAAtB,EAAAe,KAAA,KAAAE,EAAA,EAAA,CAAA,EAiBAzJ,EAAA+J,aAAApB,EAAAY,KAAA,KAAAG,EAAA,EAAA,CAAA,EACA1J,EAAAgK,aAAArB,EAAAY,KAAA,KAAAI,EAAA,EAAA,CAAA,GAIA3J,CACA,CAIA,SAAAwJ,EAAAvC,EAAAC,EAAAC,GACAD,EAAAC,GAAA,IAAAF,EACAC,EAAAC,EAAA,GAAAF,IAAA,EAAA,IACAC,EAAAC,EAAA,GAAAF,IAAA,GAAA,IACAC,EAAAC,EAAA,GAAAF,IAAA,EACA,CAEA,SAAAwC,EAAAxC,EAAAC,EAAAC,GACAD,EAAAC,GAAAF,IAAA,GACAC,EAAAC,EAAA,GAAAF,IAAA,GAAA,IACAC,EAAAC,EAAA,GAAAF,IAAA,EAAA,IACAC,EAAAC,EAAA,GAAA,IAAAF,CACA,CAEA,SAAAyC,EAAAxC,EAAAC,GACA,OAAAD,EAAAC,GACAD,EAAAC,EAAA,IAAA,EACAD,EAAAC,EAAA,IAAA,GACAD,EAAAC,EAAA,IAAA,MAAA,CACA,CAEA,SAAAwC,EAAAzC,EAAAC,GACA,OAAAD,EAAAC,IAAA,GACAD,EAAAC,EAAA,IAAA,GACAD,EAAAC,EAAA,IAAA,EACAD,EAAAC,EAAA,MAAA,CACA,CA5UApH,EAAAC,QAAA8G,EAAAA,CAAA,C,yBCKA,IAEAmD,EAMAC,EAAAD,WAAA,SAAAC,GACA,MAAA,eAAAvH,KAAAuH,CAAA,CACA,EAEAC,EAMAD,EAAAC,UAAA,SAAAD,GAGA,IAAArI,GAFAqI,EAAAA,EAAAjG,QAAA,MAAA,GAAA,EACAA,QAAA,UAAA,GAAA,GACAmG,MAAA,GAAA,EACAC,EAAAJ,EAAAC,CAAA,EACAI,EAAA,GACAD,IACAC,EAAAzI,EAAA0I,MAAA,EAAA,KACA,IAAA,IAAAhJ,EAAA,EAAAA,EAAAM,EAAAvB,QACA,OAAAuB,EAAAN,GACA,EAAAA,GAAA,OAAAM,EAAAN,EAAA,GACAM,EAAAuD,OAAA,EAAA7D,EAAA,CAAA,EACA8I,EACAxI,EAAAuD,OAAA7D,EAAA,CAAA,EAEA,EAAAA,EACA,MAAAM,EAAAN,GACAM,EAAAuD,OAAA7D,EAAA,CAAA,EAEA,EAAAA,EAEA,OAAA+I,EAAAzI,EAAAQ,KAAA,GAAA,CACA,EASA6H,EAAAvJ,QAAA,SAAA6J,EAAAC,EAAAC,GAGA,OAFAA,IACAD,EAAAN,EAAAM,CAAA,GACAR,CAAAA,EAAAQ,CAAA,IAIAD,GADAA,EADAE,EAEAF,EADAL,EAAAK,CAAA,GACAvG,QAAA,iBAAA,EAAA,GAAA3D,OAAA6J,EAAAK,EAAA,IAAAC,CAAA,EAHAA,CAIA,C,yBC/DA1K,EAAAC,QA6BA,SAAA2K,EAAAvI,EAAAwI,GACA,IAAAC,EAAAD,GAAA,KACAE,EAAAD,IAAA,EACAE,EAAA,KACAxK,EAAAsK,EACA,OAAA,SAAAD,GACA,GAAAA,EAAA,GAAAE,EAAAF,EACA,OAAAD,EAAAC,CAAA,EACAC,EAAAtK,EAAAqK,IACAG,EAAAJ,EAAAE,CAAA,EACAtK,EAAA,GAEA2G,EAAA9E,EAAA4I,KAAAD,EAAAxK,EAAAA,GAAAqK,CAAA,EAGA,OAFA,EAAArK,IACAA,EAAA,GAAA,EAAAA,IACA2G,CACA,CACA,C,0BChCA+D,EAAA3K,OAAA,SAAAU,GAGA,IAFA,IACAwB,EADA0I,EAAA,EAEA3J,EAAA,EAAAA,EAAAP,EAAAV,OAAA,EAAAiB,GACAiB,EAAAxB,EAAAyB,WAAAlB,CAAA,GACA,IACA2J,GAAA,EACA1I,EAAA,KACA0I,GAAA,EACA,QAAA,MAAA1I,IAAA,QAAA,MAAAxB,EAAAyB,WAAAlB,EAAA,CAAA,IACA,EAAAA,EACA2J,GAAA,GAEAA,GAAA,EAEA,OAAAA,CACA,EASAD,EAAAE,KAAA,SAAA1J,EAAAC,EAAAC,GACA,GAAAA,EAAAD,EAAA,EACA,MAAA,GAIA,IADA,IAAA0J,EAAA,GACA7J,EAAAG,EAAAH,EAAAI,GAAA,CACA,IAOA0J,EAPAzJ,EAAAH,EAAAF,CAAA,IACAK,GAAA,IACAwJ,GAAAlJ,OAAAC,aAAAP,CAAA,EACA,KAAAA,GAAAA,EAAA,IAEAwJ,GAAA,MADAE,GAAA,GAAA1J,IAAA,EAAA,GAAAH,EAAAF,CAAA,KACAW,OAAAC,aAAAmJ,CAAA,EA5CA,IA6CA,KAAA1J,GAAAA,EAAA,IAEAwJ,GAAA,OADAC,GAAA,GAAAzJ,IAAA,IAAA,GAAAH,EAAAF,CAAA,MAAA,EAAA,GAAAE,EAAAF,CAAA,KACAW,OAAAC,aAAAkJ,CAAA,EA/CA,IAgDA,KAAAzJ,KACA2J,GAAA,EAAA3J,IAAA,IAAA,GAAAH,EAAAF,CAAA,MAAA,IAAA,GAAAE,EAAAF,CAAA,MAAA,EAAA,GAAAE,EAAAF,CAAA,KACA,OAAA,QAAAgK,EACAH,GAnDA,IAuDAA,EADAA,EAAAlJ,OAAAC,aAAA,QADAoJ,GAAA,QACA,GAAA,EACArJ,OAAAC,aAAA,OAAA,KAAAoJ,EAAA,EAGA,CAEA,OAAAH,CACA,EASAH,EAAAO,MAAA,SAAAxK,EAAAS,EAAAlB,GAIA,IAHA,IACAkL,EACAH,EAFA5J,EAAAnB,EAGAgB,EAAA,EAAAA,EAAAP,EAAAV,OAAA,EAAAiB,GACAkK,EAAAzK,EAAAyB,WAAAlB,CAAA,GACA,IACAE,EAAAlB,CAAA,IAAAkL,GACAA,EAAA,KACAhK,EAAAlB,CAAA,IAAAkL,GAAA,EAAA,KAEA,QAAA,MAAAA,IAAA,QAAA,OAAAH,EAAAtK,EAAAyB,WAAAlB,EAAA,CAAA,KAEA,EAAAA,EACAE,EAAAlB,CAAA,KAFAkL,EAAA,QAAA,KAAAA,IAAA,KAAA,KAAAH,KAEA,GAAA,IACA7J,EAAAlB,CAAA,IAAAkL,GAAA,GAAA,GAAA,KAIAhK,EAAAlB,CAAA,IAAAkL,GAAA,GAAA,IAHAhK,EAAAlB,CAAA,IAAAkL,GAAA,EAAA,GAAA,KANAhK,EAAAlB,CAAA,IAAA,GAAAkL,EAAA,KAcA,OAAAlL,EAAAmB,CACA,C,oDCtGA3B,EAAAC,QAAA0L,EAEA,IAAAC,EAAA,QAsBA,SAAAD,EAAAhH,EAAAkH,GACAD,EAAAhJ,KAAA+B,CAAA,IACAA,EAAA,mBAAAA,EAAA,SACAkH,EAAA,CAAAC,OAAA,CAAAC,OAAA,CAAAD,OAAA,CAAAjM,SAAA,CAAAiM,OAAAD,CAAA,CAAA,CAAA,CAAA,CAAA,GAEAF,EAAAhH,GAAAkH,CACA,CAWAF,EAAA,MAAA,CAUAK,IAAA,CACAC,OAAA,CACAC,SAAA,CACAC,KAAA,SACAC,GAAA,CACA,EACA/H,MAAA,CACA8H,KAAA,QACAC,GAAA,CACA,CACA,CACA,CACA,CAAA,EAIAT,EAAA,WAAA,CAUAU,SAAAC,EAAA,CACAL,OAAA,CACAM,QAAA,CACAJ,KAAA,QACAC,GAAA,CACA,EACAI,MAAA,CACAL,KAAA,QACAC,GAAA,CACA,CACA,CACA,CACA,CAAA,EAEAT,EAAA,YAAA,CAUAc,UAAAH,CACA,CAAA,EAEAX,EAAA,QAAA,CAOAe,MAAA,CACAT,OAAA,EACA,CACA,CAAA,EAEAN,EAAA,SAAA,CASAgB,OAAA,CACAV,OAAA,CACAA,OAAA,CACAW,QAAA,SACAT,KAAA,QACAC,GAAA,CACA,CACA,CACA,EAeAS,MAAA,CACAC,OAAA,CACAC,KAAA,CACAC,MAAA,CACA,YACA,cACA,cACA,YACA,cACA,YAEA,CACA,EACAf,OAAA,CACAgB,UAAA,CACAd,KAAA,YACAC,GAAA,CACA,EACAc,YAAA,CACAf,KAAA,SACAC,GAAA,CACA,EACAe,YAAA,CACAhB,KAAA,SACAC,GAAA,CACA,EACAgB,UAAA,CACAjB,KAAA,OACAC,GAAA,CACA,EACAiB,YAAA,CACAlB,KAAA,SACAC,GAAA,CACA,EACAkB,UAAA,CACAnB,KAAA,YACAC,GAAA,CACA,CACA,CACA,EAEAmB,UAAA,CACAC,OAAA,CACAC,WAAA,CACA,CACA,EASAC,UAAA,CACAzB,OAAA,CACAuB,OAAA,CACAG,KAAA,WACAxB,KAAA,QACAC,GAAA,CACA,CACA,CACA,CACA,CAAA,EAEAT,EAAA,WAAA,CASAiC,YAAA,CACA3B,OAAA,CACA5H,MAAA,CACA8H,KAAA,SACAC,GAAA,CACA,CACA,CACA,EASAyB,WAAA,CACA5B,OAAA,CACA5H,MAAA,CACA8H,KAAA,QACAC,GAAA,CACA,CACA,CACA,EASA0B,WAAA,CACA7B,OAAA,CACA5H,MAAA,CACA8H,KAAA,QACAC,GAAA,CACA,CACA,CACA,EASA2B,YAAA,CACA9B,OAAA,CACA5H,MAAA,CACA8H,KAAA,SACAC,GAAA,CACA,CACA,CACA,EASA4B,WAAA,CACA/B,OAAA,CACA5H,MAAA,CACA8H,KAAA,QACAC,GAAA,CACA,CACA,CACA,EASA6B,YAAA,CACAhC,OAAA,CACA5H,MAAA,CACA8H,KAAA,SACAC,GAAA,CACA,CACA,CACA,EASA8B,UAAA,CACAjC,OAAA,CACA5H,MAAA,CACA8H,KAAA,OACAC,GAAA,CACA,CACA,CACA,EASA+B,YAAA,CACAlC,OAAA,CACA5H,MAAA,CACA8H,KAAA,SACAC,GAAA,CACA,CACA,CACA,EASAgC,WAAA,CACAnC,OAAA,CACA5H,MAAA,CACA8H,KAAA,QACAC,GAAA,CACA,CACA,CACA,CACA,CAAA,EAEAT,EAAA,aAAA,CASA0C,UAAA,CACApC,OAAA,CACAqC,MAAA,CACAX,KAAA,WACAxB,KAAA,SACAC,GAAA,CACA,CACA,CACA,CACA,CAAA,EAiBAT,EAAA4C,IAAA,SAAAC,GACA,OAAA7C,EAAA6C,IAAA,IACA,C,0BCzYA,IAEAC,EAAA1O,EAAA,EAAA,EACA2O,EAAA3O,EAAA,EAAA,EAWA,SAAA4O,EAAAC,EAAAC,EAAAC,EAAAC,GACA,IAAAC,EAAA,CAAA,EAEA,GAAAH,EAAAI,aACA,GAAAJ,EAAAI,wBAAAR,EAAA,CAAAG,EACA,eAAAG,CAAA,EACA,IAAA,IAAAvB,EAAAqB,EAAAI,aAAAzB,OAAA7J,EAAAD,OAAAC,KAAA6J,CAAA,EAAAhM,EAAA,EAAAA,EAAAmC,EAAApD,OAAA,EAAAiB,EAEAgM,EAAA7J,EAAAnC,MAAAqN,EAAAK,aAAAF,IAAAJ,EACA,UAAA,EACA,4CAAAG,EAAAA,EAAAA,CAAA,EACAF,EAAAM,UAAAP,EAEA,OAAA,EACAI,EAAA,CAAA,GAEAJ,EACA,UAAAjL,EAAAnC,EAAA,EACA,WAAAgM,EAAA7J,EAAAnC,GAAA,EACA,SAAAuN,EAAAvB,EAAA7J,EAAAnC,GAAA,EACA,OAAA,EACAoN,EACA,GAAA,CACA,MAAAA,EACA,0BAAAG,CAAA,EACA,sBAAAF,EAAAO,SAAA,mBAAA,EACA,oCAAAL,EAAAD,EAAAC,CAAA,MACA,CACA,IAAAM,EAAA,CAAA,EACA,OAAAR,EAAA1C,MACA,IAAA,SACA,IAAA,QAAAyC,EACA,kBAAAG,EAAAA,CAAA,EACA,MACA,IAAA,SACA,IAAA,UAAAH,EACA,cAAAG,EAAAA,CAAA,EACA,MACA,IAAA,QACA,IAAA,SACA,IAAA,WAAAH,EACA,YAAAG,EAAAA,CAAA,EACA,MACA,IAAA,SACA,IAAA,UACAM,EAAA,CAAA,EAEA,IAAA,QACA,IAAA,SACA,IAAA,WAAAT,EACA,eAAA,EACA,kCAAAG,EAAAA,EAAAM,CAAA,EACA,iCAAAN,CAAA,EACA,uBAAAA,EAAAA,CAAA,EACA,iCAAAA,CAAA,EACA,UAAAA,EAAAA,CAAA,EACA,iCAAAA,CAAA,EACA,+DAAAA,EAAAA,EAAAA,EAAAM,EAAA,OAAA,EAAA,EACA,MACA,IAAA,QAAAT,EACA,4BAAAG,CAAA,EACA,wEAAAA,EAAAA,EAAAA,CAAA,EACA,2BAAAA,CAAA,EACA,UAAAA,EAAAA,CAAA,EACA,MACA,IAAA,SAAAH,EACA,kBAAAG,EAAAA,CAAA,EACA,MACA,IAAA,OAAAH,EACA,mBAAAG,EAAAA,CAAA,CAKA,CACA,CACA,OAAAH,CAEA,CA0EA,SAAAU,EAAAV,EAAAC,EAAAC,EAAAC,GAEA,GAAAF,EAAAI,aACAJ,EAAAI,wBAAAR,EAAAG,EACA,yFAAAG,EAAAD,EAAAC,EAAAA,EAAAD,EAAAC,EAAAA,CAAA,EACAH,EACA,oCAAAG,EAAAD,EAAAC,CAAA,MACA,CACA,IAAAM,EAAA,CAAA,EACA,OAAAR,EAAA1C,MACA,IAAA,SACA,IAAA,QAAAyC,EACA,6CAAAG,EAAAA,EAAAA,EAAAA,CAAA,EACA,MACA,IAAA,SACA,IAAA,UACAM,EAAA,CAAA,EAEA,IAAA,QACA,IAAA,SACA,IAAA,WAAAT,EACA,mDAAA,EACA,mGAAAG,EAAAA,EAAAA,EAAAA,EAAAA,EAAAM,CAAA,EACA,iCAAAN,CAAA,EACA,uCAAAA,EAAAA,EAAAA,CAAA,EACA,MAAA,EACA,4IAAAA,EAAAA,EAAAA,EAAAA,EAAAM,EAAA,OAAA,GAAAN,CAAA,EACA,MACA,IAAA,QAAAH,EACA,gHAAAG,EAAAA,EAAAA,EAAAA,EAAAA,CAAA,EACA,MACA,QAAAH,EACA,UAAAG,EAAAA,CAAA,CAEA,CACA,CACA,OAAAH,CAEA,CAzGAW,EAAAC,WAAA,SAAAC,GAEA,IAAAxD,EAAAwD,EAAAC,YACAd,EAAAF,EAAA7L,QAAA,CAAA,IAAA,KAAA4M,EAAA9K,KAAA,aAAA,EACA,4BAAA,EACA,UAAA,EACA,GAAA,CAAAsH,EAAA1L,OAAA,OAAAqO,EACA,sBAAA,EACAA,EACA,uBAAA,EACA,sBAAAa,EAAAL,SAAA,mBAAA,EACA,sBAAA,EACA,2BAAA,EACA,+CAAA,EACAR,EACA,qBAAA,EACA,IAAA,IAAApN,EAAA,EAAAA,EAAAyK,EAAA1L,OAAA,EAAAiB,EAAA,CACA,IAAAqN,EAAA5C,EAAAzK,GAAAZ,QAAA,EACAmO,EAAAL,EAAAiB,SAAAd,EAAAlK,IAAA,EAGAkK,EAAAe,KAAAhB,EACA,WAAAG,CAAA,EACA,0BAAAA,CAAA,EACA,sBAAAF,EAAAO,SAAA,mBAAA,EACA,SAAAL,CAAA,EACA,oDAAAA,CAAA,EACAH,EACA,yBAAA,EACA,2BAAAG,CAAA,EACAJ,EAAAC,EAAAC,EAAArN,EAAAuN,EAAA,SAAA,EACA,GAAA,EACA,GAAA,GAGAF,EAAAM,UAAAP,EACA,WAAAG,CAAA,EACA,0BAAAA,CAAA,EACA,sBAAAF,EAAAO,SAAA,kBAAA,EACA,SAAAL,CAAA,EACA,iCAAAA,CAAA,EACAJ,EAAAC,EAAAC,EAAArN,EAAAuN,EAAA,KAAA,EACA,GAAA,EACA,GAAA,IAIAF,EAAAI,wBAAAR,GAAAG,EACA,iBAAAG,CAAA,EACAJ,EAAAC,EAAAC,EAAArN,EAAAuN,CAAA,EACAF,EAAAI,wBAAAR,GAAAG,EACA,GAAA,EAEA,CAAA,OAAAA,EACA,UAAA,CAEA,EAwDAW,EAAAM,SAAA,SAAAJ,GAEA,IAAAxD,EAAAwD,EAAAC,YAAArN,MAAA,EAAAyN,KAAApB,EAAAqB,iBAAA,EACA,GAAA,CAAA9D,EAAA1L,OACA,OAAAmO,EAAA7L,QAAA,EAAA,WAAA,EAaA,IAZA,IAAA+L,EAAAF,EAAA7L,QAAA,CAAA,IAAA,IAAA,KAAA4M,EAAA9K,KAAA,WAAA,EACA,QAAA,EACA,MAAA,EACA,sBAAA,EACA,2BAAA,EACA,mCAAA,EACA,UAAA,EAEAqL,EAAA,GACAC,EAAA,GACAC,EAAA,GACA1O,EAAA,EACAA,EAAAyK,EAAA1L,OAAA,EAAAiB,EACAyK,EAAAzK,GAAA2O,SACAlE,EAAAzK,GAAAZ,QAAA,EAAAuO,SAAAa,EACA/D,EAAAzK,GAAAoO,IAAAK,EACAC,GAAAhO,KAAA+J,EAAAzK,EAAA,EAEA,GAAAwO,EAAAzP,OAAA,CAEA,IAFAqO,EACA,2BAAA,EACApN,EAAA,EAAAA,EAAAwO,EAAAzP,OAAA,EAAAiB,EAAAoN,EACA,SAAAF,EAAAiB,SAAAK,EAAAxO,GAAAmD,IAAA,CAAA,EACAiK,EACA,GAAA,CACA,CAEA,GAAAqB,EAAA1P,OAAA,CAEA,IAFAqO,EACA,4BAAA,EACApN,EAAA,EAAAA,EAAAyO,EAAA1P,OAAA,EAAAiB,EAAAoN,EACA,SAAAF,EAAAiB,SAAAM,EAAAzO,GAAAmD,IAAA,CAAA,EACAiK,EACA,GAAA,CACA,CAEA,GAAAsB,EAAA3P,OAAA,CAEA,IAFAqO,EACA,iBAAA,EACApN,EAAA,EAAAA,EAAA0O,EAAA3P,OAAA,EAAAiB,EAAA,CACA,IAWA4O,EAXAvB,EAAAqB,EAAA1O,GACAuN,EAAAL,EAAAiB,SAAAd,EAAAlK,IAAA,EACAkK,EAAAI,wBAAAR,EAAAG,EACA,6BAAAG,EAAAF,EAAAI,aAAAoB,WAAAxB,EAAAK,aAAAL,EAAAK,WAAA,EACAL,EAAAyB,KAAA1B,EACA,gBAAA,EACA,gCAAAC,EAAAK,YAAAqB,IAAA1B,EAAAK,YAAAsB,KAAA3B,EAAAK,YAAAuB,QAAA,EACA,+HAAA1B,CAAA,EACA,OAAA,EACA,sFAAAA,EAAAF,EAAAK,YAAA7L,SAAA,EAAAwL,EAAAK,YAAA7L,SAAA,EAAAwL,EAAAK,YAAAwB,SAAA,CAAA,EACA7B,EAAA8B,OACAP,EAAA/P,MAAA2E,UAAA3C,MAAA4I,KAAA4D,EAAAK,WAAA,EACAN,EACA,6BAAAG,EAAA5M,OAAAC,aAAArB,MAAAoB,OAAA0M,EAAAK,WAAA,CAAA,EACA,OAAA,EACA,SAAAH,EAAAqB,CAAA,EACA,6CAAArB,EAAAA,CAAA,EACA,GAAA,GACAH,EACA,SAAAG,EAAAF,EAAAK,WAAA,CACA,CAAAN,EACA,GAAA,CACA,CAEA,IADA,IAAAgC,EAAA,CAAA,EACApP,EAAA,EAAAA,EAAAyK,EAAA1L,OAAA,EAAAiB,EAAA,CACA,IAAAqN,EAAA5C,EAAAzK,GACAf,EAAAgP,EAAAoB,EAAAC,QAAAjC,CAAA,EACAE,EAAAL,EAAAiB,SAAAd,EAAAlK,IAAA,EACAkK,EAAAe,KACAgB,IAAAA,EAAA,CAAA,EAAAhC,EACA,SAAA,GACAA,EACA,0CAAAG,EAAAA,CAAA,EACA,SAAAA,CAAA,EACA,gCAAA,EACAH,EACA,0BAAA,EACA,4BAAAG,CAAA,EACAO,EAAAV,EAAAC,EAAApO,EAAAsO,EAAA,UAAA,EACA,GAAA,GACAF,EAAAM,UAAAP,EACA,uBAAAG,EAAAA,CAAA,EACA,SAAAA,CAAA,EACA,iCAAAA,CAAA,EACAO,EAAAV,EAAAC,EAAApO,EAAAsO,EAAA,KAAA,EACA,GAAA,IACAH,EACA,mDAAAG,EAAAF,EAAAlK,IAAA,EACA2K,EAAAV,EAAAC,EAAApO,EAAAsO,CAAA,EACAF,EAAAsB,QAAAvB,EACA,cAAA,EACA,SAAAF,EAAAiB,SAAAd,EAAAsB,OAAAxL,IAAA,EAAAkK,EAAAlK,IAAA,GAEAiK,EACA,GAAA,CACA,CACA,OAAAA,EACA,UAAA,CAEA,C,qCC5TA5O,EAAAC,QAeA,SAAAwP,GA0BA,IAxBA,IAAAb,EAAAF,EAAA7L,QAAA,CAAA,IAAA,IAAA,IAAA,KAAA4M,EAAA9K,KAAA,SAAA,EACA,4BAAA,EACA,oBAAA,EACA,sBAAA,EACA,6BAAA,EACA,+CAAA,EACA,WAAA8K,EAAAC,YAAAqB,OAAA,SAAAlC,GAAA,OAAAA,EAAAe,GAAA,CAAA,EAAArP,OAAA,WAAA,GAAA,EACA,mBAAA,EACA,SAAA,EACA,OAAA,EACA,WAAA,EACA,aAAA,EACA,wCAAA,EACA,SAAA,EACA,SAAA,EACA,GAAA,EACA,iBAAA,EACA,iBAAA,EACA,kBAAA,EACA,WAAA,EACA,OAAA,EACA,gBAAA,EAEAiB,EAAA,EACAA,EAAAiO,EAAAC,YAAAnP,OAAA,EAAAiB,EAAA,CACA,IAAAqN,EAAAY,EAAAoB,EAAArP,GAAAZ,QAAA,EACAuL,EAAA0C,EAAAI,wBAAAR,EAAA,QAAAI,EAAA1C,KACA6E,EAAA,IAAAtC,EAAAiB,SAAAd,EAAAlK,IAAA,EAAAiK,EACA,aAAAC,EAAAzC,EAAA,EAGAyC,EAAAe,KAAAhB,EACA,4BAAAoC,CAAA,EACA,QAAAA,CAAA,EACA,yBAAA,EACA,cAAA,EACA,wCAAA,EACA,UAAA,EAEAC,EAAAC,SAAArC,EAAAjC,WAAAlN,GAAAkP,EACA,OAAAqC,EAAAC,SAAArC,EAAAjC,QAAA,EACAgC,EACA,QAAA,EAEAqC,EAAAC,SAAA/E,KAAAzM,GAAAkP,EACA,WAAAqC,EAAAC,SAAA/E,EAAA,EACAyC,EACA,YAAA,EAEAA,EACA,kBAAA,EACA,qBAAA,EACA,mBAAA,EACA,0BAAAC,EAAAjC,OAAA,EACA,SAAA,EAEAqE,EAAAE,MAAAhF,KAAAzM,GAAAkP,EACA,qDAAApN,CAAA,EACAoN,EACA,eAAAzC,CAAA,EAEAyC,EACA,OAAA,EACA,UAAA,EACA,sBAAA,EACA,OAAA,EACA,GAAA,EACA,GAAA,EACA,gBAAA,EACA,wCAAA,EACA,SAAA,EAEAqC,EAAAX,KAAAzB,EAAAjC,WAAAlN,GAAAkP,EACA,qDAAAoC,CAAA,GAEA,WAAAnC,EAAAjC,SAAAgC,EACA,qBAAA,EACA,sBAAAoC,CAAA,EACApC,EACA,cAAAoC,CAAA,IAIAnC,EAAAM,UAAAP,EAEA,uBAAAoC,EAAAA,CAAA,EACA,QAAAA,CAAA,EAGAC,EAAAG,OAAAjF,KAAAzM,IAAAkP,EACA,gBAAA,EACA,yBAAA,EACA,cAAA,EACA,wCAAA,EACA,UAAA,EACA,iBAAA,EACA,kBAAAoC,EAAA7E,CAAA,EACA,gBAAA,EACA,wCAAA,EACA,SAAA,EACA,OAAA,EAGA8E,EAAAE,MAAAhF,KAAAzM,GAAAkP,EAAAC,EAAAwC,UACA,wDACA,wDAAAL,EAAAxP,CAAA,EACAoN,EACA,kBAAAoC,EAAA7E,CAAA,GAGA8E,EAAAE,MAAAhF,KAAAzM,GAAAkP,EAAAC,EAAAwC,UACA,kDACA,kDAAAL,EAAAxP,CAAA,EACAoN,EACA,YAAAoC,EAAA7E,CAAA,EACAyC,EACA,OAAA,EACA,GAAA,CAEA,CAgBA,IAhBAA,EACA,UAAA,EACA,mBAAA,EACA,OAAA,EAEA,GAAA,EACA,GAAA,EAEAA,EACA,oBAAA,EACA,eAAA,EACA,wCAAA,EACA,SAAA,EACA,GAAA,EAGApN,EAAA,EAAAA,EAAAiO,EAAAoB,EAAAtQ,OAAA,EAAAiB,EAAA,CACA,IAAA8P,EAAA7B,EAAAoB,EAAArP,GACA8P,EAAAC,UAAA3C,EACA,wCAAA0C,EAAA3M,IAAA,EACA,4CArJA,qBAqJA2M,EArJA3M,KAAA,GAqJA,CACA,CAEA,OAAAiK,EACA,UAAA,CAEA,EAhKA,IAAAH,EAAA1O,EAAA,EAAA,EACAkR,EAAAlR,EAAA,EAAA,EACA2O,EAAA3O,EAAA,EAAA,C,2CCJAC,EAAAC,QA0BA,SAAAwP,GAcA,IAZA,IAOAuB,EAPApC,EAAAF,EAAA7L,QAAA,CAAA,IAAA,IAAA,KAAA4M,EAAA9K,KAAA,SAAA,EACA,QAAA,EACA,mBAAA,EACA,sBAAA,EACA,2BAAA,EACA,mCAAA,EAKAsH,EAAAwD,EAAAC,YAAArN,MAAA,EAAAyN,KAAApB,EAAAqB,iBAAA,EAEAvO,EAAA,EAAAA,EAAAyK,EAAA1L,OAAA,EAAAiB,EAAA,CACA,IAAAqN,EAAA5C,EAAAzK,GAAAZ,QAAA,EACAH,EAAAgP,EAAAoB,EAAAC,QAAAjC,CAAA,EACA1C,EAAA0C,EAAAI,wBAAAR,EAAA,QAAAI,EAAA1C,KACAqF,EAAAP,EAAAE,MAAAhF,GACA6E,EAAA,IAAAtC,EAAAiB,SAAAd,EAAAlK,IAAA,EAGAkK,EAAAe,KACAhB,EACA,kDAAAoC,EAAAnC,EAAAlK,IAAA,EACA,mDAAAqM,CAAA,EACA,4CAAAnC,EAAAzC,IAAA,EAAA,KAAA,EAAA,EAAA6E,EAAAQ,OAAA5C,EAAAjC,SAAAiC,EAAAjC,OAAA,EACA4E,IAAA9R,GAAAkP,EACA,wEAAAnO,EAAAuQ,CAAA,EACApC,EACA,qCAAA,GAAA4C,EAAArF,EAAA6E,CAAA,EACApC,EACA,GAAA,EACA,GAAA,GAGAC,EAAAM,UAAAP,EACA,2BAAAoC,EAAAA,CAAA,EAGAnC,EAAAuC,QAAAH,EAAAG,OAAAjF,KAAAzM,GAAAkP,EAEA,uBAAAC,EAAAzC,IAAA,EAAA,KAAA,CAAA,EACA,+BAAA4E,CAAA,EACA,cAAA7E,EAAA6E,CAAA,EACA,YAAA,GAGApC,EAEA,+BAAAoC,CAAA,EACAQ,IAAA9R,GACAgS,EAAA9C,EAAAC,EAAApO,EAAAuQ,EAAA,KAAA,EACApC,EACA,0BAAAC,EAAAzC,IAAA,EAAAoF,KAAA,EAAArF,EAAA6E,CAAA,GAEApC,EACA,GAAA,IAIAC,EAAA8C,UAAA/C,EACA,iDAAAoC,EAAAnC,EAAAlK,IAAA,EAEA6M,IAAA9R,GACAgS,EAAA9C,EAAAC,EAAApO,EAAAuQ,CAAA,EACApC,EACA,uBAAAC,EAAAzC,IAAA,EAAAoF,KAAA,EAAArF,EAAA6E,CAAA,EAGA,CAEA,OAAApC,EACA,UAAA,CAEA,EAnGA,IAAAH,EAAA1O,EAAA,EAAA,EACAkR,EAAAlR,EAAA,EAAA,EACA2O,EAAA3O,EAAA,EAAA,EAWA,SAAA2R,EAAA9C,EAAAC,EAAAC,EAAAkC,GACAnC,EAAAwC,UACAzC,EAAA,mDAAAE,EAAAkC,GAAAnC,EAAAzC,IAAA,EAAA,KAAA,GAAAyC,EAAAzC,IAAA,EAAA,KAAA,CAAA,EACAwC,EAAA,wDAAAE,EAAAkC,GAAAnC,EAAAzC,IAAA,EAAA,KAAA,CAAA,CACA,C,2CCnBApM,EAAAC,QAAAwO,EAGA,IAAAmD,EAAA7R,EAAA,EAAA,EAGA8R,KAFApD,EAAAzJ,UAAAtB,OAAAqB,OAAA6M,EAAA5M,SAAA,GAAA8M,YAAArD,GAAAsD,UAAA,OAEAhS,EAAA,EAAA,GACA2O,EAAA3O,EAAA,EAAA,EAcA,SAAA0O,EAAA9J,EAAA6I,EAAA5H,EAAAoM,EAAAC,EAAAC,GAGA,GAFAN,EAAA3G,KAAApG,KAAAF,EAAAiB,CAAA,EAEA4H,GAAA,UAAA,OAAAA,EACA,MAAA2E,UAAA,0BAAA,EAgDA,GA1CAtN,KAAAwL,WAAA,GAMAxL,KAAA2I,OAAA9J,OAAAqB,OAAAF,KAAAwL,UAAA,EAMAxL,KAAAmN,QAAAA,EAMAnN,KAAAoN,SAAAA,GAAA,GAMApN,KAAAqN,cAAAA,EAMArN,KAAAuN,EAAA,GAMAvN,KAAAwN,SAAA3S,GAMA8N,EACA,IAAA,IAAA7J,EAAAD,OAAAC,KAAA6J,CAAA,EAAAhM,EAAA,EAAAA,EAAAmC,EAAApD,OAAA,EAAAiB,EACA,cAAAmC,EAAAnC,IAAA,UAAA,OAAAgM,EAAA7J,EAAAnC,MACAqD,KAAAwL,WAAAxL,KAAA2I,OAAA7J,EAAAnC,IAAAgM,EAAA7J,EAAAnC,KAAAmC,EAAAnC,GACA,CAKAiN,EAAAzJ,UAAAsN,EAAA,SAAAC,GASA,OARAA,EAAA1N,KAAA2N,GAAAD,EACAX,EAAA5M,UAAAsN,EAAArH,KAAApG,KAAA0N,CAAA,EAEA7O,OAAAC,KAAAkB,KAAA2I,MAAA,EAAAiF,QAAAC,IACA,IAAAC,EAAAjE,EAAAkE,MAAA,GAAA/N,KAAAgO,CAAA,EACAhO,KAAAuN,EAAAM,GAAAhE,EAAAkE,MAAAD,EAAA9N,KAAAqN,eAAArN,KAAAqN,cAAAQ,IAAA7N,KAAAqN,cAAAQ,GAAAI,UAAA,EAAA,CACA,CAAA,EAEAjO,IACA,EAgBA4J,EAAAsE,SAAA,SAAApO,EAAAkH,GACAmH,EAAA,IAAAvE,EAAA9J,EAAAkH,EAAA2B,OAAA3B,EAAAjG,QAAAiG,EAAAmG,QAAAnG,EAAAoG,QAAA,EAKA,OAJAe,EAAAX,SAAAxG,EAAAwG,SACAxG,EAAA0G,UACAS,EAAAR,EAAA3G,EAAA0G,SACAS,EAAAC,EAAA,SACAD,CACA,EAOAvE,EAAAzJ,UAAAkO,OAAA,SAAAC,GACAC,EAAAD,CAAAA,CAAAA,GAAAE,CAAAA,CAAAF,EAAAC,aACA,OAAA1E,EAAAmB,SAAA,CACA,UAAAhL,KAAAyO,EAAA,EACA,UAAAzO,KAAAe,QACA,gBAAAf,KAAAqN,cACA,SAAArN,KAAA2I,OACA,WAAA3I,KAAAwN,UAAAxN,KAAAwN,SAAA9R,OAAAsE,KAAAwN,SAAA3S,GACA,UAAA0T,EAAAvO,KAAAmN,QAAAtS,GACA,WAAA0T,EAAAvO,KAAAoN,SAAAvS,GACA,CACA,EAYA+O,EAAAzJ,UAAAuO,IAAA,SAAA5O,EAAAyH,EAAA4F,EAAApM,GAGA,GAAA,CAAA8I,EAAA8E,SAAA7O,CAAA,EACA,MAAAwN,UAAA,uBAAA,EAEA,GAAA,CAAAzD,EAAA+E,UAAArH,CAAA,EACA,MAAA+F,UAAA,uBAAA,EAEA,GAAA,cAAAxN,EAAA,CAGA,GAAAE,KAAA2I,OAAA7I,KAAAjF,GACA,MAAAiD,MAAA,mBAAAgC,EAAA,QAAAE,IAAA,EAEA,GAAAA,KAAA6O,aAAAtH,CAAA,EACA,MAAAzJ,MAAA,MAAAyJ,EAAA,mBAAAvH,IAAA,EAEA,GAAAA,KAAA8O,eAAAhP,CAAA,EACA,MAAAhC,MAAA,SAAAgC,EAAA,oBAAAE,IAAA,EAEA,GAAAA,KAAAwL,WAAAjE,KAAA1M,GAAA,CACA,GAAAmF,CAAAA,KAAAe,SAAAf,CAAAA,KAAAe,QAAAgO,YACA,MAAAjR,MAAA,gBAAAyJ,EAAA,OAAAvH,IAAA,EACAA,KAAA2I,OAAA7I,GAAAyH,CACA,MACAvH,KAAAwL,WAAAxL,KAAA2I,OAAA7I,GAAAyH,GAAAzH,EAEAiB,IACAf,KAAAqN,gBAAAxS,KACAmF,KAAAqN,cAAA,IACArN,KAAAqN,cAAAvN,GAAAiB,GAAA,MAGAf,KAAAoN,SAAAtN,GAAAqN,GAAA,IAxBA,CAyBA,OAAAnN,IACA,EASA4J,EAAAzJ,UAAA6O,OAAA,SAAAlP,GAEA,GAAA,CAAA+J,EAAA8E,SAAA7O,CAAA,EACA,MAAAwN,UAAA,uBAAA,EAEA,IAAAjL,EAAArC,KAAA2I,OAAA7I,GACA,GAAA,MAAAuC,EACA,MAAAvE,MAAA,SAAAgC,EAAA,uBAAAE,IAAA,EAQA,OANA,OAAAA,KAAAwL,WAAAnJ,GACA,OAAArC,KAAA2I,OAAA7I,GACA,OAAAE,KAAAoN,SAAAtN,GACAE,KAAAqN,eACA,OAAArN,KAAAqN,cAAAvN,GAEAE,IACA,EAOA4J,EAAAzJ,UAAA0O,aAAA,SAAAtH,GACA,OAAAyF,EAAA6B,aAAA7O,KAAAwN,SAAAjG,CAAA,CACA,EAOAqC,EAAAzJ,UAAA2O,eAAA,SAAAhP,GACA,OAAAkN,EAAA8B,eAAA9O,KAAAwN,SAAA1N,CAAA,CACA,C,2CChOA3E,EAAAC,QAAA6T,EAGA,IAOAC,EAPAnC,EAAA7R,EAAA,EAAA,EAGA0O,KAFAqF,EAAA9O,UAAAtB,OAAAqB,OAAA6M,EAAA5M,SAAA,GAAA8M,YAAAgC,GAAA/B,UAAA,QAEAhS,EAAA,EAAA,GACAkR,EAAAlR,EAAA,EAAA,EACA2O,EAAA3O,EAAA,EAAA,EAIAiU,EAAA,+BA6CA,SAAAF,EAAAnP,EAAAyH,EAAAD,EAAAwB,EAAAsG,EAAArO,EAAAoM,GAcA,GAZAtD,EAAAwF,SAAAvG,CAAA,GACAqE,EAAAiC,EACArO,EAAA+H,EACAA,EAAAsG,EAAAvU,IACAgP,EAAAwF,SAAAD,CAAA,IACAjC,EAAApM,EACAA,EAAAqO,EACAA,EAAAvU,IAGAkS,EAAA3G,KAAApG,KAAAF,EAAAiB,CAAA,EAEA,CAAA8I,EAAA+E,UAAArH,CAAA,GAAAA,EAAA,EACA,MAAA+F,UAAA,mCAAA,EAEA,GAAA,CAAAzD,EAAA8E,SAAArH,CAAA,EACA,MAAAgG,UAAA,uBAAA,EAEA,GAAAxE,IAAAjO,IAAA,CAAAsU,EAAApR,KAAA+K,EAAAA,EAAAtK,SAAA,EAAA8Q,YAAA,CAAA,EACA,MAAAhC,UAAA,4BAAA,EAEA,GAAA8B,IAAAvU,IAAA,CAAAgP,EAAA8E,SAAAS,CAAA,EACA,MAAA9B,UAAA,yBAAA,EASAtN,KAAA8I,MAFAA,EADA,oBAAAA,EACA,WAEAA,IAAA,aAAAA,EAAAA,EAAAjO,GAMAmF,KAAAsH,KAAAA,EAMAtH,KAAAuH,GAAAA,EAMAvH,KAAAoP,OAAAA,GAAAvU,GAMAmF,KAAAsK,SAAA,aAAAxB,EAMA9I,KAAA+K,IAAA,CAAA,EAMA/K,KAAAuP,QAAA,KAMAvP,KAAAsL,OAAA,KAMAtL,KAAAqK,YAAA,KAMArK,KAAAwP,aAAA,KAMAxP,KAAAyL,KAAA5B,CAAAA,CAAAA,EAAA4F,MAAArD,EAAAX,KAAAnE,KAAAzM,GAMAmF,KAAA8L,MAAA,UAAAxE,EAMAtH,KAAAoK,aAAA,KAMApK,KAAA0P,eAAA,KAMA1P,KAAA2P,eAAA,KAMA3P,KAAAmN,QAAAA,CACA,CAlJA8B,EAAAf,SAAA,SAAApO,EAAAkH,GACAgD,EAAA,IAAAiF,EAAAnP,EAAAkH,EAAAO,GAAAP,EAAAM,KAAAN,EAAA8B,KAAA9B,EAAAoI,OAAApI,EAAAjG,QAAAiG,EAAAmG,OAAA,EAIA,OAHAnG,EAAA0G,UACA1D,EAAA2D,EAAA3G,EAAA0G,SACA1D,EAAAoE,EAAA,SACApE,CACA,EAoJAnL,OAAA+Q,eAAAX,EAAA9O,UAAA,WAAA,CACAuJ,IAAA,WACA,MAAA,oBAAA1J,KAAAgO,EAAA6B,cACA,CACA,CAAA,EAQAhR,OAAA+Q,eAAAX,EAAA9O,UAAA,WAAA,CACAuJ,IAAA,WACA,MAAA,CAAA1J,KAAA0M,QACA,CACA,CAAA,EASA7N,OAAA+Q,eAAAX,EAAA9O,UAAA,YAAA,CACAuJ,IAAA,WACA,OAAA1J,KAAAoK,wBAAA8E,GACA,cAAAlP,KAAAgO,EAAA8B,gBACA,CACA,CAAA,EAQAjR,OAAA+Q,eAAAX,EAAA9O,UAAA,SAAA,CACAuJ,IAAA,WACA,MAAA,WAAA1J,KAAAgO,EAAA+B,uBACA,CACA,CAAA,EAQAlR,OAAA+Q,eAAAX,EAAA9O,UAAA,cAAA,CACAuJ,IAAA,WACA,MAAA1J,CAAAA,KAAAsK,UAAAtK,CAAAA,KAAA+K,MAGA/K,KAAAsL,QACAtL,KAAA2P,gBAAA3P,KAAA0P,gBACA,aAAA1P,KAAAgO,EAAA6B,eACA,CACA,CAAA,EAKAZ,EAAA9O,UAAA6P,UAAA,SAAAlQ,EAAAN,EAAAyQ,GACA,OAAAlD,EAAA5M,UAAA6P,UAAA5J,KAAApG,KAAAF,EAAAN,EAAAyQ,CAAA,CACA,EAuBAhB,EAAA9O,UAAAkO,OAAA,SAAAC,GACAC,EAAAD,CAAAA,CAAAA,GAAAE,CAAAA,CAAAF,EAAAC,aACA,OAAA1E,EAAAmB,SAAA,CACA,UAAAhL,KAAAyO,EAAA,EACA,OAAA,aAAAzO,KAAA8I,MAAA9I,KAAA8I,MAAAjO,GACA,OAAAmF,KAAAsH,KACA,KAAAtH,KAAAuH,GACA,SAAAvH,KAAAoP,OACA,UAAApP,KAAAe,QACA,UAAAwN,EAAAvO,KAAAmN,QAAAtS,GACA,CACA,EAOAoU,EAAA9O,UAAApE,QAAA,WAEA,IAsCAuG,EAtCA,OAAAtC,KAAAkQ,SACAlQ,OAEAA,KAAAqK,YAAA+B,EAAAC,SAAArM,KAAAsH,SAAAzM,IACAmF,KAAAoK,cAAApK,KAAA2P,gBAAA3P,MAAAmQ,OAAAC,iBAAApQ,KAAAsH,IAAA,EACAtH,KAAAoK,wBAAA8E,EACAlP,KAAAqK,YAAA,KAEArK,KAAAqK,YAAArK,KAAAoK,aAAAzB,OAAA9J,OAAAC,KAAAkB,KAAAoK,aAAAzB,MAAA,EAAA,KACA3I,KAAAe,SAAAf,KAAAe,QAAAsP,kBAEArQ,KAAAqK,YAAA,MAIArK,KAAAe,SAAA,MAAAf,KAAAe,QAAA,UACAf,KAAAqK,YAAArK,KAAAe,QAAA,QACAf,KAAAoK,wBAAAR,GAAA,UAAA,OAAA5J,KAAAqK,cACArK,KAAAqK,YAAArK,KAAAoK,aAAAzB,OAAA3I,KAAAqK,eAIArK,KAAAe,UACAf,KAAAe,QAAAwL,SAAA1R,IAAAmF,CAAAA,KAAAoK,cAAApK,KAAAoK,wBAAAR,GACA,OAAA5J,KAAAe,QAAAwL,OACA1N,OAAAC,KAAAkB,KAAAe,OAAA,EAAArF,SACAsE,KAAAe,QAAAlG,KAIAmF,KAAAyL,MACAzL,KAAAqK,YAAAR,EAAA4F,KAAAa,WAAAtQ,KAAAqK,YAAA,WAAArK,KAAAsH,MAAA,YAAAtH,KAAAsH,IAAA,EAGAzI,OAAA0R,QACA1R,OAAA0R,OAAAvQ,KAAAqK,WAAA,GAEArK,KAAA8L,OAAA,UAAA,OAAA9L,KAAAqK,cAEAR,EAAA1N,OAAA4B,KAAAiC,KAAAqK,WAAA,EACAR,EAAA1N,OAAAwB,OAAAqC,KAAAqK,YAAA/H,EAAAuH,EAAA2G,UAAA3G,EAAA1N,OAAAT,OAAAsE,KAAAqK,WAAA,CAAA,EAAA,CAAA,EAEAR,EAAAxD,KAAAO,MAAA5G,KAAAqK,YAAA/H,EAAAuH,EAAA2G,UAAA3G,EAAAxD,KAAA3K,OAAAsE,KAAAqK,WAAA,CAAA,EAAA,CAAA,EACArK,KAAAqK,YAAA/H,GAIAtC,KAAA+K,IACA/K,KAAAwP,aAAA3F,EAAA4G,YACAzQ,KAAAsK,SACAtK,KAAAwP,aAAA3F,EAAA6G,WAEA1Q,KAAAwP,aAAAxP,KAAAqK,YAGArK,KAAAmQ,kBAAAjB,IACAlP,KAAAmQ,OAAAQ,KAAAxQ,UAAAH,KAAAF,MAAAE,KAAAwP,cAEAzC,EAAA5M,UAAApE,QAAAqK,KAAApG,IAAA,EACA,EAQAiP,EAAA9O,UAAAyQ,EAAA,SAAAlD,GACA,IAaApG,EAbA,MAAA,WAAAoG,GAAA,WAAAA,EACA,IAGAO,EAAA,GAEA,aAAAjO,KAAA8I,OACAmF,EAAA4B,eAAA,mBAEA7P,KAAAmQ,QAAA/D,EAAAC,SAAArM,KAAAsH,QAAAzM,KAIAyM,EAAAtH,KAAAmQ,OAAAzG,IAAA1J,KAAAsH,KAAA9B,MAAA,GAAA,EAAAqL,IAAA,CAAA,IACAvJ,aAAA4H,GAAA5H,EAAAwJ,QACA7C,EAAA6B,iBAAA,aAGA,CAAA,IAAA9P,KAAA+Q,UAAA,QAAA,EACA9C,EAAA8B,wBAAA,SACA,CAAA,IAAA/P,KAAA+Q,UAAA,QAAA,IACA9C,EAAA8B,wBAAA,YAEA9B,EACA,EAKAgB,EAAA9O,UAAAsN,EAAA,SAAAC,GACA,OAAAX,EAAA5M,UAAAsN,EAAArH,KAAApG,KAAAA,KAAA2N,GAAAD,CAAA,CACA,EAsBAuB,EAAA+B,EAAA,SAAAC,EAAAC,EAAAC,EAAA3B,GAUA,MAPA,YAAA,OAAA0B,EACAA,EAAArH,EAAAuH,aAAAF,CAAA,EAAApR,KAGAoR,GAAA,UAAA,OAAAA,IACAA,EAAArH,EAAAwH,aAAAH,CAAA,EAAApR,MAEA,SAAAK,EAAAmR,GACAzH,EAAAuH,aAAAjR,EAAA8M,WAAA,EACAyB,IAAA,IAAAO,EAAAqC,EAAAL,EAAAC,EAAAC,EAAA,CAAAI,QAAA/B,CAAA,CAAA,CAAA,CACA,CACA,EAgBAP,EAAAuC,EAAA,SAAAC,GACAvC,EAAAuC,CACA,C,iDCncA,IAAAzW,EAAAG,EAAAC,QAAAF,EAAA,EAAA,EAEAF,EAAA0W,MAAA,QAoDA1W,EAAA2W,KAjCA,SAAA7Q,EAAA8Q,EAAA5Q,GAMA,OAHA4Q,EAFA,YAAA,OAAAA,GACA5Q,EAAA4Q,EACA,IAAA5W,EAAA6W,MACAD,GACA,IAAA5W,EAAA6W,MACAF,KAAA7Q,EAAAE,CAAA,CACA,EA0CAhG,EAAA8W,SANA,SAAAhR,EAAA8Q,GAGA,OADAA,EADAA,GACA,IAAA5W,EAAA6W,MACAC,SAAAhR,CAAA,CACA,EAKA9F,EAAA+W,QAAA7W,EAAA,EAAA,EACAF,EAAAgX,QAAA9W,EAAA,EAAA,EACAF,EAAAiX,SAAA/W,EAAA,EAAA,EACAF,EAAA0P,UAAAxP,EAAA,EAAA,EAGAF,EAAA+R,iBAAA7R,EAAA,EAAA,EACAF,EAAAgS,UAAA9R,EAAA,EAAA,EACAF,EAAA6W,KAAA3W,EAAA,EAAA,EACAF,EAAA4O,KAAA1O,EAAA,EAAA,EACAF,EAAAkU,KAAAhU,EAAA,EAAA,EACAF,EAAAiU,MAAA/T,EAAA,EAAA,EACAF,EAAAkX,MAAAhX,EAAA,EAAA,EACAF,EAAAmX,SAAAjX,EAAA,EAAA,EACAF,EAAAoX,QAAAlX,EAAA,EAAA,EACAF,EAAAqX,OAAAnX,EAAA,EAAA,EAGAF,EAAAsX,QAAApX,EAAA,EAAA,EACAF,EAAAuX,SAAArX,EAAA,EAAA,EAGAF,EAAAoR,MAAAlR,EAAA,EAAA,EACAF,EAAA6O,KAAA3O,EAAA,EAAA,EAGAF,EAAA+R,iBAAAyE,EAAAxW,EAAA6W,IAAA,EACA7W,EAAAgS,UAAAwE,EAAAxW,EAAAkU,KAAAlU,EAAAoX,QAAApX,EAAA4O,IAAA,EACA5O,EAAA6W,KAAAL,EAAAxW,EAAAkU,IAAA,EACAlU,EAAAiU,MAAAuC,EAAAxW,EAAAkU,IAAA,C,2ICtGA,IAAAlU,EAAAI,EA2BA,SAAAoX,IACAxX,EAAA6O,KAAA2H,EAAA,EACAxW,EAAAyX,OAAAjB,EAAAxW,EAAA0X,YAAA,EACA1X,EAAA2X,OAAAnB,EAAAxW,EAAA4X,YAAA,CACA,CAvBA5X,EAAA0W,MAAA,UAGA1W,EAAAyX,OAAAvX,EAAA,EAAA,EACAF,EAAA0X,aAAAxX,EAAA,EAAA,EACAF,EAAA2X,OAAAzX,EAAA,EAAA,EACAF,EAAA4X,aAAA1X,EAAA,EAAA,EAGAF,EAAA6O,KAAA3O,EAAA,EAAA,EACAF,EAAA6X,IAAA3X,EAAA,EAAA,EACAF,EAAA8X,MAAA5X,EAAA,EAAA,EACAF,EAAAwX,UAAAA,EAcAA,EAAA,C,mEClCAxX,EAAAG,EAAAC,QAAAF,EAAA,EAAA,EAEAF,EAAA0W,MAAA,OAGA1W,EAAA+X,SAAA7X,EAAA,EAAA,EACAF,EAAAgY,MAAA9X,EAAA,EAAA,EACAF,EAAA8L,OAAA5L,EAAA,EAAA,EAGAF,EAAA6W,KAAAL,EAAAxW,EAAAkU,KAAAlU,EAAAgY,MAAAhY,EAAA8L,MAAA,C,iDCVA3L,EAAAC,QAAA+W,EAGA,IAAAlD,EAAA/T,EAAA,EAAA,EAGAkR,KAFA+F,EAAAhS,UAAAtB,OAAAqB,OAAA+O,EAAA9O,SAAA,GAAA8M,YAAAkF,GAAAjF,UAAA,WAEAhS,EAAA,EAAA,GACA2O,EAAA3O,EAAA,EAAA,EAcA,SAAAiX,EAAArS,EAAAyH,EAAAQ,EAAAT,EAAAvG,EAAAoM,GAIA,GAHA8B,EAAA7I,KAAApG,KAAAF,EAAAyH,EAAAD,EAAAzM,GAAAA,GAAAkG,EAAAoM,CAAA,EAGA,CAAAtD,EAAA8E,SAAA5G,CAAA,EACA,MAAAuF,UAAA,0BAAA,EAMAtN,KAAA+H,QAAAA,EAMA/H,KAAAiT,gBAAA,KAGAjT,KAAA+K,IAAA,CAAA,CACA,CAuBAoH,EAAAjE,SAAA,SAAApO,EAAAkH,GACA,OAAA,IAAAmL,EAAArS,EAAAkH,EAAAO,GAAAP,EAAAe,QAAAf,EAAAM,KAAAN,EAAAjG,QAAAiG,EAAAmG,OAAA,CACA,EAOAgF,EAAAhS,UAAAkO,OAAA,SAAAC,GACAC,EAAAD,CAAAA,CAAAA,GAAAE,CAAAA,CAAAF,EAAAC,aACA,OAAA1E,EAAAmB,SAAA,CACA,UAAAhL,KAAA+H,QACA,OAAA/H,KAAAsH,KACA,KAAAtH,KAAAuH,GACA,SAAAvH,KAAAoP,OACA,UAAApP,KAAAe,QACA,UAAAwN,EAAAvO,KAAAmN,QAAAtS,GACA,CACA,EAKAsX,EAAAhS,UAAApE,QAAA,WACA,GAAAiE,KAAAkQ,SACA,OAAAlQ,KAGA,GAAAoM,EAAAQ,OAAA5M,KAAA+H,WAAAlN,GACA,MAAAiD,MAAA,qBAAAkC,KAAA+H,OAAA,EAEA,OAAAkH,EAAA9O,UAAApE,QAAAqK,KAAApG,IAAA,CACA,EAYAmS,EAAAnB,EAAA,SAAAC,EAAAiC,EAAAC,GAUA,MAPA,YAAA,OAAAA,EACAA,EAAAtJ,EAAAuH,aAAA+B,CAAA,EAAArT,KAGAqT,GAAA,UAAA,OAAAA,IACAA,EAAAtJ,EAAAwH,aAAA8B,CAAA,EAAArT,MAEA,SAAAK,EAAAmR,GACAzH,EAAAuH,aAAAjR,EAAA8M,WAAA,EACAyB,IAAA,IAAAyD,EAAAb,EAAAL,EAAAiC,EAAAC,CAAA,CAAA,CACA,CACA,C,2CC5HAhY,EAAAC,QAAAkX,EAEA,IAAAzI,EAAA3O,EAAA,EAAA,EASA,SAAAoX,EAAAc,GAEA,GAAAA,EACA,IAAA,IAAAtU,EAAAD,OAAAC,KAAAsU,CAAA,EAAAzW,EAAA,EAAAA,EAAAmC,EAAApD,OAAA,EAAAiB,EAAA,CACA,IAAAkR,EAAA/O,EAAAnC,GACA,cAAAkR,IAEA7N,KAAA6N,GAAAuF,EAAAvF,GACA,CACA,CAyBAyE,EAAApS,OAAA,SAAAkT,GACA,OAAApT,KAAAqT,MAAAnT,OAAAkT,CAAA,CACA,EAUAd,EAAA1V,OAAA,SAAA2S,EAAA+D,GACA,OAAAtT,KAAAqT,MAAAzW,OAAA2S,EAAA+D,CAAA,CACA,EAUAhB,EAAAiB,gBAAA,SAAAhE,EAAA+D,GACA,OAAAtT,KAAAqT,MAAAE,gBAAAhE,EAAA+D,CAAA,CACA,EAWAhB,EAAA3U,OAAA,SAAA6V,GACA,OAAAxT,KAAAqT,MAAA1V,OAAA6V,CAAA,CACA,EAWAlB,EAAAmB,gBAAA,SAAAD,GACA,OAAAxT,KAAAqT,MAAAI,gBAAAD,CAAA,CACA,EASAlB,EAAAoB,OAAA,SAAAnE,GACA,OAAAvP,KAAAqT,MAAAK,OAAAnE,CAAA,CACA,EASA+C,EAAA3H,WAAA,SAAAgJ,GACA,OAAA3T,KAAAqT,MAAA1I,WAAAgJ,CAAA,CACA,EAUArB,EAAAtH,SAAA,SAAAuE,EAAAxO,GACA,OAAAf,KAAAqT,MAAArI,SAAAuE,EAAAxO,CAAA,CACA,EAMAuR,EAAAnS,UAAAkO,OAAA,WACA,OAAArO,KAAAqT,MAAArI,SAAAhL,KAAA6J,EAAAyE,aAAA,CACA,C,+BC3IAnT,EAAAC,QAAAiX,EAGA,IAAAtF,EAAA7R,EAAA,EAAA,EAGA2O,KAFAwI,EAAAlS,UAAAtB,OAAAqB,OAAA6M,EAAA5M,SAAA,GAAA8M,YAAAoF,GAAAnF,UAAA,SAEAhS,EAAA,EAAA,GAiBA,SAAAmX,EAAAvS,EAAAwH,EAAAsM,EAAA/R,EAAAgS,EAAAC,EAAA/S,EAAAoM,EAAA4G,GAYA,GATAlK,EAAAwF,SAAAwE,CAAA,GACA9S,EAAA8S,EACAA,EAAAC,EAAAjZ,IACAgP,EAAAwF,SAAAyE,CAAA,IACA/S,EAAA+S,EACAA,EAAAjZ,IAIAyM,IAAAzM,IAAAgP,CAAAA,EAAA8E,SAAArH,CAAA,EACA,MAAAgG,UAAA,uBAAA,EAGA,GAAA,CAAAzD,EAAA8E,SAAAiF,CAAA,EACA,MAAAtG,UAAA,8BAAA,EAGA,GAAA,CAAAzD,EAAA8E,SAAA9M,CAAA,EACA,MAAAyL,UAAA,+BAAA,EAEAP,EAAA3G,KAAApG,KAAAF,EAAAiB,CAAA,EAMAf,KAAAsH,KAAAA,GAAA,MAMAtH,KAAA4T,YAAAA,EAMA5T,KAAA6T,cAAAA,CAAAA,CAAAA,GAAAhZ,GAMAmF,KAAA6B,aAAAA,EAMA7B,KAAA8T,eAAAA,CAAAA,CAAAA,GAAAjZ,GAMAmF,KAAAgU,oBAAA,KAMAhU,KAAAiU,qBAAA,KAMAjU,KAAAmN,QAAAA,EAKAnN,KAAA+T,cAAAA,CACA,CAsBA1B,EAAAnE,SAAA,SAAApO,EAAAkH,GACA,OAAA,IAAAqL,EAAAvS,EAAAkH,EAAAM,KAAAN,EAAA4M,YAAA5M,EAAAnF,aAAAmF,EAAA6M,cAAA7M,EAAA8M,eAAA9M,EAAAjG,QAAAiG,EAAAmG,QAAAnG,EAAA+M,aAAA,CACA,EAOA1B,EAAAlS,UAAAkO,OAAA,SAAAC,GACAC,EAAAD,CAAAA,CAAAA,GAAAE,CAAAA,CAAAF,EAAAC,aACA,OAAA1E,EAAAmB,SAAA,CACA,OAAA,QAAAhL,KAAAsH,MAAAtH,KAAAsH,MAAAzM,GACA,cAAAmF,KAAA4T,YACA,gBAAA5T,KAAA6T,cACA,eAAA7T,KAAA6B,aACA,iBAAA7B,KAAA8T,eACA,UAAA9T,KAAAe,QACA,UAAAwN,EAAAvO,KAAAmN,QAAAtS,GACA,gBAAAmF,KAAA+T,cACA,CACA,EAKA1B,EAAAlS,UAAApE,QAAA,WAGA,OAAAiE,KAAAkQ,SACAlQ,MAEAA,KAAAgU,oBAAAhU,KAAAmQ,OAAA+D,WAAAlU,KAAA4T,WAAA,EACA5T,KAAAiU,qBAAAjU,KAAAmQ,OAAA+D,WAAAlU,KAAA6B,YAAA,EAEAkL,EAAA5M,UAAApE,QAAAqK,KAAApG,IAAA,EACA,C,qCC9JA7E,EAAAC,QAAA4R,EAGA,IAOAkC,EACAkD,EACAxI,EATAmD,EAAA7R,EAAA,EAAA,EAGA+T,KAFAjC,EAAA7M,UAAAtB,OAAAqB,OAAA6M,EAAA5M,SAAA,GAAA8M,YAAAD,GAAAE,UAAA,YAEAhS,EAAA,EAAA,GACA2O,EAAA3O,EAAA,EAAA,EACAgX,EAAAhX,EAAA,EAAA,EAsCA,SAAAiZ,EAAAC,EAAA9F,GACA,GAAA8F,CAAAA,GAAAA,CAAAA,EAAA1Y,OACA,OAAAb,GAEA,IADA,IAAAwZ,EAAA,GACA1X,EAAA,EAAAA,EAAAyX,EAAA1Y,OAAA,EAAAiB,EACA0X,EAAAD,EAAAzX,GAAAmD,MAAAsU,EAAAzX,GAAA0R,OAAAC,CAAA,EACA,OAAA+F,CACA,CA2CA,SAAArH,EAAAlN,EAAAiB,GACAgM,EAAA3G,KAAApG,KAAAF,EAAAiB,CAAA,EAMAf,KAAAiH,OAAApM,GAOAmF,KAAAsU,EAAA,KASAtU,KAAAuU,EAAA1V,OAAAqB,OAAA,IAAA,EAOAF,KAAAwU,EAAA,CAAA,EAOAxU,KAAAyU,EAAA,CAAA,CACA,CAEA,SAAAC,EAAAC,GACAA,EAAAL,EAAA,KACAK,EAAAJ,EAAA1V,OAAAqB,OAAA,IAAA,EAIA,IADA,IAAAiQ,EAAAwE,EACAxE,EAAAA,EAAAA,QACAA,EAAAoE,EAAA1V,OAAAqB,OAAA,IAAA,EAEA,OAAAyU,CACA,CAhHA3H,EAAAkB,SAAA,SAAApO,EAAAkH,EAAA4N,GAEA,OADAA,EAAA/K,EAAAgL,WAAAD,CAAA,EACA,IAAA5H,EAAAlN,EAAAkH,EAAAjG,OAAA,EAAA+T,QAAA9N,EAAAC,OAAA2N,CAAA,CACA,EAkBA5H,EAAAmH,YAAAA,EAQAnH,EAAA6B,aAAA,SAAArB,EAAAjG,GACA,GAAAiG,EACA,IAAA,IAAA7Q,EAAA,EAAAA,EAAA6Q,EAAA9R,OAAA,EAAAiB,EACA,GAAA,UAAA,OAAA6Q,EAAA7Q,IAAA6Q,EAAA7Q,GAAA,IAAA4K,GAAAiG,EAAA7Q,GAAA,GAAA4K,EACA,MAAA,CAAA,EACA,MAAA,CAAA,CACA,EAQAyF,EAAA8B,eAAA,SAAAtB,EAAA1N,GACA,GAAA0N,EACA,IAAA,IAAA7Q,EAAA,EAAAA,EAAA6Q,EAAA9R,OAAA,EAAAiB,EACA,GAAA6Q,EAAA7Q,KAAAmD,EACA,MAAA,CAAA,EACA,MAAA,CAAA,CACA,EAuEAjB,OAAA+Q,eAAA5C,EAAA7M,UAAA,cAAA,CACAuJ,IAAA,WACA,OAAA1J,KAAAsU,IAAAtU,KAAAsU,EAAAzK,EAAAkL,QAAA/U,KAAAiH,MAAA,EACA,CACA,CAAA,EA0BA+F,EAAA7M,UAAAkO,OAAA,SAAAC,GACA,OAAAzE,EAAAmB,SAAA,CACA,UAAAhL,KAAAe,QACA,SAAAoT,EAAAnU,KAAAgV,YAAA1G,CAAA,EACA,CACA,EAQAtB,EAAA7M,UAAA2U,QAAA,SAAAG,EAAAL,GACAA,EAAA/K,EAAAgL,WAAAD,CAAA,EAGA,GAAAK,EACA,IAAA,IAAAhO,EAAAiO,EAAArW,OAAAC,KAAAmW,CAAA,EAAAtY,EAAA,EAAAA,EAAAuY,EAAAxZ,OAAA,EAAAiB,EACAsK,EAAAgO,EAAAC,EAAAvY,IAJAqD,KAKA0O,KACAzH,EAAAG,SAAAvM,GACAqU,EACAjI,EAAA0B,SAAA9N,GACA+O,EACA3C,EAAAkO,UAAAta,GACAuX,EACAnL,EAAAM,KAAA1M,GACAoU,EACAjC,GAPAkB,SAOAgH,EAAAvY,GAAAsK,EAAA2N,EAAA,CAAA,CACA,EAGA,OAAA5U,IACA,EAOAgN,EAAA7M,UAAAuJ,IAAA,SAAA5J,GACA,OAAAE,KAAAiH,QAAApI,OAAAsB,UAAAiV,eAAAhP,KAAApG,KAAAiH,OAAAnH,CAAA,EACAE,KAAAiH,OAAAnH,GACA,IACA,EASAkN,EAAA7M,UAAAkV,QAAA,SAAAvV,GACA,GAAAE,KAAAiH,QAAApI,OAAAsB,UAAAiV,eAAAhP,KAAApG,KAAAiH,OAAAnH,CAAA,GAAAE,KAAAiH,OAAAnH,aAAA8J,EACA,OAAA5J,KAAAiH,OAAAnH,GAAA6I,OACA,MAAA7K,MAAA,iBAAAgC,CAAA,CACA,EASAkN,EAAA7M,UAAAuO,IAAA,SAAAiF,GAEA,GAAA,EAAAA,aAAA1E,GAAA0E,EAAAvE,SAAAvU,IAAA8Y,aAAAzE,GAAAyE,aAAAzB,GAAAyB,aAAA/J,GAAA+J,aAAAvB,GAAAuB,aAAA3G,GACA,MAAAM,UAAA,sCAAA,EAEA,GAAA,cAAAqG,EAAA7T,KACA,OAAAE,KAEA,GAAAA,KAAAiH,OAEA,CACA,IAAAqO,EAAAtV,KAAA0J,IAAAiK,EAAA7T,IAAA,EACA,GAAAwV,EAAA,CACA,GAAAA,EAAAA,aAAAtI,GAAA2G,aAAA3G,IAAAsI,aAAApG,GAAAoG,aAAAlD,EAWA,MAAAtU,MAAA,mBAAA6V,EAAA7T,KAAA,QAAAE,IAAA,EARA,IADA,IAAAiH,EAAAqO,EAAAN,YACArY,EAAA,EAAAA,EAAAsK,EAAAvL,OAAA,EAAAiB,EACAgX,EAAAjF,IAAAzH,EAAAtK,EAAA,EACAqD,KAAAgP,OAAAsG,CAAA,EACAtV,KAAAiH,SACAjH,KAAAiH,OAAA,IACA0M,EAAA4B,WAAAD,EAAAvU,QAAA,CAAA,CAAA,CAIA,CACA,MAjBAf,KAAAiH,OAAA,GAkBAjH,KAAAiH,OAAA0M,EAAA7T,MAAA6T,EAEA3T,gBAAAkP,GAAAlP,gBAAAoS,GAAApS,gBAAA4J,GAAA5J,gBAAAiP,GAEA0E,EAAAhG,IAEAgG,EAAAhG,EAAAgG,EAAAvF,GAIApO,KAAAwU,EAAA,CAAA,EACAxU,KAAAyU,EAAA,CAAA,EAIA,IADA,IAAAtE,EAAAnQ,KACAmQ,EAAAA,EAAAA,QACAA,EAAAqE,EAAA,CAAA,EACArE,EAAAsE,EAAA,CAAA,EAIA,OADAd,EAAA6B,MAAAxV,IAAA,EACA0U,EAAA1U,IAAA,CACA,EASAgN,EAAA7M,UAAA6O,OAAA,SAAA2E,GAEA,GAAA,EAAAA,aAAA5G,GACA,MAAAO,UAAA,mCAAA,EACA,GAAAqG,EAAAxD,SAAAnQ,KACA,MAAAlC,MAAA6V,EAAA,uBAAA3T,IAAA,EAOA,OALA,OAAAA,KAAAiH,OAAA0M,EAAA7T,MACAjB,OAAAC,KAAAkB,KAAAiH,MAAA,EAAAvL,SACAsE,KAAAiH,OAAApM,IAEA8Y,EAAA8B,SAAAzV,IAAA,EACA0U,EAAA1U,IAAA,CACA,EAQAgN,EAAA7M,UAAAuV,OAAA,SAAApQ,EAAA0B,GAEA,GAAA6C,EAAA8E,SAAArJ,CAAA,EACAA,EAAAA,EAAAE,MAAA,GAAA,OACA,GAAA,CAAAhK,MAAAma,QAAArQ,CAAA,EACA,MAAAgI,UAAA,cAAA,EACA,GAAAhI,GAAAA,EAAA5J,QAAA,KAAA4J,EAAA,GACA,MAAAxH,MAAA,uBAAA,EACA,GAAAwH,EAAA5J,OAAAmO,EAAA+L,eACA,MAAA9X,MAAA,oBAAA,EAGA,IADA,IAAA+X,EAAA7V,KACA,EAAAsF,EAAA5J,QAAA,CACA,IAAAoa,EAAAxQ,EAAAK,MAAA,EACA,GAAAkQ,EAAA5O,QAAA4O,EAAA5O,OAAA6O,IAEA,GAAA,GADAD,EAAAA,EAAA5O,OAAA6O,cACA9I,GACA,MAAAlP,MAAA,2CAAA,CAAA,MAEA+X,EAAAnH,IAAAmH,EAAA,IAAA7I,EAAA8I,CAAA,CAAA,CACA,CAGA,OAFA9O,GACA6O,EAAAf,QAAA9N,CAAA,EACA6O,CACA,EAMA7I,EAAA7M,UAAA4V,WAAA,WACA,GAAA/V,KAAAyU,EAAA,CAEAzU,KAAAgW,EAAAhW,KAAA2N,CAAA,EAEA,IAAA1G,EAAAjH,KAAAgV,YAAArY,EAAA,EAEA,IADAqD,KAAAjE,QAAA,EACAY,EAAAsK,EAAAvL,QACAuL,EAAAtK,aAAAqQ,EACA/F,EAAAtK,CAAA,IAAAoZ,WAAA,EAEA9O,EAAAtK,CAAA,IAAAZ,QAAA,EACAiE,KAAAyU,EAAA,CAAA,CAXA,CAYA,OAAAzU,IACA,EAKAgN,EAAA7M,UAAA6V,EAAA,SAAAtI,GAUA,OATA1N,KAAAwU,IACAxU,KAAAwU,EAAA,CAAA,EAEA9G,EAAA1N,KAAA2N,GAAAD,EAEAX,EAAA5M,UAAA6V,EAAA5P,KAAApG,KAAA0N,CAAA,EACA1N,KAAAgV,YAAApH,QAAA3G,IACAA,EAAA+O,EAAAtI,CAAA,CACA,CAAA,GACA1N,IACA,EASAgN,EAAA7M,UAAA8V,OAAA,SAAA3Q,EAAA4Q,EAAAC,GAQA,GANA,WAAA,OAAAD,GACAC,EAAAD,EACAA,EAAArb,IACAqb,GAAA,CAAA1a,MAAAma,QAAAO,CAAA,IACAA,EAAA,CAAAA,IAEArM,EAAA8E,SAAArJ,CAAA,GAAAA,EAAA5J,OAAA,CACA,GAAA,MAAA4J,EACA,OAAAtF,KAAA4R,KACAtM,EAAAA,EAAAE,MAAA,GAAA,CACA,MAAA,GAAA,CAAAF,EAAA5J,OACA,OAAAsE,KAEA,IAAAoW,EAAA9Q,EAAA7H,KAAA,GAAA,EAGA,GAAA,KAAA6H,EAAA,GACA,OAAAtF,KAAA4R,KAAAqE,OAAA3Q,EAAA9H,MAAA,CAAA,EAAA0Y,CAAA,EAGA,IAAAG,EAAArW,KAAA4R,KAAA0E,GAAAtW,KAAA4R,KAAA0E,EAAA,IAAAF,GACA,GAAAC,IAAA,CAAAH,GAAAA,CAAAA,EAAAjK,QAAAoK,EAAApJ,WAAA,GACA,OAAAoJ,EAKA,IADAA,EAAArW,KAAAuW,EAAAjR,EAAA8Q,CAAA,KACA,CAAAF,GAAAA,CAAAA,EAAAjK,QAAAoK,EAAApJ,WAAA,GACA,OAAAoJ,EAGA,GAAAF,CAAAA,EAKA,IADA,IAAAK,EAAAxW,KACAwW,EAAArG,QAAA,CAEA,IADAkG,EAAAG,EAAArG,OAAAoG,EAAAjR,EAAA8Q,CAAA,KACA,CAAAF,GAAAA,CAAAA,EAAAjK,QAAAoK,EAAApJ,WAAA,GACA,OAAAoJ,EAEAG,EAAAA,EAAArG,MACA,CACA,OAAA,IACA,EASAnD,EAAA7M,UAAAoW,EAAA,SAAAjR,EAAA8Q,GACA,GAAAvX,OAAAsB,UAAAiV,eAAAhP,KAAApG,KAAAuU,EAAA6B,CAAA,EACA,OAAApW,KAAAuU,EAAA6B,GAIA,IAAAC,EAAArW,KAAA0J,IAAApE,EAAA,EAAA,EACAmR,EAAA,KACA,GAAAJ,EACA,IAAA/Q,EAAA5J,OACA+a,EAAAJ,EACAA,aAAArJ,IACA1H,EAAAA,EAAA9H,MAAA,CAAA,EACAiZ,EAAAJ,EAAAE,EAAAjR,EAAAA,EAAA7H,KAAA,GAAA,CAAA,QAKA,IAAA,IAAAd,EAAA,EAAAA,EAAAqD,KAAAgV,YAAAtZ,OAAA,EAAAiB,EACA,GAAAqD,KAAAsU,EAAA3X,aAAAqQ,IAAAqJ,EAAArW,KAAAsU,EAAA3X,GAAA4Z,EAAAjR,EAAA8Q,CAAA,GAAA,CACAK,EAAAJ,EACA,KACA,CAKA,OADArW,KAAAuU,EAAA6B,GAAAK,CAEA,EAoBAzJ,EAAA7M,UAAA+T,WAAA,SAAA5O,GACA,IAAA+Q,EAAArW,KAAAiW,OAAA3Q,EAAA,CAAA4J,EAAA,EACA,GAAAmH,EAEA,OAAAA,EADA,MAAAvY,MAAA,iBAAAwH,CAAA,CAEA,EASA0H,EAAA7M,UAAAuW,WAAA,SAAApR,GACA,IAAA+Q,EAAArW,KAAAiW,OAAA3Q,EAAA,CAAAsE,EAAA,EACA,GAAAyM,EAEA,OAAAA,EADA,MAAAvY,MAAA,iBAAAwH,EAAA,QAAAtF,IAAA,CAEA,EASAgN,EAAA7M,UAAAiQ,iBAAA,SAAA9K,GACA,IAAA+Q,EAAArW,KAAAiW,OAAA3Q,EAAA,CAAA4J,EAAAtF,EAAA,EACA,GAAAyM,EAEA,OAAAA,EADA,MAAAvY,MAAA,yBAAAwH,EAAA,QAAAtF,IAAA,CAEA,EASAgN,EAAA7M,UAAAwW,cAAA,SAAArR,GACA,IAAA+Q,EAAArW,KAAAiW,OAAA3Q,EAAA,CAAA8M,EAAA,EACA,GAAAiE,EAEA,OAAAA,EADA,MAAAvY,MAAA,oBAAAwH,EAAA,QAAAtF,IAAA,CAEA,EAGAgN,EAAAwE,EAAA,SAAAC,EAAAmF,EAAAC,GACA3H,EAAAuC,EACAW,EAAAwE,EACAhN,EAAAiN,CACA,C,kDC5iBA1b,EAAAC,QAAA2R,GAEAG,UAAA,mBAEA,MAAAgF,EAAAhX,EAAA,EAAA,EACA,IAEA2W,EAFAhI,EAAA3O,EAAA,EAAA,EAMA4b,EAAA,CAAAC,UAAA,OAAAlH,eAAA,WAAAmH,YAAA,QAAAlH,iBAAA,kBAAAC,wBAAA,SAAAkH,gBAAA,QAAA,EACAC,EAAA,CAAAH,UAAA,SAAAlH,eAAA,WAAAmH,YAAA,qBAAAlH,iBAAA,kBAAAC,wBAAA,WAAAkH,gBAAA,MAAA,EACAE,EAAA,CAAAJ,UAAA,OAAAlH,eAAA,WAAAmH,YAAA,QAAAlH,iBAAA,kBAAAC,wBAAA,SAAAkH,gBAAA,QAAA,EAUA,SAAAlK,EAAAjN,EAAAiB,GAEA,GAAA,CAAA8I,EAAA8E,SAAA7O,CAAA,EACA,MAAAwN,UAAA,uBAAA,EAEA,GAAAvM,GAAA,CAAA8I,EAAAwF,SAAAtO,CAAA,EACA,MAAAuM,UAAA,2BAAA,EAMAtN,KAAAe,QAAAA,EAMAf,KAAA+T,cAAA,KAMA/T,KAAAF,KAAAA,EAOAE,KAAA2N,EAAA,KAQA3N,KAAAoO,EAAA,SAOApO,KAAAgO,EAAA,GAOAhO,KAAAoX,EAAA,CAAA,EAMApX,KAAAmQ,OAAA,KAMAnQ,KAAAkQ,SAAA,CAAA,EAMAlQ,KAAAmN,QAAA,KAMAnN,KAAAc,SAAA,IACA,CAEAjC,OAAAwY,iBAAAtK,EAAA5M,UAAA,CAQAyR,KAAA,CACAlI,IAAA,WAEA,IADA,IAAAmM,EAAA7V,KACA,OAAA6V,EAAA1F,QACA0F,EAAAA,EAAA1F,OACA,OAAA0F,CACA,CACA,EAQAtL,SAAA,CACAb,IAAA,WAGA,IAFA,IAAApE,EAAA,CAAAtF,KAAAF,MACA+V,EAAA7V,KAAAmQ,OACA0F,GACAvQ,EAAAgS,QAAAzB,EAAA/V,IAAA,EACA+V,EAAAA,EAAA1F,OAEA,OAAA7K,EAAA7H,KAAA,GAAA,CACA,CACA,CACA,CAAA,EAOAsP,EAAA5M,UAAAkO,OAAA,WACA,MAAAvQ,MAAA,CACA,EAOAiP,EAAA5M,UAAAqV,MAAA,SAAArF,GACAnQ,KAAAmQ,QAAAnQ,KAAAmQ,SAAAA,GACAnQ,KAAAmQ,OAAAnB,OAAAhP,IAAA,EACAA,KAAAmQ,OAAAA,EACAnQ,KAAAkQ,SAAA,CAAA,EACA0B,EAAAzB,EAAAyB,KACAA,aAAAC,GACAD,EAAA2F,EAAAvX,IAAA,CACA,EAOA+M,EAAA5M,UAAAsV,SAAA,SAAAtF,GACAyB,EAAAzB,EAAAyB,KACAA,aAAAC,GACAD,EAAA4F,EAAAxX,IAAA,EACAA,KAAAmQ,OAAA,KACAnQ,KAAAkQ,SAAA,CAAA,CACA,EAMAnD,EAAA5M,UAAApE,QAAA,WAKA,OAJAiE,KAAAkQ,UAEAlQ,KAAA4R,gBAAAC,IACA7R,KAAAkQ,SAAA,CAAA,GACAlQ,IACA,EAOA+M,EAAA5M,UAAA6V,EAAA,SAAAtI,GACA,OAAA1N,KAAAyN,EAAAzN,KAAA2N,GAAAD,CAAA,CACA,EAOAX,EAAA5M,UAAAsN,EAAA,SAAAC,GACA,GAAA1N,CAAAA,KAAAoX,EAAA,CAIA,IAAA/K,EAAA,GAGA,GAAA,CAAAqB,EACA,MAAA5P,MAAA,uBAAAkC,KAAAuK,QAAA,EAGA,IAAAkN,EAAA5N,EAAAkE,MAAA,GAAA/N,KAAAe,SAAAf,KAAAe,QAAAkN,SACAjO,KAAA4Q,EAAAlD,CAAA,CAAA,EAEA,GAAA1N,KAAA2N,EAAA,CAGA,GAAA,WAAAD,EACArB,EAAAxN,OAAA6Y,OAAA,GAAAR,CAAA,OACA,GAAA,WAAAxJ,EACArB,EAAAxN,OAAA6Y,OAAA,GAAAP,CAAA,MACA,CAAA,GAAA,SAAAzJ,EAGA,MAAA5P,MAAA,oBAAA4P,CAAA,EAFArB,EAAAxN,OAAA6Y,OAAA,GAAAZ,CAAA,CAGA,CACA9W,KAAAgO,EAAAnE,EAAAkE,MAAA1B,EAAAoL,CAAA,CAGA,KAfA,CAoBA,GAAAzX,KAAAsL,kBAAA4G,EAAA,CACAyF,EAAA9N,EAAAkE,MAAA,GAAA/N,KAAAsL,OAAA0C,CAAA,EACAhO,KAAAgO,EAAAnE,EAAAkE,MAAA4J,EAAAF,CAAA,CACA,MAAA,GAAAzX,CAAAA,KAAA2P,eAEA,CAAA,GAAA3P,CAAAA,KAAAmQ,OAIA,MAAArS,MAAA,+BAAAkC,KAAAuK,QAAA,EAHAuD,EAAAjE,EAAAkE,MAAA,GAAA/N,KAAAmQ,OAAAnC,CAAA,EACAhO,KAAAgO,EAAAnE,EAAAkE,MAAAD,EAAA2J,CAAA,CAGA,CACAzX,KAAA0P,iBAEA1P,KAAA0P,eAAA1B,EAAAhO,KAAAgO,EAlBA,CAFAhO,KAAAoX,EAAA,CAAA,CAzBA,CAgDA,EAQArK,EAAA5M,UAAAyQ,EAAA,WACA,MAAA,EACA,EAOA7D,EAAA5M,UAAA4Q,UAAA,SAAAjR,GACA,OAAAE,KAAAe,QACAf,KAAAe,QAAAjB,GACAjF,EACA,EASAkS,EAAA5M,UAAA6P,UAAA,SAAAlQ,EAAAN,EAAAyQ,GAYA,MAXA,cAAAnQ,IAEAE,KAAAe,UACAf,KAAAe,QAAA,IACA,cAAAhD,KAAA+B,CAAA,EACA+J,EAAA+N,YAAA5X,KAAAe,QAAAjB,EAAAN,EAAAyQ,CAAA,EACAA,GAAAjQ,KAAAe,QAAAjB,KAAAjF,KACAmF,KAAA+Q,UAAAjR,CAAA,IAAAN,IAAAQ,KAAAkQ,SAAA,CAAA,GACAlQ,KAAAe,QAAAjB,GAAAN,IAGAQ,IACA,EASA+M,EAAA5M,UAAA0X,gBAAA,SAAA/X,EAAAN,EAAAsY,GACA,IAKA/D,EAIAgE,EAgBAC,EAKA,MA9BA,cAAAlY,IAEAE,KAAA+T,gBACA/T,KAAA+T,cAAA,IAEAA,EAAA/T,KAAA+T,cACA+D,GAGAC,EAAAhE,EAAAkE,KAAA,SAAAF,GACA,OAAAlZ,OAAAsB,UAAAiV,eAAAhP,KAAA2R,EAAAjY,CAAA,CACA,CAAA,IAIAoY,EAAAH,EAAAjY,GACA+J,EAAA+N,YAAAM,EAAAJ,EAAAtY,CAAA,KAGAuY,EAAA,IACAjY,GAAA+J,EAAA+N,YAAA,GAAAE,EAAAtY,CAAA,EACAuU,EAAA1W,KAAA0a,CAAA,KAIAC,EAAA,IACAlY,GAAAN,EACAuU,EAAA1W,KAAA2a,CAAA,IAGAhY,IACA,EAQA+M,EAAA5M,UAAAoV,WAAA,SAAAxU,EAAAkP,GACA,GAAAlP,EACA,IAAA,IAAAjC,EAAAD,OAAAC,KAAAiC,CAAA,EAAApE,EAAA,EAAAA,EAAAmC,EAAApD,OAAA,EAAAiB,EACAqD,KAAAgQ,UAAAlR,EAAAnC,GAAAoE,EAAAjC,EAAAnC,IAAAsT,CAAA,EACA,OAAAjQ,IACA,EAMA+M,EAAA5M,UAAA3B,SAAA,WACA,IAAA0O,EAAAlN,KAAAiN,YAAAC,UACA3C,EAAAvK,KAAAuK,SACA,OAAAA,EAAA7O,OACAwR,EAAA,IAAA3C,EACA2C,CACA,EAMAH,EAAA5M,UAAAsO,EAAA,WACA,OAAAzO,KAAA2N,GAAA,WAAA3N,KAAA2N,EAKA3N,KAAA2N,EAFA9S,EAGA,EAGAkS,EAAAyE,EAAA,SAAA2G,GACAtG,EAAAsG,CACA,C,qCC5XAhd,EAAAC,QAAA8W,EAGA,IAAAnF,EAAA7R,EAAA,EAAA,EAGA+T,KAFAiD,EAAA/R,UAAAtB,OAAAqB,OAAA6M,EAAA5M,SAAA,GAAA8M,YAAAiF,GAAAhF,UAAA,QAEAhS,EAAA,EAAA,GACA2O,EAAA3O,EAAA,EAAA,EAYA,SAAAgX,EAAApS,EAAAsY,EAAArX,EAAAoM,GAQA,GAPA3R,MAAAma,QAAAyC,CAAA,IACArX,EAAAqX,EACAA,EAAAvd,IAEAkS,EAAA3G,KAAApG,KAAAF,EAAAiB,CAAA,EAGAqX,IAAAvd,IAAAW,CAAAA,MAAAma,QAAAyC,CAAA,EACA,MAAA9K,UAAA,6BAAA,EAMAtN,KAAAmI,MAAAiQ,GAAA,GAOApY,KAAA6K,YAAA,GAMA7K,KAAAmN,QAAAA,CACA,CAyCA,SAAAkL,EAAAlQ,GACA,GAAAA,EAAAgI,OACA,IAAA,IAAAxT,EAAA,EAAAA,EAAAwL,EAAA0C,YAAAnP,OAAA,EAAAiB,EACAwL,EAAA0C,YAAAlO,GAAAwT,QACAhI,EAAAgI,OAAAzB,IAAAvG,EAAA0C,YAAAlO,EAAA,CACA,CA9BAuV,EAAAhE,SAAA,SAAApO,EAAAkH,GACA,OAAA,IAAAkL,EAAApS,EAAAkH,EAAAmB,MAAAnB,EAAAjG,QAAAiG,EAAAmG,OAAA,CACA,EAOA+E,EAAA/R,UAAAkO,OAAA,SAAAC,GACAC,EAAAD,CAAAA,CAAAA,GAAAE,CAAAA,CAAAF,EAAAC,aACA,OAAA1E,EAAAmB,SAAA,CACA,UAAAhL,KAAAe,QACA,QAAAf,KAAAmI,MACA,UAAAoG,EAAAvO,KAAAmN,QAAAtS,GACA,CACA,EAqBAqX,EAAA/R,UAAAuO,IAAA,SAAA1E,GAGA,GAAAA,aAAAiF,EASA,OANAjF,EAAAmG,QAAAnG,EAAAmG,SAAAnQ,KAAAmQ,QACAnG,EAAAmG,OAAAnB,OAAAhF,CAAA,EACAhK,KAAAmI,MAAA9K,KAAA2M,EAAAlK,IAAA,EACAE,KAAA6K,YAAAxN,KAAA2M,CAAA,EAEAqO,EADArO,EAAAsB,OAAAtL,IACA,EACAA,KARA,MAAAsN,UAAA,uBAAA,CASA,EAOA4E,EAAA/R,UAAA6O,OAAA,SAAAhF,GAGA,GAAA,EAAAA,aAAAiF,GACA,MAAA3B,UAAA,uBAAA,EAEA,IAAA1R,EAAAoE,KAAA6K,YAAAoB,QAAAjC,CAAA,EAGA,GAAApO,EAAA,EACA,MAAAkC,MAAAkM,EAAA,uBAAAhK,IAAA,EAUA,OARAA,KAAA6K,YAAArK,OAAA5E,EAAA,CAAA,EAIA,CAAA,GAHAA,EAAAoE,KAAAmI,MAAA8D,QAAAjC,EAAAlK,IAAA,IAIAE,KAAAmI,MAAA3H,OAAA5E,EAAA,CAAA,EAEAoO,EAAAsB,OAAA,KACAtL,IACA,EAKAkS,EAAA/R,UAAAqV,MAAA,SAAArF,GACApD,EAAA5M,UAAAqV,MAAApP,KAAApG,KAAAmQ,CAAA,EAGA,IAFA,IAEAxT,EAAA,EAAAA,EAAAqD,KAAAmI,MAAAzM,OAAA,EAAAiB,EAAA,CACA,IAAAqN,EAAAmG,EAAAzG,IAAA1J,KAAAmI,MAAAxL,EAAA,EACAqN,GAAA,CAAAA,EAAAsB,SACAtB,EAAAsB,OALAtL,MAMA6K,YAAAxN,KAAA2M,CAAA,CAEA,CAEAqO,EAAArY,IAAA,CACA,EAKAkS,EAAA/R,UAAAsV,SAAA,SAAAtF,GACA,IAAA,IAAAnG,EAAArN,EAAA,EAAAA,EAAAqD,KAAA6K,YAAAnP,OAAA,EAAAiB,GACAqN,EAAAhK,KAAA6K,YAAAlO,IAAAwT,QACAnG,EAAAmG,OAAAnB,OAAAhF,CAAA,EACA+C,EAAA5M,UAAAsV,SAAArP,KAAApG,KAAAmQ,CAAA,CACA,EAUAtR,OAAA+Q,eAAAsC,EAAA/R,UAAA,mBAAA,CACAuJ,IAAA,WACA,IAIAM,EAJA,OAAA,MAAAhK,KAAA6K,aAAA,IAAA7K,KAAA6K,YAAAnP,SAKA,OADAsO,EAAAhK,KAAA6K,YAAA,IACA9J,SAAA,CAAA,IAAAiJ,EAAAjJ,QAAA,gBACA,CACA,CAAA,EAkBAmR,EAAAlB,EAAA,WAGA,IAFA,IAAAoH,EAAA5c,MAAAC,UAAAC,MAAA,EACAE,EAAA,EACAA,EAAAH,UAAAC,QACA0c,EAAAxc,GAAAH,UAAAG,CAAA,IACA,OAAA,SAAAuE,EAAAmY,GACAzO,EAAAuH,aAAAjR,EAAA8M,WAAA,EACAyB,IAAA,IAAAwD,EAAAoG,EAAAF,CAAA,CAAA,EACAvZ,OAAA+Q,eAAAzP,EAAAmY,EAAA,CACA5O,IAAAG,EAAA0O,YAAAH,CAAA,EACAI,IAAA3O,EAAA4O,YAAAL,CAAA,CACA,CAAA,CACA,CACA,C,4CC5NAjd,EAAAC,QAAA4X,IAEAlS,SAAA,KACAkS,GAAA3G,SAAA,CAAAqM,SAAA,CAAA,CAAA,EAEA,IAAA3F,EAAA7X,EAAA,EAAA,EACA2W,EAAA3W,EAAA,EAAA,EACAgU,EAAAhU,EAAA,EAAA,EACA+T,EAAA/T,EAAA,EAAA,EACAiX,EAAAjX,EAAA,EAAA,EACAgX,EAAAhX,EAAA,EAAA,EACA0O,EAAA1O,EAAA,EAAA,EACAkX,EAAAlX,EAAA,EAAA,EACAmX,EAAAnX,EAAA,EAAA,EACA6R,EAAA7R,EAAA,EAAA,EACAkR,EAAAlR,EAAA,EAAA,EACA2O,EAAA3O,EAAA,EAAA,EAEAyd,EAAA,gBACAC,EAAA,kBACAC,EAAA,qBACAC,EAAA,uBACAC,EAAA,YACAC,EAAA,cACAC,EAAApP,EAAAqP,SAAAD,SACAE,GAAA,2BACAC,GAAAvP,EAAAqP,SAAAE,UAkCA,SAAApG,GAAAzU,EAAAqT,EAAA7Q,GAEA6Q,aAAAC,IACA9Q,EAAA6Q,EACAA,EAAA,IAAAC,GAKA,IASAwH,EACAC,EACAC,EAi0BAC,EA9oBAA,EACAC,EA/LAC,GAFA3Y,EADAA,GACAiS,GAAA3G,UAEAqN,uBAAA,CAAA,EACAC,EAAA5G,EAAAxU,EAAAwC,EAAA6Y,sBAAA,CAAA,CAAA,EACAC,EAAAF,EAAAE,KACAxc,EAAAsc,EAAAtc,KACAyc,EAAAH,EAAAG,KACAC,EAAAJ,EAAAI,KACAC,EAAAL,EAAAK,KAEAC,EAAA,CAAA,EAIAvM,EAAA,SAEAmI,EAAAjE,EAEAsI,EAAA,GACAC,EAAA,GAEAC,EAAArZ,EAAA2X,SAAA,SAAA5Y,GAAA,OAAAA,CAAA,EAAA+J,EAAAwQ,UAaA,SAAAC,EAAAd,EAAA1Z,EAAAya,GACA,IAAAzZ,EAAAkS,GAAAlS,SAGA,OAFAyZ,IACAvH,GAAAlS,SAAA,MACAhD,MAAA,YAAAgC,GAAA,SAAA,KAAA0Z,EAAA,OAAA1Y,EAAAA,EAAA,KAAA,IAAA,QAAA6Y,EAAAa,KAAA,GAAA,CACA,CAEA,SAAAC,IACA,IACAjB,EADA7Q,EAAA,GAEA,GAEA,GAAA,OAAA6Q,EAAAK,EAAA,IAAA,MAAAL,EACA,MAAAc,EAAAd,CAAA,CAAA,OAEA7Q,EAAAtL,KAAAwc,EAAA,CAAA,EACAE,EAAAP,CAAA,EAEA,OADAA,EAAAM,EAAA,IACA,MAAAN,GACA,OAAA7Q,EAAAlL,KAAA,EAAA,CACA,CAEA,SAAAid,EAAAC,GACA,IAAAnB,EAAAK,EAAA,EACA,OAAAL,GACA,IAAA,IACA,IAAA,IAEA,OADAnc,EAAAmc,CAAA,EACAiB,EAAA,EACA,IAAA,OAAA,IAAA,OACA,MAAA,CAAA,EACA,IAAA,QAAA,IAAA,QACA,MAAA,CAAA,CACA,CACA,IACAG,IAoDApB,EApDAA,EAoDAe,EApDA,CAAA,EAqDA/X,EAAA,EAKA,OAJA,MAAAgX,EAAA,IAAAA,MACAhX,EAAA,CAAA,EACAgX,EAAAA,EAAAqB,UAAA,CAAA,GAEArB,GACA,IAAA,MAAA,IAAA,MAAA,IAAA,MACA,OAAAhX,GAAAW,EAAAA,GACA,IAAA,MAAA,IAAA,MAAA,IAAA,MAAA,IAAA,MACA,OAAAD,IACA,IAAA,IACA,OAAA,CACA,CACA,GAAAyV,EAAA5a,KAAAyb,CAAA,EACA,OAAAhX,EAAAsY,SAAAtB,EAAA,EAAA,EACA,GAAAX,EAAA9a,KAAAyb,CAAA,EACA,OAAAhX,EAAAsY,SAAAtB,EAAA,EAAA,EACA,GAAAT,EAAAhb,KAAAyb,CAAA,EACA,OAAAhX,EAAAsY,SAAAtB,EAAA,CAAA,EAGA,GAAAP,EAAAlb,KAAAyb,CAAA,EACA,OAAAhX,EAAAuY,WAAAvB,CAAA,EAGA,MAAAc,EAAAd,EAAA,SAAAe,CAAA,CAtEA,CAPA,MAAAtY,GAEA,GAAA0Y,GAAAvB,GAAArb,KAAAyb,CAAA,EACA,OAAAA,EAGA,MAAAc,EAAAd,EAAA,OAAA,CACA,CACA,CAEA,SAAAwB,EAAAC,EAAAC,GACA,IAAApe,EACA,GACA,GAAAoe,CAAAA,GAAA,OAAA1B,EAAAM,EAAA,IAAA,MAAAN,EAOA,IACAyB,EAAA5d,KAAA,CAAAP,EAAAqe,EAAAtB,EAAA,CAAA,EAAAE,EAAA,KAAA,CAAA,CAAA,EAAAoB,EAAAtB,EAAA,CAAA,EAAA/c,EAAA,CAOA,CANA,MAAAb,GACA,GAAAif,EAAAA,GAAA9B,GAAArb,KAAAyb,CAAA,GAAA,MAAA9L,GAGA,MAAAzR,EAFAgf,EAAA5d,KAAAmc,CAAA,CAIA,KAfA,CACA,IAAAhT,EAAAiU,EAAA,EAEA,GADAQ,EAAA5d,KAAAmJ,CAAA,EACA,MAAAkH,EACA,MAAA4M,EAAA9T,EAAA,IAAA,CAEA,CAUA,OACAuT,EAAA,IAAA,CAAA,CAAA,GACA,IAAAqB,EAAA,CAAAra,QAAAlG,GACAmV,UAAA,SAAAlQ,EAAAN,GACAQ,KAAAe,UAAAlG,KAAAmF,KAAAe,QAAA,IACAf,KAAAe,QAAAjB,GAAAN,CACA,CAJA,EAKA6b,EACAD,EACA,SAAA5B,GAEA,GAAA,WAAAA,EAIA,MAAAc,EAAAd,CAAA,EAHA8B,EAAAF,EAAA5B,CAAA,EACAO,EAAA,GAAA,CAGA,EACA,WACAwB,EAAAH,CAAA,CACA,CAAA,CACA,CA+BA,SAAAD,EAAA3B,EAAAgC,GACA,OAAAhC,GACA,IAAA,MAAA,IAAA,MAAA,IAAA,MACA,OAAA,UACA,IAAA,IACA,OAAA,CACA,CAGA,GAAAgC,GAAA,MAAAhC,EAAA,IAAAA,IAAA,CAGA,GAAAZ,EAAA7a,KAAAyb,CAAA,EACA,OAAAsB,SAAAtB,EAAA,EAAA,EACA,GAAAV,EAAA/a,KAAAyb,CAAA,EACA,OAAAsB,SAAAtB,EAAA,EAAA,EAGA,GAAAR,EAAAjb,KAAAyb,CAAA,EACA,OAAAsB,SAAAtB,EAAA,CAAA,CATA,CAYA,MAAAc,EAAAd,EAAA,IAAA,CACA,CA8DA,SAAAiC,EAAAtL,EAAAqJ,EAAA5E,GAIA,OAHAA,IAAA/Z,KACA+Z,EAAA,GAEA4E,GAEA,IAAA,SAGA,OAFA8B,EAAAnL,EAAAqJ,CAAA,EACAO,EAAA,GAAA,EACA,EAEA,IAAA,UAEA,OADA2B,EAAAvL,EAAAqJ,EAAA5E,EAAA,CAAA,EACA,EAEA,IAAA,OAEA,OADA+G,EAAAxL,CAAA,EACA,EAEA,IAAA,UACAyL,IAweAC,EAVA1L,EA9dAA,EA8dAqJ,EA9dAA,EA8dA5E,EA9dAA,EAAA,EAieA,IADAA,EADAA,IAAA/Z,GACA,EACA+Z,GAAA/K,EAAA+L,eACA,MAAA9X,MAAA,oBAAA,EAGA,GAAAqb,GAAApb,KAAAyb,EAAAK,EAAA,CAAA,EApeA,OAweAwB,EADAQ,EAAA,IAAAzJ,EAAAoH,CAAA,EACA,SAAAA,GACA,GAAAiC,CAAAA,EAAAI,EAAArC,EAAA5E,CAAA,EAAA,CAKA,GAAA,QAAA4E,EAGA,MAAAc,EAAAd,CAAA,EAFAsC,IAUA3L,EAVA0L,EAaAE,EAAA/B,EAAA,EAEA1S,EAAAkS,EAGA,GAAA,CAAAL,GAAApb,KAAAyb,EAAAK,EAAA,CAAA,EACA,MAAAS,EAAAd,EAAA,MAAA,EAEA,IACA5F,EAAAC,EACAC,EAFAhU,EAAA0Z,EASA,GALAO,EAAA,GAAA,EACAA,EAAA,SAAA,CAAA,CAAA,IACAlG,EAAA,CAAA,GAGA,CAAAuF,GAAArb,KAAAyb,EAAAK,EAAA,CAAA,EACA,MAAAS,EAAAd,CAAA,EAQA,GANA5F,EAAA4F,EACAO,EAAA,GAAA,EAAAA,EAAA,SAAA,EAAAA,EAAA,GAAA,EACAA,EAAA,SAAA,CAAA,CAAA,IACAjG,EAAA,CAAA,GAGA,CAAAsF,GAAArb,KAAAyb,EAAAK,EAAA,CAAA,EACA,MAAAS,EAAAd,CAAA,EAEA3X,EAAA2X,EACAO,EAAA,GAAA,EAEA,IAAAiC,EAAA,IAAA3J,EAAAvS,EAAAwH,EAAAsM,EAAA/R,EAAAgS,EAAAC,CAAA,EACAkI,EAAA7O,QAAA4O,EACAV,EAAAW,EAAA,SAAAxC,GAGA,GAAA,WAAAA,EAIA,MAAAc,EAAAd,CAAA,EAHA8B,EAAAU,EAAAxC,CAAA,EACAO,EAAA,GAAA,CAIA,CAAA,EACA5J,EAAAzB,IAAAsN,CAAA,CA7DA,CAOA,CAAA,EACA7L,EAAAzB,IAAAmN,CAAA,EACA1L,IAAA0F,GACAqE,EAAA7c,KAAAwe,CAAA,EArfA,EAqeA,MAAAvB,EAAAd,EAAA,cAAA,EAneA,IAAA,SACAyC,IA8iBAC,EANA/L,EAxiBAA,EAwiBAqJ,EAxiBAA,EAwiBA5E,EAxiBAA,EA2iBA,GAAAwE,GAAArb,KAAAyb,EAAAK,EAAA,CAAA,EA1iBA,OA6iBAqC,EAAA1C,EACA6B,EAAA,KAAA,SAAA7B,GACA,OAAAA,GAEA,IAAA,WACA,IAAA,WACA2C,EAAAhM,EAAAqJ,EAAA0C,EAAAtH,EAAA,CAAA,EACA,MAEA,IAAA,WAGAuH,EAAAhM,EADA,WAAAzC,EACA,kBAEA,WAFAwO,EAAAtH,EAAA,CAAA,EAIA,MAEA,QAEA,GAAA,WAAAlH,GAAA,CAAA0L,GAAArb,KAAAyb,CAAA,EACA,MAAAc,EAAAd,CAAA,EACAnc,EAAAmc,CAAA,EACA2C,EAAAhM,EAAA,WAAA+L,EAAAtH,EAAA,CAAA,CAEA,CACA,CAAA,EAvkBA,EA2iBA,MAAA0F,EAAAd,EAAA,WAAA,CA1iBA,CAEA,CAEA,SAAA6B,EAAAhH,EAAA+H,EAAAC,GACA,IAQA7C,EARA8C,EAAA3C,EAAAa,KAOA,GANAnG,IACA,UAAA,OAAAA,EAAAlH,UACAkH,EAAAlH,QAAA6M,EAAA,GAEA3F,EAAAvT,SAAAkS,GAAAlS,UAEAiZ,EAAA,IAAA,CAAA,CAAA,EAAA,CAEA,KAAA,OAAAP,EAAAK,EAAA,IACAuC,EAAA5C,CAAA,EACAO,EAAA,IAAA,CAAA,CAAA,CACA,MACAsC,GACAA,EAAA,EACAtC,EAAA,GAAA,EACA1F,IAAA,UAAA,OAAAA,EAAAlH,SAAAuM,KACArF,EAAAlH,QAAA6M,EAAAsC,CAAA,GAAAjI,EAAAlH,QAEA,CAEA,SAAAuO,EAAAvL,EAAAqJ,EAAA5E,GAGA,IADAA,EADAA,IAAA/Z,GACA,EACA+Z,GAAA/K,EAAA0S,aACA,MAAAze,MAAA,oBAAA,EAGA,GAAA,CAAAqb,GAAApb,KAAAyb,EAAAK,EAAA,CAAA,EACA,MAAAS,EAAAd,EAAA,WAAA,EAEA,IAAAlS,EAAA,IAAA4H,EAAAsK,CAAA,EACA6B,EAAA/T,EAAA,SAAAkS,GACA,GAAAiC,CAAAA,EAAAnU,EAAAkS,EAAA5E,CAAA,EAGA,OAAA4E,GAEA,IAAA,MACAgD,IAgLArM,EAhLA7I,EAkLAS,GADAgS,EAAA,GAAA,EACAF,EAAA,GAGA,GAAAzN,EAAAQ,OAAA7E,KAAAlN,GACA,MAAAyf,EAAAvS,EAAA,MAAA,EAEAgS,EAAA,GAAA,EACA,IAAA0C,EAAA5C,EAAA,EAGA,GAAA,CAAAT,GAAArb,KAAA0e,CAAA,EACA,MAAAnC,EAAAmC,EAAA,MAAA,EAEA1C,EAAA,GAAA,EACA,IAAAja,EAAA+Z,EAAA,EAGA,GAAA,CAAAV,GAAApb,KAAA+B,CAAA,EACA,MAAAwa,EAAAxa,EAAA,MAAA,EAEAia,EAAA,GAAA,EACA,IAAA/P,EAAA,IAAAmI,EAAAiI,EAAAta,CAAA,EAAAqb,EAAAtB,EAAA,CAAA,EAAA9R,EAAA0U,CAAA,EACApB,EAAArR,EAAA,SAAAwP,GAGA,GAAA,WAAAA,EAIA,MAAAc,EAAAd,CAAA,EAHA8B,EAAAtR,EAAAwP,CAAA,EACAO,EAAA,GAAA,CAIA,EAAA,WACAwB,EAAAvR,CAAA,CACA,CAAA,EACAmG,EAAAzB,IAAA1E,CAAA,EAnNA,MAEA,IAAA,WACA,GAAA,WAAA0D,EACA,MAAA4M,EAAAd,CAAA,EAEA,IAAA,WACA2C,EAAA7U,EAAAkS,EAAA3e,GAAA+Z,EAAA,CAAA,EACA,MAEA,IAAA,WAEA,GAAA,WAAAlH,EACAyO,EAAA7U,EAAA,kBAAAzM,GAAA+Z,EAAA,CAAA,MACA,CAAA,GAAA,WAAAlH,EACA,MAAA4M,EAAAd,CAAA,EAEA2C,EAAA7U,EAAA,WAAAzM,GAAA+Z,EAAA,CAAA,CACA,CACA,MAEA,IAAA,QACA8H,IAgMAvM,EAhMA7I,EAgMAkS,EAhMAA,EAgMA5E,EAhMAA,EAAA,EAmMA,GAAA,CAAAuE,GAAApb,KAAAyb,EAAAK,EAAA,CAAA,EACA,MAAAS,EAAAd,EAAA,MAAA,EAEA,IAAArR,EAAA,IAAA+J,EAAAkI,EAAAZ,CAAA,CAAA,EACA6B,EAAAlT,EAAA,SAAAqR,GACA,WAAAA,GACA8B,EAAAnT,EAAAqR,CAAA,EACAO,EAAA,GAAA,IAEA1c,EAAAmc,CAAA,EACA2C,EAAAhU,EAAA,WAAAtN,GAAA+Z,CAAA,EAEA,CAAA,EACAzE,EAAAzB,IAAAvG,CAAA,EA/MA,MAEA,IAAA,aACA6S,EAAA1T,EAAAqV,aAAArV,EAAAqV,WAAA,GAAA,EACA,MAEA,IAAA,WACA3B,EAAA1T,EAAAkG,WAAAlG,EAAAkG,SAAA,IAAA,CAAA,CAAA,EACA,MAEA,QAEA,GAAA,WAAAE,GAAA,CAAA0L,GAAArb,KAAAyb,CAAA,EACA,MAAAc,EAAAd,CAAA,EAGAnc,EAAAmc,CAAA,EACA2C,EAAA7U,EAAA,WAAAzM,GAAA+Z,EAAA,CAAA,CAEA,CACA,CAAA,EACAzE,EAAAzB,IAAApH,CAAA,EACA6I,IAAA0F,GACAqE,EAAA7c,KAAAiK,CAAA,CAEA,CAEA,SAAA6U,EAAAhM,EAAArH,EAAAsG,EAAAwF,GACA,IAAAtN,EAAAuS,EAAA,EACA,GAAA,UAAAvS,EAAA,CACAsV,IAyDAzM,EAzDAA,EAyDArH,EAzDAA,EAyDA8L,EAzDAA,EA4DA,IADAA,EADAA,IAAA/Z,GACA,EACA+Z,GAAA/K,EAAA0S,aACA,MAAAze,MAAA,oBAAA,EACA,GAAA,MAAA4P,EACA,MAAA4M,EAAA,OAAA,EAEA,IAWAhT,EAEA0C,EAbAlK,EAAA+Z,EAAA,EAGA,GAAAV,GAAApb,KAAA+B,CAAA,EAnEA,OAsEAwR,EAAAzH,EAAAgT,QAAA/c,CAAA,EACAA,IAAAwR,IACAxR,EAAA+J,EAAAiT,QAAAhd,CAAA,GACAia,EAAA,GAAA,EACAxS,EAAA4T,EAAAtB,EAAA,CAAA,GACAvS,EAAA,IAAA4H,EAAApP,CAAA,GACAgR,MAAA,CAAA,GAEA9G,EADA,IAAAiF,EAAAqC,EAAA/J,EAAAzH,EAAAgJ,CAAA,GACAhI,SAAAkS,GAAAlS,SACAua,EAAA/T,EAAA,SAAAkS,GACA,OAAAA,GAEA,IAAA,SACA8B,EAAAhU,EAAAkS,CAAA,EACAO,EAAA,GAAA,EACA,MACA,IAAA,WACA,IAAA,WACAoC,EAAA7U,EAAAkS,EAAA3e,GAAA+Z,EAAA,CAAA,EACA,MAEA,IAAA,WAGAuH,EAAA7U,EADA,WAAAoG,EACA,kBAEA,WAFA7S,GAAA+Z,EAAA,CAAA,EAIA,MAEA,IAAA,UACA8G,EAAApU,EAAAkS,EAAA5E,EAAA,CAAA,EACA,MAEA,IAAA,OACA+G,EAAArU,CAAA,EACA,MAEA,IAAA,WACA0T,EAAA1T,EAAAkG,WAAAlG,EAAAkG,SAAA,IAAA,CAAA,CAAA,EACA,MAGA,QACA,MAAA8M,EAAAd,CAAA,CACA,CACA,CAAA,EAtCAxP,KAuCAmG,EAAAzB,IAAApH,CAAA,EACAoH,IAAA1E,CAAA,EAlDA,MAAAsQ,EAAAxa,EAAA,MAAA,CAnEA,CAQA,KAAAwH,EAAAyV,SAAA,GAAA,GAAAjD,EAAA,EAAAkD,WAAA,GAAA,GACA1V,GAAAuS,EAAA,EAIA,GAAA,CAAAT,GAAArb,KAAAuJ,CAAA,EACA,MAAAgT,EAAAhT,EAAA,MAAA,EAEA,IAAAxH,EAAA+Z,EAAA,EAIA,GAAA,CAAAV,GAAApb,KAAA+B,CAAA,EACA,MAAAwa,EAAAxa,EAAA,MAAA,EAEAA,EAAAsa,EAAAta,CAAA,EACAia,EAAA,GAAA,EAEA,IAAA/P,EAAA,IAAAiF,EAAAnP,EAAAqb,EAAAtB,EAAA,CAAA,EAAAvS,EAAAwB,EAAAsG,CAAA,EAEAiM,EAAArR,EAAA,SAAAwP,GAGA,GAAA,WAAAA,EAIA,MAAAc,EAAAd,CAAA,EAHA8B,EAAAtR,EAAAwP,CAAA,EACAO,EAAA,GAAA,CAIA,EAAA,WACAwB,EAAAvR,CAAA,CACA,CAAA,EAEA,oBAAAlB,GAEAX,EAAA,IAAA+J,EAAA,IAAApS,CAAA,EACAkK,EAAAgG,UAAA,kBAAA,CAAA,CAAA,EACA7H,EAAAuG,IAAA1E,CAAA,EACAmG,EAAAzB,IAAAvG,CAAA,GAEAgI,EAAAzB,IAAA1E,CAAA,EAEAmG,IAAA0F,GACAqE,EAAA7c,KAAA2M,CAAA,CAEA,CA6HA,SAAA2R,EAAAxL,EAAAqJ,GAGA,GAAA,CAAAL,GAAApb,KAAAyb,EAAAK,EAAA,CAAA,EACA,MAAAS,EAAAd,EAAA,MAAA,EAEA,IAAArL,EAAA,IAAAvE,EAAA4P,CAAA,EACA6B,EAAAlN,EAAA,SAAAqL,GACA,OAAAA,GACA,IAAA,SACA8B,EAAAnN,EAAAqL,CAAA,EACAO,EAAA,GAAA,EACA,MAEA,IAAA,WACAiB,EAAA7M,EAAAX,WAAAW,EAAAX,SAAA,IAAA,CAAA,CAAA,EACAW,EAAAX,WAAA3S,KAAAsT,EAAAX,SAAA,IACA,MAEA,QACAyP,IASA9M,EATAhC,EASAqL,EATAA,EAYA,GAAA,CAAAL,GAAApb,KAAAyb,CAAA,EACA,MAAAc,EAAAd,EAAA,MAAA,EAEAO,EAAA,GAAA,EACA,IAAAva,EAAA2b,EAAAtB,EAAA,EAAA,CAAA,CAAA,EACAuB,EAAA,CACAra,QAAAlG,GAEAkW,UAAA,SAAAjR,GACA,OAAAE,KAAAe,QAAAjB,EACA,EACAkQ,UAAA,SAAAlQ,EAAAN,GACAuN,EAAA5M,UAAA6P,UAAA5J,KAAAgV,EAAAtb,EAAAN,CAAA,CACA,EACAqY,gBAAA,WACA,OAAAhd,EACA,CATA,EAnBAoiB,OA6BA5B,EAAAD,EAAA,SAAA5B,GAGA,GAAA,WAAAA,EAIA,MAAAc,EAAAd,CAAA,EAHA8B,EAAAF,EAAA5B,CAAA,EACAO,EAAA,GAAA,CAIA,EAAA,WACAwB,EAAAH,CAAA,CACA,CAAA,EAXAC,KAYAlL,EAAAzB,IAAA8K,EAAAha,EAAA4b,EAAAjO,QAAAiO,EAAArH,eAAAqH,EAAAra,OAAA,CAxCA,CACA,CAAA,EACAoP,EAAAzB,IAAAP,CAAA,EACAgC,IAAA0F,GACAqE,EAAA7c,KAAA8Q,CAAA,CAEA,CAqCA,SAAAmN,EAAAnL,EAAAqJ,GACA,IAEA0D,EAAA,CAAA,EAKA,IAJA,WAAA1D,IACAA,EAAAK,EAAA,GAGA,MAAAL,GAAA,CACA,GAAA,OAAAA,EACA,MAAAc,EAAAd,EAAA,cAAA,EAOA,GALA,MAAAA,IACA2D,EAAAtD,EAAA,EACAE,EAAA,GAAA,EACAP,EAAA,IAAA2D,EAAA,KAEAD,EAAA,CAEA,GADAA,EAAA,CAAA,EACA1D,EAAA4D,SAAA,GAAA,GAAA,CAAA5D,EAAA4D,SAAA,GAAA,EAAA,CACA,IAAAC,EAAA7D,EAAAhU,MAAA,GAAA,EACA8X,EAAAD,EAAA,GAAA,IACA7D,EAAA6D,EAAA,GACA,QACA,CACAC,EAAA9D,CACA,MACA1B,EAAAA,EAAAA,EAAA0B,EAAAA,EAEAA,EAAAK,EAAA,CACA,CACA,IAoFA/Z,EAAAgY,EApFAhY,EAAAgY,EAAAwF,EAAAC,OAAAzF,CAAA,EAAAwF,EACAE,EAMA,SAAAC,EAAAtN,EAAArQ,EAAA8U,GACAA,IAAA/Z,KACA+Z,EAAA,GACA,GAAAA,EAAA/K,EAAA+L,eACA,MAAA9X,MAAA,oBAAA,EAEA,GAAAic,EAAA,IAAA,CAAA,CAAA,EAAA,CAGA,IAFA,IAAA2D,EAAA,GAEA,CAAA3D,EAAA,IAAA,CAAA,CAAA,GAAA,CAEA,GAAA,CAAAZ,GAAApb,KAAAyb,EAAAK,EAAA,CAAA,EACA,MAAAS,EAAAd,EAAA,MAAA,EAEA,GAAA,OAAAA,EACA,MAAAc,EAAAd,EAAA,cAAA,EAGA,IAAAha,EAYAme,EAXA7F,EAAA0B,EAIA,GAFAO,EAAA,IAAA,CAAA,CAAA,EAEA,MAAAD,EAAA,EAIAta,EAAAie,EAAAtN,EAAArQ,EAAA,IAAA0Z,EAAA5E,EAAA,CAAA,OACA,GAAA,MAAAkF,EAAA,GAGA,GAFAta,EAAA,GAEAua,EAAA,IAAA,CAAA,CAAA,EAAA,CACA,KACA4D,EAAAjD,EAAA,CAAA,CAAA,EACAlb,EAAAnC,KAAAsgB,CAAA,EACA5D,EAAA,IAAA,CAAA,CAAA,IACAA,EAAA,GAAA,EACA,KAAA,IAAA4D,GACA3N,EAAAG,EAAArQ,EAAA,IAAA0Z,EAAAmE,CAAA,CAEA,CAAA,MAEAne,EAAAkb,EAAA,CAAA,CAAA,EACA1K,EAAAG,EAAArQ,EAAA,IAAA0Z,EAAAha,CAAA,EAGA,IAAAoe,EAAAF,EAAA5F,GAEA8F,IACApe,EAAA,GAAA+d,OAAAK,CAAA,EAAAL,OAAA/d,CAAA,GAEA,cAAAsY,IACA4F,EAAA5F,GAAAtY,GAGAua,EAAA,IAAA,CAAA,CAAA,EACAA,EAAA,IAAA,CAAA,CAAA,CACA,CAEA,OAAA2D,CACA,CAEA,IAAAG,EAAAnD,EAAA,CAAA,CAAA,EACA1K,EAAAG,EAAArQ,EAAA+d,CAAA,EACA,OAAAA,CAEA,EAxEA1N,EAAArQ,CAAA,EACAgY,EAAAA,GAAA,MAAAA,EAAA,GAAAA,EAAAta,MAAA,CAAA,EAAAsa,EACAwF,EAAAA,GAAA,MAAAA,EAAAA,EAAA5hB,OAAA,GAAA4hB,EAAA9f,MAAA,EAAA,CAAA,CAAA,EAAA8f,EAiFAxd,EAhFAwd,EAgFA9d,EAhFAge,EAgFA1F,EAhFAA,GAgFA3H,EAhFAA,GAiFA0H,iBACA1H,EAAA0H,gBAAA/X,EAAAN,EAAAsY,CAAA,CAjFA,CAsEA,SAAA9H,EAAAG,EAAArQ,EAAAN,GACAqW,IAAA1F,GAAA,cAAApS,KAAA+B,CAAA,EACAqa,EAAAra,GAAAN,EAGA2Q,EAAAH,WACAG,EAAAH,UAAAlQ,EAAAN,CAAA,CACA,CAOA,SAAA+b,EAAApL,GACA,GAAA4J,EAAA,IAAA,CAAA,CAAA,EAAA,CACA,KACAuB,EAAAnL,EAAA,QAAA,EACA4J,EAAA,IAAA,CAAA,CAAA,IACAA,EAAA,GAAA,CACA,CAEA,CAoHA,KAAA,QAAAP,EAAAK,EAAA,IACA,OAAAL,GAEA,IAAA,UAGA,GAAA,CAAAS,EACA,MAAAK,EAAAd,CAAA,EArqBA,GAAAH,IAAAxe,GACA,MAAAyf,EAAA,SAAA,EAKA,GAHAjB,EAAAQ,EAAA,EAGA,CAAAT,GAAArb,KAAAsb,CAAA,EACA,MAAAiB,EAAAjB,EAAA,MAAA,EAEAxD,EAAAA,EAAAH,OAAA2D,CAAA,EAEAU,EAAA,GAAA,EA6pBA,MAEA,IAAA,SAGA,GAAA,CAAAE,EACA,MAAAK,EAAAd,CAAA,EA7pBA,OADAC,EADAD,EAAAA,KAAAA,EAAAM,EAAA,GAGA,IAAA,OACAL,EAAAF,EAAAA,GAAA,GACAM,EAAA,EACA,MACA,IAAA,SACAA,EAAA,EAEA,QACAJ,EAAAH,EAAAA,GAAA,EAEA,CACAE,EAAAiB,EAAA,EACAV,EAAA,GAAA,EACAN,EAAApc,KAAAmc,CAAA,EAkpBA,MAEA,IAAA,SAGA,GAAA,CAAAS,EACA,MAAAK,EAAAd,CAAA,EAhpBA,GAJAO,EAAA,GAAA,GACArM,EAAA+M,EAAA,GAGA,KACA,MAAAH,EAAA5M,EAAA,QAAA,EAEAqM,EAAA,GAAA,EAgpBA,MAEA,IAAA,UAEA,GAAA,CAAAE,EACA,MAAAK,EAAAd,CAAA,EA5oBA,GALAO,EAAA,GAAA,EACArM,EAAA+M,EAAA,EAIA,CAHA,CAAA,QAGA2C,SAAA1P,CAAA,EACA,MAAA4M,EAAA5M,EAAA,SAAA,EAEAqM,EAAA,GAAA,EA2oBA,MAEA,IAAA,SACAuB,EAAAzF,EAAA2D,CAAA,EACAO,EAAA,IAAA,CAAA,CAAA,EACA,MAEA,QAGA,GAAA0B,EAAA5F,EAAA2D,EAAA,CAAA,EAAA,CACAS,EAAA,CAAA,EACA,QACA,CAGA,MAAAK,EAAAd,CAAA,CACA,CAMA,OAj3BAU,EAAAtM,QAAAyG,IACAA,EAAA1G,EAAAD,EACA7O,OAAAC,KAAAqb,CAAA,EAAAvM,QAAAmK,IACA1D,EAAAtD,UAAAgH,CAAA,IAAAld,IACAwZ,EAAArE,UAAA+H,EAAAoC,EAAApC,GAAA,CAAA,CAAA,CACA,CAAA,CACA,CAAA,EA02BA/E,GAAAlS,SAAA,KACA,CACAgd,QAAAzE,EACAC,QAAAA,EACAC,YAAAA,EACA3H,KAAAA,CACA,CACA,C,iGCl9BAzW,EAAAC,QAAAuX,EAEA,IAEAC,EAFA/I,EAAA3O,EAAA,EAAA,EAIA6iB,EAAAlU,EAAAkU,SACA1X,EAAAwD,EAAAxD,KAGA,SAAA2X,EAAAxK,EAAAyK,GACA,OAAAC,WAAA,uBAAA1K,EAAAjR,IAAA,OAAA0b,GAAA,GAAA,MAAAzK,EAAAlN,GAAA,CACA,CAQA,SAAAqM,EAAA9V,GAMAmD,KAAAsC,IAAAzF,EAMAmD,KAAAuC,IAAA,EAMAvC,KAAAsG,IAAAzJ,EAAAnB,MACA,CAeA,SAAAwE,IACA,OAAA2J,EAAAsU,OACA,SAAAthB,GACA,OAAA8V,EAAAzS,OAAA,SAAArD,GACA,OAAAgN,EAAAsU,OAAAC,SAAAvhB,CAAA,EACA,IAAA+V,EAAA/V,CAAA,EAEAwhB,EAAAxhB,CAAA,CACA,GAAAA,CAAA,CACA,EAEAwhB,CACA,CAzBA,IA0DA7e,EA1DA6e,EAAA,aAAA,OAAA1c,WACA,SAAA9E,GACA,GAAAA,aAAA8E,YAAAnG,MAAAma,QAAA9Y,CAAA,EACA,OAAA,IAAA8V,EAAA9V,CAAA,EACA,MAAAiB,MAAA,gBAAA,CACA,EAEA,SAAAjB,GACA,GAAArB,MAAAma,QAAA9Y,CAAA,EACA,OAAA,IAAA8V,EAAA9V,CAAA,EACA,MAAAiB,MAAA,gBAAA,CACA,EAyFA,SAAAwgB,IAEA,IAAAC,EAAA,IAAAR,EAAA,EAAA,CAAA,EACAphB,EAAA,EACA,GAAAqD,EAAA,EAAAA,KAAAsG,IAAAtG,KAAAuC,KAaA,CACA,KAAA5F,EAAA,EAAA,EAAAA,EAAA,CAEA,GAAAqD,KAAAuC,KAAAvC,KAAAsG,IACA,MAAA0X,EAAAhe,IAAA,EAGA,GADAue,EAAAva,IAAAua,EAAAva,IAAA,IAAAhE,KAAAsC,IAAAtC,KAAAuC,OAAA,EAAA5F,KAAA,EACAqD,KAAAsC,IAAAtC,KAAAuC,GAAA,IAAA,IACA,OAAAgc,CACA,CAGA,OADAA,EAAAva,IAAAua,EAAAva,IAAA,IAAAhE,KAAAsC,IAAAtC,KAAAuC,GAAA,MAAA,EAAA5F,KAAA,EACA4hB,CACA,CAzBA,KAAA5hB,EAAA,EAAA,EAAAA,EAGA,GADA4hB,EAAAva,IAAAua,EAAAva,IAAA,IAAAhE,KAAAsC,IAAAtC,KAAAuC,OAAA,EAAA5F,KAAA,EACAqD,KAAAsC,IAAAtC,KAAAuC,GAAA,IAAA,IACA,OAAAgc,EAKA,GAFAA,EAAAva,IAAAua,EAAAva,IAAA,IAAAhE,KAAAsC,IAAAtC,KAAAuC,OAAA,MAAA,EACAgc,EAAAta,IAAAsa,EAAAta,IAAA,IAAAjE,KAAAsC,IAAAtC,KAAAuC,OAAA,KAAA,EACAvC,KAAAsC,IAAAtC,KAAAuC,GAAA,IAAA,IACA,OAAAgc,EAgBA,GAfA5hB,EAAA,EAeA,EAAAqD,KAAAsG,IAAAtG,KAAAuC,KACA,KAAA5F,EAAA,EAAA,EAAAA,EAGA,GADA4hB,EAAAta,IAAAsa,EAAAta,IAAA,IAAAjE,KAAAsC,IAAAtC,KAAAuC,OAAA,EAAA5F,EAAA,KAAA,EACAqD,KAAAsC,IAAAtC,KAAAuC,GAAA,IAAA,IACA,OAAAgc,CACA,MAEA,KAAA5hB,EAAA,EAAA,EAAAA,EAAA,CAEA,GAAAqD,KAAAuC,KAAAvC,KAAAsG,IACA,MAAA0X,EAAAhe,IAAA,EAGA,GADAue,EAAAta,IAAAsa,EAAAta,IAAA,IAAAjE,KAAAsC,IAAAtC,KAAAuC,OAAA,EAAA5F,EAAA,KAAA,EACAqD,KAAAsC,IAAAtC,KAAAuC,GAAA,IAAA,IACA,OAAAgc,CACA,CAGA,MAAAzgB,MAAA,yBAAA,CACA,CAiCA,SAAA0gB,EAAAlc,EAAAvF,GACA,OAAAuF,EAAAvF,EAAA,GACAuF,EAAAvF,EAAA,IAAA,EACAuF,EAAAvF,EAAA,IAAA,GACAuF,EAAAvF,EAAA,IAAA,MAAA,CACA,CA8BA,SAAA0hB,IAGA,GAAAze,KAAAuC,IAAA,EAAAvC,KAAAsG,IACA,MAAA0X,EAAAhe,KAAA,CAAA,EAEA,OAAA,IAAA+d,EAAAS,EAAAxe,KAAAsC,IAAAtC,KAAAuC,KAAA,CAAA,EAAAic,EAAAxe,KAAAsC,IAAAtC,KAAAuC,KAAA,CAAA,CAAA,CACA,CAhMAoQ,EAAAzS,OAAAA,EAAA,EAEAyS,EAAAxS,UAAAue,EAAA7U,EAAArO,MAAA2E,UAAAwe,UAAA9U,EAAArO,MAAA2E,UAAA3C,MAqBAmV,EAAAxS,UAAAye,QACApf,EAAA,WACA,WACA,GAAAQ,KAAAsG,IAAAtG,KAAAuC,IAAA,EAAA,CACA,GAAAvC,KAAAuC,KAAAvC,KAAAsG,IACA,MAAA0X,EAAAhe,IAAA,EACA,GAAA,KAAAA,KAAAsC,IAAAtC,KAAAuC,KACAsc,CAAAA,IA1BArL,EA0BAxT,KAvBA,IADA,IAAAR,EAAA,EACA7C,EAAA,EAAAA,EAAA,EAAA,EAAAA,EAAA,CACA,GAAA6W,EAAAjR,KAAAiR,EAAAlN,IACA,MAAA0X,EAAAxK,CAAA,EACA,IAAApW,EAAAoW,EAAAlR,IAAAkR,EAAAjR,GAAA,IACA/C,GAAAA,GAAA,IAAApC,IAAA,EAAAT,KAAA,EACA,GAAAS,EAAA,IACA,OAAAoC,CACA,CACA,MAAAwe,EAAAxK,CAAA,EAeAqL,MAAA,CACA,CACA,GAAArf,GAAA,IAAAQ,KAAAsC,IAAAtC,KAAAuC,QAAA,EAAAvC,KAAAsC,IAAAtC,KAAAuC,GAAA,IAAA,MACA/C,GAAAA,GAAA,IAAAQ,KAAAsC,IAAAtC,KAAAuC,OAAA,KAAA,EAAAvC,KAAAsC,IAAAtC,KAAAuC,GAAA,IAAA,MACA/C,GAAAA,GAAA,IAAAQ,KAAAsC,IAAAtC,KAAAuC,OAAA,MAAA,EAAAvC,KAAAsC,IAAAtC,KAAAuC,GAAA,IAAA,MACA/C,GAAAA,GAAA,IAAAQ,KAAAsC,IAAAtC,KAAAuC,OAAA,MAAA,EAAAvC,KAAAsC,IAAAtC,KAAAuC,GAAA,IAAA,MACA/C,GAAAA,GAAA,GAAAQ,KAAAsC,IAAAtC,KAAAuC,OAAA,MAAA,EAAAvC,KAAAsC,IAAAtC,KAAAuC,GAAA,IAAA,KAGA,GAAAvC,KAAAuC,KAAA,GAAAvC,KAAAsG,SAIA,OAAA9G,EAFA,MADAQ,KAAAuC,IAAAvC,KAAAsG,IACA0X,EAAAhe,KAAA,EAAA,CAGA,GAOA2S,EAAAxS,UAAA2e,MAAA,WACA,OAAA,EAAA9e,KAAA4e,OAAA,CACA,EAMAjM,EAAAxS,UAAA4e,OAAA,WACA,IAAAvf,EAAAQ,KAAA4e,OAAA,EACA,OAAApf,IAAA,EAAA,EAAA,EAAAA,GAAA,CACA,EAoFAmT,EAAAxS,UAAA6e,KAAA,WACA,OAAA,IAAAhf,KAAA4e,OAAA,CACA,EAaAjM,EAAAxS,UAAA8e,QAAA,WAGA,GAAAjf,KAAAuC,IAAA,EAAAvC,KAAAsG,IACA,MAAA0X,EAAAhe,KAAA,CAAA,EAEA,OAAAwe,EAAAxe,KAAAsC,IAAAtC,KAAAuC,KAAA,CAAA,CACA,EAMAoQ,EAAAxS,UAAA+e,SAAA,WAGA,GAAAlf,KAAAuC,IAAA,EAAAvC,KAAAsG,IACA,MAAA0X,EAAAhe,KAAA,CAAA,EAEA,OAAA,EAAAwe,EAAAxe,KAAAsC,IAAAtC,KAAAuC,KAAA,CAAA,CACA,EAkCAoQ,EAAAxS,UAAAgf,MAAA,WAGA,GAAAnf,KAAAuC,IAAA,EAAAvC,KAAAsG,IACA,MAAA0X,EAAAhe,KAAA,CAAA,EAEA,IAAAR,EAAAqK,EAAAsV,MAAA1a,YAAAzE,KAAAsC,IAAAtC,KAAAuC,GAAA,EAEA,OADAvC,KAAAuC,KAAA,EACA/C,CACA,EAOAmT,EAAAxS,UAAAif,OAAA,WAGA,GAAApf,KAAAuC,IAAA,EAAAvC,KAAAsG,IACA,MAAA0X,EAAAhe,KAAA,CAAA,EAEA,IAAAR,EAAAqK,EAAAsV,MAAAha,aAAAnF,KAAAsC,IAAAtC,KAAAuC,GAAA,EAEA,OADAvC,KAAAuC,KAAA,EACA/C,CACA,EAMAmT,EAAAxS,UAAA2L,MAAA,WACA,IAAApQ,EAAAsE,KAAA4e,OAAA,EACA9hB,EAAAkD,KAAAuC,IACAxF,EAAAiD,KAAAuC,IAAA7G,EAGA,GAAAqB,EAAAiD,KAAAsG,IACA,MAAA0X,EAAAhe,KAAAtE,CAAA,EAGA,OADAsE,KAAAuC,KAAA7G,EACAF,MAAAma,QAAA3V,KAAAsC,GAAA,EACAtC,KAAAsC,IAAA9E,MAAAV,EAAAC,CAAA,EAEAD,IAAAC,GACAsiB,EAAAxV,EAAAsU,QAEAkB,EAAAtZ,MAAA,CAAA,EACA,IAAA/F,KAAAsC,IAAA2K,YAAA,CAAA,EAEAjN,KAAA0e,EAAAtY,KAAApG,KAAAsC,IAAAxF,EAAAC,CAAA,CACA,EAMA4V,EAAAxS,UAAA/D,OAAA,WACA,IAAA0P,EAAA9L,KAAA8L,MAAA,EACA,OAAAzF,EAAAE,KAAAuF,EAAA,EAAAA,EAAApQ,MAAA,CACA,EAOAiX,EAAAxS,UAAA4Z,KAAA,SAAAre,GACA,GAAA,UAAA,OAAAA,EAAA,CAEA,GAAAsE,KAAAuC,IAAA7G,EAAAsE,KAAAsG,IACA,MAAA0X,EAAAhe,KAAAtE,CAAA,EACAsE,KAAAuC,KAAA7G,CACA,MACA,GAEA,GAAAsE,KAAAuC,KAAAvC,KAAAsG,IACA,MAAA0X,EAAAhe,IAAA,CAAA,OACA,IAAAA,KAAAsC,IAAAtC,KAAAuC,GAAA,KAEA,OAAAvC,IACA,EAMA2S,EAAAiD,eAAA/L,EAAA+L,eAQAjD,EAAAxS,UAAAmf,SAAA,SAAA3S,EAAAiI,GAEA,GAAAjC,EAAAiD,gBADAhB,EAAAA,IAAA/Z,GAAA,EACA+Z,GACA,MAAA9W,MAAA,gCAAA,EACA,OAAA6O,GACA,KAAA,EACA3M,KAAA+Z,KAAA,EACA,MACA,KAAA,EACA/Z,KAAA+Z,KAAA,CAAA,EACA,MACA,KAAA,EACA/Z,KAAA+Z,KAAA/Z,KAAA4e,OAAA,CAAA,EACA,MACA,KAAA,EACA,KAAA,IAAAjS,EAAA,EAAA3M,KAAA4e,OAAA,IACA5e,KAAAsf,SAAA3S,EAAAiI,EAAA,CAAA,EAEA,MACA,KAAA,EACA5U,KAAA+Z,KAAA,CAAA,EACA,MAGA,QACA,MAAAjc,MAAA,qBAAA6O,EAAA,cAAA3M,KAAAuC,GAAA,CACA,CACA,OAAAvC,IACA,EAEA2S,EAAAnB,EAAA,SAAA+N,GACA3M,EAAA2M,EACA5M,EAAAzS,OAAAA,EAAA,EACA0S,EAAApB,EAAA,EAEA,IAAAnW,EAAAwO,EAAA4F,KAAA,SAAA,WACA5F,EAAAkE,MAAA4E,EAAAxS,UAAA,CAEAqf,MAAA,WACA,OAAAlB,EAAAlY,KAAApG,IAAA,EAAA3E,GAAA,CAAA,CAAA,CACA,EAEAokB,OAAA,WACA,OAAAnB,EAAAlY,KAAApG,IAAA,EAAA3E,GAAA,CAAA,CAAA,CACA,EAEAqkB,OAAA,WACA,OAAApB,EAAAlY,KAAApG,IAAA,EAAA2f,SAAA,EAAAtkB,GAAA,CAAA,CAAA,CACA,EAEAukB,QAAA,WACA,OAAAnB,EAAArY,KAAApG,IAAA,EAAA3E,GAAA,CAAA,CAAA,CACA,EAEAwkB,SAAA,WACA,OAAApB,EAAArY,KAAApG,IAAA,EAAA3E,GAAA,CAAA,CAAA,CACA,CAEA,CAAA,CACA,C,+BC5bAF,EAAAC,QAAAwX,EAGA,IAAAD,EAAAzX,EAAA,EAAA,EAGA2O,IAFA+I,EAAAzS,UAAAtB,OAAAqB,OAAAyS,EAAAxS,SAAA,GAAA8M,YAAA2F,EAEA1X,EAAA,EAAA,GASA,SAAA0X,EAAA/V,GACA8V,EAAAvM,KAAApG,KAAAnD,CAAA,CAOA,CAEA+V,EAAApB,EAAA,WAEA3H,EAAAsU,SACAvL,EAAAzS,UAAAue,EAAA7U,EAAAsU,OAAAhe,UAAA3C,MACA,EAMAoV,EAAAzS,UAAA/D,OAAA,WACA,IAAAkK,EAAAtG,KAAA4e,OAAA,EACA,OAAA5e,KAAAsC,IAAAwd,UACA9f,KAAAsC,IAAAwd,UAAA9f,KAAAuC,IAAAvC,KAAAuC,IAAAhG,KAAAwjB,IAAA/f,KAAAuC,IAAA+D,EAAAtG,KAAAsG,GAAA,CAAA,EACAtG,KAAAsC,IAAA9D,SAAA,QAAAwB,KAAAuC,IAAAvC,KAAAuC,IAAAhG,KAAAwjB,IAAA/f,KAAAuC,IAAA+D,EAAAtG,KAAAsG,GAAA,CAAA,CACA,EASAsM,EAAApB,EAAA,C,qCCjDArW,EAAAC,QAAAyW,EAGA,IAQA3C,EACA8D,EACAlM,EAVAkG,EAAA9R,EAAA,EAAA,EAGA+T,KAFA4C,EAAA1R,UAAAtB,OAAAqB,OAAA8M,EAAA7M,SAAA,GAAA8M,YAAA4E,GAAA3E,UAAA,OAEAhS,EAAA,EAAA,GACA0O,EAAA1O,EAAA,EAAA,EACAgX,EAAAhX,EAAA,EAAA,EACA2O,EAAA3O,EAAA,EAAA,EAaA,SAAA2W,EAAA9Q,GACAiM,EAAA5G,KAAApG,KAAA,GAAAe,CAAA,EAMAf,KAAAggB,SAAA,GAMAhgB,KAAAigB,MAAA,GAOAjgB,KAAA2N,EAAA,SAOA3N,KAAAsW,EAAA,EACA,CAwCA,SAAA4J,KA/BArO,EAAA3D,SAAA,SAAAlH,EAAA4K,EAAAgD,GAMA,OALAA,EAAA/K,EAAAgL,WAAAD,CAAA,EAEAhD,EADAA,GACA,IAAAC,EACA7K,EAAAjG,SACA6Q,EAAA2D,WAAAvO,EAAAjG,OAAA,EACA6Q,EAAAkD,QAAA9N,EAAAC,OAAA2N,CAAA,EAAAmB,WAAA,CACA,EAUAlE,EAAA1R,UAAAggB,YAAAtW,EAAAvE,KAAAvJ,QAUA8V,EAAA1R,UAAAQ,MAAAkJ,EAAAlJ,MAaAkR,EAAA1R,UAAAwR,KAAA,SAAAA,EAAA7Q,EAAAC,EAAAC,GACA,YAAA,OAAAD,IACAC,EAAAD,EACAA,EAAAlG,IAEA,IAAAulB,EAAApgB,KACA,GAAA,CAAAgB,EACA,OAAA6I,EAAAjJ,UAAA+Q,EAAAyO,EAAAtf,EAAAC,CAAA,EAGA,IAAAsf,EAAArf,IAAAkf,EAGA,SAAAI,EAAArkB,EAAA2V,GAEA,GAAA5Q,EAAA,CAGA,GAAAqf,EACA,MAAApkB,EAEA2V,GACAA,EAAAmE,WAAA,EAEA,IAAAwK,EAAAvf,EACAA,EAAA,KACAuf,EAAAtkB,EAAA2V,CAAA,CATA,CAUA,CAGA,SAAA4O,EAAA1f,GACA,IAAA2f,EAAA3f,EAAA4f,YAAA,kBAAA,EACA,GAAA,CAAA,EAAAD,EAAA,CACAE,EAAA7f,EAAA+Z,UAAA4F,CAAA,EACA,GAAAE,KAAA7Z,EAAA,OAAA6Z,CACA,CACA,OAAA,IACA,CAGA,SAAAC,EAAA9f,EAAAvC,EAAAqW,GACAA,IAAA/Z,KACA+Z,EAAA,GACA,IACA,GAAAA,EAAA/K,EAAA+L,eACA,MAAA9X,MAAA,oBAAA,EAGA,GAFA+L,EAAA8E,SAAApQ,CAAA,GAAA,MAAAA,EAAA,IAAAA,MACAA,EAAAoB,KAAAqT,MAAAzU,CAAA,GACAsL,EAAA8E,SAAApQ,CAAA,EAEA,CACAyU,EAAAlS,SAAAA,EACA,IACAoP,EADA2Q,EAAA7N,EAAAzU,EAAA6hB,EAAArf,CAAA,EAEApE,EAAA,EACA,GAAAkkB,EAAAvH,QACA,KAAA3c,EAAAkkB,EAAAvH,QAAA5d,OAAA,EAAAiB,GACAuT,EAAAsQ,EAAAK,EAAAvH,QAAA3c,EAAA,GAAAyjB,EAAAD,YAAArf,EAAA+f,EAAAvH,QAAA3c,EAAA,IACAgE,EAAAuP,EAAA,CAAA,EAAA0E,EAAA,CAAA,EACA,GAAAiM,EAAAtH,YACA,IAAA5c,EAAA,EAAAA,EAAAkkB,EAAAtH,YAAA7d,OAAA,EAAAiB,GACAuT,EAAAsQ,EAAAK,EAAAtH,YAAA5c,EAAA,GAAAyjB,EAAAD,YAAArf,EAAA+f,EAAAtH,YAAA5c,EAAA,IACAgE,EAAAuP,EAAA,CAAA,EAAA0E,EAAA,CAAA,CACA,MAdAwL,EAAA7K,WAAAhX,EAAAwC,OAAA,EAAA+T,QAAAvW,EAAA0I,MAAA,CAiBA,CAFA,MAAAhL,GACAqkB,EAAArkB,CAAA,CACA,CACAokB,GAAAS,GACAR,EAAA,KAAAF,CAAA,CAEA,CAGA,SAAAzf,EAAAG,EAAAigB,EAAAnM,GAMA,GALAA,IAAA/Z,KACA+Z,EAAA,GACA9T,EAAA0f,EAAA1f,CAAA,GAAAA,EAGAsf,CAAAA,CAAAA,EAAAH,MAAAhU,QAAAnL,CAAA,EAMA,GAHAsf,EAAAH,MAAA5iB,KAAAyD,CAAA,EAGAA,KAAAgG,EACAuZ,EACAO,EAAA9f,EAAAgG,EAAAhG,GAAA8T,CAAA,GAEA,EAAAkM,EACAE,WAAA,WACA,EAAAF,EACAF,EAAA9f,EAAAgG,EAAAhG,GAAA8T,CAAA,CACA,CAAA,QAMA,GAAAyL,EAAA,CACA,IAAA9hB,EACA,IACAA,EAAAsL,EAAAhJ,GAAAmB,aAAAlB,CAAA,EAAAtC,SAAA,MAAA,CAKA,CAJA,MAAAvC,GAGA,OAFA,KAAA8kB,GACAT,EAAArkB,CAAA,EAEA,CACA2kB,EAAA9f,EAAAvC,EAAAqW,CAAA,CACA,KACA,EAAAkM,EACAV,EAAAzf,MAAAG,EAAA,SAAA7E,EAAAsC,GACA,EAAAuiB,EAEA9f,IAGA/E,EAEA8kB,EAEAD,GACAR,EAAA,KAAAF,CAAA,EAFAE,EAAArkB,CAAA,EAKA2kB,EAAA9f,EAAAvC,EAAAqW,CAAA,EACA,CAAA,CAEA,CACA,IAAAkM,EAAA,EAIAjX,EAAA8E,SAAA7N,CAAA,IACAA,EAAA,CAAAA,IAEA,IAAA,IAAAoP,EAAAvT,EAAA,EAAAA,EAAAmE,EAAApF,OAAA,EAAAiB,GACAuT,EAAAkQ,EAAAD,YAAA,GAAArf,EAAAnE,EAAA,IACAgE,EAAAuP,CAAA,EASA,OARAmQ,EACAD,EAAArK,WAAA,EAGA+K,GACAR,EAAA,KAAAF,CAAA,EAGAA,CACA,EA+BAvO,EAAA1R,UAAA2R,SAAA,SAAAhR,EAAAC,GACA,GAAA8I,EAAAoX,OAEA,OAAAjhB,KAAA2R,KAAA7Q,EAAAC,EAAAmf,CAAA,EADA,MAAApiB,MAAA,eAAA,CAEA,EAKA+T,EAAA1R,UAAA4V,WAAA,WACA,GAAA,CAAA/V,KAAAyU,EAAA,OAAAzU,KAEA,GAAAA,KAAAggB,SAAAtkB,OACA,MAAAoC,MAAA,4BAAAkC,KAAAggB,SAAAjV,IAAA,SAAAf,GACA,MAAA,WAAAA,EAAAoF,OAAA,QAAApF,EAAAmG,OAAA5F,QACA,CAAA,EAAA9M,KAAA,IAAA,CAAA,EACA,OAAAuP,EAAA7M,UAAA4V,WAAA3P,KAAApG,IAAA,CACA,EAGA,IAAAkhB,EAAA,SAUA,SAAAC,EAAAvP,EAAA5H,GACA,IAEAoX,EAFAC,EAAArX,EAAAmG,OAAA8F,OAAAjM,EAAAoF,MAAA,EACA,GAAAiS,EASA,OARAD,EAAA,IAAAnS,EAAAjF,EAAAO,SAAAP,EAAAzC,GAAAyC,EAAA1C,KAAA0C,EAAAlB,KAAAjO,GAAAmP,EAAAjJ,OAAA,EAEAsgB,EAAA3X,IAAA0X,EAAAthB,IAAA,KAGAshB,EAAAzR,eAAA3F,GACA0F,eAAA0R,EACAC,EAAA3S,IAAA0S,CAAA,GACA,CAGA,CAQAvP,EAAA1R,UAAAoX,EAAA,SAAA5D,GACA,GAAAA,aAAA1E,EAEA0E,EAAAvE,SAAAvU,IAAA8Y,EAAAjE,gBACAyR,EAAAnhB,EAAA2T,CAAA,GACA3T,KAAAggB,SAAA3iB,KAAAsW,CAAA,OAEA,GAAAA,aAAA/J,EAEAsX,EAAAnjB,KAAA4V,EAAA7T,IAAA,IACA6T,EAAAxD,OAAAwD,EAAA7T,MAAA6T,EAAAhL,aAEA,GAAA,EAAAgL,aAAAzB,GAAA,CAEA,GAAAyB,aAAAzE,EACA,IAAA,IAAAvS,EAAA,EAAAA,EAAAqD,KAAAggB,SAAAtkB,QACAylB,EAAAnhB,EAAAA,KAAAggB,SAAArjB,EAAA,EACAqD,KAAAggB,SAAAxf,OAAA7D,EAAA,CAAA,EAEA,EAAAA,EACA,IAAA,IAAAQ,EAAA,EAAAA,EAAAwW,EAAAqB,YAAAtZ,OAAA,EAAAyB,EACA6C,KAAAuX,EAAA5D,EAAAW,EAAAnX,EAAA,EACA+jB,EAAAnjB,KAAA4V,EAAA7T,IAAA,IACA6T,EAAAxD,OAAAwD,EAAA7T,MAAA6T,EACA,EAEAA,aAAAzE,GAAAyE,aAAA/J,GAAA+J,aAAA1E,KAEAjP,KAAAsW,EAAA3C,EAAApJ,UAAAoJ,EAMA,EAQA9B,EAAA1R,UAAAqX,EAAA,SAAA7D,GAGA,IAKA/X,EAPA,GAAA+X,aAAA1E,EAEA0E,EAAAvE,SAAAvU,KACA8Y,EAAAjE,gBACAiE,EAAAjE,eAAAS,OAAAnB,OAAA2E,EAAAjE,cAAA,EACAiE,EAAAjE,eAAA,MAIA,CAAA,GAFA9T,EAAAoE,KAAAggB,SAAA/T,QAAA0H,CAAA,IAGA3T,KAAAggB,SAAAxf,OAAA5E,EAAA,CAAA,QAIA,GAAA+X,aAAA/J,EAEAsX,EAAAnjB,KAAA4V,EAAA7T,IAAA,GACA,OAAA6T,EAAAxD,OAAAwD,EAAA7T,WAEA,GAAA6T,aAAA3G,EAAA,CAEA,IAAA,IAAArQ,EAAA,EAAAA,EAAAgX,EAAAqB,YAAAtZ,OAAA,EAAAiB,EACAqD,KAAAwX,EAAA7D,EAAAW,EAAA3X,EAAA,EAEAukB,EAAAnjB,KAAA4V,EAAA7T,IAAA,GACA,OAAA6T,EAAAxD,OAAAwD,EAAA7T,KAEA,CAEA,OAAAE,KAAAsW,EAAA3C,EAAApJ,SACA,EAGAsH,EAAAL,EAAA,SAAAC,EAAA6P,EAAAC,GACArS,EAAAuC,EACAuB,EAAAsO,EACAxa,EAAAya,CACA,C,uDC1ZApmB,EAAAC,QAAAyD,OAAAqB,OAAA,IAAA,C,0BCKA9E,EA6BAgX,QAAAlX,EAAA,EAAA,C,+BClCAC,EAAAC,QAAAgX,EAEA,IAAAvI,EAAA3O,EAAA,EAAA,EAsCA,SAAAkX,EAAAoP,EAAAC,EAAAC,GAEA,GAAA,YAAA,OAAAF,EACA,MAAAlU,UAAA,4BAAA,EAEAzD,EAAA9J,aAAAqG,KAAApG,IAAA,EAMAA,KAAAwhB,QAAAA,EAMAxhB,KAAAyhB,iBAAAjT,CAAAA,CAAAiT,EAMAzhB,KAAA0hB,kBAAAlT,CAAAA,CAAAkT,CACA,GA3DAtP,EAAAjS,UAAAtB,OAAAqB,OAAA2J,EAAA9J,aAAAI,SAAA,GAAA8M,YAAAmF,GAwEAjS,UAAAwhB,QAAA,SAAAA,EAAA3F,EAAA4F,EAAAC,EAAAC,EAAA9gB,GAEA,GAAA,CAAA8gB,EACA,MAAAxU,UAAA,2BAAA,EAEA,IAAA8S,EAAApgB,KACA,GAAA,CAAAgB,EACA,OAAA6I,EAAAjJ,UAAA+gB,EAAAvB,EAAApE,EAAA4F,EAAAC,EAAAC,CAAA,EAEA,GAAA,CAAA1B,EAAAoB,QAEA,OADAR,WAAA,WAAAhgB,EAAAlD,MAAA,eAAA,CAAA,CAAA,EAAA,CAAA,EACAjD,GAGA,IACA,OAAAulB,EAAAoB,QACAxF,EACA4F,EAAAxB,EAAAqB,iBAAA,kBAAA,UAAAK,CAAA,EAAAxB,OAAA,EACA,SAAArkB,EAAAwF,GAEA,GAAAxF,EAEA,OADAmkB,EAAA3f,KAAA,QAAAxE,EAAA+f,CAAA,EACAhb,EAAA/E,CAAA,EAGA,GAAA,OAAAwF,EAEA,OADA2e,EAAArjB,IAAA,CAAA,CAAA,EACAlC,GAGA,GAAA,EAAA4G,aAAAogB,GACA,IACApgB,EAAAogB,EAAAzB,EAAAsB,kBAAA,kBAAA,UAAAjgB,CAAA,CAIA,CAHA,MAAAxF,GAEA,OADAmkB,EAAA3f,KAAA,QAAAxE,EAAA+f,CAAA,EACAhb,EAAA/E,CAAA,CACA,CAIA,OADAmkB,EAAA3f,KAAA,OAAAgB,EAAAua,CAAA,EACAhb,EAAA,KAAAS,CAAA,CACA,CACA,CAKA,CAJA,MAAAxF,GAGA,OAFAmkB,EAAA3f,KAAA,QAAAxE,EAAA+f,CAAA,EACAgF,WAAA,WAAAhgB,EAAA/E,CAAA,CAAA,EAAA,CAAA,EACApB,EACA,CACA,EAOAuX,EAAAjS,UAAApD,IAAA,SAAAglB,GAOA,OANA/hB,KAAAwhB,UACAO,GACA/hB,KAAAwhB,QAAA,KAAA,KAAA,IAAA,EACAxhB,KAAAwhB,QAAA,KACAxhB,KAAAS,KAAA,KAAA,EAAAH,IAAA,GAEAN,IACA,C,+BC5IA7E,EAAAC,QAAAgX,EAGA,IAAApF,EAAA9R,EAAA,EAAA,EAGAmX,KAFAD,EAAAjS,UAAAtB,OAAAqB,OAAA8M,EAAA7M,SAAA,GAAA8M,YAAAmF,GAAAlF,UAAA,UAEAhS,EAAA,EAAA,GACA2O,EAAA3O,EAAA,EAAA,EACA2X,EAAA3X,EAAA,EAAA,EAWA,SAAAkX,EAAAtS,EAAAiB,GACAiM,EAAA5G,KAAApG,KAAAF,EAAAiB,CAAA,EAMAf,KAAAmV,QAAA,GAOAnV,KAAAgiB,EAAA,IACA,CA8DA,SAAAtN,EAAAmH,GAEA,OADAA,EAAAmG,EAAA,KACAnG,CACA,CAhDAzJ,EAAAlE,SAAA,SAAApO,EAAAkH,EAAA4N,GACAA,EAAA/K,EAAAgL,WAAAD,CAAA,EACA,IAAAiH,EAAA,IAAAzJ,EAAAtS,EAAAkH,EAAAjG,OAAA,EAEA,GAAAiG,EAAAmO,QACA,IAAA,IAAAD,EAAArW,OAAAC,KAAAkI,EAAAmO,OAAA,EAAAxY,EAAA,EAAAA,EAAAuY,EAAAxZ,OAAA,EAAAiB,EACAkf,EAAAnN,IAAA2D,EAAAnE,SAAAgH,EAAAvY,GAAAqK,EAAAmO,QAAAD,EAAAvY,GAAA,CAAA,EAOA,OANAqK,EAAAC,QACA4U,EAAA/G,QAAA9N,EAAAC,OAAA2N,CAAA,EACA5N,EAAA0G,UACAmO,EAAAlO,EAAA3G,EAAA0G,SACAmO,EAAA1O,QAAAnG,EAAAmG,QACA0O,EAAAzN,EAAA,SACAyN,CACA,EAOAzJ,EAAAjS,UAAAkO,OAAA,SAAAC,GACA,IAAA2T,EAAAjV,EAAA7M,UAAAkO,OAAAjI,KAAApG,KAAAsO,CAAA,EACAC,EAAAD,CAAAA,CAAAA,GAAAE,CAAAA,CAAAF,EAAAC,aACA,OAAA1E,EAAAmB,SAAA,CACA,UAAAhL,KAAAyO,EAAA,EACA,UAAAwT,GAAAA,EAAAlhB,SAAAlG,GACA,UAAAmS,EAAAmH,YAAAnU,KAAAkiB,aAAA5T,CAAA,GAAA,GACA,SAAA2T,GAAAA,EAAAhb,QAAApM,GACA,UAAA0T,EAAAvO,KAAAmN,QAAAtS,GACA,CACA,EAQAgE,OAAA+Q,eAAAwC,EAAAjS,UAAA,eAAA,CACAuJ,IAAA,WACA,OAAA1J,KAAAgiB,IAAAhiB,KAAAgiB,EAAAnY,EAAAkL,QAAA/U,KAAAmV,OAAA,EACA,CACA,CAAA,EAUA/C,EAAAjS,UAAAuJ,IAAA,SAAA5J,GACA,OAAAjB,OAAAsB,UAAAiV,eAAAhP,KAAApG,KAAAmV,QAAArV,CAAA,EACAE,KAAAmV,QAAArV,GACAkN,EAAA7M,UAAAuJ,IAAAtD,KAAApG,KAAAF,CAAA,CACA,EAKAsS,EAAAjS,UAAA4V,WAAA,WACA,GAAA/V,KAAAyU,EAAA,CAEAzH,EAAA7M,UAAApE,QAAAqK,KAAApG,IAAA,EAEA,IADA,IAAAmV,EAAAnV,KAAAkiB,aACAvlB,EAAA,EAAAA,EAAAwY,EAAAzZ,OAAA,EAAAiB,EACAwY,EAAAxY,GAAAZ,QAAA,CALA,CAMA,OAAAiE,IACA,EAKAoS,EAAAjS,UAAA6V,EAAA,SAAAtI,GASA,OARA1N,KAAAwU,IAEA9G,EAAA1N,KAAA2N,GAAAD,EAEAV,EAAA7M,UAAA6V,EAAA5P,KAAApG,KAAA0N,CAAA,EACA1N,KAAAkiB,aAAAtU,QAAAoO,IACAA,EAAAhG,EAAAtI,CAAA,CACA,CAAA,GACA1N,IACA,EAKAoS,EAAAjS,UAAAuO,IAAA,SAAAiF,GAEA,GAAA3T,KAAA0J,IAAAiK,EAAA7T,IAAA,EACA,MAAAhC,MAAA,mBAAA6V,EAAA7T,KAAA,QAAAE,IAAA,EAEA,OAAA2T,aAAAtB,EACA,cAAAsB,EAAA7T,KACAE,KAGA0U,GAFA1U,KAAAmV,QAAAxB,EAAA7T,MAAA6T,GACAxD,OAAAnQ,IACA,EAEAgN,EAAA7M,UAAAuO,IAAAtI,KAAApG,KAAA2T,CAAA,CACA,EAKAvB,EAAAjS,UAAA6O,OAAA,SAAA2E,GACA,GAAAA,aAAAtB,EAAA,CAGA,GAAArS,KAAAmV,QAAAxB,EAAA7T,QAAA6T,EACA,MAAA7V,MAAA6V,EAAA,uBAAA3T,IAAA,EAIA,OAFA,OAAAA,KAAAmV,QAAAxB,EAAA7T,MACA6T,EAAAxD,OAAA,KACAuE,EAAA1U,IAAA,CACA,CACA,OAAAgN,EAAA7M,UAAA6O,OAAA5I,KAAApG,KAAA2T,CAAA,CACA,EASAvB,EAAAjS,UAAAD,OAAA,SAAAshB,EAAAC,EAAAC,GAEA,IADA,IACA1F,EADAmG,EAAA,IAAAtP,EAAAT,QAAAoP,EAAAC,EAAAC,CAAA,EACA/kB,EAAA,EAAAA,EAAAqD,KAAAkiB,aAAAxmB,OAAA,EAAAiB,EAEAwlB,EADAtY,EAAAgT,SAAAb,EAAAhc,KAAAgiB,EAAArlB,IAAAZ,QAAA,EAAA+D,IAAA,EAAAT,QAAA,WAAA,EAAA,GACA,SAAA2c,EAAApI,EAAA/R,GACA,OAAA,SAAAigB,EAAA9gB,GACA,OAAA6R,EAAAT,QAAAjS,UAAAwhB,QAAAvb,KAAApG,KAAAgc,EAAApI,EAAA/R,EAAAigB,EAAA9gB,CAAA,CACA,CACA,EAAAgb,EAAAA,EAAAhI,oBAAArD,KAAAqL,EAAA/H,qBAAAtD,IAAA,EAEA,OAAAwR,CACA,C,iDC/LAhnB,EAAAC,QAAA2X,EAEA,IAAAqP,EAAA,uBACAC,EAAA,kCACAC,EAAA,kCAEAC,EAAA,aACAC,EAAA,aACAC,EAAA,MACAC,EAAA,KACAC,EAAA,UAEAC,EAAA,CACAC,EAAA,KACAC,EAAA,KACAxmB,EAAA,KACAU,EAAA,IACA,EASA,SAAA+lB,EAAAvc,GACA,OAAAA,EAAAnH,QAAAsjB,EAAA,SAAArjB,EAAAC,GACA,OAAAA,GACA,IAAA,KACA,IAAA,GACA,OAAAA,EACA,QACA,OAAAqjB,EAAArjB,IAAA,EACA,CACA,CAAA,CACA,CA6DA,SAAAwT,EAAAxU,EAAAqb,GAEArb,EAAAA,EAAAC,SAAA,EAEA,IAAA7C,EAAA,EACAD,EAAA6C,EAAA7C,OACA8e,EAAA,EACAwI,EAAA,EACA5V,EAAA,GAEA6V,EAAA,GAEAC,EAAA,KASA,SAAA5I,EAAA6I,GACA,OAAArlB,MAAA,WAAAqlB,EAAA,UAAA3I,EAAA,GAAA,CACA,CAyBA,SAAA4I,EAAA7gB,GACA,OAAAhE,EAAAA,EAAAgE,IAAAhE,EACA,CAUA,SAAA8kB,EAAAvmB,EAAAC,EAAAumB,GACA,IAYA1lB,EAZAuP,EAAA,CACA7F,KAAA/I,EAAAA,EAAAzB,CAAA,KAAAyB,GACAglB,UAAA,CAAA,EACAC,QAAAF,CACA,EAGAG,EADA7J,EACA,EAEA,EAEA8J,EAAA5mB,EAAA2mB,EAEA,GACA,GAAA,EAAAC,EAAA,GACA,OAAA9lB,EAAAW,EAAAA,EAAAmlB,IAAAnlB,IAAA,CACA4O,EAAAoW,UAAA,CAAA,EACA,KACA,CAAA,OACA,MAAA3lB,GAAA,OAAAA,GAIA,IAHA,IAAA+lB,EAAAplB,EACAsc,UAAA/d,EAAAC,CAAA,EACAyI,MAAAid,CAAA,EACA9lB,EAAA,EAAAA,EAAAgnB,EAAAjoB,OAAA,EAAAiB,EACAgnB,EAAAhnB,GAAAgnB,EAAAhnB,GACA0C,QAAAua,EAAA4I,EAAAD,EAAA,EAAA,EACAqB,KAAA,EACAzW,EAAA0W,KAAAF,EACAlmB,KAAA,IAAA,EACAmmB,KAAA,EAEAxW,EAAAoN,GAAArN,EACA6V,EAAAxI,CACA,CAEA,SAAAsJ,EAAAC,GACA,IAAAC,EAAAC,EAAAF,CAAA,EAGAG,EAAA3lB,EAAAsc,UAAAkJ,EAAAC,CAAA,EAEA,MADA,WAAAjmB,KAAAmmB,CAAA,CAEA,CAEA,SAAAD,EAAAE,GAGA,IADA,IAAAH,EAAAG,EACAH,EAAAtoB,GAAA,OAAA0nB,EAAAY,CAAA,GACAA,CAAA,GAEA,OAAAA,CACA,CAOA,SAAAnK,IACA,GAAA,EAAAoJ,EAAAvnB,OACA,OAAAunB,EAAAtd,MAAA,EACA,GAAAud,EAAA,CA3FA,IAAAkB,EAAA,MAAAlB,EAAAZ,EAAAD,EAEAgC,GADAD,EAAAE,UAAA3oB,EAAA,EACAyoB,EAAAG,KAAAhmB,CAAA,GACA,GAAA8lB,EAKA,OAHA1oB,EAAAyoB,EAAAE,UACAjnB,EAAA6lB,CAAA,EACAA,EAAA,KACAH,EAAAsB,EAAA,EAAA,EAJA,MAAA/J,EAAA,QAAA,CAwFA,CACA,IAAAkK,EACAlP,EACAmP,EACA3nB,EACA4nB,EACAC,EAAA,IAAAhpB,EACA,EAAA,CACA,GAAAA,IAAAD,EACA,OAAA,KAEA,IADA8oB,EAAA,CAAA,EACA9B,EAAA3kB,KAAA0mB,EAAArB,EAAAznB,CAAA,CAAA,GAKA,GAJA,OAAA8oB,IACAE,EAAA,CAAA,EACA,EAAAnK,GAEA,EAAA7e,IAAAD,EACA,OAAA,KAGA,GAAA,MAAA0nB,EAAAznB,CAAA,EAAA,CACA,GAAA,EAAAA,IAAAD,EACA,MAAA4e,EAAA,SAAA,EAEA,GAAA,MAAA8I,EAAAznB,CAAA,EACA,GAAAie,EAAA,CAsBA,GADA8K,EAAA,CAAA,EACAZ,GAFAhnB,EAAAnB,GAEA,CAAA,EAEA,IADA+oB,EAAA,CAAA,GAEA/oB,EAAAsoB,EAAAtoB,CAAA,KACAD,IAGAC,CAAA,GACAgpB,GAIAb,EAAAnoB,CAAA,UAEAA,EAAAY,KAAAwjB,IAAArkB,EAAAuoB,EAAAtoB,CAAA,EAAA,CAAA,EAEA+oB,IACArB,EAAAvmB,EAAAnB,EAAAgpB,CAAA,EACAA,EAAA,CAAA,GAEAnK,CAAA,EAEA,KA5CA,CAIA,IAFAkK,EAAA,MAAAtB,EAAAtmB,EAAAnB,EAAA,CAAA,EAEA,OAAAynB,EAAA,EAAAznB,CAAA,GACA,GAAAA,IAAAD,EACA,OAAA,KAGA,EAAAC,EACA+oB,IACArB,EAAAvmB,EAAAnB,EAAA,EAAAgpB,CAAA,EAGAA,EAAA,CAAA,GAEA,EAAAnK,CA4BA,KA7CA,CA8CA,GAAA,OAAAiK,EAAArB,EAAAznB,CAAA,GAqBA,MAAA,IAnBAmB,EAAAnB,EAAA,EACA+oB,EAAA9K,GAAA,MAAAwJ,EAAAtmB,CAAA,EACA,GAIA,GAHA,OAAA2nB,GACA,EAAAjK,EAEA,EAAA7e,IAAAD,EACA,MAAA4e,EAAA,SAAA,CACA,OACAhF,EAAAmP,EACAA,EAAArB,EAAAznB,CAAA,EACA,MAAA2Z,GAAA,MAAAmP,GACA,EAAA9oB,EACA+oB,IACArB,EAAAvmB,EAAAnB,EAAA,EAAAgpB,CAAA,EACAA,EAAA,CAAA,EAKA,CAxBAH,EAAA,CAAA,CAyBA,CACA,OAAAA,GAIA,IAAAznB,EAAApB,EAGA,GAFAymB,EAAAkC,UAAA,EAEA,CADAlC,EAAArkB,KAAAqlB,EAAArmB,CAAA,EAAA,CAAA,EAEA,KAAAA,EAAArB,GAAA,CAAA0mB,EAAArkB,KAAAqlB,EAAArmB,CAAA,CAAA,GACA,EAAAA,EACAyc,EAAAjb,EAAAsc,UAAAlf,EAAAA,EAAAoB,CAAA,EAGA,MAFA,KAAAyc,GAAA,KAAAA,IACA0J,EAAA1J,GACAA,CACA,CAQA,SAAAnc,EAAAmc,GACAyJ,EAAA5lB,KAAAmc,CAAA,CACA,CAOA,SAAAM,IACA,GAAA,CAAAmJ,EAAAvnB,OAAA,CACA,IAAA8d,EAAAK,EAAA,EACA,GAAA,OAAAL,EACA,OAAA,KACAnc,EAAAmc,CAAA,CACA,CACA,OAAAyJ,EAAA,EACA,CAmDA,OAAApkB,OAAA+Q,eAAA,CACAiK,KAAAA,EACAC,KAAAA,EACAzc,KAAAA,EACA0c,KA7CA,SAAA6K,EAAA9X,GACA,IAAA+X,EAAA/K,EAAA,EAEA,GADA+K,IAAAD,EAGA,OADA/K,EAAA,EACA,CAAA,EAEA,GAAA/M,EAEA,MAAA,CAAA,EADA,MAAAwN,EAAA,UAAAuK,EAAA,OAAAD,EAAA,YAAA,CAEA,EAoCA5K,KA5BA,SAAAsC,GACA,IACAnP,EADA2X,EAAA,KAmBA,OAjBAxI,IAAAzhB,IACAsS,EAAAC,EAAAoN,EAAA,GACA,OAAApN,EAAAoN,EAAA,GACArN,IAAAyM,GAAA,MAAAzM,EAAA7F,MAAA6F,EAAAoW,aACAuB,EAAA3X,EAAAqW,QAAArW,EAAA0W,KAAA,QAIAb,EAAA1G,GACAxC,EAAA,EAEA3M,EAAAC,EAAAkP,GACA,OAAAlP,EAAAkP,GACAnP,CAAAA,GAAAA,EAAAoW,WAAA3J,CAAAA,GAAA,MAAAzM,EAAA7F,OACAwd,EAAA3X,EAAAqW,QAAA,KAAArW,EAAA0W,OAGAiB,CACA,CAQA,EAAA,OAAA,CACApb,IAAA,WAAA,OAAA8Q,CAAA,CACA,CAAA,CAEA,CAxXAzH,EAAAgQ,SAAAA,C,0BCtCA5nB,EAAAC,QAAA8T,EAGA,IAAAlC,EAAA9R,EAAA,EAAA,EAGA0O,KAFAsF,EAAA/O,UAAAtB,OAAAqB,OAAA8M,EAAA7M,SAAA,GAAA8M,YAAAiC,GAAAhC,UAAA,OAEAhS,EAAA,EAAA,GACAgX,EAAAhX,EAAA,EAAA,EACA+T,EAAA/T,EAAA,EAAA,EACAiX,EAAAjX,EAAA,EAAA,EACAkX,EAAAlX,EAAA,EAAA,EACAoX,EAAApX,EAAA,EAAA,EACAyX,EAAAzX,EAAA,EAAA,EACAuX,EAAAvX,EAAA,EAAA,EACA2O,EAAA3O,EAAA,EAAA,EACA6W,EAAA7W,EAAA,EAAA,EACA8W,EAAA9W,EAAA,EAAA,EACA+W,EAAA/W,EAAA,EAAA,EACAwP,EAAAxP,EAAA,EAAA,EACAqX,EAAArX,EAAA,EAAA,EAUA,SAAAgU,EAAApP,EAAAiB,GACAjB,EAAAA,EAAAT,QAAA,MAAA,EAAA,EACA2N,EAAA5G,KAAApG,KAAAF,EAAAiB,CAAA,EAMAf,KAAAoH,OAAA,GAMApH,KAAAiI,OAAApN,GAMAmF,KAAA2c,WAAA9hB,GAMAmF,KAAAwN,SAAA3S,GAMAmF,KAAA8Q,MAAAjW,GAOAmF,KAAA+kB,EAAA,KAOA/kB,KAAAgM,EAAA,KAOAhM,KAAAglB,EAAA,KAOAhlB,KAAAilB,EAAA,IACA,CAyHA,SAAAvQ,EAAApN,GAKA,OAJAA,EAAAyd,EAAAzd,EAAA0E,EAAA1E,EAAA0d,EAAA,KACA,OAAA1d,EAAA1K,OACA,OAAA0K,EAAA3J,OACA,OAAA2J,EAAAoM,OACApM,CACA,CA7HAzI,OAAAwY,iBAAAnI,EAAA/O,UAAA,CAQA+kB,WAAA,CACAxb,IAAA,WAGA,GAAA1J,CAAAA,KAAA+kB,EAAA,CAGA/kB,KAAA+kB,EAAA,GACA,IAAA,IAAA7P,EAAArW,OAAAC,KAAAkB,KAAAoH,MAAA,EAAAzK,EAAA,EAAAA,EAAAuY,EAAAxZ,OAAA,EAAAiB,EAAA,CACA,IAAAqN,EAAAhK,KAAAoH,OAAA8N,EAAAvY,IACA4K,EAAAyC,EAAAzC,GAGA,GAAAvH,KAAA+kB,EAAAxd,GACA,MAAAzJ,MAAA,gBAAAyJ,EAAA,OAAAvH,IAAA,EAEAA,KAAA+kB,EAAAxd,GAAAyC,CACA,CAZA,CAaA,OAAAhK,KAAA+kB,CACA,CACA,EAQAla,YAAA,CACAnB,IAAA,WACA,OAAA1J,KAAAgM,IAAAhM,KAAAgM,EAAAnC,EAAAkL,QAAA/U,KAAAoH,MAAA,EACA,CACA,EAQA+d,YAAA,CACAzb,IAAA,WACA,OAAA1J,KAAAglB,IAAAhlB,KAAAglB,EAAAnb,EAAAkL,QAAA/U,KAAAiI,MAAA,EACA,CACA,EAQA0I,KAAA,CACAjH,IAAA,WACA,OAAA1J,KAAAilB,IAAAjlB,KAAA2Q,KAAAzB,EAAAkW,oBAAAplB,IAAA,EAAA,EACA,EACAwY,IAAA,SAAA7H,GAmBA,IAhBA,IAAAxQ,EAAAwQ,EAAAxQ,UAeAxD,GAdAwD,aAAAmS,KACA3B,EAAAxQ,UAAA,IAAAmS,GAAArF,YAAA0D,EACA9G,EAAAkE,MAAA4C,EAAAxQ,UAAAA,CAAA,GAIAwQ,EAAA0C,MAAA1C,EAAAxQ,UAAAkT,MAAArT,KAGA6J,EAAAkE,MAAA4C,EAAA2B,EAAA,CAAA,CAAA,EAEAtS,KAAAilB,EAAAtU,EAGA,GACAhU,EAAAqD,KAAA6K,YAAAnP,OAAA,EAAAiB,EACAqD,KAAAgM,EAAArP,GAAAZ,QAAA,EAIA,IADA,IAAAspB,EAAA,GACA1oB,EAAA,EAAAA,EAAAqD,KAAAmlB,YAAAzpB,OAAA,EAAAiB,EACA0oB,EAAArlB,KAAAglB,EAAAroB,GAAAZ,QAAA,EAAA+D,MAAA,CACA4J,IAAAG,EAAA0O,YAAAvY,KAAAglB,EAAAroB,GAAAwL,KAAA,EACAqQ,IAAA3O,EAAA4O,YAAAzY,KAAAglB,EAAAroB,GAAAwL,KAAA,CACA,EACAxL,GACAkC,OAAAwY,iBAAA1G,EAAAxQ,UAAAklB,CAAA,CACA,CACA,CACA,CAAA,EAOAnW,EAAAkW,oBAAA,SAAAxa,GAIA,IAFA,IAEAZ,EAFAD,EAAAF,EAAA7L,QAAA,CAAA,KAAA4M,EAAA9K,IAAA,EAEAnD,EAAA,EAAAA,EAAAiO,EAAAC,YAAAnP,OAAA,EAAAiB,GACAqN,EAAAY,EAAAoB,EAAArP,IAAAoO,IAAAhB,EACA,YAAAF,EAAAiB,SAAAd,EAAAlK,IAAA,CAAA,EACAkK,EAAAM,UAAAP,EACA,YAAAF,EAAAiB,SAAAd,EAAAlK,IAAA,CAAA,EACA,OAAAiK,EACA,4FAAA,EACA,sBAAA,CAEA,EA4BAmF,EAAAhB,SAAA,SAAApO,EAAAkH,EAAA4N,GAGA,IADAA,EADAA,IAAA/Z,GACA,EACA+Z,GAAA/K,EAAA0S,aACA,MAAAze,MAAA,oBAAA,EAMA,IALA,IAAAwJ,EAAA,IAAA4H,EAAApP,EAAAkH,EAAAjG,OAAA,EAGAmU,GAFA5N,EAAAqV,WAAA3V,EAAA2V,WACArV,EAAAkG,SAAAxG,EAAAwG,SACA3O,OAAAC,KAAAkI,EAAAI,MAAA,GACAzK,EAAA,EACAA,EAAAuY,EAAAxZ,OAAA,EAAAiB,EACA2K,EAAAoH,KACA,KAAA,IAAA1H,EAAAI,OAAA8N,EAAAvY,IAAAoL,QACAoK,EACAlD,GADAf,SACAgH,EAAAvY,GAAAqK,EAAAI,OAAA8N,EAAAvY,GAAA,CACA,EACA,GAAAqK,EAAAiB,OACA,IAAAiN,EAAArW,OAAAC,KAAAkI,EAAAiB,MAAA,EAAAtL,EAAA,EAAAA,EAAAuY,EAAAxZ,OAAA,EAAAiB,EACA2K,EAAAoH,IAAAwD,EAAAhE,SAAAgH,EAAAvY,GAAAqK,EAAAiB,OAAAiN,EAAAvY,GAAA,CAAA,EACA,GAAAqK,EAAAC,OACA,IAAAiO,EAAArW,OAAAC,KAAAkI,EAAAC,MAAA,EAAAtK,EAAA,EAAAA,EAAAuY,EAAAxZ,OAAA,EAAAiB,EAAA,CACA,IAAAsK,EAAAD,EAAAC,OAAAiO,EAAAvY,IACA2K,EAAAoH,KACAzH,EAAAM,KAAA1M,GACAoU,EACAhI,EAAAG,SAAAvM,GACAqU,EACAjI,EAAA0B,SAAA9N,GACA+O,EACA3C,EAAAkO,UAAAta,GACAuX,EACApF,GAPAkB,SAOAgH,EAAAvY,GAAAsK,EAAA2N,EAAA,CAAA,CACA,CACA,CAYA,OAXA5N,EAAA2V,YAAA3V,EAAA2V,WAAAjhB,SACA4L,EAAAqV,WAAA3V,EAAA2V,YACA3V,EAAAwG,UAAAxG,EAAAwG,SAAA9R,SACA4L,EAAAkG,SAAAxG,EAAAwG,UACAxG,EAAA8J,QACAxJ,EAAAwJ,MAAA,CAAA,GACA9J,EAAAmG,UACA7F,EAAA6F,QAAAnG,EAAAmG,SACAnG,EAAA0G,UACApG,EAAAqG,EAAA3G,EAAA0G,SACApG,EAAA8G,EAAA,SACA9G,CACA,EAOA4H,EAAA/O,UAAAkO,OAAA,SAAAC,GACA,IAAA2T,EAAAjV,EAAA7M,UAAAkO,OAAAjI,KAAApG,KAAAsO,CAAA,EACAC,EAAAD,CAAAA,CAAAA,GAAAE,CAAAA,CAAAF,EAAAC,aACA,OAAA1E,EAAAmB,SAAA,CACA,UAAAhL,KAAAyO,EAAA,EACA,UAAAwT,GAAAA,EAAAlhB,SAAAlG,GACA,SAAAmS,EAAAmH,YAAAnU,KAAAmlB,YAAA7W,CAAA,EACA,SAAAtB,EAAAmH,YAAAnU,KAAA6K,YAAAqB,OAAA,SAAAmI,GAAA,MAAA,CAAAA,EAAA1E,cAAA,CAAA,EAAArB,CAAA,GAAA,GACA,aAAAtO,KAAA2c,YAAA3c,KAAA2c,WAAAjhB,OAAAsE,KAAA2c,WAAA9hB,GACA,WAAAmF,KAAAwN,UAAAxN,KAAAwN,SAAA9R,OAAAsE,KAAAwN,SAAA3S,GACA,QAAAmF,KAAA8Q,OAAAjW,GACA,SAAAonB,GAAAA,EAAAhb,QAAApM,GACA,UAAA0T,EAAAvO,KAAAmN,QAAAtS,GACA,CACA,EAKAqU,EAAA/O,UAAA4V,WAAA,WACA,GAAA/V,KAAAyU,EAAA,CAEAzH,EAAA7M,UAAA4V,WAAA3P,KAAApG,IAAA,EAEA,IADA,IAAAiI,EAAAjI,KAAAmlB,YAAAxoB,EAAA,EACAA,EAAAsL,EAAAvM,QACAuM,EAAAtL,CAAA,IAAAZ,QAAA,EAEA,IADA,IAAAqL,EAAApH,KAAA6K,YAAAlO,EAAA,EACAA,EAAAyK,EAAA1L,QACA0L,EAAAzK,CAAA,IAAAZ,QAAA,CARA,CASA,OAAAiE,IACA,EAKAkP,EAAA/O,UAAA6V,EAAA,SAAAtI,GAYA,OAXA1N,KAAAwU,IAEA9G,EAAA1N,KAAA2N,GAAAD,EAEAV,EAAA7M,UAAA6V,EAAA5P,KAAApG,KAAA0N,CAAA,EACA1N,KAAAmlB,YAAAvX,QAAAzF,IACAA,EAAAsF,EAAAC,CAAA,CACA,CAAA,EACA1N,KAAA6K,YAAA+C,QAAA5D,IACAA,EAAAyD,EAAAC,CAAA,CACA,CAAA,GACA1N,IACA,EAKAkP,EAAA/O,UAAAuJ,IAAA,SAAA5J,GACA,OAAAjB,OAAAsB,UAAAiV,eAAAhP,KAAApG,KAAAoH,OAAAtH,CAAA,EACAE,KAAAoH,OAAAtH,GACAE,KAAAiI,QAAApJ,OAAAsB,UAAAiV,eAAAhP,KAAApG,KAAAiI,OAAAnI,CAAA,EACAE,KAAAiI,OAAAnI,GACAE,KAAAiH,QAAApI,OAAAsB,UAAAiV,eAAAhP,KAAApG,KAAAiH,OAAAnH,CAAA,EACAE,KAAAiH,OAAAnH,GACA,IACA,EASAoP,EAAA/O,UAAAuO,IAAA,SAAAiF,GACA,GAAA3T,KAAA0J,IAAAiK,EAAA7T,IAAA,EACA,MAAAhC,MAAA,mBAAA6V,EAAA7T,KAAA,QAAAE,IAAA,EAEA,GAAA2T,aAAA1E,GAAA0E,EAAAvE,SAAAvU,GAAA,CAMA,IAAAmF,KAAA+kB,GAAA/kB,KAAAklB,YAAAvR,EAAApM,IACA,MAAAzJ,MAAA,gBAAA6V,EAAApM,GAAA,OAAAvH,IAAA,EACA,GAAAA,KAAA6O,aAAA8E,EAAApM,EAAA,EACA,MAAAzJ,MAAA,MAAA6V,EAAApM,GAAA,mBAAAvH,IAAA,EACA,GAAAA,KAAA8O,eAAA6E,EAAA7T,IAAA,GAAA,MAAA6T,EAAA7T,KAAA,IAAA6T,IACA,MAAA7V,MAAA,SAAA6V,EAAA7T,KAAA,oBAAAE,IAAA,EACA,MAAA,cAAA2T,EAAA7T,KACAE,MAEA2T,EAAAxD,QACAwD,EAAAxD,OAAAnB,OAAA2E,CAAA,GACA3T,KAAAoH,OAAAuM,EAAA7T,MAAA6T,GACApE,QAAAvP,KACA2T,EAAA6B,MAAAxV,IAAA,EACA0U,EAAA1U,IAAA,EACA,CACA,GAAA2T,aAAAzB,EAAA,CACA,GAAA,MAAAyB,EAAA7T,KAAA,IAAA6T,IACA,MAAA7V,MAAA,SAAA6V,EAAA7T,KAAA,oBAAAE,IAAA,EACA,MAAA,cAAA2T,EAAA7T,KACAE,MACAA,KAAAiI,SACAjI,KAAAiI,OAAA,KACAjI,KAAAiI,OAAA0L,EAAA7T,MAAA6T,GACA6B,MAAAxV,IAAA,EACA0U,EAAA1U,IAAA,EACA,CACA,OAAAgN,EAAA7M,UAAAuO,IAAAtI,KAAApG,KAAA2T,CAAA,CACA,EASAzE,EAAA/O,UAAA6O,OAAA,SAAA2E,GACA,GAAAA,aAAA1E,GAAA0E,EAAAvE,SAAAvU,GAAA,CAIA,GAAAmF,KAAAoH,QAAApH,KAAAoH,OAAAuM,EAAA7T,QAAA6T,EAMA,OAHA,OAAA3T,KAAAoH,OAAAuM,EAAA7T,MACA6T,EAAAxD,OAAA,KACAwD,EAAA8B,SAAAzV,IAAA,EACA0U,EAAA1U,IAAA,EALA,MAAAlC,MAAA6V,EAAA,uBAAA3T,IAAA,CAMA,CACA,GAAA2T,aAAAzB,EAAA,CAGA,GAAAlS,KAAAiI,QAAAjI,KAAAiI,OAAA0L,EAAA7T,QAAA6T,EAMA,OAHA,OAAA3T,KAAAiI,OAAA0L,EAAA7T,MACA6T,EAAAxD,OAAA,KACAwD,EAAA8B,SAAAzV,IAAA,EACA0U,EAAA1U,IAAA,EALA,MAAAlC,MAAA6V,EAAA,uBAAA3T,IAAA,CAMA,CACA,OAAAgN,EAAA7M,UAAA6O,OAAA5I,KAAApG,KAAA2T,CAAA,CACA,EAOAzE,EAAA/O,UAAA0O,aAAA,SAAAtH,GACA,OAAAyF,EAAA6B,aAAA7O,KAAAwN,SAAAjG,CAAA,CACA,EAOA2H,EAAA/O,UAAA2O,eAAA,SAAAhP,GACA,OAAAkN,EAAA8B,eAAA9O,KAAAwN,SAAA1N,CAAA,CACA,EAOAoP,EAAA/O,UAAAD,OAAA,SAAAkT,GACA,OAAA,IAAApT,KAAA2Q,KAAAyC,CAAA,CACA,EAMAlE,EAAA/O,UAAAmlB,MAAA,WAMA,IAFA,IAAA/a,EAAAvK,KAAAuK,SACA6B,EAAA,GACAzP,EAAA,EAAAA,EAAAqD,KAAA6K,YAAAnP,OAAA,EAAAiB,EACAyP,EAAA/O,KAAA2C,KAAAgM,EAAArP,GAAAZ,QAAA,EAAAqO,YAAA,EAGApK,KAAApD,OAAAmV,EAAA/R,IAAA,EAAA,CACAyS,OAAAA,EACArG,MAAAA,EACAvC,KAAAA,CACA,CAAA,EACA7J,KAAArC,OAAAqU,EAAAhS,IAAA,EAAA,CACA2S,OAAAA,EACAvG,MAAAA,EACAvC,KAAAA,CACA,CAAA,EACA7J,KAAA0T,OAAAzB,EAAAjS,IAAA,EAAA,CACAoM,MAAAA,EACAvC,KAAAA,CACA,CAAA,EACA7J,KAAA2K,WAAAD,EAAAC,WAAA3K,IAAA,EAAA,CACAoM,MAAAA,EACAvC,KAAAA,CACA,CAAA,EACA7J,KAAAgL,SAAAN,EAAAM,SAAAhL,IAAA,EAAA,CACAoM,MAAAA,EACAvC,KAAAA,CACA,CAAA,EAGA,IAEA0b,EAFAC,EAAAjT,EAAAhI,GAaA,OAZAib,KACAD,EAAA1mB,OAAAqB,OAAAF,IAAA,GAEA2K,WAAA3K,KAAA2K,WACA3K,KAAA2K,WAAA6a,EAAA7a,WAAAhG,KAAA4gB,CAAA,EAGAA,EAAAva,SAAAhL,KAAAgL,SACAhL,KAAAgL,SAAAwa,EAAAxa,SAAArG,KAAA4gB,CAAA,GAIAvlB,IACA,EAQAkP,EAAA/O,UAAAvD,OAAA,SAAA2S,EAAA+D,GACA,OAAAtT,KAAAslB,MAAA,EAAA1oB,OAAAV,MAAA8D,KAAAvE,SAAA,CACA,EAQAyT,EAAA/O,UAAAoT,gBAAA,SAAAhE,EAAA+D,GACA,OAAAtT,KAAApD,OAAA2S,EAAA+D,GAAAA,EAAAhN,IAAAgN,EAAAmS,KAAA,EAAAnS,CAAA,EAAAoS,OAAA,CACA,EAYAxW,EAAA/O,UAAAxC,OAAA,SAAA6V,EAAA9X,EAAAqB,EAAA6X,GACA,OAAA5U,KAAAslB,MAAA,EAAA3nB,OAAA6V,EAAA9X,EAAAqB,EAAA6X,CAAA,CACA,EASA1F,EAAA/O,UAAAsT,gBAAA,SAAAD,GAGA,OAFAA,aAAAb,IACAa,EAAAb,EAAAzS,OAAAsT,CAAA,GACAxT,KAAArC,OAAA6V,EAAAA,EAAAoL,OAAA,CAAA,CACA,EAQA1P,EAAA/O,UAAAuT,OAAA,SAAAnE,EAAAqF,GACA,OAAA5U,KAAAslB,MAAA,EAAA5R,OAAAnE,EAAAqF,CAAA,CACA,EAQA1F,EAAA/O,UAAAwK,WAAA,SAAAgJ,EAAAiB,GACA,OAAA5U,KAAAslB,MAAA,EAAA3a,WAAAgJ,EAAAiB,CAAA,CACA,EA2BA1F,EAAA/O,UAAA6K,SAAA,SAAAuE,EAAAxO,GACA,OAAAf,KAAAslB,MAAA,EAAAta,SAAA9O,MAAA8D,KAAAvE,SAAA,CACA,EAiBAyT,EAAA8B,EAAA,SAAA2U,GACA,OAAA,SAAA1K,GACApR,EAAAuH,aAAA6J,EAAA0K,CAAA,CACA,CACA,C,mHCjnBA,IAEA9b,EAAA3O,EAAA,EAAA,EAEA0qB,EAAA,CACA,SACA,QACA,QACA,SACA,SACA,UACA,WACA,QACA,SACA,SACA,UACA,WACA,OACA,SACA,SAGA,SAAAC,EAAAld,EAAAhN,GACA,IAAAgB,EAAA,EAAAmpB,EAAAjnB,OAAAqB,OAAA,IAAA,EAEA,IADAvE,GAAA,EACAgB,EAAAgM,EAAAjN,QAAAoqB,EAAAF,EAAAjpB,EAAAhB,IAAAgN,EAAAhM,CAAA,IACA,OAAAmpB,CACA,CAsBA1Z,EAAAE,MAAAuZ,EAAA,CACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EAuBAzZ,EAAAC,SAAAwZ,EAAA,CACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,CAAA,EACA,GACAhc,EAAA6G,WACA,KACA,EAYAtE,EAAAX,KAAAoa,EAAA,CACA,EACA,EACA,EACA,EACA,GACA,CAAA,EAmBAzZ,EAAAQ,OAAAiZ,EAAA,CACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,GACA,CAAA,EAoBAzZ,EAAAG,OAAAsZ,EAAA,CACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,EACA,C,+BC7LA,IAIA3W,EACAtF,EALAC,EAAA1O,EAAAC,QAAAF,EAAA,EAAA,EAEA4X,EAAA5X,EAAA,EAAA,EAUA+C,GALA4L,EAAA7L,QAAA9C,EAAA,CAAA,EACA2O,EAAAlJ,MAAAzF,EAAA,CAAA,EACA2O,EAAAvE,KAAApK,EAAA,CAAA,EACA2O,EAAAqP,SAAAhe,EAAA,EAAA,EAEA2O,EAAAqP,SAAAjb,YAqFA8nB,GA/EAlc,EAAAhJ,GAAA3F,EAAA,EAAA,EAQA2O,EAAAgL,WAAA,SAAAD,GAGA,IADAA,EADAA,IAAA/Z,GACA,EACA+Z,GAAA/K,EAAA+L,eACA,MAAA9X,MAAA,oBAAA,EACA,OAAA8W,CACA,EAOA/K,EAAAkL,QAAA,SAAApB,GACA,GAAAA,EAAA,CAIA,IAHA,IAAA7U,EAAAD,OAAAC,KAAA6U,CAAA,EACAS,EAAA5Y,MAAAsD,EAAApD,MAAA,EACAE,EAAA,EACAA,EAAAkD,EAAApD,QACA0Y,EAAAxY,GAAA+X,EAAA7U,EAAAlD,CAAA,KACA,OAAAwY,CACA,CACA,MAAA,EACA,EAOAvK,EAAAmB,SAAA,SAAAoJ,GAGA,IAFA,IAAAT,EAAA,GACA/X,EAAA,EACAA,EAAAwY,EAAA1Y,QAAA,CACA,IAAAmS,EAAAuG,EAAAxY,CAAA,IACAyG,EAAA+R,EAAAxY,CAAA,IACAyG,IAAAxH,KACA8Y,EAAA9F,GAAAxL,EACA,CACA,OAAAsR,CACA,EAOA9J,EAAAmc,WAAA,SAAAlmB,GACA,OAAA7B,EAAAF,KAAA+B,CAAA,CACA,EAOA+J,EAAAiB,SAAA,SAAAZ,GACA,MAAA,CAAA,YAAAnM,KAAAmM,CAAA,GAAAjM,EAAAF,KAAAmM,CAAA,EACA,IAAAvK,KAAAC,UAAAsK,CAAA,EAAA,IACA,IAAAA,CACA,EAOAL,EAAAiT,QAAA,SAAAtW,GACA,OAAAA,EAAA,IAAAA,IAAAyf,YAAA,EAAAzf,EAAAqU,UAAA,CAAA,CACA,EAEA,aAuDAqL,GAhDArc,EAAAwQ,UAAA,SAAA7T,GACA,OAAAA,EAAAqU,UAAA,EAAA,CAAA,EACArU,EAAAqU,UAAA,CAAA,EACAxb,QAAA0mB,EAAA,SAAAzmB,EAAAC,GAAA,OAAAA,EAAA0mB,YAAA,CAAA,CAAA,CACA,EAQApc,EAAAqB,kBAAA,SAAAib,EAAA/oB,GACA,OAAA+oB,EAAA5e,GAAAnK,EAAAmK,EACA,EAUAsC,EAAAuH,aAAA,SAAAT,EAAAgV,GAGA,OAAAhV,EAAA0C,OACAsS,GAAAhV,EAAA0C,MAAAvT,OAAA6lB,IACA9b,EAAAuc,aAAApX,OAAA2B,EAAA0C,KAAA,EACA1C,EAAA0C,MAAAvT,KAAA6lB,EACA9b,EAAAuc,aAAA1X,IAAAiC,EAAA0C,KAAA,GAEA1C,EAAA0C,QAOA/L,EAAA,IAFA4H,EADAA,GACAhU,EAAA,EAAA,GAEAyqB,GAAAhV,EAAA7Q,IAAA,EACA+J,EAAAuc,aAAA1X,IAAApH,CAAA,EACAA,EAAAqJ,KAAAA,EACA9R,OAAA+Q,eAAAe,EAAA,QAAA,CAAAnR,MAAA8H,EAAA+e,WAAA,CAAA,CAAA,CAAA,EACAxnB,OAAA+Q,eAAAe,EAAAxQ,UAAA,QAAA,CAAAX,MAAA8H,EAAA+e,WAAA,CAAA,CAAA,CAAA,EACA/e,EACA,EAEA,GAOAuC,EAAAwH,aAAA,SAAAsC,GAGA,IAOAxF,EAPA,OAAAwF,EAAAN,QAOAlF,EAAA,IAFAvE,EADAA,GACA1O,EAAA,EAAA,GAEA,OAAAgrB,CAAA,GAAAvS,CAAA,EACA9J,EAAAuc,aAAA1X,IAAAP,CAAA,EACAtP,OAAA+Q,eAAA+D,EAAA,QAAA,CAAAnU,MAAA2O,EAAAkY,WAAA,CAAA,CAAA,CAAA,EACAlY,EACA,EAWAtE,EAAA+N,YAAA,SAAA0O,EAAAhhB,EAAA9F,EAAAyQ,GAkBA,GAAA,UAAA,OAAAqW,EACA,MAAAhZ,UAAA,uBAAA,EACA,GAAA,CAAAhI,EACA,MAAAgI,UAAA,wBAAA,EAGA,IADAhI,EAAAA,EAAAE,MAAA,GAAA,GACA9J,OAAAmO,EAAA+L,eACA,MAAA9X,MAAA,oBAAA,EACA,OAzBA,SAAAyoB,EAAAD,EAAAhhB,EAAA9F,GACA,IAAAsW,EAAAxQ,EAAAK,MAAA,EACA,GAAAkE,CAAAA,EAAA2c,iBAAA1Q,CAAA,EAEA,GAAA,EAAAxQ,EAAA5J,OACA4qB,EAAAxQ,GAAAyQ,EAAAD,EAAAxQ,IAAA,GAAAxQ,EAAA9F,CAAA,MACA,CAEA,IADAoe,EAAA0I,EAAAxQ,KACA7F,EACA,OAAAqW,EACA1I,IACApe,EAAA,GAAA+d,OAAAK,CAAA,EAAAL,OAAA/d,CAAA,GACA8mB,EAAAxQ,GAAAtW,CACA,CACA,OAAA8mB,CACA,EAUAA,EAAAhhB,EAAA9F,CAAA,CACA,EAQAX,OAAA+Q,eAAA/F,EAAA,eAAA,CACAH,IAAA,WACA,OAAAoJ,EAAA,YAAAA,EAAA,UAAA,IAAA5X,EAAA,EAAA,GACA,CACA,CAAA,C,+ECnOA,IAAA2F,EAAA,KACA,KACAA,EAAA3F,EAAA,EAAA,IACA2F,EAAAK,UAAAL,EAAAmB,eACAnB,EAAA,KAGA,CAFA,MAAAoB,IAGA9G,EAAAC,QAAAyF,C,+BCTA1F,EAAAC,QAAA2iB,EAEA,IAAAlU,EAAA3O,EAAA,EAAA,EAUA,SAAA6iB,EAAA/Z,EAAAC,GASAjE,KAAAgE,GAAAA,IAAA,EAMAhE,KAAAiE,GAAAA,IAAA,CACA,CAOA,IAAAwiB,EAAA1I,EAAA0I,KAAA,IAAA1I,EAAA,EAAA,CAAA,EAoFAlgB,GAlFA4oB,EAAA5a,SAAA,WAAA,OAAA,CAAA,EACA4a,EAAAC,SAAAD,EAAA9G,SAAA,WAAA,OAAA3f,IAAA,EACAymB,EAAA/qB,OAAA,WAAA,OAAA,CAAA,EAOAqiB,EAAA4I,SAAA,mBAOA5I,EAAAzN,WAAA,SAAA9Q,GACA,IAEAgD,EAGAwB,EALA,OAAA,IAAAxE,EACAinB,GAIAziB,GADAxE,GAFAgD,EAAAhD,EAAA,GAEA,CAAAA,EACAA,KAAA,EACAyE,GAAAzE,EAAAwE,GAAA,aAAA,EACAxB,IACAyB,EAAA,CAAAA,IAAA,EACAD,EAAA,CAAAA,IAAA,EACA,WAAA,EAAAA,IACAA,EAAA,EACA,WAAA,EAAAC,IACAA,EAAA,KAGA,IAAA8Z,EAAA/Z,EAAAC,CAAA,EACA,EAOA8Z,EAAA6I,KAAA,SAAApnB,GACA,GAAA,UAAA,OAAAA,EACA,OAAAue,EAAAzN,WAAA9Q,CAAA,EACA,GAAAqK,EAAA8E,SAAAnP,CAAA,EAAA,CAEA,GAAAqK,CAAAA,EAAA4F,KAGA,OAAAsO,EAAAzN,WAAAwK,SAAAtb,EAAA,EAAA,CAAA,EAFAA,EAAAqK,EAAA4F,KAAAoX,WAAArnB,CAAA,CAGA,CACA,OAAAA,EAAAkM,KAAAlM,EAAAmM,KAAA,IAAAoS,EAAAve,EAAAkM,MAAA,EAAAlM,EAAAmM,OAAA,CAAA,EAAA8a,CACA,EAOA1I,EAAA5d,UAAA0L,SAAA,SAAAD,GACA,IAEA3H,EAFA,MAAA,CAAA2H,GAAA5L,KAAAiE,KAAA,IACAD,EAAA,EAAA,CAAAhE,KAAAgE,KAAA,EACAC,EAAA,CAAAjE,KAAAiE,KAAA,EAGA,EAAAD,EAAA,YADAC,EADAD,EAEAC,EADAA,EAAA,IAAA,KAGAjE,KAAAgE,GAAA,WAAAhE,KAAAiE,EACA,EAOA8Z,EAAA5d,UAAA2mB,OAAA,SAAAlb,GACA,OAAA/B,EAAA4F,KACA,IAAA5F,EAAA4F,KAAA,EAAAzP,KAAAgE,GAAA,EAAAhE,KAAAiE,GAAAuK,CAAAA,CAAA5C,CAAA,EAEA,CAAAF,IAAA,EAAA1L,KAAAgE,GAAA2H,KAAA,EAAA3L,KAAAiE,GAAA2H,SAAA4C,CAAAA,CAAA5C,CAAA,CACA,EAEAtO,OAAA6C,UAAAtC,YAOAkgB,EAAAgJ,SAAA,SAAAC,GACA,MAjFAjJ,qBAiFAiJ,EACAP,EACA,IAAA1I,GACAlgB,EAAAuI,KAAA4gB,EAAA,CAAA,EACAnpB,EAAAuI,KAAA4gB,EAAA,CAAA,GAAA,EACAnpB,EAAAuI,KAAA4gB,EAAA,CAAA,GAAA,GACAnpB,EAAAuI,KAAA4gB,EAAA,CAAA,GAAA,MAAA,GAEAnpB,EAAAuI,KAAA4gB,EAAA,CAAA,EACAnpB,EAAAuI,KAAA4gB,EAAA,CAAA,GAAA,EACAnpB,EAAAuI,KAAA4gB,EAAA,CAAA,GAAA,GACAnpB,EAAAuI,KAAA4gB,EAAA,CAAA,GAAA,MAAA,CACA,CACA,EAMAjJ,EAAA5d,UAAA8mB,OAAA,WACA,OAAA3pB,OAAAC,aACA,IAAAyC,KAAAgE,GACAhE,KAAAgE,KAAA,EAAA,IACAhE,KAAAgE,KAAA,GAAA,IACAhE,KAAAgE,KAAA,GACA,IAAAhE,KAAAiE,GACAjE,KAAAiE,KAAA,EAAA,IACAjE,KAAAiE,KAAA,GAAA,IACAjE,KAAAiE,KAAA,EACA,CACA,EAMA8Z,EAAA5d,UAAAumB,SAAA,WACA,IAAAQ,EAAAlnB,KAAAiE,IAAA,GAGA,OAFAjE,KAAAiE,KAAAjE,KAAAiE,IAAA,EAAAjE,KAAAgE,KAAA,IAAAkjB,KAAA,EACAlnB,KAAAgE,IAAAhE,KAAAgE,IAAA,EAAAkjB,KAAA,EACAlnB,IACA,EAMA+d,EAAA5d,UAAAwf,SAAA,WACA,IAAAuH,EAAA,EAAA,EAAAlnB,KAAAgE,IAGA,OAFAhE,KAAAgE,KAAAhE,KAAAgE,KAAA,EAAAhE,KAAAiE,IAAA,IAAAijB,KAAA,EACAlnB,KAAAiE,IAAAjE,KAAAiE,KAAA,EAAAijB,KAAA,EACAlnB,IACA,EAMA+d,EAAA5d,UAAAzE,OAAA,WACA,IAAAyrB,EAAAnnB,KAAAgE,GACAojB,GAAApnB,KAAAgE,KAAA,GAAAhE,KAAAiE,IAAA,KAAA,EACAojB,EAAArnB,KAAAiE,KAAA,GACA,OAAA,GAAAojB,EACA,GAAAD,EACAD,EAAA,MACAA,EAAA,IAAA,EAAA,EACAA,EAAA,QAAA,EAAA,EACAC,EAAA,MACAA,EAAA,IAAA,EAAA,EACAA,EAAA,QAAA,EAAA,EACAC,EAAA,IAAA,EAAA,EACA,C,+BCtMA,IAAAxd,EAAAzO,EA6BA,SAAAorB,EAAA3Y,GACA,MAAA,cAAAA,GAAA,cAAAA,GAAA,gBAAAA,CACA,CA4NA,SAAAE,EAAAuY,GAIA,IAHA,IACAgB,GAAArX,EADA,WAAA,OAAAxU,UAAAA,UAAAC,OAAA,IACAD,UAAAC,OAAA,EAAAD,UAAAC,OACAuU,EAAAA,GAAAxU,UAAAA,UAAAC,OAAA,GACAyqB,EAAA,EAAAA,EAAAmB,EAAA,EAAAnB,EAAA,CACA,IAAAoB,EAAA9rB,UAAA0qB,GACA,GAAAoB,EAEA,IAAA,IAAAzoB,EAAAD,OAAAC,KAAAyoB,CAAA,EAAA5qB,EAAA,EAAAA,EAAAmC,EAAApD,OAAA,EAAAiB,EACA6pB,EAAA1nB,EAAAnC,EAAA,GAAA2pB,EAAAxnB,EAAAnC,MAAA9B,IAAAoV,IACAqW,EAAAxnB,EAAAnC,IAAA4qB,EAAAzoB,EAAAnC,IACA,CACA,OAAA2pB,CACA,CAgDA,SAAAkB,EAAA1nB,GAEA,SAAA2nB,EAAAlY,EAAA6D,GAEA,GAAA,EAAApT,gBAAAynB,GACA,OAAA,IAAAA,EAAAlY,EAAA6D,CAAA,EAKAvU,OAAA+Q,eAAA5P,KAAA,UAAA,CAAA0J,IAAA,WAAA,OAAA6F,CAAA,CAAA,CAAA,EAGAzR,MAAA4pB,kBACA5pB,MAAA4pB,kBAAA1nB,KAAAynB,CAAA,EAEA5oB,OAAA+Q,eAAA5P,KAAA,QAAA,CAAAR,MAAA1B,MAAA,EAAAmlB,OAAA,EAAA,CAAA,EAEA7P,GACArF,EAAA/N,KAAAoT,CAAA,CACA,CA2BA,OAzBAqU,EAAAtnB,UAAAtB,OAAAqB,OAAApC,MAAAqC,UAAA,CACA8M,YAAA,CACAzN,MAAAioB,EACAE,SAAA,CAAA,EACAtB,WAAA,CAAA,EACAuB,aAAA,CAAA,CACA,EACA9nB,KAAA,CACA4J,IAAA,WAAA,OAAA5J,CAAA,EACA0Y,IAAA3d,GACAwrB,WAAA,CAAA,EAKAuB,aAAA,CAAA,CACA,EACAppB,SAAA,CACAgB,MAAA,WAAA,OAAAQ,KAAAF,KAAA,KAAAE,KAAAuP,OAAA,EACAoY,SAAA,CAAA,EACAtB,WAAA,CAAA,EACAuB,aAAA,CAAA,CACA,CACA,CAAA,EAEAH,CACA,CArWA5d,EAAAjJ,UAAA1F,EAAA,CAAA,EAGA2O,EAAA1N,OAAAjB,EAAA,CAAA,EAGA2O,EAAA9J,aAAA7E,EAAA,CAAA,EAGA2O,EAAAsV,MAAAjkB,EAAA,CAAA,EAGA2O,EAAAxD,KAAAnL,EAAA,EAAA,EAGA2O,EAAAge,KAAA3sB,EAAA,CAAA,EAGA2O,EAAAkU,SAAA7iB,EAAA,EAAA,EAYA2O,EAAA2c,iBAAAA,EAOA3c,EAAAoX,OAAAzS,CAAAA,EAAA,aAAA,OAAAsZ,QACAA,QACAA,OAAAlH,SACAkH,OAAAlH,QAAAmH,UACAD,OAAAlH,QAAAmH,SAAAC,MAOAne,EAAAie,OAAAje,EAAAoX,QAAA6G,QACA,aAAA,OAAAG,QAAAA,QACA,aAAA,OAAA7H,MAAAA,MACApgB,KAQA6J,EAAA6G,WAAA7R,OAAA0R,OAAA1R,OAAA0R,OAAA,EAAA,EAAA,GAOA1G,EAAA4G,YAAA5R,OAAA0R,OAAA1R,OAAA0R,OAAA,EAAA,EAAA,GAQA1G,EAAA+E,UAAAnP,OAAAmP,WAAA,SAAApP,GACA,MAAA,UAAA,OAAAA,GAAA0oB,SAAA1oB,CAAA,GAAAjD,KAAAmD,MAAAF,CAAA,IAAAA,CACA,EAOAqK,EAAA8E,SAAA,SAAAnP,GACA,MAAA,UAAA,OAAAA,GAAAA,aAAAlC,MACA,EAOAuM,EAAAwF,SAAA,SAAA7P,GACA,OAAAA,GAAA,UAAA,OAAAA,CACA,EAUAqK,EAAAse,MAQAte,EAAAue,MAAA,SAAA/T,EAAAnK,GACA,IAAA1K,EAAA6U,EAAAnK,GACA,MAAA1K,EAAA,MAAAA,GAAAX,CAAAA,OAAAuW,eAAAhP,KAAAiO,EAAAnK,CAAA,KACA,UAAA,OAAA1K,GAAA,GAAAhE,MAAAma,QAAAnW,CAAA,EAAAA,EAAAX,OAAAC,KAAAU,CAAA,GAAA9D,OAEA,EAaAmO,EAAAsU,OAAA,WACA,IACA,IAAAA,EAAAtU,EAAAie,OAAA3J,OAEA,OAAAA,EAAAhe,UAAAkoB,UAAAlK,EAAA,IAIA,CAHA,MAAAlc,GAEA,OAAA,IACA,CACA,EAAA,EAGA4H,EAAAye,EAAA,KAGAze,EAAA0e,EAAA,KAOA1e,EAAA2G,UAAA,SAAAgY,GAEA,MAAA,UAAA,OAAAA,EACA3e,EAAAsU,OACAtU,EAAA0e,EAAAC,CAAA,EACA,IAAA3e,EAAArO,MAAAgtB,CAAA,EACA3e,EAAAsU,OACAtU,EAAAye,EAAAE,CAAA,EACA,aAAA,OAAA7mB,WACA6mB,EACA,IAAA7mB,WAAA6mB,CAAA,CACA,EAMA3e,EAAArO,MAAA,aAAA,OAAAmG,WAAAA,WAAAnG,MAeAqO,EAAA4F,KAAA5F,EAAAie,OAAAW,SAAA5e,EAAAie,OAAAW,QAAAhZ,MACA5F,EAAAie,OAAArY,MACA,WACA,IACA,IAAAA,EAAAvU,EAAA,MAAA,EACA,OAAAuU,GAAAA,EAAAiZ,OAAAjZ,EAAA,IAIA,CAHA,MAAAxN,GAEA,OAAA,IACA,CACA,EAAA,EAOA4H,EAAA8e,OAAA,mBAOA9e,EAAA+e,QAAA,wBAOA/e,EAAAgf,QAAA,6CAOAhf,EAAAif,WAAA,SAAAtpB,GACA,OAAAA,EACAqK,EAAAkU,SAAA6I,KAAApnB,CAAA,EAAAynB,OAAA,EACApd,EAAAkU,SAAA4I,QACA,EAQA9c,EAAAkf,aAAA,SAAA/B,EAAApb,GACA2S,EAAA1U,EAAAkU,SAAAgJ,SAAAC,CAAA,EACA,OAAAnd,EAAA4F,KACA5F,EAAA4F,KAAAuZ,SAAAzK,EAAAva,GAAAua,EAAAta,GAAA2H,CAAA,EACA2S,EAAA1S,SAAA2C,CAAAA,CAAA5C,CAAA,CACA,EAwBA/B,EAAAkE,MAAAA,EAOAlE,EAAA0S,aAAA,GAOA1S,EAAA+L,eAAA,IASA/L,EAAAof,SAAA,SAAA5U,EAAAxG,GACAhP,OAAA+Q,eAAAyE,EAAAxG,EAAA,CACAwY,WAAA,CAAA,EACAuB,aAAA,CAAA,EACAD,SAAA,CAAA,CACA,CAAA,CACA,EAOA9d,EAAAgT,QAAA,SAAArW,GACA,OAAAA,EAAA,IAAAA,IAAA8I,YAAA,EAAA9I,EAAAqU,UAAA,CAAA,CACA,EA0DAhR,EAAA2d,SAAAA,EAmBA3d,EAAAqf,cAAA1B,EAAA,eAAA,EAoBA3d,EAAA0O,YAAA,SAAAH,GAEA,IADA,IAAA+Q,EAAA,GACAxsB,EAAA,EAAAA,EAAAyb,EAAA1c,OAAA,EAAAiB,EACAwsB,EAAA/Q,EAAAzb,IAAA,EAOA,OAAA,WACA,IAAA,IAAAmC,EAAAD,OAAAC,KAAAkB,IAAA,EAAArD,EAAAmC,EAAApD,OAAA,EAAA,CAAA,EAAAiB,EAAA,EAAAA,EACA,GAAA,IAAAwsB,EAAArqB,EAAAnC,KAAAqD,KAAAlB,EAAAnC,MAAA9B,IAAA,OAAAmF,KAAAlB,EAAAnC,IACA,OAAAmC,EAAAnC,EACA,CACA,EAeAkN,EAAA4O,YAAA,SAAAL,GAQA,OAAA,SAAAtY,GACA,IAAA,IAAAnD,EAAA,EAAAA,EAAAyb,EAAA1c,OAAA,EAAAiB,EACAyb,EAAAzb,KAAAmD,GACA,OAAAE,KAAAoY,EAAAzb,GACA,CACA,EAkBAkN,EAAAyE,cAAA,CACA8a,MAAA9rB,OACA+rB,MAAA/rB,OACAwO,MAAAxO,OACA0J,KAAA,CAAA,CACA,EAGA6C,EAAA2H,EAAA,WACA,IAAA2M,EAAAtU,EAAAsU,OAEAA,GAMAtU,EAAAye,EAAAnK,EAAAyI,OAAAjlB,WAAAilB,MAAAzI,EAAAyI,MAEA,SAAApnB,EAAA8pB,GACA,OAAA,IAAAnL,EAAA3e,EAAA8pB,CAAA,CACA,EACAzf,EAAA0e,EAAApK,EAAAoL,aAEA,SAAAvjB,GACA,OAAA,IAAAmY,EAAAnY,CAAA,CACA,GAdA6D,EAAAye,EAAAze,EAAA0e,EAAA,IAeA,C,qECteArP,EAAAD,SAAA,oDACAC,EAAAE,UAAA,+DACAF,EAAAjb,WAAA,sT,0BCLA9C,EAAAC,QAwHA,SAAAwP,GAGA,IAAAb,EAAAF,EAAA7L,QAAA,CAAA,IAAA,KAAA4M,EAAA9K,KAAA,SAAA,EACA,mCAAA,EACA,WAAA,iBAAA,EACA,sBAAA,EACA,2BAAA,EACA,WAAA,gCAAA,EACAmI,EAAA2C,EAAAua,YACAqE,EAAA,GACAvhB,EAAAvM,QAAAqO,EACA,UAAA,EAEA,IAAA,IAAApN,EAAA,EAAAA,EAAAiO,EAAAC,YAAAnP,OAAA,EAAAiB,EAAA,CACA,IA2BA8sB,EA3BAzf,EAAAY,EAAAoB,EAAArP,GAAAZ,QAAA,EACAoQ,EAAA,IAAAtC,EAAAiB,SAAAd,EAAAlK,IAAA,EAEAkK,EAAA8C,UAAA/C,EACA,kDAAAoC,EAAAnC,EAAAlK,IAAA,EAGAkK,EAAAe,KAAAhB,EACA,yBAAAoC,CAAA,EACA,WAAAud,EAAA1f,EAAA,QAAA,CAAA,EACA,wBAAAmC,CAAA,EACA,8BAAA,EA3DA,SAAApC,EAAAC,EAAAmC,GAEA,OAAAnC,EAAAjC,SACA,IAAA,QACA,IAAA,SACA,IAAA,SACA,IAAA,UACA,IAAA,WAAAgC,EACA,6BAAAoC,CAAA,EACA,WAAAud,EAAA1f,EAAA,aAAA,CAAA,EACA,MACA,IAAA,QACA,IAAA,SACA,IAAA,SACA,IAAA,UACA,IAAA,WAAAD,EACA,6BAAAoC,CAAA,EACA,WAAAud,EAAA1f,EAAA,kBAAA,CAAA,EACA,MACA,IAAA,OAAAD,EACA,4BAAAoC,CAAA,EACA,WAAAud,EAAA1f,EAAA,aAAA,CAAA,CAEA,CAGA,EAkCAD,EAAAC,EAAA,MAAA,EACA2f,EAAA5f,EAAAC,EAAArN,EAAAwP,EAAA,QAAA,EACA,GAAA,GAGAnC,EAAAM,UAAAP,EACA,yBAAAoC,CAAA,EACA,WAAAud,EAAA1f,EAAA,OAAA,CAAA,EACA,gCAAAmC,CAAA,EACAwd,EAAA5f,EAAAC,EAAArN,EAAAwP,EAAA,KAAA,EACA,GAAA,IAIAnC,EAAAsB,SACAme,EAAA5f,EAAAiB,SAAAd,EAAAsB,OAAAxL,IAAA,EACA,IAAA0pB,EAAAxf,EAAAsB,OAAAxL,OAAAiK,EACA,cAAA0f,CAAA,EACA,WAAAzf,EAAAsB,OAAAxL,KAAA,mBAAA,EACA0pB,EAAAxf,EAAAsB,OAAAxL,MAAA,EACAiK,EACA,QAAA0f,CAAA,GAEAE,EAAA5f,EAAAC,EAAArN,EAAAwP,CAAA,GAEAnC,EAAA8C,UAAA/C,EACA,GAAA,CACA,CACA,OAAAA,EACA,aAAA,CAEA,EAhLA,IAAAH,EAAA1O,EAAA,EAAA,EACA2O,EAAA3O,EAAA,EAAA,EAEA,SAAAwuB,EAAA1f,EAAA4a,GACA,OAAA5a,EAAAlK,KAAA,KAAA8kB,GAAA5a,EAAAM,UAAA,UAAAsa,EAAA,KAAA5a,EAAAe,KAAA,WAAA6Z,EAAA,MAAA5a,EAAAjC,QAAA,IAAA,IAAA,WACA,CAWA,SAAA4hB,EAAA5f,EAAAC,EAAAC,EAAAkC,GAEA,GAAAnC,EAAAI,aACA,GAAAJ,EAAAI,wBAAAR,EAAA,CAAAG,EACA,cAAAoC,CAAA,EACA,UAAA,EACA,WAAAud,EAAA1f,EAAA,YAAA,CAAA,EACA,IAAA,IAAAlL,EAAAD,OAAAC,KAAAkL,EAAAI,aAAAzB,MAAA,EAAAxL,EAAA,EAAAA,EAAA2B,EAAApD,OAAA,EAAAyB,EAAA4M,EACA,WAAAC,EAAAI,aAAAzB,OAAA7J,EAAA3B,GAAA,EACA4M,EACA,OAAA,EACA,GAAA,CACA,MACAA,EACA,GAAA,EACA,kCAAAE,EAAAkC,CAAA,EACA,OAAA,EACA,aAAAnC,EAAAlK,KAAA,GAAA,EACA,GAAA,OAGA,OAAAkK,EAAA1C,MACA,IAAA,QACA,IAAA,SACA,IAAA,SACA,IAAA,UACA,IAAA,WAAAyC,EACA,0BAAAoC,CAAA,EACA,WAAAud,EAAA1f,EAAA,SAAA,CAAA,EACA,MACA,IAAA,QACA,IAAA,SACA,IAAA,SACA,IAAA,UACA,IAAA,WAAAD,EACA,kFAAAoC,EAAAA,EAAAA,EAAAA,CAAA,EACA,WAAAud,EAAA1f,EAAA,cAAA,CAAA,EACA,MACA,IAAA,QACA,IAAA,SAAAD,EACA,2BAAAoC,CAAA,EACA,WAAAud,EAAA1f,EAAA,QAAA,CAAA,EACA,MACA,IAAA,OAAAD,EACA,4BAAAoC,CAAA,EACA,WAAAud,EAAA1f,EAAA,SAAA,CAAA,EACA,MACA,IAAA,SAAAD,EACA,yBAAAoC,CAAA,EACA,WAAAud,EAAA1f,EAAA,QAAA,CAAA,EACA,MACA,IAAA,QAAAD,EACA,4DAAAoC,EAAAA,EAAAA,CAAA,EACA,WAAAud,EAAA1f,EAAA,QAAA,CAAA,CAEA,CAEA,OAAAD,CAEA,C,qCCvEA,IAEAuI,EAAApX,EAAA,EAAA,EACA2O,EAAA3O,EAAA,EAAA,EA6BAqX,EAAA,wBAAA,CAEA5H,WAAA,SAAAgJ,EAAAiB,GAGA,IADAA,EADAA,IAAA/Z,GACA,EACA+Z,GAAA/K,EAAA+L,eACA,MAAA9X,MAAA,oBAAA,EAGA,GAAA6V,GAAAA,EAAA,SAAA,CAEA,IAKAtM,EALAvH,EAAA6T,EAAA,SAAAkH,UAAA,EAAAlH,EAAA,SAAA+M,YAAA,GAAA,CAAA,EACApZ,EAAAtH,KAAAiW,OAAAnW,CAAA,EAEA,GAAAwH,EAQA,MAHAD,EAHAA,EAAA,MAAAsM,EAAA,SAAA,IAAAA,IACAA,EAAA,SAAAnW,MAAA,CAAA,EAAAmW,EAAA,UAEA1H,QAAA,GAAA,IACA5E,EAAA,IAAAA,GAEArH,KAAAE,OAAA,CACAmH,SAAAA,EACA7H,MAAA8H,EAAA1K,OAAA0K,EAAAqD,WAAAgJ,EAAAiB,EAAA,CAAA,CAAA,EAAA0L,OAAA,CACA,CAAA,CAEA,CAEA,OAAAtgB,KAAA2K,WAAAgJ,EAAAiB,CAAA,CACA,EAEA5J,SAAA,SAAAuE,EAAAxO,EAAA6T,GAGA,IADAA,EADAA,IAAA/Z,GACA,EACA+Z,GAAA/K,EAAA+L,eACA,MAAA9X,MAAA,oBAAA,EAGA,IAkBA6V,EACAiW,EAlBAlkB,EAAA,GACA5F,EAAA,GAeA,OAZAiB,GAAAA,EAAAiG,MAAAuI,EAAAlI,UAAAkI,EAAA/P,QAEAM,EAAAyP,EAAAlI,SAAAwT,UAAA,EAAAtL,EAAAlI,SAAAqZ,YAAA,GAAA,CAAA,EAEAhb,EAAA6J,EAAAlI,SAAAwT,UAAA,EAAA,EAAAtL,EAAAlI,SAAAqZ,YAAA,GAAA,CAAA,GACApZ,EAAAtH,KAAAiW,OAAAnW,CAAA,KAGAyP,EAAAjI,EAAA3J,OAAA4R,EAAA/P,MAAA3E,GAAAA,GAAA+Z,EAAA,CAAA,IAIA,EAAArF,aAAAvP,KAAA2Q,OAAApB,aAAA+C,GACAqB,EAAApE,EAAA8D,MAAArI,SAAAuE,EAAAxO,EAAA6T,EAAA,CAAA,EACAgV,EAAA,MAAAra,EAAA8D,MAAA9I,SAAA,GACAgF,EAAA8D,MAAA9I,SAAA/M,MAAA,CAAA,EAAA+R,EAAA8D,MAAA9I,SAMAoJ,EAAA,SADA7T,GAFA4F,EADA,KAAAA,EAtBA,uBAyBAA,GAAAkkB,EAEAjW,GAGA3T,KAAAgL,SAAAuE,EAAAxO,EAAA6T,CAAA,CACA,CACA,C,qCC7GAzZ,EAAAC,QAAAqX,EAEA,IAEAC,EAFA7I,EAAA3O,EAAA,EAAA,EAIA6iB,EAAAlU,EAAAkU,SACA5hB,EAAA0N,EAAA1N,OACAkK,EAAAwD,EAAAxD,KAWA,SAAAwjB,EAAAxuB,EAAAiL,EAAAjE,GAMArC,KAAA3E,GAAAA,EAMA2E,KAAAsG,IAAAA,EAMAtG,KAAA6Z,KAAAhf,GAMAmF,KAAAqC,IAAAA,CACA,CAGA,SAAAynB,KAUA,SAAAC,EAAAzW,GAMAtT,KAAAia,KAAA3G,EAAA2G,KAMAja,KAAAgqB,KAAA1W,EAAA0W,KAMAhqB,KAAAsG,IAAAgN,EAAAhN,IAMAtG,KAAA6Z,KAAAvG,EAAA2W,MACA,CAOA,SAAAxX,IAMAzS,KAAAsG,IAAA,EAMAtG,KAAAia,KAAA,IAAA4P,EAAAC,EAAA,EAAA,CAAA,EAMA9pB,KAAAgqB,KAAAhqB,KAAAia,KAMAja,KAAAiqB,OAAA,IAOA,CAEA,SAAA/pB,IACA,OAAA2J,EAAAsU,OACA,WACA,OAAA1L,EAAAvS,OAAA,WACA,OAAA,IAAAwS,CACA,GAAA,CACA,EAEA,WACA,OAAA,IAAAD,CACA,CACA,CAqCA,SAAAyX,EAAA7nB,EAAAC,EAAAC,GACAD,EAAAC,GAAA,IAAAF,CACA,CAmBA,SAAA8nB,EAAA7jB,EAAAjE,GACArC,KAAAsG,IAAAA,EACAtG,KAAA6Z,KAAAhf,GACAmF,KAAAqC,IAAAA,CACA,CA6CA,SAAA+nB,EAAA/nB,EAAAC,EAAAC,GAGA,IAFA,IAAAyB,EAAA3B,EAAA2B,GACAC,EAAA5B,EAAA4B,GACAA,GACA3B,EAAAC,CAAA,IAAA,IAAAyB,EAAA,IACAA,GAAAA,IAAA,EAAAC,GAAA,MAAA,EACAA,KAAA,EAEA,KAAA,IAAAD,GACA1B,EAAAC,CAAA,IAAA,IAAAyB,EAAA,IACAA,KAAA,EAEA1B,EAAAC,CAAA,IAAAyB,CACA,CA0CA,SAAAqmB,EAAAhoB,EAAAC,EAAAC,GACAD,EAAAC,GAAA,IAAAF,EACAC,EAAAC,EAAA,GAAAF,IAAA,EAAA,IACAC,EAAAC,EAAA,GAAAF,IAAA,GAAA,IACAC,EAAAC,EAAA,GAAAF,IAAA,EACA,CAhKAoQ,EAAAvS,OAAAA,EAAA,EAOAuS,EAAA1M,MAAA,SAAAC,GACA,OAAA,IAAA6D,EAAArO,MAAAwK,CAAA,CACA,EAIA6D,EAAArO,QAAAA,QACAiX,EAAA1M,MAAA8D,EAAAge,KAAApV,EAAA1M,MAAA8D,EAAArO,MAAA2E,UAAAwe,QAAA,GAUAlM,EAAAtS,UAAAmqB,EAAA,SAAAjvB,EAAAiL,EAAAjE,GAGA,OAFArC,KAAAgqB,KAAAhqB,KAAAgqB,KAAAnQ,KAAA,IAAAgQ,EAAAxuB,EAAAiL,EAAAjE,CAAA,EACArC,KAAAsG,KAAAA,EACAtG,IACA,GA6BAmqB,EAAAhqB,UAAAtB,OAAAqB,OAAA2pB,EAAA1pB,SAAA,GACA9E,GAxBA,SAAAgH,EAAAC,EAAAC,GACA,KAAA,IAAAF,GACAC,EAAAC,CAAA,IAAA,IAAAF,EAAA,IACAA,KAAA,EAEAC,EAAAC,GAAAF,CACA,EAyBAoQ,EAAAtS,UAAAye,OAAA,SAAApf,GAWA,OARAQ,KAAAsG,MAAAtG,KAAAgqB,KAAAhqB,KAAAgqB,KAAAnQ,KAAA,IAAAsQ,GACA3qB,KAAA,GACA,IAAA,EACAA,EAAA,MAAA,EACAA,EAAA,QAAA,EACAA,EAAA,UAAA,EACA,EACAA,CAAA,GAAA8G,IACAtG,IACA,EAQAyS,EAAAtS,UAAA2e,MAAA,SAAAtf,GACA,OAAAA,GAAA,GAAA,EACAQ,KAAAsqB,EAAAF,EAAA,GAAArM,EAAAzN,WAAA9Q,CAAA,CAAA,EACAQ,KAAA4e,OAAApf,CAAA,CACA,EAOAiT,EAAAtS,UAAA4e,OAAA,SAAAvf,GACA,OAAAQ,KAAA4e,QAAApf,GAAA,EAAAA,GAAA,MAAA,CAAA,CACA,EAmCAiT,EAAAtS,UAAAqf,MAZA/M,EAAAtS,UAAAsf,OAAA,SAAAjgB,GACA+e,EAAAR,EAAA6I,KAAApnB,CAAA,EACA,OAAAQ,KAAAsqB,EAAAF,EAAA7L,EAAA7iB,OAAA,EAAA6iB,CAAA,CACA,EAiBA9L,EAAAtS,UAAAuf,OAAA,SAAAlgB,GACA+e,EAAAR,EAAA6I,KAAApnB,CAAA,EAAAknB,SAAA,EACA,OAAA1mB,KAAAsqB,EAAAF,EAAA7L,EAAA7iB,OAAA,EAAA6iB,CAAA,CACA,EAOA9L,EAAAtS,UAAA6e,KAAA,SAAAxf,GACA,OAAAQ,KAAAsqB,EAAAJ,EAAA,EAAA1qB,EAAA,EAAA,CAAA,CACA,EAwBAiT,EAAAtS,UAAA+e,SAVAzM,EAAAtS,UAAA8e,QAAA,SAAAzf,GACA,OAAAQ,KAAAsqB,EAAAD,EAAA,EAAA7qB,IAAA,CAAA,CACA,EA4BAiT,EAAAtS,UAAA0f,SAZApN,EAAAtS,UAAAyf,QAAA,SAAApgB,GACA+e,EAAAR,EAAA6I,KAAApnB,CAAA,EACA,OAAAQ,KAAAsqB,EAAAD,EAAA,EAAA9L,EAAAva,EAAA,EAAAsmB,EAAAD,EAAA,EAAA9L,EAAAta,EAAA,CACA,EAiBAwO,EAAAtS,UAAAgf,MAAA,SAAA3f,GACA,OAAAQ,KAAAsqB,EAAAzgB,EAAAsV,MAAA5a,aAAA,EAAA/E,CAAA,CACA,EAQAiT,EAAAtS,UAAAif,OAAA,SAAA5f,GACA,OAAAQ,KAAAsqB,EAAAzgB,EAAAsV,MAAAla,cAAA,EAAAzF,CAAA,CACA,EAEA,IAAA+qB,EAAA1gB,EAAArO,MAAA2E,UAAAqY,IACA,SAAAnW,EAAAC,EAAAC,GACAD,EAAAkW,IAAAnW,EAAAE,CAAA,CACA,EAEA,SAAAF,EAAAC,EAAAC,GACA,IAAA,IAAA5F,EAAA,EAAAA,EAAA0F,EAAA3G,OAAA,EAAAiB,EACA2F,EAAAC,EAAA5F,GAAA0F,EAAA1F,EACA,EAOA8V,EAAAtS,UAAA2L,MAAA,SAAAtM,GACA,IAIA8C,EAJAgE,EAAA9G,EAAA9D,SAAA,EACA,OAAA4K,GAEAuD,EAAA8E,SAAAnP,CAAA,IACA8C,EAAAmQ,EAAA1M,MAAAO,EAAAnK,EAAAT,OAAA8D,CAAA,CAAA,EACArD,EAAAwB,OAAA6B,EAAA8C,EAAA,CAAA,EACA9C,EAAA8C,GAEAtC,KAAA4e,OAAAtY,CAAA,EAAAgkB,EAAAC,EAAAjkB,EAAA9G,CAAA,GANAQ,KAAAsqB,EAAAJ,EAAA,EAAA,CAAA,CAOA,EAOAzX,EAAAtS,UAAA/D,OAAA,SAAAoD,GACA,IAAA8G,EAAAD,EAAA3K,OAAA8D,CAAA,EACA,OAAA8G,EACAtG,KAAA4e,OAAAtY,CAAA,EAAAgkB,EAAAjkB,EAAAO,MAAAN,EAAA9G,CAAA,EACAQ,KAAAsqB,EAAAJ,EAAA,EAAA,CAAA,CACA,EAOAzX,EAAAtS,UAAAslB,KAAA,WAIA,OAHAzlB,KAAAiqB,OAAA,IAAAF,EAAA/pB,IAAA,EACAA,KAAAia,KAAAja,KAAAgqB,KAAA,IAAAH,EAAAC,EAAA,EAAA,CAAA,EACA9pB,KAAAsG,IAAA,EACAtG,IACA,EAMAyS,EAAAtS,UAAAqqB,MAAA,WAUA,OATAxqB,KAAAiqB,QACAjqB,KAAAia,KAAAja,KAAAiqB,OAAAhQ,KACAja,KAAAgqB,KAAAhqB,KAAAiqB,OAAAD,KACAhqB,KAAAsG,IAAAtG,KAAAiqB,OAAA3jB,IACAtG,KAAAiqB,OAAAjqB,KAAAiqB,OAAApQ,OAEA7Z,KAAAia,KAAAja,KAAAgqB,KAAA,IAAAH,EAAAC,EAAA,EAAA,CAAA,EACA9pB,KAAAsG,IAAA,GAEAtG,IACA,EAMAyS,EAAAtS,UAAAulB,OAAA,WACA,IAAAzL,EAAAja,KAAAia,KACA+P,EAAAhqB,KAAAgqB,KACA1jB,EAAAtG,KAAAsG,IAOA,OANAtG,KAAAwqB,MAAA,EAAA5L,OAAAtY,CAAA,EACAA,IACAtG,KAAAgqB,KAAAnQ,KAAAI,EAAAJ,KACA7Z,KAAAgqB,KAAAA,EACAhqB,KAAAsG,KAAAA,GAEAtG,IACA,EAMAyS,EAAAtS,UAAAmgB,OAAA,WAIA,IAHA,IAAArG,EAAAja,KAAAia,KAAAJ,KACAvX,EAAAtC,KAAAiN,YAAAlH,MAAA/F,KAAAsG,GAAA,EACA/D,EAAA,EACA0X,GACAA,EAAA5e,GAAA4e,EAAA5X,IAAAC,EAAAC,CAAA,EACAA,GAAA0X,EAAA3T,IACA2T,EAAAA,EAAAJ,KAGA,OAAAvX,CACA,EAEAmQ,EAAAjB,EAAA,SAAAiZ,GACA/X,EAAA+X,EACAhY,EAAAvS,OAAAA,EAAA,EACAwS,EAAAlB,EAAA,CACA,C,+BCjdArW,EAAAC,QAAAsX,EAGA,IAAAD,EAAAvX,EAAA,EAAA,EAGA2O,IAFA6I,EAAAvS,UAAAtB,OAAAqB,OAAAuS,EAAAtS,SAAA,GAAA8M,YAAAyF,EAEAxX,EAAA,EAAA,GAQA,SAAAwX,IACAD,EAAArM,KAAApG,IAAA,CACA,CAuCA,SAAA0qB,EAAAroB,EAAAC,EAAAC,GACAF,EAAA3G,OAAA,GACAmO,EAAAxD,KAAAO,MAAAvE,EAAAC,EAAAC,CAAA,EACAD,EAAA+lB,UACA/lB,EAAA+lB,UAAAhmB,EAAAE,CAAA,EAEAD,EAAAsE,MAAAvE,EAAAE,CAAA,CACA,CA5CAmQ,EAAAlB,EAAA,WAOAkB,EAAA3M,MAAA8D,EAAA0e,EAEA7V,EAAAiY,iBAAA9gB,EAAAsU,QAAAtU,EAAAsU,OAAAhe,qBAAAwB,YAAA,QAAAkI,EAAAsU,OAAAhe,UAAAqY,IAAA1Y,KACA,SAAAuC,EAAAC,EAAAC,GACAD,EAAAkW,IAAAnW,EAAAE,CAAA,CAEA,EAEA,SAAAF,EAAAC,EAAAC,GACA,GAAAF,EAAAuoB,KACAvoB,EAAAuoB,KAAAtoB,EAAAC,EAAA,EAAAF,EAAA3G,MAAA,OACA,IAAA,IAAAiB,EAAA,EAAAA,EAAA0F,EAAA3G,QACA4G,EAAAC,CAAA,IAAAF,EAAA1F,CAAA,GACA,CACA,EAMA+V,EAAAvS,UAAA2L,MAAA,SAAAtM,GAGA,IAAA8G,GADA9G,EADAqK,EAAA8E,SAAAnP,CAAA,EACAqK,EAAAye,EAAA9oB,EAAA,QAAA,EACAA,GAAA9D,SAAA,EAIA,OAHAsE,KAAA4e,OAAAtY,CAAA,EACAA,GACAtG,KAAAsqB,EAAA5X,EAAAiY,iBAAArkB,EAAA9G,CAAA,EACAQ,IACA,EAcA0S,EAAAvS,UAAA/D,OAAA,SAAAoD,GACA,IAAA8G,EAAAuD,EAAAsU,OAAA0M,WAAArrB,CAAA,EAIA,OAHAQ,KAAA4e,OAAAtY,CAAA,EACAA,GACAtG,KAAAsqB,EAAAI,EAAApkB,EAAA9G,CAAA,EACAQ,IACA,EAUA0S,EAAAlB,EAAA,mB7CpFAzW,MAcAC,EAPA,SAAA8vB,EAAAhrB,GACA,IAAAirB,EAAAhwB,EAAA+E,GAGA,OAFAirB,GACAjwB,EAAAgF,GAAA,GAAAsG,KAAA2kB,EAAAhwB,EAAA+E,GAAA,CAAA1E,QAAA,EAAA,EAAA0vB,EAAAC,EAAAA,EAAA3vB,OAAA,EACA2vB,EAAA3vB,OACA,OAEA,EAAA,GAGAyO,KAAAie,OAAA9sB,SAAAA,EAGA,YAAA,OAAA0a,QAAAA,OAAAsV,KACAtV,OAAA,CAAA,QAAA,SAAAjG,GAKA,OAJAA,GAAAA,EAAAiZ,SACA1tB,EAAA6O,KAAA4F,KAAAA,EACAzU,EAAAwX,UAAA,GAEAxX,CACA,CAAA,EAGA,UAAA,OAAAG,QAAAA,QAAAA,OAAAC,UACAD,OAAAC,QAAAJ","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\";\r\nmodule.exports = asPromise;\r\n\r\n/**\r\n * Callback as used by {@link util.asPromise}.\r\n * @typedef asPromiseCallback\r\n * @type {function}\r\n * @param {Error|null} error Error, if any\r\n * @param {...*} params Additional arguments\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Returns a promise from a node-style callback function.\r\n * @memberof util\r\n * @param {asPromiseCallback} fn Function to call\r\n * @param {*} ctx Function context\r\n * @param {...*} params Function arguments\r\n * @returns {Promise<*>} Promisified function\r\n */\r\nfunction asPromise(fn, ctx/*, varargs */) {\r\n    var params  = new Array(arguments.length - 1),\r\n        offset  = 0,\r\n        index   = 2,\r\n        pending = true;\r\n    while (index < arguments.length)\r\n        params[offset++] = arguments[index++];\r\n    return new Promise(function executor(resolve, reject) {\r\n        params[offset] = function callback(err/*, varargs */) {\r\n            if (pending) {\r\n                pending = false;\r\n                if (err)\r\n                    reject(err);\r\n                else {\r\n                    var params = new Array(arguments.length - 1),\r\n                        offset = 0;\r\n                    while (offset < params.length)\r\n                        params[offset++] = arguments[offset];\r\n                    resolve.apply(null, params);\r\n                }\r\n            }\r\n        };\r\n        try {\r\n            fn.apply(ctx || null, params);\r\n        } catch (err) {\r\n            if (pending) {\r\n                pending = false;\r\n                reject(err);\r\n            }\r\n        }\r\n    });\r\n}\r\n","\"use strict\";\r\n\r\n/**\r\n * A minimal base64 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n */\r\nvar base64 = exports;\r\n\r\n/**\r\n * Calculates the byte length of a base64 encoded string.\r\n * @param {string} string Base64 encoded string\r\n * @returns {number} Byte length\r\n */\r\nbase64.length = function length(string) {\r\n    var p = string.length;\r\n    if (!p)\r\n        return 0;\r\n    var n = 0;\r\n    while (--p % 4 > 1 && string.charAt(p) === \"=\")\r\n        ++n;\r\n    return Math.ceil(string.length * 3) / 4 - n;\r\n};\r\n\r\n// Base64 encoding table\r\nvar b64 = new Array(64);\r\n\r\n// Base64 decoding table\r\nvar s64 = new Array(123);\r\n\r\n// 65..90, 97..122, 48..57, 43, 47\r\nfor (var i = 0; i < 64;)\r\n    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;\r\n\r\n/**\r\n * Encodes a buffer to a base64 encoded string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} Base64 encoded string\r\n */\r\nbase64.encode = function encode(buffer, start, end) {\r\n    var parts = null,\r\n        chunk = [];\r\n    var i = 0, // output index\r\n        j = 0, // goto index\r\n        t;     // temporary\r\n    while (start < end) {\r\n        var b = buffer[start++];\r\n        switch (j) {\r\n            case 0:\r\n                chunk[i++] = b64[b >> 2];\r\n                t = (b & 3) << 4;\r\n                j = 1;\r\n                break;\r\n            case 1:\r\n                chunk[i++] = b64[t | b >> 4];\r\n                t = (b & 15) << 2;\r\n                j = 2;\r\n                break;\r\n            case 2:\r\n                chunk[i++] = b64[t | b >> 6];\r\n                chunk[i++] = b64[b & 63];\r\n                j = 0;\r\n                break;\r\n        }\r\n        if (i > 8191) {\r\n            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));\r\n            i = 0;\r\n        }\r\n    }\r\n    if (j) {\r\n        chunk[i++] = b64[t];\r\n        chunk[i++] = 61;\r\n        if (j === 1)\r\n            chunk[i++] = 61;\r\n    }\r\n    if (parts) {\r\n        if (i)\r\n            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\r\n        return parts.join(\"\");\r\n    }\r\n    return String.fromCharCode.apply(String, chunk.slice(0, i));\r\n};\r\n\r\nvar invalidEncoding = \"invalid encoding\";\r\n\r\n/**\r\n * Decodes a base64 encoded string to a buffer.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Number of bytes written\r\n * @throws {Error} If encoding is invalid\r\n */\r\nbase64.decode = function decode(string, buffer, offset) {\r\n    var start = offset;\r\n    var j = 0, // goto index\r\n        t;     // temporary\r\n    for (var i = 0; i < string.length;) {\r\n        var c = string.charCodeAt(i++);\r\n        if (c === 61 && j > 1)\r\n            break;\r\n        if ((c = s64[c]) === undefined)\r\n            throw Error(invalidEncoding);\r\n        switch (j) {\r\n            case 0:\r\n                t = c;\r\n                j = 1;\r\n                break;\r\n            case 1:\r\n                buffer[offset++] = t << 2 | (c & 48) >> 4;\r\n                t = c;\r\n                j = 2;\r\n                break;\r\n            case 2:\r\n                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;\r\n                t = c;\r\n                j = 3;\r\n                break;\r\n            case 3:\r\n                buffer[offset++] = (t & 3) << 6 | c;\r\n                j = 0;\r\n                break;\r\n        }\r\n    }\r\n    if (j === 1)\r\n        throw Error(invalidEncoding);\r\n    return offset - start;\r\n};\r\n\r\n/**\r\n * Tests if the specified string appears to be base64 encoded.\r\n * @param {string} string String to test\r\n * @returns {boolean} `true` if probably base64 encoded, otherwise false\r\n */\r\nbase64.test = function test(string) {\r\n    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);\r\n};\r\n","\"use strict\";\r\nmodule.exports = codegen;\r\n\r\nvar 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)$/;\r\n\r\n/**\r\n * Begins generating a function.\r\n * @memberof util\r\n * @param {string[]} functionParams Function parameter names\r\n * @param {string} [functionName] Function name if not anonymous\r\n * @returns {Codegen} Appender that appends code to the function's body\r\n */\r\nfunction codegen(functionParams, functionName) {\r\n\r\n    /* istanbul ignore if */\r\n    if (typeof functionParams === \"string\") {\r\n        functionName = functionParams;\r\n        functionParams = undefined;\r\n    }\r\n\r\n    var body = [];\r\n\r\n    /**\r\n     * Appends code to the function's body or finishes generation.\r\n     * @typedef Codegen\r\n     * @type {function}\r\n     * @param {string|Object.<string,*>} [formatStringOrScope] Format string or, to finish the function, an object of additional scope variables, if any\r\n     * @param {...*} [formatParams] Format parameters\r\n     * @returns {Codegen|Function} Itself or the generated function if finished\r\n     * @throws {Error} If format parameter counts do not match\r\n     */\r\n\r\n    function Codegen(formatStringOrScope) {\r\n        // note that explicit array handling below makes this ~50% faster\r\n\r\n        // finish the function\r\n        if (typeof formatStringOrScope !== \"string\") {\r\n            var source = toString();\r\n            if (codegen.verbose)\r\n                console.log(\"codegen: \" + source); // eslint-disable-line no-console\r\n            source = \"return \" + source;\r\n            if (formatStringOrScope) {\r\n                var scopeKeys   = Object.keys(formatStringOrScope),\r\n                    scopeParams = new Array(scopeKeys.length + 1),\r\n                    scopeValues = new Array(scopeKeys.length),\r\n                    scopeOffset = 0;\r\n                while (scopeOffset < scopeKeys.length) {\r\n                    scopeParams[scopeOffset] = scopeKeys[scopeOffset];\r\n                    scopeValues[scopeOffset] = formatStringOrScope[scopeKeys[scopeOffset++]];\r\n                }\r\n                scopeParams[scopeOffset] = source;\r\n                return Function.apply(null, scopeParams).apply(null, scopeValues); // eslint-disable-line no-new-func\r\n            }\r\n            return Function(source)(); // eslint-disable-line no-new-func\r\n        }\r\n\r\n        // otherwise append to body\r\n        var formatParams = new Array(arguments.length - 1),\r\n            formatOffset = 0;\r\n        while (formatOffset < formatParams.length)\r\n            formatParams[formatOffset] = arguments[++formatOffset];\r\n        formatOffset = 0;\r\n        formatStringOrScope = formatStringOrScope.replace(/%([%dfijs])/g, function replace($0, $1) {\r\n            var value = formatParams[formatOffset++];\r\n            switch ($1) {\r\n                case \"d\": case \"f\": return String(Number(value));\r\n                case \"i\": return String(Math.floor(value));\r\n                case \"j\": return JSON.stringify(value);\r\n                case \"s\": return String(value);\r\n            }\r\n            return \"%\";\r\n        });\r\n        if (formatOffset !== formatParams.length)\r\n            throw Error(\"parameter count mismatch\");\r\n        body.push(formatStringOrScope);\r\n        return Codegen;\r\n    }\r\n\r\n    function toString(functionNameOverride) {\r\n        return \"function \" + safeFunctionName(functionNameOverride || functionName) + \"(\" + (functionParams && functionParams.join(\",\") || \"\") + \"){\\n  \" + body.join(\"\\n  \") + \"\\n}\";\r\n    }\r\n\r\n    Codegen.toString = toString;\r\n    return Codegen;\r\n}\r\n\r\n/**\r\n * Begins generating a function.\r\n * @memberof util\r\n * @function codegen\r\n * @param {string} [functionName] Function name if not anonymous\r\n * @returns {Codegen} Appender that appends code to the function's body\r\n * @variation 2\r\n */\r\n\r\n/**\r\n * When set to `true`, codegen will log generated code to console. Useful for debugging.\r\n * @name util.codegen.verbose\r\n * @type {boolean}\r\n */\r\ncodegen.verbose = false;\r\n\r\nfunction safeFunctionName(name) {\r\n    if (!name)\r\n        return \"\";\r\n    name = String(name).replace(/[^\\w$]/g, \"\");\r\n    if (!name)\r\n        return \"\";\r\n    if (/^\\d/.test(name))\r\n        name = \"_\" + name;\r\n    return reservedRe.test(name) ? name + \"_\" : name;\r\n}\r\n","\"use strict\";\r\nmodule.exports = EventEmitter;\r\n\r\n/**\r\n * Constructs a new event emitter instance.\r\n * @classdesc A minimal event emitter.\r\n * @memberof util\r\n * @constructor\r\n */\r\nfunction EventEmitter() {\r\n\r\n    /**\r\n     * Registered listeners.\r\n     * @type {Object.<string,*>}\r\n     * @private\r\n     */\r\n    this._listeners = Object.create(null);\r\n}\r\n\r\n/**\r\n * Event listener as used by {@link util.EventEmitter}.\r\n * @typedef EventEmitterListener\r\n * @type {function}\r\n * @param {...*} args Arguments\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Registers an event listener.\r\n * @param {string} evt Event name\r\n * @param {EventEmitterListener} fn Listener\r\n * @param {*} [ctx] Listener context\r\n * @returns {this} `this`\r\n */\r\nEventEmitter.prototype.on = function on(evt, fn, ctx) {\r\n    (this._listeners[evt] || (this._listeners[evt] = [])).push({\r\n        fn  : fn,\r\n        ctx : ctx || this\r\n    });\r\n    return this;\r\n};\r\n\r\n/**\r\n * Removes an event listener or any matching listeners if arguments are omitted.\r\n * @param {string} [evt] Event name. Removes all listeners if omitted.\r\n * @param {EventEmitterListener} [fn] Listener to remove. Removes all listeners of `evt` if omitted.\r\n * @returns {this} `this`\r\n */\r\nEventEmitter.prototype.off = function off(evt, fn) {\r\n    if (evt === undefined)\r\n        this._listeners = Object.create(null);\r\n    else {\r\n        if (fn === undefined)\r\n            this._listeners[evt] = [];\r\n        else {\r\n            var listeners = this._listeners[evt];\r\n            if (!listeners)\r\n                return this;\r\n            for (var i = 0; i < listeners.length;)\r\n                if (listeners[i].fn === fn)\r\n                    listeners.splice(i, 1);\r\n                else\r\n                    ++i;\r\n        }\r\n    }\r\n    return this;\r\n};\r\n\r\n/**\r\n * Emits an event by calling its listeners with the specified arguments.\r\n * @param {string} evt Event name\r\n * @param {...*} args Arguments\r\n * @returns {this} `this`\r\n */\r\nEventEmitter.prototype.emit = function emit(evt) {\r\n    var listeners = this._listeners[evt];\r\n    if (listeners) {\r\n        var args = [],\r\n            i = 1;\r\n        for (; i < arguments.length;)\r\n            args.push(arguments[i++]);\r\n        for (i = 0; i < listeners.length;)\r\n            listeners[i].fn.apply(listeners[i++].ctx, args);\r\n    }\r\n    return this;\r\n};\r\n","\"use strict\";\r\nmodule.exports = fetch;\r\n\r\nvar asPromise = require(1),\r\n    fs        = require(6);\r\n\r\n/**\r\n * Node-style callback as used by {@link util.fetch}.\r\n * @typedef FetchCallback\r\n * @type {function}\r\n * @param {?Error} error Error, if any, otherwise `null`\r\n * @param {string} [contents] File contents, if there hasn't been an error\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Options as used by {@link util.fetch}.\r\n * @interface IFetchOptions\r\n * @property {boolean} [binary=false] Whether expecting a binary response\r\n * @property {boolean} [xhr=false] If `true`, forces the use of XMLHttpRequest\r\n */\r\n\r\n/**\r\n * Fetches the contents of a file.\r\n * @memberof util\r\n * @param {string} filename File path or url\r\n * @param {IFetchOptions} options Fetch options\r\n * @param {FetchCallback} callback Callback function\r\n * @returns {undefined}\r\n */\r\nfunction fetch(filename, options, callback) {\r\n    if (typeof options === \"function\") {\r\n        callback = options;\r\n        options = {};\r\n    } else if (!options)\r\n        options = {};\r\n\r\n    if (!callback)\r\n        return asPromise(fetch, this, filename, options); // eslint-disable-line no-invalid-this\r\n\r\n    // if a node-like filesystem is present, try it first but fall back to XHR if nothing is found.\r\n    if (!options.xhr && fs && fs.readFile)\r\n        return fs.readFile(filename, function fetchReadFileCallback(err, contents) {\r\n            return err && typeof XMLHttpRequest !== \"undefined\"\r\n                ? fetch.xhr(filename, options, callback)\r\n                : err\r\n                ? callback(err)\r\n                : callback(null, options.binary ? contents : contents.toString(\"utf8\"));\r\n        });\r\n\r\n    // use the XHR version otherwise.\r\n    return fetch.xhr(filename, options, callback);\r\n}\r\n\r\n/**\r\n * Fetches the contents of a file.\r\n * @name util.fetch\r\n * @function\r\n * @param {string} path File path or url\r\n * @param {FetchCallback} callback Callback function\r\n * @returns {undefined}\r\n * @variation 2\r\n */\r\n\r\n/**\r\n * Fetches the contents of a file.\r\n * @name util.fetch\r\n * @function\r\n * @param {string} path File path or url\r\n * @param {IFetchOptions} [options] Fetch options\r\n * @returns {Promise<string|Uint8Array>} Promise\r\n * @variation 3\r\n */\r\n\r\n/**/\r\nfetch.xhr = function fetch_xhr(filename, options, callback) {\r\n    var xhr = new XMLHttpRequest();\r\n    xhr.onreadystatechange /* works everywhere */ = function fetchOnReadyStateChange() {\r\n\r\n        if (xhr.readyState !== 4)\r\n            return undefined;\r\n\r\n        // local cors security errors return status 0 / empty string, too. afaik this cannot be\r\n        // reliably distinguished from an actually empty file for security reasons. feel free\r\n        // to send a pull request if you are aware of a solution.\r\n        if (xhr.status !== 0 && xhr.status !== 200)\r\n            return callback(Error(\"status \" + xhr.status));\r\n\r\n        // if binary data is expected, make sure that some sort of array is returned, even if\r\n        // ArrayBuffers are not supported. the binary string fallback, however, is unsafe.\r\n        if (options.binary) {\r\n            var buffer = xhr.response;\r\n            if (!buffer) {\r\n                buffer = [];\r\n                for (var i = 0; i < xhr.responseText.length; ++i)\r\n                    buffer.push(xhr.responseText.charCodeAt(i) & 255);\r\n            }\r\n            return callback(null, typeof Uint8Array !== \"undefined\" ? new Uint8Array(buffer) : buffer);\r\n        }\r\n        return callback(null, xhr.responseText);\r\n    };\r\n\r\n    if (options.binary) {\r\n        // ref: https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/Sending_and_Receiving_Binary_Data#Receiving_binary_data_in_older_browsers\r\n        if (\"overrideMimeType\" in xhr)\r\n            xhr.overrideMimeType(\"text/plain; charset=x-user-defined\");\r\n        xhr.responseType = \"arraybuffer\";\r\n    }\r\n\r\n    xhr.open(\"GET\", filename);\r\n    xhr.send();\r\n};\r\n","\"use strict\";\r\n\r\nvar fs = null;\r\ntry {\r\n    fs = require(11);\r\n    if (!fs || !fs.readFile || !fs.readFileSync)\r\n        fs = null;\r\n} catch (e) {\r\n    // `fs` is unavailable in browsers and browser-like bundles.\r\n}\r\nmodule.exports = fs;\r\n","\"use strict\";\r\n\r\nmodule.exports = factory(factory);\r\n\r\n/**\r\n * Reads / writes floats / doubles from / to buffers.\r\n * @name util.float\r\n * @namespace\r\n */\r\n\r\n/**\r\n * Writes a 32 bit float to a buffer using little endian byte order.\r\n * @name util.float.writeFloatLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Writes a 32 bit float to a buffer using big endian byte order.\r\n * @name util.float.writeFloatBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Reads a 32 bit float from a buffer using little endian byte order.\r\n * @name util.float.readFloatLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Reads a 32 bit float from a buffer using big endian byte order.\r\n * @name util.float.readFloatBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Writes a 64 bit double to a buffer using little endian byte order.\r\n * @name util.float.writeDoubleLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Writes a 64 bit double to a buffer using big endian byte order.\r\n * @name util.float.writeDoubleBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Reads a 64 bit double from a buffer using little endian byte order.\r\n * @name util.float.readDoubleLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Reads a 64 bit double from a buffer using big endian byte order.\r\n * @name util.float.readDoubleBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n// Factory function for the purpose of node-based testing in modified global environments\r\nfunction factory(exports) {\r\n\r\n    // float: typed array\r\n    if (typeof Float32Array !== \"undefined\") (function() {\r\n\r\n        var f32 = new Float32Array([ -0 ]),\r\n            f8b = new Uint8Array(f32.buffer),\r\n            le  = f8b[3] === 128;\r\n\r\n        function writeFloat_f32_cpy(val, buf, pos) {\r\n            f32[0] = val;\r\n            buf[pos    ] = f8b[0];\r\n            buf[pos + 1] = f8b[1];\r\n            buf[pos + 2] = f8b[2];\r\n            buf[pos + 3] = f8b[3];\r\n        }\r\n\r\n        function writeFloat_f32_rev(val, buf, pos) {\r\n            f32[0] = val;\r\n            buf[pos    ] = f8b[3];\r\n            buf[pos + 1] = f8b[2];\r\n            buf[pos + 2] = f8b[1];\r\n            buf[pos + 3] = f8b[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;\r\n        /* istanbul ignore next */\r\n        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;\r\n\r\n        function readFloat_f32_cpy(buf, pos) {\r\n            f8b[0] = buf[pos    ];\r\n            f8b[1] = buf[pos + 1];\r\n            f8b[2] = buf[pos + 2];\r\n            f8b[3] = buf[pos + 3];\r\n            return f32[0];\r\n        }\r\n\r\n        function readFloat_f32_rev(buf, pos) {\r\n            f8b[3] = buf[pos    ];\r\n            f8b[2] = buf[pos + 1];\r\n            f8b[1] = buf[pos + 2];\r\n            f8b[0] = buf[pos + 3];\r\n            return f32[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;\r\n        /* istanbul ignore next */\r\n        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;\r\n\r\n    // float: ieee754\r\n    })(); else (function() {\r\n\r\n        function writeFloat_ieee754(writeUint, val, buf, pos) {\r\n            var sign = val < 0 ? 1 : 0;\r\n            if (sign)\r\n                val = -val;\r\n            if (val === 0)\r\n                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);\r\n            else if (isNaN(val))\r\n                writeUint(2143289344, buf, pos);\r\n            else if (val > 3.4028234663852886e+38) // +-Infinity\r\n                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);\r\n            else if (val < 1.1754943508222875e-38) // denormal\r\n                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);\r\n            else {\r\n                var exponent = Math.floor(Math.log(val) / Math.LN2),\r\n                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;\r\n                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);\r\n            }\r\n        }\r\n\r\n        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);\r\n        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);\r\n\r\n        function readFloat_ieee754(readUint, buf, pos) {\r\n            var uint = readUint(buf, pos),\r\n                sign = (uint >> 31) * 2 + 1,\r\n                exponent = uint >>> 23 & 255,\r\n                mantissa = uint & 8388607;\r\n            return exponent === 255\r\n                ? mantissa\r\n                ? NaN\r\n                : sign * Infinity\r\n                : exponent === 0 // denormal\r\n                ? sign * 1.401298464324817e-45 * mantissa\r\n                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);\r\n        }\r\n\r\n        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);\r\n        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);\r\n\r\n    })();\r\n\r\n    // double: typed array\r\n    if (typeof Float64Array !== \"undefined\") (function() {\r\n\r\n        var f64 = new Float64Array([-0]),\r\n            f8b = new Uint8Array(f64.buffer),\r\n            le  = f8b[7] === 128;\r\n\r\n        function writeDouble_f64_cpy(val, buf, pos) {\r\n            f64[0] = val;\r\n            buf[pos    ] = f8b[0];\r\n            buf[pos + 1] = f8b[1];\r\n            buf[pos + 2] = f8b[2];\r\n            buf[pos + 3] = f8b[3];\r\n            buf[pos + 4] = f8b[4];\r\n            buf[pos + 5] = f8b[5];\r\n            buf[pos + 6] = f8b[6];\r\n            buf[pos + 7] = f8b[7];\r\n        }\r\n\r\n        function writeDouble_f64_rev(val, buf, pos) {\r\n            f64[0] = val;\r\n            buf[pos    ] = f8b[7];\r\n            buf[pos + 1] = f8b[6];\r\n            buf[pos + 2] = f8b[5];\r\n            buf[pos + 3] = f8b[4];\r\n            buf[pos + 4] = f8b[3];\r\n            buf[pos + 5] = f8b[2];\r\n            buf[pos + 6] = f8b[1];\r\n            buf[pos + 7] = f8b[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;\r\n        /* istanbul ignore next */\r\n        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;\r\n\r\n        function readDouble_f64_cpy(buf, pos) {\r\n            f8b[0] = buf[pos    ];\r\n            f8b[1] = buf[pos + 1];\r\n            f8b[2] = buf[pos + 2];\r\n            f8b[3] = buf[pos + 3];\r\n            f8b[4] = buf[pos + 4];\r\n            f8b[5] = buf[pos + 5];\r\n            f8b[6] = buf[pos + 6];\r\n            f8b[7] = buf[pos + 7];\r\n            return f64[0];\r\n        }\r\n\r\n        function readDouble_f64_rev(buf, pos) {\r\n            f8b[7] = buf[pos    ];\r\n            f8b[6] = buf[pos + 1];\r\n            f8b[5] = buf[pos + 2];\r\n            f8b[4] = buf[pos + 3];\r\n            f8b[3] = buf[pos + 4];\r\n            f8b[2] = buf[pos + 5];\r\n            f8b[1] = buf[pos + 6];\r\n            f8b[0] = buf[pos + 7];\r\n            return f64[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;\r\n        /* istanbul ignore next */\r\n        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;\r\n\r\n    // double: ieee754\r\n    })(); else (function() {\r\n\r\n        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {\r\n            var sign = val < 0 ? 1 : 0;\r\n            if (sign)\r\n                val = -val;\r\n            if (val === 0) {\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);\r\n            } else if (isNaN(val)) {\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint(2146959360, buf, pos + off1);\r\n            } else if (val > 1.7976931348623157e+308) { // +-Infinity\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);\r\n            } else {\r\n                var mantissa;\r\n                if (val < 2.2250738585072014e-308) { // denormal\r\n                    mantissa = val / 5e-324;\r\n                    writeUint(mantissa >>> 0, buf, pos + off0);\r\n                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);\r\n                } else {\r\n                    var exponent = Math.floor(Math.log(val) / Math.LN2);\r\n                    if (exponent === 1024)\r\n                        exponent = 1023;\r\n                    mantissa = val * Math.pow(2, -exponent);\r\n                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);\r\n                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);\r\n                }\r\n            }\r\n        }\r\n\r\n        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);\r\n        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);\r\n\r\n        function readDouble_ieee754(readUint, off0, off1, buf, pos) {\r\n            var lo = readUint(buf, pos + off0),\r\n                hi = readUint(buf, pos + off1);\r\n            var sign = (hi >> 31) * 2 + 1,\r\n                exponent = hi >>> 20 & 2047,\r\n                mantissa = 4294967296 * (hi & 1048575) + lo;\r\n            return exponent === 2047\r\n                ? mantissa\r\n                ? NaN\r\n                : sign * Infinity\r\n                : exponent === 0 // denormal\r\n                ? sign * 5e-324 * mantissa\r\n                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);\r\n        }\r\n\r\n        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);\r\n        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);\r\n\r\n    })();\r\n\r\n    return exports;\r\n}\r\n\r\n// uint helpers\r\n\r\nfunction writeUintLE(val, buf, pos) {\r\n    buf[pos    ] =  val        & 255;\r\n    buf[pos + 1] =  val >>> 8  & 255;\r\n    buf[pos + 2] =  val >>> 16 & 255;\r\n    buf[pos + 3] =  val >>> 24;\r\n}\r\n\r\nfunction writeUintBE(val, buf, pos) {\r\n    buf[pos    ] =  val >>> 24;\r\n    buf[pos + 1] =  val >>> 16 & 255;\r\n    buf[pos + 2] =  val >>> 8  & 255;\r\n    buf[pos + 3] =  val        & 255;\r\n}\r\n\r\nfunction readUintLE(buf, pos) {\r\n    return (buf[pos    ]\r\n          | buf[pos + 1] << 8\r\n          | buf[pos + 2] << 16\r\n          | buf[pos + 3] << 24) >>> 0;\r\n}\r\n\r\nfunction readUintBE(buf, pos) {\r\n    return (buf[pos    ] << 24\r\n          | buf[pos + 1] << 16\r\n          | buf[pos + 2] << 8\r\n          | buf[pos + 3]) >>> 0;\r\n}\r\n","\"use strict\";\r\n\r\n/**\r\n * A minimal path module to resolve Unix, Windows and URL paths alike.\r\n * @memberof util\r\n * @namespace\r\n */\r\nvar path = exports;\r\n\r\nvar isAbsolute =\r\n/**\r\n * Tests if the specified path is absolute.\r\n * @param {string} path Path to test\r\n * @returns {boolean} `true` if path is absolute\r\n */\r\npath.isAbsolute = function isAbsolute(path) {\r\n    return /^(?:\\/|\\w+:)/.test(path);\r\n};\r\n\r\nvar normalize =\r\n/**\r\n * Normalizes the specified path.\r\n * @param {string} path Path to normalize\r\n * @returns {string} Normalized path\r\n */\r\npath.normalize = function normalize(path) {\r\n    path = path.replace(/\\\\/g, \"/\")\r\n               .replace(/\\/{2,}/g, \"/\");\r\n    var parts    = path.split(\"/\"),\r\n        absolute = isAbsolute(path),\r\n        prefix   = \"\";\r\n    if (absolute)\r\n        prefix = parts.shift() + \"/\";\r\n    for (var i = 0; i < parts.length;) {\r\n        if (parts[i] === \"..\") {\r\n            if (i > 0 && parts[i - 1] !== \"..\")\r\n                parts.splice(--i, 2);\r\n            else if (absolute)\r\n                parts.splice(i, 1);\r\n            else\r\n                ++i;\r\n        } else if (parts[i] === \".\")\r\n            parts.splice(i, 1);\r\n        else\r\n            ++i;\r\n    }\r\n    return prefix + parts.join(\"/\");\r\n};\r\n\r\n/**\r\n * Resolves the specified include path against the specified origin path.\r\n * @param {string} originPath Path to the origin file\r\n * @param {string} includePath Include path relative to origin path\r\n * @param {boolean} [alreadyNormalized=false] `true` if both paths are already known to be normalized\r\n * @returns {string} Path to the include file\r\n */\r\npath.resolve = function resolve(originPath, includePath, alreadyNormalized) {\r\n    if (!alreadyNormalized)\r\n        includePath = normalize(includePath);\r\n    if (isAbsolute(includePath))\r\n        return includePath;\r\n    if (!alreadyNormalized)\r\n        originPath = normalize(originPath);\r\n    return (originPath = originPath.replace(/(?:\\/|^)[^/]+$/, \"\")).length ? normalize(originPath + \"/\" + includePath) : includePath;\r\n};\r\n","\"use strict\";\r\nmodule.exports = pool;\r\n\r\n/**\r\n * An allocator as used by {@link util.pool}.\r\n * @typedef PoolAllocator\r\n * @type {function}\r\n * @param {number} size Buffer size\r\n * @returns {Uint8Array} Buffer\r\n */\r\n\r\n/**\r\n * A slicer as used by {@link util.pool}.\r\n * @typedef PoolSlicer\r\n * @type {function}\r\n * @param {number} start Start offset\r\n * @param {number} end End offset\r\n * @returns {Uint8Array} Buffer slice\r\n * @this {Uint8Array}\r\n */\r\n\r\n/**\r\n * A general purpose buffer pool.\r\n * @memberof util\r\n * @function\r\n * @param {PoolAllocator} alloc Allocator\r\n * @param {PoolSlicer} slice Slicer\r\n * @param {number} [size=8192] Slab size\r\n * @returns {PoolAllocator} Pooled allocator\r\n */\r\nfunction pool(alloc, slice, size) {\r\n    var SIZE   = size || 8192;\r\n    var MAX    = SIZE >>> 1;\r\n    var slab   = null;\r\n    var offset = SIZE;\r\n    return function pool_alloc(size) {\r\n        if (size < 1 || size > MAX)\r\n            return alloc(size);\r\n        if (offset + size > SIZE) {\r\n            slab = alloc(SIZE);\r\n            offset = 0;\r\n        }\r\n        var buf = slice.call(slab, offset, offset += size);\r\n        if (offset & 7) // align to 32 bit\r\n            offset = (offset | 7) + 1;\r\n        return buf;\r\n    };\r\n}\r\n","\"use strict\";\r\n\r\n/**\r\n * A minimal UTF8 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n */\r\nvar utf8 = exports,\r\n    replacementChar = \"\\ufffd\";\r\n\r\n/**\r\n * Calculates the UTF8 byte length of a string.\r\n * @param {string} string String\r\n * @returns {number} Byte length\r\n */\r\nutf8.length = function utf8_length(string) {\r\n    var len = 0,\r\n        c = 0;\r\n    for (var i = 0; i < string.length; ++i) {\r\n        c = string.charCodeAt(i);\r\n        if (c < 128)\r\n            len += 1;\r\n        else if (c < 2048)\r\n            len += 2;\r\n        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {\r\n            ++i;\r\n            len += 4;\r\n        } else\r\n            len += 3;\r\n    }\r\n    return len;\r\n};\r\n\r\n/**\r\n * Reads UTF8 bytes as a string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} String read\r\n */\r\nutf8.read = function utf8_read(buffer, start, end) {\r\n    if (end - start < 1) {\r\n        return \"\";\r\n    }\r\n\r\n    var str = \"\";\r\n    for (var i = start; i < end;) {\r\n        var t = buffer[i++];\r\n        if (t <= 0x7F) {\r\n            str += String.fromCharCode(t);\r\n        } else if (t >= 0xC0 && t < 0xE0) {\r\n            var c2 = (t & 0x1F) << 6 | buffer[i++] & 0x3F;\r\n            str += c2 >= 0x80 ? String.fromCharCode(c2) : replacementChar;\r\n        } else if (t >= 0xE0 && t < 0xF0) {\r\n            var c3 = (t & 0xF) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;\r\n            str += c3 >= 0x800 ? String.fromCharCode(c3) : replacementChar;\r\n        } else if (t >= 0xF0) {\r\n            var t2 = (t & 7) << 18 | (buffer[i++] & 0x3F) << 12 | (buffer[i++] & 0x3F) << 6 | buffer[i++] & 0x3F;\r\n            if (t2 < 0x10000 || t2 > 0x10FFFF)\r\n                str += replacementChar;\r\n            else {\r\n                t2 -= 0x10000;\r\n                str += String.fromCharCode(0xD800 + (t2 >> 10));\r\n                str += String.fromCharCode(0xDC00 + (t2 & 0x3FF));\r\n            }\r\n        }\r\n    }\r\n\r\n    return str;\r\n};\r\n\r\n/**\r\n * Writes a string as UTF8 bytes.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Bytes written\r\n */\r\nutf8.write = function utf8_write(string, buffer, offset) {\r\n    var start = offset,\r\n        c1, // character 1\r\n        c2; // character 2\r\n    for (var i = 0; i < string.length; ++i) {\r\n        c1 = string.charCodeAt(i);\r\n        if (c1 < 128) {\r\n            buffer[offset++] = c1;\r\n        } else if (c1 < 2048) {\r\n            buffer[offset++] = c1 >> 6       | 192;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {\r\n            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);\r\n            ++i;\r\n            buffer[offset++] = c1 >> 18      | 240;\r\n            buffer[offset++] = c1 >> 12 & 63 | 128;\r\n            buffer[offset++] = c1 >> 6  & 63 | 128;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        } else {\r\n            buffer[offset++] = c1 >> 12      | 224;\r\n            buffer[offset++] = c1 >> 6  & 63 | 128;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        }\r\n    }\r\n    return offset - start;\r\n};\r\n","\"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            },\n            numberValue: {\n                type: \"double\",\n                id: 2\n            },\n            stringValue: {\n                type: \"string\",\n                id: 3\n            },\n            boolValue: {\n                type: \"bool\",\n                id: 4\n            },\n            structValue: {\n                type: \"Struct\",\n                id: 5\n            },\n            listValue: {\n                type: \"ListValue\",\n                id: 6\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 IDoubleValue\n     * @type {Object}\n     * @property {number} [value]\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(16),\n    util = require(38);\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 * @returns {Codegen} Codegen instance\n * @ignore\n */\nfunction genValuePartial_fromObject(gen, field, fieldIndex, prop) {\n    var defaultAlreadyEmitted = false;\n    /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */\n    if (field.resolvedType) {\n        if (field.resolvedType instanceof Enum) { gen\n            (\"switch(d%s){\", prop);\n            for (var values = field.resolvedType.values, keys = Object.keys(values), i = 0; i < keys.length; ++i) {\n                // enum unknown values passthrough\n                if (values[keys[i]] === field.typeDefault && !defaultAlreadyEmitted) { gen\n                    (\"default:\")\n                        (\"if(typeof(d%s)===\\\"number\\\"){m%s=d%s;break}\", prop, prop, prop);\n                    if (!field.repeated) gen // fallback to default value only for\n                                             // arrays, to avoid leaving holes.\n                        (\"break\");           // for non-repeated fields, just ignore\n                    defaultAlreadyEmitted = true;\n                }\n                gen\n                (\"case%j:\", keys[i])\n                (\"case %i:\", values[keys[i]])\n                    (\"m%s=%j\", prop, values[keys[i]])\n                    (\"break\");\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,n+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\", \"n\"], mtype.name + \"$fromObject\")\n    (\"if(d instanceof this.ctor)\")\n        (\"return d\");\n    if (!fields.length) return gen\n    (\"return new this.ctor\");\n    gen\n    (\"if(!util.isObject(d))\")\n        (\"throw TypeError(%j)\", mtype.fullName + \": object expected\")\n    (\"if(n===undefined)n=0\")\n    (\"if(n>util.recursionLimit)\")\n        (\"throw Error(\\\"maximum nesting depth exceeded\\\")\");\n    gen\n    (\"var m=new this.ctor\");\n    for (var i = 0; i < fields.length; ++i) {\n        var field  = fields[i].resolve(),\n            prop   = util.safeProp(field.name);\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        (\"m%s=[]\", prop)\n        (\"for(var i=0;i<d%s.length;++i){\", prop);\n            genValuePartial_fromObject(gen, field, /* not sorted */ i, prop + \"[i]\")\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        genValuePartial_fromObject(gen, field, /* not sorted */ i, prop);\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} prop Property reference\n * @returns {Codegen} Codegen instance\n * @ignore\n */\nfunction genValuePartial_toObject(gen, field, fieldIndex, prop) {\n    /* eslint-disable no-unexpected-multiline, block-scoped-var, no-redeclare */\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\", prop, fieldIndex, prop, prop, fieldIndex, prop, prop);\n        else gen\n            (\"d%s=types[%i].toObject(m%s,o,q+1)\", prop, fieldIndex, prop);\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\", prop, prop, 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(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()\", prop, prop, prop, prop, prop, isUnsigned)\n            (\"else if(typeof m%s===\\\"number\\\")\", prop)\n                (\"d%s=o.longs===String?String(m%s):m%s\", prop, prop, prop)\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\", prop, prop, prop, prop, isUnsigned ? \"true\": \"\", prop);\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\", prop, prop, prop, prop, prop);\n                break;\n            default: gen\n            (\"d%s=m%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 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\"], mtype.name + \"$toObject\")\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, String.fromCharCode.apply(String, field.typeDefault))\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        (\"for(var j=0;j<ks2.length;++j){\");\n            gen\n        (\"if(ks2[j]===\\\"__proto__\\\")\")\n            (\"util.makeProp(d%s,ks2[j])\", prop);\n            genValuePartial_toObject(gen, field, /* sorted */ index, prop + \"[ks2[j]]\")\n        (\"}\");\n        } else if (field.repeated) { gen\n    (\"if(m%s&&m%s.length){\", prop, prop)\n        (\"d%s=[]\", 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) 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(16),\n    types   = require(37),\n    util    = require(38);\n\nfunction missing(field) {\n    return \"missing required '\" + field.name + \"'\";\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 gen = util.codegen([\"r\", \"l\", \"e\", \"n\"], mtype.name + \"$decode\")\n    (\"if(!(r instanceof Reader))\")\n        (\"r=Reader.create(r)\")\n    (\"if(n===undefined)n=0\")\n    (\"if(n>Reader.recursionLimit)\")\n        (\"throw Error(\\\"maximum nesting depth exceeded\\\")\")\n    (\"var c,m\" + (mtype.fieldsArray.filter(function(field) { return field.map; }).length ? \",k,value\" : \"\"))\n    (\"if(l===undefined)\")\n        (\"c=r.len\")\n    (\"else{\")\n        (\"c=r.pos+l\")\n        (\"if(c>r.len)\")\n            (\"throw RangeError(\\\"index out of range\\\")\")\n        (\"l=r.len\")\n        (\"r.len=c\")\n    (\"}\")\n    (\"m=new this.ctor\")\n    (\"while(r.pos<c){\")\n        (\"var t=r.uint32()\")\n        (\"if(t===e)\")\n            (\"break\")\n        (\"switch(t>>>3){\");\n\n    var i = 0;\n    for (; 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); gen\n            (\"case %i: {\", field.id);\n\n        // Map fields\n        if (field.map) { gen\n                (\"if(%s===util.emptyObject)\", ref)\n                    (\"%s={}\", ref)\n                (\"var c2=r.uint32()+r.pos\")\n                (\"if(c2>r.len)\")\n                    (\"throw RangeError(\\\"index out of range\\\")\")\n                (\"r.len=c2\");\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.defaults[type] !== undefined) gen\n                (\"value=%j\", types.defaults[type]);\n            else gen\n                (\"value=null\");\n\n            gen\n                (\"while(r.pos<c2){\")\n                    (\"var tag2=r.uint32()\")\n                    (\"switch(tag2>>>3){\")\n                        (\"case 1: k=r.%s(); break\", field.keyType)\n                        (\"case 2:\");\n\n            if (types.basic[type] === undefined) gen\n                            (\"value=types[%i].decode(r,r.uint32(),undefined,n+1)\", i); // can't be groups\n            else gen\n                            (\"value=r.%s()\", type);\n\n            gen\n                            (\"break\")\n                        (\"default:\")\n                            (\"r.skipType(tag2&7,n)\")\n                            (\"break\")\n                    (\"}\")\n                (\"}\")\n                (\"if(r.pos!==c2)\")\n                    (\"throw RangeError(\\\"index out of range\\\")\")\n                (\"r.len=c\");\n\n            if (types.long[field.keyType] !== undefined) gen\n                (\"%s[typeof k===\\\"object\\\"?util.longToHash(k):k]=value\", ref);\n            else {\n                if (field.keyType === \"string\") gen\n                (\"if(k===\\\"__proto__\\\")\")\n                    (\"util.makeProp(%s,k)\", ref);\n                gen\n                (\"%s[k]=value\", ref);\n            }\n\n        // Repeated fields\n        } else if (field.repeated) { gen\n\n                (\"if(!(%s&&%s.length))\", ref, ref)\n                    (\"%s=[]\", ref);\n\n            // Packable (always check for forward and backward compatiblity)\n            if (types.packed[type] !== undefined) gen\n                (\"if((t&7)===2){\")\n                    (\"var c2=r.uint32()+r.pos\")\n                    (\"if(c2>r.len)\")\n                        (\"throw RangeError(\\\"index out of range\\\")\")\n                    (\"r.len=c2\")\n                    (\"while(r.pos<c2)\")\n                        (\"%s.push(r.%s())\", ref, type)\n                    (\"if(r.pos!==c2)\")\n                        (\"throw RangeError(\\\"index out of range\\\")\")\n                    (\"r.len=c\")\n                (\"}else\");\n\n            // Non-packed\n            if (types.basic[type] === undefined) gen(field.delimited\n                    ? \"%s.push(types[%i].decode(r,undefined,((t&~7)|4),n+1))\"\n                    : \"%s.push(types[%i].decode(r,r.uint32(),undefined,n+1))\", ref, i);\n            else gen\n                    (\"%s.push(r.%s())\", ref, type);\n\n        // Non-repeated\n        } else if (types.basic[type] === undefined) gen(field.delimited\n                ? \"%s=types[%i].decode(r,undefined,((t&~7)|4),n+1)\"\n                : \"%s=types[%i].decode(r,r.uint32(),undefined,n+1)\", ref, i);\n        else gen\n                (\"%s=r.%s()\", ref, type);\n        gen\n                (\"break\")\n            (\"}\");\n        // Unknown fields\n    } gen\n            (\"default:\")\n                (\"r.skipType(t&7,n)\")\n                (\"break\")\n\n        (\"}\")\n    (\"}\");\n\n    gen\n    (\"if(l!==undefined){\")\n        (\"if(r.pos!==c)\")\n            (\"throw RangeError(\\\"index out of range\\\")\")\n        (\"r.len=l\")\n    (\"}\");\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(16),\n    types    = require(37),\n    util     = require(38);\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\"], mtype.name + \"$encode\")\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            (\"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).fork()\", (field.id << 3 | 2) >>> 0)\n        (\"for(var i=0;i<%s.length;++i)\", ref)\n            (\"w.%s(%s[i])\", type, ref)\n        (\"w.ldelim()\");\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.optional) gen\n    (\"if(%s!=null&&Object.hasOwnProperty.call(m,%j))\", ref, field.name); // !== undefined && !== null\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    (\"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(25);\n((Enum.prototype = Object.create(ReflectionObject.prototype)).constructor = Enum).className = \"Enum\";\n\nvar Namespace = require(24),\n    util = require(38);\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>} [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 = {};\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>}\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 {Object.<string,number>} values Enum values\n * @property {Object.<string,*>} [options] Enum options\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);\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(25);\n((Field.prototype = Object.create(ReflectionObject.prototype)).constructor = Field).className = \"Field\";\n\nvar Enum  = require(16),\n    types = require(37),\n    util  = require(38);\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    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    if (rule === \"proto3_optional\") {\n        rule = \"optional\";\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/**\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 * @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} [rule=\"optional\"] Field rule\n * @property {string} type Field type\n * @property {number} id Field id\n * @property {Object.<string,*>} [options] Field options\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        \"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)\n        this.parent.ctor.prototype[this.name] = this.defaultValue;\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 */\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 */\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/**\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 */\n// like Field.d but without a default value\n\n// Sets up cyclic dependencies (called in index-light)\nField._configure = function configure(Type_) {\n    Type = Type_;\n};\n","\"use strict\";\nvar protobuf = module.exports = require(19);\n\nprotobuf.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 protobuf.Root();\n    } else if (!root)\n        root = new protobuf.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\nprotobuf.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 protobuf.Root();\n    return root.loadSync(filename);\n}\n\nprotobuf.loadSync = loadSync;\n\n// Serialization\nprotobuf.encoder          = require(15);\nprotobuf.decoder          = require(14);\nprotobuf.verifier         = require(43);\nprotobuf.converter        = require(13);\n\n// Reflection\nprotobuf.ReflectionObject = require(25);\nprotobuf.Namespace        = require(24);\nprotobuf.Root             = require(30);\nprotobuf.Enum             = require(16);\nprotobuf.Type             = require(36);\nprotobuf.Field            = require(17);\nprotobuf.OneOf            = require(26);\nprotobuf.MapField         = require(21);\nprotobuf.Service          = require(34);\nprotobuf.Method           = require(23);\n\n// Runtime\nprotobuf.Message          = require(22);\nprotobuf.wrappers         = require(44);\n\n// Utility\nprotobuf.types            = require(37);\nprotobuf.util             = require(38);\n\n// Set up possibly cyclic reflection dependencies\nprotobuf.ReflectionObject._configure(protobuf.Root);\nprotobuf.Namespace._configure(protobuf.Type, protobuf.Service, protobuf.Enum);\nprotobuf.Root._configure(protobuf.Type);\nprotobuf.Field._configure(protobuf.Type);\n","\"use strict\";\nvar protobuf = exports;\n\n/**\n * Build type, one of `\"full\"`, `\"light\"` or `\"minimal\"`.\n * @name build\n * @type {string}\n * @const\n */\nprotobuf.build = \"minimal\";\n\n// Serialization\nprotobuf.Writer       = require(45);\nprotobuf.BufferWriter = require(46);\nprotobuf.Reader       = require(28);\nprotobuf.BufferReader = require(29);\n\n// Utility\nprotobuf.util         = require(41);\nprotobuf.rpc          = require(32);\nprotobuf.roots        = require(31);\nprotobuf.configure    = configure;\n\n/* istanbul ignore next */\n/**\n * Reconfigures the library according to the environment.\n * @returns {undefined}\n */\nfunction configure() {\n    protobuf.util._configure();\n    protobuf.Writer._configure(protobuf.BufferWriter);\n    protobuf.Reader._configure(protobuf.BufferReader);\n}\n\n// Set up buffer utility according to the environment\nconfigure();\n","\"use strict\";\nvar protobuf = module.exports = require(18);\n\nprotobuf.build = \"full\";\n\n// Parser\nprotobuf.tokenize         = require(35);\nprotobuf.parse            = require(27);\nprotobuf.common           = require(12);\n\n// Configure parser\nprotobuf.Root._configure(protobuf.Type, protobuf.parse, protobuf.common);\n","\"use strict\";\nmodule.exports = MapField;\n\n// extends Field\nvar Field = require(17);\n((MapField.prototype = Object.create(Field.prototype)).constructor = MapField).className = \"MapField\";\n\nvar types   = require(37),\n    util    = require(38);\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    return new MapField(name, json.id, json.keyType, json.type, json.options, json.comment);\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        \"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 */\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(41);\n\n/**\n * Constructs a new message instance.\n * @classdesc Abstract runtime message.\n * @constructor\n * @param {Properties<T>} [properties] Properties to set\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            var key = keys[i];\n            if (key === \"__proto__\")\n                continue;\n            this[key] = properties[key];\n        }\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/*eslint-disable valid-jsdoc*/\n\n/**\n * Creates a new message of this type using the specified properties.\n * @param {Object.<string,*>} [properties] Properties to set\n * @returns {Message<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\n/*eslint-enable valid-jsdoc*/\n","\"use strict\";\nmodule.exports = Method;\n\n// extends ReflectionObject\nvar ReflectionObject = require(25);\n((Method.prototype = Object.create(ReflectionObject.prototype)).constructor = Method).className = \"Method\";\n\nvar util = require(38);\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 {Object.<string,*>} [parsedOptions] Declared options, properly parsed into an object\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 {boolean|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 {boolean|undefined}\n     */\n    this.responseStream = responseStream ? true : undefined; // toJSON\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 an object\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} comment Method comments\n * @property {Object.<string,*>} [parsedOptions] Method options properly parsed into an object\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    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(25);\n((Namespace.prototype = Object.create(ReflectionObject.prototype)).constructor = Namespace).className = \"Namespace\";\n\nvar Field    = require(17),\n    util     = require(38),\n    OneOf    = require(26);\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    depth = util.checkDepth(depth);\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    depth = util.checkDepth(depth);\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    delete this.nested[object.name];\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    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    // Early bailout for objects with matching absolute paths\n    var found = this.root._fullyQualifiedObjects && this.root._fullyQualifiedObjects[\".\" + flatPath];\n    if (found && (!filterTypes || filterTypes.indexOf(found.constructor) > -1)) {\n        return found;\n    }\n\n    // Do a regular lookup at this namespace and below\n    found = this._lookupImpl(path, 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(26);\nvar util = require(38);\n\nvar Root; // cyclic\n\n/* eslint-disable no-warning-comments */\n// TODO: Replace with embedded proto.\nvar editions2023Defaults = {enum_type: \"OPEN\", field_presence: \"EXPLICIT\", json_format: \"ALLOW\", message_encoding: \"LENGTH_PREFIXED\", repeated_field_encoding: \"PACKED\", utf8_validation: \"VERIFY\"};\nvar proto2Defaults = {enum_type: \"CLOSED\", field_presence: \"EXPLICIT\", json_format: \"LEGACY_BEST_EFFORT\", message_encoding: \"LENGTH_PREFIXED\", repeated_field_encoding: \"EXPANDED\", utf8_validation: \"NONE\"};\nvar proto3Defaults = {enum_type: \"OPEN\", field_presence: \"IMPLICIT\", json_format: \"ALLOW\", message_encoding: \"LENGTH_PREFIXED\", repeated_field_encoding: \"PACKED\", utf8_validation: \"VERIFY\"};\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 * @abstract\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 {\n            throw new Error(\"Unknown edition: \" + edition);\n        }\n        this._features = util.merge(defaults, protoFeatures);\n        this._featuresResolved = true;\n        return;\n    }\n\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    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)\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 if (!ifNotSet || this.options[name] === undefined) {\n        if (this.getOption(name) !== value) this.resolved = false;\n        this.options[name] = value;\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 * @returns {string} Class name[, space, full name]\n */\nReflectionObject.prototype.toString = 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\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(25);\n((OneOf.prototype = Object.create(ReflectionObject.prototype)).constructor = OneOf).className = \"OneOf\";\n\nvar Field = require(17),\n    util  = require(38);\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 */\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 */\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 */\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(35),\n    Root      = require(30),\n    Type      = require(36),\n    Field     = require(17),\n    MapField  = require(21),\n    OneOf     = require(26),\n    Enum      = require(16),\n    Service   = require(34),\n    Method    = require(23),\n    ReflectionObject = require(25),\n    types     = require(37),\n    util      = require(38);\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\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) {\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()), skip(\"to\", true) ? parseId(next()) : 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) {\n        switch (token) {\n            case \"max\": case \"MAX\": case \"Max\":\n                return 536870911;\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 (!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 \"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\"];\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 \"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 (!nameRe.test(token = next()))\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 \"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 === \"group\") {\n            parseGroup(parent, rule, 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            type += next();\n        }\n\n        /* istanbul ignore if */\n        if (!typeRefRe.test(type))\n            throw illegal(type, \"type\");\n\n        var name = next();\n\n        /* istanbul ignore if */\n\n        if (!nameRe.test(name))\n            throw illegal(name, \"name\");\n\n        name = applyCase(name);\n        skip(\"=\");\n\n        var field = new Field(name, parseId(next()), type, rule, extend);\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, 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 (!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);\n        field.filename = parse.filename;\n        ifBlock(type, function parseGroup_block(token) {\n            switch (token) {\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                /* 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    }\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 (!nameRe.test(name))\n            throw illegal(name, \"name\");\n\n        skip(\"=\");\n        var field = new MapField(applyCase(name), parseId(next()), keyType, valueType);\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 (!nameRe.test(token = next()))\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 (!nameRe.test(token = next()))\n            throw illegal(token, \"name\");\n\n        var enm = new Enum(token);\n        ifBlock(enm, function parseEnum_block(token) {\n          switch(token) {\n            case \"option\":\n              parseOption(enm, token);\n              skip(\";\");\n              break;\n\n            case \"reserved\":\n              readRanges(enm.reserved || (enm.reserved = []), true);\n              if(enm.reserved === undefined) enm.reserved = [];\n              break;\n\n            default:\n              parseEnumValue(enm, token);\n          }\n        });\n        parent.add(enm);\n        if (parent === ptr) {\n            topLevelObjects.push(enm);\n        }\n    }\n\n    function parseEnumValue(parent, 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        parent.add(token, value, dummy.comment, dummy.parsedOptions || dummy.options);\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                /* istanbul ignore if */\n                if (!nameRe.test(token = next())) {\n                    throw illegal(token, \"name\");\n                }\n                if (token === null) {\n                  throw illegal(token, \"end of input\");\n                }\n\n                var value;\n                var propName = token;\n\n                skip(\":\", true);\n\n                if (peek() === \"{\") {\n                    // option (my_option) = {\n                    //     repeated_value: [ \"foo\", \"bar\" ]\n                    // };\n                    value = parseOptionValue(parent, name + \".\" + token, depth + 1);\n                } else if (peek() === \"[\") {\n                    value = [];\n                    var lastValue;\n                    if (skip(\"[\", true)) {\n                        do {\n                            lastValue = readValue(true);\n                            value.push(lastValue);\n                        } while (skip(\",\", true));\n                        skip(\"]\");\n                        if (typeof lastValue !== \"undefined\") {\n                            setOption(parent, name + \".\" + token, lastValue);\n                        }\n                    }\n                } else {\n                    value = readValue(true);\n                    setOption(parent, name + \".\" + token, value);\n                }\n\n                var prevValue = objectResult[propName];\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        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 (!nameRe.test(token = next()))\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 === \"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 === \"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 (!typeRefRe.test(token = next()))\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 \"package\":\n\n                /* istanbul ignore if */\n                if (!head)\n                    throw illegal(token);\n\n                parsePackage();\n                break;\n\n            case \"import\":\n\n                /* istanbul ignore if */\n                if (!head)\n                    throw illegal(token);\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(41);\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` if available, otherwise `Array`.\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\nvar create_array = typeof Uint8Array !== \"undefined\"\n    ? function create_typed_array(buffer) {\n        if (buffer instanceof Uint8Array || Array.isArray(buffer))\n            return new Reader(buffer);\n        throw Error(\"illegal buffer\");\n    }\n    /* istanbul ignore next */\n    : function create_array(buffer) {\n        if (Array.isArray(buffer))\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\nReader.prototype._slice = util.Array.prototype.subarray || /* istanbul ignore next */ util.Array.prototype.slice;\n\nfunction readVarint32NearEnd(reader) {\n    // Safely read up to four bytes of a varint32 near the reader limit\n    var value = 0;\n    for (var i = 0; i < 4; ++i) {\n        if (reader.pos >= reader.len)\n            throw indexOutOfRange(reader);\n        var b = reader.buf[reader.pos++];\n        value = (value | (b & 127) << i * 7) >>> 0;\n        if (b < 128)\n            return value;\n    }\n    throw indexOutOfRange(reader);\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_setup() {\n    var value = 4294967295; // optimizer type-hint, tends to deopt otherwise (?!)\n    return function read_uint32() {\n        if (this.len - this.pos < 5) {\n            if (this.pos >= this.len)\n                throw indexOutOfRange(this);\n            if (this.buf[this.pos] >= 128)\n                return readVarint32NearEnd(this);\n        }\n        value = (         this.buf[this.pos] & 127       ) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) <<  7) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) << 14) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] & 127) << 21) >>> 0; if (this.buf[this.pos++] < 128) return value;\n        value = (value | (this.buf[this.pos] &  15) << 28) >>> 0; if (this.buf[this.pos++] < 128) return value;\n\n        /* istanbul ignore if */\n        if ((this.pos += 5) > this.len) {\n            this.pos = this.len;\n            throw indexOutOfRange(this, 10);\n        }\n        return value;\n    };\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 < 3; ++i) {\n            /* istanbul ignore if */\n            if (this.pos >= this.len)\n                throw indexOutOfRange(this);\n            // 1st..3th\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        // 4th\n        bits.lo = (bits.lo | (this.buf[this.pos++] & 127) << i * 7) >>> 0;\n        return bits;\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    return this.uint32() !== 0;\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 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 += length;\n    if (Array.isArray(this.buf)) // plain array\n        return this.buf.slice(start, end);\n\n    if (start === end) { // fix for IE 10/Win8 and others' subarray returning array of size 1\n        var nativeBuffer = util.Buffer;\n        return nativeBuffer\n            ? nativeBuffer.alloc(0)\n            : new this.buf.constructor(0);\n    }\n    return this._slice.call(this.buf, 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 bytes = this.bytes();\n    return utf8.read(bytes, 0, bytes.length);\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 * 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 * @returns {Reader} `this`\n */\nReader.prototype.skipType = function(wireType, depth) {\n    if (depth === undefined) depth = 0;\n    if (depth > Reader.recursionLimit)\n        throw Error(\"maximum nesting depth exceeded\");\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 ((wireType = this.uint32() & 7) !== 4) {\n                this.skipType(wireType, depth + 1);\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(28);\n(BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;\n\nvar util = require(41);\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/**\n * @override\n */\nBufferReader.prototype.string = function read_string_buffer() {\n    var len = this.uint32(); // modifies pos\n    return this.buf.utf8Slice\n        ? this.buf.utf8Slice(this.pos, this.pos = Math.min(this.pos + len, this.len))\n        : this.buf.toString(\"utf-8\", this.pos, this.pos = Math.min(this.pos + len, this.len));\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(24);\n((Root.prototype = Object.create(Namespace.prototype)).constructor = Root).className = \"Root\";\n\nvar Field   = require(17),\n    Enum    = require(16),\n    OneOf   = require(26),\n    util    = require(38);\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    depth = util.checkDepth(depth);\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 (altname in common) return altname;\n        }\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 (filename in common) {\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(33);\n","\"use strict\";\nmodule.exports = Service;\n\nvar util = require(41);\n\n// Extends EventEmitter\n(Service.prototype = Object.create(util.EventEmitter.prototype)).constructor = Service;\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 {function}\n * @param {TReq|Properties<TReq>} request Request message or plain object\n * @param {rpc.ServiceMethodCallback<TRes>} [callback] Node-style callback called with the error, if any, and the response message\n * @returns {Promise<Message<TRes>>} Promise if `callback` has been omitted, otherwise `undefined`\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(24);\n((Service.prototype = Object.create(Namespace.prototype)).constructor = Service).className = \"Service\";\n\nvar Method = require(23),\n    util   = require(38),\n    rpc    = require(32);\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 {Object.<string,IMethod>} methods Method descriptors\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    depth = util.checkDepth(depth);\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            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                            } while (isDoubleSlashCommentLine(offset));\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(24);\n((Type.prototype = Object.create(Namespace.prototype)).constructor = Type).className = \"Type\";\n\nvar Enum      = require(16),\n    OneOf     = require(26),\n    Field     = require(17),\n    MapField  = require(21),\n    Service   = require(34),\n    Message   = require(22),\n    Reader    = require(28),\n    Writer    = require(45),\n    util      = require(38),\n    encoder   = require(15),\n    decoder   = require(14),\n    verifier  = require(43),\n    converter = require(13),\n    wrappers  = require(44);\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\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     * @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()).constructor = ctor;\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\n            // Messages have non-enumerable default values on their prototype\n            var i = 0;\n            for (; i < /* initializes */ this.fieldsArray.length; ++i)\n                this._fieldsArray[i].resolve(); // ensures a proper value\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\"], mtype.name);\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 = 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 {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 */\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 (!this.fields || this.fields[object.name] !== object)\n            throw Error(object + \" is not a member of \" + this);\n\n        delete this.fields[object.name];\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 (!this.oneofs || this.oneofs[object.name] !== object)\n            throw Error(object + \" is not a member of \" + this);\n\n        delete this.oneofs[object.name];\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 {Message<{}>} 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    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    });\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    });\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 originalThis = Object.create(this);\n        // if (wrapper.fromObject) {\n            originalThis.fromObject = this.fromObject;\n            this.fromObject = wrapper.fromObject.bind(originalThis);\n        // }\n        // if (wrapper.toObject) {\n            originalThis.toObject = this.toObject;\n            this.toObject = wrapper.toObject.bind(originalThis);\n        // }\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.len ? writer.fork() : writer).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 * @param {number} [end] Expected group end tag, if decoding a group\n * @param {number} [depth] Current nesting depth\n * @returns {Message<{}>} 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, end, depth) {\n    return this.setup().decode(reader, length, end, depth); // 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 {Message<{}>} 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 * @param {number} [depth] Current nesting depth\n * @returns {null|string} `null` if valid, otherwise the reason why it is not\n */\nType.prototype.verify = function verify_setup(message, depth) {\n    return this.setup().verify(message, depth); // 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 * @param {number} [depth] Current nesting depth\n * @returns {Message<{}>} Message instance\n */\nType.prototype.fromObject = function fromObject(object, depth) {\n    return this.setup().fromObject(object, depth);\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 * 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 */\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 */\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(38);\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(41);\n\nvar roots = require(31);\n\nvar Type, // cyclic\n    Enum;\n\nutil.codegen = require(3);\nutil.fetch   = require(5);\nutil.path    = require(8);\nutil.patterns = require(42);\n\nvar reservedRe = util.patterns.reservedRe;\n\n/**\n * Node's fs module if available.\n * @type {Object.<string,*>}\n */\nutil.fs = require(39);\n\n/**\n * Checks a recursion depth.\n * @param {number|undefined} depth Depth of recursion\n * @returns {number} Depth of recursion\n * @throws {Error} If depth exceeds util.recursionLimit\n */\nutil.checkDepth = function checkDepth(depth) {\n    if (depth === undefined)\n        depth = 0;\n    if (depth > util.recursionLimit)\n        throw Error(\"max depth exceeded\");\n    return depth;\n};\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 * 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 */\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 * 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 */\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(36);\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 */\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(16);\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 */\nObject.defineProperty(util, \"decorateRoot\", {\n    get: function() {\n        return roots[\"decorated\"] || (roots[\"decorated\"] = new (require(30))());\n    }\n});\n","\"use strict\";\n\nvar fs = null;\ntry {\n    fs = require(11);\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 util = require(41);\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 (util.isString(value)) {\n        /* istanbul ignore else */\n        if (util.Long)\n            value = util.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 util.Long\n        ? new util.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","\"use strict\";\nvar util = exports;\n\n// used to return a Promise where callback is omitted\nutil.asPromise = require(1);\n\n// converts to / from base64 encoded strings\nutil.base64 = require(2);\n\n// base class of rpc.Service\nutil.EventEmitter = require(4);\n\n// float handling accross browsers\nutil.float = require(7);\n\n// converts to / from utf8 encoded strings\nutil.utf8 = require(10);\n\n// provides a node-like buffer pool in the browser\nutil.pool = require(9);\n\n// utility to work with the low and high bits of a 64 bit value\nutil.LongBits = require(40);\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           || 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 ? Buffer : /* istanbul ignore next */ null;\n    } catch (e) {\n        /* istanbul ignore next */\n        return null;\n    }\n})();\n\n// Internal alias of or polyfull for Buffer.from.\nutil._Buffer_from = null;\n\n// Internal alias of or polyfill for Buffer.allocUnsafe.\nutil._Buffer_allocUnsafe = null;\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    /* istanbul ignore next */\n    return typeof sizeOrArray === \"number\"\n        ? util.Buffer\n            ? util._Buffer_allocUnsafe(sizeOrArray)\n            : new util.Array(sizeOrArray)\n        : util.Buffer\n            ? util._Buffer_from(sizeOrArray)\n            : typeof Uint8Array === \"undefined\"\n                ? sizeOrArray\n                : new Uint8Array(sizeOrArray);\n};\n\n/**\n * Array implementation used in the browser. `Uint8Array` if supported, otherwise `Array`.\n * @type {Constructor<Uint8Array>}\n */\nutil.Array = typeof Uint8Array !== \"undefined\" ? Uint8Array /* istanbul ignore next */ : Array;\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]*))$/;\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 * 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]) && (dst[keys[i]] === undefined || !ifNotSet))\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 * @returns {undefined}\n */\nutil.makeProp = function makeProp(obj, key) {\n    Object.defineProperty(obj, key, {\n        enumerable: true,\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\n// Sets up buffer utility according to the environment (called in index-minimal)\nutil._configure = function() {\n    var Buffer = util.Buffer;\n    /* istanbul ignore if */\n    if (!Buffer) {\n        util._Buffer_from = util._Buffer_allocUnsafe = null;\n        return;\n    }\n    // because node 4.x buffers are incompatible & immutable\n    // see: https://github.com/dcodeIO/protobuf.js/pull/665\n    util._Buffer_from = Buffer.from !== Uint8Array.from && Buffer.from ||\n        /* istanbul ignore next */\n        function Buffer_from(value, encoding) {\n            return new Buffer(value, encoding);\n        };\n    util._Buffer_allocUnsafe = Buffer.allocUnsafe ||\n        /* istanbul ignore next */\n        function Buffer_allocUnsafe(size) {\n            return new Buffer(size);\n        };\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 = verifier;\n\nvar Enum      = require(16),\n    util      = require(38);\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    if (field.resolvedType) {\n        if (field.resolvedType instanceof Enum) { gen\n            (\"switch(%s){\", ref)\n                (\"default:\")\n                    (\"return%j\", invalid(field, \"enum value\"));\n            for (var keys = Object.keys(field.resolvedType.values), j = 0; j < keys.length; ++j) gen\n                (\"case %i:\", field.resolvedType.values[keys[j]]);\n            gen\n                    (\"break\")\n            (\"}\");\n        } else {\n            gen\n            (\"{\")\n                (\"var e=types[%i].verify(%s,n+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\", \"n\"], mtype.name + \"$verify\")\n    (\"if(typeof m!==\\\"object\\\"||m===null)\")\n        (\"return%j\", \"object expected\")\n    (\"if(n===undefined)n=0\")\n    (\"if(n>util.recursionLimit)\")\n        (\"return%j\", \"maximum nesting 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(22),\n    util    = require(41);\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        if (depth === undefined)\n            depth = 0;\n        if (depth > util.recursionLimit)\n            throw Error(\"max depth exceeded\");\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);\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 + 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\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);\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(41);\n\nvar BufferWriter; // cyclic\n\nvar LongBits  = util.LongBits,\n    base64    = util.base64,\n    utf8      = util.utf8;\n\n/**\n * Constructs a new writer operation instance.\n * @classdesc Scheduled writer operation.\n * @constructor\n * @param {function(*, Uint8Array, number)} fn Function to call\n * @param {number} len Value byte length\n * @param {*} val Value to write\n * @ignore\n */\nfunction Op(fn, len, val) {\n\n    /**\n     * Function to call.\n     * @type {function(Uint8Array, number, *)}\n     */\n    this.fn = fn;\n\n    /**\n     * Value byte length.\n     * @type {number}\n     */\n    this.len = len;\n\n    /**\n     * Next operation.\n     * @type {Writer.Op|undefined}\n     */\n    this.next = undefined;\n\n    /**\n     * Value to write.\n     * @type {*}\n     */\n    this.val = val; // type varies\n}\n\n/* istanbul ignore next */\nfunction noop() {} // eslint-disable-line no-empty-function\n\n/**\n * Constructs a new writer state instance.\n * @classdesc Copied writer state.\n * @memberof Writer\n * @constructor\n * @param {Writer} writer Writer to copy state from\n * @ignore\n */\nfunction State(writer) {\n\n    /**\n     * Current head.\n     * @type {Writer.Op}\n     */\n    this.head = writer.head;\n\n    /**\n     * Current tail.\n     * @type {Writer.Op}\n     */\n    this.tail = writer.tail;\n\n    /**\n     * Current buffer length.\n     * @type {number}\n     */\n    this.len = writer.len;\n\n    /**\n     * Next state.\n     * @type {State|null}\n     */\n    this.next = writer.states;\n}\n\n/**\n * Constructs a new writer instance.\n * @classdesc Wire format writer using `Uint8Array` if available, otherwise `Array`.\n * @constructor\n */\nfunction Writer() {\n\n    /**\n     * Current length.\n     * @type {number}\n     */\n    this.len = 0;\n\n    /**\n     * Operations head.\n     * @type {Object}\n     */\n    this.head = new Op(noop, 0, 0);\n\n    /**\n     * Operations tail\n     * @type {Object}\n     */\n    this.tail = this.head;\n\n    /**\n     * Linked forked states.\n     * @type {Object|null}\n     */\n    this.states = null;\n\n    // When a value is written, the writer calculates its byte length and puts it into a linked\n    // list of operations to perform when finish() is called. This both allows us to allocate\n    // buffers of the exact required size and reduces the amount of work we have to do compared\n    // to first calculating over objects and then encoding over objects. In our case, the encoding\n    // part is just a linked list walk calling operations with already prepared values.\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 util.Array(size);\n};\n\n// Use Uint8Array buffer pool in the browser, just like node does with buffers\n/* istanbul ignore else */\nif (util.Array !== Array)\n    Writer.alloc = util.pool(Writer.alloc, util.Array.prototype.subarray);\n\n/**\n * Pushes a new operation to the queue.\n * @param {function(Uint8Array, number, *)} fn Function to call\n * @param {number} len Value byte length\n * @param {number} val Value to write\n * @returns {Writer} `this`\n * @private\n */\nWriter.prototype._push = function push(fn, len, val) {\n    this.tail = this.tail.next = new Op(fn, len, val);\n    this.len += len;\n    return this;\n};\n\nfunction writeByte(val, buf, pos) {\n    buf[pos] = val & 255;\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}\n\n/**\n * Constructs a new varint writer operation instance.\n * @classdesc Scheduled varint writer operation.\n * @extends Op\n * @constructor\n * @param {number} len Value byte length\n * @param {number} val Value to write\n * @ignore\n */\nfunction VarintOp(len, val) {\n    this.len = len;\n    this.next = undefined;\n    this.val = val;\n}\n\nVarintOp.prototype = Object.create(Op.prototype);\nVarintOp.prototype.fn = writeVarint32;\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    // here, the call to this.push has been inlined and a varint specific Op subclass is used.\n    // uint32 is by far the most frequently used operation and benefits significantly from this.\n    this.len += (this.tail = this.tail.next = new VarintOp(\n        (value = value >>> 0)\n                < 128       ? 1\n        : value < 16384     ? 2\n        : value < 2097152   ? 3\n        : value < 268435456 ? 4\n        :                     5,\n    value)).len;\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    return (value |= 0) < 0\n        ? this._push(writeVarint64, 10, LongBits.fromNumber(value)) // 10 bytes per spec\n        : 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}\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    return this._push(writeVarint64, bits.length(), bits);\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    return this._push(writeVarint64, bits.length(), bits);\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    return this._push(writeByte, 1, value ? 1 : 0);\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    return this._push(writeFixed32, 4, value >>> 0);\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    return this._push(writeFixed32, 4, bits.lo)._push(writeFixed32, 4, bits.hi);\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    return this._push(util.float.writeFloatLE, 4, value);\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    return this._push(util.float.writeDoubleLE, 8, value);\n};\n\nvar writeBytes = util.Array.prototype.set\n    ? function writeBytes_set(val, buf, pos) {\n        buf.set(val, pos); // also works for plain array values\n    }\n    /* istanbul ignore next */\n    : function writeBytes_for(val, buf, pos) {\n        for (var i = 0; i < val.length; ++i)\n            buf[pos + i] = val[i];\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        return this._push(writeByte, 1, 0);\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    return this.uint32(len)._push(writeBytes, len, value);\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 len = utf8.length(value);\n    return len\n        ? this.uint32(len)._push(utf8.write, len, value)\n        : this._push(writeByte, 1, 0);\n};\n\n/**\n * Forks this writer's state by pushing it to a stack.\n * Calling {@link Writer#reset|reset} or {@link Writer#ldelim|ldelim} resets the writer to the previous state.\n * @returns {Writer} `this`\n */\nWriter.prototype.fork = function fork() {\n    this.states = new State(this);\n    this.head = this.tail = new Op(noop, 0, 0);\n    this.len = 0;\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    if (this.states) {\n        this.head   = this.states.head;\n        this.tail   = this.states.tail;\n        this.len    = this.states.len;\n        this.states = this.states.next;\n    } else {\n        this.head = this.tail = new Op(noop, 0, 0);\n        this.len  = 0;\n    }\n    return this;\n};\n\n/**\n * Resets to the last state and appends the fork state's current write length as a varint followed by its operations.\n * @returns {Writer} `this`\n */\nWriter.prototype.ldelim = function ldelim() {\n    var head = this.head,\n        tail = this.tail,\n        len  = this.len;\n    this.reset().uint32(len);\n    if (len) {\n        this.tail.next = head.next; // skip noop\n        this.tail = tail;\n        this.len += len;\n    }\n    return this;\n};\n\n/**\n * Finishes the write operation.\n * @returns {Uint8Array} Finished buffer\n */\nWriter.prototype.finish = function finish() {\n    var head = this.head.next, // skip noop\n        buf  = this.constructor.alloc(this.len),\n        pos  = 0;\n    while (head) {\n        head.fn(head.val, buf, pos);\n        pos += head.len;\n        head = head.next;\n    }\n    // this.head = this.tail = null;\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(45);\n(BufferWriter.prototype = Object.create(Writer.prototype)).constructor = BufferWriter;\n\nvar util = require(41);\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\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_allocUnsafe;\n\n    BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === \"set\"\n        ? function writeBytesBuffer_set(val, buf, pos) {\n          buf.set(val, pos); // faster than copy (requires node >= 4 where Buffers extend Uint8Array and set is properly inherited)\n          // also works for plain array values\n        }\n        /* istanbul ignore next */\n        : function writeBytesBuffer_copy(val, buf, pos) {\n          if (val.copy) // Buffer values\n            val.copy(buf, pos, 0, val.length);\n          else for (var i = 0; i < val.length;) // plain array values\n            buf[pos++] = val[i++];\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._push(BufferWriter.writeBytesBuffer, len, value);\n    return this;\n};\n\nfunction writeStringBuffer(val, buf, pos) {\n    if (val.length < 40) // plain js is faster for short strings (probably due to redundant assertions)\n        util.utf8.write(val, buf, pos);\n    else if (buf.utf8Write)\n        buf.utf8Write(val, pos);\n    else\n        buf.write(val, pos);\n}\n\n/**\n * @override\n */\nBufferWriter.prototype.string = function write_string_buffer(value) {\n    var len = util.Buffer.byteLength(value);\n    this.uint32(len);\n    if (len)\n        this._push(writeStringBuffer, len, value);\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":"."}