{"version":3,"file":"static/chunks/148.d5a9d8648026a4f8.js","mappings":"umCAyBO,IKJPA,EQLAC,ECCAC,EIDAC,ESKAC,ECLAC,ECZAC,ExBgBON,ESJAE,EIDAC,ESKAC,ECLAC,ECZAC,E7BsBAC,EAAA,iBAAAC,WACPA,WACA,iBAAAC,KACAA,KACA,iBAAAC,OACAA,OACA,iBAAqBC,EAAAC,EACHD,EAAAC,EAClB,GCjBOC,EAAA,QCAPC,EAAA,gCAoGOC,EAAAC,SAnFAC,CAAA,EACP,IAAAC,EAAA,IAAAC,IAAA,CAAAF,EAAA,EACAG,EAAA,IAAAD,IACAE,EAAAJ,EAAAK,MAAAR,GACA,IAAAO,EAEA,kBAA6B,UAE7B,IAAAE,EAAA,CACAC,MAAA,CAAAH,CAAA,IACAI,MAAA,CAAAJ,CAAA,IACAK,MAAA,CAAAL,CAAA,IACAM,WAAAN,CAAA,KAGA,GAAAE,MAAAA,EAAAI,WACA,gBAAAC,CAAA,EACA,OAAAA,IAAAX,CACA,EAEA,SAAAY,EAAAC,CAAA,EAEA,OADAV,EAAAW,IAAAD,GACA,EACA,CAKA,gBAAAF,CAAA,EACA,GAAAV,EAAAc,IAAAJ,GACA,SAEA,GAAAR,EAAAY,IAAAJ,GACA,SAEA,IAAAK,EAAAL,EAAAN,MAAAR,GACA,IAAAmB,EAGA,OAAAJ,EAAAD,GAEA,IAAAM,EAAA,CACAV,MAAA,CAAAS,CAAA,IACAR,MAAA,CAAAQ,CAAA,IACAP,MAAA,CAAAO,CAAA,IACAN,WAAAM,CAAA,YAGA,MAAAC,EAAAP,YAIAJ,EAAAC,QAAAU,EAAAV,MAHAK,EAAAD,GAMAL,IAAAA,EAAAC,MACA,EAAAC,QAAAS,EAAAT,OACAF,EAAAG,OAAAQ,EAAAR,OAhCAR,EAAAa,IAiCAH,GAhCA,IAkCAC,EAAAD,GAEA,EAAAH,OAAAS,EAAAT,OArCAP,EAAAa,IAsCAH,GArCA,IAuCAC,EAAAD,EACA,CACA,EAgBkDf,GCjGlDsB,EAAAC,OAAAC,IAAA,wBADYxB,EAAAyB,MAAa,SAGlB,SAAAC,EAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,EAEP,SAAAA,GAAoCA,CAAAA,EAAA,IACpC,IAFAC,EAEAC,EAAAC,CAAA,CAAAX,EAAA,QAAAS,CAAAA,EAAAE,CAAA,CAAAX,EAAA,GAAAS,KAAA,IAAAA,EAAAA,EAAA,CACAG,QAAiBlC,CACjB,EACA,IAAA8B,GAAAE,CAAA,CAAAL,EAAA,EAEA,IAAAQ,EAAA,sEAAAR,GAEA,OADAE,EAAAO,MAAAD,EAAAE,OAAAF,EAAAG,SACA,EACA,CACA,GAAAN,EAAAE,UAAwBlC,EAAO,CAE/B,IAAAmC,EAAA,sDAAAH,EAAAE,QAAA,QAAAP,EAAA,8CAA6J3B,GAE7J,OADA6B,EAAAO,MAAAD,EAAAE,OAAAF,EAAAG,SACA,EACA,CAGA,OAFAN,CAAA,CAAAL,EAAA,CAAAC,EACAC,EAAAU,MAAA,+CAAAZ,EAAA,KAA8E3B,EAAO,KACrF,EACA,CACO,SAAAwC,EAAAb,CAAA,EAEP,IADAI,EAAAU,EACA1B,EAAA,OAAAgB,CAAAA,EAAAE,CAAA,CAAAX,EAAA,GAAAS,KAAA,IAAAA,EAAA,OAAAA,EAAAG,QACA,MAA2BhC,EAAYa,GAGvC,cAAA0B,CAAAA,EAAAR,CAAA,CAAAX,EAAA,GAAAmB,KAAA,IAAAA,EAAA,OAAAA,CAAA,CAAAd,EAAA,CAEO,SAAAe,EAAAf,CAAA,CAAAE,CAAA,EACPA,EAAAU,MAAA,kDAAAZ,EAAA,KAAiF3B,EAAO,KACxF,IAAAgC,EAAAC,CAAA,CAAAX,EAAA,CACAU,GACA,OAAAA,CAAA,CAAAL,EAAA,CCxCA,IAAAgB,EAA0B,SAAAC,CAAA,CAAAC,CAAA,EAC1B,IAAAC,EAAA,mBAAAvB,QAAAqB,CAAA,CAAArB,OAAAwB,SAAA,CACA,IAAAD,EAAA,OAAAF,EACA,IAAAI,EAAAC,EAAAC,EAAAJ,EAAAK,KAAAP,GAAAQ,EAAA,GACA,IACA,MAAAP,KAAA,IAAAA,GAAAA,KAAA,MAAAG,EAAAE,EAAAG,MAAA,EAAAC,MAAAF,EAAAG,KAAAP,EAAAQ,MACA,CACA,MAAApB,EAAA,CAAoBa,EAAA,CAAMb,MAAAA,CAAA,SAC1B,CACA,IACAY,GAAA,CAAAA,EAAAM,MAAAR,CAAAA,EAAAI,EAAA,SAAAJ,EAAAK,KAAAD,EACA,QACA,CAAkB,GAAAD,EAAA,MAAAA,EAAAb,KAAA,CAClB,CACA,OAAAgB,CACA,EACAK,EAAiC,SAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,EACjC,GAAAA,GAAAC,GAAAA,UAAAC,OAAA,QAAAV,EAAAF,EAAA,EAAAa,EAAAJ,EAAAG,OAA6EZ,EAAAa,EAAOb,KACpFE,GAAAF,KAAAS,IACAP,GAAAA,CAAAA,EAAAY,MAAAC,UAAAC,MAAAf,KAAAQ,EAAA,EAAAT,EAAA,EACAE,CAAA,CAAAF,EAAA,CAAAS,CAAA,CAAAT,EAAA,EAGA,OAAAQ,EAAAS,OAAAf,GAAAY,MAAAC,UAAAC,MAAAf,KAAAQ,GACA,EAWAS,EAAA,WACA,SAAAA,EAAAC,CAAA,EACA,KAAAC,WAAAD,EAAAE,WAAA,qBACA,CAoCA,OAnCAH,EAAAH,UAAA1B,MAAA,WAEA,QADAiC,EAAA,GACAC,EAAA,EAAyBA,EAAAZ,UAAAC,OAAuBW,IAChDD,CAAA,CAAAC,EAAA,CAAAZ,SAAA,CAAAY,EAAA,CAEA,OAAAC,EAAA,aAAAJ,WAAAE,EACA,EACAJ,EAAAH,UAAA7B,MAAA,WAEA,QADAoC,EAAA,GACAC,EAAA,EAAyBA,EAAAZ,UAAAC,OAAuBW,IAChDD,CAAA,CAAAC,EAAA,CAAAZ,SAAA,CAAAY,EAAA,CAEA,OAAAC,EAAA,aAAAJ,WAAAE,EACA,EACAJ,EAAAH,UAAAU,KAAA,WAEA,QADAH,EAAA,GACAC,EAAA,EAAyBA,EAAAZ,UAAAC,OAAuBW,IAChDD,CAAA,CAAAC,EAAA,CAAAZ,SAAA,CAAAY,EAAA,CAEA,OAAAC,EAAA,YAAAJ,WAAAE,EACA,EACAJ,EAAAH,UAAAW,KAAA,WAEA,QADAJ,EAAA,GACAC,EAAA,EAAyBA,EAAAZ,UAAAC,OAAuBW,IAChDD,CAAA,CAAAC,EAAA,CAAAZ,SAAA,CAAAY,EAAA,CAEA,OAAAC,EAAA,YAAAJ,WAAAE,EACA,EACAJ,EAAAH,UAAAY,QAAA,WAEA,QADAL,EAAA,GACAC,EAAA,EAAyBA,EAAAZ,UAAAC,OAAuBW,IAChDD,CAAA,CAAAC,EAAA,CAAAZ,SAAA,CAAAY,EAAA,CAEA,OAAAC,EAAA,eAAAJ,WAAAE,EACA,EACAJ,CACA,IAEA,SAAAM,EAAAI,CAAA,CAAAP,CAAA,CAAAC,CAAA,EACA,IAAAO,EAAiBvC,EAAS,QAE1B,GAAAuC,EAIA,OADAP,EAAAQ,QAAAT,GACAQ,CAAA,CAAAD,EAAA,CAAAG,MAAAF,EAAAtB,EAAA,GAAAd,EAAA6B,GAAA,IACA,CC7EArF,CAFAA,EAkBCA,GAAAA,CAAAA,EAAA,IAhBD,CAAAA,EAAA,eAEAA,CAAA,CAAAA,EAAA,kBAEAA,CAAA,CAAAA,EAAA,gBAEAA,CAAA,CAAAA,EAAA,gBAEAA,CAAA,CAAAA,EAAA,kBAKAA,CAAA,CAAAA,EAAA,sBAEAA,CAAA,CAAAA,EAAA,gBEvBA,IAAI+F,EAAsB,SAAAtC,CAAA,CAAAC,CAAA,EAC1B,IAAAC,EAAA,mBAAAvB,QAAAqB,CAAA,CAAArB,OAAAwB,SAAA,CACA,IAAAD,EAAA,OAAAF,EACA,IAAAI,EAAAC,EAAAC,EAAAJ,EAAAK,KAAAP,GAAAQ,EAAA,GACA,IACA,MAAAP,KAAA,IAAAA,GAAAA,KAAA,MAAAG,EAAAE,EAAAG,MAAA,EAAAC,MAAAF,EAAAG,KAAAP,EAAAQ,MACA,CACA,MAAApB,EAAA,CAAoBa,EAAA,CAAMb,MAAAA,CAAA,SAC1B,CACA,IACAY,GAAA,CAAAA,EAAAM,MAAAR,CAAAA,EAAAI,EAAA,SAAAJ,EAAAK,KAAAD,EACA,QACA,CAAkB,GAAAD,EAAA,MAAAA,EAAAb,KAAA,CAClB,CACA,OAAAgB,CACA,EACI+B,EAA6B,SAAAzB,CAAA,CAAAC,CAAA,CAAAC,CAAA,EACjC,GAAAA,GAAAC,GAAAA,UAAAC,OAAA,QAAAV,EAAAF,EAAA,EAAAa,EAAAJ,EAAAG,OAA6EZ,EAAAa,EAAOb,KACpFE,GAAAF,KAAAS,IACAP,GAAAA,CAAAA,EAAAY,MAAAC,UAAAC,MAAAf,KAAAQ,EAAA,EAAAT,EAAA,EACAE,CAAA,CAAAF,EAAA,CAAAS,CAAA,CAAAT,EAAA,EAGA,OAAAQ,EAAAS,OAAAf,GAAAY,MAAAC,UAAAC,MAAAf,KAAAQ,GACA,EAUAyB,EAAA,WAKA,SAAAA,IACA,SAAAC,EAAAP,CAAA,EACA,kBAEA,QADAN,EAAA,GACAC,EAAA,EAAiCA,EAAAZ,UAAAC,OAAuBW,IACxDD,CAAA,CAAAC,EAAA,CAAAZ,SAAA,CAAAY,EAAA,CAFA,IAIAM,EAA6BvC,EAAS,QAEtC,GAAAuC,EAEA,OAAAA,CAAA,CAAAD,EAAA,CAAAG,MAAAF,EAAsDI,EAAa,GAAKD,EAAMV,GAAA,IAC9E,CACA,CAEA,IAAA5E,EAAA,KA4BAA,EAAA0F,UA1BA,SAAAP,CAAA,CAAAQ,CAAA,EAGA,GADA,SAAAA,GAAgDA,CAAAA,EAAA,CAAsBC,SAAUrG,EAAAsG,IAAiB,GACjGV,IAAAnF,EAAA,CAIA,IANAmC,EAAAU,EAAAiD,EAMAvD,EAAA,4IAEA,OADAvC,EAAAwC,MAAA,OAAAL,CAAAA,EAAAI,EAAAE,KAAA,GAAAN,KAAA,IAAAA,EAAAA,EAAAI,EAAAG,SACA,EACA,CACA,iBAAAiD,GACAA,CAAAA,EAAA,CACAC,SAAAD,CACA,GAEA,IAAAI,EAA4BnD,EAAS,QACrCoD,EAA4BC,SDxErBC,CAAA,CAAAf,CAAA,EASP,SAAAgB,EAAAjB,CAAA,CAAAkB,CAAA,EACA,IAAAC,EAAAlB,CAAA,CAAAD,EAAA,OACA,mBAAAmB,GAAAH,GAAAE,EACAC,EAAAC,KAAAnB,GAEA,YACA,CACA,OAfAe,EAAmB3G,EAAAgH,KACnBL,EAAmB3G,EAAAgH,KAEnBL,EAAwB3G,EAAAiH,KACxBN,CAAAA,EAAmB3G,EAAAiH,GAAA,EAGnBrB,EAAAA,GAAA,GAQA,CACA3C,MAAA2D,EAAA,QAAoC5G,EAAAkH,OACpCzB,KAAAmB,EAAA,OAAkC5G,EAAAmH,MAClC3B,KAAAoB,EAAA,OAAkC5G,EAAAsG,MAClClD,MAAAwD,EAAA,QAAoC5G,EAAAoH,OACpC1B,QAAAkB,EAAA,UAAwC5G,EAAAqH,QACxC,CACA,ECiDoD,OAAA/D,CAAAA,EAAA8C,EAAAC,QAAA,GAAA/C,KAAA,IAAAA,EAAAA,EAAoEtD,EAAAsG,KAAiBV,GAEzI,GAAAY,GAAA,CAAAJ,EAAAkB,wBAAA,CACA,IAAApE,EAAA,OAAAqD,CAAAA,EAAA,QAAArD,KAAA,GAAAqD,KAAA,IAAAA,EAAAA,EAAA,kCACAC,EAAAf,KAAA,2CAAAvC,GACAuD,EAAAhB,KAAA,6DAAAvC,EACA,CACA,OAAmBX,EAAc,OAAAkE,EAAAhG,EAAA,GACjC,EAEAA,EAAA8G,QAAA,WACYhE,EAvDZ,OAuD4B9C,EAC5B,EACAA,EAAA+G,sBAAA,SAAAC,CAAA,EACA,WAAuBxC,EAAmBwC,EAC1C,EACAhH,EAAAiF,QAAAQ,EAAA,WACAzF,EAAA2C,MAAA8C,EAAA,SACAzF,EAAA+E,KAAAU,EAAA,QACAzF,EAAAgF,KAAAS,EAAA,QACAzF,EAAAwC,MAAAiD,EAAA,QACA,CAQA,OANAD,EAAAxD,SAAA,WAIA,OAHA,KAAAiF,WACA,MAAAA,UAAA,IAAAzB,CAAA,EAEA,KAAAyB,SACA,EACAzB,CACA,ICvGI0B,EAAsB,SAAAlE,CAAA,CAAAC,CAAA,EAC1B,IAAAC,EAAA,mBAAAvB,QAAAqB,CAAA,CAAArB,OAAAwB,SAAA,CACA,IAAAD,EAAA,OAAAF,EACA,IAAAI,EAAAC,EAAAC,EAAAJ,EAAAK,KAAAP,GAAAQ,EAAA,GACA,IACA,MAAAP,KAAA,IAAAA,GAAAA,KAAA,MAAAG,EAAAE,EAAAG,MAAA,EAAAC,MAAAF,EAAAG,KAAAP,EAAAQ,MACA,CACA,MAAApB,EAAA,CAAoBa,EAAA,CAAMb,MAAAA,CAAA,SAC1B,CACA,IACAY,GAAA,CAAAA,EAAAM,MAAAR,CAAAA,EAAAI,EAAA,SAAAJ,EAAAK,KAAAD,EACA,QACA,CAAkB,GAAAD,EAAA,MAAAA,EAAAb,KAAA,CAClB,CACA,OAAAgB,CACA,EACA2D,EAA4B,SAAAnE,CAAA,EAC5B,IAAAoE,EAAA,mBAAAzF,QAAAA,OAAAwB,SAAAD,EAAAkE,GAAApE,CAAA,CAAAoE,EAAA,CAAA9D,EAAA,EACA,GAAAJ,EAAA,OAAAA,EAAAK,KAAAP,GACA,GAAAA,GAAA,iBAAAA,EAAAkB,OAAA,OACAT,KAAA,WAEA,OADAT,GAAAM,GAAAN,EAAAkB,QAAAlB,CAAAA,EAAA,QACA,CAAqBY,MAAAZ,GAAAA,CAAA,CAAAM,IAAA,CAAAI,KAAA,CAAAV,CAAA,CACrB,CACA,CACA,iBAAAoE,EAAA,4DACA,EACAC,EAAA,WACA,SAAAA,EAAAC,CAAA,EACA,KAAAC,SAAAD,EAAA,IAAAE,IAAAF,GAAA,IAAAE,GACA,CAiDA,OAhDAH,EAAAhD,UAAAoD,SAAA,SAAAC,CAAA,EACA,IAAAC,EAAA,KAAAJ,SAAAK,IAAAF,GACA,GAAAC,EAGA,OAAAE,OAAAC,OAAA,GAA+BH,EAC/B,EACAN,EAAAhD,UAAA0D,cAAA,WACA,OAAA3D,MAAAL,KAAA,KAAAwD,SAAAD,WAAAU,IAAA,SAAA7F,CAAA,EACA,IAAAU,EAAqBqE,EAAM/E,EAAA,GAC3B,OAD2BU,CAAA,IAAAA,CAAA,IAC3B,EAEA,EACAwE,EAAAhD,UAAA4D,SAAA,SAAAP,CAAA,CAAAC,CAAA,EACA,IAAAO,EAAA,IAAAb,EAAA,KAAAE,UAEA,OADAW,EAAAX,SAAAY,IAAAT,EAAAC,GACAO,CACA,EACAb,EAAAhD,UAAA+D,YAAA,SAAAV,CAAA,EACA,IAAAQ,EAAA,IAAAb,EAAA,KAAAE,UAEA,OADAW,EAAAX,SAAAc,OAAAX,GACAQ,CACA,EACAb,EAAAhD,UAAAiE,cAAA,WAGA,QAFAC,EAAApG,EACAqG,EAAA,GACA3D,EAAA,EAAyBA,EAAAZ,UAAAC,OAAuBW,IAChD2D,CAAA,CAAA3D,EAAA,CAAAZ,SAAA,CAAAY,EAAA,CAFA,IAIAqD,EAAA,IAAAb,EAAA,KAAAE,UACA,IACA,QAAAkB,EAAAtB,EAAAqB,GAAAE,EAAAD,EAAAhF,OAAwE,CAAAiF,EAAAhF,KAAgBgF,EAAAD,EAAAhF,OAAA,CACxF,IAAAiE,EAAAgB,EAAA9E,MACAsE,EAAAX,SAAAc,OAAAX,EACA,CACA,CACA,MAAAiB,EAAA,CAAwBJ,EAAA,CAAQ/F,MAAAmG,CAAA,SAChC,CACA,IACAD,GAAA,CAAAA,EAAAhF,MAAAvB,CAAAA,EAAAsG,EAAAG,MAAA,GAAAzG,EAAAoB,KAAAkF,EACA,QACA,CAAsB,GAAAF,EAAA,MAAAA,EAAA/F,KAAA,CACtB,CACA,OAAA0F,CACA,EACAb,EAAAhD,UAAAwE,MAAA,WACA,WAAAxB,CACA,EACAA,CACA,IC7EOyB,EAAAnH,OAAA,wBCAPM,EAAWuD,EAAAxD,WAMJ,SAAA+G,EAAAzB,CAAA,EAEP,OADA,SAAAA,GAA8BA,CAAAA,EAAA,IAC9B,IAAeD,EAAW,IAAAG,IAAAK,OAAAP,QAAAA,IAC1B,CAOO,SAAA0B,EAAAC,CAAA,EAKP,MAJA,iBAAAA,IACAhH,EAAAO,MAAA,4DAAAyG,GACAA,EAAA,IAEA,CACAC,SAAkBJ,EAClBK,SAAA,WACA,OAAAF,CACA,CACA,CACA,CC7BO,SAAAG,EAAAC,CAAA,EAOP,OAAA1H,OAAAC,IAAAyH,EACA,CA0BO,IAAAC,EAAA,IAnBP,SAAAC,EAAAC,CAAA,EAEA,IAAAxJ,EAAA,KACAA,EAAAyJ,gBAAAD,EAAA,IAAAhC,IAAAgC,GAAA,IAAAhC,IACAxH,EAAA0J,SAAA,SAAAhC,CAAA,EAAyC,OAAA1H,EAAAyJ,gBAAA7B,IAAAF,EAAA,EACzC1H,EAAA2J,SAAA,SAAAjC,CAAA,CAAA9D,CAAA,EACA,IAAAgG,EAAA,IAAAL,EAAAvJ,EAAAyJ,iBAEA,OADAG,EAAAH,gBAAAtB,IAAAT,EAAA9D,GACAgG,CACA,EACA5J,EAAA6J,YAAA,SAAAnC,CAAA,EACA,IAAAkC,EAAA,IAAAL,EAAAvJ,EAAAyJ,iBAEA,OADAG,EAAAH,gBAAApB,OAAAX,GACAkC,CACA,CACA,EC/BAE,EAAA,CACA,CAAM7G,EAAA,QAAA8G,EAAA,SACN,CAAM9G,EAAA,OAAA8G,EAAA,QACN,CAAM9G,EAAA,OAAA8G,EAAA,QACN,CAAM9G,EAAA,QAAA8G,EAAA,SACN,CAAM9G,EAAA,UAAA8G,EAAA,SACN,CAMAC,EACA,WAuBA,QAAA1G,EAAA,EAAwBA,EAAAwG,EAAA5F,OAAuBZ,IAC/C,KAAAwG,CAAA,CAAAxG,EAAA,CAAAL,EAAA,CAAAgH,SAvBA/E,CAAA,EACA,kBAEA,QADAN,EAAA,GACAC,EAAA,EAAiCA,EAAAZ,UAAAC,OAAuBW,IACxDD,CAAA,CAAAC,EAAA,CAAAZ,SAAA,CAAAY,EAAA,CAEA,GAAAqF,QAAA,CAGA,IAAA7D,EAAA6D,OAAA,CAAAhF,EAAA,CAOA,GANA,mBAAAmB,GAGAA,CAAAA,EAAA6D,QAAAC,GAAA,EAGA,mBAAA9D,EACA,OAAAA,EAAAhB,MAAA6E,QAAAtF,EAEA,CACA,CACA,EAEAkF,CAAA,CAAAxG,EAAA,CAAAyG,EAEA,ECvCAK,GACA5K,EAAA,SAAA6K,CAAA,CAAAC,CAAA,EAIA,MAAA9K,CAHAA,EAAAqI,OAAA0C,gBACA,EAAeC,UAAA,eAAgBpG,OAAA,SAAAiG,CAAA,CAAAC,CAAA,EAAsCD,EAAAG,UAAAF,CAAA,GACrE,SAAAD,CAAA,CAAAC,CAAA,EAA8B,QAAAG,KAAAH,EAAAzC,OAAAxD,UAAAqG,eAAAnH,KAAA+G,EAAAG,IAAAJ,CAAAA,CAAA,CAAAI,EAAA,CAAAH,CAAA,CAAAG,EAAA,IAC9BJ,EAAAC,EACA,EACA,SAAAD,CAAA,CAAAC,CAAA,EACA,sBAAAA,GAAAA,OAAAA,EACA,uCAAAK,OAAAL,GAAA,iCAEA,SAAAM,IAAwB,KAAAC,YAAAR,CAAA,CADxB7K,EAAA6K,EAAAC,GAEAD,EAAAhG,UAAAiG,OAAAA,EAAAzC,OAAAiD,OAAAR,GAAAM,CAAAA,EAAAvG,UAAAiG,EAAAjG,UAAA,IAAAuG,CAAA,CACA,GAMAG,EAAA,WACA,SAAAA,IACA,CA6CA,OAzCAA,EAAA1G,UAAA2G,gBAAA,SAAAC,CAAA,CAAAC,CAAA,EACA,OAAAC,EACA,EAIAJ,EAAA1G,UAAA+G,cAAA,SAAAH,CAAA,CAAAC,CAAA,EACA,OAAAG,CACA,EAIAN,EAAA1G,UAAAiH,oBAAA,SAAAL,CAAA,CAAAC,CAAA,EACA,OAAAK,EACA,EAIAR,EAAA1G,UAAAmH,sBAAA,SAAAP,CAAA,CAAAC,CAAA,EACA,OAAAO,EACA,EAIAV,EAAA1G,UAAAqH,wBAAA,SAAAT,CAAA,CAAAC,CAAA,EACA,OAAAS,EACA,EAIAZ,EAAA1G,UAAAuH,8BAAA,SAAAX,CAAA,CAAAC,CAAA,EACA,OAAAW,EACA,EAIAd,EAAA1G,UAAAyH,2BAAA,SAAAC,CAAA,CAAAC,CAAA,IAIAjB,EAAA1G,UAAA4H,8BAAA,SAAAF,CAAA,IACAhB,CACA,IAEAmB,EACA,WACA,EAIAC,EAAA,SAAAC,CAAA,EAEA,SAAAD,IACA,OAAAC,OAAAA,GAAAA,EAAA/G,MAAA,KAAApB,YAAA,KAGA,OALAmG,EAAA+B,EAAAC,GAIAD,EAAA9H,UAAA/C,IAAA,SAAA+K,CAAA,CAAAC,CAAA,IACAH,CACA,EAACD,GAEDK,EAAA,SAAAH,CAAA,EAEA,SAAAG,IACA,OAAAH,OAAAA,GAAAA,EAAA/G,MAAA,KAAApB,YAAA,KAGA,OALAmG,EAAAmC,EAAAH,GAIAG,EAAAlI,UAAA/C,IAAA,SAAA+K,CAAA,CAAAC,CAAA,IACAC,CACA,EAACL,GAEDM,EAAA,SAAAJ,CAAA,EAEA,SAAAI,IACA,OAAAJ,OAAAA,GAAAA,EAAA/G,MAAA,KAAApB,YAAA,KAGA,OALAmG,EAAAoC,EAAAJ,GAIAI,EAAAnI,UAAAoI,OAAA,SAAAJ,CAAA,CAAAC,CAAA,IACAE,CACA,EAACN,GAEDQ,EAAA,WACA,SAAAA,IACA,CAGA,OAFAA,EAAArI,UAAAsI,YAAA,SAAAZ,CAAA,IACAW,EAAArI,UAAAuI,eAAA,SAAAb,CAAA,IACAW,CACA,IAEAG,EAAA,SAAAT,CAAA,EAEA,SAAAS,IACA,OAAAT,OAAAA,GAAAA,EAAA/G,MAAA,KAAApB,YAAA,KAEA,OAJAmG,EAAAyC,EAAAT,GAIAS,CACA,EAACH,GAEDI,EAAA,SAAAV,CAAA,EAEA,SAAAU,IACA,OAAAV,OAAAA,GAAAA,EAAA/G,MAAA,KAAApB,YAAA,KAEA,OAJAmG,EAAA0C,EAAAV,GAIAU,CACA,EAACJ,GAEDK,EAAA,SAAAX,CAAA,EAEA,SAAAW,IACA,OAAAX,OAAAA,GAAAA,EAAA/G,MAAA,KAAApB,YAAA,KAEA,OAJAmG,EAAA2C,EAAAX,GAIAW,CACA,EAACL,GAEMM,EAAA,IAAAjC,EAEAM,EAAA,IAAAc,EACAhB,GAAA,IAAAqB,EACAjB,GAAA,IAAAgB,EAEAZ,GAAA,IAAAkB,EACApB,GAAA,IAAAqB,EACAjB,GAAA,IAAAkB,EAIA,SAAAE,KACP,OAAAD,CACA,CCjJAvN,CADAA,EAGCA,GAAAA,CAAAA,EAAA,IAFD,CAAAA,EAAA,aACAA,CAAA,CAAAA,EAAA,mBCJO,IAAAyN,GAAA,CACPtF,IAAA,SAAAuF,CAAA,CAAAzF,CAAA,EACA,GAAAyF,MAAAA,EAGA,OAAAA,CAAA,CAAAzF,EAAA,EAEAc,KAAA,SAAA2E,CAAA,SACA,MAAAA,EACA,GAEAtF,OAAAW,KAAA2E,EACA,CACA,EACOC,GAAA,CACPjF,IAAA,SAAAgF,CAAA,CAAAzF,CAAA,CAAA9D,CAAA,EACA,MAAAuJ,GAGAA,CAAAA,CAAA,CAAAzF,EAAA,CAAA9D,CAAA,CACA,CACA,ECrBIyJ,GAAsB,SAAArK,CAAA,CAAAC,CAAA,EAC1B,IAAAC,EAAA,mBAAAvB,QAAAqB,CAAA,CAAArB,OAAAwB,SAAA,CACA,IAAAD,EAAA,OAAAF,EACA,IAAAI,EAAAC,EAAAC,EAAAJ,EAAAK,KAAAP,GAAAQ,EAAA,GACA,IACA,MAAAP,KAAA,IAAAA,GAAAA,KAAA,MAAAG,EAAAE,EAAAG,MAAA,EAAAC,MAAAF,EAAAG,KAAAP,EAAAQ,MACA,CACA,MAAApB,EAAA,CAAoBa,EAAA,CAAMb,MAAAA,CAAA,SAC1B,CACA,IACAY,GAAA,CAAAA,EAAAM,MAAAR,CAAAA,EAAAI,EAAA,SAAAJ,EAAAK,KAAAD,EACA,QACA,CAAkB,GAAAD,EAAA,MAAAA,EAAAb,KAAA,CAClB,CACA,OAAAgB,CACA,EACI8J,GAA6B,SAAAxJ,CAAA,CAAAC,CAAA,CAAAC,CAAA,EACjC,GAAAA,GAAAC,GAAAA,UAAAC,OAAA,QAAAV,EAAAF,EAAA,EAAAa,EAAAJ,EAAAG,OAA6EZ,EAAAa,EAAOb,KACpFE,GAAAF,KAAAS,IACAP,GAAAA,CAAAA,EAAAY,MAAAC,UAAAC,MAAAf,KAAAQ,EAAA,EAAAT,EAAA,EACAE,CAAA,CAAAF,EAAA,CAAAS,CAAA,CAAAT,EAAA,EAGA,OAAAQ,EAAAS,OAAAf,GAAAY,MAAAC,UAAAC,MAAAf,KAAAQ,GACA,EAEAwJ,GAAA,WACA,SAAAA,IACA,CAoBA,OAnBAA,EAAAlJ,UAAAmJ,OAAA,WACA,OAAelE,CACf,EACAiE,EAAAlJ,UAAAoJ,KAAA,SAAAC,CAAA,CAAAC,CAAA,CAAAC,CAAA,EAEA,QADAhJ,EAAA,GACAC,EAAA,EAAyBA,EAAAZ,UAAAC,OAAuBW,IAChDD,CAAA,CAAAC,EAAA,GAAAZ,SAAA,CAAAY,EAAA,CAEA,OAAA8I,EAAApK,KAAA8B,MAAAsI,EAAiCL,GAAa,CAAAM,EAAA,CAAYP,GAAMzI,GAAA,IAChE,EACA2I,EAAAlJ,UAAAiC,KAAA,SAAAoH,CAAA,CAAAG,CAAA,EACA,OAAAA,CACA,EACAN,EAAAlJ,UAAAyJ,OAAA,WACA,aAEAP,EAAAlJ,UAAAyC,QAAA,WACA,aAEAyG,CACA,ICjDIQ,GAAsB,SAAA/K,CAAA,CAAAC,CAAA,EAC1B,IAAAC,EAAA,mBAAAvB,QAAAqB,CAAA,CAAArB,OAAAwB,SAAA,CACA,IAAAD,EAAA,OAAAF,EACA,IAAAI,EAAAC,EAAAC,EAAAJ,EAAAK,KAAAP,GAAAQ,EAAA,GACA,IACA,MAAAP,KAAA,IAAAA,GAAAA,KAAA,MAAAG,EAAAE,EAAAG,MAAA,EAAAC,MAAAF,EAAAG,KAAAP,EAAAQ,MACA,CACA,MAAApB,EAAA,CAAoBa,EAAA,CAAMb,MAAAA,CAAA,SAC1B,CACA,IACAY,GAAA,CAAAA,EAAAM,MAAAR,CAAAA,EAAAI,EAAA,SAAAJ,EAAAK,KAAAD,EACA,QACA,CAAkB,GAAAD,EAAA,MAAAA,EAAAb,KAAA,CAClB,CACA,OAAAgB,CACA,EACIwK,GAA6B,SAAAlK,CAAA,CAAAC,CAAA,CAAAC,CAAA,EACjC,GAAAA,GAAAC,GAAAA,UAAAC,OAAA,QAAAV,EAAAF,EAAA,EAAAa,EAAAJ,EAAAG,OAA6EZ,EAAAa,EAAOb,KACpFE,GAAAF,KAAAS,IACAP,GAAAA,CAAAA,EAAAY,MAAAC,UAAAC,MAAAf,KAAAQ,EAAA,EAAAT,EAAA,EACAE,CAAA,CAAAF,EAAA,CAAAS,CAAA,CAAAT,EAAA,EAGA,OAAAQ,EAAAS,OAAAf,GAAAY,MAAAC,UAAAC,MAAAf,KAAAQ,GACA,EAIIkK,GAAQ,UACZC,GAAA,IAA+BX,GAI/BY,GAAA,WAEA,SAAAA,IACA,CAuDA,OArDAA,EAAAC,YAAA,WAIA,OAHA,KAAAnH,WACA,MAAAA,UAAA,IAAAkH,CAAA,EAEA,KAAAlH,SACA,EAMAkH,EAAA9J,UAAAgK,wBAAA,SAAAC,CAAA,EACA,OAAexM,EAAemM,GAAQK,EAAkB9I,EAAAxD,WACxD,EAIAmM,EAAA9J,UAAAmJ,OAAA,WACA,YAAAe,qBAAAf,QACA,EASAW,EAAA9J,UAAAoJ,KAAA,SAAA7D,CAAA,CAAA+D,CAAA,CAAAC,CAAA,EAGA,QAFAzL,EACAyC,EAAA,GACAC,EAAA,EAAyBA,EAAAZ,UAAAC,OAAuBW,IAChDD,CAAA,CAAAC,EAAA,GAAAZ,SAAA,CAAAY,EAAA,CAEA,OAAA1C,EAAA,KAAAoM,oBAAA,EAAAd,KAAApI,MAAAlD,EAA+D6L,GAAa,CAAApE,EAAA+D,EAAAC,EAAA,CAAyBG,GAAMnJ,GAAA,IAC3G,EAOAuJ,EAAA9J,UAAAiC,KAAA,SAAAsD,CAAA,CAAAiE,CAAA,EACA,YAAAU,qBAAAjI,KAAAsD,EAAAiE,EACA,EACAM,EAAA9J,UAAAkK,mBAAA,WACA,OAAe3L,EAAUqL,KAAQC,EACjC,EAEAC,EAAA9J,UAAAyC,QAAA,WACA,KAAAyH,qBAAAzH,UACQhE,EAAiBmL,GAAUzI,EAAAxD,WACnC,EACAmM,CACA,GCzFAzO,EAFAA,EAKCA,GAAAA,CAAAA,EAAA,IAHD,CAAAA,EAAA,eAEAA,CAAA,CAAAA,EAAA,qBCJO,IAAA8O,GAAA,mBACAC,GAAA,mCACAC,GAAA,CACPC,QAAAF,GACAG,OAAAJ,GACAK,WAAgBnP,EAAA6G,IAChB,ECDAuI,GAAA,WACA,SAAAA,EAAAC,CAAA,EACA,SAAAA,GAAuCA,CAAAA,EAAeL,EAAA,EACtD,KAAAK,aAAAA,CACA,CAiCA,OA/BAD,EAAAzK,UAAA2K,YAAA,WACA,YAAAD,YACA,EAEAD,EAAAzK,UAAA4K,aAAA,SAAAC,CAAA,CAAA7C,CAAA,EACA,aAGAyC,EAAAzK,UAAA8K,cAAA,SAAA7C,CAAA,EACA,aAGAwC,EAAAzK,UAAA+K,SAAA,SAAAnE,CAAA,CAAAqB,CAAA,EACA,aAGAwC,EAAAzK,UAAAgL,UAAA,SAAAC,CAAA,EACA,aAGAR,EAAAzK,UAAAkL,WAAA,SAAAtE,CAAA,EACA,aAGA6D,EAAAzK,UAAAmL,IAAA,SAAAC,CAAA,IAEAX,EAAAzK,UAAAqL,YAAA,WACA,QACA,EAEAZ,EAAAzK,UAAAsL,gBAAA,SAAAC,CAAA,CAAAC,CAAA,IACAf,CACA,ICtCAgB,GAAe1G,EAAgB,kCAMxB,SAAA2G,GAAAnG,CAAA,EACP,OAAAA,EAAAF,SAAAoG,KAAAE,KAAAA,CACA,CAIO,SAAAC,KACP,OAAAF,GAAmB5B,GAAAC,cAAsBZ,SACzC,CAOO,SAAA0C,GAAAtG,CAAA,CAAAuG,CAAA,EACP,OAAAvG,EAAAD,SAAAmG,GAAAK,EACA,CAMO,SAAAC,GAAAxG,CAAA,EACP,OAAAA,EAAAC,YAAAiG,GACA,CAQO,SAAAO,GAAAzG,CAAA,CAAAoF,CAAA,EACP,OAAAkB,GAAAtG,EAAA,IAAgCkF,GAAgBE,GAChD,CAMO,SAAAsB,GAAA1G,CAAA,EACP,IAAAzH,EACA,cAAAA,CAAAA,EAAA4N,GAAAnG,EAAA,GAAAzH,KAAA,IAAAA,EAAA,OAAAA,EAAA6M,aACA,CCtDA,IAAAuB,GAAA,oBACAC,GAAA,kBACO,SAAAC,GAAA9B,CAAA,EACP,OAAA4B,GAAAG,KAAA/B,IAAAA,IAA4DF,EAC5D,CACO,SAAAkC,GAAA/B,CAAA,EACP,OAAA4B,GAAAE,KAAA9B,IAAAA,IAAyDJ,EACzD,CAKO,SAAAoC,GAAA5B,CAAA,EACP,OAAAyB,GAAAzB,EAAAL,UAAAgC,GAAA3B,EAAAJ,OACA,CAOO,SAAAiC,GAAA7B,CAAA,EACP,WAAeF,GAAgBE,EAC/B,CCrBA,IAAA8B,GAAiB3C,GAAAC,cAIjB2C,GAAA,WACA,SAAAA,IACA,CAyCA,OAvCAA,EAAA1M,UAAA2M,UAAA,SAAAC,CAAA,CAAAjK,CAAA,CAAA4C,CAAA,EAGA,GAFA,SAAAA,GAAkCA,CAAAA,EAAAkH,GAAAtD,QAAA,EAClCxG,MAAAA,EAAA,OAAAA,EAAAkK,KAEA,WAAuBpC,GAEvB,IAAAqC,EAAAvH,GAA2C0G,GAAc1G,SACzD,UAoCA,OApCAuH,GAqCA,iBAAAnC,EAAA,QACA,iBAAAA,EAAA,SACA,iBAAAA,EAAA,YAtCY4B,GAAkBO,GAC9B,IAAuBrC,GAAgBqC,GAGvC,IAAuBrC,EAEvB,EACAiC,EAAA1M,UAAA+M,gBAAA,SAAAH,CAAA,CAAAI,CAAA,CAAAC,CAAA,CAAAC,CAAA,EAIA,IAAAtN,CAAAA,UAAAC,OAAA,IAGAD,GAAAA,UAAAC,OACAyJ,EAAA0D,EAEApN,GAAAA,UAAAC,QACAsN,EAAAH,EACA1D,EAAA2D,IAGAE,EAAAH,EACAI,EAAAH,EACA3D,EAAA4D,GAEA,IAlBAC,EACAC,EACA9D,EAgBAnE,EAAAiI,MAAAA,EAAAA,EAAAX,GAAAtD,SACA2C,EAAA,KAAAa,UAAAC,EAAAO,EAAAhI,GACAkI,EAAiCxB,GAAO1G,EAAA2G,GACxC,OAAAW,GAAArD,KAAAiE,EAAA/D,EAAAqC,KAAAA,EAAAG,GACA,EACAY,CACA,ICnDAY,GAAA,IAAsBZ,GAItBa,GAAA,WACA,SAAAA,EAAAC,CAAA,CAAAZ,CAAA,CAAA3O,CAAA,CAAA0E,CAAA,EACA,KAAA6K,UAAAA,EACA,KAAAZ,KAAAA,EACA,KAAA3O,QAAAA,EACA,KAAA0E,QAAAA,CACA,CAuBA,OAtBA4K,EAAAvN,UAAA2M,UAAA,SAAAC,CAAA,CAAAjK,CAAA,CAAA4C,CAAA,EACA,YAAAkI,aAAAd,UAAAC,EAAAjK,EAAA4C,EACA,EACAgI,EAAAvN,UAAA+M,gBAAA,SAAAnG,CAAA,CAAAC,CAAA,CAAAwC,CAAA,CAAAqE,CAAA,EACA,IAAAC,EAAA,KAAAF,aACA,OAAAG,QAAA5M,MAAA2M,EAAAZ,gBAAAY,EAAA/N,UACA,EAKA2N,EAAAvN,UAAAyN,WAAA,WACA,QAAAI,UACA,YAAAA,UAEA,IAAAF,EAAA,KAAAH,UAAAM,kBAAA,KAAAlB,KAAA,KAAA3O,QAAA,KAAA0E,gBACA,GAGA,KAAAkL,UAAAF,EACA,KAAAE,WAHAP,EAIA,EACAC,CACA,IEjCAQ,GAAA,GDKA,YACA,SAAAC,IACA,CAIA,OAHAA,EAAAhO,UAAAiO,UAAA,SAAArH,CAAA,CAAAsH,CAAA,CAAArH,CAAA,EACA,WAAmB6F,EACnB,EACAsB,CACA,GAAC,ECHDG,GAAA,WACA,SAAAA,IACA,CAsBA,OAlBAA,EAAAnO,UAAAiO,UAAA,SAAArB,CAAA,CAAA3O,CAAA,CAAA0E,CAAA,EACA,IAAA7E,EACA,cAAAA,CAAAA,EAAA,KAAAgQ,kBAAAlB,EAAA3O,EAAA0E,EAAA,GAAA7E,KAAA,IAAAA,EAAAA,EAAA,IAA2GyP,GAAW,KAAAX,EAAA3O,EAAA0E,EACtH,EACAwL,EAAAnO,UAAAoO,YAAA,WACA,IAAAtQ,EACA,cAAAA,CAAAA,EAAA,KAAA+P,SAAA,GAAA/P,KAAA,IAAAA,EAAAA,EAAAiQ,EACA,EAIAI,EAAAnO,UAAAqO,YAAA,SAAAC,CAAA,EACA,KAAAT,UAAAS,CACA,EACAH,EAAAnO,UAAA8N,kBAAA,SAAAlB,CAAA,CAAA3O,CAAA,CAAA0E,CAAA,EACA,IAAA7E,EACA,cAAAA,CAAAA,EAAA,KAAA+P,SAAA,GAAA/P,KAAA,IAAAA,EAAA,OAAAA,EAAAmQ,UAAArB,EAAA3O,EAAA0E,EACA,EACAwL,CACA,GCzBA7S,EALAA,EAgBCA,GAAAA,CAAAA,EAAA,IAXD,CAAAA,EAAA,2BAKAA,CAAA,CAAAA,EAAA,mBAKAA,CAAA,CAAAA,EAAA,2CClBAC,CAFAA,EAyBCA,GAAAA,CAAAA,EAAA,IAvBD,CAAAA,EAAA,uBAKAA,CAAA,CAAAA,EAAA,mBAKAA,CAAA,CAAAA,EAAA,mBAMAA,CAAA,CAAAA,EAAA,uBAMAA,CAAA,CAAAA,EAAA,uBChCAC,CAJAA,EAcCA,GAAAA,CAAAA,EAAA,IAVD,CAAAA,EAAA,iBAKAA,CAAA,CAAAA,EAAA,WAIAA,CAAA,CAAAA,EAAA,iBCFA,IAAA+S,GAAA,eAGAC,GAAA,mBAFAD,GAEA,WADA,YAAAA,EAAA,kBAAmEA,GACnE,YACAE,GAAA,sBACAC,GAAA,MCSAC,GAAA,WACA,SAAAA,EAAAC,CAAA,EACA,KAAAC,eAAA,IAAA1L,IACAyL,GACA,KAAAE,OAAAF,EACA,CAgEA,OA/DAD,EAAA3O,UAAA8D,IAAA,SAAAT,CAAA,CAAA9D,CAAA,EAGA,IAAAwP,EAAA,KAAAC,SAKA,OAJAD,EAAAF,eAAA3R,IAAAmG,IACA0L,EAAAF,eAAA7K,OAAAX,GAEA0L,EAAAF,eAAA/K,IAAAT,EAAA9D,GACAwP,CACA,EACAJ,EAAA3O,UAAAiP,MAAA,SAAA5L,CAAA,EACA,IAAA0L,EAAA,KAAAC,SAEA,OADAD,EAAAF,eAAA7K,OAAAX,GACA0L,CACA,EACAJ,EAAA3O,UAAAuD,IAAA,SAAAF,CAAA,EACA,YAAAwL,eAAAtL,IAAAF,EACA,EACAsL,EAAA3O,UAAAkP,UAAA,WACA,IAAAC,EAAA,KACA,YAAAC,QACAC,OAAA,SAAAC,CAAA,CAAAjM,CAAA,EAEA,OADAiM,EAAAhQ,KAAA+D,EAtCA,IAsCA8L,EAAA5L,IAAAF,IACAiM,CACA,EAAS,IACTC,KA1CA,IA2CA,EACAZ,EAAA3O,UAAA8O,OAAA,SAAAF,CAAA,GACAA,CAAAA,EAAA/O,OA9CA,GA8CA,IAEA,KAAAgP,eAAAD,EACApR,MAhDA,KAiDAgS,UACAH,OAAA,SAAAC,CAAA,CAAAG,CAAA,EACA,IAAAC,EAAAD,EAAAE,OACA1Q,EAAAyQ,EAAAE,QAnDA,KAoDA,GAAA3Q,KAAAA,EAAA,CACA,IAAAoE,EAAAqM,EAAAzP,MAAA,EAAAhB,GACAM,EAAAmQ,EAAAzP,MAAAhB,EAAA,EAAAwQ,EAAA5P,QD3CA2O,GAAAnC,KC4C+BhJ,IDrC/BoL,GAAApC,KCqCqD9M,IDpCrD,CAAAmP,GAAArC,KCoCqD9M,IACrD+P,EAAAxL,IAAAT,EAAA9D,EAKA,CACA,OAAA+P,CACA,EAAS,IAAAnM,KAET,KAAA0L,eAAAgB,KApEA,IAqEA,MAAAhB,eAAA,IAAA1L,IAAApD,MAAAL,KAAA,KAAAmP,eAAA5L,WACAuM,UACAvP,MAAA,EAvEA,IAuEA,EAEA,EACA0O,EAAA3O,UAAAoP,MAAA,WACA,OAAArP,MAAAL,KAAA,KAAAmP,eAAA1K,QAAAqL,SACA,EACAb,EAAA3O,UAAAgP,OAAA,WACA,IAAAD,EAAA,IAAAJ,EAEA,OADAI,EAAAF,eAAA,IAAA1L,IAAA,KAAA0L,gBACAE,CACA,EACAJ,CACA,ICnFO,SAAAmB,GAAAlB,CAAA,EACP,WAAeD,GAAcC,EAC7B,CCCO,IAAArJ,GAAcuE,GAAAC,cCKVgG,GAAO5O,EAAAxD,WCKXqS,GAAA,GATP,YACA,SAAAC,IACA,CAIA,OAHAA,EAAAjQ,UAAAkQ,SAAA,SAAAtJ,CAAA,CAAAsH,CAAA,CAAArH,CAAA,EACA,OAAe8B,CACf,EACAsH,CACA,GAAC,ECTGE,GAAQ,UCCLC,GAAcC,CDGrB,WAEA,SAAAA,IACA,CA+BA,OA7BAA,EAAAtG,YAAA,WAIA,OAHA,KAAAnH,WACA,MAAAA,UAAA,IAAAyN,CAAA,EAEA,KAAAzN,SACA,EAKAyN,EAAArQ,UAAAsQ,uBAAA,SAAAC,CAAA,EACA,OAAe9S,EAAe0S,GAAQI,EAAYpP,EAAAxD,WAClD,EAIA0S,EAAArQ,UAAAwQ,iBAAA,WACA,OAAejS,EAAU4R,KAAaH,EACtC,EAIAK,EAAArQ,UAAAkQ,SAAA,SAAAtD,CAAA,CAAA3O,CAAA,CAAA0E,CAAA,EACA,YAAA6N,mBAAAN,SAAAtD,EAAA3O,EAAA0E,EACA,EAEA0N,EAAArQ,UAAAyC,QAAA,WACQhE,EAAiB0R,GAAUhP,EAAAxD,WACnC,EACA0S,CACA,KCtCqBtG,cCDrB0G,GAAA,WACA,SAAAA,IACA,CAUA,OARAA,EAAAzQ,UAAA0Q,OAAA,SAAArH,CAAA,CAAAsH,CAAA,IAEAF,EAAAzQ,UAAA4Q,QAAA,SAAArL,CAAA,CAAAoL,CAAA,EACA,OAAApL,CACA,EACAkL,EAAAzQ,UAAA6Q,OAAA,WACA,UAEAJ,CACA,ICXAK,GAAkB/L,EAAgB,6BAO3B,SAAAgM,GAAAxL,CAAA,EACP,OAAAA,EAAAF,SAAAyL,KAAAnF,KAAAA,CACA,CAMO,SAAAqF,KACP,OAAAD,GAAsBjH,GAAAC,cAAsBZ,SAC5C,CAOO,SAAA8H,GAAA1L,CAAA,CAAA2L,CAAA,EACP,OAAA3L,EAAAD,SAAAwL,GAAAI,EACA,CAMO,SAAAC,GAAA5L,CAAA,EACP,OAAAA,EAAAC,YAAAsL,GACA,CCjCA,IAAIM,GAAQ,cACZC,GAAA,IAAmCZ,GCH5Ba,GAAkBC,CDOzB,WAEA,SAAAA,IACA,KAAA7M,cAA6BA,EAC7B,KAAAqM,WAA0BA,GAC1B,KAAAC,iBAAgCA,GAChC,KAAAC,WAA0BA,GAC1B,KAAAE,cAA6BA,EAC7B,CAmDA,OAjDAI,EAAAxH,YAAA,WAIA,OAHA,KAAAnH,WACA,MAAAA,UAAA,IAAA2O,CAAA,EAEA,KAAA3O,SACA,EAMA2O,EAAAvR,UAAAwR,oBAAA,SAAAC,CAAA,EACA,OAAehU,EAAe2T,GAAQK,EAActQ,EAAAxD,WACpD,EAQA4T,EAAAvR,UAAA0Q,OAAA,SAAAnL,CAAA,CAAAuD,CAAA,CAAA4I,CAAA,EAEA,OADA,SAAAA,GAAiCA,CAAAA,EAAS3I,EAAA,EAC1C,KAAA4I,uBAAAjB,OAAAnL,EAAAuD,EAAA4I,EACA,EAQAH,EAAAvR,UAAA4Q,QAAA,SAAArL,CAAA,CAAAuD,CAAA,CAAA8I,CAAA,EAEA,OADA,SAAAA,GAAiCA,CAAAA,EAAS/I,EAAA,EAC1C,KAAA8I,uBAAAf,QAAArL,EAAAuD,EAAA8I,EACA,EAIAL,EAAAvR,UAAA6Q,OAAA,WACA,YAAAc,uBAAAd,QACA,EAEAU,EAAAvR,UAAAyC,QAAA,WACQhE,EAAiB2S,GAAUjQ,EAAAxD,WACnC,EACA4T,EAAAvR,UAAA2R,qBAAA,WACA,OAAepT,EAAU6S,KAAQC,EACjC,EACAE,CACA,KCnEyBxH,cCCrB8H,GAAQ,QCDLC,GAAYC,CDKnB,WAEA,SAAAA,IACA,KAAAC,qBAAA,IAAwC7D,GACxC,KAAA3B,gBAA+BA,GAC/B,KAAAD,mBAAkCA,GAClC,KAAAR,WAA0BA,GAC1B,KAAAL,QAAuBA,GACvB,KAAAE,cAA6BA,GAC7B,KAAAK,eAA8BA,GAC9B,KAAAJ,QAAuBA,GACvB,KAAAG,eAA8BA,EAC9B,CAqCA,OAnCA+F,EAAAhI,YAAA,WAIA,OAHA,KAAAnH,WACA,MAAAA,UAAA,IAAAmP,CAAA,EAEA,KAAAnP,SACA,EAMAmP,EAAA/R,UAAAiS,wBAAA,SAAA1B,CAAA,EACA,IAAA2B,EAAsBzU,EAAeoU,GAAQ,KAAAG,qBAA6B7Q,EAAAxD,YAI1E,OAHAuU,GACA,KAAAF,qBAAA3D,YAAAkC,GAEA2B,CACA,EAIAH,EAAA/R,UAAAmS,kBAAA,WACA,OAAe5T,EAAUsT,KAAQ,KAAAG,oBACjC,EAIAD,EAAA/R,UAAAiO,UAAA,SAAArB,CAAA,CAAA3O,CAAA,EACA,YAAAkU,oBAAAlE,UAAArB,EAAA3O,EACA,EAEA8T,EAAA/R,UAAAyC,QAAA,WACQhE,EAAiBoT,GAAU1Q,EAAAxD,YACnC,KAAAqU,qBAAA,IAAwC7D,EACxC,EACA4D,CACA,KCvDmBhI,cC0BnBqI,GAAe,CACf7M,QAAaA,GACb3H,KAAUmS,GACVK,QAAaA,GACbkB,YAAiBA,GACjBQ,MAAWA,EACX","sources":["webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/platform/browser/globalThis.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/version.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/internal/semver.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/internal/global-utils.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/diag/types.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/api/diag.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/baggage/internal/symbol.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/baggage/utils.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/context/context.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/diag/consoleLogger.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/metrics/NoopMeter.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/metrics/Metric.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/api/context.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/context-utils.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/SamplingResult.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/span_kind.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/status.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-validators.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/internal/tracestate-impl.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace/internal/utils.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/context-api.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/diag-api.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/api/metrics.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/metrics-api.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/api/propagation.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/propagation-api.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/api/trace.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/trace-api.js","webpack://_N_E/./node_modules/@opentelemetry/api/build/esm/index.js","webpack://_N_E/<anon>"],"sourcesContent":["/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Updates to this file should also be replicated to @opentelemetry/core too.\n/**\n * - globalThis (New standard)\n * - self (Will return the current window instance for supported browsers)\n * - window (fallback for older browser implementations)\n * - global (NodeJS implementation)\n * - <object> (When all else fails)\n */\n/** only globals that common to node and browsers are allowed */\n// eslint-disable-next-line node/no-unsupported-features/es-builtins, no-undef\nexport var _globalThis = typeof globalThis === 'object'\n    ? globalThis\n    : typeof self === 'object'\n        ? self\n        : typeof window === 'object'\n            ? window\n            : typeof global === 'object'\n                ? global\n                : {};\n//# sourceMappingURL=globalThis.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// this is autogenerated file, see scripts/version-update.js\nexport var VERSION = '1.4.1';\n//# sourceMappingURL=version.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { VERSION } from '../version';\nvar re = /^(\\d+)\\.(\\d+)\\.(\\d+)(-(.+))?$/;\n/**\n * Create a function to test an API version to see if it is compatible with the provided ownVersion.\n *\n * The returned function has the following semantics:\n * - Exact match is always compatible\n * - Major versions must match exactly\n *    - 1.x package cannot use global 2.x package\n *    - 2.x package cannot use global 1.x package\n * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API\n *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects\n *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3\n * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor\n * - Patch and build tag differences are not considered at this time\n *\n * @param ownVersion version which should be checked against\n */\nexport function _makeCompatibilityCheck(ownVersion) {\n    var acceptedVersions = new Set([ownVersion]);\n    var rejectedVersions = new Set();\n    var myVersionMatch = ownVersion.match(re);\n    if (!myVersionMatch) {\n        // we cannot guarantee compatibility so we always return noop\n        return function () { return false; };\n    }\n    var ownVersionParsed = {\n        major: +myVersionMatch[1],\n        minor: +myVersionMatch[2],\n        patch: +myVersionMatch[3],\n        prerelease: myVersionMatch[4],\n    };\n    // if ownVersion has a prerelease tag, versions must match exactly\n    if (ownVersionParsed.prerelease != null) {\n        return function isExactmatch(globalVersion) {\n            return globalVersion === ownVersion;\n        };\n    }\n    function _reject(v) {\n        rejectedVersions.add(v);\n        return false;\n    }\n    function _accept(v) {\n        acceptedVersions.add(v);\n        return true;\n    }\n    return function isCompatible(globalVersion) {\n        if (acceptedVersions.has(globalVersion)) {\n            return true;\n        }\n        if (rejectedVersions.has(globalVersion)) {\n            return false;\n        }\n        var globalVersionMatch = globalVersion.match(re);\n        if (!globalVersionMatch) {\n            // cannot parse other version\n            // we cannot guarantee compatibility so we always noop\n            return _reject(globalVersion);\n        }\n        var globalVersionParsed = {\n            major: +globalVersionMatch[1],\n            minor: +globalVersionMatch[2],\n            patch: +globalVersionMatch[3],\n            prerelease: globalVersionMatch[4],\n        };\n        // if globalVersion has a prerelease tag, versions must match exactly\n        if (globalVersionParsed.prerelease != null) {\n            return _reject(globalVersion);\n        }\n        // major versions must match\n        if (ownVersionParsed.major !== globalVersionParsed.major) {\n            return _reject(globalVersion);\n        }\n        if (ownVersionParsed.major === 0) {\n            if (ownVersionParsed.minor === globalVersionParsed.minor &&\n                ownVersionParsed.patch <= globalVersionParsed.patch) {\n                return _accept(globalVersion);\n            }\n            return _reject(globalVersion);\n        }\n        if (ownVersionParsed.minor <= globalVersionParsed.minor) {\n            return _accept(globalVersion);\n        }\n        return _reject(globalVersion);\n    };\n}\n/**\n * Test an API version to see if it is compatible with this API.\n *\n * - Exact match is always compatible\n * - Major versions must match exactly\n *    - 1.x package cannot use global 2.x package\n *    - 2.x package cannot use global 1.x package\n * - The minor version of the API module requesting access to the global API must be less than or equal to the minor version of this API\n *    - 1.3 package may use 1.4 global because the later global contains all functions 1.3 expects\n *    - 1.4 package may NOT use 1.3 global because it may try to call functions which don't exist on 1.3\n * - If the major version is 0, the minor version is treated as the major and the patch is treated as the minor\n * - Patch and build tag differences are not considered at this time\n *\n * @param version version of the API requesting an instance of the global API\n */\nexport var isCompatible = _makeCompatibilityCheck(VERSION);\n//# sourceMappingURL=semver.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { _globalThis } from '../platform';\nimport { VERSION } from '../version';\nimport { isCompatible } from './semver';\nvar major = VERSION.split('.')[0];\nvar GLOBAL_OPENTELEMETRY_API_KEY = Symbol.for(\"opentelemetry.js.api.\" + major);\nvar _global = _globalThis;\nexport function registerGlobal(type, instance, diag, allowOverride) {\n    var _a;\n    if (allowOverride === void 0) { allowOverride = false; }\n    var api = (_global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a !== void 0 ? _a : {\n        version: VERSION,\n    });\n    if (!allowOverride && api[type]) {\n        // already registered an API of this type\n        var err = new Error(\"@opentelemetry/api: Attempted duplicate registration of API: \" + type);\n        diag.error(err.stack || err.message);\n        return false;\n    }\n    if (api.version !== VERSION) {\n        // All registered APIs must be of the same version exactly\n        var err = new Error(\"@opentelemetry/api: Registration of version v\" + api.version + \" for \" + type + \" does not match previously registered API v\" + VERSION);\n        diag.error(err.stack || err.message);\n        return false;\n    }\n    api[type] = instance;\n    diag.debug(\"@opentelemetry/api: Registered a global for \" + type + \" v\" + VERSION + \".\");\n    return true;\n}\nexport function getGlobal(type) {\n    var _a, _b;\n    var globalVersion = (_a = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a === void 0 ? void 0 : _a.version;\n    if (!globalVersion || !isCompatible(globalVersion)) {\n        return;\n    }\n    return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];\n}\nexport function unregisterGlobal(type, diag) {\n    diag.debug(\"@opentelemetry/api: Unregistering a global for \" + type + \" v\" + VERSION + \".\");\n    var api = _global[GLOBAL_OPENTELEMETRY_API_KEY];\n    if (api) {\n        delete api[type];\n    }\n}\n//# sourceMappingURL=global-utils.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { getGlobal } from '../internal/global-utils';\n/**\n * Component Logger which is meant to be used as part of any component which\n * will add automatically additional namespace in front of the log message.\n * It will then forward all message to global diag logger\n * @example\n * const cLogger = diag.createComponentLogger({ namespace: '@opentelemetry/instrumentation-http' });\n * cLogger.debug('test');\n * // @opentelemetry/instrumentation-http test\n */\nvar DiagComponentLogger = /** @class */ (function () {\n    function DiagComponentLogger(props) {\n        this._namespace = props.namespace || 'DiagComponentLogger';\n    }\n    DiagComponentLogger.prototype.debug = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return logProxy('debug', this._namespace, args);\n    };\n    DiagComponentLogger.prototype.error = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return logProxy('error', this._namespace, args);\n    };\n    DiagComponentLogger.prototype.info = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return logProxy('info', this._namespace, args);\n    };\n    DiagComponentLogger.prototype.warn = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return logProxy('warn', this._namespace, args);\n    };\n    DiagComponentLogger.prototype.verbose = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return logProxy('verbose', this._namespace, args);\n    };\n    return DiagComponentLogger;\n}());\nexport { DiagComponentLogger };\nfunction logProxy(funcName, namespace, args) {\n    var logger = getGlobal('diag');\n    // shortcut if logger not set\n    if (!logger) {\n        return;\n    }\n    args.unshift(namespace);\n    return logger[funcName].apply(logger, __spreadArray([], __read(args), false));\n}\n//# sourceMappingURL=ComponentLogger.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Defines the available internal logging levels for the diagnostic logger, the numeric values\n * of the levels are defined to match the original values from the initial LogLevel to avoid\n * compatibility/migration issues for any implementation that assume the numeric ordering.\n */\nexport var DiagLogLevel;\n(function (DiagLogLevel) {\n    /** Diagnostic Logging level setting to disable all logging (except and forced logs) */\n    DiagLogLevel[DiagLogLevel[\"NONE\"] = 0] = \"NONE\";\n    /** Identifies an error scenario */\n    DiagLogLevel[DiagLogLevel[\"ERROR\"] = 30] = \"ERROR\";\n    /** Identifies a warning scenario */\n    DiagLogLevel[DiagLogLevel[\"WARN\"] = 50] = \"WARN\";\n    /** General informational log message */\n    DiagLogLevel[DiagLogLevel[\"INFO\"] = 60] = \"INFO\";\n    /** General debug log message */\n    DiagLogLevel[DiagLogLevel[\"DEBUG\"] = 70] = \"DEBUG\";\n    /**\n     * Detailed trace level logging should only be used for development, should only be set\n     * in a development environment.\n     */\n    DiagLogLevel[DiagLogLevel[\"VERBOSE\"] = 80] = \"VERBOSE\";\n    /** Used to set the logging level to include all logging */\n    DiagLogLevel[DiagLogLevel[\"ALL\"] = 9999] = \"ALL\";\n})(DiagLogLevel || (DiagLogLevel = {}));\n//# sourceMappingURL=types.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { DiagLogLevel } from '../types';\nexport function createLogLevelDiagLogger(maxLevel, logger) {\n    if (maxLevel < DiagLogLevel.NONE) {\n        maxLevel = DiagLogLevel.NONE;\n    }\n    else if (maxLevel > DiagLogLevel.ALL) {\n        maxLevel = DiagLogLevel.ALL;\n    }\n    // In case the logger is null or undefined\n    logger = logger || {};\n    function _filterFunc(funcName, theLevel) {\n        var theFunc = logger[funcName];\n        if (typeof theFunc === 'function' && maxLevel >= theLevel) {\n            return theFunc.bind(logger);\n        }\n        return function () { };\n    }\n    return {\n        error: _filterFunc('error', DiagLogLevel.ERROR),\n        warn: _filterFunc('warn', DiagLogLevel.WARN),\n        info: _filterFunc('info', DiagLogLevel.INFO),\n        debug: _filterFunc('debug', DiagLogLevel.DEBUG),\n        verbose: _filterFunc('verbose', DiagLogLevel.VERBOSE),\n    };\n}\n//# sourceMappingURL=logLevelLogger.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { DiagComponentLogger } from '../diag/ComponentLogger';\nimport { createLogLevelDiagLogger } from '../diag/internal/logLevelLogger';\nimport { DiagLogLevel, } from '../diag/types';\nimport { getGlobal, registerGlobal, unregisterGlobal, } from '../internal/global-utils';\nvar API_NAME = 'diag';\n/**\n * Singleton object which represents the entry point to the OpenTelemetry internal\n * diagnostic API\n */\nvar DiagAPI = /** @class */ (function () {\n    /**\n     * Private internal constructor\n     * @private\n     */\n    function DiagAPI() {\n        function _logProxy(funcName) {\n            return function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                var logger = getGlobal('diag');\n                // shortcut if logger not set\n                if (!logger)\n                    return;\n                return logger[funcName].apply(logger, __spreadArray([], __read(args), false));\n            };\n        }\n        // Using self local variable for minification purposes as 'this' cannot be minified\n        var self = this;\n        // DiagAPI specific functions\n        var setLogger = function (logger, optionsOrLogLevel) {\n            var _a, _b, _c;\n            if (optionsOrLogLevel === void 0) { optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }; }\n            if (logger === self) {\n                // There isn't much we can do here.\n                // Logging to the console might break the user application.\n                // Try to log to self. If a logger was previously registered it will receive the log.\n                var err = new Error('Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation');\n                self.error((_a = err.stack) !== null && _a !== void 0 ? _a : err.message);\n                return false;\n            }\n            if (typeof optionsOrLogLevel === 'number') {\n                optionsOrLogLevel = {\n                    logLevel: optionsOrLogLevel,\n                };\n            }\n            var oldLogger = getGlobal('diag');\n            var newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);\n            // There already is an logger registered. We'll let it know before overwriting it.\n            if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {\n                var stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : '<failed to generate stacktrace>';\n                oldLogger.warn(\"Current logger will be overwritten from \" + stack);\n                newLogger.warn(\"Current logger will overwrite one already registered from \" + stack);\n            }\n            return registerGlobal('diag', newLogger, self, true);\n        };\n        self.setLogger = setLogger;\n        self.disable = function () {\n            unregisterGlobal(API_NAME, self);\n        };\n        self.createComponentLogger = function (options) {\n            return new DiagComponentLogger(options);\n        };\n        self.verbose = _logProxy('verbose');\n        self.debug = _logProxy('debug');\n        self.info = _logProxy('info');\n        self.warn = _logProxy('warn');\n        self.error = _logProxy('error');\n    }\n    /** Get the singleton instance of the DiagAPI API */\n    DiagAPI.instance = function () {\n        if (!this._instance) {\n            this._instance = new DiagAPI();\n        }\n        return this._instance;\n    };\n    return DiagAPI;\n}());\nexport { DiagAPI };\n//# sourceMappingURL=diag.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nvar BaggageImpl = /** @class */ (function () {\n    function BaggageImpl(entries) {\n        this._entries = entries ? new Map(entries) : new Map();\n    }\n    BaggageImpl.prototype.getEntry = function (key) {\n        var entry = this._entries.get(key);\n        if (!entry) {\n            return undefined;\n        }\n        return Object.assign({}, entry);\n    };\n    BaggageImpl.prototype.getAllEntries = function () {\n        return Array.from(this._entries.entries()).map(function (_a) {\n            var _b = __read(_a, 2), k = _b[0], v = _b[1];\n            return [k, v];\n        });\n    };\n    BaggageImpl.prototype.setEntry = function (key, entry) {\n        var newBaggage = new BaggageImpl(this._entries);\n        newBaggage._entries.set(key, entry);\n        return newBaggage;\n    };\n    BaggageImpl.prototype.removeEntry = function (key) {\n        var newBaggage = new BaggageImpl(this._entries);\n        newBaggage._entries.delete(key);\n        return newBaggage;\n    };\n    BaggageImpl.prototype.removeEntries = function () {\n        var e_1, _a;\n        var keys = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            keys[_i] = arguments[_i];\n        }\n        var newBaggage = new BaggageImpl(this._entries);\n        try {\n            for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {\n                var key = keys_1_1.value;\n                newBaggage._entries.delete(key);\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return newBaggage;\n    };\n    BaggageImpl.prototype.clear = function () {\n        return new BaggageImpl();\n    };\n    return BaggageImpl;\n}());\nexport { BaggageImpl };\n//# sourceMappingURL=baggage-impl.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Symbol used to make BaggageEntryMetadata an opaque type\n */\nexport var baggageEntryMetadataSymbol = Symbol('BaggageEntryMetadata');\n//# sourceMappingURL=symbol.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { DiagAPI } from '../api/diag';\nimport { BaggageImpl } from './internal/baggage-impl';\nimport { baggageEntryMetadataSymbol } from './internal/symbol';\nvar diag = DiagAPI.instance();\n/**\n * Create a new Baggage with optional entries\n *\n * @param entries An array of baggage entries the new baggage should contain\n */\nexport function createBaggage(entries) {\n    if (entries === void 0) { entries = {}; }\n    return new BaggageImpl(new Map(Object.entries(entries)));\n}\n/**\n * Create a serializable BaggageEntryMetadata object from a string.\n *\n * @param str string metadata. Format is currently not defined by the spec and has no special meaning.\n *\n */\nexport function baggageEntryMetadataFromString(str) {\n    if (typeof str !== 'string') {\n        diag.error(\"Cannot create baggage metadata from unknown type: \" + typeof str);\n        str = '';\n    }\n    return {\n        __TYPE__: baggageEntryMetadataSymbol,\n        toString: function () {\n            return str;\n        },\n    };\n}\n//# sourceMappingURL=utils.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/** Get a key to uniquely identify a context value */\nexport function createContextKey(description) {\n    // The specification states that for the same input, multiple calls should\n    // return different keys. Due to the nature of the JS dependency management\n    // system, this creates problems where multiple versions of some package\n    // could hold different keys for the same property.\n    //\n    // Therefore, we use Symbol.for which returns the same key for the same input.\n    return Symbol.for(description);\n}\nvar BaseContext = /** @class */ (function () {\n    /**\n     * Construct a new context which inherits values from an optional parent context.\n     *\n     * @param parentContext a context from which to inherit values\n     */\n    function BaseContext(parentContext) {\n        // for minification\n        var self = this;\n        self._currentContext = parentContext ? new Map(parentContext) : new Map();\n        self.getValue = function (key) { return self._currentContext.get(key); };\n        self.setValue = function (key, value) {\n            var context = new BaseContext(self._currentContext);\n            context._currentContext.set(key, value);\n            return context;\n        };\n        self.deleteValue = function (key) {\n            var context = new BaseContext(self._currentContext);\n            context._currentContext.delete(key);\n            return context;\n        };\n    }\n    return BaseContext;\n}());\n/** The root context is used as the default parent context when there is no active context */\nexport var ROOT_CONTEXT = new BaseContext();\n//# sourceMappingURL=context.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar consoleMap = [\n    { n: 'error', c: 'error' },\n    { n: 'warn', c: 'warn' },\n    { n: 'info', c: 'info' },\n    { n: 'debug', c: 'debug' },\n    { n: 'verbose', c: 'trace' },\n];\n/**\n * A simple Immutable Console based diagnostic logger which will output any messages to the Console.\n * If you want to limit the amount of logging to a specific level or lower use the\n * {@link createLogLevelDiagLogger}\n */\nvar DiagConsoleLogger = /** @class */ (function () {\n    function DiagConsoleLogger() {\n        function _consoleFunc(funcName) {\n            return function () {\n                var args = [];\n                for (var _i = 0; _i < arguments.length; _i++) {\n                    args[_i] = arguments[_i];\n                }\n                if (console) {\n                    // Some environments only expose the console when the F12 developer console is open\n                    // eslint-disable-next-line no-console\n                    var theFunc = console[funcName];\n                    if (typeof theFunc !== 'function') {\n                        // Not all environments support all functions\n                        // eslint-disable-next-line no-console\n                        theFunc = console.log;\n                    }\n                    // One last final check\n                    if (typeof theFunc === 'function') {\n                        return theFunc.apply(console, args);\n                    }\n                }\n            };\n        }\n        for (var i = 0; i < consoleMap.length; i++) {\n            this[consoleMap[i].n] = _consoleFunc(consoleMap[i].c);\n        }\n    }\n    return DiagConsoleLogger;\n}());\nexport { DiagConsoleLogger };\n//# sourceMappingURL=consoleLogger.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n/**\n * NoopMeter is a noop implementation of the {@link Meter} interface. It reuses\n * constant NoopMetrics for all of its methods.\n */\nvar NoopMeter = /** @class */ (function () {\n    function NoopMeter() {\n    }\n    /**\n     * @see {@link Meter.createHistogram}\n     */\n    NoopMeter.prototype.createHistogram = function (_name, _options) {\n        return NOOP_HISTOGRAM_METRIC;\n    };\n    /**\n     * @see {@link Meter.createCounter}\n     */\n    NoopMeter.prototype.createCounter = function (_name, _options) {\n        return NOOP_COUNTER_METRIC;\n    };\n    /**\n     * @see {@link Meter.createUpDownCounter}\n     */\n    NoopMeter.prototype.createUpDownCounter = function (_name, _options) {\n        return NOOP_UP_DOWN_COUNTER_METRIC;\n    };\n    /**\n     * @see {@link Meter.createObservableGauge}\n     */\n    NoopMeter.prototype.createObservableGauge = function (_name, _options) {\n        return NOOP_OBSERVABLE_GAUGE_METRIC;\n    };\n    /**\n     * @see {@link Meter.createObservableCounter}\n     */\n    NoopMeter.prototype.createObservableCounter = function (_name, _options) {\n        return NOOP_OBSERVABLE_COUNTER_METRIC;\n    };\n    /**\n     * @see {@link Meter.createObservableUpDownCounter}\n     */\n    NoopMeter.prototype.createObservableUpDownCounter = function (_name, _options) {\n        return NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC;\n    };\n    /**\n     * @see {@link Meter.addBatchObservableCallback}\n     */\n    NoopMeter.prototype.addBatchObservableCallback = function (_callback, _observables) { };\n    /**\n     * @see {@link Meter.removeBatchObservableCallback}\n     */\n    NoopMeter.prototype.removeBatchObservableCallback = function (_callback) { };\n    return NoopMeter;\n}());\nexport { NoopMeter };\nvar NoopMetric = /** @class */ (function () {\n    function NoopMetric() {\n    }\n    return NoopMetric;\n}());\nexport { NoopMetric };\nvar NoopCounterMetric = /** @class */ (function (_super) {\n    __extends(NoopCounterMetric, _super);\n    function NoopCounterMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    NoopCounterMetric.prototype.add = function (_value, _attributes) { };\n    return NoopCounterMetric;\n}(NoopMetric));\nexport { NoopCounterMetric };\nvar NoopUpDownCounterMetric = /** @class */ (function (_super) {\n    __extends(NoopUpDownCounterMetric, _super);\n    function NoopUpDownCounterMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    NoopUpDownCounterMetric.prototype.add = function (_value, _attributes) { };\n    return NoopUpDownCounterMetric;\n}(NoopMetric));\nexport { NoopUpDownCounterMetric };\nvar NoopHistogramMetric = /** @class */ (function (_super) {\n    __extends(NoopHistogramMetric, _super);\n    function NoopHistogramMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    NoopHistogramMetric.prototype.record = function (_value, _attributes) { };\n    return NoopHistogramMetric;\n}(NoopMetric));\nexport { NoopHistogramMetric };\nvar NoopObservableMetric = /** @class */ (function () {\n    function NoopObservableMetric() {\n    }\n    NoopObservableMetric.prototype.addCallback = function (_callback) { };\n    NoopObservableMetric.prototype.removeCallback = function (_callback) { };\n    return NoopObservableMetric;\n}());\nexport { NoopObservableMetric };\nvar NoopObservableCounterMetric = /** @class */ (function (_super) {\n    __extends(NoopObservableCounterMetric, _super);\n    function NoopObservableCounterMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return NoopObservableCounterMetric;\n}(NoopObservableMetric));\nexport { NoopObservableCounterMetric };\nvar NoopObservableGaugeMetric = /** @class */ (function (_super) {\n    __extends(NoopObservableGaugeMetric, _super);\n    function NoopObservableGaugeMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return NoopObservableGaugeMetric;\n}(NoopObservableMetric));\nexport { NoopObservableGaugeMetric };\nvar NoopObservableUpDownCounterMetric = /** @class */ (function (_super) {\n    __extends(NoopObservableUpDownCounterMetric, _super);\n    function NoopObservableUpDownCounterMetric() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    return NoopObservableUpDownCounterMetric;\n}(NoopObservableMetric));\nexport { NoopObservableUpDownCounterMetric };\nexport var NOOP_METER = new NoopMeter();\n// Synchronous instruments\nexport var NOOP_COUNTER_METRIC = new NoopCounterMetric();\nexport var NOOP_HISTOGRAM_METRIC = new NoopHistogramMetric();\nexport var NOOP_UP_DOWN_COUNTER_METRIC = new NoopUpDownCounterMetric();\n// Asynchronous instruments\nexport var NOOP_OBSERVABLE_COUNTER_METRIC = new NoopObservableCounterMetric();\nexport var NOOP_OBSERVABLE_GAUGE_METRIC = new NoopObservableGaugeMetric();\nexport var NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC = new NoopObservableUpDownCounterMetric();\n/**\n * Create a no-op Meter\n */\nexport function createNoopMeter() {\n    return NOOP_METER;\n}\n//# sourceMappingURL=NoopMeter.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/** The Type of value. It describes how the data is reported. */\nexport var ValueType;\n(function (ValueType) {\n    ValueType[ValueType[\"INT\"] = 0] = \"INT\";\n    ValueType[ValueType[\"DOUBLE\"] = 1] = \"DOUBLE\";\n})(ValueType || (ValueType = {}));\n//# sourceMappingURL=Metric.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport var defaultTextMapGetter = {\n    get: function (carrier, key) {\n        if (carrier == null) {\n            return undefined;\n        }\n        return carrier[key];\n    },\n    keys: function (carrier) {\n        if (carrier == null) {\n            return [];\n        }\n        return Object.keys(carrier);\n    },\n};\nexport var defaultTextMapSetter = {\n    set: function (carrier, key, value) {\n        if (carrier == null) {\n            return;\n        }\n        carrier[key] = value;\n    },\n};\n//# sourceMappingURL=TextMapPropagator.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { ROOT_CONTEXT } from './context';\nvar NoopContextManager = /** @class */ (function () {\n    function NoopContextManager() {\n    }\n    NoopContextManager.prototype.active = function () {\n        return ROOT_CONTEXT;\n    };\n    NoopContextManager.prototype.with = function (_context, fn, thisArg) {\n        var args = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            args[_i - 3] = arguments[_i];\n        }\n        return fn.call.apply(fn, __spreadArray([thisArg], __read(args), false));\n    };\n    NoopContextManager.prototype.bind = function (_context, target) {\n        return target;\n    };\n    NoopContextManager.prototype.enable = function () {\n        return this;\n    };\n    NoopContextManager.prototype.disable = function () {\n        return this;\n    };\n    return NoopContextManager;\n}());\nexport { NoopContextManager };\n//# sourceMappingURL=NoopContextManager.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nimport { NoopContextManager } from '../context/NoopContextManager';\nimport { getGlobal, registerGlobal, unregisterGlobal, } from '../internal/global-utils';\nimport { DiagAPI } from './diag';\nvar API_NAME = 'context';\nvar NOOP_CONTEXT_MANAGER = new NoopContextManager();\n/**\n * Singleton object which represents the entry point to the OpenTelemetry Context API\n */\nvar ContextAPI = /** @class */ (function () {\n    /** Empty private constructor prevents end users from constructing a new instance of the API */\n    function ContextAPI() {\n    }\n    /** Get the singleton instance of the Context API */\n    ContextAPI.getInstance = function () {\n        if (!this._instance) {\n            this._instance = new ContextAPI();\n        }\n        return this._instance;\n    };\n    /**\n     * Set the current context manager.\n     *\n     * @returns true if the context manager was successfully registered, else false\n     */\n    ContextAPI.prototype.setGlobalContextManager = function (contextManager) {\n        return registerGlobal(API_NAME, contextManager, DiagAPI.instance());\n    };\n    /**\n     * Get the currently active context\n     */\n    ContextAPI.prototype.active = function () {\n        return this._getContextManager().active();\n    };\n    /**\n     * Execute a function with an active context\n     *\n     * @param context context to be active during function execution\n     * @param fn function to execute in a context\n     * @param thisArg optional receiver to be used for calling fn\n     * @param args optional arguments forwarded to fn\n     */\n    ContextAPI.prototype.with = function (context, fn, thisArg) {\n        var _a;\n        var args = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            args[_i - 3] = arguments[_i];\n        }\n        return (_a = this._getContextManager()).with.apply(_a, __spreadArray([context, fn, thisArg], __read(args), false));\n    };\n    /**\n     * Bind a context to a target function or event emitter\n     *\n     * @param context context to bind to the event emitter or function. Defaults to the currently active context\n     * @param target function or event emitter to bind\n     */\n    ContextAPI.prototype.bind = function (context, target) {\n        return this._getContextManager().bind(context, target);\n    };\n    ContextAPI.prototype._getContextManager = function () {\n        return getGlobal(API_NAME) || NOOP_CONTEXT_MANAGER;\n    };\n    /** Disable and remove the global context manager */\n    ContextAPI.prototype.disable = function () {\n        this._getContextManager().disable();\n        unregisterGlobal(API_NAME, DiagAPI.instance());\n    };\n    return ContextAPI;\n}());\nexport { ContextAPI };\n//# sourceMappingURL=context.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport var TraceFlags;\n(function (TraceFlags) {\n    /** Represents no flag set. */\n    TraceFlags[TraceFlags[\"NONE\"] = 0] = \"NONE\";\n    /** Bit to represent whether trace is sampled in trace flags. */\n    TraceFlags[TraceFlags[\"SAMPLED\"] = 1] = \"SAMPLED\";\n})(TraceFlags || (TraceFlags = {}));\n//# sourceMappingURL=trace_flags.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { TraceFlags } from './trace_flags';\nexport var INVALID_SPANID = '0000000000000000';\nexport var INVALID_TRACEID = '00000000000000000000000000000000';\nexport var INVALID_SPAN_CONTEXT = {\n    traceId: INVALID_TRACEID,\n    spanId: INVALID_SPANID,\n    traceFlags: TraceFlags.NONE,\n};\n//# sourceMappingURL=invalid-span-constants.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { INVALID_SPAN_CONTEXT } from './invalid-span-constants';\n/**\n * The NonRecordingSpan is the default {@link Span} that is used when no Span\n * implementation is available. All operations are no-op including context\n * propagation.\n */\nvar NonRecordingSpan = /** @class */ (function () {\n    function NonRecordingSpan(_spanContext) {\n        if (_spanContext === void 0) { _spanContext = INVALID_SPAN_CONTEXT; }\n        this._spanContext = _spanContext;\n    }\n    // Returns a SpanContext.\n    NonRecordingSpan.prototype.spanContext = function () {\n        return this._spanContext;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.setAttribute = function (_key, _value) {\n        return this;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.setAttributes = function (_attributes) {\n        return this;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.addEvent = function (_name, _attributes) {\n        return this;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.setStatus = function (_status) {\n        return this;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.updateName = function (_name) {\n        return this;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.end = function (_endTime) { };\n    // isRecording always returns false for NonRecordingSpan.\n    NonRecordingSpan.prototype.isRecording = function () {\n        return false;\n    };\n    // By default does nothing\n    NonRecordingSpan.prototype.recordException = function (_exception, _time) { };\n    return NonRecordingSpan;\n}());\nexport { NonRecordingSpan };\n//# sourceMappingURL=NonRecordingSpan.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { createContextKey } from '../context/context';\nimport { NonRecordingSpan } from './NonRecordingSpan';\nimport { ContextAPI } from '../api/context';\n/**\n * span key\n */\nvar SPAN_KEY = createContextKey('OpenTelemetry Context Key SPAN');\n/**\n * Return the span if one exists\n *\n * @param context context to get span from\n */\nexport function getSpan(context) {\n    return context.getValue(SPAN_KEY) || undefined;\n}\n/**\n * Gets the span from the current context, if one exists.\n */\nexport function getActiveSpan() {\n    return getSpan(ContextAPI.getInstance().active());\n}\n/**\n * Set the span on a context\n *\n * @param context context to use as parent\n * @param span span to set active\n */\nexport function setSpan(context, span) {\n    return context.setValue(SPAN_KEY, span);\n}\n/**\n * Remove current span stored in the context\n *\n * @param context context to delete span from\n */\nexport function deleteSpan(context) {\n    return context.deleteValue(SPAN_KEY);\n}\n/**\n * Wrap span context in a NoopSpan and set as span in a new\n * context\n *\n * @param context context to set active span on\n * @param spanContext span context to be wrapped\n */\nexport function setSpanContext(context, spanContext) {\n    return setSpan(context, new NonRecordingSpan(spanContext));\n}\n/**\n * Get the span context of the span if it exists.\n *\n * @param context context to get values from\n */\nexport function getSpanContext(context) {\n    var _a;\n    return (_a = getSpan(context)) === null || _a === void 0 ? void 0 : _a.spanContext();\n}\n//# sourceMappingURL=context-utils.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { INVALID_SPANID, INVALID_TRACEID } from './invalid-span-constants';\nimport { NonRecordingSpan } from './NonRecordingSpan';\nvar VALID_TRACEID_REGEX = /^([0-9a-f]{32})$/i;\nvar VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i;\nexport function isValidTraceId(traceId) {\n    return VALID_TRACEID_REGEX.test(traceId) && traceId !== INVALID_TRACEID;\n}\nexport function isValidSpanId(spanId) {\n    return VALID_SPANID_REGEX.test(spanId) && spanId !== INVALID_SPANID;\n}\n/**\n * Returns true if this {@link SpanContext} is valid.\n * @return true if this {@link SpanContext} is valid.\n */\nexport function isSpanContextValid(spanContext) {\n    return (isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId));\n}\n/**\n * Wrap the given {@link SpanContext} in a new non-recording {@link Span}\n *\n * @param spanContext span context to be wrapped\n * @returns a new non-recording {@link Span} with the provided context\n */\nexport function wrapSpanContext(spanContext) {\n    return new NonRecordingSpan(spanContext);\n}\n//# sourceMappingURL=spancontext-utils.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ContextAPI } from '../api/context';\nimport { getSpanContext, setSpan } from '../trace/context-utils';\nimport { NonRecordingSpan } from './NonRecordingSpan';\nimport { isSpanContextValid } from './spancontext-utils';\nvar contextApi = ContextAPI.getInstance();\n/**\n * No-op implementations of {@link Tracer}.\n */\nvar NoopTracer = /** @class */ (function () {\n    function NoopTracer() {\n    }\n    // startSpan starts a noop span.\n    NoopTracer.prototype.startSpan = function (name, options, context) {\n        if (context === void 0) { context = contextApi.active(); }\n        var root = Boolean(options === null || options === void 0 ? void 0 : options.root);\n        if (root) {\n            return new NonRecordingSpan();\n        }\n        var parentFromContext = context && getSpanContext(context);\n        if (isSpanContext(parentFromContext) &&\n            isSpanContextValid(parentFromContext)) {\n            return new NonRecordingSpan(parentFromContext);\n        }\n        else {\n            return new NonRecordingSpan();\n        }\n    };\n    NoopTracer.prototype.startActiveSpan = function (name, arg2, arg3, arg4) {\n        var opts;\n        var ctx;\n        var fn;\n        if (arguments.length < 2) {\n            return;\n        }\n        else if (arguments.length === 2) {\n            fn = arg2;\n        }\n        else if (arguments.length === 3) {\n            opts = arg2;\n            fn = arg3;\n        }\n        else {\n            opts = arg2;\n            ctx = arg3;\n            fn = arg4;\n        }\n        var parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();\n        var span = this.startSpan(name, opts, parentContext);\n        var contextWithSpanSet = setSpan(parentContext, span);\n        return contextApi.with(contextWithSpanSet, fn, undefined, span);\n    };\n    return NoopTracer;\n}());\nexport { NoopTracer };\nfunction isSpanContext(spanContext) {\n    return (typeof spanContext === 'object' &&\n        typeof spanContext['spanId'] === 'string' &&\n        typeof spanContext['traceId'] === 'string' &&\n        typeof spanContext['traceFlags'] === 'number');\n}\n//# sourceMappingURL=NoopTracer.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { NoopTracer } from './NoopTracer';\nvar NOOP_TRACER = new NoopTracer();\n/**\n * Proxy tracer provided by the proxy tracer provider\n */\nvar ProxyTracer = /** @class */ (function () {\n    function ProxyTracer(_provider, name, version, options) {\n        this._provider = _provider;\n        this.name = name;\n        this.version = version;\n        this.options = options;\n    }\n    ProxyTracer.prototype.startSpan = function (name, options, context) {\n        return this._getTracer().startSpan(name, options, context);\n    };\n    ProxyTracer.prototype.startActiveSpan = function (_name, _options, _context, _fn) {\n        var tracer = this._getTracer();\n        return Reflect.apply(tracer.startActiveSpan, tracer, arguments);\n    };\n    /**\n     * Try to get a tracer from the proxy tracer provider.\n     * If the proxy tracer provider has no delegate, return a noop tracer.\n     */\n    ProxyTracer.prototype._getTracer = function () {\n        if (this._delegate) {\n            return this._delegate;\n        }\n        var tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);\n        if (!tracer) {\n            return NOOP_TRACER;\n        }\n        this._delegate = tracer;\n        return this._delegate;\n    };\n    return ProxyTracer;\n}());\nexport { ProxyTracer };\n//# sourceMappingURL=ProxyTracer.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { NoopTracer } from './NoopTracer';\n/**\n * An implementation of the {@link TracerProvider} which returns an impotent\n * Tracer for all calls to `getTracer`.\n *\n * All operations are no-op.\n */\nvar NoopTracerProvider = /** @class */ (function () {\n    function NoopTracerProvider() {\n    }\n    NoopTracerProvider.prototype.getTracer = function (_name, _version, _options) {\n        return new NoopTracer();\n    };\n    return NoopTracerProvider;\n}());\nexport { NoopTracerProvider };\n//# sourceMappingURL=NoopTracerProvider.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ProxyTracer } from './ProxyTracer';\nimport { NoopTracerProvider } from './NoopTracerProvider';\nvar NOOP_TRACER_PROVIDER = new NoopTracerProvider();\n/**\n * Tracer provider which provides {@link ProxyTracer}s.\n *\n * Before a delegate is set, tracers provided are NoOp.\n *   When a delegate is set, traces are provided from the delegate.\n *   When a delegate is set after tracers have already been provided,\n *   all tracers already provided will use the provided delegate implementation.\n */\nvar ProxyTracerProvider = /** @class */ (function () {\n    function ProxyTracerProvider() {\n    }\n    /**\n     * Get a {@link ProxyTracer}\n     */\n    ProxyTracerProvider.prototype.getTracer = function (name, version, options) {\n        var _a;\n        return ((_a = this.getDelegateTracer(name, version, options)) !== null && _a !== void 0 ? _a : new ProxyTracer(this, name, version, options));\n    };\n    ProxyTracerProvider.prototype.getDelegate = function () {\n        var _a;\n        return (_a = this._delegate) !== null && _a !== void 0 ? _a : NOOP_TRACER_PROVIDER;\n    };\n    /**\n     * Set the delegate tracer provider\n     */\n    ProxyTracerProvider.prototype.setDelegate = function (delegate) {\n        this._delegate = delegate;\n    };\n    ProxyTracerProvider.prototype.getDelegateTracer = function (name, version, options) {\n        var _a;\n        return (_a = this._delegate) === null || _a === void 0 ? void 0 : _a.getTracer(name, version, options);\n    };\n    return ProxyTracerProvider;\n}());\nexport { ProxyTracerProvider };\n//# sourceMappingURL=ProxyTracerProvider.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * @deprecated use the one declared in @opentelemetry/sdk-trace-base instead.\n * A sampling decision that determines how a {@link Span} will be recorded\n * and collected.\n */\nexport var SamplingDecision;\n(function (SamplingDecision) {\n    /**\n     * `Span.isRecording() === false`, span will not be recorded and all events\n     * and attributes will be dropped.\n     */\n    SamplingDecision[SamplingDecision[\"NOT_RECORD\"] = 0] = \"NOT_RECORD\";\n    /**\n     * `Span.isRecording() === true`, but `Sampled` flag in {@link TraceFlags}\n     * MUST NOT be set.\n     */\n    SamplingDecision[SamplingDecision[\"RECORD\"] = 1] = \"RECORD\";\n    /**\n     * `Span.isRecording() === true` AND `Sampled` flag in {@link TraceFlags}\n     * MUST be set.\n     */\n    SamplingDecision[SamplingDecision[\"RECORD_AND_SAMPLED\"] = 2] = \"RECORD_AND_SAMPLED\";\n})(SamplingDecision || (SamplingDecision = {}));\n//# sourceMappingURL=SamplingResult.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport var SpanKind;\n(function (SpanKind) {\n    /** Default value. Indicates that the span is used internally. */\n    SpanKind[SpanKind[\"INTERNAL\"] = 0] = \"INTERNAL\";\n    /**\n     * Indicates that the span covers server-side handling of an RPC or other\n     * remote request.\n     */\n    SpanKind[SpanKind[\"SERVER\"] = 1] = \"SERVER\";\n    /**\n     * Indicates that the span covers the client-side wrapper around an RPC or\n     * other remote request.\n     */\n    SpanKind[SpanKind[\"CLIENT\"] = 2] = \"CLIENT\";\n    /**\n     * Indicates that the span describes producer sending a message to a\n     * broker. Unlike client and server, there is no direct critical path latency\n     * relationship between producer and consumer spans.\n     */\n    SpanKind[SpanKind[\"PRODUCER\"] = 3] = \"PRODUCER\";\n    /**\n     * Indicates that the span describes consumer receiving a message from a\n     * broker. Unlike client and server, there is no direct critical path latency\n     * relationship between producer and consumer spans.\n     */\n    SpanKind[SpanKind[\"CONSUMER\"] = 4] = \"CONSUMER\";\n})(SpanKind || (SpanKind = {}));\n//# sourceMappingURL=span_kind.js.map","/**\n * An enumeration of status codes.\n */\nexport var SpanStatusCode;\n(function (SpanStatusCode) {\n    /**\n     * The default status.\n     */\n    SpanStatusCode[SpanStatusCode[\"UNSET\"] = 0] = \"UNSET\";\n    /**\n     * The operation has been validated by an Application developer or\n     * Operator to have completed successfully.\n     */\n    SpanStatusCode[SpanStatusCode[\"OK\"] = 1] = \"OK\";\n    /**\n     * The operation contains an error.\n     */\n    SpanStatusCode[SpanStatusCode[\"ERROR\"] = 2] = \"ERROR\";\n})(SpanStatusCode || (SpanStatusCode = {}));\n//# sourceMappingURL=status.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar VALID_KEY_CHAR_RANGE = '[_0-9a-z-*/]';\nvar VALID_KEY = \"[a-z]\" + VALID_KEY_CHAR_RANGE + \"{0,255}\";\nvar VALID_VENDOR_KEY = \"[a-z0-9]\" + VALID_KEY_CHAR_RANGE + \"{0,240}@[a-z]\" + VALID_KEY_CHAR_RANGE + \"{0,13}\";\nvar VALID_KEY_REGEX = new RegExp(\"^(?:\" + VALID_KEY + \"|\" + VALID_VENDOR_KEY + \")$\");\nvar VALID_VALUE_BASE_REGEX = /^[ -~]{0,255}[!-~]$/;\nvar INVALID_VALUE_COMMA_EQUAL_REGEX = /,|=/;\n/**\n * Key is opaque string up to 256 characters printable. It MUST begin with a\n * lowercase letter, and can only contain lowercase letters a-z, digits 0-9,\n * underscores _, dashes -, asterisks *, and forward slashes /.\n * For multi-tenant vendor scenarios, an at sign (@) can be used to prefix the\n * vendor name. Vendors SHOULD set the tenant ID at the beginning of the key.\n * see https://www.w3.org/TR/trace-context/#key\n */\nexport function validateKey(key) {\n    return VALID_KEY_REGEX.test(key);\n}\n/**\n * Value is opaque string up to 256 characters printable ASCII RFC0020\n * characters (i.e., the range 0x20 to 0x7E) except comma , and =.\n */\nexport function validateValue(value) {\n    return (VALID_VALUE_BASE_REGEX.test(value) &&\n        !INVALID_VALUE_COMMA_EQUAL_REGEX.test(value));\n}\n//# sourceMappingURL=tracestate-validators.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { validateKey, validateValue } from './tracestate-validators';\nvar MAX_TRACE_STATE_ITEMS = 32;\nvar MAX_TRACE_STATE_LEN = 512;\nvar LIST_MEMBERS_SEPARATOR = ',';\nvar LIST_MEMBER_KEY_VALUE_SPLITTER = '=';\n/**\n * TraceState must be a class and not a simple object type because of the spec\n * requirement (https://www.w3.org/TR/trace-context/#tracestate-field).\n *\n * Here is the list of allowed mutations:\n * - New key-value pair should be added into the beginning of the list\n * - The value of any key can be updated. Modified keys MUST be moved to the\n * beginning of the list.\n */\nvar TraceStateImpl = /** @class */ (function () {\n    function TraceStateImpl(rawTraceState) {\n        this._internalState = new Map();\n        if (rawTraceState)\n            this._parse(rawTraceState);\n    }\n    TraceStateImpl.prototype.set = function (key, value) {\n        // TODO: Benchmark the different approaches(map vs list) and\n        // use the faster one.\n        var traceState = this._clone();\n        if (traceState._internalState.has(key)) {\n            traceState._internalState.delete(key);\n        }\n        traceState._internalState.set(key, value);\n        return traceState;\n    };\n    TraceStateImpl.prototype.unset = function (key) {\n        var traceState = this._clone();\n        traceState._internalState.delete(key);\n        return traceState;\n    };\n    TraceStateImpl.prototype.get = function (key) {\n        return this._internalState.get(key);\n    };\n    TraceStateImpl.prototype.serialize = function () {\n        var _this = this;\n        return this._keys()\n            .reduce(function (agg, key) {\n            agg.push(key + LIST_MEMBER_KEY_VALUE_SPLITTER + _this.get(key));\n            return agg;\n        }, [])\n            .join(LIST_MEMBERS_SEPARATOR);\n    };\n    TraceStateImpl.prototype._parse = function (rawTraceState) {\n        if (rawTraceState.length > MAX_TRACE_STATE_LEN)\n            return;\n        this._internalState = rawTraceState\n            .split(LIST_MEMBERS_SEPARATOR)\n            .reverse() // Store in reverse so new keys (.set(...)) will be placed at the beginning\n            .reduce(function (agg, part) {\n            var listMember = part.trim(); // Optional Whitespace (OWS) handling\n            var i = listMember.indexOf(LIST_MEMBER_KEY_VALUE_SPLITTER);\n            if (i !== -1) {\n                var key = listMember.slice(0, i);\n                var value = listMember.slice(i + 1, part.length);\n                if (validateKey(key) && validateValue(value)) {\n                    agg.set(key, value);\n                }\n                else {\n                    // TODO: Consider to add warning log\n                }\n            }\n            return agg;\n        }, new Map());\n        // Because of the reverse() requirement, trunc must be done after map is created\n        if (this._internalState.size > MAX_TRACE_STATE_ITEMS) {\n            this._internalState = new Map(Array.from(this._internalState.entries())\n                .reverse() // Use reverse same as original tracestate parse chain\n                .slice(0, MAX_TRACE_STATE_ITEMS));\n        }\n    };\n    TraceStateImpl.prototype._keys = function () {\n        return Array.from(this._internalState.keys()).reverse();\n    };\n    TraceStateImpl.prototype._clone = function () {\n        var traceState = new TraceStateImpl();\n        traceState._internalState = new Map(this._internalState);\n        return traceState;\n    };\n    return TraceStateImpl;\n}());\nexport { TraceStateImpl };\n//# sourceMappingURL=tracestate-impl.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { TraceStateImpl } from './tracestate-impl';\nexport function createTraceState(rawTraceState) {\n    return new TraceStateImpl(rawTraceState);\n}\n//# sourceMappingURL=utils.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { ContextAPI } from './api/context';\n/** Entrypoint for context API */\nexport var context = ContextAPI.getInstance();\n//# sourceMappingURL=context-api.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { DiagAPI } from './api/diag';\n/**\n * Entrypoint for Diag API.\n * Defines Diagnostic handler used for internal diagnostic logging operations.\n * The default provides a Noop DiagLogger implementation which may be changed via the\n * diag.setLogger(logger: DiagLogger) function.\n */\nexport var diag = DiagAPI.instance();\n//# sourceMappingURL=diag-api.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { NOOP_METER } from './NoopMeter';\n/**\n * An implementation of the {@link MeterProvider} which returns an impotent Meter\n * for all calls to `getMeter`\n */\nvar NoopMeterProvider = /** @class */ (function () {\n    function NoopMeterProvider() {\n    }\n    NoopMeterProvider.prototype.getMeter = function (_name, _version, _options) {\n        return NOOP_METER;\n    };\n    return NoopMeterProvider;\n}());\nexport { NoopMeterProvider };\nexport var NOOP_METER_PROVIDER = new NoopMeterProvider();\n//# sourceMappingURL=NoopMeterProvider.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { NOOP_METER_PROVIDER } from '../metrics/NoopMeterProvider';\nimport { getGlobal, registerGlobal, unregisterGlobal, } from '../internal/global-utils';\nimport { DiagAPI } from './diag';\nvar API_NAME = 'metrics';\n/**\n * Singleton object which represents the entry point to the OpenTelemetry Metrics API\n */\nvar MetricsAPI = /** @class */ (function () {\n    /** Empty private constructor prevents end users from constructing a new instance of the API */\n    function MetricsAPI() {\n    }\n    /** Get the singleton instance of the Metrics API */\n    MetricsAPI.getInstance = function () {\n        if (!this._instance) {\n            this._instance = new MetricsAPI();\n        }\n        return this._instance;\n    };\n    /**\n     * Set the current global meter provider.\n     * Returns true if the meter provider was successfully registered, else false.\n     */\n    MetricsAPI.prototype.setGlobalMeterProvider = function (provider) {\n        return registerGlobal(API_NAME, provider, DiagAPI.instance());\n    };\n    /**\n     * Returns the global meter provider.\n     */\n    MetricsAPI.prototype.getMeterProvider = function () {\n        return getGlobal(API_NAME) || NOOP_METER_PROVIDER;\n    };\n    /**\n     * Returns a meter from the global meter provider.\n     */\n    MetricsAPI.prototype.getMeter = function (name, version, options) {\n        return this.getMeterProvider().getMeter(name, version, options);\n    };\n    /** Remove the global meter provider */\n    MetricsAPI.prototype.disable = function () {\n        unregisterGlobal(API_NAME, DiagAPI.instance());\n    };\n    return MetricsAPI;\n}());\nexport { MetricsAPI };\n//# sourceMappingURL=metrics.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { MetricsAPI } from './api/metrics';\n/** Entrypoint for metrics API */\nexport var metrics = MetricsAPI.getInstance();\n//# sourceMappingURL=metrics-api.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * No-op implementations of {@link TextMapPropagator}.\n */\nvar NoopTextMapPropagator = /** @class */ (function () {\n    function NoopTextMapPropagator() {\n    }\n    /** Noop inject function does nothing */\n    NoopTextMapPropagator.prototype.inject = function (_context, _carrier) { };\n    /** Noop extract function does nothing and returns the input context */\n    NoopTextMapPropagator.prototype.extract = function (context, _carrier) {\n        return context;\n    };\n    NoopTextMapPropagator.prototype.fields = function () {\n        return [];\n    };\n    return NoopTextMapPropagator;\n}());\nexport { NoopTextMapPropagator };\n//# sourceMappingURL=NoopTextMapPropagator.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ContextAPI } from '../api/context';\nimport { createContextKey } from '../context/context';\n/**\n * Baggage key\n */\nvar BAGGAGE_KEY = createContextKey('OpenTelemetry Baggage Key');\n/**\n * Retrieve the current baggage from the given context\n *\n * @param {Context} Context that manage all context values\n * @returns {Baggage} Extracted baggage from the context\n */\nexport function getBaggage(context) {\n    return context.getValue(BAGGAGE_KEY) || undefined;\n}\n/**\n * Retrieve the current baggage from the active/current context\n *\n * @returns {Baggage} Extracted baggage from the context\n */\nexport function getActiveBaggage() {\n    return getBaggage(ContextAPI.getInstance().active());\n}\n/**\n * Store a baggage in the given context\n *\n * @param {Context} Context that manage all context values\n * @param {Baggage} baggage that will be set in the actual context\n */\nexport function setBaggage(context, baggage) {\n    return context.setValue(BAGGAGE_KEY, baggage);\n}\n/**\n * Delete the baggage stored in the given context\n *\n * @param {Context} Context that manage all context values\n */\nexport function deleteBaggage(context) {\n    return context.deleteValue(BAGGAGE_KEY);\n}\n//# sourceMappingURL=context-helpers.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { getGlobal, registerGlobal, unregisterGlobal, } from '../internal/global-utils';\nimport { NoopTextMapPropagator } from '../propagation/NoopTextMapPropagator';\nimport { defaultTextMapGetter, defaultTextMapSetter, } from '../propagation/TextMapPropagator';\nimport { getBaggage, getActiveBaggage, setBaggage, deleteBaggage, } from '../baggage/context-helpers';\nimport { createBaggage } from '../baggage/utils';\nimport { DiagAPI } from './diag';\nvar API_NAME = 'propagation';\nvar NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();\n/**\n * Singleton object which represents the entry point to the OpenTelemetry Propagation API\n */\nvar PropagationAPI = /** @class */ (function () {\n    /** Empty private constructor prevents end users from constructing a new instance of the API */\n    function PropagationAPI() {\n        this.createBaggage = createBaggage;\n        this.getBaggage = getBaggage;\n        this.getActiveBaggage = getActiveBaggage;\n        this.setBaggage = setBaggage;\n        this.deleteBaggage = deleteBaggage;\n    }\n    /** Get the singleton instance of the Propagator API */\n    PropagationAPI.getInstance = function () {\n        if (!this._instance) {\n            this._instance = new PropagationAPI();\n        }\n        return this._instance;\n    };\n    /**\n     * Set the current propagator.\n     *\n     * @returns true if the propagator was successfully registered, else false\n     */\n    PropagationAPI.prototype.setGlobalPropagator = function (propagator) {\n        return registerGlobal(API_NAME, propagator, DiagAPI.instance());\n    };\n    /**\n     * Inject context into a carrier to be propagated inter-process\n     *\n     * @param context Context carrying tracing data to inject\n     * @param carrier carrier to inject context into\n     * @param setter Function used to set values on the carrier\n     */\n    PropagationAPI.prototype.inject = function (context, carrier, setter) {\n        if (setter === void 0) { setter = defaultTextMapSetter; }\n        return this._getGlobalPropagator().inject(context, carrier, setter);\n    };\n    /**\n     * Extract context from a carrier\n     *\n     * @param context Context which the newly created context will inherit from\n     * @param carrier Carrier to extract context from\n     * @param getter Function used to extract keys from a carrier\n     */\n    PropagationAPI.prototype.extract = function (context, carrier, getter) {\n        if (getter === void 0) { getter = defaultTextMapGetter; }\n        return this._getGlobalPropagator().extract(context, carrier, getter);\n    };\n    /**\n     * Return a list of all fields which may be used by the propagator.\n     */\n    PropagationAPI.prototype.fields = function () {\n        return this._getGlobalPropagator().fields();\n    };\n    /** Remove the global propagator */\n    PropagationAPI.prototype.disable = function () {\n        unregisterGlobal(API_NAME, DiagAPI.instance());\n    };\n    PropagationAPI.prototype._getGlobalPropagator = function () {\n        return getGlobal(API_NAME) || NOOP_TEXT_MAP_PROPAGATOR;\n    };\n    return PropagationAPI;\n}());\nexport { PropagationAPI };\n//# sourceMappingURL=propagation.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { PropagationAPI } from './api/propagation';\n/** Entrypoint for propagation API */\nexport var propagation = PropagationAPI.getInstance();\n//# sourceMappingURL=propagation-api.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { getGlobal, registerGlobal, unregisterGlobal, } from '../internal/global-utils';\nimport { ProxyTracerProvider } from '../trace/ProxyTracerProvider';\nimport { isSpanContextValid, wrapSpanContext, } from '../trace/spancontext-utils';\nimport { deleteSpan, getActiveSpan, getSpan, getSpanContext, setSpan, setSpanContext, } from '../trace/context-utils';\nimport { DiagAPI } from './diag';\nvar API_NAME = 'trace';\n/**\n * Singleton object which represents the entry point to the OpenTelemetry Tracing API\n */\nvar TraceAPI = /** @class */ (function () {\n    /** Empty private constructor prevents end users from constructing a new instance of the API */\n    function TraceAPI() {\n        this._proxyTracerProvider = new ProxyTracerProvider();\n        this.wrapSpanContext = wrapSpanContext;\n        this.isSpanContextValid = isSpanContextValid;\n        this.deleteSpan = deleteSpan;\n        this.getSpan = getSpan;\n        this.getActiveSpan = getActiveSpan;\n        this.getSpanContext = getSpanContext;\n        this.setSpan = setSpan;\n        this.setSpanContext = setSpanContext;\n    }\n    /** Get the singleton instance of the Trace API */\n    TraceAPI.getInstance = function () {\n        if (!this._instance) {\n            this._instance = new TraceAPI();\n        }\n        return this._instance;\n    };\n    /**\n     * Set the current global tracer.\n     *\n     * @returns true if the tracer provider was successfully registered, else false\n     */\n    TraceAPI.prototype.setGlobalTracerProvider = function (provider) {\n        var success = registerGlobal(API_NAME, this._proxyTracerProvider, DiagAPI.instance());\n        if (success) {\n            this._proxyTracerProvider.setDelegate(provider);\n        }\n        return success;\n    };\n    /**\n     * Returns the global tracer provider.\n     */\n    TraceAPI.prototype.getTracerProvider = function () {\n        return getGlobal(API_NAME) || this._proxyTracerProvider;\n    };\n    /**\n     * Returns a tracer from the global tracer provider.\n     */\n    TraceAPI.prototype.getTracer = function (name, version) {\n        return this.getTracerProvider().getTracer(name, version);\n    };\n    /** Remove the global tracer provider */\n    TraceAPI.prototype.disable = function () {\n        unregisterGlobal(API_NAME, DiagAPI.instance());\n        this._proxyTracerProvider = new ProxyTracerProvider();\n    };\n    return TraceAPI;\n}());\nexport { TraceAPI };\n//# sourceMappingURL=trace.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { TraceAPI } from './api/trace';\n/** Entrypoint for trace API */\nexport var trace = TraceAPI.getInstance();\n//# sourceMappingURL=trace-api.js.map","/*\n * Copyright The OpenTelemetry Authors\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport { baggageEntryMetadataFromString } from './baggage/utils';\n// Context APIs\nexport { createContextKey, ROOT_CONTEXT } from './context/context';\n// Diag APIs\nexport { DiagConsoleLogger } from './diag/consoleLogger';\nexport { DiagLogLevel, } from './diag/types';\n// Metrics APIs\nexport { createNoopMeter } from './metrics/NoopMeter';\nexport { ValueType, } from './metrics/Metric';\n// Propagation APIs\nexport { defaultTextMapGetter, defaultTextMapSetter, } from './propagation/TextMapPropagator';\nexport { ProxyTracer } from './trace/ProxyTracer';\nexport { ProxyTracerProvider } from './trace/ProxyTracerProvider';\nexport { SamplingDecision } from './trace/SamplingResult';\nexport { SpanKind } from './trace/span_kind';\nexport { SpanStatusCode } from './trace/status';\nexport { TraceFlags } from './trace/trace_flags';\nexport { createTraceState } from './trace/internal/utils';\nexport { isSpanContextValid, isValidTraceId, isValidSpanId, } from './trace/spancontext-utils';\nexport { INVALID_SPANID, INVALID_TRACEID, INVALID_SPAN_CONTEXT, } from './trace/invalid-span-constants';\n// Split module-level variable definition into separate files to allow\n// tree-shaking on each api instance.\nimport { context } from './context-api';\nimport { diag } from './diag-api';\nimport { metrics } from './metrics-api';\nimport { propagation } from './propagation-api';\nimport { trace } from './trace-api';\n// Named export.\nexport { context, diag, metrics, propagation, trace };\n// Default export.\nexport default {\n    context: context,\n    diag: diag,\n    metrics: metrics,\n    propagation: propagation,\n    trace: trace,\n};\n//# sourceMappingURL=index.js.map"],"names":["DiagLogLevel","extendStatics","ValueType","TraceFlags","SamplingDecision","SpanKind","SpanStatusCode","_globalThis","globalThis","self","window","__webpack_require__","g","VERSION","re","isCompatible","_makeCompatibilityCheck","ownVersion","acceptedVersions","Set","rejectedVersions","myVersionMatch","match","ownVersionParsed","major","minor","patch","prerelease","globalVersion","_reject","v","add","has","globalVersionMatch","globalVersionParsed","GLOBAL_OPENTELEMETRY_API_KEY","Symbol","for","split","registerGlobal","type","instance","diag","allowOverride","_a","api","_global","version","err","error","stack","message","debug","getGlobal","_b","unregisterGlobal","__read","o","n","m","iterator","r","e","i","call","ar","next","done","push","value","__spreadArray","to","from","pack","arguments","length","l","Array","prototype","slice","concat","DiagComponentLogger","props","_namespace","namespace","args","_i","logProxy","info","warn","verbose","funcName","logger","unshift","apply","diag_read","diag_spreadArray","DiagAPI","_logProxy","setLogger","optionsOrLogLevel","logLevel","INFO","_c","oldLogger","newLogger","createLogLevelDiagLogger","maxLevel","_filterFunc","theLevel","theFunc","bind","NONE","ALL","ERROR","WARN","DEBUG","VERBOSE","suppressOverrideMessage","disable","createComponentLogger","options","_instance","baggage_impl_read","__values","s","BaggageImpl","entries","_entries","Map","getEntry","key","entry","get","Object","assign","getAllEntries","map","setEntry","newBaggage","set","removeEntry","delete","removeEntries","e_1","keys","keys_1","keys_1_1","e_1_1","return","clear","baggageEntryMetadataSymbol","createBaggage","baggageEntryMetadataFromString","str","__TYPE__","toString","createContextKey","description","ROOT_CONTEXT","BaseContext","parentContext","_currentContext","getValue","setValue","context","deleteValue","consoleMap","c","DiagConsoleLogger","_consoleFunc","console","log","__extends","d","b","setPrototypeOf","__proto__","p","hasOwnProperty","String","__","constructor","create","NoopMeter","createHistogram","_name","_options","NOOP_HISTOGRAM_METRIC","createCounter","NOOP_COUNTER_METRIC","createUpDownCounter","NOOP_UP_DOWN_COUNTER_METRIC","createObservableGauge","NOOP_OBSERVABLE_GAUGE_METRIC","createObservableCounter","NOOP_OBSERVABLE_COUNTER_METRIC","createObservableUpDownCounter","NOOP_OBSERVABLE_UP_DOWN_COUNTER_METRIC","addBatchObservableCallback","_callback","_observables","removeBatchObservableCallback","NoopMetric","NoopCounterMetric","_super","_value","_attributes","NoopUpDownCounterMetric","NoopHistogramMetric","record","NoopObservableMetric","addCallback","removeCallback","NoopObservableCounterMetric","NoopObservableGaugeMetric","NoopObservableUpDownCounterMetric","NOOP_METER","createNoopMeter","defaultTextMapGetter","carrier","defaultTextMapSetter","NoopContextManager_read","NoopContextManager_spreadArray","NoopContextManager","active","with","_context","fn","thisArg","target","enable","context_read","context_spreadArray","context_API_NAME","NOOP_CONTEXT_MANAGER","ContextAPI","getInstance","setGlobalContextManager","contextManager","_getContextManager","INVALID_SPANID","INVALID_TRACEID","INVALID_SPAN_CONTEXT","traceId","spanId","traceFlags","NonRecordingSpan","_spanContext","spanContext","setAttribute","_key","setAttributes","addEvent","setStatus","_status","updateName","end","_endTime","isRecording","recordException","_exception","_time","SPAN_KEY","getSpan","undefined","getActiveSpan","setSpan","span","deleteSpan","setSpanContext","getSpanContext","VALID_TRACEID_REGEX","VALID_SPANID_REGEX","isValidTraceId","test","isValidSpanId","isSpanContextValid","wrapSpanContext","contextApi","NoopTracer","startSpan","name","root","parentFromContext","startActiveSpan","arg2","arg3","arg4","opts","ctx","contextWithSpanSet","NOOP_TRACER","ProxyTracer","_provider","_getTracer","_fn","tracer","Reflect","_delegate","getDelegateTracer","NOOP_TRACER_PROVIDER","NoopTracerProvider","getTracer","_version","ProxyTracerProvider","getDelegate","setDelegate","delegate","VALID_KEY_CHAR_RANGE","VALID_KEY_REGEX","VALID_VALUE_BASE_REGEX","INVALID_VALUE_COMMA_EQUAL_REGEX","TraceStateImpl","rawTraceState","_internalState","_parse","traceState","_clone","unset","serialize","_this","_keys","reduce","agg","join","reverse","part","listMember","trim","indexOf","size","createTraceState","diag_api_diag","NOOP_METER_PROVIDER","NoopMeterProvider","getMeter","metrics_API_NAME","metrics","MetricsAPI","setGlobalMeterProvider","provider","getMeterProvider","NoopTextMapPropagator","inject","_carrier","extract","fields","BAGGAGE_KEY","getBaggage","getActiveBaggage","setBaggage","baggage","deleteBaggage","propagation_API_NAME","NOOP_TEXT_MAP_PROPAGATOR","propagation","PropagationAPI","setGlobalPropagator","propagator","setter","_getGlobalPropagator","getter","trace_API_NAME","trace","TraceAPI","_proxyTracerProvider","setGlobalTracerProvider","success","getTracerProvider","esm"],"sourceRoot":""}