{"version":3,"file":"4342af58d7f43a0da4cedab2.js?3.6.14.7428b935c.1727745705662","mappings":";uHAsBA,IAAIA,EAA+B,WAC/B,SAASA,EAAcC,QACH,IAAZA,IAAsBA,EAAU,CAAC,GACrCC,KAAKC,SAAWF,CACpB,CA4CA,OA3CAG,OAAOC,eAAeL,EAAe,aAAc,CAC/CM,IAAK,WAGD,MAAO,CAAC,CACZ,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeL,EAAe,UAAW,CAC5CM,IAAK,WAGD,MAAO,CAAC,CACZ,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeL,EAAe,UAAW,CAC5CM,IAAK,WAGD,MAAO,CAAC,CACZ,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeL,EAAe,iBAAkB,CACnDM,IAAK,WAID,MAAO,CAAC,CACZ,EACAC,YAAY,EACZC,cAAc,IAElBR,EAAcS,UAAUC,KAAO,WAE/B,EACAV,EAAcS,UAAUE,QAAU,WAElC,EACOX,CACX,CAjDkC,yECG9BY,EAA0B,CAAC,QAAS,SAAU,WAAY,UAI1DC,EAAmC,SAAUC,GAE7C,SAASD,EAAkBZ,GACvB,IAAIc,EAAQD,EAAOE,KAAKd,KAAM,KAAiB,CAAC,EAAGW,EAAkBI,eAAgBhB,KAAaC,KAUlG,OATAa,EAAMG,YAAa,EACnBH,EAAMI,aAAc,EACpBJ,EAAMK,wBAAyB,EAC/BL,EAAMM,eAAiB,iBACvBN,EAAMO,kBAAoB,iBAC1BP,EAAMQ,oBAAqB,EAC3BR,EAAMS,sBAAwB,KAC9BT,EAAMU,iBAAkB,EACxBV,EAAMW,cAAe,EACdX,CACX,CA6YA,OA1ZA,KAAkBF,EAAmBC,GAcrCV,OAAOC,eAAeQ,EAAmB,UAAW,CAChDP,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeQ,EAAmB,aAAc,CACnDP,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeQ,EAAmB,UAAW,CAChDP,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeQ,EAAmB,iBAAkB,CACvDP,IAAK,WACD,MAAO,CACHqB,wBAAyB,WAAgC,EACzDC,iBAAkB,WAAgC,EAClDC,4BAA6B,WAAc,OAAO,IAAM,EACxDC,uBAAwB,WAAc,OAAO,CAAG,EAChDC,iBAAkB,WAAc,OAAO,CAAG,EAC1CC,mBAAoB,WAAc,OAAO,CAAO,EAChDC,gBAAiB,WAAc,OAAO,CAAO,EAC7CC,yBAA0B,WAAc,OAAO,CAAO,EACtDC,kBAAmB,WAAc,OAAO,CAAO,EAC/CC,cAAe,WAAc,OAAO,CAAO,EAC3CC,aAAc,WAAgC,EAC9CC,2BAA4B,WAAgC,EAC5DC,4BAA6B,WAAgC,EAC7DC,iCAAkC,WAAgC,EAClEC,+BAAgC,WAAgC,EAExE,EACAlC,YAAY,EACZC,cAAc,IAElBK,EAAkBJ,UAAUiC,OAAS,WACQ,IAArCxC,KAAKC,SAAS4B,qBAGd7B,KAAKC,SAAS6B,mBAAmB,GACjC9B,KAAKuB,iBAAkB,EAElBvB,KAAKC,SAAS8B,gBAAgB,KACnC/B,KAAKwB,cAAe,GAE5B,EAIAb,EAAkBJ,UAAUkC,aAAe,SAAUC,GACjD1C,KAAKgB,WAAa0B,CACtB,EAIA/B,EAAkBJ,UAAUoC,uBAAyB,SAAUD,GAC3D1C,KAAKiB,YAAcyB,CACvB,EAIA/B,EAAkBJ,UAAUqC,mBAAqB,SAAUF,GACvD1C,KAAKkB,uBAAyBwB,CAClC,EAIA/B,EAAkBJ,UAAUsC,qBAAuB,SAAUC,GACzD9C,KAAKqB,mBAAqByB,CAC9B,EACAnC,EAAkBJ,UAAUwC,iBAAmB,WAC3C,OAAO/C,KAAKmB,cAChB,EACAR,EAAkBJ,UAAUyC,iBAAmB,SAAUC,GAChDjD,KAAKkD,cAAcD,KAGpBjD,KAAKuB,gBACLvB,KAAKmD,oBAAoBF,GAEpBjD,KAAKwB,aACVxB,KAAKoD,iBAAiBH,GAGtBjD,KAAKqD,2BAA2BJ,GAExC,EAIAtC,EAAkBJ,UAAU+C,cAAgB,SAAUC,EAAGC,GACjDA,GAAiB,GACjBxD,KAAKC,SAASsC,+BAA+BiB,EAAe,IAEpE,EAIA7C,EAAkBJ,UAAUkD,eAAiB,SAAUF,EAAGC,GACtD,IAAI3C,EAAQb,KACRwD,GAAiB,GACjBxD,KAAKC,SAASsC,+BAA+BiB,EAAe,MAMhEE,YAAW,WACF7C,EAAMZ,SAASgC,qBAChBpB,EAAM8C,iCAEd,GAAG,EACP,EAIAhD,EAAkBJ,UAAUqD,cAAgB,SAAUC,EAAKC,EAAgBN,GACvE,IAAIO,EAA0B,cAAZF,EAAIG,KAAuC,KAAhBH,EAAII,QAC7CC,EAAwB,YAAZL,EAAIG,KAAqC,KAAhBH,EAAII,QACzCE,EAA2B,eAAZN,EAAIG,KAAwC,KAAhBH,EAAII,QAC/CG,EAA0B,cAAZP,EAAIG,KAAuC,KAAhBH,EAAII,QAC7CI,EAAqB,SAAZR,EAAIG,KAAkC,KAAhBH,EAAII,QACnCK,EAAoB,QAAZT,EAAIG,KAAiC,KAAhBH,EAAII,QACjCM,EAAsB,UAAZV,EAAIG,KAAmC,KAAhBH,EAAII,QACrCO,EAAsB,UAAZX,EAAIG,KAAmC,KAAhBH,EAAII,QACzC,GAAIjE,KAAKC,SAASiC,gBACVgC,GAAaI,GACbT,EAAIY,iBACJzE,KAAK0E,qBAEAN,GAAeC,KACpBR,EAAIY,iBACJzE,KAAK2E,yBAPb,CAWA,IAAIC,EAAe5E,KAAKC,SAAS2B,yBACjC,MAAsB,IAAlBgD,IACAA,EAAepB,GACI,GAFvB,CAQA,IAAIqB,EACJ,GAAK7E,KAAKiB,aAAemD,IAAkBpE,KAAKiB,aAAekD,EAC3DnE,KAAK8E,qBAAqBjB,GAC1BgB,EAAY7E,KAAK+E,iBAAiBH,QAEjC,GAAK5E,KAAKiB,aAAeiD,IAAgBlE,KAAKiB,aAAe8C,EAC9D/D,KAAK8E,qBAAqBjB,GAC1BgB,EAAY7E,KAAKgF,iBAAiBJ,QAEjC,GAAIP,EACLrE,KAAK8E,qBAAqBjB,GAC1BgB,EAAY7E,KAAK2E,yBAEhB,GAAIL,EACLtE,KAAK8E,qBAAqBjB,GAC1BgB,EAAY7E,KAAK0E,wBAEhB,IAAIH,GAAWC,IACZV,EAAgB,CAEhB,IAAImB,EAASpB,EAAIoB,OACjB,GAAIA,GAA6B,MAAnBA,EAAOC,SAAmBX,EACpC,OAEJvE,KAAK8E,qBAAqBjB,GACtB7D,KAAKmF,qBACLnF,KAAKoF,0BAA0BR,GAEnC5E,KAAKC,SAASkC,aAAayC,EAC/B,CAEJ5E,KAAKoB,kBAAoBwD,OACPS,IAAdR,IACA7E,KAAKsF,oBAAoBT,GACzB7E,KAAKoB,kBAAoByD,EAnC7B,CATA,CA8CJ,EAIAlE,EAAkBJ,UAAUgF,YAAc,SAAUtC,EAAOuC,GACnDvC,IAAU,mBAGVjD,KAAKmF,qBACLnF,KAAKoF,0BAA0BnC,EAAOuC,GAE1CxF,KAAKC,SAASkC,aAAac,GAC3BjD,KAAKsF,oBAAoBrC,GACzBjD,KAAKoB,kBAAoB6B,EAC7B,EAIAtC,EAAkBJ,UAAUwE,iBAAmB,SAAU9B,GACrD,IACI4B,EAAY5B,EAAQ,EACxB,GAAI4B,GAFQ7E,KAAKC,SAAS4B,mBAEF,CACpB,IAAI7B,KAAKgB,WAKL,OAAOiC,EAJP4B,EAAY,CAMpB,CAEA,OADA7E,KAAKC,SAASyB,iBAAiBmD,GACxBA,CACX,EAIAlE,EAAkBJ,UAAUyE,iBAAmB,SAAU/B,GACrD,IAAIwC,EAAYxC,EAAQ,EACxB,GAAIwC,EAAY,EAAG,CACf,IAAIzF,KAAKgB,WAKL,OAAOiC,EAJPwC,EAAYzF,KAAKC,SAAS4B,mBAAqB,CAMvD,CAEA,OADA7B,KAAKC,SAASyB,iBAAiB+D,GACxBA,CACX,EACA9E,EAAkBJ,UAAUoE,kBAAoB,WAE5C,OADA3E,KAAKC,SAASyB,iBAAiB,GACxB,CACX,EACAf,EAAkBJ,UAAUmE,iBAAmB,WAC3C,IAAIgB,EAAY1F,KAAKC,SAAS4B,mBAAqB,EAEnD,OADA7B,KAAKC,SAASyB,iBAAiBgE,GACxBA,CACX,EAKA/E,EAAkBJ,UAAUuE,qBAAuB,SAAUjB,GACzD,IACIqB,GAAW,GADFrB,EAAIoB,OACUC,SAASS,eACc,IAA9CjF,EAAwBkF,QAAQV,IAChCrB,EAAIY,gBAEZ,EACA9D,EAAkBJ,UAAU8C,2BAA6B,SAAUJ,GAC/D,GAAIjD,KAAKmB,iBAAmB8B,EAA5B,CAGA,IAAI4C,EAAoB,8BACpB7F,KAAKqB,qBACLwE,EAAoB,gCAEpB7F,KAAKmB,iBAAmB,kBACxBnB,KAAKC,SAASmC,2BAA2BpC,KAAKmB,eAAgB0E,GAElE7F,KAAKC,SAASwB,wBAAwBwB,EAAO4C,GAC7C7F,KAAK8F,kCAAkC7C,GACvCjD,KAAKmB,eAAiB8B,CAVtB,CAWJ,EAIAtC,EAAkBJ,UAAUuF,kCAAoC,SAAU7C,GAElEjD,KAAKmB,iBAAmB,mBACxBnB,KAAKsB,sBACDtB,KAAKC,SAAS0B,4BAA4BsB,EAAO,oBAEzD,IAAI8C,EAA+C,OAA/B/F,KAAKsB,sBACrB0E,EAAgBD,EAAgB,kBAAuB,mBACvD/F,KAAKmB,iBAAmB,kBACxBnB,KAAKC,SAASoC,4BAA4BrC,KAAKmB,eAAgB6E,EAAe,SAElF,IAAIC,EAAqBF,EAAgB/F,KAAKsB,sBAAwB,OACtEtB,KAAKC,SAASoC,4BAA4BY,EAAO+C,EAAeC,EACpE,EAIAtF,EAAkBJ,UAAU6C,iBAAmB,SAAUH,GACrDjD,KAAKC,SAASqC,iCAAiCW,GAAO,GAClDjD,KAAKmB,iBAAmB,kBACxBnB,KAAKC,SAASoC,4BAA4BrC,KAAKmB,eAAgB,kBAAsB,SAEzFnB,KAAKC,SAASoC,4BAA4BY,EAAO,kBAAsB,QACvEjD,KAAKmB,eAAiB8B,CAC1B,EACAtC,EAAkBJ,UAAU4C,oBAAsB,SAAUF,GACxD,IAAK,IAAIiD,EAAI,EAAGA,EAAIlG,KAAKC,SAAS4B,mBAAoBqE,IAAK,CACvD,IAAIC,GAAY,EACZlD,EAAM2C,QAAQM,IAAM,IACpBC,GAAY,GAEhBnG,KAAKC,SAASqC,iCAAiC4D,EAAGC,GAClDnG,KAAKC,SAASoC,4BAA4B6D,EAAG,kBAAsBC,EAAY,OAAS,QAC5F,CACAnG,KAAKmB,eAAiB8B,CAC1B,EACAtC,EAAkBJ,UAAU+E,oBAAsB,SAAUrC,GACpDjD,KAAKoB,oBAAsB,kBAAiC,IAAV6B,EAGlDjD,KAAKC,SAASoC,4BAA4B,EAAG,WAAY,MAEpDrC,KAAKoB,mBAAqB,GAAKpB,KAAKoB,oBAAsB6B,GAC/DjD,KAAKC,SAASoC,4BAA4BrC,KAAKoB,kBAAmB,WAAY,MAElFpB,KAAKC,SAASoC,4BAA4BY,EAAO,WAAY,IACjE,EAIAtC,EAAkBJ,UAAU4E,kBAAoB,WAC5C,OAAOnF,KAAKkB,wBAA0BlB,KAAKuB,iBAAmBvB,KAAKwB,YACvE,EACAb,EAAkBJ,UAAUoD,gCAAkC,WAC1D,IAAIyC,EAAc,EACdpG,KAAKmF,sBAC8B,iBAAxBnF,KAAKmB,gBAA+BnB,KAAKmB,iBAAmB,iBACnEiF,EAAcpG,KAAKmB,eAEAnB,KAAKmB,0BAlWJkF,OAkWuBrG,KAAKmB,eAAemF,OAAS,IACxEF,EAAcpG,KAAKmB,eAAeoF,QAAO,SAAU3B,EAAc4B,GAAY,OAAOC,KAAKC,IAAI9B,EAAc4B,EAAW,MAG9HxG,KAAKsF,oBAAoBc,EAC7B,EACAzF,EAAkBJ,UAAU2C,cAAgB,SAAUD,GAClD,IAAIpC,EAAQb,KACZ,GAAIiD,aAAiBoD,MAAO,CACxB,IAAKrG,KAAKuB,gBACN,MAAM,IAAIoF,MAAM,+EAEpB,OAAqB,IAAjB1D,EAAMqD,QAICrD,EAAM2D,MAAK,SAAUV,GAAK,OAAOrF,EAAMgG,gBAAgBX,EAAI,GAE1E,CACK,GAAqB,iBAAVjD,EAAoB,CAChC,GAAIjD,KAAKuB,gBACL,MAAM,IAAIoF,MAAM,sFAAwF1D,GAE5G,OAAOjD,KAAK6G,gBAAgB5D,EAChC,CAEI,OAAO,CAEf,EACAtC,EAAkBJ,UAAUsG,gBAAkB,SAAU5D,GACpD,IAAI6D,EAAW9G,KAAKC,SAAS4B,mBAC7B,OAAOoB,GAAS,GAAKA,EAAQ6D,CACjC,EACAnG,EAAkBJ,UAAU6E,0BAA4B,SAAUnC,EAAOuC,QAC9C,IAAnBA,IAA6BA,GAAiB,GAC9CxF,KAAKuB,gBACLvB,KAAK+G,uBAAuB9D,EAAOuC,GAGnCxF,KAAKgD,iBAAiBC,EAE9B,EACAtC,EAAkBJ,UAAUwG,uBAAyB,SAAU9D,EAAOuC,GAClE,IAAIW,EAAYnG,KAAKC,SAAS+B,yBAAyBiB,GACnDuC,IACAW,GAAaA,EACbnG,KAAKC,SAASqC,iCAAiCW,EAAOkD,IAE1DnG,KAAKC,SAASoC,4BAA4BY,EAAO,kBAAsBkD,EAAY,OAAS,SAE5F,IAAIa,EAAkBhH,KAAKmB,iBAAmB,iBAAsB,GAAKnB,KAAKmB,eAAe8F,QACzFd,EACAa,EAAgBE,KAAKjE,GAGrB+D,EAAkBA,EAAgBG,QAAO,SAAUjB,GAAK,OAAOA,IAAMjD,CAAO,IAEhFjD,KAAKmB,eAAiB6F,CAC1B,EACOrG,CACX,CA5ZsC,CA4ZpC,2EChaEyG,EAA0C,SAAUxG,GAEpD,SAASwG,EAAyBrH,GAC9B,IAAIc,EAAQD,EAAOE,KAAKd,KAAM,KAAiB,CAAC,EAAGoH,EAAyBrG,eAAgBhB,KAAaC,KAWzG,OAVAa,EAAMwG,SAAU,EAChBxG,EAAMyG,cAAe,EACrBzG,EAAM0G,mBAAoB,EAC1B1G,EAAM2G,kBAAmB,EACzB3G,EAAM4G,yBAA2B,EACjC5G,EAAM6G,0BAA4B,EAClC7G,EAAM8G,oBAAsB,EAC5B9G,EAAM+G,cAAgB,eACtB/G,EAAMgH,cAAgB,CAAEC,IAAK,EAAGC,MAAO,EAAGC,OAAQ,EAAGC,KAAM,GAC3DpH,EAAMqH,UAAY,CAAEC,EAAG,EAAGC,EAAG,GACtBvH,CACX,CAmZA,OAjaA,KAAkBuG,EAA0BxG,GAe5CV,OAAOC,eAAeiH,EAA0B,aAAc,CAC1DhH,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeiH,EAA0B,UAAW,CACvDhH,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeiH,EAA0B,UAAW,CACvDhH,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeiH,EAA0B,SAAU,CACtDhH,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeiH,EAA0B,iBAAkB,CAI9DhH,IAAK,WAED,MAAO,CACHiI,SAAU,WAAgC,EAC1CC,YAAa,WAAgC,EAC7CC,SAAU,WAAc,OAAO,CAAO,EACtCC,UAAW,WAAc,OAAO,CAAO,EACvCC,qBAAsB,WAAc,OAAO,CAAO,EAClDC,UAAW,WAAc,OAAO,CAAO,EACvCC,MAAO,WAAc,OAAO,CAAO,EACnCC,mBAAoB,WAAc,MAAO,CAAGC,OAAQ,EAAGC,MAAO,EAAM,EACpEC,oBAAqB,WAAc,OAAO,IAAM,EAChDC,oBAAqB,WAAc,MAAO,CAAGH,OAAQ,EAAGC,MAAO,EAAM,EACrEG,kBAAmB,WAAc,MAAO,CAAGJ,OAAQ,EAAGC,MAAO,EAAM,EACnEI,gBAAiB,WAAc,MAAO,CAAGf,EAAG,EAAGC,EAAG,EAAM,EACxDe,YAAa,WAAgC,EAC7CC,aAAc,WAAgC,EAC9CC,mBAAoB,WAAgC,EACpDC,UAAW,WAAgC,EAC3CC,aAAc,WAAgC,EAC9CC,YAAa,WAAgC,EAC7CC,WAAY,WAAgC,EAGpD,EACApJ,YAAY,EACZC,cAAc,IAElB8G,EAAyB7G,UAAUC,KAAO,WACtC,IAAIkJ,EAAKtC,EAAyBuC,WAAYC,EAAOF,EAAGE,KAAMC,EAAOH,EAAGG,KACxE,IAAK7J,KAAKC,SAASsI,SAASqB,GACxB,MAAM,IAAIjD,MAAMiD,EAAO,oCAEvB5J,KAAKC,SAASsI,SAASsB,KACvB7J,KAAKqH,SAAU,EAEvB,EACAD,EAAyB7G,UAAUE,QAAU,WACzCqJ,aAAa9J,KAAKyH,0BAClBqC,aAAa9J,KAAK0H,2BAElBqC,qBAAqB/J,KAAK2H,oBAC9B,EAIAP,EAAyB7G,UAAUyJ,gBAAkB,SAAUC,GAC3DjK,KAAK4H,cAAgBqC,CACzB,EAIA7C,EAAyB7G,UAAU2J,gBAAkB,SAAUC,GAC3DnK,KAAK6H,cAAcC,IAAMqC,EAAOrC,KAAO,EACvC9H,KAAK6H,cAAcE,MAAQoC,EAAOpC,OAAS,EAC3C/H,KAAK6H,cAAcG,OAASmC,EAAOnC,QAAU,EAC7ChI,KAAK6H,cAAcI,KAAOkC,EAAOlC,MAAQ,CAC7C,EAEAb,EAAyB7G,UAAU6J,aAAe,SAAUC,GACxDrK,KAAKuH,kBAAoB8C,CAC7B,EAEAjD,EAAyB7G,UAAU+J,iBAAmB,SAAUC,GAC5DvK,KAAKwH,iBAAmB+C,CAC5B,EAEAnD,EAAyB7G,UAAUiK,oBAAsB,SAAUrC,EAAGC,GAClEpI,KAAKkI,UAAUC,EAAInI,KAAKyK,UAAUtC,GAAKA,EAAI,EAC3CnI,KAAKkI,UAAUE,EAAIpI,KAAKyK,UAAUrC,GAAKA,EAAI,CAC/C,EACAhB,EAAyB7G,UAAUmK,aAAe,SAAUC,GACxD3K,KAAKsH,aAAeqD,CACxB,EACAvD,EAAyB7G,UAAUqK,OAAS,WACxC,OAAO5K,KAAKqH,OAChB,EAIAD,EAAyB7G,UAAUsK,KAAO,WACtC,IAAIhK,EAAQb,KACZA,KAAKC,SAASqJ,YACTtJ,KAAKsH,cACNtH,KAAKC,SAASoI,SAASjB,EAAyBuC,WAAWmB,gBAE/D9K,KAAK2H,oBAAsBoD,uBAAsB,WAC7ClK,EAAMZ,SAASoI,SAASjB,EAAyBuC,WAAWE,MAC5DhJ,EAAMmK,YAAcnK,EAAMZ,SAAS2I,qBACnC/H,EAAMoK,gBACFpK,EAAMyG,aACNzG,EAAMZ,SAASwJ,aAGf5I,EAAM4G,yBAA2B/D,YAAW,WACxC7C,EAAM4G,yBAA2B,EACjC5G,EAAMZ,SAASqI,YAAYlB,EAAyBuC,WAAWmB,gBAC/DjK,EAAMZ,SAASwJ,YACnB,GAAG,8BAEX,IACAzJ,KAAKqH,SAAU,CACnB,EAIAD,EAAyB7G,UAAU2K,MAAQ,SAAUC,GACjD,IAAItK,EAAQb,UACa,IAArBmL,IAA+BA,GAAmB,GACjDnL,KAAKsH,cACNtH,KAAKC,SAASoI,SAASjB,EAAyBuC,WAAWyB,kBAE/DL,uBAAsB,WAClBlK,EAAMZ,SAASqI,YAAYlB,EAAyBuC,WAAWE,MAC3DhJ,EAAMyG,aACNzG,EAAMZ,SAASuJ,cAGf3I,EAAM6G,0BAA4BhE,YAAW,WACzC7C,EAAM6G,0BAA4B,EAClC7G,EAAMZ,SAASqI,YAAYlB,EAAyBuC,WAAWyB,kBAC/DvK,EAAMZ,SAASuJ,aACnB,GAAG,+BAEX,IACAxJ,KAAKqH,SAAU,EACV8D,GACDnL,KAAKqL,oBAEb,EAEAjE,EAAyB7G,UAAU+K,gBAAkB,SAAUzH,GAC3D,IAAI0H,EAAK1H,EAAIoB,OACTjF,KAAKC,SAASwI,qBAAqB8C,IAGvCvL,KAAKkL,OACT,EAEA9D,EAAyB7G,UAAUqD,cAAgB,SAAUC,GACzD,IAAII,EAAUJ,EAAII,SACK,WADUJ,EAAIG,KACU,KAAZC,IAE/BjE,KAAKkL,OAEb,EACA9D,EAAyB7G,UAAU0K,cAAgB,WAC/C,IAAIvB,EAEJ1J,KAAKwL,cAAgBxL,KAAKyL,6BAC1B,IAAIxB,EAASjK,KAAK0L,mBACdC,EAAuB3L,KAAK4L,yBAAyB3B,GACrD4B,EAAoB7L,KAAK8L,QAAQ7B,EAAQ,aAAoB,SAAW,MACxE8B,EAAsB/L,KAAK8L,QAAQ7B,EAAQ,YAAmB,QAAU,OACxE+B,EAAmBhM,KAAKiM,2BAA2BhC,GACnDiC,EAAiBlM,KAAKmM,yBAAyBlC,GAC/CmC,EAAKpM,KAAKwL,cAAea,EAAaD,EAAGC,WAAYC,EAAcF,EAAGE,YACtEC,IAAY7C,EAAK,CAAC,GACfqC,GAAuBC,EAC1BtC,EAAGmC,GAAqBK,EACxBxC,GAEA2C,EAAWvD,MAAQwD,EAAYxD,MAAQ,0CACvCiD,EAAsB,WAGtB/L,KAAKuH,mBAAqBvH,KAAKwH,mBAC/BxH,KAAKwM,iCAAiCD,GAE1CvM,KAAKC,SAASoJ,mBAAmB0C,EAAsB,IAAMF,GAC7D7L,KAAKC,SAASkJ,YAAYoD,GAC1BvM,KAAKC,SAASmJ,aAAauC,EAAuBA,EAAuB,KAAO,GACpF,EAIAvE,EAAyB7G,UAAUkL,2BAA6B,WAC5D,IAAIgB,EAAazM,KAAKC,SAAS8I,sBAC3B2D,EAAW1M,KAAKC,SAASgJ,oBACzB0D,EAAe3M,KAAKC,SAAS+I,sBAC7B4D,EAAe5M,KAAKC,SAASiJ,kBAajC,OAZKuD,IAEDA,EAAa,CACT3E,IAAK9H,KAAKkI,UAAUE,EACpBL,MAAO/H,KAAKkI,UAAUC,EACtBH,OAAQhI,KAAKkI,UAAUE,EACvBH,KAAMjI,KAAKkI,UAAUC,EACrBW,MAAO,EACPD,OAAQ,IAIT,CACHwD,WAAYI,EACZC,SAAUA,EACVJ,YAAatM,KAAKgL,YAClB6B,iBAAkB,CAEd/E,IAAK2E,EAAW3E,IAChBC,MAAO4E,EAAa7D,MAAQ2D,EAAW1E,MACvCC,OAAQ2E,EAAa9D,OAAS4D,EAAWzE,OACzCC,KAAMwE,EAAWxE,MAErB0E,aAAcA,EACdC,aAAcA,EAEtB,EAIAxF,EAAyB7G,UAAUmL,iBAAmB,WAElD,IAAIzB,EAAS,cACTP,EAAK1J,KAAKwL,cAAeqB,EAAmBnD,EAAGmD,iBAAkBR,EAAa3C,EAAG2C,WAAYC,EAAc5C,EAAG4C,YAC9GQ,EAAkB9M,KAAK8L,QAAQ9L,KAAK4H,cAAe,aACnDmF,EAAeD,EAAkBD,EAAiB/E,IAAMuE,EAAWxD,OAAS7I,KAAK6H,cAAcG,OAC7F6E,EAAiB/E,IAAM9H,KAAK6H,cAAcC,IAC5CkF,EAAkBF,EAAkBD,EAAiB7E,OAAShI,KAAK6H,cAAcG,OAC/E6E,EAAiB7E,OAASqE,EAAWxD,OAAS7I,KAAK6H,cAAcC,IACnEmF,EAAcX,EAAYzD,OAASkE,EACnCG,EAAiBZ,EAAYzD,OAASmE,EACtCE,EAAiB,GAAKD,EAAcC,IACpCjD,EAASjK,KAAKmN,QAAQlD,EAAQ,cAElC,IAAItB,EAAQ3I,KAAKC,SAAS0I,QACtByE,EAAYpN,KAAK8L,QAAQ9L,KAAK4H,cAAe,eAC7CyF,EAAyBrN,KAAK8L,QAAQ9L,KAAK4H,cAAe,YAC1D0F,EAAkBD,IAA2B1E,IAC3C0E,GAA0BD,GAAazE,EACzC4E,EAAgBD,EAAiBT,EAAiB5E,KAAOoE,EAAWvD,MAAQ9I,KAAK6H,cAAcE,MAC/F8E,EAAiB5E,KAAOjI,KAAK6H,cAAcI,KAC3CuF,EAAiBF,EAAiBT,EAAiB9E,MAAQ/H,KAAK6H,cAAcE,MAC9E8E,EAAiB9E,MAAQsE,EAAWvD,MAAQ9I,KAAK6H,cAAcI,KAC/DwF,EAAenB,EAAYxD,MAAQyE,EACnCG,EAAgBpB,EAAYxD,MAAQ0E,EAMxC,OALKC,EAAe,GAAKH,GAAkB3E,GACtC0E,IAA2BC,GAAkBG,EAAe,GAC5DC,EAAgB,GAAKD,EAAeC,KACrCzD,EAASjK,KAAKmN,QAAQlD,EAAQ,aAE3BA,CACX,EAKA7C,EAAyB7G,UAAUqL,yBAA2B,SAAU3B,GACpE,IAAI4C,EAAmB7M,KAAKwL,cAAcqB,iBACtCc,EAAY,EACZb,EAAkB9M,KAAK8L,QAAQ7B,EAAQ,aACvC2D,EAAmB5N,KAAK8L,QAAQ9L,KAAK4H,cAAe,aACpDiG,EAAiBzG,EAAyB0G,QAAQD,eAetD,OAbIf,GACAa,EAAYd,EAAiB/E,IAAM9H,KAAK6H,cAAcC,IAAM+F,EACvDD,IACDD,GAAa3N,KAAKwL,cAAca,WAAWxD,UAI/C8E,EACId,EAAiB7E,OAAShI,KAAK6H,cAAcG,OAAShI,KAAKwL,cAAca,WAAWxD,OAASgF,EAC7FD,IACAD,GAAa3N,KAAKwL,cAAca,WAAWxD,SAG5C8E,CACX,EAKAvG,EAAyB7G,UAAU0L,2BAA6B,SAAUhC,GACtE,IAAIoC,EAAarM,KAAKwL,cAAca,WAEhC0B,EAAiB/N,KAAK8L,QAAQ7B,EAAQ,YACtCoD,EAAyBrN,KAAK8L,QAAQ9L,KAAK4H,cAAe,YAC9D,GAAImG,EAAgB,CAChB,IAAIC,EAAcX,EAAyBhB,EAAWvD,MAAQ9I,KAAK6H,cAAcI,KAAOjI,KAAK6H,cAAcE,MAI3G,OAAI/H,KAAKuH,mBAAqBvH,KAAKwH,iBACxBwG,GAAehO,KAAKwL,cAAcmB,aAAa7D,MAAQ9I,KAAKwL,cAAckB,SAAS5D,OAEvFkF,CACX,CACA,OAAOX,EAAyBhB,EAAWvD,MAAQ9I,KAAK6H,cAAcE,MAAQ/H,KAAK6H,cAAcI,IACrG,EAKAb,EAAyB7G,UAAU4L,yBAA2B,SAAUlC,GACpE,IAAIoC,EAAarM,KAAKwL,cAAca,WAChCS,EAAkB9M,KAAK8L,QAAQ7B,EAAQ,aACvCgE,EAAuBjO,KAAK8L,QAAQ9L,KAAK4H,cAAe,aAQ5D,OANIkF,EACImB,EAAuB5B,EAAWxD,OAAS7I,KAAK6H,cAAcC,KAAO9H,KAAK6H,cAAcG,OAGxFiG,EAAwB5B,EAAWxD,OAAS7I,KAAK6H,cAAcG,OAAUhI,KAAK6H,cAAcC,GAGxG,EAEAV,EAAyB7G,UAAUiM,iCAAmC,SAAUD,GAC5E,IAAI2B,EAAKxE,EACL0C,EAAKpM,KAAKwL,cAAeoB,EAAeR,EAAGQ,aAAcC,EAAmBT,EAAGS,iBAC/EsB,EAAQjO,OAAOkO,KAAK7B,GACxB,IACI,IAAK,IAAI8B,EAAU,KAAiBF,GAAQG,EAAYD,EAAQE,QAASD,EAAUE,KAAMF,EAAYD,EAAQE,OAAQ,CACjH,IAAIE,EAAOH,EAAU5L,MACjBA,EAAQ6J,EAASkC,IAAS,EAG9B/L,GAASmK,EAAiB4B,GAGrBzO,KAAKwH,mBACO,QAATiH,EACA/L,GAASkK,EAAaxE,EAER,WAATqG,EACL/L,GAASkK,EAAaxE,EAER,SAATqG,EACL/L,GAASkK,EAAazE,EAGtBzF,GAASkK,EAAazE,GAG9BoE,EAASkC,GAAQ/L,CACrB,CACJ,CACA,MAAOgM,GAASR,EAAM,CAAES,MAAOD,EAAS,CACxC,QACI,IACQJ,IAAcA,EAAUE,OAAS9E,EAAK2E,EAAQO,SAASlF,EAAG5I,KAAKuN,EACvE,CACA,QAAU,GAAIH,EAAK,MAAMA,EAAIS,KAAO,CACxC,CACJ,EAKAvH,EAAyB7G,UAAU8K,mBAAqB,WACpD,IAAInJ,EAAgBlC,KAAKC,SAASyI,YAC9BmG,EAAgBC,SAASC,eAAiB/O,KAAKC,SAASwI,qBAAqBqG,SAASC,gBACtF7M,GAAiB2M,IACjB7O,KAAKC,SAASsJ,cAEtB,EACAnC,EAAyB7G,UAAUuL,QAAU,SAAU7B,EAAQ+E,GAC3D,OAAOC,QAAQhF,EAAS+E,EAC5B,EACA5H,EAAyB7G,UAAU4M,QAAU,SAAUlD,EAAQ+E,GAC3D,OAAO/E,EAAS+E,CACpB,EAKA5H,EAAyB7G,UAAUkK,UAAY,SAAUyE,GACrD,MAAsB,iBAARA,GAAoBC,SAASD,EAC/C,EACO9H,CACX,CAna6C,CAma3C,sFClaEgI,EAAmC,SAAUxO,GAE7C,SAASwO,EAAkBrP,GACvB,IAAIc,EAAQD,EAAOE,KAAKd,KAAM,KAAiB,CAAC,EAAGoP,EAAkBrO,eAAgBhB,KAAaC,KAGlG,OAFAa,EAAM6G,0BAA4B,EAClC7G,EAAMwO,mBAAqB,eACpBxO,CACX,CA4HA,OAlIA,KAAkBuO,EAAmBxO,GAOrCV,OAAOC,eAAeiP,EAAmB,aAAc,CACnDhP,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeiP,EAAmB,UAAW,CAChDhP,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeiP,EAAmB,UAAW,CAChDhP,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAeiP,EAAmB,iBAAkB,CAIvDhP,IAAK,WAED,MAAO,CACHkP,yBAA0B,WAAgC,EAC1DC,8BAA+B,WAAgC,EAC/DC,6BAA8B,WAAgC,EAC9DC,kCAAmC,WAAgC,EACnEC,qBAAsB,WAAc,OAAO,CAAO,EAClDC,aAAc,WAAgC,EAC9CC,gBAAiB,WAAc,OAAQ,CAAG,EAC1CC,eAAgB,WAAgC,EAChDC,iBAAkB,WAAc,OAAO,CAAG,EAC1CpO,iBAAkB,WAAgC,EAClDqO,cAAe,WAAgC,EAC/CC,gCAAiC,WAAc,OAAQ,CAAG,EAC1DC,wBAAyB,WAAc,OAAO,CAAO,EAG7D,EACA5P,YAAY,EACZC,cAAc,IAElB8O,EAAkB7O,UAAUE,QAAU,WAC9BT,KAAK0H,2BACLoC,aAAa9J,KAAK0H,2BAEtB1H,KAAKC,SAAS0P,cAClB,EACAP,EAAkB7O,UAAUqD,cAAgB,SAAUC,GAClD,IAAIG,EAAMH,EAAIG,IAAKC,EAAUJ,EAAII,SACb,QAARD,GAA6B,IAAZC,IAEzBjE,KAAKC,SAAS0P,cAAqC,EAE3D,EACAP,EAAkB7O,UAAU2P,iBAAmB,SAAUC,GACrD,IAAItP,EAAQb,KACRiD,EAAQjD,KAAKC,SAAS2P,gBAAgBO,GACtClN,EAAQ,IAGZjD,KAAKC,SAAS4P,eAAe,CAAE5M,MAAOA,IACtCjD,KAAKC,SAAS0P,eAEd3P,KAAK0H,0BAA4BhE,YAAW,WACpC7C,EAAMZ,SAASgQ,wBAAwBhN,IACvCpC,EAAMmC,iBAAiBC,EAE/B,GAAG,uCACP,EACAmM,EAAkB7O,UAAU6P,wBAA0B,WAClD,OAAQpQ,KAAKqP,oBACT,KAAK,gBACDrP,KAAKC,SAASyB,iBAAiB,GAC/B,MACJ,KAAK,eACD1B,KAAKC,SAASyB,iBAAiB1B,KAAKC,SAAS6P,mBAAqB,GAClE,MACJ,KAAK,UAED,MACJ,QACI9P,KAAKC,SAAS8P,gBAG1B,EAMAX,EAAkB7O,UAAU8P,qBAAuB,SAAUC,GACzDtQ,KAAKqP,mBAAqBiB,CAC9B,EAKAlB,EAAkB7O,UAAUyC,iBAAmB,SAAUC,GAErD,GADAjD,KAAKuQ,gBAAgBtN,IAChBjD,KAAKC,SAASgQ,wBAAwBhN,GACvC,MAAM,IAAI0D,MAAM,6DAEpB,IAAI6J,EAAoBxQ,KAAKC,SAAS+P,gCAAgC/M,GAClEuN,GAAqB,IACrBxQ,KAAKC,SAASwP,kCAAkCe,EAAmB,wBACnExQ,KAAKC,SAASsP,8BAA8BiB,EAAmB,+BAEnExQ,KAAKC,SAASqP,yBAAyBrM,EAAO,8BAC9CjD,KAAKC,SAASuP,6BAA6BvM,EAAO,uBAA2B,OACjF,EACAmM,EAAkB7O,UAAUgQ,gBAAkB,SAAUtN,GACpD,IAAIwN,EAAWzQ,KAAKC,SAAS6P,mBAE7B,KADqB7M,GAAS,GAAKA,EAAQwN,GAEvC,MAAM,IAAI9J,MAAM,sDAExB,EACOyI,CACX,CApIsC,CAoIpC,sFCnIEsB,EAAyB,CACzB,aAAc,cAAe,YAAa,WAG1CC,EAAmC,CACnC,WAAY,YAAa,UAAW,eAGpCC,EAAmB,GACnBC,EAAqC,SAAUjQ,GAE/C,SAASiQ,EAAoB9Q,GACzB,IAAIc,EAAQD,EAAOE,KAAKd,KAAM,KAAiB,CAAC,EAAG6Q,EAAoB9P,eAAgBhB,KAAaC,KAoBpG,OAnBAa,EAAMiQ,8BAA+B,EACrCjQ,EAAMkQ,iBAAmB,EACzBlQ,EAAMmQ,4BAA8B,EACpCnQ,EAAMoQ,SAAW,IACjBpQ,EAAMqQ,OAAS,CAAEpI,MAAO,EAAGD,OAAQ,GACnChI,EAAMsQ,aAAe,EACrBtQ,EAAMuQ,aAAe,EACrBvQ,EAAMwQ,WAAa,EACnBxQ,EAAMyQ,iBAAmB,CAAErJ,KAAM,EAAGH,IAAK,GACzCjH,EAAM0Q,iBAAmB1Q,EAAM2Q,0BAC/B3Q,EAAM4Q,yBAA2B,WAC7B5Q,EAAMiQ,8BAA+B,EACrCjQ,EAAM6Q,gCACV,EACA7Q,EAAM8Q,iBAAmB,SAAUC,GAAK,OAAO/Q,EAAMgR,UAAUD,EAAI,EACnE/Q,EAAMiR,mBAAqB,WAAc,OAAOjR,EAAMkR,aAAe,EACrElR,EAAMmR,cAAgB,WAAc,OAAOnR,EAAMoR,aAAe,EAChEpR,EAAMqR,aAAe,WAAc,OAAOrR,EAAMsR,YAAc,EAC9DtR,EAAMuR,eAAiB,WAAc,OAAOvR,EAAM2B,QAAU,EACrD3B,CACX,CA2YA,OAlaA,KAAkBgQ,EAAqBjQ,GAwBvCV,OAAOC,eAAe0Q,EAAqB,aAAc,CACrDzQ,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAe0Q,EAAqB,UAAW,CAClDzQ,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAe0Q,EAAqB,UAAW,CAClDzQ,IAAK,WACD,OAAO,IACX,EACAC,YAAY,EACZC,cAAc,IAElBJ,OAAOC,eAAe0Q,EAAqB,iBAAkB,CACzDzQ,IAAK,WACD,MAAO,CACHiI,SAAU,WAAgC,EAC1CgK,uBAAwB,WAAc,OAAO,CAAM,EACnDC,oBAAqB,WAAc,MAAO,CAAGxK,IAAK,EAAGC,MAAO,EAAGC,OAAQ,EAAGC,KAAM,EAAGa,MAAO,EAAGD,OAAQ,EAAM,EAC3G0J,oBAAqB,WAAc,OAAO,CAAM,EAChDC,qCAAsC,WAAgC,EACtEC,6BAA8B,WAAgC,EAC9DC,wBAAyB,WAAgC,EACzDC,oBAAqB,WAAc,MAAO,CAAGxK,EAAG,EAAGC,EAAG,EAAM,EAC5DwK,gBAAiB,WAAc,OAAO,CAAM,EAC5CC,kBAAmB,WAAc,OAAO,CAAM,EAC9CC,YAAa,WAAc,OAAO,CAAM,EACxCC,mCAAoC,WAAgC,EACpEC,2BAA4B,WAAgC,EAC5DC,sBAAuB,WAAgC,EACvD3K,YAAa,WAAgC,EAC7C4K,kBAAmB,WAAgC,EAE3D,EACA7S,YAAY,EACZC,cAAc,IAElBuQ,EAAoBtQ,UAAUC,KAAO,WACjC,IAAIK,EAAQb,KACRmT,EAAsBnT,KAAKoT,uBAE/B,GADApT,KAAKqT,sBAAsBF,GACvBA,EAAqB,CACrB,IAAIzJ,EAAKmH,EAAoBlH,WAAY2J,EAAS5J,EAAGE,KAAM2J,EAAc7J,EAAG8J,UAC5EzI,uBAAsB,WAClBlK,EAAMZ,SAASoI,SAASiL,GACpBzS,EAAMZ,SAAS6S,gBACfjS,EAAMZ,SAASoI,SAASkL,GAExB1S,EAAM4S,kBAEd,GACJ,CACJ,EACA5C,EAAoBtQ,UAAUE,QAAU,WACpC,IAAII,EAAQb,KACZ,GAAIA,KAAKoT,uBAAwB,CACzBpT,KAAK+Q,mBACLjH,aAAa9J,KAAK+Q,kBAClB/Q,KAAK+Q,iBAAmB,EACxB/Q,KAAKC,SAASqI,YAAYuI,EAAoBlH,WAAW+J,gBAEzD1T,KAAKgR,8BACLlH,aAAa9J,KAAKgR,6BAClBhR,KAAKgR,4BAA8B,EACnChR,KAAKC,SAASqI,YAAYuI,EAAoBlH,WAAWgK,kBAE7D,IAAIjK,EAAKmH,EAAoBlH,WAAYiK,EAASlK,EAAGE,KAAMiK,EAAcnK,EAAG8J,UAC5EzI,uBAAsB,WAClBlK,EAAMZ,SAASqI,YAAYsL,GAC3B/S,EAAMZ,SAASqI,YAAYuL,GAC3BhT,EAAMiT,gBACV,GACJ,CACA9T,KAAK+T,0BACL/T,KAAKgU,iCACT,EAIAnD,EAAoBtQ,UAAU0T,SAAW,SAAUpQ,GAC/C7D,KAAK6R,UAAUhO,EACnB,EACAgN,EAAoBtQ,UAAU2T,WAAa,WACvClU,KAAK+R,aACT,EACAlB,EAAoBtQ,UAAUiC,OAAS,WACnC,IAAI3B,EAAQb,KACRA,KAAKoR,cACLrH,qBAAqB/J,KAAKoR,cAE9BpR,KAAKoR,aAAerG,uBAAsB,WACtClK,EAAM4S,kBACN5S,EAAMuQ,aAAe,CACzB,GACJ,EACAP,EAAoBtQ,UAAU4T,aAAe,SAAUC,GACnD,IAAIZ,EAAY3C,EAAoBlH,WAAW6J,UAC3CY,EACApU,KAAKC,SAASoI,SAASmL,GAGvBxT,KAAKC,SAASqI,YAAYkL,EAElC,EACA3C,EAAoBtQ,UAAU0R,YAAc,WACxC,IAAIpR,EAAQb,KACZ+K,uBAAsB,WAClB,OAAOlK,EAAMZ,SAASoI,SAASwI,EAAoBlH,WAAW0K,WAClE,GACJ,EACAxD,EAAoBtQ,UAAU4R,WAAa,WACvC,IAAItR,EAAQb,KACZ+K,uBAAsB,WAClB,OAAOlK,EAAMZ,SAASqI,YAAYuI,EAAoBlH,WAAW0K,WACrE,GACJ,EAOAxD,EAAoBtQ,UAAU6S,qBAAuB,WACjD,OAAOpT,KAAKC,SAASoS,wBACzB,EACAxB,EAAoBtQ,UAAUiR,wBAA0B,WACpD,MAAO,CACH8C,qBAAiBjP,EACjBkP,sBAAsB,EACtBC,aAAa,EACbC,gBAAgB,EAChBC,uBAAuB,EACvBC,sBAAsB,EAE9B,EAIA9D,EAAoBtQ,UAAU8S,sBAAwB,SAAUF,GAC5D,IAAItS,EAAQb,KACRmT,IACAzC,EAAuBkE,SAAQ,SAAUC,GACrChU,EAAMZ,SAAS+S,2BAA2B6B,EAAShU,EAAM8Q,iBAC7D,IACI3R,KAAKC,SAAS6S,eACd9S,KAAKC,SAASgT,sBAAsBjT,KAAKoS,iBAGjDpS,KAAKC,SAAS+S,2BAA2B,QAAShT,KAAKgS,eACvDhS,KAAKC,SAAS+S,2BAA2B,OAAQhT,KAAKkS,aAC1D,EACArB,EAAoBtQ,UAAUuU,8BAAgC,SAAUjR,GACpE,IAAIhD,EAAQb,KACK,YAAb6D,EAAIkR,KACJ/U,KAAKC,SAAS+S,2BAA2B,QAAShT,KAAK8R,oBAGvDnB,EAAiCiE,SAAQ,SAAUC,GAC/ChU,EAAMZ,SAAS8S,mCAAmC8B,EAAShU,EAAMiR,mBACrE,GAER,EACAjB,EAAoBtQ,UAAUwT,wBAA0B,WACpD,IAAIlT,EAAQb,KACZ0Q,EAAuBkE,SAAQ,SAAUC,GACrChU,EAAMZ,SAASwS,6BAA6BoC,EAAShU,EAAM8Q,iBAC/D,IACA3R,KAAKC,SAASwS,6BAA6B,QAASzS,KAAKgS,eACzDhS,KAAKC,SAASwS,6BAA6B,OAAQzS,KAAKkS,cACpDlS,KAAKC,SAAS6S,eACd9S,KAAKC,SAASyS,wBAAwB1S,KAAKoS,eAEnD,EACAvB,EAAoBtQ,UAAUyT,gCAAkC,WAC5D,IAAInT,EAAQb,KACZA,KAAKC,SAASwS,6BAA6B,QAASzS,KAAK8R,oBACzDnB,EAAiCiE,SAAQ,SAAUC,GAC/ChU,EAAMZ,SAASuS,qCAAqCqC,EAAShU,EAAMiR,mBACvE,GACJ,EACAjB,EAAoBtQ,UAAUuT,eAAiB,WAC3C,IAAIjT,EAAQb,KACRgV,EAAgBnE,EAAoBoE,QAC7B/U,OAAOkO,KAAK4G,GAClBJ,SAAQ,SAAU5Q,GACS,IAAxBA,EAAI4B,QAAQ,SACZ/E,EAAMZ,SAASiT,kBAAkB8B,EAAchR,GAAM,KAE7D,GACJ,EACA6M,EAAoBtQ,UAAUsR,UAAY,SAAUhO,GAChD,IAAIhD,EAAQb,KACZ,IAAIA,KAAKC,SAAS4S,oBAAlB,CAGA,IAAIqC,EAAkBlV,KAAKuR,iBAC3B,IAAI2D,EAAgBV,YAApB,CAIA,IAAIW,EAA0BnV,KAAKoV,yBACXD,QAAmC9P,IAARxB,GAAqBsR,EAAwBJ,OAASlR,EAAIkR,OAI7GG,EAAgBV,aAAc,EAC9BU,EAAgBT,oBAAyBpP,IAARxB,EACjCqR,EAAgBZ,gBAAkBzQ,EAClCqR,EAAgBR,uBAAwBQ,EAAgBT,qBAAiCpP,IAARxB,IAAmC,cAAbA,EAAIkR,MAAqC,eAAblR,EAAIkR,MAAsC,gBAAblR,EAAIkR,WACpI1P,IAARxB,GAAqB+M,EAAiBtK,OAAS,GAAKsK,EAAiBhK,MAAK,SAAU3B,GAAU,OAAOpE,EAAMZ,SAASsS,oBAAoBtN,EAAS,IAGrKjF,KAAKqV,8BAGGhQ,IAARxB,IACA+M,EAAiB1J,KAAKrD,EAAIoB,QAC1BjF,KAAK8U,8BAA8BjR,IAEvCqR,EAAgBP,qBAAuB3U,KAAKsV,wBAAwBzR,GAChEqR,EAAgBP,sBAChB3U,KAAKuV,qBAETxK,uBAAsB,WAElB6F,EAAmB,GACdsE,EAAgBP,2BACNtP,IAARxB,GACa,MAAZA,EAAIG,KAA+B,KAAhBH,EAAII,UAO3BiR,EAAgBP,qBAAuB9T,EAAMyU,wBAAwBzR,GACjEqR,EAAgBP,sBAChB9T,EAAM0U,sBAGTL,EAAgBP,uBAEjB9T,EAAM0Q,iBAAmB1Q,EAAM2Q,0BAEvC,KA9CA,CAJA,CAmDJ,EACAX,EAAoBtQ,UAAU+U,wBAA0B,SAAUzR,GAC9D,YAAgBwB,IAARxB,GAAkC,YAAbA,EAAIkR,MAAsB/U,KAAKC,SAAS2S,iBACzE,EACA/B,EAAoBtQ,UAAUgV,mBAAqB,WAC/C,IAAI1U,EAAQb,KACR0J,EAAKmH,EAAoBoE,QAASO,EAAyB9L,EAAG8L,uBAAwBC,EAAuB/L,EAAG+L,qBAChHrJ,EAAKyE,EAAoBlH,WAAYgK,EAAkBvH,EAAGuH,gBAAiBD,EAAgBtH,EAAGsH,cAC9FgC,EAA0B7E,EAAoB/C,QAAQ4H,wBAC1D1V,KAAKyT,kBACL,IAAIkC,EAAiB,GACjBC,EAAe,GACnB,IAAK5V,KAAKC,SAAS6S,cAAe,CAC9B,IAAI+C,EAAK7V,KAAK8V,+BAAgCC,EAAaF,EAAGE,WAAYC,EAAWH,EAAGG,SACxFL,EAAiBI,EAAW5N,EAAI,OAAS4N,EAAW3N,EAAI,KACxDwN,EAAeI,EAAS7N,EAAI,OAAS6N,EAAS5N,EAAI,IACtD,CACApI,KAAKC,SAASiT,kBAAkBsC,EAAwBG,GACxD3V,KAAKC,SAASiT,kBAAkBuC,EAAsBG,GAEtD9L,aAAa9J,KAAK+Q,kBAClBjH,aAAa9J,KAAKgR,6BAClBhR,KAAKiW,8BACLjW,KAAKC,SAASqI,YAAYqL,GAE1B3T,KAAKC,SAASqS,sBACdtS,KAAKC,SAASoI,SAASqL,GACvB1T,KAAK+Q,iBAAmBrN,YAAW,WAAc,OAAO7C,EAAM4Q,0BAA4B,GAAGiE,EACjG,EACA7E,EAAoBtQ,UAAUuV,6BAA+B,WACzD,IACIC,EADArM,EAAK1J,KAAKuR,iBAAkB+C,EAAkB5K,EAAG4K,gBAoBrD,MAAO,CAAEyB,WARTA,EAAa,CACT5N,GAVA4N,EAH0FrM,EAAGgL,uBAGhF,OAAyBJ,EAAiBtU,KAAKC,SAAS0S,sBAAuB3S,KAAKC,SAASqS,uBAG7F,CACTnK,EAAGnI,KAAKkR,OAAOpI,MAAQ,EACvBV,EAAGpI,KAAKkR,OAAOrI,OAAS,IAKdV,EAAKnI,KAAKmR,aAAe,EACvC/I,EAAG2N,EAAW3N,EAAKpI,KAAKmR,aAAe,GAMV6E,SAJlB,CACX7N,EAAInI,KAAKkR,OAAOpI,MAAQ,EAAM9I,KAAKmR,aAAe,EAClD/I,EAAIpI,KAAKkR,OAAOrI,OAAS,EAAM7I,KAAKmR,aAAe,GAG3D,EACAN,EAAoBtQ,UAAUmR,+BAAiC,WAC3D,IAAI7Q,EAAQb,KAGR2T,EAAkB9C,EAAoBlH,WAAWgK,gBACjDjK,EAAK1J,KAAKuR,iBAAkBgD,EAAuB7K,EAAG6K,qBAAsBC,EAAc9K,EAAG8K,aACxED,IAAyBC,IACxBxU,KAAK8Q,+BAC3B9Q,KAAKiW,8BACLjW,KAAKC,SAASoI,SAASsL,GACvB3T,KAAKgR,4BAA8BtN,YAAW,WAC1C7C,EAAMZ,SAASqI,YAAYqL,EAC/B,GAAG,yBAEX,EACA9C,EAAoBtQ,UAAU0V,4BAA8B,WACxD,IAAIvC,EAAgB7C,EAAoBlH,WAAW+J,cACnD1T,KAAKC,SAASqI,YAAYoL,GAC1B1T,KAAK8Q,8BAA+B,EACpC9Q,KAAKC,SAASqS,qBAClB,EACAzB,EAAoBtQ,UAAU8U,sBAAwB,WAClD,IAAIxU,EAAQb,KACZA,KAAKoV,yBAA2BpV,KAAKuR,iBAAiB+C,gBACtDtU,KAAKuR,iBAAmBvR,KAAKwR,0BAG7B9N,YAAW,WAAc,OAAO7C,EAAMuU,8BAA2B/P,CAAW,GAAGwL,EAAoB/C,QAAQoI,aAC/G,EACArF,EAAoBtQ,UAAUwR,YAAc,WACxC,IAAIlR,EAAQb,KACRkV,EAAkBlV,KAAKuR,iBAE3B,GAAK2D,EAAgBV,YAArB,CAGA,IAAI2B,EAAQ,KAAiB,CAAC,EAAGjB,GAC7BA,EAAgBT,gBAChB1J,uBAAsB,WAAc,OAAOlK,EAAMuV,qBAAqBD,EAAQ,IAC9EnW,KAAKqV,0BAGLrV,KAAKgU,kCACLjJ,uBAAsB,WAClBlK,EAAM0Q,iBAAiBgD,sBAAuB,EAC9C1T,EAAMuV,qBAAqBD,GAC3BtV,EAAMwU,uBACV,IAZJ,CAcJ,EACAxE,EAAoBtQ,UAAU6V,qBAAuB,SAAU1M,GAC3D,IAAIgL,EAAwBhL,EAAGgL,sBAAuBC,EAAuBjL,EAAGiL,sBAC5ED,GAAyBC,IACzB3U,KAAK0R,gCAEb,EACAb,EAAoBtQ,UAAUkT,gBAAkB,WAE5CzT,KAAKkR,OAASlR,KAAKC,SAASqS,sBAC5B,IAAI+D,EAAS5P,KAAK6P,IAAItW,KAAKkR,OAAOrI,OAAQ7I,KAAKkR,OAAOpI,OAWtD9I,KAAKqR,WAAarR,KAAKC,SAAS6S,cAAgBuD,EAH3B5P,KAAK8P,KAAK9P,KAAK+P,IAVxBxW,KAUkCkR,OAAOpI,MAAO,GAAKrC,KAAK+P,IAV1DxW,KAUoEkR,OAAOrI,OAAQ,IACvEgI,EAAoB/C,QAAQ2I,QAIpDzW,KAAKmR,aAAe1K,KAAKiQ,MAAML,EAASxF,EAAoB/C,QAAQ6I,sBACpE3W,KAAKiR,SAAW,GAAKjR,KAAKqR,WAAarR,KAAKmR,aAC5CnR,KAAK4W,sBACT,EACA/F,EAAoBtQ,UAAUqW,qBAAuB,WACjD,IAAIlN,EAAKmH,EAAoBoE,QAAS4B,EAAcnN,EAAGmN,YAAaC,EAAWpN,EAAGoN,SAAUC,EAAUrN,EAAGqN,QAASC,EAAetN,EAAGsN,aACpIhX,KAAKC,SAASiT,kBAAkB2D,EAAa7W,KAAKmR,aAAe,MACjEnR,KAAKC,SAASiT,kBAAkB8D,EAAchX,KAAKiR,UAC/CjR,KAAKC,SAAS6S,gBACd9S,KAAKsR,iBAAmB,CACpBrJ,KAAMxB,KAAKwQ,MAAOjX,KAAKkR,OAAOpI,MAAQ,EAAM9I,KAAKmR,aAAe,GAChErJ,IAAKrB,KAAKwQ,MAAOjX,KAAKkR,OAAOrI,OAAS,EAAM7I,KAAKmR,aAAe,IAEpEnR,KAAKC,SAASiT,kBAAkB4D,EAAU9W,KAAKsR,iBAAiBrJ,KAAO,MACvEjI,KAAKC,SAASiT,kBAAkB6D,EAAS/W,KAAKsR,iBAAiBxJ,IAAM,MAE7E,EACO+I,CACX,CApawC,CAoatC","sources":["webpack://mono-repo/./node_modules/@material/base/foundation.js","webpack://mono-repo/./node_modules/@material/list/foundation.js","webpack://mono-repo/./node_modules/@material/menu-surface/foundation.js","webpack://mono-repo/./node_modules/@material/menu/foundation.js","webpack://mono-repo/./node_modules/@material/ripple/foundation.js"],"sourcesContent":["/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nvar MDCFoundation = /** @class */ (function () {\n    function MDCFoundation(adapter) {\n        if (adapter === void 0) { adapter = {}; }\n        this.adapter_ = adapter;\n    }\n    Object.defineProperty(MDCFoundation, \"cssClasses\", {\n        get: function () {\n            // Classes extending MDCFoundation should implement this method to return an object which exports every\n            // CSS class the foundation class needs as a property. e.g. {ACTIVE: 'mdc-component--active'}\n            return {};\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCFoundation, \"strings\", {\n        get: function () {\n            // Classes extending MDCFoundation should implement this method to return an object which exports all\n            // semantic strings as constants. e.g. {ARIA_ROLE: 'tablist'}\n            return {};\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCFoundation, \"numbers\", {\n        get: function () {\n            // Classes extending MDCFoundation should implement this method to return an object which exports all\n            // of its semantic numbers as constants. e.g. {ANIMATION_DELAY_MS: 350}\n            return {};\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCFoundation, \"defaultAdapter\", {\n        get: function () {\n            // Classes extending MDCFoundation may choose to implement this getter in order to provide a convenient\n            // way of viewing the necessary methods of an adapter. In the future, this could also be used for adapter\n            // validation.\n            return {};\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MDCFoundation.prototype.init = function () {\n        // Subclasses should override this method to perform initialization routines (registering events, etc.)\n    };\n    MDCFoundation.prototype.destroy = function () {\n        // Subclasses should override this method to perform de-initialization routines (de-registering events, etc.)\n    };\n    return MDCFoundation;\n}());\nexport { MDCFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCFoundation } from '@material/base/foundation';\nimport { cssClasses, numbers, strings } from './constants';\nvar ELEMENTS_KEY_ALLOWED_IN = ['input', 'button', 'textarea', 'select'];\nfunction isNumberArray(selectedIndex) {\n    return selectedIndex instanceof Array;\n}\nvar MDCListFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCListFoundation, _super);\n    function MDCListFoundation(adapter) {\n        var _this = _super.call(this, tslib_1.__assign({}, MDCListFoundation.defaultAdapter, adapter)) || this;\n        _this.wrapFocus_ = false;\n        _this.isVertical_ = true;\n        _this.isSingleSelectionList_ = false;\n        _this.selectedIndex_ = numbers.UNSET_INDEX;\n        _this.focusedItemIndex_ = numbers.UNSET_INDEX;\n        _this.useActivatedClass_ = false;\n        _this.ariaCurrentAttrValue_ = null;\n        _this.isCheckboxList_ = false;\n        _this.isRadioList_ = false;\n        return _this;\n    }\n    Object.defineProperty(MDCListFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCListFoundation, \"cssClasses\", {\n        get: function () {\n            return cssClasses;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCListFoundation, \"numbers\", {\n        get: function () {\n            return numbers;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCListFoundation, \"defaultAdapter\", {\n        get: function () {\n            return {\n                addClassForElementIndex: function () { return undefined; },\n                focusItemAtIndex: function () { return undefined; },\n                getAttributeForElementIndex: function () { return null; },\n                getFocusedElementIndex: function () { return 0; },\n                getListItemCount: function () { return 0; },\n                hasCheckboxAtIndex: function () { return false; },\n                hasRadioAtIndex: function () { return false; },\n                isCheckboxCheckedAtIndex: function () { return false; },\n                isFocusInsideList: function () { return false; },\n                isRootFocused: function () { return false; },\n                notifyAction: function () { return undefined; },\n                removeClassForElementIndex: function () { return undefined; },\n                setAttributeForElementIndex: function () { return undefined; },\n                setCheckedCheckboxOrRadioAtIndex: function () { return undefined; },\n                setTabIndexForListItemChildren: function () { return undefined; },\n            };\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MDCListFoundation.prototype.layout = function () {\n        if (this.adapter_.getListItemCount() === 0) {\n            return;\n        }\n        if (this.adapter_.hasCheckboxAtIndex(0)) {\n            this.isCheckboxList_ = true;\n        }\n        else if (this.adapter_.hasRadioAtIndex(0)) {\n            this.isRadioList_ = true;\n        }\n    };\n    /**\n     * Sets the private wrapFocus_ variable.\n     */\n    MDCListFoundation.prototype.setWrapFocus = function (value) {\n        this.wrapFocus_ = value;\n    };\n    /**\n     * Sets the isVertical_ private variable.\n     */\n    MDCListFoundation.prototype.setVerticalOrientation = function (value) {\n        this.isVertical_ = value;\n    };\n    /**\n     * Sets the isSingleSelectionList_ private variable.\n     */\n    MDCListFoundation.prototype.setSingleSelection = function (value) {\n        this.isSingleSelectionList_ = value;\n    };\n    /**\n     * Sets the useActivatedClass_ private variable.\n     */\n    MDCListFoundation.prototype.setUseActivatedClass = function (useActivated) {\n        this.useActivatedClass_ = useActivated;\n    };\n    MDCListFoundation.prototype.getSelectedIndex = function () {\n        return this.selectedIndex_;\n    };\n    MDCListFoundation.prototype.setSelectedIndex = function (index) {\n        if (!this.isIndexValid_(index)) {\n            return;\n        }\n        if (this.isCheckboxList_) {\n            this.setCheckboxAtIndex_(index);\n        }\n        else if (this.isRadioList_) {\n            this.setRadioAtIndex_(index);\n        }\n        else {\n            this.setSingleSelectionAtIndex_(index);\n        }\n    };\n    /**\n     * Focus in handler for the list items.\n     */\n    MDCListFoundation.prototype.handleFocusIn = function (_, listItemIndex) {\n        if (listItemIndex >= 0) {\n            this.adapter_.setTabIndexForListItemChildren(listItemIndex, '0');\n        }\n    };\n    /**\n     * Focus out handler for the list items.\n     */\n    MDCListFoundation.prototype.handleFocusOut = function (_, listItemIndex) {\n        var _this = this;\n        if (listItemIndex >= 0) {\n            this.adapter_.setTabIndexForListItemChildren(listItemIndex, '-1');\n        }\n        /**\n         * Between Focusout & Focusin some browsers do not have focus on any element. Setting a delay to wait till the focus\n         * is moved to next element.\n         */\n        setTimeout(function () {\n            if (!_this.adapter_.isFocusInsideList()) {\n                _this.setTabindexToFirstSelectedItem_();\n            }\n        }, 0);\n    };\n    /**\n     * Key handler for the list.\n     */\n    MDCListFoundation.prototype.handleKeydown = function (evt, isRootListItem, listItemIndex) {\n        var isArrowLeft = evt.key === 'ArrowLeft' || evt.keyCode === 37;\n        var isArrowUp = evt.key === 'ArrowUp' || evt.keyCode === 38;\n        var isArrowRight = evt.key === 'ArrowRight' || evt.keyCode === 39;\n        var isArrowDown = evt.key === 'ArrowDown' || evt.keyCode === 40;\n        var isHome = evt.key === 'Home' || evt.keyCode === 36;\n        var isEnd = evt.key === 'End' || evt.keyCode === 35;\n        var isEnter = evt.key === 'Enter' || evt.keyCode === 13;\n        var isSpace = evt.key === 'Space' || evt.keyCode === 32;\n        if (this.adapter_.isRootFocused()) {\n            if (isArrowUp || isEnd) {\n                evt.preventDefault();\n                this.focusLastElement();\n            }\n            else if (isArrowDown || isHome) {\n                evt.preventDefault();\n                this.focusFirstElement();\n            }\n            return;\n        }\n        var currentIndex = this.adapter_.getFocusedElementIndex();\n        if (currentIndex === -1) {\n            currentIndex = listItemIndex;\n            if (currentIndex < 0) {\n                // If this event doesn't have a mdc-list-item ancestor from the\n                // current list (not from a sublist), return early.\n                return;\n            }\n        }\n        var nextIndex;\n        if ((this.isVertical_ && isArrowDown) || (!this.isVertical_ && isArrowRight)) {\n            this.preventDefaultEvent_(evt);\n            nextIndex = this.focusNextElement(currentIndex);\n        }\n        else if ((this.isVertical_ && isArrowUp) || (!this.isVertical_ && isArrowLeft)) {\n            this.preventDefaultEvent_(evt);\n            nextIndex = this.focusPrevElement(currentIndex);\n        }\n        else if (isHome) {\n            this.preventDefaultEvent_(evt);\n            nextIndex = this.focusFirstElement();\n        }\n        else if (isEnd) {\n            this.preventDefaultEvent_(evt);\n            nextIndex = this.focusLastElement();\n        }\n        else if (isEnter || isSpace) {\n            if (isRootListItem) {\n                // Return early if enter key is pressed on anchor element which triggers synthetic MouseEvent event.\n                var target = evt.target;\n                if (target && target.tagName === 'A' && isEnter) {\n                    return;\n                }\n                this.preventDefaultEvent_(evt);\n                if (this.isSelectableList_()) {\n                    this.setSelectedIndexOnAction_(currentIndex);\n                }\n                this.adapter_.notifyAction(currentIndex);\n            }\n        }\n        this.focusedItemIndex_ = currentIndex;\n        if (nextIndex !== undefined) {\n            this.setTabindexAtIndex_(nextIndex);\n            this.focusedItemIndex_ = nextIndex;\n        }\n    };\n    /**\n     * Click handler for the list.\n     */\n    MDCListFoundation.prototype.handleClick = function (index, toggleCheckbox) {\n        if (index === numbers.UNSET_INDEX) {\n            return;\n        }\n        if (this.isSelectableList_()) {\n            this.setSelectedIndexOnAction_(index, toggleCheckbox);\n        }\n        this.adapter_.notifyAction(index);\n        this.setTabindexAtIndex_(index);\n        this.focusedItemIndex_ = index;\n    };\n    /**\n     * Focuses the next element on the list.\n     */\n    MDCListFoundation.prototype.focusNextElement = function (index) {\n        var count = this.adapter_.getListItemCount();\n        var nextIndex = index + 1;\n        if (nextIndex >= count) {\n            if (this.wrapFocus_) {\n                nextIndex = 0;\n            }\n            else {\n                // Return early because last item is already focused.\n                return index;\n            }\n        }\n        this.adapter_.focusItemAtIndex(nextIndex);\n        return nextIndex;\n    };\n    /**\n     * Focuses the previous element on the list.\n     */\n    MDCListFoundation.prototype.focusPrevElement = function (index) {\n        var prevIndex = index - 1;\n        if (prevIndex < 0) {\n            if (this.wrapFocus_) {\n                prevIndex = this.adapter_.getListItemCount() - 1;\n            }\n            else {\n                // Return early because first item is already focused.\n                return index;\n            }\n        }\n        this.adapter_.focusItemAtIndex(prevIndex);\n        return prevIndex;\n    };\n    MDCListFoundation.prototype.focusFirstElement = function () {\n        this.adapter_.focusItemAtIndex(0);\n        return 0;\n    };\n    MDCListFoundation.prototype.focusLastElement = function () {\n        var lastIndex = this.adapter_.getListItemCount() - 1;\n        this.adapter_.focusItemAtIndex(lastIndex);\n        return lastIndex;\n    };\n    /**\n     * Ensures that preventDefault is only called if the containing element doesn't\n     * consume the event, and it will cause an unintended scroll.\n     */\n    MDCListFoundation.prototype.preventDefaultEvent_ = function (evt) {\n        var target = evt.target;\n        var tagName = (\"\" + target.tagName).toLowerCase();\n        if (ELEMENTS_KEY_ALLOWED_IN.indexOf(tagName) === -1) {\n            evt.preventDefault();\n        }\n    };\n    MDCListFoundation.prototype.setSingleSelectionAtIndex_ = function (index) {\n        if (this.selectedIndex_ === index) {\n            return;\n        }\n        var selectedClassName = cssClasses.LIST_ITEM_SELECTED_CLASS;\n        if (this.useActivatedClass_) {\n            selectedClassName = cssClasses.LIST_ITEM_ACTIVATED_CLASS;\n        }\n        if (this.selectedIndex_ !== numbers.UNSET_INDEX) {\n            this.adapter_.removeClassForElementIndex(this.selectedIndex_, selectedClassName);\n        }\n        this.adapter_.addClassForElementIndex(index, selectedClassName);\n        this.setAriaForSingleSelectionAtIndex_(index);\n        this.selectedIndex_ = index;\n    };\n    /**\n     * Sets aria attribute for single selection at given index.\n     */\n    MDCListFoundation.prototype.setAriaForSingleSelectionAtIndex_ = function (index) {\n        // Detect the presence of aria-current and get the value only during list initialization when it is in unset state.\n        if (this.selectedIndex_ === numbers.UNSET_INDEX) {\n            this.ariaCurrentAttrValue_ =\n                this.adapter_.getAttributeForElementIndex(index, strings.ARIA_CURRENT);\n        }\n        var isAriaCurrent = this.ariaCurrentAttrValue_ !== null;\n        var ariaAttribute = isAriaCurrent ? strings.ARIA_CURRENT : strings.ARIA_SELECTED;\n        if (this.selectedIndex_ !== numbers.UNSET_INDEX) {\n            this.adapter_.setAttributeForElementIndex(this.selectedIndex_, ariaAttribute, 'false');\n        }\n        var ariaAttributeValue = isAriaCurrent ? this.ariaCurrentAttrValue_ : 'true';\n        this.adapter_.setAttributeForElementIndex(index, ariaAttribute, ariaAttributeValue);\n    };\n    /**\n     * Toggles radio at give index. Radio doesn't change the checked state if it is already checked.\n     */\n    MDCListFoundation.prototype.setRadioAtIndex_ = function (index) {\n        this.adapter_.setCheckedCheckboxOrRadioAtIndex(index, true);\n        if (this.selectedIndex_ !== numbers.UNSET_INDEX) {\n            this.adapter_.setAttributeForElementIndex(this.selectedIndex_, strings.ARIA_CHECKED, 'false');\n        }\n        this.adapter_.setAttributeForElementIndex(index, strings.ARIA_CHECKED, 'true');\n        this.selectedIndex_ = index;\n    };\n    MDCListFoundation.prototype.setCheckboxAtIndex_ = function (index) {\n        for (var i = 0; i < this.adapter_.getListItemCount(); i++) {\n            var isChecked = false;\n            if (index.indexOf(i) >= 0) {\n                isChecked = true;\n            }\n            this.adapter_.setCheckedCheckboxOrRadioAtIndex(i, isChecked);\n            this.adapter_.setAttributeForElementIndex(i, strings.ARIA_CHECKED, isChecked ? 'true' : 'false');\n        }\n        this.selectedIndex_ = index;\n    };\n    MDCListFoundation.prototype.setTabindexAtIndex_ = function (index) {\n        if (this.focusedItemIndex_ === numbers.UNSET_INDEX && index !== 0) {\n            // If no list item was selected set first list item's tabindex to -1.\n            // Generally, tabindex is set to 0 on first list item of list that has no preselected items.\n            this.adapter_.setAttributeForElementIndex(0, 'tabindex', '-1');\n        }\n        else if (this.focusedItemIndex_ >= 0 && this.focusedItemIndex_ !== index) {\n            this.adapter_.setAttributeForElementIndex(this.focusedItemIndex_, 'tabindex', '-1');\n        }\n        this.adapter_.setAttributeForElementIndex(index, 'tabindex', '0');\n    };\n    /**\n     * @return Return true if it is single selectin list, checkbox list or radio list.\n     */\n    MDCListFoundation.prototype.isSelectableList_ = function () {\n        return this.isSingleSelectionList_ || this.isCheckboxList_ || this.isRadioList_;\n    };\n    MDCListFoundation.prototype.setTabindexToFirstSelectedItem_ = function () {\n        var targetIndex = 0;\n        if (this.isSelectableList_()) {\n            if (typeof this.selectedIndex_ === 'number' && this.selectedIndex_ !== numbers.UNSET_INDEX) {\n                targetIndex = this.selectedIndex_;\n            }\n            else if (isNumberArray(this.selectedIndex_) && this.selectedIndex_.length > 0) {\n                targetIndex = this.selectedIndex_.reduce(function (currentIndex, minIndex) { return Math.min(currentIndex, minIndex); });\n            }\n        }\n        this.setTabindexAtIndex_(targetIndex);\n    };\n    MDCListFoundation.prototype.isIndexValid_ = function (index) {\n        var _this = this;\n        if (index instanceof Array) {\n            if (!this.isCheckboxList_) {\n                throw new Error('MDCListFoundation: Array of index is only supported for checkbox based list');\n            }\n            if (index.length === 0) {\n                return true;\n            }\n            else {\n                return index.some(function (i) { return _this.isIndexInRange_(i); });\n            }\n        }\n        else if (typeof index === 'number') {\n            if (this.isCheckboxList_) {\n                throw new Error('MDCListFoundation: Expected array of index for checkbox based list but got number: ' + index);\n            }\n            return this.isIndexInRange_(index);\n        }\n        else {\n            return false;\n        }\n    };\n    MDCListFoundation.prototype.isIndexInRange_ = function (index) {\n        var listSize = this.adapter_.getListItemCount();\n        return index >= 0 && index < listSize;\n    };\n    MDCListFoundation.prototype.setSelectedIndexOnAction_ = function (index, toggleCheckbox) {\n        if (toggleCheckbox === void 0) { toggleCheckbox = true; }\n        if (this.isCheckboxList_) {\n            this.toggleCheckboxAtIndex_(index, toggleCheckbox);\n        }\n        else {\n            this.setSelectedIndex(index);\n        }\n    };\n    MDCListFoundation.prototype.toggleCheckboxAtIndex_ = function (index, toggleCheckbox) {\n        var isChecked = this.adapter_.isCheckboxCheckedAtIndex(index);\n        if (toggleCheckbox) {\n            isChecked = !isChecked;\n            this.adapter_.setCheckedCheckboxOrRadioAtIndex(index, isChecked);\n        }\n        this.adapter_.setAttributeForElementIndex(index, strings.ARIA_CHECKED, isChecked ? 'true' : 'false');\n        // If none of the checkbox items are selected and selectedIndex is not initialized then provide a default value.\n        var selectedIndexes = this.selectedIndex_ === numbers.UNSET_INDEX ? [] : this.selectedIndex_.slice();\n        if (isChecked) {\n            selectedIndexes.push(index);\n        }\n        else {\n            selectedIndexes = selectedIndexes.filter(function (i) { return i !== index; });\n        }\n        this.selectedIndex_ = selectedIndexes;\n    };\n    return MDCListFoundation;\n}(MDCFoundation));\nexport { MDCListFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCListFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCFoundation } from '@material/base/foundation';\nimport { Corner, CornerBit, cssClasses, numbers, strings } from './constants';\nvar MDCMenuSurfaceFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCMenuSurfaceFoundation, _super);\n    function MDCMenuSurfaceFoundation(adapter) {\n        var _this = _super.call(this, tslib_1.__assign({}, MDCMenuSurfaceFoundation.defaultAdapter, adapter)) || this;\n        _this.isOpen_ = false;\n        _this.isQuickOpen_ = false;\n        _this.isHoistedElement_ = false;\n        _this.isFixedPosition_ = false;\n        _this.openAnimationEndTimerId_ = 0;\n        _this.closeAnimationEndTimerId_ = 0;\n        _this.animationRequestId_ = 0;\n        _this.anchorCorner_ = Corner.TOP_START;\n        _this.anchorMargin_ = { top: 0, right: 0, bottom: 0, left: 0 };\n        _this.position_ = { x: 0, y: 0 };\n        return _this;\n    }\n    Object.defineProperty(MDCMenuSurfaceFoundation, \"cssClasses\", {\n        get: function () {\n            return cssClasses;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCMenuSurfaceFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCMenuSurfaceFoundation, \"numbers\", {\n        get: function () {\n            return numbers;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCMenuSurfaceFoundation, \"Corner\", {\n        get: function () {\n            return Corner;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCMenuSurfaceFoundation, \"defaultAdapter\", {\n        /**\n         * @see {@link MDCMenuSurfaceAdapter} for typing information on parameters and return types.\n         */\n        get: function () {\n            // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n            return {\n                addClass: function () { return undefined; },\n                removeClass: function () { return undefined; },\n                hasClass: function () { return false; },\n                hasAnchor: function () { return false; },\n                isElementInContainer: function () { return false; },\n                isFocused: function () { return false; },\n                isRtl: function () { return false; },\n                getInnerDimensions: function () { return ({ height: 0, width: 0 }); },\n                getAnchorDimensions: function () { return null; },\n                getWindowDimensions: function () { return ({ height: 0, width: 0 }); },\n                getBodyDimensions: function () { return ({ height: 0, width: 0 }); },\n                getWindowScroll: function () { return ({ x: 0, y: 0 }); },\n                setPosition: function () { return undefined; },\n                setMaxHeight: function () { return undefined; },\n                setTransformOrigin: function () { return undefined; },\n                saveFocus: function () { return undefined; },\n                restoreFocus: function () { return undefined; },\n                notifyClose: function () { return undefined; },\n                notifyOpen: function () { return undefined; },\n            };\n            // tslint:enable:object-literal-sort-keys\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MDCMenuSurfaceFoundation.prototype.init = function () {\n        var _a = MDCMenuSurfaceFoundation.cssClasses, ROOT = _a.ROOT, OPEN = _a.OPEN;\n        if (!this.adapter_.hasClass(ROOT)) {\n            throw new Error(ROOT + \" class required in root element.\");\n        }\n        if (this.adapter_.hasClass(OPEN)) {\n            this.isOpen_ = true;\n        }\n    };\n    MDCMenuSurfaceFoundation.prototype.destroy = function () {\n        clearTimeout(this.openAnimationEndTimerId_);\n        clearTimeout(this.closeAnimationEndTimerId_);\n        // Cancel any currently running animations.\n        cancelAnimationFrame(this.animationRequestId_);\n    };\n    /**\n     * @param corner Default anchor corner alignment of top-left menu surface corner.\n     */\n    MDCMenuSurfaceFoundation.prototype.setAnchorCorner = function (corner) {\n        this.anchorCorner_ = corner;\n    };\n    /**\n     * @param margin Set of margin values from anchor.\n     */\n    MDCMenuSurfaceFoundation.prototype.setAnchorMargin = function (margin) {\n        this.anchorMargin_.top = margin.top || 0;\n        this.anchorMargin_.right = margin.right || 0;\n        this.anchorMargin_.bottom = margin.bottom || 0;\n        this.anchorMargin_.left = margin.left || 0;\n    };\n    /** Used to indicate if the menu-surface is hoisted to the body. */\n    MDCMenuSurfaceFoundation.prototype.setIsHoisted = function (isHoisted) {\n        this.isHoistedElement_ = isHoisted;\n    };\n    /** Used to set the menu-surface calculations based on a fixed position menu. */\n    MDCMenuSurfaceFoundation.prototype.setFixedPosition = function (isFixedPosition) {\n        this.isFixedPosition_ = isFixedPosition;\n    };\n    /** Sets the menu-surface position on the page. */\n    MDCMenuSurfaceFoundation.prototype.setAbsolutePosition = function (x, y) {\n        this.position_.x = this.isFinite_(x) ? x : 0;\n        this.position_.y = this.isFinite_(y) ? y : 0;\n    };\n    MDCMenuSurfaceFoundation.prototype.setQuickOpen = function (quickOpen) {\n        this.isQuickOpen_ = quickOpen;\n    };\n    MDCMenuSurfaceFoundation.prototype.isOpen = function () {\n        return this.isOpen_;\n    };\n    /**\n     * Open the menu surface.\n     */\n    MDCMenuSurfaceFoundation.prototype.open = function () {\n        var _this = this;\n        this.adapter_.saveFocus();\n        if (!this.isQuickOpen_) {\n            this.adapter_.addClass(MDCMenuSurfaceFoundation.cssClasses.ANIMATING_OPEN);\n        }\n        this.animationRequestId_ = requestAnimationFrame(function () {\n            _this.adapter_.addClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n            _this.dimensions_ = _this.adapter_.getInnerDimensions();\n            _this.autoPosition_();\n            if (_this.isQuickOpen_) {\n                _this.adapter_.notifyOpen();\n            }\n            else {\n                _this.openAnimationEndTimerId_ = setTimeout(function () {\n                    _this.openAnimationEndTimerId_ = 0;\n                    _this.adapter_.removeClass(MDCMenuSurfaceFoundation.cssClasses.ANIMATING_OPEN);\n                    _this.adapter_.notifyOpen();\n                }, numbers.TRANSITION_OPEN_DURATION);\n            }\n        });\n        this.isOpen_ = true;\n    };\n    /**\n     * Closes the menu surface.\n     */\n    MDCMenuSurfaceFoundation.prototype.close = function (skipRestoreFocus) {\n        var _this = this;\n        if (skipRestoreFocus === void 0) { skipRestoreFocus = false; }\n        if (!this.isQuickOpen_) {\n            this.adapter_.addClass(MDCMenuSurfaceFoundation.cssClasses.ANIMATING_CLOSED);\n        }\n        requestAnimationFrame(function () {\n            _this.adapter_.removeClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n            if (_this.isQuickOpen_) {\n                _this.adapter_.notifyClose();\n            }\n            else {\n                _this.closeAnimationEndTimerId_ = setTimeout(function () {\n                    _this.closeAnimationEndTimerId_ = 0;\n                    _this.adapter_.removeClass(MDCMenuSurfaceFoundation.cssClasses.ANIMATING_CLOSED);\n                    _this.adapter_.notifyClose();\n                }, numbers.TRANSITION_CLOSE_DURATION);\n            }\n        });\n        this.isOpen_ = false;\n        if (!skipRestoreFocus) {\n            this.maybeRestoreFocus_();\n        }\n    };\n    /** Handle clicks and close if not within menu-surface element. */\n    MDCMenuSurfaceFoundation.prototype.handleBodyClick = function (evt) {\n        var el = evt.target;\n        if (this.adapter_.isElementInContainer(el)) {\n            return;\n        }\n        this.close();\n    };\n    /** Handle keys that close the surface. */\n    MDCMenuSurfaceFoundation.prototype.handleKeydown = function (evt) {\n        var keyCode = evt.keyCode, key = evt.key;\n        var isEscape = key === 'Escape' || keyCode === 27;\n        if (isEscape) {\n            this.close();\n        }\n    };\n    MDCMenuSurfaceFoundation.prototype.autoPosition_ = function () {\n        var _a;\n        // Compute measurements for autoposition methods reuse.\n        this.measurements_ = this.getAutoLayoutMeasurements_();\n        var corner = this.getOriginCorner_();\n        var maxMenuSurfaceHeight = this.getMenuSurfaceMaxHeight_(corner);\n        var verticalAlignment = this.hasBit_(corner, CornerBit.BOTTOM) ? 'bottom' : 'top';\n        var horizontalAlignment = this.hasBit_(corner, CornerBit.RIGHT) ? 'right' : 'left';\n        var horizontalOffset = this.getHorizontalOriginOffset_(corner);\n        var verticalOffset = this.getVerticalOriginOffset_(corner);\n        var _b = this.measurements_, anchorSize = _b.anchorSize, surfaceSize = _b.surfaceSize;\n        var position = (_a = {},\n            _a[horizontalAlignment] = horizontalOffset,\n            _a[verticalAlignment] = verticalOffset,\n            _a);\n        // Center align when anchor width is comparable or greater than menu surface, otherwise keep corner.\n        if (anchorSize.width / surfaceSize.width > numbers.ANCHOR_TO_MENU_SURFACE_WIDTH_RATIO) {\n            horizontalAlignment = 'center';\n        }\n        // If the menu-surface has been hoisted to the body, it's no longer relative to the anchor element\n        if (this.isHoistedElement_ || this.isFixedPosition_) {\n            this.adjustPositionForHoistedElement_(position);\n        }\n        this.adapter_.setTransformOrigin(horizontalAlignment + \" \" + verticalAlignment);\n        this.adapter_.setPosition(position);\n        this.adapter_.setMaxHeight(maxMenuSurfaceHeight ? maxMenuSurfaceHeight + 'px' : '');\n    };\n    /**\n     * @return Measurements used to position menu surface popup.\n     */\n    MDCMenuSurfaceFoundation.prototype.getAutoLayoutMeasurements_ = function () {\n        var anchorRect = this.adapter_.getAnchorDimensions();\n        var bodySize = this.adapter_.getBodyDimensions();\n        var viewportSize = this.adapter_.getWindowDimensions();\n        var windowScroll = this.adapter_.getWindowScroll();\n        if (!anchorRect) {\n            // tslint:disable:object-literal-sort-keys Positional properties are more readable when they're grouped together\n            anchorRect = {\n                top: this.position_.y,\n                right: this.position_.x,\n                bottom: this.position_.y,\n                left: this.position_.x,\n                width: 0,\n                height: 0,\n            };\n            // tslint:enable:object-literal-sort-keys\n        }\n        return {\n            anchorSize: anchorRect,\n            bodySize: bodySize,\n            surfaceSize: this.dimensions_,\n            viewportDistance: {\n                // tslint:disable:object-literal-sort-keys Positional properties are more readable when they're grouped together\n                top: anchorRect.top,\n                right: viewportSize.width - anchorRect.right,\n                bottom: viewportSize.height - anchorRect.bottom,\n                left: anchorRect.left,\n            },\n            viewportSize: viewportSize,\n            windowScroll: windowScroll,\n        };\n    };\n    /**\n     * Computes the corner of the anchor from which to animate and position the menu surface.\n     */\n    MDCMenuSurfaceFoundation.prototype.getOriginCorner_ = function () {\n        // Defaults: open from the top left.\n        var corner = Corner.TOP_LEFT;\n        var _a = this.measurements_, viewportDistance = _a.viewportDistance, anchorSize = _a.anchorSize, surfaceSize = _a.surfaceSize;\n        var isBottomAligned = this.hasBit_(this.anchorCorner_, CornerBit.BOTTOM);\n        var availableTop = isBottomAligned ? viewportDistance.top + anchorSize.height + this.anchorMargin_.bottom\n            : viewportDistance.top + this.anchorMargin_.top;\n        var availableBottom = isBottomAligned ? viewportDistance.bottom - this.anchorMargin_.bottom\n            : viewportDistance.bottom + anchorSize.height - this.anchorMargin_.top;\n        var topOverflow = surfaceSize.height - availableTop;\n        var bottomOverflow = surfaceSize.height - availableBottom;\n        if (bottomOverflow > 0 && topOverflow < bottomOverflow) {\n            corner = this.setBit_(corner, CornerBit.BOTTOM);\n        }\n        var isRtl = this.adapter_.isRtl();\n        var isFlipRtl = this.hasBit_(this.anchorCorner_, CornerBit.FLIP_RTL);\n        var avoidHorizontalOverlap = this.hasBit_(this.anchorCorner_, CornerBit.RIGHT);\n        var isAlignedRight = (avoidHorizontalOverlap && !isRtl) ||\n            (!avoidHorizontalOverlap && isFlipRtl && isRtl);\n        var availableLeft = isAlignedRight ? viewportDistance.left + anchorSize.width + this.anchorMargin_.right :\n            viewportDistance.left + this.anchorMargin_.left;\n        var availableRight = isAlignedRight ? viewportDistance.right - this.anchorMargin_.right :\n            viewportDistance.right + anchorSize.width - this.anchorMargin_.left;\n        var leftOverflow = surfaceSize.width - availableLeft;\n        var rightOverflow = surfaceSize.width - availableRight;\n        if ((leftOverflow < 0 && isAlignedRight && isRtl) ||\n            (avoidHorizontalOverlap && !isAlignedRight && leftOverflow < 0) ||\n            (rightOverflow > 0 && leftOverflow < rightOverflow)) {\n            corner = this.setBit_(corner, CornerBit.RIGHT);\n        }\n        return corner;\n    };\n    /**\n     * @param corner Origin corner of the menu surface.\n     * @return Maximum height of the menu surface, based on available space. 0 indicates should not be set.\n     */\n    MDCMenuSurfaceFoundation.prototype.getMenuSurfaceMaxHeight_ = function (corner) {\n        var viewportDistance = this.measurements_.viewportDistance;\n        var maxHeight = 0;\n        var isBottomAligned = this.hasBit_(corner, CornerBit.BOTTOM);\n        var isBottomAnchored = this.hasBit_(this.anchorCorner_, CornerBit.BOTTOM);\n        var MARGIN_TO_EDGE = MDCMenuSurfaceFoundation.numbers.MARGIN_TO_EDGE;\n        // When maximum height is not specified, it is handled from CSS.\n        if (isBottomAligned) {\n            maxHeight = viewportDistance.top + this.anchorMargin_.top - MARGIN_TO_EDGE;\n            if (!isBottomAnchored) {\n                maxHeight += this.measurements_.anchorSize.height;\n            }\n        }\n        else {\n            maxHeight =\n                viewportDistance.bottom - this.anchorMargin_.bottom + this.measurements_.anchorSize.height - MARGIN_TO_EDGE;\n            if (isBottomAnchored) {\n                maxHeight -= this.measurements_.anchorSize.height;\n            }\n        }\n        return maxHeight;\n    };\n    /**\n     * @param corner Origin corner of the menu surface.\n     * @return Horizontal offset of menu surface origin corner from corresponding anchor corner.\n     */\n    MDCMenuSurfaceFoundation.prototype.getHorizontalOriginOffset_ = function (corner) {\n        var anchorSize = this.measurements_.anchorSize;\n        // isRightAligned corresponds to using the 'right' property on the surface.\n        var isRightAligned = this.hasBit_(corner, CornerBit.RIGHT);\n        var avoidHorizontalOverlap = this.hasBit_(this.anchorCorner_, CornerBit.RIGHT);\n        if (isRightAligned) {\n            var rightOffset = avoidHorizontalOverlap ? anchorSize.width - this.anchorMargin_.left : this.anchorMargin_.right;\n            // For hoisted or fixed elements, adjust the offset by the difference between viewport width and body width so\n            // when we calculate the right value (`adjustPositionForHoistedElement_`) based on the element position,\n            // the right property is correct.\n            if (this.isHoistedElement_ || this.isFixedPosition_) {\n                return rightOffset - (this.measurements_.viewportSize.width - this.measurements_.bodySize.width);\n            }\n            return rightOffset;\n        }\n        return avoidHorizontalOverlap ? anchorSize.width - this.anchorMargin_.right : this.anchorMargin_.left;\n    };\n    /**\n     * @param corner Origin corner of the menu surface.\n     * @return Vertical offset of menu surface origin corner from corresponding anchor corner.\n     */\n    MDCMenuSurfaceFoundation.prototype.getVerticalOriginOffset_ = function (corner) {\n        var anchorSize = this.measurements_.anchorSize;\n        var isBottomAligned = this.hasBit_(corner, CornerBit.BOTTOM);\n        var avoidVerticalOverlap = this.hasBit_(this.anchorCorner_, CornerBit.BOTTOM);\n        var y = 0;\n        if (isBottomAligned) {\n            y = avoidVerticalOverlap ? anchorSize.height - this.anchorMargin_.top : -this.anchorMargin_.bottom;\n        }\n        else {\n            y = avoidVerticalOverlap ? (anchorSize.height + this.anchorMargin_.bottom) : this.anchorMargin_.top;\n        }\n        return y;\n    };\n    /** Calculates the offsets for positioning the menu-surface when the menu-surface has been hoisted to the body. */\n    MDCMenuSurfaceFoundation.prototype.adjustPositionForHoistedElement_ = function (position) {\n        var e_1, _a;\n        var _b = this.measurements_, windowScroll = _b.windowScroll, viewportDistance = _b.viewportDistance;\n        var props = Object.keys(position);\n        try {\n            for (var props_1 = tslib_1.__values(props), props_1_1 = props_1.next(); !props_1_1.done; props_1_1 = props_1.next()) {\n                var prop = props_1_1.value;\n                var value = position[prop] || 0;\n                // Hoisted surfaces need to have the anchor elements location on the page added to the\n                // position properties for proper alignment on the body.\n                value += viewportDistance[prop];\n                // Surfaces that are absolutely positioned need to have additional calculations for scroll\n                // and bottom positioning.\n                if (!this.isFixedPosition_) {\n                    if (prop === 'top') {\n                        value += windowScroll.y;\n                    }\n                    else if (prop === 'bottom') {\n                        value -= windowScroll.y;\n                    }\n                    else if (prop === 'left') {\n                        value += windowScroll.x;\n                    }\n                    else { // prop === 'right'\n                        value -= windowScroll.x;\n                    }\n                }\n                position[prop] = value;\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (props_1_1 && !props_1_1.done && (_a = props_1.return)) _a.call(props_1);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n    };\n    /**\n     * The last focused element when the menu surface was opened should regain focus, if the user is\n     * focused on or within the menu surface when it is closed.\n     */\n    MDCMenuSurfaceFoundation.prototype.maybeRestoreFocus_ = function () {\n        var isRootFocused = this.adapter_.isFocused();\n        var childHasFocus = document.activeElement && this.adapter_.isElementInContainer(document.activeElement);\n        if (isRootFocused || childHasFocus) {\n            this.adapter_.restoreFocus();\n        }\n    };\n    MDCMenuSurfaceFoundation.prototype.hasBit_ = function (corner, bit) {\n        return Boolean(corner & bit); // tslint:disable-line:no-bitwise\n    };\n    MDCMenuSurfaceFoundation.prototype.setBit_ = function (corner, bit) {\n        return corner | bit; // tslint:disable-line:no-bitwise\n    };\n    /**\n     * isFinite that doesn't force conversion to number type.\n     * Equivalent to Number.isFinite in ES2015, which is not supported in IE.\n     */\n    MDCMenuSurfaceFoundation.prototype.isFinite_ = function (num) {\n        return typeof num === 'number' && isFinite(num);\n    };\n    return MDCMenuSurfaceFoundation;\n}(MDCFoundation));\nexport { MDCMenuSurfaceFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCMenuSurfaceFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2018 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCFoundation } from '@material/base/foundation';\nimport { MDCMenuSurfaceFoundation } from '@material/menu-surface/foundation';\nimport { cssClasses, DefaultFocusState, numbers, strings } from './constants';\nvar MDCMenuFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCMenuFoundation, _super);\n    function MDCMenuFoundation(adapter) {\n        var _this = _super.call(this, tslib_1.__assign({}, MDCMenuFoundation.defaultAdapter, adapter)) || this;\n        _this.closeAnimationEndTimerId_ = 0;\n        _this.defaultFocusState_ = DefaultFocusState.LIST_ROOT;\n        return _this;\n    }\n    Object.defineProperty(MDCMenuFoundation, \"cssClasses\", {\n        get: function () {\n            return cssClasses;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCMenuFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCMenuFoundation, \"numbers\", {\n        get: function () {\n            return numbers;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCMenuFoundation, \"defaultAdapter\", {\n        /**\n         * @see {@link MDCMenuAdapter} for typing information on parameters and return types.\n         */\n        get: function () {\n            // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n            return {\n                addClassToElementAtIndex: function () { return undefined; },\n                removeClassFromElementAtIndex: function () { return undefined; },\n                addAttributeToElementAtIndex: function () { return undefined; },\n                removeAttributeFromElementAtIndex: function () { return undefined; },\n                elementContainsClass: function () { return false; },\n                closeSurface: function () { return undefined; },\n                getElementIndex: function () { return -1; },\n                notifySelected: function () { return undefined; },\n                getMenuItemCount: function () { return 0; },\n                focusItemAtIndex: function () { return undefined; },\n                focusListRoot: function () { return undefined; },\n                getSelectedSiblingOfItemAtIndex: function () { return -1; },\n                isSelectableItemAtIndex: function () { return false; },\n            };\n            // tslint:enable:object-literal-sort-keys\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MDCMenuFoundation.prototype.destroy = function () {\n        if (this.closeAnimationEndTimerId_) {\n            clearTimeout(this.closeAnimationEndTimerId_);\n        }\n        this.adapter_.closeSurface();\n    };\n    MDCMenuFoundation.prototype.handleKeydown = function (evt) {\n        var key = evt.key, keyCode = evt.keyCode;\n        var isTab = key === 'Tab' || keyCode === 9;\n        if (isTab) {\n            this.adapter_.closeSurface(/** skipRestoreFocus */ true);\n        }\n    };\n    MDCMenuFoundation.prototype.handleItemAction = function (listItem) {\n        var _this = this;\n        var index = this.adapter_.getElementIndex(listItem);\n        if (index < 0) {\n            return;\n        }\n        this.adapter_.notifySelected({ index: index });\n        this.adapter_.closeSurface();\n        // Wait for the menu to close before adding/removing classes that affect styles.\n        this.closeAnimationEndTimerId_ = setTimeout(function () {\n            if (_this.adapter_.isSelectableItemAtIndex(index)) {\n                _this.setSelectedIndex(index);\n            }\n        }, MDCMenuSurfaceFoundation.numbers.TRANSITION_CLOSE_DURATION);\n    };\n    MDCMenuFoundation.prototype.handleMenuSurfaceOpened = function () {\n        switch (this.defaultFocusState_) {\n            case DefaultFocusState.FIRST_ITEM:\n                this.adapter_.focusItemAtIndex(0);\n                break;\n            case DefaultFocusState.LAST_ITEM:\n                this.adapter_.focusItemAtIndex(this.adapter_.getMenuItemCount() - 1);\n                break;\n            case DefaultFocusState.NONE:\n                // Do nothing.\n                break;\n            default:\n                this.adapter_.focusListRoot();\n                break;\n        }\n    };\n    /**\n     * Sets default focus state where the menu should focus every time when menu\n     * is opened. Focuses the list root (`DefaultFocusState.LIST_ROOT`) element by\n     * default.\n     */\n    MDCMenuFoundation.prototype.setDefaultFocusState = function (focusState) {\n        this.defaultFocusState_ = focusState;\n    };\n    /**\n     * Selects the list item at `index` within the menu.\n     * @param index Index of list item within the menu.\n     */\n    MDCMenuFoundation.prototype.setSelectedIndex = function (index) {\n        this.validatedIndex_(index);\n        if (!this.adapter_.isSelectableItemAtIndex(index)) {\n            throw new Error('MDCMenuFoundation: No selection group at specified index.');\n        }\n        var prevSelectedIndex = this.adapter_.getSelectedSiblingOfItemAtIndex(index);\n        if (prevSelectedIndex >= 0) {\n            this.adapter_.removeAttributeFromElementAtIndex(prevSelectedIndex, strings.ARIA_CHECKED_ATTR);\n            this.adapter_.removeClassFromElementAtIndex(prevSelectedIndex, cssClasses.MENU_SELECTED_LIST_ITEM);\n        }\n        this.adapter_.addClassToElementAtIndex(index, cssClasses.MENU_SELECTED_LIST_ITEM);\n        this.adapter_.addAttributeToElementAtIndex(index, strings.ARIA_CHECKED_ATTR, 'true');\n    };\n    MDCMenuFoundation.prototype.validatedIndex_ = function (index) {\n        var menuSize = this.adapter_.getMenuItemCount();\n        var isIndexInRange = index >= 0 && index < menuSize;\n        if (!isIndexInRange) {\n            throw new Error('MDCMenuFoundation: No list item at specified index.');\n        }\n    };\n    return MDCMenuFoundation;\n}(MDCFoundation));\nexport { MDCMenuFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCMenuFoundation;\n//# sourceMappingURL=foundation.js.map","/**\n * @license\n * Copyright 2016 Google Inc.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\nimport * as tslib_1 from \"tslib\";\nimport { MDCFoundation } from '@material/base/foundation';\nimport { cssClasses, numbers, strings } from './constants';\nimport { getNormalizedEventCoords } from './util';\n// Activation events registered on the root element of each instance for activation\nvar ACTIVATION_EVENT_TYPES = [\n    'touchstart', 'pointerdown', 'mousedown', 'keydown',\n];\n// Deactivation events registered on documentElement when a pointer-related down event occurs\nvar POINTER_DEACTIVATION_EVENT_TYPES = [\n    'touchend', 'pointerup', 'mouseup', 'contextmenu',\n];\n// simultaneous nested activations\nvar activatedTargets = [];\nvar MDCRippleFoundation = /** @class */ (function (_super) {\n    tslib_1.__extends(MDCRippleFoundation, _super);\n    function MDCRippleFoundation(adapter) {\n        var _this = _super.call(this, tslib_1.__assign({}, MDCRippleFoundation.defaultAdapter, adapter)) || this;\n        _this.activationAnimationHasEnded_ = false;\n        _this.activationTimer_ = 0;\n        _this.fgDeactivationRemovalTimer_ = 0;\n        _this.fgScale_ = '0';\n        _this.frame_ = { width: 0, height: 0 };\n        _this.initialSize_ = 0;\n        _this.layoutFrame_ = 0;\n        _this.maxRadius_ = 0;\n        _this.unboundedCoords_ = { left: 0, top: 0 };\n        _this.activationState_ = _this.defaultActivationState_();\n        _this.activationTimerCallback_ = function () {\n            _this.activationAnimationHasEnded_ = true;\n            _this.runDeactivationUXLogicIfReady_();\n        };\n        _this.activateHandler_ = function (e) { return _this.activate_(e); };\n        _this.deactivateHandler_ = function () { return _this.deactivate_(); };\n        _this.focusHandler_ = function () { return _this.handleFocus(); };\n        _this.blurHandler_ = function () { return _this.handleBlur(); };\n        _this.resizeHandler_ = function () { return _this.layout(); };\n        return _this;\n    }\n    Object.defineProperty(MDCRippleFoundation, \"cssClasses\", {\n        get: function () {\n            return cssClasses;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCRippleFoundation, \"strings\", {\n        get: function () {\n            return strings;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCRippleFoundation, \"numbers\", {\n        get: function () {\n            return numbers;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(MDCRippleFoundation, \"defaultAdapter\", {\n        get: function () {\n            return {\n                addClass: function () { return undefined; },\n                browserSupportsCssVars: function () { return true; },\n                computeBoundingRect: function () { return ({ top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0 }); },\n                containsEventTarget: function () { return true; },\n                deregisterDocumentInteractionHandler: function () { return undefined; },\n                deregisterInteractionHandler: function () { return undefined; },\n                deregisterResizeHandler: function () { return undefined; },\n                getWindowPageOffset: function () { return ({ x: 0, y: 0 }); },\n                isSurfaceActive: function () { return true; },\n                isSurfaceDisabled: function () { return true; },\n                isUnbounded: function () { return true; },\n                registerDocumentInteractionHandler: function () { return undefined; },\n                registerInteractionHandler: function () { return undefined; },\n                registerResizeHandler: function () { return undefined; },\n                removeClass: function () { return undefined; },\n                updateCssVariable: function () { return undefined; },\n            };\n        },\n        enumerable: true,\n        configurable: true\n    });\n    MDCRippleFoundation.prototype.init = function () {\n        var _this = this;\n        var supportsPressRipple = this.supportsPressRipple_();\n        this.registerRootHandlers_(supportsPressRipple);\n        if (supportsPressRipple) {\n            var _a = MDCRippleFoundation.cssClasses, ROOT_1 = _a.ROOT, UNBOUNDED_1 = _a.UNBOUNDED;\n            requestAnimationFrame(function () {\n                _this.adapter_.addClass(ROOT_1);\n                if (_this.adapter_.isUnbounded()) {\n                    _this.adapter_.addClass(UNBOUNDED_1);\n                    // Unbounded ripples need layout logic applied immediately to set coordinates for both shade and ripple\n                    _this.layoutInternal_();\n                }\n            });\n        }\n    };\n    MDCRippleFoundation.prototype.destroy = function () {\n        var _this = this;\n        if (this.supportsPressRipple_()) {\n            if (this.activationTimer_) {\n                clearTimeout(this.activationTimer_);\n                this.activationTimer_ = 0;\n                this.adapter_.removeClass(MDCRippleFoundation.cssClasses.FG_ACTIVATION);\n            }\n            if (this.fgDeactivationRemovalTimer_) {\n                clearTimeout(this.fgDeactivationRemovalTimer_);\n                this.fgDeactivationRemovalTimer_ = 0;\n                this.adapter_.removeClass(MDCRippleFoundation.cssClasses.FG_DEACTIVATION);\n            }\n            var _a = MDCRippleFoundation.cssClasses, ROOT_2 = _a.ROOT, UNBOUNDED_2 = _a.UNBOUNDED;\n            requestAnimationFrame(function () {\n                _this.adapter_.removeClass(ROOT_2);\n                _this.adapter_.removeClass(UNBOUNDED_2);\n                _this.removeCssVars_();\n            });\n        }\n        this.deregisterRootHandlers_();\n        this.deregisterDeactivationHandlers_();\n    };\n    /**\n     * @param evt Optional event containing position information.\n     */\n    MDCRippleFoundation.prototype.activate = function (evt) {\n        this.activate_(evt);\n    };\n    MDCRippleFoundation.prototype.deactivate = function () {\n        this.deactivate_();\n    };\n    MDCRippleFoundation.prototype.layout = function () {\n        var _this = this;\n        if (this.layoutFrame_) {\n            cancelAnimationFrame(this.layoutFrame_);\n        }\n        this.layoutFrame_ = requestAnimationFrame(function () {\n            _this.layoutInternal_();\n            _this.layoutFrame_ = 0;\n        });\n    };\n    MDCRippleFoundation.prototype.setUnbounded = function (unbounded) {\n        var UNBOUNDED = MDCRippleFoundation.cssClasses.UNBOUNDED;\n        if (unbounded) {\n            this.adapter_.addClass(UNBOUNDED);\n        }\n        else {\n            this.adapter_.removeClass(UNBOUNDED);\n        }\n    };\n    MDCRippleFoundation.prototype.handleFocus = function () {\n        var _this = this;\n        requestAnimationFrame(function () {\n            return _this.adapter_.addClass(MDCRippleFoundation.cssClasses.BG_FOCUSED);\n        });\n    };\n    MDCRippleFoundation.prototype.handleBlur = function () {\n        var _this = this;\n        requestAnimationFrame(function () {\n            return _this.adapter_.removeClass(MDCRippleFoundation.cssClasses.BG_FOCUSED);\n        });\n    };\n    /**\n     * We compute this property so that we are not querying information about the client\n     * until the point in time where the foundation requests it. This prevents scenarios where\n     * client-side feature-detection may happen too early, such as when components are rendered on the server\n     * and then initialized at mount time on the client.\n     */\n    MDCRippleFoundation.prototype.supportsPressRipple_ = function () {\n        return this.adapter_.browserSupportsCssVars();\n    };\n    MDCRippleFoundation.prototype.defaultActivationState_ = function () {\n        return {\n            activationEvent: undefined,\n            hasDeactivationUXRun: false,\n            isActivated: false,\n            isProgrammatic: false,\n            wasActivatedByPointer: false,\n            wasElementMadeActive: false,\n        };\n    };\n    /**\n     * supportsPressRipple Passed from init to save a redundant function call\n     */\n    MDCRippleFoundation.prototype.registerRootHandlers_ = function (supportsPressRipple) {\n        var _this = this;\n        if (supportsPressRipple) {\n            ACTIVATION_EVENT_TYPES.forEach(function (evtType) {\n                _this.adapter_.registerInteractionHandler(evtType, _this.activateHandler_);\n            });\n            if (this.adapter_.isUnbounded()) {\n                this.adapter_.registerResizeHandler(this.resizeHandler_);\n            }\n        }\n        this.adapter_.registerInteractionHandler('focus', this.focusHandler_);\n        this.adapter_.registerInteractionHandler('blur', this.blurHandler_);\n    };\n    MDCRippleFoundation.prototype.registerDeactivationHandlers_ = function (evt) {\n        var _this = this;\n        if (evt.type === 'keydown') {\n            this.adapter_.registerInteractionHandler('keyup', this.deactivateHandler_);\n        }\n        else {\n            POINTER_DEACTIVATION_EVENT_TYPES.forEach(function (evtType) {\n                _this.adapter_.registerDocumentInteractionHandler(evtType, _this.deactivateHandler_);\n            });\n        }\n    };\n    MDCRippleFoundation.prototype.deregisterRootHandlers_ = function () {\n        var _this = this;\n        ACTIVATION_EVENT_TYPES.forEach(function (evtType) {\n            _this.adapter_.deregisterInteractionHandler(evtType, _this.activateHandler_);\n        });\n        this.adapter_.deregisterInteractionHandler('focus', this.focusHandler_);\n        this.adapter_.deregisterInteractionHandler('blur', this.blurHandler_);\n        if (this.adapter_.isUnbounded()) {\n            this.adapter_.deregisterResizeHandler(this.resizeHandler_);\n        }\n    };\n    MDCRippleFoundation.prototype.deregisterDeactivationHandlers_ = function () {\n        var _this = this;\n        this.adapter_.deregisterInteractionHandler('keyup', this.deactivateHandler_);\n        POINTER_DEACTIVATION_EVENT_TYPES.forEach(function (evtType) {\n            _this.adapter_.deregisterDocumentInteractionHandler(evtType, _this.deactivateHandler_);\n        });\n    };\n    MDCRippleFoundation.prototype.removeCssVars_ = function () {\n        var _this = this;\n        var rippleStrings = MDCRippleFoundation.strings;\n        var keys = Object.keys(rippleStrings);\n        keys.forEach(function (key) {\n            if (key.indexOf('VAR_') === 0) {\n                _this.adapter_.updateCssVariable(rippleStrings[key], null);\n            }\n        });\n    };\n    MDCRippleFoundation.prototype.activate_ = function (evt) {\n        var _this = this;\n        if (this.adapter_.isSurfaceDisabled()) {\n            return;\n        }\n        var activationState = this.activationState_;\n        if (activationState.isActivated) {\n            return;\n        }\n        // Avoid reacting to follow-on events fired by touch device after an already-processed user interaction\n        var previousActivationEvent = this.previousActivationEvent_;\n        var isSameInteraction = previousActivationEvent && evt !== undefined && previousActivationEvent.type !== evt.type;\n        if (isSameInteraction) {\n            return;\n        }\n        activationState.isActivated = true;\n        activationState.isProgrammatic = evt === undefined;\n        activationState.activationEvent = evt;\n        activationState.wasActivatedByPointer = activationState.isProgrammatic ? false : evt !== undefined && (evt.type === 'mousedown' || evt.type === 'touchstart' || evt.type === 'pointerdown');\n        var hasActivatedChild = evt !== undefined && activatedTargets.length > 0 && activatedTargets.some(function (target) { return _this.adapter_.containsEventTarget(target); });\n        if (hasActivatedChild) {\n            // Immediately reset activation state, while preserving logic that prevents touch follow-on events\n            this.resetActivationState_();\n            return;\n        }\n        if (evt !== undefined) {\n            activatedTargets.push(evt.target);\n            this.registerDeactivationHandlers_(evt);\n        }\n        activationState.wasElementMadeActive = this.checkElementMadeActive_(evt);\n        if (activationState.wasElementMadeActive) {\n            this.animateActivation_();\n        }\n        requestAnimationFrame(function () {\n            // Reset array on next frame after the current event has had a chance to bubble to prevent ancestor ripples\n            activatedTargets = [];\n            if (!activationState.wasElementMadeActive\n                && evt !== undefined\n                && (evt.key === ' ' || evt.keyCode === 32)) {\n                // If space was pressed, try again within an rAF call to detect :active, because different UAs report\n                // active states inconsistently when they're called within event handling code:\n                // - https://bugs.chromium.org/p/chromium/issues/detail?id=635971\n                // - https://bugzilla.mozilla.org/show_bug.cgi?id=1293741\n                // We try first outside rAF to support Edge, which does not exhibit this problem, but will crash if a CSS\n                // variable is set within a rAF callback for a submit button interaction (#2241).\n                activationState.wasElementMadeActive = _this.checkElementMadeActive_(evt);\n                if (activationState.wasElementMadeActive) {\n                    _this.animateActivation_();\n                }\n            }\n            if (!activationState.wasElementMadeActive) {\n                // Reset activation state immediately if element was not made active.\n                _this.activationState_ = _this.defaultActivationState_();\n            }\n        });\n    };\n    MDCRippleFoundation.prototype.checkElementMadeActive_ = function (evt) {\n        return (evt !== undefined && evt.type === 'keydown') ? this.adapter_.isSurfaceActive() : true;\n    };\n    MDCRippleFoundation.prototype.animateActivation_ = function () {\n        var _this = this;\n        var _a = MDCRippleFoundation.strings, VAR_FG_TRANSLATE_START = _a.VAR_FG_TRANSLATE_START, VAR_FG_TRANSLATE_END = _a.VAR_FG_TRANSLATE_END;\n        var _b = MDCRippleFoundation.cssClasses, FG_DEACTIVATION = _b.FG_DEACTIVATION, FG_ACTIVATION = _b.FG_ACTIVATION;\n        var DEACTIVATION_TIMEOUT_MS = MDCRippleFoundation.numbers.DEACTIVATION_TIMEOUT_MS;\n        this.layoutInternal_();\n        var translateStart = '';\n        var translateEnd = '';\n        if (!this.adapter_.isUnbounded()) {\n            var _c = this.getFgTranslationCoordinates_(), startPoint = _c.startPoint, endPoint = _c.endPoint;\n            translateStart = startPoint.x + \"px, \" + startPoint.y + \"px\";\n            translateEnd = endPoint.x + \"px, \" + endPoint.y + \"px\";\n        }\n        this.adapter_.updateCssVariable(VAR_FG_TRANSLATE_START, translateStart);\n        this.adapter_.updateCssVariable(VAR_FG_TRANSLATE_END, translateEnd);\n        // Cancel any ongoing activation/deactivation animations\n        clearTimeout(this.activationTimer_);\n        clearTimeout(this.fgDeactivationRemovalTimer_);\n        this.rmBoundedActivationClasses_();\n        this.adapter_.removeClass(FG_DEACTIVATION);\n        // Force layout in order to re-trigger the animation.\n        this.adapter_.computeBoundingRect();\n        this.adapter_.addClass(FG_ACTIVATION);\n        this.activationTimer_ = setTimeout(function () { return _this.activationTimerCallback_(); }, DEACTIVATION_TIMEOUT_MS);\n    };\n    MDCRippleFoundation.prototype.getFgTranslationCoordinates_ = function () {\n        var _a = this.activationState_, activationEvent = _a.activationEvent, wasActivatedByPointer = _a.wasActivatedByPointer;\n        var startPoint;\n        if (wasActivatedByPointer) {\n            startPoint = getNormalizedEventCoords(activationEvent, this.adapter_.getWindowPageOffset(), this.adapter_.computeBoundingRect());\n        }\n        else {\n            startPoint = {\n                x: this.frame_.width / 2,\n                y: this.frame_.height / 2,\n            };\n        }\n        // Center the element around the start point.\n        startPoint = {\n            x: startPoint.x - (this.initialSize_ / 2),\n            y: startPoint.y - (this.initialSize_ / 2),\n        };\n        var endPoint = {\n            x: (this.frame_.width / 2) - (this.initialSize_ / 2),\n            y: (this.frame_.height / 2) - (this.initialSize_ / 2),\n        };\n        return { startPoint: startPoint, endPoint: endPoint };\n    };\n    MDCRippleFoundation.prototype.runDeactivationUXLogicIfReady_ = function () {\n        var _this = this;\n        // This method is called both when a pointing device is released, and when the activation animation ends.\n        // The deactivation animation should only run after both of those occur.\n        var FG_DEACTIVATION = MDCRippleFoundation.cssClasses.FG_DEACTIVATION;\n        var _a = this.activationState_, hasDeactivationUXRun = _a.hasDeactivationUXRun, isActivated = _a.isActivated;\n        var activationHasEnded = hasDeactivationUXRun || !isActivated;\n        if (activationHasEnded && this.activationAnimationHasEnded_) {\n            this.rmBoundedActivationClasses_();\n            this.adapter_.addClass(FG_DEACTIVATION);\n            this.fgDeactivationRemovalTimer_ = setTimeout(function () {\n                _this.adapter_.removeClass(FG_DEACTIVATION);\n            }, numbers.FG_DEACTIVATION_MS);\n        }\n    };\n    MDCRippleFoundation.prototype.rmBoundedActivationClasses_ = function () {\n        var FG_ACTIVATION = MDCRippleFoundation.cssClasses.FG_ACTIVATION;\n        this.adapter_.removeClass(FG_ACTIVATION);\n        this.activationAnimationHasEnded_ = false;\n        this.adapter_.computeBoundingRect();\n    };\n    MDCRippleFoundation.prototype.resetActivationState_ = function () {\n        var _this = this;\n        this.previousActivationEvent_ = this.activationState_.activationEvent;\n        this.activationState_ = this.defaultActivationState_();\n        // Touch devices may fire additional events for the same interaction within a short time.\n        // Store the previous event until it's safe to assume that subsequent events are for new interactions.\n        setTimeout(function () { return _this.previousActivationEvent_ = undefined; }, MDCRippleFoundation.numbers.TAP_DELAY_MS);\n    };\n    MDCRippleFoundation.prototype.deactivate_ = function () {\n        var _this = this;\n        var activationState = this.activationState_;\n        // This can happen in scenarios such as when you have a keyup event that blurs the element.\n        if (!activationState.isActivated) {\n            return;\n        }\n        var state = tslib_1.__assign({}, activationState);\n        if (activationState.isProgrammatic) {\n            requestAnimationFrame(function () { return _this.animateDeactivation_(state); });\n            this.resetActivationState_();\n        }\n        else {\n            this.deregisterDeactivationHandlers_();\n            requestAnimationFrame(function () {\n                _this.activationState_.hasDeactivationUXRun = true;\n                _this.animateDeactivation_(state);\n                _this.resetActivationState_();\n            });\n        }\n    };\n    MDCRippleFoundation.prototype.animateDeactivation_ = function (_a) {\n        var wasActivatedByPointer = _a.wasActivatedByPointer, wasElementMadeActive = _a.wasElementMadeActive;\n        if (wasActivatedByPointer || wasElementMadeActive) {\n            this.runDeactivationUXLogicIfReady_();\n        }\n    };\n    MDCRippleFoundation.prototype.layoutInternal_ = function () {\n        var _this = this;\n        this.frame_ = this.adapter_.computeBoundingRect();\n        var maxDim = Math.max(this.frame_.height, this.frame_.width);\n        // Surface diameter is treated differently for unbounded vs. bounded ripples.\n        // Unbounded ripple diameter is calculated smaller since the surface is expected to already be padded appropriately\n        // to extend the hitbox, and the ripple is expected to meet the edges of the padded hitbox (which is typically\n        // square). Bounded ripples, on the other hand, are fully expected to expand beyond the surface's longest diameter\n        // (calculated based on the diagonal plus a constant padding), and are clipped at the surface's border via\n        // `overflow: hidden`.\n        var getBoundedRadius = function () {\n            var hypotenuse = Math.sqrt(Math.pow(_this.frame_.width, 2) + Math.pow(_this.frame_.height, 2));\n            return hypotenuse + MDCRippleFoundation.numbers.PADDING;\n        };\n        this.maxRadius_ = this.adapter_.isUnbounded() ? maxDim : getBoundedRadius();\n        // Ripple is sized as a fraction of the largest dimension of the surface, then scales up using a CSS scale transform\n        this.initialSize_ = Math.floor(maxDim * MDCRippleFoundation.numbers.INITIAL_ORIGIN_SCALE);\n        this.fgScale_ = \"\" + this.maxRadius_ / this.initialSize_;\n        this.updateLayoutCssVars_();\n    };\n    MDCRippleFoundation.prototype.updateLayoutCssVars_ = function () {\n        var _a = MDCRippleFoundation.strings, VAR_FG_SIZE = _a.VAR_FG_SIZE, VAR_LEFT = _a.VAR_LEFT, VAR_TOP = _a.VAR_TOP, VAR_FG_SCALE = _a.VAR_FG_SCALE;\n        this.adapter_.updateCssVariable(VAR_FG_SIZE, this.initialSize_ + \"px\");\n        this.adapter_.updateCssVariable(VAR_FG_SCALE, this.fgScale_);\n        if (this.adapter_.isUnbounded()) {\n            this.unboundedCoords_ = {\n                left: Math.round((this.frame_.width / 2) - (this.initialSize_ / 2)),\n                top: Math.round((this.frame_.height / 2) - (this.initialSize_ / 2)),\n            };\n            this.adapter_.updateCssVariable(VAR_LEFT, this.unboundedCoords_.left + \"px\");\n            this.adapter_.updateCssVariable(VAR_TOP, this.unboundedCoords_.top + \"px\");\n        }\n    };\n    return MDCRippleFoundation;\n}(MDCFoundation));\nexport { MDCRippleFoundation };\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCRippleFoundation;\n//# sourceMappingURL=foundation.js.map"],"names":["MDCFoundation","adapter","this","adapter_","Object","defineProperty","get","enumerable","configurable","prototype","init","destroy","ELEMENTS_KEY_ALLOWED_IN","MDCListFoundation","_super","_this","call","defaultAdapter","wrapFocus_","isVertical_","isSingleSelectionList_","selectedIndex_","focusedItemIndex_","useActivatedClass_","ariaCurrentAttrValue_","isCheckboxList_","isRadioList_","addClassForElementIndex","focusItemAtIndex","getAttributeForElementIndex","getFocusedElementIndex","getListItemCount","hasCheckboxAtIndex","hasRadioAtIndex","isCheckboxCheckedAtIndex","isFocusInsideList","isRootFocused","notifyAction","removeClassForElementIndex","setAttributeForElementIndex","setCheckedCheckboxOrRadioAtIndex","setTabIndexForListItemChildren","layout","setWrapFocus","value","setVerticalOrientation","setSingleSelection","setUseActivatedClass","useActivated","getSelectedIndex","setSelectedIndex","index","isIndexValid_","setCheckboxAtIndex_","setRadioAtIndex_","setSingleSelectionAtIndex_","handleFocusIn","_","listItemIndex","handleFocusOut","setTimeout","setTabindexToFirstSelectedItem_","handleKeydown","evt","isRootListItem","isArrowLeft","key","keyCode","isArrowUp","isArrowRight","isArrowDown","isHome","isEnd","isEnter","isSpace","preventDefault","focusLastElement","focusFirstElement","currentIndex","nextIndex","preventDefaultEvent_","focusNextElement","focusPrevElement","target","tagName","isSelectableList_","setSelectedIndexOnAction_","undefined","setTabindexAtIndex_","handleClick","toggleCheckbox","prevIndex","lastIndex","toLowerCase","indexOf","selectedClassName","setAriaForSingleSelectionAtIndex_","isAriaCurrent","ariaAttribute","ariaAttributeValue","i","isChecked","targetIndex","Array","length","reduce","minIndex","Math","min","Error","some","isIndexInRange_","listSize","toggleCheckboxAtIndex_","selectedIndexes","slice","push","filter","MDCMenuSurfaceFoundation","isOpen_","isQuickOpen_","isHoistedElement_","isFixedPosition_","openAnimationEndTimerId_","closeAnimationEndTimerId_","animationRequestId_","anchorCorner_","anchorMargin_","top","right","bottom","left","position_","x","y","addClass","removeClass","hasClass","hasAnchor","isElementInContainer","isFocused","isRtl","getInnerDimensions","height","width","getAnchorDimensions","getWindowDimensions","getBodyDimensions","getWindowScroll","setPosition","setMaxHeight","setTransformOrigin","saveFocus","restoreFocus","notifyClose","notifyOpen","_a","cssClasses","ROOT","OPEN","clearTimeout","cancelAnimationFrame","setAnchorCorner","corner","setAnchorMargin","margin","setIsHoisted","isHoisted","setFixedPosition","isFixedPosition","setAbsolutePosition","isFinite_","setQuickOpen","quickOpen","isOpen","open","ANIMATING_OPEN","requestAnimationFrame","dimensions_","autoPosition_","close","skipRestoreFocus","ANIMATING_CLOSED","maybeRestoreFocus_","handleBodyClick","el","measurements_","getAutoLayoutMeasurements_","getOriginCorner_","maxMenuSurfaceHeight","getMenuSurfaceMaxHeight_","verticalAlignment","hasBit_","horizontalAlignment","horizontalOffset","getHorizontalOriginOffset_","verticalOffset","getVerticalOriginOffset_","_b","anchorSize","surfaceSize","position","adjustPositionForHoistedElement_","anchorRect","bodySize","viewportSize","windowScroll","viewportDistance","isBottomAligned","availableTop","availableBottom","topOverflow","bottomOverflow","setBit_","isFlipRtl","avoidHorizontalOverlap","isAlignedRight","availableLeft","availableRight","leftOverflow","rightOverflow","maxHeight","isBottomAnchored","MARGIN_TO_EDGE","numbers","isRightAligned","rightOffset","avoidVerticalOverlap","e_1","props","keys","props_1","props_1_1","next","done","prop","e_1_1","error","return","childHasFocus","document","activeElement","bit","Boolean","num","isFinite","MDCMenuFoundation","defaultFocusState_","addClassToElementAtIndex","removeClassFromElementAtIndex","addAttributeToElementAtIndex","removeAttributeFromElementAtIndex","elementContainsClass","closeSurface","getElementIndex","notifySelected","getMenuItemCount","focusListRoot","getSelectedSiblingOfItemAtIndex","isSelectableItemAtIndex","handleItemAction","listItem","handleMenuSurfaceOpened","setDefaultFocusState","focusState","validatedIndex_","prevSelectedIndex","menuSize","ACTIVATION_EVENT_TYPES","POINTER_DEACTIVATION_EVENT_TYPES","activatedTargets","MDCRippleFoundation","activationAnimationHasEnded_","activationTimer_","fgDeactivationRemovalTimer_","fgScale_","frame_","initialSize_","layoutFrame_","maxRadius_","unboundedCoords_","activationState_","defaultActivationState_","activationTimerCallback_","runDeactivationUXLogicIfReady_","activateHandler_","e","activate_","deactivateHandler_","deactivate_","focusHandler_","handleFocus","blurHandler_","handleBlur","resizeHandler_","browserSupportsCssVars","computeBoundingRect","containsEventTarget","deregisterDocumentInteractionHandler","deregisterInteractionHandler","deregisterResizeHandler","getWindowPageOffset","isSurfaceActive","isSurfaceDisabled","isUnbounded","registerDocumentInteractionHandler","registerInteractionHandler","registerResizeHandler","updateCssVariable","supportsPressRipple","supportsPressRipple_","registerRootHandlers_","ROOT_1","UNBOUNDED_1","UNBOUNDED","layoutInternal_","FG_ACTIVATION","FG_DEACTIVATION","ROOT_2","UNBOUNDED_2","removeCssVars_","deregisterRootHandlers_","deregisterDeactivationHandlers_","activate","deactivate","setUnbounded","unbounded","BG_FOCUSED","activationEvent","hasDeactivationUXRun","isActivated","isProgrammatic","wasActivatedByPointer","wasElementMadeActive","forEach","evtType","registerDeactivationHandlers_","type","rippleStrings","strings","activationState","previousActivationEvent","previousActivationEvent_","resetActivationState_","checkElementMadeActive_","animateActivation_","VAR_FG_TRANSLATE_START","VAR_FG_TRANSLATE_END","DEACTIVATION_TIMEOUT_MS","translateStart","translateEnd","_c","getFgTranslationCoordinates_","startPoint","endPoint","rmBoundedActivationClasses_","TAP_DELAY_MS","state","animateDeactivation_","maxDim","max","sqrt","pow","PADDING","floor","INITIAL_ORIGIN_SCALE","updateLayoutCssVars_","VAR_FG_SIZE","VAR_LEFT","VAR_TOP","VAR_FG_SCALE","round"],"sourceRoot":""}