{"version":3,"file":"ketting.min.js","mappings":"CAAA,SAA2CA,EAAMC,GAC1B,iBAAZC,SAA0C,iBAAXC,OACxCA,OAAOD,QAAUD,IACQ,mBAAXG,QAAyBA,OAAOC,IAC9CD,OAAO,GAAIH,GACe,iBAAZC,QACdA,QAAiB,QAAID,IAErBD,EAAc,QAAIC,GACnB,CATD,CASGK,MAAM,WACT,O,+CCaA,IAOIC,EAPAC,EAAuB,iBAAZC,QAAuBA,QAAU,KAC5CC,EAAeF,GAAwB,mBAAZA,EAAEG,MAC7BH,EAAEG,MACF,SAAsBC,EAAQC,EAAUC,GACxC,OAAOC,SAASC,UAAUL,MAAMM,KAAKL,EAAQC,EAAUC,EACzD,EAIAP,EADEC,GAA0B,mBAAdA,EAAEU,QACCV,EAAEU,QACVC,OAAOC,sBACC,SAAwBR,GACvC,OAAOO,OAAOE,oBAAoBT,GAC/BU,OAAOH,OAAOC,sBAAsBR,GACzC,EAEiB,SAAwBA,GACvC,OAAOO,OAAOE,oBAAoBT,EACpC,EAOF,IAAIW,EAAcC,OAAOC,OAAS,SAAqBC,GACrD,OAAOA,GAAUA,CACnB,EAEA,SAASC,IACPA,EAAaC,KAAKX,KAAKY,KACzB,CACA1B,EAAOD,QAAUyB,EACjBxB,EAAOD,QAAQ4B,KAwYf,SAAcC,EAASC,GACrB,OAAO,IAAIC,SAAQ,SAAUC,EAASC,GACpC,SAASC,EAAcC,GACrBN,EAAQO,eAAeN,EAAMO,GAC7BJ,EAAOE,EACT,CAEA,SAASE,IAC+B,mBAA3BR,EAAQO,gBACjBP,EAAQO,eAAe,QAASF,GAElCF,EAAQ,GAAGM,MAAMvB,KAAKwB,WACxB,CAEAC,EAA+BX,EAASC,EAAMO,EAAU,CAAET,MAAM,IACnD,UAATE,GAMR,SAAuCD,EAASY,EAASC,GAC7B,mBAAfb,EAAQc,IACjBH,EAA+BX,EAAS,QAASY,EAPO,CAAEb,MAAM,GASpE,CATMgB,CAA8Bf,EAASK,EAE3C,GACF,EAxZAT,EAAaA,aAAeA,EAE5BA,EAAaX,UAAU+B,aAAUC,EACjCrB,EAAaX,UAAUiC,aAAe,EACtCtB,EAAaX,UAAUkC,mBAAgBF,EAIvC,IAAIG,EAAsB,GAE1B,SAASC,EAAcC,GACrB,GAAwB,mBAAbA,EACT,MAAM,IAAIC,UAAU,0EAA4ED,EAEpG,CAoCA,SAASE,EAAiBC,GACxB,YAA2BR,IAAvBQ,EAAKN,cACAvB,EAAawB,oBACfK,EAAKN,aACd,CAkDA,SAASO,EAAa7C,EAAQ8C,EAAML,EAAUM,GAC5C,IAAIC,EACAC,EACAC,EA1HsBC,EAgJ1B,GApBAX,EAAcC,QAGCL,KADfa,EAASjD,EAAOmC,UAEdc,EAASjD,EAAOmC,QAAU5B,OAAO6C,OAAO,MACxCpD,EAAOqC,aAAe,SAIKD,IAAvBa,EAAOI,cACTrD,EAAOsD,KAAK,cAAeR,EACfL,EAASA,SAAWA,EAASA,SAAWA,GAIpDQ,EAASjD,EAAOmC,SAElBe,EAAWD,EAAOH,SAGHV,IAAbc,EAEFA,EAAWD,EAAOH,GAAQL,IACxBzC,EAAOqC,kBAeT,GAbwB,mBAAba,EAETA,EAAWD,EAAOH,GAChBC,EAAU,CAACN,EAAUS,GAAY,CAACA,EAAUT,GAErCM,EACTG,EAASK,QAAQd,GAEjBS,EAASM,KAAKf,IAIhBO,EAAIL,EAAiB3C,IACb,GAAKkD,EAASO,OAAST,IAAME,EAASQ,OAAQ,CACpDR,EAASQ,QAAS,EAGlB,IAAIC,EAAI,IAAIC,MAAM,+CACEV,EAASO,OAAS,IAAMI,OAAOf,GADjC,qEAIlBa,EAAEvC,KAAO,8BACTuC,EAAExC,QAAUnB,EACZ2D,EAAEb,KAAOA,EACTa,EAAEG,MAAQZ,EAASO,OA7KGN,EA8KHQ,EA7KnBI,SAAWA,QAAQC,MAAMD,QAAQC,KAAKb,EA8KxC,CAGF,OAAOnD,CACT,CAaA,SAASiE,IACP,IAAKhD,KAAKiD,MAGR,OAFAjD,KAAKjB,OAAO0B,eAAeT,KAAK6B,KAAM7B,KAAKkD,QAC3ClD,KAAKiD,OAAQ,EACY,IAArBrC,UAAU4B,OACLxC,KAAKwB,SAASpC,KAAKY,KAAKjB,QAC1BiB,KAAKwB,SAAS1C,MAAMkB,KAAKjB,OAAQ6B,UAE5C,CAEA,SAASuC,EAAUpE,EAAQ8C,EAAML,GAC/B,IAAI4B,EAAQ,CAAEH,OAAO,EAAOC,YAAQ/B,EAAWpC,OAAQA,EAAQ8C,KAAMA,EAAML,SAAUA,GACjF6B,EAAUL,EAAYM,KAAKF,GAG/B,OAFAC,EAAQ7B,SAAWA,EACnB4B,EAAMF,OAASG,EACRA,CACT,CAyHA,SAASE,EAAWxE,EAAQ8C,EAAM2B,GAChC,IAAIxB,EAASjD,EAAOmC,QAEpB,QAAeC,IAAXa,EACF,MAAO,GAET,IAAIyB,EAAazB,EAAOH,GACxB,YAAmBV,IAAfsC,EACK,GAEiB,mBAAfA,EACFD,EAAS,CAACC,EAAWjC,UAAYiC,GAAc,CAACA,GAElDD,EAsDT,SAAyBE,GAEvB,IADA,IAAIC,EAAM,IAAIC,MAAMF,EAAIlB,QACfqB,EAAI,EAAGA,EAAIF,EAAInB,SAAUqB,EAChCF,EAAIE,GAAKH,EAAIG,GAAGrC,UAAYkC,EAAIG,GAElC,OAAOF,CACT,CA3DIG,CAAgBL,GAAcM,EAAWN,EAAYA,EAAWjB,OACpE,CAmBA,SAASwB,EAAcnC,GACrB,IAAIG,EAAShC,KAAKkB,QAElB,QAAeC,IAAXa,EAAsB,CACxB,IAAIyB,EAAazB,EAAOH,GAExB,GAA0B,mBAAf4B,EACT,OAAO,EACF,QAAmBtC,IAAfsC,EACT,OAAOA,EAAWjB,MAEtB,CAEA,OAAO,CACT,CAMA,SAASuB,EAAWL,EAAKO,GAEvB,IADA,IAAIC,EAAO,IAAIN,MAAMK,GACZJ,EAAI,EAAGA,EAAII,IAAKJ,EACvBK,EAAKL,GAAKH,EAAIG,GAChB,OAAOK,CACT,CA2CA,SAASrD,EAA+BX,EAASC,EAAMqB,EAAUT,GAC/D,GAA0B,mBAAfb,EAAQc,GACbD,EAAMd,KACRC,EAAQD,KAAKE,EAAMqB,GAEnBtB,EAAQc,GAAGb,EAAMqB,OAEd,IAAwC,mBAA7BtB,EAAQiE,iBAYxB,MAAM,IAAI1C,UAAU,6EAA+EvB,GATnGA,EAAQiE,iBAAiBhE,GAAM,SAASiE,EAAaC,GAG/CtD,EAAMd,MACRC,EAAQoE,oBAAoBnE,EAAMiE,GAEpC5C,EAAS6C,EACX,GAGF,CACF,CAraA/E,OAAOiF,eAAezE,EAAc,sBAAuB,CACzD0E,YAAY,EACZC,IAAK,WACH,OAAOnD,CACT,EACAoD,IAAK,SAASL,GACZ,GAAmB,iBAARA,GAAoBA,EAAM,GAAK3E,EAAY2E,GACpD,MAAM,IAAIM,WAAW,kGAAoGN,EAAM,KAEjI/C,EAAsB+C,CACxB,IAGFvE,EAAaC,KAAO,gBAEGoB,IAAjBnB,KAAKkB,SACLlB,KAAKkB,UAAY5B,OAAOsF,eAAe5E,MAAMkB,UAC/ClB,KAAKkB,QAAU5B,OAAO6C,OAAO,MAC7BnC,KAAKoB,aAAe,GAGtBpB,KAAKqB,cAAgBrB,KAAKqB,oBAAiBF,CAC7C,EAIArB,EAAaX,UAAU0F,gBAAkB,SAAyBZ,GAChE,GAAiB,iBAANA,GAAkBA,EAAI,GAAKvE,EAAYuE,GAChD,MAAM,IAAIU,WAAW,gFAAkFV,EAAI,KAG7G,OADAjE,KAAKqB,cAAgB4C,EACdjE,IACT,EAQAF,EAAaX,UAAU2F,gBAAkB,WACvC,OAAOpD,EAAiB1B,KAC1B,EAEAF,EAAaX,UAAUkD,KAAO,SAAcR,GAE1C,IADA,IAAI5C,EAAO,GACF4E,EAAI,EAAGA,EAAIjD,UAAU4B,OAAQqB,IAAK5E,EAAKsD,KAAK3B,UAAUiD,IAC/D,IAAIkB,EAAoB,UAATlD,EAEXG,EAAShC,KAAKkB,QAClB,QAAeC,IAAXa,EACF+C,EAAWA,QAA4B5D,IAAjBa,EAAOgD,WAC1B,IAAKD,EACR,OAAO,EAGT,GAAIA,EAAS,CACX,IAAIE,EAGJ,GAFIhG,EAAKuD,OAAS,IAChByC,EAAKhG,EAAK,IACRgG,aAActC,MAGhB,MAAMsC,EAGR,IAAIzE,EAAM,IAAImC,MAAM,oBAAsBsC,EAAK,KAAOA,EAAGC,QAAU,IAAM,KAEzE,MADA1E,EAAI2E,QAAUF,EACRzE,CACR,CAEA,IAAIM,EAAUkB,EAAOH,GAErB,QAAgBV,IAAZL,EACF,OAAO,EAET,GAAuB,mBAAZA,EACTjC,EAAaiC,EAASd,KAAMf,OAE5B,KAAImG,EAAMtE,EAAQ0B,OACd6C,EAAYtB,EAAWjD,EAASsE,GACpC,IAASvB,EAAI,EAAGA,EAAIuB,IAAOvB,EACzBhF,EAAawG,EAAUxB,GAAI7D,KAAMf,EAHX,CAM1B,OAAO,CACT,EAgEAa,EAAaX,UAAUmG,YAAc,SAAqBzD,EAAML,GAC9D,OAAOI,EAAa5B,KAAM6B,EAAML,GAAU,EAC5C,EAEA1B,EAAaX,UAAU6B,GAAKlB,EAAaX,UAAUmG,YAEnDxF,EAAaX,UAAUoG,gBACnB,SAAyB1D,EAAML,GAC7B,OAAOI,EAAa5B,KAAM6B,EAAML,GAAU,EAC5C,EAoBJ1B,EAAaX,UAAUc,KAAO,SAAc4B,EAAML,GAGhD,OAFAD,EAAcC,GACdxB,KAAKgB,GAAGa,EAAMsB,EAAUnD,KAAM6B,EAAML,IAC7BxB,IACT,EAEAF,EAAaX,UAAUqG,oBACnB,SAA6B3D,EAAML,GAGjC,OAFAD,EAAcC,GACdxB,KAAKuF,gBAAgB1D,EAAMsB,EAAUnD,KAAM6B,EAAML,IAC1CxB,IACT,EAGJF,EAAaX,UAAUsB,eACnB,SAAwBoB,EAAML,GAC5B,IAAIiE,EAAMzD,EAAQ0D,EAAU7B,EAAG8B,EAK/B,GAHApE,EAAcC,QAGCL,KADfa,EAAShC,KAAKkB,SAEZ,OAAOlB,KAGT,QAAamB,KADbsE,EAAOzD,EAAOH,IAEZ,OAAO7B,KAET,GAAIyF,IAASjE,GAAYiE,EAAKjE,WAAaA,EACb,KAAtBxB,KAAKoB,aACTpB,KAAKkB,QAAU5B,OAAO6C,OAAO,cAEtBH,EAAOH,GACVG,EAAOvB,gBACTT,KAAKqC,KAAK,iBAAkBR,EAAM4D,EAAKjE,UAAYA,SAElD,GAAoB,mBAATiE,EAAqB,CAGrC,IAFAC,GAAY,EAEP7B,EAAI4B,EAAKjD,OAAS,EAAGqB,GAAK,EAAGA,IAChC,GAAI4B,EAAK5B,KAAOrC,GAAYiE,EAAK5B,GAAGrC,WAAaA,EAAU,CACzDmE,EAAmBF,EAAK5B,GAAGrC,SAC3BkE,EAAW7B,EACX,KACF,CAGF,GAAI6B,EAAW,EACb,OAAO1F,KAEQ,IAAb0F,EACFD,EAAKG,QAiIf,SAAmBH,EAAMI,GACvB,KAAOA,EAAQ,EAAIJ,EAAKjD,OAAQqD,IAC9BJ,EAAKI,GAASJ,EAAKI,EAAQ,GAC7BJ,EAAKK,KACP,CAnIUC,CAAUN,EAAMC,GAGE,IAAhBD,EAAKjD,SACPR,EAAOH,GAAQ4D,EAAK,SAEQtE,IAA1Ba,EAAOvB,gBACTT,KAAKqC,KAAK,iBAAkBR,EAAM8D,GAAoBnE,EAC1D,CAEA,OAAOxB,IACT,EAEJF,EAAaX,UAAU6G,IAAMlG,EAAaX,UAAUsB,eAEpDX,EAAaX,UAAU8G,mBACnB,SAA4BpE,GAC1B,IAAIwD,EAAWrD,EAAQ6B,EAGvB,QAAe1C,KADfa,EAAShC,KAAKkB,SAEZ,OAAOlB,KAGT,QAA8BmB,IAA1Ba,EAAOvB,eAUT,OATyB,IAArBG,UAAU4B,QACZxC,KAAKkB,QAAU5B,OAAO6C,OAAO,MAC7BnC,KAAKoB,aAAe,QACMD,IAAjBa,EAAOH,KACY,KAAtB7B,KAAKoB,aACTpB,KAAKkB,QAAU5B,OAAO6C,OAAO,aAEtBH,EAAOH,IAEX7B,KAIT,GAAyB,IAArBY,UAAU4B,OAAc,CAC1B,IACI0D,EADAC,EAAO7G,OAAO6G,KAAKnE,GAEvB,IAAK6B,EAAI,EAAGA,EAAIsC,EAAK3D,SAAUqB,EAEjB,oBADZqC,EAAMC,EAAKtC,KAEX7D,KAAKiG,mBAAmBC,GAK1B,OAHAlG,KAAKiG,mBAAmB,kBACxBjG,KAAKkB,QAAU5B,OAAO6C,OAAO,MAC7BnC,KAAKoB,aAAe,EACbpB,IACT,CAIA,GAAyB,mBAFzBqF,EAAYrD,EAAOH,IAGjB7B,KAAKS,eAAeoB,EAAMwD,QACrB,QAAkBlE,IAAdkE,EAET,IAAKxB,EAAIwB,EAAU7C,OAAS,EAAGqB,GAAK,EAAGA,IACrC7D,KAAKS,eAAeoB,EAAMwD,EAAUxB,IAIxC,OAAO7D,IACT,EAmBJF,EAAaX,UAAUkG,UAAY,SAAmBxD,GACpD,OAAO0B,EAAWvD,KAAM6B,GAAM,EAChC,EAEA/B,EAAaX,UAAUiH,aAAe,SAAsBvE,GAC1D,OAAO0B,EAAWvD,KAAM6B,GAAM,EAChC,EAEA/B,EAAakE,cAAgB,SAAS9D,EAAS2B,GAC7C,MAAqC,mBAA1B3B,EAAQ8D,cACV9D,EAAQ8D,cAAcnC,GAEtBmC,EAAc5E,KAAKc,EAAS2B,EAEvC,EAEA/B,EAAaX,UAAU6E,cAAgBA,EAiBvClE,EAAaX,UAAUkH,WAAa,WAClC,OAAOrG,KAAKoB,aAAe,EAAI1C,EAAesB,KAAKkB,SAAW,EAChE,C,iBCzaC,IAAWoF,EAAmM7H,KAAnM6H,EAAwM,IAAK,MAAM,aAAa,IAAIC,EAAE,CAAC,IAAI,CAACA,EAAED,KAAKhH,OAAOiF,eAAe+B,EAAE,aAAa,CAACzG,OAAM,IAAKyG,EAAEE,YAAO,EAAOF,EAAEE,OAAO,SAASD,GAAG,OAAOE,KAAKF,EAAE,GAAG,IAAI,CAACA,EAAED,KAAKhH,OAAOiF,eAAe+B,EAAE,aAAa,CAACzG,OAAM,IAAK,MAAM6G,UAAU/D,MAAMgE,YAAYJ,EAAED,EAAEI,GAAGE,MAAML,GAAGvG,KAAK6G,WAAWP,EAAEtG,KAAK8G,SAASJ,CAAC,EAAEJ,EAAES,QAAQL,GAAG,GAAG,CAACH,EAAED,EAAEI,KAAKpH,OAAOiF,eAAe+B,EAAE,aAAa,CAACzG,OAAM,IAAK,MAAMoE,EAAEyC,EAAE,KAAKJ,EAAES,QAAQ,MAAMJ,YAAYJ,EAAED,EAAE,MAAM,IAAIC,EAAES,YAAYV,IAAIC,EAAEU,YAAY,MAAM,IAAItE,MAAM,0DAA0D3C,KAAKkH,QAAQX,EAAEA,EAAEU,cAAcnE,QAAQC,KAAK,+OAA+OuD,EAAE,CAACW,YAAYV,EAAEU,YAAYE,aAAaZ,EAAEY,cAAc,KAAKC,UAAU,OAAOpH,KAAKqH,MAAMf,EAAEtG,KAAKsH,cAAc,KAAKtH,KAAKuH,aAAa,KAAKvH,KAAKwH,iBAAiB,CAACC,YAAYlB,EAAED,GAAG,MAAMI,EAAE,IAAIgB,QAAQnB,EAAED,GAAG,OAAOtG,KAAK2H,QAAQjB,GAAGH,GAAGqB,MAAMrB,IAAI,CAACkB,cAAclB,EAAED,GAAG,MAAMI,QAAQ1G,KAAK6H,iBAAiB,IAAI5D,EAAEsC,EAAEuB,QAAQ7D,EAAE8D,QAAQrD,IAAI,gBAAgB,UAAUgC,GAAG,IAAIsB,QAAQ1B,EAAErC,GAAG,IAAI+D,EAAEC,IAAI,MAAMD,EAAEE,OAAO,CAAC,MAAMxB,QAAQ1G,KAAKmH,eAAelD,EAAEsC,EAAEuB,QAAQ7D,EAAE8D,QAAQrD,IAAI,gBAAgB,UAAUgC,EAAEO,aAAae,QAAQ1B,EAAErC,EAAE,CAAC,OAAO+D,CAAC,CAACP,iBAAiB,OAAOzH,KAAKqH,QAAQ,OAAOrH,KAAKqH,MAAMD,WAAWpH,KAAKqH,MAAMD,UAAUe,KAAKC,OAAOpI,KAAKqH,MAAMrH,KAAKmH,cAAc,CAACM,uBAAuB,aAAazH,KAAKqI,YAAYpB,WAAW,CAACQ,qBAAqB,GAAGzH,KAAKsH,cAAc,OAAOtH,KAAKsH,cAActH,KAAKsH,eAAc,EAAGrD,EAAEkD,cAAcnH,KAAKkH,QAAQlH,KAAKqH,OAAO,IAAI,MAAMd,QAAQvG,KAAKsH,cAAc,OAAOtH,KAAKqH,MAAMd,EAAEvG,KAAKwH,kBAAkBjB,CAAwG,CAAtG,MAAMA,GAAG,MAAMvG,KAAKkH,QAAQoB,aAAatI,KAAKkH,QAAQoB,YAAY/B,GAAGA,CAAC,CAAC,QAAQvG,KAAKsH,cAAc,IAAI,CAAC,CAACE,kBAAkB,GAAGxH,KAAKuH,eAAegB,aAAavI,KAAKuH,cAAcvH,KAAKuH,aAAa,OAAOvH,KAAKqH,QAAQrH,KAAKqH,MAAMD,YAAYpH,KAAKqH,MAAMF,aAAa,OAAO,MAAMZ,EAAEvG,KAAKqH,MAAMD,UAAUe,KAAKC,MAAM7B,EAAE,OAAOvG,KAAKuH,aAAaiB,YAAW,UAAW,UAAUxI,KAAKmH,cAA+G,CAAhG,MAAMZ,GAAGzD,QAAQkC,MAAM,uEAAuEuB,EAAE,CAAE,GAAEA,EAAE,KAAK,EAAC,EAAG,IAAI,CAACA,EAAED,EAAEI,KAAKpH,OAAOiF,eAAe+B,EAAE,aAAa,CAACzG,OAAM,IAAKyG,EAAEa,aAAab,EAAEmC,sBAAiB,EAAO,MAAMxE,EAAEyC,EAAE,KAAKsB,EAAEtB,EAAE,KAAK,SAASgC,EAAEnC,GAAG,OAAOjH,OAAOqJ,QAAQpC,GAAGqC,KAAI,EAAGrC,EAAED,UAAK,IAASA,EAAE,GAAGuC,mBAAmBtC,GAAG,IAAIsC,mBAAmBvC,KAAKwC,KAAK,IAAI,CAACxC,EAAEmC,iBAAiBC,EAAEpC,EAAEa,aAAaM,eAAelB,EAAED,EAAEI,GAAG,IAAI7C,EAAE,MAAMkF,EAAErC,EAAE,GAAG,MAAMqC,OAAE,EAAOA,EAAE5B,aAAatD,EAAE,CAACmF,WAAW,gBAAgBC,cAAcF,EAAE5B,mBAAc,IAASb,EAAE4C,eAAerF,EAAEsF,UAAU7C,EAAE8C,eAAe,OAAO9C,EAAEU,WAAW,IAAI,qBAAqBnD,EAAE,CAACmF,WAAW,sBAAsB1C,EAAE+C,QAAQxF,EAAEwF,MAAM/C,EAAE+C,MAAMP,KAAK,MAAM,MAAM,IAAI,WAAWjF,EAAE,CAACmF,WAAW,WAAWM,SAAShD,EAAEiD,SAASC,SAASlD,EAAEkD,UAAUlD,EAAE+C,QAAQxF,EAAEwF,MAAM/C,EAAE+C,MAAMP,KAAK,MAAM,MAAM,IAAI,qBAAqBjF,EAAE,CAACmF,WAAW,qBAAqBS,KAAKnD,EAAEmD,KAAKC,aAAapD,EAAEqD,YAAYR,UAAU7C,EAAE8C,SAASQ,cAActD,EAAEuD,cAAc,MAAM,QAAQ,KAAK,iBAAiBvD,EAAEU,UAAU,IAAIrE,MAAM,sBAAsB2D,EAAEU,WAAW,IAAIrE,MAAM,gEAAgE,MAAMmH,EAAE,CAAC,eAAe,qCAAqC,IAAIC,GAAE,EAAG,QAAG,IAASzD,EAAE4C,aAAa,CAACa,GAAE,EAAG,MAAMxD,GAAE,EAAGtC,EAAEuC,QAAQF,EAAE8C,SAAS,IAAI9C,EAAE4C,cAAcY,EAAEE,cAAc,SAASzD,CAAC,CAAC,MAAM0D,QAAQrC,MAAMtB,EAAE4D,cAAc,CAACC,OAAO,OAAOpC,QAAQ+B,EAAEM,KAAK1B,EAAE7E,KAAKwG,QAAQJ,EAAEK,OAAO,IAAIL,EAAEhC,GAAG,CAAC,GAAG,kBAAkBpE,EAAEmF,YAAY1C,EAAEU,UAAU,OAAOT,EAAED,EAAE,MAAM,MAAMI,EAAEuD,EAAE/B,OAAO,IAAIjE,EAAEyE,EAAE,MAAM2B,EAAErF,OAAOf,EAAE,gBAAgBoG,EAAErF,MAAM,IAAIqF,EAAEE,oBAAoBtG,GAAG,IAAIoG,EAAEE,mBAAmB7B,EAAE2B,EAAErF,QAAQf,EAAE,cAAcgG,EAAE/B,OAAO,IAAI+B,EAAEO,WAAW,MAAMP,EAAE/B,QAAQ6B,IAAI9F,GAAG,qEAAqEyE,EAAE,MAAM,IAAIV,EAAEjB,QAAQ9C,EAAEyE,EAAEhC,EAAE,CAAC,MAAM+D,EAAE,CAACxD,YAAYoD,EAAEK,aAAatD,UAAUiD,EAAEM,WAAWxC,KAAKC,MAAM,IAAIiC,EAAEM,WAAW,KAAKxD,aAAakD,EAAEpB,cAAcoB,EAAEpB,cAAc,MAAM,OAAO3C,EAAEsE,eAAetE,EAAEsE,cAAcH,GAAGA,CAAC,IAAInE,EAAE,CAAC,EAAE,SAASI,EAAEzC,GAAG,IAAI+D,EAAE1B,EAAErC,GAAG,QAAG,IAAS+D,EAAE,OAAOA,EAAE3J,QAAQ,IAAIqK,EAAEpC,EAAErC,GAAG,CAAC5F,QAAQ,CAAC,GAAG,OAAOkI,EAAEtC,GAAGyE,EAAEA,EAAErK,QAAQqI,GAAGgC,EAAErK,OAAO,CAAC,IAAI4F,EAAE,CAAC,EAAE,MAAM,MAAM,IAAIsC,EAAEtC,EAAE3E,OAAOiF,eAAegC,EAAE,aAAa,CAAC1G,OAAM,IAAK0G,EAAEsE,YAAYtE,EAAEuE,OAAOvE,EAAEwE,cAAcxE,EAAEQ,aAAQ,EAAO,IAAIT,EAAEI,EAAE,IAAIpH,OAAOiF,eAAegC,EAAE,UAAU,CAAC/B,YAAW,EAAGC,IAAI,WAAW,OAAO6B,EAAES,OAAO,IAAIzH,OAAOiF,eAAegC,EAAE,gBAAgB,CAAC/B,YAAW,EAAGC,IAAI,WAAW,OAAO6B,EAAES,OAAO,IAAIzH,OAAOiF,eAAegC,EAAE,SAAS,CAAC/B,YAAW,EAAGC,IAAI,WAAW,OAAO6B,EAAES,OAAO,IAAI,IAAIiB,EAAEtB,EAAE,KAAKpH,OAAOiF,eAAegC,EAAE,cAAc,CAAC/B,YAAW,EAAGC,IAAI,WAAW,OAAOuD,EAAEjB,OAAO,GAAI,EAAze,GAA6e9C,CAAE,EAAxoJ,GAAxJ3F,EAAOD,QAAQiI,G,+BCEhF,IAAI0E,EAA8B,uDAC9BC,EAAkB,qCAClBC,EAAkB,iBAClBC,EAAkB,oBAClBC,EAAoB,QACpBC,EAAuB,WAOvBC,EAAgB,iCAQpB,SAASC,EAAM1L,GACb,OAAOA,EAAM2L,QAASP,EAAiB,GACzC,CAEA,SAASQ,EAAe5L,GACtB,OAAOqL,EAAgBQ,KAAM7L,EAC/B,CAEA,SAAS8L,EAAgB9L,EAAO+L,GAC9B,KAAOH,EAAe5L,EAAM+L,KAC1BA,IAEF,OAAOA,CACT,CAEA,SAASC,EAAahM,GACpB,OAAOwL,EAAqBK,KAAM7L,KAC/ByL,EAAcI,KAAM7L,EACzB,CAEA,MAAMiM,EAQJnF,YAAa9G,GAGXG,KAAK+L,KAAO,GAERlM,GACFG,KAAKgM,MAAOnM,EAGhB,CAOAoM,IAAKpM,GAKH,IAHA,IAAIqM,EAAQ,GACRrK,EAAOhC,EAAMsM,cAERtI,EAAI,EAAGA,EAAI7D,KAAK+L,KAAKvJ,OAAQqB,IAChC7D,KAAK+L,KAAMlI,GAAIoI,IAAIE,gBAAkBtK,GACvCqK,EAAM3J,KAAMvC,KAAK+L,KAAMlI,IAI3B,OAAOqI,CAET,CAQAzH,IAAK2H,EAAMvM,GAETuM,EAAOA,EAAKD,cAIZ,IAFA,IAAID,EAAQ,GAEHrI,EAAI,EAAGA,EAAI7D,KAAK+L,KAAKvJ,OAAQqB,IAChC7D,KAAK+L,KAAMlI,GAAKuI,KAAWvM,GAC7BqM,EAAM3J,KAAMvC,KAAK+L,KAAMlI,IAI3B,OAAOqI,CAET,CAEAxH,IAAK2H,GAEH,OADArM,KAAK+L,KAAKxJ,KAAM8J,GACTrM,IACT,CAEAsM,IAAKF,EAAMvM,GAETuM,EAAOA,EAAKD,cAEZ,IAAK,IAAItI,EAAI,EAAGA,EAAI7D,KAAK+L,KAAKvJ,OAAQqB,IACpC,GAAI7D,KAAK+L,KAAMlI,GAAKuI,KAAWvM,EAC7B,OAAO,EAIX,OAAO,CAET,CAEAmM,MAAOnM,EAAO+L,GAaZ,IALA,IAAIxI,EAjHA,EAkHAZ,GAHJ3C,EAAQ0L,EAHR1L,GADA+L,EAASA,GAAU,GACF/L,EAAMc,MAAOiL,GAAW/L,GAGnB2L,QAASL,EAAiB,KAG7B3I,OAEf+J,GADAX,EAAS,EACH,MAEHA,EAASpJ,GACd,GAvHE,IAuHEY,EAAuB,CACzB,GAAIqI,EAAe5L,EAAM+L,IAAY,CACnCA,IACA,QACF,CAAO,GAAsB,MAAlB/L,EAAM+L,GAaf,MAAM,IAAIjJ,MAAO,yBAA2B9C,EAAM+L,GAAU,eAAiBA,GAN7E,GANW,MAAPW,IACS,MAAXA,EAAIN,IACFjM,KAAK+L,KAAKxJ,QAASuJ,EAAKU,gBAAiBD,IACzCvM,KAAK+L,KAAKxJ,KAAMgK,KAGP,KADTE,EAAM5M,EAAM6M,QAAS,IAAKd,IACb,MAAM,IAAIjJ,MAAO,2CAA6CiJ,GAC/EW,EAAM,CAAEI,IAAK9M,EAAMc,MAAOiL,EAAS,EAAGa,IAEtCb,EAASa,EACTrJ,EArIH,EAyICwI,GACF,MAAO,GA1IN,IA0IUxI,EAAsB,CAC/B,GAAIqI,EAAe5L,EAAM+L,IAAY,CACnCA,IACA,QACF,CAAO,GAAsB,MAAlB/L,EAAM+L,GACfxI,EA9IF,EA+IEwI,QACK,IAAsB,MAAlB/L,EAAM+L,GAIf,MAAM,IAAIjJ,MAAO,yBAA2B9C,EAAM+L,GAAU,eAAiBA,GAH7ExI,EAnJF,EAoJEwI,GAGF,CACF,KAAO,IAtJL,IAsJSxI,EAsDT,MAAM,IAAIT,MAAO,yBAA2BS,EAAQ,KArDpD,GAAqB,MAAjBvD,EAAM+L,IAAkBH,EAAe5L,EAAM+L,IAAY,CAC3DA,IACA,QACF,CAEA,IAAa,KADTa,EAAM5M,EAAM6M,QAAS,IAAKd,IACb,MAAM,IAAIjJ,MAAO,0CAA4CiJ,GAC9E,IAAIQ,EAAOb,EAAM1L,EAAMc,MAAOiL,EAAQa,IAAQN,cAC1CS,EAAY,GAGhB,GAAsB,MAAlB/M,EADJ+L,EAASD,EAAgB9L,EADzB+L,EAASa,EAAM,IAIb,IADAb,IACOA,EAASpJ,GAAS,CACvB,GAAsB,MAAlB3C,EAAM+L,GAAkB,CAC1BA,IAAU,KACZ,CACsB,OAAlB/L,EAAM+L,IACRA,IAEFgB,GAAa/M,EAAM+L,GACnBA,GACF,KACK,CAEL,IADA,IAAIa,EAAMb,EAAS,GACXR,EAAkBM,KAAM7L,EAAM4M,KAAUA,EAAMjK,GACpDiK,IAEFG,EAAY/M,EAAMc,MAAOiL,EAAQa,GACjCb,EAASa,CACX,CAkBA,OAjBIF,EAAKH,IAAUN,EAAKe,sBAAuBT,KAER,MAA5BA,EAAMA,EAAK5J,OAAS,GAC7B+J,EAAKH,GAASN,EAAKgB,mBAAoBF,IAEvCA,EAAqB,SAATR,EACVQ,EAAUT,cAAgBS,EACT,MAAfL,EAAKH,GACHxI,MAAMmJ,QAASR,EAAKH,IACtBG,EAAKH,GAAO7J,KAAMqK,GAElBL,EAAKH,GAAS,CAAEG,EAAKH,GAAQQ,GAG/BL,EAAKH,GAASQ,IAGV/M,EAAM+L,IACZ,IAAK,IAAKxI,EAzMZ,EAyMgC,MAC9B,IAAK,IAAKA,EAxMZ,EA0MAwI,GAGF,CAWF,OARW,MAAPW,IACS,MAAXA,EAAIN,IACFjM,KAAK+L,KAAKxJ,QAASuJ,EAAKU,gBAAiBD,IACzCvM,KAAK+L,KAAKxJ,KAAMgK,IAGpBA,EAAM,KAECvM,IAET,CAEAgN,WAME,IAJA,IAAIjB,EAAO,GACPM,EAAO,GACPE,EAAM,KAED1I,EAAI,EAAGA,EAAI7D,KAAK+L,KAAKvJ,OAAQqB,IACpC0I,EAAMvM,KAAK+L,KAAKlI,GAChBwI,EAAO/M,OAAO6G,KAAMnG,KAAK+L,KAAKlI,IAAKoJ,QAAQ,SAAUZ,EAAMD,GACzD,MAAa,QAATA,EAAwBC,EACrBA,EAAO,KAAOP,EAAKoB,gBAAiBd,EAAMG,EAAKH,GACxD,GAAG,IAAMG,EAAII,IAAM,KACnBZ,EAAKxJ,KAAM8J,GAGb,OAAON,EAAKjD,KAAM,KAEpB,EAUFgD,EAAKqB,qBAAuB,SAAUtN,GACpC,OAAOmL,EAA4BU,KAAM7L,EAC3C,EAEAiM,EAAKE,MAAQ,SAAUnM,EAAO+L,GAC5B,OAAO,IAAIE,GAAOE,MAAOnM,EAAO+L,EAClC,EAEAE,EAAKe,sBAAwB,SAAUT,GACrC,MAAgB,QAATA,GAA2B,SAATA,GAA4B,UAATA,GACjC,UAATA,GAA6B,WAATA,CACxB,EAEAN,EAAKsB,YAAc,SAAUhB,GAC3B,MAAgB,QAATA,GAA2B,SAATA,GAA4B,WAATA,CAC9C,EAEAN,EAAKuB,aAAe,SAAUxN,GAC5B,OAAOA,EAAM2L,QAAS,KAAM,MAC9B,EAEAM,EAAKU,gBAAkB,SAAUD,GAE/B,OADWA,EAAIN,IAAIqB,MAAO,KACd1E,KAAK,SAAUqD,GACzB,IAAIpM,EAAQP,OAAOiO,OAAQ,CAAC,EAAGhB,GAE/B,OADA1M,EAAMoM,IAAMA,EACLpM,CACT,GACF,EAQAiM,EAAKgB,mBAAqB,SAAUjN,GAClC,IAAI2N,EAAQ,6BAA6BC,KAAM5N,GAC/C,MAAO,CACL6N,SAAUF,EAAM,GAAGrB,cACnBwB,SAAU7B,EAAKqB,qBAAsBK,EAAM,IACzC,KAAOA,EAAM,GAAGrB,cAClBtM,MAAOiM,EAAKqB,qBAAsBK,EAAM,IACtCI,mBAAoBJ,EAAM,IAAOA,EAAM,GAE7C,EAQA1B,EAAK+B,wBAA0B,SAAUzB,EAAM0B,GAE7C,IAAIH,GAAaG,EAAKH,UAAY,SAAUI,cAc5C,OAAO3B,EAAO,IAAMuB,EAAW,KAbhBG,EAAKJ,UAAY,MAcnB,KAVTM,OAAOC,SAAUH,EAAKjO,QAAWiM,EAAKqB,qBAAsBQ,GAC/CG,EAAKjO,MAAMmN,SAAUW,GAC3BK,OAAOC,SAAUH,EAAKjO,OAChBiO,EAAKjO,MAAMmN,SAAU,OACjCxB,QAAS,gBAAiB,OAEd3C,mBAAoBiF,EAAKjO,OAM5C,EAQAiM,EAAKoB,gBAAkB,SAAUd,EAAMvM,GAErC,OAAI+D,MAAMmJ,QAASlN,GACVA,EAAM+I,KAAMsF,GACVpC,EAAKoB,gBAAiBd,EAAM8B,KAClCpF,KAAM,MAGqB,MAA5BsD,EAAMA,EAAK5J,OAAS,IAAgC,iBAAV3C,EACrCiM,EAAK+B,wBAAyBzB,EAAMvM,IAGzCiM,EAAKsB,YAAahB,GACpBvM,EAAQgM,EAAahM,GACnB,IAAMiM,EAAKuB,aAAcxN,GAAU,IACnCiM,EAAKuB,aAAcxN,GACZgM,EAAahM,KAQtBA,EAAQ,KALRA,GAFAA,EAAQgJ,mBAAoBhJ,IAGzB2L,QAAS,OAAQ,KACjBA,QAAS,OAAQ,KACjBA,QAAS,OAAQ,MAEE,KAGjBY,EAAO,IAAMvM,EAEtB,EAEAvB,EAAOD,QAAUyN,C,kBCzXjBxN,EAAOD,QAAU,SAAmB8P,GAElC,OADAA,EAASA,GAAU,MACZ,SAAgBC,GAErB,OADAA,EAASxL,OAAOwL,IACF5C,QAAQ2C,GAAQ,SAAUpM,GACtC,IAAIgH,EAAIhH,EAAE,GAAGsM,WAAW,GACpBC,EAAU,GAWd,OAVIvF,EAAI,IACNuF,EAAQ/L,KAAKwG,GACH,KAAOA,GAAKA,EAAI,MAC1BuF,EAAQ/L,KAAMwG,GAAK,EAAK,KACxBuF,EAAQ/L,KAAU,GAAJwG,EAAU,OAExBuF,EAAQ/L,KAAMwG,GAAK,GAAM,KACzBuF,EAAQ/L,KAAOwG,GAAK,EAAK,GAAM,KAC/BuF,EAAQ/L,KAAU,GAAJwG,EAAU,MAEnBuF,EAAQ1F,KAAI,SAAUG,GAC3B,MAAO,IAAMA,EAAEiE,SAAS,IAAIe,aAC9B,IAAGjF,KAAK,GACV,GACF,CACF,C,mCClBA,IAAIyF,EAAclQ,EACd2P,EAAS,aAuEb,SAASQ,EAAW9F,EAAG+F,GACrB,IACE,OAAOb,mBAAmBlF,EAG5B,CAFE,MAAOnC,GACP,OAAOgI,EAAYG,eAAehG,EAAG+F,GAAczB,UACrD,CACF,CAzEAuB,EAAYG,eAAiB,SAAShG,EAAG+F,GAKvC,IAJA,IAEIxK,EAAGlC,EAAG4M,EAFNC,EAAM,IAAIZ,EAAOtF,EAAElG,QACnBY,EAAQ,EAGHyL,EAAU,EAAGC,EAAW,EAAGD,GAAWnG,EAAElG,OAAQqM,IAAW,CAClE,IAAI9F,EAAI8F,EAAUnG,EAAElG,OAASkG,EAAE2F,WAAWQ,GAAWE,IACrD,OAAQ3L,GACN,KAAK,EACH,OAAQ2F,GACN,KAAK,GACH9E,EAAI,EACJlC,EAAI,EACJqB,EAAQ,EACR,MACF,KAAK,GACCqL,IACF1F,EAAI,IAER,QACE6F,EAAIE,KAAc/F,EAGtB,MAEF,KAAK,EAEH,GADA4F,EAAU5F,EACNA,GAAK,IAAWA,GAAK,GACvB9E,EAAI8E,EAAI,QACH,GAAIA,GAAK,IAAWA,GAAK,GAC9B9E,EAAI8E,EAAI,GAAU,OACb,MAAIA,GAAK,IAAWA,GAAK,KAEzB,CACL6F,EAAIE,KAAc,GAClBF,EAAIE,KAAc/F,EAClB3F,EAAQ,EACR,KACF,CANEa,EAAI8E,EAAI,GAAU,EAMpB,CACA3F,EAAQ,EACR,MAEF,KAAK,EAEH,GADAA,EAAQ,EACJ2F,GAAK,IAAWA,GAAK,GACvBhH,EAAIgH,EAAK,QACJ,GAAIA,GAAK,IAAWA,GAAK,GAC9BhH,EAAIgH,EAAI,GAAU,OACb,MAAIA,GAAK,IAAWA,GAAK,KAEzB,CACL6F,EAAIE,KAAc,GAClBF,EAAIE,KAAcH,EAClBC,EAAIE,KAAc/F,EAClB,KACF,CANEhH,EAAIgH,EAAI,GAAU,EAMpB,CACA6F,EAAIE,KAAc,GAAK7K,EAAIlC,EAGjC,CAIA,OAAO6M,EAAIjO,MAAM,EAAGmO,EAAW,EACjC,EAUAP,EAAYS,SAAWR,EAIvB,IADA,IAAIS,EAAW,IAAIrL,MAAM,KAChBC,EAAI,EAAGA,EAAI,MAAOA,EACzBoL,EAASpL,GAAK,MAAQA,EAAI,GAAK,IAAM,IAAMA,EAAEmJ,SAAS,KAAKe,cAC7DQ,EAAYW,OAAS,SAASC,GAGT,iBAARA,IACTA,GAAO,IAIT,IAHA,IAAIP,EAAM,GACNQ,EAAU,EAELvL,EAAI,EAAGA,EAAIsL,EAAI3M,SAAUqB,EAAG,CACnC,IAAIkF,EAAIoG,EAAId,WAAWxK,GAQvB,KAAU,KAANkF,GAAoB,KAANA,GAAoB,KAANA,GAAoB,KAANA,GAAoB,MAANA,GACvDA,GAAK,IAAQA,GAAK,IAClBA,GAAK,IAAQA,GAAK,IAClBA,GAAK,IAAQA,GAAK,IAClBA,GAAK,IAAQA,GAAK,KAQvB,GAJIlF,EAAIuL,EAAU,IAChBR,GAAOO,EAAIxO,MAAMyO,EAASvL,IAGxBkF,EAAI,IACNqG,EAAUvL,EAAI,EACd+K,GAAOK,EAASlG,QAKlB,GAAIA,EAAI,KACNqG,EAAUvL,EAAI,EACd+K,GAAOK,EAAS,IAAQlG,GAAK,GAAMkG,EAAS,IAAY,GAAJlG,QAGtD,GAAIA,EAAI,OAAUA,GAAK,MACrBqG,EAAUvL,EAAI,EACd+K,GAAOK,EAAS,IAAQlG,GAAK,IACtBkG,EAAS,IAASlG,GAAK,EAAK,IAC5BkG,EAAS,IAAY,GAAJlG,OAJ1B,CASA,IAAIsG,EACJ,OAFExL,EAEMsL,EAAI3M,QAGV,MAAM,IAAI8M,SAAS,iBAFnBD,EAAyB,KAApBF,EAAId,WAAWxK,GAGtBuL,EAAUvL,EAAI,EAEd+K,GAAOK,EAAS,KADhBlG,EAAI,QAAiB,KAAJA,IAAc,GAAMsG,KACR,IACtBJ,EAAS,IAASlG,GAAK,GAAM,IAC7BkG,EAAS,IAASlG,GAAK,EAAK,IAC5BkG,EAAS,IAAY,GAAJlG,EAbxB,CAcF,CACA,OAAgB,IAAZqG,EACKD,EACLC,EAAUD,EAAI3M,OACToM,EAAMO,EAAIxO,MAAMyO,GAClBR,CACT,EAEA,IAAIW,EAAqB,SAASC,GAChC,MAAiB,iBAANA,EACFA,EACQ,iBAANA,GAAkBC,SAASD,GAC7B,GAAKA,EACG,kBAANA,EACFA,EAAI,OAAS,QACf,EACT,EAqOA,SAASE,EAAUhH,EAAGiH,GACpB,IACE,OAAOA,EAAQjH,EAGjB,CAFE,MAAOnC,GACP,OAAOgI,EAAYS,SAAStG,GAAG,EACjC,CACF,CAxOA6F,EAAYqB,UAAYrB,EAAY/H,OAAS,SAASqJ,EAAKC,EAAKC,EAAI7I,GAClE4I,EAAMA,GAAO,IACbC,EAAKA,GAAM,IAEX,IAAIvJ,EAAS+H,EAAYW,OAKzB,GAJIhI,GAAiD,mBAA/BA,EAAQ2B,qBAC5BrC,EAASU,EAAQ2B,oBAGP,OAARgH,GAA+B,iBAARA,EAAkB,CAK3C,IAJA,IAAI1J,EAAO7G,OAAO6G,KAAK0J,GACnBzK,EAAMe,EAAK3D,OACXwN,EAAQ5K,EAAM,EACd6K,EAAS,GACJpM,EAAI,EAAGA,EAAIuB,IAAOvB,EAAG,CAC5B,IAAIqM,EAAI/J,EAAKtC,GACT2L,EAAIK,EAAIK,GACRC,EAAK3J,EAAO+I,EAAmBW,IAAMH,EAEzC,GAAInM,MAAMmJ,QAAQyC,GAAI,CAGpB,IAFA,IAAIY,EAAOZ,EAAEhN,OACT6N,EAAQD,EAAO,EACVE,EAAI,EAAGA,EAAIF,IAAQE,EAC1BL,GAAUE,EAAK3J,EAAO+I,EAAmBC,EAAEc,KACvCA,EAAID,IACNJ,GAAUH,GAEVM,GAAQvM,EAAImM,IACdC,GAAUH,EACd,MACEG,GAAUE,EAAK3J,EAAO+I,EAAmBC,IACrC3L,EAAImM,IACNC,GAAUH,EAEhB,CACA,OAAOG,CACT,CACA,MAAO,EACT,EAGA1B,EAAYvC,MAAQuC,EAAYgC,OAAS,SAASC,EAAIV,EAAKC,EAAI7I,GAC7D4I,EAAMA,GAAO,IACbC,EAAKA,GAAM,IAEX,IAAIF,EAAM,CAAC,EAEX,GAAkB,iBAAPW,GAAiC,IAAdA,EAAGhO,OAC/B,OAAOqN,EAGU,iBAARC,IACTA,GAAO,IAET,IAAIW,EAAQV,EAAGvN,OACXkO,EAASZ,EAAItN,OAEbmO,EAAU,IACVzJ,GAAsC,iBAApBA,EAAQyJ,UAC5BA,EAAUzJ,EAAQyJ,SAGpB,IAAIC,EAAQC,IACRF,EAAU,IACZC,EAAQD,GAEV,IAAIJ,EAAShC,EAAYS,SACrB9H,GAAiD,mBAA/BA,EAAQ0G,qBAC5B2C,EAASrJ,EAAQ0G,oBAanB,IAXA,IAAIkD,EAAgBP,IAAW/B,EAE3BrI,EAAO,GACPiJ,EAAU,EACV2B,EAAS,EACTC,EAAQ,EACR9K,EAAM,GACNrG,EAAQ,GACRoR,EAAaH,EACbI,EAAaJ,EACbK,EAAc,EACTtN,EAAI,EAAGA,EAAI2M,EAAGhO,SAAUqB,EAAG,CAClC,IAAI4F,EAAO+G,EAAGnC,WAAWxK,GAGzB,GAAI4F,IAASqG,EAAIzB,WAAW0C,GAA5B,CA2DA,GAnBEA,EAAS,EACJG,IAGU,KAATzH,EACF0H,EAAc,EACLA,EAAc,IACZ1H,GAAQ,IAAWA,GAAQ,IAC3BA,GAAQ,IAAWA,GAAQ,IAC3BA,GAAQ,IAAWA,GAAQ,KAChB,KAAhB0H,IACJD,GAAa,GAEfC,EAAc,GAMhBH,EAAQP,EAAO,CACjB,GAAIhH,IAASsG,EAAG1B,WAAW2C,GAAQ,GAC3BA,IAAUP,IAGVrB,GADA3C,EAAM5I,EAAImN,EAAQ,KAEpB9K,GAAOsK,EAAG7P,MAAMyO,EAAS3C,IAC3B0E,EAAc,EACd/B,EAAUvL,EAAI,GAEhB,QACF,CACEmN,EAAQ,EACHC,IAGU,KAATxH,EACF0H,EAAc,EACLA,EAAc,IACZ1H,GAAQ,IAAWA,GAAQ,IAC3BA,GAAQ,IAAWA,GAAQ,IAC3BA,GAAQ,IAAWA,GAAQ,KAChB,KAAhB0H,IACJF,GAAa,GAEfE,EAAc,EAItB,CAEa,KAAT1H,IACEuH,EAAQP,GACN5M,EAAIuL,EAAU,IAChBlJ,GAAOsK,EAAG7P,MAAMyO,EAASvL,IAC3BqC,GAAO,MACP+K,GAAa,IAETpN,EAAIuL,EAAU,IAChBvP,GAAS2Q,EAAG7P,MAAMyO,EAASvL,IAC7BhE,GAAS,MACTqR,GAAa,GAEf9B,EAAUvL,EAAI,EA9ChB,MAvDE,KAAMkN,IAAWL,EAAQ,CAEvB,IAkBMU,EAlBF3E,EAAM5I,EAAIkN,EAAS,EA2BvB,GA1BIC,EAAQP,EAGNrB,EAAU3C,IACZvG,GAAOsK,EAAG7P,MAAMyO,EAAS3C,IAClB2C,EAAU3C,IACnB5M,GAAS2Q,EAAG7P,MAAMyO,EAAS3C,IACzBwE,IACF/K,EAAMwJ,EAAUxJ,EAAKqK,IACnBW,IACFrR,EAAQ6P,EAAU7P,EAAO0Q,KAGA,IAAvBpK,EAAKuG,QAAQxG,IACf2J,EAAI3J,GAAOrG,EACXsG,EAAKA,EAAK3D,QAAU0D,IAEhBkL,EAAWvB,EAAI3J,cAIKtC,MACtBwN,EAASA,EAAS5O,QAAU3C,EAE5BgQ,EAAI3J,GAAO,CAACkL,EAAUvR,GAEV,KAAV+Q,EACJ,MACFK,EAAaC,EAAaJ,EAC1BK,EAAc,EACdjL,EAAMrG,EAAQ,GACduP,EAAUvL,EAAI,EACdkN,EAASC,EAAQ,CACnB,CAmEJ,CA+BA,OA5BIJ,EAAQ,IAAMxB,EAAUoB,EAAGhO,QAAUwO,EAAQ,KAC3C5B,EAAUoB,EAAGhO,SACXwO,EAAQP,EACVvK,GAAOsK,EAAG7P,MAAMyO,GACT2B,EAASL,IAChB7Q,GAAS2Q,EAAG7P,MAAMyO,KAElB6B,IACF/K,EAAMwJ,EAAUxJ,EAAKqK,IACnBW,IACFrR,EAAQ6P,EAAU7P,EAAO0Q,KAGA,IAAvBpK,EAAKuG,QAAQxG,IACf2J,EAAI3J,GAAOrG,EACXsG,EAAKA,EAAK3D,QAAU0D,IAEhBkL,EAAWvB,EAAI3J,cAIKtC,MACtBwN,EAASA,EAAS5O,QAAU3C,EAE5BgQ,EAAI3J,GAAO,CAACkL,EAAUvR,IAIrBgQ,CACT,C,0HCrYA,eAsDA,qBAyCElJ,YAAY0K,EAAgBC,GAC1BtR,KAAKqR,OAASA,EAEd,IAAI,MAAOnB,EAAGV,KAAMlQ,OAAOqJ,QAAQ2I,GACjCtR,KAAKkQ,GAAyBV,CAGlC,CAKA/H,aAAa8J,GAEX,MAAM5E,EAAM,IAAI6E,IAAIxR,KAAK2M,KAEzB,GAAoB,QAAhB3M,KAAKmK,OAGP,OAFAwC,EAAI8E,OAASjB,EAAGZ,UAAU2B,GACTvR,KAAKqR,OAAOK,GAAG/E,EAAIK,YACpBvI,MAElB,IAAI2F,EACJ,OAAQpK,KAAK2R,aACX,IAAK,oCACHvH,EAAOoG,EAAGZ,UAAU2B,GACpB,MACF,IAAK,mBACHnH,EAAOwH,KAAKhC,UAAU2B,GACtB,MACF,QACE,MAAM,IAAI5O,MAAM,wBAAwB3C,KAAK2R,+CAEjD,MAAME,QAAiB7R,KAAKqR,OAAOS,QAAQC,aAAapF,EAAIK,WAAY,CACtE7C,OAAQnK,KAAKmK,OACbC,OACArC,QAAS,CACP,eAAgB/H,KAAK2R,eAIzB,OADc3R,KAAKqR,OAAOW,oBAAoBrF,EAAIK,WAAY6E,EAGhE,GAGF,MAAaI,UAAuBtP,OAApC,kB,wGC9HA,qBAIEgE,cACE3G,KAAKkS,MAAQ,IAAIC,GACnB,CAOAC,MAAMhP,GACJpD,KAAKkS,MAAMxN,IACTtB,EAAMuJ,IACNvJ,EAAM0E,QAEV,CAKArD,IAAIkI,GAEF,MAAMvJ,EAAQpD,KAAKkS,MAAMzN,IAAIkI,GAC7B,OAAKvJ,EAGEA,EAAM0E,QAFJ,IAIX,CAKAwE,IAAIK,GAEF,OAAO3M,KAAKkS,MAAM5F,IAAIK,EAExB,CAKA0F,OAAO1F,GACL3M,KAAKkS,MAAMG,OAAO1F,EACpB,CAKA2F,QACEtS,KAAKkS,MAAMI,OACb,E,oICrEF,aAAS,8EAAAC,YAAY,IACrB,aAAS,4EAAAC,UAAU,IACnB,aAAS,4EAAAC,UAAU,G,sGCUnB,mBAOEL,MAAMhP,GAEN,CAKAqB,IAAIkI,GACF,OAAO,IACT,CAKAL,IAAIK,GAEF,OAAO,CAET,CAKA0F,OAAO1F,GAEP,CAKA2F,QAEA,E,wGClDF,eAcA,MAAaE,UAAmB,EAAAD,aAU9B5L,YAAY+L,EAAuB,KACjC9L,QACA5G,KAAK0S,aAAeA,EACpB1S,KAAK2S,aAAe,IAAIR,GAC1B,CAOAC,MAAMhP,GACJwD,MAAMwL,MAAMhP,GACZpD,KAAK4S,SAASxP,EAAMuJ,IACtB,CAEQiG,SAASjG,GAEX3M,KAAK2S,aAAarG,IAAIK,IACxBpE,aAAavI,KAAK2S,aAAalO,IAAIkI,IAQrC3M,KAAK2S,aAAajO,IAChBiI,EACAnE,YAAY,KACVxI,KAAKqS,OAAO1F,GACZ3M,KAAK2S,aAAaN,OAAO1F,EAAI,GAC5B3M,KAAK0S,cAGZ,EA7CF,c,oFCfA,cACA,SAEA,QASA,SACA,SAGA,SACA,SACA,SACA,SAwRA,SAASG,EAAwBC,EAAmBC,EAAwCC,GAErFA,IAAQA,EAAS,IAAIC,KAE1B,IAAI,MAAMtG,KAAOmG,EAEVE,EAAO1G,IAAIK,KACdqG,EAAOE,IAAIvG,GACPoG,EAAazG,IAAIK,IACnBkG,EAAwBE,EAAatO,IAAIkI,GAAOoG,EAAcC,IAMpE,OAAOA,CAET,CAMA,SAASG,EAAa/P,EAAcgQ,EAAqB,IAAIH,KAE3DG,EAAOF,IAAI9P,GACX,IAAI,MAAMiQ,KAAYjQ,EAAMkQ,cAC1BH,EAAaE,EAAUD,GAEzB,OAAOA,CAET,CArTA,gBA+CEzM,YAAY4M,GA7BZ,KAAAC,eAEI,CACA,iCAAkC,CAAC,EAAAC,gBAAiB,OACpD,uBAAwB,CAAC,EAAAA,gBAAiB,OAC1C,2BAA4B,CAAC,EAAAC,oBAAqB,OAClD,6BAA8B,CAAC,EAAAC,kBAAmB,OAClD,kCAAmC,CAAC,EAAAC,eAAgB,OACpD,mBAAoB,CAAC,EAAAH,gBAAiB,OACtC,YAAa,CAAC,EAAAI,iBAAkB,QAkJ7B,KAAAC,kBAA8C,IAAI3B,IA7HvDnS,KAAKuT,YAAcA,EACnBvT,KAAK8R,QAAU,IAAI,EAAAiC,QACnB/T,KAAK8R,QAAQkC,KAAI,aAAsBhU,OACvCA,KAAK8R,QAAQkC,KAAI,aAAiBhU,OAClCA,KAAK8R,QAAQkC,KAAI,gBACjBhU,KAAKkS,MAAQ,IAAI,EAAAK,aACjBvS,KAAKiU,UAAY,IAAI9B,GACvB,CASA+B,OAAgCjI,EAAakI,GAE3C,OAAOnU,KAAK0R,KAAKwC,OAAOjI,EAAKkI,EAE/B,CAkBAzC,GAAoB/E,GAElB,IAAIyH,EAQJ,GANEA,OADUjT,IAARwL,EACY3M,KAAKuT,YACK,iBAAR5G,GACF,IAAAtM,SAAQL,KAAKuT,YAAa5G,IAE1B,IAAAtM,SAAQsM,IAEnB3M,KAAKiU,UAAU3H,IAAI8H,GAAc,CACpC,MAAMC,EAAW,IAAI,UAASrU,KAAMoU,GAEpC,OADApU,KAAKiU,UAAUvP,IAAI0P,EAAaC,GACzBA,C,CAET,OAAOrU,KAAKiU,UAAUxP,IAAI2P,EAE5B,CASAJ,IAAIM,EAA6BC,EAAiB,KAEhDvU,KAAK8R,QAAQkC,IAAIM,EAAYC,EAE/B,CAKAC,aAEExU,KAAKkS,MAAMI,QACXtS,KAAK8T,kBAAoB,IAAI3B,GAE/B,CAQAsC,WAAWrR,GAGT,MAAMsR,EAAYvB,EAAa/P,GAG/B,IAAI,MAAMuR,KAAUD,EAClB,IAAI,MAAME,KAAaD,EAAOzI,MAAM2I,QAAQ,UAC1C7U,KAAK8U,oBAAmB,IAAAzU,SAAQuU,GAAYD,EAAOhI,KAKvD,IAAI,MAAMgI,KAAUD,EAClB1U,KAAKkS,MAAME,MAAMuC,GAInB,IAAI,MAAMA,KAAUD,EAAW,CAC7B,MAAML,EAAWrU,KAAKiU,UAAUxP,IAAIkQ,EAAOhI,KACvC0H,GAEFA,EAAShS,KAAK,SAAUsS,E,CAI9B,CAuBAG,mBAAmBC,EAAmBC,GAEhChV,KAAK8T,kBAAkBxH,IAAIyI,GAC7B/U,KAAK8T,kBAAkBrP,IAAIsQ,GAAY7B,IAAI8B,GAE3ChV,KAAK8T,kBAAkBpP,IAAIqQ,EAAW,IAAI9B,IAAI,CAAC+B,IAGnD,CAWAC,mBAAmBC,EAAqBC,GAEtC,IAAIC,EAAQ,IAAInC,IAChB,MAAMoC,EAAU,IAAIpC,IACpB,IAAI,MAAMtG,KAAOuI,EACfE,EAAMlC,KAAI,IAAA7S,SAAQL,KAAKuT,YAAa5G,IAEtC,IAAI,MAAMA,KAAOwI,EACfC,EAAMlC,KAAI,IAAA7S,SAAQL,KAAKuT,YAAa5G,IACpC0I,EAAQnC,KAAI,IAAA7S,SAAQL,KAAKuT,YAAa5G,IAGxCyI,EAAQvC,EACN,IAAII,IAAI,IAAImC,KAAUC,IACtBrV,KAAK8T,mBAGP,IAAI,MAAMnH,KAAOyI,EAAO,CACtBpV,KAAKkS,MAAMG,OAAO1F,GAElB,MAAM0H,EAAWrU,KAAKiU,UAAUxP,IAAIkI,GAChC0H,IACEgB,EAAQ/I,IAAIK,GACd0H,EAAShS,KAAK,UAEdgS,EAAShS,KAAK,S,CAOtB,CAKAoF,0BAA0BkF,EAAakF,GAErC,MAAMF,GAAc,IAAA2D,kBAAiBzD,EAAS9J,QAAQtD,IAAI,iBAE1D,OAAKkN,GAAmC,MAApBE,EAAS3J,OAIzByJ,KAAe3R,KAAKwT,eACfxT,KAAKwT,eAAe7B,GAAa,GAAG3R,KAAM2M,EAAKkF,GAC7CF,EAAY4D,WAAW,UAEzB,IAAAC,kBAAiBxV,KAAM2M,EAAKkF,GAC1BF,EAAY8D,MAAM,oCAEpB,IAAAhC,iBAAgBzT,KAAM2M,EAAKkF,IAE3B,IAAA6D,oBAAmB1V,KAAM2M,EAAKkF,IAZ9B,IAAA6D,oBAAmB1V,KAAM2M,EAAKkF,EAezC,E,gIClRF,MAAe8D,EAMbhP,cACE3G,KAAK4V,iBAAkB,EACvB5V,KAAK6V,yBAA0B,EAC/B7V,KAAK8V,gBAAiB,CACxB,CAEAC,WAEE,OADA/V,KAAK4V,iBAAkB,EAChB5V,IACT,CAEAgW,mBAEE,OADAhW,KAAK6V,yBAA0B,EACxB7V,IACT,CAQAiW,UAGE,OADAjW,KAAK8V,gBAAiB,EACf9V,IAET,EAsBF,MAAakW,UAAkCP,EAM7ChP,YAAY0N,EAAwCpI,EAAakI,GAE/DvN,QACA5G,KAAKqU,SAAWA,EAChBrU,KAAKiM,IAAMA,EACXjM,KAAKmU,UAAYA,CAEnB,CAQAgC,KACEC,EACAC,GAGA,OAAOrW,KAAKsW,sBAAsBH,KAAKC,EAAaC,EAEtD,CAKAE,MAAwCF,GAEtC,OAAOrW,KAAKsW,sBAAsBH,UAAKhV,EAAWkV,EAEpD,CAKAG,QAAwBC,GAEtB,OAAOzW,KAAKmW,MACV,IAAMM,MACN,IAAMA,KAGV,CASAvC,OAAsBjI,EAAakI,GAEjC,OAAO,IAAI+B,EAAiBlW,KAAKsW,sBAAuBrK,EAAKkI,EAE/D,CAOAuC,UAAyBzK,GAEvB,OAAO,IAAI0K,EAAkB3W,KAAKsW,sBAAuBrK,EAE3D,CAMQxE,4BAEN,MAAM4M,QAAiBrU,KAAKqU,SAEtBtM,EAAsC,CAAC,EAK7C,IAAI3E,GAJCpD,KAAK8V,gBAAkB9V,KAAK6V,0BAC/B9N,EAAQ6O,OAAS,cAAgB5W,KAAKiM,KAKtC7I,EADEpD,KAAK8V,qBACOzB,EAASwC,KAAK,CAAC9O,kBAEfsM,EAAS5P,IAAI,CACzBsD,YAIJ,MAAM+O,EAAc1T,EAAM8Q,OAAOlU,KAAKiM,IAAKjM,KAAKmU,WAShD,OAPInU,KAAK4V,iBACPkB,EAAYrS,MAAM8R,OAAO/V,IAEvBsC,QAAQC,KAAK,0CAA2CvC,EAAI,IAIzDsW,CAET,EA5GF,qBAkHA,MAAaH,UAAmChB,EAK9ChP,YAAY0N,EAAwCpI,GAElDrF,QACA5G,KAAKqU,SAAWA,EAChBrU,KAAKiM,IAAMA,CAEb,CAKAkK,KACEC,EACAC,GAGA,OAAOrW,KAAK+W,uBAAuBZ,KAAKC,EAAaC,EAEvD,CAKAE,MAAwCF,GAEtC,OAAOrW,KAAK+W,uBAAuBZ,UAAKhV,EAAWkV,EAErD,CAKAG,QAAwBC,GAEtB,OAAOzW,KAAKmW,MACV,IAAMM,MACN,IAAMA,KAGV,CAMQhP,6BAEN,MAAM4M,QAAiBrU,KAAKqU,SACtBtM,EAAsC,CAAC,EAK7C,IAAI3E,GAJCpD,KAAK8V,gBAAkB9V,KAAK6V,0BAC/B9N,EAAQ6O,OAAS,cAAgB5W,KAAKiM,KAKtC7I,EADEpD,KAAK8V,qBACOzB,EAASwC,KAAK,CAAC9O,kBAEfsM,EAAS5P,IAAI,CACzBsD,YAIJ,MAAMqL,EAAwBhQ,EAAMsT,UAAU1W,KAAKiM,KAWnD,OATIjM,KAAK4V,iBACPxC,EAAOxK,KAAKyL,IACVA,EAAS5P,MAAM8R,OAAO/V,IAEpBsC,QAAQC,KAAK,0CAA2CvC,EAAI,GAC5D,IAIC4S,CAET,EAhFF,qB,oFC9KA,eAEA,UAAe,CAAC7J,EAAkBC,KAEhC,MAAMwN,EAAkB,SAAWC,EAAOzQ,OAAO+C,EAAW,IAAMC,GAElE,MAAO,CAAC0N,EAASC,KAEfD,EAAQnP,QAAQrD,IAAI,gBAAiBsS,GAC9BG,EAAKD,GAEb,C,kFCVH,UAAgB7P,IAEd,MAAM+P,EAAmB,UAAY/P,EAErC,MAAO,CAAC6P,EAASC,KAEfD,EAAQnP,QAAQrD,IAAI,gBAAiB0S,GAC9BD,EAAKD,GAEb,C,+GCJH,MAAaG,UAAkB1U,MAK7BgE,YAAYkL,GACVjL,MAAM,cAAgBiL,EAAS3J,QAC/BlI,KAAK6R,SAAWA,EAChB7R,KAAKkI,OAAS2J,EAAS3J,MACzB,EATF,cAoBA,MAAaoP,UAAgBD,EAW3B1Q,YAAYkL,EAAoB0F,G,QAC9B3Q,MAAMiL,GAEN7R,KAAKoK,KAAO,OAAH,QACPvI,KAAsB,QAAhB,EAAA0V,EAAY1V,YAAI,QAAI,cAC1BqG,OAA0B,QAAlB,EAAAqP,EAAYrP,cAAM,QAAIlI,KAAKkI,QAChCqP,GAGDvX,KAAKoK,KAAKoN,QACZxX,KAAKkF,QAAU,cAAgBlF,KAAKkI,OAAS,KAAOlI,KAAKoK,KAAKoN,MAElE,EAvBF,YAqCA,UAAe/P,eAA8BoK,GAE3C,MAAMF,EAAcE,EAAS9J,QAAQtD,IAAI,gBACzC,GAAIkN,aAAW,EAAXA,EAAa8D,MAAM,gCAAiC,CACtD,MAAM8B,QAAoB1F,EAASvH,OACnC,OAAO,IAAIgN,EAAQzF,EAAU0F,E,CAE7B,OAAO,IAAIF,EAAUxF,EAGzB,C,qHC1EA,eACA,OAYA,MAAakC,EAAb,cAEE,KAAA0D,YAA2C,GAE3C,KAAAC,kBAA4B,CA6E9B,CArEE9P,MAAMyM,EAA0BtU,GAE9B,MAAMmX,EAAU,IAAIxP,QAAQ2M,EAAUtU,GAEhCwU,EAAS,IAAI/C,IAAI0F,EAAQS,KAAKpD,OAC9BqD,EAAM5X,KAAK6X,uBAAuBtD,GAWxC,OAVAqD,EAAIrV,MAAMuV,KAEHA,EAAa/P,QAAQuE,IAAI,eAAiBtM,KAAK0X,kBAElDI,EAAa/P,QAAQrD,IAAI,aAAc,WAAa,WAG/CkD,MAAMkQ,MAGRC,EAAkBH,EAAKV,EAEhC,CAMAW,uBAAuBtD,GAErB,OAAOvU,KAAKyX,YAAYO,QAAQ,EAAEC,KACzBA,EAAMvM,KAAK6I,KAEjB3L,KAAK,EAAE,CAAE0L,KACHA,GAGX,CAKAN,IAAIkE,EAAqB3D,EAAiB,KAExC,MACM4D,EADa5D,EAAOjH,MAAM,KACF1E,KAC5BwP,GACEA,EAAK5M,QAAQ,sBAAuB,UACtC1C,KAAK,QAEDmP,EAAQ,IAAII,OAAO,IAAMF,EAAa,KAC5CnY,KAAKyX,YAAYlV,KAAK,CAAC0V,EAAOC,GAEhC,CAQAzQ,mBAAmB4M,EAA0BtU,GAE3C,MAAM8R,QAAiB7R,KAAK4H,MAAMyM,EAAUtU,GAE5C,GAAI8R,EAAS5J,GACX,OAAO4J,EAEP,YAAY,aAAeA,EAG/B,EAKF,SAASkG,EAAkBH,EAAwBV,GAEjD,OAAOU,EAAI,GACTV,GACCoB,GACQP,EAAkBH,EAAIjX,MAAM,GAAI2X,IAI7C,CA7FA,YAkFA,UAAevE,C,oFC9Ff,cAEA,UAAe,CAACwE,EAAqDlR,KAEnE,MAAMmR,EAAS,IAAI,EAAA1N,OAAOyN,EAAelR,GACzC,OAAOmR,EAAO7Q,QAAQrE,KAAKkV,EAAO,C,6JCNpC,eACA,SAKA,4BAAiC7G,GAE/B,OAAKA,GAGDA,EAAY8G,SAAS,OACvB9G,EAAcA,EAAYrE,MAAM,KAAK,IAEhCqE,EAAYpG,QALV,IAOX,EAGA,qBAA0BpG,EAAiBuT,GAEzC,MAAMtF,EAAS,IAAI,EAAAuF,MAAMxT,GACzB,IAAKuT,EACH,OAAOtF,EAGT,IAAK,MAAMwF,KAAYC,EAAW7M,MAAM0M,GAAQ3M,KAE9C,IAAK,MAAME,KAAO2M,EAAS3M,IAAIqB,MAAM,KAAM,CAEzC,MAAMjB,EAAO,CACXJ,IAAKA,EACL6M,KAAMF,EAASjM,IACfxH,UACAqS,MAAOoB,EAASpB,MAChBuB,SAAUH,EAASG,SACnBlX,KAAM+W,EAAS/W,MAEjBuR,EAAOF,IAAI7G,E,CAGf,OAAO+G,CACT,EAEA,MAAM4F,EAAc,CAAC,MAAO,OAAQ,UAAW,MAAO,WAAY,SAAU,SAAU,SAEtF,wBAA6B7O,GAC3B,OAAO6O,EAAYP,SAAStO,EAC9B,EAUa,EAAA8O,kBAAoB,CAC/B,eACA,mBACA,mBACA,cACA,OACA,UACA,gBACA,SACA,QACA,U,kHCnEF,eAkEA,MAAaN,EAIXhS,YAAmBuS,EAAwBhN,GAIzC,GAJiB,KAAAgN,eAAAA,EAEjBlZ,KAAKoS,MAAQ,IAAID,IAEbjG,EACF,GAAIA,aAAiByM,EACnB3Y,KAAKkT,OAAOhH,EAAMiN,eAElB,IAAK,MAAM9M,KAAQH,EACjBlM,KAAKkT,IAAI7G,EAKjB,CAOA6G,OAAOjU,GAEL,IAAIiN,EAGFA,EADqB,iBAAZjN,EAAK,GACN,CAAC,CACPgN,IAAKhN,EAAK,GACV6Z,KAAM7Z,EAAK,GACXkG,QAASnF,KAAKkZ,iBAGRja,EAAK2J,KAAKyD,GAAiB,OAAP,QAASlH,QAASnF,KAAKkZ,gBAAmB7M,KAGxE,IAAI,MAAMA,KAAQH,EACZlM,KAAKoS,MAAM9F,IAAID,EAAKJ,KACtBjM,KAAKoS,MAAM3N,IAAI4H,EAAKJ,KAAM1J,KAAK8J,GAE/BrM,KAAKoS,MAAM1N,IAAI2H,EAAKJ,IAAK,CAACI,GAIhC,CASA3H,IAAI0U,EAAWC,GAEb,IAAIhN,EAEFA,EADkB,iBAAT+M,EACF,CACLnN,IAAKmN,EACLN,KAAMO,EACNlU,QAASnF,KAAKkZ,gBAGT,OAAH,QACF/T,QAASnF,KAAKkZ,gBACXE,GAGPpZ,KAAKoS,MAAM1N,IAAI2H,EAAKJ,IAAK,CAACI,GAE5B,CAOA5H,IAAIwH,GAEF,MAAMC,EAAQlM,KAAKoS,MAAM3N,IAAIwH,GAC7B,GAAKC,KAASA,EAAM1J,OAAS,GAG7B,OAAO0J,EAAM,EAEf,CAQAmG,OAAOpG,EAAa6M,GAElB,QAAW3X,IAAP2X,EAEF,YADA9Y,KAAKoS,MAAMC,OAAOpG,GAIpB,MAAM6G,EAAO9S,KAAKoS,MAAM3N,IAAIwH,GAC5B,IAAK6G,EAAM,OAEX9S,KAAKoS,MAAMC,OAAOpG,GAClB,MAAMqN,GAAU,IAAAjZ,SAAQL,KAAKkZ,eAAgBJ,GAC7C9Y,KAAKoS,MAAM1N,IAAIuH,EACb6G,EAAKkF,QAAOrL,IAAO,IAAAtM,SAAQsM,KAAS2M,IAExC,CAOAzE,QAAQ5I,GAEN,OAAOjM,KAAKoS,MAAM3N,IAAIwH,IAAQ,EAEhC,CAKAkN,SACE,MAAM/F,EAAS,GACf,IAAI,MAAMlH,KAASlM,KAAKoS,MAAMmH,SAC5BnG,EAAO7Q,QAAQ2J,GAEjB,OAAOkH,CACT,CAKA9G,IAAIL,GAEF,OAAOjM,KAAKoS,MAAM9F,IAAIL,EAExB,EA9IF,UAsJA,MAAauN,UAAqB7W,OAAlC,gB,kFChNA,mBAAwB0O,GAEtB,OAAO5J,MAAMyP,EAASC,KAEpB,IAAKD,EAAQnP,QAAQuE,IAAI,UAAW,CAClC,MAAMmN,EAAena,OAAOqJ,QAAQ0I,EAAOmC,gBAAgB5K,KACzD,EAAE+I,GAAc,CAAE+H,MAAQ/H,EAAc,MAAQ+H,IAChD5Q,KAAK,MACPoO,EAAQnP,QAAQrD,IAAI,SAAU+U,E,CAEhC,OAAOtC,EAAKD,EAAQ,CAIxB,C,oFCtBA,eACA,SACA,SAYA,mBAAwB7F,GAEtB,OAAO5J,MAAMyP,EAASC,KAMpB,IAAIwC,GAAe,EAEfzC,EAAQnP,QAAQuE,IAAI,wBACtBqN,GAAe,EACfzC,EAAQnP,QAAQsK,OAAO,uBAGzB,MAAMR,QAAiBsF,EAAKD,GAE5B,IAAI,IAAA0C,cAAa1C,EAAQ/M,QACvB,OAAO0H,EAGT,IAAKA,EAAS5J,GAEZ,OAAO4J,EAIT,MAAMuD,EAAQ,GACRC,EAAU,GAUhB,GARuB,WAAnB6B,EAAQ/M,OACVkL,EAAQ9S,KAAK2U,EAAQS,KACXgC,GACVvE,EAAM7S,KAAK2U,EAAQS,KAKjB9F,EAAS9J,QAAQuE,IAAI,QACvB,IAAK,MAAMsM,KAAYC,EAAW7M,MAAM6F,EAAS9J,QAAQtD,IAAI,SAAUwH,IAAI,eAAgB,CACzF,MAAMU,GAAM,IAAAtM,SAAQ6W,EAAQS,IAAKiB,EAASjM,KAC1CyI,EAAM7S,KAAKoK,E,CAgBf,GAXIkF,EAAS9J,QAAQuE,IAAI,aACvB8I,EAAM7S,MACJ,IAAAlC,SAAQ6W,EAAQS,IAAK9F,EAAS9J,QAAQtD,IAAI,cAI9C4M,EAAO4D,mBAAmBG,EAAOC,GAK7BxD,EAAS9J,QAAQuE,IAAI,oBAAqB,CAC5C,MAAMuN,GAAK,IAAAxZ,SAAQ6W,EAAQS,IAAK9F,EAAS9J,QAAQtD,IAAI,qBAC/CqV,QAAgBzI,EAAOW,oBAC3B6H,EACAhI,GAEFR,EAAOoD,WAAWqF,E,CAGpB,OAAOjI,CAAQ,CAInB,C,oFCpFA,eACA,SAQA,qBAEE,OAAOpK,MAAMyP,EAASC,KAEpB,MAAMtF,QAAiBsF,EAAKD,GAE5B,GADoBrF,EAAS9J,QAAQtD,IAAI,eACxB,CACf,MAAMsV,EAASlI,EAAS9J,QAAQtD,IAAI,UACpC,IAAIuV,EAAM,0BAA0B9C,EAAQS,qBAI5C,GAHIoC,IACFC,GAAO,8BAAgCD,GAErClI,EAAS9J,QAAQuE,IAAI,QACvB,IAAK,MAAMsM,KAAYC,EAAW7M,MAAM6F,EAAS9J,QAAQtD,IAAI,SAAUwH,IAAI,eAEzE+N,GAAO,QADK,IAAA3Z,SAAQ6W,EAAQS,IAAKiB,EAASjM,6BAM9C7J,QAAQC,KAAKiX,E,CAGf,OAAOnI,CAAQ,CAInB,C,sGCpCA,cACA,SACA,SACA,SACA,SAEA,SAQA,MAAaoI,UAA0B,EAAAna,aAyBrC6G,YAAY0K,EAAgB1E,GAC1B/F,QARe,KAAAU,cAAgD,IAAI6K,IASnEnS,KAAKqR,OAASA,EACdrR,KAAK2M,IAAMA,EACX3M,KAAK6E,gBAAgB,IAEvB,CAOAJ,IAAIyV,GAEF,MAAM9W,EAAQpD,KAAKma,WACnB,GAAI/W,EACF,OAAOhD,QAAQC,QAAQ+C,GAGzB,MAAMgX,EAASC,EAAqB,MAAOH,GACrCvN,EAAM3M,KAAK2M,IAEX2N,EAAOC,EAAYva,KAAK2M,IAAKuN,GAenC,OAbKla,KAAKsH,cAAcgF,IAAIgO,IAC1Bta,KAAKsH,cAAc5C,IAAI4V,EAAM,WAC3B,IACE,MAAMzI,QAAiB7R,KAAK+R,aAAaqI,GACnChX,QAAcpD,KAAKqR,OAAOW,oBAAoBrF,EAAKkF,GAEzD,OADA7R,KAAKwa,YAAYpX,GACVA,C,SAEPpD,KAAKsH,cAAc+K,OAAOiI,E,CAE7B,EAT4B,IAYxBta,KAAKsH,cAAc7C,IAAI6V,EAChC,CAQA7S,WAAWgT,GAET,IAAIrX,EAA8BpD,KAAKqR,OAAOa,MAAMzN,IAAIzE,KAAK2M,KAC7D,GAAIvJ,EACF,OAAOA,EAGT,MAAMyO,QAAiB7R,KAAK+R,aAC1BsI,EAAqB,OAAQI,IAI/B,OADArX,QAAc,IAAAsX,kBAAiB1a,KAAKqR,OAAQrR,KAAK2M,IAAKkF,GAC/CzO,CAET,CASAuX,QAAQT,GAEN,MAAME,EAASC,EAAqB,MAAOH,GAC3CE,EAAOlI,MAAQ,WACf,MAAMvF,EAAM3M,KAAK2M,IAEX2N,EAAOC,EAAYva,KAAK2M,IAAKuN,GAenC,OAbKla,KAAKsH,cAAcgF,IAAIgO,IAC1Bta,KAAKsH,cAAc5C,IAAI4V,EAAM,WAC3B,IACE,MAAMzI,QAAiB7R,KAAK+R,aAAaqI,GACnChX,QAAcpD,KAAKqR,OAAOW,oBAAoBrF,EAAKkF,GAEzD,OADA7R,KAAKwa,YAAYpX,GACVA,C,SAEPpD,KAAKsH,cAAc+K,OAAOiI,E,CAE7B,EAT4B,IAYxBta,KAAKsH,cAAc7C,IAAI6V,EAChC,CAKA7S,UAAUP,GAER,MAAM0T,EAAcP,EAAqB,MAAOnT,IAU5C,IAAA2T,SAAQ3T,IACV0T,EAAY7S,QAAQrD,IAAI,qBAAsB,WAG1C1E,KAAK+R,aAAa6I,IAEpB,IAAAC,SAAQ3T,IACVlH,KAAKwa,YAAYtT,EAIrB,CAKAO,qBAEQzH,KAAK+R,aACT,CAAE5H,OAAQ,UAGd,CAUA1C,WAAWP,GAET,MAAM2K,QAAiB7R,KAAK+R,aAC1BsI,EAAqB,OAAQnT,IAG/B,OAAOlH,KAAKqR,OAAOW,oBAAoBhS,KAAK2M,IAAKkF,EAEnD,CAWApK,iBAAiBP,GAEf,MAAM2K,QAAiB7R,KAAK+R,aAC1BsI,EAAqB,OAAQnT,IAG/B,OAAQ2K,EAAS3J,QACf,KAAK,IACH,GAAI2J,EAAS9J,QAAQuE,IAAI,YACvB,OAAOtM,KAAK0R,GAAGG,EAAS9J,QAAQtD,IAAI,aAEtC,MAAM,IAAI9B,MAAM,+MAClB,KAAK,IACL,KAAK,IACH,OAAO3C,KACT,QACE,MAAM,IAAI2C,MAAM,6FAGtB,CASA8E,YAAYP,GAEV,MAAM2K,QAAiB7R,KAAK+R,aAC1BsI,EAAqB,QAASnT,IAGhC,GAAwB,MAApB2K,EAAS3J,OACX,aAAalI,KAAKqR,OAAOW,oBAAoBhS,KAAK2M,IAAKkF,EAE3D,CASAqC,OAAgCjI,EAAakI,GAE3C,OAAO,IAAI,EAAA+B,iBAAiBlW,KAAMiM,EAAKkI,EAEzC,CAQAuC,UAAmCzK,GAEjC,OAAO,IAAI,EAAA0K,kBAAkB3W,KAAMiM,EAErC,CAUAyF,GAAsB/E,GAEpB,MAAmB,iBAARA,EACF3M,KAAKqR,OAAOK,IAAG,IAAArR,SAAQL,KAAK2M,IAAKA,IAEjC3M,KAAKqR,OAAOK,GAAG/E,EAG1B,CAKA/E,MAAM7H,GAEJ,OAAOC,KAAKqR,OAAOS,QAAQlK,MAAM5H,KAAK2M,IAAK5M,EAE7C,CAQAgS,aAAahS,GAEX,OAAOC,KAAKqR,OAAOS,QAAQC,aAAa/R,KAAK2M,IAAK5M,EAEpD,CAOAya,YAAYpX,GAEV,GAAIA,EAAMuJ,MAAQ3M,KAAK2M,IACrB,MAAM,IAAIhK,MAAM,0GAElB3C,KAAKqR,OAAOoD,WAAWrR,EAEzB,CAKAoR,aAEExU,KAAKqR,OAAO4D,mBAAmB,CAACjV,KAAK2M,KAAK,GAE5C,CAMAwN,WAEE,OAAOna,KAAKqR,OAAOa,MAAMzN,IAAIzE,KAAK2M,IAEpC,CASAlF,WAAWwE,GAET,MACMI,SADcrM,KAAKyE,OACNyH,MAAMzH,IAAIwH,GAE7B,IAAKI,EACH,MAAM,IAAI,EAAAmN,aAAa,kBAAkBvN,kBAAoBjM,KAAK2M,OAEpE,OAAON,CAET,CAOA5E,YAAYwE,GAEV,MAAM7I,QAAcpD,KAAKyE,MACzB,OAAKwH,EAGI7I,EAAM8I,MAAM2I,QAAQ5I,GAFpB7I,EAAM8I,MAAMiN,QAKvB,CASA1R,cAAcwE,GAGZ,aADoBjM,KAAKyE,OACZyH,MAAMI,IAAIL,EAEzB,EAsGF,SAASoO,EAAqBlQ,EAAgBjD,GAE5C,IAAKA,EACH,MAAO,CACLiD,SACApC,QAAS,IAAI+S,SAGjB,IAAI/S,EAWAqC,EAWJ,OApBErC,EADEb,EAAQ6T,kBACA,IAAID,QAAQ5T,EAAQ6T,qBACrB7T,EAAQa,QACP,IAAI+S,QAAQ5T,EAAQa,SAEpB,IAAI+S,QAEX/S,EAAQuE,IAAI,iBACfvE,EAAQrD,IAAI,eAAgB,yBAGSvD,IAAlC+F,EAAgB8T,cACnB5Q,EAAQlD,EAAgB8T,gBACd9T,EAAgB4G,MAC1B1D,EAAQlD,EAAgB4G,MACpB,IAAAmN,oBAAmB7Q,KACrBA,EAAOwH,KAAKhC,UAAUxF,KAGxBA,EAAO,KAEF,CACLD,SACAC,OACArC,UAGJ,CAEA,SAASwS,EAAY5N,EAAazF,G,MAEhC,MAAMa,EAAkC,CAAC,EAYzC,OAXIb,GACF,IAAI4T,SAAiC,QAAzB,EAAA5T,EAAQ6T,yBAAiB,yBAAQ7T,EAAQa,SAClDmT,SAAQ,CAACrb,EAAOqG,KACf6B,EAAQ7B,GAAOrG,CAAK,IAQnB8M,EAAM,IAJKrN,OAAOqJ,QAAQZ,GAASa,KAAK,EAAEzI,EAAMN,KAC9CM,EAAKgM,cAAgB,IAAMtM,IACjCiJ,KAAK,IAGV,CA3gBA,aAscA,UAAemR,C,qHCpdf,eAEA,QAEA,SACA,SACA,SA2BA,MAAakB,EAwBXxU,YAAY5G,GACVC,KAAKqR,OAAStR,EAAKsR,OACnBrR,KAAK2M,IAAM5M,EAAK4M,IAChB3M,KAAK+H,QAAUhI,EAAKgI,QACpB/H,KAAKob,UAAYjT,KAAKC,MACtBpI,KAAKkM,MAAQnM,EAAKmM,KACpB,CASAgI,OAAgCjI,EAAakI,G,MAE3C,MAAM9H,EAAOrM,KAAKkM,MAAMzH,IAAIwH,GAC5B,IAAKI,EAAM,MAAM,IAAI,EAAAmN,aAAa,iBAAiBvN,QAAUjM,KAAK2M,iBAElE,IAAImM,EAYJ,OATEA,EADEzM,EAAKgP,WACA,IAAAC,QAAOjP,EAAM8H,GAAa,CAAC,IAE3B,IAAA9T,SAAQgM,GAEU,gBAAb,QAAV,EAAAA,EAAKkP,aAAK,eAAErT,SAEdpF,QAAQC,KAAK,iBAAiBsJ,EAAKJ,eAAejM,KAAK2M,4BAA6BN,GAG/ErM,KAAKqR,OAAOK,GAAGoH,EAExB,CAQApC,UAAmCzK,GAEjC,OAAOjM,KAAKkM,MAAM2I,QAAQ5I,GAAKrD,KAAKyD,I,MAEP,gBAAb,QAAV,EAAAA,EAAKkP,aAAK,eAAErT,SAEdpF,QAAQC,KAAK,iBAAiBsJ,EAAKJ,eAAejM,KAAK2M,4BAA6BN,GAEtF,MAAMyM,GAAO,IAAAzY,SAAQgM,GACrB,OAAOrM,KAAKqR,OAAOK,GAAGoH,EAAK,GAI/B,CAWA0C,iBAEE,MAAMpI,EAAmC,CAAC,EAE1C,IAAI,MAAMqI,KAAiB,EAAAxC,kBACrBjZ,KAAK+H,QAAQuE,IAAImP,KACnBrI,EAAOqI,GAAiBzb,KAAK+H,QAAQtD,IAAIgX,IAG7C,OAAO,IAAIX,QAAQ1H,EAErB,EArGF,kBA4GA,MAAasI,UAAqBP,EAQhCxU,YAAY5G,GAEV6G,MAAM7G,GACNC,KAAK8N,KAAO/N,EAAK+N,KACjB9N,KAAK2b,WAAa5b,EAAK6b,SAAW,GAClC5b,KAAKqT,SAAWtT,EAAKsT,UAAY,EAEnC,CAQAwI,OAAoD1b,GAElD,IAAKH,KAAK2b,WAAWnZ,OACnB,MAAM,IAAI,EAAAyP,eAAe,0CAE3B,QAAa9Q,IAAThB,EACF,OAAO,IAAI,EAAA2b,aAAa9b,KAAKqR,OAAQrR,KAAK2b,WAAW,IAEvD,IAAI,MAAME,KAAU7b,KAAK2b,WACvB,GAAIE,EAAO1b,OAASA,EAClB,OAAO,IAAI,EAAA2b,aAAa9b,KAAKqR,OAAQwK,GAGzC,MAAM,IAAI,EAAA5J,eAAe,+BAE3B,CAKA2J,UAEE,OAAO5b,KAAK2b,WAAW/S,KAAIiT,GAAU,IAAI,EAAAC,aAAa9b,KAAKqR,OAAQwK,IAErE,CAOAE,UAAU5b,GAER,QAAWgB,IAAPhB,EAAkB,OAAOH,KAAK2b,WAAWnZ,OAAO,EACpD,IAAI,MAAMqZ,KAAU7b,KAAK2b,WACvB,GAAIxb,IAAS0b,EAAO1b,KAClB,OAAO,EAGX,OAAO,CAET,CASA6a,gBAEE,OACI,EAAAgB,EAAehO,QAAUhO,KAAK8N,gBAAgBE,QAC9C,EAAAgO,EAAeC,MAAQjc,KAAK8N,gBAAgBmO,MACzB,iBAAdjc,KAAK8N,KAEL9N,KAAK8N,KAEP8D,KAAKhC,UAAU5P,KAAK8N,KAE7B,CAWAwF,cAEE,OAAOtT,KAAKqT,QAEd,CAEAvL,QAEE,OAAO,IAAI4T,EAAU,CACnBrK,OAAQrR,KAAKqR,OACb1E,IAAK3M,KAAK2M,IACVmB,KAAM9N,KAAK8N,KACX/F,QAAS,IAAI+S,QAAQ9a,KAAK+H,SAC1BmE,MAAO,IAAI,EAAAyM,MAAM3Y,KAAKkM,MAAMgN,eAAgBlZ,KAAKkM,MAAMiN,UACvDyC,QAAS5b,KAAK2b,YAGlB,EAhHF,a,qGC9IA,aAEA,SAKa,EAAAvd,QAA8BqJ,MAAO4J,EAAQ1E,EAAKkF,IAEtD,IAAI,EAAA6J,UAAU,CACnBrK,SACA1E,MACAmB,WAAY+D,EAASqK,OACrBnU,QAAS8J,EAAS9J,QAClBmE,OAAO,IAAAiQ,WAAUxP,EAAKkF,EAAS9J,QAAQtD,IAAI,U,kdCd/C,aACA,SAOA,MAAa2X,UAAyB,EAAAV,UAEpCV,gBAEE,MAAM,IAAIrY,MAAM,mJAClB,EALF,YAYa,EAAAvE,QAAwBqJ,MAAO4J,EAAQ1E,EAAKkF,KAEvD,MAAMzH,QAAayH,EAASvH,OAEtB4B,GAAQ,IAAAiQ,WAAUxP,EAAKkF,EAAS9J,QAAQtD,IAAI,SAClDyH,EAAMgH,OA0ER,SAAsBmJ,EAAoBjS,GAExC,MAAMgJ,EAAiB,GACvB,QAA8BjS,IAA1BiJ,EAAKkS,WAAWpQ,MAGlB,IAAK,MAAMG,KAAQjC,EAAKkS,WAAWpQ,MACjCkH,EAAO7Q,KAAK,CACV4C,QAASkX,EACTvD,KAAMzM,EAAKyM,KACX7M,IAAKI,EAAKJ,IACVuL,MAAOnL,EAAKlM,OAKlB,QAA8BgB,IAA1BiJ,EAAKkS,WAAWC,MAIlB,IAAK,MAAMrO,KAAQ9D,EAAKkS,WAAWC,MAE5BrO,EAAK4K,MAIV1F,EAAO7Q,KAAK,CACV4C,QAASkX,EACTvD,KAAM5K,EAAK4K,KACX7M,IAAK,SAOX,QAAgC9K,IAA5BiJ,EAAKkS,WAAWE,QAGlB,IAAK,MAAMC,KAASrS,EAAKkS,WAAWE,QAE7BC,EAAM3O,KAUTsF,EAAO7Q,KAAK,CACV4C,QAASkX,EACTvD,KAAM2D,EAAM3D,KAAO2D,EAAM3O,KAAKlF,KAC5B8T,GAAY,KAAOA,EAASvc,KAAO,MACnC2I,KAAK,IACPuS,WAAW,EACXpP,IAAKwQ,EAAMxQ,IACXuL,MAAOiF,EAAMtc,OAffiT,EAAO7Q,KAAK,CACV4C,QAASkX,EACTvD,KAAM2D,EAAM3D,KACZ7M,IAAKwQ,EAAMxQ,IACXuL,MAAOiF,EAAMtc,OAkBrB,OAAOiT,CAET,CA5IOuJ,CAAahQ,EAAKvC,IAIvB,MAAM,UACJwS,EAAS,OACTC,GAEEzS,EADC0S,EAAO,EACR1S,EAJE,wBAMN,OAAO,IAAIgS,EAAQ,CACjB/K,SACA1E,MACAmB,KAAMgP,EACN/U,QAAS8J,EAAS9J,QAClBmE,SACA,C,mdC1CJ,aACA,SACA,SACA,SAUA,MAAa6Q,UAA0B,EAAArB,UAErCV,gBAEE,OAAOpJ,KAAKhC,UAAU,OAAD,QACnBiN,OAAQ7c,KAAKgd,kBACVhd,KAAK8N,MAGZ,CAEQkP,iBAEN,MAAM9Q,EAAmC,CACvCzN,KAAM,CAAEqa,KAAM9Y,KAAK2M,MAErB,IAAI,MAAMN,KAAQrM,KAAKkM,MAAMiN,SAAU,CAErC,MAAM,IAAElN,EAAG,QAAE9G,GAA2BkH,EAAf4Q,EAAU,EAAK5Q,EAAlC,mBAEM,SAARJ,SAKe9K,IAAf+K,EAAMD,GAERC,EAAMD,GAAQgR,EACLrZ,MAAMmJ,QAAQb,EAAMD,IAE5BC,EAAMD,GAAuB1J,KAAK0a,GAGnC/Q,EAAMD,GAAO,CAACC,EAAMD,GAAqBgR,G,CAK7C,OAAO/Q,CAET,CAEApE,QAEE,OAAO,IAAIiV,EAAS,CAClB1L,OAAQrR,KAAKqR,OACb1E,IAAK3M,KAAK2M,IACVmB,KAAM9N,KAAK8N,KACX/F,QAAS,IAAI+S,QAAQ9a,KAAK+H,SAC1BmE,MAAO,IAAI,EAAAyM,MAAM3Y,KAAKkM,MAAMgN,eAAgBlZ,KAAKkM,MAAMiN,UACvDyC,QAAS5b,KAAK2b,YAGlB,EAiDF,SAASuB,EAAc/X,EAAiBiF,G,QAEtC,QAAoBjJ,IAAhBiJ,EAAKyS,OACP,MAAO,GAGT,MAAMzJ,EAAiB,GASjB+J,EAAa,IAAIlK,IAEvB,IAAK,MAAOmK,EAASlR,KAAU5M,OAAOqJ,QAAQyB,EAAKyS,QAAS,CAE1D,MAAMQ,EAAWzZ,MAAMmJ,QAAQb,GAASA,EAAQ,CAACA,GAEjD,IAAK,MAAMG,KAAQgR,EACjBF,EAAWjK,IAAIkK,EAAU,IAAM/Q,EAAKyM,MAGtC1F,EAAO7Q,QACF+a,EAAanY,EAASiY,EAASC,G,CAMtC,GAAIjT,EAAKwS,UAEP,IAAK,IAAK3Q,EAAKsR,KAAgBje,OAAOqJ,QAAQyB,EAAKwS,WAAY,CAExDhZ,MAAMmJ,QAAQwQ,KACjBA,EAAc,CAACA,IAGjB,IAAI,MAAMC,KAAaD,EAAa,CAElC,MAAMzE,EAAqC,QAAvB,EAAiB,QAAjB,EAAA0E,aAAS,EAATA,EAAWX,cAAM,eAAEpe,YAAI,eAAEqa,KACxCA,IAIDqE,EAAW7Q,IAAIL,EAAM,IAAM6M,IAG/B1F,EAAO7Q,KAAK,CACV0J,IAAKA,EACL6M,KAAMA,EACN3T,QAASA,I,EASjB,OAAOiO,CAET,CAKA,SAASkK,EAAanY,EAAiB8G,EAAaC,GAElD,MAAMkH,EAAiB,GAEvB,IAAK,MAAM/G,KAAQH,EACjBkH,EAAO7Q,KAAK,OAAD,QACT0J,MACA9G,WACGkH,IAIP,OAAO+G,CAET,CAMA,SAASqK,EAAiBpM,EAAgBlM,EAAiBiF,EAAuBrC,G,QAEhF,QAAuB5G,IAAnBiJ,EAAKwS,YAA4BxS,EAAKwS,UACxC,MAAO,GAGT,MAAMxJ,EAA0B,GAEhC,IAAK,MAAMC,KAAY/T,OAAOia,OAAOnP,EAAKwS,WAAY,CAEpD,IAAIc,EAKFA,EAHG9Z,MAAMmJ,QAAQsG,GAGFA,EAFA,CAACA,GAKlB,IAAK,MAAMsK,KAAgBD,EAAc,CAEvC,QAAwCvc,KAAX,QAAzB,EAAmB,QAAnB,EAAAwc,EAAad,cAAM,eAAEpe,YAAI,eAAEqa,MAAoB,CAEjDhW,QAAQC,KAAK,8EACb,Q,CAGF,MAAM6a,GAAe,IAAAvd,SAAQ8E,EAASwY,EAAad,OAAOpe,KAAKqa,OAGzD,UACJ8D,EAAS,OACTC,GAEEc,EADCb,EAAO,EACRa,EAJE,wBAMNvK,EAAO7Q,KAAK,IAAIwa,EAAS,CACvB1L,SACA1E,IAAKiR,EACL9P,KAAMgP,EACN/U,QAAS,IAAI+S,QAAQ,CACnB,eAAgB/S,EAAQtD,IAAI,kBAE9ByH,MAAO,IAAI,EAAAyM,MAAMiF,EAAcV,EAAc/X,EAASwY,IAGtDtK,SAAUoK,EAAiBpM,EAAQuM,EAAcD,EAAc5V,GAC/D6T,QAASiC,EAAcD,EAAcD,K,EAK3C,OAAOvK,CAET,CAEA,SAASyK,EAAc1Y,EAAiBiF,GAEtC,OAAKA,EAAK0T,WAEHxe,OAAOqJ,QAAQyB,EAAK0T,YAAYlV,KAAK,EAAE1C,EAAK6X,MAC1C,CACLpR,KAAK,IAAAtM,SAAQ8E,EAAS4Y,EAAGhf,QAAU,IACnCoB,KAAM+F,EACNsR,MAAOuG,EAAGvG,MACVrN,OAAQ4T,EAAG5T,OACXwH,YAAaoM,EAAGpM,aAAe,mBAC/B1B,OAAQ8N,EAAGC,WAAaD,EAAGC,WAAWpV,KAAIqV,GAMhD,SAAuBC,G,MAErB,OAAOA,EAASrc,MACd,UAAKV,EACL,IAAK,OACL,IAAK,SACL,IAAK,MACL,IAAK,MACL,IAAK,QAEH,GAAI+c,EAAShX,QAAS,CACpB,MAAMiX,EAAY,CAChBhe,KAAM+d,EAAS/d,KACf0B,KAAM,SACNuc,MAAOF,EAASG,OAChBC,SAAUJ,EAASI,WAAY,EAC/BC,SAAUL,EAASK,WAAY,EAC/BC,SAAUN,EAAShX,QAAQsX,SAC3B3e,MAAQqe,EAAShX,QAAQuX,gBAAkBP,EAASre,OAGhD6e,EAAaR,EAAShX,QAAQyX,aAAe,SAC7CC,EAAaV,EAAShX,QAAQ0X,YAAc,QAClD,QA+I6Bzd,IA/IT+c,EAAShX,QA+IX2X,OA/IqB,CAErC,MAAM3X,EAAkC,CAAC,EAEzC,IAAI,MAAM4X,KAASZ,EAAShX,QAAQ2X,OAEb,iBAAVC,EACT5X,EAAQ4X,GAASA,EAEjB5X,EAAQ4X,EAAMF,IAAeE,EAAMJ,GAIvC,OAAO,OAAP,wBACKP,GAAS,CACZjX,W,CAGF,OAAO,OAAP,wBACKiX,GAAS,CACZY,WAAY,CACVjG,KAAMoF,EAAShX,QAAQmF,KAAKyM,KAC5BjX,KAAMqc,EAAShX,QAAQmF,KAAKxK,KAC5B6c,aACAE,e,CAKN,MAAO,CACLze,KAAM+d,EAAS/d,KACf0B,KAAmB,QAAb,EAAAqc,EAASrc,YAAI,QAAI,OACvByc,SAAUJ,EAASI,WAAY,EAC/BC,SAAUL,EAASK,WAAY,EAC/B1e,MAAOqe,EAASre,MAChBmf,QAASd,EAASjG,MAAQ,IAAII,OAAO6F,EAASjG,YAAS9W,EACvDid,MAAOF,EAASG,OAChBY,YAAaf,EAASgB,YACtBC,UAAWjB,EAASiB,UACpBC,UAAWlB,EAASkB,WAG1B,IAAK,SACH,MAAO,CACLjf,KAAM+d,EAAS/d,KACf0B,KAAM,SACNyc,SAAUJ,EAASI,WAAY,EAC/BC,SAAUL,EAASK,WAAY,EAC/B1e,MAAOqe,EAASre,MAChBue,MAAOF,EAASG,OAChBY,YAAaf,EAASgB,aAE1B,IAAK,WACH,MAAO,CACL/e,KAAM+d,EAAS/d,KACf0B,KAAMqc,EAASrc,KACfyc,SAAUJ,EAASI,WAAY,EAC/BC,SAAUL,EAASK,WAAY,EAC/B1e,MAAOqe,EAASre,MAChBue,MAAOF,EAASG,OAChBY,YAAaf,EAASgB,YACtBG,KAAMnB,EAASmB,KACfC,KAAMpB,EAASoB,KACfH,UAAWjB,EAASiB,UACpBC,UAAWlB,EAASkB,WAExB,IAAK,WACH,MAAO,CACLjf,KAAM+d,EAAS/d,KACf0B,KAAMqc,EAASrc,KACfyc,SAAUJ,EAASI,WAAY,EAC/BC,SAAUL,EAASK,WAAY,EAC/BH,MAAOF,EAASG,OAChBY,YAAaf,EAASgB,YACtBC,UAAWjB,EAASiB,UACpBC,UAAWlB,EAASkB,WAExB,IAAK,OACL,IAAK,QACL,IAAK,OACL,IAAK,OACH,MAAO,CACLjf,KAAM+d,EAAS/d,KACf0B,KAAMqc,EAASrc,KACfhC,MAAOqe,EAASre,MAChBye,SAAUJ,EAASI,WAAY,EAC/BC,SAAUL,EAASK,WAAY,EAC/BH,MAAOF,EAASG,OAChBkB,IAAKrB,EAASqB,IACdC,IAAKtB,EAASsB,IACdC,KAAMvB,EAASuB,MAEnB,IAAK,SACL,IAAK,QACH,MAAO,CACLtf,KAAM+d,EAAS/d,KACf0B,KAAMqc,EAASrc,KACfhC,MAAOqe,EAASre,OAASqe,EAASre,WAAQsB,EAC1Cmd,SAAUJ,EAASI,WAAY,EAC/BC,SAAUL,EAASK,WAAY,EAC/BH,MAAOF,EAASG,OAChBkB,IAAKrB,EAASqB,IACdC,IAAKtB,EAASsB,IACdC,KAAMvB,EAASuB,MAEnB,IAAK,iBACH,MAAO,CACLtf,KAAM+d,EAAS/d,KACf0B,KAAMqc,EAASrc,KACfhC,MAAOqe,EAASre,MAAQ,IAAIsI,KAAK+V,EAASre,YAASsB,EACnDmd,SAAUJ,EAASI,WAAY,EAC/BC,SAAUL,EAASK,WAAY,EAC/BH,MAAOF,EAASG,OAChBkB,IAAKrB,EAASqB,IACdC,IAAKtB,EAASsB,IACdC,KAAMvB,EAASuB,MAEnB,IAAK,QACH,MAAO,CACLtf,KAAM+d,EAAS/d,KACf0B,KAAMqc,EAASrc,KACfyc,SAAUJ,EAASI,WAAY,EAC/BC,SAAUL,EAASK,WAAY,EAC/BH,MAAOF,EAASG,OAChBxe,MAAOqe,EAASre,OAEpB,IAAK,QACL,IAAK,WACH,MAAO,CACLM,KAAM+d,EAAS/d,KACf0B,KAAMqc,EAASrc,KACfyc,SAAUJ,EAASI,WAAY,EAC/BC,SAAUL,EAASK,WAAY,EAC/BH,MAAOF,EAASG,OAChBxe,QAASqe,EAASre,OAK1B,CAxKwD6f,CAAczB,KAAS,OAThD,EAa/B,CArQA,aA4Da,EAAA7f,QAAuBqJ,MAAO4J,EAAQ1E,EAAKkF,KAEtD,MAAMzH,QAAayH,EAASvH,OACtB4B,GAAQ,IAAAiQ,WAAUxP,EAAKkF,EAAS9J,QAAQtD,IAAI,SAIlD,GAAIb,MAAMmJ,QAAQ3C,GAChB,OAAO,IAAI2S,EAAS,CAClB1L,SACA1E,MACAmB,KAAM1D,EACNrC,QAAS8J,EAAS9J,QAClBmE,UAIJA,EAAMgH,OAAOgK,EAAcvQ,EAAKvC,IAGhC,MAAM,UACJwS,EAAS,OACTC,EAAM,WACNiB,GAEE1T,EADC0S,EAAO,EACR1S,EALE,qCAON,OAAO,IAAI2S,EAAS,CAClB1L,SACA1E,IAAKA,EACLmB,KAAMgP,EACN/U,QAAS8J,EAAS9J,QAClBmE,MAAOA,EACPmH,SAAUoK,EAAiBpM,EAAQ1E,EAAKvC,EAAMyH,EAAS9J,SACvD6T,QAASiC,EAAclR,EAAKvC,IAC5B,C,qGC5GJ,aACA,SASa,EAAAhM,QAAUqJ,MAAO4J,EAAgB1E,EAAakF,KAEzD,MAAM3F,GAAQ,IAAAiQ,WAAUxP,EAAKkF,EAAS9J,QAAQtD,IAAI,SAElD,OAAO,IAAI,EAAA0W,cAAc,CACvB9J,SACA1E,MACA5E,QAAS8J,EAAS9J,QAClBmE,SACA,C,qGCnBJ,aACA,SACA,SAEA,SAMa,EAAA9N,QAAuBqJ,MAAO4J,EAAQ1E,EAAKkF,KAEtD,MAAMzH,QAAayH,EAAS8N,OAEtBzT,GAAQ,IAAAiQ,WAAUxP,EAAKkF,EAAS9J,QAAQtD,IAAI,SAC5Cmb,GAAa,IAAAC,WAAUlT,EAAKvC,GAGlC,OAFA8B,EAAMgH,OAAO0M,EAAW1T,OAEjB,IAAI,EAAAwP,UAAU,CACnBrK,SACA1E,MACAmB,KAAM1D,EACNrC,QAAS8J,EAAS9J,QAClBmE,QACA0P,QAASgE,EAAWE,MAAMlX,KAAImX,GAKlC,SAAsB5a,EAAiB4a,GAErC,MAAO,CACLpT,KAAK,IAAAtM,SAAQ8E,EAAS4a,EAAKlE,QAC3B1b,KAAM4f,EAAK9T,KAAO8T,EAAKC,IAAM,GAC7B7V,OAAQ4V,EAAK5V,QAAU,MACvBwH,YAAaoO,EAAKE,SAAW,oCAE7BhQ,OAAQ,GAEZ,CAf0CiQ,CAAavT,EAAKoT,MACxD,C,6TCzBJ,aAAyC,yEAAAlF,OAAO,IAChD,WAAS,2EAAAa,SAAS,IAAE,+EAAAP,aAAa,IACjC,aAAS,iFAAA/c,OAAO,IAAqB,0EAAA2e,QAAQ,IAC7C,aAAS,oFAAA3e,OAAO,IAChB,YAAS,qFAAAA,OAAO,IAChB,aAAS,mFAAAA,OAAO,IAAuB,4EAAA+hB,UAAU,IACjD,aAAS,kFAAA/hB,OAAO,IAChB,aAAS,gFAAAA,OAAO,IAAoB,yEAAAge,OAAO,IAC3C,aAAS,kFAAAhe,OAAO,IAChB,aAAS,kFAAAA,OAAO,G,qGCRhB,eA6HA,mBAAwBgiB,GAEtB,MACgC,iBAAtBA,EAAczT,KACrByT,EAAclU,iBAAiB,EAAAyM,OAC/ByH,EAAcrY,mBAAmB+S,OAGtC,C,oGCtIA,aACA,SA+HA,SAASuF,EAAiBhE,EAAoBpQ,EAAaI,GAEzD,MAAO,CACLlH,QAASkX,EACTpQ,MACA6M,KAAsB,iBAATzM,EAAoBA,EAAOA,EAAKyM,KAGjD,CAhIa,EAAA1a,QAAUqJ,MAAO4J,EAAgB1E,EAAakF,KAEzD,MAAMzH,QAAayH,EAASvH,OAEtB4B,GAAQ,IAAAiQ,WAAUxP,EAAKkF,EAAS9J,QAAQtD,IAAI,SAMlD,OALAyH,EAAMgH,OAuDR,SAA2BmJ,EAAoBjS,GAE7C,MAAMgJ,EAAiB,GAEvB,QAAmBjS,IAAfiJ,EAAK8B,MACP,OAAOkH,EAGT,IAAK,MAAOnH,EAAKqU,KAAchhB,OAAOqJ,QAAQyB,EAAK8B,OAE7CtI,MAAMmJ,QAAQuT,GAChBlN,EAAO7Q,QAAQ+d,EAAU1X,KAAKyD,GAAQgU,EAAiBhE,EAAYpQ,EAAKI,MAExE+G,EAAO7Q,KAAK8d,EAAiBhE,EAAYpQ,EAAKqU,IAKlD,OAAOlN,CAET,CA1EOmN,CAAkB5T,EAAKvC,MAoF9B,SAAgCiS,EAAoBjS,GAElD,IAAKxG,MAAMmJ,QAAQ3C,EAAK0D,MAEtB,MAAO,GAGT,MAAMsF,EAAiB,GACvB,IAAK,MAAMoN,KAAUpW,EAAK0D,KAExB,GAAI,UAAW0S,GAAU,SAAUA,EAAOtU,MAAQ,CAEhD,MAAMuU,EAAWJ,EAAiBhE,EAAY,OAAQmE,EAAOtU,MAAOzN,MACpE2U,EAAO7Q,KAAK,CACV4C,QAASkX,EACTvD,KAAM2H,EAAS3H,KACf7M,IAAK,Q,CAMX,OAAOmH,CAET,CA3GOsN,CAAuB/T,EAAKvC,IAG1B,IAAI,EAAAsR,UAAU,CACnBrK,SACA1E,MACAmB,KAAM1D,EACNrC,QAAS8J,EAAS9J,QAClBmE,MAAOA,GACP,C,qdCxBJ,aACA,SACA,SACA,SAQA,MAAaiU,UAAsB,EAAAzE,UASjCV,gBAEE,MAAM,IAAIrY,MAAM,yIAElB,CAEAmF,QAEE,OAAO,IAAIqY,EAAW,CACpB9O,OAAQrR,KAAKqR,OACb1E,IAAK3M,KAAK2M,IACVmB,KAAM9N,KAAK8N,KACX/F,QAAS,IAAI+S,QAAQ9a,KAAK+H,SAC1BmE,MAAO,IAAI,EAAAyM,MAAM3Y,KAAK2M,IAAK3M,KAAKkM,OAChC0P,QAAS5b,KAAK2b,YAGlB,EAwEF,SAASgF,EAAgBtE,EAAoBjS,GAE3C,MAAMgJ,EAAiB,GAEvB,QAAmBjS,IAAfiJ,EAAK8B,MACP,IAAK,MAAMG,KAAQjC,EAAK8B,MACtBkH,EAAO7Q,QAAQqe,EAAevE,EAAYhQ,IAI9C,QAAsBlL,IAAlBiJ,EAAKyW,SACP,IAAK,MAAMC,KAAa1W,EAAKyW,cACW1f,IAAjC2f,EAAwBhI,KAC3B1F,EAAO7Q,QAAQqe,EAAevE,EAAYyE,IAE1C1N,EAAO7Q,QAAQwe,EAA0B1E,EAAYyE,IAK3D,OAAO1N,CAET,CAEA,SAASwN,EAAevE,EAAoBhQ,GAE1C,MAAM+G,EAAiB,IAGrBnH,IAAK+U,GAEH3U,EADC4Q,EAAU,EACX5Q,EAHE,SAIN,IAAK,MAAMJ,KAAO+U,EAAM,CAEtB,MAAMC,EAAO,eACXhV,MACA9G,QAASkX,GACNY,GAEL7J,EAAO7Q,KAAK0e,E,CAId,OAAO7N,CAET,CAEA,SAAS8N,EAAmB7P,EAAgBgL,EAAoBjS,EAAwBrC,GAEtF,QAAsB5G,IAAlBiJ,EAAKyW,SACP,MAAO,GAGT,MAAMzN,EAAyC,GAE/C,IAAK,MAAM+N,KAAU/W,EAAKyW,SACxB,QA2E6B1f,IA3EbggB,EA2EIrI,KA3EK,CACvB,MAAMsI,EAAWC,EAA8BhQ,EAAQgL,EAAY8E,EAAQpZ,GAC1D,OAAbqZ,GACFhO,EAAO7Q,KAAK6e,E,CAKlB,OAAOhO,CAET,CAEA,SAAS2N,EAA0B1E,EAAoByE,GAErD,QAAwB3f,IAApB2f,EAAU5U,MAEZ,MAAO,GAET,IAAIoV,EAA0B,KAC9B,IAAK,MAAMjV,KAAQyU,EAAU5U,MACvBG,EAAKJ,IAAIwM,SAAS,UACpB6I,EAAWjV,EAAKyM,MAGpB,OAAiB,OAAbwI,EAEK,GAGFR,EAAU7U,IAAIrD,KAAIqD,IACvB,MAAMuL,EAAQsJ,EAAUtJ,MAClBnL,EAAa,CACjByM,KAAMwI,EACNrV,MACA9G,QAASkX,GAKX,OAHI7E,IACFnL,EAAKmL,MAAQA,GAERnL,CAAI,GAGf,CAEA,SAASgV,EAA8BhQ,EAAgBgL,EAAoByE,EAA2B/Y,GAEpG,QAAwB5G,IAApB2f,EAAU5U,MAEZ,OAAO,KAET,IAAIoV,EAAW,KACf,IAAK,MAAMjV,KAAQyU,EAAU5U,MACvBG,EAAKJ,IAAIwM,SAAS,UACpB6I,EAAWjV,EAAKyM,MAGpB,IAAKwI,EAEH,OAAO,KAGT,MAAMC,GAAe,IAAAlhB,SAAQgc,EAAYiF,GAEzC,OAAO,IAAInB,EAAW,CACpB9O,SACA1E,IAAK4U,EACLzT,KAAMgT,EAAU9C,WAChBjW,UACAmE,MAAO,IAAI,EAAAyM,MAAM2I,EAAUX,EAAgBW,EAAUR,KAGzD,CAjOA,eAkCa,EAAA1iB,QAAUqJ,MAAO4J,EAAgB1E,EAAakF,KAEzD,MAAMzH,QAA8ByH,EAASvH,OAEvC4B,GAAQ,IAAAiQ,WAAUxP,EAAKkF,EAAS9J,QAAQtD,IAAI,SAGlD,OAFAyH,EAAMgH,OAAOyN,EAAgBhU,EAAKvC,IAE3B,IAAI+V,EAAW,CACpB9O,SACA1E,MACAmB,KAAM1D,EAAK4T,WACXjW,QAAS8J,EAAS9J,QAClBmE,MAAOA,EACPmH,SAAU6N,EAAmB7P,EAAQ1E,EAAKvC,EAAMyH,EAAS9J,SACzD6T,QAASxR,EAAKwR,QAAUxR,EAAKwR,QAAQhT,KAAKiT,GAyL9C,SAA0BlP,EAAakP,GACrC,MAAO,CACLlP,KAAK,IAAAtM,SAAQsM,EAAKkP,EAAO/C,MACzB3Y,KAAM0b,EAAO1b,KACbqX,MAAOqE,EAAOrE,MACdrN,OAAQ0R,EAAO1R,QAAU,MACzBwH,YAAakK,EAAOha,MAAQ,oCAC5BoO,OAAQ4L,EAAO5L,OAAS4L,EAAO5L,OAAOrH,KAAK4Y,GAI/C,SAA2BpB,GAEzB,MAAMhN,EAAgB,CACpBjT,KAAMigB,EAAMjgB,KACZ0B,KAAMue,EAAMve,MAAQ,OACpByc,UAAU,EACVC,UAAU,GAUZ,OAPI6B,EAAMvgB,QACRuT,EAAOvT,MAAQugB,EAAMvgB,OAEnBugB,EAAM5I,QACRpE,EAAOgL,MAAQgC,EAAM5I,OAGhBpE,CACT,CArBwDqO,CAAkBD,KAAU,GAEpF,CAlMwDE,CAAiB/U,EAAKkP,KAAY,IACtF,C,qGC5DJ,aAEA,SAMa,EAAAzd,QAAgCqJ,MAAO4J,EAAgB1E,EAAakF,IAExE,IAAI,EAAA6J,UAAU,CACnBrK,SACA1E,MACAmB,WAAY+D,EAAS8N,OACrB5X,QAAS8J,EAAS9J,QAClBmE,OAAO,IAAAiQ,WAAUxP,EAAKkF,EAAS9J,QAAQtD,IAAI,U,kGCZ/C,kBAAuB2b,GAErB,OAAO3Z,KAAK2Z,EAEd,C,8GCPA,8BAAmCA,GAEjC,MAAoB,iBAATA,KAIPA,aAAiBnE,KAMvB,C,uGCXA,eAwCA,SAAS0F,EAAatF,EAAoBuF,GAExC,MAAMxO,EAAiB,GAEvB,IAAK,MAAMyO,KAAQD,EAAU,CAE3B,MAAMZ,EAAOa,EAAKC,aAAa,OACzBhJ,EAAO+I,EAAKC,aAAa,QACzBjgB,EAAOggB,EAAKC,aAAa,cAAW3gB,EAE1C,GAAK6f,GAASlI,EAId,IAAK,MAAM7M,KAAO+U,EAAK1T,MAAM,KAAM,CAEjC,MAAMjB,EAAY,CAChBJ,IAAKA,EACL9G,QAASkX,EACTvD,KAAMA,GAEJjX,IAAMwK,EAAKxK,KAAOA,GACtBuR,EAAO7Q,KAAK8J,E,EAKhB,OAAO+G,CAET,CAEA,SAAS2O,EAAa1F,EAAoBuF,GAExC,MAAMxO,EAAS,GAEf,IAAK,MAAMyO,KAAQD,EAAU,CAE3B,MAAMZ,EAAOa,EAAKC,aAAa,OACzBjG,EAASgG,EAAKC,aAAa,UAC3B7B,EAAU4B,EAAKC,aAAa,YAAc,oCAC1C9B,EAAK6B,EAAKC,aAAa,MACvB3X,EAAS0X,EAAKC,aAAa,WAAa,MAE9C,GAAKd,EAWL,IAAK,MAAM/U,KAAO+U,EAAK1T,MAAM,KAAM,CAEjC,MAAMyS,EAAO,CACX9T,MACA4P,QAAQ,IAAAxb,SAAQgc,EAAYR,GAC5BoE,UACAD,KACA7V,UAEFiJ,EAAO7Q,KAAKwd,E,MAnBZ3M,EAAO7Q,KAAK,CACV0J,IAAK,KACL4P,QAAQ,IAAAxb,SAAQgc,EAAYR,GAC5BoE,UACAD,KACA7V,U,CAoBN,OAAOiJ,CAET,CA/FA,qBAA0BiJ,EAAoBjS,GAE5C,MACM4X,GADS,IAAIC,WACAC,gBAAgB9X,EAAM,aAEzC,MAAO,CACL0V,MAAOiC,EACL1F,EACA2F,EAAIG,qBAAqB,SAE3BjW,MAAO,IACFyV,EACDtF,EACA2F,EAAIG,qBAAqB,YAExBR,EACDtF,EACA2F,EAAIG,qBAAqB,OAKjC,C,oGCvCA,eACA,SAKA,kBAAuB/I,EAAmBC,EAA4B+I,GAEpE,IAAIjd,EACAkd,EACAC,EAEgB,iBAATlJ,GACTjU,EAAUiU,EACViJ,EAAWhJ,EACXiJ,EAAOF,IAEPjd,EAAUiU,EAAKjU,QACfkd,EAAWjJ,EAAKN,KAChBwJ,EAAQjJ,GAEV,MACMkJ,EADQC,EAAYxW,MAAMqW,GACT/G,OAAOgH,GAC9B,OAAO,IAAAjiB,SAAQ8E,EAASod,EAC1B,C,2GCXA,mBAAwBE,EAAmBC,G,MAEzC,GAAoB,iBAATD,EACTC,EAAWD,EAAK3J,KAChB2J,EAAOA,EAAKtd,aAEZ,IAAKud,EACH,OAAOD,EAKX,GAAmB,oBAARjR,KAA2D,KAAZ,QAAxB,gBAAc/D,KAAKgV,UAAK,eAAE5c,OAC1D,OAAQ,IAAI2L,IAAIkR,EAAUD,GAAMzV,WAMlC,MAAMgV,EAAUW,SACVC,EAAUZ,EAAIG,qBAAqB,QAAQ,GAC3CU,EAAUD,aAAO,EAAPA,EAAS9J,KACnBgK,EAAUd,EAAInL,MAAQmL,EAAIG,qBAAqB,QAAQ,GACvDY,EAAUH,GAAWE,EAAQE,YAAYhB,EAAIiB,cAAc,SAC3DviB,EAAWshB,EAAIiB,cAAc,KAEnCF,EAAQjK,KAAO2J,EACf/hB,EAASoY,KAAO4J,EAChB,MAAMQ,EAAexiB,EAASoY,KAO9B,OALI8J,EACFA,EAAQ9J,KAAO+J,EAEfC,EAAQK,YAAYJ,GAEfG,CAET,EAOA,iBAAsBvL,GAGpB,MAAO,CACLyL,KAFa,IAAI5R,IAAImG,GAERyL,KAGjB,C,+BC/DA/kB,EAAQglB,YAAa,EACrBhlB,EAAQ2O,cAAW,EAwBnB3O,EAAQ2O,SAvBR,SAASA,EAAS6U,GACd,IAAIyB,EAAIC,EACR,OAAQ1B,EAAKhgB,MACT,IAAK,WACD,OAAOggB,EAAKrU,MAAM5E,IAAIoE,GAAUlE,KAAK,IACzC,IAAK,UACD,OAAO+Y,EAAKhiB,MAChB,IAAK,aACD,MAAO,IAAMgiB,EAAK2B,SAAW3B,EAAK1N,UAAUvL,IAAIoE,GAAUlE,KAAK,KAAO,IAC1E,IAAK,WACD,IAAI8F,EAAMiT,EAAK1hB,KAUf,MAT2E,YAA7C,QAAxBmjB,EAAKzB,EAAK4B,gBAA6B,IAAPH,OAAgB,EAASA,EAAGzhB,MAC9D+M,GAAO,IAEqE,WAA7C,QAAxB2U,EAAK1B,EAAK4B,gBAA6B,IAAPF,OAAgB,EAASA,EAAG1hB,QACnE+M,GAAO,IAAMiT,EAAK4B,SAASjhB,QAE3Bqf,EAAK6B,YACL9U,GAAO,IAAMiT,EAAK6B,UAAY,KAE3B9U,EAEnB,C,mCCxBA,IAAI+U,EAAY3jB,MAAQA,KAAK2jB,UAAa,WAStC,OARAA,EAAWrkB,OAAOiO,QAAU,SAASjH,GACjC,IAAK,IAAIoC,EAAG7E,EAAI,EAAGI,EAAIrD,UAAU4B,OAAQqB,EAAII,EAAGJ,IAE5C,IAAK,IAAI+f,KADTlb,EAAI9H,UAAUiD,GACOvE,OAAOH,UAAU0kB,eAAezkB,KAAKsJ,EAAGkb,KACzDtd,EAAEsd,GAAKlb,EAAEkb,IAEjB,OAAOtd,CACX,EACOqd,EAAS7kB,MAAMkB,KAAMY,UAChC,EACIkjB,EAAmB9jB,MAAQA,KAAK8jB,iBAAoB,SAAUC,GAC9D,OAAQA,GAAOA,EAAIV,WAAcU,EAAM,CAAE,QAAWA,EACxD,EACA1lB,EAAQglB,YAAa,EACrBhlB,EAAQ2lB,iBAAmB3lB,EAAQ4lB,oBAAiB,EACpD,IAAIC,EAAeJ,EAAgB,EAAQ,MACvCK,EAAW,CACXC,SAAS,EAAIF,EAAsB,SAAG,aACtCG,YAAY,EAAIH,EAAsB,SAAG,gDAa7C7lB,EAAQ4lB,eAXR,SAAwBK,EAAK/K,GASzB,OARc+K,EAAI9W,MAAM5E,KAAI,SAAUwP,GAClC,OAAQA,EAAKvW,MACT,IAAK,UACD,OAAOuW,EAAKvY,MAChB,IAAK,aACD,OAAOmkB,EAAiB5L,EAAMmB,GAE1C,IACezQ,KAAK,GACxB,EAEA,IAAIyb,EAAW,CACXC,MAAO,GACP1U,IAAK,IACL2U,MAAO,GACPje,OAAQ2d,EAASC,QACjBM,OAAO,GAEPC,EAAkB,CAClB,GAAIhB,EAAS,CAAC,EAAGY,GACjB,IAAKZ,EAASA,EAAS,CAAC,EAAGY,GAAW,CAAE/d,OAAQ2d,EAASE,aACzD,IAAKV,EAASA,EAAS,CAAC,EAAGY,GAAW,CAAE/d,OAAQ2d,EAASE,WAAYG,MAAO,IAAKC,MAAO,MACxF,IAAKd,EAASA,EAAS,CAAC,EAAGY,GAAW,CAAEC,MAAO,IAAK1U,IAAK,MACzD,IAAK6T,EAASA,EAAS,CAAC,EAAGY,GAAW,CAAEC,MAAO,IAAK1U,IAAK,IAAK2U,MAAO,MACrE,IAAKd,EAASA,EAAS,CAAC,EAAGY,GAAW,CAAEC,MAAO,IAAK1U,IAAK,IAAK4U,OAAO,IACrE,IAAKf,EAASA,EAAS,CAAC,EAAGY,GAAW,CAAEC,MAAO,IAAK1U,IAAK,IAAK2U,MAAO,IAAKC,OAAO,IACjF,IAAKf,EAASA,EAAS,CAAC,EAAGY,GAAW,CAAEC,MAAO,IAAK1U,IAAK,IAAK2U,MAAO,IAAKC,OAAO,KAErF,SAASV,EAAiBY,EAAYrL,GAClC,IAAIsL,EAASF,EAAgBC,EAAWpB,UACpCsB,EAAU,GAQd,GAPAF,EAAWzQ,UAAU+G,SAAQ,SAAU6J,GACnC,IAAIllB,EAAQ0Z,EAAOwL,EAAS5kB,MAC5B,GAyFR,SAAiBqP,GACb,cAAeA,GACX,IAAK,YACD,OAAO,EACX,IAAK,SACD,GAAS,MAALA,EACA,OAAO,EAEX,GAAI5L,MAAMmJ,QAAQyC,GACd,OAAOA,EAAEhN,OAAS,EAEtB,IAAK,IAAI0N,KAAKV,EACV,GAAY,MAARA,EAAEU,GACF,OAAO,EAEf,OAAO,EACX,QACI,OAAO,EAEnB,CA5Ga8U,CAAQnlB,GAAb,CAEA,IAAIuO,EAaZ,SAAwB2W,EAAUllB,EAAOglB,GACrC,IAAIvB,EACJ,GAAa,MAATzjB,EACA,MAAM,IAAI4B,UAAU,2CAA6CsjB,EAAS5kB,KAAO,mCAErF,MAAgF,aAA9C,QAA5BmjB,EAAKyB,EAAStB,gBAA6B,IAAPH,OAAgB,EAASA,EAAGzhB,MAuC1E,SAA4BkjB,EAAUllB,EAAOyjB,GACzC,IAAI9c,EAAS8c,EAAG9c,OAAQke,EAAQpB,EAAGoB,MAAO5U,EAAMwT,EAAGxT,IACnD,GAAIlM,MAAMmJ,QAAQlN,GAAQ,CACtB,IAAI0c,EAAQ1c,EAAM+I,IAAIpC,GAItB,OAHIke,IACAnI,EAAQA,EAAM3T,KAAI,SAAUsF,GAAQ,OAAO6W,EAAS5kB,KAAO,IAAM+N,CAAM,KAEpEqO,EAAMzT,KAAKgH,EACtB,CACK,GAAqB,iBAAVjQ,EAAoB,CAChC,IAAIolB,EAAU,GAad,OAZA3lB,OAAOqJ,QAAQ9I,GAAOqb,SAAQ,SAAUoI,GACpC,IAAIpT,EAAIoT,EAAG,GAAI9T,EAAI8T,EAAG,GACtBpT,EAAI1J,EAAO0J,GACPtM,MAAMmJ,QAAQyC,GACdA,EAAE0L,SAAQ,SAAUhN,GAChB+W,EAAQ1iB,KAAK2N,EAAI,IAAM1J,EAAO0H,GAClC,IAGA+W,EAAQ1iB,KAAK2N,EAAI,IAAM1J,EAAOgJ,GAEtC,IACOyV,EAAQnc,KAAKgH,EACxB,CAEI,IAAIpH,EAAI7I,EAAMmN,WACd,OAAOxG,EAAOkC,EAEtB,CAnEewc,CAAmBH,EAAUllB,EAAOglB,GAMnD,SAA2BE,EAAUllB,EAAOyjB,GACxC,IAAIC,EAAI4B,EAKJvW,EAJA6V,EAAQnB,EAAGmB,MAAOje,EAAS8c,EAAG9c,OAAQke,EAAQpB,EAAGoB,MACrD,GAAqB,iBAAV7kB,GAAkG,YAA9C,QAA5B0jB,EAAKwB,EAAStB,gBAA6B,IAAPF,OAAgB,EAASA,EAAG1hB,MAC/F,MAAM,IAAIc,MAAM,uDAAyDoiB,EAAS5kB,MA0BtF,OAvBIyD,MAAMmJ,QAAQlN,GACd+O,EAAM/O,EAAM+I,IAAIpC,GAAQsC,KAAK,KAEP,iBAAVjJ,EACZ+O,EAAMtP,OAAOqJ,QAAQ9I,GAChB+I,KAAI,SAAUkW,GAAS,OAAOA,EAAMlW,IAAIpC,GAAQsC,KAAK,IAAM,IAC3DA,KAAK,MAGV8F,EAAM/O,EAAMmN,WACoE,YAA9C,QAA5BmY,EAAKJ,EAAStB,gBAA6B,IAAP0B,OAAgB,EAASA,EAAGtjB,QAClE+M,EAAMA,EAAIwW,UAAU,EAAGL,EAAStB,SAASjhB,SAE7CoM,EAAMpI,EAAOoI,IAEb8V,IAEI9V,EADAA,EACMmW,EAAS5kB,KAAO,IAAMyO,EAGtB,GAAKmW,EAAS5kB,KAAOskB,GAG5B7V,CACX,CAlCeyW,CAAkBN,EAAUllB,EAAOglB,EAElD,CAxBqBS,CAAeP,EAAUllB,EAAOglB,GAC7CC,EAAQviB,KAAK6L,GAAU,GAFb,CAGd,IACuB,IAAnB0W,EAAQtiB,OACR,MAAO,GAEX,IAAI+f,EAAWuC,EAAQhc,KAAK+b,EAAO/U,KACnC,OAAwB,IAApByS,EAAS/f,OACFqiB,EAAOJ,MAEXI,EAAOL,MAAQjC,CAC1B,CACAlkB,EAAQ2lB,iBAAmBA,C,+BC7D3B,SAASuB,EAAgBrgB,EAASsgB,EAAUC,EAAOC,GAC/C,IAAIjnB,EAAOkE,MAAMvD,KAAKY,KAAMkF,GAQ5B,OAPI5F,OAAOqmB,gBACPrmB,OAAOqmB,eAAelnB,EAAM8mB,EAAgBpmB,WAEhDV,EAAK+mB,SAAWA,EAChB/mB,EAAKgnB,MAAQA,EACbhnB,EAAKinB,SAAWA,EAChBjnB,EAAK0B,KAAO,cACL1B,CACX,CAEA,SAASmnB,EAAWzW,EAAK0W,EAAcC,GAEnC,OADAA,EAAYA,GAAa,IACrB3W,EAAI3M,OAASqjB,EACN1W,GAEX0W,GAAgB1W,EAAI3M,OAEb2M,GADP2W,GAAaA,EAAUC,OAAOF,IACPllB,MAAM,EAAGklB,GACpC,EAzBA,SAAsBG,EAAOC,GACzB,SAASC,IAAMlmB,KAAK2G,YAAcqf,CAAO,CACzCE,EAAE/mB,UAAY8mB,EAAO9mB,UACrB6mB,EAAM7mB,UAAY,IAAI+mB,CAC1B,CAYAC,CAAaZ,EAAiB5iB,OAU9B4iB,EAAgBpmB,UAAUinB,OAAS,SAAUC,GACzC,IAAIlX,EAAM,UAAYnP,KAAKkF,QAC3B,GAAIlF,KAAK0lB,SAAU,CACf,IACIxV,EADAoW,EAAM,KAEV,IAAKpW,EAAI,EAAGA,EAAImW,EAAQ7jB,OAAQ0N,IAC5B,GAAImW,EAAQnW,GAAGqW,SAAWvmB,KAAK0lB,SAASa,OAAQ,CAC5CD,EAAMD,EAAQnW,GAAGyP,KAAKrS,MAAM,eAC5B,KACJ,CAEJ,IAAI5E,EAAI1I,KAAK0lB,SAASc,MAClBC,EAAMzmB,KAAK0lB,SAASa,OAAS,IAAM7d,EAAEge,KAAO,IAAMhe,EAAEie,OACxD,GAAIL,EAAK,CACL,IAAI/f,EAAIvG,KAAK0lB,SAASjZ,IAClBma,EAAShB,EAAW,GAAIld,EAAEge,KAAK1Z,WAAWxK,QAC1CkkB,EAAOJ,EAAI5d,EAAEge,KAAO,GACpBG,EAAOne,EAAEge,OAASngB,EAAEmgB,KAAOngB,EAAEogB,OAASD,EAAKlkB,OAAS,EACxD2M,GAAO,aAAYsX,EAAM,KACnBG,EAAS,OACTle,EAAEge,KAAO,MAAQA,EAAO,KACxBE,EAAS,MAAQhB,EAAW,GAAIld,EAAEie,OAAS,GAC3Cf,EAAW,GAAIiB,EAAOne,EAAEie,OAAQ,IAC1C,MAEIxX,GAAO,SAAWsX,CAE1B,CACA,OAAOtX,CACX,EACAoW,EAAgBuB,aAAe,SAAUtB,EAAUC,GAC/C,IAAIsB,EAA2B,CAC3BC,QAAS,SAAUC,GACf,MAAO,IAAOC,EAAcD,EAAYtH,MAAQ,GACpD,EACA,MAAS,SAAUsH,GACf,IAAIE,EAAeF,EAAYzZ,MAAM5E,KAAI,SAAUwP,GAC/C,OAAOxU,MAAMmJ,QAAQqL,GACfgP,EAAYhP,EAAK,IAAM,IAAMgP,EAAYhP,EAAK,IAC9CgP,EAAYhP,EACtB,IACA,MAAO,KAAO6O,EAAYI,SAAW,IAAM,IAAMF,EAAe,GACpE,EACAG,IAAK,WACD,MAAO,eACX,EACA7a,IAAK,WACD,MAAO,cACX,EACA8a,MAAO,SAAUN,GACb,OAAOA,EAAYO,WACvB,GAEJ,SAASC,EAAIC,GACT,OAAOA,EAAGrZ,WAAW,GAAGrB,SAAS,IAAIe,aACzC,CACA,SAASmZ,EAAcxe,GACnB,OAAOA,EACF8C,QAAQ,MAAO,QACfA,QAAQ,KAAM,OACdA,QAAQ,MAAO,OACfA,QAAQ,MAAO,OACfA,QAAQ,MAAO,OACfA,QAAQ,MAAO,OACfA,QAAQ,gBAAgB,SAAUkc,GAAM,MAAO,OAASD,EAAIC,EAAK,IACjElc,QAAQ,yBAAyB,SAAUkc,GAAM,MAAO,MAAQD,EAAIC,EAAK,GAClF,CACA,SAASN,EAAY1e,GACjB,OAAOA,EACF8C,QAAQ,MAAO,QACfA,QAAQ,MAAO,OACfA,QAAQ,MAAO,OACfA,QAAQ,KAAM,OACdA,QAAQ,MAAO,OACfA,QAAQ,MAAO,OACfA,QAAQ,MAAO,OACfA,QAAQ,MAAO,OACfA,QAAQ,gBAAgB,SAAUkc,GAAM,MAAO,OAASD,EAAIC,EAAK,IACjElc,QAAQ,yBAAyB,SAAUkc,GAAM,MAAO,MAAQD,EAAIC,EAAK,GAClF,CACA,SAASC,EAAoBV,GACzB,OAAOF,EAAyBE,EAAYplB,MAAMolB,EACtD,CA4BA,MAAO,YA3BP,SAA0BzB,GACtB,IACI3hB,EAAGyM,EADHsX,EAAepC,EAAS5c,IAAI+e,GAGhC,GADAC,EAAaC,OACTD,EAAaplB,OAAS,EAAG,CACzB,IAAKqB,EAAI,EAAGyM,EAAI,EAAGzM,EAAI+jB,EAAaplB,OAAQqB,IACpC+jB,EAAa/jB,EAAI,KAAO+jB,EAAa/jB,KACrC+jB,EAAatX,GAAKsX,EAAa/jB,GAC/ByM,KAGRsX,EAAaplB,OAAS8N,CAC1B,CACA,OAAQsX,EAAaplB,QACjB,KAAK,EACD,OAAOolB,EAAa,GACxB,KAAK,EACD,OAAOA,EAAa,GAAK,OAASA,EAAa,GACnD,QACI,OAAOA,EAAajnB,MAAM,GAAI,GAAGmI,KAAK,MAChC,QACA8e,EAAaA,EAAaplB,OAAS,GAErD,CAIqBslB,CAAiBtC,GAAY,QAHlD,SAAuBC,GACnB,OAAOA,EAAQ,IAAOyB,EAAczB,GAAS,IAAO,cACxD,CAC4DsC,CAActC,GAAS,SACvF,EA4lBAnnB,EAAOD,QAAU,CACb2pB,YAAazC,EACbvZ,MA7lBJ,SAAmBoU,EAAOlZ,GAEtB,IA2CI+gB,EA8G8BzC,EAAUC,EAAOC,EAzJ/CwC,EAAa,CAAC,EACdC,GAFJjhB,OAAsB/F,IAAZ+F,EAAwBA,EAAU,CAAC,GAEpBkhB,cACrBC,EAAyB,CAAEhG,SAAUiG,GACrCC,EAAwBD,EAQxBE,EAAS,cACTC,EAAS,kBACTC,EAAS,SACTC,EAAS,QACTC,EAAS,QACTC,EAASC,EAAuB,KAAK,GACrCC,EAASD,EAAuB,KAAK,GACrCE,EAASC,EAAqB,CAAC,IAAK,IAAK,IAAK,IAAK,IAAK,IAAK,MAAM,GAAO,GAC1EC,EAASJ,EAAuB,KAAK,GACrCK,EAASF,EAAqB,CAAC,CAAC,IAAK,KAAM,CAAC,IAAK,KAAM,CAAC,IAAK,KAAM,IAAK,IAAK,MAAM,GAAO,GAC1FG,EAASN,EAAuB,KAAK,GACrCO,EAASP,EAAuB,KAAK,GACrCQ,EAASL,EAAqB,CAAC,CAAC,IAAK,OAAO,GAAO,GACnDM,EAASN,EAAqB,CAAC,MAAM,GAAM,GAC3CO,EAASV,EAAuB,KAAK,GACrCW,EAAUR,EAAqB,CAAC,MAAM,GAAM,GAC5CS,EAAUZ,EAAuB,KAAK,GAGtCa,EAAS,SAAUC,EAAIpa,GAAK,OAAOA,CAAG,EAOtCqa,EAAc,EAEdC,EAAsB,CAAC,CAAEpD,KAAM,EAAGC,OAAQ,IAC1CoD,EAAiB,EACjBC,EAAsB,GAG1B,GAAI,cAAe9iB,EAAS,CACxB,KAAMA,EAAQ+iB,aAAa5B,GACvB,MAAM,IAAI1lB,MAAM,mCAAqCuE,EAAQ+iB,UAAY,MAE7E1B,EAAwBF,EAAuBnhB,EAAQ+iB,UAC3D,CA6BA,SAASnB,EAAuBnJ,EAAMuK,GAClC,MAAO,CAAEroB,KAAM,UAAW8d,KAAMA,EAAMuK,WAAYA,EACtD,CACA,SAASjB,EAAqBzb,EAAO6Z,EAAU6C,GAC3C,MAAO,CAAEroB,KAAM,QAAS2L,MAAOA,EAAO6Z,SAAUA,EAAU6C,WAAYA,EAC1E,CAUA,SAASC,EAAsBC,GAC3B,IACIxG,EADAyG,EAAUP,EAAoBM,GAElC,GAAIC,EACA,OAAOA,EAIP,IADAzG,EAAIwG,EAAM,GACFN,EAAoBlG,IACxBA,IAOJ,IAJAyG,EAAU,CACN3D,MAFJ2D,EAAUP,EAAoBlG,IAEZ8C,KACdC,OAAQ0D,EAAQ1D,QAEb/C,EAAIwG,GACqB,KAAxBhK,EAAM/R,WAAWuV,IACjByG,EAAQ3D,OACR2D,EAAQ1D,OAAS,GAGjB0D,EAAQ1D,SAEZ/C,IAGJ,OADAkG,EAAoBM,GAAOC,EACpBA,CAEf,CACA,SAASC,EAAoBC,EAAUC,GACnC,IAAIC,EAAkBN,EAAsBI,GACxCG,EAAgBP,EAAsBK,GAC1C,MAAO,CACHjE,OAAQ4B,EACR3B,MAAO,CACH5a,OAAQ2e,EACR7D,KAAM+D,EAAgB/D,KACtBC,OAAQ8D,EAAgB9D,QAE5Bla,IAAK,CACDb,OAAQ4e,EACR9D,KAAMgE,EAAchE,KACpBC,OAAQ+D,EAAc/D,QAGlC,CACA,SAASgE,EAASnF,GACVqE,EAAcE,IAGdF,EAAcE,IACdA,EAAiBF,EACjBG,EAAsB,IAE1BA,EAAoBznB,KAAKijB,GAC7B,CAOA,SAAS8C,IACL,IAAQsC,EAAIC,EAOZ,IANKhB,EACLe,EAAK,IACLC,EAAKC,OACM5C,IACP2C,EAAKE,KAEFF,IAAO3C,GACV0C,EAAGroB,KAAKsoB,IACRA,EAAKC,OACM5C,IACP2C,EAAKE,KAMb,MAlJmC,CAAElpB,KAAM,WAAY2L,MAgJ3Cod,EAGhB,CACA,SAASG,IACL,IAAIC,EAAIJ,EAAIC,EAAII,EAAIC,EAkDpB,OAjDAF,EAAKnB,EACiC,MAAlCzJ,EAAM/R,WAAWwb,IACjBe,EAhLK,IAiLLf,MAGAe,EAAK1C,EAEDyC,EAAS9B,IAGb+B,IAAO1C,GACP2C,EAuCR,WACI,IAAIG,EAcJ,OAbIxC,EAAO9c,KAAK0U,EAAM+K,OAAOtB,KACzBmB,EAAK5K,EAAM+K,OAAOtB,GAClBA,MAGAmB,EAAK9C,EAEDyC,EAAS3B,IAGbgC,IAAO9C,IACP8C,EAAK,IAEFA,CACX,CAvDaI,GACDP,IAAO3C,GACP+C,EAsDZ,WACI,IAAID,EAAIJ,EAAIC,EAAII,EAAIC,EAAIG,EAxNLzB,EAAI0B,EA2NvB,GAFAN,EAAKnB,GACLe,EAAKW,OACMrD,EAAY,CA4BnB,IA3BA2C,EAAK,GACLI,EAAKpB,EACiC,KAAlCzJ,EAAM/R,WAAWwb,IACjBqB,EAxPC,IAyPDrB,MAGAqB,EAAKhD,EAEDyC,EAASzB,IAGbgC,IAAOhD,IACPmD,EAAKE,OACMrD,EAEP+C,EAAKtB,EAAOiB,EAAIS,IAQpBxB,EAAcoB,EACdA,EAAK/C,GAEF+C,IAAO/C,GACV2C,EAAGtoB,KAAK0oB,GACRA,EAAKpB,EACiC,KAAlCzJ,EAAM/R,WAAWwb,IACjBqB,EApRH,IAqRGrB,MAGAqB,EAAKhD,EAEDyC,EAASzB,IAGbgC,IAAOhD,IACPmD,EAAKE,OACMrD,EAEP+C,EAAKtB,EAAOiB,EAAIS,IAQpBxB,EAAcoB,EACdA,EAAK/C,GAjRE0B,EAqRHgB,GArROU,EAqRHT,GArRcvoB,QAAQsnB,GAqRtCoB,EArRkDM,CAsRtD,MAEIzB,EAAcmB,EACdA,EAAK9C,EAET,OAAO8C,CACX,CA3HiBQ,GACDP,IAAO/C,GAC+B,MAAlC9H,EAAM/R,WAAWwb,IACjBqB,EA9LP,IA+LOrB,MAGAqB,EAAKhD,EAEDyC,EAAS5B,IAGbmC,IAAOhD,EAEP8C,EAjLiC,CAAEnpB,KAAM,aAAc2hB,SAiL3CqH,EAjL+D1W,UAiL3D8W,IAGhBpB,EAAcmB,EACdA,EAAK9C,KAIT2B,EAAcmB,EACdA,EAAK9C,KAIT2B,EAAcmB,EACdA,EAAK9C,KAIT2B,EAAcmB,EACdA,EAAK9C,GAEF8C,CACX,CAwFA,SAASO,IACL,IAAIP,EAAIJ,EAAIC,EAAII,EAchB,GAbAD,EAAKnB,EACLe,EAAKf,EACLgB,EAAK,GACDpC,EAAO/c,KAAK0U,EAAM+K,OAAOtB,KACzBoB,EAAK7K,EAAM+K,OAAOtB,GAClBA,MAGAoB,EAAK/C,EAEDyC,EAASxB,IAGb8B,IAAO/C,EACP,KAAO+C,IAAO/C,GACV2C,EAAGtoB,KAAK0oB,GACJxC,EAAO/c,KAAK0U,EAAM+K,OAAOtB,KACzBoB,EAAK7K,EAAM+K,OAAOtB,GAClBA,MAGAoB,EAAK/C,EAEDyC,EAASxB,SAMrB0B,EAAK3C,EA2BT,OAxBI0C,EADAC,IAAO3C,EACF9H,EAAMgF,UAAUwF,EAAIf,GAGpBgB,KAEE3C,GACP2C,EAwCR,WACI,IAAIG,EAAIJ,EAAIC,EAAII,EAAIC,EAYpB,GAXAF,EAAKnB,EACiC,KAAlCzJ,EAAM/R,WAAWwb,IACjBe,EAxYK,IAyYLf,MAGAe,EAAK1C,EAEDyC,EAAStB,IAGbuB,IAAO1C,EAAY,CAanB,GAZA2C,EAAKhB,EACLoB,EAAK,GACDvC,EAAOhd,KAAK0U,EAAM+K,OAAOtB,KACzBqB,EAAK9K,EAAM+K,OAAOtB,GAClBA,MAGAqB,EAAKhD,EAEDyC,EAASrB,IAGb4B,IAAOhD,EACP,KAAOgD,IAAOhD,GACV+C,EAAG1oB,KAAK2oB,GACJxC,EAAOhd,KAAK0U,EAAM+K,OAAOtB,KACzBqB,EAAK9K,EAAM+K,OAAOtB,GAClBA,MAGAqB,EAAKhD,EAEDyC,EAASrB,SAMrB2B,EAAK/C,GAGL2C,EADAI,IAAO/C,EACF9H,EAAMgF,UAAUyF,EAAIhB,GAGpBoB,KAEE/C,EAEP8C,EA9Z4B,CAAEnpB,KAAM,SAAUW,OAAQipB,SA8Z1CZ,KAGZhB,EAAcmB,EACdA,EAAK9C,EAEb,MAEI2B,EAAcmB,EACdA,EAAK9C,EAET,OAAO8C,CACX,CAxGaU,GACDb,IAAO3C,IACP2C,EAkBZ,WACI,IAAQD,EAiBR,OAhBKf,EACiC,KAAlCzJ,EAAM/R,WAAWwb,IACjBe,EArXK,IAsXLf,MAGAe,EAAK1C,EAEDyC,EAASvB,IAGbwB,IAAO1C,IAEP0C,EAtW0B,CAAE/oB,KAAM,YAwWjC+oB,CAET,CArCiBe,IAELd,IAAO3C,IACP2C,EAAK,MAETI,EAgJR,WACI,IAAID,EAAIJ,EAAIC,EAAII,EAAIC,EAYpB,GAXAF,EAAKnB,EACiC,KAAlCzJ,EAAM/R,WAAWwb,IACjBe,EAtfK,IAufLf,MAGAe,EAAK1C,EAEDyC,EAASnB,IAGboB,IAAO1C,EAAY,CAanB,GAZA2C,EAAKhB,EACLoB,EAAK,GACDrC,EAAOld,KAAK0U,EAAM+K,OAAOtB,KACzBqB,EAAK9K,EAAM+K,OAAOtB,GAClBA,MAGAqB,EAAKhD,EAEDyC,EAASlB,IAGbyB,IAAOhD,EACP,KAAOgD,IAAOhD,GACV+C,EAAG1oB,KAAK2oB,GACJtC,EAAOld,KAAK0U,EAAM+K,OAAOtB,KACzBqB,EAAK9K,EAAM+K,OAAOtB,GAClBA,MAGAqB,EAAKhD,EAEDyC,EAASlB,SAMrBwB,EAAK/C,GAGL2C,EADAI,IAAO/C,EACF9H,EAAMgF,UAAUyF,EAAIhB,GAGpBoB,KAEE/C,GAC+B,KAAlC9H,EAAM/R,WAAWwb,IACjBoB,EAriBH,IAsiBGpB,MAGAoB,EAAK/C,EAEDyC,EAASjB,IAGbuB,IAAO/C,EAEP8C,EAAYH,GAGZhB,EAAcmB,EACdA,EAAK9C,KAIT2B,EAAcmB,EACdA,EAAK9C,EAEb,MAEI2B,EAAcmB,EACdA,EAAK9C,EAET,OAAO8C,CACX,CAhOaY,GACDX,IAAO/C,IACP+C,EAAK,MAGTD,EAhVmD,CAAEnpB,KAAM,WAAY1B,KAgV3DyqB,EAhVuEnH,SAgVnEoH,EAhVuFnH,UAgVnFuH,KAGpBpB,EAAcmB,EACdA,EAAK9C,GAEF8C,CACX,CAsFA,SAASF,IACL,IAAQF,EAAIC,EAAII,EAchB,GAbKpB,EACLe,EAAKf,EACLgB,EAAK,GACDlC,EAAOjd,KAAK0U,EAAM+K,OAAOtB,KACzBoB,EAAK7K,EAAM+K,OAAOtB,GAClBA,MAGAoB,EAAK/C,EAEDyC,EAASpB,IAGb0B,IAAO/C,EACP,KAAO+C,IAAO/C,GACV2C,EAAGtoB,KAAK0oB,GACJtC,EAAOjd,KAAK0U,EAAM+K,OAAOtB,KACzBoB,EAAK7K,EAAM+K,OAAOtB,GAClBA,MAGAoB,EAAK/C,EAEDyC,EAASpB,SAMrBsB,EAAK3C,EAaT,OAVI0C,EADAC,IAAO3C,EACF9H,EAAMgF,UAAUwF,EAAIf,GAGpBgB,KAEE3C,IAEP0C,EAnd+B,CAAE/oB,KAAM,UAAWhC,MAmdtC+qB,IAEXA,CAET,CAmFA,IADA3C,EAAaM,OACML,GAAc2B,IAAgBzJ,EAAM5d,OACnD,OAAOylB,EAMP,MAHIA,IAAeC,GAAc2B,EAAczJ,EAAM5d,QACjDmoB,EA1fG,CAAE9oB,KAAM,QAiEe2jB,EA2bCwE,EA3bSvE,EA2bYsE,EAAiB3J,EAAM5d,OAAS4d,EAAM+K,OAAOpB,GAAkB,KA3bpErE,EA2b0EqE,EAAiB3J,EAAM5d,OAC1I8nB,EAAoBP,EAAgBA,EAAiB,GACrDO,EAAoBP,EAAgBA,GA5bnC,IAAIxE,EAAgBA,EAAgBuB,aAAatB,EAAUC,GAAQD,EAAUC,EAAOC,EA8bnG,E,mCCvuBA,IAAImG,EAAmB7rB,MAAQA,KAAK6rB,kBAAqBvsB,OAAO6C,OAAS,SAAU6F,EAAGjG,EAAGmO,EAAG4b,QAC7E3qB,IAAP2qB,IAAkBA,EAAK5b,GAC3B5Q,OAAOiF,eAAeyD,EAAG8jB,EAAI,CAAEtnB,YAAY,EAAMC,IAAK,WAAa,OAAO1C,EAAEmO,EAAI,GACnF,EAAI,SAAUlI,EAAGjG,EAAGmO,EAAG4b,QACT3qB,IAAP2qB,IAAkBA,EAAK5b,GAC3BlI,EAAE8jB,GAAM/pB,EAAEmO,EACb,GACG6b,EAAsB/rB,MAAQA,KAAK+rB,qBAAwBzsB,OAAO6C,OAAS,SAAU6F,EAAGwH,GACxFlQ,OAAOiF,eAAeyD,EAAG,UAAW,CAAExD,YAAY,EAAM3E,MAAO2P,GAClE,EAAI,SAASxH,EAAGwH,GACbxH,EAAW,QAAIwH,CACnB,GACIwc,EAAgBhsB,MAAQA,KAAKgsB,cAAiB,SAAUjI,GACxD,GAAIA,GAAOA,EAAIV,WAAY,OAAOU,EAClC,IAAI3Q,EAAS,CAAC,EACd,GAAW,MAAP2Q,EAAa,IAAK,IAAI7T,KAAK6T,EAAe,YAAN7T,GAAmB5Q,OAAOH,UAAU0kB,eAAezkB,KAAK2kB,EAAK7T,IAAI2b,EAAgBzY,EAAQ2Q,EAAK7T,GAEtI,OADA6b,EAAmB3Y,EAAQ2Q,GACpB3Q,CACX,EACI6Y,EAAgBjsB,MAAQA,KAAKisB,cAAiB,SAASlqB,EAAG1D,GAC1D,IAAK,IAAIulB,KAAK7hB,EAAa,YAAN6hB,GAAoBtkB,OAAOH,UAAU0kB,eAAezkB,KAAKf,EAASulB,IAAIiI,EAAgBxtB,EAAS0D,EAAG6hB,EAC3H,EACAvlB,EAAQglB,YAAa,EACrBhlB,EAAQ6tB,UAAY7tB,EAAQ2N,WAAQ,EACpC,IAAImgB,EAAUH,EAAa,EAAQ,MAC/BI,EAAMJ,EAAa,EAAQ,IAC3BK,EAAa,EAAQ,KAUzB,SAASH,EAAU9L,EAAO6J,GAEtB,YADkB,IAAdA,IAAwBA,EAAY,YACjCkC,EAAQngB,MAAMoU,EAAO,CAAE6J,UAAWA,GAC7C,CAJA5rB,EAAQ2N,MARR,SAAeoU,GACX,IAAIkE,EAAM4H,EAAU9L,EAAO,YAC3B,MAAO,CACHkE,IAAKA,EACLhJ,OAAQ,SAAU/B,GAAU,OAAO,EAAI8S,EAAWpI,gBAAgBK,EAAK/K,EAAS,EAChFvM,SAAU,WAAc,OAAOof,EAAIpf,SAASsX,EAAM,EAE1D,EAMAjmB,EAAQ6tB,UAAYA,EACpBD,EAAa,EAAQ,KAAe5tB,E,wECzChCiuB,EAA2B,CAAC,EAGhC,SAASC,EAAoBC,GAE5B,IAAIC,EAAeH,EAAyBE,GAC5C,QAAqBrrB,IAAjBsrB,EACH,OAAOA,EAAapuB,QAGrB,IAAIC,EAASguB,EAAyBE,GAAY,CAGjDnuB,QAAS,CAAC,GAOX,OAHAquB,EAAoBF,GAAUptB,KAAKd,EAAOD,QAASC,EAAQA,EAAOD,QAASkuB,GAGpEjuB,EAAOD,OACf,CCtBAkuB,EAAoBvQ,EAAI,WACvB,GAA0B,iBAAf2Q,WAAyB,OAAOA,WAC3C,IACC,OAAO3sB,MAAQ,IAAId,SAAS,cAAb,EAGhB,CAFE,MAAOqH,GACR,GAAsB,iBAAXqmB,OAAqB,OAAOA,MACxC,CACA,CAPuB,G,qXCAxB,aAAS,wEAAA7lB,OAAO,IAAY,yEAAAA,OAAO,IAAa,yEAAAA,OAAO,IACvD,aAAS,0EAAAA,OAAO,IAEhB,aAAe,8EAAAyS,YAAY,IAAE,uEAAAb,KAAK,IAElC,aAAS,yEAAAtY,OAAO,IAEhB,YACE,2EAAAqb,SAAS,IACT,+EAAAP,aAAa,IAEb,0EAAA4B,QAAQ,IACR,4EAAAoD,UAAU,IACV,yEAAA/D,OAAO,IACP,yEAAAvB,OAAO,IAGT,aAAS,8EAAAtI,YAAY,IACrB,aAAS,4EAAAC,UAAU,IACnB,aAAS,4EAAAC,UAAU,IAEnB,aAAS,2EAAA1L,OAAO,IAChB,aAAS,4EAAAA,OAAO,IAChB,aAAS,wEAAAA,OAAO,IAEhB,aAAS,yEAAAuQ,OAAO,IAKhB,aAAS,kFAAApB,gBAAgB,IAAE,mFAAAS,iBAAiB,G","sources":["webpack://Ketting/webpack/universalModuleDefinition","webpack://Ketting/./node_modules/events/events.js","webpack://Ketting/./node_modules/fetch-mw-oauth2/browser/fetch-mw-oauth2.min.js","webpack://Ketting/./node_modules/http-link-header/lib/link.js","webpack://Ketting/./node_modules/pct-encode/index.js","webpack://Ketting/./node_modules/querystring-browser/querystring.js","webpack://Ketting/./src/action.ts","webpack://Ketting/./src/cache/forever.ts","webpack://Ketting/./src/cache/index.ts","webpack://Ketting/./src/cache/never.ts","webpack://Ketting/./src/cache/short.ts","webpack://Ketting/./src/client.ts","webpack://Ketting/./src/follow-promise.ts","webpack://Ketting/./src/http/basic-auth.ts","webpack://Ketting/./src/http/bearer-auth.ts","webpack://Ketting/./src/http/error.ts","webpack://Ketting/./src/http/fetcher.ts","webpack://Ketting/./src/http/oauth2.ts","webpack://Ketting/./src/http/util.ts","webpack://Ketting/./src/link.ts","webpack://Ketting/./src/middlewares/accept-header.ts","webpack://Ketting/./src/middlewares/cache.ts","webpack://Ketting/./src/middlewares/warning.ts","webpack://Ketting/./src/resource.ts","webpack://Ketting/./src/state/base-state.ts","webpack://Ketting/./src/state/binary.ts","webpack://Ketting/./src/state/collection-json.ts","webpack://Ketting/./src/state/hal.ts","webpack://Ketting/./src/state/head.ts","webpack://Ketting/./src/state/html.ts","webpack://Ketting/./src/state/index.ts","webpack://Ketting/./src/state/interface.ts","webpack://Ketting/./src/state/jsonapi.ts","webpack://Ketting/./src/state/siren.ts","webpack://Ketting/./src/state/text.ts","webpack://Ketting/./src/util/base64.web.ts","webpack://Ketting/./src/util/fetch-body-helper.web.ts","webpack://Ketting/./src/util/html.web.ts","webpack://Ketting/./src/util/uri-template.ts","webpack://Ketting/./src/util/uri.web.ts","webpack://Ketting/./node_modules/uri-template/dist/ast.js","webpack://Ketting/./node_modules/uri-template/dist/expander.js","webpack://Ketting/./node_modules/uri-template/dist/grammar.js","webpack://Ketting/./node_modules/uri-template/dist/index.js","webpack://Ketting/webpack/bootstrap","webpack://Ketting/webpack/runtime/global","webpack://Ketting/./src/index.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Ketting\"] = factory();\n\telse\n\t\troot[\"Ketting\"] = factory();\n})(self, function() {\nreturn ","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function errorListener(err) {\n      emitter.removeListener(name, resolver);\n      reject(err);\n    }\n\n    function resolver() {\n      if (typeof emitter.removeListener === 'function') {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n\n    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });\n    if (name !== 'error') {\n      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });\n    }\n  });\n}\n\nfunction addErrorHandlerIfEventEmitter(emitter, handler, flags) {\n  if (typeof emitter.on === 'function') {\n    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);\n  }\n}\n\nfunction eventTargetAgnosticAddListener(emitter, name, listener, flags) {\n  if (typeof emitter.on === 'function') {\n    if (flags.once) {\n      emitter.once(name, listener);\n    } else {\n      emitter.on(name, listener);\n    }\n  } else if (typeof emitter.addEventListener === 'function') {\n    // EventTarget does not have `error` event semantics like Node\n    // EventEmitters, we do not listen for `error` events here.\n    emitter.addEventListener(name, function wrapListener(arg) {\n      // IE does not have builtin `{ once: true }` support so we\n      // have to do it manually.\n      if (flags.once) {\n        emitter.removeEventListener(name, wrapListener);\n      }\n      listener(arg);\n    });\n  } else {\n    throw new TypeError('The \"emitter\" argument must be of type EventEmitter. Received type ' + typeof emitter);\n  }\n}\n","!function(e,t){\"object\"==typeof exports&&\"object\"==typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define([],t):\"object\"==typeof exports?exports.fetchMwOAuth2=t():e.fetchMwOAuth2=t()}(self,(()=>(()=>{\"use strict\";var e={681:(e,t)=>{Object.defineProperty(t,\"__esModule\",{value:!0}),t.encode=void 0,t.encode=function(e){return btoa(e)}},443:(e,t)=>{Object.defineProperty(t,\"__esModule\",{value:!0});class r extends Error{constructor(e,t,r){super(e),this.oauth2Code=t,this.httpCode=r}}t.default=r},13:(e,t,r)=>{Object.defineProperty(t,\"__esModule\",{value:!0});const n=r(882);t.default=class{constructor(e,t=null){if(!e.grantType&&!t&&!e.accessToken)throw new Error(\"If no grantType is specified, a token must be provided\");this.options=e,e.accessToken&&(console.warn(\"[fetch-mw-oauth2] Specifying accessToken via the options argument in the constructor of OAuth2 is deprecated. Please supply the options in the second argument. Backwards compatability will be removed in a future version of this library\"),t={accessToken:e.accessToken,refreshToken:e.refreshToken||null,expiresAt:null}),this.token=t,this.activeRefresh=null,this.refreshTimer=null,this.scheduleRefresh()}async fetch(e,t){const r=new Request(e,t);return this.fetchMw(r,(e=>fetch(e)))}async fetchMw(e,t){const r=await this.getAccessToken();let n=e.clone();n.headers.set(\"Authorization\",\"Bearer \"+r);let o=await t(n);if(!o.ok&&401===o.status){const r=await this.refreshToken();n=e.clone(),n.headers.set(\"Authorization\",\"Bearer \"+r.accessToken),o=await t(n)}return o}async getToken(){return this.token&&(null===this.token.expiresAt||this.token.expiresAt>Date.now())?this.token:this.refreshToken()}async getAccessToken(){return(await this.getToken()).accessToken}async refreshToken(){if(this.activeRefresh)return this.activeRefresh;this.activeRefresh=(0,n.refreshToken)(this.options,this.token);try{const e=await this.activeRefresh;return this.token=e,this.scheduleRefresh(),e}catch(e){throw this.options.onAuthError&&this.options.onAuthError(e),e}finally{this.activeRefresh=null}}scheduleRefresh(){if(this.refreshTimer&&(clearTimeout(this.refreshTimer),this.refreshTimer=null),!this.token||!this.token.expiresAt||!this.token.refreshToken)return;const e=this.token.expiresAt-Date.now();e<12e4||(this.refreshTimer=setTimeout((async()=>{try{await this.refreshToken()}catch(e){console.error(\"[fetch-mw-oauth2] error while doing a background OAuth2 auto-refresh\",e)}}),e-6e4))}}},882:(e,t,r)=>{Object.defineProperty(t,\"__esModule\",{value:!0}),t.refreshToken=t.objToQueryString=void 0;const n=r(681),o=r(443);function s(e){return Object.entries(e).map((([e,t])=>void 0===t?\"\":encodeURIComponent(e)+\"=\"+encodeURIComponent(t))).join(\"&\")}t.objToQueryString=s,t.refreshToken=async function e(t,r){let i;const c=r;if(null==c?void 0:c.refreshToken)i={grant_type:\"refresh_token\",refresh_token:c.refreshToken},void 0===t.clientSecret&&(i.client_id=t.clientId);else switch(t.grantType){case\"client_credentials\":i={grant_type:\"client_credentials\"},t.scope&&(i.scope=t.scope.join(\" \"));break;case\"password\":i={grant_type:\"password\",username:t.userName,password:t.password},t.scope&&(i.scope=t.scope.join(\" \"));break;case\"authorization_code\":i={grant_type:\"authorization_code\",code:t.code,redirect_uri:t.redirectUri,client_id:t.clientId,code_verifier:t.codeVerifier};break;default:throw\"string\"==typeof t.grantType?new Error(\"Unknown grantType: \"+t.grantType):new Error('Cannot obtain an access token if no \"grantType\" is specified')}const a={\"Content-Type\":\"application/x-www-form-urlencoded\"};let h=!1;if(void 0!==t.clientSecret){h=!0;const e=(0,n.encode)(t.clientId+\":\"+t.clientSecret);a.Authorization=\"Basic \"+e}const u=await fetch(t.tokenEndpoint,{method:\"POST\",headers:a,body:s(i)}),f=await u.json();if(!u.ok){if(\"refresh_token\"===i.grant_type&&t.grantType)return e(t,null);const r=u.status;let n,s;throw f.error?(n=\"OAuth2 error \"+f.error+\".\",f.error_description&&(n+=\" \"+f.error_description),s=f.error):(n=\"HTTP Error \"+u.status+\" \"+u.statusText,401===u.status&&h&&(n+=\". It's likely that the clientId and/or clientSecret was incorrect\"),s=null),new o.default(n,s,r)}const l={accessToken:f.access_token,expiresAt:f.expires_in?Date.now()+1e3*f.expires_in:null,refreshToken:f.refresh_token?f.refresh_token:null};return t.onTokenUpdate&&t.onTokenUpdate(l),l}}},t={};function r(n){var o=t[n];if(void 0!==o)return o.exports;var s=t[n]={exports:{}};return e[n](s,s.exports,r),s.exports}var n={};return(()=>{var e=n;Object.defineProperty(e,\"__esModule\",{value:!0}),e.OAuth2Error=e.OAuth2=e.fetchMwOAuth2=e.default=void 0;var t=r(13);Object.defineProperty(e,\"default\",{enumerable:!0,get:function(){return t.default}}),Object.defineProperty(e,\"fetchMwOAuth2\",{enumerable:!0,get:function(){return t.default}}),Object.defineProperty(e,\"OAuth2\",{enumerable:!0,get:function(){return t.default}});var o=r(443);Object.defineProperty(e,\"OAuth2Error\",{enumerable:!0,get:function(){return o.default}})})(),n})()));\n//# sourceMappingURL=fetch-mw-oauth2.min.js.map","'use strict'\n\nvar COMPATIBLE_ENCODING_PATTERN = /^utf-?8|ascii|utf-?16-?le|ucs-?2|base-?64|latin-?1$/i\nvar WS_TRIM_PATTERN = /^[\\s\\uFEFF\\xA0]+|[\\s\\uFEFF\\xA0]+$/g\nvar WS_CHAR_PATTERN = /\\s|\\uFEFF|\\xA0/\nvar WS_FOLD_PATTERN = /\\r?\\n[\\x20\\x09]+/g\nvar DELIMITER_PATTERN = /[;,\"]/\nvar WS_DELIMITER_PATTERN = /[;,\"]|\\s/\n\n/**\n * Token character pattern\n * @type {RegExp}\n * @see https://tools.ietf.org/html/rfc7230#section-3.2.6\n */\nvar TOKEN_PATTERN = /^[!#$%&'*+\\-\\.^_`|~\\da-zA-Z]+$/\n\nvar STATE = {\n  IDLE: 1 << 0,\n  URI: 1 << 1,\n  ATTR: 1 << 2,\n}\n\nfunction trim( value ) {\n  return value.replace( WS_TRIM_PATTERN, '' )\n}\n\nfunction hasWhitespace( value ) {\n  return WS_CHAR_PATTERN.test( value )\n}\n\nfunction skipWhitespace( value, offset ) {\n  while( hasWhitespace( value[offset] ) ) {\n    offset++\n  }\n  return offset\n}\n\nfunction needsQuotes( value ) {\n  return WS_DELIMITER_PATTERN.test( value ) ||\n    !TOKEN_PATTERN.test( value )\n}\n\nclass Link {\n\n  /**\n   * Link\n   * @constructor\n   * @param {String} [value]\n   * @returns {Link}\n   */\n  constructor( value ) {\n\n    /** @type {Array} URI references */\n    this.refs = []\n\n    if( value ) {\n      this.parse( value )\n    }\n\n  }\n\n  /**\n   * Get refs with given relation type\n   * @param {String} value\n   * @returns {Array<Object>}\n   */\n  rel( value ) {\n\n    var links = []\n    var type = value.toLowerCase()\n\n    for( var i = 0; i < this.refs.length; i++ ) {\n      if( this.refs[ i ].rel.toLowerCase() === type ) {\n        links.push( this.refs[ i ] )\n      }\n    }\n\n    return links\n\n  }\n\n  /**\n   * Get refs where given attribute has a given value\n   * @param {String} attr\n   * @param {String} value\n   * @returns {Array<Object>}\n   */\n  get( attr, value ) {\n\n    attr = attr.toLowerCase()\n\n    var links = []\n\n    for( var i = 0; i < this.refs.length; i++ ) {\n      if( this.refs[ i ][ attr ] === value ) {\n        links.push( this.refs[ i ] )\n      }\n    }\n\n    return links\n\n  }\n\n  set( link ) {\n    this.refs.push( link )\n    return this\n  }\n\n  has( attr, value ) {\n\n    attr = attr.toLowerCase()\n\n    for( var i = 0; i < this.refs.length; i++ ) {\n      if( this.refs[ i ][ attr ] === value ) {\n        return true\n      }\n    }\n\n    return false\n\n  }\n\n  parse( value, offset ) {\n\n    offset = offset || 0\n    value = offset ? value.slice( offset ) : value\n\n    // Trim & unfold folded lines\n    value = trim( value ).replace( WS_FOLD_PATTERN, '' )\n\n    var state = STATE.IDLE\n    var length = value.length\n    var offset = 0\n    var ref = null\n\n    while( offset < length ) {\n      if( state === STATE.IDLE ) {\n        if( hasWhitespace( value[offset] ) ) {\n          offset++\n          continue\n        } else if( value[offset] === '<' ) {\n          if( ref != null ) {\n            ref.rel != null ?\n              this.refs.push( ...Link.expandRelations( ref ) ) :\n              this.refs.push( ref )\n          }\n          var end = value.indexOf( '>', offset )\n          if( end === -1 ) throw new Error( 'Expected end of URI delimiter at offset ' + offset )\n          ref = { uri: value.slice( offset + 1, end ) }\n          // this.refs.push( ref )\n          offset = end\n          state = STATE.URI\n        } else {\n          throw new Error( 'Unexpected character \"' + value[offset] + '\" at offset ' + offset )\n        }\n        offset++\n      } else if( state === STATE.URI ) {\n        if( hasWhitespace( value[offset] ) ) {\n          offset++\n          continue\n        } else if( value[offset] === ';' ) {\n          state = STATE.ATTR\n          offset++\n        } else if( value[offset] === ',' ) {\n          state = STATE.IDLE\n          offset++\n        } else {\n          throw new Error( 'Unexpected character \"' + value[offset] + '\" at offset ' + offset )\n        }\n      } else if( state === STATE.ATTR ) {\n        if( value[offset] ===';' || hasWhitespace( value[offset] ) ) {\n          offset++\n          continue\n        }\n        var end = value.indexOf( '=', offset )\n        if( end === -1 ) throw new Error( 'Expected attribute delimiter at offset ' + offset )\n        var attr = trim( value.slice( offset, end ) ).toLowerCase()\n        var attrValue = ''\n        offset = end + 1\n        offset = skipWhitespace( value, offset )\n        if( value[offset] === '\"' ) {\n          offset++\n          while( offset < length ) {\n            if( value[offset] === '\"' ) {\n              offset++; break\n            }\n            if( value[offset] === '\\\\' ) {\n              offset++\n            }\n            attrValue += value[offset]\n            offset++\n          }\n        } else {\n          var end = offset + 1\n          while( !DELIMITER_PATTERN.test( value[end] ) && end < length ) {\n            end++\n          }\n          attrValue = value.slice( offset, end )\n          offset = end\n        }\n        if( ref[ attr ] && Link.isSingleOccurenceAttr( attr ) ) {\n          // Ignore multiples of attributes which may only appear once\n        } else if( attr[ attr.length - 1 ] === '*' ) {\n          ref[ attr ] = Link.parseExtendedValue( attrValue )\n        } else {\n          attrValue = attr === 'type' ?\n            attrValue.toLowerCase() : attrValue\n          if( ref[ attr ] != null ) {\n            if( Array.isArray( ref[ attr ] ) ) {\n              ref[ attr ].push( attrValue )\n            } else {\n              ref[ attr ] = [ ref[ attr ], attrValue ]\n            }\n          } else {\n            ref[ attr ] = attrValue\n          }\n        }\n        switch( value[offset] ) {\n          case ',': state = STATE.IDLE; break\n          case ';': state = STATE.ATTR; break\n        }\n        offset++\n      } else {\n        throw new Error( 'Unknown parser state \"' + state + '\"' )\n      }\n    }\n\n    if( ref != null ) {\n      ref.rel != null ?\n        this.refs.push( ...Link.expandRelations( ref ) ) :\n        this.refs.push( ref )\n    }\n\n    ref = null\n\n    return this\n\n  }\n\n  toString() {\n\n    var refs = []\n    var link = ''\n    var ref = null\n\n    for( var i = 0; i < this.refs.length; i++ ) {\n      ref = this.refs[i]\n      link = Object.keys( this.refs[i] ).reduce( function( link, attr ) {\n        if( attr === 'uri' ) return link\n        return link + '; ' + Link.formatAttribute( attr, ref[ attr ] )\n      }, '<' + ref.uri + '>' )\n      refs.push( link )\n    }\n\n    return refs.join( ', ' )\n\n  }\n\n}\n\n/**\n * Determines whether an encoding can be\n * natively handled with a `Buffer`\n * @param {String} value\n * @returns {Boolean}\n */\nLink.isCompatibleEncoding = function( value ) {\n  return COMPATIBLE_ENCODING_PATTERN.test( value )\n}\n\nLink.parse = function( value, offset ) {\n  return new Link().parse( value, offset )\n}\n\nLink.isSingleOccurenceAttr = function( attr ) {\n  return attr === 'rel' || attr === 'type' || attr === 'media' ||\n    attr === 'title' || attr === 'title*'\n}\n\nLink.isTokenAttr = function( attr ) {\n  return attr === 'rel' || attr === 'type' || attr === 'anchor'\n}\n\nLink.escapeQuotes = function( value ) {\n  return value.replace( /\"/g, '\\\\\"' )\n}\n\nLink.expandRelations = function( ref ) {\n  var rels = ref.rel.split( ' ' )\n  return rels.map( function( rel ) {\n    var value = Object.assign( {}, ref )\n    value.rel = rel\n    return value\n  })\n}\n\n/**\n * Parses an extended value and attempts to decode it\n * @internal\n * @param {String} value\n * @return {Object}\n */\nLink.parseExtendedValue = function( value ) {\n  var parts = /([^']+)?(?:'([^']*)')?(.+)/.exec( value )\n  return {\n    language: parts[2].toLowerCase(),\n    encoding: Link.isCompatibleEncoding( parts[1] ) ?\n      null : parts[1].toLowerCase(),\n    value: Link.isCompatibleEncoding( parts[1] ) ?\n      decodeURIComponent( parts[3] ) : parts[3]\n  }\n}\n\n/**\n * Format a given extended attribute and it's value\n * @param {String} attr\n * @param {Object} data\n * @return {String}\n */\nLink.formatExtendedAttribute = function( attr, data ) {\n\n  var encoding = ( data.encoding || 'utf-8' ).toUpperCase()\n  var language = data.language || 'en'\n\n  var encodedValue = ''\n\n  if( Buffer.isBuffer( data.value ) && Link.isCompatibleEncoding( encoding ) ) {\n    encodedValue = data.value.toString( encoding )\n  } else if( Buffer.isBuffer( data.value ) ) {\n    encodedValue = data.value.toString( 'hex' )\n      .replace( /[0-9a-f]{2}/gi, '%$1' )\n  } else {\n    encodedValue = encodeURIComponent( data.value )\n  }\n\n  return attr + '=' + encoding + '\\'' +\n    language + '\\'' + encodedValue\n\n}\n\n/**\n * Format a given attribute and it's value\n * @param {String} attr\n * @param {String|Object} value\n * @return {String}\n */\nLink.formatAttribute = function( attr, value ) {\n\n  if( Array.isArray( value ) ) {\n    return value.map(( item ) => {\n      return Link.formatAttribute( attr, item )\n    }).join( '; ' )\n  }\n\n  if( attr[ attr.length - 1 ] === '*' || typeof value !== 'string' ) {\n    return Link.formatExtendedAttribute( attr, value )\n  }\n\n  if( Link.isTokenAttr( attr ) ) {\n    value = needsQuotes( value ) ?\n      '\"' + Link.escapeQuotes( value ) + '\"' :\n      Link.escapeQuotes( value )\n  } else if( needsQuotes( value ) ) {\n    value = encodeURIComponent( value )\n    // We don't need to escape <SP> <,> <;> within quotes\n    value = value\n      .replace( /%20/g, ' ' )\n      .replace( /%2C/g, ',' )\n      .replace( /%3B/g, ';' )\n\n    value = '\"' + value + '\"'\n  }\n\n  return attr + '=' + value\n\n}\n\nmodule.exports = Link\n","module.exports = function pctEncode(regexp) {\n  regexp = regexp || /\\W/g;\n  return function encode(string) {\n    string = String(string);\n    return string.replace(regexp, function (m) {\n      var c = m[0].charCodeAt(0)\n        , encoded = [];\n      if (c < 128) {\n        encoded.push(c);\n      } else if ((128 <= c && c < 2048)) {\n        encoded.push((c >> 6) | 192);\n        encoded.push((c & 63) | 128);\n      } else {\n        encoded.push((c >> 12) | 224);\n        encoded.push(((c >> 6) & 63) | 128);\n        encoded.push((c & 63) | 128);\n      }\n      return encoded.map(function (c) {\n        return '%' + c.toString(16).toUpperCase();\n      }).join('');\n    })\n  }\n}\n","// Query String Utilities\n\n'use strict';\n\nvar QueryString = exports;\nvar Buffer = require('buffer').Buffer;\n\n\n// a safe fast alternative to decodeURIComponent\nQueryString.unescapeBuffer = function(s, decodeSpaces) {\n  var out = new Buffer(s.length);\n  var state = 0;\n  var n, m, hexchar;\n\n  for (var inIndex = 0, outIndex = 0; inIndex <= s.length; inIndex++) {\n    var c = inIndex < s.length ? s.charCodeAt(inIndex) : NaN;\n    switch (state) {\n      case 0: // Any character\n        switch (c) {\n          case 37: // '%'\n            n = 0;\n            m = 0;\n            state = 1;\n            break;\n          case 43: // '+'\n            if (decodeSpaces)\n              c = 32; // ' '\n            // falls through\n          default:\n            out[outIndex++] = c;\n            break;\n        }\n        break;\n\n      case 1: // First hex digit\n        hexchar = c;\n        if (c >= 48/*0*/ && c <= 57/*9*/) {\n          n = c - 48/*0*/;\n        } else if (c >= 65/*A*/ && c <= 70/*F*/) {\n          n = c - 65/*A*/ + 10;\n        } else if (c >= 97/*a*/ && c <= 102/*f*/) {\n          n = c - 97/*a*/ + 10;\n        } else {\n          out[outIndex++] = 37/*%*/;\n          out[outIndex++] = c;\n          state = 0;\n          break;\n        }\n        state = 2;\n        break;\n\n      case 2: // Second hex digit\n        state = 0;\n        if (c >= 48/*0*/ && c <= 57/*9*/) {\n          m = c -  48/*0*/;\n        } else if (c >= 65/*A*/ && c <= 70/*F*/) {\n          m = c - 65/*A*/ + 10;\n        } else if (c >= 97/*a*/ && c <= 102/*f*/) {\n          m = c - 97/*a*/ + 10;\n        } else {\n          out[outIndex++] = 37/*%*/;\n          out[outIndex++] = hexchar;\n          out[outIndex++] = c;\n          break;\n        }\n        out[outIndex++] = 16 * n + m;\n        break;\n    }\n  }\n\n  // TODO support returning arbitrary buffers.\n\n  return out.slice(0, outIndex - 1);\n};\n\n\nfunction qsUnescape(s, decodeSpaces) {\n  try {\n    return decodeURIComponent(s);\n  } catch (e) {\n    return QueryString.unescapeBuffer(s, decodeSpaces).toString();\n  }\n}\nQueryString.unescape = qsUnescape;\n\n\nvar hexTable = new Array(256);\nfor (var i = 0; i < 256; ++i)\n  hexTable[i] = '%' + ((i < 16 ? '0' : '') + i.toString(16)).toUpperCase();\nQueryString.escape = function(str) {\n  // replaces encodeURIComponent\n  // http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3.4\n  if (typeof str !== 'string')\n    str += '';\n  var out = '';\n  var lastPos = 0;\n\n  for (var i = 0; i < str.length; ++i) {\n    var c = str.charCodeAt(i);\n\n    // These characters do not need escaping (in order):\n    // ! - . _ ~\n    // ' ( ) *\n    // digits\n    // alpha (uppercase)\n    // alpha (lowercase)\n    if (c === 0x21 || c === 0x2D || c === 0x2E || c === 0x5F || c === 0x7E ||\n        (c >= 0x27 && c <= 0x2A) ||\n        (c >= 0x30 && c <= 0x39) ||\n        (c >= 0x41 && c <= 0x5A) ||\n        (c >= 0x61 && c <= 0x7A)) {\n      continue;\n    }\n\n    if (i - lastPos > 0)\n      out += str.slice(lastPos, i);\n\n    // Other ASCII characters\n    if (c < 0x80) {\n      lastPos = i + 1;\n      out += hexTable[c];\n      continue;\n    }\n\n    // Multi-byte characters ...\n    if (c < 0x800) {\n      lastPos = i + 1;\n      out += hexTable[0xC0 | (c >> 6)] + hexTable[0x80 | (c & 0x3F)];\n      continue;\n    }\n    if (c < 0xD800 || c >= 0xE000) {\n      lastPos = i + 1;\n      out += hexTable[0xE0 | (c >> 12)] +\n             hexTable[0x80 | ((c >> 6) & 0x3F)] +\n             hexTable[0x80 | (c & 0x3F)];\n      continue;\n    }\n    // Surrogate pair\n    ++i;\n    var c2;\n    if (i < str.length)\n      c2 = str.charCodeAt(i) & 0x3FF;\n    else\n      throw new URIError('URI malformed');\n    lastPos = i + 1;\n    c = 0x10000 + (((c & 0x3FF) << 10) | c2);\n    out += hexTable[0xF0 | (c >> 18)] +\n           hexTable[0x80 | ((c >> 12) & 0x3F)] +\n           hexTable[0x80 | ((c >> 6) & 0x3F)] +\n           hexTable[0x80 | (c & 0x3F)];\n  }\n  if (lastPos === 0)\n    return str;\n  if (lastPos < str.length)\n    return out + str.slice(lastPos);\n  return out;\n};\n\nvar stringifyPrimitive = function(v) {\n  if (typeof v === 'string')\n    return v;\n  if (typeof v === 'number' && isFinite(v))\n    return '' + v;\n  if (typeof v === 'boolean')\n    return v ? 'true' : 'false';\n  return '';\n};\n\n\nQueryString.stringify = QueryString.encode = function(obj, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n\n  var encode = QueryString.escape;\n  if (options && typeof options.encodeURIComponent === 'function') {\n    encode = options.encodeURIComponent;\n  }\n\n  if (obj !== null && typeof obj === 'object') {\n    var keys = Object.keys(obj);\n    var len = keys.length;\n    var flast = len - 1;\n    var fields = '';\n    for (var i = 0; i < len; ++i) {\n      var k = keys[i];\n      var v = obj[k];\n      var ks = encode(stringifyPrimitive(k)) + eq;\n\n      if (Array.isArray(v)) {\n        var vlen = v.length;\n        var vlast = vlen - 1;\n        for (var j = 0; j < vlen; ++j) {\n          fields += ks + encode(stringifyPrimitive(v[j]));\n          if (j < vlast)\n            fields += sep;\n        }\n        if (vlen && i < flast)\n          fields += sep;\n      } else {\n        fields += ks + encode(stringifyPrimitive(v));\n        if (i < flast)\n          fields += sep;\n      }\n    }\n    return fields;\n  }\n  return '';\n};\n\n// Parse a key/val string.\nQueryString.parse = QueryString.decode = function(qs, sep, eq, options) {\n  sep = sep || '&';\n  eq = eq || '=';\n\n  var obj = {};\n\n  if (typeof qs !== 'string' || qs.length === 0) {\n    return obj;\n  }\n\n  if (typeof sep !== 'string')\n    sep += '';\n\n  var eqLen = eq.length;\n  var sepLen = sep.length;\n\n  var maxKeys = 1000;\n  if (options && typeof options.maxKeys === 'number') {\n    maxKeys = options.maxKeys;\n  }\n\n  var pairs = Infinity;\n  if (maxKeys > 0)\n    pairs = maxKeys;\n\n  var decode = QueryString.unescape;\n  if (options && typeof options.decodeURIComponent === 'function') {\n    decode = options.decodeURIComponent;\n  }\n  var customDecode = (decode !== qsUnescape);\n\n  var keys = [];\n  var lastPos = 0;\n  var sepIdx = 0;\n  var eqIdx = 0;\n  var key = '';\n  var value = '';\n  var keyEncoded = customDecode;\n  var valEncoded = customDecode;\n  var encodeCheck = 0;\n  for (var i = 0; i < qs.length; ++i) {\n    var code = qs.charCodeAt(i);\n\n    // Try matching key/value pair separator (e.g. '&')\n    if (code === sep.charCodeAt(sepIdx)) {\n      if (++sepIdx === sepLen) {\n        // Key/value pair separator match!\n        var end = i - sepIdx + 1;\n        if (eqIdx < eqLen) {\n          // If we didn't find the key/value separator, treat the substring as\n          // part of the key instead of the value\n          if (lastPos < end)\n            key += qs.slice(lastPos, end);\n        } else if (lastPos < end)\n          value += qs.slice(lastPos, end);\n        if (keyEncoded)\n          key = decodeStr(key, decode);\n        if (valEncoded)\n          value = decodeStr(value, decode);\n        // Use a key array lookup instead of using hasOwnProperty(), which is\n        // slower\n        if (keys.indexOf(key) === -1) {\n          obj[key] = value;\n          keys[keys.length] = key;\n        } else {\n          var curValue = obj[key];\n          // `instanceof Array` is used instead of Array.isArray() because it\n          // is ~15-20% faster with v8 4.7 and is safe to use because we are\n          // using it with values being created within this function\n          if (curValue instanceof Array)\n            curValue[curValue.length] = value;\n          else\n            obj[key] = [curValue, value];\n        }\n        if (--pairs === 0)\n          break;\n        keyEncoded = valEncoded = customDecode;\n        encodeCheck = 0;\n        key = value = '';\n        lastPos = i + 1;\n        sepIdx = eqIdx = 0;\n      }\n      continue;\n    } else {\n      sepIdx = 0;\n      if (!valEncoded) {\n        // Try to match an (valid) encoded byte (once) to minimize unnecessary\n        // calls to string decoding functions\n        if (code === 37/*%*/) {\n          encodeCheck = 1;\n        } else if (encodeCheck > 0 &&\n                   ((code >= 48/*0*/ && code <= 57/*9*/) ||\n                    (code >= 65/*A*/ && code <= 70/*Z*/) ||\n                    (code >= 97/*a*/ && code <= 102/*z*/))) {\n          if (++encodeCheck === 3)\n            valEncoded = true;\n        } else {\n          encodeCheck = 0;\n        }\n      }\n    }\n\n    // Try matching key/value separator (e.g. '=') if we haven't already\n    if (eqIdx < eqLen) {\n      if (code === eq.charCodeAt(eqIdx)) {\n        if (++eqIdx === eqLen) {\n          // Key/value separator match!\n          var end = i - eqIdx + 1;\n          if (lastPos < end)\n            key += qs.slice(lastPos, end);\n          encodeCheck = 0;\n          lastPos = i + 1;\n        }\n        continue;\n      } else {\n        eqIdx = 0;\n        if (!keyEncoded) {\n          // Try to match an (valid) encoded byte once to minimize unnecessary\n          // calls to string decoding functions\n          if (code === 37/*%*/) {\n            encodeCheck = 1;\n          } else if (encodeCheck > 0 &&\n                     ((code >= 48/*0*/ && code <= 57/*9*/) ||\n                      (code >= 65/*A*/ && code <= 70/*Z*/) ||\n                      (code >= 97/*a*/ && code <= 102/*z*/))) {\n            if (++encodeCheck === 3)\n              keyEncoded = true;\n          } else {\n            encodeCheck = 0;\n          }\n        }\n      }\n    }\n\n    if (code === 43/*+*/) {\n      if (eqIdx < eqLen) {\n        if (i - lastPos > 0)\n          key += qs.slice(lastPos, i);\n        key += '%20';\n        keyEncoded = true;\n      } else {\n        if (i - lastPos > 0)\n          value += qs.slice(lastPos, i);\n        value += '%20';\n        valEncoded = true;\n      }\n      lastPos = i + 1;\n    }\n  }\n\n  // Check if we have leftover key or value data\n  if (pairs > 0 && (lastPos < qs.length || eqIdx > 0)) {\n    if (lastPos < qs.length) {\n      if (eqIdx < eqLen)\n        key += qs.slice(lastPos);\n      else if (sepIdx < sepLen)\n        value += qs.slice(lastPos);\n    }\n    if (keyEncoded)\n      key = decodeStr(key, decode);\n    if (valEncoded)\n      value = decodeStr(value, decode);\n    // Use a key array lookup instead of using hasOwnProperty(), which is\n    // slower\n    if (keys.indexOf(key) === -1) {\n      obj[key] = value;\n      keys[keys.length] = key;\n    } else {\n      var curValue = obj[key];\n      // `instanceof Array` is used instead of Array.isArray() because it\n      // is ~15-20% faster with v8 4.7 and is safe to use because we are\n      // using it with values being created within this function\n      if (curValue instanceof Array)\n        curValue[curValue.length] = value;\n      else\n        obj[key] = [curValue, value];\n    }\n  }\n\n  return obj;\n};\n\n\n// v8 does not optimize functions with try-catch blocks, so we isolate them here\n// to minimize the damage\nfunction decodeStr(s, decoder) {\n  try {\n    return decoder(s);\n  } catch (e) {\n    return QueryString.unescape(s, true);\n  }\n}","import { State } from './state';\nimport * as qs from 'querystring';\nimport Client from './client';\nimport { Field } from './field';\n\nexport interface ActionInfo {\n\n  /**\n   * What url to post the form to.\n   */\n  uri: string;\n\n  /**\n   * Action name.\n   *\n   * Some formats call this the 'rel'\n   */\n  name: string | null;\n\n  /**\n   * Form title.\n   *\n   * Should be human-friendly.\n   */\n  title?: string;\n\n  /**\n   * The HTTP method to use\n   */\n  method: string;\n\n  /**\n   * The contentType to use for the form submission\n   */\n  contentType: string;\n\n  /**\n   * Returns the list of fields associated to an action\n   */\n  fields: Field[];\n\n}\n\n/**\n * An action represents a hypermedia form submission or action.\n */\nexport interface Action<T extends Record<string, any> = Record<string, any>> extends ActionInfo {\n\n  /**\n   * Execute the action or submit the form.\n   */\n  submit(formData: T): Promise<State>;\n\n}\n\nexport class SimpleAction<TFormData extends Record<string, any>> implements Action {\n\n  /**\n   * What url to post the form to.\n   */\n  uri!: string;\n\n  /**\n   * Action name.\n   *\n   * Some formats call this the 'rel'\n   */\n  name!: string | null;\n\n  /**\n   * Form title.\n   *\n   * Should be human-friendly.\n   */\n  title!: string;\n\n  /**\n   * The HTTP method to use\n   */\n  method!: string;\n\n  /**\n   * The contentType to use for the form submission\n   */\n  contentType!: string;\n\n  /**\n   * Returns the list of fields associated to an action\n   */\n  fields!: Field[];\n\n  /**\n   * Reference to client\n   */\n  client: Client;\n\n  constructor(client: Client, formInfo: ActionInfo) {\n    this.client = client;\n\n    for(const [k, v] of Object.entries(formInfo)) {\n      this[k as keyof ActionInfo] = v;\n    }\n\n  }\n\n  /**\n   * Execute the action or submit the form.\n   */\n  async submit(formData: TFormData): Promise<State<any>> {\n\n    const uri = new URL(this.uri);\n\n    if (this.method === 'GET') {\n      uri.search = qs.stringify(formData);\n      const resource = this.client.go(uri.toString());\n      return resource.get();\n    }\n    let body;\n    switch (this.contentType) {\n      case 'application/x-www-form-urlencoded' :\n        body = qs.stringify(formData);\n        break;\n      case 'application/json':\n        body = JSON.stringify(formData);\n        break;\n      default :\n        throw new Error(`Serializing mimetype ${this.contentType} is not yet supported in actions`);\n    }\n    const response = await this.client.fetcher.fetchOrThrow(uri.toString(), {\n      method: this.method,\n      body,\n      headers: {\n        'Content-Type': this.contentType\n      }\n    });\n    const state = this.client.getStateForResponse(uri.toString(), response);\n    return state;\n\n  }\n}\n\nexport class ActionNotFound extends Error {}\n","import { StateCache } from './';\nimport { State } from '../state';\n\n/**\n * The 'Forever' cache stores any State for as long as the application\n * lives.\n *\n * It is a good default for most applications, but it means that if\n * a resource was changed server-side, Ketting will not pick up that change\n * until something was done to expire caches.\n *\n * Executing an unsafe method, calling clearCache() on a resource, or\n * when a resource appears in Location, Content-Location, or \"invalidates\"\n * link relationships.\n */\nexport class ForeverCache implements StateCache {\n\n  private cache: Map<string, State>;\n\n  constructor() {\n    this.cache = new Map();\n  }\n\n  /**\n   * Store a State object.\n   *\n   * This function will clone the state object before storing\n   */\n  store(state: State) {\n    this.cache.set(\n      state.uri,\n      state.clone()\n    );\n  }\n\n  /**\n   * Retrieve a State object from the cache by its absolute uri\n   */\n  get(uri: string): State | null {\n\n    const state = this.cache.get(uri);\n    if (!state) {\n      return null;\n    }\n    return state.clone();\n\n  }\n\n  /**\n   * Return true if a State object with the specified uri exists in the cache\n   */\n  has(uri: string): boolean {\n\n    return this.cache.has(uri);\n\n  }\n\n  /**\n   * Delete a State object from the cache, by its uri\n   */\n  delete(uri: string) {\n    this.cache.delete(uri);\n  }\n\n  /**\n   * Purge the entire cache\n   */\n  clear() {\n    this.cache.clear();\n  }\n\n}\n","export { ForeverCache } from './forever';\nexport { ShortCache } from './short';\nexport { NeverCache } from './never';\nimport { State } from '../state';\n\n/**\n * Cache interface\n *\n * The cache is responsible for storing 'state' objects\n */\nexport interface StateCache {\n\n  /**\n   * Store a State object.\n   *\n   * This function will clone the state object before storing\n   */\n  store: (state: State) => void;\n\n  /**\n   * Retrieve a State object from the cache by its absolute uri\n   */\n  get: (uri: string) => State | null;\n\n  /**\n   * Return true if a State object with the specified uri exists in the cache\n   */\n  has: (uri: string) => boolean;\n\n  /**\n   * Delete a State object from the cache, by its uri\n   */\n  delete: (uri: string) => void;\n\n  /**\n   * Purge the entire cache\n   */\n  clear: () => void;\n\n}\n","import { StateCache } from './';\nimport { State } from '../state';\n\n/**\n * The NeverCache caches absolutely nothing.\n *\n * This should usually only be used in testing scenarios or if you really\n * know what you're doing.\n *\n * Using it could cause excessive requests, and will cause embedded items\n * to be ignored.\n */\nexport class NeverCache implements StateCache {\n\n  /**\n   * Store a State object.\n   *\n   * This function will clone the state object before storing\n   */\n  store(state: State) {\n    // Nothing to do\n  }\n\n  /**\n   * Retrieve a State object from the cache by its absolute uri\n   */\n  get(uri: string): null {\n    return null;\n  }\n\n  /**\n   * Return true if a State object with the specified uri exists in the cache\n   */\n  has(uri: string): boolean {\n\n    return false;\n\n  }\n\n  /**\n   * Delete a State object from the cache, by its uri\n   */\n  delete(uri: string) {\n    // Nothing to do\n  }\n\n  /**\n   * Purge the entire cache\n   */\n  clear() {\n    // Nothing to do\n  }\n\n}\n","import { State } from '../state';\nimport { ForeverCache } from './forever';\n\n/**\n * ShortCache stores items in the cache for a short time.\n *\n * This cache can be a good choice if your server heavily relies\n * on HTTP cache headers and Ketting runs in your browser, or if in general\n * you want very up-to-date data.\n *\n * The reason in this scenarios it's useful to still have a 'very temporary'\n * cache, is because during many operations `get()` may be called in rapid\n * succession, and it also allows for enough time for 'embedded items' to\n * pe placed in the cache and extracted again.\n */\nexport class ShortCache extends ForeverCache {\n\n  private cacheTimeout: number;\n  private activeTimers: Map<string, ReturnType<typeof setInterval>>;\n\n  /**\n   * Create the short cache.\n   *\n   * cacheTimeout is specified in ms.\n   */\n  constructor(cacheTimeout: number = 30000) {\n    super();\n    this.cacheTimeout = cacheTimeout;\n    this.activeTimers = new Map();\n  }\n\n  /**\n   * Store a State object.\n   *\n   * This function will clone the state object before storing\n   */\n  store(state: State) {\n    super.store(state);\n    this.setTimer(state.uri);\n  }\n\n  private setTimer(uri: string) {\n\n    if (this.activeTimers.has(uri)) {\n      clearTimeout(this.activeTimers.get(uri)!);\n    }\n    // If there is a TON in the cache, this algorithm might\n    // be optimized by using a linked list and a single timeout\n    // for the 'next scheduled' expiry.\n    //\n    // The expectation is that this is not the case though, so this is the\n    // lazy/easy way.\n    this.activeTimers.set(\n      uri,\n      setTimeout( () => {\n        this.delete(uri);\n        this.activeTimers.delete(uri);\n      }, this.cacheTimeout)\n    );\n\n  }\n\n}\n","import { Fetcher, FetchMiddleware } from './http/fetcher';\nimport Resource from './resource';\nimport { State, StateFactory } from './state';\nimport {\n  halStateFactory,\n  binaryStateFactory,\n  jsonApiStateFactory,\n  sirenStateFactory,\n  textStateFactory,\n  cjStateFactory,\n  htmlStateFactory\n} from './state';\nimport { parseContentType } from './http/util';\nimport { resolve } from './util/uri';\nimport { Link, LinkVariables } from './link';\nimport { FollowPromiseOne } from './follow-promise';\nimport { StateCache, ForeverCache } from './cache';\nimport cacheExpireMiddleware from './middlewares/cache';\nimport acceptMiddleware from './middlewares/accept-header';\nimport warningMiddleware from './middlewares/warning';\n\nexport default class Client {\n\n  /**\n   * All relative urls will by default use the bookmarkUri to\n   * expand. It should usually be the starting point of your\n   * API\n   */\n  bookmarkUri: string;\n\n  /**\n   * Supported content types\n   *\n   * Each content-type has a 'factory' that turns a HTTP response\n   * into a State object.\n   *\n   * The last value in the array is the 'q=' value, used in Accept\n   * headers. Higher means higher priority.\n   */\n  contentTypeMap: {\n    [mimeType: string]: [StateFactory<any>, string];\n  } = {\n      'application/prs.hal-forms+json': [halStateFactory, '1.0'],\n      'application/hal+json': [halStateFactory, '0.9'],\n      'application/vnd.api+json': [jsonApiStateFactory, '0.8'],\n      'application/vnd.siren+json': [sirenStateFactory, '0.8'],\n      'application/vnd.collection+json': [cjStateFactory, '0.8'],\n      'application/json': [halStateFactory, '0.7'],\n      'text/html': [htmlStateFactory, '0.6'],\n    };\n\n  /**\n   * The cache for 'State' objects\n   */\n  cache: StateCache;\n\n  /**\n   * The cache for 'Resource' objects. Each unique uri should\n   * only ever get 1 associated resource.\n   */\n  resources: Map<string, Resource>;\n\n  /**\n   * Fetcher is a utility object that handles fetch() requests\n   * and middlewares.\n   */\n  fetcher: Fetcher;\n\n  constructor(bookmarkUri: string) {\n    this.bookmarkUri = bookmarkUri;\n    this.fetcher = new Fetcher();\n    this.fetcher.use(cacheExpireMiddleware(this));\n    this.fetcher.use(acceptMiddleware(this));\n    this.fetcher.use(warningMiddleware());\n    this.cache = new ForeverCache();\n    this.resources = new Map();\n  }\n\n  /**\n   * Follows a relationship, based on its reltype. For example, this might be\n   * 'alternate', 'item', 'edit' or a custom url-based one.\n   *\n   * This function can also follow templated uris. You can specify uri\n   * variables in the optional variables argument.\n   */\n  follow<TFollowedResource = any>(rel: string, variables?: LinkVariables): FollowPromiseOne<TFollowedResource> {\n\n    return this.go().follow(rel, variables);\n\n  }\n\n  /**\n   * Returns a resource by its uri.\n   *\n   * This function doesn't do any HTTP requests. The uri is optional. If it's\n   * not specified, it will return the bookmark resource.\n   *\n   * If a relative uri is passed, it will be resolved based on the bookmark\n   * uri.\n   *\n   * @example\n   * const res = ketting.go('https://example.org/);\n   * @example\n   * const res = ketting.go<Author>('/users/1');\n   * @example\n   * const res = ketting.go(); // bookmark\n   */\n  go<TResource = any>(uri?: string|Link): Resource<TResource> {\n\n    let absoluteUri;\n    if (uri === undefined) {\n      absoluteUri = this.bookmarkUri;\n    } else if (typeof uri === 'string') {\n      absoluteUri = resolve(this.bookmarkUri, uri);\n    } else {\n      absoluteUri = resolve(uri);\n    }\n    if (!this.resources.has(absoluteUri)) {\n      const resource = new Resource(this, absoluteUri);\n      this.resources.set(absoluteUri, resource);\n      return resource;\n    }\n    return this.resources.get(absoluteUri)!;\n\n  }\n\n  /**\n   * Adds a fetch middleware, which will be executed for\n   * each fetch() call.\n   *\n   * If 'origin' is specified, fetch middlewares can be executed\n   * only if the host/origin matches.\n   */\n  use(middleware: FetchMiddleware, origin: string = '*') {\n\n    this.fetcher.use(middleware, origin);\n\n  }\n\n  /**\n   * Clears the entire state cache\n   */\n  clearCache() {\n\n    this.cache.clear();\n    this.cacheDependencies = new Map();\n\n  }\n\n  /**\n   * Caches a State object\n   *\n   * This function will also emit 'update' events to resources, and store all\n   * embedded states.\n   */\n  cacheState(state: State) {\n\n    // Flatten the list of state objects.\n    const newStates = flattenState(state);\n\n    // Register all cache dependencies.\n    for(const nState of newStates) {\n      for(const invByLink of nState.links.getMany('inv-by')) {\n        this.addCacheDependency(resolve(invByLink), nState.uri);\n      }\n    }\n\n    // Store all new caches\n    for(const nState of newStates) {\n      this.cache.store(nState);\n    }\n\n    // Emit 'update' events\n    for(const nState of newStates) {\n      const resource = this.resources.get(nState.uri);\n      if (resource) {\n        // We have a resource for this object, notify it as well.\n        resource.emit('update', nState);\n      }\n    }\n\n  }\n\n  /**\n   * cacheDependencies contains all cache relationships between\n   * resources.\n   *\n   * This lets a user (for example) let a resource automatically\n   * expire, if another one expires.\n   *\n   * A server can populate this list using the `inv-by' link.\n   *\n   * @deprecated This property will go private in a future release.\n   */\n  public cacheDependencies: Map<string, Set<string>> = new Map();\n\n  /**\n   * Adds a cache dependency between two resources.\n   *\n   * If the 'target' resource ever expires, it will cause 'dependentUri' to\n   * also expire.\n   *\n   * Both argument MUST be absolute urls.\n   */\n  addCacheDependency(targetUri: string, dependentUri: string): void {\n\n    if (this.cacheDependencies.has(targetUri)) {\n      this.cacheDependencies.get(targetUri)!.add(dependentUri);\n    } else {\n      this.cacheDependencies.set(targetUri, new Set([dependentUri]));\n    }\n\n  }\n\n  /**\n   * Helper function for clearing the cache for a resource.\n   *\n   * This function will also emit the 'stale' event for resources that have\n   * subscribers, and handle any dependent resource caches.\n   *\n   * If any resources are specified in deletedUris, those will not\n   * receive 'stale' events, but 'delete' events instead.\n   */\n  clearResourceCache(staleUris: string[], deletedUris: string[]) {\n\n    let stale = new Set<string>();\n    const deleted = new Set<string>();\n    for(const uri of staleUris) {\n      stale.add(resolve(this.bookmarkUri, uri));\n    }\n    for(const uri of deletedUris) {\n      stale.add(resolve(this.bookmarkUri, uri));\n      deleted.add(resolve(this.bookmarkUri, uri));\n    }\n\n    stale = expandCacheDependencies(\n      new Set([...stale, ...deleted]),\n      this.cacheDependencies\n    );\n\n    for(const uri of stale) {\n      this.cache.delete(uri);\n\n      const resource = this.resources.get(uri);\n      if (resource) {\n        if (deleted.has(uri)) {\n          resource.emit('delete');\n        } else {\n          resource.emit('stale');\n        }\n\n      }\n\n    }\n\n  }\n\n  /**\n   * Transforms a fetch Response to a State object.\n   */\n  async getStateForResponse(uri: string, response: Response): Promise<State> {\n\n    const contentType = parseContentType(response.headers.get('Content-Type')!);\n\n    if (!contentType || response.status === 204) {\n      return binaryStateFactory(this, uri, response);\n    }\n\n    if (contentType in this.contentTypeMap) {\n      return this.contentTypeMap[contentType][0](this, uri, response);\n    } else if (contentType.startsWith('text/')) {\n      // Default to TextState for any format starting with text/\n      return textStateFactory(this, uri, response);\n    } else if (contentType.match(/^application\\/[A-Za-z-.]+\\+json/)) {\n      // Default to HalState for any format containing a pattern like application/*+json\n      return halStateFactory(this, uri, response);\n    } else {\n      return binaryStateFactory(this, uri, response);\n    }\n\n  }\n\n\n}\n\n\n\n/**\n * Find all dependencies for a given resource.\n *\n * For example, if\n *   * if resourceA depends on resourceB\n *   * and resourceB depends on resourceC\n *\n * Then if 'resourceC' expires, so should 'resourceA' and 'resourceB'.\n *\n * This function helps us find these dependencies recursively and guarding\n * against recursive loops.\n */\nfunction expandCacheDependencies(uris: Set<string>, dependencies: Map<string, Set<string>>, output?: Set<string>): Set<string> {\n\n  if (!output) output = new Set();\n\n  for(const uri of uris) {\n\n    if (!output.has(uri)) {\n      output.add(uri);\n      if (dependencies.has(uri)) {\n        expandCacheDependencies(dependencies.get(uri)!, dependencies, output);\n      }\n    }\n\n  }\n\n  return output;\n\n}\n\n/**\n * Take a State object, find all it's embedded resources and return a flat\n * array of all resources at any depth.\n */\nfunction flattenState(state: State, result: Set<State> = new Set<State>()): Set<State> {\n\n  result.add(state);\n  for(const embedded of state.getEmbedded()) {\n    flattenState(embedded, result);\n  }\n  return result;\n\n}\n","import Resource from './resource';\nimport { LinkVariables } from './link';\n\n/**\n * Base interface for both FollowOne and FollowAll\n */\nabstract class FollowPromise<T> implements PromiseLike<T> {\n\n  protected prefetchEnabled: boolean;\n  protected preferTranscludeEnabled: boolean;\n  protected useHeadEnabled: boolean;\n\n  constructor() {\n    this.prefetchEnabled = false;\n    this.preferTranscludeEnabled = false;\n    this.useHeadEnabled = false;\n  }\n\n  preFetch(): this {\n    this.prefetchEnabled = true;\n    return this;\n  }\n\n  preferTransclude(): this {\n    this.preferTranscludeEnabled = true;\n    return this;\n  }\n\n  /**\n   * Use a HTTP HEAD request to fetch the links.\n   *\n   * This is useful when interacting with servers that embed links in Link\n   * Headers.\n   */\n  useHead(): this {\n\n    this.useHeadEnabled = true;\n    return this;\n\n  }\n\n  abstract then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;\n  abstract catch<TResult1 = T, TResult2 = never>(onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;\n\n}\n\n/**\n * The FollowPromise class is what's being returned from follow() functions.\n *\n * It's 'PromiseLike', which means you can treat it like a Promise, and it\n * can be awaited. When used as a Promise, it resolves to the Resource object\n * that was followed.\n *\n * In addition to being a Promise<Resource> stand-in, it also exposes other\n * functions, namely:\n *\n * * `follow()` to allow a user to chain several follow() functions to do\n *   several 'hops' all at once.\n * * `followAll()`, allowing a user to call `followAll()` at the end of a\n *   chain.\n */\nexport class FollowPromiseOne<T = any> extends FollowPromise<Resource<T>> {\n\n  private resource: Resource | Promise<Resource>;\n  private rel: string;\n  private variables?: LinkVariables;\n\n  constructor(resource: Resource | Promise<Resource>, rel: string, variables?: LinkVariables) {\n\n    super();\n    this.resource = resource;\n    this.rel = rel;\n    this.variables = variables;\n\n  }\n\n  /**\n   * This 'then' function behaves like a Promise then() function.\n   *\n   * This method signature is pretty crazy, but trust that it's pretty much\n   * like any then() method on a promise.\n   */\n  then<TResult1 = Resource<T>, TResult2 = never>(\n    onfulfilled?: ((value: Resource<T>) => TResult1 | PromiseLike<TResult1>) | null | undefined,\n    onrejected?: ((reason: Error) => TResult2 | PromiseLike<TResult2>) | null | undefined\n  ): Promise<TResult1 | TResult2> {\n\n    return this.fetchLinkedResource().then(onfulfilled, onrejected);\n\n  }\n\n  /**\n   * This 'catch' function behaves like a Promise catch() function.\n   */\n  catch<TResult1 = any, TResult2 = never>(onrejected?: ((reason: Error) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2> {\n\n    return this.fetchLinkedResource().then(undefined, onrejected);\n\n  }\n\n  /**\n   * Implementation of a Promise.finally function\n   */\n  finally<TResult1 = any>(onfinally: () => TResult1 | PromiseLike<TResult1>): Promise<TResult1> {\n\n    return this.then(\n      () => onfinally(),\n      () => onfinally()\n    );\n\n  }\n\n  /**\n   * Follow another link immediately after following this link.\n   *\n   * This allows you to follow several hops of links in one go.\n   *\n   * For example: resource.follow('foo').follow('bar');\n   */\n  follow<TNested = any>(rel: string, variables?: LinkVariables): FollowPromiseOne<TNested> {\n\n    return new FollowPromiseOne(this.fetchLinkedResource(), rel, variables);\n\n  }\n\n  /**\n   * Follows a set of links immediately after following this link.\n   *\n   * For example: resource.follow('foo').followAll('item');\n   */\n  followAll<TNested = any>(rel: string): FollowPromiseMany<TNested> {\n\n    return new FollowPromiseMany(this.fetchLinkedResource(), rel);\n\n  }\n\n  /**\n   * This function does the actual fetching of the linked\n   * resource.\n   */\n  private async fetchLinkedResource(): Promise<Resource<T>> {\n\n    const resource = await this.resource;\n\n    const headers: { [name: string]: string } = {};\n    if (!this.useHeadEnabled && this.preferTranscludeEnabled) {\n      headers.Prefer = 'transclude=' + this.rel;\n    }\n\n    let state;\n    if (this.useHeadEnabled) {\n      state = await resource.head({headers});\n    } else {\n      state = await resource.get({\n        headers\n      });\n    }\n\n    const newResource = state.follow(this.rel, this.variables);\n\n    if (this.prefetchEnabled) {\n      newResource.get().catch( err => {\n        // eslint-disable-next-line no-console\n        console.warn('Error while prefetching linked resource', err);\n      });\n    }\n\n    return newResource;\n\n  }\n\n}\n\n/**\n */\nexport class FollowPromiseMany<T = any> extends FollowPromise<Resource<T>[]> {\n\n  private resource: Resource | Promise<Resource>;\n  private rel: string;\n\n  constructor(resource: Resource | Promise<Resource>, rel: string) {\n\n    super();\n    this.resource = resource;\n    this.rel = rel;\n\n  }\n\n  /**\n   * This 'then' function behaves like a Promise then() function.\n   */\n  then<TResult1 = Resource<T>[], TResult2 = never>(\n    onfulfilled?: ((value: Resource<T>[]) => TResult1 | PromiseLike<TResult1>) | null | undefined,\n    onrejected?: ((reason: Error) => TResult2 | PromiseLike<TResult2>) | null | undefined\n  ): Promise<TResult1 | TResult2> {\n\n    return this.fetchLinkedResources().then(onfulfilled, onrejected);\n\n  }\n\n  /**\n   * This 'catch' function behaves like a Promise catch() function.\n   */\n  catch<TResult1 = any, TResult2 = never>(onrejected?: ((reason: Error) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2> {\n\n    return this.fetchLinkedResources().then(undefined, onrejected);\n\n  }\n\n  /**\n   * Implementation of a Promise.finally function\n   */\n  finally<TResult1 = any>(onfinally: () => TResult1 | PromiseLike<TResult1>): Promise<TResult1> {\n\n    return this.then(\n      () => onfinally(),\n      () => onfinally()\n    );\n\n  }\n\n  /**\n   * This function does the actual fetching, to obtained the url\n   * of the linked resource. It returns the Resource object.\n   */\n  private async fetchLinkedResources(): Promise<Resource<T>[]> {\n\n    const resource = await this.resource;\n    const headers: { [name: string]: string } = {};\n    if (!this.useHeadEnabled && this.preferTranscludeEnabled) {\n      headers.Prefer = 'transclude=' + this.rel;\n    }\n\n    let state;\n    if (this.useHeadEnabled) {\n      state = await resource.head({headers});\n    } else {\n      state = await resource.get({\n        headers\n      });\n    }\n\n    const result: Resource<T>[] = state.followAll(this.rel);\n\n    if (this.prefetchEnabled) {\n      result.map( resource => {\n        resource.get().catch( err => {\n          // eslint-disable-next-line no-console\n          console.warn('Error while prefetching linked resource', err);\n        });\n      });\n    }\n\n    return result;\n\n  }\n\n}\n","import { FetchMiddleware } from './fetcher';\nimport * as base64 from '../util/base64';\n\nexport default (userName: string, password: string): FetchMiddleware => {\n\n  const basicAuthHeader = 'Basic ' + base64.encode(userName + ':' + password);\n\n  return (request, next) => {\n\n    request.headers.set('Authorization', basicAuthHeader);\n    return next(request);\n\n  };\n\n};\n","import { FetchMiddleware } from './fetcher';\n\nexport default (token: string): FetchMiddleware => {\n\n  const bearerAuthHeader = 'Bearer ' + token;\n\n  return (request, next) => {\n\n    request.headers.set('Authorization', bearerAuthHeader);\n    return next(request);\n\n  };\n\n};\n","/**\n * HttpError extends the Error object, and is thrown wheenever servers emit\n * HTTP errors.\n *\n * It has a response property, allowing users to find out more about the\n * nature of the error.\n */\nexport class HttpError extends Error {\n\n  response: Response;\n  status: number;\n\n  constructor(response: Response) {\n    super('HTTP error ' + response.status);\n    this.response = response;\n    this.status = response.status;\n  }\n\n}\n\n/**\n * Problem extends the HttpError object. If a server emits a HTTP error, and\n * the response body's content-type is application/problem+json.\n *\n * application/problem+json is defined in RFC7807 and provides a standardized\n * way to describe error conditions by a HTTP server.\n */\nexport class Problem extends HttpError {\n\n  body: {\n    type: string;\n    title?: string;\n    status: number;\n    detail?: string;\n    instance?: string;\n    [x: string]: any;\n  };\n\n  constructor(response: Response, problemBody: Record<string, any>) {\n    super(response);\n\n    this.body = {\n      type: problemBody.type ?? 'about:blank',\n      status: problemBody.status ?? this.status,\n      ...problemBody\n    };\n\n    if (this.body.title) {\n      this.message = 'HTTP Error ' + this.status + ': ' + this.body.title;\n    }\n  }\n\n}\n\n/**\n * This function creates problems, not unlike the the author of this file.\n *\n * It takes a Fetch Response object, and returns a HttpError. If the HTTP\n * response has a type of application/problem+json it will return a Problem\n * object.\n *\n * Because parsing the response might be asynchronous, the function returns\n * a Promise resolving in either object.\n */\nexport default async function problemFactory(response: Response): Promise<HttpError | Problem> {\n\n  const contentType = response.headers.get('Content-Type');\n  if (contentType?.match(/^application\\/problem\\+json/i)) {\n    const problemBody = await response.json();\n    return new Problem(response, problemBody);\n  } else {\n    return new HttpError(response);\n  }\n\n}\n\n","import problemFactory from './error';\nimport './fetch-polyfill';\n\nexport type FetchMiddleware =\n  (request: Request, next: (request: Request) => Promise<Response>) => Promise<Response>;\n\n/**\n * The fetcher object is responsible for calling fetch()\n *\n * This is wrapped in an object because we want to support\n * 'fetch middlewares'. These middlewares are similar to server-side\n * middlewares and can intercept requests and alter requests/responses.\n */\nexport class Fetcher {\n\n  middlewares: [RegExp, FetchMiddleware][] = [];\n\n  advertiseKetting: boolean = true;\n\n  /**\n   * A wrapper for MDN fetch()\n   *\n   * This wrapper supports 'fetch middlewares'. It will call them\n   * in sequence.\n   */\n  fetch(resource: string|Request, init?: RequestInit): Promise<Response> {\n\n    const request = new Request(resource, init);\n\n    const origin = new URL(request.url).origin;\n    const mws = this.getMiddlewaresByOrigin(origin);\n    mws.push((innerRequest: Request) => {\n\n      if (!innerRequest.headers.has('User-Agent') && this.advertiseKetting) {\n        // eslint-disable-next-line @typescript-eslint/no-var-requires\n        innerRequest.headers.set('User-Agent', 'Ketting/' + require('../../package.json').version);\n      }\n\n      return fetch(innerRequest);\n    });\n\n    return invokeMiddlewares(mws, request);\n\n  }\n\n  /**\n   * Returns the list of middlewares that are applicable to\n   * a specific origin\n   */\n  getMiddlewaresByOrigin(origin: string): FetchMiddleware[] {\n\n    return this.middlewares.filter( ([regex]) => {\n      return regex.test(origin);\n\n    }).map( ([, middleware]) => {\n      return middleware;\n    });\n\n  }\n\n  /**\n   * Add a middleware\n   */\n  use(mw: FetchMiddleware, origin: string = '*'): void {\n\n    const matchSplit = origin.split('*');\n    const matchRegex = matchSplit.map(\n      part =>\n        part.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')\n    ).join('(.*)');\n\n    const regex = new RegExp('^' + matchRegex + '$');\n    this.middlewares.push([regex, mw]);\n\n  }\n\n  /**\n   * Does a HTTP request and throws an exception if the server emitted\n   * a HTTP error.\n   *\n   * @see https://developer.mozilla.org/en-US/docs/Web/API/Request/Request\n   */\n  async fetchOrThrow(resource: string|Request, init?: RequestInit): Promise<Response> {\n\n    const response = await this.fetch(resource, init);\n\n    if (response.ok) {\n      return response;\n    } else {\n      throw await problemFactory(response);\n    }\n\n  }\n\n}\nexport default Fetcher;\n\nfunction invokeMiddlewares(mws: FetchMiddleware[], request: Request): Promise<Response> {\n\n  return mws[0](\n    request,\n    (nextRequest: Request) => {\n      return invokeMiddlewares(mws.slice(1), nextRequest);\n    }\n  );\n\n}\n","import { FetchMiddleware } from './fetcher';\nimport { OAuth2Options, OAuth2, OAuth2Token } from 'fetch-mw-oauth2';\n\nexport default (oauth2Options: OAuth2Options & Partial<OAuth2Token>, token?: OAuth2Token): FetchMiddleware => {\n\n  const oauth2 = new OAuth2(oauth2Options, token);\n  return oauth2.fetchMw.bind(oauth2);\n\n};\n","import * as LinkHeader from 'http-link-header';\nimport { Links } from '../link';\n\n/**\n * Takes a Content-Type header, and only returns the mime-type part.\n */\nexport function parseContentType(contentType: string | null): string | null {\n\n  if (!contentType) {\n    return null;\n  }\n  if (contentType.includes(';')) {\n    contentType = contentType.split(';')[0];\n  }\n  return contentType.trim();\n\n}\n\n\nexport function parseLink(context: string, header: string|null): Links {\n\n  const result = new Links(context);\n  if (!header) {\n    return result;\n  }\n\n  for (const httpLink of LinkHeader.parse(header).refs) {\n    // Looping through individual links\n    for (const rel of httpLink.rel.split(' ')) {\n      // Looping through space separated rel values.\n      const link = {\n        rel: rel,\n        href: httpLink.uri,\n        context,\n        title: httpLink.title,\n        hreflang: httpLink.hreflang,\n        type: httpLink.type,\n      };\n      result.add(link);\n    }\n  }\n  return result;\n}\n\nconst safeMethods = ['GET', 'HEAD', 'OPTIONS', 'PRI', 'PROPFIND', 'REPORT', 'SEARCH', 'TRACE'];\n\nexport function isSafeMethod(method: string): boolean {\n  return safeMethods.includes(method);\n}\n\n/**\n * Older HTTP versions calls these 'entity headers'.\n *\n * Never HTTP/1.1 specs calls some of these 'representation headers'.\n *\n * What they have in common is that these headers can exist on request and\n * response and say something *about* the content.\n */\nexport const entityHeaderNames = [\n  'Content-Type',\n  'Content-Language',\n  'Content-Location',\n  'Deprecation',\n  'ETag',\n  'Expires',\n  'Last-Modified',\n  'Sunset',\n  'Title',\n  'Warning',\n];\n","import { LinkHints } from 'hal-types';\nimport { resolve } from './util/uri';\n\nexport type Link = {\n  /**\n   * Target URI\n   */\n  href: string;\n\n  /**\n   * Context URI.\n   *\n   * Used to resolve relative URIs\n   */\n  context: string;\n\n  /**\n   * Relation type\n   */\n  rel: string;\n\n  /**\n   * Link title\n   */\n  title?: string;\n\n  /**\n   * Content type hint of the target resource\n   */\n  type?: string;\n\n  /**\n   * Anchor.\n   *\n   * This describes where the link is linked from, from for example\n   * a fragment in the current document\n   */\n  anchor?: string;\n\n  /**\n   * Language of the target resource\n   */\n  hreflang?: string;\n\n  /**\n   * HTML5 media attribute\n   */\n  media?: string;\n\n  /**\n   * If templated is set to true, the href is a templated URI.\n   */\n  templated?: boolean;\n\n  /**\n   * Link hints, as defined in draft-nottingham-link-hint\n   */\n  hints?: LinkHints;\n\n}\n\ntype NewLink = Omit<Link, 'context'>;\n\n\n/**\n * Links container, providing an easy way to manage a set of links.\n */\nexport class Links {\n\n  private store: Map<string, Link[]>;\n\n  constructor(public defaultContext: string, links?: Link[] | Links) {\n\n    this.store = new Map();\n\n    if (links) {\n      if (links instanceof Links) {\n        this.add(...links.getAll());\n      } else {\n        for (const link of links) {\n          this.add(link);\n        }\n      }\n    }\n\n  }\n\n  /**\n   * Adds a link to the list\n   */\n  add(...links: (Link | NewLink)[]): void\n  add(rel: string, href: string): void\n  add(...args: any[]): void {\n\n    let links: Link[];\n\n    if (typeof args[0] === 'string') {\n      links = [{\n        rel: args[0],\n        href: args[1],\n        context: this.defaultContext,\n      }];\n    } else {\n      links = args.map( link => { return { context: this.defaultContext, ...link };} );\n    }\n\n    for(const link of links) {\n      if (this.store.has(link.rel)) {\n        this.store.get(link.rel)!.push(link);\n      } else {\n        this.store.set(link.rel, [link]);\n      }\n    }\n\n  }\n\n  /**\n   * Set a link\n   *\n   * If a link with the provided 'rel' already existed, it will be overwritten.\n   */\n  set(link: Link | NewLink): void\n  set(rel: string, href: string): void\n  set(arg1: any, arg2?: any): void {\n\n    let link: Link;\n    if (typeof arg1 === 'string') {\n      link = {\n        rel: arg1,\n        href: arg2,\n        context: this.defaultContext,\n      };\n    } else {\n      link = {\n        context: this.defaultContext,\n        ...arg1,\n      };\n    }\n    this.store.set(link.rel, [link]);\n\n  }\n\n  /**\n   * Return a single link by its 'rel'.\n   *\n   * If the link does not exist, undefined is returned.\n   */\n  get(rel: string): Link|undefined {\n\n    const links = this.store.get(rel);\n    if (!links || links.length < 0) {\n      return undefined;\n    }\n    return links[0];\n\n  }\n\n  /**\n    * Delete all links with the given 'rel'.\n   *\n   * If the second argument is provided, only links that match the href will\n   * be removed.\n   */\n  delete(rel: string, href?: string): void {\n\n    if (href===undefined) {\n      this.store.delete(rel);\n      return;\n    }\n\n    const uris = this.store.get(rel);\n    if (!uris) return;\n\n    this.store.delete(rel);\n    const absHref = resolve(this.defaultContext, href);\n    this.store.set(rel,\n      uris.filter(uri => resolve(uri) !== absHref)\n    );\n  }\n\n  /**\n   * Return all links that have a given rel.\n   *\n   * If no links with the rel were found, an empty array is returned.\n   */\n  getMany(rel: string): Link[] {\n\n    return this.store.get(rel) || [];\n\n  }\n\n  /**\n   * Return all links.\n   */\n  getAll(): Link[] {\n    const result = [];\n    for(const links of this.store.values()) {\n      result.push(...links);\n    }\n    return result;\n  }\n\n  /**\n   * Returns true if at least 1 link with the given rel exists.\n   */\n  has(rel: string): boolean {\n\n    return this.store.has(rel);\n\n  }\n\n}\n\n/**\n * The LinkNotFound error gets thrown whenever something tries to follow a\n * link by its rel, that doesn't exist\n */\nexport class LinkNotFound extends Error {}\n\n/**\n * A key->value map of variables to place in a templated link\n */\nexport type LinkVariables = {\n  [key: string]: string | number;\n};\n","import { FetchMiddleware } from '../http/fetcher';\nimport Client from '../client';\n\n/**\n * This middleware injects a default Accept header.\n *\n * The list of content-types is generated from the Client's\n * 'contentTypeMap'.\n */\nexport default function(client: Client): FetchMiddleware {\n\n  return async(request, next) => {\n\n    if (!request.headers.has('Accept')) {\n      const acceptHeader = Object.entries(client.contentTypeMap).map(\n        ([contentType, [, q]]) => contentType + ';q=' + q\n      ).join(', ');\n      request.headers.set('Accept', acceptHeader);\n    }\n    return next(request);\n\n  };\n\n}\n","import { FetchMiddleware } from '../http/fetcher';\nimport { isSafeMethod } from '../http/util';\nimport * as LinkHeader from 'http-link-header';\nimport { resolve } from '../util/uri';\nimport Client from '../client';\n\n/**\n * This middleware manages the cache based on information in requests\n * and responses.\n *\n * It expires items from the cache and updates the cache if `Content-Location`\n * appeared in the response.\n *\n * It's also responsible for emitting 'stale' events.\n */\nexport default function(client: Client): FetchMiddleware {\n\n  return async(request, next) => {\n\n    /**\n     * Prevent a 'stale' event from being emitted, but only for the main\n     * uri\n     */\n    let noStaleEvent = false;\n\n    if (request.headers.has('X-KETTING-NO-STALE')) {\n      noStaleEvent = true;\n      request.headers.delete('X-KETTING-NO-STALE');\n    }\n\n    const response = await next(request);\n\n    if (isSafeMethod(request.method)) {\n      return response;\n    }\n\n    if (!response.ok) {\n      // There was an error, no cache changes\n      return response;\n    }\n\n    // We just processed an unsafe method, lets notify all subsystems.\n    const stale = [];\n    const deleted = [];\n\n    if (request.method === 'DELETE') {\n      deleted.push(request.url);\n    } else if (!noStaleEvent) {\n      stale.push(request.url);\n    }\n\n    // If the response had a Link: rel=invalidate header, we want to\n    // expire those too.\n    if (response.headers.has('Link')) {\n      for (const httpLink of LinkHeader.parse(response.headers.get('Link')!).rel('invalidates')) {\n        const uri = resolve(request.url, httpLink.uri);\n        stale.push(uri);\n      }\n    }\n\n    // Location headers should also expire\n    if (response.headers.has('Location')) {\n      stale.push(\n        resolve(request.url, response.headers.get('Location')!)\n      );\n    }\n\n    client.clearResourceCache(stale, deleted);\n\n    // If the response had a 'Content-Location' header, it means that the\n    // response body is the _new_ state for the url in the content-location\n    // header, so we store it!\n    if (response.headers.has('Content-Location')) {\n      const cl = resolve(request.url, response.headers.get('Content-Location')!);\n      const clState = await client.getStateForResponse(\n        cl,\n        response\n      );\n      client.cacheState(clState);\n    }\n\n    return response;\n\n  };\n\n}\n","import { FetchMiddleware } from '../http/fetcher';\nimport * as LinkHeader from 'http-link-header';\nimport { resolve } from '../util/uri';\n\n/**\n * This middleware will emit warnings based on HTTP responses.\n *\n * Currently it just inspects the 'Deprecation' HTTP header from\n *   draft-dalal-deprecation-header\n */\nexport default function(): FetchMiddleware {\n\n  return async(request, next) => {\n\n    const response = await next(request);\n    const deprecation = response.headers.get('Deprecation');\n    if (deprecation) {\n      const sunset = response.headers.get('Sunset');\n      let msg = `[Ketting] The resource ${request.url} is deprecated.`;\n      if (sunset) {\n        msg += ' It will no longer respond ' + sunset;\n      }\n      if (response.headers.has('Link')) {\n        for (const httpLink of LinkHeader.parse(response.headers.get('Link')!).rel('deprecation')) {\n          const uri = resolve(request.url, httpLink.uri);\n          msg += `See ${uri} for more information.`;\n        }\n      }\n\n      /* eslint-disable-next-line no-console */\n      console.warn(msg);\n\n    }\n    return response;\n\n  };\n\n}\n","import Client from './client';\nimport { State, headStateFactory, HeadState, isState } from './state';\nimport { resolve } from './util/uri';\nimport { FollowPromiseOne, FollowPromiseMany } from './follow-promise';\nimport { Link, LinkNotFound, LinkVariables } from './link';\nimport { EventEmitter } from 'events';\nimport { GetRequestOptions, PostRequestOptions, PatchRequestOptions, PutRequestOptions, HeadRequestOptions } from './types';\nimport { needsJsonStringify } from './util/fetch-body-helper';\n\n/**\n * A 'resource' represents an endpoint on a server.\n *\n * A resource has a uri, methods that correspond to HTTP methods,\n * and events to subscribe to state changes.\n */\nexport class Resource<T = any> extends EventEmitter {\n\n  /**\n   * URI of the current resource\n   */\n  uri: string;\n\n  /**\n   * Reference to the Client that created the resource\n   */\n  client: Client;\n\n  /**\n   * This object tracks all in-flight requests.\n   *\n   * When 2 identical requests are made in quick succession, this object is\n   * used to de-duplicate the requests.\n   */\n  private readonly activeRefresh: Map<string, Promise<State<T>>> = new Map<string, Promise<State<T>>>();\n\n  /**\n   * Create the resource.\n   *\n   * This is usually done by the Client.\n   */\n  constructor(client: Client, uri: string) {\n    super();\n    this.client = client;\n    this.uri = uri;\n    this.setMaxListeners(500);\n\n  }\n\n  /**\n   * Gets the current state of the resource.\n   *\n   * This function will return a State object.\n   */\n  get(getOptions?: GetRequestOptions): Promise<State<T>> {\n\n    const state = this.getCache();\n    if (state) {\n      return Promise.resolve(state);\n    }\n\n    const params = optionsToRequestInit('GET', getOptions);\n    const uri = this.uri;\n\n    const hash = requestHash(this.uri, getOptions);\n\n    if (!this.activeRefresh.has(hash)) {\n      this.activeRefresh.set(hash, (async (): Promise<State<T>> => {\n        try {\n          const response = await this.fetchOrThrow(params);\n          const state = await this.client.getStateForResponse(uri, response);\n          this.updateCache(state);\n          return state;\n        } finally {\n          this.activeRefresh.delete(hash);\n        }\n      })());\n    }\n\n    return this.activeRefresh.get(hash)!;\n  }\n\n  /**\n   * Does a HEAD request and returns a HeadState object.\n   *\n   * If there was a valid existing cache for a GET request, it will\n   * still return that.\n   */\n  async head(headOptions?: HeadRequestOptions): Promise<HeadState> {\n\n    let state: State|HeadState|null = this.client.cache.get(this.uri);\n    if (state) {\n      return state;\n    }\n\n    const response = await this.fetchOrThrow(\n      optionsToRequestInit('HEAD', headOptions)\n    );\n\n    state = await headStateFactory(this.client, this.uri, response);\n    return state;\n\n  }\n\n\n  /**\n   * Gets the current state of the resource, skipping\n   * the cache.\n   *\n   * This function will return a State object.\n   */\n  refresh(getOptions?: GetRequestOptions): Promise<State<T>> {\n\n    const params = optionsToRequestInit('GET', getOptions);\n    params.cache = 'no-cache';\n    const uri = this.uri;\n\n    const hash = requestHash(this.uri, getOptions);\n\n    if (!this.activeRefresh.has(hash)) {\n      this.activeRefresh.set(hash, (async (): Promise<State<T>> => {\n        try {\n          const response = await this.fetchOrThrow(params);\n          const state = await this.client.getStateForResponse(uri, response);\n          this.updateCache(state);\n          return state;\n        } finally {\n          this.activeRefresh.delete(hash);\n        }\n      })());\n    }\n\n    return this.activeRefresh.get(hash)!;\n  }\n\n  /**\n   * Updates the server state with a PUT request\n   */\n  async put(options: PutRequestOptions<T> | State): Promise<void> {\n\n    const requestInit = optionsToRequestInit('PUT', options);\n\n    /**\n     * If we got a 'State' object passed, it means we don't need to emit a\n     * stale event, as the passed object is the new\n     * state.\n     *\n     * We're gonna track that with a custom header that will be removed\n     * later in the fetch pipeline.\n     */\n    if (isState(options)) {\n      requestInit.headers.set('X-KETTING-NO-STALE', '1');\n    }\n\n    await this.fetchOrThrow(requestInit);\n\n    if (isState(options)) {\n      this.updateCache(options);\n\n    }\n\n  }\n\n  /**\n   * Deletes the resource\n   */\n  async delete(): Promise<void> {\n\n    await this.fetchOrThrow(\n      { method: 'DELETE' }\n    );\n\n  }\n\n  /**\n   * Sends a POST request to the resource.\n   *\n   * See the documentation for PostRequestOptions for more details.\n   * This function is used for RPC-like endpoints and form submissions.\n   *\n   * This function will return the response as a State object.\n   */\n  async post(options: PostRequestOptions): Promise<State> {\n\n    const response = await this.fetchOrThrow(\n      optionsToRequestInit('POST', options)\n    );\n\n    return this.client.getStateForResponse(this.uri, response);\n\n  }\n\n  /**\n   * Sends a POST request, and follows to the next resource.\n   *\n   * If a server responds with a 201 Status code and a Location header,\n   * it will automatically return the newly created resource.\n   *\n   * If the server responded with a 204 or 205, this function will return\n   * `this`.\n   */\n  async postFollow(options: PostRequestOptions): Promise<Resource> {\n\n    const response = await this.fetchOrThrow(\n      optionsToRequestInit('POST', options)\n    );\n\n    switch (response.status) {\n      case 201:\n        if (response.headers.has('location')) {\n          return this.go(response.headers.get('location')!);\n        }\n        throw new Error('Could not follow after a 201 request, because the server did not reply with a Location header. If you sent a Location header, check if your service is returning \"Access-Control-Expose-Headers: Location\".');\n      case 204 :\n      case 205 :\n        return this;\n      default:\n        throw new Error('Did not receive a 201, 204 or 205 status code so we could not follow to the next resource');\n    }\n\n  }\n\n  /**\n   * Sends a PATCH request to the resource.\n   *\n   * This function defaults to a application/json content-type header.\n   *\n   * If the server responds with 200 Status code this will return a State object\n   */\n  async patch(options: PatchRequestOptions): Promise<undefined | State<T>> {\n\n    const response = await this.fetchOrThrow(\n      optionsToRequestInit('PATCH', options)\n    );\n\n    if (response.status === 200) {\n      return await this.client.getStateForResponse(this.uri, response);\n    }\n  }\n\n  /**\n   * Follows a relationship, based on its reltype. For example, this might be\n   * 'alternate', 'item', 'edit' or a custom url-based one.\n   *\n   * This function can also follow templated uris. You can specify uri\n   * variables in the optional variables argument.\n   */\n  follow<TFollowedResource = any>(rel: string, variables?: LinkVariables): FollowPromiseOne<TFollowedResource> {\n\n    return new FollowPromiseOne(this, rel, variables);\n\n  }\n\n  /**\n   * Follows a relationship based on its reltype. This function returns a\n   * Promise that resolves to an array of Resource objects.\n   *\n   * If no resources were found, the array will be empty.\n   */\n  followAll<TFollowedResource = any>(rel: string): FollowPromiseMany<TFollowedResource> {\n\n    return new FollowPromiseMany(this, rel);\n\n  }\n\n  /**\n   * Resolves a new resource based on a relative uri.\n   *\n   * Use this function to manually get a Resource object via a uri. The uri\n   * will be resolved based on the uri of the current resource.\n   *\n   * This function doesn't do any HTTP requests.\n   */\n  go<TGoResource = any>(uri: string|Link): Resource<TGoResource> {\n\n    if (typeof uri === 'string') {\n      return this.client.go(resolve(this.uri, uri));\n    } else {\n      return this.client.go(uri);\n    }\n\n  }\n\n  /**\n   * Does a HTTP request on the current resource URI\n   */\n  fetch(init?: RequestInit): Promise<Response> {\n\n    return this.client.fetcher.fetch(this.uri, init);\n\n  }\n\n  /**\n   * Does a HTTP request on the current resource URI.\n   *\n   * If the response was a 4XX or 5XX, this function will throw\n   * an exception.\n   */\n  fetchOrThrow(init?: RequestInit): Promise<Response> {\n\n    return this.client.fetcher.fetchOrThrow(this.uri, init);\n\n  }\n\n  /**\n   * Updates the state cache, and emits events.\n   *\n   * This will update the local state but *not* update the server\n   */\n  updateCache(state: State<T>) {\n\n    if (state.uri !== this.uri) {\n      throw new Error('When calling updateCache on a resource, the uri of the State object must match the uri of the Resource');\n    }\n    this.client.cacheState(state);\n\n  }\n\n  /**\n   * Clears the state cache for this resource.\n   */\n  clearCache(): void {\n\n    this.client.clearResourceCache([this.uri],[]);\n\n  }\n\n  /**\n   * Retrieves the current cached resource state, and return `null` if it's\n   * not available.\n   */\n  getCache(): State<T>|null {\n\n    return this.client.cache.get(this.uri);\n\n  }\n\n  /**\n   * Returns a Link object, by its REL.\n   *\n   * If the link does not exist, a LinkNotFound error will be thrown.\n   *\n   * @deprecated\n   */\n  async link(rel: string): Promise<Link> {\n\n    const state = await this.get();\n    const link = state.links.get(rel);\n\n    if (!link) {\n      throw new LinkNotFound(`Link with rel: ${rel} not found on ${this.uri}`);\n    }\n    return link;\n\n  }\n\n  /**\n   * Returns all links defined on this object.\n   *\n   * @deprecated\n   */\n  async links(rel?: string): Promise<Link[]> {\n\n    const state = await this.get();\n    if (!rel) {\n      return state.links.getAll();\n    } else {\n      return state.links.getMany(rel);\n    }\n\n  }\n\n  /**\n   *\n   * Returns true or false depending on if a link with the specified relation\n   * type exists.\n   *\n   * @deprecated\n   */\n  async hasLink(rel: string): Promise<boolean> {\n\n    const state = await this.get();\n    return state.links.has(rel);\n\n  }\n}\n\n// eslint doesn't like that we have a generic T but not using it.\n// eslint-disable-next-line\nexport declare interface Resource<T = any> {\n\n  /**\n   * Subscribe to the 'update' event.\n   *\n   * This event will get triggered whenever a new State is received\n   * from the server, either through a GET request or if it was\n   * transcluded.\n   *\n   * It will also trigger when calling 'PUT' with a full state object,\n   * and when updateCache() was used.\n   */\n  on(event: 'update', listener: (state: State) => void) : this;\n\n  /**\n   * Subscribe to the 'stale' event.\n   *\n   * This event will get triggered whenever an unsafe method was\n   * used, such as POST, PUT, PATCH, etc.\n   *\n   * When any of these methods are used, the local cache is stale.\n   */\n  on(event: 'stale',  listener: () => void) : this;\n\n  /**\n   * Subscribe to the 'delete' event.\n   *\n   * This event gets triggered when the `DELETE` http method is used.\n   */\n  on(event: 'delete', listener: () => void) : this;\n\n  /**\n   * Subscribe to the 'update' event and unsubscribe after it was\n   * emitted the first time.\n   */\n  once(event: 'update', listener: (state: State) => void) : this;\n\n  /**\n   * Subscribe to the 'stale' event and unsubscribe after it was\n   * emitted the first time.\n   */\n  once(event: 'stale',  listener: () => void) : this;\n\n  /**\n   * Subscribe to the 'delete' event and unsubscribe after it was\n   * emitted the first time.\n   */\n  once(event: 'delete', listener: () => void) : this;\n\n  /**\n   * Unsubscribe from the 'update' event\n   */\n  off(event: 'update', listener: (state: State) => void) : this;\n\n  /**\n   * Unsubscribe from the 'stale' event\n   */\n  off(event: 'stale',  listener: () => void) : this;\n\n  /**\n   * Unsubscribe from the 'delete' event\n   */\n  off(event: 'delete', listener: () => void) : this;\n\n  /**\n   * Emit an 'update' event.\n   */\n  emit(event: 'update', state: State) : boolean;\n\n  /**\n   * Emit a 'stale' event.\n   */\n  emit(event: 'stale') : boolean;\n\n  /**\n   * Emit a 'delete' event.\n   */\n  emit(event: 'delete') : boolean;\n\n}\n\nexport default Resource;\n\ntype StrictRequestInit = RequestInit & {\n  headers: Headers;\n};\n\n/**\n * Convert request options to RequestInit\n *\n * RequestInit is passed to the constructor of fetch(). We have our own 'options' format\n */\nfunction optionsToRequestInit(method: 'GET', options?: GetRequestOptions): StrictRequestInit;\nfunction optionsToRequestInit(method: 'HEAD', options?: HeadRequestOptions): StrictRequestInit;\nfunction optionsToRequestInit(method: 'PATCH', options?: PatchRequestOptions): StrictRequestInit;\nfunction optionsToRequestInit(method: 'POST', options?: PostRequestOptions): StrictRequestInit;\nfunction optionsToRequestInit(method: 'PUT', options?: PutRequestOptions): StrictRequestInit;\nfunction optionsToRequestInit(method: string, options?: GetRequestOptions | PostRequestOptions | PatchRequestOptions | PutRequestOptions): StrictRequestInit {\n\n  if (!options) {\n    return {\n      method,\n      headers: new Headers(),\n    };\n  }\n  let headers;\n  if (options.getContentHeaders) {\n    headers = new Headers(options.getContentHeaders());\n  } else if (options.headers) {\n    headers = new Headers(options.headers);\n  } else {\n    headers = new Headers();\n  }\n  if (!headers.has('Content-Type')) {\n    headers.set('Content-Type', 'application/json');\n  }\n  let body;\n  if ((options as any).serializeBody !== undefined) {\n    body = (options as any).serializeBody();\n  } else if ((options as any).data) {\n    body = (options as any).data;\n    if (needsJsonStringify(body)) {\n      body = JSON.stringify(body);\n    }\n  } else {\n    body = null;\n  }\n  return {\n    method,\n    body,\n    headers,\n  };\n\n}\n\nfunction requestHash(uri: string, options: GetRequestOptions | undefined): string {\n\n  const headers: Record<string, string> = {};\n  if (options) {\n    new Headers(options.getContentHeaders?.() || options.headers)\n      .forEach((value, key) => {\n        headers[key] = value;\n      });\n  }\n\n  const headerStr = Object.entries(headers).map( ([name, value]) => {\n    return name.toLowerCase() + ':' + value;\n  }).join(',');\n\n  return uri + '|' + headerStr;\n}\n","import { State, HeadState } from './interface';\nimport { Links, LinkVariables, LinkNotFound } from '../link';\nimport Client from '../client';\nimport { Action, ActionNotFound, ActionInfo, SimpleAction } from '../action';\nimport { Resource } from '../resource';\nimport { resolve } from '../util/uri';\nimport { expand } from '../util/uri-template';\nimport { entityHeaderNames } from '../http/util';\n\ntype HeadStateInit = {\n\n  client: Client;\n  uri: string;\n  links: Links;\n\n  /**\n   * The full list of HTTP headers that were sent with the response.\n   */\n  headers: Headers;\n}\n\ntype StateInit<T> = {\n  client: Client;\n  uri: string;\n  data: T;\n  headers: Headers;\n  links: Links;\n  embedded?: State[];\n  actions?: ActionInfo[];\n}\n\n/**\n * Implements a State object for HEAD responses\n */\nexport class BaseHeadState implements HeadState {\n\n  uri: string;\n\n  /**\n   * Timestamp of when the State was first generated\n   */\n  timestamp: number;\n\n  /**\n   * The full list of HTTP headers that were sent with the response.\n   */\n  headers: Headers;\n\n  /**\n   * All links associated with the resource.\n   */\n  links: Links;\n\n  /**\n   * Reference to main client that created this state\n   */\n  client: Client;\n\n  constructor(init: HeadStateInit) {\n    this.client = init.client;\n    this.uri = init.uri;\n    this.headers = init.headers;\n    this.timestamp = Date.now();\n    this.links = init.links;\n  }\n\n  /**\n   * Follows a relationship, based on its reltype. For example, this might be\n   * 'alternate', 'item', 'edit' or a custom url-based one.\n   *\n   * This function can also follow templated uris. You can specify uri\n   * variables in the optional variables argument.\n   */\n  follow<TFollowedResource = any>(rel: string, variables?: LinkVariables): Resource<TFollowedResource> {\n\n    const link = this.links.get(rel);\n    if (!link) throw new LinkNotFound(`Link with rel ${rel} on ${this.uri} not found`);\n\n    let href;\n\n    if (link.templated) {\n      href = expand(link, variables || {});\n    } else {\n      href = resolve(link);\n    }\n    if (link.hints?.status === 'deprecated') {\n      /* eslint-disable-next-line no-console */\n      console.warn(`[ketting] The ${link.rel} link on ${this.uri} is marked deprecated.`, link);\n    }\n\n    return this.client.go(href);\n\n  }\n\n  /**\n   * Follows a relationship based on its reltype. This function returns a\n   * Promise that resolves to an array of Resource objects.\n   *\n   * If no resources were found, the array will be empty.\n   */\n  followAll<TFollowedResource = any>(rel: string): Resource<TFollowedResource>[] {\n\n    return this.links.getMany(rel).map( link => {\n\n      if (link.hints?.status === 'deprecated') {\n        /* eslint-disable-next-line no-console */\n        console.warn(`[ketting] The ${link.rel} link on ${this.uri} is marked deprecated.`, link);\n      }\n      const href = resolve(link);\n      return this.client.go(href);\n\n    });\n\n  }\n\n\n  /**\n   * Content-headers are a subset of HTTP headers that related directly\n   * to the content. The obvious ones are Content-Type.\n   *\n   * This set of headers will be sent by the server along with a GET\n   * response, but will also be sent back to the server in a PUT\n   * request.\n   */\n  contentHeaders(): Headers {\n\n    const result: {[name: string]: string} = {};\n\n    for(const contentHeader of entityHeaderNames) {\n      if (this.headers.has(contentHeader)) {\n        result[contentHeader] = this.headers.get(contentHeader)!;\n      }\n    }\n    return new Headers(result);\n\n  }\n\n}\n\n/**\n * The Base State provides a convenient way to implement a new State type.\n */\nexport class BaseState<T> extends BaseHeadState implements State<T> {\n\n\n  data: T;\n\n  protected embedded: State[];\n  protected actionInfo: ActionInfo[];\n\n  constructor(init: StateInit<T>) {\n\n    super(init);\n    this.data = init.data;\n    this.actionInfo = init.actions || [];\n    this.embedded = init.embedded || [];\n\n  }\n\n  /**\n   * Return an action by name.\n   *\n   * If no name is given, the first action is returned. This is useful for\n   * formats that only supply 1 action, and no name.\n   */\n  action<TFormData extends Record<string, any> = any>(name?: string): Action<TFormData> {\n\n    if (!this.actionInfo.length) {\n      throw new ActionNotFound('This State does not define any actions');\n    }\n    if (name === undefined) {\n      return new SimpleAction(this.client, this.actionInfo[0]);\n    }\n    for(const action of this.actionInfo) {\n      if (action.name === name) {\n        return new SimpleAction(this.client, action);\n      }\n    }\n    throw new ActionNotFound('This State defines no action');\n\n  }\n\n  /**\n   * Returns all actions\n   */\n  actions(): Action[] {\n\n    return this.actionInfo.map(action => new SimpleAction(this.client, action));\n\n  }\n\n  /**\n   * Checks if the specified action exists.\n   *\n   * If no name is given, checks if _any_ action exists.\n   */\n  hasAction(name?: string): boolean {\n\n    if (name===undefined) return this.actionInfo.length>0;\n    for(const action of this.actionInfo) {\n      if (name === action.name) {\n        return true;\n      }\n    }\n    return false;\n\n  }\n\n  /**\n   * Returns a serialization of the state that can be used in a HTTP\n   * response.\n   *\n   * For example, a JSON object might simply serialize using\n   * JSON.serialize().\n   */\n  serializeBody(): Buffer|Blob|string {\n\n    if (\n      ((global as any).Buffer && this.data instanceof Buffer) ||\n      ((global as any).Blob && this.data instanceof Blob) ||\n      typeof this.data === 'string')\n    {\n      return this.data;\n    }\n    return JSON.stringify(this.data);\n\n  }\n\n  /**\n   * Certain formats can embed other resources, identified by their\n   * own URI.\n   *\n   * When a format has embedded resources, we will use these to warm\n   * the cache.\n   *\n   * This method returns every embedded resource.\n   */\n  getEmbedded(): State[] {\n\n    return this.embedded;\n\n  }\n\n  clone(): State<T> {\n\n    return new BaseState({\n      client: this.client,\n      uri: this.uri,\n      data: this.data,\n      headers: new Headers(this.headers),\n      links: new Links(this.links.defaultContext, this.links.getAll()),\n      actions: this.actionInfo,\n    });\n\n  }\n\n}\n","import { BaseState } from './base-state';\nimport { StateFactory } from './interface';\nimport { parseLink } from '../http/util';\n\n/**\n * Turns a HTTP response into a BinaryState\n */\nexport const factory: StateFactory<Blob> = async (client, uri, response): Promise<BaseState<Blob>> => {\n\n  return new BaseState({\n    client,\n    uri,\n    data: await response.blob(),\n    headers: response.headers,\n    links: parseLink(uri, response.headers.get('Link')),\n  });\n\n};\n","import { BaseState } from './base-state';\nimport { parseLink } from '../http/util';\nimport { Link } from '../link';\nimport { StateFactory } from './interface';\n\n/**\n * Represents a resource state in the HAL format\n */\nexport class CjState<T = any> extends BaseState<T> {\n\n  serializeBody(): string {\n\n    throw new Error('Reserializing Collection+JSON states is not yet supported. Please log an issue in the Ketting project to help figure out how this should be done');\n  }\n\n}\n\n/**\n * Turns a HTTP response into a CjState\n */\nexport const factory: StateFactory = async (client, uri, response): Promise<CjState<CjCollection>> => {\n\n  const body = await response.json();\n\n  const links = parseLink(uri, response.headers.get('Link'));\n  links.add(\n    ...parseCjLinks(uri, body),\n  );\n\n  // Remove _links and _embedded from body\n  const {\n    _embedded,\n    _links,\n    ...newBody\n  } = body;\n\n  return new CjState({\n    client,\n    uri,\n    data: newBody,\n    headers: response.headers,\n    links,\n  });\n\n};\n\ntype CjDocument = {\n  collection: CjCollection;\n};\n\ntype CjCollection = {\n  version?: string;\n  href?: string;\n  links?: CjLink[];\n  items?: CjItem[];\n  queries?: CjQuery[];\n  template?: CjTemplate;\n  error?: CjError;\n};\n\ntype CjError = {\n  title?: string;\n  code?: string;\n  message?: string;\n};\n\ntype CjTemplate = {\n  data?: CjProperty[];\n};\n\ntype CjItem = {\n  href?: string;\n  data?: CjProperty[];\n  links?: CjLink[];\n};\n\ntype CjProperty = {\n  name: string;\n  value?: string;\n  prompt?: string;\n};\n\ntype CjQuery = {\n  href: string;\n  rel: string;\n  name?: string;\n  prompt?: string;\n  data?: CjProperty[];\n};\n\ntype CjLink = {\n  href: string;\n  rel: string;\n  name?: string;\n  render?: 'image' | 'link';\n  prompt?: string;\n};\n\n\nfunction parseCjLinks(contextUri: string, body: CjDocument) {\n\n  const result: Link[] = [];\n  if (body.collection.links !== undefined) {\n\n    // Lets start with all links from the links property.\n    for (const link of body.collection.links) {\n      result.push({\n        context: contextUri,\n        href: link.href,\n        rel: link.rel,\n        title: link.name,\n      });\n    }\n  }\n\n  if (body.collection.items !== undefined) {\n\n    // Things that are in the 'items' array should also be considered links\n    // with the 'item' link relationship.\n    for (const item of body.collection.items) {\n\n      if (!item.href) {\n        continue;\n      }\n\n      result.push({\n        context: contextUri,\n        href: item.href,\n        rel: 'item',\n      });\n    }\n\n  }\n\n\n  if (body.collection.queries !== undefined) {\n\n    // Things that are in the 'queries' array can be considered links too.\n    for (const query of body.collection.queries) {\n\n      if (!query.data) {\n        // Non-templated\n        result.push({\n          context: contextUri,\n          href: query.href,\n          rel: query.rel,\n          title: query.name,\n        });\n      } else {\n        // This query has a data property so we need 50% more magic\n        result.push({\n          context: contextUri,\n          href: query.href + query.data.map(\n            property => '{?' + property.name + '}'\n          ).join(''),\n          templated: true,\n          rel: query.rel,\n          title: query.name,\n        });\n      }\n    }\n\n  }\n\n  return result;\n\n}\n","import { BaseState } from './base-state';\nimport { parseLink } from '../http/util';\nimport { Link, Links } from '../link';\nimport { resolve } from '../util/uri';\nimport { ActionInfo } from '../action';\nimport { Field } from '../field';\nimport { StateFactory } from './interface';\nimport Client from '../client';\nimport * as hal from 'hal-types';\n\n/**\n * Represents a resource state in the HAL format\n */\nexport class HalState<T = any> extends BaseState<T> {\n\n  serializeBody(): string {\n\n    return JSON.stringify({\n      _links: this.serializeLinks(),\n      ...this.data\n    });\n\n  }\n\n  private serializeLinks(): hal.HalResource['_links'] {\n\n    const links: hal.HalResource['_links'] = {\n      self: { href: this.uri },\n    };\n    for(const link of this.links.getAll()) {\n\n      const { rel, context, ...attributes } = link;\n\n      if (rel === 'self') {\n        // skip\n        continue;\n      }\n\n      if (links[rel] === undefined) {\n        // First link of its kind\n        links[rel] =  attributes;\n      } else if (Array.isArray(links[rel])) {\n        // Add link to link array.\n        (links[rel] as hal.HalLink[]).push(attributes);\n      } else {\n        // 1 link with this rel existed, so we will transform it to an array.\n        links[rel] = [links[rel] as hal.HalLink, attributes];\n      }\n\n    }\n\n    return links;\n\n  }\n\n  clone(): HalState<T> {\n\n    return new HalState({\n      client: this.client,\n      uri: this.uri,\n      data: this.data,\n      headers: new Headers(this.headers),\n      links: new Links(this.links.defaultContext, this.links.getAll()),\n      actions: this.actionInfo,\n    });\n\n  }\n\n}\n\n/**\n * Turns a HTTP response into a HalState\n */\nexport const factory:StateFactory = async (client, uri, response): Promise<HalState> => {\n\n  const body = await response.json();\n  const links = parseLink(uri, response.headers.get('Link'));\n\n  // The HAL factory is also respondible for plain JSON, which might be an\n  // array.\n  if (Array.isArray(body)) {\n    return new HalState({\n      client,\n      uri,\n      data: body,\n      headers: response.headers,\n      links,\n    });\n  }\n\n  links.add(...parseHalLinks(uri, body));\n\n  // Remove _links and _embedded from body\n  const {\n    _embedded,\n    _links,\n    _templates,\n    ...newBody\n  } = body;\n\n  return new HalState({\n    client,\n    uri: uri,\n    data: newBody,\n    headers: response.headers,\n    links: links,\n    embedded: parseHalEmbedded(client, uri, body, response.headers),\n    actions: parseHalForms(uri, body),\n  });\n\n};\n\n/**\n * Parse the Hal _links object and populate the 'links' property.\n */\nfunction parseHalLinks(context: string, body: hal.HalResource): Link[] {\n\n  if (body._links === undefined) {\n    return [];\n  }\n\n  const result: Link[] = [];\n\n  /**\n   * We're capturing all rel-link pairs so we don't duplicate them if they\n   * re-appear in _embedded.\n   *\n   * Links that are embedded _should_ appear in both lists, but not everyone\n   * does this.\n   */\n  const foundLinks = new Set();\n\n  for (const [relType, links] of Object.entries(body._links)) {\n\n    const linkList = Array.isArray(links) ? links : [links];\n\n    for (const link of linkList) {\n      foundLinks.add(relType + ';' + link.href);\n    }\n\n    result.push(\n      ...parseHalLink(context, relType, linkList)\n    );\n\n\n  }\n\n  if (body._embedded) {\n    // eslint-disable-next-line prefer-const\n    for (let [rel, innerBodies] of Object.entries(body._embedded)) {\n\n      if (!Array.isArray(innerBodies)) {\n        innerBodies = [innerBodies];\n      }\n\n      for(const innerBody of innerBodies) {\n\n        const href:string = innerBody?._links?.self?.href;\n        if (!href) {\n          continue;\n        }\n\n        if (foundLinks.has(rel + ';' + href)) {\n          continue;\n        }\n        result.push({\n          rel: rel,\n          href: href,\n          context: context,\n        });\n\n      }\n\n    }\n\n  }\n\n  return result;\n\n}\n\n/**\n * Parses a single HAL link from a _links object\n */\nfunction parseHalLink(context: string, rel: string, links: hal.HalLink[]): Link[] {\n\n  const result: Link[] = [];\n\n  for (const link of links) {\n    result.push({\n      rel,\n      context,\n      ...link,\n    });\n  }\n\n  return result;\n\n}\n\n/**\n * Parse the HAL _embedded object. Right now we're just grabbing the\n * information from _embedded and turn it into links.\n */\nfunction parseHalEmbedded(client: Client, context: string, body: hal.HalResource, headers: Headers): HalState<any>[] {\n\n  if (body._embedded === undefined || !body._embedded) {\n    return [];\n  }\n\n  const result: HalState<any>[] = [];\n\n  for (const embedded of Object.values(body._embedded)) {\n\n    let embeddedList: hal.HalResource[];\n\n    if (!Array.isArray(embedded)) {\n      embeddedList = [embedded];\n    } else {\n      embeddedList = embedded;\n\n    }\n    for (const embeddedItem of embeddedList) {\n\n      if (embeddedItem._links?.self?.href === undefined) {\n        // eslint-disable-next-line no-console\n        console.warn('An item in _embedded was ignored. Each item must have a single \"self\" link');\n        continue;\n      }\n\n      const embeddedSelf = resolve(context, embeddedItem._links.self.href);\n\n      // Remove _links and _embedded from body\n      const {\n        _embedded,\n        _links,\n        ...newBody\n      } = embeddedItem;\n\n      result.push(new HalState({\n        client,\n        uri: embeddedSelf,\n        data: newBody,\n        headers: new Headers({\n          'Content-Type': headers.get('Content-Type')!,\n        }),\n        links: new Links(embeddedSelf, parseHalLinks(context, embeddedItem)),\n        // Parsing nested embedded items. Note that we assume that the base url is relative to\n        // the outermost parent, not relative to the embedded item. HAL is not clear on this.\n        embedded: parseHalEmbedded(client, embeddedSelf, embeddedItem, headers),\n        actions: parseHalForms(embeddedSelf, embeddedItem)\n      }));\n    }\n  }\n\n  return result;\n\n}\n\nfunction parseHalForms(context: string, body: hal.HalResource): ActionInfo[] {\n\n  if (!body._templates) return [];\n\n  return Object.entries(body._templates).map( ([key, hf]) => {\n    return {\n      uri: resolve(context, hf.target || ''),\n      name: key,\n      title: hf.title,\n      method: hf.method,\n      contentType: hf.contentType || 'application/json',\n      fields: hf.properties ? hf.properties.map(prop => parseHalField(prop)) : [],\n    };\n  });\n\n}\n\nfunction parseHalField(halField: hal.HalFormsProperty): Field {\n\n  switch(halField.type) {\n    case undefined:\n    case 'text' :\n    case 'search' :\n    case 'tel' :\n    case 'url' :\n    case 'email' :\n\n      if (halField.options) {\n        const baseField = {\n          name: halField.name,\n          type: 'select' as const,\n          label: halField.prompt,\n          required: halField.required || false,\n          readOnly: halField.readOnly || false,\n          multiple: halField.options.multiple as any,\n          value: (halField.options.selectedValues || halField.value) as any\n        };\n\n        const labelField = halField.options.promptField || 'prompt';\n        const valueField = halField.options.valueField || 'value';\n        if (isInlineOptions(halField.options)) {\n\n          const options: Record<string, string> = {};\n\n          for(const entry of halField.options.inline) {\n\n            if (typeof entry === 'string') {\n              options[entry] = entry;\n            } else {\n              options[entry[valueField]] = entry[labelField];\n            }\n          }\n\n          return {\n            ...baseField,\n            options\n          };\n        } else {\n          return {\n            ...baseField,\n            dataSource: {\n              href: halField.options.link.href,\n              type: halField.options.link.type,\n              labelField,\n              valueField,\n            }\n          };\n        }\n      } else {\n        return {\n          name: halField.name,\n          type: halField.type ?? 'text',\n          required: halField.required || false,\n          readOnly: halField.readOnly || false,\n          value: halField.value,\n          pattern: halField.regex ? new RegExp(halField.regex) : undefined,\n          label: halField.prompt,\n          placeholder: halField.placeHolder,\n          minLength: halField.minLength,\n          maxLength: halField.maxLength,\n        };\n      }\n    case 'hidden' :\n      return {\n        name: halField.name,\n        type: 'hidden',\n        required: halField.required || false,\n        readOnly: halField.readOnly || false,\n        value: halField.value,\n        label: halField.prompt,\n        placeholder: halField.placeHolder,\n      };\n    case 'textarea' :\n      return {\n        name: halField.name,\n        type: halField.type,\n        required: halField.required || false,\n        readOnly: halField.readOnly || false,\n        value: halField.value,\n        label: halField.prompt,\n        placeholder: halField.placeHolder,\n        cols: halField.cols,\n        rows: halField.rows,\n        minLength: halField.minLength,\n        maxLength: halField.maxLength,\n      };\n    case 'password' :\n      return {\n        name: halField.name,\n        type: halField.type,\n        required: halField.required || false,\n        readOnly: halField.readOnly || false,\n        label: halField.prompt,\n        placeholder: halField.placeHolder,\n        minLength: halField.minLength,\n        maxLength: halField.maxLength,\n      };\n    case 'date' :\n    case 'month' :\n    case 'week' :\n    case 'time' :\n      return {\n        name: halField.name,\n        type: halField.type,\n        value: halField.value,\n        required: halField.required || false,\n        readOnly: halField.readOnly || false,\n        label: halField.prompt,\n        min: halField.min,\n        max: halField.max,\n        step: halField.step,\n      };\n    case 'number' :\n    case 'range' :\n      return {\n        name: halField.name,\n        type: halField.type,\n        value: halField.value ? +halField.value : undefined,\n        required: halField.required || false,\n        readOnly: halField.readOnly || false,\n        label: halField.prompt,\n        min: halField.min,\n        max: halField.max,\n        step: halField.step,\n      };\n    case 'datetime-local' :\n      return {\n        name: halField.name,\n        type: halField.type,\n        value: halField.value ? new Date(halField.value) : undefined,\n        required: halField.required || false,\n        readOnly: halField.readOnly || false,\n        label: halField.prompt,\n        min: halField.min,\n        max: halField.max,\n        step: halField.step,\n      };\n    case 'color' :\n      return {\n        name: halField.name,\n        type: halField.type,\n        required: halField.required || false,\n        readOnly: halField.readOnly || false,\n        label: halField.prompt,\n        value: halField.value,\n      };\n    case 'radio' :\n    case 'checkbox' :\n      return {\n        name: halField.name,\n        type: halField.type,\n        required: halField.required || false,\n        readOnly: halField.readOnly || false,\n        label: halField.prompt,\n        value: !!halField.value,\n      };\n\n  }\n\n}\n\nfunction isInlineOptions(options: hal.HalFormsSimpleProperty['options']): options is hal.HalFormsOptionsInline {\n\n  return (options as any).inline !== undefined;\n\n}\n","import { BaseHeadState } from './base-state';\nimport { parseLink } from '../http/util';\nimport Client from '../client';\n\n/**\n * Turns the response to a HTTP Head request into a HeadState object.\n *\n * HeadState is a bit different from normal State objects, because it's\n * missing a bunch of information.\n */\nexport const factory = async (client: Client, uri: string, response: Response): Promise<BaseHeadState> => {\n\n  const links = parseLink(uri, response.headers.get('Link'));\n\n  return new BaseHeadState({\n    client,\n    uri,\n    headers: response.headers,\n    links,\n  });\n\n};\n","import { BaseState } from './base-state';\nimport { parseLink } from '../http/util';\nimport { parseHtml, HtmlForm } from '../util/html';\nimport { ActionInfo } from '../action';\nimport { resolve } from '../util/uri';\nimport { StateFactory } from './interface';\n\n/**\n * Turns a HTTP response into a HtmlState\n */\nexport const factory:StateFactory = async (client, uri, response): Promise<BaseState<string>> => {\n\n  const body = await response.text();\n\n  const links = parseLink(uri, response.headers.get('Link'));\n  const htmlResult = parseHtml(uri, body);\n  links.add(...htmlResult.links);\n\n  return new BaseState({\n    client,\n    uri,\n    data: body,\n    headers: response.headers,\n    links,\n    actions: htmlResult.forms.map(form => formToAction(uri, form)),\n  });\n\n};\n\nfunction formToAction(context: string, form: HtmlForm): ActionInfo {\n\n  return {\n    uri: resolve(context, form.action),\n    name: form.rel || form.id || '',\n    method: form.method || 'GET',\n    contentType: form.enctype || 'application/x-www-form-urlencoded',\n    // Fields are not yet supported :(\n    fields: [],\n  };\n}\n","export { State, StateFactory, HeadState, isState } from './interface';\nexport { BaseState, BaseHeadState } from './base-state';\nexport { factory as halStateFactory, HalState } from './hal';\nexport { factory as binaryStateFactory } from './binary';\nexport { factory as jsonApiStateFactory } from './jsonapi';\nexport { factory as sirenStateFactory, SirenState } from './siren';\nexport { factory as textStateFactory } from './text';\nexport { factory as cjStateFactory, CjState } from './collection-json';\nexport { factory as htmlStateFactory } from './html';\nexport { factory as headStateFactory } from './head';\n","import { Action } from '../action';\nimport { Links, LinkVariables } from '../link';\nimport Client from '../client';\nimport { Resource } from '../resource';\n\nexport type State<T = any> = {\n\n  /**\n   * The URI associated with this state\n   */\n  uri: string;\n\n  /**\n   * Represents the body of the HTTP response.\n   *\n   * In the case of a JSON response, this will be deserialized\n   */\n  data: T;\n\n  /**\n   * All links associated with the resource.\n   */\n  links: Links;\n\n  /**\n   * The full list of HTTP headers that were sent with the response.\n   */\n  headers: Headers;\n\n  /**\n   * Reference to main client that created this state\n   */\n  client: Client;\n\n  /**\n   * Follows a relationship, based on its reltype. For example, this might be\n   * 'alternate', 'item', 'edit' or a custom url-based one.\n   *\n   * This function can also follow templated uris. You can specify uri\n   * variables in the optional variables argument.\n   */\n  follow<TFollowedResource = any>(rel: string, variables?: LinkVariables): Resource<TFollowedResource>;\n\n  /**\n   * Follows a relationship based on its reltype. This function returns a\n   * Promise that resolves to an array of Resource objects.\n   *\n   * If no resources were found, the array will be empty.\n   */\n  followAll<TFollowedResource = any>(rel: string): Resource<TFollowedResource>[];\n\n  /**\n   * Return an action by name.\n   *\n   * If the format provides a default action, the name may be omitted.\n   */\n  action<TFormData extends Record<string, any> = any>(name?: string): Action<TFormData>;\n\n  /**\n   * Returns all actions\n   */\n  actions(): Action[];\n\n  /**\n   * Checks if the specified action exists.\n   *\n   * If no name is given, checks if _any_ action exists.\n   */\n  hasAction(name?: string): boolean;\n\n  /**\n   * Returns a serialization of the state that can be used in a HTTP\n   * response.\n   *\n   * For example, a JSON object might simply serialize using\n   * JSON.serialize().\n   */\n  serializeBody(): Buffer|Blob|string;\n\n  /**\n   * Content-headers are a subset of HTTP headers that related directly\n   * to the content. The obvious ones are Content-Type.\n   *\n   * This set of headers will be sent by the server along with a GET\n   * response, but will also be sent back to the server in a PUT\n   * request.\n   */\n  contentHeaders(): Headers;\n\n  /**\n   * Some formats support embedding resources inside other resources.\n   *\n   * Please note: generally you should always use the .follow() and\n   * .followAll() functions to get access to linked embedded resources.\n   *\n   * There's several operations that change the State in the Ketting Cache,\n   * and usually this erases any associated embedded resources.\n   *\n   * .follow() and .followAll() will return the embedded resources, and also\n   * keeps their respective states fresh when changes are made.\n   */\n  getEmbedded(): State[];\n\n  /**\n   * Timestamp of when the State was first generated\n   */\n  timestamp: number;\n\n  clone(): State<T>;\n\n}\n\n/**\n * HeadState represents the response to a HEAD request.\n *\n * Some information in HEAD responses might be available, but many aren't.\n * Notably, the body.\n */\nexport type HeadState = Omit<State, 'data' | 'action' | 'actions' | 'hasAction' | 'serializeBody' | 'getEmbedded' | 'client' | 'clone'>;\n\n/**\n * A 'StateFactory' is responsible for taking a Fetch Response, and returning\n * an object that impements the State interface\n */\nexport type StateFactory<T = any> = (client: Client, uri: string, request: Response) => Promise<State<T>>;\n\nexport function isState(input: Record<string, any>): input is State {\n\n  return (\n    typeof (input as any).uri === 'string' &&\n    (input as any).links instanceof Links &&\n    (input as any).headers instanceof Headers\n  );\n\n}\n","import { BaseState } from './base-state';\nimport { parseLink } from '../http/util';\nimport { Link } from '../link';\nimport Client from '../client';\n\n/**\n * Turns a HTTP response into a JsonApiState\n */\nexport const factory = async (client: Client, uri: string, response: Response): Promise<BaseState<JsonApiTopLevelObject>> => {\n\n  const body = await response.json();\n\n  const links = parseLink(uri, response.headers.get('Link'));\n  links.add(\n    ...parseJsonApiLinks(uri, body),\n    ...parseJsonApiCollection(uri, body),\n  );\n\n  return new BaseState({\n    client,\n    uri,\n    data: body,\n    headers: response.headers,\n    links: links,\n  });\n\n};\n/**\n * A JSON:API link can either be a string, or an object with at least a href\n * property.\n */\ntype JsonApiLink = string | { href: string };\n\n/**\n * This type is a full 'links' object, which might appear on the top level\n * or on resource objects.\n */\ntype JsonApiLinksObject = {\n  self?: JsonApiLink;\n  profile?: JsonApiLink;\n  [rel: string]: JsonApiLink | JsonApiLink[] | undefined;\n};\n\n/**\n * This is a single JSON:API resource. Its type contains just the properties\n * we care about.\n */\ntype JsonApiResource = {\n  type: string;\n  id: string;\n  links?: JsonApiLinksObject;\n};\n\n\n/**\n * This type represents a valid JSON:API response. We're only interested\n * in the links object at the moment, so everything else is (for now)\n * untyped.\n */\ntype JsonApiTopLevelObject = {\n  links?: JsonApiLinksObject;\n  data: JsonApiResource | JsonApiResource[] | null;\n  [s: string]: any;\n};\n\n/**\n * This function takes a JSON:API object, and extracts the links property.\n */\nfunction parseJsonApiLinks(contextUri: string, body: JsonApiTopLevelObject): Link[] {\n\n  const result: Link[] = [];\n\n  if (body.links === undefined) {\n    return result;\n  }\n\n  for (const [rel, linkValue] of Object.entries(body.links)) {\n\n    if (Array.isArray(linkValue)) {\n      result.push(...linkValue.map( link => parseJsonApiLink(contextUri, rel, link)));\n    } else {\n      result.push(parseJsonApiLink(contextUri, rel, linkValue!));\n    }\n\n  }\n\n  return result;\n\n}\n\n/**\n * Find collection members in JSON:API objects.\n *\n * A JSON:API top-level object might represent a collection that has 0 or more\n * members.\n *\n * Members of this collection should appear as an 'item' link to the parent.\n */\nfunction parseJsonApiCollection(contextUri: string, body: JsonApiTopLevelObject): Link[] {\n\n  if (!Array.isArray(body.data)) {\n    // Not a collection\n    return [];\n  }\n\n  const result: Link[] = [];\n  for (const member of body.data) {\n\n    if ('links' in member && 'self' in member.links!) {\n\n      const selfLink = parseJsonApiLink(contextUri, 'self', member.links!.self!);\n      result.push({\n        context: contextUri,\n        href: selfLink.href,\n        rel: 'item'\n      });\n\n    }\n  }\n\n  return result;\n\n}\n\n/**\n * This function takes a single link value from a JSON:API link object, and\n * returns a object of type Link\n */\nfunction parseJsonApiLink(contextUri: string, rel: string, link: JsonApiLink): Link {\n\n  return ({\n    context: contextUri,\n    rel,\n    href: typeof link === 'string' ? link : link.href,\n  });\n\n}\n","import { BaseState } from './base-state';\nimport { parseLink } from '../http/util';\nimport { Link, Links } from '../link';\nimport { resolve } from '../util/uri';\nimport { ActionInfo } from '../action';\nimport { Field } from '../field';\nimport Client from '../client';\n\n/**\n * Represents a resource state in the Siren format\n */\nexport class SirenState<T> extends BaseState<T> {\n\n  /**\n   * Returns a serialization of the state that can be used in a HTTP\n   * response.\n   *\n   * For example, a JSON object might simply serialize using\n   * JSON.serialize().\n   */\n  serializeBody(): string {\n\n    throw new Error('Reserializing Siren states is not yet supported. Please log an issue in the Ketting project to help figure out how this should be done');\n\n  }\n\n  clone(): SirenState<T> {\n\n    return new SirenState({\n      client: this.client,\n      uri: this.uri,\n      data: this.data,\n      headers: new Headers(this.headers),\n      links: new Links(this.uri, this.links),\n      actions: this.actionInfo,\n    });\n\n  }\n\n}\n\n\n/**\n * Turns a HTTP response into a SirenState\n */\nexport const factory = async (client: Client, uri: string, response: Response): Promise<SirenState<any>> => {\n\n  const body:SirenEntity<any> = await response.json();\n\n  const links = parseLink(uri, response.headers.get('Link'));\n  links.add(...parseSirenLinks(uri, body));\n\n  return new SirenState({\n    client,\n    uri,\n    data: body.properties,\n    headers: response.headers,\n    links: links,\n    embedded: parseSirenEmbedded(client, uri, body, response.headers),\n    actions: body.actions ? body.actions.map( action => parseSirenAction(uri, action) ) : [],\n  });\n\n};\n\ntype SirenProperties = Record<string, any> | undefined;\n\ntype SirenEntity<T extends SirenProperties> = {\n\n  class?: string[];\n\n  properties: T;\n  entities?: (SirenLink | SirenSubEntity)[];\n\n  links?: SirenLink[];\n  actions?: SirenAction[];\n  title?: string;\n\n};\n\ntype SirenSubEntity = SirenEntity<any> & { rel: string[] };\n\ntype SirenLink = {\n\n  class?: string[];\n  rel: string[];\n  href: string;\n  type?: string;\n  title?: string;\n\n};\n\ntype SirenAction = {\n  name: string;\n  class?: string[];\n  method?: string;\n  href: string;\n  title?: string;\n  type?: string;\n  fields?: SirenField[];\n};\n\ntype SirenField = {\n  name: string;\n  class?: string[];\n  type?: 'hidden' | 'text' | 'search' | 'tel' | 'url' | 'email' | 'password' | 'datetime' | 'date' | 'month' | 'week' | 'time' | 'datetime-local' | 'number' | 'range' | 'color' | 'checkbox' | 'radio' | 'file';\n  value?: string;\n  title?: string;\n};\n\nfunction parseSirenLinks(contextUri: string, body: SirenEntity<any>): Link[] {\n\n  const result: Link[] = [];\n\n  if (body.links !== undefined) {\n    for (const link of body.links) {\n      result.push(...parseSirenLink(contextUri, link));\n    }\n  }\n\n  if (body.entities !== undefined) {\n    for (const subEntity of body.entities) {\n      if ((subEntity as SirenLink).href !== undefined) {\n        result.push(...parseSirenLink(contextUri, subEntity as SirenLink));\n      } else {\n        result.push(...parseSirenSubEntityAsLink(contextUri, subEntity as SirenSubEntity));\n      }\n    }\n  }\n\n  return result;\n\n}\n\nfunction parseSirenLink(contextUri: string, link: SirenLink): Link[] {\n\n  const result: Link[] = [];\n\n  const {\n    rel: rels,\n    ...attributes\n  } = link;\n  for (const rel of rels) {\n\n    const newLink: Link = {\n      rel,\n      context: contextUri,\n      ...attributes,\n    };\n    result.push(newLink);\n\n  }\n\n  return result;\n\n}\n\nfunction parseSirenEmbedded(client: Client, contextUri: string, body: SirenEntity<any>, headers: Headers): SirenState<SirenEntity<any>>[] {\n\n  if (body.entities === undefined) {\n    return [];\n  }\n\n  const result: SirenState<SirenEntity<any>>[] = [];\n\n  for (const entity of body.entities) {\n    if (isSubEntity(entity)) {\n      const subState = parseSirenSubEntityAsEmbedded(client, contextUri, entity, headers);\n      if (subState !== null) {\n        result.push(subState);\n      }\n    }\n  }\n\n  return result;\n\n}\n\nfunction parseSirenSubEntityAsLink(contextUri: string, subEntity: SirenSubEntity): Link[] {\n\n  if (subEntity.links === undefined) {\n    // We don't yet support subentities that don't have a URI.\n    return [];\n  }\n  let selfHref: string | null = null;\n  for (const link of subEntity.links) {\n    if (link.rel.includes('self')) {\n      selfHref = link.href;\n    }\n  }\n  if (selfHref === null) {\n    // We don't yet support subentities that don't have a URI.\n    return [];\n  }\n\n  return subEntity.rel.map(rel => {\n    const title = subEntity.title;\n    const link: Link = {\n      href: selfHref!,\n      rel,\n      context: contextUri,\n    };\n    if (title) {\n      link.title = title;\n    }\n    return link;\n  });\n\n}\n\nfunction parseSirenSubEntityAsEmbedded(client: Client, contextUri: string, subEntity: SirenSubEntity, headers: Headers): SirenState<SirenEntity<any>> | null {\n\n  if (subEntity.links === undefined) {\n    // We don't yet support subentities that don't have a URI.\n    return null;\n  }\n  let selfHref = null;\n  for (const link of subEntity.links) {\n    if (link.rel.includes('self')) {\n      selfHref = link.href;\n    }\n  }\n  if (!selfHref) {\n    // We don't yet support subentities that don't have a URI.\n    return null;\n  }\n\n  const subEntityUrl = resolve(contextUri, selfHref);\n\n  return new SirenState({\n    client,\n    uri: subEntityUrl,\n    data: subEntity.properties,\n    headers,\n    links: new Links(selfHref, parseSirenLinks(selfHref, subEntity)),\n  });\n\n}\n\nfunction isSubEntity(input: SirenLink | SirenSubEntity): input is SirenSubEntity {\n\n  return (input as any).href === undefined;\n\n}\n\nfunction parseSirenAction(uri: string, action: SirenAction): ActionInfo {\n  return {\n    uri: resolve(uri, action.href),\n    name: action.name,\n    title: action.title,\n    method: action.method || 'GET',\n    contentType: action.type || 'application/x-www-form-urlencoded',\n    fields: action.fields ? action.fields.map( field => sirenFieldToField(field)) : [],\n  };\n}\n\nfunction sirenFieldToField(input: SirenField): Field {\n\n  const result: Field = {\n    name: input.name,\n    type: input.type || 'text',\n    required: false,\n    readOnly: false,\n  };\n\n  if (input.value) {\n    result.value = input.value;\n  }\n  if (input.title) {\n    result.label = input.title;\n  }\n\n  return result;\n}\n","import { BaseState } from './base-state';\nimport { StateFactory } from './interface';\nimport { parseLink } from '../http/util';\nimport Client from '../client';\n\n/**\n * Turns a HTTP response into a TextState\n */\nexport const factory: StateFactory<string> = async (client: Client, uri: string, response: Response): Promise<BaseState<string>> => {\n\n  return new BaseState({\n    client,\n    uri,\n    data: await response.text(),\n    headers: response.headers,\n    links: parseLink(uri, response.headers.get('Link')),\n  });\n\n};\n","/**\n * Encoding a string to base64 in a browser.\n */\nexport function encode(input: string): string {\n\n  return btoa(input);\n\n}\n","export function needsJsonStringify(input: any): boolean {\n\n  if (typeof input ==='string') {\n    return false;\n  }\n\n  if (input instanceof Blob) {\n    return false;\n  }\n\n  return true;\n\n}\n","import { Link } from '../link';\nimport { resolve } from './uri';\n\nexport type HtmlForm = {\n  action: string;\n  method: string | null;\n  enctype: string | null;\n  rel: string | null;\n  id: string | null;\n}\n\ntype ParseHtmlResult = {\n\n  links: Link[];\n  forms: HtmlForm[];\n\n}\nexport function parseHtml(contextUri: string, body: string): ParseHtmlResult {\n\n  const parser = new DOMParser();\n  const doc = parser.parseFromString(body, 'text/html');\n\n  return {\n    forms: formFromTags(\n      contextUri,\n      doc.getElementsByTagName('form')\n    ),\n    links: [\n      ...linkFromTags(\n        contextUri,\n        doc.getElementsByTagName('link')\n      ),\n      ...linkFromTags(\n        contextUri,\n        doc.getElementsByTagName('a')\n      )\n    ]\n  };\n\n}\n\nfunction linkFromTags(contextUri: string, elements: HTMLCollectionOf<HTMLElement>): Link[] {\n\n  const result: Link[] = [];\n\n  for (const node of elements) {\n\n    const rels = node.getAttribute('rel');\n    const href = node.getAttribute('href');\n    const type = node.getAttribute('type') || undefined;\n\n    if (!rels || !href) {\n      continue;\n    }\n\n    for (const rel of rels.split(' ')) {\n\n      const link:Link = {\n        rel: rel,\n        context: contextUri,\n        href: href,\n      };\n      if (type) link.type = type;\n      result.push(link);\n\n    }\n\n  }\n  return result;\n\n}\n\nfunction formFromTags(contextUri: string, elements: HTMLCollectionOf<HTMLFormElement>): HtmlForm[] {\n\n  const result = [];\n\n  for (const node of elements) {\n\n    const rels = node.getAttribute('rel');\n    const action = node.getAttribute('action')!;\n    const enctype = node.getAttribute('enctype') || 'application/x-www-form-urlencoded';\n    const id = node.getAttribute('id');\n    const method = node.getAttribute('method') || 'GET';\n\n    if (!rels) {\n      result.push({\n        rel: null,\n        action: resolve(contextUri, action),\n        enctype,\n        id,\n        method\n      });\n      continue;\n    }\n\n    for (const rel of rels.split(' ')) {\n\n      const form = {\n        rel,\n        action: resolve(contextUri, action),\n        enctype,\n        id,\n        method\n      };\n      result.push(form);\n\n    }\n\n  }\n\n  return result;\n\n}\n","import * as uriTemplate from 'uri-template';\nimport { resolve } from './uri';\nimport { LinkVariables, Link } from '../link';\n\nexport function expand(context: string, template: string, vars: LinkVariables): string;\nexport function expand(link: Link, vars: LinkVariables): string;\nexport function expand(arg1: string|Link, arg2: string|LinkVariables, arg3?: LinkVariables): string {\n\n  let context:string;\n  let template:string;\n  let vars:LinkVariables;\n\n  if (typeof arg1 === 'string') {\n    context = arg1;\n    template = arg2 as string;\n    vars = arg3 as LinkVariables;\n  } else {\n    context = arg1.context;\n    template = arg1.href;\n    vars =  arg2 as LinkVariables;\n  }\n  const templ = uriTemplate.parse(template);\n  const expanded = templ.expand(vars);\n  return resolve(context, expanded);\n}\n","import { Link } from '../link';\n\ntype UrlParts = {\n  host?: string;\n};\n\n/**\n * Resolves a relative url using another url.\n *\n * This is the browser-based version.\n */\nexport function resolve(base: string, relative: string): string;\nexport function resolve(link: Link): string;\nexport function resolve(base: string|Link, relative?: string): string {\n\n  if (typeof base !== 'string') {\n    relative = base.href;\n    base = base.context;\n  } else {\n    if (!relative) {\n      return base;\n    }\n  }\n\n  // If the URL object is supported, we prefer that.\n  if (typeof URL !== 'undefined' && /https?:\\/\\//.exec(base)?.index === 0) {\n    return (new URL(relative, base).toString());\n  }\n\n  // Code taken from this gist:;\n  // https://gist.github.com/johan/3915545#file-resolveurl-js\n\n  const doc     = document;\n  const oldBase = doc.getElementsByTagName('base')[0];\n  const oldHref = oldBase?.href;\n  const docHead = doc.head || doc.getElementsByTagName('head')[0];\n  const ourBase = oldBase || docHead.appendChild(doc.createElement('base'));\n  const resolver = doc.createElement('a');\n\n  ourBase.href = base;\n  resolver.href = relative!;\n  const resolvedUrl  = resolver.href; // browser magic at work here\n\n  if (oldBase) {\n    oldBase.href = oldHref;\n  } else {\n    docHead.removeChild(ourBase);\n  }\n  return resolvedUrl;\n\n}\n\n/**\n * Parses a url in multiple components.\n *\n * This is the browser-based version.\n */\nexport function parse(url: string): UrlParts {\n\n  const urlObj = new URL(url);\n  return {\n    host: urlObj.host,\n  };\n\n}\n","\"use strict\";\nexports.__esModule = true;\nexports.toString = void 0;\nfunction toString(node) {\n    var _a, _b;\n    switch (node.type) {\n        case \"template\":\n            return node.parts.map(toString).join(\"\");\n        case \"literal\":\n            return node.value;\n        case \"expression\":\n            return \"{\" + node.operator + node.variables.map(toString).join(\",\") + \"}\";\n        case \"variable\":\n            var out = node.name;\n            if (((_a = node.modifier) === null || _a === void 0 ? void 0 : _a.type) == \"explode\") {\n                out += \"*\";\n            }\n            else if (((_b = node.modifier) === null || _b === void 0 ? void 0 : _b.type) == \"substr\") {\n                out += \":\" + node.modifier.length;\n            }\n            if (node.extension) {\n                out += \"(\" + node.extension + \")\";\n            }\n            return out;\n    }\n}\nexports.toString = toString;\n","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nexports.__esModule = true;\nexports.expandExpression = exports.expandTemplate = void 0;\nvar pct_encode_1 = __importDefault(require(\"pct-encode\"));\nvar encoders = {\n    UrlSafe: (0, pct_encode_1[\"default\"])(/[^\\w~.-]/g),\n    Restricted: (0, pct_encode_1[\"default\"])(/[^\\w.~:\\/\\?#\\[\\]@!\\$&'()*+,;=%-]|%(?!\\d\\d)/g)\n};\nfunction expandTemplate(ast, values) {\n    var strings = ast.parts.map(function (part) {\n        switch (part.type) {\n            case \"literal\":\n                return part.value;\n            case \"expression\":\n                return expandExpression(part, values);\n        }\n    });\n    return strings.join(\"\");\n}\nexports.expandTemplate = expandTemplate;\nvar defaults = {\n    first: \"\",\n    sep: \",\",\n    empty: \"\",\n    encode: encoders.UrlSafe,\n    named: false\n};\nvar OperatorConfigs = {\n    \"\": __assign({}, defaults),\n    \"+\": __assign(__assign({}, defaults), { encode: encoders.Restricted }),\n    \"#\": __assign(__assign({}, defaults), { encode: encoders.Restricted, first: \"#\", empty: \"#\" }),\n    \"/\": __assign(__assign({}, defaults), { first: \"/\", sep: \"/\" }),\n    \".\": __assign(__assign({}, defaults), { first: \".\", sep: \".\", empty: \".\" }),\n    \";\": __assign(__assign({}, defaults), { first: \";\", sep: \";\", named: true }),\n    \"?\": __assign(__assign({}, defaults), { first: \"?\", sep: \"&\", empty: \"=\", named: true }),\n    \"&\": __assign(__assign({}, defaults), { first: \"&\", sep: \"&\", empty: \"=\", named: true })\n};\nfunction expandExpression(expression, values) {\n    var config = OperatorConfigs[expression.operator];\n    var strings = [];\n    expression.variables.forEach(function (variable) {\n        var value = values[variable.name];\n        if (!present(value))\n            return;\n        var string = expandVariable(variable, value, config);\n        strings.push(string || \"\");\n    });\n    if (strings.length === 0) {\n        return \"\";\n    }\n    var expanded = strings.join(config.sep);\n    if (expanded.length === 0) {\n        return config.empty;\n    }\n    return config.first + expanded;\n}\nexports.expandExpression = expandExpression;\nfunction expandVariable(variable, value, config) {\n    var _a;\n    if (value == null) {\n        throw new TypeError(\"tried to expand null value for variable \" + variable.name + \", this is a bug in uri-template\");\n    }\n    if (((_a = variable.modifier) === null || _a === void 0 ? void 0 : _a.type) === \"explode\") {\n        return expandValueExplode(variable, value, config);\n    }\n    else {\n        return expandValueSingle(variable, value, config);\n    }\n}\nfunction expandValueSingle(variable, value, _a) {\n    var _b, _c;\n    var empty = _a.empty, encode = _a.encode, named = _a.named;\n    if (typeof value === \"object\" && ((_b = variable.modifier) === null || _b === void 0 ? void 0 : _b.type) === \"substr\") {\n        throw new Error(\"Prefixed variables do not support lists/maps. Check \" + variable.name);\n    }\n    var out;\n    if (Array.isArray(value)) {\n        out = value.map(encode).join(\",\");\n    }\n    else if (typeof value === \"object\") {\n        out = Object.entries(value)\n            .map(function (entry) { return entry.map(encode).join(\",\"); })\n            .join(\",\");\n    }\n    else {\n        out = value.toString();\n        if (((_c = variable.modifier) === null || _c === void 0 ? void 0 : _c.type) === \"substr\") {\n            out = out.substring(0, variable.modifier.length);\n        }\n        out = encode(out);\n    }\n    if (named) {\n        if (out) {\n            out = variable.name + \"=\" + out;\n        }\n        else {\n            out = \"\" + variable.name + empty;\n        }\n    }\n    return out;\n}\nfunction expandValueExplode(variable, value, _a) {\n    var encode = _a.encode, named = _a.named, sep = _a.sep;\n    if (Array.isArray(value)) {\n        var items = value.map(encode);\n        if (named) {\n            items = items.map(function (item) { return variable.name + \"=\" + item; });\n        }\n        return items.join(sep);\n    }\n    else if (typeof value === \"object\") {\n        var pairs_1 = [];\n        Object.entries(value).forEach(function (_a) {\n            var k = _a[0], v = _a[1];\n            k = encode(k);\n            if (Array.isArray(v)) {\n                v.forEach(function (item) {\n                    pairs_1.push(k + \"=\" + encode(item));\n                });\n            }\n            else {\n                pairs_1.push(k + \"=\" + encode(v));\n            }\n        });\n        return pairs_1.join(sep);\n    }\n    else {\n        var s = value.toString();\n        return encode(s);\n    }\n}\nfunction present(v) {\n    switch (typeof v) {\n        case \"undefined\":\n            return false;\n        case \"object\":\n            if (v == null) {\n                return false;\n            }\n            if (Array.isArray(v)) {\n                return v.length > 0;\n            }\n            for (var k in v) {\n                if (v[k] != null)\n                    return true;\n            }\n            return false;\n        default:\n            return true;\n    }\n}\n","// Generated by Peggy 1.2.0.\n//\n// https://peggyjs.org/\n\"use strict\";\nfunction peg$subclass(child, parent) {\n    function C() { this.constructor = child; }\n    C.prototype = parent.prototype;\n    child.prototype = new C();\n}\nfunction peg$SyntaxError(message, expected, found, location) {\n    var self = Error.call(this, message);\n    if (Object.setPrototypeOf) {\n        Object.setPrototypeOf(self, peg$SyntaxError.prototype);\n    }\n    self.expected = expected;\n    self.found = found;\n    self.location = location;\n    self.name = \"SyntaxError\";\n    return self;\n}\npeg$subclass(peg$SyntaxError, Error);\nfunction peg$padEnd(str, targetLength, padString) {\n    padString = padString || \" \";\n    if (str.length > targetLength) {\n        return str;\n    }\n    targetLength -= str.length;\n    padString += padString.repeat(targetLength);\n    return str + padString.slice(0, targetLength);\n}\npeg$SyntaxError.prototype.format = function (sources) {\n    var str = \"Error: \" + this.message;\n    if (this.location) {\n        var src = null;\n        var k;\n        for (k = 0; k < sources.length; k++) {\n            if (sources[k].source === this.location.source) {\n                src = sources[k].text.split(/\\r\\n|\\n|\\r/g);\n                break;\n            }\n        }\n        var s = this.location.start;\n        var loc = this.location.source + \":\" + s.line + \":\" + s.column;\n        if (src) {\n            var e = this.location.end;\n            var filler = peg$padEnd(\"\", s.line.toString().length);\n            var line = src[s.line - 1];\n            var last = s.line === e.line ? e.column : line.length + 1;\n            str += \"\\n --> \" + loc + \"\\n\"\n                + filler + \" |\\n\"\n                + s.line + \" | \" + line + \"\\n\"\n                + filler + \" | \" + peg$padEnd(\"\", s.column - 1)\n                + peg$padEnd(\"\", last - s.column, \"^\");\n        }\n        else {\n            str += \"\\n at \" + loc;\n        }\n    }\n    return str;\n};\npeg$SyntaxError.buildMessage = function (expected, found) {\n    var DESCRIBE_EXPECTATION_FNS = {\n        literal: function (expectation) {\n            return \"\\\"\" + literalEscape(expectation.text) + \"\\\"\";\n        },\n        \"class\": function (expectation) {\n            var escapedParts = expectation.parts.map(function (part) {\n                return Array.isArray(part)\n                    ? classEscape(part[0]) + \"-\" + classEscape(part[1])\n                    : classEscape(part);\n            });\n            return \"[\" + (expectation.inverted ? \"^\" : \"\") + escapedParts + \"]\";\n        },\n        any: function () {\n            return \"any character\";\n        },\n        end: function () {\n            return \"end of input\";\n        },\n        other: function (expectation) {\n            return expectation.description;\n        }\n    };\n    function hex(ch) {\n        return ch.charCodeAt(0).toString(16).toUpperCase();\n    }\n    function literalEscape(s) {\n        return s\n            .replace(/\\\\/g, \"\\\\\\\\\")\n            .replace(/\"/g, \"\\\\\\\"\")\n            .replace(/\\0/g, \"\\\\0\")\n            .replace(/\\t/g, \"\\\\t\")\n            .replace(/\\n/g, \"\\\\n\")\n            .replace(/\\r/g, \"\\\\r\")\n            .replace(/[\\x00-\\x0F]/g, function (ch) { return \"\\\\x0\" + hex(ch); })\n            .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function (ch) { return \"\\\\x\" + hex(ch); });\n    }\n    function classEscape(s) {\n        return s\n            .replace(/\\\\/g, \"\\\\\\\\\")\n            .replace(/\\]/g, \"\\\\]\")\n            .replace(/\\^/g, \"\\\\^\")\n            .replace(/-/g, \"\\\\-\")\n            .replace(/\\0/g, \"\\\\0\")\n            .replace(/\\t/g, \"\\\\t\")\n            .replace(/\\n/g, \"\\\\n\")\n            .replace(/\\r/g, \"\\\\r\")\n            .replace(/[\\x00-\\x0F]/g, function (ch) { return \"\\\\x0\" + hex(ch); })\n            .replace(/[\\x10-\\x1F\\x7F-\\x9F]/g, function (ch) { return \"\\\\x\" + hex(ch); });\n    }\n    function describeExpectation(expectation) {\n        return DESCRIBE_EXPECTATION_FNS[expectation.type](expectation);\n    }\n    function describeExpected(expected) {\n        var descriptions = expected.map(describeExpectation);\n        var i, j;\n        descriptions.sort();\n        if (descriptions.length > 0) {\n            for (i = 1, j = 1; i < descriptions.length; i++) {\n                if (descriptions[i - 1] !== descriptions[i]) {\n                    descriptions[j] = descriptions[i];\n                    j++;\n                }\n            }\n            descriptions.length = j;\n        }\n        switch (descriptions.length) {\n            case 1:\n                return descriptions[0];\n            case 2:\n                return descriptions[0] + \" or \" + descriptions[1];\n            default:\n                return descriptions.slice(0, -1).join(\", \")\n                    + \", or \"\n                    + descriptions[descriptions.length - 1];\n        }\n    }\n    function describeFound(found) {\n        return found ? \"\\\"\" + literalEscape(found) + \"\\\"\" : \"end of input\";\n    }\n    return \"Expected \" + describeExpected(expected) + \" but \" + describeFound(found) + \" found.\";\n};\nfunction peg$parse(input, options) {\n    options = options !== undefined ? options : {};\n    var peg$FAILED = {};\n    var peg$source = options.grammarSource;\n    var peg$startRuleFunctions = { template: peg$parsetemplate };\n    var peg$startRuleFunction = peg$parsetemplate;\n    var peg$c0 = \"{\";\n    var peg$c1 = \"}\";\n    var peg$c2 = \",\";\n    var peg$c3 = \"*\";\n    var peg$c4 = \":\";\n    var peg$c5 = \"(\";\n    var peg$c6 = \")\";\n    var peg$r0 = /^[\\/;.?&+#]/;\n    var peg$r1 = /^[a-zA-Z0-9_.%]/;\n    var peg$r2 = /^[0-9]/;\n    var peg$r3 = /^[^{]/;\n    var peg$r4 = /^[^)]/;\n    var peg$e0 = peg$literalExpectation(\"{\", false);\n    var peg$e1 = peg$literalExpectation(\"}\", false);\n    var peg$e2 = peg$classExpectation([\"/\", \";\", \".\", \"?\", \"&\", \"+\", \"#\"], false, false);\n    var peg$e3 = peg$literalExpectation(\",\", false);\n    var peg$e4 = peg$classExpectation([[\"a\", \"z\"], [\"A\", \"Z\"], [\"0\", \"9\"], \"_\", \".\", \"%\"], false, false);\n    var peg$e5 = peg$literalExpectation(\"*\", false);\n    var peg$e6 = peg$literalExpectation(\":\", false);\n    var peg$e7 = peg$classExpectation([[\"0\", \"9\"]], false, false);\n    var peg$e8 = peg$classExpectation([\"{\"], true, false);\n    var peg$e9 = peg$literalExpectation(\"(\", false);\n    var peg$e10 = peg$classExpectation([\")\"], true, false);\n    var peg$e11 = peg$literalExpectation(\")\", false);\n    var peg$f0 = function (parts) { return { type: 'template', parts: parts }; };\n    var peg$f1 = function (operator, variables) { return { type: 'expression', operator: operator, variables: variables }; };\n    var peg$f2 = function (hd, v) { return v; };\n    var peg$f3 = function (hd, rst) { rst.unshift(hd); return rst; };\n    var peg$f4 = function (name, modifier, extension) { return { type: 'variable', name: name, modifier: modifier, extension: extension }; };\n    var peg$f5 = function () { return { type: 'explode' }; };\n    var peg$f6 = function (digits) { return { type: 'substr', length: parseInt(digits) }; };\n    var peg$f7 = function (value) { return { type: 'literal', value: value }; };\n    var peg$f8 = function (text) { return text; };\n    var peg$currPos = 0;\n    var peg$savedPos = 0;\n    var peg$posDetailsCache = [{ line: 1, column: 1 }];\n    var peg$maxFailPos = 0;\n    var peg$maxFailExpected = [];\n    var peg$silentFails = 0;\n    var peg$result;\n    if (\"startRule\" in options) {\n        if (!(options.startRule in peg$startRuleFunctions)) {\n            throw new Error(\"Can't start parsing from rule \\\"\" + options.startRule + \"\\\".\");\n        }\n        peg$startRuleFunction = peg$startRuleFunctions[options.startRule];\n    }\n    function text() {\n        return input.substring(peg$savedPos, peg$currPos);\n    }\n    function offset() {\n        return peg$savedPos;\n    }\n    function range() {\n        return {\n            source: peg$source,\n            start: peg$savedPos,\n            end: peg$currPos\n        };\n    }\n    function location() {\n        return peg$computeLocation(peg$savedPos, peg$currPos);\n    }\n    function expected(description, location) {\n        location = location !== undefined\n            ? location\n            : peg$computeLocation(peg$savedPos, peg$currPos);\n        throw peg$buildStructuredError([peg$otherExpectation(description)], input.substring(peg$savedPos, peg$currPos), location);\n    }\n    function error(message, location) {\n        location = location !== undefined\n            ? location\n            : peg$computeLocation(peg$savedPos, peg$currPos);\n        throw peg$buildSimpleError(message, location);\n    }\n    function peg$literalExpectation(text, ignoreCase) {\n        return { type: \"literal\", text: text, ignoreCase: ignoreCase };\n    }\n    function peg$classExpectation(parts, inverted, ignoreCase) {\n        return { type: \"class\", parts: parts, inverted: inverted, ignoreCase: ignoreCase };\n    }\n    function peg$anyExpectation() {\n        return { type: \"any\" };\n    }\n    function peg$endExpectation() {\n        return { type: \"end\" };\n    }\n    function peg$otherExpectation(description) {\n        return { type: \"other\", description: description };\n    }\n    function peg$computePosDetails(pos) {\n        var details = peg$posDetailsCache[pos];\n        var p;\n        if (details) {\n            return details;\n        }\n        else {\n            p = pos - 1;\n            while (!peg$posDetailsCache[p]) {\n                p--;\n            }\n            details = peg$posDetailsCache[p];\n            details = {\n                line: details.line,\n                column: details.column\n            };\n            while (p < pos) {\n                if (input.charCodeAt(p) === 10) {\n                    details.line++;\n                    details.column = 1;\n                }\n                else {\n                    details.column++;\n                }\n                p++;\n            }\n            peg$posDetailsCache[pos] = details;\n            return details;\n        }\n    }\n    function peg$computeLocation(startPos, endPos) {\n        var startPosDetails = peg$computePosDetails(startPos);\n        var endPosDetails = peg$computePosDetails(endPos);\n        return {\n            source: peg$source,\n            start: {\n                offset: startPos,\n                line: startPosDetails.line,\n                column: startPosDetails.column\n            },\n            end: {\n                offset: endPos,\n                line: endPosDetails.line,\n                column: endPosDetails.column\n            }\n        };\n    }\n    function peg$fail(expected) {\n        if (peg$currPos < peg$maxFailPos) {\n            return;\n        }\n        if (peg$currPos > peg$maxFailPos) {\n            peg$maxFailPos = peg$currPos;\n            peg$maxFailExpected = [];\n        }\n        peg$maxFailExpected.push(expected);\n    }\n    function peg$buildSimpleError(message, location) {\n        return new peg$SyntaxError(message, null, null, location);\n    }\n    function peg$buildStructuredError(expected, found, location) {\n        return new peg$SyntaxError(peg$SyntaxError.buildMessage(expected, found), expected, found, location);\n    }\n    function peg$parsetemplate() {\n        var s0, s1, s2;\n        s0 = peg$currPos;\n        s1 = [];\n        s2 = peg$parseliteral();\n        if (s2 === peg$FAILED) {\n            s2 = peg$parseexpression();\n        }\n        while (s2 !== peg$FAILED) {\n            s1.push(s2);\n            s2 = peg$parseliteral();\n            if (s2 === peg$FAILED) {\n                s2 = peg$parseexpression();\n            }\n        }\n        peg$savedPos = s0;\n        s1 = peg$f0(s1);\n        s0 = s1;\n        return s0;\n    }\n    function peg$parseexpression() {\n        var s0, s1, s2, s3, s4;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 123) {\n            s1 = peg$c0;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$e0);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parseoperator();\n            if (s2 !== peg$FAILED) {\n                s3 = peg$parsevariables();\n                if (s3 !== peg$FAILED) {\n                    if (input.charCodeAt(peg$currPos) === 125) {\n                        s4 = peg$c1;\n                        peg$currPos++;\n                    }\n                    else {\n                        s4 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$e1);\n                        }\n                    }\n                    if (s4 !== peg$FAILED) {\n                        peg$savedPos = s0;\n                        s0 = peg$f1(s2, s3);\n                    }\n                    else {\n                        peg$currPos = s0;\n                        s0 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parseoperator() {\n        var s0;\n        if (peg$r0.test(input.charAt(peg$currPos))) {\n            s0 = input.charAt(peg$currPos);\n            peg$currPos++;\n        }\n        else {\n            s0 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$e2);\n            }\n        }\n        if (s0 === peg$FAILED) {\n            s0 = '';\n        }\n        return s0;\n    }\n    function peg$parsevariables() {\n        var s0, s1, s2, s3, s4, s5;\n        s0 = peg$currPos;\n        s1 = peg$parsevariable();\n        if (s1 !== peg$FAILED) {\n            s2 = [];\n            s3 = peg$currPos;\n            if (input.charCodeAt(peg$currPos) === 44) {\n                s4 = peg$c2;\n                peg$currPos++;\n            }\n            else {\n                s4 = peg$FAILED;\n                if (peg$silentFails === 0) {\n                    peg$fail(peg$e3);\n                }\n            }\n            if (s4 !== peg$FAILED) {\n                s5 = peg$parsevariable();\n                if (s5 !== peg$FAILED) {\n                    peg$savedPos = s3;\n                    s3 = peg$f2(s1, s5);\n                }\n                else {\n                    peg$currPos = s3;\n                    s3 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s3;\n                s3 = peg$FAILED;\n            }\n            while (s3 !== peg$FAILED) {\n                s2.push(s3);\n                s3 = peg$currPos;\n                if (input.charCodeAt(peg$currPos) === 44) {\n                    s4 = peg$c2;\n                    peg$currPos++;\n                }\n                else {\n                    s4 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$e3);\n                    }\n                }\n                if (s4 !== peg$FAILED) {\n                    s5 = peg$parsevariable();\n                    if (s5 !== peg$FAILED) {\n                        peg$savedPos = s3;\n                        s3 = peg$f2(s1, s5);\n                    }\n                    else {\n                        peg$currPos = s3;\n                        s3 = peg$FAILED;\n                    }\n                }\n                else {\n                    peg$currPos = s3;\n                    s3 = peg$FAILED;\n                }\n            }\n            peg$savedPos = s0;\n            s0 = peg$f3(s1, s2);\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parsevariable() {\n        var s0, s1, s2, s3;\n        s0 = peg$currPos;\n        s1 = peg$currPos;\n        s2 = [];\n        if (peg$r1.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n        }\n        else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$e4);\n            }\n        }\n        if (s3 !== peg$FAILED) {\n            while (s3 !== peg$FAILED) {\n                s2.push(s3);\n                if (peg$r1.test(input.charAt(peg$currPos))) {\n                    s3 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                }\n                else {\n                    s3 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$e4);\n                    }\n                }\n            }\n        }\n        else {\n            s2 = peg$FAILED;\n        }\n        if (s2 !== peg$FAILED) {\n            s1 = input.substring(s1, peg$currPos);\n        }\n        else {\n            s1 = s2;\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$parsesubstr();\n            if (s2 === peg$FAILED) {\n                s2 = peg$parselistMarker();\n            }\n            if (s2 === peg$FAILED) {\n                s2 = null;\n            }\n            s3 = peg$parseextension();\n            if (s3 === peg$FAILED) {\n                s3 = null;\n            }\n            peg$savedPos = s0;\n            s0 = peg$f4(s1, s2, s3);\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parselistMarker() {\n        var s0, s1;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 42) {\n            s1 = peg$c3;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$e5);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$f5();\n        }\n        s0 = s1;\n        return s0;\n    }\n    function peg$parsesubstr() {\n        var s0, s1, s2, s3, s4;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 58) {\n            s1 = peg$c4;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$e6);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$currPos;\n            s3 = [];\n            if (peg$r2.test(input.charAt(peg$currPos))) {\n                s4 = input.charAt(peg$currPos);\n                peg$currPos++;\n            }\n            else {\n                s4 = peg$FAILED;\n                if (peg$silentFails === 0) {\n                    peg$fail(peg$e7);\n                }\n            }\n            if (s4 !== peg$FAILED) {\n                while (s4 !== peg$FAILED) {\n                    s3.push(s4);\n                    if (peg$r2.test(input.charAt(peg$currPos))) {\n                        s4 = input.charAt(peg$currPos);\n                        peg$currPos++;\n                    }\n                    else {\n                        s4 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$e7);\n                        }\n                    }\n                }\n            }\n            else {\n                s3 = peg$FAILED;\n            }\n            if (s3 !== peg$FAILED) {\n                s2 = input.substring(s2, peg$currPos);\n            }\n            else {\n                s2 = s3;\n            }\n            if (s2 !== peg$FAILED) {\n                peg$savedPos = s0;\n                s0 = peg$f6(s2);\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    function peg$parseliteral() {\n        var s0, s1, s2, s3;\n        s0 = peg$currPos;\n        s1 = peg$currPos;\n        s2 = [];\n        if (peg$r3.test(input.charAt(peg$currPos))) {\n            s3 = input.charAt(peg$currPos);\n            peg$currPos++;\n        }\n        else {\n            s3 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$e8);\n            }\n        }\n        if (s3 !== peg$FAILED) {\n            while (s3 !== peg$FAILED) {\n                s2.push(s3);\n                if (peg$r3.test(input.charAt(peg$currPos))) {\n                    s3 = input.charAt(peg$currPos);\n                    peg$currPos++;\n                }\n                else {\n                    s3 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$e8);\n                    }\n                }\n            }\n        }\n        else {\n            s2 = peg$FAILED;\n        }\n        if (s2 !== peg$FAILED) {\n            s1 = input.substring(s1, peg$currPos);\n        }\n        else {\n            s1 = s2;\n        }\n        if (s1 !== peg$FAILED) {\n            peg$savedPos = s0;\n            s1 = peg$f7(s1);\n        }\n        s0 = s1;\n        return s0;\n    }\n    function peg$parseextension() {\n        var s0, s1, s2, s3, s4;\n        s0 = peg$currPos;\n        if (input.charCodeAt(peg$currPos) === 40) {\n            s1 = peg$c5;\n            peg$currPos++;\n        }\n        else {\n            s1 = peg$FAILED;\n            if (peg$silentFails === 0) {\n                peg$fail(peg$e9);\n            }\n        }\n        if (s1 !== peg$FAILED) {\n            s2 = peg$currPos;\n            s3 = [];\n            if (peg$r4.test(input.charAt(peg$currPos))) {\n                s4 = input.charAt(peg$currPos);\n                peg$currPos++;\n            }\n            else {\n                s4 = peg$FAILED;\n                if (peg$silentFails === 0) {\n                    peg$fail(peg$e10);\n                }\n            }\n            if (s4 !== peg$FAILED) {\n                while (s4 !== peg$FAILED) {\n                    s3.push(s4);\n                    if (peg$r4.test(input.charAt(peg$currPos))) {\n                        s4 = input.charAt(peg$currPos);\n                        peg$currPos++;\n                    }\n                    else {\n                        s4 = peg$FAILED;\n                        if (peg$silentFails === 0) {\n                            peg$fail(peg$e10);\n                        }\n                    }\n                }\n            }\n            else {\n                s3 = peg$FAILED;\n            }\n            if (s3 !== peg$FAILED) {\n                s2 = input.substring(s2, peg$currPos);\n            }\n            else {\n                s2 = s3;\n            }\n            if (s2 !== peg$FAILED) {\n                if (input.charCodeAt(peg$currPos) === 41) {\n                    s3 = peg$c6;\n                    peg$currPos++;\n                }\n                else {\n                    s3 = peg$FAILED;\n                    if (peg$silentFails === 0) {\n                        peg$fail(peg$e11);\n                    }\n                }\n                if (s3 !== peg$FAILED) {\n                    peg$savedPos = s0;\n                    s0 = peg$f8(s2);\n                }\n                else {\n                    peg$currPos = s0;\n                    s0 = peg$FAILED;\n                }\n            }\n            else {\n                peg$currPos = s0;\n                s0 = peg$FAILED;\n            }\n        }\n        else {\n            peg$currPos = s0;\n            s0 = peg$FAILED;\n        }\n        return s0;\n    }\n    peg$result = peg$startRuleFunction();\n    if (peg$result !== peg$FAILED && peg$currPos === input.length) {\n        return peg$result;\n    }\n    else {\n        if (peg$result !== peg$FAILED && peg$currPos < input.length) {\n            peg$fail(peg$endExpectation());\n        }\n        throw peg$buildStructuredError(peg$maxFailExpected, peg$maxFailPos < input.length ? input.charAt(peg$maxFailPos) : null, peg$maxFailPos < input.length\n            ? peg$computeLocation(peg$maxFailPos, peg$maxFailPos + 1)\n            : peg$computeLocation(peg$maxFailPos, peg$maxFailPos));\n    }\n}\nmodule.exports = {\n    SyntaxError: peg$SyntaxError,\n    parse: peg$parse\n};\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nexports.__esModule = true;\nexports.parseRule = exports.parse = void 0;\nvar grammar = __importStar(require(\"./grammar.js\"));\nvar AST = __importStar(require(\"./ast\"));\nvar expander_1 = require(\"./expander\");\nfunction parse(input) {\n    var ast = parseRule(input, \"template\");\n    return {\n        ast: ast,\n        expand: function (values) { return (0, expander_1.expandTemplate)(ast, values); },\n        toString: function () { return AST.toString(ast); }\n    };\n}\nexports.parse = parse;\nfunction parseRule(input, startRule) {\n    if (startRule === void 0) { startRule = \"template\"; }\n    return grammar.parse(input, { startRule: startRule });\n}\nexports.parseRule = parseRule;\n__exportStar(require(\"./expander\"), exports);\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","export { default as Client, default as Ketting, default } from './client';\nexport { default as Resource } from './resource';\n\nexport { Link, LinkNotFound, Links } from './link';\n\nexport { resolve } from './util/uri';\n\nexport {\n  BaseState,\n  BaseHeadState,\n  State,\n  HalState,\n  SirenState,\n  CjState,\n  isState,\n} from './state';\n\nexport { ForeverCache } from './cache/forever';\nexport { ShortCache } from './cache/short';\nexport { NeverCache } from './cache/never';\n\nexport { default as basicAuth } from './http/basic-auth';\nexport { default as bearerAuth } from './http/bearer-auth';\nexport { default as oauth2 } from './http/oauth2';\n\nexport { Problem } from './http/error';\n\nexport { Action } from './action';\nexport { Field } from './field';\n\nexport { FollowPromiseOne, FollowPromiseMany } from './follow-promise';\n"],"names":["root","factory","exports","module","define","amd","self","ReflectOwnKeys","R","Reflect","ReflectApply","apply","target","receiver","args","Function","prototype","call","ownKeys","Object","getOwnPropertySymbols","getOwnPropertyNames","concat","NumberIsNaN","Number","isNaN","value","EventEmitter","init","this","once","emitter","name","Promise","resolve","reject","errorListener","err","removeListener","resolver","slice","arguments","eventTargetAgnosticAddListener","handler","flags","on","addErrorHandlerIfEventEmitter","_events","undefined","_eventsCount","_maxListeners","defaultMaxListeners","checkListener","listener","TypeError","_getMaxListeners","that","_addListener","type","prepend","m","events","existing","warning","create","newListener","emit","unshift","push","length","warned","w","Error","String","count","console","warn","onceWrapper","fired","wrapFn","_onceWrap","state","wrapped","bind","_listeners","unwrap","evlistener","arr","ret","Array","i","unwrapListeners","arrayClone","listenerCount","n","copy","addEventListener","wrapListener","arg","removeEventListener","defineProperty","enumerable","get","set","RangeError","getPrototypeOf","setMaxListeners","getMaxListeners","doError","error","er","message","context","len","listeners","addListener","prependListener","prependOnceListener","list","position","originalListener","shift","index","pop","spliceOne","off","removeAllListeners","key","keys","rawListeners","eventNames","t","e","encode","btoa","r","constructor","super","oauth2Code","httpCode","default","grantType","accessToken","options","refreshToken","expiresAt","token","activeRefresh","refreshTimer","scheduleRefresh","async","Request","fetchMw","fetch","getAccessToken","clone","headers","o","ok","status","Date","now","getToken","onAuthError","clearTimeout","setTimeout","objToQueryString","s","entries","map","encodeURIComponent","join","c","grant_type","refresh_token","clientSecret","client_id","clientId","scope","username","userName","password","code","redirect_uri","redirectUri","code_verifier","codeVerifier","a","h","Authorization","u","tokenEndpoint","method","body","f","json","error_description","statusText","l","access_token","expires_in","onTokenUpdate","OAuth2Error","OAuth2","fetchMwOAuth2","COMPATIBLE_ENCODING_PATTERN","WS_TRIM_PATTERN","WS_CHAR_PATTERN","WS_FOLD_PATTERN","DELIMITER_PATTERN","WS_DELIMITER_PATTERN","TOKEN_PATTERN","trim","replace","hasWhitespace","test","skipWhitespace","offset","needsQuotes","Link","refs","parse","rel","links","toLowerCase","attr","link","has","ref","expandRelations","end","indexOf","uri","attrValue","isSingleOccurenceAttr","parseExtendedValue","isArray","toString","reduce","formatAttribute","isCompatibleEncoding","isTokenAttr","escapeQuotes","split","assign","parts","exec","language","encoding","decodeURIComponent","formatExtendedAttribute","data","toUpperCase","Buffer","isBuffer","item","regexp","string","charCodeAt","encoded","QueryString","qsUnescape","decodeSpaces","unescapeBuffer","hexchar","out","inIndex","outIndex","NaN","unescape","hexTable","escape","str","lastPos","c2","URIError","stringifyPrimitive","v","isFinite","decodeStr","decoder","stringify","obj","sep","eq","flast","fields","k","ks","vlen","vlast","j","decode","qs","eqLen","sepLen","maxKeys","pairs","Infinity","customDecode","sepIdx","eqIdx","keyEncoded","valEncoded","encodeCheck","curValue","client","formInfo","formData","URL","search","go","contentType","JSON","response","fetcher","fetchOrThrow","getStateForResponse","ActionNotFound","cache","Map","store","delete","clear","ForeverCache","ShortCache","NeverCache","cacheTimeout","activeTimers","setTimer","expandCacheDependencies","uris","dependencies","output","Set","add","flattenState","result","embedded","getEmbedded","bookmarkUri","contentTypeMap","halStateFactory","jsonApiStateFactory","sirenStateFactory","cjStateFactory","htmlStateFactory","cacheDependencies","Fetcher","use","resources","follow","variables","absoluteUri","resource","middleware","origin","clearCache","cacheState","newStates","nState","invByLink","getMany","addCacheDependency","targetUri","dependentUri","clearResourceCache","staleUris","deletedUris","stale","deleted","parseContentType","startsWith","textStateFactory","match","binaryStateFactory","FollowPromise","prefetchEnabled","preferTranscludeEnabled","useHeadEnabled","preFetch","preferTransclude","useHead","FollowPromiseOne","then","onfulfilled","onrejected","fetchLinkedResource","catch","finally","onfinally","followAll","FollowPromiseMany","Prefer","head","newResource","fetchLinkedResources","basicAuthHeader","base64","request","next","bearerAuthHeader","HttpError","Problem","problemBody","title","middlewares","advertiseKetting","url","mws","getMiddlewaresByOrigin","innerRequest","invokeMiddlewares","filter","regex","mw","matchRegex","part","RegExp","nextRequest","oauth2Options","oauth2","includes","header","Links","httpLink","LinkHeader","href","hreflang","safeMethods","entityHeaderNames","defaultContext","getAll","arg1","arg2","absHref","values","LinkNotFound","acceptHeader","q","noStaleEvent","isSafeMethod","cl","clState","sunset","msg","Resource","getOptions","getCache","params","optionsToRequestInit","hash","requestHash","updateCache","headOptions","headStateFactory","refresh","requestInit","isState","Headers","getContentHeaders","serializeBody","needsJsonStringify","forEach","BaseHeadState","timestamp","templated","expand","hints","contentHeaders","contentHeader","BaseState","actionInfo","actions","action","SimpleAction","hasAction","g","Blob","blob","parseLink","CjState","contextUri","collection","items","queries","query","property","parseCjLinks","_embedded","_links","newBody","HalState","serializeLinks","attributes","parseHalLinks","foundLinks","relType","linkList","parseHalLink","innerBodies","innerBody","parseHalEmbedded","embeddedList","embeddedItem","embeddedSelf","parseHalForms","_templates","hf","properties","prop","halField","baseField","label","prompt","required","readOnly","multiple","selectedValues","labelField","promptField","valueField","inline","entry","dataSource","pattern","placeholder","placeHolder","minLength","maxLength","cols","rows","min","max","step","parseHalField","text","htmlResult","parseHtml","forms","form","id","enctype","formToAction","SirenState","input","parseJsonApiLink","linkValue","parseJsonApiLinks","member","selfLink","parseJsonApiCollection","parseSirenLinks","parseSirenLink","entities","subEntity","parseSirenSubEntityAsLink","rels","newLink","parseSirenEmbedded","entity","subState","parseSirenSubEntityAsEmbedded","selfHref","subEntityUrl","field","sirenFieldToField","parseSirenAction","linkFromTags","elements","node","getAttribute","formFromTags","doc","DOMParser","parseFromString","getElementsByTagName","arg3","template","vars","expanded","uriTemplate","base","relative","document","oldBase","oldHref","docHead","ourBase","appendChild","createElement","resolvedUrl","removeChild","host","__esModule","_a","_b","operator","modifier","extension","__assign","p","hasOwnProperty","__importDefault","mod","expandExpression","expandTemplate","pct_encode_1","encoders","UrlSafe","Restricted","ast","defaults","first","empty","named","OperatorConfigs","expression","config","strings","variable","present","pairs_1","expandValueExplode","_c","substring","expandValueSingle","expandVariable","peg$SyntaxError","expected","found","location","setPrototypeOf","peg$padEnd","targetLength","padString","repeat","child","parent","C","peg$subclass","format","sources","src","source","start","loc","line","column","filler","last","buildMessage","DESCRIBE_EXPECTATION_FNS","literal","expectation","literalEscape","escapedParts","classEscape","inverted","any","other","description","hex","ch","describeExpectation","descriptions","sort","describeExpected","describeFound","SyntaxError","peg$result","peg$FAILED","peg$source","grammarSource","peg$startRuleFunctions","peg$parsetemplate","peg$startRuleFunction","peg$r0","peg$r1","peg$r2","peg$r3","peg$r4","peg$e0","peg$literalExpectation","peg$e1","peg$e2","peg$classExpectation","peg$e3","peg$e4","peg$e5","peg$e6","peg$e7","peg$e8","peg$e9","peg$e10","peg$e11","peg$f2","hd","peg$currPos","peg$posDetailsCache","peg$maxFailPos","peg$maxFailExpected","startRule","ignoreCase","peg$computePosDetails","pos","details","peg$computeLocation","startPos","endPos","startPosDetails","endPosDetails","peg$fail","s1","s2","peg$parseliteral","peg$parseexpression","s0","s3","s4","charAt","peg$parseoperator","s5","rst","peg$parsevariable","peg$parsevariables","parseInt","peg$parsesubstr","peg$parselistMarker","peg$parseextension","__createBinding","k2","__setModuleDefault","__importStar","__exportStar","parseRule","grammar","AST","expander_1","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","globalThis","window"],"sourceRoot":""}