| 1 |
- {"version":3,"sources":["webpack://mdc/webpack/universalModuleDefinition","webpack://mdc/webpack/bootstrap","webpack://mdc/./packages/material-components-web/index.ts","webpack://mdc/./packages/mdc-animation/util.ts","webpack://mdc/./packages/mdc-auto-init/constants.ts","webpack://mdc/./packages/mdc-auto-init/index.ts","webpack://mdc/./packages/mdc-base/component.ts","webpack://mdc/./packages/mdc-base/foundation.ts","webpack://mdc/./packages/mdc-base/index.ts","webpack://mdc/./packages/mdc-checkbox/component.ts","webpack://mdc/./packages/mdc-checkbox/constants.ts","webpack://mdc/./packages/mdc-checkbox/foundation.ts","webpack://mdc/./packages/mdc-checkbox/index.ts","webpack://mdc/./packages/mdc-chips/chip-set/component.ts","webpack://mdc/./packages/mdc-chips/chip-set/constants.ts","webpack://mdc/./packages/mdc-chips/chip-set/foundation.ts","webpack://mdc/./packages/mdc-chips/chip-set/index.ts","webpack://mdc/./packages/mdc-chips/chip/component.ts","webpack://mdc/./packages/mdc-chips/chip/constants.ts","webpack://mdc/./packages/mdc-chips/chip/foundation.ts","webpack://mdc/./packages/mdc-chips/chip/index.ts","webpack://mdc/./packages/mdc-chips/index.ts","webpack://mdc/./packages/mdc-chips/trailingaction/component.ts","webpack://mdc/./packages/mdc-chips/trailingaction/constants.ts","webpack://mdc/./packages/mdc-chips/trailingaction/foundation.ts","webpack://mdc/./packages/mdc-chips/trailingaction/index.ts","webpack://mdc/./packages/mdc-circular-progress/component.ts","webpack://mdc/./packages/mdc-circular-progress/constants.ts","webpack://mdc/./packages/mdc-circular-progress/foundation.ts","webpack://mdc/./packages/mdc-circular-progress/index.ts","webpack://mdc/./packages/mdc-data-table/component.ts","webpack://mdc/./packages/mdc-data-table/constants.ts","webpack://mdc/./packages/mdc-data-table/foundation.ts","webpack://mdc/./packages/mdc-data-table/index.ts","webpack://mdc/./packages/mdc-dialog/component.ts","webpack://mdc/./packages/mdc-dialog/constants.ts","webpack://mdc/./packages/mdc-dialog/foundation.ts","webpack://mdc/./packages/mdc-dialog/index.ts","webpack://mdc/./packages/mdc-dialog/util.ts","webpack://mdc/./packages/mdc-dom/announce.ts","webpack://mdc/./packages/mdc-dom/events.ts","webpack://mdc/./packages/mdc-dom/focus-trap.ts","webpack://mdc/./packages/mdc-dom/index.ts","webpack://mdc/./packages/mdc-dom/keyboard.ts","webpack://mdc/./packages/mdc-dom/ponyfill.ts","webpack://mdc/./packages/mdc-drawer/component.ts","webpack://mdc/./packages/mdc-drawer/constants.ts","webpack://mdc/./packages/mdc-drawer/dismissible/foundation.ts","webpack://mdc/./packages/mdc-drawer/index.ts","webpack://mdc/./packages/mdc-drawer/modal/foundation.ts","webpack://mdc/./packages/mdc-drawer/util.ts","webpack://mdc/./packages/mdc-floating-label/component.ts","webpack://mdc/./packages/mdc-floating-label/constants.ts","webpack://mdc/./packages/mdc-floating-label/foundation.ts","webpack://mdc/./packages/mdc-floating-label/index.ts","webpack://mdc/./packages/mdc-form-field/component.ts","webpack://mdc/./packages/mdc-form-field/constants.ts","webpack://mdc/./packages/mdc-form-field/foundation.ts","webpack://mdc/./packages/mdc-form-field/index.ts","webpack://mdc/./packages/mdc-icon-button/component.ts","webpack://mdc/./packages/mdc-icon-button/constants.ts","webpack://mdc/./packages/mdc-icon-button/foundation.ts","webpack://mdc/./packages/mdc-icon-button/index.ts","webpack://mdc/./packages/mdc-line-ripple/component.ts","webpack://mdc/./packages/mdc-line-ripple/constants.ts","webpack://mdc/./packages/mdc-line-ripple/foundation.ts","webpack://mdc/./packages/mdc-line-ripple/index.ts","webpack://mdc/./packages/mdc-linear-progress/component.ts","webpack://mdc/./packages/mdc-linear-progress/constants.ts","webpack://mdc/./packages/mdc-linear-progress/foundation.ts","webpack://mdc/./packages/mdc-linear-progress/index.ts","webpack://mdc/./packages/mdc-list/component.ts","webpack://mdc/./packages/mdc-list/constants.ts","webpack://mdc/./packages/mdc-list/events.ts","webpack://mdc/./packages/mdc-list/foundation.ts","webpack://mdc/./packages/mdc-list/index.ts","webpack://mdc/./packages/mdc-list/typeahead.ts","webpack://mdc/./packages/mdc-menu-surface/component.ts","webpack://mdc/./packages/mdc-menu-surface/constants.ts","webpack://mdc/./packages/mdc-menu-surface/foundation.ts","webpack://mdc/./packages/mdc-menu-surface/index.ts","webpack://mdc/./packages/mdc-menu-surface/util.ts","webpack://mdc/./packages/mdc-menu/component.ts","webpack://mdc/./packages/mdc-menu/constants.ts","webpack://mdc/./packages/mdc-menu/foundation.ts","webpack://mdc/./packages/mdc-menu/index.ts","webpack://mdc/./packages/mdc-notched-outline/component.ts","webpack://mdc/./packages/mdc-notched-outline/constants.ts","webpack://mdc/./packages/mdc-notched-outline/foundation.ts","webpack://mdc/./packages/mdc-notched-outline/index.ts","webpack://mdc/./packages/mdc-radio/component.ts","webpack://mdc/./packages/mdc-radio/constants.ts","webpack://mdc/./packages/mdc-radio/foundation.ts","webpack://mdc/./packages/mdc-radio/index.ts","webpack://mdc/./packages/mdc-ripple/component.ts","webpack://mdc/./packages/mdc-ripple/constants.ts","webpack://mdc/./packages/mdc-ripple/foundation.ts","webpack://mdc/./packages/mdc-ripple/index.ts","webpack://mdc/./packages/mdc-ripple/util.ts","webpack://mdc/./packages/mdc-select/component.ts","webpack://mdc/./packages/mdc-select/constants.ts","webpack://mdc/./packages/mdc-select/foundation.ts","webpack://mdc/./packages/mdc-select/helper-text/component.ts","webpack://mdc/./packages/mdc-select/helper-text/constants.ts","webpack://mdc/./packages/mdc-select/helper-text/foundation.ts","webpack://mdc/./packages/mdc-select/helper-text/index.ts","webpack://mdc/./packages/mdc-select/icon/component.ts","webpack://mdc/./packages/mdc-select/icon/constants.ts","webpack://mdc/./packages/mdc-select/icon/foundation.ts","webpack://mdc/./packages/mdc-select/icon/index.ts","webpack://mdc/./packages/mdc-select/index.ts","webpack://mdc/./packages/mdc-slider/component.ts","webpack://mdc/./packages/mdc-slider/constants.ts","webpack://mdc/./packages/mdc-slider/foundation.ts","webpack://mdc/./packages/mdc-slider/index.ts","webpack://mdc/./packages/mdc-snackbar/component.ts","webpack://mdc/./packages/mdc-snackbar/constants.ts","webpack://mdc/./packages/mdc-snackbar/foundation.ts","webpack://mdc/./packages/mdc-snackbar/index.ts","webpack://mdc/./packages/mdc-snackbar/util.ts","webpack://mdc/./packages/mdc-switch/component.ts","webpack://mdc/./packages/mdc-switch/constants.ts","webpack://mdc/./packages/mdc-switch/foundation.ts","webpack://mdc/./packages/mdc-switch/index.ts","webpack://mdc/./packages/mdc-tab-bar/component.ts","webpack://mdc/./packages/mdc-tab-bar/constants.ts","webpack://mdc/./packages/mdc-tab-bar/foundation.ts","webpack://mdc/./packages/mdc-tab-bar/index.ts","webpack://mdc/./packages/mdc-tab-indicator/component.ts","webpack://mdc/./packages/mdc-tab-indicator/constants.ts","webpack://mdc/./packages/mdc-tab-indicator/fading-foundation.ts","webpack://mdc/./packages/mdc-tab-indicator/foundation.ts","webpack://mdc/./packages/mdc-tab-indicator/index.ts","webpack://mdc/./packages/mdc-tab-indicator/sliding-foundation.ts","webpack://mdc/./packages/mdc-tab-scroller/component.ts","webpack://mdc/./packages/mdc-tab-scroller/constants.ts","webpack://mdc/./packages/mdc-tab-scroller/foundation.ts","webpack://mdc/./packages/mdc-tab-scroller/index.ts","webpack://mdc/./packages/mdc-tab-scroller/rtl-default-scroller.ts","webpack://mdc/./packages/mdc-tab-scroller/rtl-negative-scroller.ts","webpack://mdc/./packages/mdc-tab-scroller/rtl-reverse-scroller.ts","webpack://mdc/./packages/mdc-tab-scroller/rtl-scroller.ts","webpack://mdc/./packages/mdc-tab-scroller/util.ts","webpack://mdc/./packages/mdc-tab/component.ts","webpack://mdc/./packages/mdc-tab/constants.ts","webpack://mdc/./packages/mdc-tab/foundation.ts","webpack://mdc/./packages/mdc-tab/index.ts","webpack://mdc/./packages/mdc-textfield/character-counter/component.ts","webpack://mdc/./packages/mdc-textfield/character-counter/constants.ts","webpack://mdc/./packages/mdc-textfield/character-counter/foundation.ts","webpack://mdc/./packages/mdc-textfield/character-counter/index.ts","webpack://mdc/./packages/mdc-textfield/component.ts","webpack://mdc/./packages/mdc-textfield/constants.ts","webpack://mdc/./packages/mdc-textfield/foundation.ts","webpack://mdc/./packages/mdc-textfield/helper-text/component.ts","webpack://mdc/./packages/mdc-textfield/helper-text/constants.ts","webpack://mdc/./packages/mdc-textfield/helper-text/foundation.ts","webpack://mdc/./packages/mdc-textfield/helper-text/index.ts","webpack://mdc/./packages/mdc-textfield/icon/component.ts","webpack://mdc/./packages/mdc-textfield/icon/constants.ts","webpack://mdc/./packages/mdc-textfield/icon/foundation.ts","webpack://mdc/./packages/mdc-textfield/icon/index.ts","webpack://mdc/./packages/mdc-textfield/index.ts","webpack://mdc/./packages/mdc-top-app-bar/component.ts","webpack://mdc/./packages/mdc-top-app-bar/constants.ts","webpack://mdc/./packages/mdc-top-app-bar/fixed/foundation.ts","webpack://mdc/./packages/mdc-top-app-bar/foundation.ts","webpack://mdc/./packages/mdc-top-app-bar/index.ts","webpack://mdc/./packages/mdc-top-app-bar/short/foundation.ts","webpack://mdc/./packages/mdc-top-app-bar/standard/foundation.ts"],"names":[],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,O;ACVA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kDAA0C,gCAAgC;AAC1E;AACA;;AAEA;AACA;AACA;AACA,gEAAwD,kBAAkB;AAC1E;AACA,yDAAiD,cAAc;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAyC,iCAAiC;AAC1E,wHAAgH,mBAAmB,EAAE;AACrI;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;;AAGA;AACA;;;;;;;;;;;;;;AC7DG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,kDAAiD;AA4D/C,mBA5DK,QA4DG;AA3DV,4CAA6C;AA4D3C,eAAI;AA3DN,gDAAqD;AA4DnD,mBAAQ;AA3DV,6CAA+C;AA4D7C,gBAAK;AA3DP,wDAAsE;AA4DpE,2BAAgB;AA3DlB,iDAAwD;AA4DtD,oBAAS;AA3DX,8CAAiD;AA4D/C,iBAAM;AA3DR,2CAA2C;AA4DzC,cAAG;AA3DL,8CAAiD;AA4D/C,iBAAM;AA3DR,qDAAgE;AA4D9D,wBAAa;AA3Df,iDAAwD;AA4DtD,oBAAS;AA3DX,kDAA0D;AA4DxD,qBAAU;AA3DZ,kDAA0D;AA4DxD,qBAAU;AA3DZ,sDAAkE;AA4DhE,yBAAc;AA3DhB,4CAA6C;AA4D3C,eAAI;AA3DN,mDAA4D;AA6D1D,sBAAW;AA5Db,4CAA6C;AA2D3C,eAAI;AA1DN,sDAAkE;AA4DhE,yBAAc;AA3DhB,6CAA+C;AA4D7C,gBAAK;AA3DP,8CAAiD;AA4D/C,iBAAM;AA3DR,8CAAiD;AA4D/C,iBAAM;AA3DR,8CAAiD;AA4D/C,iBAAM;AA3DR,gDAAqD;AA4DnD,mBAAQ;AA3DV,qDAAwD;AA4DtD,wBAAa;AA3Df,8CAAkD;AA6DhD,iBAAM;AA5DR,oDAA8D;AA6D5D,uBAAY;AA5Dd,mDAA4D;AA6D1D,sBAAW;AA5Db,2CAA2C;AAyDzC,cAAG;AAxDL,iDAAuD;AA4DrD,oBAAS;AA3DX,iDAAyD;AA4DvD,oBAAS;AA1De;AAC1B,QAAQ,QAAS,SAAc,eAAU,SAAc;AACvD,QAAQ,QAAS,SAAU,WAAO,MAAU;AAC5C,QAAQ,QAAS,SAAa,cAAO,MAAa;AAClD,QAAQ,QAAS,SAAsB,uBAAkB,iBAAsB;AAC/E,QAAQ,QAAS,SAAe,gBAAW,UAAe;AAC1D,QAAQ,QAAS,SAAY,aAAQ,OAAY;AACjD,QAAQ,QAAS,SAAY,aAAQ,OAAY;AACjD,QAAQ,QAAS,SAAmB,oBAAe,cAAmB;AACtE,QAAQ,QAAS,SAAe,gBAAW,UAAe;AAC1D,QAAQ,QAAS,SAAsB,uBAAY,WAAsB;AACzE,QAAQ,QAAS,SAAgB,iBAAY,WAAgB;AAC7D,QAAQ,QAAS,SAAoB,qBAAgB,eAAoB;AACzE,QAAQ,QAAS,SAAU,WAAM,KAAU;AAC3C,QAAQ,QAAS,SAAU,WAAM,KAAU;AAC3C,QAAQ,QAAS,SAAiB,kBAAa,YAAiB;AAChE,QAAQ,QAAS,SAAoB,qBAAgB,eAAoB;AACzE,QAAQ,QAAS,SAAW,YAAO,MAAW;AAC9C,QAAQ,QAAS,SAAY,aAAQ,OAAY;AACjD,QAAQ,QAAS,SAAY,aAAQ,OAAY;AACjD,QAAQ,QAAS,SAAY,aAAQ,OAAY;AACjD,QAAQ,QAAS,SAAc,eAAU,SAAc;AACvD,QAAQ,QAAS,SAAY,aAAe,cAAY;AACxD,QAAQ,QAAS,SAAY,aAAQ,OAAY;AACjD,QAAQ,QAAS,SAAe,gBAAW,UAAe;AAC1D,QAAQ,QAAS,SAAe,gBAAW,UAAe,c;;;;;;;;;;;;;AC1DvD;;;;;;;;;;;;;;;;;;;;;;;;AAQH,IAAwB;AACb;AACC,kBAAqB;AACrB,kBACT;AAHU;AAIF;AACC,kBAAqB;AACrB,kBACT;AAHU;AAID;AACA,kBAAsB;AACtB,kBAEV;AAJY;AATmC;AAejD,IAAoB;AACN;AACC,qBAAa;AAChB,kBAAsB;AACtB,kBACT;AAJa;AAKI;AACL,qBAAa;AAChB,kBAA4B;AAC5B,kBACT;AAJmB;AAKN;AACD,qBAAa;AAChB,kBAAwB;AACxB,kBACT;AAJe;AAKH;AACA,qBAAc;AACjB,kBAAuB;AACvB,kBAEV;AALe;AAhB2B;AAuB5C,SAAiB,SAAkB;AACjC,WAAc,QAAU,UAAU,aAAI,OAAgB,UAAS,SAAc,kBAC/E;AAAC;AAED,SAAsC,uBAAkB,WAAsC;AAE5F,QAAY,SAAW,cAAe,eAAsB,oBAAE;AAC5D,YAAQ,KAAY,UAAS,SAAc,cAAQ;AAC7C,oCAAsD;YAArD,cAAQ;YAAE,cAA4C;AAC7D,YAAgB,aAAW,YAAM,GAAO;AACxC,eAAmB,aAAW,WAAU;AACzC;AACD,WACF;AAAC;AATD,iCASC;AAED,SAAmC,oBAAkB,WAAgC;AAEnF,QAAY,SAAW,cAAa,aAAkB,gBAAE;AACtD,YAAQ,KAAY,UAAS,SAAc,cAAQ;AAC7C,gCAA6D;YAA5D,cAAQ;YAAE,cAAQ;YAAE,iBAAyC;AACpE,YAAgB,aAAc,eAAM,GAAO;AAC3C,eAAmB,aAAW,WAAU;AACzC;AACD,WACF;AAAC;AATD,8BASC,oB;;;;;;;;;;;;;ACtEE;;;;;;;;;;;;;;;;;;;;;;;;AAEU,QAAO;AACJ,kBAAsB;AAChB,wBAA4B;AAC/B,qBACjB;AAJqB,E;;;;;;;;;;;;;ACFpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAOH,sCAAoC;AAE7B,yCAAc;IAAE,2CAAoB;IAAE,wCAA6B;AAa1E,IAAc,WAAiC;AAE/C,IAAkB,eAAU,QAAK,KAAK,KAAU,UAAkC;AAElF,SAAa,KAAkC,SAAY,SAAsB;AAApB;AAAA,uBAAoB;;AAC/E,QAAQ;AACR,QAAI,OAAkB,gBAAe,YAAE;AAClC,kBAAkB,YAAW;AACvB,qBAAc;AACf,oBACL;AAH+B,SAA5B;AAIP,WAAM;AACF,cAAW,SAAY,YAAgB;AACvC,YAAgB,gBAAQ,SAAc,cAAO,OAAW;AAC5D;AAEO,aAAc,cACxB;AAAC;AAEsE;AAGpE;;;AACH,SAAoB,YAAgB;;AAAf;AAAA,eAAe;;AAClC,QAAgB,aAAM;AACtB,QAAS,QAAgB,GAAM,MAAK,KAAK,KAAiB,iBAAC,MAAkB,iBAAM;AAC9E,kBAAe,OAAC,UAAK;AAAK,eAAI,KAAa,aAAsB,0BAAsB;AAAE,KAAjF;;AAEb,aAAmB,uBAAK;AAAnB,gBAAU;AACb,gBAAc,WAAO,KAAa,aAAiB;AACnD,gBAAI,CAAS,UAAE;AACb,sBAAM,IAAS,MAAoD;AACpE;AAED,gBAAiB,cAAW,SAAW,UANf,CAMoD;AAC5E,gBAAI,OAAkB,gBAAe,YAAE;AACrC,sBAAM,IAAS,MACX,gEAA0E;AAC/E;AAEsE;AACqC;AAC5G,gBAAe,YAAc,YAAS,SAAO;AACvC,mBAAe,eAAK,MAAU;AACtB,8BAAM;AACR,4BAAO;AACZ,uBAAW;AACR,0BACP;AALmC;AAM5B,uBAAK,KAAY;AACvB,iBAAa,aAAqB,sBAAqB;AAC5D;;;;;;;;;;AAEG,SAAkB,mBAAM;AAC5B,WACF;AAAC;AA2BO,sBAAW;AAzB2F;AACrE;AAC9B,YAAS,WAAG,UAA8B,eAA4B,aAAqB;AAAnB;AAAA,eAAmB;;AACpG,QAAI,OAAkB,gBAAe,YAAE;AACrC,cAAM,IAAS,MAAC,gDAAyD,cAAwB;AAClG;AACD,QAAmB,gBAAW,SAAgB;AAC9C,QAAiB,eAAE;AACb,aAAC,iDAA4D,2BAAoB,0BAA2B;AACjH;AACO,aAAe,iBACzB;AAAE;AAES,YAAW,aAAG,UAA8B;AACrD,WAAe,SACjB;AAAE;AAEgB;AACP,YAAc,gBAAG;AAC1B,QAAU,OAAS,OAAK,KAAuB;AAC3C,SAAQ,QAAK,KAAW,YAC9B;AAAE;AAE+G;AACjH,kBAA2B,Y;;;;;;;;;;;;;ACvGxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAA2C;AAG3C;AAWE,0BACwB,MAA6B;AAAE,mBAAkB;aAAlB,SAAkB,GAAlB,eAAkB;AAAlB,qCAAkB;;AAA9D,aAAI,OAAS;AAClB,aAAW,iBAAX,eAAqB;AACwE;AAC5B;AACjE,aAAW,aACD,eAAgB,YAAK,KAAyB,yBAAY;AACpE,aAAW,WAAQ;AACnB,aACN;AAAC;AAnBM,iBAAQ,WAAf,UAA6B;AACyE;AACE;AACE;AACzE;AAC/B,eAAO,IAAgB,aAAK,MAAE,IAAI,aAAa,cACjD;AAAC;AAe2G;AAC5G,2BAAU,aAAV;AAAW,oBAAwB;aAAxB,SAAwB,GAAxB,eAAwB;AAAxB,kCAAwB;;AACiE;AACF;AAElG;AAAC;AAED,2BAAoB,uBAApB;AACkG;AACnF;AACb,cAAM,IAAS,MAAiF,mFAElG;AAAC;AAED,2BAAkB,qBAAlB;AACuG;AACK;AACL;AAEvG;AAAC;AAED,2BAAO,UAAP;AACuG;AACR;AACzF,aAAW,WACjB;AAAC;AAUD,2BAAM,SAAN,UAAsB,SAAwB,SAA6C;AACrF,aAAK,KAAiB,iBAAQ,SAAS,SAC7C;AAAC;AAUD,2BAAQ,WAAR,UAAwB,SAAwB,SAA6C;AACvF,aAAK,KAAoB,oBAAQ,SAAS,SAChD;AAAC;AAIE;;;AACH,2BAAI,OAAJ,UAAsC,SAAY,SAAsB;AAApB;AAAA,2BAAoB;;AACtE,YAAwB;AACxB,YAAI,OAAkB,gBAAe,YAAE;AAClC,sBAAkB,YAAW;AACvB,yBAAc;AACf,wBACL;AAH+B,aAA5B;AAIP,eAAM;AACF,kBAAW,SAAY,YAAgB;AACvC,gBAAgB,gBAAQ,SAAc,cAAO,OAAW;AAC5D;AAEG,aAAK,KAAc,cACzB;AAAC;AACH,WAAC;AAAA;AA1FY,uBAAY;AA4FwF;AACjH,kBAA4B,a;;;;;;;;;;;;;AClGzB;;;;;;;;;;;;;;;;;;;;;;;;AAEH;AA0BE,2BAA8D;AAAxC;AAAA,sBAAwC;;AAAxC,aAAO,UAAoC;AAAC;AAzBlE,0BAAW,eAAU;aAArB;AACyG;AACV;AAC7F,mBACF;AAAC;;sBAAA;;AAED,0BAAW,eAAO;aAAlB;AACuG;AACxC;AAC7D,mBACF;AAAC;;sBAAA;;AAED,0BAAW,eAAO;aAAlB;AACuG;AAC9B;AACvE,mBACF;AAAC;;sBAAA;;AAED,0BAAW,eAAc;aAAzB;AACyG;AACE;AAC3F;AACd,mBACF;AAAC;;sBAAA;;AAID,4BAAI,OAAJ;AAEA;AAAC;AAED,4BAAO,UAAP;AAEA;AAAC;AACH,WAAC;AAAA;AAnCY,wBAAa;AAqCuF;AACjH,kBAA6B,c;;;;;;;;;;;;;ACxC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,6BAA4B;AAC5B,6BAA6B,0D;;;;;;;;;;;;;ACH1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,iCAA6D;AAC7D,sCAAsD;AACtD,mCAAkD;AAClD,qCAA+C;AAE/C,sCAAqD;AACrD,uCAAgE;AAIhE,sCAAoC;AACpC,uCAAmD;AAOnD,IAAoB,iBAAG,CAAU,WAAmB;AAIpD;AAAiC,2BAAmC;AAApE;AAAA,wEA+JC;AAtHkB,cAAO,UAAkB,MAAiB;eAsH7D;AAAC;AA9JQ,gBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAe,YACxB;AAAC;AAED,0BAAI,uBAAM;aAAV;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAED,0BAAI,uBAAO;aAAX;AACE,mBAAW,KAAe,eAC5B;AAAC;aAED,aAA4B;AACtB,iBAAe,eAAQ,UAC7B;AAAC;;sBAJA;;AAMD,0BAAI,uBAAa;aAAjB;AACE,mBAAW,KAAe,eAC5B;AAAC;aAED,aAAwC;AAClC,iBAAe,eAAc,gBACnC;AAAC;;sBAJA;;AAMD,0BAAI,uBAAQ;aAAZ;AACE,mBAAW,KAAe,eAC5B;AAAC;aAED,aAA8B;AACxB,iBAAW,WAAY,YAC7B;AAAC;;sBAJA;;AAMD,0BAAI,uBAAK;aAAT;AACE,mBAAW,KAAe,eAC5B;AAAC;aAED,aAAuB;AACjB,iBAAe,eAAM,QAC3B;AAAC;;sBAJA;;AAUD,0BAAU,aAAV;AACS,0DAAmC;AACtC,aAAe,eAAc,gBACzB,KAAe,eAAa,aAAyB,6BAAY;AACrE,aAAe,eAAgB,gBACrC;AAAC;AAED,0BAAkB,qBAAlB;AAAA,oBAMC;AALK,aAAc,gBAAG;AAAM,mBAAI,MAAW,WAAe;AAAC;AACtD,aAAoB,sBAAG;AAAM,mBAAI,MAAW,WAAqB;AAAC;AAClE,aAAe,eAAiB,iBAAS,UAAM,KAAgB;AAC/D,aAAO,OAAC,OAAmB,oBAAO,QAAiB,iBAAM,KAAsB;AAC/E,aACN;AAAC;AAED,0BAAO,UAAP;AACM,aAAQ,QAAW;AACnB,aAAe,eAAoB,oBAAS,UAAM,KAAgB;AAClE,aAAS,SAAC,OAAmB,oBAAO,QAAiB,iBAAM,KAAsB;AACjF,aAAiC;AACrC,yBAAa,aACf;AAAC;AAED,0BAAoB,uBAApB;AAAA,oBAwBC;AAvBuG;AACG;AACzG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE;AAAM,uBAAK,MAAqB,KAAY;AAAA;AACzC,8BAAE;AAAM,wBAAC,CAAK,MAAe;AAAA;AAC9B,6BAAE;AAAM,uBAAO,QAAK,MAAK,KAAY;AAAA;AAC3C,uBAAE;AAAM,uBAAI,MAAQ;AAAA;AACd,6BAAE;AAAM,uBAAI,MAAc;AAAA;AAC9B,yBAAE,qBAAU;AACjB,sBAAK,KAAU,UAAO,OAC5B;AAAC;AACsB,qCAAE,iCAAK;AACxB,sBAAe,eAAgB,gBACrC;AAAC;AACmB,kCAAE,8BAAK,MAAO;AAC5B,sBAAe,eAAa,aAAK,MACvC;AAAC;AACuB,sCAAE,kCAAS;AAC7B,sBAAe,eAAS,WAC9B;AACA;AAnBkC;AAoBpC,eAAO,IAAI,aAAqB,sBAClC;AAAC;AAEO,0BAAa,gBAArB;AAAA,oBAaC;AAZuG;AACG;AACzG,YAAa,gCACR,YAAS,UAAc,cAAM,UACJ,8BAAE,sCAAQ,SAAS;AAAK,uBAAI,MAAe,eAAoB,oBAClF,SAAS,SAAE,SAAe;AAAA,eACpB,iBAAE;AAAM,kCAAO,QAAK,MAAe,gBAAY;AAAA,eACnD,aAAE;AAAM,uBAAI;AAAA,eACG,4BAAE,oCAAQ,SAAS;AAAK,uBAAI,MAAe,eAAiB,iBAC7E,SAAS,SAAE,SAAe;AACnC;AACF,eAAO,IAAI,YAAS,UAAK,KAAK,MAAE,IAAI,aAAmB,oBACzD;AAAC;AAEO,0BAA2B,8BAAnC;AAAA,oBA0BC;AAzBC,YAAc,WAAO,KAAgB;AACrC,YAAa,UAAS,OAAe,eAAW;AAElC,uBAAQ,QAAC,UAAa;AAClC,gBAAU,OAAS,OAAyB,yBAAQ,SAAgB;AAC2B;AAC1C;AACrD,gBAAI,CAAgB,gBAAM,OAAE;AACnB;AACR;AAE8D;AAC/D,gBAAkB,eAA4C,KAAK;AAEnE,gBAAkB;AACJ,8BAAM,KAAa;AACrB,4BAAM,KAAW;AACxB,qBAAc;AACd,qBAAE,aAAe;AACd,yBAAK,IAAK,KAAS,UAAS;AAC5B,0BAAW,WACjB;AACA;AARmB;AASf,mBAAe,eAAS,UAAc,cAC9C;AACF;AAAC;AAEO,0BAA6B,gCAArC;AACE,YAAc,WAAO,KAAgB;AACrC,YAAa,UAAS,OAAe,eAAW;AAElC,uBAAQ,QAAC,UAAa;AAClC,gBAAU,OAAS,OAAyB,yBAAQ,SAAgB;AACpE,gBAAI,CAAgB,gBAAM,OAAE;AACnB;AACR;AACK,mBAAe,eAAS,UAAc,cAC9C;AACF;AAAC;AAED,0BAAY,uBAAc;aAA1B;AACS,8DAAmC;AAC1C,gBAAQ,KACA,KAAK,KAAc,cAA4C;AACvE,gBAAI,CAAG,IAAE;AACP,sBAAM,IAAS,MAAC,mCAAwD,0BAAY;AACrF;AACD,mBACF;AAAC;;sBAAA;;AACH,WAAC;AAAA,EA/JgC,YA+JhC;AA/JY,sBAAW;AAiKxB,SAAwB,gBAA8C;AACpE,WAAO,CAAC,CAAc,iBAAI,OAAoB,cAAI,QACpD;AAAC,C;;;;;;;;;;;;;AC3LE;;;;;;;;;;;;;;;;;;;;;;;;AAEU,QAAU;AACK,gCAA4C;AAChD,4BAAwC;AACpC,gCAA4C;AAC1C,kCAA8C;AACpD,4BAAwC;AAClC,kCAA8C;AAChE,gBAA4B;AAC/B,aAAyB;AACvB,eAA2B;AACtB,oBAAgC;AACtC,cAA0B;AACrB,mBAA+B;AACnC,eAA2B;AACtB,oBAAgC;AAC1C,UAAgB;AACZ,cAA0B;AAC1B,cACR;AAlBwB;AAoBb,QAAO;AACD,uBAAgB;AACD,sCAAS;AAClB,6BAAsB;AACtB,6BAAiC;AAChC,8BAAW;AACL,oCAAiB;AAC1B,2BAAQ;AACH,gCAC1B;AATqB;AAWV,QAAO;AACD,uBACjB;AAFqB,E;;;;;;;;;;;;;ACjCpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAyD;AAEzD;AAA2C,qCAAiC;AAiC1E,mCAAiD;AAAjD,oBACE,wCAA+B,sBAAe,iBAAc,aAC7D;AAPO,cAAkB,qBAAG,YAAO,QAAuB;AACnD,cAAsB,yBAAM;AAC5B,cAAkB,qBAAK;AACvB,cAA0B,6BAAS;eAI3C;AAAC;AAlCD,0BAAW,uBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,uBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,uBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,uBAAc;aAAzB;AACE;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACZ,kCAAE;AAAM,2BAAK;AAAA;AACd,iCAAE;AAAM,2BAAK;AAAA;AACnB,2BAAE;AAAM,2BAAK;AAAA;AACP,iCAAE;AAAM,2BAAK;AAAA;AACjB,6BAAE;AAAM,2BAAS;AAAA;AACL,yCAAE;AAAM,2BAAS;AAAA;AACpB,sCAAE;AAAM,2BAAS;AAAA;AACb,0CAAE;AAAM,2BAAS;AAE7C;AAZS;AAYR;;sBAAA;;AAWD,oCAAI,OAAJ;AACM,aAAmB,qBAAO,KAAwB;AAClD,aAAsB;AACtB,aAAQ,QAAS,SAAC,YAAU,WAClC;AAAC;AAED,oCAAO,UAAP;AACc,qBAAK,KACnB;AAAC;AAED,oCAAW,cAAX,UAA6B;AACvB,aAAQ,QAAyB,yBAAW;AAChD,YAAY,UAAE;AACR,iBAAQ,QAAS,SAAC,YAAU,WAAW;AAC5C,eAAM;AACD,iBAAQ,QAAY,YAAC,YAAU,WAAW;AAElD;AAAC;AAIE;;;AACH,oCAAkB,qBAAlB;AAAA,oBAWC;AAVC,YAAI,CAAK,KAA2B,4BAAE;AAC7B;AACR;AAEW,qBAAK,KAAqB;AAElC,aAAmB,gCAAc;AAC/B,kBAAQ,QAAY,YAAK,MAAyB;AAClD,kBAA2B,6BACjC;AAAC,SAHmC,EAGjC,YAAO,QACZ;AAAC;AAIE;;;AACH,oCAAY,eAAZ;AACM,aACN;AAAC;AAEO,oCAAqB,wBAA7B;AACE,YAAI,CAAK,KAAQ,QAAmB,oBAAE;AAC7B;AACR;AACD,YAAc,WAAO,KAAoB;AACzC,YAAc,WAAO,KAAwB;AAE7C,YAAY,aAAa,UAAE;AAClB;AACR;AAEG,aAAsB;AAEnB,6DAAsC;AACtC,8CAAuB;AAC9B,YAAY,aAA+B,4BAAE;AACvC,iBAAQ,QAAY,YAAW;AACpC,eAAM;AACD,iBAAQ,QAAS,SAAW;AACjC;AAE6F;AACnB;AAC3E,YAAQ,KAAuB,uBAAO,SAAI,GAAE;AAC9B,yBAAK,KAAqB;AAClC,iBAAQ,QAAe;AACvB,iBAAQ,QAAY,YAAK,KAAyB;AACvD;AAEG,aAAuB,yBAAO,KAA6B,6BAAS,UAAY;AAChF,aAAmB,qBAAY;AAEiD;AACtE;AACd,YAAQ,KAAQ,QAAkB,qBAC1B,KAAuB,uBAAO,SAAI,GAAE;AACtC,iBAAQ,QAAS,SAAK,KAAyB;AAC/C,iBAA2B,6BAAQ;AAE3C;AAAC;AAEO,oCAAoB,uBAA5B;AAEI,iEAA8B;YAC9B,+CAAwB;YACxB,iDACU;AAEZ,YAAQ,KAAQ,QAAkB,mBAAE;AAClC,mBAAsC;AACvC;AACD,eAAW,KAAQ,QAAc,cAA2B,2BAE9D;AAAC;AAEO,oCAA4B,+BAApC,UAAqD,UAAkB;AAEnE,wDAAqB;YACrB,+CAAwB;YACxB,iDACU;AAEN,uCAO8B;YANlC,4BAAsB;YACtB,kCAA4B;YAC5B,4BAAsB;YACtB,gCAA0B;YAC1B,gCAA0B;YAC1B,kCACmC;AAErC,gBAAkB;AAChB,iBAA0B;AACxB,oBAAY,aAA+B,4BAAE;AAC3C,2BAAU;AACX;AACD,uBAAe,aAA+B,2BAA6B,6BAA8B;AAC3G,iBAA+B;AAC7B,uBAAe,aAA+B,2BAAyB,yBAA8B;AACvG,iBAA6B;AAC3B,uBAAe,aAAiC,6BAAyB,yBAA4B;AACvG;AAA0C;AACxC,uBAAe,aAA+B,2BAA6B,6BAEjF;;AAAC;AAEO,oCAAkB,qBAA1B;AAC+E;AAC7E,YAAQ,KAAQ,QAAkB,mBAAE;AAC9B,iBAAQ,QAAqB,qBAC7B,YAAO,QAAkB,mBAAE,YAAO,QAAmC;AAC1E,eAAM;AACiE;AACA;AAClE,iBAAQ,QAAwB,wBAAC,YAAO,QAAoB;AAEpE;AAAC;AACH,WAAC;AAAA,EAhL0C,aAgL1C;AAhLY,gCAAqB;AAkL+E;AACjH,kBAAqC,sB;;;;;;;;;;;;;ACzLlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,8D;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AACtD,qCAAgD;AAChD,sCAA0D;AAC1D,uCAAqD;AAIrD,uCAAkD;AAE5C,wCAAiG;IAAhG,uBAAiB;IAAE,qBAAe;IAAE,mBAAa;IAAE,sBAA8C;AACjG,8DAA8C;AAErD,IAAa,YAAK;AAElB;AAAgC,0BAAkC;AAAlE;mEAuIA;AAAC;AAtIQ,eAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAc,WACvB;AAAC;AAED,0BAAI,sBAAK;aAAT;AACE,mBAAW,KAAO,OACpB;AAAC;;sBAAA;;AAKD,0BAAI,sBAAe;AADhB;;;aACH;AACE,mBAAW,KAAW,WACxB;AAAC;;sBAAA;;AAWE;;;AACH,yBAAU,aAAV,UAAgE;AAArD;AAAA,+CAAiC;AAAK,2BAAI,YAAO,QAAI;AAAA;;AAC1D,aAAa,eAAe;AAC5B,aAAO,SAAO,KAAkB,kBAAK,KAC3C;AAAC;AAED,yBAAkB,qBAAlB;AAAA,oBAmBC;AAlBK,aAAO,OAAQ,QAAC,UAAK;AACvB,gBAAQ,KAAG,MAAQ,KAAS,UAAE;AACxB,sBAAW,WAAO,OAAK,KAAK;AAEpC;AAAG;AAEC,aAAuB,yBAAG,UAAI;AAC9B,mBAAI,MAAW,WAAsB,sBAAI,IAAQ;AAAC;AAClD,aAAqB,uBAAG,UAAI;AAC5B,mBAAI,MAAW,WAAoB,oBAAI,IAAQ;AAAC;AAChD,aAAmB,qBAAG,UAAI;AAC1B,mBAAI,MAAW,WAAkB,kBAAI,IAAQ;AAAC;AAC9C,aAAsB,wBAAG,UAAI;AAC7B,mBAAI,MAAW,WAAqB,qBAAI,IAAQ;AAAC;AACjD,aAAO,OAAkB,mBAAM,KAAyB;AACxD,aAAO,OAAgB,iBAAM,KAAuB;AACpD,aAAO,OAAc,eAAM,KAAqB;AAChD,aAAO,OAAiB,kBAAM,KACpC;AAAC;AAED,yBAAO,UAAP;AACM,aAAO,OAAQ,QAAC,UAAK;AACnB,iBACN;AAAG;AAEC,aAAS,SAAkB,mBAAM,KAAyB;AAC1D,aAAS,SAAgB,iBAAM,KAAuB;AACtD,aAAS,SAAc,eAAM,KAAqB;AAClD,aAAS,SAAiB,kBAAM,KAAwB;AAE5D,yBAAa,aACf;AAAC;AAIE;;;AACH,yBAAO,UAAP,UAAuB;AACf,eAAG,KAAS,OAAG,MAAI,cAAY,EAAc;AAC/C,aAAO,OAAK,KAAK,KAAa,aACpC;AAAC;AAED,yBAAoB,uBAApB;AAAA,oBAqCC;AApCuG;AACG;AACzG,YAAa;AACI,6BAAE,yBAAQ;AACvB,2BAAQ,SACV;AAAC;AAC4B,2CAAE,uCAAM;AAC/B,sBAAO,OAAO,OACpB;AAAC;AAC6B,4CAAE,wCAAM;AAChC,sBAAO,OAAO,OACpB;AAAC;AACe,8BAAE;AAAM,uBAAI,MAAO,OAAO;AAAA;AACxB,gCAAE,4BAAO;AACzB,uBAAW,MAAe,eAC5B;AAAC;AACO,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AAC3D,mBAAE;AAAM,uBAAM,OAAiB,iBAAK,MAAM,MAAiB,iBACnC,iBAAU;AAAA;AACtB,+BAAE,2BAAM;AACvB,oBAAS,SAAK,KAAS,QAAO,MAAO,OAAO,QAAE;AACxC,0BAAO,OAAO,OAAW;AACzB,0BAAO,OAAO,OAAU;AACxB,0BAAO,OAAO,OAAM,OAAK;AAEjC;AAAC;AACyB,wCAAE,oCAAM;AAC5B,sBAAO,OAAO,OACpB;AAAC;AACgB,+BAAE,2BAAM,OAAU,UAAqB;AACtD,oBAAS,SAAK,KAAS,QAAO,MAAO,OAAO,QAAE;AACxC,0BAAO,OAAO,OAAuB,uBAAS,UAAuB;AAE7E;AACA;AAhCiC;AAiCnC,eAAO,IAAI,aAAoB,qBACjC;AAAC;AAIE;;;AACK,yBAAiB,oBAAzB,UAAqD;AACnD,YAAkB,eACZ,GAAM,MAAK,KAAK,KAAK,KAAiB,iBAAiB;AAC7D,4BAAuB,IAAC,UAAG;AACvB,eAAG,KAAK,GAAG,MAAI,cAAY,EAAc;AAC3C,mBAAkB,YACpB;AACF,SAJqB;AAIpB;AAIE;;;AACK,yBAAc,iBAAtB,UAAqC;AACnC,aAAK,IAAK,IAAI,GAAG,IAAO,KAAO,OAAO,QAAK,KAAE;AAC3C,gBAAQ,KAAO,OAAG,GAAG,OAAW,QAAE;AAChC,uBAAS;AACV;AACF;AACD,eAAO,CACT;AAAC;AACH,WAAC;AAAA,EAvI+B,YAuI/B;AAvIY,qBAAU,W;;;;;;;;;;;;;AChBpB;;;;;;;;;;;;;;;;;;;;;;;;AAEU,QAAO;AACL,mBACb;AAFqB;AAIV,QAAU;AACf,YAAwB;AACxB,YACN;AAHwB,E;;;;;;;;;;;;;ACNvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAA+G;AAI/G,sCAAgD;AAEhD;AAA0C,oCAAgC;AA6BxE,kCAAgD;AAAhD,oBACE,wCAA8B,qBAAe,iBAAc,aAC5D;AALE;;;AACK,cAAgB,mBAAgB;eAIxC;AAAC;AA9BD,0BAAW,sBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,sBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,sBAAc;aAAzB;AACE;AACiB,iCAAE;AAAM,2BAAS;AAAA;AACH,+CAAE;AAAM,2BAAS;AAAA;AAChB,gDAAE;AAAM,2BAAS;AAAA;AAC/B,kCAAE;AAAM,4BAAE;AAAA;AACR,oCAAE;AAAM,4BAAE;AAAA;AACpB,0BAAE;AAAM,2BAAK;AAAA;AAChB,uBAAE;AAAM,2BAAK;AAAA;AACD,mCAAE;AAAM,2BAAS;AAAA;AACR,4CAAE;AAAM,2BAAS;AAAA;AAC1B,mCAAE;AAAM,2BAAS;AAEtC;AAZS;AAYR;;sBAAA;;AAaE;;;AACH,mCAAkB,qBAAlB;AACE,eAAW,KAAiB,iBAC9B;AAAC;AAKE;;;;AACH,mCAAM,SAAN,UAAqB;AACf,aAAQ,QAAO,QACrB;AAAC;AAIE;;;AACH,mCAAqB,wBAArB,UAA6D;YAAtC,YAAM;AAC3B,YAAW,QAAO,KAAQ,QAAmB,mBAAS;AAClD,aAA4B,4BAAQ;AACxC,YAAQ,KAAQ,QAAS,SAAC,YAAU,WAAQ,WACpC,KAAQ,QAAS,SAAC,YAAU,WAAQ,SAAE;AACxC,iBAAc,cAAS;AAE/B;AAAC;AAIE;;;AACH,mCAAmB,sBAAnB,UACmD;YAD9B,YAAM;YAAE,cAAQ;YAAE,kBAAY;AAEN;AAC3C,YAAgB,cAAE;AACT;AACR;AAED,YAAoB,iBAAO,KAAiB,iBAAQ,QAAQ,WAAM;AAClE,YAAY,YAAI,CAAe,gBAAE;AAC3B,iBAAO,OAAS;AACrB,eAAM,IAAI,CAAS,YAAkB,gBAAE;AAClC,iBAAU,UAAS;AAE3B;AAAC;AAIE;;;AACH,mCAAiB,oBAAjB,UAA0E;YAAvD,YAAM;YAAE,yBAAmB;AAC5C,YAAuB,qBAAE;AACnB,iBAAQ,QAAgB,gBAAsB;AACnD;AAED,YAAW,QAAO,KAAQ,QAAmB,mBAAS;AAClD,aAA0B,0BAAS;AACnC,aAAQ,QAAkB,kBAAQ;AACtC,YAAc,WAAO,KAAQ,QAAmB,qBAAK;AACrD,YAAe,YAAO,KAAI,IAAM,OAAY;AACxC,aAA4B,4BAAY;AACoC;AAC5E,aAAQ,QAA+B,+BAC7C;AAAC;AAIE;;;AACH,mCAAoB,uBAApB,UAAwE;YAAlD,YAAM;YAAE,SAAG;YAAE,YAAM;AACvC,YAAc,WAAO,KAAQ,QAAmB,qBAAK;AACrD,YAAS,QAAO,KAAQ,QAAmB,mBAAS;AACa;AACjE,YAAS,UAAK,CAAE,KAAI,CAAC,YAAc,eAAI,IAAK,MAAE;AACrC;AACR;AAED,YAAW,QAAO,KAAQ,QAAS;AACnC,YAAe,YAAM,QAAK,YAAW,QAAe,kBAC7C,QAAK,YAAW,QAAmB;AAC1C,YAAgB,aAAM,QAAK,YAAW,QAAgB,mBAC/C,QAAK,YAAW,QAAoB;AAC3C,YAAe,YAAM,QAAK,YAAW,QAAe,kBAC7C,QAAK,YAAW,QAAmB;AAC1C,YAAqB,kBACjB,CAAM,SAAc,cAAS,SAAa,aAAc;AAC5D,YAAY,SAAM,QAAK,YAAW,QAAU;AAC5C,YAAW,QAAM,QAAK,YAAW,QAAS;AAC1C,YAAmB,iBAAE;AACX;AACT,mBAAgB,QAAE;AACZ,oBAAK;AACX,SAFM,UAES,OAAE;AACX,oBAAY;AAClB,SAFM,MAEA;AACG;AACT;AAE0C;AAC3C,YAAS,QAAI,KAAS,QAAW,UAAE;AAC1B;AACR;AAEG,aAA4B,4BAAQ;AACpC,aAAiB,iBAAM,OAAK,KAClC;AAAC;AAEO,mCAAgB,mBAAxB,UAAsC,OAAa,KAAqB;AACtE,YAAqB,kBAAG,YAAY,aAAI,IAAM;AAC9C,YAAmB,mBAAU,WAAK,YAAW,YAAQ,SAAE;AACrD,mBAAW,KAAQ,QAA8B,8BAAQ;AAC1D;AAED,YAAmB,mBAAU,WAAK,YAAW,YAAS,UAAE;AACtD,mBAAW,KAAQ,QAA+B,+BAAQ;AAC3D;AAED,YAAS,MAAO,KAAc,cAAM;AACpC,YAAO,QAAK,YAAS,UAAK,MAAE;AAC1B,mBAAW,KAAQ,QAA+B,+BAAQ;AAC3D;AAED,YAAO,QAAK,YAAS,UAAM,OAAE;AAC3B,mBAAW,KAAQ,QAA8B,8BAAQ;AAE7D;AAAC;AAEO,mCAAa,gBAArB,UAAiC;AAC/B,YAAW,QAAO,KAAQ,QAAS;AACnC,YAAe,YAAM,QAAK,YAAW,QAAe,kBAC7C,QAAK,YAAW,QAAmB;AAC1C,YAAgB,aAAM,QAAK,YAAW,QAAgB,mBAC/C,QAAK,YAAW,QAAoB;AAC3C,YAAI,CAAM,SAAa,aAAS,SAAc,YAAE;AAC9C,mBAAO,YAAS,UAAM;AACvB;AAED,eAAO,YAAS,UAClB;AAAC;AAIE;;;AACK,mCAAS,YAAjB,UAAgC,QAA6B;AAA3B;AAAA,kCAA2B;;AAC3D,YAAW,QAAO,KAAiB,iBAAQ,QAAS;AACpD,YAAS,SAAK,GAAE;AACV,iBAAiB,iBAAO,OAAM,OAAK;AACvC,gBAAe,YAAO,KAAQ,QAAmB,mBAAS;AACtD,iBAAQ,QAAkB,kBACjB,WAAmB,iBAAM,OAAuB;AAEjE;AAAC;AAIE;;;AACK,mCAAyB,4BAAjC,UAAgD;AAC1C,aAAU,UAAO,QACvB;AAAC;AAIE;;;AACK,mCAAa,gBAArB,UAAoC;AAClC,YAAQ,KAAiB,iBAAQ,QAAQ,WAAK,GAAE;AAC1C,iBAA0B,0BAAS;AACxC,eAAM;AACD,iBAAwB,wBAAS;AAEzC;AAAC;AAEO,mCAA2B,8BAAnC,UAAiD;AAC/C,YAAe,YAAO,KAAQ,QAAoB;AAClD,aAAK,IAAK,IAAI,GAAG,IAAY,WAAK,KAAE;AAClC,gBAAK,MAAU,OAAE;AACX,qBAAQ,QAA2B,2BAAI;AAC5C;AAEL;AAAC;AAEO,mCAAuB,0BAA/B,UAA8C;AACxC,aAAQ,QAAO,QACrB;AAAC;AAEO,mCAAO,UAAf,UAA8B,QAA8B;AAC1D,YAAQ,KAAiB,iBAAQ,QAAQ,WAAK,GAAE;AACvC;AACR;AAED,YAAQ,KAAQ,QAAS,SAAC,YAAU,WAAQ,WACpC,KAAiB,iBAAO,SAAI,GAAE;AACpC,gBAA4B,yBAAO,KAAiB,iBAAI;AACxD,gBAA6B,0BACrB,KAAQ,QAAmB,mBAAyB;AACxD,iBAAiB,mBAAM;AACvB,iBAAQ,QAAkB,kBACH,yBAAmB,iBAAM,OAC3B;AAC1B;AACG,aAAiB,iBAAK,KAAS;AACnC,YAAW,QAAO,KAAQ,QAAmB,mBAAS;AAClD,aAAQ,QAAkB,kBACrB,OAAmB,iBAAK,MACnC;AAAC;AACH,WAAC;AAAA,EA1OyC,aA0OzC;AA1OY,+BAAoB;AA4OgF;AACjH,kBAAoC,qB;;;;;;;;;;;;;ACvPjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA6B;AAC7B,sCAAuF;AAA/E,wCAA+B;AAAE,qCAAyB,Q;;;;;;;;;;;;;ACL/D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAGtD,sCAAuE;AACvE,uCAAgE;AAGhE,sCAAgG;AAChG,sCAA6E;AAI7E,sCAAoC;AACpC,uCAA+C;AAK/C;AAA6B,uBAA+B;AAA5D;mEAkRA;AAAC;AA9QC,0BAAI,mBAAQ;AADT;;;aACH;AACE,mBAAW,KAAW,WACxB;AAAC;AAIE;;;aACH,aAA8B;AACxB,iBAAW,WAAY,YAC7B;AAAC;;sBAPA;;AAYD,0BAAI,mBAA+B;AADhC;;;aACH;AACE,mBAAW,KAAW,WACxB;AAAC;AAIE;;;aACH,aAAyD;AACnD,iBAAW,WAAmC,mCACpD;AAAC;;sBAPA;;AAYD,0BAAI,mBAAkC;AADnC;;;aACH,aAA2D;AACrD,iBAAW,WAAmC,mCACpD;AAAC;;sBAAA;;AAED,0BAAI,mBAAM;aAAV;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAED,0BAAI,mBAAE;aAAN;AACE,mBAAW,KAAK,KAClB;AAAC;;sBAAA;;AAEM,YAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAW,QACpB;AAAC;AAwBD,sBAAU,aAAV,UAE4E,eAEA;AAJ5E,oBA0BC;AAzBG;AAAA,mDAC0B,IAAY;AAAK,2BAAI,YAAS,UAAG,IAAa;AAAA;;AACxE;AAAA,mEACsC;AAAK,2BAAI,YAAqB,sBAAI;AAAA;;AAEtE,aAAa,eAAO,KAAK,KAAc,cAAC,YAAO,QAAwB;AACvE,aAAW,aAAO,KAAK,KAAc,cAAC,YAAO,QAAqB;AAClE,aAAe,iBACX,KAAK,KAAc,cAAC,YAAO,QAA0B;AAE7D,YAAsB,mBACd,KAAK,KAAc,cAAC,YAAO,QAA2B;AAE9D,YAAoB,kBAAE;AAChB,iBAAgB,kBAAwB,sBAAmB;AAChE;AAEqG;AACG;AACzG,YAAmB,sCACd,YAAS,UAAc,cAAM,UACb,qBAAE;AAAM,uBAAI,MAAW,WAAgB;AAC1D;AACE,aAAQ,UACK,cAAK,KAAK,MAAE,IAAI,aAAmB,oBACtD;AAAC;AAED,sBAAkB,qBAAlB;AAAA,oBAyCC;AAxCiB;AACZ,aAAiC,mCAAG;AAClC,kBAAW,WACjB;AAAE;AACE,aAAgC,kCAChC,UAA0C;AACpC,kBAAW,WAA+B,+BAChD;AAAE;AACU;AACZ,aAAa,eAAG;AACd,kBAAW,WACjB;AAAE;AACE,aAAe,iBAAG,UAAmB;AACnC,kBAAW,WAAc,cAC/B;AAAE;AACE,aAAqB,uBAAG,UAAqB;AAC3C,kBAAW,WAAoB,oBACrC;AAAE;AACE,aAAe,iBAAG,UAAgB;AAChC,kBAAW,WAAc,cAC/B;AAAE;AACE,aAAgB,kBAAG,UAAgB;AACjC,kBAAW,WAAe,eAChC;AAAE;AAGE,aAAO,OAAgB,iBAAM,KAAuB;AACpD,aAAO,OAAQ,SAAM,KAAe;AACpC,aAAO,OAAU,WAAM,KAAiB;AACxC,aAAO,OAAU,WAAM,KAAiB;AACxC,aAAO,OAAW,YAAM,KAAkB;AAE9C,YAAQ,KAAgB,iBAAE;AACpB,iBAAO,OACP,YAAqB,QAAkB,mBACnC,KAAmC;AACvC,iBAAO,OACP,YAAqB,QAAiB,kBAClC,KAAkC;AAE9C;AAAC;AAED,sBAAO,UAAP;AACM,aAAQ,QAAW;AAEnB,aAAS,SAAgB,iBAAM,KAAuB;AACtD,aAAS,SAAU,WAAM,KAAiB;AAC1C,aAAS,SAAQ,SAAM,KAAe;AACtC,aAAS,SAAU,WAAM,KAAiB;AAC1C,aAAS,SAAW,YAAM,KAAkB;AAEhD,YAAQ,KAAgB,iBAAE;AACpB,iBAAS,SACT,YAAqB,QAAkB,mBACnC,KAAmC;AACvC,iBAAS,SACT,YAAqB,QAAiB,kBAClC,KAAkC;AAC3C;AAED,yBAAa,aACf;AAAC;AAIE;;;AACH,sBAAS,YAAT;AACM,aAAW,WACjB;AAAC;AAED,sBAAoB,uBAApB;AAAA,oBAiFC;AAhFuG;AACG;AACzG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AACtC,mCAAE,+BAAU;AAC/B,oBAAQ,MAAa,cAAE;AACjB,0BAAa,aAAU,UAAI,IAAY;AAE/C;AAAC;AACkB,iCAAE,6BAAO,QAAW;AACnC,uBAAQ,SAAoB,OAAU,UAAS,SAAa,aAAM;AAAA;AACpD,gCAAE;AAClB,oBAAQ,MAAe,gBAAE;AAClB,0BAA+B,eAAS;AAEjD;AAAC;AACkB,iCAAE;AACnB,oBAAQ,MAAgB,iBAAE;AACpB,0BAAgB,gBAAS;AAEjC;AAAC;AACW,0BAAE,sBAAK;AAAK,uBAAI,MAAK,KAAa,aAAM;AAAA;AACtB,4CAAE;AAC5B,uBAAI,MAAa,aAAK,MAAW,WAA0B,0BAAK;AAAA;AAC/C,mCAAE,+BAAa;AAChC,uBAAM,OAAiB,iBAAK,MAAM,MAAiB,iBAAc;AAAA;AAC5C,uCAAE;AAAM,uBAAI,MAAK,KAAwB;AAAA;AAC1D,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AAClD,4BAAE;AAAM,wBAAC,CAAK,MAAa;AAAA;AACpC,mBAAE;AAAM,uBAAM,OAAiB,iBAAK,MAAM,MAAiB,iBACnC,iBAAU;AAAA;AACd,uCAAE;AACzB,oBAAQ,MAAgB,iBAAE;AACxB,2BAAW,MAAgB,gBAAe;AAC3C;AACD,uBACF;AAAC;AACgB,+BAAE;AAAM,uBAAI,MAAK,KAC9B,YAAO,QAAkB,mBAAE,EAAO,QAAM,MAAI,MACxC,KAAoB;AAAA;AACZ,8BAAE,0BAAI,KAAQ;AAC1B,uBAAI,MAAK,KACL,YAAO,QAAiB,kBAAE,EAAO,QAAM,MAAG,IAAK,UAAQ,QAAC,UACpD,KAAoB;AAAA;AACnB,2BAAE,uBAAoB;AAC7B,sBAAK,KACL,YAAO,QAAc,eAAE,EAAO,QAAM,MAAG,IAAqB,qBAAC,uBACzD,KACV;AAAC;AACc,6BAAE,yBAAS,UAAc;AACpC,uBAAI,MAAK,KACL,YAAO,QAAgB,iBACvB,EAAO,QAAM,MAAG,IAAU,oBAAc,cAAC,gBACrC,KAAoB;AAAA;AACH,2CAAE;AAC3B,uBAAI,MAAK,KACL,YAAO,QAAgC,iCAAE,EAAO,QAAM,MAAI,MACtD,KAAoB;AAAA;AACjB,6BAAE,2BAA+B,CAAC;AACjC,8BAAE,4BAA+B,CAAC;AACvC,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACvC,wCAAE,oCAAU;AACpC,oBAAQ,MAAa,cAAE;AACjB,0BAAa,aAAU,UAAO,OAAY;AAElD;AAAC;AACwB,uCAAE;AACzB,oBAAQ,MAAgB,iBAAE;AACpB,0BAAgB,gBAAe;AAEvC;AAAC;AACmB,kCAAE,8BAAK,MAAO;AAChC,oBAAQ,MAAe,gBAAE;AACnB,0BAAe,eAAa,aAAK,MAAS;AAElD;AAAC;AACe,8BAAE,0BAAa,cAAO;AAClC,uBAAK,MAAqB,KAAM,MAAY,YAAa,cAAQ;AACrE;AA5E8B;AA6EhC,eAAO,IAAI,aAAiB,kBAC9B;AAAC;AAED,sBAAsB,yBAAtB,UAAwC,UAA8B;AAChE,aAAW,WAAuB,uBAAS,UACjD;AAAC;AAED,sBAAkB,qBAAlB;AACM,aAAW,WACjB;AAAC;AAED,sBAAmB,sBAAnB;AACM,aAAW,WACjB;AAAC;AAED,sBAAW,cAAX;AACM,aAAW,WACjB;AAAC;AAED,sBAAM,SAAN;AACE,YAAY,SAAO,KAAK,KAAY;AACpC,YAAU,WAAS,MAAE;AACb,mBAAY,YAAK,KAAO;AAElC;AAAC;AACH,WAAC;AAAA,EAlR4B,YAkR5B;AAlRY,kBAAO,Q;;;;;;;;;;;;;ACpBjB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAGC;AAHD,WAAqB;AACnB,wBAAa;AACb,yBACF;AAAC,GAHoB,YAAT,QAAS,cAAT,QAAS,YAGpB;AAED,IAIC;AAJD,WAAuB;AACrB,6BAAmB;AACnB,8BAAqB;AACrB,0BACF;AAAC,GAJsB,cAAX,QAAW,gBAAX,QAAW,cAItB;AAEY,QAAO;AACU,kCAAoC;AACpD,kBAAgB;AACd,oBAAa;AACb,oBAAa;AACZ,qBAAc;AACjB,kBAAW;AACV,mBAAa;AACR,wBAAwB;AAChC,gBAAU;AACb,aAAO;AACL,eAAS;AACE,0BAAkB;AAC9B,cAAQ;AACC,uBAAQ;AACR,uBAAQ;AACP,wBAAS;AACZ,qBAAM;AACR,mBAAO;AACH,uBAAuB;AACnB,2BAA4B;AACjC,sBAAsB;AACf,6BAA6B;AACtB,oCAAsC;AACvD,mBAAmB;AACjB,qBAAqB;AACxB,kBAAK;AACR,eAAY;AACG,8BAA6B;AACtB,qCAAmC;AAC5C,4BACtB;AA/BqB;AAiCV,QAAU;AACZ,eAAuB;AACvB,eAAkB;AAClB,eAAuB;AACxB,cAAsB;AACvB,aAAqB;AACT,yBAAkC;AACzC,kBAA2B;AACzB,oBAA4B;AACpB,4BAAoC;AAClD,cAAsB;AAC1B,UAAkB;AACP,qBAA6B;AAC/B,mBACb;AAdwB;AAgBb,QAAc,iBAAG,IAAkB;AACsC;AACtF,QAAc,eAAI,IAAC,QAAO,QAAiB;AAC3C,QAAc,eAAI,IAAC,QAAO,QAAkB;AAC5C,QAAc,eAAI,IAAC,QAAO,QAAiB;AAC3C,QAAc,eAAI,IAAC,QAAO,QAAe;AACzC,QAAc,eAAI,IAAC,QAAO,QAAU;AACpC,QAAc,eAAI,IAAC,QAAO,QAAW;AACrC,QAAc,eAAI,IAAC,QAAO,QAAoB;AAC9C,QAAc,eAAI,IAAC,QAAO,QAAqB;AAC/C,QAAc,eAAI,IAAC,QAAO,QAAoB;AAC9C,QAAc,eAAI,IAAC,QAAO,QAAkB;AAE/B,QAAY,eAAG,IAAkB;AACwC;AACtF,QAAY,aAAI,IAAC,QAAO,QAAe;AACvC,QAAY,aAAI,IAAC,QAAO,QAAiB;AACzC,QAAY,aAAI,IAAC,QAAO,QAAW;AACnC,QAAY,aAAI,IAAC,QAAO,QAAU;AAClC,QAAY,aAAI,IAAC,QAAO,QAAkB;AAC1C,QAAY,aAAI,IAAC,QAAO,QAAoB,mB;;;;;;;;;;;;;AClFzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAKxD,sCAAsG;AAEtG,IAAqB;AACb,YAAG;AACH,YAAG;AACL,UAAG;AACF,WAAG;AACL,SAAG;AACD,WACL;AAPsB;AASxB,IAGC;AAHD,WAAkB;AAChB,uDAAY;AACZ,2DACF;AAAC,GAHiB,kCAGjB;AAED;AAAuC,iCAA6B;AAiDlE,+BAA6C;AAA7C,oBACE,wCAA2B,kBAAe,iBAAc,aACzD;AAZwF;AACjF,cAAgC,mCAAQ;AAM7C;;;;;AACK,cAAgC,mCAAQ;eAIhD;AAAC;AAlDD,0BAAW,mBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,mBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,mBAAc;aAAzB;AACE;AACU,0BAAE;AAAM,2BAAS;AAAA;AACJ,uCAAE;AAAM,2BAAS;AAAA;AACnB,qCAAE;AAAM,2BAAK;AAAA;AACd,oCAAE;AAAM,2BAAS;AAAA;AAChB,qCAAE;AAAM,2BAAS;AAAA;AACxB,8BAAE;AAAM,2BAAI;AAAA;AACM,gDAAE;AAAM,2BAAe;AAAA;AAChC,uCAAE;AAAM,2BAAE;AAAA;AACN,2CAAE;AAAM,2BAAe;AAAA;AACxC,0BAAE;AAAM,2BAAK;AAAA;AACP,gCAAE;AAAM,2BAAK;AAAA;AACtB,uBAAE;AAAM,2BAAK;AAAA;AACO,2CAAE;AAAM,2BAAK;AAAA;AACtB,kCAAE;AAAM,2BAAS;AAAA;AAClB,iCAAE;AAAM,2BAAS;AAAA;AACf,mCAAE;AAAM,2BAAS;AAAA;AAClB,kCAAE;AAAM,2BAAS;AAAA;AACpB,+BAAE;AAAM,2BAAS;AAAA;AACf,iCAAE;AAAM,2BAAS;AAAA;AACH,+CAAE;AAAM,2BAAS;AAAA;AACnC,6BAAE;AAAM,2BAAS;AAAA;AACF,4CAAE;AAAM,2BAAS;AAAA;AAClB,2CAAE;AAAM,2BAAS;AAAA;AACtB,sCAAE;AAAM,2BAAS;AAAA;AACrB,kCAAE;AAAM,2BAAS;AAErC;AA3BS;AA2BR;;sBAAA;;AAgBD,gCAAU,aAAV;AACE,eAAW,KAAQ,QAAS,SAAC,YAAU,WACzC;AAAC;AAED,gCAAU,aAAV;AACE,eAAW,KAAQ,QAAS,SAAC,YAAU,WACzC;AAAC;AAED,gCAAS,YAAT;AACE,eAAW,KAAQ,QAAS,SAAC,YAAU,WACzC;AAAC;AAED,gCAAW,cAAX,UAA6B;AACvB,aAAa,aAAW;AACxB,aAAiB,iBACvB;AAAC;AAED,gCAAsB,yBAAtB,UAAwC,UAA8B;AAChE,aAAa,aAAW;AAC5B,YAAuB,qBAAE;AACnB,iBAAwB,wBAAW;AAE3C;AAAC;AAED,gCAAkC,qCAAlC;AACE,eAAW,KACb;AAAC;AAED,gCAAkC,qCAAlC,UAAwD;AAClD,aAAiC,mCACvC;AAAC;AAED,gCAAkC,qCAAlC,UAAuD;AACjD,aAAiC,mCACvC;AAAC;AAED,gCAAa,gBAAb;AAAA,oBA2BC;AA1BC,YAAiB,cAAG;AAAM,mBAAI,MAAQ,QAA4B;AAAC;AACnE,YAAsB,mBAAG;AACrB,mBAAI,MAAQ,QAAiC;AAAC;AAE+D;AACxF;AACzB,YAAI,CAAK,KAAQ,QAAiB,kBAAE;AAClC,gBAAmB,gBAAsB;AACzC,gBAAiB,eAAE;AACjB,oBAAc,WAAiB;AACiF;AACzC;AACyC;AAC9D;AAClD;AACQ,4BAAU,SAAO;AACjB,4BAAU,SAAO;AACnB,0BAAU,SAAK;AACd,2BAAU,SAAM;AAClB,yBAAU,SAAI;AACZ,2BAAU,SAAM,QAAgB,cACrC;AAPK;AAQR;AACF;AAED,eACF;AAAC;AAIE;;;AACH,gCAAS,YAAT;AACM,aAAQ,QAAS,SAAC,YAAU,WAClC;AAAC;AAED,gCAAW,cAAX;AACM,aAAQ,QAAqB;AAC7B,aAA2B,2BAAK,KACtC;AAAC;AAED,gCAAiB,oBAAjB;AACE,YAAQ,KAAa,cAAE;AACjB,iBAAgB;AAExB;AAAC;AAIE;;;AACH,gCAAmB,sBAAnB,UAAwC;AAAxC,oBAyDC;AAxD2E;AAC1E,YAAkB,eACV,KAAQ,QAAoB,oBAAI,IAAO,QAAE,YAAU,WAAY;AACvE,YAAsB,mBAAM,IAAa,iBAAa;AACtD,YAAwB,qBAAM,IAAa,iBAAe;AAE1D,YAAgB,gBAAsB,oBAAE;AACmD;AACzF,gBAAe,cAAO,KAAQ,QAAsB,sBAAU;AAEwB;AACd;AACnD,kCAAC;AAChB,sBAAQ,QAAiB,iBAAQ,SAAa;AAEyB;AACvE,sBAAQ,QAAiB,iBAAU,WAAO;AAC1C,sBAAQ,QAAiB,iBAAS,UAAO;AAE8B;AACtD,sCAAC;AAChB,0BAAQ,QAAiB,iBAAQ,SACvC;AACF;AAAG;AACI;AACR;AAED,YAAgB,gBAAoB,kBAAE;AAChC,iBAAe;AACnB,gBAAyB,sBACjB,KAAQ,QAAa,aAAC,YAAO,QAAiC;AAElE,iBAAQ,QAAc,cAAsB;AACjD;AAEyG;AAC1G,YAAI,CAAmB,oBAAE;AAChB;AACR;AAED,YAA2B,wBACnB,KAAQ,QAAoB,oBAAI,IAAO,QAAE,YAAU,WAAc,iBACjE,KAAQ,QAAS,SAAC,YAAU,WAAW;AAC/C,YAA2B,wBACnB,KAAQ,QAAoB,oBAAI,IAAO,QAAE,YAAU,WAAW,cAClE,CAAK,KAAQ,QAAS,SAAC,YAAU,WAAW;AAEhD,YAAyB,uBAAE;AACrB,iBAAQ,QAAsB,sBAAC,YAAU,WAAsB;AAC5D;AACR;AAED,YAAyB,uBAAE;AACrB,iBAAQ,QAA2B,2BAAC,YAAU,WAAsB;AACjE;AAEX;AAAC;AAED,gCAAa,gBAAb,UAA6B;AACoC;AAC/D,YAAI,CAAK,KAAwB,wBAAK,MAAE;AAC/B;AACR;AAEG,aAAQ,QAAS,SAAC,YAAU,WAClC;AAAC;AAED,gCAAc,iBAAd,UAA8B;AACmC;AAC/D,YAAI,CAAK,KAAwB,wBAAK,MAAE;AAC/B;AACR;AAED,YAAQ,KAAY,aAAE;AAChB,iBAAiB;AACtB;AAEG,aAAQ,QAAY,YAAC,YAAU,WACrC;AAAC;AAKE;;;;AACH,gCAA+B,kCAA/B;AACM,aAAQ,QAAiC;AACzC,aACN;AAAC;AAIE;;;AACH,gCAAa,gBAAb,UAAgC;AAC9B,YAAQ,KAAY,aAAE;AACpB,gBAAQ,KAAoB,oBAAK,MAAE;AAC9B,oBAAkB;AACjB,qBAAiB;AACtB;AACwE;AAClD;AAChB;AACR;AAED,YAAQ,KAAa,cAAE;AACrB,gBAAQ,KAAmB,mBAAK,MAAE;AAC7B,oBAAkB;AACjB,qBAAgB;AACrB;AACF;AAED,YAAQ,KAAyB,yBAAK,MAAE;AAClC,iBAAQ,QAAqB;AAC7B,iBAA2B,2BAAK,KAAsB;AACnD;AACR;AAED,YAAQ,KAAgB,gBAAK,MAAE;AAC1B,gBAAkB;AACjB,iBAAe;AACZ;AACR;AAEqC;AACtC,YAAI,CAAC,YAAc,eAAI,IAAI,IAAK,MAAE;AACzB;AACR;AAE0E;AACxE,YAAkB;AACjB,aAAiB,iBAAI,IAAI,KAAE,YAAW,YAC5C;AAAC;AAED,gCAA8B,iCAA9B,UAAwE;AACtE,eAAW,KAAiB,iBAAI,IAAO,OAAI,KAAE,YAAW,YAC1D;AAAC;AAIE;;;AACH,gCAAW,cAAX;AACM,aAAQ,QAAqB,qBAAC,YAAO,QAAU,WAAQ;AACvD,aAAQ,QACd;AAAC;AAKE;;;;AACH,gCAAkB,qBAAlB;AACM,aAA2B,2BAAc,cAC/C;AAAC;AAKE;;;;AACH,gCAAmB,sBAAnB;AACE,YAA+B,4BAAO,KAAQ,QAA6B;AAC3E,YAA6B,2BAAE;AACzB,iBAAQ,QAAqB,qBAAC,YAAO,QAAU,WAAQ;AACvD,iBAAQ,QAAuB;AAC5B;AACR;AAEG,aACN;AAAC;AAEO,gCAA0B,6BAAlC,UAA+D;AACzD,aAAQ,QAAqB,qBAAC,YAAO,QAAU,WAAO;AAC1D,YAAiB,kBAAkB,cAAa,cAAE;AAC5C,iBAAQ,QAAsB;AACnC;AACG,aAAQ,QACd;AAAC;AAEO,gCAAiB,oBAAzB;AACE,YAAQ,KAAiC,kCAAE;AACzC,mBAAoB,cAAc;AACnC;AACD,eAAoB,cACtB;AAAC;AAEO,gCAAgB,mBAAxB,UAAoC,KAAqB;AACvD,YAA+B,4BAAO,KAAQ,QAA6B;AAC3E,YAAS,MAAO,KAAc,cAAM;AAEM;AAC1C,YAAI,YAAY,aAAI,IAAK,QAAI,CAA0B,2BAAE;AACvD,mBAAW,KAAQ,QAAiB,iBAAI,KAAU;AACnD;AAED,YAAU,WAAK,YAAW,YAAQ,WAAO,QAAK,YAAS,UAAM,OAAE;AAC7D,mBAAW,KAAuB;AACnC;AAED,YAAU,WAAK,YAAW,YAAS,YAAO,QAAK,YAAS,UAAK,MAAE;AAC7D,mBAAW,KAAsB;AAClC;AAEG,aAAQ,QAAiB,iBAAI,KAAE,YAAW,YAChD;AAAC;AAEO,gCAAa,gBAArB,UAAiC;AAC/B,YAAW,QAAO,KAAQ,QAAS;AACnC,YAAe,YACR,QAAK,YAAO,QAAe,kBAAO,QAAK,YAAO,QAAmB;AACxE,YAAgB,aACT,QAAK,YAAO,QAAgB,mBAAO,QAAK,YAAO,QAAoB;AAC1E,YAAI,CAAM,SAAa,aAAS,SAAc,YAAE;AAC9C,mBAAO,YAAS,UAAM;AACvB;AAED,eAAO,YAAS,UAClB;AAAC;AAEO,gCAAW,cAAnB;AACE,YAAQ,KAAiC,kCAAE;AACrC,iBAAa;AAErB;AAAC;AAEO,gCAAkB,qBAA1B,UAA6C;AAC3C,eAAW,KAAwB,wBAAK,QAAO,IAAI,QAAK,YAAO,QACjE;AAAC;AAEO,gCAAmB,sBAA3B,UAA8C;AAC5C,eAAU,IAAI,QAAK,YAAO,QAC5B;AAAC;AAEO,gCAAwB,2BAAhC,UAAmD;AACjD,eAAU,IAAI,QAAK,YAAO,QAAU,aAAO,IAAI,QAAK,YAAO,QAC7D;AAAC;AAEO,gCAAe,kBAAvB,UAA0C;AACxC,YAAiB,cAAO,KAAQ,QAAS,SAAC,YAAU,WAAY;AAChE,eACI,gBAAI,IAAI,QAAK,YAAO,QAAc,iBAAO,IAAI,QAAK,YAAO,QAAW,cAChE,IAAI,QAAK,YAAO,QAC1B;AAAC;AAEO,gCAAY,eAApB,UAAsC;AACpC,YAAY,UAAE;AACR,iBAAQ,QAAS,SAAC,YAAU,WAAW;AACvC,iBAAQ,QAAqB,qBAAC,YAAO,QAAa,cAAU;AACjE,eAAM;AACD,iBAAQ,QAAY,YAAC,YAAU,WAAW;AAC1C,iBAAQ,QAAqB,qBAAC,YAAO,QAAa,cAAW;AAErE;AAAC;AAEO,gCAAgB,mBAAxB,UAA0C;AACpC,aAAQ,QAAgB,gBAAS,UACvC;AAAC;AAEO,gCAAuB,0BAA/B,UAAiD;AAC3C,aAAQ,QAAgB,gBAAS,UACvC;AAAC;AAEO,gCAAuB,0BAA/B,UAA0C;AACxC,eAAW,KAAQ,QAAoB,oBAChC,IAAO,QAAE,YAAU,WAC5B;AAAC;AAEO,gCAAY,eAApB;AACM,aAAQ,QAAS,SAAC,YAAU,WAAU;AACtC,aAAQ,QACd;AAAC;AAEO,gCAAa,gBAArB;AACM,aAAQ,QAAY,YAAC,YAAU,WAAU;AACzC,aAAQ,QACd;AAAC;AACH,WAAC;AAAA,EA5ZsC,aA4ZtC;AA5ZY,4BAAiB;AA8ZmF;AACjH,kBAAiC,kB;;;;;;;;;;;;;ACtb9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA6B;AAE7B,sCAAiF;AAAzE,qCAA4B;AAAE,kCAAsB,Q;;;;;;;;;;;;;ACNzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,6BAAuC;AACvC,6BAA6B;AAC7B,6BAAiC,mE;;;;;;;;;;;;;ACJ9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAGtD,sCAAuE;AACvE,uCAAgE;AAGhE,sCAAoC;AACpC,uCAA6D;AAU7D;AACI,qCAA6C;AADjD;mEAkFA;AAAC;AA/EC,0BAAI,iCAAM;aAAV;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAEM,0BAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAyB,sBAClC;AAAC;AAQD,oCAAU,aAAV,UAEqC;AADjC;AAAA,mDAAqC,IAAY;AAC7C,2BAAI,YAAS,UAAG,IAAa;AAAA;;AACyC;AACP;AACL;AAChE,YAAmB,gBAAqB,YAAS,UAAc,cAAO;AAClE,aAAQ,UACK,cAAK,KAAK,MAAE,IAAI,aAAmB,oBACtD;AAAC;AAED,oCAAkB,qBAAlB;AAAA,oBAUC;AATK,aAAa,eAAG,UAAgB;AAC9B,kBAAW,WAAY,YAC7B;AAAE;AACE,aAAe,iBAAG,UAAmB;AACnC,kBAAW,WAAc,cAC/B;AAAE;AAEE,aAAO,OAAQ,SAAM,KAAe;AACpC,aAAO,OAAU,WAAM,KAC7B;AAAC;AAED,oCAAO,UAAP;AACM,aAAQ,QAAW;AACnB,aAAS,SAAQ,SAAM,KAAe;AACtC,aAAS,SAAU,WAAM,KAAiB;AAC9C,yBAAa,aACf;AAAC;AAED,oCAAoB,uBAApB;AAAA,oBAsBC;AArB6E;AACP;AACL;AAChE,YAAa;AACN,mBAAE;AACwD;AACxD,sBAAqB,KAC5B;AAAC;AACW,0BAAE,sBAAK;AAAK,uBAAI,MAAK,KAAa,aAAM;AAAA;AACnC,+BAAE,2BAAQ;AACvB,uBAAI,MAAK,KACL,YAAO,QAAkB,mBAAE,EAAQ,SAAC,WAAM,KAAoB;AAAA;AACtD,8BAAE,0BAAI;AAChB,sBAAK,KACL,YAAO,QAAiB,kBAAE,EAAI,KAAC,OAAM,KAC3C;AAAC;AACW,0BAAE,sBAAK,MAAO;AACpB,sBAAK,KAAa,aAAK,MAC7B;AACA;AAhB4C;AAiB9C,eAAO,IAAI,aAA+B,gCAC5C;AAAC;AAED,oCAAW,cAAX;AACE,eAAW,KAAW,WACxB;AAAC;AAED,oCAAK,QAAL;AACM,aAAW,WACjB;AAAC;AAED,oCAAW,cAAX;AACM,aAAW,WACjB;AAAC;AACH,WAAC;AAAA,EAjFG,YAiFH;AAlFY,gCAAqB,sB;;;;;;;;;;;;;ACpB/B;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAOC;AAPD,WAA8B;AAC5B,gEAAW;AACX,0DAAK;AACL,kEAAa;AACb,+DAAU;AACV,iEAAY;AACZ,8DACF;AAAC,GAP6B,qBAAlB,QAAkB,uBAAlB,QAAkB,qBAO7B;AAEY,QAAO;AACP,iBAAe;AACT,uBAAqC;AACtC,sBAAoC;AAC3C,eACT;AALqB,E;;;;;;;;;;;;;ACXpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AACxD,qCAA4E;AAG5E,sCAAwD;AAExD;AACI,+CAA2C;AAe7C,6CAA2D;eACzD,wCAAyC,gCAAe,iBAAc,aACxE;AAAC;AAhBD,0BAAW,iCAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,iCAAc;aAAzB;AACE;AACO,uBAAE;AAAM,2BAAS;AAAA;AACV,8BAAE;AAAM,2BAAI;AAAA;AACZ,8BAAE;AAAM,2BAAS;AAAA;AACZ,mCAAE;AAAM,2BAAS;AAAA;AAClB,kCAAE;AAAM,2BAAS;AAErC;AAPS;AAOR;;sBAAA;;AAMD,8CAAW,cAAX,UAA2B;AACtB,YAAmB;AAClB,aAAQ,QAAkB,kBAAC,YAAkB,mBACnD;AAAC;AAED,8CAAa,gBAAb,UAAgC;AAC3B,YAAmB;AACtB,YAAS,MAAG,WAAY,aAAM;AAC9B,YAAQ,KAAgC,gCAAK,MAAE;AAC7C,gBAAa,UAAO,KAAmB,mBAAM;AACzC,iBAAQ,QAAkB,kBAAU;AACjC;AACR;AAED,YAAI,WAAiB,kBAAK,MAAE;AACtB,iBAAQ,QAAiB,iBAAM;AAC5B;AAEX;AAAC;AAED,8CAAW,cAAX;AACM,aAAQ,QAAa,aAAC,YAAO,QAAU,WAC7C;AAAC;AAED,8CAAK,QAAL;AACM,aAAQ,QAAa,aAAC,YAAO,QAAU,WAAO;AAC9C,aAAQ,QACd;AAAC;AAED,8CAAW,cAAX;AACE,eAAW,KAAQ,QAAa,aAAC,YAAO,QAAa,iBACvD;AAAC;AAEO,8CAA+B,kCAAvC,UAAmD;AACjD,YAAqB,kBAAM,QAAK,WAAG,IAAM,SAAO,QAAK,WAAG,IAAU;AAClE,YAAqB,kBAAM,QAAK,WAAG,IAAU,aAAO,QAAK,WAAG,IAAQ;AAEpE,eAAsB,mBACxB;AAAC;AAEO,8CAAkB,qBAA1B,UAAsC;AACpC,YAAO,QAAK,WAAG,IAAS,UAAE;AACxB,mBAAO,YAAkB,mBAAc;AACxC;AAED,YAAO,QAAK,WAAG,IAAM,OAAE;AACrB,mBAAO,YAAkB,mBAAW;AACrC;AAED,YAAO,QAAK,WAAG,IAAO,QAAE;AACtB,mBAAO,YAAkB,mBAAY;AACtC;AAED,YAAO,QAAK,WAAG,IAAU,WAAE;AACzB,mBAAO,YAAkB,mBAAe;AACzC;AAEwC;AACzC,eAAO,YAAkB,mBAC3B;AAAC;AACH,WAAC;AAAA,EA/EG,aA+EH;AAhFY,0CAA+B;AAkFqE;AACjH,kBAA+C,gC;;;;;;;;;;;;;AC3F5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA6B;AAE7B,sCAA6D;AAArD,4CAAgC,Q;;;;;;;;;;;;;ACNrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAGtD,uCAA2D;AAE3D;AACI,mCAA2C;AAD/C;mEAwEA;AAAC;AAnEC,kCAAU,aAAV;AACM,aAAmB,qBAAO,KAAK,KAAc,cAC7C,aAA6B,8BAAQ,QAC3C;AAAC;AAEM,wBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAuB,oBAChC;AAAC;AAMD,0BAAI,+BAAW;AADZ;;;;aACH,aAA8B;AACxB,iBAAW,WAAe,eAChC;AAAC;;sBAAA;;AAQD,0BAAI,+BAAQ;AADT;;;;;;aACH,aAA0B;AACpB,iBAAW,WAAY,YAC7B;AAAC;;sBAAA;;AAKD,0BAAI,+BAAQ;AADT;;;aACH;AACE,mBAAW,KAAW,WACxB;AAAC;;sBAAA;;AAIE;;;AACH,kCAAI,OAAJ;AACM,aAAW,WACjB;AAAC;AAIE;;;AACH,kCAAK,QAAL;AACM,aAAW,WACjB;AAAC;AAED,kCAAoB,uBAApB;AAAA,oBAkBC;AAjB6E;AACP;AACL;AAChE,YAAa;AACH,sBAAE,kBAAkB;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AACtC,2CAAE,uCAAsB;AACjD,uBAAI,MAAmB,mBAAa,aAAe;AAAA;AAC/C,sBAAE,kBAAkB;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AAC7D,yBAAE,qBAAkB;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AAC1D,6BAAE,yBAAsB;AACnC,uBAAI,MAAK,KAAgB,gBAAe;AAAA;AAChC,0BAAE,sBAAsB,eAAe;AAC/C,uBAAI,MAAK,KAAa,aAAc,eAAQ;AAAA;AACnB,2CAAE,uCAAsB,eAAe;AAChE,uBAAI,MAAmB,mBAAa,aAAc,eAAQ;AAC9D;AAZ0C;AAa5C,eAAO,IAAI,aAA6B,8BAC1C;AAAC;AACH,WAAC;AAAA,EAvEG,YAuEH;AAxEY,8BAAmB,oB;;;;;;;;;;;;;ACP7B;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;;AACU,QAAU;AACF,uBAAwC;AAC/C,gBACZ;AAHwB;AAOvB;;;AACU,QAAO;AACS,+BAA8C;AAC5D,iBAAiB;AACxB,UAAK;AACM,qBACjB;AALqB,E;;;;;;;;;;;;;ACbpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAGxD,sCAAgD;AAEhD;AACI,6CAAyC;AA2B3C,2CAAyD;eACvD,wCAAuC,8BAAe,iBAAc,aACtE;AAAC;AA3BD,0BAAW,+BAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,+BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,+BAAc;aAAzB;AACE;AACU,0BAAE;AAAM,2BAAS;AAAA;AACI,+CAAE;AAAM,2BAAI;AAAA;AACjC,0BAAE;AAAM,2BAAK;AAAA;AACV,6BAAE;AAAM,2BAAS;AAAA;AACb,iCAAE;AAAM,2BAAS;AAAA;AACpB,8BAAE;AAAM,2BAAS;AAAA;AACA,+CAAE;AAAM,2BAAS;AAElD;AATS;AASR;;sBAAA;;AAWD,4CAAI,OAAJ;AACM,aAAU,YAAO,KAAQ,QAAS,SAAC,YAAU,WAAe;AAC5D,aAAe,iBACf,CAAK,KAAQ,QAAS,SAAC,YAAU,WAAsB;AACvD,aAAU,YAAK;AAEnB,YAAQ,KAAe,gBAAE;AACnB,iBAAQ,QAAa,aACrB,YAAO,QAAc,eAAM,KAAU,UAAa;AACvD;AAEG,aAAQ,UACF,OAAK,KAAQ,QAA8B,8BAAC,YAAO,QAC/D;AAAC;AAED,4CAAa,gBAAb;AACE,eAAW,KACb;AAAC;AAED,4CAAW,cAAX;AACE,eAAW,KACb;AAAC;AAIE;;;AACH,4CAAQ,WAAR;AACE,eAAW,KACb;AAAC;AAKE;;;;AACH,4CAAc,iBAAd,UAAqC;AAC/B,aAAe,iBAAiB;AAEpC,YAAQ,KAAe,gBAAE;AACnB,iBAAQ,QAAY,YAAC,YAAU,WAAsB;AACrD,iBAAY,YAAK,KAAY;AAClC,eAAM;AACD,iBAAQ,QAAS,SAAC,YAAU,WAAsB;AAClD,iBAAQ,QAAgB,gBAAC,YAAO,QAAgB;AAExD;AAAC;AAOE;;;;;;AACH,4CAAW,cAAX,UAAyB;AACnB,aAAU,YAAS;AACvB,YAAQ,KAAe,gBAAE;AACvB,gBAAuB,oBACnB,CAAE,IAAO,KAAc,cAAE,IAAO,KAAG,KAAO,KAAU;AAEpD,iBAAQ,QAA8B,8BACtC,YAAO,QAAkB,mBAAE,KAAwB;AACnD,iBAAQ,QAAa,aACrB,YAAO,QAAc,eAAM,KAAU,UAAa;AAE1D;AAAC;AAIE;;;AACH,4CAAI,OAAJ;AACM,aAAU,YAAS;AACnB,aAAQ,QAAY,YAAC,YAAU,WACrC;AAAC;AAIE;;;AACH,4CAAK,QAAL;AACM,aAAU,YAAQ;AAClB,aAAQ,QAAS,SAAC,YAAU,WAClC;AAAC;AACH,WAAC;AAAA,EA/GG,aA+GH;AAhHY,wCAA6B;AAkHuE;AACjH,kBAA6C,8B;;;;;;;;;;;;;AC1H1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,uE;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,sCAA6E;AAC7E,qCAA+C;AAG/C,sCAA+F;AAC/F,uCAAoD;AAKjD;;;AACH;AAAkC,4BAAoC;AAAtE;mEAkRA;AAAC;AAjRQ,iBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAgB,aACzB;AAAC;AAYD,2BAAU,aAAV,UAAqF;AAA1E;AAAA,uDAAkD;AAAK,2BAAI,YAAW,YAAI;AAAA;;AAC/E,aAAgB,kBACtB;AAAC;AAED,2BAAkB,qBAAlB;AAAA,oBAoBC;AAnBK,aAAU,YACN,KAAK,KAAc,cAAC,MAAI,YAAU,WAA8B;AACpE,aAA8B,gCAAG;AACjC,mBAAI,MAAW,WAAgC;AAAC;AAChD,aAAU,UAAiB,iBACnB,UAAM,KAAgC;AAE9C,aAAuB,yBAAG,UAAM;AAC9B,kBAAqB,qBAC3B;AAAE;AACE,aAAU,UAAiB,iBAAQ,SAAM,KAAyB;AAElE,aAAQ,UACJ,KAAK,KAAc,cAAC,MAAI,YAAU,WAA2B;AACjE,aAAwB,0BAAG,UAAM;AACjC,mBAAI,MAAW,WAAwB,wBAAO;AAAC;AAC/C,aAAQ,QAAiB,iBAAS,UAAM,KAA0B;AAElE,aACN;AAAC;AAIE;;;AACH,2BAAM,SAAN;AACM,aAAW,WACjB;AAAC;AAIE;;;AACH,2BAAc,iBAAd;AACE,eAAS,GAAM,MAAK,KAAK,KAAK,KAAiB,iBAAC,YAAS,UAC3D;AAAC;AAIE;;;AACH,2BAAO,UAAP;AACE,eAAW,KAAW,WACxB;AAAC;AAIE;;;AACH,2BAAiB,oBAAjB;AACE,eAAW,KAAW,WACxB;AAAC;AAKE;;;;AACH,2BAAiB,oBAAjB,UAAkC;AAC5B,aAAW,WAAkB,kBACnC;AAAC;AAED,2BAAO,UAAP;AACM,aAAU,UAAoB,oBACtB,UAAM,KAAgC;AAC9C,aAAU,UAAoB,oBAAQ,SAAM,KAAyB;AACrE,aAAQ,QAAoB,oBAAS,UAAM,KAA0B;AAErE,aAAkB,kBAAW;AAC7B,aAAgB,gBAAQ,QAAC,UAAS;AAC5B,qBACV;AACF;AAAC;AAED,2BAAoB,uBAApB;AAAA,oBAmJC;AAlJuG;AACG;AACD;AACxG,YAAa;AACH,sBAAE,kBAAU;AACd,sBAAK,KAAU,UAAI,IACzB;AAAC;AACU,yBAAE,qBAAU;AACjB,sBAAK,KAAU,UAAO,OAC5B;AAAC;AACoB,mCAAE;AAAM,uBAAI,MAAiB;AAAA;AAChC,gCAAE;AAAM,uBAAI,MAAiB,iBAAO;AAAA;AACzB,2CAAE,uCAAM,OAAW;AAC9C,uBAAW,MAAiB,iBAAO,OAAa,aAClD;AAAC;AAC4B,2CAAE,uCAAM,OAAW,WAAO;AACjD,sBAAiB,iBAAO,OAAa,aAAU,WACrD;AAAC;AAC4B,2CAAE,uCAAM,OAAW;AAC1C,sBAAiB,iBAAO,OAAU,UAAI,IAC5C;AAAC;AAC+B,8CAAE,0CAAM,OAAW;AAC7C,sBAAiB,iBAAO,OAAU,UAAO,OAC/C;AAAC;AACe,8BAAE,0BAAK;AACjB,sBAAK,KAAC,YAAM,OAAO,QAAM,MAAqB,mBACpD;AAAC;AACiB,gCAAE;AAClB,oBAAe,YACP,MAAK,KAAc,cAAc,YAAS,UAAU;AAE5D,oBAAI,CAAU,WAAE;AACd,0BAAM,IAAS,MAAgD;AAChE;AAED,uBAAmB,UAAwB,wBAAO,SACpD;AAAC;AACmB,kCAAE;AACpB,oBAAiB,cACT,MAAK,KAAc,cAAc,YAAS,UAAa;AAE/D,oBAAI,CAAY,aAAE;AAChB,0BAAM,IAAS,MAAkD;AAClE;AAED,uBAAqB,YAAwB,wBAAO,SACtD;AAAC;AACyB,wCAAE,oCAAO;AACjC,oBAAuB,oBACf,MAAK,KAAc,cAAc,YAAS,UAAqB;AAEvE,oBAAI,CAAkB,mBAAE;AACtB,0BAAM,IAAS,MAC4C;AAC5D;AAEY,yBAAkB,kBAAM,OACvC;AAAC;AACiB,gCAAE,4BAAiB,UAAmB;AAClD,sBAAU,UAAU,UAAU,UAAI,IACxC;AAAC;AACU,yBAAE;AAAM,uBAAI,MAAU,UAAO;AAAA;AAC1B,4BACV;AAAM,uBAAE,GAAM,MAAK,KAAK,MAAK,KAAiB,iBAAC,YAAS,UAAM;AAAA;AACnD,6BAAE,yBAAiB;AAC9B,uBAAI,MAAU,UAAU,UAAa,aAAC,YAAc,eAAQ;AAAA;AACvC,uCAAE,mCAAY;AACrC,uBAAW,MAAU,UAAQ,QACxB,WAAO,QAAG,IAAE,YAAS,UAC5B;AAAC;AACkB,iCAAE;AACjB,uBAAI,MAAK,KAAiB,iBAAC,YAAS,UAAc,cAAO;AAAA;AAClC,yCAAE,qCAAiB;AAC1C,uBAAI,MAAgB,gBAAU,UAAQ;AAAA;AAChB,wCAAE;AAAM,uBAAI,MAAkB,kBAAQ;AAAA;AAChD,8BAAE;AAAM,wBAAC,CAAK,MAAK,KAAc,cAAC,YAAS,UAAc;AAAA;AAChD,uCACrB,mCAAiD;AAC3C,sBAAK,KACL,YAAM,OAAsB;AACvB,yBAAM,MAAc,cAAK,KAAU;AACjC,2BAAM,MAAgB,gBAAK,KAAU;AAClC,8BAAM,KAAS;AACf,8BAAM,KACf;AAL6B;AAMX,mCACzB;AAAC;AACY,+BAAE;AACb,sBAAK,KAAC,YAAM,OAAa,cAAI,IAAqB,mBACxD;AAAC;AACkB,iCAAE;AACf,sBAAK,KAAC,YAAM,OAAe,gBAAI,IAAqB,mBAC1D;AAAC;AACwB,uCAAE;AACzB,oBAAQ,MAAkB,mBAAE;AACtB,0BAAkB,kBAAW;AAClC;AAED,oBAAgB,aACP,MAAK,KAAc,cAAC,YAAS,UACpB;AACd,sBAAkB,oBAAO,MAAgB,gBAC/C;AAAC;AACoB,mCAAE;AACrB,oBAAQ,MAAgB,iBAAE;AACpB,0BAAgB,gBAAQ,QAAC,UAAS;AAC5B,iCACV;AAAG;AACJ;AAEG,sBAAgB,kBAAM;AACtB,sBAAU,UAAQ,QAAC,UAAM;AAC3B,wBAAc,WAAO,MAAgB,gBAC3B,MAAc,cAAC,YAAS,UAAgC;AAC9D,0BAAgB,gBAAK,KAC3B;AACF;AAAC;AACoB,mCAAE,+BAAiB,UAAmB;AACrD,sBAAU,UAAU,UAAU,UAAO,OAC3C;AAAC;AACqB,oCAClB,gCAAiB,UAAc,MAAe;AACxC,sBAAU,UAAU,UAAa,aAAK,MAC5C;AAAC;AACsB,yCAAE,qCAAiB;AACxC,sBAAkB,kBAAQ,UAChC;AAAC;AACgC,+CAAE,2CAAuB;AACpD,sBAAkB,kBAAc,gBACtC;AAAC;AAC2B,0CAAE,sCAAiB,UAAkB;AAC3D,sBAAgB,gBAAU,UAAQ,UACxC;AAAC;AACkC,iDAAE,6CACd,aAAsB;AAC3C,oBAAgB,aAAO,MAAiB,iBAAc;AACtD,oBAAqB,kBACP,WAAc,cAAc,YAAS,UAAoB;AAEvE,oBAAI,CAAgB,iBAAS;AAEd,gCAAY,cACnB,MAAgC,gCAC1C;AACA;AA7ImC;AA8IrC,eAAO,IAAI,aAAsB,uBACnC;AAAC;AAEO,2BAAa,gBAArB,UAAmC;AACjC,eAAW,KAAU,UACvB;AAAC;AAEO,2BAAe,kBAAvB,UAAqC;AACnC,eAAW,KAAc,cAAO,OAAa,aAAC,YAAc,eAC9D;AAAC;AAEO,2BAAoB,uBAA5B,UAAyC;AACvC,YAAgB,aACZ,WAAO,QAAM,MAAkB,QAAE,YAAS,UAC9B;AAEhB,YAAI,CAAW,YAAE;AACR;AACR;AAED,YAAc,WAAa,WAAa,aAAC,YAAc,eAAY;AACnE,YAAiB,cAAO,KAAiB,iBAAQ,QAAa;AAC9D,YAAe,gBAAK,CAAE,GAAE;AACf;AACR;AAEG,aAAW,WAAiB,iBAAC,EAAS,oBAAa,0BAAY,YACrE;AAAC;AAEO,2BAA+B,kCAAvC,UAA4D;AAC1D,gBAAmB;AACjB,iBAAK,YAAS,UAAU;AACtB,uBAAO,YAAQ,SAAqB;AACtC,iBAAK,YAAS,UAAW;AACvB,uBAAO,YAAQ,SAAsB;AACvC;AACE,uBAEN;;AAAC;AACH,WAAC;AAAA,EAlRiC,YAkRjC;AAlRY,uBAAY,a;;;;;;;;;;;;;ACftB;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;;AACU,QAAU;AACjB,QAAwB;AAChB,gBAAiC;AACtC,WAA2B;AACvB,eAA+B;AACzB,qBAAqC;AACpC,sBAAuC;AAC5B,iCACuB;AAC/B,yBAA0C;AAC5C,uBAAuC;AAChD,cAA8B;AACrB,uBAAuC;AAC/C,eAA+B;AACxB,sBAAsC;AACpD,QAAkB;AACnB,OAAuB;AACd,gBAAgC;AAChC,gBAAiC;AAC7B,oBAAoC;AACnC,qBAAqC;AACvB,mCACsB;AACvB,kCAE9B;AAzBwB;AA6BvB;;;AACU,QAAU;AACR,iBAAiB;AACrB,aACT;AAHwB;AAOvB;;;AACU,QAAc;AAChB,aAAkB;AACrB,UACN;AAH4B;AAO3B;;;AACU,QAAS;AACb,WAAE,MAAI,QAAU,WAAU;AACtB,eAAE,MAAI,QAAU,WAAc;AACpB,yBAAE,MAAI,QAAU,WAAwB;AACnD,cAAE,MAAI,QAAU,WAAa;AACpB,uBAAE,MAAI,QAAU,WAAsB;AACvC,sBAAE,MAAI,QAAU,WAAqB;AACpD,OAAE,MAAI,QAAU,WAAM;AACb,gBAAE,MAAI,QAAU,WAAe;AAC/B,gBAAE,MAAI,QAAU,WAAe;AAC3B,oBAAE,MAAI,QAAU,WAAmB;AAClC,qBAAE,MAAI,QAAU,WACjC;AAZuB;AAgBtB;;;AACU,QAAQ;AACC,wBAA8B;AAC/B,uBACnB;AAHsB;AAQrB;;;;AACU,QAAO;AACL,iBAAE,QAAU,WAAc;AAC9B,aAAE,QAAU,WAAU;AACf,oBAAE,QAAc,eAAO;AACX,gCAAE,QAAS,UAAoB;AACtC,yBAAE,QAAS,UAAa;AACxB,yBAAE,QAAS,UAAa;AACjC,gBAAE,QAAS,UACvB;AARqB;AAapB;;;;AACH,IAYC;AAZD,WAAqB;AACmC;AACtD,2BAAuB;AAEgC;AACvD,4BAAyB;AAEyB;AAClD,sBAAa;AAE2D;AACxE,uBACF;AAAC,GAZoB,YAAT,QAAS,cAAT,QAAS,YAYpB;AAIE;;;AACU,QAAM;AACI,yBAAoC;AAC7C,gBAA4B;AAC1B,kBAA8B;AACtC,UACN;AALoB,E;;;;;;;;;;;;;AC5GnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAGxD,sCAA2D;AAMxD;;;;AACH;AAA4C,sCAAkC;AAsC5E,oCAAkD;eAChD,wCAAgC,uBAAe,iBAAc,aAC/D;AAAC;AAvCD,0BAAW,wBAAc;aAAzB;AACE;AACU,0BAAE;AAAM,2BAAS;AAAA;AACP,oCAAE;AAAM,2BAAS;AAAA;AACN,+CAAE;AAAM,2BAAE;AAAA;AACrB,oCAAE;AAAM,2BAAC;AAAA;AACN,uCAAE;AAAM,2BAAE;AAAA;AACpB,6BAAE;AAAM,2BAAC;AAAA;AACN,gCAAE;AAAM,2BAAE;AAAA;AACT,iCAAE;AAAM,2BAAE;AAAA;AACA,2CAAE;AAAM,2BAAC;AAAA;AACf,qCAAE;AAAM,2BAAC;AAAA;AACV,oCAAE;AAAM,2BAAE;AAAA;AACR,sCAAE;AAAM,2BAAE;AAAA;AACH,6CAAE;AAAM,2BAAK;AAAA;AACd,4CAAE;AAAM,2BAAK;AAAA;AACvB,kCAAE;AAAM,2BAAK;AAAA;AACJ,2CAAE;AAAM,2BAAS;AAAA;AACzB,mCAAE;AAAM,2BAAS;AAAA;AAClB,kCAAE;AAAM,2BAAS;AAAA;AACd,qCAAE;AAAM,2BAAS;AAAA;AACX,2CAAE;AAAM,2BAAS;AAAA;AACrB,uCAAE;AAAM,2BAAS;AAAA;AAC3B,6BAAE;AAAM,2BAAS;AAAA;AACP,uCAAE;AAAM,2BAAS;AAAA;AACN,kDAAE;AAAM,2BAAS;AAAA;AAC3B,wCAAE;AAAM,2BAAS;AAAA;AACV,+CAAE;AAAM,2BAAS;AAAA;AACjB,+CAAE;AAAM,2BAAS;AAAA;AACnB,6CAAE;AAAM,2BAAS;AAAA;AACX,mDAAE;AAAM,2BAAS;AAAA;AACxB,4CAAE;AAAM,2BAAS;AAAA;AACf,8CAAE;AAAM,2BAAS;AAAA;AACV,qDAAE;AAAM,2BAAS;AAExD;AAlCS;AAkCR;;sBAAA;;AASE;;;;AACH,qCAAM,SAAN;AACE,YAAQ,KAAQ,QAAmB,oBAAE;AAC/B,iBAAQ,QAA6B;AACrC,iBAAQ,QAAyB;AAEjC,iBAA6B;AAErC;AAAC;AAKE;;;;AACG,qCAAW,cAAjB;;;;;6BACU,KAAQ,QAAmB,oBAA/B,qBAA+B;AACjC,6CAAU,KAAQ,QAA4B;;AAA9C,2BAA+C;AAC/C,6CAAU,KAAQ,QAAwB;;AAA1C,2BAA2C;AAEvC,6BAA6B;;;;;;;AAEpC;AAIE;;;AACH,qCAAO,UAAP;AACE,eAAW,KAAQ,QACrB;AAAC;AAIE;;;AACH,qCAAc,iBAAd;AACE,eAAW,KAAQ,QACrB;AAAC;AAKE;;;;AACH,qCAAiB,oBAAjB,UAAkC;AAChC,aAAK,IAAY,WAAI,GAAU,WAAO,KAAQ,QAAc,eAAY,YAAE;AACxE,gBAAW,QAAO,KAAQ,QAAgB,gBAAW;AAErD,gBAAc,aAAS;AACvB,gBAAS,SAAU,OAAQ,QAAO,UAAK,GAAE;AAC7B,6BAAQ;AACnB;AAEG,iBAAQ,QAA6B,6BAAS,UAAc;AAC5D,iBAAiB,iBAAS,UAAc;AAC7C;AAEG,aACN;AAAC;AAIE;;;AACH,qCAAS,YAAT;AACE,YAAY,SAAM;AAClB,aAAK,IAAY,WAAI,GAAU,WAAO,KAAQ,QAAc,eAAY,YAAE;AAClE,mBAAK,KAAK,KAAQ,QAAgB,gBAAY;AACrD;AAED,eACF;AAAC;AAIE;;;AACH,qCAAiB,oBAAjB;AACE,YAAoB,iBAA0B;AAC9C,aAAK,IAAY,WAAI,GAAU,WAAO,KAAQ,QAAc,eAAY,YAAE;AACxE,gBAAQ,KAAQ,QAA4B,4BAAU,WAAE;AACxC,+BAAK,KAAK,KAAQ,QAAgB,gBAAY;AAC7D;AACF;AAED,eACF;AAAC;AAIE;;;AACH,qCAA6B,gCAA7B;AACE,YAAqB,kBAAO,KAAQ,QAA8B;AAElE,aAAK,IAAY,WAAI,GAAU,WAAO,KAAQ,QAAc,eAAY,YAAE;AACpE,iBAAQ,QAA6B,6BAAS,UAAmB;AACjE,iBAAiB,iBAAS,UAAmB;AAClD;AAED,YAAmB,iBAAE;AACf,iBAAQ,QAAqB;AAClC,eAAM;AACD,iBAAQ,QAAuB;AAEvC;AAAC;AAIE;;;AACH,qCAAuB,0BAAvB,UAAoC;AAClC,YAAc,WAAO,KAAQ,QAA0B,0BAC9C,MAA6B;AAEtC,YAAY,aAAK,CAAE,GAAE;AACZ;AACR;AAED,YAAc,WAAO,KAAQ,QAA4B,4BAAW;AAEhE,aAAiB,iBAAS,UAAY;AACtC,aAA6B;AAEjC,YAAW,QAAO,KAAQ,QAAgB,gBAAW;AACjD,aAAQ,QAA0B,0BAAC,EAAM,cAAU,oBAAU,UACnE;AAAC;AAIE;;;AACH,qCAAgB,mBAAhB,UAA+C;AACtC,iCAAQ;YAAE,wBAAW;YAAE,uBAAwB;AAEG;AACzD,aAAK,IAAS,QAAI,GAAO,QAAO,KAAQ,QAAqB,sBAAS,SAAE;AACtE,gBAAS,UAAgB,aAAE;AAChB;AACV;AAEG,iBAAQ,QAAiC,iCACpC,OAAE,YAAU,WAAqB;AACtC,iBAAQ,QAAiC,iCACpC,OAAE,YAAU,WAAgC;AACjD,iBAAQ,QAA8B,8BACjC,OAAE,YAAO,QAAU,WAAE,YAAS,UAAO;AAC1C,iBAAQ,QAAoC,oCAAM,OAAE,YAAS,UAAO;AACzE;AAEkE;AAC/D,aAAQ,QAA8B,8BAC3B,aAAE,YAAU,WAAqB;AAEhD,YAAsB,mBAAO,KAAQ,QAA8B,8BACpD,aAAE,YAAO,QAAY;AACpC,YAAa,YAAG,YAAS,UAAM;AAEmB;AAClD,YAAoB,qBAAK,YAAS,UAAU,WAAE;AACxC,iBAAQ,QAA8B,8BAC3B,aAAE,YAAU,WAAgC;AACvD,iBAAQ,QAA8B,8BAC3B,aAAE,YAAO,QAAU,WAAE,YAAS,UAAa;AACjD,wBAAG,YAAS,UAAY;AACiB;AACnD,mBAA0B,qBAAK,YAAS,UAAW,YAAE;AAChD,iBAAQ,QAAiC,iCAC9B,aAAE,YAAU,WAAgC;AACvD,iBAAQ,QAA8B,8BAC3B,aAAE,YAAO,QAAU,WAAE,YAAS,UAAY;AAChD,wBAAG,YAAS,UAAW;AACjC,SANM,MAMA;AAC0C;AAC3C,iBAAQ,QAA8B,8BAC3B,aAAE,YAAO,QAAU,WAAE,YAAS,UAAY;AAChD,wBAAG,YAAS,UAAW;AACjC;AAEG,aAAQ,QAAoC,oCAAY,aAAa;AAErE,aAAQ,QAAiB;AACnB;AACG;AACD;AACD,uBAEb;AANgC;AAM/B;AAKE;;;;AACH,qCAAY,eAAZ;AACE,YAAY,SAAO,KAAQ,QAAsB;AACjD,YAAS,MAAO,KAAQ,QAAwB;AAE5C,aAAQ,QAA2B;AAC/B;AACH,iBACF;AAHqC;AAIpC,aAAQ,QAAS,SAAC,YAAU,WAClC;AAAC;AAIE;;;AACH,qCAAY,eAAZ;AACM,aAAQ,QAAY,YAAC,YAAU,WACrC;AAAC;AAIE;;;AACK,qCAAyB,4BAAjC;AACE,YAAQ,KAAQ,QAAsB,0BAAS,KAAQ,QAAc,eAAE;AACjE,iBAAQ,QAA4B,4BAAO;AAC3C,iBAAQ,QAAkC,kCAAQ;AACvD,mBAAc,KAAQ,QAAsB,0BAAM,GAAE;AAC/C,iBAAQ,QAAkC,kCAAQ;AAClD,iBAAQ,QAA4B,4BAAQ;AACjD,SAHM,MAGA;AACD,iBAAQ,QAAkC,kCAAO;AACjD,iBAAQ,QAA4B,4BAAQ;AAEpD;AAAC;AAIE;;;AACK,qCAAgB,mBAAxB,UAAyC,UAAmB;AAC1D,YAAY,UAAE;AACR,iBAAQ,QAAmB,mBAAS,UAAE,YAAU,WAAe;AAC/D,iBAAQ,QAAuB,uBACvB,UAAE,YAAO,QAAc,eAAU;AAC9C,eAAM;AACD,iBAAQ,QAAsB,sBAAS,UAAE,YAAU,WAAe;AAClE,iBAAQ,QAAuB,uBACvB,UAAE,YAAO,QAAc,eAAW;AAElD;AAAC;AACH,WAAC;AAAA,EAtR2C,aAsR3C;AAtRY,iCAAsB,uB;;;;;;;;;;;;;ACZhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA6B;AAC7B,6BAA4B,8D;;;;;;;;;;;;;ACLzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,uCAAmD;AACnD,qCAAwD;AACxD,sCAAqD;AAErD,uCAAiD;AAEjD,4CAA+B;AAGxB,+CAA+B;AAEtC;AAA+B,yBAAiC;AAAhE;mEAqKA;AAAC;AApKC,0BAAI,qBAAM;aAAV;AACE,mBAAW,KAAW,WACxB;AAAC;;sBAAA;;AAED,0BAAI,qBAAe;aAAnB;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAA0B;AACpB,iBAAW,WAAmB,mBACpC;AAAC;;sBAJA;;AAMD,0BAAI,qBAAgB;aAApB;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAA2B;AACrB,iBAAW,WAAoB,oBACrC;AAAC;;sBAJA;;AAMD,0BAAI,qBAAgB;aAApB;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAA8B;AACxB,iBAAW,WAAoB,oBACrC;AAAC;;sBAJA;;AAMM,cAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAa,UACtB;AAAC;AAkBD,wBAAU,aAAV,UACuG;;AAAnG;AAAA,yDAAiD,IAAc;AAAK,2BAAI,aAAS,UAAG,IAAe;AAAA;;AAErG,YAAe,YACP,KAAK,KAAc,cAAqB,QAAqB;AACrE,YAAI,CAAU,WAAE;AACd,kBAAM,IAAS,MAAC,iCAAsC,QAAmB,qBAAsB;AAChG;AACG,aAAW,aAAa;AACxB,aAAS,WACL,KAAK,KAAc,cAAqB,QAAmB;AAC/D,aAAS,WAAK,GAAM,MAAK,KACrB,KAAK,KAAiB,iBAAqB,QAAmB;AAClE,aAAe,iBAAO,KAAK,KAAc,cACzC,MAAW,QAAyB,2BAAK;AACzC,aAAkB,oBAAoB;AACtC,aAAe,iBAAM;;AAEzB,iBAAuB,kBAAI,KAAS,qDAAE;AAAjC,oBAAc;AACb,qBAAe,eAAK,KAAC,IAAI,YAAS,UAAY;AACnD;;;;;;;;;AACH;AAAC;AAED,wBAAkB,qBAAlB;AAAA,oBAwBC;AAvBK,aAAW,aAAO,KAAwB,wBACtC,KAAW,YAAM,KAAkB,mBAAM,KAAqB,wBAAe;AAEjF,aAAa,eAAO,KAAW,WAAY,YAAK,KAAK,KAAa;AAClE,aAAe,iBAAO,KAAW,WAAc,cAAK,KAAK,KAAa;AACtE,aAAuB,yBACnB,KAAW,WAAsB,sBAAK,KAAK,KAAa;AAC5D,aAAc,gBAAO,KAAO,OAAK,KAAO;AAE5C,YAAmB,gBAAG,CAAS,UAAuB;AAClD,aAAe,iBAAG;AACP,0BAAQ,QAAC,UAAQ;AAAK,uBAAM,OAAiB,iBAAQ,SAAM,MAAe;AAAE;AACjF,qBAAiB,iBAAU,WAAM,MAC3C;AAAE;AACE,aAAe,iBAAG;AACP,0BAAQ,QAAC,UAAQ;AAAK,uBAAM,OAAoB,oBAAQ,SAAM,MAAe;AAAE;AACpF,qBAAoB,oBAAU,WAAM,MAC9C;AAAE;AAEE,aAAO,OAAQ,SAAM,KAAe;AACpC,aAAO,OAAU,WAAM,KAAiB;AACxC,aAAO,OAAQ,QAAc,eAAM,KAAiB;AACpD,aAAO,OAAQ,QAAc,eAAM,KACzC;AAAC;AAED,wBAAO,UAAP;AACM,aAAS,SAAQ,SAAM,KAAe;AACtC,aAAS,SAAU,WAAM,KAAiB;AAC1C,aAAS,SAAQ,QAAc,eAAM,KAAiB;AACtD,aAAS,SAAQ,QAAc,eAAM,KAAiB;AACtD,aAAkB;AAElB,aAAe,eAAQ,QAAC,UAAO;AAAK,mBAAM,OAAU;AAAE;AAC1D,yBAAa,aACf;AAAC;AAED,wBAAM,SAAN;AACM,aAAW,WACjB;AAAC;AAED,wBAAI,OAAJ;AACM,aAAW,WACjB;AAAC;AAED,wBAAK,QAAL,UAAiB;AAAX;AAAA,qBAAW;;AACX,aAAW,WAAM,MACvB;AAAC;AAED,wBAAoB,uBAApB;AAAA,oBAuCC;AAtCuG;AACG;AACzG,YAAa;AACC,0BAAE,sBAAU;AAAK,uBAAQ,SAAK,KAAU,UAAI,IAAW;AAAA;AAC3D,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAC1C,+BAAE;AAAM,uBAAI,KAAkB,kBAAK,MAAU;AAAA;AAC5C,gCAAE;AAChB,uBAAI,MAAe,kBAAQ,MAAe,eAAQ;AAAA;AACpC,gCAAE,4BAAO,QAAU;AACjC,uBAAQ,SAAC,WAAO,QAAkB,QAAa,YAAM;AAAA;AACvC,gCAAE,4BAAW;AAC7B,oBAAI,CAAI,IAAO,QAAE;AACf,2BAAU;AACX;AACD,oBAAa,UAAG,WAAO,QAAI,IAAkB,QAAE,MAAW,QAAiB,mBAAK;AAChF,uBAAc,WAAW,QAAa,aAAQ,QAChD;AAAC;AACgB,+BAAE;AAAM,uBAAI,MAAqB;AAAA;AAC1C,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AAC7C,iCAAE;AAAM,uBAAI,KAAa,aAAK,MAAU;AAAA;AAC/C,0BAAE,sBAAO;AAAK,uBAAI,MAAK,KACxB,QAAa,cAAU,SAAC,EAAO,QAAG,WAAI;AAAA;AACpC,2BAAE,uBAAO;AAAK,uBAAI,MAAK,KACzB,QAAc,eAAU,SAAC,EAAO,QAAG,WAAI;AAAA;AACtC,0BAAE;AAAM,uBAAI,MAAK,KAAQ,QAAa,cAAK;AAAA;AAC1C,2BAAE;AAAM,uBAAI,MAAK,KAAQ,QAAc,eAAK;AAAA;AAC7C,0BAAE;AAAM,uBAAI,MAAW,WAAe;AAAA;AACnC,6BAAE,yBAAU;AAAK,uBAAQ,SAAK,KAAU,UAAO,OAAW;AAAA;AAC9D,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACnD,4BAAE;AACV,sBAAS,SAAW;AACpB,sBAAS,SAAQ,QAAC,UAAO;AACrB,2BAAe,cAAY,YACnC;AACF;AAAC;AACQ,uBAAE;AAAM,uBAAI,MAAW,WAAY;AAC5C;AAlCgC;AAmClC,eAAO,IAAI,aAAmB,oBAChC;AAAC;AAEO,wBAAkB,qBAA1B;AACE,eAAe,SAAc,cAAC,MAAW,QAAwB,0BACnE;AAAC;AACH,WAAC;AAAA,EArK8B,YAqK9B;AArKY,oBAAS,U;;;;;;;;;;;;;ACfnB;;;;;;;;;;;;;;;;;;;;;;;;AAEU,QAAU;AACd,aAAuB;AAC1B,UAAoB;AACjB,aAAuB;AACpB,gBAA0B;AACzB,iBAA0B;AAC9B,aACP;AAPwB;AASb,QAAO;AACF,sBAA0B;AAClB,8BAAkC;AAC3C,qBAAuB;AAC1B,kBAAoB;AACpB,kBAAS;AACR,mBAAqB;AAChB,wBAA0B;AAC5B,sBAAwB;AAC1B,oBAAW;AACF,6BAAiC;AAC5C,kBAAoB;AACnB,mBAAqB;AACpB,oBAAsB;AACL,qCAAE,CACrB,YAEX,4BAAK,KAAM;AACI,sBAChB;AAnBqB;AAqBV,QAAO;AACY,oCAAI;AACL,mCAC7B;AAHqB,E;;;;;;;;;;;;;AChCpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAyD;AAEzD;AAAyC,mCAA+B;AA6CtE,iCAA+C;AAA/C,oBACE,wCAA6B,oBAAe,iBAAc,aAC3D;AAXO,cAAO,UAAS;AAChB,cAAe,kBAAK;AACpB,cAAe,kBAAK;AACpB,cAAY,eAAK;AACjB,cAAgB,mBAAG,YAAO,QAAc;AACxC,cAAiB,oBAAG,YAAO,QAAc;AACzC,cAAiB,oBAAQ;AACzB,cAAkB,qBAAS;eAInC;AAAC;AA9CD,0BAAW,qBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAc;aAAzB;AACE;AACc,8BAAE;AAAM,2BAAS;AAAA;AACrB,0BAAE;AAAM,2BAAS;AAAA;AACR,mCAAE;AAAM,2BAAK;AAAA;AACZ,oCAAE;AAAM,2BAAS;AAAA;AACjB,oCAAE;AAAM,2BAAK;AAAA;AACb,oCAAE;AAAM,2BAAE;AAAA;AACX,mCAAE;AAAM,2BAAI;AAAA;AACrB,0BAAE;AAAM,2BAAK;AAAA;AACF,qCAAE;AAAM,2BAAK;AAAA;AACpB,8BAAE;AAAM,2BAAS;AAAA;AAChB,+BAAE;AAAM,2BAAS;AAAA;AAClB,8BAAE;AAAM,2BAAS;AAAA;AAChB,+BAAE;AAAM,2BAAS;AAAA;AAClB,8BAAE;AAAM,2BAAS;AAAA;AACd,iCAAE;AAAM,2BAAS;AAAA;AACrB,6BAAE;AAAM,2BAAS;AAAA;AACd,gCAAE;AAAM,2BAAS;AAAA;AACtB,2BAAE;AAAM,2BAAS;AAE9B;AApBS;AAoBR;;sBAAA;;AAeD,kCAAI,OAAJ;AACE,YAAQ,KAAQ,QAAS,SAAC,YAAU,WAAS,UAAE;AACzC,iBAAoB,oBAAQ;AAEpC;AAAC;AAED,kCAAO,UAAP;AACE,YAAQ,KAAQ,SAAE;AACZ,iBAAM,MAAC,YAAO,QAAiB;AACpC;AAED,YAAQ,KAAgB,iBAAE;AACZ,yBAAK,KAAkB;AAC/B,iBAA4B;AACjC;AAED,YAAQ,KAAa,cAAE;AACD,iCAAK,KAAe;AACpC,iBAAa,eAAK;AAE1B;AAAC;AAED,kCAAI,OAAJ;AAAA,oBAkBC;AAjBK,aAAQ,UAAQ;AAChB,aAAQ,QAAiB;AACzB,aAAQ,QAAS,SAAC,YAAU,WAAU;AAEwC;AAC9E,aAAuB,uBAAC;AACtB,kBAAQ,QAAS,SAAC,YAAU,WAAO;AACnC,kBAAQ,QAAa,aAAC,YAAU,WAAc;AAE9C,kBAAU;AAEV,kBAAgB,6BAAc;AAC5B,sBAA4B;AAC5B,sBAAQ,QAAU,UAAK,MAAQ,QAAsB;AACrD,sBAAQ,QACd;AAAC,aAJgC,EAI9B,YAAO,QACZ;AACF;AAAC;AAED,kCAAK,QAAL,UAAiB;AAAjB,oBAqBC;AArBK;AAAA,qBAAW;;AACf,YAAI,CAAK,KAAQ,SAAE;AACoF;AAC9F;AACR;AAEG,aAAQ,UAAS;AACjB,aAAQ,QAAc,cAAS;AAC/B,aAAQ,QAAS,SAAC,YAAU,WAAU;AACtC,aAAQ,QAAY,YAAC,YAAU,WAAO;AACtC,aAAQ,QAAgB,gBAAC,YAAU,WAAc;AAEjC,6BAAK,KAAkB;AACvC,aAAgB,kBAAK;AAEb,qBAAK,KAAkB;AAC/B,aAAgB,6BAAc;AAC5B,kBAAQ,QAAgB;AACxB,kBAA4B;AAC5B,kBAAQ,QAAa,aAC3B;AAAC,SAJgC,EAI9B,YAAO,QACZ;AAAC;AAED,kCAAM,SAAN;AACE,eAAW,KACb;AAAC;AAED,kCAAkB,qBAAlB;AACE,eAAW,KACb;AAAC;AAED,kCAAkB,qBAAlB,UAAiC;AAC3B,aAAiB,mBACvB;AAAC;AAED,kCAAmB,sBAAnB;AACE,eAAW,KACb;AAAC;AAED,kCAAmB,sBAAnB,UAAkC;AAC5B,aAAkB,oBACxB;AAAC;AAED,kCAAmB,sBAAnB;AACE,eAAW,KACb;AAAC;AAED,kCAAmB,sBAAnB,UAAsC;AAChC,aAAkB,oBACxB;AAAC;AAED,kCAAM,SAAN;AAAA,oBAQC;AAPC,YAAQ,KAAa,cAAE;AACD,iCAAK,KAAe;AACzC;AACG,aAAa,qCAAyB;AACpC,kBAAmB;AACnB,kBAAa,eACnB;AACF,SAJ2C;AAI1C;AAE+C;AAChD,kCAAW,cAAX,UAA2B;AACzB,YAAa,UACL,KAAQ,QAAmB,mBAAI,IAAO,QAAE,YAAO,QAAiB;AACG;AAC3E,YAAW,WAAQ,KAAkB,sBAAO,IAAE;AACxC,iBAAM,MAAK,KAAoB;AACpC,eAAM;AACL,gBAAY,SAAO,KAAQ,QAAmB,mBAAM;AACpD,gBAAU,QAAE;AACN,qBAAM,MAAS;AACpB;AAEL;AAAC;AAEiD;AAClD,kCAAa,gBAAb,UAAgC;AAC9B,YAAa,UAAM,IAAI,QAAY,WAAO,IAAQ,YAAQ;AAC1D,YAAI,CAAQ,SAAE;AACL;AACR;AACD,YAAY,SAAO,KAAQ,QAAmB,mBAAM;AACpD,YAAU,QAAE;AAC4C;AACQ;AACvD;AACR;AAED,YAAe,YAAG,CAAK,KAAQ,QAAmB,mBAC3C,IAAO,QAAE,YAAO,QAAkC;AACzD,YAAW,WAAa,WAAE;AACpB,iBAAQ,QAAsB;AAEtC;AAAC;AAEsC;AACvC,kCAAqB,wBAArB,UAAwC;AACtC,YAAc,WAAM,IAAI,QAAa,YAAO,IAAQ,YAAQ;AAC5D,YAAY,YAAQ,KAAiB,qBAAO,IAAE;AACxC,iBAAM,MAAK,KAAmB;AAEtC;AAAC;AAEO,kCAAe,kBAAvB;AACE,YAAQ,KAAkB,mBAAE;AACtB,iBAAyB;AAC9B;AACG,aACN;AAAC;AAEO,kCAAwB,2BAAhC;AACM,aAAgB,kBAAK;AACrB,aAAQ,QAAY,YAAC,YAAU,WAAU;AACzC,aAAQ,QAAY,YAAC,YAAU,WACrC;AAAC;AAIE;;;AACK,kCAAsB,yBAA9B,UAAmD;AAAnD,oBAOC;AANqB,6BAAK,KAAkB;AACvC,aAAgB,wCAAyB;AACvC,kBAAgB,kBAAK;AACb,yBAAK,MAAkB;AAC/B,kBAAgB,kBAAa,WAAS,UAC5C;AACF,SAL8C;AAK7C;AAEO,kCAAqB,wBAA7B;AAC6E;AACvE,aAAQ,QAAY,YAAC,YAAU,WAAU;AAE7C,YAAuB,oBAAO,KAAQ,QAAqB;AAE3D,YAAqB,mBAAE;AACjB,iBAAQ,QAAS,SAAC,YAAU,WAAU;AAC3C;AAED,YAAqB,sBAAS,KAAmB,oBAAE;AAC7C,iBAAQ,QAAkB;AAC1B,iBAAmB,qBAAqB;AAEhD;AAAC;AAEO,kCAAwB,2BAAhC;AACgF;AAC1E,aAAQ,QAAY,YAAC,YAAU,WAAa;AAChD,YAAQ,KAAQ,QAAsB,uBAAE;AAClC,iBAAQ,QAAS,SAAC,YAAU,WAAa;AAEjD;AAAC;AACH,WAAC;AAAA,EAnPwC,aAmPxC;AAnPY,8BAAmB;AAqPiF;AACjH,kBAAmC,oB;;;;;;;;;;;;;AC5PhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,4CAA+B;AAEvB,eAAI;AAEZ,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,4D;;;;;;;;;;;;;ACR1B;;;;;;;;;;;;;;;;;;;;;;;;AASH,SAAuC,wBACb,WACqB,kBACf;AAE9B,WAAuB,iBAAU,WAAE,EAAe,gBACpD;AAAC;AAND,kCAMC;AAED,SAA4B,aAAuB;AACjD,WAAW,KAAG,GAAa,eAAK,GAAe,eACjD;AAAC;AAFD,uBAEC;AAED,SAAiC,kBAAmB;AAClD,QAAU,OAAG,IAAU;AACrB,OAAQ,QAAK,KAAI,KAAE,UAAgB;AAAK,eAAI,KAAI,IAAG,GAAW;AAAE;AAClE,WAAW,KAAK,OAClB;AAAC;AAJD,4BAIC,kB;;;;;;;;;;;;;ACzBE;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;;AACH,IAGC;AAHD,WAA6B;AAC3B,kCAAiB;AACjB,qCACF;AAAC,GAH4B,oBAAjB,QAAiB,sBAAjB,QAAiB,oBAG5B;AAIE;;;AACH,SAAwB,SAAgB,SAA8B;AAC3D,cAAc,cAAI,IAAQ,SACrC;AAAC;AAFD,mBAEC;AAED;AAYkE;AAChE;AACM,aAAY,cAAG,IACrB;AAAC;AAXM,cAAW,cAAlB;AACE,YAAI,CAAU,UAAS,UAAE;AACd,sBAAS,WAAG,IAAgB;AACtC;AAED,eAAgB,UAClB;AAAC;AAOD,wBAAG,MAAH,UAAmB,SAAwD;AAAtD;AAAA,uBAA+C,kBAAO;;AACzE,YAAgB,aAAO,KAAc,cAAW;AACsB;AAC9C;AACd,mBAAY,cAAM;AACuC;AACzD,mBAAC;AACC,uBAAY,cAAW;AACzB,qBAAiB,iBAAQ,SACnC;AAAC,WAAK;AAEN,iBAAwB;AACZ,uBAAY,cAAM;AACpB,qBAAoB,oBAAQ,SACtC;AACF;AAAC;AAEO,wBAAa,gBAArB,UAAiD;AAC/C,YAAwB,qBAAO,KAAY,YAAI,IAAW;AAC1D,YAAsB,sBACV,SAAK,KAAS,SAA4B,qBAAE;AACtD,mBAA0B;AAC3B;AAED,YAAgB,aAAO,KAAiB,iBAAW;AAC/C,aAAY,YAAI,IAAS,UAAc;AAC3C,eACF;AAAC;AAEO,wBAAgB,mBAAxB,UAAoD;AAClD,YAAQ,KAAW,SAAc,cAAQ;AACvC,WAAM,MAAS,WAAc;AAC7B,WAAM,MAAI,MAAa;AACvB,WAAM,MAAK,OAAa;AACxB,WAAM,MAAO,SAAS;AACtB,WAAM,MAAS,WAAY;AAC3B,WAAa,aAAc,eAAU;AACrC,WAAa,aAAY,aAAY;AAC/B,iBAAK,KAAY,YAAK;AAC9B,eACF;AAAC;AACH,WAAC;AAAA,I;;;;;;;;;;;;;AC3EE;;;;;;;;;;;;;;;;;;;;;;;;AAKA;;;;AACH,SAA4B,aAA2B;AAA1B;AAAA,oBAA0B;;AAErD,WAA4B,sBAAa,aACrC,EAAQ,SAAoC,SAElD;AAAC;AALD,uBAKC;AAED,SAA8B,sBAA2B;AAA1B;AAAA,oBAA0B;;AACjD;AAC0E;AAChF,QAAoB,mBAAS;AAE7B,QAAI;AACF,YAAa;AACqC;AACL;AAC3C,gBAAW;AACO,mCAAQ;AACxB,uBACF;AACA;AAPc;AAShB,YAAa,UAAG,mBAAO,CAAE;AAChB,kBAAS,SAAiB,iBAAO,QAAS,SAAW;AACrD,kBAAS,SAAoB,oBAC5B,QAAS,SAAmC;AACvD,MAAC,OAAU,KAAE;AACI,2BAAS;AAC1B;AAED,WACF;AAAC,C;;;;;;;;;;;;;ACrCE;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAA0B,uBAA4B;AAQnD;;;;;;;AACH;AAIE,uBACsC,MACS;AAA1B;AAAA,sBAA0B;;AAD1B,aAAI,OAAa;AACjB,aAAO,UAAmB;AALK;AAC5C,aAAwB,2BAIkB;AAAC;AAKhD;;;;AACH,wBAAS,YAAT;AACE,YAAkB,eAAO,KAAqB,qBAAK,KAAO;AAC1D,YAAgB,aAAO,WAAM,GAAE;AAC7B,kBAAM,IAAS,MACmD;AACnE;AAEG,aAAyB,2BACjB,SAAc,yBAAyB,cAAS,SAAgB,gBACnB;AACrD,aAAa,aAAK,KAAK,MAAgB;AAE3C,YAAI,CAAK,KAAQ,QAAiB,kBAAE;AAC9B,iBAAoB,oBAAa,cAAM,KAAQ,QAAiB;AAExE;AAAC;AAKE;;;;AACH,wBAAY,eAAZ;AACI,WAAM,MAAK,KAAK,KAAK,KAAiB,iBAAC,MAA4B,uBACzD,QAAC,UAAwB;AACrB,uBAAe,cAAY,YACvC;AAAG;AAEP,YAAQ,KAAyB,0BAAE;AAC7B,iBAAyB,yBAAS;AAE1C;AAAC;AAQE;;;;;;;AACK,wBAAY,eAApB,UAAoC,IAA6B;AAC/D,YAAmB,gBAAO,KAAkB;AAC5C,YAAiB,cAAO,KAAkB;AAE7B,sBAAiB,iBAAQ,SAAE;AACtC,gBAAgB,aAAO,SAAI,GAAE;AACf,6BAAa,aAAO,SAAK,GAAS;AAElD;AAAG;AACQ,oBAAiB,iBAAQ,SAAE;AACpC,gBAAgB,aAAO,SAAI,GAAE;AACf,6BAAG,GAAS;AAE5B;AAAG;AAED,WAAa,aAAc,eAAI,GAAS,SAAK;AAC7C,WAAY,YAChB;AAAC;AAKE;;;;AACK,wBAAmB,sBAA3B,UAC+B,cAA8B;AAC3D,YAAc,aAAK;AACnB,YAAkB,gBAAE;AACR,yBAAO,KAAI,IAAa,aAAQ,QAAgB,iBAAK;AAChE;AACW,qBAAY,YAC1B;AAAC;AAEO,wBAAoB,uBAA5B,UAA8C;AAC5C,YAAkB,eACZ,GAAM,MAAK,KAAK,KAAiB,iBAErB;AAClB,4BAA0B,OAAC,UAAG;AAC5B,gBAAwB,qBAAK,GAAa,aAAiB,qBAAW,UAChE,GAAa,aAAY,eAAQ,QACjC,GAAa,aAAU,aAAQ,QAC/B,GAAa,aAAe,mBAAY;AAC9C,gBAA0B,uBAAK,GAAS,YAAK,KACvC,GAAwB,wBAAM,QAAI,KACpC,CAAG,GAAU,UAAS,SAAsB,yBAAI,CAAoB;AAExE,gBAA4B,2BAAS;AACrC,gBAAwB,sBAAE;AACxB,oBAAW,QAAmB,iBAAK;AACX,2CACf,MAAQ,YAAW,UAAS,MAAW,eAAc;AAC/D;AACD,mBAA2B,wBAAI,CACjC;AACF,SAjBqB;AAiBpB;AAEO,wBAAc,iBAAtB;AACE,YAAc,WAAW,SAAc,cAAQ;AACvC,iBAAa,aAAW,YAAO;AACH;AAC5B,iBAAa,aAAc,eAAU;AACrC,iBAAU,UAAI,IAAuB;AAC7C,eACF;AAAC;AACH,WAAC;AAAA;AAnHY,oBAAS,U;;;;;;;;;;;;;ACXnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,8CAAmC;AAK3B,iBAAM;AAJd,iDAA0C;AAI1B,oBAAS;AAHzB,gDAAuC;AAGZ,mBAAQ;AAFnC,gDAAuC;AAEF,mBAAQ,S;;;;;;;;;;;;;ACP1C;;;;;;;;;;;;;;;;;;;;;;;;AAIA;;;AACU,QAAG;AACP,aAAW;AACT,eAAa;AACjB,WAAS;AACN,cAAY;AACb,aAAU;AACR,eAAY;AAClB,SAAO;AACN,UAAQ;AACF,gBAAa;AACf,cAAW;AACR,iBAAc;AACf,gBAAa;AACjB,YAAU;AACV,YACN;AAfiB;AAiBnB,IAAoB,iBAAG,IAAkB;AACqC;AACnE;AACG,eAAI,IAAC,QAAG,IAAY;AACpB,eAAI,IAAC,QAAG,IAAQ;AAChB,eAAI,IAAC,QAAG,IAAW;AACnB,eAAI,IAAC,QAAG,IAAU;AAClB,eAAI,IAAC,QAAG,IAAY;AACpB,eAAI,IAAC,QAAG,IAAM;AACd,eAAI,IAAC,QAAG,IAAO;AACf,eAAI,IAAC,QAAG,IAAa;AACrB,eAAI,IAAC,QAAG,IAAW;AACnB,eAAI,IAAC,QAAG,IAAc;AACtB,eAAI,IAAC,QAAG,IAAa;AACrB,eAAI,IAAC,QAAG,IAAS;AACjB,eAAI,IAAC,QAAG,IAAS;AAE/B,IAAc;AACH,eAAG;AACP,WAAI;AACD,cAAI;AACL,aAAI;AACF,eAAI;AACV,SAAI;AACH,UAAI;AACE,gBAAI;AACN,cAAI;AACD,iBAAI;AACL,gBAAI;AACR,YAAI;AACJ,YACN;AAde;AAgBjB,IAAoB,iBAAG,IAA0B;AAC6B;AACnE;AACG,eAAI,IAAS,SAAU,WAAE,QAAG,IAAY;AACxC,eAAI,IAAS,SAAM,OAAE,QAAG,IAAQ;AAChC,eAAI,IAAS,SAAS,UAAE,QAAG,IAAW;AACtC,eAAI,IAAS,SAAQ,SAAE,QAAG,IAAU;AACpC,eAAI,IAAS,SAAU,WAAE,QAAG,IAAY;AACxC,eAAI,IAAS,SAAI,KAAE,QAAG,IAAM;AAC5B,eAAI,IAAS,SAAK,MAAE,QAAG,IAAO;AAC9B,eAAI,IAAS,SAAW,YAAE,QAAG,IAAa;AAC1C,eAAI,IAAS,SAAS,UAAE,QAAG,IAAW;AACtC,eAAI,IAAS,SAAY,aAAE,QAAG,IAAc;AAC5C,eAAI,IAAS,SAAW,YAAE,QAAG,IAAa;AAC1C,eAAI,IAAS,SAAO,QAAE,QAAG,IAAS;AAClC,eAAI,IAAS,SAAO,QAAE,QAAG,IAAS;AAEhD,IAAoB,iBAAG,IAAkB;AACqC;AACnE;AACG,eAAI,IAAC,QAAG,IAAU;AAClB,eAAI,IAAC,QAAG,IAAY;AACpB,eAAI,IAAC,QAAG,IAAM;AACd,eAAI,IAAC,QAAG,IAAO;AACf,eAAI,IAAC,QAAG,IAAa;AACrB,eAAI,IAAC,QAAG,IAAW;AACnB,eAAI,IAAC,QAAG,IAAc;AACtB,eAAI,IAAC,QAAG,IAAa;AAIhC;;;AACH,SAA4B,aAAmB;AACtC,kBAAW;AACqC;AACvD,QAAkB,eAAI,IAAK,MAAE;AAC3B,eAAW;AACZ;AAEsC;AACvC,QAAe,YAAiB,eAAI,IAAI,IAAU;AAClD,QAAa,WAAE;AACb,eAAiB;AAClB;AACD,WAAO,QAAG,IACZ;AAAC;AAbD,uBAaC;AAIE;;;AACH,SAAiC,kBAAmB;AAClD,WAAqB,eAAI,IAAa,aACxC;AAAC;AAFD,4BAEC,kB;;;;;;;;;;;;;AC3GE;;;;;;;;;;;;;;;;;;;;;;;;AAKA;;;;AAEH,SAAuB,QAAiB,SAAkB;AACxD,QAAW,QAAQ,SAAE;AACnB,eAAc,QAAQ,QAAW;AAClC;AAED,QAAM,KAA2B;AACjC,WAAS,IAAE;AACT,YAAW,QAAG,IAAW,WAAE;AACzB,mBAAU;AACX;AACC,aAAK,GAAe;AACvB;AACD,WACF;AAAC;AAbD,kBAaC;AAED,SAAuB,QAAiB,SAAkB;AACxD,QAAmB,gBAAU,QAAQ,WACvB,QAAsB,yBACtB,QAAmB;AACjC,WAAoB,cAAK,KAAQ,SACnC;AAAC;AALD,kBAKC;AASE;;;;;;;;AACH,SAAmC,oBAAiB;AACuB;AACnB;AACwB;AAClB;AAC5D,QAAY,SAA0B;AACtC,QAAU,OAAa,iBAAS,MAAE;AAChC,eAAa,OAAa;AAC3B;AAED,QAAW,QAAS,OAAU,UAAsB;AAC/C,UAAM,MAAY,YAAW,YAAc;AAC3C,UAAM,MAAY,YAAY,aAAiC;AAC5D,aAAgB,gBAAY,YAAQ;AAC5C,QAAiB,cAAQ,MAAa;AAC9B,aAAgB,gBAAY,YAAQ;AAC5C,WACF;AAAC;AAjBD,8BAiBC,oB;;;;;;;;;;;;;ACtDE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,uCAAmD;AACnD,sCAAiE;AACjE,uCAA4D;AAE5D,uCAAwE;AACxE,uCAA4D;AAC5D,4CAA+B;AAGxB,6DAAU;IAAE,sDAA0C;AAK1D;;;;AACH;AAA+B,yBAA4C;AAA3E;mEAwIA;AAAC;AAvIQ,cAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAa,UACtB;AAAC;AAMD,0BAAI,qBAAI;AADL;;;;aACH;AACE,mBAAW,KAAW,WACxB;AAAC;AAIE;;;aACH,aAAwB;AACtB,gBAAU,QAAE;AACN,qBAAW,WAAQ;AACxB,mBAAM;AACD,qBAAW,WAAS;AAE5B;AAAC;;sBAXA;;AAwBD,0BAAI,qBAAI;aAAR;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAED,wBAAU,aAAV,UAC2E,kBAClB;AADrD;AAAA,yDAAiD;AAAK,2BAAI,aAAS,UAAI;AAAA;;AACvE;AAAA,+CAAiC;AAAK,2BAAI,YAAO,QAAI;AAAA;;AAEvD,YAAY,SACJ,KAAK,KAAc,cAAC,MAAI,aAAiB,kBAAW,WAAS;AACrE,YAAU,QAAE;AACN,iBAAM,QAAc,YAAS;AAC7B,iBAAM,MAAU,YAAQ;AAC7B;AACG,aAAkB,oBACxB;AAAC;AAED,wBAAkB,qBAAlB;AAAA,oBAqBC;AApBQ,+BAAoB;AACpB,qCAA0B;AAE7B,aAAO,SAAQ,KAAK,KAAuB,WACf,cAA8B;AAE9D,YAAQ,KAAO,UAAQ,KAAK,KAAU,UAAS,SAAO,QAAE;AAClD,iBAAkB,oBAAG;AACrB,uBAAK,MAAwC,WAAmB;AAAC;AACjE,iBAAO,OAAiB,iBAAQ,SAAM,KAAoB;AAC1D,iBAAW,aAAO,KAAwB,wBACtC,KAAoB,MAAM,KAAoB;AACvD;AAEG,aAAe,iBAAG,UAAI;AAAK,mBAAI,MAAW,WAAc,cAAK;AAAC;AAC9D,aAAqB,uBAAG,UAAI;AAC5B,mBAAI,MAAW,WAAoB,oBAAK;AAAC;AAEzC,aAAO,OAAU,WAAM,KAAiB;AACxC,aAAO,OAAgB,iBAAM,KACnC;AAAC;AAED,wBAAO,UAAP;AACM,aAAS,SAAU,WAAM,KAAiB;AAC1C,aAAS,SAAgB,iBAAM,KAAuB;AAE1D,YAAQ,KAAM,OAAE;AACV,iBAAM,MAAW;AACtB;AAEM,+BAAoB;AAC3B,YAAQ,KAAO,UAAQ,KAAkB,qBACjC,KAAK,KAAU,UAAS,SAAO,QAAE;AACnC,iBAAO,OAAoB,oBAAQ,SAAM,KAAoB;AACP;AACtD,iBAAK,OAAS;AAEtB;AAAC;AAED,wBAAoB,uBAApB;AAAA,oBA2CC;AA1CuG;AACG;AACD;AACxG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACzD,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AACjD,6BAAE,yBAAQ,SAAW;AAChC,uBAAO,QAAU,UAAS,SAAW;AAAA;AAChC,uBAAE;AAAM,uBAAI,MAAe,iBAAW,SAAc;AAAA;AACjD,0BAAE;AACZ,oBAAmB,gBAAO,MAA2C;AACrE,oBAAiB,iBAAiB,cAAM,SAChC,MAAK,KAAS,SAAS,SAAe,gBAAE;AACjC,kCAAS;AAE1B;AAAC;AACwB,uCAAE;AACzB,oBAAqB,kBAAO,MAAK,KAAc,cAC3C,MAAI,aAAiB,kBAAW,WAA8B;AAClE,oBAAmB,iBAAE;AACJ,oCAAS;AAE5B;AAAC;AACU,yBAAE;AACT,uBAAI,MAAK,KAAQ,QAAY,aAAI,IAAM,KAAoB;AAAA;AACrD,wBAAE;AACR,uBAAI,MAAK,KAAQ,QAAW,YAAI,IAAM,KAAoB;AAAA;AACrD,uBAAE;AAAM,uBAAI,MAAY,WAAY;AAAA;AACjC,0BAAE;AAAM,uBAAI,MAAY,WAAe;AACnD;AA3BgC;AA4BO;AAElC,qCAAW;YAAE,mBAAoB;AACxC,YAAQ,KAAK,KAAU,UAAS,SAAa,cAAE;AAC7C,mBAAO,IAAI,aAA8B,+BAAU;AACpD,mBAAc,KAAK,KAAU,UAAS,SAAO,QAAE;AAC9C,mBAAO,IAAI,aAAwB,yBAAU;AAC9C,SAFM,MAEA;AACL,kBAAM,IAAS,MACX,wEAAiF,wBAAa,QAAK;AAE3G;AAAC;AACH,WAAC;AAAA,EAxI8B,YAwI9B;AAxIY,oBAAS,U;;;;;;;;;;;;;ACnBnB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACP,aAAuB;AACvB,aAAuB;AACnB,iBAA2B;AACjC,WAAqB;AACtB,UAAoB;AACjB,aAAuB;AAC1B,UACJ;AARiB;AAiBX,qBAAU;AAPlB,IAAa;AACS,0BAA2B;AACpC,iBAAoB;AACrB,gBAAoB;AAChB,oBACd;AALc;AAOI,kBAAO,Q;;;;;;;;;;;;;ACnBxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAiD;AAEjD;AAAoD,8CAA+B;AA8BjF,4CAA+C;AAA/C,oBACE,wCAAwC,+BAAe,iBAAc,aACtE;AALO,cAAe,kBAAK;AACpB,cAAe,kBAAK;eAI5B;AAAC;AA/BD,0BAAW,gCAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,gCAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,gCAAc;aAAzB;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACpB,0BAAE;AAAM,2BAAK;AAAA;AACN,iCAAE;AAAM,2BAAK;AAAA;AACjB,6BAAE;AAAM,2BAAS;AAAA;AAClB,4BAAE;AAAM,2BAAS;AAAA;AAClB,2BAAE;AAAM,2BAAS;AAAA;AACd,8BAAE;AAAM,2BAAS;AAAA;AACJ,2CAAE;AAAM,2BAAS;AAAA;AACjC,2BAAE;AAAM,2BAAS;AAAA;AACd,8BAAE;AAAM,2BAAS;AAC7B;AAZK;AAcT;AAAC;;sBAAA;;AASD,6CAAO,UAAP;AACE,YAAQ,KAAgB,iBAAE;AACJ,iCAAK,KAAkB;AAC5C;AACD,YAAQ,KAAgB,iBAAE;AACZ,yBAAK,KAAkB;AAEvC;AAAC;AAIE;;;AACH,6CAAI,OAAJ;AAAA,oBAcC;AAbC,YAAQ,KAAS,YAAQ,KAAY,eAAQ,KAAY,aAAE;AAClD;AACR;AAEG,aAAQ,QAAS,SAAC,YAAU,WAAO;AACnC,aAAQ,QAAS,SAAC,YAAU,WAAU;AAEwC;AAC9E,aAAuB,uBAAC;AACtB,kBAAQ,QAAS,SAAC,YAAU,WAClC;AAAG;AAEC,aAAQ,QACd;AAAC;AAIE;;;AACH,6CAAK,QAAL;AACE,YAAI,CAAK,KAAS,YAAQ,KAAY,eAAQ,KAAY,aAAE;AACnD;AACR;AAEG,aAAQ,QAAS,SAAC,YAAU,WAClC;AAAC;AAKE;;;;AACH,6CAAM,SAAN;AACE,eAAW,KAAQ,QAAS,SAAC,YAAU,WACzC;AAAC;AAKE;;;;AACH,6CAAS,YAAT;AACE,eAAW,KAAQ,QAAS,SAAC,YAAU,WAAS,YACxC,KAAQ,QAAS,SAAC,YAAU,WACtC;AAAC;AAKE;;;;AACH,6CAAS,YAAT;AACE,eAAW,KAAQ,QAAS,SAAC,YAAU,WACzC;AAAC;AAIE;;;AACH,6CAAa,gBAAb,UAAgC;AACvB,0BAAO;YAAE,UAAW;AAC3B,YAAc,WAAM,QAAa,YAAW,YAAQ;AACpD,YAAY,UAAE;AACR,iBAAS;AAEjB;AAAC;AAIE;;;AACH,6CAAmB,sBAAnB,UAAwC;AAC/B,6CAAO;YAAE,iCAAO;YAAE,8BAAI;YAAE,iCAAO;YAAE,8BAAmB;AAEuD;AAClH,YAAmB,gBAAO,KAAW,WAAI,IAAQ,WACzC,KAAQ,QAAgB,gBAAI,IAAO,QAAQ;AACnD,YAAI,CAAc,eAAE;AACX;AACR;AAED,YAAQ,KAAY,aAAE;AAChB,iBAAQ,QAAY,YAAO;AAC3B,iBAAW;AACX,iBAAQ,QAAgB;AACxB,iBAAQ,QAAe;AAC5B,eAAM;AACD,iBAAQ,QAA6B;AACrC,iBAAW;AACX,iBAAQ,QAAc;AAC3B;AAEG,aAAQ,QAAY,YAAU;AAC9B,aAAQ,QAAY,YAAU;AAC9B,aAAQ,QAAY,YAC1B;AAAC;AAIE;;;AACO,6CAAO,UAAjB,YAAqB,CAAC,GAAgC;AAInD;;;AACO,6CAAO,UAAjB,YAAqB,CAAC,GAAgC;AAInD;;;AACK,6CAAsB,yBAA9B,UAAmD;AAAnD,oBAOC;AANqB,6BAAK,KAAkB;AACvC,aAAgB,wCAAyB;AACvC,kBAAgB,kBAAK;AACb,yBAAK,MAAkB;AAC/B,kBAAgB,kBAAa,WAAS,UAC5C;AACF,SAL8C;AAK7C;AAEO,6CAAU,aAAlB,UAAmC;AACqD;AACtF,eAAc,QAAqB,QACrC;AAAC;AACH,WAAC;AAAA,EApKmD,aAoKnD;AApKY,yCAA8B;AAsKsE;AACjH,kBAA8C,+B;;;;;;;;;;;;;AC7K3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,4CAA+B;AAEvB,eAAI;AAEZ,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAAyC;AACzC,6BAAmC,wE;;;;;;;;;;;;;ACThC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAyE;AAEX;AAC9D;AAA8C,wCAA8B;AAA5E;mEAqBA;AAAC;AAlBI;;;AACH,uCAAgB,mBAAhB;AACM,aACN;AAAC;AAIE;;;AACO,uCAAO,UAAjB;AACM,aAAQ,QACd;AAAC;AAIE;;;AACO,uCAAO,UAAjB;AACM,aAAQ,QACd;AAAC;AACH,WAAC;AAAA,EArB6C,aAqB7C;AArBY,mCAAwB;AAuB4E;AACjH,kBAAwC,yB;;;;;;;;;;;;;AC7BrC;;;;;;;;;;;;;;;;;;;;;;;;AASH,SAAuC,wBACb,WACqB;AAE7C,4BAAiC;AACkB;AACjC,0BAEpB;AAJqC,KAAZ;AAIxB;AARD,kCAQC,wB;;;;;;;;;;;;;ACjBE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AACtD,qCAA2D;AAE3D,uCAAwD;AAIxD;AAAsC,gCAAwC;AAA9E;mEAiDA;AAAC;AAhDQ,qBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAoB,iBAC7B;AAAC;AAKE;;;;AACH,+BAAK,QAAL,UAA0B;AACpB,aAAW,WAAM,MACvB;AAAC;AAKE;;;;AACH,+BAAK,QAAL,UAA0B;AACpB,aAAW,WAAM,MACvB;AAAC;AAKE;;;;AACH,+BAAW,cAAX,UAA+B;AACzB,aAAW,WAAY,YAC7B;AAAC;AAED,+BAAQ,WAAR;AACE,eAAW,KAAW,WACxB;AAAC;AAED,+BAAoB,uBAApB;AAAA,oBAeC;AAduG;AACG;AACD;AACxG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACzD,sBAAE;AAAM,kCAAmB,oBAAK,MAAM;AAAA;AACpB,wCAAE,oCAAQ,SAAS;AACzC,uBAAI,MAAO,OAAQ,SAAU;AAAA;AACL,0CAAE,sCAAQ,SAAS;AAC3C,uBAAI,MAAS,SAAQ,SAAU;AACnC;AARuC;AASA;AACzC,eAAO,IAAI,aAA0B,2BACvC;AAAC;AACH,WAAC;AAAA,EAjDqC,YAiDrC;AAjDY,2BAAgB,iB;;;;;;;;;;;;;ACT1B;;;;;;;;;;;;;;;;;;;;;;;;AAEU,QAAU;AACJ,qBAAmC;AACtC,kBAAgC;AACnC,eAA6B;AACpC,QACJ;AALwB,E;;;;;;;;;;;;;ACFvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAGxD,sCAAuC;AAEvC;AAAgD,0CAAsC;AAsBpF,wCAAsD;AAAtD,oBACE,wCAAoC,2BAAe,iBAAc,aAGlE;AADK,cAA0B,4BAAG;AAAM,mBAAI,MAA2B;AAAC;eACzE;AAAC;AAzBD,0BAAW,4BAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAKD,0BAAW,4BAAc;AADtB;;;aACH;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACpB,0BAAE;AAAM,2BAAC;AAAA;AACS,4CAAE;AAAM,2BAAS;AAAA;AACf,8CAAE;AAAM,2BAAS;AAC7C;AANK;AAQT;AAAC;;sBAAA;;AAUD,yCAAI,OAAJ;AACM,aAAQ,QAA2B,2BAAe,gBAAM,KAC9D;AAAC;AAED,yCAAO,UAAP;AACM,aAAQ,QAA6B,6BAAe,gBAAM,KAChE;AAAC;AAIE;;;AACH,yCAAQ,WAAR;AACE,eAAW,KAAQ,QACrB;AAAC;AAKE;;;;AACH,yCAAK,QAAL,UAA0B;AACjB,gEAAqD;AAC5D,YAAe,aAAE;AACX,iBAAQ,QAAS,SAAc;AACpC,eAAM;AACD,iBAAQ,QAAY,YAAc;AAE1C;AAAC;AAKE;;;;AACH,yCAAK,QAAL,UAA0B;AAClB,4CAAwE;YAAvE,uBAAiB;YAAE,iBAAqD;AAC/E,YAAe,aAAE;AACX,iBAAQ,QAAS,SAAoB;AAC1C,eAAM;AACD,iBAAQ,QAAY,YAAoB;AACxC,iBAAQ,QAAY,YAAc;AAE1C;AAAC;AAKE;;;;AACH,yCAAW,cAAX,UAA+B;AACtB,mEAAwD;AAC/D,YAAc,YAAE;AACV,iBAAQ,QAAS,SAAiB;AACvC,eAAM;AACD,iBAAQ,QAAY,YAAiB;AAE7C;AAAC;AAEO,yCAAwB,2BAAhC;AACS,gEAAqD;AACxD,aAAQ,QAAY,YAC1B;AAAC;AACH,WAAC;AAAA,EAvF+C,aAuF/C;AAvFY,qCAA0B;AAyF0E;AACjH,kBAA0C,2B;;;;;;;;;;;;;ACjGvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,oE;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAGtD,uCAAoD;AAMpD;AAAkC,4BAAoC;AAAtE;mEAyCA;AAAC;AAxCQ,iBAAQ,WAAf,UAAiC;AAC/B,eAAO,IAAgB,aACzB;AAAC;AAIO,2BAAO,UAAf;AACS,yEAAiD;AACxD,eAAW,KAAK,KAAc,cAChC;AAAC;AAED,2BAAoB,uBAApB;AAAA,oBA4BC;AA3BuG;AACG;AACzG,YAAa;AACQ,iCAAE;AACnB,oBAAQ,MAAM,SAAQ,MAAM,MAAO,QAAE;AAC/B,0BAAM,MAAO,OAAY;AAEjC;AAAC;AACoB,mCAAE;AACrB,oBAAQ,MAAM,SAAQ,MAAM,MAAO,QAAE;AAC/B,0BAAM,MAAO,OAAc;AAEnC;AAAC;AAC2B,0CAAE,sCAAQ,SAAS;AAC7C,oBAAa,UAAO,MAAW;AAC/B,oBAAW,SAAE;AACa,4BAAoB,oBAAQ,SAAW;AAEnE;AAAC;AACyB,wCAAE,oCAAQ,SAAS;AAC3C,oBAAa,UAAO,MAAW;AAC/B,oBAAW,SAAE;AACa,4BAAiB,iBAAQ,SAAW;AAEhE;AACA;AAvBmC;AAwBrC,eAAO,IAAI,aAAsB,uBACnC;AAAC;AACH,WAAC;AAAA,EAzCiC,YAyCjC;AAzCY,uBAAY,a;;;;;;;;;;;;;ACXtB;;;;;;;;;;;;;;;;;;;;;;;;AAEU,QAAU;AACjB,UACJ;AAFwB;AAIb,QAAO;AACJ,oBACd;AAFqB,E;;;;;;;;;;;;;ACNpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAgD;AAEhD;AAA4C,sCAAkC;AAoB5E,oCAAkD;AAAlD,oBACE,wCAAgC,uBAAe,iBAAc,aAK9D;AAHK,cAAM,QAAG;AACP,kBACN;AAAE;eACJ;AAAC;AAzBD,0BAAW,wBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,wBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,wBAAc;aAAzB;AACE;AACqB,qCAAE;AAAM,2BAAS;AAAA;AACf,uCAAE;AAAM,2BAAS;AAAA;AACV,8CAAE;AAAM,2BAAS;AAAA;AACnB,4CAAE;AAAM,2BAAS;AAE/C;AANS;AAMR;;sBAAA;;AAYD,qCAAI,OAAJ;AACM,aAAQ,QAA2B,2BAAQ,SAAM,KACvD;AAAC;AAED,qCAAO,UAAP;AACM,aAAQ,QAA6B,6BAAQ,SAAM,KACzD;AAAC;AAEO,qCAAW,cAAnB;AAAA,oBAKC;AAJK,aAAQ,QAAuB;AACd,8BAAC;AAChB,kBAAQ,QACd;AACF;AAAC;AACH,WAAC;AAAA,EA1C2C,aA0C3C;AA1CY,iCAAsB;AA4C8E;AACjH,kBAAsC,uB;;;;;;;;;;;;;ACnDnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,gE;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,sCAAqD;AAErD,uCAA2D;AAGpD,yDAAyC;AAEhD;AAAyC,mCAA2C;AAApF;AAAA,wEAyDC;AApDkB,cAAe,kBAAkB,MAAgB;eAoDpE;AAAC;AAxDQ,wBAAQ,WAAf,UAAiC;AAC/B,eAAO,IAAuB,oBAChC;AAAC;AAMD,kCAAkB,qBAAlB;AAAA,oBAKC;AAJK,aAAY,cAAG;AACb,kBAAW,WACjB;AAAE;AACE,aAAO,OAAQ,SAAM,KAC3B;AAAC;AAED,kCAAO,UAAP;AACM,aAAS,SAAQ,SAAM,KAAc;AACrC,aAAO,OAAW;AACtB,yBAAa,aACf;AAAC;AAED,kCAAoB,uBAApB;AAAA,oBAgBC;AAfuG;AACG;AACzG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AACnD,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AACpD,0BAAE,sBAAQ;AAChB,sBAAK,KACE,QAAa,cAC1B;AAAC;AACU,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AAC1D,qBAAE,iBAAS;AAAK,uBAAI,MAAK,KAAa,aAAU;AAAA;AAChD,qBAAE,iBAAS,UAAW;AACzB,uBAAI,MAAK,KAAa,aAAS,UAAY;AAC/C;AAX0C;AAY5C,eAAO,IAAI,aAA6B,8BAC1C;AAAC;AAED,0BAAI,+BAAM;aAAV;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAED,0BAAI,+BAAE;aAAN;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAAoB;AACd,iBAAW,WAAO,OACxB;AAAC;;sBAJA;;AAMO,kCAAY,eAApB;AACE,YAAY,SAAG,IAAI,YAAS,UAAK,KAAO;AAClC,eAAU,YAAQ;AACxB,eACF;AAAC;AACH,WAAC;AAAA,EAzDwC,YAyDxC;AAzDY,8BAAmB,oB;;;;;;;;;;;;;ACX7B;;;;;;;;;;;;;;;;;;;;;;;;AAEU,QAAU;AACP,oBAAuB;AACjC,UACJ;AAHwB;AAKb,QAAO;AACR,gBAAc;AACZ,kBAAgB;AACT,yBAAuB;AACxB,wBAAsB;AAC5B,kBACZ;AANqB,E;;;;;;;;;;;;;ACPpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAgD;AAEhD;AAAmD,6CAAyC;AA0B1F,2CAAyD;AAAzD,oBACE,wCAAuC,8BAAe,iBAAc,aACrE;AAxBE;;;;AACK,cAAmB,sBAAkB;eAuB7C;AAAC;AArBD,0BAAW,+BAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,+BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,+BAAc;aAAzB;AACE;AACU,0BAAE;AAAM,2BAAS;AAAA;AACjB,0BAAE;AAAM,2BAAK;AAAA;AACT,8BAAE;AAAM,2BAAS;AAAA;AAClB,6BAAE;AAAM,2BAAS;AAAA;AACrB,yBAAE;AAAM,2BAAI;AAAA;AACZ,yBAAE;AAAM,2BAAS;AAE5B;AARS;AAQR;;sBAAA;;AAMD,4CAAI,OAAJ;AACE,YAAiB,cAAO,KAAQ,QAAQ,QAAC,YAAO,QAAqB;AACrE,YAAkB,eAAO,KAAQ,QAAQ,QAAC,YAAO,QAAsB;AACvE,YAAe,eAAgB,cAAE;AAC/B,gBAAQ,KAAQ,QAAQ,QAAC,YAAO,QAAc,kBAAS,MAAE;AACvD,sBAAM,IAAS,MAC4C,0DACL;AACvD;AAEG,iBAAoB,sBAAQ;AACjC,eAAM;AACD,iBAAQ,QAAQ,QAAC,YAAO,QAAa,cAAQ,OAAK,KAAU;AAEpE;AAAC;AAED,4CAAW,cAAX;AACM,aAAU;AACV,aAAQ,QAAa,aAAC,EAAK,MAAM,KACvC;AAAC;AAED,4CAAI,OAAJ;AACE,eAAW,KAAQ,QAAS,SAAC,YAAU,WACzC;AAAC;AAED,4CAAM,SAAN,UAAmC;AAA5B;AAAA,oBAAqB,KAAO;;AACL;AAC5B,YAAQ,MAAE;AACJ,iBAAQ,QAAS,SAAC,YAAU,WAAiB;AAClD,eAAM;AACD,iBAAQ,QAAY,YAAC,YAAU,WAAiB;AACrD;AAEwC;AACzC,YAAQ,KAAoB,qBAAE;AAC5B,gBAAe,YAAS,OAChB,KAAQ,QAAQ,QAAC,YAAO,QAAsB,sBAC9C,KAAQ,QAAQ,QAAC,YAAO,QAAsB;AAClD,iBAAQ,QAAQ,QAAC,YAAO,QAAW,YAAW,aAAQ;AAC3D,eAAM;AACD,iBAAQ,QAAQ,QAAC,YAAO,QAAa,cAAE,KAAW;AAE1D;AAAC;AACH,WAAC;AAAA,EAzEkD,aAyElD;AAzEY,wCAA6B;AA2EuE;AACjH,kBAA6C,8B;;;;;;;;;;;;;AClF1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,iE;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,uCAAqD;AAIrD;AAAmC,6BAAqC;AAAxE;mEA0CA;AAAC;AAzCQ,kBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAiB,cAC1B;AAAC;AAIE;;;AACH,4BAAQ,WAAR;AACM,aAAW,WACjB;AAAC;AAIE;;;AACH,4BAAU,aAAV;AACM,aAAW,WACjB;AAAC;AAKE;;;;AACH,4BAAe,kBAAf,UAAmC;AAC7B,aAAW,WAAgB,gBACjC;AAAC;AAED,4BAAoB,uBAApB;AAAA,oBAcC;AAbuG;AACG;AACD;AACxG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACzD,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AACxD,sBAAE,kBAAa,cAAO;AAAK,uBAAK,MAAqB,KAAM,MAAY,YAAa,cAAQ;AAAA;AAChF,kCAAE,8BAAQ,SAAS;AAAK,uBAAI,MAAO,OAAQ,SAAU;AAAA;AACnD,oCAAE,gCAAQ,SAAS;AAAK,uBAAI,MAAS,SAAQ,SAAU;AAC7E;AAPoC;AAQG;AACzC,eAAO,IAAI,aAAuB,wBACpC;AAAC;AACH,WAAC;AAAA,EA1CkC,YA0ClC;AA1CY,wBAAa,c;;;;;;;;;;;;;ACRvB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACI,sBAA2B;AACrB,4BACxB;AAHiB;AAKX,qBAAU,W;;;;;;;;;;;;;ACPf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAGxD,sCAAuC;AAEvC;AAA6C,uCAAmC;AAuB9E,qCAAmD;AAAnD,oBACE,wCAAiC,wBAAe,iBAAc,aAG/D;AADK,cAAsB,wBAAG,UAAI;AAAK,mBAAI,MAAoB,oBAAK;AAAC;eACtE;AAAC;AA1BD,0BAAW,yBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAKD,0BAAW,yBAAc;AADtB;;;aACH;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACpB,0BAAE;AAAM,2BAAK;AAAA;AACb,0BAAE;AAAM,2BAAS;AAAA;AACL,sCAAE;AAAM,2BAAS;AAAA;AACf,wCAAE;AAAM,2BAAS;AACvC;AAPK;AAST;AAAC;;sBAAA;;AAUD,sCAAI,OAAJ;AACM,aAAQ,QAAqB,qBACd,iBAAM,KAC3B;AAAC;AAED,sCAAO,UAAP;AACM,aAAQ,QAAuB,uBAChB,iBAAM,KAC3B;AAAC;AAED,sCAAQ,WAAR;AACM,aAAQ,QAAY,YAAC,YAAU,WAA2B;AAC1D,aAAQ,QAAS,SAAC,YAAU,WAClC;AAAC;AAED,sCAAe,kBAAf,UAAmC;AAC7B,aAAQ,QAAS,SAAmB,oBAAgB,cAC1D;AAAC;AAED,sCAAU,aAAV;AACM,aAAQ,QAAS,SAAC,YAAU,WAClC;AAAC;AAED,sCAAmB,sBAAnB,UAAwC;AACwB;AACpB;AAC1C,YAAoB,iBACZ,KAAQ,QAAS,SAAC,YAAU,WAA2B;AAE/D,YAAO,IAAa,iBAAc,WAAE;AAClC,gBAAkB,gBAAE;AACd,qBAAQ,QAAY,YAAC,YAAU,WAAqB;AACpD,qBAAQ,QAAY,YAAC,YAAU,WAA2B;AAC/D;AAEL;AAAC;AACH,WAAC;AAAA,EAjE4C,aAiE5C;AAjEY,kCAAuB;AAmE6E;AACjH,kBAAuC,wB;;;;;;;;;;;;;AC3EpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,iE;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAGtD,uCAAyD;AAEzD;AACI,iCAAyC;AAD7C;mEAmEA;AAAC;AAjEQ,sBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAqB,kBAC9B;AAAC;AAED,0BAAI,6BAAW;aAAf,aAA8B;AACxB,iBAAW,WAAe,eAChC;AAAC;;sBAAA;;AAED,0BAAI,6BAAQ;aAAZ,aAA0B;AACpB,iBAAW,WAAY,YAC7B;AAAC;;sBAAA;;AAED,0BAAI,6BAAM;aAAV,aAAwB;AAClB,iBAAW,WAAU,UAC3B;AAAC;;sBAAA;;AAED,0BAAI,6BAAO;aAAX,aAA0B;AACpB,iBAAW,WAAW,WAC5B;AAAC;;sBAAA;;AAED,gCAAI,OAAJ;AACM,aAAW,WACjB;AAAC;AAED,gCAAK,QAAL;AACM,aAAW,WACjB;AAAC;AAED,gCAAoB,uBAApB;AAAA,oBAoCC;AAnCuG;AACG;AACzG,YAAa;AACH,sBAAE,kBAAkB;AACtB,sBAAK,KAAU,UAAI,IACzB;AAAC;AACU,yBAAE;AACP,sBAAK,KACX;AAAC;AACgB,+BAAE,2BAAsB,eAAe;AACtD,oBAAe,YAAO,MAAK,KAAc,cACrC,aAA2B,4BAAQ,QAAsB;AAC7D,oBAAa,WAAE;AACJ,8BAAM,MAAY,YAAc,eAAS;AAEtD;AAAC;AACiB,gCAAE,4BAAsB,eAAe;AACvD,oBAAgB,aAAO,MAAK,KAAc,cACtC,aAA2B,4BAAQ,QAAuB;AAC9D,oBAAc,YAAE;AACJ,+BAAM,MAAY,YAAc,eAAS;AAEvD;AAAC;AACO,sBAAE,kBAAkB;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AACzD,6BAAE,yBAAsB;AACjC,sBAAK,KAAgB,gBAC3B;AAAC;AACU,yBAAE,qBAAkB;AACzB,sBAAK,KAAU,UAAO,OAC5B;AAAC;AACW,0BAAE,sBAAsB,eAAe;AAC7C,sBAAK,KAAa,aAAc,eACtC;AACA;AA/BwC;AAgC1C,eAAO,IAAI,aAA2B,4BACxC;AAAC;AACH,WAAC;AAAA,EAlEG,YAkEH;AAnEY,4BAAiB,kB;;;;;;;;;;;;;ACP3B;;;;;;;;;;;;;;;;;;;;;;;;AAEU,QAAU;AACT,kBAA+B;AACxB,yBAAsC;AAC3C,oBACd;AAJwB;AAMb,QAAO;AACL,mBAAiB;AACX,yBAAoC;AAC7C,gBAAc;AACJ,0BACpB;AALqB,E;;;;;;;;;;;;;ACRpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,iCAAgE;AAChE,uCAAwD;AAGxD,sCAAgD;AAEhD;AACI,2CAAuC;AA4BzC,yCAAuD;eACrD,wCAAqC,4BAAe,iBAAc,aACpE;AAAC;AA5BD,0BAAW,6BAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,6BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,6BAAc;aAAzB;AACE;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACX,mCAAE;AAAM,2BAAI;AAAA;AACX,oCAAE;AAAM,2BAAI;AAAA;AACtB,0BAAE;AAAM,2BAAK;AAAA;AACN,iCAAE;AAAM,2BAAS;AAAA;AACrB,6BAAE;AAAM,2BAAS;AAAA;AAChB,8BAAE;AAAM,2BAAS;AAEjC;AAVS;AAUR;;sBAAA;;AAWD,0CAAI,OAAJ;AACM,aAAc,gBAAG,CAAK,KAAQ,QAAS,SAAC,YAAU,WAAsB;AACxE,aAAW,aAAO,KAAQ,QAAS,SAAC,YAAU,WAAiB;AAC/D,aAAS,WAAK;AACd,aAAO,SACb;AAAC;AAED,0CAAc,iBAAd,UAAqC;AAC/B,aAAc,gBAAiB;AAEnC,YAAQ,KAAc,eAAE;AAClB,iBAAQ,QAAY,YAAC,YAAU,WAAsB;AACrD,iBAAQ,QAAa,aACrB,YAAO,QAAc,eAAM,KAAS,SAAa;AACjD,iBAAsB,sBAAK,KAAW;AACtC,iBAAqB,qBAAK,KAAS;AAEhC;AACR;AAED,YAAQ,KAAW,YAAE;AACkD;AACC;AACH;AACD;AACzD;AACL,iBAAQ,QAAY,YAAC,YAAU,WAAiB;AAChD,iBAAQ,QAAe;AACvB,iBAAQ,QAAS,SAAC,YAAU,WAAiB;AAClD;AAEG,aAAQ,QAAS,SAAC,YAAU,WAAsB;AAClD,aAAQ,QAAgB,gBAAC,YAAO,QAAgB;AAChD,aAAsB,sBAAI;AAC1B,aAAqB,qBAC3B;AAAC;AAED,0CAAc,iBAAd;AACE,eAAW,KACb;AAAC;AAED,0CAAW,cAAX,UAAyB;AACnB,aAAS,WAAS;AACtB,YAAQ,KAAc,eAAE;AAClB,iBAAsB,sBAAQ;AAC9B,iBAAQ,QAAa,aAAC,YAAO,QAAc,eAAO,MAAa;AAEvE;AAAC;AAED,0CAAW,cAAX;AACE,eAAW,KACb;AAAC;AAED,0CAAS,YAAT,UAAuB;AACjB,aAAO,SAAS;AACpB,YAAQ,KAAc,eAAE;AAClB,iBAAqB,qBAAQ;AAErC;AAAC;AAED,0CAAU,aAAV,UAA8B;AACxB,aAAW,aAAc;AAE7B,YAAI,CAAK,KAAc,eAAE;AACsC;AACW;AACH;AACK;AACjE;AACL,iBAAQ,QAAY,YAAC,YAAU,WAAsB;AACrD,iBAAQ,QAAe;AACvB,iBAAQ,QAAS,SAAC,YAAU,WAAsB;AACvD;AAED,YAAQ,KAAW,YAAE;AACf,iBAAQ,QAAS,SAAC,YAAU,WAAiB;AAC1C;AACR;AAEG,aAAQ,QAAY,YAAC,YAAU,WACrC;AAAC;AAED,0CAAI,OAAJ;AACM,aAAQ,QAAY,YAAC,YAAU,WACrC;AAAC;AAED,0CAAK,QAAL;AACM,aAAQ,QAAS,SAAC,YAAU,WAClC;AAAC;AAEO,0CAAqB,wBAA7B,UAAmD;AACjD,YAAW,QAAG,YAAuB,gBAAI;AAEsC;AAC/E,YAAmB,gBAAG,OAAa,WAAkB,cACjD,OAAsB,uBAAO,QAAgB,eAAa;AAC1D,aAAQ,QAAmB,mBAAc,eAC/C;AAAC;AAEO,0CAAoB,uBAA5B,UAAkD;AAChD,YAAW,QAAmB,gBAAM,MAAI;AACpC,aAAQ,QAAkB,kBAAC,YAAO,QAAW,YACnD;AAAC;AACH,WAAC;AAAA,EAvIG,aAuIH;AAxIY,sCAA2B;AA0IyE;AACjH,kBAA2C,4B;;;;;;;;;;;;;ACnJxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,qE;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,qCAAwD;AAExD,sCAAgD;AAChD,uCAA+C;AAK/C;AAA6B,uBAA+B;AAA5D;mEAgSA;AAAC;AA/RC,0BAAI,mBAAQ;aAAZ,aAA2B;AACrB,iBAAW,WAAuB,uBACxC;AAAC;;sBAAA;;AAED,0BAAI,mBAAY;aAAhB;AACE,mBAAS,GAAM,MAAK,KACZ,KAAK,KAAiB,iBAAC,MAAI,YAAU,WAC/C;AAAC;;sBAAA;;AAED,0BAAI,mBAAS;aAAb,aAA4B;AACtB,iBAAW,WAAa,aAC9B;AAAC;;sBAAA;;AAKD,0BAAI,mBAAmB;AADpB;;;aACH;AACE,mBAAW,KAAW,WACxB;AAAC;;sBAAA;;AAMD,0BAAI,mBAAY;AADb;;;;aACH,aAAsC;AAChC,iBAAW,WAAgB,gBACjC;AAAC;;sBAAA;;AAED,0BAAI,mBAAe;aAAnB,aAAkD;AAC5C,iBAAW,WAAmB,mBACpC;AAAC;;sBAAA;;AAED,0BAAI,mBAAa;aAAjB;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAAqC;AAC/B,iBAAW,WAAiB,iBAClC;AAAC;;sBAJA;;AAMM,YAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAW,QACpB;AAAC;AAOD,sBAAkB,qBAAlB;AACM,aAAa,eAAO,KAAkB,kBAAK,KAAO;AAClD,aAAe,iBAAO,KAAoB,oBAAK,KAAO;AACtD,aAAsB,wBAAO,KAAoB,oBAAK,KAAO;AAC7D,aAAuB,yBAAO,KAAqB,qBAAK,KAAO;AAC/D,aAAO,OAAU,WAAM,KAAiB;AACxC,aAAO,OAAQ,SAAM,KAAe;AACpC,aAAO,OAAU,WAAM,KAAwB;AAC/C,aAAO,OAAW,YAAM,KAAyB;AACjD,aAAU;AACV,aACN;AAAC;AAED,sBAAO,UAAP;AACM,aAAS,SAAU,WAAM,KAAiB;AAC1C,aAAS,SAAQ,SAAM,KAAe;AACtC,aAAS,SAAU,WAAM,KAAwB;AACjD,aAAS,SAAW,YAAM,KAChC;AAAC;AAED,sBAAM,SAAN;AACE,YAAe,YAAO,KAAK,KAAa,aAAC,YAAO,QAAmB;AAC/D,aAAS,WAAY,cAAK,YAAO,QAA6B;AAEF;AAC9D,WAAM,MAAK,KAAK,KAAK,KAAiB,iBAAmC,mCAC/D,QAAC,UAAY;AACjB,eAAa,aAAW,YAC5B;AAAG;AAEoE;AACzE,WAAM,MAAK,KAAK,KAAK,KAAiB,iBAAC,YAAO,QAA2B,2BAC/D,QAAC,UAAY;AAAK,mBAAE,GAAa,aAAW,YAAO;AAAE;AAE7D,aAAW,WACjB;AAAC;AAME;;;;;AACH,sBAAc,iBAAd,UAA4B;AAC1B,YAAiB,cACT,KAAc,cAAC,MAAI,YAAU,WAAiC;AACtE,YAAe,aAAE;AACf,mBAAkB,YAAY,eAAO;AACtC;AAED,YAAoB,iBACZ,KAAc,cAAC,MAAI,YAAU,WAAyB;AAC9D,eAAsB,kBAAkB,eAAa,WAA9C,IACT;AAAC;AAIE;;;AACH,sBAAkB,qBAAlB;AAAA,oBAyBC;AAxBC,YAAuB,oBACf,KAAK,KAAiB,iBAAC,YAAO,QAA8B;AACpE,YAA4B,yBAAO,KAAK,KAAc,cAAC,cAClD,YAAU,WAA0B,2CACpC,YAAU,WAAyB,2BACrC;AACH,YAA2B,wBACnB,KAAK,KAAc,cAAC,YAAO,QAA8B;AAEjE,YAAqB,kBAAO,QAAE;AAC5B,gBAAsB,mBACd,KAAK,KAAiB,iBAAC,YAAO,QAAiC;AACnE,iBAAc,mBACR,IAAK,KAAiB,kBAAE,UAAkB;AAAK,uBAAI,MAAa,aAAQ,QAAU;AAAc,aAApG;AACP,mBAAgC,wBAAE;AACjC,gBAA0B,uBAAU,UAAS,SAAC,YAAU,WAA2B,4BAAE;AAC/E,qBAAW,WAAqB,qBAAO;AAC5C;AAEG,iBAAgB,kBAAQ;AACxB,iBAAc,gBAAO,KAAa,aAAQ,QAAyB;AACxE,SAPM,MAOA,IAAyB,uBAAE;AAC5B,iBAAc,gBAAO,KAAa,aAAQ,QAAwB;AAE1E;AAAC;AAME;;;;;AACH,sBAAU,aAAV,UAA4B,WAAoB;AAC1C,aAAW,WAAW,WAAU,WACtC;AAAC;AAWE;;;;;;;;;;AACH,sBAAkB,qBAAlB,UAAmC,UAAwB;AACzD,eAAW,KAAW,WAAmB,mBAC7B,UAAe,eAAkB,gBAC/C;AAAC;AAED,sBAAoB,uBAApB;AAAA,oBA0EC;AAzEuG;AACG;AACzG,YAAa;AACY,qCAAE,iCAAM,OAAW;AACxC,oBAAa,UAAO,MAAa,aAAQ;AACzC,oBAAW,SAAE;AACJ,4BAAU,UAAI,IAAY;AAErC;AAAC;AACe,8BAAE,0BAAM;AACtB,oBAAa,UAAO,MAAa,aAAmC;AACpE,oBAAW,SAAE;AACJ,4BAAS;AAEpB;AAAC;AAC0B,yCAAE,qCAAM,OAAM;AACrC,uBAAI,MAAa,aAAO,OAAa,aAAM;AAAA;AACzB,oCAAE;AACpB,uBAAI,MAAa,aAAQ,QAAS,SAAgB;AAAA;AACtC,8BAAE;AAAM,uBAAI,MAAa,aAAO;AAAA;AAC3B,mCAAE,+BAAM;AACzB,uBAAI,MAAe,eAAK,MAAa,aAAQ;AAAA;AAC/B,gCAAE,4BAAM;AACxB,oBAAc,WAAO,MAAa,aAAQ;AAC1C,uBAAO,CAAC,CAAS,SAAc,cAAC,YAAO,QACzC;AAAC;AACc,6BAAE,yBAAM;AACrB,oBAAc,WAAO,MAAa,aAAQ;AAC1C,uBAAO,CAAC,CAAS,SAAc,cAAC,YAAO,QACzC;AAAC;AACuB,sCAAE,kCAAM;AAC9B,oBAAc,WAAO,MAAa,aAAQ;AAC1C,oBAAc,WAAW,SAAc,cAAmB,YAAO,QAAoB;AACrF,uBAAgB,SAClB;AAAC;AACgB,+BAAE;AACjB,uBAAW,MAAK,KAAS,SAAS,SACpC;AAAC;AACY,2BAAE;AAAM,uBAAQ,SAAc,kBAAS,MAAK;AAAA;AAClC,qCAAE,iCAAM,OAAW;AACtC,uBAAI,MAAa,aAAO,OAAU,UAAS,SAAW;AAAA;AAC9C,0BAAE,sBAAM;AACd,sBAAK,KAA2B,YAAO,QAAa,cAAE,EAAM,OAAC,SAAqB,mBACxF;AAAC;AACyB,wCAAE,oCAAM,OAAW;AAC3C,oBAAa,UAAO,MAAa,aAAQ;AACzC,oBAAW,SAAE;AACJ,4BAAU,UAAO,OAAY;AAExC;AAAC;AAC0B,yCAAE,qCAAM,OAAM,MAAO;AAC9C,oBAAa,UAAO,MAAa,aAAQ;AACzC,oBAAW,SAAE;AACJ,4BAAa,aAAK,MAAS;AAEtC;AAAC;AAC+B,8CAAE,0CAAM,OAAW;AACjD,oBAAc,WAAO,MAAa,aAAQ;AAC1C,oBAAc,WAAW,SAAc,cAAmB,YAAO,QAA0B;AAClF,yBAAQ,UAAa;AAE9B,oBAAW,QAAW,SAAY,YAAU;AACvC,sBAAU,UAAS,UAAM,MAAQ;AAC7B,yBAAc,cACzB;AAAC;AAC6B,4CAAE,wCAAc,eAAe;AAC3D,oBAAa,UAAO,MAAa,aAAgB;AACjD,oBAAsB,mBAChB,GAAM,MAAK,KAAQ,QAAiB,iBAAC,YAAO,QAAqC;AACvE,iCAAQ,QAAC,UAAG;AAAK,2BAAE,GAAa,aAAW,YAAgB;AAC7E;AACA;AArE8B;AAsEhC,eAAO,IAAI,aAAiB,kBAC9B;AAAC;AAKE;;;;AACK,sBAAiB,oBAAzB,UAAoC;AAClC,YAAiB,cAAM,IAAmB;AAC1C,YAAmB,gBAAG,WAAO,QAAY,aAAE,MAAI,YAAU,WAAgB,0BAAM,YAAU,WAAS;AAE7C;AACrD,YAAiB,iBAAI,WAAO,QAAc,eAAE,MAAI,YAAU,WAAmB,kBAAE;AAC7E,mBAAW,KAAa,aAAQ,QAAgB;AACjD;AAED,eAAO,CACT;AAAC;AAIE;;;AACK,sBAAmB,sBAA3B,UAA2C;AACzC,YAAW,QAAO,KAAkB,kBAAM;AACtC,aAAW,WAAc,cAAI,KACnC;AAAC;AAIE;;;AACK,sBAAoB,uBAA5B,UAA4C;AAC1C,YAAW,QAAO,KAAkB,kBAAM;AACtC,aAAW,WAAe,eAAI,KACpC;AAAC;AAKE;;;;AACK,sBAAmB,sBAA3B,UAA8C;AAC5C,YAAW,QAAO,KAAkB,kBAAM;AAC1C,YAAY,SAAM,IAAmB;AACjC,aAAW,WAAc,cACtB,KAAQ,OAAU,UAAS,SAAC,YAAU,WAAiB,kBAChE;AAAC;AAIE;;;AACK,sBAAiB,oBAAzB,UAAyC;AACvC,YAAW,QAAO,KAAkB,kBAAM;AAC1C,YAAY,SAAM,IAAmB;AAEsE;AAC3G,YAAoB,iBAAG,CAAC,WAAO,QAAO,QAAE,YAAO,QAA0B;AACrE,aAAW,WAAY,YAAM,OACnC;AAAC;AACH,WAAC;AAAA,EAhS4B,YAgS5B;AAhSY,kBAAO,Q;;;;;;;;;;;;;ACZjB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACW,+BAA4B;AACtC,qBAAiB;AACR,8BAA2B;AAC3B,8BAA2B;AAC/B,0BAAuB;AACf,kCAA+B;AACvD,UACJ;AARiB;AAyCF,qBAAU;AA/B3B,IAAa;AACC,kBAAkB;AAClB,kBAAgB;AACE,oCAA0C;AAC7C,iCAAuC;AACtD,kBAAgB;AACf,mBAAiB;AACd,sBAAoB;AACT,iCAAc;AACd,iCAAqB;AACnC,mBAAiB;AACP,6BAA+C;AACrD,uBAA0B;AACV,uCAAE,YACpB,WAAgB,qDAChB,WAAgB,kBAC9B;AACuB,8BAAE,YACX,WAAgB,qDAChB,WAAgB,iCAChB,WAAgB,oEAChB,WAAgB,kBAC9B;AACa,oBACd;AAxBc;AA+BR,kBAAO;AALf,IAAa;AACA,iBAAE,CAAE;AACkB,uCACjC;AAHc;AAKa,kBAAO,Q;;;;;;;;;;;;;AC3CjC;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAA6B,0BAAG,CAAQ,SAAU,UAAY,YAAY;AAOvE;;;;;;AACU,QAAmB,sBAAG,UAAmB;AACpD,QAAY,SAAM,IAAmB;AACrC,QAAI,CAAO,QAAE;AACJ;AACR;AACD,QAAa,UAAG,MAAS,OAAU,SAAe;AAClD,QAA2B,wBAAQ,QAAS,aAAK,CAAE,GAAE;AAChD,YAAkB;AAEzB;AAAC,E;;;;;;;;;;;;;ACnBE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AACxD,qCAAoD;AAGpD,sCAAyD;AACzD,iDAAyC;AAEzC,mCAA6C;AAE7C,SAAsB,cAA4B;AAChD,WAAoB,yBACtB;AAAC;AAED;AAAuC,iCAA6B;AAkDlE,+BAA6C;AAA7C,oBACE,wCAA2B,kBAAe,iBAAc,aACzD;AAjBO,cAAU,aAAS;AACnB,cAAW,cAAQ;AACnB,cAAsB,yBAAS;AAC/B,cAAc,iBAAiB,YAAO,QAAa;AACnD,cAAgB,mBAAG,YAAO,QAAa;AACvC,cAAkB,qBAAS;AAC3B,cAAqB,wBAAuB;AAC5C,cAAe,kBAAS;AACxB,cAAY,eAAS;AAErB,cAAY,eAAS;AAC2B;AACvC,cAAc,iBAAY,UAAa;AAChD,cAAsB,yBAAG,IAAyC;eAI1E;AAAC;AAnDD,0BAAW,mBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,mBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,mBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,mBAAc;aAAzB;AACE;AACyB,yCAAE;AAAM,2BAAS;AAAA;AACxB,kCAAE;AAAM,2BAAS;AAAA;AACN,6CAAE;AAAM,2BAAI;AAAA;AACjB,wCAAE;AAAM,2BAAC;AAAA;AACf,kCAAE;AAAM,2BAAC;AAAA;AACP,oCAAE;AAAM,2BAAK;AAAA;AAChB,iCAAE;AAAM,2BAAK;AAAA;AACJ,0CAAE;AAAM,2BAAK;AAAA;AACpB,mCAAE;AAAM,2BAAK;AAAA;AACjB,+BAAE;AAAM,2BAAK;AAAA;AACH,yCAAE;AAAM,2BAAK;AAAA;AACxB,8BAAE;AAAM,2BAAS;AAAA;AACH,4CAAE;AAAM,2BAAS;AAAA;AAChB,6CAAE;AAAM,2BAAS;AAAA;AACZ,kDAAE;AAAM,2BAAS;AAAA;AACnB,gDAAE;AAAM,2BAAS;AAAA;AAC1B,uCAAE;AAAM,2BAAE;AAEnC;AAnBS;AAmBR;;sBAAA;;AAqBD,gCAAM,SAAN;AACE,YAAQ,KAAQ,QAAmB,uBAAM,GAAE;AAClC;AACR;AAED,YAAQ,KAAQ,QAAmB,mBAAG,IAAE;AAClC,iBAAgB,kBAAQ;AAC7B,eAAM,IAAQ,KAAQ,QAAgB,gBAAG,IAAE;AACtC,iBAAa,eAAQ;AAC1B;AAED,YAAQ,KAAa,cAAE;AACjB,iBAAuB,yBAAO,KAA4B;AAElE;AAAC;AAIE;;;AACH,gCAAY,eAAZ,UAA2B;AACrB,aAAW,aACjB;AAAC;AAIE;;;AACH,gCAAsB,yBAAtB,UAAqC;AAC/B,aAAY,cAClB;AAAC;AAIE;;;AACH,gCAAkB,qBAAlB,UAAiC;AAC3B,aAAuB,yBAC7B;AAAC;AAKE;;;;AACH,gCAAe,kBAAf,UAAqC;AAC/B,aAAa,eAAgB;AACjC,YAAgB,cAAE;AACZ,iBAAuB,yBAAO,KAA4B;AAElE;AAAC;AAIE;;;AACH,gCAAqB,wBAArB;AACE,eAAW,KAAa,gBACX,UAAmB,mBAAK,KACvC;AAAC;AAIE;;;AACH,gCAAoB,uBAApB,UAA0C;AACpC,aAAmB,qBACzB;AAAC;AAED,gCAAgB,mBAAhB;AACE,eAAW,KACb;AAAC;AAED,gCAAgB,mBAAhB,UAAoC;AAClC,YAAI,CAAK,KAAc,cAAO,QAAE;AACvB;AACR;AAED,YAAQ,KAAgB,iBAAE;AACpB,iBAAoB,oBAAoB;AAC7C,mBAAc,KAAa,cAAE;AACxB,iBAAiB,iBAAkB;AACxC,SAFM,MAEA;AACD,iBAA2B,2BAAkB;AAErD;AAAC;AAIE;;;AACH,gCAAa,gBAAb,UAA2B,GAAuB;AAChD,YAAiB,iBAAK,GAAE;AAClB,iBAAiB,mBAAiB;AAClC,iBAAQ,QAA+B,+BAAc,eAAO;AAEpE;AAAC;AAIE;;;AACH,gCAAc,iBAAd,UAA4B,GAAuB;AAAnD,oBAcC;AAbC,YAAiB,iBAAK,GAAE;AAClB,iBAAQ,QAA+B,+BAAc,eAAQ;AAClE;AAKE;;;;AACO,mBAAC;AACT,gBAAI,CAAK,MAAQ,QAAoB,qBAAE;AACjC,sBAAmC;AAE3C;AAAC,WACH;AAAC;AAIE;;;AACH,gCAAa,gBAAb,UACwB,OAAyB,gBAAuB;AADxE,oBAoGC;AAlGC,YAAiB,cAAG,WAAY,aAAO,WAAiB;AACxD,YAAe,YAAG,WAAY,aAAO,WAAe;AACpD,YAAkB,eAAG,WAAY,aAAO,WAAkB;AAC1D,YAAiB,cAAG,WAAY,aAAO,WAAiB;AACxD,YAAY,SAAG,WAAY,aAAO,WAAY;AAC9C,YAAW,QAAG,WAAY,aAAO,WAAW;AAC5C,YAAa,UAAG,WAAY,aAAO,WAAa;AAChD,YAAa,UAAG,WAAY,aAAO,WAAgB;AAEnD,YAAQ,KAAQ,QAAgB,iBAAE;AAChC,gBAAa,aAAS,OAAE;AACjB,sBAAkB;AACnB,qBAAoB;AACzB,mBAAM,IAAe,eAAU,QAAE;AAC3B,sBAAkB;AACnB,qBAAqB;AAC1B;AAED,gBAAQ,KAAa,cAAE;AACrB,oBAAuB;AAChB;AACW,sCAAE,0BAAM;AAClB,8BAAiB,iBACvB;AAAC;AACe,sCAAE,CAAE;AACJ,sCAAgB;AACV,4CAAM,KAAuB;AAC9B,2CAAE,+BAAM;AACzB,+BAAI,MAAQ,QAAwB,wBAC3B,OAAE,YAAU,WAA0B;AACnD;AAXqD;AAa9C,0BAAc,cAAkB,mBAAM,KAAiB;AACjE;AAEM;AACR;AAED,YAAgB,eAAO,KAAQ,QAA0B;AACzD,YAAgB,iBAAK,CAAE,GAAE;AACX,2BAAiB;AAC7B,gBAAgB,eAAI,GAAE;AAC2C;AACZ;AAC5C;AACR;AACF;AAED,YAAS,KAAY,eAAoB,WAArC,IAAsC,CAAK,KAAY,eAAiB,cAAE;AAC5E,qBAAmB,oBAAQ;AACvB,iBAAiB,iBAAe;AACrC,mBAAe,KAAY,eAAkB,SAAnC,IAAoC,CAAK,KAAY,eAAgB,aAAE;AAChF,qBAAmB,oBAAQ;AACvB,iBAAiB,iBAAe;AACrC,SAHM,UAGU,QAAE;AACjB,qBAAmB,oBAAQ;AACvB,iBAAqB;AAC1B,SAHM,UAGS,OAAE;AAChB,qBAAmB,oBAAQ;AACvB,iBAAoB;AACzB,SAHM,MAGA,IAAW,WAAW,SAAE;AAC7B,gBAAkB,gBAAE;AACkF;AACpG,oBAAY,SAAQ,MAA0B;AAC9C,oBAAU,UAAU,OAAQ,YAAQ,OAAW,SAAE;AACxC;AACR;AACD,yBAAmB,oBAAQ;AAE3B,oBAAQ,KAAQ,QAAwB,wBACpB,cAAE,YAAU,WAA0B,2BAAE;AACnD;AACR;AAED,oBAAI,CAAK,KAAwB,yBAAE;AACjC,wBAAQ,KAAoB,qBAAE;AACxB,6BAA0B,0BAAe;AAC9C;AACG,yBAAQ,QAAa,aAAe;AACzC;AACF;AACF;AAED,YAAQ,KAAa,cAAE;AACrB,gBAAuB;AAChB;AACW,kCAAE,0BAAM;AAClB,0BAAiB,iBACvB;AAAC;AACe,kCAAM,KAAiB;AACvB,kCAAgB;AACV,wCAAM,KAAuB;AAC9B,uCAAE,+BAAM;AAAK,2BAAI,MAAQ,QAAwB,wBAC7D,OAAE,YAAU,WAA0B;AAC/C;AAVqD;AAY9C,sBAAc,cAAkB,mBAAM,KAAiB;AAEpE;AAAC;AAIE;;;AACH,gCAAW,cAAX,UAAyB,OAAyB;AAChD,YAAS,UAAK,YAAO,QAAY,aAAE;AAC1B;AACR;AAEG,aAAoB,oBAAQ;AAC5B,aAAiB,mBAAS;AAE9B,YAAQ,KAAQ,QAAwB,wBAC3B,OAAE,YAAU,WAA0B,2BAAE;AAC5C;AACR;AACD,YAAQ,KAAoB,qBAAE;AACxB,iBAA0B,0BAAM,OAAkB;AACvD;AAEG,aAAQ,QAAa,aAC3B;AAAC;AAIE;;;AACH,gCAAgB,mBAAhB,UAA8B;AAC5B,YAAW,QAAO,KAAQ,QAAoB;AAC9C,YAAa,YAAQ,QAAK;AAC1B,YAAa,aAAS,OAAE;AACtB,gBAAQ,KAAW,YAAE;AACV,4BAAK;AACf,mBAAM;AACgD;AACrD,uBAAa;AACd;AACF;AACG,aAAiB,iBAAY;AAEjC,eACF;AAAC;AAIE;;;AACH,gCAAgB,mBAAhB,UAA8B;AAC5B,YAAa,YAAQ,QAAK;AAC1B,YAAa,YAAI,GAAE;AACjB,gBAAQ,KAAW,YAAE;AACV,4BAAO,KAAQ,QAAmB,qBAAK;AACjD,mBAAM;AACiD;AACtD,uBAAa;AACd;AACF;AACG,aAAiB,iBAAY;AACjC,eACF;AAAC;AAED,gCAAiB,oBAAjB;AACM,aAAiB,iBAAI;AACzB,eACF;AAAC;AAED,gCAAgB,mBAAhB;AACE,YAAe,YAAO,KAAQ,QAAmB,qBAAK;AAClD,aAAiB,iBAAY;AACjC,eACF;AAAC;AAKE;;;;AACH,gCAAU,aAAV,UAA4B,WAAoB;AAC9C,YAAI,CAAK,KAAc,cAAW,YAAE;AAC3B;AACR;AAED,YAAa,WAAE;AACT,iBAAQ,QAA2B,2BAC1B,WAAE,YAAU,WAA2B;AAChD,iBAAQ,QAA4B,4BAC3B,WAAE,YAAO,QAAc,eAAW;AAChD,eAAM;AACD,iBAAQ,QAAwB,wBACvB,WAAE,YAAU,WAA2B;AAChD,iBAAQ,QAA4B,4BAC3B,WAAE,YAAO,QAAc,eAAU;AAElD;AAAC;AAGO,gCAA0B,6BAAlC,UAAgD;AAC9C,YAAQ,KAAe,mBAAU,OAAE;AAC1B;AACR;AAED,YAAqB,oBAAG,YAAU,WAA0B;AAC5D,YAAQ,KAAmB,oBAAE;AACV,gCAAG,YAAU,WAA2B;AAC1D;AAED,YAAQ,KAAe,mBAAK,YAAO,QAAY,aAAE;AAC3C,iBAAQ,QAA2B,2BAC/B,KAAyB,gBAAqB;AACvD;AACG,aAAQ,QAAwB,wBAAM,OAAqB;AAC3D,aAAkC,kCAAQ;AAE1C,aAAe,iBACrB;AAAC;AAIE;;;AACK,gCAAiC,oCAAzC,UAAuD;AAC8D;AACnH,YAAQ,KAAe,mBAAK,YAAO,QAAY,aAAE;AAC3C,iBAAsB,wBAClB,KAAQ,QAA4B,4BAAM,OAAE,YAAO,QAAe;AAC3E;AAED,YAAmB,gBAAO,KAAsB,0BAAU;AAC1D,YAAmB,gBAAkB,gBAAC,YAAO,QAAe,eAAC,YAAO,QAAe;AAEnF,YAAQ,KAAe,mBAAK,YAAO,QAAY,aAAE;AAC3C,iBAAQ,QAA4B,4BAChC,KAAyB,gBAAe,eAAW;AAC5D;AAED,YAAwB,qBAAkB,gBAAK,KAAwB,wBAAQ;AAC3E,aAAQ,QAA4B,4BAC/B,OAAe,eAC1B;AAAC;AAIE;;;AACK,gCAAgB,mBAAxB,UAAsC;AAChC,aAAQ,QAAiC,iCAAM,OAAQ;AAE3D,YAAQ,KAAe,mBAAK,YAAO,QAAY,aAAE;AAC3C,iBAAQ,QAA4B,4BAChC,KAAyB,gBAAE,YAAO,QAAa,cAAW;AACnE;AAEG,aAAQ,QAA4B,4BAC/B,OAAE,YAAO,QAAa,cAAU;AAErC,aAAe,iBACrB;AAAC;AAEO,gCAAmB,sBAA3B,UAA2C;AACzC,aAAK,IAAK,IAAI,GAAG,IAAO,KAAQ,QAAmB,oBAAK,KAAE;AACxD,gBAAa,YAAS;AACtB,gBAAS,MAAQ,QAAG,MAAK,GAAE;AAChB,4BAAQ;AAClB;AAEG,iBAAQ,QAAiC,iCAAE,GAAa;AACxD,iBAAQ,QAA4B,4BACnC,GAAE,YAAO,QAAa,cAAa,YAAS,SAAU;AAC5D;AAEG,aAAe,iBACrB;AAAC;AAEO,gCAAmB,sBAA3B,UAAyC;AACvC,YAAQ,KAAiB,qBAAK,YAAO,QAAY,eAAS,UAAM,GAAE;AACK;AACuB;AACxF,iBAAQ,QAA4B,4BAAE,GAAY,YAAQ;AAC/D,eAAM,IAAQ,KAAiB,oBAAK,KAAQ,KAAiB,qBAAU,OAAE;AACpE,iBAAQ,QAA4B,4BAChC,KAAiB,kBAAY,YAAQ;AAC9C;AAEG,aAAQ,QAA4B,4BAAM,OAAY,YAC5D;AAAC;AAIE;;;AACK,gCAAiB,oBAAzB;AACE,eAAW,KAAuB,0BAAQ,KAAgB,mBAAQ,KACpE;AAAC;AAEO,gCAA+B,kCAAvC;AACE,YAAe,cAAK;AAEpB,YAAQ,KAAoB,qBAAE;AAC5B,gBAAI,OAAW,KAAe,mBAAa,YAAQ,KAAe,mBAAK,YAAO,QAAY,aAAE;AAC/E,8BAAO,KAAgB;AACnC,mBAAM,IAAiB,cAAK,KAAgB,mBAAQ,KAAe,eAAO,SAAI,GAAE;AACpE,mCAAsB,eAAO,OAAC,UAAa,cAAU;AAAK,2BAAI,KAAI,IAAa,cAAW;AAAE,iBAArF;AACnB;AACF;AAEG,aAAoB,oBAC1B;AAAC;AAEO,gCAAa,gBAArB,UAAyC;AAAzC,oBAmBC;AAlBC,YAAS,iBAAiB,OAAE;AAC1B,gBAAI,CAAK,KAAgB,iBAAE;AACzB,sBAAM,IAAS,MAAgF;AAChG;AAED,gBAAS,MAAO,WAAM,GAAE;AACtB,uBAAY;AACb,mBAAM;AACL,6BAAiB,KAAC,UAAE;AAAK,2BAAI,MAAgB,gBAAG;AAAE,iBAAtC;AACb;AACF,mBAAU,OAAY,UAAa,UAAE;AACpC,gBAAQ,KAAgB,iBAAE;AACxB,sBAAM,IAAS,MAAsF,wFAAU;AAChH;AACD,mBAAW,KAAgB,gBAAQ;AACpC,SALM,MAKA;AACL,mBAAa;AAEjB;AAAC;AAEO,gCAAe,kBAAvB,UAAqC;AACnC,YAAc,WAAO,KAAQ,QAAoB;AACjD,eAAY,SAAK,KAAS,QAC5B;AAAC;AAKE;;;;AACK,gCAAyB,4BAAjC,UAA+C,OAAuB;AAArB;AAAA,6BAAqB;;AACpE,YAAQ,KAAgB,iBAAE;AACpB,iBAAuB,uBAAM,OAAkB;AACpD,eAAM;AACD,iBAAiB,iBAAQ;AAEjC;AAAC;AAEO,gCAAsB,yBAA9B,UAA4C,OAAyB;AACnE,YAAa,YAAO,KAAQ,QAAyB,yBAAQ;AAE7D,YAAkB,gBAAE;AACT,wBAAG,CAAW;AACnB,iBAAQ,QAAiC,iCAAM,OAAa;AACjE;AAEG,aAAQ,QAA4B,4BAC/B,OAAE,YAAO,QAAa,cAAa,YAAS,SAAU;AAEiD;AAChH,YAAmB,kBAAO,KAAe,mBAAK,YAAO,QAAc,cAAK,KAAM,KAA4B,eAAS;AAEnH,YAAa,WAAE;AACE,4BAAK,KAAQ;AAC7B,eAAM;AACU,8CAAyB,OAAC,UAAE;AAAK,uBAAC,MAAU;AAAE,aAA5B;AAClC;AAEG,aAAe,iBACrB;AAAC;AAEO,gCAAgB,mBAAxB,UAAsC;AAChC,aAAoB,oBAAQ;AAC5B,aAAQ,QAAiB,iBAAQ;AACjC,aAAiB,mBACvB;AAAC;AAcE;;;;;;;;;;;;;AACH,gCAAkB,qBAAlB,UACoB,UAAwB,eAAmB;AAD/D,oBAcC;AAb6C;AAAA,wBAAiB;;AAC7D,YAAU;AACQ,8BAAE,0BAAM;AAClB,sBAAiB,iBACvB;AAAC;AACe,8BAAiB,gBAAgB,gBAAK,KAAiB;AAC/D;AACc,oCAAM,KAAuB;AAC1C;AACY,mCAAE,+BAAM;AAAK,uBAAI,MAAQ,QAAwB,wBAC7D,OAAE,YAAU,WAA0B;AAC/C;AAV6C;AAW/C,eAAgB,UAAU,UAAK,MAAM,KACvC;AAAC;AAOE;;;;;;AACK,gCAAwB,2BAAhC;AACE,eAAgB,UAAgB,gBACxB,KAAQ,QAAmB,oBAAM,KAAQ,QACnD;AAAC;AAIE;;;AACH,gCAAoB,uBAApB;AACW,kBAAY,YAAK,KAC5B;AAAC;AACH,WAAC;AAAA,EAvkBsC,aAukBtC;AAvkBY,4BAAiB;AAykBmF;AACjH,kBAAiC,kB;;;;;;;;;;;;;ACzlB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,0D;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;AAEH,qCAAoD;AAEpD,sCAAoC;AACpC,mCAA6C;AAoB1C;;;;;;;;AACH,SAAyB;AACvB,QAAW;AACS,4BAAG;AACL,0BAAI;AACH,2BAAG;AACL,yBACf;AAL4B;AAM9B,WACF;AAAC;AARD,oBAQC;AAYE;;;;;;;;;;;AACH,SAA+B,gBACN,eAEX;AACZ,QAA4B,yBAAG,IAAyC;AAEjC;AACvC,SAAK,IAAK,IAAI,GAAG,IAAgB,eAAK,KAAE;AACtC,YAAiB,cAA4B,0BAAG,GAAQ;AACxD,YAAI,CAAY,aAAE;AACP;AACV;AAED,YAAe,YAAc,YAAG,GAAe;AAC/C,YAAI,CAAuB,uBAAI,IAAW,YAAE;AACpB,mCAAI,IAAU,WAAM;AAC3C;AACqB,+BAAI,IAAY,WAAK,KACvC,EAAK,MAAa,YAAc,eAAO,OAAM;AAClD;AAEkB;AACkD;AAC/C,2BAAQ,QAAC,UAAO;AAC9B,eAAK,KAAC,UAA2B,OAA6B;AAClE,mBAAY,MAAM,QAAS,OAC7B;AACF;AAAG;AAEH,WACF;AAAC;AA9BD,0BA8BC;AA6BE;;;;;;;;;;;;;;;;AACH,SAAyB,UACO,MAAuB;AAEnD,wBAAQ;QACR,wBAAgB;QAChB,8BAAsB;QACtB,wBAAgB;QAChB,iBAAS;QACT,6BACO;AAEG,iBAAM,MAAqB;AAElC,UAAmB,gCAAc;AACzB,oBACb;AAAC,KAFoC,EAElC,YAAO,QAAoC;AAEzC,UAAgB,kBAAQ,MAAgB,kBAAY;AAEzD,QAAkB;AAClB,QAAS,MAAgB,gBAAO,WAAM,GAAE;AACjC,gBAAiB,eACI,wBAAkB,kBAAuB,uBAAS;AAC7E,WAAM;AACA,gBAAgB,cAAuB,wBAAuB,uBAAS;AAC7E;AAED,QAAS,UAAK,CAAE,KAAI,CAAU,WAAE;AACd,yBAAQ;AACzB;AACD,WACF;AAAC;AA/BD,oBA+BC;AAME;;;;;AACH,SAAuB,eACuC,wBAClC,kBAAmD,uBACtD;AACvB,QAAe,YAAQ,MAAgB,gBAAI;AAC3C,QAA4B,yBAAyB,uBAAI,IAAY;AACrE,QAAI,CAAuB,wBAAE;AAC3B,eAAO,CAAG;AACX;AAE+C;AACgB;AACnB;AAC7C,QAAa,cAAU,MAAiB,oBACd,uBAAM,MAAmB,mBAAM,UACjC,kBAAE;AACnB,cAAkB,oBACnB,CAAM,MAAkB,oBAAK,KAAyB,uBAAQ;AAElE,YAAc,WAAyB,uBAAM,MAAmB,mBAAO;AACvE,YAAI,CAAsB,sBAAU,WAAE;AACpC,mBAAgB;AACjB;AACF;AAEwD;AACW;AAC1D;AAC8D;AACnE,UAAiB,mBAAa;AAEnC,QAAqB,oBAAG,CAAG;AAC3B,QAAmB;AAC+B;AAClD,SAAmB,iBAAI,GAAgB,iBAAyB,uBAAO,QAClD,kBAAE;AACrB,YAAI,CAAsB,sBAAuB,uBAAgB,gBAAO,QAAE;AACvD,gCAAkB;AAC7B;AACP;AACF;AAEwE;AACF;AAC1D;AACb,WAAqB,iBAAyB,uBAAO,QAAkB,kBAAE;AACvE,YAA0B,uBAAgB,gBAAM,QAAmB,oBAC/D,CAAsB,sBAAuB,uBAAgB,gBAAO,QAAE;AACvD,gCAAkB;AAC7B;AACP;AACF;AAED,QAAqB,sBAAK,CAAE,GAAE;AACvB,cAAkB,oBAAqB;AAC5C,eAA6B,uBAAM,MAAmB,mBAAO;AAC9D;AAED,WAAO,CACT;AAAC;AAKE;;;;AACH,SAAsB,cACwC,wBACT,uBAC5B;AACvB,QAAe,YAAQ,MAAgB,gBAAI;AAC3C,QAA4B,yBAAyB,uBAAI,IAAY;AACrE,QAAI,CAAuB,wBAAE;AAC3B,eAAO,CAAG;AACX;AAEoC;AACrC,QAAkB,eAAyB,uBAAM,MAAoB;AACrE,QAAgB,aAAK,KAAY,YAAM,MAAgB,iBAAI,OAAM,KAC7D,CAAsB,sBAAa,aAAO,QAAE;AAC9C,eAAmB,aAAO;AAC3B;AAEuE;AACzC;AAC/B,QAAkB,iBACd,CAAM,MAAkB,oBAAK,KAAyB,uBAAQ;AAClE,QAAsB,qBAAG,CAAG;AAC5B,WAAqB,mBAAU,MAAkB,mBAAE;AACjD,YAAiB,cAAyB,uBAAiB;AAE3D,YAAa,UACE,YAAK,KAAY,YAAM,MAAgB,iBAAI,OAAO;AACjE,YAAe,YAAG,CAAsB,sBAAY,YAAQ;AAC5D,YAAW,WAAa,WAAE;AACN,iCAAkB;AAC9B;AACP;AAEa,yBAAG,CAAe,iBAAK,KAAyB,uBAAQ;AACvE;AAED,QAAsB,uBAAK,CAAE,GAAE;AACxB,cAAkB,oBAAsB;AAC7C,eAA6B,uBAAM,MAAmB,mBAAO;AAC9D;AAED,WAAO,CACT;AAAC;AAME;;;;;AACH,SAAkC,mBAAsB;AACtD,WAAY,MAAgB,gBAAO,SACrC;AAAC;AAFD,6BAEC;AAmBE;;;;;;AACH,SAA2B,YAAsB;AAC1C,UAAgB,kBACvB;AAAC;AAFD,sBAEC;AAkBE;;;;;;;;;;;;;;;;;AACH,SAA6B,cAAwB,MAAuB;AAExE,qBAAK;QACL,wBAAgB;QAChB,wBAAgB;QAChB,wBAAgB;QAChB,8BAAsB;QACtB,6BACO;AAET,QAAiB,cAAG,WAAY,aAAO,WAAiB;AACxD,QAAe,YAAG,WAAY,aAAO,WAAe;AACpD,QAAkB,eAAG,WAAY,aAAO,WAAkB;AAC1D,QAAiB,cAAG,WAAY,aAAO,WAAiB;AACxD,QAAY,SAAG,WAAY,aAAO,WAAY;AAC9C,QAAW,QAAG,WAAY,aAAO,WAAW;AAC5C,QAAa,UAAG,WAAY,aAAO,WAAa;AAChD,QAAa,UAAG,WAAY,aAAO,WAAgB;AAEnD,QAAe,eAAa,aAAgB,gBAAe,eAAU,UAC5D,SAAW,SAAE;AACpB,eAAO,CAAG;AACX;AAED,QAAoB,iBAAG,CAAQ,WAAS,MAAI,IAAO,WAAO;AAE1D,QAAkB,gBAAE;AAClB,iBAAmB,oBAAQ;AAC3B,YAAmB;AACD;AACA;AACR,sBAAO,MAAI,IAAc;AACX;AACb,uBAAO;AACK,mCACrB;AAP4C;AAQ9C,eAAgB,UAAc,eAAS;AACxC;AAED,QAAI,CAAQ,SAAE;AACZ,eAAO,CAAG;AACX;AAED,QAAoB,kBAAE;AACpB,iBAAmB,oBAAQ;AAC5B;AAED,QAAyB,sBAAmB,oBAAsB,mBAAQ;AAE1E,QAAuB,qBAAE;AACvB,YAAmB;AACD;AACA;AACR,sBAAK;AACS;AACb,uBAAO;AACK,mCACrB;AAP4C;AAQqB;AACnE,eAAgB,UAAc,eAAS;AACxC;AAED,WAAO,CACT;AAAC;AA/DD,wBA+DC,c;;;;;;;;;;;;;AC7WE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAGtD,sCAAwD;AACxD,uCAAsD;AAEtD,4CAA+B;AAM/B;AAAoC,8BAAsC;AAA1E;mEAiLA;AAAC;AAhLQ,mBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAkB,eAC3B;AAAC;AAgBD,6BAAkB,qBAAlB;AAAA,oBA4BC;AA3BC,YAAc,WAAO,KAAK,KAAe;AACrC,aAAc,gBAAW,YAAY,SAAU,UAAS,SAAC,YAAU,WAAU,UAAW,WAAM;AAElG,YAAQ,KAAK,KAAU,UAAS,SAAC,YAAU,WAAO,QAAE;AAC9C,iBAAiB,iBAAO;AAC7B;AAEG,aAAc,gBAAG,UAAM;AACrB,kBAAW,WAAc,cAC/B;AAAE;AACE,aAAgB,kBAAG,UAAM;AACvB,kBAAW,WAAgB,gBACjC;AAAE;AAEmE;AACF;AAC/D,aAA0B,4BAAG;AACvB,qBAAK,KAAiB,iBACnB,SAAM,MAAgB,iBAAE,EAAQ,SAC7C;AAAE;AACE,aAA4B,8BAAG;AACzB,qBAAK,KAAoB,oBAAQ,SAAM,MACjD;AAAE;AAEE,aAAO,OAAU,WAAM,KAAgB;AACvC,aAAO,OAAC,YAAO,QAAa,cAAM,KAA4B;AAC9D,aAAO,OAAC,YAAO,QAAa,cAAM,KACxC;AAAC;AAED,6BAAO,UAAP;AACM,aAAS,SAAU,WAAM,KAAgB;AACzC,aAAS,SAAC,YAAO,QAAa,cAAM,KAA4B;AAChE,aAAS,SAAC,YAAO,QAAa,cAAM,KAA8B;AACtE,yBAAa,aACf;AAAC;AAED,6BAAM,SAAN;AACE,eAAW,KAAW,WACxB;AAAC;AAED,6BAAI,OAAJ;AACM,aAAW,WACjB;AAAC;AAED,6BAAK,QAAL,UAA8B;AAAxB;AAAA,+BAAwB;;AACxB,aAAW,WAAM,MACvB;AAAC;AAED,0BAAI,0BAAS;aAAb,aAAgC;AAC1B,iBAAW,WAAa,aAC9B;AAAC;;sBAAA;;AAEsG;AACvG,6BAAY,eAAZ,UAA+B;AACzB,aAAW,WAAa,aAC9B;AAAC;AAE4D;AAC7D,6BAA2B,8BAA3B,UAA4C;AACtC,aAAc,gBACpB;AAAC;AAE+C;AAChD,6BAAgB,mBAAhB,UAAiC;AAC/B,YAAW,SAAE;AACP,iBAAK,KAAU,UAAI,IAAC,YAAU,WAAQ;AAC3C,eAAM;AACD,iBAAK,KAAU,UAAO,OAAC,YAAU,WAAQ;AAC9C;AAEG,aAAW,WAAiB,iBAClC;AAAC;AAE2F;AAC5F,6BAAmB,sBAAnB,UAA6B,GAAW;AAClC,aAAW,WAAoB,oBAAE,GAAK;AACtC,aAAa,aACnB;AAAC;AAIE;;;AACH,6BAAe,kBAAf,UAA8B;AACxB,aAAW,WAAgB,gBACjC;AAAC;AAED,6BAAe,kBAAf,UAAgD;AAC1C,aAAW,WAAgB,gBACjC;AAAC;AAED,6BAAoB,uBAApB;AAAA,oBAkEC;AAjEuG;AACG;AACD;AACxG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACzD,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AACvD,uBAAE;AAAM,wBAAC,CAAK,MAAc;AAAA;AAC1B,yBAAE;AACT,uBAAI,MAAK,KAAC,aAAwB,yBAAQ,QAAa,cAAK;AAAA;AACtD,wBAAE;AACR,uBAAI,MAAK,KAAC,aAAwB,yBAAQ,QAAa,cAAK;AAAA;AAC5C,kCAAE,8BAAG;AAAK,uBAAI,MAAK,KAAS,SAAI;AAAA;AAC/C,mBAAE;AACH,uBAAgB,iBAAK,MAAM,MAAiB,iBAAa,iBAAU;AAAA;AACrD,gCAAE,4BAAO;AACzB,oBAAkB,eAAU,KAAyB,yBAAQ,UAAU;AAClE,sBAAqB,KAAM,MAAY,YAAa,cAC3D;AAAC;AAEQ,uBAAE;AAAM,uBAAQ,SAAc,kBAAS,MAAK;AAAA;AAC5C,uBAAE;AACL,sBAAc,gBACN,SACd;AAAC;AACW,0BAAE;AACZ,oBAAQ,MAAK,KAAS,SAAS,SAAe,gBAAE;AAC9C,wBAAQ,MAAc,iBAAQ,MAAc,cAAM,OAAE;AAC9C,8BAAc,cAAS;AAC5B;AAEL;AAAC;AAEiB,gCAAE;AAClB;AACO,2BAAO,MAAqB,KAAY;AACvC,4BAAO,MAAqB,KAEtC;AAJS;AAIR;AACkB,iCAAE;AAAM,uBAAI,MAAgB,gBACvC,MAAc,cAA0B,0BACxC;AAAA;AACW,iCAAE;AACnB,uBAAO,EAAM,OAAQ,OAAW,YAAQ,QAAQ,OAClD;AAAC;AACgB,+BAAE;AACjB,uBAAO,EAAM,OAAU,SAAK,KAAY,aAAQ,QAAU,SAAK,KACjE;AAAC;AACc,6BAAE;AACf,uBAAO,EAAE,GAAQ,OAAY,aAAG,GAAQ,OAC1C;AAAC;AACU,yBAAE,qBAAS;AACpB,oBAAc,WAAO,MAAqB;AAClC,yBAAM,MAAK,OAAS,UAAc,WAAY,SAAK,OAAM,OAAI;AAC7D,yBAAM,MAAM,QAAU,WAAc,WAAY,SAAM,QAAM,OAAI;AAChE,yBAAM,MAAI,MAAQ,SAAc,WAAY,SAAI,MAAM,OAAI;AAC1D,yBAAM,MAAO,SACT,YAAc,WAAY,SAAO,SAAM,OACrD;AAAC;AACW,0BAAE,sBAAO;AACd,sBAAqB,KAAM,MAAU,YAC5C;AACA;AA3DqC;AA4DE;AACzC,eAAO,IAAI,aAAwB,yBACrC;AAAC;AACH,WAAC;AAAA,EAjLmC,YAiLnC;AAjLY,yBAAc,e;;;;;;;;;;;;;ACdxB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACR,YAA4B;AAClB,sBAAsC;AACxC,oBAAoC;AAC7C,WAA2B;AACnB,mBAAmC;AAC5C,UAA0B;AAC1B,UACJ;AARiB;AA+DX,qBAAU;AArDwB;AAC1C,IAAa;AACC,kBAAyB;AACzB,kBAAyB;AACnB,wBAAE,CACK,yBAAsC,sCAAwB,wBAC9D,yBAA2B,2BACnD,+DAAK,KACN;AAPc;AAoDI,kBAAO;AA5Cc;AAEzC,IAAa;AAC0C;AAC7B,8BAAK;AAEyB;AAC7B,+BAAI;AAEkG;AACjH,oBAAI;AAE6F;AAC7E,wCAClC;AAZc;AA0Ca,kBAAO;AA1BjC;;;AACH,IAKC;AALD,WAAc;AACZ,yCAAU;AACV,yCAAU;AACV,wCAAS;AACT,2CACF;AAAC,GALa,0BAKb;AAoBqC,oBAAS;AAZ5C;;;;;;;AACH,IASC;AATD,WAAW;AACT,qCAAY;AACZ,sCAA2B;AAC3B,wCAA8B;AAC9B,yCAAiD;AACjD,sCAA8B;AAC9B,qCAA8C;AAC9C,yCAAoD;AACpD,wCACF;AAAC,GATU,oBASV;AAEgD,iBAAM,O;;;;;;;;;;;;;ACjEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAA4E;AAY5E;AAA8C,wCAAoC;AAmFhF,sCAAoD;AAApD,oBACE,wCAAkC,yBAAe,iBAAc,aAChE;AAnCO,cAAa,gBAAS;AACtB,cAAW,cAAS;AACpB,cAAgB,mBAAS;AACzB,cAAe,kBAAS;AAExB,cAAuB,0BAAK;AAC5B,cAAwB,2BAAK;AAC7B,cAAkB,qBAAK;AAEvB,cAAY,eAAW,YAAM,OAAW;AAe7C;;;;;;;;;;;;;;AACK,cAAY,eAAW,YAAM,OAAW;AAC/B,cAAY,eACP,EAAI,KAAG,GAAO,OAAG,GAAQ,QAAG,GAAM,MAAK;AAC5C,cAAQ,WAAiB,EAAE,GAAG,GAAG,GAAK;eAOvD;AAAC;AApFD,0BAAW,0BAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,0BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,0BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,0BAAM;aAAjB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAKD,0BAAW,0BAAc;AADtB;;;aACH;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACpB,0BAAE;AAAM,2BAAK;AAAA;AACZ,2BAAE;AAAM,2BAAK;AAAA;AAEF,sCAAE;AAAM,2BAAK;AAAA;AACxB,2BAAE;AAAM,2BAAK;AAAA;AACjB,uBAAE;AAAM,2BAAK;AAAA;AAEA,oCAAE;AAAM,2BAAC,EAAO,QAAG,GAAO,OAAK;AAAA;AAC9B,qCAAE;AAAM,2BAAI;AAAA;AACZ,qCAAE;AAAM,2BAAC,EAAO,QAAG,GAAO,OAAK;AAAA;AACjC,mCAAE;AAAM,2BAAC,EAAO,QAAG,GAAO,OAAK;AAAA;AACjC,iCAAE;AAAM,2BAAC,EAAE,GAAG,GAAG,GAAK;AAAA;AAC1B,6BAAE;AAAM,2BAAS;AAAA;AAChB,8BAAE;AAAM,2BAAS;AAAA;AACX,oCAAE;AAAM,2BAAS;AAAA;AAE1B,2BAAE;AAAM,2BAAS;AAAA;AACd,8BAAE;AAAM,2BAAS;AAAA;AAElB,6BAAE;AAAM,2BAAS;AAAA;AAClB,4BAAE;AAAM,2BAAS;AAC3B;AAxBK;AA0BT;AAAC;;sBAAA;;AAuCD,uCAAI,OAAJ;AACQ,0CAAkD;YAAjD,UAAI;YAAE,UAA4C;AAEzD,YAAI,CAAK,KAAQ,QAAS,SAAM,OAAE;AAChC,kBAAM,IAAS,MAAQ,OAAoC;AAC5D;AAED,YAAQ,KAAQ,QAAS,SAAM,OAAE;AAC3B,iBAAc,gBAAQ;AAE9B;AAAC;AAED,uCAAO,UAAP;AACc,qBAAK,KAA0B;AAC/B,qBAAK,KAA2B;AACD;AACvB,6BAAK,KAC3B;AAAC;AAIE;;;AACH,uCAAe,kBAAf,UAA8B;AACxB,aAAa,eACnB;AAAC;AAIE;;;AACH,uCAAsB,yBAAtB;AACM,aAAa,eAAO,KAAa,eAAG,YAAS,UACnD;AAAC;AAIE;;;AACH,uCAAe,kBAAf,UAAgD;AAC1C,aAAa,aAAI,MAAS,OAAI,OAAM;AACpC,aAAa,aAAM,QAAS,OAAM,SAAM;AACxC,aAAa,aAAO,SAAS,OAAO,UAAM;AAC1C,aAAa,aAAK,OAAS,OAAK,QACtC;AAAC;AAEkE;AACnE,uCAAY,eAAZ,UAA+B;AACzB,aAAiB,mBACvB;AAAC;AAE+E;AAChF,uCAAgB,mBAAhB,UAAyC;AACnC,aAAgB,kBACtB;AAAC;AAEiD;AAClD,uCAAmB,sBAAnB,UAA6B,GAAW;AAClC,aAAS,SAAE,IAAO,KAAS,SAAK,KAAI,IAAG;AACvC,aAAS,SAAE,IAAO,KAAS,SAAK,KAAI,IAC1C;AAAC;AAED,uCAAY,eAAZ,UAA+B;AACzB,aAAY,cAClB;AAAC;AAED,uCAAM,SAAN;AACE,eAAW,KACb;AAAC;AAIE;;;AACH,uCAAI,OAAJ;AAAA,oBA6BC;AA5BC,YAAQ,KAAc,eAAE;AACf;AACR;AAEG,aAAQ,QAAa;AAEzB,YAAQ,KAAY,aAAE;AAChB,iBAAc,gBAAQ;AACtB,iBAAQ,QAAS,SAAyB,yBAAW,WAAO;AAC5D,iBAAW,aAAO,KAAQ,QAAsB;AAChD,iBAAgB;AAChB,iBAAQ,QAAc;AAC3B,eAAM;AACD,iBAAQ,QAAS,SAAyB,yBAAW,WAAiB;AACtE,iBAAmB,2CAAyB;AAC1C,sBAAQ,QAAS,SAAyB,yBAAW,WAAO;AAC5D,sBAAW,aAAO,MAAQ,QAAsB;AAChD,sBAAgB;AAChB,sBAAwB,qCAAc;AACpC,0BAAwB,0BAAK;AAC7B,0BAAQ,QAAY,YACI,yBAAW,WAAiB;AACpD,0BAAQ,QACd;AAAC,iBALwC,EAKtC,YAAO,QACZ;AAAG,aAV4C;AAY3C,iBAAc,gBAAQ;AAE9B;AAAC;AAIE;;;AACH,uCAAK,QAAL,UAA8B;AAA9B,oBAoCC;AApCK;AAAA,+BAAwB;;AAC5B,YAAI,CAAK,KAAc,eAAE;AAChB;AACR;AAED,YAAQ,KAAY,aAAE;AAChB,iBAAc,gBAAS;AAC3B,gBAAI,CAAiB,kBAAE;AACjB,qBAAqB;AAC1B;AAEG,iBAAQ,QAAY,YAAyB,yBAAW,WAAO;AAC/D,iBAAQ,QAAY,YACI,yBAAW,WAAgB;AACnD,iBAAQ,QAAe;AAE5B,eAAM;AACD,iBAAQ,QAAS,SACO,yBAAW,WAAmB;AACrC,kCAAC;AAChB,sBAAQ,QAAY,YAAyB,yBAAW,WAAO;AAC/D,sBAAQ,QAAY,YACI,yBAAW,WAAgB;AACnD,sBAAyB,sCAAc;AACrC,0BAAyB,2BAAK;AAC9B,0BAAQ,QAAY,YACI,yBAAW,WAAmB;AACtD,0BAAQ,QACd;AAAC,iBALyC,EAKvC,YAAO,QACZ;AAAG;AAEC,iBAAc,gBAAS;AAC3B,gBAAI,CAAiB,kBAAE;AACjB,qBAAqB;AAC1B;AAEL;AAAC;AAEiE;AAClE,uCAAe,kBAAf,UAA+B;AAC7B,YAAQ,KAAM,IAAmB;AACjC,YAAQ,KAAQ,QAAqB,qBAAI,KAAE;AAClC;AACR;AACG,aACN;AAAC;AAEyC;AAC1C,uCAAa,gBAAb,UAAgC;AACvB,0BAAO;YAAE,UAAW;AAE3B,YAAc,WAAM,QAAa,YAAW,YAAQ;AACpD,YAAY,UAAE;AACR,iBAAS;AAEjB;AAAC;AAEO,uCAAY,eAApB;;AACyD;AACnD,aAAa,eAAO,KAA6B;AAErD,YAAY,SAAO,KAAmB;AACtC,YAA0B,uBAAO,KAAwB,wBAAS;AAClE,YAAuB,oBACf,KAAO,OAAO,QAAE,YAAS,UAAU,UAAW,WAAO;AAC7D,YAAuB,sBACf,KAAO,OAAO,QAAE,YAAS,UAAS,SAAU,UAAQ;AAC5D,YAAsB,mBAAO,KAA0B,0BAAS;AAChE,YAAoB,iBAAO,KAAwB,wBAAS;AACtD,sBAA6C;YAA5C,gBAAU;YAAE,iBAAiC;AAEpD,YAAc,qBACZ,GAAoB,uBAAmB,kBACvC,GAAkB,qBAAiB,gBACnC;AAEkG;AACpG,YAAc,WAAM,QAAc,YAAM,QAAG,YAAO,QAAmC,oCAAE;AAClE,kCAAY;AAChC;AAEiG;AAClG,YAAQ,KAAiB,oBAAQ,KAAgB,iBAAE;AAC7C,iBAAgC,gCAAW;AAChD;AAEG,aAAQ,QAAmB,mBACL,4BAAyB;AAC/C,aAAQ,QAAY,YAAW;AAC/B,aAAQ,QAAa,aACC,uBAAqB,uBAAS,OAAK;AAED;AAC5D,YAAI,CAAK,KAAO,OAAO,QAAE,YAAS,UAAQ,SAAE;AACtC,iBAAQ,QAAS,SAAyB,yBAAW,WAAgB;AAE7E;AAAC;AAIE;;;AACK,uCAAyB,4BAAjC;AACE,YAAc,aAAO,KAAQ,QAAuB;AACpD,YAAc,WAAO,KAAQ,QAAqB;AAClD,YAAkB,eAAO,KAAQ,QAAuB;AACxD,YAAkB,eAAO,KAAQ,QAAmB;AAEpD,YAAI,CAAW,YAAE;AACiG;AACtG;AACL,qBAAM,KAAS,SAAE;AACf,uBAAM,KAAS,SAAE;AAChB,wBAAM,KAAS,SAAE;AACnB,sBAAM,KAAS,SAAE;AAChB,uBAAG;AACF,wBACN;AAPW;AAQ4B;AAC1C;AAED;AACY,wBAAY;AACd;AACG,yBAAM,KAAW;AACZ;AACkG;AAC7G,qBAAY,WAAI;AACd,uBAAc,aAAM,QAAa,WAAM;AACtC,wBAAc,aAAO,SAAa,WAAO;AAC3C,sBAAY,WAEjB;AAPiB;AAQN;AACA,0BAEhB;AAfS;AAeR;AAQE;;;;;;;AACK,uCAAe,kBAAvB;AACE,YAAU,SAAO,KAAc;AAEzB,sBAA+D;YAA9D,sBAAgB;YAAE,gBAAU;YAAE,iBAAiC;AAC/D,8DAAmD;AAE1D,YAAwB,qBAAO,KAAO,OAAK,KAAa,cAAE,YAAS,UAAS;AAE5E,YAAiB;AACjB,YAAoB;AACpB,YAAsB,oBAAE;AACV,2BAAmB,iBAAI,MAAiB,iBAAa,WAAO,SAChE,KAAa,aAAQ;AACd,8BACK,iBAAO,SAAiB,iBAAO,KAAa,aAAQ;AACzE,eAAM;AACO,2BACQ,iBAAI,MAAiB,iBAAO,KAAa,aAAK;AACnD,8BAAmB,iBAAO,SAAiB,iBAC5C,WAAO,SAAO,KAAa,aAAK;AAC/C;AAED,YAAuB,oBAAkB,kBAAc,YAAO,SAAK;AACnE,YAAI,CAAkB,qBAAgB,gBAAmB,iBAAE;AACV;AACzC,qBAAO,KAAO,OAAO,QAAE,YAAS,UAAS;AAChD;AAED,YAAW,QAAO,KAAQ,QAAS;AACnC,YAAe,YAAO,KAAO,OAAK,KAAa,cAAE,YAAS,UAAW;AACrE,YAAiB,cAAO,KAAO,OAAK,KAAa,cAAE,YAAS,UAAQ;AAER;AAC5D,YAAqB,oBAAS;AAEV;AACpB,YAAS,SAAa,WAAE;AACL,gCAAG,CAAa;AAClC,eAAM;AACe;AACH,gCAAe;AACjC;AAED,YAAkB;AAClB,YAAmB;AACnB,YAAqB,mBAAE;AACR,4BACO,iBAAK,OAAa,WAAM,QAAO,KAAa,aAAO;AACzD,6BAAmB,iBAAM,QAAO,KAAa,aAAO;AACnE,eAAM;AACQ,4BAAmB,iBAAK,OAAO,KAAa,aAAM;AACjD,6BACM,iBAAM,QAAa,WAAM,QAAO,KAAa,aAAM;AACxE;AAED,YAAqB,kBAAgB,gBAAc,YAAM,QAAK;AAC9D,YAAsB,mBAAiB,iBAAc,YAAM,QAAK;AAChE,YAAgC,6BACxB,KAAO,OAAO,QAAE,YAAS,UAAU,aACnC,KAAO,OAAO,QAAE,YAAS,UAAQ;AAEzC,YAAoB,oBAA8B,8BAAS,SACvD,CAAgB,mBAA8B,4BAAE;AACL;AACvC,qBAAO,KAAS,SAAO,QAAE,YAAS,UAAQ;AACjD,eAAM,IACY,mBAAqB,qBACpC,SAAgB,mBAAI,CAAkB,qBACtC,eAAC,CAAiB,oBAAiB,iBAAmB,gBAAE;AACZ;AACxC,qBAAO,KAAO,OAAO,QAAE,YAAS,UAAQ;AAC/C;AAED,eACF;AAAC;AAKE;;;;AACK,uCAAuB,0BAA/B,UAA8C;AACrC,iDAAsC;AAE7C,YAAa,YAAK;AAClB,YAAqB,kBAAO,KAAO,OAAO,QAAE,YAAS,UAAS;AAC9D,YAAsB,mBAAO,KAAO,OAAK,KAAa,cAAE,YAAS,UAAS;AACnE,8DAAmD;AAEM;AAChE,YAAmB,iBAAE;AACV,wBAAmB,iBAAI,MAAO,KAAa,aAAI,MAAkB;AAC1E,gBAAI,CAAiB,kBAAE;AACZ,6BAAQ,KAAa,aAAW,WAAQ;AAClD;AACF,eAAM;AACI,wBAAmB,iBAAO,SAAO,KAAa,aAAO,SACtD,KAAa,aAAW,WAAO,SAAkB;AACzD,gBAAoB,kBAAE;AACX,6BAAQ,KAAa,aAAW,WAAQ;AAClD;AACF;AAED,eACF;AAAC;AAKE;;;;AACK,uCAAyB,4BAAjC,UAAgD;AACvC,2CAAgC;AAEoC;AAC3E,YAAoB,iBAAO,KAAO,OAAO,QAAE,YAAS,UAAQ;AAC5D,YAA4B,yBACpB,KAAO,OAAK,KAAa,cAAE,YAAS,UAAQ;AAEpD,YAAkB,gBAAE;AAClB,gBAAiB,cAA2B,yBAC9B,WAAM,QAAO,KAAa,aAAO,OACvC,KAAa,aAAO;AAEyC;AACE;AACN;AACtB;AAC3C,gBAAQ,KAAiB,oBAAQ,KAAgB,iBAAE;AACjD,uBACI,eAAK,KAAa,aAAa,aAAM,QAChC,KAAa,aAAS,SAAQ;AACxC;AAED,mBAAmB;AACpB;AAED,eAA+B,yBAAW,WAAM,QAAO,KAAa,aAAQ,QACxC,KAAa,aACnD;AAAC;AAKE;;;;AACK,uCAAuB,0BAA/B,UAA8C;AACrC,2CAAgC;AACvC,YAAqB,kBAAO,KAAO,OAAO,QAAE,YAAS,UAAS;AAC9D,YAA0B,uBAClB,KAAO,OAAK,KAAa,cAAE,YAAS,UAAS;AAErD,YAAK,IAAK;AACV,YAAmB,iBAAE;AAClB,gBAAyB,uBAAW,WAAO,SAAO,KAAa,aAAM,MAC3C,CAAK,KAAa,aAAQ;AACtD,eAAM;AACJ,gBACG,uBAAW,WAAO,SAAO,KAAa,aAAU,SAC5C,KAAa,aAAK;AAC3B;AACD,eACF;AAAC;AAEiH;AAC1G,uCAA+B,kCAAvC,UAA0E;;AAClE,sBAAoD;YAAnD,kBAAY;YAAE,sBAAsC;AAE3D,YAAW,QAAS,OAAK,KAAoD;;AAE7E,iBAAmB,uBAAK,iFAAE;AAArB,oBAAU;AACb,oBAAS,QAAW,SAAM,SAAM;AAEsD;AAC9B;AACnD,yBAAoB,iBAAO;AAE0D;AAChE;AAC1B,oBAAI,CAAK,KAAgB,iBAAE;AACzB,wBAAQ,SAAU,OAAE;AACb,iCAAgB,aAAG;AACzB,+BAAc,SAAa,UAAE;AACvB,iCAAgB,aAAG;AACzB,qBAFM,UAEQ,SAAW,QAAE;AACrB,iCAAgB,aAAG;AACzB,qBAFM,MAEA;AAAqB;AACrB,iCAAgB,aAAG;AACzB;AACF;AAEO,yBAAM,QAAS;AACxB;;;;;;;;;AACH;AAAC;AAKE;;;;AACK,uCAAiB,oBAAzB;AACE,YAAmB,gBAAO,KAAQ,QAAa;AAC/C,YAAmB,gBAAW,SAAc,iBACpC,KAAQ,QAAqB,qBAAS,SAAgB;AAC9D,YAAiB,iBAAiB,eAAE;AAC9B,iBAAQ,QAAgB;AAEhC;AAAC;AAEO,uCAAM,SAAd,UAA6B,QAAgB;AAC3C,eAAc,QAAO,SAAQ,MAC/B;AAAC;AAEO,uCAAM,SAAd,UAA6B,QAAgB;AAC3C,eAAa,SAAO,KACtB;AAAC;AAEO,uCAAQ,WAAhB,UAA+B,QAAgB;AAC7C,eAAa,SACf;AAAC;AAKE;;;;AACK,uCAAQ,WAAhB,UAA4B;AAC1B,eAAO,OAAU,QAAa,YAAY,SAC5C;AAAC;AACH,WAAC;AAAA,EA/iB6C,aA+iB7C;AA/iBY,mCAAwB;AAijB4E;AACjH,kBAAwC,yB;;;;;;;;;;;;;AClkBrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,4CAA+B;AAEvB,eAAI;AAEZ,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,kE;;;;;;;;;;;;;ACR1B;;;;;;;;;;;;;;;;;;;;;;;;AAIH,IAA0E;AAIvE;;;AACH,SAAiC,yBAAkB,WAAsB;AAApB;AAAA,mBAAoB;;AACvE,MAAmC,oCAAc,aAAgB,cAAE;AACjE,QAAQ,KAAY,UAAS,SAAc,cAAQ;AACpB,sCAAc,eAAM,GAAQ,QAAc,cAAmB;AAC7F;AACD,SACF;AAAC;AAEO,mCAAwB,yB;;;;;;;;;;;;;ACjB7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,qCAA+C;AAC/C,sCAAiE;AACjE,uCAA4D;AAE5D,sCAAuF;AAEvF,uCAA2E;AAG3E,sCAAmE;AACnE,uCAA+C;AAK/C;AAA6B,uBAA+B;AAA5D;mEA2QA;AAAC;AA1QQ,YAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAW,QACpB;AAAC;AAYD,sBAAU,aAAV,UAC8E,oBACrB;AADrD;AAAA,6DAA+C;AAAK,2BAAI,YAAc,eAAI;AAAA;;AAC1E;AAAA,+CAAiC;AAAK,2BAAI,YAAO,QAAI;AAAA;;AACnD,aAAoB,sBAAsB;AAC1C,aAAa,eACnB;AAAC;AAED,sBAAkB,qBAAlB;AAAA,oBAoBC;AAnBK,aAAa,eAAO,KAAoB,oBAAK,KAAO;AAExD,YAAU,OAAO,KAAK,KAAc,cAAC,YAAO,QAAgB;AAC5D,YAAQ,MAAE;AACJ,iBAAM,QAAO,KAAa,aAAO;AACjC,iBAAM,MAAU,YAAQ;AAC7B,eAAM;AACD,iBAAM,QAAQ;AACnB;AAEG,aAAe,iBAAG,UAAI;AAAK,mBAAI,MAAW,WAAc,cAAK;AAAC;AAC9D,aAAkB,oBAAG,UAAI;AACzB,mBAAI,MAAW,WAAiB,iBAAK,MAAM,MAAI,IAAO,OAAQ;AAAC;AAC/D,aAAyB,2BAAG;AAC5B,mBAAI,MAAW,WAA0B;AAAC;AAE1C,aAAa,aAAO,OAAC,aAAwB,yBAAQ,QAAa,cAAM,KAA2B;AACnG,aAAO,OAAU,WAAM,KAAiB;AACxC,aAAO,OAAC,aAAiB,kBAAQ,QAAa,cAAM,KAC1D;AAAC;AAED,sBAAO,UAAP;AACE,YAAQ,KAAM,OAAE;AACV,iBAAM,MAAW;AACtB;AAEG,aAAa,aAAW;AACxB,aAAa,aAAS,SAAC,aAAwB,yBAAQ,QAAa,cAAM,KAA2B;AACrG,aAAS,SAAU,WAAM,KAAiB;AAC1C,aAAS,SAAC,aAAiB,kBAAQ,QAAa,cAAM,KAAoB;AAC9E,yBAAa,aACf;AAAC;AAED,0BAAI,mBAAI;aAAR;AACE,mBAAW,KAAa,aAC1B;AAAC;aAED,aAAuB;AACrB,gBAAS,OAAE;AACL,qBAAa,aAAQ;AAC1B,mBAAM;AACD,qBAAa,aAAS;AAE9B;AAAC;;sBARA;;AAUD,0BAAI,mBAAS;aAAb;AACE,mBAAW,KAAQ,QAAK,KAAM,MAAY,YAC5C;AAAC;aAED,aAA4B;AAC1B,gBAAQ,KAAM,OAAE;AACV,qBAAM,MAAU,YAAS;AAEjC;AAAC;;sBANA;;AAYD,0BAAI,mBAAY;AADb;;;;aACH,aAA+B;AAC7B,gBAAQ,KAAM,OAAE;AACV,qBAAM,MAAa,eAAS;AAEpC;AAAC;;sBAAA;;AAKD,0BAAI,mBAAmB;AADpB;;;aACH;AACE,mBAAW,KAAQ,QAAK,KAAM,MAAsB,sBACtD;AAAC;;sBAAA;;AAcE;;;;;;;;;;;;;AACH,sBAAkB,qBAAlB,UAAmC,UAAwB;AACzD,YAAQ,KAAM,OAAE;AACd,mBAAW,KAAM,MAAmB,mBAAS,UAAiB;AAC/D;AACD,eAAO,CACT;AAAC;AAKE;;;;AACH,sBAAM,SAAN;AACE,YAAQ,KAAM,OAAE;AACV,iBAAM,MAAU;AAExB;AAAC;AAOD,0BAAI,mBAAK;AADN;;;;;aACH;AACE,mBAAW,KAAQ,QAAK,KAAM,MAAe,eAC/C;AAAC;;sBAAA;;AAED,0BAAI,mBAAS;aAAb,aAAgC;AAC1B,iBAAa,aAAU,YAC7B;AAAC;;sBAAA;;AAOE;;;;;;AACH,sBAAoB,uBAApB,UAAkD;AAC5C,aAAW,WAAqB,qBACtC;AAAC;AAIE;;;AACH,sBAAe,kBAAf,UAA8B;AACxB,aAAa,aAAgB,gBACnC;AAAC;AAED,sBAAe,kBAAf,UAAgD;AAC1C,aAAa,aAAgB,gBACnC;AAAC;AAKE;;;;AACH,sBAAgB,mBAAhB,UAA8B;AACxB,aAAW,WAAiB,iBAClC;AAAC;AAME;;;;;AACH,sBAAU,aAAV,UAAwB,OAAoB;AACtC,aAAW,WAAW,WAAM,OAClC;AAAC;AAIE;;;AACH,sBAAgB,mBAAhB,UAA8B;AAC5B,YAAW,QAAO,KAAO;AAEzB,YAAS,QAAQ,MAAO,QAAE;AACxB,mBAAW,KAAM,MAAQ;AAC1B,eAAM;AACL,mBAAY;AAEhB;AAAC;AAKE;;;;AACH,sBAAqB,wBAArB,UAAmC;AACjC,YAAU,OAAO,KAAiB,iBAAQ;AAC1C,YAAQ,QAAQ,KAAM,OAAE;AACtB,mBAAW,KAAM,MAAe,eAAM,SAAO;AAC9C;AACD,eACF;AAAC;AAED,sBAAgB,mBAAhB,UAAiC;AAC3B,aAAa,aAAiB,iBACpC;AAAC;AAED,sBAAY,eAAZ,UAA+B;AACzB,aAAa,aAAa,aAChC;AAAC;AAED,sBAAmB,sBAAnB,UAA6B,GAAW;AAClC,aAAa,aAAoB,oBAAE,GACzC;AAAC;AAIE;;;AACH,sBAAgB,mBAAhB,UAAiC;AAC3B,aAAa,aAAc,gBACjC;AAAC;AAED,sBAAoB,uBAApB;AAAA,oBA8CC;AA7CuG;AACG;AACD;AACxG,YAAa;AACa,sCAAE,kCAAM,OAAW;AACzC,oBAAU,OAAO,MAAO;AACpB,qBAAO,OAAU,UAAI,IAC3B;AAAC;AAC4B,2CAAE,uCAAM,OAAW;AAC9C,oBAAU,OAAO,MAAO;AACpB,qBAAO,OAAU,UAAO,OAC9B;AAAC;AAC2B,0CAAE,sCAAM,OAAM,MAAO;AAC/C,oBAAU,OAAO,MAAO;AACpB,qBAAO,OAAa,aAAK,MAC/B;AAAC;AACgC,+CAAE,2CAAM,OAAM;AAC7C,oBAAU,OAAO,MAAO;AACpB,qBAAO,OAAgB,gBAC7B;AAAC;AACmB,kCAAE,8BAAQ,SAAW;AACrC,uBAAO,QAAU,UAAS,SAAW;AAAA;AAC7B,0BAAE,sBAA0B;AACpC,uBAAI,MAAa,aAAM,MAAkB;AAAA;AAC9B,6BAAE,yBAAQ;AAAK,uBAAI,MAAM,MAAQ,QAAS;AAAA;AAC3C,4BAAE,wBAAQ;AACpB,6BAAS,KAAkC,YAAO,QAAe;AAC1D,2BAAS,QAAM;AAChB,0BAAM,MAAM,MAAQ,QACxB;AAHiE,iBAA/D;AAGF;AACU,8BAAE;AAAM,uBAAI,MAAM,MAAO;AAAA;AACzB,8BAAE,0BAAM;AAAK,uBAAK,MAAM,MAAuB,OAAQ;AAAA;AAC1D,2BAAE;AACX,uBAAK,MAAK,KAAc,cAAC,YAAO,QAA+B,eACnD;AAAA;AACO,qCAAE,iCAAM;AAC3B,wBAAC,CAAC,WAAO,QAAK,MAAM,MAAO,QAAE,MAAI,YAAU,WAAwB;AAAA;AACxC,6CAAE,yCAAM;AACrC,oBAAsB,mBAAG,WAAO,QAAK,MAAM,MAAO,QAAE,MAAI,YAAU,WAAwC;AAC1G,oBAAoB,iBAAmB,iBAAc,cAAC,MAAI,YAAU,WAA4B;AAChG,uBAAuB,iBAAK,MAAM,MAAQ,QAAkB,kBAAC,CAC/D;AACA;AAvC8B;AAwCS;AACzC,eAAO,IAAI,aAAiB,kBAC9B;AAAC;AACH,WAAC;AAAA,EA3Q4B,YA2Q5B;AA3QY,kBAAO,Q;;;;;;;;;;;;;ACnBjB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACS,6BAA2B;AAC9B,0BAA6B;AAC7C,UACJ;AAJiB;AAyBX,qBAAU;AAnBlB,IAAa;AACM,uBAAgB;AACf,wBAAiB;AAClB,uBAA0B;AAC9B,mBAAa;AACZ,oBACd;AANc;AAmBI,kBAAO;AAX3B,IAAa;AACK,sBAAE,CAClB;AAFc;AAWa,kBAAO;AAPpC,IAKC;AALD,WAAsB;AACpB,uDAAQ;AACR,4DAAa;AACb,6DAAc;AACd,4DACF;AAAC,GALqB,0CAKrB;AAEqC,4BAAiB,kB;;;;;;;;;;;;;AC3BpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AACxD,sCAAsE;AACtE,uCAA2E;AAE3E,sCAA4E;AAE5E;AAAuC,iCAA6B;AAuClE,+BAA6C;AAA7C,oBACE,wCAA2B,kBAAe,iBAAc,aACzD;AA5BO,cAAyB,4BAAK;AAC9B,cAAkB,qBAAG,YAAiB,kBAAW;eA2BzD;AAAC;AAxCD,0BAAW,mBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,mBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,mBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAQD,0BAAW,mBAAc;AADtB;;;aACH;AAC0G;AACxG;AAC0B,0CAAE;AAAM,2BAAS;AAAA;AACZ,+CAAE;AAAM,2BAAS;AAAA;AAClB,8CAAE;AAAM,2BAAS;AAAA;AACZ,mDAAE;AAAM,2BAAS;AAAA;AAC9B,sCAAE;AAAM,2BAAK;AAAA;AACrB,8BAAE;AAAM,2BAAS;AAAA;AACd,iCAAE;AAAM,4BAAE;AAAA;AACX,gCAAE;AAAM,2BAAS;AAAA;AACf,kCAAE;AAAM,2BAAC;AAAA;AACT,kCAAE;AAAM,2BAAS;AAAA;AACpB,+BAAE;AAAM,2BAAS;AAAA;AACC,iDAAE;AAAM,4BAAE;AAAA;AAClB,yCAAE;AAAM,2BAAK;AACpC;AAdK;AAgBT;AAAC;;sBAAA;;AAMD,gCAAO,UAAP;AACE,YAAQ,KAA0B,2BAAE;AACtB,yBAAK,KAA4B;AAC9C;AAEG,aAAQ,QACd;AAAC;AAED,gCAAa,gBAAb,UAAgC;AACvB,sBAAG;YAAE,cAAe;AAC3B,YAAW,QAAM,QAAU,SAAW,YAAO;AAE7C,YAAS,OAAE;AACL,iBAAQ,QAAa,cAAwB,uBAAO;AAE5D;AAAC;AAED,gCAAgB,mBAAhB,UAAkC;AAAlC,oBAkBC;AAjBC,YAAW,QAAO,KAAQ,QAAgB,gBAAW;AACrD,YAAS,QAAI,GAAE;AACN;AACR;AAEG,aAAQ,QAAe,eAAC,EAAM,OAAG;AACjC,aAAQ,QAAgB;AAEoD;AAC5E,aAA0B,uCAAc;AACoB;AAC9D,gBAAqB,kBAAO,MAAQ,QAAgB,gBAAW;AAC/D,gBAAmB,mBAAK,KAChB,MAAQ,QAAwB,wBAAiB,kBAAE;AACrD,sBAAiB,iBAAkB;AAE3C;AAAC,SAP0C,EAOxC,aAAwB,yBAAQ,QACrC;AAAC;AAED,gCAAuB,0BAAvB;AACE,gBAAY,KAAqB;AAC/B,iBAAK,YAAiB,kBAAW;AAC3B,qBAAQ,QAAiB,iBAAI;AAC3B;AACR,iBAAK,YAAiB,kBAAU;AAC1B,qBAAQ,QAAiB,iBAAK,KAAQ,QAAmB,qBAAM;AAC7D;AACR,iBAAK,YAAiB,kBAAK;AACX;AACR;AACR;AACM,qBAAQ,QAAiB;AAGnC;;AAAC;AAME;;;;;AACH,gCAAoB,uBAApB,UAAkD;AAC5C,aAAmB,qBACzB;AAAC;AAKE;;;;AACH,gCAAgB,mBAAhB,UAA8B;AACxB,aAAgB,gBAAQ;AAE5B,YAAI,CAAK,KAAQ,QAAwB,wBAAO,QAAE;AAChD,kBAAM,IAAS,MAA8D;AAC9E;AAED,YAAuB,oBACf,KAAQ,QAAgC,gCAAQ;AACxD,YAAqB,qBAAK,GAAE;AACtB,iBAAQ,QAAkC,kCACzB,mBAAE,YAAO,QAAoB;AAC9C,iBAAQ,QAA8B,8BACrB,mBAAE,YAAU,WAA0B;AAC5D;AAEG,aAAQ,QAAyB,yBAC5B,OAAE,YAAU,WAA0B;AAC3C,aAAQ,QAA6B,6BAChC,OAAE,YAAO,QAAkB,mBACtC;AAAC;AAME;;;;;AACH,gCAAU,aAAV,UAAwB,OAAoB;AACtC,aAAgB,gBAAQ;AAE5B,YAAa,WAAE;AACT,iBAAQ,QAA8B,8BACjC,OAAE,YAAc,WAA2B;AAChD,iBAAQ,QAA6B,6BAChC,OAAE,YAAO,QAAmB,oBAAW;AACjD,eAAM;AACD,iBAAQ,QAAyB,yBAC5B,OAAE,YAAc,WAA2B;AAChD,iBAAQ,QAA6B,6BAChC,OAAE,YAAO,QAAmB,oBAAU;AAEnD;AAAC;AAEO,gCAAe,kBAAvB,UAAqC;AACnC,YAAc,WAAO,KAAQ,QAAoB;AACjD,YAAoB,iBAAQ,SAAK,KAAS,QAAY;AAEtD,YAAI,CAAe,gBAAE;AACnB,kBAAM,IAAS,MAAwD;AAE3E;AAAC;AACH,WAAC;AAAA,EAjKsC,aAiKtC;AAjKY,4BAAiB;AAmKmF;AACjH,kBAAiC,kB;;;;;;;;;;;;;AC5K9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAwD,qFAA8B;AAA9E,6BAAM;AAEd,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,0D;;;;;;;;;;;;;ACN1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AACtD,uCAA+E;AAE/E,sCAAgD;AAChD,uCAAyD;AAIzD;AAAuC,iCAAyC;AAAhF;mEAsDA;AAAC;AArDQ,sBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAqB,kBAC9B;AAAC;AAID,gCAAkB,qBAAlB;AACM,aAAc,gBACV,KAAK,KAAc,cAAc,YAAO,QAA0B;AAE1E,YAAW,QAAO,KAAK,KAAc,cAC9B,MAAG,aAA0B,2BAAW,WAAO;AACtD,YAAS,OAAE;AACJ,kBAAM,MAAmB,qBAAQ;AAClC,iBAAK,KAAU,UAAI,IAAC,YAAU,WAAmB;AAChC,kCAAC;AACf,sBAAM,MAAmB,qBAChC;AAAG;AACJ,eAAM;AACD,iBAAK,KAAU,UAAI,IAAC,YAAU,WAAW;AAEjD;AAAC;AAKE;;;;AACH,gCAAK,QAAL,UAAwB;AAClB,aAAW,WAAM,MACvB;AAAC;AAIE;;;AACH,gCAAU,aAAV;AACM,aAAW,WACjB;AAAC;AAED,gCAAoB,uBAApB;AAAA,oBAcC;AAbuG;AACG;AACD;AACxG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AAC5C,mCAAE,+BAAM;AACzB,uBAAI,MAAc,cAAM,MAAY,YAAQ,SAAO,QAAQ;AAAA;AACvC,sCAAE;AACtB,uBAAI,MAAc,cAAM,MAAe,eAAS;AACpD;AAPwC;AAQD;AACzC,eAAO,IAAI,aAA2B,4BACxC;AAAC;AACH,WAAC;AAAA,EAtDsC,YAsDtC;AAtDY,4BAAiB,kB;;;;;;;;;;;;;ACV3B;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAa;AACW,4BACtB;AAFc;AAea,kBAAO;AAXpC,IAAa;AACuD;AAC7C,2BACrB;AAHc;AAWI,kBAAO;AAN3B,IAAgB;AACN,cAAiC;AAC1B,qBAAgC;AAC/B,sBAChB;AAJiB;AAMX,qBAAU,W;;;;;;;;;;;;;ACjBf;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAyD;AAEzD;AAAiD,2CAAuC;AA2BtF,yCAAuD;eACrD,wCAAqC,4BAAe,iBAAc,aACpE;AAAC;AA5BD,0BAAW,6BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,6BAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,6BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAKD,0BAAW,6BAAc;AADtB;;;aACH;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACP,uCAAE;AAAM,2BAAS;AAAA;AACd,0CAAE;AAAM,2BAAS;AACzC;AALK;AAOT;AAAC;;sBAAA;;AAQE;;;AACH,0CAAK,QAAL,UAAwB;AACf,qEAA0D;AAEjE,YAAc,aAAI,GAAE;AACR,0BAAI,YAAO,QAAuB,uBAAgC;AAC7E;AAEG,aAAQ,QAAsB,sBAAa;AAC3C,aAAQ,QAAS,SACvB;AAAC;AAIE;;;AACH,0CAAU,aAAV;AACS,qEAA0D;AAC7D,aAAQ,QAAY,YAAkB;AACtC,aAAQ,QACd;AAAC;AACH,WAAC;AAAA,EArDgD,aAqDhD;AArDY,sCAA2B;AAuDyE;AACjH,kBAA2C,4B;;;;;;;;;;;;;AC9DxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,qE;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AACtD,mCAAkD;AAElD,sCAAqD;AACrD,uCAAgE;AAGhE,uCAAgD;AAEhD;AAA8B,wBAAgC;AAA9D;AAAA,wEAgFC;AA/CkB,cAAO,UAAkB,MAAiB;eA+C7D;AAAC;AA/EQ,aAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAY,SACrB;AAAC;AAED,0BAAI,oBAAO;aAAX;AACE,mBAAW,KAAe,eAC5B;AAAC;aAED,aAA4B;AACtB,iBAAe,eAAQ,UAC7B;AAAC;;sBAJA;;AAMD,0BAAI,oBAAQ;aAAZ;AACE,mBAAW,KAAe,eAC5B;AAAC;aAED,aAA8B;AACxB,iBAAW,WAAY,YAC7B;AAAC;;sBAJA;;AAMD,0BAAI,oBAAK;aAAT;AACE,mBAAW,KAAe,eAC5B;AAAC;aAED,aAAuB;AACjB,iBAAe,eAAM,QAC3B;AAAC;;sBAJA;;AAMD,0BAAI,oBAAM;aAAV;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAID,uBAAO,UAAP;AACM,aAAQ,QAAW;AACvB,yBAAa,aACf;AAAC;AAED,uBAAoB,uBAApB;AAAA,oBAUC;AATuG;AACG;AACzG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACzC,sCAAE,kCAAS;AAAK,uBAAI,MAAe,eAAS,WACxD;AACZ;AAL+B;AAMjC,eAAO,IAAI,aAAkB,mBAC/B;AAAC;AAEO,uBAAa,gBAArB;AAAA,oBAiBC;AAhBuG;AACG;AACD;AACxG,YAAa,gCACR,YAAS,UAAc,cAAM,UACN,4BAAE,oCAAQ,SAAS;AAAK,uBAAI,MAAe,eAAiB,iBAC7E,SAAS,SAAE,SAAe;AAAA,eACP,8BAAE,sCAAQ,SAAS;AAAK,uBAAI,MAAe,eAAoB,oBAClF,SAAS,SAAE,SAAe;AAAA;AACmD;AACtD;AACjB,6BAAE;AAAM,uBAAK;AAAA,eACjB,aAAE;AAAM,uBAAI;AACvB;AACuC;AACzC,eAAO,IAAI,YAAS,UAAK,KAAK,MAAE,IAAI,aAAmB,oBACzD;AAAC;AAED,0BAAY,oBAAc;aAA1B;AACS,kFAAsD;AAC7D,gBAAQ,KACA,KAAK,KAAc,cAA4C;AACvE,gBAAI,CAAG,IAAE;AACP,sBAAM,IAAS,MAAC,gCAAqD,0BAAY;AAClF;AACD,mBACF;AAAC;;sBAAA;;AACH,WAAC;AAAA,EAhF6B,YAgF7B;AAhFY,mBAAQ,S;;;;;;;;;;;;;ACXlB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAa;AACY,6BACvB;AAFc;AASR,kBAAO;AALf,IAAgB;AACN,cAAuB;AAC3B,UACJ;AAHiB;AAKF,qBAAU,W;;;;;;;;;;;;;ACXxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAgD;AAEhD;AAAwC,kCAA8B;AAiBpE,gCAA8C;eAC5C,wCAA4B,mBAAe,iBAAc,aAC3D;AAAC;AAlBD,0BAAW,oBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,oBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,oBAAc;aAAzB;AACE;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACJ,0CAAE;AAAM,2BAAS;AAE7C;AALS;AAKR;;sBAAA;;AAMD,iCAAW,cAAX,UAA6B;AACpB,qDAA0C;AAC7C,aAAQ,QAAyB,yBAAW;AAChD,YAAY,UAAE;AACR,iBAAQ,QAAS,SAAW;AACjC,eAAM;AACD,iBAAQ,QAAY,YAAW;AAEvC;AAAC;AACH,WAAC;AAAA,EA9BuC,aA8BvC;AA9BY,6BAAkB;AAgCkF;AACjH,kBAAkC,mB;;;;;;;;;;;;;ACvC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,2D;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AACtD,mCAAkD;AAClD,qCAA+C;AAE/C,uCAAiD;AAEjD,4CAA+B;AAI/B;AAA+B,yBAAiC;AAAhE;AAAA,wEAsFC;AA3CC,cAAQ,WAAS;eA2CnB;AAAC;AArFQ,cAAQ,WAAf,UAA6B,MAAsD;AAApD;AAAA,qBAAwC,aAAY;;AACjF,YAAY,SAAG,IAAa,UAAO;AACkC;AACrE,YAAQ,KAAY,gBAAc,WAAE;AAC5B,mBAAU,YAAO,KAAa;AACrC;AACD,eACF;AAAC;AAEM,cAAa,gBAApB,UAAsD;AACpD;AACU,sBAAE,kBAAU;AAAK,uBAAQ,SAAK,KAAU,UAAI,IAAW;AAAA;AACzC,oCAAE;AAAM,uBAAI,KAAqB,qBAAQ;AAAA;AAC5C,iCAAE;AAAM,uBAAQ,SAAK,KAAwB;AAAA;AAC7C,iCAAE,6BAAO;AAAK,uBAAQ,SAAK,KAAS,SAAgB;AAAA;AACnC,kDAAE,8CAAQ,SAAS;AACnD,uBAAQ,SAAgB,gBAAoB,oBACjC,SAAS,SAAE,SAAe;AAAA;AACb,0CAAE,sCAAQ,SAAS;AAC3C,uBAAS,SAAqB,KACN,oBAAQ,SAAS,SAAE,SAAe;AAAA;AACvC,qCAAE,iCAAQ;AAC7B,uBAAM,OAAoB,oBAAS,UAAU;AAAA;AAC9B,iCAAE;AACjB,uBAAC,EAAE,GAAQ,OAAY,aAAG,GAAQ,OAAc;AAAA;AACrC,6BAAE;AAAM,kCAAO,QAAS,SAAK,MAAY;AAAA;AACvC,+BAAE;AAAM,uBAAO,QAAS,SAAU;AAAA;AACxC,yBAAE;AAAM,uBAAO,QAAS,SAAW;AAAA;AACZ,gDAAE,4CAAQ,SAAS;AACjD,uBAAQ,SAAgB,gBAAiB,iBAC9B,SAAS,SAAE,SAAe;AAAA;AACf,wCAAE,oCAAQ,SAAS;AACzC,uBAAS,SAAqB,KACT,iBAAQ,SAAS,SAAE,SAAe;AAAA;AACtC,mCAAE,+BAAQ;AAC3B,uBAAM,OAAiB,iBAAS,UAAU;AAAA;AACnC,yBAAE,qBAAU;AAAK,uBAAQ,SAAK,KAAU,UAAO,OAAW;AAAA;AACpD,+BAAE,2BAAQ,SAAO;AAC9B,uBAAS,SAAqB,KAAM,MAAY,YAAQ,SAAQ;AAExE;AA9BS;AA8BR;AAMD,0BAAI,qBAAS;aAAb;AACE,mBAAc,QAAK,KACrB;AAAC;aAED,aAAgC;AAC1B,iBAAW,aAAU,QAAY;AACjC,iBACN;AAAC;;sBALA;;AAOD,wBAAQ,WAAR;AACM,aAAW,WACjB;AAAC;AAED,wBAAU,aAAV;AACM,aAAW,WACjB;AAAC;AAED,wBAAM,SAAN;AACM,aAAW,WACjB;AAAC;AAED,wBAAoB,uBAApB;AACE,eAAO,IAAI,aAAmB,oBAAU,UAAc,cACxD;AAAC;AAED,wBAAkB,qBAAlB;AACE,YAAU,OAAO,KAAqB;AAClC,aAAU,YAAyB,0BAAQ,KACjD;AAAC;AAOE;;;;;;AACK,wBAAa,gBAArB;AACM,aAAW,WAAa,aAAQ,QAAK,KAC3C;AAAC;AACH,WAAC;AAAA,EAtF8B,YAsF9B;AAtFY,oBAAS,U;;;;;;;;;;;;;ACZnB;;;;;;;;;;;;;;;;;;;;;;;;AAEU,QAAU;AAC+D;AACI;AACpC;AAC1C,gBAA2C;AACxC,mBAA8C;AAC5C,qBAAgD;AAC3D,UAAuB;AAClB,eACT;AATwB;AAWb,QAAO;AACN,kBAAyB;AAC1B,iBAAwB;AACf,0BAAiC;AAC/B,4BAAmC;AACjD,cAAqB;AACtB,aACP;AAPqB;AASV,QAAO;AACK,6BAAK;AACV,wBAAK;AACH,0BAAK;AAClB,aAAI;AACC,kBACZ;AANqB,E;;;;;;;;;;;;;ACtBpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAyD;AAEzD,iCAAgD;AAwBmC;AACnF,IAA4B,yBAA0B,CACxC,cAAe,eAAa,aACxC;AAE2F;AAC7F,IAAsC,mCAA4B,CACtD,YAAa,aAAW,WAClC;AAEgC;AAClC,IAAoB,mBAAiC;AAErD;AAAyC,mCAA+B;AAsDtE,iCAA+C;AAA/C,oBACE,wCAA6B,oBAAe,iBAAc,aAa3D;AAlCO,cAA4B,+BAAS;AAErC,cAAgB,mBAAK;AACrB,cAA2B,8BAAK;AAChC,cAAQ,WAAO;AACf,cAAM,SAAG,EAAM,OAAG,GAAQ,QAAK;AAC/B,cAAY,eAAK;AACjB,cAAY,eAAK;AACjB,cAAU,aAAK;AACf,cAAgB,mBAAgB,EAAK,MAAG,GAAK,KAAK;AAcpD,cAAiB,mBAAO,MAA2B;AAEnD,cAAyB,2BAAG;AAC1B,kBAA6B,+BAAQ;AACrC,kBACN;AAAE;AACE,cAAiB,mBAAG,UAAE;AAAK,mBAAI,MAAU,UAAG;AAAC;AAC7C,cAAmB,qBAAG;AAAM,mBAAI,MAAc;AAAC;AAC/C,cAAc,gBAAG;AAAM,mBAAI,MAAc;AAAC;AAC1C,cAAa,eAAG;AAAM,mBAAI,MAAa;AAAC;AACxC,cAAe,iBAAG;AAAM,mBAAI,MAAS;AAAC;eAC5C;AAAC;AAnED,0BAAW,qBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAc;aAAzB;AACE;AACU,0BAAE;AAAM,2BAAS;AAAA;AACH,wCAAE;AAAM,2BAAI;AAAA;AACf,qCAAE;AAAM,2BAAC,EAAI,KAAG,GAAO,OAAG,GAAQ,QAAG,GAAM,MAAG,GAAO,OAAG,GAAQ,QAAK;AAAA;AACrE,qCAAE;AAAM,2BAAI;AAAA;AACK,sDAAE;AAAM,2BAAS;AAAA;AACzB,8CAAE;AAAM,2BAAS;AAAA;AACtB,yCAAE;AAAM,2BAAS;AAAA;AACrB,qCAAE;AAAM,2BAAC,EAAE,GAAG,GAAG,GAAK;AAAA;AAC1B,iCAAE;AAAM,2BAAI;AAAA;AACV,mCAAE;AAAM,2BAAI;AAAA;AAClB,6BAAE;AAAM,2BAAI;AAAA;AACW,oDAAE;AAAM,2BAAS;AAAA;AACzB,4CAAE;AAAM,2BAAS;AAAA;AACtB,uCAAE;AAAM,2BAAS;AAAA;AAC3B,6BAAE;AAAM,2BAAS;AAAA;AACX,mCAAE;AAAM,2BAAS;AAEtC;AAlBS;AAkBR;;sBAAA;;AAsCD,kCAAI,OAAJ;AAAA,oBAgBC;AAfC,YAAyB,sBAAO,KAAwB;AAEpD,aAAsB,sBAAsB;AAEhD,YAAuB,qBAAE;AACjB,yCAAkD;gBAAjD,YAAI;gBAAE,iBAA4C;AACpC,kCAAC;AAChB,sBAAQ,QAAS,SAAO;AAC5B,oBAAQ,MAAQ,QAAc,eAAE;AAC1B,0BAAQ,QAAS,SAAY;AACsE;AACnG,0BAAmB;AAE3B;AAAG;AAEP;AAAC;AAED,kCAAO,UAAP;AAAA,oBAyBC;AAxBC,YAAQ,KAAuB,wBAAE;AAC/B,gBAAQ,KAAiB,kBAAE;AACb,6BAAK,KAAmB;AAChC,qBAAiB,mBAAK;AACtB,qBAAQ,QAAY,YAAoB,oBAAW,WAAgB;AACxE;AAED,gBAAQ,KAA4B,6BAAE;AACxB,6BAAK,KAA8B;AAC3C,qBAA4B,8BAAK;AACjC,qBAAQ,QAAY,YACD,oBAAW,WAAkB;AACrD;AAEK,yCAAkD;gBAAjD,YAAI;gBAAE,iBAA4C;AACpC,kCAAC;AAChB,sBAAQ,QAAY,YAAO;AAC3B,sBAAQ,QAAY,YAAY;AAChC,sBACN;AAAG;AACJ;AAEG,aAA2B;AAC3B,aACN;AAAC;AAIE;;;AACH,kCAAQ,WAAR,UAAoB;AACd,aAAU,UAChB;AAAC;AAED,kCAAU,aAAV;AACM,aACN;AAAC;AAED,kCAAM,SAAN;AAAA,oBAQC;AAPC,YAAQ,KAAa,cAAE;AACD,iCAAK,KAAe;AACzC;AACG,aAAa,qCAAyB;AACpC,kBAAmB;AACnB,kBAAa,eACnB;AACF,SAJ2C;AAI1C;AAED,kCAAY,eAAZ,UAA+B;AACtB,uDAA4C;AACnD,YAAa,WAAE;AACT,iBAAQ,QAAS,SAAY;AAClC,eAAM;AACD,iBAAQ,QAAY,YAAY;AAExC;AAAC;AAED,kCAAW,cAAX;AAAA,oBAGC;AAFsB,8BACjB;AAAM,mBAAI,MAAQ,QAAS,SAAoB,oBAAW,WAAY;AAC5E;AAAC;AAED,kCAAU,aAAV;AAAA,oBAIC;AAHsB,8BACjB;AAAM,mBAAI,MAAQ,QAAY,YACP,oBAAW,WAAY;AACpD;AAAC;AAOE;;;;;;AACK,kCAAoB,uBAA5B;AACE,eAAW,KAAQ,QACrB;AAAC;AAEO,kCAAuB,0BAA/B;AACE;AACiB,6BAAW;AACN,kCAAO;AAChB,yBAAO;AACJ,4BAAO;AACA,mCAAO;AACR,kCAExB;AARS;AAQR;AAIE;;;AACK,kCAAqB,wBAA7B,UAA0D;AAA1D,oBAYC;AAXC,YAAuB,qBAAE;AACD,mCAAQ,QAAC,UAAQ;AACjC,sBAAQ,QAA2B,2BAAQ,SAAM,MACvD;AAAG;AACH,gBAAQ,KAAQ,QAAc,eAAE;AAC1B,qBAAQ,QAAsB,sBAAK,KAAiB;AACzD;AACF;AAEG,aAAQ,QAA2B,2BAAQ,SAAM,KAAgB;AACjE,aAAQ,QAA2B,2BAAO,QAAM,KACtD;AAAC;AAEO,kCAA6B,gCAArC,UAAgD;AAAhD,oBASC;AARC,YAAO,IAAK,SAAc,WAAE;AACtB,iBAAQ,QAA2B,2BAAQ,SAAM,KAAqB;AAC3E,eAAM;AAC2B,6CAAQ,QAAC,UAAQ;AAC3C,sBAAQ,QAAmC,mCACpC,SAAM,MACnB;AAAG;AAEP;AAAC;AAEO,kCAAuB,0BAA/B;AAAA,oBAUC;AATuB,+BAAQ,QAAC,UAAQ;AACjC,kBAAQ,QAA6B,6BAAQ,SAAM,MACzD;AAAG;AACC,aAAQ,QAA6B,6BAAQ,SAAM,KAAgB;AACnE,aAAQ,QAA6B,6BAAO,QAAM,KAAe;AAErE,YAAQ,KAAQ,QAAc,eAAE;AAC1B,iBAAQ,QAAwB,wBAAK,KAAiB;AAE9D;AAAC;AAEO,kCAA+B,kCAAvC;AAAA,oBAMC;AALK,aAAQ,QAA6B,6BAAQ,SAAM,KAAqB;AAC5C,yCAAQ,QAAC,UAAQ;AAC3C,kBAAQ,QAAqC,qCACtC,SAAM,MACnB;AACF;AAAC;AAEO,kCAAc,iBAAtB;AAAA,oBAQC;AAPC,YAAmB,gBAAsB,oBAAS;AAClD,YAAU,OAAS,OAAK,KAAqD;AACzE,aAAQ,QAAC,UAAI;AACf,gBAAO,IAAQ,QAAQ,YAAM,GAAE;AACzB,sBAAQ,QAAkB,kBAAc,cAAK,MAAQ;AAE7D;AACF;AAAC;AAEO,kCAAS,YAAjB,UAA6B;AAA7B,oBAoEC;AAnEC,YAAQ,KAAQ,QAAoB,qBAAE;AAC7B;AACR;AAED,YAAqB,kBAAO,KAAkB;AAC9C,YAAmB,gBAAY,aAAE;AACxB;AACR;AAEsG;AACvG,YAA6B,0BAAO,KAA0B;AAC9D,YAAuB,oBAA0B,2BAAO,QAAc,aAA2B,wBAAK,SAAQ,IAAM;AACpH,YAAqB,mBAAE;AACd;AACR;AAEc,wBAAY,cAAQ;AACpB,wBAAe,iBAAM,QAAe;AACpC,wBAAgB,kBAAO;AACvB,wBAAsB,wBAAkB,gBAAiB,iBAAQ,QAAI,QAAkB,cAC/F,IAAK,SAAgB,eAAO,IAAK,SAAiB,gBAAO,IAAK,SACnE;AAEF,YAAuB,oBAAM,QAAc,aACvB,iBAAO,SAAI,sBACN,KACjB,UAAO;AAAK,mBAAI,MAAQ,QAAoB,oBAAQ;AAAE,SAD1C;AAEpB,YAAqB,mBAAE;AAC6E;AAC9F,iBAAyB;AACtB;AACR;AAED,YAAO,QAAc,WAAE;AACL,6BAAK,KAAI,IAAS;AAC9B,iBAA8B,8BAAM;AACzC;AAEc,wBAAqB,uBAAO,KAAwB,wBAAM;AACzE,YAAmB,gBAAqB,sBAAE;AACpC,iBAAsB;AAC3B;AAEoB,8BAAC;AACuF;AAC3F,+BAAM;AAEtB,gBAAI,CAAgB,gBAAqB,wBAC/B,QACH,cAAuB,IAAI,QAAQ,OAA0B,IAAQ,YAAQ,KAAE;AACiB;AACtB;AACd;AACR;AACgD;AACxB;AAClE,gCAAqB,uBAAO,MAAwB,wBAAM;AACzE,oBAAmB,gBAAqB,sBAAE;AACpC,0BAAsB;AAC3B;AACF;AAED,gBAAI,CAAgB,gBAAqB,sBAAE;AAC4B;AACjE,sBAAiB,mBAAO,MAA2B;AAE3D;AACF;AAAC;AAEO,kCAAuB,0BAA/B,UAA2C;AACzC,eAAW,QAAc,aAAO,IAAK,SAAiB,SAA/C,GACC,KAAQ,QAAoB,oBAEtC;AAAC;AAEO,kCAAkB,qBAA1B;AAAA,oBA4BC;AA3BO,qCAA4E;YAA3E,4BAAsB;YAAE,0BAAoD;AAC7E,qCAAiE;YAAhE,qBAAe;YAAE,mBAAgD;AACjE,kEAAuD;AAE1D,aAAmB;AAEvB,YAAkB,iBAAM;AACxB,YAAgB,eAAM;AAEtB,YAAI,CAAK,KAAQ,QAAc,eAAE;AACzB,0BAA4D;gBAA3D,gBAAU;gBAAE,cAAgD;AACrD,6BAAgB,WAAE,aAAiB,WAAE,IAAK;AAC5C,2BAAc,SAAE,aAAe,SAAE,IAAK;AACnD;AAEG,aAAQ,QAAkB,kBAAuB,wBAAkB;AACnE,aAAQ,QAAkB,kBAAqB,sBAAgB;AACX;AAC5C,qBAAK,KAAmB;AACxB,qBAAK,KAA8B;AAC3C,aAA+B;AAC/B,aAAQ,QAAY,YAAkB;AAEW;AACjD,aAAQ,QAAuB;AAC/B,aAAQ,QAAS,SAAgB;AACjC,aAAiB,8BAAc;AAAM,mBAAI,MAA2B;AAAA,SAAtC,EACpC;AAAC;AAEO,kCAA4B,+BAApC;AACQ,sBAAgE;YAA/D,qBAAe;YAAE,2BAA+C;AAEvE,YAAe;AACf,YAAyB,uBAAE;AACf,yBAAG,OAAwB,yBAClB,iBACX,KAAQ,QAAsB,uBAC9B,KAAQ,QACd;AACH,eAAM;AACK;AACP,mBAAM,KAAO,OAAM,QAAI;AACvB,mBAAM,KAAO,OAAO,SACrB;AAHW;AAId;AAC4C;AACnC;AACP,eAAY,WAAK,IAAK,KAAa,eAAK;AACxC,eAAY,WAAK,IAAK,KAAa,eACpC;AAHW;AAKb,YAAc;AACX,eAAO,KAAO,OAAM,QAAQ,CAA1B,GAA+B,KAAa,eAAK;AACnD,eAAO,KAAO,OAAO,SAAQ,CAA3B,GAAgC,KAAa,eAChD;AAHe;AAKjB,eAAO,EAAW,wBAAU,UAC9B;AAAC;AAEO,kCAA8B,iCAAtC;AAAA,oBAcC;AAb0G;AACjC;AACjE,6DAAkD;AACnD,sBAA2D;YAA1D,0BAAoB;YAAE,iBAAqC;AAClE,YAAwB,qBAAuB,wBAAI,CAAa;AAEhE,YAAsB,sBAAQ,KAA6B,8BAAE;AACvD,iBAA+B;AAC/B,iBAAQ,QAAS,SAAkB;AACnC,iBAA4B,yCAAc;AACxC,sBAAQ,QAAY,YAC1B;AAAC,aAF4C,EAE1C,YAAO,QAAqB;AAEnC;AAAC;AAEO,kCAA2B,8BAAnC;AACS,2DAAgD;AACnD,aAAQ,QAAY,YAAgB;AACpC,aAA6B,+BAAS;AACtC,aAAQ,QACd;AAAC;AAEO,kCAAqB,wBAA7B;AAAA,oBAMC;AALK,aAAyB,2BAAO,KAAiB,iBAAiB;AAClE,aAAiB,mBAAO,KAA2B;AACkC;AACa;AAC5F,mBAAC;AAAM,mBAAI,MAAyB,2BAAY;AAAA,WAAqB,oBAAQ,QACzF;AAAC;AAEO,kCAAW,cAAnB;AAAA,oBAoBC;AAnBC,YAAqB,kBAAO,KAAkB;AAC6C;AAC3F,YAAI,CAAgB,gBAAY,aAAE;AACzB;AACR;AAED,YAAW,qBAA6C;AAExD,YAAmB,gBAAe,gBAAE;AACb,kCAAC;AAAM,uBAAI,MAAqB,qBAAO;AAAE;AAC1D,iBAAyB;AAC9B,eAAM;AACD,iBAAmC;AAClB,kCAAC;AAChB,sBAAiB,iBAAqB,uBAAQ;AAC9C,sBAAqB,qBAAQ;AAC7B,sBACN;AAAG;AAEP;AAAC;AAEO,kCAAoB,uBAA5B,UAA+F;YAAjE,2BAAqB;YAAE,0BAAoB;AACvE,YAAyB,yBAAwB,sBAAE;AAC7C,iBAAkC;AAE1C;AAAC;AAEO,kCAAe,kBAAvB;AAAA,oBA4BC;AA3BK,aAAO,SAAO,KAAQ,QAAuB;AACjD,YAAY,SAAO,KAAI,IAAK,KAAO,OAAO,QAAM,KAAO,OAAQ;AAEc;AACsC;AACL;AACI;AACR;AACpF;AACtB,YAAsB,mBAAG;AACvB,gBAAgB,aAAO,KAAK,KAAK,KAAI,IAAK,MAAO,OAAM,OAAI,KAAO,KAAI,IAAK,MAAO,OAAO,QAAM;AAC/F,mBAAiB,aAAsB,oBAAQ,QACjD;AAAE;AAEE,aAAW,aAAO,KAAQ,QAAgB,gBAAS,SAAoB;AAEyC;AACpH,YAAiB,cAAO,KAAM,MAAO,SAAsB,oBAAQ,QAAuB;AACZ;AAC9E,YAAQ,KAAQ,QAAc,iBAAe,cAAI,MAAM,GAAE;AACnD,iBAAa,eAAc,cAAK;AACrC,eAAM;AACD,iBAAa,eAAe;AACjC;AACG,aAAS,WAAG,KAAO,KAAW,aAAO,KAAgB;AAErD,aACN;AAAC;AAEO,kCAAoB,uBAA5B;AACQ,qCAEyB;YAD7B,iBAAW;YAAE,cAAQ;YAAE,aAAO;YAAE,kBACF;AAE5B,aAAQ,QAAkB,kBAAY,aAAS,KAAa,eAAM;AAClE,aAAQ,QAAkB,kBAAa,cAAM,KAAW;AAE5D,YAAQ,KAAQ,QAAc,eAAE;AAC1B,iBAAiB;AACf,sBAAM,KAAM,MAAM,KAAO,OAAM,QAAQ,CAA1B,GAA+B,KAAa,eAAM;AAChE,qBAAM,KAAM,MAAM,KAAO,OAAO,SAAQ,CAA3B,GAAgC,KAAa,eAC7D;AAHsB;AAKpB,iBAAQ,QAAkB,kBAClB,UAAS,KAAiB,iBAAK,OAAM;AAC7C,iBAAQ,QAAkB,kBAAQ,SAAS,KAAiB,iBAAI,MAAM;AAE9E;AAAC;AACH,WAAC;AAAA,EA/dwC,aA+dxC;AA/dY,8BAAmB;AAieiF;AACjH,kBAAmC,oB;;;;;;;;;;;;;AC7gBhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,4CAA+B;AAEvB,eAAI;AAEZ,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,4D;;;;;;;;;;;;;;;ACF1B;;;;AACH,IAA+C;AAE/C,SAAoC,qBAAkB,WAAsB;AAApB;AAAA,uBAAoB;;AACnE,wBAAiB;AACxB,QAAmB,kBAAyB;AAC5C,QAAI,OAA4B,0BAAc,aAAI,CAAa,cAAE;AAC/D,eAA6B;AAC9B;AAED,QAA6B,0BAAM,OAAI,OAAU,IAAS,aAAgB;AAC1E,QAAI,CAAwB,yBAAE;AAC5B,eAAa;AACd;AAED,QAA+B,4BAAM,IAAS,SAAa,cAAS;AACd;AACtB;AAChC,QAA0C,oCACnC,IAAS,SAAqB,wBAC9B,IAAS,SAAQ,SACtB;AAEa,sBACc,6BAAsC;AAEnE,QAAI,CAAa,cAAE;AACI,gCAAmB;AACzC;AACD,WACF;AAAC;AA3BD,+BA2BC;AAED,SAAwC,yBAAuB,KAA4B,YAAwB;AAEjH,QAAI,CAAI,KAAE;AACR,eAAO,EAAE,GAAG,GAAG,GAAK;AACrB;AACM,uBAAC;QAAE,eAAgB;AAC1B,QAAe,YAAI,IAAa,WAAM;AACtC,QAAe,YAAI,IAAa,WAAK;AAErC,QAAgB;AAChB,QAAgB;AAC0C;AAC1D,QAAO,IAAK,SAAiB,cAAE;AAC7B,YAAgB,aAAqB;AAC1B,sBAAa,WAAe,eAAG,GAAM,QAAa;AAClD,sBAAa,WAAe,eAAG,GAAM,QAAa;AAC9D,WAAM;AACL,YAAgB,aAAqB;AAC1B,sBAAa,WAAM,QAAa;AAChC,sBAAa,WAAM,QAAa;AAC5C;AAED,WAAO,EAAE,GAAa,aAAG,GAC3B;AAAC;AAvBD,mCAuBC,yB;;;;;;;;;;;;;AC7DE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,sCAA6F;AAC7F,sCAAoF;AACpF,4DAAyE;AACzE,sCAAiE;AACjE,qDAA0D;AAE1D,sCAAgG;AAEhG,sCAAqD;AACrD,uCAAgE;AAEhE,sCAAgD;AAChD,uCAAiD;AACjD,sCAAwF;AACxF,sCAAqE;AAGrE;AAA+B,yBAAiC;AAAhE;mEAgcA;AAAC;AA/bQ,cAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAa,UACtB;AAAC;AA8BD,wBAAU,aAAV,UAC4E,cACD,mBACK,gBACvB,aACY,aACkB;AALnF;AAAA,iDAA2C;AAAK,2BAAI,YAAgB,iBAAI;AAAA;;AACxE;AAAA,2DAA6C;AAAK,2BAAI,YAAa,cAAI;AAAA;;AACvE;AAAA,qDAA8C;AAAK,2BAAI,YAAiB,kBAAI;AAAA;;AAC5E;AAAA,+CAAiC;AAAK,2BAAI,YAAO,QAAI;AAAA;;AACrD;AAAA,+CAAuC;AAAK,2BAAI,YAAa,cAAI;AAAA;;AACjE;AAAA,2DAAmD;AAAK,2BAAI,YAAmB,oBAAI;AAAA;;AAEjF,aAAa,eACT,KAAK,KAAc,cAAC,YAAO,QAAwC;AACvE,aAAa,eACT,KAAK,KAAc,cAAC,YAAO,QAAwC;AAE3E,YAAI,CAAK,KAAa,cAAE;AACtB,kBAAM,IAAS,MACoE,mFAC/E,MAAI,YAAO,QAAuB,yBACpC;AACH;AAED,YAAQ,KAAa,aAAa,aAAC,YAAO,QAAe,gBAAE;AACzD,gBAAuB,oBAAW,SAAe,eACzC,KAAa,aAAa,aAAC,YAAO,QAAkB;AAC5D,gBAAqB,mBAAE;AACjB,qBAAW,aAAoB,kBAAoB;AACxD;AACF;AAEG,aAAU,UAAc;AAE5B,YAAkB,eAAO,KAAK,KAAc,cAAC,YAAO,QAAiB;AACjE,aAAM,QAAiB,eAAa,aAAgB,gBAAM;AAE9D,YAAuB,oBACf,KAAK,KAAc,cAAC,YAAO,QAAuB;AACtD,aAAW,aACQ,oBAAkB,kBAAqB,qBAAM;AAEpE,YAAoB,iBAAO,KAAK,KAAc,cAAC,YAAO,QAAmB;AACrE,aAAQ,UAAmB,iBAAe,eAAkB,kBAAM;AAEtE,YAAiB,cAAO,KAAK,KAAc,cAAC,YAAO,QAAwB;AAC3E,YAAe,aAAE;AACX,iBAAY,cAAc,YAAc;AAC7C;AAED,YAAI,CAAK,KAAK,KAAU,UAAS,SAAC,YAAU,WAAU,WAAE;AAClD,iBAAO,SAAO,KAAgB;AAEtC;AAAC;AAKE;;;;AACH,wBAAkB,qBAAlB;AAAA,oBAwCC;AAvCK,aAAa,eAAG;AACd,kBAAW,WACjB;AAAE;AACE,aAAY,cAAG;AACb,kBAAW,WACjB;AAAE;AACE,aAAW,aAAG;AACZ,kBAAW,WACjB;AAAE;AACE,aAAY,cAAG,UAAI;AACjB,kBAAa,aAAS;AACtB,kBAAW,WAAY,YAAK,MAAyB,yBAC3D;AAAE;AACE,aAAc,gBAAG,UAAI;AACnB,kBAAW,WAAc,cAC/B;AAAE;AACE,aAAqB,uBAAG,UAAI;AAC1B,kBAAW,WAAqB,qBAAI,IAAO,OACjD;AAAE;AACE,aAAiB,mBAAG;AAClB,kBAAW,WACjB;AAAE;AACE,aAAiB,mBAAG;AAClB,kBAAW,WACjB;AAAE;AAEE,aAAa,aAAiB,iBAAQ,SAAM,KAAc;AAC1D,aAAa,aAAiB,iBAAO,QAAM,KAAa;AAExD,aAAa,aAAiB,iBACvB,SAAM,KAA+B;AAE5C,aAAa,aAAiB,iBAAU,WAAM,KAAgB;AAC9D,aAAK,KAAO,OACQ,qBAAQ,QAAa,cAAM,KAAmB;AAClE,aAAK,KAAO,OACQ,qBAAQ,QAAa,cAAM,KAAmB;AAClE,aAAK,KAAO,OACC,cAAQ,QAAe,gBAAM,KAChD;AAAC;AAED,wBAAO,UAAP;AACM,aAAa,aAAoB,oBAAS,UAAM,KAAe;AAC/D,aAAa,aAAoB,oBAAQ,SAAM,KAAc;AAC7D,aAAa,aAAoB,oBAAO,QAAM,KAAa;AAC3D,aAAa,aAAoB,oBAAU,WAAM,KAAgB;AACjE,aAAa,aAAoB,oBAC1B,SAAM,KAA+B;AAE5C,aAAK,KAAS,SACM,qBAAQ,QAAa,cAAM,KAAmB;AAClE,aAAK,KAAS,SACM,qBAAQ,QAAa,cAAM,KAAmB;AAClE,aAAK,KAAS,SACD,cAAQ,QAAe,gBAAM,KAAuB;AACjE,aAAK,KAAW;AAEpB,YAAQ,KAAO,QAAE;AACX,iBAAO,OAAW;AACvB;AACD,YAAQ,KAAQ,SAAE;AACZ,iBAAQ,QAAW;AACxB;AACD,YAAQ,KAAY,aAAE;AAChB,iBAAY,YAAW;AAC5B;AACD,YAAQ,KAAW,YAAE;AACf,iBAAW,WAAW;AAC3B;AAED,yBAAa,aACf;AAAC;AAED,0BAAI,qBAAK;aAAT;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAAuB;AACjB,iBAAW,WAAS,SAC1B;AAAC;;sBAJA;;AAMD,0BAAI,qBAAa;aAAjB;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAAuC;AACjC,iBAAW,WAAiB,iBAAc,eAAkB,gBAClE;AAAC;;sBAJA;;AAMD,0BAAI,qBAAQ;aAAZ;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAA8B;AACxB,iBAAW,WAAY,YAC7B;AAAC;;sBAJA;;AAMD,0BAAI,qBAAoB;aAAxB,aAAsC;AAChC,iBAAW,WAAwB,wBACzC;AAAC;;sBAAA;;AAKD,0BAAI,qBAAkB;AADnB;;;aACH,aAAsC;AAChC,iBAAW,WAAsB,sBACvC;AAAC;;sBAAA;;AAKD,0BAAI,qBAAiB;AADlB;;;aACH,aAAqC;AAC/B,iBAAW,WAAqB,qBACtC;AAAC;;sBAAA;;AAQD,0BAAI,qBAAoB;AADrB;;;;;;aACH,aAAsD;AAChD,iBAAW,WAAwB,wBACzC;AAAC;;sBAAA;;AAKD,0BAAI,qBAAK;AAMN;;;aACH;AACE,mBAAW,KAAW,WACxB;AAAC;AAVE;;;aACH,aAA0B;AACpB,iBAAW,WAAS,SAC1B;AAAC;;sBAAA;;AAYD,0BAAI,qBAAQ;AAMT;;;aACH;AACE,mBAAW,KAAW,WACxB;AAAC;AAVE;;;aACH,aAAgC;AAC1B,iBAAW,WAAY,YAC7B;AAAC;;sBAAA;;AAYE;;;;AACH,wBAAM,SAAN;AACM,aAAW,WACjB;AAAC;AAKE;;;;AACH,wBAAa,gBAAb;AACM,aAAW,WAAiB;AAC5B,aAAK,KACX;AAAC;AAED,wBAAoB,uBAApB;AACwG;AACG;AACzG,YAAa,kDACJ,KAA0B,4BAC1B,KAA0B,4BAC1B,KAA2B,6BAC3B,KACP;AACF,eAAO,IAAI,aAAmB,oBAAQ,SAAM,KAC9C;AAAC;AAIE;;;AACK,wBAAS,YAAjB,UAA6C;AACvC,aAAY,cAAO,KAAK,KAAc,cAAC,YAAO,QAAiB;AAC/D,aAAK,OAAc,YAAK,KAAc;AACtC,aAAK,KAAa,eACxB;AAAC;AAEO,wBAAY,eAApB;AAAA,oBAeC;AAduG;AACG;AACD;AACxG,YAAa,gCACR,YAAS,UAAc,cAAC,EAAK,MAAM,KAAe,oBAC3B,4BAAE,oCAAQ,SAAS;AACvC,sBAAa,aAAiB,iBAAQ,SAC5C;AAAC,eAC2B,8BAAE,sCAAQ,SAAS;AACzC,sBAAa,aAAoB,oBAAQ,SAC/C;AACA;AACuC;AACzC,eAAO,IAAI,YAAS,UAAK,KAAa,cAAE,IAAI,aAAmB,oBACjE;AAAC;AAEO,wBAAuB,0BAA/B;AAAA,oBAoEC;AAnEyG;AACxG;AACqB,iCAAE;AACjB,uBAAI,MAAY,YAAc,cAAC,YAAO,QAAwB;AAAA;AACnD,6BAAE,yBAAkB,UAAc;AAC7C,uBAAQ,SAAa,aAAM;AAAA;AAChB,6BAAE,yBAAa;AACxB,sBAAa,aAAY,cAC/B;AAAC;AACoB,mCAAE;AAAM,uBAAQ,SAAc,kBAAS,MAAa;AAAA;AACtD,iCAAE,6BAAa;AAC9B,uBAAI,MAAa,aAAa,aAAM;AAAA;AACrB,iCAAE,6BAAa,MAAe;AAC3C,sBAAa,aAAa,aAAK,MACrC;AAAC;AACqB,oCAAE,gCAAa;AAC/B,sBAAa,aAAgB,gBACnC;AAAC;AACW,0BAAE,sBAAkB;AAC1B,sBAAY,YAAU,UAAI,IAChC;AAAC;AACc,6BAAE,yBAAkB;AAC7B,sBAAY,YAAU,UAAO,OACnC;AAAC;AACO,sBAAE;AACJ,sBAAK,KAAK,OAChB;AAAC;AACQ,uBAAE;AACL,sBAAK,KAAK,OAChB;AAAC;AACe,8BAAE;AACd,uBAAI,MAAK,KAAc,cAAC,YAAO,QAAyB;AAAA;AACxC,kCAAE,8BAAsB;AACtC,sBAAK,KAAiB,iBAC5B;AAAC;AACkB,iCAAE,6BAA0C;AACzD,sBAAK,KAAgB,gBAC3B;AAAC;AACe,8BAAE,0BAAmB;AAC/B,sBAAK,KAAU,YACrB;AAAC;AACkB,iCACf,6BAAc,OAAuB,eAAwB;AACvD,sBAAK,KAAM,MAAO,OAAa,aAAc,eACnD;AAAC;AACiB,oCAAE,gCAAc,OAAuB;AACvD,sBAAK,KAAM,MAAO,OAAgB,gBACxC;AAAC;AACmB,kCAAE,8BAAc;AAC7B,sBAAK,KAAM,MAAuB,OACzC;AAAC;AACe,8BAAE;AAAM,uBAAI,MAAK,KAAM,MAAO;AAAA;AAC7B,+BAAE;AAAM,6BAAS,KAAM,MAAI,IACxC,UAAG;AAAK,2BAAE,GAAa,aAAC,YAAO,QAAY,eAAM;AAAC,iBADzB;AACyB;AAChC,oCAAE,gCAAc;AAClC,uBAAI,MAAK,KAAsB,sBAAO;AAAA;AAC3B,6BAAE,yBAAc,OAAmB;AAC5C,sBAAK,KAAM,MAAO,OAAU,UAAI,IACtC;AAAC;AACiB,gCAAE,4BAAc,OAAmB;AAC/C,sBAAK,KAAM,MAAO,OAAU,UAAO,OACzC;AAAC;AACoB,mCAAE;AAAM,uBAAI,MAAK,KAAoB;AAAA;AACxC,gCAAE,4BAAiB,UAAuB;AACxD,uBAAI,MAAK,KAAmB,mBAAS,UAAgB;AACzD;AAhEK;AAkET;AAAC;AAEO,wBAAuB,0BAA/B;AAAA,oBAyBC;AAxByG;AACxG;AACU,sBAAE,kBAAkB;AACtB,sBAAK,KAAU,UAAI,IACzB;AAAC;AACU,yBAAE,qBAAkB;AACzB,sBAAK,KAAU,UAAO,OAC5B;AAAC;AACO,sBAAE,kBAAkB;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AACzD,6BAAE,yBAAoB;AAC/B,sBAAW,cAAQ,MAAW,WAAgB,gBACpD;AAAC;AACiB,gCAAE;AACd,sBAAW,cAAQ,MAAW,WACpC;AAAC;AACmB,kCAAE;AAChB,sBAAW,cAAQ,MAAW,WACpC;AAAC;AACW,0BAAE,sBAAc;AAC1B,oBAAW,QAAO,MAAe;AAC7B,sBAAK,KAAuB,YAAO,QAAa,cAAE,EAAM,cAAO,OAAC,SAAM,KAC5E;AACA;AArBK;AAuBT;AAAC;AAEO,wBAAwB,2BAAhC;AAAA,oBAYC;AAXyG;AACxG;AACY,wBAAE;AAAM,uBAAO,QAAK,MAAS;AAAA;AAC3B,0BAAE,sBAAmB;AAC3B,sBAAQ,WAAQ,MAAQ,QAAM,MACpC;AAAC;AACW,0BAAE;AACR,sBAAQ,WAAQ,MAAQ,QAC9B;AACA;AARK;AAUT;AAAC;AAEO,wBAAsB,yBAA9B;AAAA,oBAaC;AAZyG;AACxG;AACU,sBAAE;AAAM,wBAAC,CAAK,MAAM;AAAA;AAClB,wBAAE,oBAAqB;AAC3B,sBAAM,SAAQ,MAAM,MAAM,MAChC;AAAC;AACY,2BAAE;AAAM,uBAAI,MAAQ,QAAK,MAAM,MAAa,aAAE;AAAA;AAC3C,8BAAE,0BAAoB;AAChC,sBAAM,SAAQ,MAAM,MAAY,YACtC;AACA;AATK;AAWT;AAAC;AAIE;;;AACK,wBAAwB,2BAAhC,UAA2D;AACzD,YAAsB,mBAAO,IAAmB,OAAyB;AACzE,YAAiB,cACT,KAAa,aAAO,OAAI,IAAQ,QAAG,GAAU,UAAI,IAAS;AAClE,eAAkB,cAAmB,iBACvC;AAAC;AAEO,wBAAY,eAApB,UAA+C;AAC7C,eAAc,QAAoB,IACpC;AAAC;AAIE;;;AACK,wBAAgB,mBAAxB;AACE;AACY,wBAAM,KAAa,aAAK,KAAW,WAAsB,sBAC5B;AAC5B,yBAAM,KAAc,cAAK,KAAY,YAAsB,sBAG1E;AANS;AAMR;AACH,WAAC;AAAA,EAhc8B,YAgc9B;AAhcY,oBAAS,U;;;;;;;;;;;;;ACrBnB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACL,eAAyB;AAC1B,cAAwB;AACzB,aAAuB;AACvB,aAAuB;AAClB,kBAA6B;AACjC,cAAwB;AACxB,cAAwB;AAC5B,UAAc;AACC,yBAA2B;AAC7B,uBACjB;AAXiB;AAiCX,qBAAU;AApBlB,IAAa;AACE,mBAAiB;AACZ,wBAAiB;AACvB,kBAAoB;AAClB,oBAAuB;AAChB,2BAAqB;AACtB,0BAAoB;AAC3B,mBAAqB;AAClB,sBAAwB;AAClB,4BAAE,MAAc,WAAsB;AACtC,4BAA8B;AAC9B,4BAAuB;AACnC,gBACV;AAbc;AAoBI,kBAAO;AAL3B,IAAa;AACA,iBAAM;AACN,iBAAE,CACb;AAHc;AAKa,kBAAO,Q;;;;;;;;;;;;;ACnCjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AACxD,qCAAyD;AACzD,sCAAwD;AAGxD,sCAAyD;AAKzD;AAAyC,mCAA+B;AA+EC;AAIpE;;;;AACH,iCAA+C,SAAqD;AAAnD;AAAA,4BAAmD;;AAApG,oBACE,wCAA6B,oBAAe,iBAAc,aAI3D;AAzB4C;AACrC,cAAa,gBAAW,YAAO,QAAa;AACb;AAC/B,cAAc,iBAAgB;AACrB;AACT,cAAQ,WAAS;AAC+C;AACI;AACE;AACjE;AACL,cAAU,aAAS;AACiD;AACpE,cAAoB,uBAAQ;AAC5B,cAAc,iBAAQ;AAUxB,cAAY,cAAgB,cAAa;AACzC,cAAW,aAAgB,cAAY;eAC7C;AAAC;AAxFD,0BAAW,qBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAKD,0BAAW,qBAAc;AADtB;;;aACH;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACpB,0BAAE;AAAM,2BAAK;AAAA;AACH,oCAAE;AAAM,2BAAS;AAAA;AACf,sCAAE;AAAM,2BAAS;AAAA;AAClB,qCAAE;AAAM,2BAAI;AAAA;AACvB,0BAAE;AAAM,2BAAK;AAAA;AACX,4BAAE;AAAM,2BAAS;AAAA;AACd,+BAAE;AAAM,2BAAC;AAAA;AACN,kCAAE;AAAM,2BAAS;AAAA;AACvB,4BAAE;AAAM,2BAAK;AAAA;AACX,8BAAE;AAAM,2BAAS;AAAA;AACjB,8BAAE;AAAM,2BAAS;AAAA;AACd,iCAAE;AAAM,2BAAS;AAAA;AACpB,8BAAE;AAAM,2BAAS;AAAA;AACd,iCAAE;AAAM,2BAAS;AAAA;AACX,uCAAE;AAAM,2BAAK;AAAA;AACf,qCAAE;AAAM,2BAAE;AAAA;AACV,qCAAE;AAAM,2BAAS;AAAA;AACd,wCAAE;AAAM,2BAAS;AAAA;AAC3B,8BAAE;AAAM,2BAAS;AAAA;AACd,iCAAE;AAAM,2BAAS;AAAA;AACxB,0BAAE;AAAM,2BAAS;AAAA;AAChB,2BAAE;AAAM,2BAAS;AAAA;AACV,kCAAE;AAAM,2BAAI;AAAA;AACR,sCAAE;AAAM,2BAAS;AAAA;AAClB,qCAAE;AAAM,2BAAS;AAAA;AACpB,kCAAE;AAAM,2BAAS;AAAA;AACd,qCAAE;AAAM,2BAAS;AAAA;AAChB,sCAAE;AAAM,2BAAS;AAAA;AACrB,kCAAE;AAAM,2BAAC;AAAA;AACR,mCAAE;AAAM,2BAAE;AAAA;AACL,wCAAE;AAAM,2BAAE;AAAA;AACjB,iCAAE;AAAM,2BAAE;AAAA;AACV,iCAAE;AAAM,2BAAS;AAAA;AACd,oCAAE;AAAM,2BAAS;AAAA;AACd,uCAAE;AAAM,2BAAK;AAAA;AAChB,oCAAE;AAAM,4BAAE;AAC5B;AAvCK;AAyCT;AAAC;;sBAAA;;AAgC2E;AAC5E,kCAAgB,mBAAhB;AACE,eAAW,KACb;AAAC;AAED,kCAAgB,mBAAhB,UAA8B,OAAmB;AAAjB;AAAA,wBAAiB;;AAC/C,YAAS,SAAQ,KAAQ,QAAmB,oBAAE;AACrC;AACR;AAEG,aAAuB,uBAAK,KAAgB;AAC5C,aAAoB,oBAAQ;AAEhC,YAAa,WAAE;AACT,iBAAQ,QAAa;AAC1B;AAEG,aACN;AAAC;AAED,kCAAQ,WAAR,UAAsB;AACpB,YAAW,QAAO,KAAe,eAAQ,QAAQ;AAC7C,aAAiB,iBACvB;AAAC;AAED,kCAAQ,WAAR;AACE,YAAc,WAAO,KAAQ,QAAuB;AACpD,YAAY,UAAE;AACZ,mBAAW,KAAQ,QAAgB,gBAAS,UAAE,YAAO,QAAY,eAAO;AACzE;AACD,eACF;AAAC;AAED,kCAAW,cAAX;AACE,eAAW,KACb;AAAC;AAED,kCAAW,cAAX,UAA+B;AACzB,aAAS,WAAc;AAC3B,YAAQ,KAAS,UAAE;AACb,iBAAQ,QAAS,SAAC,YAAU,WAAW;AACvC,iBAAQ,QAAa;AAC1B,eAAM;AACD,iBAAQ,QAAY,YAAC,YAAU,WAAW;AAC/C;AAED,YAAQ,KAAY,aAAE;AAChB,iBAAY,YAAY,YAAK,KAAW;AAC7C;AAED,YAAQ,KAAS,UAAE;AACwD;AACd;AACvD,iBAAQ,QAAuB,uBAAa;AACjD,eAAM;AACD,iBAAQ,QAAoB,oBAAW,YAAO;AACnD;AAEG,aAAQ,QAAoB,oBAAgB,iBAAM,KAAS,SACjE;AAAC;AAEqB;AACtB,kCAAQ,WAAR;AACM,aAAQ,QAAS,SAAC,YAAU,WAAY;AACxC,aAAQ,QAAY;AACpB,aAAW,aAAQ;AACnB,aAAQ,QAAoB,oBAAgB,iBAClD;AAAC;AAIE;;;AACH,kCAAoB,uBAApB,UAAoC;AAClC,YAAQ,KAAW,YAAE;AACf,iBAAW,WAAW,WAAU;AAExC;AAAC;AAKE;;;;AACH,kCAAM,SAAN;AACE,YAAQ,KAAQ,QAAW,YAAE;AAC3B,gBAAoB,iBAAO,KAAW,WAAO,SAAK;AAClD,gBAAe,YAAO,KAAQ,QAAS,SAAC,YAAU,WAAU;AAC5D,gBAAyB,sBAAiB,kBAAc;AACxD,gBAAgB,aAAO,KAAQ,QAAS,SAAC,YAAU,WAAW;AAE1D,iBAAa,aAAsB;AACnC,iBAAQ,QAAW,WAAsB;AACzC,iBAAQ,QAAiB,iBAAa;AAE9C;AAAC;AAKE;;;;AACH,kCAAa,gBAAb;AACM,aAAe,iBAAO,KAAQ,QAAqB;AACvD,YAAmB,gBAAO,KAAe,eAAQ,QAAK,KAAa;AAC/D,aAAoB,oBAC1B;AAAC;AAED,kCAAgB,mBAAhB;AACE,YAAQ,KAAe,eAAO,WAAM,GAAE;AAC7B;AACR;AAE0F;AAC3F,YAAoB,iBAAO,KAAc,iBAAO,IAAK,KAAgB,gBAAG;AACpE,aAAQ,QAAqB,qBACnC;AAAC;AAED,kCAAgB,mBAAhB;AACM,aAAQ,QAAY,YAAC,YAAU,WAAY;AAC3C,aAAW,aAAS;AACpB,aAAQ,QAAoB,oBAAgB,iBAAW;AAEA;AAC3D,YAAI,CAAK,KAAQ,QAAwB,yBAAE;AACrC,iBAAQ;AAEhB;AAAC;AAIE;;;AACH,kCAAY,eAAZ;AACM,aAAU;AACV,aAAQ,QAAa,aAAK,KAAa;AAE3C,YAAgB,aAAO,KAAQ,QAAS,SAAC,YAAU,WAAW;AAC9D,YAAc,cAAQ,KAAqB,sBAAE;AACvC,iBAAS,SAAK,KAAY;AAC9B,gBAAQ,KAAW,YAAE;AACf,qBAAW,WAAY,YAAK,KAAY;AAC7C;AAEL;AAAC;AAED,kCAAoB,uBAApB,UAAkC;AAC5B,aAAiB,iBAAM,OAAkB,gBAC/C;AAAC;AAIE;;;AACH,kCAAW,cAAX;AACM,aAAQ,QAAS,SAAC,YAAU,WAAU;AACtC,aAAU;AAEV,aAAQ,QACd;AAAC;AAIE;;;AACH,kCAAU,aAAV;AACE,YAAQ,KAAW,YAAE;AACZ;AACR;AACG,aACN;AAAC;AAED,kCAAW,cAAX,UAA+B;AAC7B,YAAQ,KAAS,UAAE;AACV;AACR;AAED,YAAQ,KAAW,YAAE;AACf,iBAAQ,QAAa;AAClB;AACR;AAEG,aAAQ,QAAgB,gBAAc;AAEtC,aACN;AAAC;AAKE;;;;AACH,kCAAa,gBAAb,UAAkC;AAChC,YAAQ,KAAW,cAAI,CAAK,KAAQ,QAAS,SAAC,YAAU,WAAS,UAAE;AAC1D;AACR;AAED,YAAa,UAAG,WAAY,aAAO,WAAK,WAAG,IAAO;AAClD,YAAa,UAAG,WAAY,aAAO,WAAK,WAAG,IAAU;AACrD,YAAa,UAAG,WAAY,aAAO,WAAK,WAAG,IAAU;AACrD,YAAe,YAAG,WAAY,aAAO,WAAK,WAAG,IAAY;AAE7C;AACZ,YAAI,CAAQ,WAAS,MAAI,OAAS,MAAI,IAAO,WAAM,KACxC,WAAQ,KAAQ,QAAwB,yBAAE;AACnD,gBAAS,MAAY,UAAM,MAAM,MAAK;AACtC,gBAAwB,qBAChB,KAAQ,QAAmB,mBAAI,KAAM,KAAgB;AAC7D,gBAAsB,sBAAK,GAAE;AACvB,qBAAiB,iBAAqB;AAC3C;AACI,kBAAkB;AAChB;AACR;AAED,YAAI,CAAQ,WAAI,CAAQ,WAAI,CAAQ,WAAI,CAAU,WAAE;AAC3C;AACR;AAEuD;AACxD,YAAW,WAAQ,KAAc,gBAAI,GAAE;AACjC,iBAAiB,iBAAK,KAAc,gBAAM;AAC/C,eAAM,IACM,aAAQ,KAAc,gBAAO,KAAQ,QAAmB,qBAAI,GAAE;AACrE,iBAAiB,iBAAK,KAAc,gBAAM;AAC/C;AAEG,aAAY;AACX,cACP;AAAC;AAIE;;;AACH,kCAAY,eAAZ,UAA+B;AAC7B,YAAI,CAAK,KAAQ,QAAa,cAAE;AACvB;AACR;AACD,YAAe,YAAO,KAAQ,QAAS,SAAC,YAAU,WAAU;AAE5D,YAAa,WAAE;AACb,gBAAgB,aAAG,YAAO,QAAa;AACvC,gBAAgB,aAAO,KAAQ,QAAgB,kBAAc;AACzD,iBAAQ,QAAa,aAAa;AACvC,eAAM,IAAI,CAAU,WAAE;AACjB,iBAAQ,QAAgB;AAEhC;AAAC;AAIE;;;AACH,kCAAuB,0BAAvB,UAAqC;AACnC,YAAQ,KAAY,aAAE;AAChB,iBAAY,YAAa,aAAQ;AAEzC;AAAC;AAIE;;;AACH,kCAAqB,wBAArB,UAAqC;AACnC,YAAQ,KAAY,aAAE;AAChB,iBAAY,YAAW,WAAU;AAEzC;AAAC;AAED,kCAAuB,0BAAvB,UAAqD;AAC/C,aAAqB,uBAC3B;AAAC;AAED,kCAAQ,WAAR,UAAyB;AACvB,YAAI,CAAK,KAAqB,sBAAE;AAC1B,iBAAe,iBAAW;AAC/B;AAEG,aAAQ,QAAoB,oBAAe,gBAAE,CAAC,CAAS,SAAa;AACxE,YAAW,SAAE;AACP,iBAAQ,QAAY,YAAC,YAAU,WAAU;AACzC,iBAAQ,QAAgB,gBAAC,YAAU,WAAe;AACvD,eAAM;AACD,iBAAQ,QAAS,SAAC,YAAU,WAAU;AACtC,iBAAQ,QAAa,aAAC,YAAU,WAAe;AAEvD;AAAC;AAED,kCAAO,UAAP;AACE,YAAQ,KAAqB,wBACrB,KAAQ,QAAS,SAAC,YAAU,WAAU,aAC1C,CAAK,KAAQ,QAAS,SAAC,YAAU,WAAU,WAAE;AACyD;AACJ;AACpG,mBAAW,KAAc,kBAAK,YAAO,QACjC,gBAAK,KAAc,kBAAM,KAAW,QAAK,KAAc;AAC5D;AACD,eAAW,KACb;AAAC;AAED,kCAAW,cAAX,UAA+B;AAC7B,YAAc,YAAE;AACV,iBAAQ,QAAS,SAAC,YAAU,WAAW;AAC5C,eAAM;AACD,iBAAQ,QAAY,YAAC,YAAU,WAAW;AAC/C;AACG,aAAQ,QAAoB,oBAAgB,iBAAY,WAAa;AACrE,aAAQ,QAAiB,iBAC/B;AAAC;AAED,kCAAW,cAAX;AACE,eAAW,KAAQ,QAAoB,oBAAiB,qBAC1D;AAAC;AAED,kCAAI,OAAJ;AACE,YAAc,WAAO,KAAQ,QAAoB;AACjD,YAAY,UAAE;AACR,iBAAQ,QAAqB,qBAAW;AACxC,iBAAQ,QAAoB,oBAAC,YAAM,OAAe;AACvD;AACG,aAAQ,QAAiB,iBAAQ;AAEjC,aAAY,YAAK,KAAQ,QAAS,SAAC,YAAU,WAAY;AACzD,aAAiB;AACjB,aACN;AAAC;AAIE;;;AACK,kCAAI,OAAZ;AACM,aAAQ,QAAY,YAAC,YAAU,WAAU;AACzC,aAAU;AACV,aAAQ,QAAwB;AAEpC,YAAgB,aAAO,KAAQ,QAAS,SAAC,YAAU,WAAW;AAC9D,YAAc,cAAQ,KAAqB,sBAAE;AACvC,iBAAS,SAAK,KAAY;AAC9B,gBAAQ,KAAW,YAAE;AACf,qBAAW,WAAY,YAAK,KAAY;AAC7C;AAEL;AAAC;AAEO,kCAAmB,sBAA3B,UAAyC;AACnC,aAAc,gBAAS;AAE3B,YAAS,UAAK,YAAO,QAAY,aAAE;AAC7B,iBAAQ,QAAgB,gBAAK;AAC1B;AACR;AAEG,aAAQ,QAAgB,gBACpB,KAAQ,QAAuB,uBAAO,OAAS;AACnD,aAAQ,QAAgB,gBAAM,OAAE,YAAU,WAAsB;AAChE,aAAQ,QAAoB,oBAAM,OAAE,YAAO,QAAmB,oBACpE;AAAC;AAEO,kCAAsB,yBAA9B,UAA4C;AAC1C,YAAS,UAAK,YAAO,QAAY,aAAE;AAC7B,iBAAQ,QAAmB,mBAAM,OAAE,YAAU,WAAsB;AACnE,iBAAQ,QAAoB,oBACvB,OAAE,YAAO,QAAmB,oBAAW;AAEpD;AAAC;AACH,WAAC;AAAA,EA/bwC,aA+bxC;AA/bY,8BAAmB;AAiciF;AACjH,kBAAmC,oB;;;;;;;;;;;;;AC9chC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,uCAA2D;AAK3D;AAAyC,mCAA2C;AAApF;mEA2BA;AAAC;AA1BQ,wBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAuB,oBAChC;AAAC;AAGD,0BAAI,+BAAmB;AADsB;aAC7C;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAED,kCAAoB,uBAApB;AAAA,oBAgBC;AAfuG;AACG;AACD;AACxG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACzD,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AACzD,qBAAE,iBAAK,MAAO;AAAK,uBAAI,MAAK,KAAa,aAAK,MAAQ;AAAA;AACnD,wBAAE,oBAAK;AAAK,uBAAI,MAAK,KAAgB,gBAAM;AAAA;AAC3C,wBAAE,oBAAQ;AACd,sBAAK,KAAY,cACvB;AACA;AAT0C;AAUH;AACzC,eAAO,IAAI,aAA6B,8BAC1C;AAAC;AACH,WAAC;AAAA,EA3BwC,YA2BxC;AA3BY,8BAAmB,oB;;;;;;;;;;;;;ACT7B;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAa;AACA,iBAAe;AACtB,UACJ;AAHc;AAWR,kBAAO;AANf,IAAgB;AACY,gCAA0C;AAC/B,2CAErC;AAJiB;AAMF,qBAAU,W;;;;;;;;;;;;;ACbxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAgD;AAEhD;AAAmD,6CAAyC;AAyB1F,2CAAyD;eACvD,wCAAuC,8BAAe,iBAAc,aACtE;AAAC;AA1BD,0BAAW,+BAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,+BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAKD,0BAAW,+BAAc;AADtB;;;aACH;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACpB,0BAAE;AAAM,2BAAK;AAAA;AACd,yBAAE;AAAM,2BAAS;AAAA;AACd,4BAAE;AAAM,2BAAS;AAAA;AACjB,4BAAE;AAAM,2BAAS;AAC3B;AAPK;AAST;AAAC;;sBAAA;;AAQE;;;AACH,4CAAU,aAAV,UAA0B;AACpB,aAAQ,QAAW,WACzB;AAAC;AASE;;;;;;;;AACH,4CAAa,gBAAb,UAAmC;AACjC,YAAgB,cAAE;AACZ,iBAAQ,QAAS,SAAC,YAAU,WAA6B;AAC9D,eAAM;AACD,iBAAQ,QAAY,YAAC,YAAU,WAA6B;AAEpE;AAAC;AAME;;;;;AACH,4CAA0B,6BAA1B,UAAgD;AAC9C,YAAgB,cAAE;AACZ,iBAAQ,QAAS,SAAC,YAAU,WAAwC;AACzE,eAAM;AACD,iBAAQ,QAAY,YACpB,YAAU,WAAwC;AAE1D;AAAC;AAIE;;;AACH,4CAAkB,qBAAlB;AACM,aAAQ,QAAW,WAAC,YAAO,QACjC;AAAC;AAKE;;;;AACH,4CAAW,cAAX,UAAkC;AAChC,YAAqB,kBACb,KAAQ,QAAS,SAAC,YAAU,WAA6B;AAEjE,YAAI,CAAgB,iBAAE;AACsD;AACnD;AAChB;AACR;AAED,YAA+B,4BACvB,KAAQ,QAAS,SAAC,YAAU,WAAwC;AAEH;AAClB;AACvD,YAAsB,mBAAG,CAAc,iBAA8B;AACrE,YAAoB,kBAAE;AAChB,iBAAsB;AAEuC;AAC3C;AACtB,gBAAI,CAAc,eAAE;AACd,qBAAQ,QAAQ,QAAC,YAAO,QAAK,MAAW;AAC7C,mBAAM;AACD,qBAAQ,QAAW,WAAC,YAAO,QAAO;AACvC;AACM;AACR;AAEkB;AACf,aAAQ,QAAW,WAAC,YAAO,QAAO;AAClC,aACN;AAAC;AAIE;;;AACK,4CAAI,OAAZ;AACM,aAAQ,QAAQ,QAAC,YAAO,QAAY,aAC1C;AAAC;AACH,WAAC;AAAA,EArHkD,aAqHlD;AArHY,wCAA6B;AAuHuE;AACjH,kBAA6C,8B;;;;;;;;;;;;;AC9H1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA6B;AAC7B,sCAA6F;AAArF,2CAAkC;AAAE,wCAA4B,Q;;;;;;;;;;;;;ACLrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,uCAAqD;AAIrD;AAAmC,6BAAqC;AAAxE;mEAgCA;AAAC;AA/BQ,kBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAiB,cAC1B;AAAC;AAGD,0BAAI,yBAAmB;AADsB;aAC7C;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAED,4BAAoB,uBAApB;AAAA,oBAqBC;AApBuG;AACG;AACD;AACxG,YAAa;AACJ,qBAAE,iBAAK;AAAK,uBAAI,MAAK,KAAa,aAAM;AAAA;AACxC,qBAAE,iBAAK,MAAO;AAAK,uBAAI,MAAK,KAAa,aAAK,MAAQ;AAAA;AACnD,wBAAE,oBAAK;AAAK,uBAAI,MAAK,KAAgB,gBAAM;AAAA;AAC3C,wBAAE,oBAAQ;AACd,sBAAK,KAAY,cACvB;AAAC;AACyB,wCAAE,oCAAQ,SAAS;AACzC,uBAAI,MAAO,OAAQ,SAAU;AAAA;AACL,0CAAE,sCAAQ,SAAS;AAC3C,uBAAI,MAAS,SAAQ,SAAU;AAAA;AACnB,8BAAE;AAAM,uBAAI,MAAK,KAC7B,aAAuB,wBAAQ,QAAW,YAAI,GAAc,eACxD,KAAoB;AAC5B;AAdoC;AAeG;AACzC,eAAO,IAAI,aAAuB,wBACpC;AAAC;AACH,WAAC;AAAA,EAhCkC,YAgClC;AAhCY,wBAAa,c;;;;;;;;;;;;;ACRvB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAa;AACD,cAAkB;AACnB,aACT;AAHc;AAKR,kBAAO,Q;;;;;;;;;;;;;ACPZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAGxD,sCAAoC;AAIpC,IAAwB,qBAA2B,CAAQ,SAAa;AAExE;AAA6C,uCAAmC;AA2B9E,qCAAmD;AAAnD,oBACE,wCAAiC,wBAAe,iBAAc,aAG/D;AATO,cAAc,iBAAuB;AAQvC,cAAoB,sBAAG,UAAI;AAAK,mBAAI,MAAkB,kBAAK;AAAC;eAClE;AAAC;AA9BD,0BAAW,yBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAKD,0BAAW,yBAAc;AADtB;;;aACH;AAC0G;AACxG;AACS,yBAAE;AAAM,2BAAI;AAAA;AACZ,yBAAE;AAAM,2BAAS;AAAA;AACd,4BAAE;AAAM,2BAAS;AAAA;AACjB,4BAAE;AAAM,2BAAS;AAAA;AACD,4CAAE;AAAM,2BAAS;AAAA;AACf,8CAAE;AAAM,2BAAS;AAAA;AAC7B,kCAAE;AAAM,2BAAS;AACjC;AARK;AAUT;AAAC;;sBAAA;;AAaD,sCAAI,OAAJ;AAAA,oBAOC;AANK,aAAe,iBAAO,KAAQ,QAAQ,QAAa;AAErC,2BAAQ,QAAC,UAAQ;AAC7B,kBAAQ,QAA2B,2BAC5B,SAAM,MACnB;AACF;AAAC;AAED,sCAAO,UAAP;AAAA,oBAKC;AAJmB,2BAAQ,QAAC,UAAQ;AAC7B,kBAAQ,QAA6B,6BAC9B,SAAM,MACnB;AACF;AAAC;AAED,sCAAW,cAAX,UAA6B;AAC3B,YAAI,CAAK,KAAe,gBAAE;AACjB;AACR;AAED,YAAY,UAAE;AACR,iBAAQ,QAAQ,QAAW,YAAQ;AACnC,iBAAQ,QAAW,WAAS;AACjC,eAAM;AACD,iBAAQ,QAAQ,QAAW,YAAM,KAAiB;AAClD,iBAAQ,QAAQ,QAAO,QAAE,YAAO,QAAY;AAEpD;AAAC;AAED,sCAAY,eAAZ,UAA0B;AACpB,aAAQ,QAAQ,QAAa,cACnC;AAAC;AAED,sCAAU,aAAV,UAA0B;AACpB,aAAQ,QAAW,WACzB;AAAC;AAED,sCAAiB,oBAAjB,UAAiD;AAC/C,YAAgB,aAAyB,IAAI,QAAY,WAA0B,IAAQ,YAAQ;AACnG,YAAO,IAAK,SAAY,WAAc,YAAE;AAClC,iBAAQ,QAAoB;AAEpC;AAAC;AACH,WAAC;AAAA,EA7E4C,aA6E5C;AA7EY,kCAAuB;AA+E6E;AACjH,kBAAuC,wB;;;;;;;;;;;;;AC3FpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA6B;AAC7B,sCAAmD;AAA3C,kCAAsB,Q;;;;;;;;;;;;;ACL3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B;AAE7B,6BAAoC;AACpC,6BAA6B,4D;;;;;;;;;;;;;ACR1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AACtD,mCAAkD;AAElD,sCAAoC;AACpC,uCAAiD;AAEjD;AAA+B,yBAAiC;AAAhE;mEA4KA;AAAC;AA3KQ,cAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAa,UACtB;AAAC;AAOD,0BAAI,qBAAK;aAAT;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAAuB;AACjB,iBAAW,WAAS,SAC1B;AAAC;;sBAJA;;AAMD,0BAAI,qBAAG;aAAP;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAAmB;AACb,iBAAW,WAAO,OACxB;AAAC;;sBAJA;;AAMD,0BAAI,qBAAG;aAAP;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAAmB;AACb,iBAAW,WAAO,OACxB;AAAC;;sBAJA;;AAMD,0BAAI,qBAAI;aAAR;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAAqB;AACf,iBAAW,WAAQ,QACzB;AAAC;;sBAJA;;AAMD,0BAAI,qBAAQ;aAAZ;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAA8B;AACxB,iBAAW,WAAY,YAC7B;AAAC;;sBAJA;;AAMD,wBAAU,aAAV;AACM,aAAgB,kBACZ,KAAK,KAAc,cAAc,YAAO,QAA4B;AACxE,aAAO,SAAO,KAAK,KAAc,cAAc,YAAO,QAAkB;AACxE,aAAgB,kBAAO,KAAK,KAAc,cAC1C,YAAO,QAA6B;AACpC,aAAsB,wBAAO,KAAK,KAAc,cAChD,YAAO,QACb;AAAC;AAED,wBAAoB,uBAApB;AAAA,oBAkEC;AAjE6E;AACP;AACL;AACQ;AACtC;AAClC,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AACxD,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACrD,0BAAE,sBAAK;AAAK,uBAAI,MAAK,KAAa,aAAM;AAAA;AACxC,0BAAE,sBAAK,MAAO;AAAK,uBAAI,MAAK,KAAa,aAAK,MAAQ;AAAA;AACnD,6BAAE,yBAAK;AAAK,uBAAI,MAAK,KAAgB,gBAAM;AAAA;AACvC,iCAAE;AAAM,uBAAI,MAAK,KAAwB;AAAA;AACjD,yBAAE;AAAM,uBAAK,MAAqB,KAAS;AAAA;AAC5B,wCAAE,oCAAQ,SAAS;AACzC,uBAAI,MAAO,OAAQ,SAAS,SAAE,SAAe;AAAA;AACrB,0CAAE,sCAAQ,SAAS;AAC3C,uBAAI,MAAS,SAAQ,SAAS,SAAE,SAAe;AAAA;AACX,sDAAE,kDAAQ,SAAS;AACrD,sBAAgB,gBAAiB,iBAAQ,SAAS,SAAE,SAC1D;AAAC;AACyC,wDAAE,oDAAQ,SAAS;AACvD,sBAAgB,gBAAoB,oBAC7B,SAAS,SAAE,SACxB;AAAC;AAC6B,4CAAE,wCAAQ,SAAS;AAC7C,uBAAQ,SAAK,KAAiB,iBAAQ,SAAU;AAAA;AACpB,8CAAE,0CAAQ,SAAS;AAC/C,uBAAQ,SAAK,KAAoB,oBAAQ,SAAU;AAAA;AAClC,mCAAE,+BAAQ;AAC3B,uBAAM,OAAiB,iBAAS,UAAU;AAAA;AACvB,qCAAE,iCAAQ;AAC7B,uBAAM,OAAoB,oBAAS,UAAU;AAAA;AACtC,yBAAE;AAAM,uBAAI,MAAK,KACxB,YAAO,QAAY,aACd;AAAA;AACG,0BAAE;AAAM,uBAAI,MAAK,KACzB,YAAO,QAAa,cACf;AAAA;AACqB,4CAAE,wCAAa,cAAO;AAC9C,sBAAgB,gBAAM,MAAY,YAAa,cACrD;AAAC;AACoB,mCAAE,+BAAa,cAAO;AACvC,uBAAI,MAAO,OAAM,MAAY,YAAa,cAAQ;AAAA;AACxC,4BAAE,wBAAM;AAAK,uBAAI,MAAgB,gBAAU,YAChD,MAAiB;AAAA;AACX,6BAAE,yBAAK,MAAK,KAAK;AAC9B,oBAAa,UAAO,KAAkB;AACtC,oBAAY,SAAM,IAAkB;AACpC,oBAAY,SAAM,IAAkB;AAC4B;AAChE,oBAAkB,eAAG,OAAW,iBAAY,kBAAc,UAAI;AAC9D,oBAAiB,cAAS;AAC1B,oBAAqB,kBAAG,4CACT,cAAmB;AAClC,oBAAsB,mBAAG,6BAAsC,uBAC/C,eAAkB;AAClC,oBAAyB,sBAAqB,wBAAuB;AACjE,sBAAsB,sBAAM,MAAY,YAC5B,cAClB;AAAC;AACI,mBAAE;AAAM,uBAAgB,iBAAK,MAAM,MAAU,cAAU;AAC5D;AAzDgC;AA0DO;AACzC,eAAO,IAAI,aAAmB,oBAChC;AAAC;AAED,wBAAkB,qBAAlB;AACE,YAAkB,eAAO,KAAY,YAC7B,KAAK,KAAa,aAAC,YAAO,QAAe,gBAAM,KAAQ;AAC/D,YAAS,MAAO,KAAY,YACpB,KAAK,KAAa,aAAC,YAAO,QAAe,gBAAM,KAAM;AAC7D,YAAS,MAAO,KAAY,YACpB,KAAK,KAAa,aAAC,YAAO,QAAe,gBAAM,KAAM;AAEc;AACvB;AACpD,YAAO,OAAQ,KAAI,KAAE;AACf,iBAAI,MAAO;AACX,iBAAI,MAAO;AAChB,eAAM;AACD,iBAAI,MAAO;AACX,iBAAI,MAAO;AAChB;AAEG,aAAK,OAAO,KAAY,YACpB,KAAK,KAAa,aAAC,YAAO,QAAgB,iBAAM,KAAO;AAC3D,aAAM,QAAgB;AACtB,aACA,WAAK,KAAK,KAAa,aAAC,YAAO,QAAe,kBACzC,KAAK,KAAa,aAAC,YAAO,QAAe,mBAAc;AAC5D,aAAW,WACjB;AAAC;AAED,wBAAM,SAAN;AACM,aAAW,WACjB;AAAC;AAED,wBAAM,SAAN,UAAgC;AAAzB;AAAA,qBAAc,KAAK,QAAM;;AAC1B,aAAM,SACZ;AAAC;AAED,wBAAQ,WAAR,UAAkC;AAAzB;AAAA,qBAAc,KAAK,QAAM;;AAC5B,aAAM,SACZ;AAAC;AAEO,wBAAW,cAAnB,UAAoC,KAAsB;AACxD,YAAS,MAAa,WAAO,MAA4B;AACzD,YAAe,YAAG,OAAU,QAAa,YAAY,SAAM;AAC3D,eAAkB,YAAM,MAC1B;AAAC;AACH,WAAC;AAAA,EA5K8B,YA4K9B;AA5KY,oBAAS,U;;;;;;;;;;;;;ACRnB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACR,YAAsB;AACpB,cAAwB;AACxB,cAAwB;AAC3B,WAAqB;AACV,sBAA+B;AACrC,gBAA0B;AACzB,iBAAwB;AACf,0BACpB;AATiB;AA6BX,qBAAU;AAlBlB,IAAa;AACE,mBAAiB;AACjB,mBAAiB;AACjB,mBAAiB;AACjB,mBAAiB;AAClB,kBAAoB;AACrB,iBAAmB;AACL,+BAAiC;AAC5C,oBAAa;AACH,8BAAgC;AACzB,qCAAuC;AACxD,oBACd;AAZc;AAkBI,kBAAO;AAJ3B,IAAa;AACA,iBACX;AAFc;AAIa,kBAAO,Q;;;;;;;;;;;;;AC/BjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,iCAAqF;AACrF,uCAAwD;AAGxD,sCAAyD;AAWsB;AAC/E,IAAe,YAAG,OAAa,WAAiB;AAChD,IAA4B,yBAAY,aAAI,CAAC,CAAO,OAAc;AAElE,IAAiB,cACW,yBAAC,CAAiB,iBAAC,CAAY,aAAgB;AAC3E,IAAe,YACa,yBAAC,CAAe,eAAC,CAAU,WAAc;AAErE,IAAoB;AACT,eAAa;AACX,iBAAe;AAChB,gBACV;AAJmC;AAMrC,IAAa;AACD,gBAAa;AACb,gBAAa;AACZ,iBAAc;AACjB,cAAW;AAChB,SAAO;AACN,UAAQ;AACH,eAAY;AACd,aACP;AATc;AAWhB;AAAyC,mCAA+B;AA0EtE,iCAA+C;AAA/C,oBACE,wCAA6B,oBAAe,iBAAc,aAU3D;AAnCE;;;;AACK,cAAc,iBAAO;AAErB,cAAO,UAAS;AAChB,cAAU,aAAS;AACnB,cAAW,cAAS;AACpB,cAAe,kBAAS;AACxB,cAAuB,0BAAS;AAChC,cAAI,OAAK;AACT,cAAI,OAAO;AACX,cAAK,QAAK;AACV,cAAM,SAAK;AACX,cAAS,YAAS;AAClB,cAAkB,qBAAS;AAc7B,cAA8B,gCAAG;AAAM,mBAAI,MAAwB,0BAC/D;AAAC;AACL,cAAyB,2BAAG,UAAoB;AAChD,mBAAI,MAAY,YAAK;AAAC;AACtB,cAAgB,kBAAG,UAAI;AAAK,mBAAI,MAAe,eAAK;AAAC;AACrD,cAAc,gBAAG;AAAM,mBAAI,MAAe;AAAC;AAC3C,cAAa,eAAG;AAAM,mBAAI,MAAc;AAAC;AACzC,cAAe,iBAAG;AAAM,mBAAI,MAAS;AAAC;eAC5C;AAAC;AApFD,0BAAW,qBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAc;aAAzB;AAC0E;AACtC;AAClC;AACU,0BAAE;AAAM,2BAAK;AAAA;AACb,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AAChB,8BAAE;AAAM,2BAAI;AAAA;AACZ,8BAAE;AAAM,2BAAS;AAAA;AACd,iCAAE;AAAM,2BAAS;AAAA;AACb,qCAAE;AACjB,2BAAC,EAAI,KAAG,GAAO,OAAG,GAAQ,QAAG,GAAM,MAAG,GAAO,OAAG,GAAQ,QAAK;AAAA;AACtD,6BAAE;AAAM,2BAAC;AAAA;AACM,4CAAE;AAAM,2BAAS;AAAA;AACf,8CAAE;AAAM,2BAAS;AAAA;AACL,0DAAE;AAAM,2BAAS;AAAA;AACf,4DAAE;AAAM,2BAAS;AAAA;AAC7B,gDAAE;AAAM,2BAAS;AAAA;AACf,kDAAE;AAAM,2BAAS;AAAA;AAC5B,uCAAE;AAAM,2BAAS;AAAA;AACf,yCAAE;AAAM,2BAAS;AAAA;AAC7B,6BAAE;AAAM,2BAAS;AAAA;AAChB,8BAAE;AAAM,2BAAS;AAAA;AACC,gDAAE;AAAM,2BAAS;AAAA;AAC1B,uCAAE;AAAM,2BAAS;AAAA;AACxB,gCAAE;AAAM,2BAAS;AAAA;AAChB,iCAAE;AAAM,2BAAS;AAAA;AAC3B,uBAAE;AAAM,2BAAK;AAClB;AAzBK;AA2BT;AAAC;;sBAAA;;AA4CD,kCAAI,OAAJ;AAAA,oBAgCC;AA/BK,aAAY,cAAO,KAAQ,QAAS,SAAC,YAAU,WAAc;AAC7D,aAAgB,kBAAO,KAAQ,QAAS,SAAC,YAAU,WAAmB;AAE/D,oBAAQ,QAAC,UAAQ;AACtB,kBAAQ,QAA2B,2BAC5B,SAAM,MAA2B;AACxC,kBAAQ,QAAyC,yCAC1C,SAAM,MACnB;AAAG;AAEH,YAA0B,wBAAE;AAMvB;;;;;;AACC,iBAAQ,QAAS,SAAC,YAAU,WAAuB;AACxD;AAEG,aAAQ,QAA2B,2BAAU,WAAM,KAAkB;AACrE,aAAQ,QAA2B,2BAAQ,SAAM,KAAgB;AACjE,aAAQ,QAA2B,2BAAO,QAAM,KAAe;AAC/D,aAAQ,QAAsB,sBAAK,KAAiB;AAEpD,aAAU;AAEwD;AACtE,YAAQ,KAAY,eAAQ,KAAU,cAAM,GAAE;AACxC,iBAAM,QAAK;AAEnB;AAAC;AAED,kCAAO,UAAP;AAAA,oBAYC;AAXY,oBAAQ,QAAC,UAAQ;AACtB,kBAAQ,QAA6B,6BAC9B,SAAM,MAA2B;AACxC,kBAAQ,QAA2C,2CAC5C,SAAM,MACnB;AAAG;AAEC,aAAQ,QAA6B,6BAAU,WAAM,KAAkB;AACvE,aAAQ,QAA6B,6BAAQ,SAAM,KAAgB;AACnE,aAAQ,QAA6B,6BAAO,QAAM,KAAe;AACjE,aAAQ,QAAwB,wBAAK,KAC3C;AAAC;AAED,kCAAgB,mBAAhB;AACE,YAAQ,KAAY,eAAQ,KAAgB,mBAAQ,KAAU,cAAM,GAAE;AAChE,iBAAQ,QAAgB,gBACpB,KAAU,WAAM,KAAS,UAAM,KAAW;AAEtD;AAAC;AAED,kCAAM,SAAN;AACM,aAAM,QAAO,KAAQ,QAAuB;AAC5C,aACN;AAAC;AAED,kCAAQ,WAAR;AACE,eAAW,KACb;AAAC;AAED,kCAAQ,WAAR,UAAsB;AAChB,aAAU,UAAM,OACtB;AAAC;AAED,kCAAM,SAAN;AACE,eAAW,KACb;AAAC;AAED,kCAAM,SAAN,UAAkB;AAChB,YAAO,MAAO,KAAK,MAAE;AACnB,kBAAM,IAAS,MACmD;AACnE;AACG,aAAK,OAAO;AACZ,aAAU,UAAK,KAAO,QAAO,OAAQ;AACrC,aAAQ,QAAa,aAAC,YAAO,QAAc,eAAQ,OAAK,KAAQ;AAChE,aACN;AAAC;AAED,kCAAM,SAAN;AACE,eAAW,KACb;AAAC;AAED,kCAAM,SAAN,UAAkB;AAChB,YAAO,MAAO,KAAK,MAAE;AACnB,kBAAM,IAAS,MACsD;AACtE;AACG,aAAK,OAAO;AACZ,aAAU,UAAK,KAAO,QAAO,OAAQ;AACrC,aAAQ,QAAa,aAAC,YAAO,QAAc,eAAQ,OAAK,KAAQ;AAChE,aACN;AAAC;AAED,kCAAO,UAAP;AACE,eAAW,KACb;AAAC;AAED,kCAAO,UAAP,UAAoB;AAClB,YAAQ,OAAI,GAAE;AACZ,kBAAM,IAAS,MAA4C;AAC5D;AACD,YAAQ,KAAgB,gBAAQ,OAAM,SAAa,YAAQ,OAAK,IAAE;AAC5D,mBAAK;AACV;AACG,aAAM,QAAQ;AACd,aAAU,UAAK,KAAO,QAAO,OAAQ;AACrC,aACN;AAAC;AAED,kCAAU,aAAV;AACE,eAAW,KACb;AAAC;AAED,kCAAW,cAAX,UAA6B;AACvB,aAAU,YAAY;AACtB,aAAa,aAAC,YAAU,WAAS,UAAM,KAAY;AACvD,YAAQ,KAAU,WAAE;AACd,iBAAe,iBAAO,KAAQ,QAAe;AAC7C,iBAAQ,QAAa,aAAC,YAAO,QAAc,eAAU;AACrD,iBAAQ,QAAgB,gBAAa;AAC1C,eAAM;AACD,iBAAQ,QAAgB,gBAAC,YAAO,QAAgB;AACpD,gBAAI,CAAM,MAAK,KAAgB,iBAAE;AAC3B,qBAAQ,QAAa,aAAW,YAAQ,OAAK,KAAkB;AACpE;AAEL;AAAC;AAIE;;;AACK,kCAAW,cAAnB,UAA6C;AAA7C,oBAkCC;AAjCC,YAAQ,KAAU,WAAE;AACX;AACR;AAEG,aAAmB,qBAAQ;AAC3B,aAAc,cAAC,CAAK,KAA0B;AAC9C,aAAwB,0BAAS;AACjC,aAAW,WAAO;AAEtB,YAAiB,cAAG,qBAA0B;AACxC,kBAAY,YAClB;AAAE;AAEF,YAAmB,gBAAiB,eAAU,UAAwB;AAED;AACD;AACtC;AACgD;AAC9E,YAAe,YAAG;AACZ,kBAAa;AACb,kBAAQ,QAAiC,iCAC5B,eAAe;AACvB,sBAAQ,QACb,UAAQ;AAAK,uBAAI,MAAQ,QAAiC,iCAC/C,SAAY;AAC7B;AAAE;AAEE,aAAQ,QAA+B,+BAAc,eAAe;AAC/D,kBAAQ,QACb,UAAQ;AACJ,mBAAI,MAAQ,QAA+B,+BAAQ,SAAY;AAAE;AACrE,aAAiB,iBACvB;AAAC;AAIE;;;AACK,kCAAW,cAAnB,UAAuC;AAClC,YAAkB;AACjB,aAAiB,iBACvB;AAAC;AAIE;;;AACK,kCAAS,YAAjB;AACM,aAAW,WAAQ;AACnB,aAAQ,QACd;AAAC;AAIE;;;AACK,kCAAW,cAAnB,UAAuC;AACrC,YAAuB,IAAc,iBACd,IAAc,cAAO,SAAI,GAAE;AAChD,mBAA0B,IAAc,cAAG,GAAS;AACrD;AACD,eAA0B,IAC5B;AAAC;AAIE;;;AACK,kCAAgB,mBAAxB,UAA4C;AAC1C,YAAa,UAAO,KAAY,YAAM;AACtC,YAAW,QAAO,KAAyB,yBAAU;AACjD,aAAU,UAAM,OACtB;AAAC;AAIE;;;AACK,kCAAwB,2BAAhC,UAAgD;AACxC,iBAA6B;YAA5B,SAAS;YAAE,SAAkB;AACpC,YAAU,OAAU,UAAO,KAAM,MAAM;AACvC,YAAe,cAAO,OAAO,KAAM,MAAO;AAC1C,YAAQ,KAAQ,QAAQ,SAAE;AACb,0BAAI,IAAe;AAC/B;AACyD;AACN;AACpD,eAAU,MAAiB,eAAI,MACjC;AAAC;AAIE;;;AACK,kCAAc,iBAAtB,UAAyC;AACvC,YAAW,QAAO,KAAU,UAAM;AAClC,YAAW,QAAO,KAAkB,kBAAQ;AAC5C,YAAS,MAAO,QAAE;AACT;AACR;AAE2E;AACjE;AACR,YAAkB;AACjB,aAAQ,QAAS,SAAC,YAAU,WAAQ;AACpC,aAAU,UAAM,OAAQ;AACxB,aAAQ,QACd;AAAC;AAIE;;;AACK,kCAAS,YAAjB,UAAuC;AACrC,YAAU,OAAI,QAAY,QAAW,cAAU,OAAQ,YAAO,IAAE;AAC9D,mBAAc,QAAY;AAC3B;AACD,YAAU,OAAI,QAAY,QAAY,eAAU,OAAQ,YAAO,IAAE;AAC/D,mBAAc,QAAa;AAC5B;AACD,YAAU,OAAI,QAAY,QAAS,YAAU,OAAQ,YAAO,IAAE;AAC5D,mBAAc,QAAU;AACzB;AACD,YAAU,OAAI,QAAY,QAAW,cAAU,OAAQ,YAAO,IAAE;AAC9D,mBAAc,QAAY;AAC3B;AACD,YAAU,OAAI,QAAY,QAAK,QAAU,OAAQ,YAAO,IAAE;AACxD,mBAAc,QAAM;AACrB;AACD,YAAU,OAAI,QAAY,QAAI,OAAU,OAAQ,YAAO,IAAE;AACvD,mBAAc,QAAK;AACpB;AACD,YAAU,OAAI,QAAY,QAAQ,WAAU,OAAQ,YAAO,IAAE;AAC3D,mBAAc,QAAS;AACxB;AACD,YAAU,OAAI,QAAY,QAAU,aAAU,OAAQ,YAAO,IAAE;AAC7D,mBAAc,QAAW;AAC1B;AACD,eACF;AAAC;AAIE;;;AACK,kCAAiB,oBAAzB,UAAuC;AAC/B,iBAA0C;YAAzC,SAAS;YAAE,SAAS;YAAE,UAAoB;AACjD,YAAS,QAAO,QAAI,CAAI,MAAO,OAAO;AACtC,YAA2B,wBAAO,KAAQ,QACtC,YAAM,UAAY,QAAW,cAAS,UAAY,QAAc;AACpE,YAAyB,uBAAE;AACpB,oBAAG,CAAO;AAChB;AAED,gBAAe;AACb,iBAAY,QAAY;AACxB,iBAAY,QAAW;AACrB,uBAAW,KAAO,SAAS;AAC7B,iBAAY,QAAa;AACzB,iBAAY,QAAS;AACnB,uBAAW,KAAO,SAAS;AAC7B,iBAAY,QAAK;AACf,uBAAW,KAAM;AACnB,iBAAY,QAAI;AACd,uBAAW,KAAM;AACnB,iBAAY,QAAQ;AAClB,uBAAW,KAAO,SAAQ,QAAG,YAAO,QAAa;AACnD,iBAAY,QAAU;AACpB,uBAAW,KAAO,SAAQ,QAAG,YAAO,QAAa;AACnD;AACE,uBAEN;;AAAC;AAEO,kCAAY,eAApB;AACE,YAAQ,KAAmB,oBAAE;AACpB;AACR;AACG,aAAQ,QAAS,SAAC,YAAU,WAClC;AAAC;AAEO,kCAAW,cAAnB;AACM,aAAmB,qBAAS;AAC5B,aAAQ,QAAY,YAAC,YAAU,WACrC;AAAC;AAIE;;;AACK,kCAAS,YAAjB,UAA+B,OAA0B,iBAAe;AAAb;AAAA,oBAAa;;AACtE,YAAS,UAAS,KAAO,UAAI,CAAM,OAAE;AAC5B;AACR;AAEK,iBAA6B;YAA5B,SAAS;YAAE,SAAkB;AACpC,YAAwB,qBAAQ,UAAQ,OAAS,UAAS;AAC1D,YAAQ,KAAM,SAAI,CAAmB,oBAAE;AAChC,oBAAO,KAAU,UAAQ;AAC/B;AACD,YAAS,QAAM,KAAE;AACV,oBAAO;AACb,eAAM,IAAS,QAAM,KAAE;AACjB,oBAAO;AACb;AACI,gBAAQ,SAAM,GAAkB;AACjC,aAAO,SAAS;AAChB,aAAQ,QAAa,aAAC,YAAO,QAAc,eAAQ,OAAK,KAAU;AAClE,aAA4B;AAEhC,YAAmB,iBAAE;AACf,iBAAQ,QAAe;AAC3B,gBAAQ,KAAY,aAAE;AAChB,qBAAQ,QAAe,eAAQ;AACpC;AAEL;AAAC;AAIE;;;AACK,kCAAS,YAAjB,UAA+B;AAC7B,YAAc,WAAO,KAAM,MAAM,QAAO,KAAQ;AAChD,eAAe,WAAO,KACxB;AAAC;AAEO,kCAAwB,2BAAhC;AAAA,oBAgCC;AA/BO,iBAA4C;YAA3C,SAAS;YAAE,SAAS;YAAE,WAAsB;AACnD,YAAiB,cAAG,CAAM,QAAU,QAAI,MAAQ;AAChD,YAAe,cAAc,cAAO,KAAM,MAAO;AACjD,YAAQ,KAAQ,QAAQ,SAAE;AACb,0BAAO,KAAM,MAAM,QAAe;AAC9C;AAED,YAAmB,gBAAc,YAAC,OAAsB,uBAAO,QAAgB,eAAa;AAC5F,YAA0B,uBACX,YAAC,OAAmB,oBAAO,QAAiC,mBAAiB;AAE5F,YAAQ,KAAW,YAAE;AACnB,gBAAqB,oBAAG;AAClB,sBAAc,cAAQ;AACtB,sBAAQ,QAA2C,2CAC/B,sBAC1B;AAAE;AACE,iBAAQ,QAAyC,yCAC7B,sBAAmB;AAC5C;AAEoB,8BAAC;AACwC;AACN;AACzB;AACwC;AACjE,kBAAQ,QAA+B,+BAC1B,eAAE,gBAAyB,cAAwB;AAChE,kBAAQ,QAAsB,sBACjB,eAAE,YAAqB,cAC1C;AACF;AAAC;AAIE;;;AACK,kCAAU,aAAlB,UAAkC;AAC5B,aAAQ,UAAU;AAClB,aAAa,aAAC,YAAU,WAAO,QAAM,KAC3C;AAAC;AAIE;;;AACK,kCAAa,gBAArB,UAAwC;AAClC,aAAW,aAAa;AACxB,aAAa,aAAC,YAAU,WAAW,YAAM,KAC/C;AAAC;AAIE;;;AACK,kCAAY,eAApB,UAAsC,WAA0B;AAC9D,YAAmB,iBAAE;AACf,iBAAQ,QAAS,SAAY;AAClC,eAAM;AACD,iBAAQ,QAAY,YAAY;AAExC;AAAC;AACH,WAAC;AAAA,EAtfwC,aAsfxC;AAtfY,8BAAmB;AAwf+C;AAC3C;AACpC,kBAAmC,oB;;;;;;;;;;;;;ACriBhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,4D;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,qCAA+C;AAE/C,sCAAoC;AACpC,uCAAmD;AAEnD,4CAA+B;AAG7B,2CAAgB;IAAE,qCAAc;IAAE,sCAAe;IAAE,uCAAgB;IACnE,oCAAa;IAAE,mCAAY;IAAE,oCAAa;IAAE,mCAClC;AAEZ;AAAiC,2BAAmC;AAApE;mEAsIA;AAAC;AArIQ,gBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAe,YACxB;AAAC;AAWD,0BAAU,aAAV,UAA8E;AAAnE;AAAA;AAAsD,uBAAI,KAAS;AAAA;;AACxE,aAAU,YAChB;AAAC;AAED,0BAAkB,qBAAlB;AAAA,oBAiBC;AAhBK,aAAW,aAAO,KAAK,KAAc,cAAoB;AACzD,aAAS,WAAO,KAAK,KAAc,cAAkB;AACrD,aAAU,YAAO,KAAK,KAAc,cAAmB;AAEvD,aAAe,iBAAG,UAAI;AAAK,mBAAI,MAAW,WAAc,cAAK;AAAC;AAC9D,aAAoB,sBAAG,UAAI;AAC7B,gBAAY,SAAM,IAAmB;AACrC,gBAAQ,MAAgB,gBAAQ,SAAE;AAC5B,sBAAW,WAAwB,wBAAM;AAC9C,mBAAM,IAAQ,MAAc,cAAQ,SAAE;AACjC,sBAAW,WAAsB,sBAAM;AAE/C;AAAE;AAEE,aAAwB,wBAAK,KAAiB;AAC9C,aAA6B,6BAAK,KACxC;AAAC;AAED,0BAAO,UAAP;AACE,yBAAa,aAAG;AACZ,aAA0B,0BAAK,KAAiB;AAChD,aAA+B,+BAAK,KAC1C;AAAC;AAED,0BAAI,OAAJ;AACM,aAAW,WACjB;AAAC;AAME;;;;;AACH,0BAAK,QAAL,UAAiB;AAAX;AAAA,qBAAW;;AACX,aAAW,WAAM,MACvB;AAAC;AAED,0BAAoB,uBAApB;AAAA,oBAeC;AAduG;AACG;AACzG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AACnD,sBAAE;AAAM,uBAAI,MAAU,UAAK,MAAU;AAAA;AACjC,0BAAE,sBAAO;AAAK,uBAAI,MAAK,KACnB,cAAU,SAAC,EAAO,QAAG,WAAI;AAAA;AAC5B,2BAAE,uBAAO;AAAK,uBAAI,MAAK,KACnB,eAAU,SAAC,EAAO,QAAG,WAAI;AAAA;AAC9B,0BAAE;AAAM,uBAAI,MAAK,KAAa,cAAK;AAAA;AAClC,2BAAE;AAAM,uBAAI,MAAK,KAAc,eAAK;AAAA;AACtC,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AACjE;AAVkC;AAWpC,eAAO,IAAI,aAAqB,sBAClC;AAAC;AAED,0BAAI,uBAAS;aAAb;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAA+B;AACzB,iBAAW,WAAa,aAC9B;AAAC;;sBAJA;;AAMD,0BAAI,uBAAa;aAAjB;AACE,mBAAW,KAAW,WACxB;AAAC;aAED,aAAwC;AAClC,iBAAW,WAAiB,iBAClC;AAAC;;sBAJA;;AAMD,0BAAI,uBAAM;aAAV;AACE,mBAAW,KAAW,WACxB;AAAC;;sBAAA;;AAED,0BAAI,uBAAS;aAAb;AACqF;AACnC;AAChD,mBAAW,KAAS,SACtB;AAAC;aAED,aAA+B;AACzB,iBAAS,SAAY,cAC3B;AAAC;;sBAJA;;AAMD,0BAAI,uBAAgB;aAApB;AACE,mBAAW,KAAU,UACvB;AAAC;aAED,aAA6C;AACvC,iBAAU,UAAY,cAC5B;AAAC;;sBAJA;;AAMO,0BAAuB,0BAA/B,UAAyE;AACnE,aAAO,OAAU,WACvB;AAAC;AAEO,0BAAyB,4BAAjC,UAA2E;AACrE,aAAS,SAAU,WACzB;AAAC;AAEO,0BAA4B,+BAApC,UAA4E;AACtE,aAAW,WAAiB,iBAAQ,SAC1C;AAAC;AAEO,0BAA8B,iCAAtC,UAA8E;AACxE,aAAW,WAAoB,oBAAQ,SAC7C;AAAC;AAEO,0BAAe,kBAAvB,UAAuC;AACrC,eAAc,QAAC,WAAO,QAAO,QAC/B;AAAC;AAEO,0BAAa,gBAArB,UAAqC;AACnC,eAAc,QAAC,WAAO,QAAO,QAC/B;AAAC;AACH,WAAC;AAAA,EAtIgC,YAsIhC;AAtIY,sBAAW,Y;;;;;;;;;;;;;AChBrB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACP,aAAyB;AAC5B,UAAsB;AACnB,aACP;AAJiB;AAsCX,qBAAU;AAhClB,IAAa;AACI,qBAAyB;AACf,+BAAgC;AAC7C,kBAAsB;AACrB,mBAAuB;AACpB,sBAA0B;AAC5B,oBAAwB;AAC1B,kBAAsB;AACrB,mBAAuB;AACvB,mBAAU;AACT,oBAAW;AACT,sBAChB;AAZc;AAgCI,kBAAO;AAlB3B,IAAa;AACoB,qCAAM;AACxB,mBAAE,CAAE;AACU,iCAAO;AACP,iCAAM;AAE6C;AAC9C,sCAAI;AACL,qCAAK;AAMjC;;;;;AACe,wBAClB;AAhBc;AAkBa,kBAAO,Q;;;;;;;;;;;;;ACxCjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAyD;AAElD,qCAAO;IAAE,8BAAI;IAAE,iCAAsB;AACrC,wCAAa;IAAE,qCAA0B;AAEhD;AAA2C,qCAAiC;AAgC1E,mCAAiD;AAAjD,oBACE,wCAA+B,sBAAe,iBAAc,aAC7D;AATO,cAAO,UAAS;AAChB,cAAe,kBAAK;AACpB,cAAe,kBAAK;AACpB,cAAiB,oBAAK;AACtB,cAAqB,wBAAG,YAAO,QAAiC;AAChE,cAAc,iBAAQ;eAI9B;AAAC;AAjCD,0BAAW,uBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,uBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,uBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,uBAAc;aAAzB;AACE;AACU,0BAAE;AAAM,2BAAS;AAAA;AACjB,0BAAE;AAAM,2BAAS;AAAA;AACb,8BAAE;AAAM,2BAAS;AAAA;AAChB,+BAAE;AAAM,2BAAS;AAAA;AAClB,8BAAE;AAAM,2BAAS;AAAA;AAChB,+BAAE;AAAM,2BAAS;AAAA;AACnB,6BAAE;AAAM,2BAAS;AAEhC;AATS;AASR;;sBAAA;;AAaD,oCAAO,UAAP;AACM,aAA0B;AACV,6BAAK,KAAkB;AACvC,aAAgB,kBAAK;AACb,qBAAK,KAAkB;AAC/B,aAAgB,kBAAK;AACrB,aAAQ,QAAY,YAAU;AAC9B,aAAQ,QAAY,YAAO;AAC3B,aAAQ,QAAY,YAC1B;AAAC;AAED,oCAAI,OAAJ;AAAA,oBAuBC;AAtBK,aAA0B;AAC1B,aAAQ,UAAQ;AAChB,aAAQ,QAAiB;AACzB,aAAQ,QAAY,YAAU;AAC9B,aAAQ,QAAS,SAAU;AAC3B,aAAQ,QAAY;AAE0D;AAC9E,aAAuB,uBAAC;AACtB,kBAAQ,QAAS,SAAO;AAExB,kBAAgB,6BAAc;AAChC,oBAAe,YAAO,MAAgB;AAClC,sBAA4B;AAC5B,sBAAQ,QAAgB;AAC5B,oBAAa,cAAK,YAAO,QAAc,eAAE;AACnC,0BAAkB,+BAAc;AAC9B,8BAAM,MACZ;AAAC,qBAFkC,EAErB;AAElB;AAAC,aATgC,EAS9B,YAAO,QACZ;AACF;AAAC;AAME;;;;;AACH,oCAAK,QAAL,UAAiB;AAAjB,oBAqBC;AArBK;AAAA,qBAAW;;AACf,YAAI,CAAK,KAAQ,SAAE;AAC0F;AACpG;AACR;AAEmB,6BAAK,KAAkB;AACvC,aAAgB,kBAAK;AACrB,aAA0B;AAE1B,aAAQ,UAAS;AACjB,aAAQ,QAAc,cAAS;AAC/B,aAAQ,QAAS,SAAC,YAAU,WAAU;AACtC,aAAQ,QAAY,YAAC,YAAU,WAAO;AACtC,aAAQ,QAAY,YAAC,YAAU,WAAU;AAEjC,qBAAK,KAAkB;AAC/B,aAAgB,6BAAc;AAC5B,kBAA4B;AAC5B,kBAAQ,QAAa,aAC3B;AAAC,SAHgC,EAG9B,YAAO,QACZ;AAAC;AAED,oCAAM,SAAN;AACE,eAAW,KACb;AAAC;AAED,oCAAY,eAAZ;AACE,eAAW,KACb;AAAC;AAED,oCAAY,eAAZ,UAA8B;AACgC;AAC5D,YAAc,WAAG,YAAO,QAA6B;AACrD,YAAc,WAAG,YAAO,QAA6B;AACrD,YAAwB,qBAAG,YAAO,QAAe;AAEjD,YAAa,cAAK,YAAO,QAAkB,iBAAU,aAAY,YAAa,aAAa,UAAE;AACvF,iBAAsB,wBAAa;AACxC,eAAM;AACL,kBAAM,IAAS,MAAC,yDACsC,sBAAY,8BACxC,iDAAmC,YAAK;AAEtE;AAAC;AAED,oCAAgB,mBAAhB;AACE,eAAW,KACb;AAAC;AAED,oCAAgB,mBAAhB,UAAuC;AACjC,aAAe,iBACrB;AAAC;AAED,oCAAa,gBAAb,UAAgC;AAC9B,YAAiB,cAAM,IAAI,QAAa,YAAO,IAAQ,YAAQ;AAC/D,YAAe,eAAQ,KAAmB,oBAAE;AACtC,iBAAM,MAAiB;AAE/B;AAAC;AAED,oCAAuB,0BAAvB,UAAwC;AAClC,aAAM,MACZ;AAAC;AAED,oCAAqB,wBAArB,UAAsC;AAChC,aAAM,MACZ;AAAC;AAEO,oCAAsB,yBAA9B;AACc,qBAAK,KAAoB;AACjC,aAAkB,oBACxB;AAAC;AAEO,oCAAwB,2BAAhC;AACM,aAAgB,kBAAK;AACrB,aAAQ,QAAY,YAAC,YAAU,WAAU;AACzC,aAAQ,QAAY,YAAC,YAAU,WACrC;AAAC;AAIE;;;AACK,oCAAsB,yBAA9B,UAAmD;AAAnD,oBAOC;AANqB,6BAAK,KAAkB;AACvC,aAAgB,wCAAyB;AACvC,kBAAgB,kBAAK;AACb,yBAAK,MAAkB;AAC/B,kBAAgB,kBAAa,WAAS,UAC5C;AACF,SAL8C;AAK7C;AACH,WAAC;AAAA,EAxK0C,aAwK1C;AAxKY,gCAAqB;AA0K+E;AACjH,kBAAqC,sB;;;;;;;;;;;;;ACpLlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,4CAA+B;AAEvB,eAAI;AAEZ,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,8D;;;;;;;;;;;;;ACR1B;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAA6C;AAEtC,6CAA8B;AAC9B,oDAAqC;AAE5C,SAAiB,SAAgB,QAA2B;AAAzB;AAAA,kBAAyB;;AAC1D,QAAc,WAAS,OAAa,aAAc;AAEN;AACgC;AAC5E,QAAe,YAAU,QAAa,YAAQ;AAC9C,QAAI,CAAU,aAAI,CAAS,UAAE;AACpB;AACR;AAE4F;AACvF,WAAa,aAAY,aAAS;AAEiE;AACN;AACiB;AACb;AACZ;AACzF;AACuG;AACvG;AACoD;AACe;AACnE;AACmE;AACnE;AAC0G;AACM;AAChH;AACmC;AACnC;AACe;AACG;AACO;AACX;AACC;AACG;AACO;AACX;AACG;AACZ,YAAY,cAAM;AAClB,YAAU,YAA+E;AAED;AAC/B;AAC2B;AACC;AACrF,YAAa,aAA0B,2BAAa;AAEjD,eAAC;AACoD;AACvD,eAAa,aAAY,aAAY;AAEY;AAChD,gBAAgB,gBAA4B;AAE2B;AACvE,gBAAY,cACrB;AAAC,OACH;AAAC;AAEO,mBAAQ,S;;;;;;;;;;;;;ACpEb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,mCAAkD;AAClD,qCAA+C;AAE/C,sCAAqD;AACrD,uCAAgE;AAGhE,uCAAiD;AAEjD;AAA+B,yBAAiC;AAAhE;AAAA,wEAiGC;AA5FkB,cAAO,UAAO,MAAiB;eA4FlD;AAAC;AAhGQ,cAAQ,WAAf,UAAiC;AAC/B,eAAO,IAAa,UACtB;AAAC;AAOD,wBAAO,UAAP;AACE,yBAAa,aAAG;AACZ,aAAQ,QAAW;AACnB,aAAe,eAAoB,oBAAS,UAAM,KACxD;AAAC;AAED,wBAAkB,qBAAlB;AAAA,oBAQC;AAPK,aAAe,iBAAG;;AAAC,uBAAO;iBAAP,SAAO,GAAP,eAAO;AAAP,qCAAO;;AAAK,yBAAI,MAAW,YAAa,gCAAQ;AAAE;AACrE,aAAe,eAAiB,iBAAS,UAAM,KAAiB;AAEQ;AACF;AACN;AAChE,aAAQ,UAAO,KACrB;AAAC;AAED,wBAAoB,uBAApB;AAAA,oBAcC;AAbuG;AACG;AACzG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AAC1C,qCAAE,iCAAQ;AAAK,uBAAI,MAAe,eAAQ,UACtD;AAAA;AACa,sCAAE,kCAAS;AAAK,uBAAI,MAAe,eAAS,WACxD;AAAA;AACQ,kCAAE,8BAAK,MAAO;AAC9B,uBAAI,MAAe,eAAa,aAAK,MAAQ;AACjD;AATgC;AAUlC,eAAO,IAAI,aAAmB,oBAChC;AAAC;AAED,0BAAI,qBAAM;aAAV;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAED,0BAAI,qBAAO;aAAX;AACE,mBAAW,KAAe,eAC5B;AAAC;aAED,aAAmB;AACb,iBAAW,WAAW,WAC5B;AAAC;;sBAJA;;AAMD,0BAAI,qBAAQ;aAAZ;AACE,mBAAW,KAAe,eAC5B;AAAC;aAED,aAAqB;AACf,iBAAW,WAAY,YAC7B;AAAC;;sBAJA;;AAMO,wBAAa,gBAArB;AAAA,oBA6BC;AA5BQ,+EAAuD;AAC9D,YAAmB,gBACX,KAAK,KAAc,cAAyC;AAEkC;AACG;AACzG,YAAa,gCACR,YAAS,UAAc,cAAM,UACxB,UAAE,kBAAkB;AAAK,uBAAa,cAAU,UAAI,IAAW;AAAA,eACpD,qBAAE;AAAM,uBAAa,cAAwB;AAAA,eACpC,8BAAE,sCAChB,SAAmC;AAC3C,sBAAe,eAAoB,oBAAQ,SAAS,SAAE,SAC5D;AAAC,eACc,iBAAE;AAAM,kCAAO,QAAK,MAAe,gBAAY;AAAA,eACnD,aAAE;AAAM,uBAAI;AAAA,eACG,4BAAE,oCACd,SAAmC;AAC3C,sBAAe,eAAiB,iBAAQ,SAAS,SAAE,SACzD;AAAC,eACU,aAAE,qBAAkB;AAChB,8BAAU,UAAO,OAChC;AAAC,eACgB,mBAAE,2BAAgB,SAAe;AACnC,8BAAM,MAAY,YAAQ,SACzC;AACA;AACF,eAAO,IAAI,YAAS,UAAK,KAAK,MAAE,IAAI,aAAmB,oBACzD;AAAC;AAED,0BAAY,qBAAc;aAA1B;AACS,mFAAuD;AAC9D,mBAAW,KAAK,KAAc,cAChC;AAAC;;sBAAA;;AACH,WAAC;AAAA,EAjG8B,YAiG9B;AAjGY,oBAAS,U;;;;;;;;;;;;;ACbnB;;;;;;;;;;;;;;;;;;;;;;;;AAEmC;AACtC,IAAgB;AACwD;AAC/D,aAAuB;AACkB;AACxC,cACR;AALiB;AAiBX,qBAAU;AAVyB;AAC3C,IAAa;AACmD;AAC7C,uBAAgB;AAC4C;AACtD,6BAA+B;AACyB;AACxD,6BACvB;AAPc;AASI,kBAAO,Q;;;;;;;;;;;;;ACpBxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAgD;AAEhD;AAAyC,mCAA+B;AAsBtE,iCAA+C;eAC7C,wCAA6B,oBAAe,iBAAc,aAC5D;AAAC;AAtBD,0BAAW,qBAAO;AAD6B;aAC/C;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAGD,0BAAW,qBAAU;AADqB;aAC1C;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAGD,0BAAW,qBAAc;AADiB;aAC1C;AACE;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACL,yCAAE;AAAM,2BAAS;AAAA;AAChB,0CAAE;AAAM,2BAAS;AAAA;AACrB,sCAAE;AAAM,2BAAS;AAEzC;AAPS;AAOR;;sBAAA;;AAM2C;AAC5C,kCAAU,aAAV,UAA2B;AACrB,aAAQ,QAAwB,wBAAU;AAC1C,aAAmB,mBAAU;AAC7B,aAAsB,sBAC5B;AAAC;AAE4C;AAC7C,kCAAW,cAAX,UAA6B;AACvB,aAAQ,QAAyB,yBAAW;AAChD,YAAY,UAAE;AACR,iBAAQ,QAAS,SAAC,YAAU,WAAW;AAC5C,eAAM;AACD,iBAAQ,QAAY,YAAC,YAAU,WAAW;AAElD;AAAC;AAE6D;AAC9D,kCAAY,eAAZ,UAAuB;AACrB,YAAmB,gBAAM,IAA4B;AACjD,aAAmB,mBAAc,cAAU;AAC3C,aAAsB,sBAAc,cAC1C;AAAC;AAEmE;AAC5D,kCAAqB,wBAA7B,UAA8C;AAC5C,YAAW,SAAE;AACP,iBAAQ,QAAS,SAAC,YAAU,WAAU;AAC3C,eAAM;AACD,iBAAQ,QAAY,YAAC,YAAU,WAAU;AAEjD;AAAC;AAEO,kCAAkB,qBAA1B,UAA2C;AACrC,aAAQ,QAAqB,qBAC7B,YAAO,QAAkB,mBAAE,KAAG,CAAC,CACrC;AAAC;AACH,WAAC;AAAA,EA/DwC,aA+DxC;AA/DY,8BAAmB;AAiEiF;AACjH,kBAAmC,oB;;;;;;;;;;;;;ACxEhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,4D;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,sCAAuF;AACvF,sCAA8D;AAC9D,uCAA0D;AAG1D,uCAAiD;AAG1C,+CAA+B;AAEtC,IAAgB,eAAK;AAErB;AAA+B,yBAAiC;AAAhE;mEAoJA;AAAC;AAnJQ,cAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAa,UACtB;AAAC;AAOD,0BAAI,qBAAe;aAAnB,aAA4C;AACtC,iBAAS,SAAQ,QAAC,UAAI;AAAK,uBAAG,IAAgB,kBAAkB;AACtE;AAAC;;sBAAA;;AAED,0BAAI,qBAAsB;aAA1B,aAA0D;AACpD,iBAAW,WAA0B,0BAC3C;AAAC;;sBAAA;;AAED,wBAAU,aAAV,UACsD,YACwB;AAD1E;AAAA,6CAA+B;AAAK,2BAAI,YAAM,OAAI;AAAA;;AAClD;AAAA,6DAA+C;AAAK,2BAAI,YAAc,eAAI;AAAA;;AAExE,aAAS,WAAO,KAAiB,iBAAa;AAC9C,aAAa,eAAO,KAAwB,wBAClD;AAAC;AAED,wBAAkB,qBAAlB;AAAA,oBAcC;AAbK,aAAsB,wBAAG,UAAI;AAC7B,mBAAI,MAAW,WAAqB,qBAAK;AAAC;AAC1C,aAAe,iBAAG,UAAI;AAAK,mBAAI,MAAW,WAAc,cAAK;AAAC;AAE9D,aAAO,OAAC,aAAgB,iBAAQ,QAAiB,kBAAM,KAAwB;AAC/E,aAAO,OAAU,WAAM,KAAiB;AAE5C,aAAK,IAAK,IAAI,GAAG,IAAO,KAAS,SAAO,QAAK,KAAE;AAC7C,gBAAQ,KAAS,SAAG,GAAO,QAAE;AACvB,qBAAe,eAAI;AACjB;AACP;AAEL;AAAC;AAED,wBAAO,UAAP;AACE,yBAAa,aAAG;AACZ,aAAS,SAAC,aAAgB,iBAAQ,QAAiB,kBAAM,KAAwB;AACjF,aAAS,SAAU,WAAM,KAAiB;AAC1C,aAAS,SAAQ,QAAC,UAAI;AAAK,mBAAG,IAAU;AAAE;AAE9C,YAAQ,KAAa,cAAE;AACjB,iBAAa,aAAW;AAEhC;AAAC;AAED,wBAAoB,uBAApB;AAAA,oBAiDC;AAhDuG;AACG;AACD;AACxG,YAAa;AACH,sBAAE,kBAAQ;AAAK,uBAAI,MAAc,aAAS,SAAS;AAAA;AAC5C,6BAAE,yBAAiB;AAC9B,uBAAI,MAAc,aAAgB,gBAAkB;AAAA;AACvC,+BAAE;AAAM,uBAAI,MAAc,aAAoB;AAAA;AAC1C,mCAAE;AAAM,uBAAI,MAAc,aAAwB;AAAA;AACzD,4BAAE;AAAM,uBAAK,MAAqB,KAAY;AAAA;AACvD,mBAAE;AAAM,uBAAM,OAAiB,iBAAK,MAAM,MAAiB,iBACnC,iBAAU;AAAA;AAC3B,0BAAE,sBAAM;AAAK,uBAAI,MAAW,WAAY,YAAO;AAAA;AACzC,gCAAE,4BAAM,OAAY;AAClC,uBAAI,MAAS,SAAO,OAAS,SAAY;AAAA;AACzB,kCAAE,8BAAM;AAAK,uBAAI,MAAS,SAAO,OAAa;AAAA;AACnD,6BAAE,yBAAM;AAAK,uBAAI,MAAS,SAAO,OAAQ;AAAA;AACxB,8CAAE,0CAAM;AACpC,uBAAI,MAAS,SAAO,OAA6B;AAAA;AAC9B,qCAAE,iCAAM;AAC3B,uBAAI,MAAS,SAAO,OAAoB;AAAA;AACnB,uCAAE;AACzB,qBAAK,IAAK,IAAI,GAAG,IAAO,MAAS,SAAO,QAAK,KAAE;AAC7C,wBAAQ,MAAS,SAAG,GAAO,QAAE;AAC3B,+BAAS;AACV;AACF;AACD,uBAAO,CACT;AAAC;AACiB,gCAAE;AAClB,oBAAiB,cAAO,MAAmB;AAC3C,oBAAmB,gBAAW,SAAgB;AAC9C,uBAAkB,YAAQ,QAC5B;AAAC;AACgB,+BAAE,2BAAG;AACpB,qBAAK,IAAK,IAAI,GAAG,IAAO,MAAS,SAAO,QAAK,KAAE;AAC7C,wBAAQ,MAAS,SAAG,GAAG,OAAO,IAAE;AAC9B,+BAAS;AACV;AACF;AACD,uBAAO,CACT;AAAC;AACe,8BAAE;AAAM,uBAAI,MAAS,SAAO;AAAA;AAC1B,gCAAE,4BAAM;AAAK,uBAAI,MAAK,KAC7B,QAAoB,qBAAE,EAAM,OAAC,SAAO;AAC/C;AA1CgC;AA2CO;AACzC,eAAO,IAAI,aAAmB,oBAChC;AAAC;AAKE;;;;AACH,wBAAW,cAAX,UAAyB;AACnB,aAAW,WAAY,YAC7B;AAAC;AAKE;;;;AACH,wBAAc,iBAAd,UAA4B;AACtB,aAAW,WAAe,eAChC;AAAC;AAIE;;;AACK,wBAAe,kBAAvB;AACE,eAAS,GAAM,MAAK,KAAK,KAAK,KAAiB,iBAAQ,QACzD;AAAC;AAIE;;;AACK,wBAAgB,mBAAxB,UAAkD;AAChD,oBAA6B,kBAAI,IAAC,UAAG;AACjC,eAAG,KAAK,GAAG,MAAI,aAAW,EAAiB;AAC7C,mBAAiB,WACnB;AACF,SAJa;AAIZ;AAIE;;;AACK,wBAAuB,0BAA/B,UAAyE;AACvE,YAAwB,qBAChB,KAAK,KAAc,cAAQ,QAAwB;AAC3D,YAAsB,oBAAE;AACtB,mBAAyB,mBAAqB;AAC/C;AACD,eACF;AAAC;AACH,WAAC;AAAA,EApJ8B,YAoJ9B;AApJY,oBAAS,U;;;;;;;;;;;;;AChBnB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAa;AACG,oBAAa;AACZ,qBAAc;AACtB,aAAO;AACL,eAAS;AACV,cAAQ;AACP,eAAS;AACC,yBAAuB;AACrB,2BAAqB;AAC9B,kBACZ;AAVc;AAsBC,kBAAO;AAVxB,IAAa;AACO,wBAAI;AACH,yBAAI;AACZ,iBAAI;AACF,mBAAI;AACE,yBAAI;AACX,kBAAI;AACH,mBACb;AARc;AAUR,kBAAO,Q;;;;;;;;;;;;;ACxBZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAGxD,sCAA6C;AAE7C,IAAqB,kBAAG,IAAkB;AAC4C;AACvE,gBAAI,IAAC,YAAO,QAAiB;AAC7B,gBAAI,IAAC,YAAO,QAAkB;AAC9B,gBAAI,IAAC,YAAO,QAAU;AACtB,gBAAI,IAAC,YAAO,QAAW;AACvB,gBAAI,IAAC,YAAO,QAAY;AACxB,gBAAI,IAAC,YAAO,QAAY;AAEvC,IAAiB,cAAG,IAA0B;AACwC;AAC3E,YAAI,IAAC,YAAO,QAAmB,oBAAE,YAAO,QAAiB;AACzD,YAAI,IAAC,YAAO,QAAoB,qBAAE,YAAO,QAAkB;AAC3D,YAAI,IAAC,YAAO,QAAY,aAAE,YAAO,QAAU;AAC3C,YAAI,IAAC,YAAO,QAAa,cAAE,YAAO,QAAW;AAC7C,YAAI,IAAC,YAAO,QAAc,eAAE,YAAO,QAAY;AAC/C,YAAI,IAAC,YAAO,QAAc,eAAE,YAAO,QAAY;AAE1D;AAAyC,mCAA+B;AAmCtE,iCAA+C;AAA/C,oBACE,wCAA6B,oBAAe,iBAAc,aAC3D;AAJO,cAAuB,0BAAS;eAIxC;AAAC;AApCD,0BAAW,qBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,qBAAc;aAAzB;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACV,iCAAE;AAAM,2BAAS;AAAA;AACf,mCAAE;AAAM,2BAAC;AAAA;AACL,uCAAE;AAAM,2BAAC;AAAA;AAChB,gCAAE;AAAM,2BAAC;AAAA;AAClB,uBAAE;AAAM,2BAAK;AAAA;AACN,8BAAE;AAAM,2BAAS;AAAA;AACX,oCAAE;AAAM,2BAAS;AAAA;AACf,sCAAE;AAAM,2BAAS;AAAA;AACtB,iCAAE;AAAM,2BAAS;AAAA;AACA,kDAAE;AAAM,2BAAC,EAAI,KAAG,GAAO,OAAG,GAAQ,QAAG,GAAM,MAAG,GAAO,OAAG,GAAQ,QAAK;AAAA;AAC9E,yCAAE;AAAM,2BAAC,EAAS,UAAG,GAAW,WAAG,GAAa,aAAG,GAAc,cAAK;AAAA;AACpE,2CAAE;AAAM,4BAAE;AAAA;AACjB,oCAAE;AAAM,4BAAE;AAAA;AACX,mCAAE;AAAM,4BAAE;AAAA;AACX,kCAAE;AAAM,2BAAC;AAAA;AACP,oCAAE;AAAM,2BAAS;AACnC;AAlBK;AAoBT;AAAC;;sBAAA;;AAWE;;;;AACH,kCAAyB,4BAAzB,UAAyD;AACnD,aAAwB,0BAC9B;AAAC;AAED,kCAAW,cAAX,UAAyB;AACvB,YAAyB,sBAAO,KAAQ,QAA6B;AACrE,YAAI,CAAK,KAAgB,gBAAO,UAAS,UAAwB,qBAAE;AAC1D;AACR;AAED,YAAuB;AACvB,YAAuB,wBAAK,CAAE,GAAE;AAC1B,iBAAQ,QAAqB,qBAAsB;AACrC,iCACV,KAAQ,QAAiC,iCAAsB;AACxE;AAEG,aAAQ,QAAmB,mBAAM,OAAsB;AACvD,aAAe,eAAQ;AAEvB,aAAQ,QAAmB,mBACjC;AAAC;AAED,kCAAa,gBAAb,UAAgC;AACD;AAC7B,YAAS,MAAO,KAAiB,iBAAM;AAEiC;AACxE,YAAO,QAAc,WAAE;AACd;AACR;AAEgH;AACjH,YAAI,CAAK,KAAiB,iBAAK,MAAE;AAC5B,gBAAkB;AACtB;AAED,YAAQ,KAAwB,yBAAE;AAChC,gBAAQ,KAAiB,iBAAK,MAAE;AACvB;AACR;AAED,gBAAW,QAAO,KAAwB,wBAClC,KAAQ,QAA4B,6BAAO;AAC/C,iBAAQ,QAAa,aAAQ;AAC7B,iBAAe,eAAQ;AAC5B,eAAM;AACL,gBAAqB,kBAAO,KAAQ,QAAsB;AAC1D,gBAAQ,KAAiB,iBAAK,MAAE;AAC1B,qBAAQ,QAAa,aAAkB;AAC5C,mBAAM;AACL,oBAAW,QAAO,KAAwB,wBAAgB,iBAAO;AAC7D,qBAAQ,QAAgB,gBAAQ;AAChC,qBAAe,eAAQ;AAC5B;AAEL;AAAC;AAIE;;;AACH,kCAAoB,uBAApB,UAAgD;AAC1C,aAAQ,QAAa,aAAK,KAAQ,QAAkB,kBAAI,IAAO,OACrE;AAAC;AAKE;;;;AACH,kCAAc,iBAAd,UAA4B;AACgB;AAC1C,YAAI,CAAK,KAAgB,gBAAO,QAAE;AACzB;AACR;AAEkD;AACnD,YAAS,UAAM,GAAE;AACf,mBAAW,KAAQ,QAAS,SAAI;AACjC;AAE8D;AACW;AAC1E,YAAS,UAAS,KAAQ,QAAmB,qBAAI,GAAE;AACjD,mBAAW,KAAQ,QAAS,SAAK,KAAQ,QAA0B;AACpE;AAED,YAAQ,KAAS,UAAE;AACjB,mBAAW,KAAmB,mBAAQ;AACvC;AAEG,aAAgB,gBACtB;AAAC;AAME;;;;;AACK,kCAAuB,0BAA/B,UAA8C,QAAa;AACzD,YAAW,QAAO,KAAU;AAC5B,YAAc,WAAO,KAAQ,QAAmB,qBAAK;AACrD,YAAmB,gBAAM,QAAK,YAAO,QAAS;AAC9C,YAAqB,kBAAM,QAAK,YAAO,QAAe,kBAAI,CAAM,SAAO,QAAK,YAAO,QAAgB,mBAAU;AAC7G,YAAqB,kBAAM,QAAK,YAAO,QAAgB,mBAAI,CAAM,SAAO,QAAK,YAAO,QAAe,kBAAU;AAC7G,YAAS,QAAU;AAEnB,YAAiB,eAAE;AACZ,oBAAY;AAClB,mBAAyB,iBAAE;AACrB,qBAAM;AACZ,SAFM,UAEmB,iBAAE;AACrB,qBAAM;AACZ,SAFM,MAEA;AACA,oBAAK;AACX;AAED,YAAS,QAAI,GAAE;AACR,oBAAY;AAClB,eAAM,IAAS,QAAW,UAAE;AACtB,oBAAK;AACX;AAED,eACF;AAAC;AAQE;;;;;;;AACK,kCAAyB,4BAAjC,UACiB,OACI,WACK,gBACN;AAElB,YAAuB,oBAAO,KAAQ,QAAwB,wBAAY;AAC1E,YAAyB,sBAAoB,kBAAY,cAAiB,iBAAY;AACtF,YAA0B,uBAAoB,kBAAa,eAAkB;AAC7E,YAAmB,gBAAuB,uBAAG,YAAO,QAAqB;AACzE,YAAoB,iBAAsB,sBAAG,YAAO,QAAqB;AAEzE,YAAa,YAAQ,OAAE;AACrB,mBAAW,KAAI,IAAc,eAAK;AACnC;AAED,eAAW,KAAI,IAAe,gBAChC;AAAC;AASE;;;;;;;;AACK,kCAA4B,+BAApC,UACiB,OACI,WACK,gBACN,UACU;AAE5B,YAAuB,oBAAO,KAAQ,QAAwB,wBAAY;AAC1E,YAAyB,sBAAqB,qBAAoB,kBAAY,cAAkB;AAChG,YAA0B,uBAAqB,qBAAoB,kBAAa,eAAiB,iBAAY;AAC7G,YAAmB,gBAAuB,uBAAG,YAAO,QAAqB;AACzE,YAAoB,iBAAsB,sBAAG,YAAO,QAAqB;AAEzE,YAAa,YAAQ,OAAE;AACrB,mBAAW,KAAI,IAAc,eAAK;AACnC;AAED,eAAW,KAAI,IAAe,gBAChC;AAAC;AAQE;;;;;;;AACK,kCAAkC,qCAA1C,UACiB,OACkB,eACT,gBACN;AAyBf;;;;;;;;;;;;;;;;;;;;;;;;AACH,YAAsB,mBAAgB,cAAS,WAAkB;AACjE,YAAuB,oBAAgB,cAAU,YAAiB,iBAAY;AAC9E,YAAuB,oBAAmB,mBAAqB;AAC/D,YAAsB,mBAAmB,mBAAI,KAAqB,oBAAK;AACvE,YAAuB,oBAAoB,oBAAI,KAAqB,oBAAK;AAEzE,YAAoB,kBAAE;AACpB,mBAAY,QAAK;AAClB;AAED,YAAqB,mBAAE;AACrB,mBAAY,QAAK;AAClB;AAED,eAAO,CACT;AAAC;AASE;;;;;;;;AACK,kCAAqC,wCAA7C,UACiB,OACkB,eACT,gBACN,UACU;AAE5B,YAAc,WAAqB,qBAAgB,cAAS,WAAW,WAAkB;AACzF,YAAe,YAAqB,qBAAgB,cAAU,YAAkB;AAChF,YAAe,YAAW,WAAa;AACvC,YAAsB,mBAAW,WAAI,KAAa,YAAK;AACvD,YAAuB,oBAAY,YAAI,KAAa,YAAK;AAEzD,YAAoB,kBAAE;AACpB,mBAAY,QAAK;AAClB;AAED,YAAqB,mBAAE;AACrB,mBAAY,QAAK;AAClB;AAED,eAAO,CACT;AAAC;AAKE;;;;AACK,kCAAgB,mBAAxB,UAA2C;AACzC,YAAmB,gBAAI,IAAI,IAAK,MAAE;AAChC,mBAAU,IAAK;AAChB;AACD,eAAkB,YAAI,IAAI,IAC5B;AAAC;AAEO,kCAAgB,mBAAxB,UAAoC;AAClC,eAAU,QAAK,YAAO,QAAU,aAAO,QAAK,YAAO,QACrD;AAAC;AAKE;;;;AACK,kCAAe,kBAAvB,UAAqC;AACnC,eAAY,SAAK,KAAS,QAAO,KAAQ,QAC3C;AAAC;AAIE;;;AACK,kCAAM,SAAd;AACE,eAAW,KAAQ,QACrB;AAAC;AAKE;;;;AACK,kCAAe,kBAAvB,UAAqC;AACnC,YAAoB,iBAAO,KAAQ,QAAqB;AACxD,YAAc,WAAO,KAAQ,QAAkB;AAC/C,YAAmB,gBAAO,KAAQ,QAAwB,wBAAQ;AAClE,YAAe,YAAO,KAAmC,mCAAM,OAAe,eAAgB,gBAAY;AAE1G,YAAI,CAAK,KAAgB,gBAAW,YAAE;AAC7B;AACR;AAED,YAAqB,kBAAO,KAA0B,0BAAM,OAAW,WAAgB,gBAAY;AAC/F,aAAQ,QAAgB,gBAC9B;AAAC;AAKE;;;;AACK,kCAAkB,qBAA1B,UAAwC;AACtC,YAAoB,iBAAO,KAAQ,QAAqB;AACxD,YAAc,WAAO,KAAQ,QAAkB;AAC/C,YAAmB,gBAAO,KAAQ,QAAwB,wBAAQ;AAClE,YAAiB,cAAO,KAAQ,QAAyB;AACzD,YAAe,YAAO,KAAsC,sCACnD,OAAe,eAAgB,gBAAU,UAAe;AAEjE,YAAI,CAAK,KAAgB,gBAAW,YAAE;AAC7B;AACR;AAED,YAAqB,kBAAO,KAA6B,6BAAM,OAAW,WAAgB,gBAAU,UAAe;AAC/G,aAAQ,QAAgB,gBAC9B;AAAC;AACH,WAAC;AAAA,EAvXwC,aAuXxC;AAvXY,8BAAmB;AAyXiF;AACjH,kBAAmC,oB;;;;;;;;;;;;;ACnZhC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,6D;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAGtD,8CAAoE;AACpE,uCAAuD;AACvD,+CAAsE;AAItE;AAAqC,+BAAuC;AAA5E;mEA6CA;AAAC;AA5CQ,oBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAmB,gBAC5B;AAAC;AAID,8BAAU,aAAV;AACM,aAAS,WAAO,KAAK,KAAc,cACnC,aAAyB,0BAAQ,QACvC;AAAC;AAED,8BAAwB,2BAAxB;AACE,eAAW,KAAW,WACxB;AAAC;AAED,8BAAoB,uBAApB;AAAA,oBAoBC;AAnBuG;AACG;AACD;AACxG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACzC,sCAAE;AAAM,uBAAI,MAAS,SAAwB;AAAA;AAC9C,qCAAE,iCAAK,MAAO;AACjC,uBAAI,MAAS,SAAM,MAAY,YAAK,MAAQ;AAChD;AANsC;AAOC;AAEzC,YAAQ,KAAK,KAAU,UAAS,SACxB,aAAyB,0BAAW,WAAM,OAAE;AAClD,mBAAO,IAAI,oBAA+B,gCAAU;AACrD;AAEkC;AACnC,eAAO,IAAI,qBAAgC,iCAC7C;AAAC;AAED,8BAAQ,WAAR,UAAiD;AAC3C,aAAW,WAAS,SAC1B;AAAC;AAED,8BAAU,aAAV;AACM,aAAW,WACjB;AAAC;AACH,WAAC;AAAA,EA7CoC,YA6CpC;AA7CY,0BAAe,gB;;;;;;;;;;;;;ACXzB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACR,YAA6B;AAC/B,UAA2B;AAClB,mBACb;AAJiB;AAWjB,qBAAU;AALZ,IAAa;AACK,sBAChB;AAFc;AAMd,kBAAO,Q;;;;;;;;;;;;;ACdN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAuD;AAEO;AAC9D;AAAqD,+CAAyB;AAA9E;mEAQA;AAAC;AAPC,8CAAQ,WAAR;AACM,aAAQ,QAAS,SAAC,aAAyB,0BAAW,WAC5D;AAAC;AAED,8CAAU,aAAV;AACM,aAAQ,QAAY,YAAC,aAAyB,0BAAW,WAC/D;AAAC;AACH,WAAC;AAAA,EARoD,aAQpD;AARY,0CAA+B;AAUqE;AACjH,kBAA+C,gC;;;;;;;;;;;;;AChB5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAgD;AAEhD;AAAwD,yCAAqC;AAoB3F,uCAAqD;eACnD,wCAAmC,0BAAe,iBAAc,aAClE;AAAC;AArBD,0BAAW,2BAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,2BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,2BAAc;aAAzB;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACJ,0CAAE;AAAM,2BAAC,EAAI,KAAG,GAAO,OAAG,GAAQ,QAAG,GAAM,MAAG,GAAO,OAAG,GAAQ,QAAK;AAAA;AACtE,yCAAE;AAAM,2BAAS;AACxC;AALK;AAOT;AAAC;;sBAAA;;AAMD,wCAAwB,2BAAxB;AACE,eAAW,KAAQ,QACrB;AAAC;AAIH,WAAC;AAAA,EA9BuD,aA8BvD;AA9BqB,oCAAyB;AAgCkE;AACjH,kBAAyC,0B;;;;;;;;;;;;;ACvCtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B;AAC7B,6BAAoC;AACpC,6BAAqC,mF;;;;;;;;;;;;;ACPlC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAuD;AAEO;AAC9D;AAAsD,gDAAyB;AAA/E;mEAgCA;AAAC;AA/BC,+CAAQ,WAAR,UAAiD;AAC4B;AACxB;AACnD,YAAI,CAA4B,6BAAE;AAC5B,iBAAQ,QAAS,SAAC,aAAyB,0BAAW,WAAS;AAC5D;AACR;AAEsF;AACpC;AAE0B;AAC7E,YAAuB,oBAAO,KAA4B;AAC1D,YAAgB,aAA8B,4BAAM,QAAoB,kBAAO;AAC/E,YAAe,YAA8B,4BAAK,OAAoB,kBAAM;AACxE,aAAQ,QAAS,SAAC,aAAyB,0BAAW,WAAgB;AACtE,aAAQ,QAAwB,wBACrB,aAAE,gBAAuB,4BAAwB,aAAK;AAE+B;AAChG,aAA4B;AAE5B,aAAQ,QAAY,YACpB,aAAyB,0BAAW,WAAgB;AACpD,aAAQ,QAAS,SAAC,aAAyB,0BAAW,WAAS;AAC/D,aAAQ,QAAwB,wBAAY,aAClD;AAAC;AAED,+CAAU,aAAV;AACM,aAAQ,QAAY,YAAC,aAAyB,0BAAW,WAC/D;AAAC;AACH,WAAC;AAAA,EAhCqD,aAgCrD;AAhCY,2CAAgC;AAkCoE;AACjH,kBAAgD,iC;;;;;;;;;;;;;ACxC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,mCAAkD;AAClD,qCAA+C;AAE/C,uCAAsD;AACtD,4CAA+B;AAM/B;AAAoC,8BAAsC;AAA1E;mEAmGA;AAAC;AAlGQ,mBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAkB,eAC3B;AAAC;AAOD,6BAAU,aAAV;AACM,aAAM,QAAO,KAAK,KAAc,cAChC,aAAwB,yBAAQ,QAAiB;AACjD,aAAS,WAAO,KAAK,KAAc,cACnC,aAAwB,yBAAQ,QACtC;AAAC;AAED,6BAAkB,qBAAlB;AAAA,oBAUC;AATK,aAAmB,qBAAG;AAAM,mBAAI,MAAW,WAAoB;AAAC;AAChE,aAAqB,uBAAG,UAAI;AAAK,mBAAI,MAAW,WAAoB,oBAAK;AAAC;AAE1E,aAAM,MAAiB,iBAAQ,SAAM,KAAmB,oBAAE,SAAgB;AAC1E,aAAM,MAAiB,iBAAa,cAAM,KAAmB,oBAAE,SAAgB;AAC/E,aAAM,MAAiB,iBAAc,eAAM,KAAmB,oBAAE,SAAgB;AAChF,aAAM,MAAiB,iBAAY,aAAM,KAAmB,oBAAE,SAAgB;AAC9E,aAAM,MAAiB,iBAAU,WAAM,KAAmB,oBAAE,SAAgB;AAC5E,aAAS,SAAiB,iBAAgB,iBAAM,KACtD;AAAC;AAED,6BAAO,UAAP;AACE,yBAAa,aAAG;AAEZ,aAAM,MAAoB,oBAAQ,SAAM,KAAmB,oBAAE,SAAgB;AAC7E,aAAM,MAAoB,oBAAa,cAAM,KAAmB,oBAAE,SAAgB;AAClF,aAAM,MAAoB,oBAAc,eAAM,KAAmB,oBAAE,SAAgB;AACnF,aAAM,MAAoB,oBAAY,aAAM,KAAmB,oBAAE,SAAgB;AACjF,aAAM,MAAoB,oBAAU,WAAM,KAAmB,oBAAE,SAAgB;AAC/E,aAAS,SAAoB,oBAAgB,iBAAM,KACzD;AAAC;AAED,6BAAoB,uBAApB;AAAA,oBA4BC;AA3BuG;AACG;AACD;AACxG,YAAa;AACe,wCAAE,oCAAU,WAAU;AAC5C,kCAAO,QAAqB,WAAW;AAAA;AACnC,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AAC/C,gCAAE,4BAAU;AAAK,uBAAI,MAAM,MAAU,UAAI,IAAW;AAAA;AAC5C,wCAAE,oCAAK,MAAO;AACpC,uBAAI,MAAM,MAAM,MAAY,YAAK,MAAQ;AAAA;AAChB,2CAAE,uCAAK,MAAO;AACvC,uBAAI,MAAS,SAAM,MAAY,YAAK,MAAQ;AAAA;AACtB,wCAAE,oCAAS;AACjC,uBAAM,OAAiB,iBAAK,MAAU,UAAiB,iBAAU;AAAA;AAC9C,qCAAE,iCAAQ;AAAK,uBAAI,MAAM,MAAW,aAAU;AAAA;AAC9C,qCAAE;AAAM,uBAAI,MAAM,MAAW;AAAA;AACzB,yCAAE;AAAM,uBAAI,MAAS,SAAY;AAAA;AACpC,sCAAE;AAAM,uBAAI,MAAM,MAAY;AAAA;AAC3B,yCAAE;AAAM,uBAAI,MAAM,MAAwB;AAAA;AACvC,4CAAE;AAC5B,uBAAI,MAAS,SAAwB;AAAA;AACT,8CAAE;AAC9B,uBAAI,KAAiC,iCAAU;AACnD;AArBqC;AAsBE;AACzC,eAAO,IAAI,aAAwB,yBACrC;AAAC;AAIE;;;AACH,6BAAiB,oBAAjB;AACE,eAAW,KAAW,WACxB;AAAC;AAIE;;;AACH,6BAAqB,wBAArB;AACE,eAAW,KAAS,SACtB;AAAC;AAKE;;;;AACH,6BAAe,kBAAf,UAAwC;AAClC,aAAW,WAAgB,gBACjC;AAAC;AAKE;;;;AACH,6BAAQ,WAAR,UAAwB;AAClB,aAAW,WAAS,SAC1B;AAAC;AACH,WAAC;AAAA,EAnGmC,YAmGnC;AAnGY,yBAAc,e;;;;;;;;;;;;;ACdxB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACL,eAA+B;AACtB,wBAAyC;AAChD,iBACX;AAJiB;AAYjB,qBAAU;AANZ,IAAa;AACE,mBAAkC;AAC/B,sBAChB;AAHc;AAOd,kBAAO,Q;;;;;;;;;;;;;ACfN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAgD;AAChD,iDAAgE;AAChE,kDAAkE;AAClE,iDAAgE;AAIhE;AAA8C,wCAAoC;AAyChF,sCAAoD;AAApD,oBACE,wCAAkC,yBAAe,iBAAc,aAChE;AAXE;;;AACK,cAAY,eAAS;eAU7B;AAAC;AA1CD,0BAAW,0BAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,0BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,0BAAc;aAAzB;AAC0G;AACxG;AAC4B,4CAAE;AAAM,2BAAK;AAAA;AAC/B,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACV,oCAAE;AAAM,2BAAS;AAAA;AACT,4CAAE;AAAM,2BAAS;AAAA;AACd,+CAAE;AAAM,2BAAS;AAAA;AACpB,4CAAE;AAAM,2BAAE;AAAA;AACb,yCAAE;AAAM,2BAAS;AAAA;AACjB,yCAAE;AAAM,2BAAC;AAAA;AACL,6CAAE;AAAM,2BAAC;AAAA;AACZ,0CAAE;AAAM,2BAAC;AAAA;AACN,6CAAE;AAAM,2BAAC,EAAI,KAAG,GAAO,OAAG,GAAQ,QAAG,GAAM,MAAG,GAAO,OAAG,GAAQ,QAAK;AAAA;AAClE,gDAAE;AAAM,2BAAC,EAAI,KAAG,GAAO,OAAG,GAAQ,QAAG,GAAM,MAAG,GAAO,OAAG,GAAQ,QAAK;AAAA;AACnE,kDAAE;AAAM,2BAAC;AACzC;AAfK;AAiBT;AAAC;;sBAAA;;AAiBD,uCAAI,OAAJ;AACmH;AACf;AAClG,YAA+B,4BACvB,KAAQ,QAAoC;AAChD,aAAQ,QAA2B,2BACpB,iBAAE,CAA0B,4BAAS;AACpD,aAAQ,QAAmB,mBACH,yBAAW,WACzC;AAAC;AAIE;;;AACH,uCAAiB,oBAAjB;AACE,YAAQ,KAAS,UAAE;AACjB,mBAAW,KAAoC;AAChD;AAED,YAAuB,oBAAO,KAA+B;AAC7D,YAAgB,aAAO,KAAQ,QAA2B;AAC1D,eAAiB,aACnB;AAAC;AAIE;;;AACH,uCAAiB,oBAAjB;AACsC;AACpC,YAAI,CAAK,KAAa,cAAE;AACf;AACR;AAEwD;AACrD,aACN;AAAC;AAIE;;;AACH,uCAAmB,sBAAnB,UAA8B;AAC2D;AACvF,YAAe,YAAM,IAAmB;AACxC,YAAI,CAAK,KAAa,gBAClB,CAAK,KAAQ,QAA2B,2BAC3B,WAA0B,yBAAQ,QAAkB,mBAAE;AAC9D;AACR;AAEG,aAAa,eAAS;AACtB,aAAQ,QAAY,YAAyB,yBAAW,WAC9D;AAAC;AAKE;;;;AACH,uCAAe,kBAAf,UAAwC;AACY;AAClD,YAAoB,qBAAM,GAAE;AACnB;AACR;AAEG,aAAS,SAAK,KAA6B,6BACjD;AAAC;AAKE;;;;AACH,uCAAwB,2BAAxB,UAAiD;AACG;AAClD,YAAoB,qBAAM,GAAE;AACnB;AACR;AAED,YAAe,YAAO,KAA6B,6BAAmB;AACtE,YAAa,UAAY,gBAAM,GAAE;AACxB;AACR;AAEG,aAAwB;AACxB,aAAQ,QAAwB,wBAAU,UAChD;AAAC;AAIE;;;AACH,uCAAQ,WAAR,UAAwB;AACtB,YAAQ,KAAS,UAAE;AACjB,mBAAW,KAAa,aAAU;AACnC;AAEG,aAAU,UAChB;AAAC;AAIE;;;AACH,uCAAc,iBAAd;AACE,YAAI,CAAK,KAAqB,sBAAE;AAC1B,iBAAqB,uBAAO,KAAuB;AACxD;AAED,eAAW,KACb;AAAC;AAIE;;;AACK,uCAA2B,8BAAnC;AACE,YAAoB,iBAAO,KAAQ,QAA2B,2BAAc;AACpC;AACxC,YAAkB,mBAAW,QAAE;AAC7B,mBAAS;AACV;AAEuE;AACC;AACH;AAC1D;AACZ,YAAW,QAAc,YAAK,KAAiB;AAC/C,YAAI,CAAM,OAAE;AACV,mBAAS;AACV;AAED,YAAkB,eAAQ,MAAI;AAE2E;AACrB;AAC9E,iDAA8C;YAA7C,OAAC;YAAE,OAAC;YAAE,OAAC;YAAE,OAAC;YAAE,QAAE;YAAE,QAA8B;AAErD,eAAiB,WAAK,KACxB;AAAC;AAKE;;;;AACK,uCAAiB,oBAAzB,UAAyC;AACvC,YAAW,QAAO,KAAyB;AAC3C,eAAW,KAAI,IAAK,KAAI,IAAM,MAAK,MAAU,UAAO,MACtD;AAAC;AAEO,uCAAgC,mCAAxC;AACE,YAAgB,aAAO,KAA+B;AACtD,eAAW,KAAiB,iBAAqB,qBACnD;AAAC;AAEO,uCAAqB,wBAA7B;AACE,YAAkB,eAAO,KAAQ,QAA+B;AAChE,YAAe,YAAO,KAAQ,QAA4B;AAC1D;AACM,kBAAG;AACF,mBAAc,eAEvB;AAJS;AAIR;AAKE;;;;AACK,uCAAS,YAAjB,UAAiC;AAC/B,YAAoB,iBAAO,KAAqB;AAChD,YAAiB,cAAO,KAAkB,kBAAU;AACpD,YAAiB,cAAc,cAAkB;AAC7C,aAAS;AACQ,iCAAa;AACrB,yBAEf;AAJgB;AAIf;AAKE;;;;AACK,uCAAY,eAApB,UAAoC;AAClC,YAAe,YAAO,KAAiB,iBAAY,YAAU;AACzD,aAAS,SACf;AAAC;AAME;;;;;AACK,uCAA4B,+BAApC,UAAoD;AAClD,YAAQ,KAAS,UAAE;AACjB,mBAAW,KAAiB,iBAAmB,mBAAU;AAC1D;AAED,YAAoB,iBAAO,KAAqB;AAChD,YAAmB,gBAAU,UAAkB;AAC/C,YAAiB,cAAO,KAAkB,kBAAgB;AAC1D,YAAiB,cAAc,cAAkB;AACjD;AACqB,iCAAa;AACrB,yBAEf;AAJS;AAIR;AAKE;;;;AACK,uCAAQ,WAAhB,UAAmD;AAAnD,oBAqBC;AApB8E;AAC7E,YAAa,UAAY,gBAAM,GAAE;AACxB;AACR;AAEG,aAAwB;AACa;AAC0B;AAC/D,aAAQ,QAAwB,wBAAU,UAAsB;AAChE,aAAQ,QAA8B,8BAC3B,aAAE,gBAAuB,UAAY,cAAO;AAC3C;AACZ,aAAQ,QAA+B;AAEtB,8BAAC;AAChB,kBAAQ,QAAS,SAAyB,yBAAW,WAAY;AACjE,kBAAQ,QAA8B,8BAAY,aACxD;AAAG;AAEC,aAAa,eACnB;AAAC;AAIE;;;AACK,uCAAoB,uBAA5B;AACM,aAAa,eAAS;AAC1B,YAA2B,wBAAO,KAA+B;AAC7D,aAAQ,QAAY,YAAyB,yBAAW,WAAY;AACpE,aAAQ,QAA8B,8BAAY,aAAqB;AACvE,aAAQ,QAAwB,wBACtC;AAAC;AAIE;;;AACK,uCAA2B,8BAAnC;AACE,YAAuB,oBAAO,KAA+B;AAC7D,YAAgB,aAAO,KAAQ,QAA2B;AAC1D,YAAQ,KAAS,UAAE;AACjB,mBAAW,KAAiB,iBAA2B,2BAAW,YAAqB;AACxF;AAED,eAAiB,aACnB;AAAC;AAIE;;;AACK,uCAAmB,sBAA3B;AAC6E;AACT;AACxC;AACxB;AAC6B;AACL;AACwB;AAChD;AAC8B;AACyB;AAC9B;AACzB;AAC6B;AACkB;AACtB;AACzB;AACgE;AAChB;AAClD,YAAuB,oBAAO,KAAQ,QAA2B;AAC7D,aAAQ,QAAwB,wBAAkB,oBAAM;AAC5D,YAAmB,gBAAO,KAAQ,QAA2B;AAEc;AACA;AACnD;AACxB,YAAiB,gBAAI,GAAE;AACY;AAC7B,iBAAQ,QAAwB,wBAAoB;AACxD,mBAAO,IAAI,wBAAyB,0BAAK,KAAU;AACpD;AAED,YAAoB,iBAAO,KAAQ,QAA+B;AAClE,YAAuB,oBAAO,KAAQ,QAAkC;AACxE,YAAoB,iBAAO,KAAM,MAAkB,kBAAM,QAAiB,eAAQ;AACjD;AAC7B,aAAQ,QAAwB,wBAAoB;AAEkB;AACA;AACpB;AACtD,YAAkB,mBAAkB,eAAE;AACpC,mBAAO,IAAI,uBAAwB,yBAAK,KAAU;AACnD;AAED,eAAO,IAAI,uBAAwB,yBAAK,KAC1C;AAAC;AAEO,uCAAM,SAAd;AACE,eAAW,KAAQ,QAA2B,2BAAa,iBAC7D;AAAC;AACH,WAAC;AAAA,EA/V6C,aA+V7C;AA/VY,mCAAwB;AAiW4E;AACjH,kBAAwC,yB;;;;;;;;;;;;;AC7WrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,4CAA+B;AAEvB,eAAI;AAEZ,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,kE;;;;;;;;;;;;;ACR1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,yCAAiD;AAGjD;AAA8C,wCAAiB;AAA/D;mEA4CA;AAAC;AA3CC,uCAAoB,uBAApB;AACE,YAAuB,oBAAO,KAAQ,QAA2B;AAC1D,iDAAsC;AAC2B;AACxE,eAAW,KAAM,MAAM,QACzB;AAAC;AAED,uCAAW,cAAX,UAA2B;AACzB,YAAW,QAAO,KAAyB;AAC3C,YAAuB,oBAAO,KAAQ,QAA2B;AACjE,YAAuB,oBAAO,KAAkB,kBAAM,MAAM,QAAY;AACxE;AACqB,iCAAmB;AAC3B,yBAAmB,oBAElC;AAJS;AAIR;AAED,uCAAkB,qBAAlB,UAAkC;AAChC,YAAuB,oBAAO,KAAQ,QAA2B;AACjE,YAAuB,oBAAO,KAAkB,kBAAkB,oBAAY;AAC9E;AACqB,iCAAmB;AAC3B,yBAAmB,oBAElC;AAJS;AAIR;AAED,uCAA0B,6BAA1B,UAA0C;AACxC,eACF;AAAC;AAEO,uCAAqB,wBAA7B;AACE,YAAkB,eAAO,KAAQ,QAA+B;AAChE,YAAe,YAAO,KAAQ,QAA4B;AAC1D;AACM,kBAAG;AACF,mBAAc,eAEvB;AAJS;AAIR;AAEO,uCAAiB,oBAAzB,UAAyC;AACvC,YAAW,QAAO,KAAyB;AAC3C,eAAW,KAAI,IAAK,KAAI,IAAM,MAAK,MAAU,UAAO,MACtD;AAAC;AACH,WAAC;AAAA,EA5C6C,eA4C7C;AA5CY,mCAAwB;AA8C4E;AACjH,kBAAwC,yB;;;;;;;;;;;;;ACpDrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,yCAAiD;AAGjD;AAA+C,yCAAiB;AAAhE;mEAyCA;AAAC;AAxCC,wCAAoB,uBAApB,UAAuC;AACrC,YAAuB,oBAAO,KAAQ,QAA2B;AACjE,eAAW,KAAM,MAAW,aAC9B;AAAC;AAED,wCAAW,cAAX,UAA2B;AACzB,YAAuB,oBAAO,KAAQ,QAA2B;AACjE,YAAuB,oBAAO,KAAkB,kBAAC,CAAU;AAC3D;AACqB,iCAAmB;AAC3B,yBAAmB,oBAElC;AAJS;AAIR;AAED,wCAAkB,qBAAlB,UAAkC;AAChC,YAAuB,oBAAO,KAAQ,QAA2B;AACjE,YAAuB,oBAAO,KAAkB,kBAAkB,oBAAY;AAC9E;AACqB,iCAAmB;AAC3B,yBAAmB,oBAElC;AAJS;AAIR;AAED,wCAA0B,6BAA1B,UAA0C,SAAoB;AAC5D,eAAc,UAChB;AAAC;AAEO,wCAAqB,wBAA7B;AACE,YAAkB,eAAO,KAAQ,QAA+B;AAChE,YAAe,YAAO,KAAQ,QAA4B;AAC1D;AACM,kBAAW,YAAe;AACzB,mBAET;AAJS;AAIR;AAEO,wCAAiB,oBAAzB,UAAyC;AACvC,YAAW,QAAO,KAAyB;AAC3C,eAAW,KAAI,IAAK,KAAI,IAAM,MAAM,OAAU,UAAO,MACvD;AAAC;AACH,WAAC;AAAA,EAzC8C,eAyC9C;AAzCY,oCAAyB;AA2C2E;AACjH,kBAAyC,0B;;;;;;;;;;;;;ACjDtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,yCAAiD;AAGjD;AAA8C,wCAAiB;AAA/D;mEA0CA;AAAC;AAzCC,uCAAoB,uBAApB,UAAuC;AACrC,YAAuB,oBAAO,KAAQ,QAA2B;AACO;AACxE,eAAW,KAAM,MAAkB,oBACrC;AAAC;AAED,uCAAW,cAAX,UAA2B;AACzB,YAAuB,oBAAO,KAAQ,QAA2B;AACjE,YAAuB,oBAAO,KAAkB,kBAAU;AAC1D;AACqB,iCAAmB;AAC3B,yBAAmB,oBAElC;AAJS;AAIR;AAED,uCAAkB,qBAAlB,UAAkC;AAChC,YAAuB,oBAAO,KAAQ,QAA2B;AACjE,YAAuB,oBAAO,KAAkB,kBAAkB,oBAAY;AAC9E;AACqB,iCAAmB;AAC3B,yBAAmB,oBAElC;AAJS;AAIR;AAED,uCAA0B,6BAA1B,UAA0C,SAAoB;AAC5D,eAAc,UAChB;AAAC;AAEO,uCAAqB,wBAA7B;AACE,YAAkB,eAAO,KAAQ,QAA+B;AAChE,YAAe,YAAO,KAAQ,QAA4B;AAC1D;AACM,kBAAc,eAAY;AACzB,mBAET;AAJS;AAIR;AAEO,uCAAiB,oBAAzB,UAAyC;AACvC,YAAW,QAAO,KAAyB;AAC3C,eAAW,KAAI,IAAK,KAAI,IAAM,MAAM,OAAU,UAAO,MACvD;AAAC;AACH,WAAC;AAAA,EA1C6C,eA0C7C;AA1CY,mCAAwB;AA4C4E;AACjH,kBAAwC,yB;;;;;;;;;;;;;AClDrC;;;;;;;;;;;;;;;;;;;;;;;;AAKH;AACE,+BAA6D;AAA9B,aAAO,UAA0B;AAAC;AAanE,WAAC;AAAA;AAdqB,4BAAiB;AAgB0E;AACjH,kBAAiC,kB;;;;;;;;;;;;;ACtB9B;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAuC;AAIpC;;;AACH,IAAmD;AAKhD;;;;AACH,SAAgD,iCAAsB,aAA0B;AAAxB;AAAA,wBAAwB;;AAC9F,MAAqB,qBAAI,OAAiC,+BAAgB,aAAE;AAC1E,WAAkC;AACnC;AAED,MAAQ,KAAc,YAAc,cAAQ;AAC1C,KAAU,UAAI,IAAC,YAAU,WAAc;AAC9B,cAAK,KAAY,YAAK;AAEjC,MAA+B,4BAAK,GAAa,eAAK,GAAc;AACzD,cAAK,KAAY,YAAK;AAEjC,MAAqB,mBAAE;AACK,iCAA6B;AACxD;AACD,SACF;AAAC;AAhBD,2CAgBC,iC;;;;;;;;;;;;;AC7BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,sCAAuE;AACvE,uCAAgE;AAEhE,sCAA0F;AAE1F,uCAA8C;AAK9C;AAA4B,sBAA8B;AAA1D;mEAiHA;AAAC;AAhHQ,WAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAU,OACnB;AAAC;AASD,qBAAU,aAAV,UACuF,eACN;AAD7E;AAAA,mDAAqC,IAAY;AAAK,2BAAI,YAAS,UAAG,IAAa;AAAA;;AACnF;AAAA,+DAAiD;AAAK,2BAAI,YAAe,gBAAI;AAAA;;AAE3E,aAAG,KAAO,KAAK,KAAI;AACvB,YAAmB,gBAAO,KAAK,KAAc,cACzC,aAAgB,iBAAQ,QAAmB;AAC/C,YAAmB,sCACd,YAAS,UAAc,cAAM,UACxB,UAAE,kBAAkB;AAAK,uBAAa,cAAU,UAAI,IAAW;AAAA,eAC5D,aAAE,qBAAkB;AAAK,uBAAa,cAAU,UAAO,OAAW;AAAA,eAC5D,mBAAE,2BAAgB,SAAe;AAAK,uBAAa,cAAM,MAAY,YAAQ,SAAQ;AACtG;AACF,YAAsB,mBAAG,IAAI,aAAmB,oBAAgB;AAC5D,aAAQ,UAAgB,cAAK,KAAK,MAAoB;AAE1D,YAAyB,sBAAO,KAAK,KAAc,cAC/C,aAAgB,iBAAQ,QAA0B;AAClD,aAAc,gBAAsB,oBAAsB;AAC1D,aAAS,WAAO,KAAK,KAAc,cACnC,aAAgB,iBAAQ,QAC9B;AAAC;AAED,qBAAkB,qBAAlB;AAAA,oBAGC;AAFK,aAAa,eAAG;AAAM,mBAAI,MAAW,WAAc;AAAC;AACpD,aAAO,OAAQ,SAAM,KAC3B;AAAC;AAED,qBAAO,UAAP;AACM,aAAS,SAAQ,SAAM,KAAe;AACtC,aAAQ,QAAW;AACvB,yBAAa,aACf;AAAC;AAED,qBAAoB,uBAApB;AAAA,oBAuBC;AAtBuG;AACG;AACD;AACxG,YAAa;AACJ,qBAAE,iBAAK,MAAO;AAAK,uBAAI,MAAK,KAAa,aAAK,MAAQ;AAAA;AACrD,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACzD,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AAC/C,+BAAE,2BAA4B;AAC3C,uBAAI,MAAc,cAAS,SAA6B;AAAA;AACzC,iCAAE;AAAM,uBAAI,MAAc,cAAa;AAAA;AAC1C,8BAAE;AAAM,uBAAI,MAAK,KAC7B,aAAgB,iBAAQ,QAAiB,kBAAE,EAAM,OAAM,MAAI,MACvD,KAAc;AAAA;AACT,2BAAE;AAAM,uBAAK,MAAqB,KAAW;AAAA;AAC5C,4BAAE;AAAM,uBAAK,MAAqB,KAAY;AAAA;AACxC,kCAAE;AAAM,uBAAI,MAAS,SAAW;AAAA;AAC/B,mCAAE;AAAM,uBAAI,MAAS,SAAY;AAAA;AACjD,mBAAE;AAAM,uBAAK,MAAqB,KAAQ;AAC/C;AAhB6B;AAiBU;AACzC,eAAO,IAAI,aAAgB,iBAC7B;AAAC;AAKD,0BAAI,kBAAM;AADP;;;aACH;AACE,mBAAW,KAAW,WACxB;AAAC;;sBAAA;;AAED,0BAAI,kBAAe;aAAnB,aAA4C;AACtC,iBAAW,WAAmB,mBACpC;AAAC;;sBAAA;;AAIE;;;AACH,qBAAQ,WAAR,UAAgD;AAC1C,aAAW,WAAS,SAC1B;AAAC;AAIE;;;AACH,qBAAU,aAAV;AACM,aAAW,WACjB;AAAC;AAIE;;;AACH,qBAA0B,6BAA1B;AACE,eAAW,KAAc,cAC3B;AAAC;AAED,qBAAiB,oBAAjB;AACE,eAAW,KAAW,WACxB;AAAC;AAIE;;;AACH,qBAAK,QAAL;AACO,aAAqB,KAC5B;AAAC;AACH,WAAC;AAAA,EAjH2B,YAiH3B;AAjHY,iBAAM,O;;;;;;;;;;;;;ACdhB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACR,YACN;AAFiB;AAcjB,qBAAU;AAVZ,IAAa;AACE,mBAAiB;AACd,sBAAqB;AACrB,sBAAqB;AACtB,qBAAoB;AAC3B,cAAY;AACE,4BACtB;AAPc;AAWd,kBAAO,Q;;;;;;;;;;;;;ACjBN;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAgD;AAGhD;AAAsC,gCAA4B;AA8BhE,8BAA4C;AAA5C,oBACE,wCAA0B,iBAAe,iBAAc,aACxD;AAJO,cAAgB,mBAAQ;eAIhC;AAAC;AA/BD,0BAAW,kBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,kBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,kBAAc;aAAzB;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACpB,0BAAE;AAAM,2BAAK;AAAA;AACd,yBAAE;AAAM,2BAAS;AAAA;AACP,mCAAE;AAAM,2BAAS;AAAA;AACf,qCAAE;AAAM,2BAAS;AAAA;AACpB,kCAAE;AAAM,2BAAS;AAAA;AACpB,+BAAE;AAAM,2BAAC;AAAA;AACR,gCAAE;AAAM,2BAAC;AAAA;AACH,sCAAE;AAAM,2BAAC;AAAA;AACR,uCAAE;AAAM,2BAAC;AAAA;AACzB,uBAAE;AAAM,2BAAS;AACtB;AAbK;AAeT;AAAC;;sBAAA;;AAQD,+BAAW,cAAX;AACwE;AACd;AACpD,aAAQ,QACd;AAAC;AAED,+BAAQ,WAAR;AACE,eAAW,KAAQ,QAAS,SAAC,YAAU,WACzC;AAAC;AAIE;;;AACH,+BAAkB,qBAAlB,UAA2C;AACrC,aAAiB,mBACvB;AAAC;AAIE;;;AACH,+BAAQ,WAAR,UAAiD;AAC3C,aAAQ,QAAS,SAAC,YAAU,WAAS;AACrC,aAAQ,QAAQ,QAAC,YAAO,QAAc,eAAU;AAChD,aAAQ,QAAQ,QAAC,YAAO,QAAS,UAAO;AACxC,aAAQ,QAAkB,kBAA8B;AAC5D,YAAQ,KAAiB,kBAAE;AACrB,iBAAQ,QAAS;AAEzB;AAAC;AAIE;;;AACH,+BAAU,aAAV;AACe;AACb,YAAI,CAAK,KAAW,YAAE;AACb;AACR;AAEG,aAAQ,QAAY,YAAC,YAAU,WAAS;AACxC,aAAQ,QAAQ,QAAC,YAAO,QAAc,eAAW;AACjD,aAAQ,QAAQ,QAAC,YAAO,QAAS,UAAQ;AACzC,aAAQ,QACd;AAAC;AAIE;;;AACH,+BAAiB,oBAAjB;AACE,YAAe,YAAO,KAAQ,QAAkB;AAChD,YAAc,WAAO,KAAQ,QAAiB;AAC9C,YAAkB,eAAO,KAAQ,QAAyB;AAC1D,YAAiB,cAAO,KAAQ,QAAwB;AAExD;AACa,yBAAU,WAAc;AACvB,0BAAU,WAAc,cAAe;AAC3C;AACC,uBAAU,WAEvB;AANS;AAMR;AACH,WAAC;AAAA,EA/FqC,aA+FrC;AA/FY,2BAAgB;AAiGoF;AACjH,kBAAgC,iB;;;;;;;;;;;;;ACzG7B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B,yD;;;;;;;;;;;;;ACL1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,uCAAoE;AAKpE;AAAkD,4CAAoD;AAAtG;mEAoBA;AAAC;AAnBQ,iCAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAgC,6BACzC;AAAC;AAGD,0BAAI,wCAAsB;AADsB;aAChD;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAED,2CAAoB,uBAApB;AAAA,oBASC;AARuG;AACG;AACzG,YAAa;AACD,wBAAE,oBAAQ;AACd,sBAAK,KAAY,cACvB;AACA;AAJmD;AAKrD,eAAO,IAAI,aAAsC,uCACnD;AAAC;AACH,WAAC;AAAA,EApBiD,YAoBjD;AApBY,uCAA4B,6B;;;;;;;;;;;;;ACTtC;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACV,UACJ;AAFiB;AAQF,qBAAU;AAJ3B,IAAa;AACE,mBAAE,MAAc,WAC7B;AAFc;AAIR,kBAAO,Q;;;;;;;;;;;;;ACVZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAgD;AAEhD;AAA4D,sDAAkD;AAkB5G,oDAAkE;eAChE,wCAAgD,uCAAe,iBAAc,aAC/E;AAAC;AAnBD,0BAAW,wCAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,wCAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAKD,0BAAW,wCAAc;AADtB;;;aACH;AACE;AACY,4BAAE;AAAM,2BAAS;AAE/B;AAHS;AAGR;;sBAAA;;AAMD,qDAAe,kBAAf,UAAqC,eAAmB;AACzC,wBAAO,KAAI,IAAc,eAAa;AAC/C,aAAQ,QAAW,WAAiB,wBAC1C;AAAC;AACH,WAAC;AAAA,EA1B2D,aA0B3D;AA1BY,iDAAsC;AA4B8D;AACjH,kBAAsD,uC;;;;;;;;;;;;;ACnCnD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA6B;AAC7B,sCAAqG;AAA7F,+CAAsC;AAAE,4CAAgC,Q;;;;;;;;;;;;;ACL7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AACtD,mCAAkD;AAClD,gDAAmD;AACnD,sCAA6F;AAC7F,sCAAoF;AACpF,sCAAgG;AAEhG,sCAAuE;AACvE,uCAAgE;AAIhE,sCAAiH;AACjH,uCAAsF;AACtF,sCAAgD;AAChD,uCAAoD;AACpD,sCAA+F;AAC/F,uCAA0E;AAC1E,sCAA2E;AAG3E;AAAkC,4BAAoC;AAAtE;mEA8bA;AAAC;AA7bQ,iBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAgB,aACzB;AAAC;AAkBD,2BAAU,aAAV,UACuF,eACZ,mBACkB,mBACkB,yBACpC,aACC,cACI;AAN5E;AAAA,mDAAqC,IAAY;AAAK,2BAAI,YAAS,UAAG,IAAa;AAAA;;AACnF;AAAA,2DAA6C;AAAK,2BAAI,YAAa,cAAI;AAAA;;AACvE;AAAA,2DAAsD;AAAK,2BAAI,YAAsB,uBAAI;AAAA;;AACzF;AAAA,uEAAkE;AAAK,2BAAI,YAA4B,6BAAI;AAAA;;AAC3G;AAAA,+CAA0C;AAAK,2BAAI,YAAgB,iBAAI;AAAA;;AACvE;AAAA,iDAA2C;AAAK,2BAAI,YAAgB,iBAAI;AAAA;;AACxE;AAAA,qDAA8C;AAAK,2BAAI,YAAiB,kBAAI;AAAA;;AAE1E,aAAO,SAAO,KAAK,KAAc,cAAmB,YAAO,QAAkB;AAEjF,YAAkB,eAAO,KAAK,KAAc,cAAC,YAAO,QAAiB;AACjE,aAAO,SAAiB,eAAa,aAAgB,gBAAM;AAE/D,YAAuB,oBAAO,KAAK,KAAc,cAAC,YAAO,QAAuB;AAC5E,aAAY,cAAsB,oBAAkB,kBAAqB,qBAAM;AAEnF,YAAoB,iBAAO,KAAK,KAAc,cAAC,YAAO,QAAmB;AACrE,aAAS,WAAmB,iBAAe,eAAkB,kBAAM;AAEzD;AACd,YAAuB,oBAAG,aAAgC,iCAAS;AACnE,YAAwB,qBAAO,KAAK,KAAoB;AACxD,YAAsB,gBAAmB,sBAAsB,mBAAU,UAAS,SAAC,YAAU,WAAe;AAC5G,YAAkB,eACD,iBAAsB,sBAAsB,mBAAc,cAAkB,kBAAgB;AACzG,aAAY,cAAiB,eAAkB,kBAAgB,gBAAM;AAErD;AACpB,YAA6B,0BAAG,aAAsC,uCAAS;AAC/E,YAAsB,qBAAO,KAAK,KAAc,cAAwB,wBAAgB;AACT;AAC/E,YAAI,CAAmB,sBAAiB,iBAAsB,oBAAE;AAC5C,iCAAqB,mBAAc,cAAwB,wBAAgB;AAC9F;AACG,aAAkB,oBAAuB,qBAAwB,wBAAsB,sBAAM;AAElF;AACf,YAAmB,gBACX,KAAK,KAAc,cAAC,YAAO,QAAwB;AACvD,aAAa,eAAkB,gBAAY,YAAiB,iBAAM;AAEtD;AAChB,YAAoB,iBACZ,KAAK,KAAc,cAAC,YAAO,QAAyB;AACxD,aAAc,gBAAmB,iBAAY,YAAkB,kBAAM;AAErD;AAChB,aAAQ,UAAO,KAAK,KAAc,cAAC,YAAO,QAAkB;AAC5D,aAAQ,UAAO,KAAK,KAAc,cAAC,YAAO,QAAkB;AAE5D,aAAO,SAAO,KAAc,cAClC;AAAC;AAED,2BAAO,UAAP;AACE,YAAQ,KAAO,QAAE;AACX,iBAAO,OAAW;AACvB;AACD,YAAQ,KAAY,aAAE;AAChB,iBAAY,YAAW;AAC5B;AACD,YAAQ,KAAY,aAAE;AAChB,iBAAY,YAAW;AAC5B;AACD,YAAQ,KAAkB,mBAAE;AACtB,iBAAkB,kBAAW;AAClC;AACD,YAAQ,KAAa,cAAE;AACjB,iBAAa,aAAW;AAC7B;AACD,YAAQ,KAAc,eAAE;AAClB,iBAAc,cAAW;AAC9B;AACD,YAAQ,KAAO,QAAE;AACX,iBAAO,OAAW;AACvB;AACD,YAAQ,KAAS,UAAE;AACb,iBAAS,SAAW;AACzB;AACD,yBAAa,aACf;AAAC;AAKE;;;;AACH,2BAAkB,qBAAlB;AACM,aAAS,WAAO,KAAO,OAC7B;AAAC;AAED,0BAAI,wBAAK;aAAT;AACE,mBAAW,KAAW,WACxB;AAAC;AAIE;;;aACH,aAAuB;AACjB,iBAAW,WAAS,SAC1B;AAAC;;sBAPA;;AASD,0BAAI,wBAAQ;aAAZ;AACE,mBAAW,KAAW,WACxB;AAAC;AAIE;;;aACH,aAA8B;AACxB,iBAAW,WAAY,YAC7B;AAAC;;sBAPA;;AASD,0BAAI,wBAAK;aAAT;AACE,mBAAW,KAAW,WACxB;AAAC;AAIE;;;aACH,aAAwB;AAClB,iBAAW,WAAS,SAC1B;AAAC;;sBAPA;;AASD,0BAAI,wBAAQ;aAAZ;AACE,mBAAW,KAAO,OACpB;AAAC;AAIE;;;aACH,aAA8B;AACxB,iBAAO,OAAS,WACtB;AAAC;;sBAPA;;AASD,0BAAI,wBAAO;aAAX;AACE,mBAAW,KAAO,OACpB;AAAC;AAIE;;;aACH,aAA2B;AACrB,iBAAO,OAAQ,UACrB;AAAC;;sBAPA;;AASD,0BAAI,wBAAS;aAAb;AACE,mBAAW,KAAO,OACpB;AAAC;AAIE;;;aACH,aAA+B;AACzB,iBAAO,OAAU,YACvB;AAAC;;sBAPA;;AASD,0BAAI,wBAAS;aAAb;AACE,mBAAW,KAAO,OACpB;AAAC;AAIE;;;aACH,aAA+B;AAC2C;AACxE,gBAAa,YAAI,GAAE;AACb,qBAAO,OAAgB,gBAAc;AAC1C,mBAAM;AACD,qBAAO,OAAU,YAAa;AAEtC;AAAC;;sBAZA;;AAcD,0BAAI,wBAAG;aAAP;AACE,mBAAW,KAAO,OACpB;AAAC;AAIE;;;aACH,aAAmB;AACb,iBAAO,OAAI,MACjB;AAAC;;sBAPA;;AASD,0BAAI,wBAAG;aAAP;AACE,mBAAW,KAAO,OACpB;AAAC;AAIE;;;aACH,aAAmB;AACb,iBAAO,OAAI,MACjB;AAAC;;sBAPA;;AASD,0BAAI,wBAAI;aAAR;AACE,mBAAW,KAAO,OACpB;AAAC;AAIE;;;aACH,aAAqB;AACf,iBAAO,OAAK,OAClB;AAAC;;sBAPA;;AAYD,0BAAI,wBAAiB;AADlB;;;aACH,aAAqC;AAC/B,iBAAW,WAAqB,qBACtC;AAAC;;sBAAA;;AAKD,0BAAI,wBAAoB;AADrB;;;aACH,aAAsC;AAChC,iBAAW,WAAwB,wBACzC;AAAC;;sBAAA;;AAKD,0BAAI,wBAAkB;AADnB;;;aACH,aAAsC;AAChC,iBAAW,WAAsB,sBACvC;AAAC;;sBAAA;;AAKD,0BAAI,wBAAqB;AADtB;;;aACH,aAAuC;AACjC,iBAAW,WAAyB,yBAC1C;AAAC;;sBAAA;;AAKD,0BAAI,wBAAmB;AADpB;;;aACH,aAAuC;AACjC,iBAAW,WAAuB,uBACxC;AAAC;;sBAAA;;AAMD,0BAAI,wBAAmB;AADpB;;;;aACH,aAAoD;AAC9C,iBAAW,WAAuB,uBACxC;AAAC;;sBAAA;;AAKD,0BAAI,wBAAU;AADX;;;aACH;AACE,mBAAW,KAAU,UAAK,KAAQ,QAAc,cAClD;AAAC;AAIE;;;aACH,aAAsC;AACpC,gBAAQ,KAAQ,SAAE;AACZ,qBAAQ,QAAY,cAAc;AAE1C;AAAC;;sBATA;;AAcD,0BAAI,wBAAU;AADX;;;aACH;AACE,mBAAW,KAAU,UAAK,KAAQ,QAAc,cAClD;AAAC;AAIE;;;aACH,aAAsC;AACpC,gBAAQ,KAAQ,SAAE;AACZ,qBAAQ,QAAY,cAAc;AAE1C;AAAC;;sBATA;;AAaE;;;AACH,2BAAK,QAAL;AACM,aAAO,OACb;AAAC;AAIE;;;AACH,2BAAM,SAAN;AACE,YAAe,YAAO,KAAW,WAAa;AAC1C,aAAW,WAAa,aAC9B;AAAC;AAED,2BAAoB,uBAApB;AACwG;AACG;AACD;AACxG,YAAa,2DACJ,KAAyB,2BACzB,KAA0B,4BAC1B,KAA0B,4BAC1B,KAA+B,iCAC/B,KACP;AACuC;AACzC,eAAO,IAAI,aAAsB,uBAAQ,SAAM,KACjD;AAAC;AAEO,2BAAsB,yBAA9B;AAAA,oBAsBC;AArByG;AACxG;AACU,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACzD,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AAC7B,iDAAE,6CAAQ,SAAS;AAAK,uBAAI,MAAO,OAAQ,SAAU;AAAA;AACnD,mDAAE,+CAAQ,SAAS;AAAK,uBAAI,MAAS,SAAQ,SAAU;AAAA;AACpD,sDAAE,kDAAQ;AAChD,oBAAuB,oBAAG,2BAAgC;AACxD,yCACQ,IAAC,UAAS;AAAK,+BAAQ,SAAc;AAAC,qBAD1B,EAET,OAAC,UAAc;AAAK,+BAAa;AAC9C;AAAE;AACF,oBAAc,eAAuB,iBAAC,UAAc;AAAK,2BAAO,QAAkB,kBAAgB;AAAE,iBAAnF;AACjB,oBAAY,SAAG,EAAW,YAAQ;AAC1B,yBAAQ,QAAK,MAAO,QAAU;AACtC,uBACF;AAAC;AACyC,wDAAE,oDAAS;AAAK,uBAAQ,SAAa;AAC/E;AAlBK;AAoBT;AAAC;AAEO,2BAAuB,0BAA/B;AAAA,oBAWC;AAVyG;AACxG;AACgB,4BAAE;AAAM,uBAAI,MAAO;AAAA;AACxB,uBAAE;AAAM,uBAAQ,SAAc,kBAAS,MAAO;AAAA;AACxB,6CAAE,yCAAQ,SAAS;AAChD,uBAAI,MAAO,OAAiB,iBAAQ,SAAS,SAAE,SAAe;AAAA;AAC/B,+CAAE,2CAAQ,SAAS;AAClD,uBAAI,MAAO,OAAoB,oBAAQ,SAAS,SAAE,SAAe;AACnE;AAPK;AAST;AAAC;AAEO,2BAAuB,0BAA/B;AAAA,oBAQC;AAPC;AACY,wBAAE,oBAAY;AAAK,uBAAI,MAAO,UAAQ,MAAO,OAAM,MAAa;AAAA;AAC7D,2BAAE;AAAM,uBAAI,MAAS,SAAK,MAAO,OAAa,aAAE;AAAA;AACrD,sBAAE;AAAM,uBAAO,QAAK,MAAQ;AAAA;AAC1B,wBAAE,oBAAY;AAAK,uBAAI,MAAO,UAAQ,MAAO,OAAM,MAAa;AAAA;AAC1D,8BAAE,0BAAW;AAAK,uBAAI,MAAO,UAAQ,MAAO,OAAY,YAAY;AAExF;AAPS;AAOR;AAEO,2BAA4B,+BAApC;AAAA,oBAkBC;AAjBC;AACoB,gCAAE;AAClB,oBAAQ,MAAY,aAAE;AAChB,0BAAY,YAAY;AAEhC;AAAC;AACmB,kCAAE;AACpB,oBAAQ,MAAY,aAAE;AAChB,0BAAY,YAAc;AAElC;AAAC;AAC2B,0CAAE,sCAAY;AACxC,oBAAQ,MAAY,aAAE;AAChB,0BAAY,YAAgB,gBAAc;AAElD;AAEJ;AAjBS;AAiBR;AAEO,2BAAyB,4BAAjC;AAAA,oBAMC;AALC;AACc,0BAAE;AAAM,uBAAI,MAAS,YAAQ,MAAS,SAAa;AAAA;AACrD,wBAAE;AAAM,uBAAO,QAAK,MAAU;AAAA;AAC5B,0BAAE,sBAAW;AAAK,uBAAI,MAAS,YAAQ,MAAS,SAAM,MAAY;AAElF;AALS;AAKR;AAIE;;;AACK,2BAAiB,oBAAzB;AACE;AACkB,8BAAM,KAAoB,oBAClC,KAAkB,kBAAyB,yBACtC;AACH,wBAAM,KAAc,cAAK,KAAY,YAAyB,yBAChC;AAC7B,yBAAM,KAAe,eACxB,KAAa,aAAyB,yBACjC;AACD,0BAAM,KAAgB,gBAC1B,KAAc,cAAyB,yBAGnD;AAbS;AAaR;AAEO,2BAAa,gBAArB,UAAqD;AAArD,oBAoBC;AAnBC,YAAgB,aAAO,KAAK,KAAU,UAAS,SAAC,YAAU,WAAW;AACrE,YAAgB,aAAO,KAAK,KAAU,UAAS,SAAC,YAAU,WAAW;AAErE,YAAc,cAAc,YAAE;AAC5B,mBAAY;AACb;AAEqG;AACG;AACD;AACxG,YAAa,gCACR,YAAS,UAAc,cAAM,UACjB,iBAAE;AAAM,uBAAQ,SAAQ,QAAK,MAAO,QAAY;AAAA,eACrC,4BAAE,oCAAQ,SAAS;AAAK,uBAAI,MAAO,OAAiB,iBAAQ,SAAS,SAAE,SAAe;AAAA,eACpF,8BAAE,sCAAQ,SAAS;AAC7C,uBAAI,MAAO,OAAoB,oBAAQ,SAAS,SAAE,SAAe;AACnE;AACuC;AACzC,eAAoB,cAAK,KAAK,MAAE,IAAI,aAAmB,oBACzD;AAAC;AACH,WAAC;AAAA,EA9biC,YA8bjC;AA9bY,uBAAY,a;;;;;;;;;;;;;ACvBtB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAa;AACE,mBAAiB;AAChB,oBAA0B;AAC1B,oBAAuB;AAChB,2BAAkC;AACnC,0BAAoB;AACxB,sBAAwB;AACzB,qBAAkC;AAClC,qBAAkC;AAC3B,4BACtB;AAVc;AA8CI,kBAAO;AAlC3B,IAAgB;AACN,cAA4B;AAC7B,aAA2B;AACzB,eAA6B;AAC3B,iBAA8B;AAClC,aAA2B;AACpB,oBAAkC;AACxC,cAA4B;AAC5B,cAA4B;AAChC,UAAkB;AACd,cAA4B;AACnB,uBAAqC;AACpC,wBAClB;AAbiB;AAkCX,qBAAU;AAnBlB,IAAa;AACA,iBACX;AAFc;AAmBa,kBAAO;AAZjC;;;;AACH,IAA+B,4BAAG,CACvB,WAAO,OAAO,OAAY,YAAQ,QAAa,aACxD;AASoC,oCAAyB;AAL5D;;;AACH,IAAwB,qBAAG,CAClB,SAAQ,QAAkB,kBAAS,SAAS,SAAQ,QAC3D;AAE+D,6BAAkB,mB;;;;;;;;;;;;;AChDhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAIxD,sCAAwG;AAQxG,IAAwB,qBAA2B,CAAY,aAAgB;AAC/E,IAAwB,qBAA2B,CAAQ,SAAa;AAExE;AAA4C,sCAAkC;AA+EzE;;;;AACH,oCAAkD,SAAwD;AAAtD;AAAA,4BAAsD;;AAA1G,oBACE,wCAAgC,uBAAe,iBAAc,aAa9D;AApCO,cAAU,aAAS;AACnB,cAAkB,qBAAS;AAC3B,cAAQ,WAAQ;AAChB,cAAoB,uBAAQ;AAsB9B,cAAY,cAAgB,cAAY;AACxC,cAAkB,oBAAgB,cAAkB;AACpD,cAAa,eAAgB,cAAa;AAC1C,cAAc,gBAAgB,cAAc;AAE5C,cAAmB,qBAAG;AAAM,mBAAI,MAAgB;AAAC;AACjD,cAAkB,oBAAG;AAAM,mBAAI,MAAkB;AAAC;AAClD,cAAmB,qBAAG;AAAM,mBAAI,MAAc;AAAC;AAC/C,cAAmB,qBAAG,UAAI;AAAK,mBAAI,MAAmB,mBAAK;AAAC;AAC5D,cAA6B,+BAAG;AAAM,mBAAI,MAA6B;AAAC;AACxE,cAAkC,oCAAG,UAAe;AAAK,mBAAI,MAAgC,gCAAgB;AAAC;eACpH;AAAC;AA7FD,0BAAW,wBAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,wBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,wBAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAY,kCAAkB;aAA9B;AACE,gBAAU,OAAO,KAAkB,kBAAM;AACzC,mBAAO,YAAkB,mBAAQ,QAAM,SACzC;AAAC;;sBAAA;;AAED,0BAAI,kCAAW;aAAf;AACE,mBAAW,KAAmB,sBAAQ,KAAW,cAAI,CAAC,CAAK,KAAW,cAAQ,KAChF;AAAC;;sBAAA;;AAED,0BAAI,kCAAW;aAAf;AACE,mBAAO,CAAK,KAAW,cAAI,CAAK,KAAU,aAAI,CAAC,CAAK,KACtD;AAAC;;sBAAA;;AAKD,0BAAW,wBAAc;AADtB;;;aACH;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACpB,0BAAE;AAAM,2BAAI;AAAA;AACe,qDAAE;AAAM,2BAAS;AAAA;AACf,uDAAE;AAAM,2BAAS;AAAA;AACvB,iDAAE;AAAM,2BAAS;AAAA;AACf,mDAAE;AAAM,2BAAS;AAAA;AACV,0DAAE;AAAM,+BAAoB,iBAAC;AAAM,+BAAS;AAAC,qBAArC;AAAqC;AAC3C,4DAAE;AAAM,2BAAS;AAAA;AAC7C,gCAAE;AAAM,2BAAI;AAAA;AACjB,2BAAE;AAAM,2BAAK;AAAA;AACJ,oCAAE;AAAM,2BAAS;AAAA;AACf,sCAAE;AAAM,2BAAS;AAAA;AACT,8CAAE;AAAM,2BAAS;AAAA;AACnC,4BAAE;AAAM,2BAAS;AAAA;AACjB,4BAAE;AAAM,2BAAS;AAAA;AACX,kCAAE;AAAM,2BAAS;AAAA;AACzB,0BAAE;AAAM,2BAAK;AAAA;AACR,+BAAE;AAAM,2BAAC;AAAA;AACZ,4BAAE;AAAM,2BAAK;AAAA;AACX,8BAAE;AAAM,2BAAS;AAAA;AACjB,8BAAE;AAAM,2BAAS;AAC7B;AAvBK;AAyBT;AAAC;;sBAAA;;AAwCD,qCAAI,OAAJ;AAAA,oBAyBC;AAxBC,YAAQ,KAAQ,QAAW,cAAQ,KAAkB,kBAAS,UAAE;AAC1D,iBAAQ,QAAiB,iBAAO;AACrC;AAED,YAAQ,KAAQ,QAAY,aAAE;AACxB,iBAAsB;AAC3B,eAAM,IAAQ,KAAQ,QAAW,cAAQ,KAAY,aAAE;AAClD,iBAAa,aAAO;AACpB,iBAAQ,QAAW,WAAO;AAC1B,iBAAe,eAAO;AAC3B;AAEG,aAAQ,QAAgC,gCAAQ,SAAM,KAAqB;AAC3E,aAAQ,QAAgC,gCAAO,QAAM,KAAoB;AACzE,aAAQ,QAAgC,gCAAQ,SAAM,KAAqB;AAC7D,2BAAQ,QAAC,UAAQ;AAC7B,kBAAQ,QAAgC,gCAAQ,SAAM,MAC5D;AAAG;AACe,2BAAQ,QAAC,UAAQ;AAC7B,kBAAQ,QAAoC,oCAAQ,SAAM,MAChE;AAAG;AACC,aAAoB,sBAChB,KAAQ,QAAyC,yCAAK,KAAoC;AAC9F,aAAqB,qBAAK,KAAW,WAC3C;AAAC;AAED,qCAAO,UAAP;AAAA,oBAWC;AAVK,aAAQ,QAAkC,kCAAQ,SAAM,KAAqB;AAC7E,aAAQ,QAAkC,kCAAO,QAAM,KAAoB;AAC3E,aAAQ,QAAkC,kCAAQ,SAAM,KAAqB;AAC/D,2BAAQ,QAAC,UAAQ;AAC7B,kBAAQ,QAAkC,kCAAQ,SAAM,MAC9D;AAAG;AACe,2BAAQ,QAAC,UAAQ;AAC7B,kBAAQ,QAAsC,sCAAQ,SAAM,MAClE;AAAG;AACC,aAAQ,QAA2C,2CAAK,KAC9D;AAAC;AAIE;;;AACH,qCAA0B,6BAA1B;AACE,YAAiB,cAAO,KAAQ,QAAkB;AAClD,YAAe,eAAe,YAAS,UAAE;AAChC;AACR;AACG,aAAmB,qBACzB;AAAC;AAIE;;;AACH,qCAA+B,kCAA/B,UAAwD;AAAxD,oBAaC;AAZe,uBAAK,KAAC,UAAc;AAChC,gBAAI,YAAyB,0BAAQ,QAAe,iBAAG,CAAE,GAAE;AACrD,sBAAe,eAAO;AACtB,sBAAQ,QAAiB,iBAAK,MAAkB,kBAAW;AAC/D,uBAAY;AACb;AACD,mBACF;AAAG;AAEH,YAAkB,eAAQ,QAAa,eAAG,CAAE,GAAE;AACxC,iBAAqB,qBAAK,KAAW,WAAS;AAEtD;AAAC;AAIE;;;AACH,qCAAY,eAAZ,UAA+B;AAC7B,YAAI,CAAK,KAAQ,QAAa,cAAE;AACvB;AACR;AAED,YAAa,WAAE;AACb,gBAAgB,aAAO,KAAQ,QAAgB,kBAAG,YAAO,QAAa;AAClE,iBAAQ,QAAa,aAAa;AACvC,eAAM;AACD,iBAAQ,QAAgB;AAEhC;AAAC;AAIE;;;AACH,qCAAa,gBAAb;AACM,aAAW,aAAQ;AACnB,aAAc,cAAK,KAAa;AAChC,aAAQ,QAAsB;AAClC,YAAQ,KAAQ,QAAW,YAAE;AACvB,iBAAa,aAAK,KAAc;AAChC,iBAAQ,QAAW,WAAK,KAAc;AACtC,iBAAe,eAAK,KAAc;AAClC,iBAAQ,QAAW,WAAK,KAAc;AAC3C;AACD,YAAQ,KAAY,aAAE;AAChB,iBAAY,YAAsB;AAE1C;AAAC;AAKE;;;;AACH,qCAAkB,qBAAlB,UAA+C;AAC7C,YAAQ,KAAa,gBAAQ,KAAQ,QAAa,cAAE;AAC3C;AACR;AAED,YAAa,UAAsB,IAAS;AAC5C,YAAiB,cAAY,UAAQ,QAAK,KAAK;AAC/C,YAAsB,mBAAe,YAAmB,OAAyB;AACjF,YAAiB,cAA8B,YAAQ,UAAmB,iBAAM;AAC5E,aAAQ,QAA6B,6BAC3C;AAAC;AAIE;;;AACH,qCAAW,cAAX;AACM,aAAqB;AACrB,aAAqB,qBAAK,KAAW,WAC3C;AAAC;AAKE;;;;AACH,qCAAiB,oBAAjB;AACE,YAAI,CAAK,KAAmB,oBAAE;AACxB,iBAAiB;AAEzB;AAAC;AAIE;;;AACH,qCAAe,kBAAf;AACM,aAAW,aAAS;AACpB,aAAQ,QAAwB;AACpC,YAAa,UAAO,KAAW;AAC3B,aAAe,eAAU;AACzB,aAAc,cAAK,KAAa;AACpC,YAAQ,KAAQ,QAAW,YAAE;AACvB,iBAAa,aAAK,KAAc;AAChC,iBAAQ,QAAW,WAAK,KAAc;AACtC,iBAAe,eAAK,KAAc;AAClC,iBAAQ,QAAW,WAAK,KAAc;AAC3C;AACD,YAAI,CAAK,KAAY,aAAE;AACjB,iBAAmB,qBAAS;AAEpC;AAAC;AAED,qCAAQ,WAAR;AACE,eAAW,KAAkB,kBAC/B;AAAC;AAIE;;;AACH,qCAAQ,WAAR,UAAsB;AAC2E;AAC/F,YAAQ,KAAW,eAAU,OAAE;AACzB,iBAAkB,kBAAM,QAAS;AACtC;AACG,aAAqB,qBAAM,MAAS;AACxC,YAAa,UAAO,KAAW;AAC3B,aAAe,eAAU;AAC7B,YAAQ,KAAQ,QAAW,YAAE;AACvB,iBAAa,aAAK,KAAc;AAChC,iBAAQ,QAAW,WAAK,KAAc;AACtC,iBAAe,eAAK,KAAc;AAClC,iBAAQ,QAAW,WAAK,KAAc;AAE9C;AAAC;AAIE;;;AACH,qCAAO,UAAP;AACE,eAAW,KACN,uBAAK,KAAwB,wBAAK,KACzC;AAAC;AAIE;;;AACH,qCAAQ,WAAR,UAAyB;AACnB,aAAS,WAAW;AACpB,aAAe,eAAU;AAE7B,YAAiB,cAAG,CAAQ,WAAI,CAAK,KAAW,cAAI,CAAC,CAAK,KAAY;AACtE,YAAQ,KAAQ,QAAW,YAAE;AACvB,iBAAQ,QAAW,WAAc;AAEzC;AAAC;AAKE;;;;AACH,qCAAsB,yBAAtB,UAAmD;AAC7C,aAAqB,uBAC3B;AAAC;AAED,qCAAU,aAAV;AACE,eAAW,KAAkB,kBAC/B;AAAC;AAIE;;;AACH,qCAAW,cAAX,UAA6B;AACvB,aAAkB,kBAAS,WAAY;AACvC,aAAe,eACrB;AAAC;AAIE;;;AACH,qCAAoB,uBAApB,UAAoC;AAClC,YAAQ,KAAY,aAAE;AAChB,iBAAY,YAAW,WAAU;AAEzC;AAAC;AAIE;;;AACH,qCAAuB,0BAAvB,UAAqC;AACnC,YAAQ,KAAa,cAAE;AACjB,iBAAa,aAAa,aAAQ;AAE1C;AAAC;AAIE;;;AACH,qCAAqB,wBAArB,UAAqC;AACnC,YAAQ,KAAa,cAAE;AACjB,iBAAa,aAAW,WAAU;AAE1C;AAAC;AAIE;;;AACH,qCAAwB,2BAAxB,UAAsC;AACpC,YAAQ,KAAc,eAAE;AAClB,iBAAc,cAAa,aAAQ;AAE3C;AAAC;AAIE;;;AACH,qCAAsB,yBAAtB,UAAsC;AACpC,YAAQ,KAAc,eAAE;AAClB,iBAAc,cAAW,WAAU;AAE3C;AAAC;AAIE;;;AACK,qCAAoB,uBAA5B,UAAkD;AAChD,YAAI,CAAK,KAAkB,mBAAE;AACpB;AACR;AAED,YAAe,YAAO,KAAkB,kBAAW;AACnD,YAAa,cAAK,CAAE,GAAE;AACpB,kBAAM,IAAS,MAAwF;AACxG;AAEG,aAAkB,kBAAgB,gBAAc,eACtD;AAAC;AAIE;;;AACK,qCAAW,cAAnB;AACwD;AACtD,eAAW,KAAkB,kBAAS,SAAS,YACjD;AAAC;AAIE;;;AACK,qCAAmB,sBAA3B;AACE,eAAW,KAAkB,kBAAS,SACxC;AAAC;AAIE;;;AACK,qCAAc,iBAAtB,UAAuC;AAC9B,wDAA6C;AACpD,YAAW,SAAE;AACP,iBAAQ,QAAY,YAAU;AACnC,eAAM;AACD,iBAAQ,QAAS,SAAU;AAChC;AACD,YAAQ,KAAY,aAAE;AAChB,iBAAY,YAAY,YAAU;AAE1C;AAAC;AAIE;;;AACK,qCAAa,gBAArB,UAAwC;AAC/B,wDAA6C;AACpD,YAAa,WAAE;AACT,iBAAQ,QAAS,SAAU;AAChC,eAAM;AACD,iBAAQ,QAAY,YAAU;AAEtC;AAAC;AAIE;;;AACK,qCAAc,iBAAtB,UAA0C;AAClC,wCAAuD;YAAtD,cAAQ;YAAE,aAA6C;AAC9D,YAAc,YAAE;AACV,iBAAQ,QAAS,SAAW;AAC5B,iBAAQ,QAAY,YAAU;AACnC,eAAM;AACD,iBAAQ,QAAY,YAAW;AACpC;AAED,YAAQ,KAAa,cAAE;AACjB,iBAAa,aAAY,YAAa;AAC3C;AAED,YAAQ,KAAc,eAAE;AAClB,iBAAc,cAAY,YAAa;AAE/C;AAAC;AAIE;;;AACK,qCAAc,iBAAtB,UAA0C;AACjC,+DAAoD;AAC3D,YAAc,YAAE;AACV,iBAAQ,QAAS,SAAiB;AACvC,eAAM;AACD,iBAAQ,QAAY,YAAiB;AAE7C;AAAC;AAIE;;;AACK,qCAAe,kBAAvB;AACmH;AACC;AACD;AACjH,YAAiB,cAAO,KAAU,UAAK,KAAQ,QAAmB,mBAAM;AACxE,eAAkB;AACR,sBAAO;AACN,uBAAE,CAAE;AACL,sBAAO;AACX,kBAAS;AACL;AACE,0BAAO;AACV,uBACN;AAHS;AAIL,mBAET;AAXwB;AAWvB;AACH,WAAC;AAAA,EAzd2C,aAyd3C;AAzdY,iCAAsB;AA2d8E;AACjH,kBAAsC,uB;;;;;;;;;;;;;AC7enC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,uCAA8D;AAK9D;AAA4C,sCAA8C;AAA1F;mEA2BA;AAAC;AA1BQ,2BAAQ,WAAf,UAA6B;AAC3B,eAAO,IAA0B,uBACnC;AAAC;AAGD,0BAAI,kCAAsB;AADsB;aAChD;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAED,qCAAoB,uBAApB;AAAA,oBAgBC;AAfuG;AACG;AACD;AACxG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACzD,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AACzD,qBAAE,iBAAK,MAAO;AAAK,uBAAI,MAAK,KAAa,aAAK,MAAQ;AAAA;AACnD,wBAAE,oBAAK;AAAK,uBAAI,MAAK,KAAgB,gBAAM;AAAA;AAC3C,wBAAE,oBAAQ;AACd,sBAAK,KAAY,cACvB;AACA;AAT6C;AAUN;AACzC,eAAO,IAAI,aAAgC,iCAC7C;AAAC;AACH,WAAC;AAAA,EA3B2C,YA2B3C;AA3BY,iCAAsB,uB;;;;;;;;;;;;;ACThC;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACQ,4BAA0C;AACtC,gCAA8C;AACpE,UACJ;AAJiB;AAYF,qBAAU;AAN3B,IAAa;AACA,iBAAe;AACtB,UAAQ;AACC,mBAAE,MAAc,WAC7B;AAJc;AAMR,kBAAO,Q;;;;;;;;;;;;;ACdZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAgD;AAEhD;AAAsD,gDAA4C;AAyBhG,8CAA4D;eAC1D,wCAA0C,iCAAe,iBAAc,aACzE;AAAC;AA1BD,0BAAW,kCAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,kCAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAKD,0BAAW,kCAAc;AADtB;;;aACH;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACpB,0BAAE;AAAM,2BAAK;AAAA;AACd,yBAAE;AAAM,2BAAS;AAAA;AACd,4BAAE;AAAM,2BAAS;AAAA;AACjB,4BAAE;AAAM,2BAAS;AAC3B;AAPK;AAST;AAAC;;sBAAA;;AAQE;;;AACH,+CAAU,aAAV,UAA0B;AACpB,aAAQ,QAAW,WACzB;AAAC;AAIE;;;AACH,+CAAa,gBAAb,UAAmC;AACjC,YAAgB,cAAE;AACZ,iBAAQ,QAAS,SAAC,YAAU,WAAyB;AAC1D,eAAM;AACD,iBAAQ,QAAY,YAAC,YAAU,WAAyB;AAEhE;AAAC;AAIE;;;AACH,+CAAa,gBAAb,UAAmC;AACjC,YAAgB,cAAE;AACZ,iBAAQ,QAAS,SAAC,YAAU,WAA6B;AAC9D,eAAM;AACD,iBAAQ,QAAY,YAAC,YAAU,WAA6B;AAEpE;AAAC;AAIE;;;AACH,+CAAkB,qBAAlB;AACM,aAAQ,QAAW,WAAC,YAAO,QACjC;AAAC;AAIE;;;AACH,+CAAW,cAAX,UAAiC;AAC/B,YAA4B,yBAAO,KAAQ,QAAS,SAAC,YAAU,WAAyB;AACxF,YAA+B,4BAAO,KAAQ,QAAS,SAAC,YAAU,WAA6B;AAC/F,YAA+B,4BAA4B,6BAAI,CAAc;AAE7E,YAA6B,2BAAE;AACzB,iBAAQ,QAAQ,QAAC,YAAO,QAAK,MAAW;AAC7C,eAAM;AACD,iBAAQ,QAAW,WAAC,YAAO,QAAO;AACvC;AAED,YAAI,CAAuB,0BAAI,CAA0B,2BAAE;AACrD,iBAAS;AAEjB;AAAC;AAIE;;;AACK,+CAAK,QAAb;AACM,aAAQ,QAAQ,QAAC,YAAO,QAAY,aAC1C;AAAC;AACH,WAAC;AAAA,EA1FqD,aA0FrD;AA1FY,2CAAgC;AA4FoE;AACjH,kBAAgD,iC;;;;;;;;;;;;;ACnG7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA6B;AAC7B,sCAA6F;AAArF,2CAAkC;AAAE,wCAA4B,Q;;;;;;;;;;;;;ACLrE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,uCAAwD;AAIxD;AAAsC,gCAAwC;AAA9E;mEA6BA;AAAC;AA5BQ,qBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAoB,iBAC7B;AAAC;AAGD,0BAAI,4BAAsB;AADsB;aAChD;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAED,+BAAoB,uBAApB;AAAA,oBAkBC;AAjBuG;AACG;AACD;AACxG,YAAa;AACJ,qBAAE,iBAAK;AAAK,uBAAI,MAAK,KAAa,aAAM;AAAA;AACxC,qBAAE,iBAAK,MAAO;AAAK,uBAAI,MAAK,KAAa,aAAK,MAAQ;AAAA;AACnD,wBAAE,oBAAK;AAAK,uBAAI,MAAK,KAAgB,gBAAM;AAAA;AAC3C,wBAAE,oBAAQ;AACd,sBAAK,KAAY,cACvB;AAAC;AACyB,wCAAE,oCAAQ,SAAS;AAAK,uBAAI,MAAO,OAAQ,SAAU;AAAA;AACnD,0CAAE,sCAAQ,SAAS;AAAK,uBAAI,MAAS,SAAQ,SAAU;AAAA;AACnE,8BAAE;AAAM,uBAAI,MAAK,KAC7B,aAA0B,2BAAQ,QAAW,YAAI,GAAc,eAAM,KAAoB;AAC7F;AAXuC;AAYA;AACzC,eAAO,IAAI,aAA0B,2BACvC;AAAC;AACH,WAAC;AAAA,EA7BqC,YA6BrC;AA7BY,2BAAgB,iB;;;;;;;;;;;;;ACR1B;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAa;AACD,gBAAqB;AACtB,eACT;AAHc;AASR,kBAAO;AAJf,IAAgB;AACV,UACJ;AAFiB;AAIF,qBAAU,W;;;;;;;;;;;;;ACXxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAGxD,sCAAgD;AAIhD,IAAwB,qBAA2B,CAAQ,SAAa;AAExE;AAAgD,0CAAsC;AA6BpF,wCAAsD;AAAtD,oBACE,wCAAoC,2BAAe,iBAAc,aAGlE;AAPO,cAAc,iBAAuB;AAMvC,cAAoB,sBAAG,UAAI;AAAK,mBAAI,MAAkB,kBAAK;AAAC;eAClE;AAAC;AAhCD,0BAAW,4BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,4BAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAKD,0BAAW,4BAAc;AADtB;;;aACH;AAC0G;AACxG;AACS,yBAAE;AAAM,2BAAI;AAAA;AACZ,yBAAE;AAAM,2BAAS;AAAA;AACd,4BAAE;AAAM,2BAAS;AAAA;AACjB,4BAAE;AAAM,2BAAS;AAAA;AACD,4CAAE;AAAM,2BAAS;AAAA;AACf,8CAAE;AAAM,2BAAS;AAAA;AAC7B,kCAAE;AAAM,2BAAS;AACjC;AARK;AAUT;AAAC;;sBAAA;;AAWD,yCAAI,OAAJ;AAAA,oBAMC;AALK,aAAe,iBAAO,KAAQ,QAAQ,QAAa;AAErC,2BAAQ,QAAC,UAAQ;AAC7B,kBAAQ,QAA2B,2BAAQ,SAAM,MACvD;AACF;AAAC;AAED,yCAAO,UAAP;AAAA,oBAIC;AAHmB,2BAAQ,QAAC,UAAQ;AAC7B,kBAAQ,QAA6B,6BAAQ,SAAM,MACzD;AACF;AAAC;AAED,yCAAW,cAAX,UAA6B;AAC3B,YAAI,CAAK,KAAe,gBAAE;AACjB;AACR;AAED,YAAY,UAAE;AACR,iBAAQ,QAAQ,QAAW,YAAQ;AACnC,iBAAQ,QAAW,WAAS;AACjC,eAAM;AACD,iBAAQ,QAAQ,QAAW,YAAM,KAAiB;AAClD,iBAAQ,QAAQ,QAAO,QAAE,YAAO,QAAY;AAEpD;AAAC;AAED,yCAAY,eAAZ,UAA0B;AACpB,aAAQ,QAAQ,QAAa,cACnC;AAAC;AAED,yCAAU,aAAV,UAA0B;AACpB,aAAQ,QAAW,WACzB;AAAC;AAED,yCAAiB,oBAAjB,UAAiD;AAC/C,YAAgB,aAAyB,IAAI,QAAY,WAA0B,IAAQ,YAAQ;AACnG,YAAO,IAAK,SAAY,WAAc;AACjC,gBAAkB,iBADiB,CAC+B;AACtC;AAC3B,iBAAQ,QAAoB;AAEpC;AAAC;AACH,WAAC;AAAA,EA/E+C,aA+E/C;AA/EY,qCAA0B;AAiF0E;AACjH,kBAA0C,2B;;;;;;;;;;;;;AC7FvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA6B;AAC7B,sCAAiF;AAAzE,qCAA4B;AAAE,kCAAsB,Q;;;;;;;;;;;;;ACLzD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B;AAE7B,6BAA0C;AAC1C,6BAAoC;AACpC,6BAA6B,+D;;;;;;;;;;;;;ACT1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAsD;AAEtD,sCAAuE;AAEvE,sCAAgD;AAChD,uCAA+D;AAE/D,uCAA+D;AAC/D,uCAA6D;AAE7D;AAAkC,4BAAwC;AAA1E;mEAgHA;AAAC;AA/GQ,iBAAQ,WAAf,UAA6B;AAC3B,eAAO,IAAgB,aACzB;AAAC;AASD,2BAAU,aAAV,UAA2E;AAAhE;AAAA,mDAAqC;AAAK,mCAAS,UAAS,SAAI;AAAA;;AACrE,aAAS,WAAO,KAAK,KAAc,cAAC,YAAO,QAA2B;AAEf;AAC3D,YAAW,QACL,GAAM,MAAK,KAAK,KAAK,KAAiB,iBAAC,YAAO,QAAwB;AAC5E,YAAQ,KAAS,UAAE;AACZ,kBAAK,KAAK,KAAW;AAC3B;AAEG,aAAa,qBAAY,IAAC,UAAK;AACjC,gBAAY,SAAgB,cAAO;AAC7B,mBAAU,YAAQ;AACxB,mBACF;AAAG,SAJsB;AAMrB,aAAc,gBACpB;AAAC;AAED,2BAAkB,qBAAlB;AACM,aAAuB,yBACnB,KAAW,WAAsB,sBAAK,KAAK,KAAa;AAC5D,aAAoB,sBAChB,KAAW,WAAmB,mBAAK,KAAK,KAAa;AACzD,aAAoB,sBAChB,KAAW,WAAmB,mBAAK,KAAK,KAAa;AAEzD,aAAc,cAAiB,iBAAS,UAAM,KAAuC;AAEzF,YAAQ,KAAS,UAAE;AACb,iBAAS,SAAiB,iBAAQ,SAAM,KAA0C;AACvF;AAED,YAAa,UAAO,KAAK,KAAU,UAAS,SAAC,YAAU,WAAc;AACrE,YAAa,UAAO,KAAK,KAAU,UAAS,SAAC,YAAU,WAAc;AACrE,YAAI,CAAQ,WAAI,CAAQ,SAAE;AAClB,mBAAiB,iBAAS,UAAM,KAAuC;AAEjF;AAAC;AAED,2BAAO,UAAP;AACM,aAAa,aAAQ,QAAC,UAAW;AAAK,mBAAU,WAAU;AAAE;AAC5D,aAAc,cAAoB,oBAAS,UAAM,KAAuC;AAC5F,YAAQ,KAAS,UAAE;AACb,iBAAS,SAAoB,oBAAQ,SAAM,KAA0C;AAC1F;AACD,YAAa,UAAO,KAAK,KAAU,UAAS,SAAC,YAAU,WAAc;AACrE,YAAa,UAAO,KAAK,KAAU,UAAS,SAAC,YAAU,WAAc;AACrE,YAAI,CAAQ,WAAI,CAAQ,SAAE;AAClB,mBAAoB,oBAAS,UAAM,KAAuC;AACjF;AACD,yBAAa,aACf;AAAC;AAED,2BAAe,kBAAf,UAAmC;AACuB;AACpD,aAAc,cAAoB,oBAAS,UAAM,KAAuC;AAExF,aAAc,gBAAU;AAEyB;AACjD,aAAoB,sBAChB,KAAW,WAAmB,mBAAK,KAAK,KAAa;AACzD,aAAc,cAAiB,iBAAS,UAAM,KACpD;AAAC;AAED,2BAAoB,uBAApB;AAAA,oBAiCC;AAhCuG;AACG;AACD;AACxG,YAAa;AACH,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAS,SAAW;AAAA;AACxD,sBAAE,kBAAU;AAAK,uBAAI,MAAK,KAAU,UAAI,IAAW;AAAA;AAChD,yBAAE,qBAAU;AAAK,uBAAI,MAAK,KAAU,UAAO,OAAW;AAAA;AACzD,sBAAE,kBAAS,UAAO;AACtB,uBAAK,MAAqB,KAAM,MAAY,YAAS,UAAQ;AAAA;AAC/C,gCAAE;AAAM,uBAAI,MAAK,KAAa;AAAA;AACrB,yCAAE;AACzB,uBAAI,MAAK,KAAC,YAAO,QAAiB,kBAAK;AAAA;AACzB,gCAAE;AAClB,oBAAS,MAAO,MAAyB;AACzC,oBAAQ,KAAO,MAA0B;AACzC,uBAAU,IAAY,gBAAgB,YAAI,IAAc,cAAG,GAC7D;AAAC;AACkB,iCAAE;AACjB,uBAAI,MAAK,KAAiB,iBAAC,YAAO,QAAsB,sBAAO;AACnE;AAhBmC;AAiBI;AAEzC,YAA2C;AAC3C,YAAQ,KAAK,KAAU,UAAS,SAAC,YAAU,WAAa,cAAE;AAC9C,yBAAG,IAAI,aAA2B,4BAAU;AACvD,mBAAc,KAAK,KAAU,UAAS,SAAC,YAAU,WAAa,cAAE;AACrD,yBAAG,IAAI,aAA2B,4BAAU;AACvD,SAFM,MAEA;AACK,yBAAG,IAAI,aAAsB,uBAAU;AAClD;AAED,eACF;AAAC;AACH,WAAC;AAAA,EAhHiC,YAgHjC;AAhHY,uBAAY,a;;;;;;;;;;;;;ACZtB;;;;;;;;;;;;;;;;;;;;;;;;AAEH,IAAgB;AACH,iBAA0B;AACjB,0BAAmC;AAC5C,iBAA0B;AAChB,2BAAoC;AAC9B,iCAC3B;AANiB;AAqBX,qBAAU;AAblB,IAAa;AACqB,sCAAK;AACf,4BACtB;AAHc;AAaI,kBAAO;AAR3B,IAAa;AACS,0BAAiC;AACrC,sBAAoB;AACZ,8BAAqC;AAChD,mBAAoB;AACnB,oBACd;AANc;AAQa,kBAAO,Q;;;;;;;;;;;;;ACvBjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,sCAAwC;AACxC,uCAA8D;AAE9D;AAAiD,2CAAsB;AAAvE;AAAA,wEAyBC;AAtBI;;;AACK,cAAY,eAAS;eAqB/B;AAAC;AAhBI;;;;AACH,0CAAkB,qBAAlB;AACE,YAAmB,gBAAO,KAAQ,QAAsB;AAExD,YAAiB,iBAAK,GAAE;AACtB,gBAAQ,KAAa,cAAE;AACjB,qBAAQ,QAAY,YAAC,YAAU,WAAuB;AACtD,qBAAa,eAAS;AAC3B;AACF,eAAM;AACL,gBAAI,CAAK,KAAa,cAAE;AAClB,qBAAQ,QAAS,SAAC,YAAU,WAAuB;AACnD,qBAAa,eAAQ;AAC1B;AAEL;AAAC;AACH,WAAC;AAAA,EAzBgD,aAyBhD;AAzBY,sCAA2B;AA2ByE;AACjH,kBAA2C,4B;;;;;;;;;;;;;ACjCxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,uCAAwD;AAExD,sCAAyD;AAEzD;AAAgD,0CAAkC;AA+BT;AACvE,wCAAkD;eAChD,wCAAoC,2BAAe,iBAAc,aACnE;AAAC;AAjCD,0BAAW,4BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,4BAAU;aAArB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAED,0BAAW,4BAAO;aAAlB;AACE,mBAAO,YACT;AAAC;;sBAAA;;AAKD,0BAAW,4BAAc;AADtB;;;aACH;AAC0G;AACxG;AACU,0BAAE;AAAM,2BAAS;AAAA;AACd,6BAAE;AAAM,2BAAS;AAAA;AACpB,0BAAE;AAAM,2BAAK;AAAA;AACb,0BAAE;AAAM,2BAAS;AAAA;AACP,oCAAE;AAAM,2BAAC;AAAA;AACA,6CAAE;AAAM,2BAAS;AAAA;AAC1B,oCAAE;AAAM,2BAAC;AAAA;AACR,qCAAE;AAAM,2BAAC;AAC5B;AATK;AAWT;AAAC;;sBAAA;;AAOkE;AACnE,yCAAkB,qBAAlB,YAAsB,CAAC,GAAgC;AACY;AACnE,yCAAkB,qBAAlB,YAAsB,CAAC,GAAgC;AAEvD,yCAAqB,wBAArB;AACM,aAAQ,QACd;AAAC;AACH,WAAC;AAAA,EA5C+C,aA4C/C;AA5CY,qCAA0B;AA8C0E;AACjH,kBAA0C,2B;;;;;;;;;;;;;ACrDvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,6BAA4B;AAC5B,6BAA4B;AAC5B,6BAA6B;AAC7B,6BAAmC;AACnC,6BAAmC;AACnC,6BAAsC,mF;;;;;;;;;;;;;ACRnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,sCAAwC;AACxC,uCAAyD;AAEzD;AAAiD,2CAA0B;AAUF;AACvE,yCAAkD;AAAlD,oBACE,kBAAc,YACf;AAPO,cAAY,eAAS;AAErB,cAAkB,qBAAS;eAKnC;AAAC;AAXD,0BAAI,uCAAW;AADiC;aAChD;AACE,mBAAW,KACb;AAAC;;sBAAA;;AAWD,0CAAI,OAAJ;AACE,yBAAU,UAAG;AAEb,YAAQ,KAAQ,QAAsB,wBAAI,GAAE;AACtC,iBAAQ,QAAS,SAAC,YAAU,WAA8B;AAC/D;AAE+E;AAC5E,aAAmB,mBACjB,KAAQ,QAAS,SAAC,YAAU,WACpC;AAAC;AAME;;;;;AACH,0CAAkB,qBAAlB,UAAiC;AAC3B,aAAmB,qBAAG,CAAC,CAAO;AAClC,YAAQ,KAAmB,oBAAE;AACvB,iBAAa;AAClB,eAAM;AAC4D;AAC7D,iBAAqB;AAE7B;AAAC;AAED,0CAAkB,qBAAlB;AACE,eAAW,KACb;AAAC;AAKE;;;;AACH,0CAAkB,qBAAlB;AACM,aACN;AAAC;AAEO,0CAAiB,oBAAzB;AACE,YAAQ,KAAmB,oBAAE;AACpB;AACR;AACD,YAAmB,gBAAO,KAAQ,QAAsB;AAExD,YAAiB,iBAAK,GAAE;AACtB,gBAAQ,KAAa,cAAE;AACjB,qBAAe;AACpB;AACF,eAAM;AACL,gBAAI,CAAK,KAAa,cAAE;AAClB,qBAAa;AAClB;AAEL;AAAC;AAEO,0CAAW,cAAnB;AACM,aAAQ,QAAY,YAAC,YAAU,WAAwB;AACvD,aAAa,eACnB;AAAC;AAEO,0CAAS,YAAjB;AACM,aAAQ,QAAS,SAAC,YAAU,WAAwB;AACpD,aAAa,eACnB;AAAC;AACH,WAAC;AAAA,EAhFgD,aAgFhD;AAhFY,sCAA2B;AAkFyE;AACjH,kBAA2C,4B;;;;;;;;;;;;;ACzFxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGH,sCAAqC;AACrC,uCAAyD;AAEzD,IAAmB,gBAAK;AAExB;AAA4C,sCAA0B;AAyCG;AACvE,oCAAkD;AAAlD,oBACE,kBAAc,YAIf;AA5CE;;;AACK,cAAU,aAAQ;AAIvB;;;AACK,cAAgB,mBAAQ;AAI7B;;;AACK,cAAuB,0BAAK;AAIjC;;;AACK,cAAwB,2BAAS;AAItC;;;AACK,cAAiB,oBAAiB;AAcvC;;;AACK,cAAiB,oBAAiB;AAMpC,cAAoB,sBAAO,MAAQ,QAAsB;AACzD,cAAiB,mBAAO,MAAQ,QAAsB;eAC5D;AAAC;AAED,qCAAO,UAAP;AACE,yBAAa,aAAG;AACZ,aAAQ,QAAS,SAAM,OAC7B;AAAC;AAKE;;;;AACH,qCAAkB,qBAAlB;AACE,YAA2B,wBAAO,KAAI,IAAK,KAAQ,QAAqB,sBAAK;AAC7E,YAAU,OAAwB,wBAAO,KAAqB;AAC1D,aAAoB,sBAAyB;AAEoC;AACf;AACtE,YAAI,CAAK,KAAyB,0BAAE;AAC9B,iBAAwB,2BAAS;AAErC,gBAAQ,KAAwB,0BAAI,GAAE;AAChC,qBAAwB,0BAAK;AAClC,mBAAM,IAAQ,KAAI,IAAK,KAAyB,2BAAO,KAAiB,kBAAE;AACrE,qBAAwB,0BAAG,CAAK,KAAkB;AACvD;AAEG,iBAAkB;AAE1B;AAAC;AAKE;;;;AACH,qCAAkB,qBAAlB;AAAA,oBAoBC;AAnBiC;AAChC,YAAI,CAAK,KAAkB,mBAAE;AACvB,iBAAkB,+BAAc;AAC9B,sBAAkB,oBAAiB;AACnC,sBACN;AAAC,aAHkC,EAGhC,YAAO,QAAmC;AAC9C;AAEG,aAAyB,2BAAQ;AAErC,YAAQ,KAAkB,mBAAE;AACd,yBAAK,KAAoB;AACtC;AAEG,aAAkB,+BAAc;AAC9B,kBAAsB;AACtB,kBAAyB,2BAAS;AAClC,kBAAkB,oBACxB;AAAC,SAJkC,EAIhC,YAAO,QACZ;AAAC;AAIE;;;AACK,qCAAe,kBAAvB;AACE,YAA0B,uBAAG,CAAK,KAAkB;AACpD,YAA2B,wBAAO,KAAwB,0BAAK;AAC/D,YAA0B,uBAAO,KAAwB,0BAAwB;AACjF,YAAsB,mBAAwB,yBAAyB;AAEtB;AACjD,YAAoB,kBAAE;AAChB,iBAAW,aAAS;AACzB,eAAM;AAC+D;AACpE,gBAAI,CAAK,KAAW,YAAE;AAChB,qBAAW,aAAQ;AACvB,uBAAY;AACb,mBAAM,IAAQ,KAAiB,qBAAyB,sBAAE;AACrD,qBAAiB,mBAAwB;AAC7C,uBAAY;AACb;AACF;AAED,eACF;AAAC;AAIE;;;AACK,qCAAc,iBAAtB;AACE,YAAQ,KAAkB,mBAAE;AACuE;AACJ;AAC7F,gBAAU,SAAO,KAAyB;AAC1C,gBAAQ,KAAI,IAAQ,WAAQ,KAAiB,kBAAE;AACvC,yBAAG,CAAC,YAAO,QAAwB;AAC1C;AAEG,iBAAQ,QAAS,SAAM,OAAQ,SAAS;AAEhD;AAAC;AAKE;;;;AACK,qCAAuB,0BAA/B;AACE,YAAmB,gBAAO,KAAQ,QAAsB;AACxD,YAAQ,KAAiB,qBAAkB,eAAE;AACvC,iBAAW,aAAS;AAE2D;AACb;AACK;AACvE,iBAAwB,2BAAQ,KAAiB,mBAAiB;AAClE,iBAAiB,mBAAiB;AACvC;AACG,aACN;AAAC;AACH,WAAC;AAAA,EAnK2C,aAmK3C;AAnKY,iCAAsB;AAqK8E;AACjH,kBAAsC,uB","file":"material-components-web.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"mdc\"] = factory();\n\telse\n\t\troot[\"mdc\"] = factory();\n})(this, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./packages/material-components-web/index.ts\");\n","/**\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 */\n\nimport autoInit from '@material/auto-init/index';\nimport * as base from '@material/base/index';\nimport * as checkbox from '@material/checkbox/index';\nimport * as chips from '@material/chips/index';\nimport * as circularProgress from '@material/circular-progress/index';\nimport * as dataTable from '@material/data-table/index';\nimport * as dialog from '@material/dialog/index';\nimport * as dom from '@material/dom/index';\nimport * as drawer from '@material/drawer/index';\nimport * as floatingLabel from '@material/floating-label/index';\nimport * as formField from '@material/form-field/index';\nimport * as iconButton from '@material/icon-button/index';\nimport * as lineRipple from '@material/line-ripple/index';\nimport * as linearProgress from '@material/linear-progress/index';\nimport * as list from '@material/list/index';\nimport * as menuSurface from '@material/menu-surface/index';\nimport * as menu from '@material/menu/index';\nimport * as notchedOutline from '@material/notched-outline/index';\nimport * as radio from '@material/radio/index';\nimport * as ripple from '@material/ripple/index';\nimport * as select from '@material/select/index';\nimport * as slider from '@material/slider/index';\nimport * as snackbar from '@material/snackbar/index';\nimport * as switchControl from '@material/switch/index';\nimport * as tabBar from '@material/tab-bar/index';\nimport * as tabIndicator from '@material/tab-indicator/index';\nimport * as tabScroller from '@material/tab-scroller/index';\nimport * as tab from '@material/tab/index';\nimport * as textField from '@material/textfield/index';\nimport * as topAppBar from '@material/top-app-bar/index';\n\n// Register all components\nautoInit.register('MDCCheckbox', checkbox.MDCCheckbox);\nautoInit.register('MDCChip', chips.MDCChip);\nautoInit.register('MDCChipSet', chips.MDCChipSet);\nautoInit.register('MDCCircularProgress', circularProgress.MDCCircularProgress);\nautoInit.register('MDCDataTable', dataTable.MDCDataTable);\nautoInit.register('MDCDialog', dialog.MDCDialog);\nautoInit.register('MDCDrawer', drawer.MDCDrawer);\nautoInit.register('MDCFloatingLabel', floatingLabel.MDCFloatingLabel);\nautoInit.register('MDCFormField', formField.MDCFormField);\nautoInit.register('MDCIconButtonToggle', iconButton.MDCIconButtonToggle);\nautoInit.register('MDCLineRipple', lineRipple.MDCLineRipple);\nautoInit.register('MDCLinearProgress', linearProgress.MDCLinearProgress);\nautoInit.register('MDCList', list.MDCList);\nautoInit.register('MDCMenu', menu.MDCMenu);\nautoInit.register('MDCMenuSurface', menuSurface.MDCMenuSurface);\nautoInit.register('MDCNotchedOutline', notchedOutline.MDCNotchedOutline);\nautoInit.register('MDCRadio', radio.MDCRadio);\nautoInit.register('MDCRipple', ripple.MDCRipple);\nautoInit.register('MDCSelect', select.MDCSelect);\nautoInit.register('MDCSlider', slider.MDCSlider);\nautoInit.register('MDCSnackbar', snackbar.MDCSnackbar);\nautoInit.register('MDCSwitch', switchControl.MDCSwitch);\nautoInit.register('MDCTabBar', tabBar.MDCTabBar);\nautoInit.register('MDCTextField', textField.MDCTextField);\nautoInit.register('MDCTopAppBar', topAppBar.MDCTopAppBar);\n\n// Export all components.\nexport {\n autoInit,\n base,\n checkbox,\n chips,\n circularProgress,\n dataTable,\n dialog,\n dom,\n drawer,\n floatingLabel,\n formField,\n iconButton,\n lineRipple,\n linearProgress,\n list,\n menu,\n menuSurface,\n notchedOutline,\n radio,\n ripple,\n select,\n slider,\n snackbar,\n switchControl,\n tab,\n tabBar,\n tabIndicator,\n tabScroller,\n textField,\n topAppBar,\n};\n","/**\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 */\n\nimport {\n CssVendorPropertyMap, JsVendorPropertyMap,\n PrefixedCssPropertyName, PrefixedJsEventType,\n StandardCssPropertyName, StandardJsEventType,\n} from './types';\n\nconst cssPropertyNameMap: CssVendorPropertyMap = {\n animation: {\n prefixed: '-webkit-animation',\n standard: 'animation',\n },\n transform: {\n prefixed: '-webkit-transform',\n standard: 'transform',\n },\n transition: {\n prefixed: '-webkit-transition',\n standard: 'transition',\n },\n};\n\nconst jsEventTypeMap: JsVendorPropertyMap = {\n animationend: {\n cssProperty: 'animation',\n prefixed: 'webkitAnimationEnd',\n standard: 'animationend',\n },\n animationiteration: {\n cssProperty: 'animation',\n prefixed: 'webkitAnimationIteration',\n standard: 'animationiteration',\n },\n animationstart: {\n cssProperty: 'animation',\n prefixed: 'webkitAnimationStart',\n standard: 'animationstart',\n },\n transitionend: {\n cssProperty: 'transition',\n prefixed: 'webkitTransitionEnd',\n standard: 'transitionend',\n },\n};\n\nfunction isWindow(windowObj: Window): boolean {\n return Boolean(windowObj.document) && typeof windowObj.document.createElement === 'function';\n}\n\nexport function getCorrectPropertyName(windowObj: Window, cssProperty: StandardCssPropertyName):\n StandardCssPropertyName | PrefixedCssPropertyName {\n if (isWindow(windowObj) && cssProperty in cssPropertyNameMap) {\n const el = windowObj.document.createElement('div');\n const {standard, prefixed} = cssPropertyNameMap[cssProperty];\n const isStandard = standard in el.style;\n return isStandard ? standard : prefixed;\n }\n return cssProperty;\n}\n\nexport function getCorrectEventName(windowObj: Window, eventType: StandardJsEventType):\n StandardJsEventType | PrefixedJsEventType {\n if (isWindow(windowObj) && eventType in jsEventTypeMap) {\n const el = windowObj.document.createElement('div');\n const {standard, prefixed, cssProperty} = jsEventTypeMap[eventType];\n const isStandard = cssProperty in el.style;\n return isStandard ? standard : prefixed;\n }\n return eventType;\n}\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport const strings = {\n AUTO_INIT_ATTR: 'data-mdc-auto-init',\n AUTO_INIT_STATE_ATTR: 'data-mdc-auto-init-state',\n INITIALIZED_STATE: 'initialized',\n};\n","/**\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 */\n\n// tslint:disable:only-arrow-functions\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCFoundation} from '@material/base/foundation';\n\nimport {strings} from './constants';\n\nconst {AUTO_INIT_ATTR, AUTO_INIT_STATE_ATTR, INITIALIZED_STATE} = strings;\n\nexport interface MDCAttachable {\n new<F extends MDCFoundation>(root: Element, foundation?: F, ...args: Array<unknown>): MDCComponent<F>;\n\n // Static method.\n attachTo<F extends MDCFoundation>(root: Element): MDCComponent<F>;\n}\n\ninterface InternalComponentRegistry {\n [key: string]: MDCAttachable;\n}\n\nconst registry: InternalComponentRegistry = {};\n\nconst CONSOLE_WARN = console.warn.bind(console); // tslint:disable-line:no-console\n\nfunction emit<T extends object>(evtType: string, evtData: T, shouldBubble = false) {\n let evt;\n if (typeof CustomEvent === 'function') {\n evt = new CustomEvent<T>(evtType, {\n bubbles: shouldBubble,\n detail: evtData,\n });\n } else {\n evt = document.createEvent('CustomEvent');\n evt.initCustomEvent(evtType, shouldBubble, false, evtData);\n }\n\n document.dispatchEvent(evt);\n}\n\n/* istanbul ignore next: optional argument is not a branch statement */\n/**\n * Auto-initializes all MDC components on a page.\n */\nfunction mdcAutoInit(root = document) {\n const components = [];\n let nodes: Element[] = [].slice.call(root.querySelectorAll(`[${AUTO_INIT_ATTR}]`));\n nodes = nodes.filter((node) => node.getAttribute(AUTO_INIT_STATE_ATTR) !== INITIALIZED_STATE);\n\n for (const node of nodes) {\n const ctorName = node.getAttribute(AUTO_INIT_ATTR);\n if (!ctorName) {\n throw new Error('(mdc-auto-init) Constructor name must be given.');\n }\n\n const Constructor = registry[ctorName]; // tslint:disable-line:variable-name\n if (typeof Constructor !== 'function') {\n throw new Error(\n `(mdc-auto-init) Could not find constructor in registry for ${ctorName}`);\n }\n\n // TODO: Should we make an eslint rule for an attachTo() static method?\n // See https://github.com/Microsoft/TypeScript/issues/14600 for discussion of static interface support in TS\n const component = Constructor.attachTo(node);\n Object.defineProperty(node, ctorName, {\n configurable: true,\n enumerable: false,\n value: component,\n writable: false,\n });\n components.push(component);\n node.setAttribute(AUTO_INIT_STATE_ATTR, INITIALIZED_STATE);\n }\n\n emit('MDCAutoInit:End', {});\n return components;\n}\n\n// Constructor is PascalCased because it is a direct reference to a class, rather than an instance of a class.\n// tslint:disable-next-line:variable-name\nmdcAutoInit.register = function(componentName: string, Constructor: MDCAttachable, warn = CONSOLE_WARN) {\n if (typeof Constructor !== 'function') {\n throw new Error(`(mdc-auto-init) Invalid Constructor value: ${Constructor}. Expected function.`);\n }\n const registryValue = registry[componentName];\n if (registryValue) {\n warn(`(mdc-auto-init) Overriding registration for ${componentName} with ${Constructor}. Was: ${registryValue}`);\n }\n registry[componentName] = Constructor;\n};\n\nmdcAutoInit.deregister = function(componentName: string) {\n delete registry[componentName];\n};\n\n/** @nocollapse */\nmdcAutoInit.deregisterAll = function() {\n const keys = Object.keys(registry) as string[];\n keys.forEach(this.deregister, this);\n};\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default mdcAutoInit;\nexport {mdcAutoInit};\n","/**\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 */\n\nimport {MDCFoundation} from './foundation';\nimport {CustomEventListener, EventType, SpecificEventListener} from './types';\n\nexport class MDCComponent<FoundationType extends MDCFoundation> {\n static attachTo(root: Element): MDCComponent<MDCFoundation<{}>> {\n // Subclasses which extend MDCBase should provide an attachTo() method that takes a root element and\n // returns an instantiated component with its root set to that element. Also note that in the cases of\n // subclasses, an explicit foundation class will not have to be passed in; it will simply be initialized\n // from getDefaultFoundation().\n return new MDCComponent(root, new MDCFoundation({}));\n }\n\n protected foundation: FoundationType;\n\n constructor(\n public root: Element, foundation?: FoundationType, ...args: unknown[]) {\n this.initialize(...args);\n // Note that we initialize foundation here and not within the constructor's default param so that\n // this.root_ is defined and can be used within the foundation class.\n this.foundation =\n foundation === undefined ? this.getDefaultFoundation() : foundation;\n this.foundation.init();\n this.initialSyncWithDOM();\n }\n\n /* istanbul ignore next: method param only exists for typing purposes; it does not need to be unit tested */\n initialize(..._args: Array<unknown>) {\n // Subclasses can override this to do any additional setup work that would be considered part of a\n // \"constructor\". Essentially, it is a hook into the parent constructor before the foundation is\n // initialized. Any additional arguments besides root and foundation will be passed in here.\n }\n\n getDefaultFoundation(): FoundationType {\n // Subclasses must override this method to return a properly configured foundation class for the\n // component.\n throw new Error('Subclasses must override getDefaultFoundation to return a properly configured ' +\n 'foundation class');\n }\n\n initialSyncWithDOM() {\n // Subclasses should override this method if they need to perform work to synchronize with a host DOM\n // object. An example of this would be a form control wrapper that needs to synchronize its internal state\n // to some property or attribute of the host DOM. Please note: this is *not* the place to perform DOM\n // reads/writes that would cause layout / paint, as this is called synchronously from within the constructor.\n }\n\n destroy() {\n // Subclasses may implement this method to release any resources / deregister any listeners they have\n // attached. An example of this might be deregistering a resize event from the window object.\n this.foundation.destroy();\n }\n\n /**\n * Wrapper method to add an event listener to the component's root element. This is most useful when\n * listening for custom events.\n */\n listen<K extends EventType>(\n evtType: K, handler: SpecificEventListener<K>, options?: AddEventListenerOptions | boolean): void;\n listen<E extends Event>(\n evtType: string, handler: CustomEventListener<E>, options?: AddEventListenerOptions | boolean): void;\n listen(evtType: string, handler: EventListener, options?: AddEventListenerOptions | boolean) {\n this.root.addEventListener(evtType, handler, options);\n }\n\n /**\n * Wrapper method to remove an event listener to the component's root element. This is most useful when\n * unlistening for custom events.\n */\n unlisten<K extends EventType>(\n evtType: K, handler: SpecificEventListener<K>, options?: AddEventListenerOptions | boolean): void;\n unlisten<E extends Event>(\n evtType: string, handler: CustomEventListener<E>, options?: AddEventListenerOptions | boolean): void;\n unlisten(evtType: string, handler: EventListener, options?: AddEventListenerOptions | boolean) {\n this.root.removeEventListener(evtType, handler, options);\n }\n\n /**\n * Fires a cross-browser-compatible custom event from the component root of the given type, with the given data.\n */\n emit<T extends object>(evtType: string, evtData: T, shouldBubble = false) {\n let evt: CustomEvent<T>;\n if (typeof CustomEvent === 'function') {\n evt = new CustomEvent<T>(evtType, {\n bubbles: shouldBubble,\n detail: evtData,\n });\n } else {\n evt = document.createEvent('CustomEvent');\n evt.initCustomEvent(evtType, shouldBubble, false, evtData);\n }\n\n this.root.dispatchEvent(evt);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCComponent;\n","/**\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 */\n\nexport class MDCFoundation<AdapterType extends {} = {}> {\n static get cssClasses(): { [key: string]: string } {\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\n static get strings(): { [key: string]: string } {\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\n static get numbers(): { [key: string]: number } {\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\n static get defaultAdapter(): {} {\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\n constructor(protected adapter: AdapterType = {} as AdapterType) {}\n\n init() {\n // Subclasses should override this method to perform initialization routines (registering events, etc.)\n }\n\n destroy() {\n // Subclasses should override this method to perform de-initialization routines (de-registering events, etc.)\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './component';\nexport * from './foundation';\nexport * from './types';\n","/**\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 */\n\nimport {getCorrectEventName} from '@material/animation/util';\nimport {MDCComponent} from '@material/base/component';\nimport {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\n\nimport {MDCCheckboxAdapter} from './adapter';\nimport {strings} from './constants';\nimport {MDCCheckboxFoundation} from './foundation';\n\n/**\n * This type is needed for compatibility with Closure Compiler.\n */\ntype PropertyDescriptorGetter = (() => unknown) | undefined;\n\nconst CB_PROTO_PROPS = ['checked', 'indeterminate'];\n\nexport type MDCCheckboxFactory = (el: Element, foundation?: MDCCheckboxFoundation) => MDCCheckbox;\n\nexport class MDCCheckbox extends MDCComponent<MDCCheckboxFoundation> implements MDCRippleCapableSurface {\n static attachTo(root: Element) {\n return new MDCCheckbox(root);\n }\n\n get ripple(): MDCRipple {\n return this.ripple_;\n }\n\n get checked(): boolean {\n return this.nativeControl_.checked;\n }\n\n set checked(checked: boolean) {\n this.nativeControl_.checked = checked;\n }\n\n get indeterminate(): boolean {\n return this.nativeControl_.indeterminate;\n }\n\n set indeterminate(indeterminate: boolean) {\n this.nativeControl_.indeterminate = indeterminate;\n }\n\n get disabled(): boolean {\n return this.nativeControl_.disabled;\n }\n\n set disabled(disabled: boolean) {\n this.foundation.setDisabled(disabled);\n }\n\n get value(): string {\n return this.nativeControl_.value;\n }\n\n set value(value: string) {\n this.nativeControl_.value = value;\n }\n\n private readonly ripple_: MDCRipple = this.createRipple_();\n private handleChange_!: EventListener; // assigned in initialSyncWithDOM()\n private handleAnimationEnd_!: EventListener; // assigned in initialSyncWithDOM()\n\n initialize() {\n const {DATA_INDETERMINATE_ATTR} = strings;\n this.nativeControl_.indeterminate =\n this.nativeControl_.getAttribute(DATA_INDETERMINATE_ATTR) === 'true';\n this.nativeControl_.removeAttribute(DATA_INDETERMINATE_ATTR);\n }\n\n initialSyncWithDOM() {\n this.handleChange_ = () => this.foundation.handleChange();\n this.handleAnimationEnd_ = () => this.foundation.handleAnimationEnd();\n this.nativeControl_.addEventListener('change', this.handleChange_);\n this.listen(getCorrectEventName(window, 'animationend'), this.handleAnimationEnd_);\n this.installPropertyChangeHooks_();\n }\n\n destroy() {\n this.ripple_.destroy();\n this.nativeControl_.removeEventListener('change', this.handleChange_);\n this.unlisten(getCorrectEventName(window, 'animationend'), this.handleAnimationEnd_);\n this.uninstallPropertyChangeHooks_();\n super.destroy();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCCheckboxAdapter = {\n addClass: (className) => this.root.classList.add(className),\n forceLayout: () => (this.root as HTMLElement).offsetWidth,\n hasNativeControl: () => !!this.nativeControl_,\n isAttachedToDOM: () => Boolean(this.root.parentNode),\n isChecked: () => this.checked,\n isIndeterminate: () => this.indeterminate,\n removeClass: (className) => {\n this.root.classList.remove(className);\n },\n removeNativeControlAttr: (attr) => {\n this.nativeControl_.removeAttribute(attr);\n },\n setNativeControlAttr: (attr, value) => {\n this.nativeControl_.setAttribute(attr, value);\n },\n setNativeControlDisabled: (disabled) => {\n this.nativeControl_.disabled = disabled;\n },\n };\n return new MDCCheckboxFoundation(adapter);\n }\n\n private createRipple_(): MDCRipple {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCRippleAdapter = {\n ...MDCRipple.createAdapter(this),\n deregisterInteractionHandler: (evtType, handler) => this.nativeControl_.removeEventListener(\n evtType, handler, applyPassive()),\n isSurfaceActive: () => matches(this.nativeControl_, ':active'),\n isUnbounded: () => true,\n registerInteractionHandler: (evtType, handler) => this.nativeControl_.addEventListener(\n evtType, handler, applyPassive()),\n };\n return new MDCRipple(this.root, new MDCRippleFoundation(adapter));\n }\n\n private installPropertyChangeHooks_() {\n const nativeCb = this.nativeControl_;\n const cbProto = Object.getPrototypeOf(nativeCb);\n\n CB_PROTO_PROPS.forEach((controlState) => {\n const desc = Object.getOwnPropertyDescriptor(cbProto, controlState);\n // We have to check for this descriptor, since some browsers (Safari) don't support its return.\n // See: https://bugs.webkit.org/show_bug.cgi?id=49739\n if (!validDescriptor(desc)) {\n return;\n }\n\n // Type cast is needed for compatibility with Closure Compiler.\n const nativeGetter = (desc as {get: PropertyDescriptorGetter}).get;\n\n const nativeCbDesc = {\n configurable: desc.configurable,\n enumerable: desc.enumerable,\n get: nativeGetter,\n set: (state: boolean) => {\n desc.set!.call(nativeCb, state);\n this.foundation.handleChange();\n },\n };\n Object.defineProperty(nativeCb, controlState, nativeCbDesc);\n });\n }\n\n private uninstallPropertyChangeHooks_() {\n const nativeCb = this.nativeControl_;\n const cbProto = Object.getPrototypeOf(nativeCb);\n\n CB_PROTO_PROPS.forEach((controlState) => {\n const desc = Object.getOwnPropertyDescriptor(cbProto, controlState);\n if (!validDescriptor(desc)) {\n return;\n }\n Object.defineProperty(nativeCb, controlState, desc);\n });\n }\n\n private get nativeControl_(): HTMLInputElement {\n const {NATIVE_CONTROL_SELECTOR} = strings;\n const el =\n this.root.querySelector<HTMLInputElement>(NATIVE_CONTROL_SELECTOR);\n if (!el) {\n throw new Error(`Checkbox component requires a ${NATIVE_CONTROL_SELECTOR} element`);\n }\n return el;\n }\n}\n\nfunction validDescriptor(inputPropDesc: PropertyDescriptor | undefined): inputPropDesc is PropertyDescriptor {\n return !!inputPropDesc && typeof inputPropDesc.set === 'function';\n}\n","/**\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 */\n\nexport const cssClasses = {\n ANIM_CHECKED_INDETERMINATE: 'mdc-checkbox--anim-checked-indeterminate',\n ANIM_CHECKED_UNCHECKED: 'mdc-checkbox--anim-checked-unchecked',\n ANIM_INDETERMINATE_CHECKED: 'mdc-checkbox--anim-indeterminate-checked',\n ANIM_INDETERMINATE_UNCHECKED: 'mdc-checkbox--anim-indeterminate-unchecked',\n ANIM_UNCHECKED_CHECKED: 'mdc-checkbox--anim-unchecked-checked',\n ANIM_UNCHECKED_INDETERMINATE: 'mdc-checkbox--anim-unchecked-indeterminate',\n BACKGROUND: 'mdc-checkbox__background',\n CHECKED: 'mdc-checkbox--checked',\n CHECKMARK: 'mdc-checkbox__checkmark',\n CHECKMARK_PATH: 'mdc-checkbox__checkmark-path',\n DISABLED: 'mdc-checkbox--disabled',\n INDETERMINATE: 'mdc-checkbox--indeterminate',\n MIXEDMARK: 'mdc-checkbox__mixedmark',\n NATIVE_CONTROL: 'mdc-checkbox__native-control',\n ROOT: 'mdc-checkbox',\n SELECTED: 'mdc-checkbox--selected',\n UPGRADED: 'mdc-checkbox--upgraded',\n};\n\nexport const strings = {\n ARIA_CHECKED_ATTR: 'aria-checked',\n ARIA_CHECKED_INDETERMINATE_VALUE: 'mixed',\n DATA_INDETERMINATE_ATTR: 'data-indeterminate',\n NATIVE_CONTROL_SELECTOR: '.mdc-checkbox__native-control',\n TRANSITION_STATE_CHECKED: 'checked',\n TRANSITION_STATE_INDETERMINATE: 'indeterminate',\n TRANSITION_STATE_INIT: 'init',\n TRANSITION_STATE_UNCHECKED: 'unchecked',\n};\n\nexport const numbers = {\n ANIM_END_LATCH_MS: 250,\n};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCCheckboxAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nexport class MDCCheckboxFoundation extends MDCFoundation<MDCCheckboxAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get numbers() {\n return numbers;\n }\n\n static get defaultAdapter(): MDCCheckboxAdapter {\n return {\n addClass: () => undefined,\n forceLayout: () => undefined,\n hasNativeControl: () => false,\n isAttachedToDOM: () => false,\n isChecked: () => false,\n isIndeterminate: () => false,\n removeClass: () => undefined,\n removeNativeControlAttr: () => undefined,\n setNativeControlAttr: () => undefined,\n setNativeControlDisabled: () => undefined,\n };\n }\n\n private currentCheckState_ = strings.TRANSITION_STATE_INIT;\n private currentAnimationClass_ = '';\n private animEndLatchTimer_ = 0;\n private enableAnimationEndHandler_ = false;\n\n constructor(adapter?: Partial<MDCCheckboxAdapter>) {\n super({...MDCCheckboxFoundation.defaultAdapter, ...adapter});\n }\n\n init() {\n this.currentCheckState_ = this.determineCheckState_();\n this.updateAriaChecked_();\n this.adapter.addClass(cssClasses.UPGRADED);\n }\n\n destroy() {\n clearTimeout(this.animEndLatchTimer_);\n }\n\n setDisabled(disabled: boolean) {\n this.adapter.setNativeControlDisabled(disabled);\n if (disabled) {\n this.adapter.addClass(cssClasses.DISABLED);\n } else {\n this.adapter.removeClass(cssClasses.DISABLED);\n }\n }\n\n /**\n * Handles the animationend event for the checkbox\n */\n handleAnimationEnd() {\n if (!this.enableAnimationEndHandler_) {\n return;\n }\n\n clearTimeout(this.animEndLatchTimer_);\n\n this.animEndLatchTimer_ = setTimeout(() => {\n this.adapter.removeClass(this.currentAnimationClass_);\n this.enableAnimationEndHandler_ = false;\n }, numbers.ANIM_END_LATCH_MS);\n }\n\n /**\n * Handles the change event for the checkbox\n */\n handleChange() {\n this.transitionCheckState_();\n }\n\n private transitionCheckState_() {\n if (!this.adapter.hasNativeControl()) {\n return;\n }\n const oldState = this.currentCheckState_;\n const newState = this.determineCheckState_();\n\n if (oldState === newState) {\n return;\n }\n\n this.updateAriaChecked_();\n\n const {TRANSITION_STATE_UNCHECKED} = strings;\n const {SELECTED} = cssClasses;\n if (newState === TRANSITION_STATE_UNCHECKED) {\n this.adapter.removeClass(SELECTED);\n } else {\n this.adapter.addClass(SELECTED);\n }\n\n // Check to ensure that there isn't a previously existing animation class, in case for example\n // the user interacted with the checkbox before the animation was finished.\n if (this.currentAnimationClass_.length > 0) {\n clearTimeout(this.animEndLatchTimer_);\n this.adapter.forceLayout();\n this.adapter.removeClass(this.currentAnimationClass_);\n }\n\n this.currentAnimationClass_ = this.getTransitionAnimationClass_(oldState, newState);\n this.currentCheckState_ = newState;\n\n // Check for parentNode so that animations are only run when the element is attached\n // to the DOM.\n if (this.adapter.isAttachedToDOM() &&\n this.currentAnimationClass_.length > 0) {\n this.adapter.addClass(this.currentAnimationClass_);\n this.enableAnimationEndHandler_ = true;\n }\n }\n\n private determineCheckState_(): string {\n const {\n TRANSITION_STATE_INDETERMINATE,\n TRANSITION_STATE_CHECKED,\n TRANSITION_STATE_UNCHECKED,\n } = strings;\n\n if (this.adapter.isIndeterminate()) {\n return TRANSITION_STATE_INDETERMINATE;\n }\n return this.adapter.isChecked() ? TRANSITION_STATE_CHECKED :\n TRANSITION_STATE_UNCHECKED;\n }\n\n private getTransitionAnimationClass_(oldState: string, newState: string): string {\n const {\n TRANSITION_STATE_INIT,\n TRANSITION_STATE_CHECKED,\n TRANSITION_STATE_UNCHECKED,\n } = strings;\n\n const {\n ANIM_UNCHECKED_CHECKED,\n ANIM_UNCHECKED_INDETERMINATE,\n ANIM_CHECKED_UNCHECKED,\n ANIM_CHECKED_INDETERMINATE,\n ANIM_INDETERMINATE_CHECKED,\n ANIM_INDETERMINATE_UNCHECKED,\n } = MDCCheckboxFoundation.cssClasses;\n\n switch (oldState) {\n case TRANSITION_STATE_INIT:\n if (newState === TRANSITION_STATE_UNCHECKED) {\n return '';\n }\n return newState === TRANSITION_STATE_CHECKED ? ANIM_INDETERMINATE_CHECKED : ANIM_INDETERMINATE_UNCHECKED;\n case TRANSITION_STATE_UNCHECKED:\n return newState === TRANSITION_STATE_CHECKED ? ANIM_UNCHECKED_CHECKED : ANIM_UNCHECKED_INDETERMINATE;\n case TRANSITION_STATE_CHECKED:\n return newState === TRANSITION_STATE_UNCHECKED ? ANIM_CHECKED_UNCHECKED : ANIM_CHECKED_INDETERMINATE;\n default: // TRANSITION_STATE_INDETERMINATE\n return newState === TRANSITION_STATE_CHECKED ? ANIM_INDETERMINATE_CHECKED : ANIM_INDETERMINATE_UNCHECKED;\n }\n }\n\n private updateAriaChecked_() {\n // Ensure aria-checked is set to mixed if checkbox is in indeterminate state.\n if (this.adapter.isIndeterminate()) {\n this.adapter.setNativeControlAttr(\n strings.ARIA_CHECKED_ATTR, strings.ARIA_CHECKED_INDETERMINATE_VALUE);\n } else {\n // The on/off state does not need to keep track of aria-checked, since\n // the screenreader uses the checked property on the checkbox element.\n this.adapter.removeNativeControlAttr(strings.ARIA_CHECKED_ATTR);\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCCheckboxFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {announce} from '@material/dom/announce';\nimport {MDCChip, MDCChipFactory} from '../chip/component';\nimport {MDCChipFoundation} from '../chip/foundation';\nimport {MDCChipInteractionEvent, MDCChipNavigationEvent, MDCChipRemovalEvent,\n MDCChipSelectionEvent} from '../chip/types';\nimport {MDCChipSetAdapter} from './adapter';\nimport {MDCChipSetFoundation} from './foundation';\n\nconst {INTERACTION_EVENT, SELECTION_EVENT, REMOVAL_EVENT, NAVIGATION_EVENT} = MDCChipFoundation.strings;\nconst {CHIP_SELECTOR} = MDCChipSetFoundation.strings;\n\nlet idCounter = 0;\n\nexport class MDCChipSet extends MDCComponent<MDCChipSetFoundation> {\n static attachTo(root: Element) {\n return new MDCChipSet(root);\n }\n\n get chips(): ReadonlyArray<MDCChip> {\n return this.chips_.slice();\n }\n\n /**\n * @return An array of the IDs of all selected chips.\n */\n get selectedChipIds(): ReadonlyArray<string> {\n return this.foundation.getSelectedChipIds();\n }\n\n private chips_!: MDCChip[]; // assigned in initialize()\n private chipFactory_!: (el: Element) => MDCChip; // assigned in initialize()\n private handleChipInteraction_!: (evt: MDCChipInteractionEvent) => void; // assigned in initialSyncWithDOM()\n private handleChipSelection_!: (evt: MDCChipSelectionEvent) => void; // assigned in initialSyncWithDOM()\n private handleChipRemoval_!: (evt: MDCChipRemovalEvent) => void; // assigned in initialSyncWithDOM()\n private handleChipNavigation_!: (evt: MDCChipNavigationEvent) => void; // assigned in initialSyncWithDOM()\n\n /**\n * @param chipFactory A function which creates a new MDCChip.\n */\n initialize(chipFactory: MDCChipFactory = (el) => new MDCChip(el)) {\n this.chipFactory_ = chipFactory;\n this.chips_ = this.instantiateChips_(this.chipFactory_);\n }\n\n initialSyncWithDOM() {\n this.chips_.forEach((chip) => {\n if (chip.id && chip.selected) {\n this.foundation.select(chip.id);\n }\n });\n\n this.handleChipInteraction_ = (evt) =>\n this.foundation.handleChipInteraction(evt.detail);\n this.handleChipSelection_ = (evt) =>\n this.foundation.handleChipSelection(evt.detail);\n this.handleChipRemoval_ = (evt) =>\n this.foundation.handleChipRemoval(evt.detail);\n this.handleChipNavigation_ = (evt) =>\n this.foundation.handleChipNavigation(evt.detail);\n this.listen(INTERACTION_EVENT, this.handleChipInteraction_);\n this.listen(SELECTION_EVENT, this.handleChipSelection_);\n this.listen(REMOVAL_EVENT, this.handleChipRemoval_);\n this.listen(NAVIGATION_EVENT, this.handleChipNavigation_);\n }\n\n destroy() {\n this.chips_.forEach((chip) => {\n chip.destroy();\n });\n\n this.unlisten(INTERACTION_EVENT, this.handleChipInteraction_);\n this.unlisten(SELECTION_EVENT, this.handleChipSelection_);\n this.unlisten(REMOVAL_EVENT, this.handleChipRemoval_);\n this.unlisten(NAVIGATION_EVENT, this.handleChipNavigation_);\n\n super.destroy();\n }\n\n /**\n * Adds a new chip object to the chip set from the given chip element.\n */\n addChip(chipEl: Element) {\n chipEl.id = chipEl.id || `mdc-chip-${++idCounter}`;\n this.chips_.push(this.chipFactory_(chipEl));\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCChipSetAdapter = {\n announceMessage: (message) => {\n announce(message);\n },\n focusChipPrimaryActionAtIndex: (index) => {\n this.chips_[index].focusPrimaryAction();\n },\n focusChipTrailingActionAtIndex: (index) => {\n this.chips_[index].focusTrailingAction();\n },\n getChipListCount: () => this.chips_.length,\n getIndexOfChipById: (chipId) => {\n return this.findChipIndex_(chipId);\n },\n hasClass: (className) => this.root.classList.contains(className),\n isRTL: () => window.getComputedStyle(this.root).getPropertyValue(\n 'direction') === 'rtl',\n removeChipAtIndex: (index) => {\n if (index >= 0 && index < this.chips_.length) {\n this.chips_[index].destroy();\n this.chips_[index].remove();\n this.chips_.splice(index, 1);\n }\n },\n removeFocusFromChipAtIndex: (index) => {\n this.chips_[index].removeFocus();\n },\n selectChipAtIndex: (index, selected, shouldNotifyClients) => {\n if (index >= 0 && index < this.chips_.length) {\n this.chips_[index].setSelectedFromChipSet(selected, shouldNotifyClients);\n }\n },\n };\n return new MDCChipSetFoundation(adapter);\n }\n\n /**\n * Instantiates chip components on all of the chip set's child chip elements.\n */\n private instantiateChips_(chipFactory: MDCChipFactory): MDCChip[] {\n const chipElements: Element[] =\n [].slice.call(this.root.querySelectorAll(CHIP_SELECTOR));\n return chipElements.map((el) => {\n el.id = el.id || `mdc-chip-${++idCounter}`;\n return chipFactory(el);\n });\n }\n\n /**\n * Returns the index of the chip with the given id, or -1 if the chip does not exist.\n */\n private findChipIndex_(chipId: string): number {\n for (let i = 0; i < this.chips_.length; i++) {\n if (this.chips_[i].id === chipId) {\n return i;\n }\n }\n return -1;\n }\n}\n","/**\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 */\n\nexport const strings = {\n CHIP_SELECTOR: '.mdc-chip',\n};\n\nexport const cssClasses = {\n CHOICE: 'mdc-chip-set--choice',\n FILTER: 'mdc-chip-set--filter',\n};\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\n\nimport {Direction, EventSource, jumpChipKeys, navigationKeys, strings as chipStrings} from '../chip/constants';\nimport {MDCChipInteractionEventDetail, MDCChipNavigationEventDetail, MDCChipRemovalEventDetail, MDCChipSelectionEventDetail} from '../chip/types';\n\nimport {MDCChipSetAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCChipSetFoundation extends MDCFoundation<MDCChipSetAdapter> {\n static get strings() {\n return strings;\n }\n\n static get cssClasses() {\n return cssClasses;\n }\n\n static get defaultAdapter(): MDCChipSetAdapter {\n return {\n announceMessage: () => undefined,\n focusChipPrimaryActionAtIndex: () => undefined,\n focusChipTrailingActionAtIndex: () => undefined,\n getChipListCount: () => -1,\n getIndexOfChipById: () => -1,\n hasClass: () => false,\n isRTL: () => false,\n removeChipAtIndex: () => undefined,\n removeFocusFromChipAtIndex: () => undefined,\n selectChipAtIndex: () => undefined,\n };\n }\n\n /**\n * The ids of the selected chips in the set. Only used for choice chip set or filter chip set.\n */\n private selectedChipIds_: string[] = [];\n\n constructor(adapter?: Partial<MDCChipSetAdapter>) {\n super({...MDCChipSetFoundation.defaultAdapter, ...adapter});\n }\n\n /**\n * Returns an array of the IDs of all selected chips.\n */\n getSelectedChipIds(): ReadonlyArray<string> {\n return this.selectedChipIds_.slice();\n }\n\n /**\n * Selects the chip with the given id. Deselects all other chips if the chip set is of the choice variant.\n * Does not notify clients of the updated selection state.\n */\n select(chipId: string) {\n this.select_(chipId, false);\n }\n\n /**\n * Handles a chip interaction event\n */\n handleChipInteraction({chipId}: MDCChipInteractionEventDetail) {\n const index = this.adapter.getIndexOfChipById(chipId);\n this.removeFocusFromChipsExcept_(index);\n if (this.adapter.hasClass(cssClasses.CHOICE) ||\n this.adapter.hasClass(cssClasses.FILTER)) {\n this.toggleSelect_(chipId);\n }\n }\n\n /**\n * Handles a chip selection event, used to handle discrepancy when selection state is set directly on the Chip.\n */\n handleChipSelection({chipId, selected, shouldIgnore}:\n MDCChipSelectionEventDetail) {\n // Early exit if we should ignore the event\n if (shouldIgnore) {\n return;\n }\n\n const chipIsSelected = this.selectedChipIds_.indexOf(chipId) >= 0;\n if (selected && !chipIsSelected) {\n this.select(chipId);\n } else if (!selected && chipIsSelected) {\n this.deselect_(chipId);\n }\n }\n\n /**\n * Handles the event when a chip is removed.\n */\n handleChipRemoval({chipId, removedAnnouncement}: MDCChipRemovalEventDetail) {\n if (removedAnnouncement) {\n this.adapter.announceMessage(removedAnnouncement);\n }\n\n const index = this.adapter.getIndexOfChipById(chipId);\n this.deselectAndNotifyClients_(chipId);\n this.adapter.removeChipAtIndex(index);\n const maxIndex = this.adapter.getChipListCount() - 1;\n const nextIndex = Math.min(index, maxIndex);\n this.removeFocusFromChipsExcept_(nextIndex);\n // After removing a chip, we should focus the trailing action for the next chip.\n this.adapter.focusChipTrailingActionAtIndex(nextIndex);\n }\n\n /**\n * Handles a chip navigation event.\n */\n handleChipNavigation({chipId, key, source}: MDCChipNavigationEventDetail) {\n const maxIndex = this.adapter.getChipListCount() - 1;\n let index = this.adapter.getIndexOfChipById(chipId);\n // Early exit if the index is out of range or the key is unusable\n if (index === -1 || !navigationKeys.has(key)) {\n return;\n }\n\n const isRTL = this.adapter.isRTL();\n const isLeftKey = key === chipStrings.ARROW_LEFT_KEY ||\n key === chipStrings.IE_ARROW_LEFT_KEY;\n const isRightKey = key === chipStrings.ARROW_RIGHT_KEY ||\n key === chipStrings.IE_ARROW_RIGHT_KEY;\n const isDownKey = key === chipStrings.ARROW_DOWN_KEY ||\n key === chipStrings.IE_ARROW_DOWN_KEY;\n const shouldIncrement =\n !isRTL && isRightKey || isRTL && isLeftKey || isDownKey;\n const isHome = key === chipStrings.HOME_KEY;\n const isEnd = key === chipStrings.END_KEY;\n if (shouldIncrement) {\n index++;\n } else if (isHome) {\n index = 0;\n } else if (isEnd) {\n index = maxIndex;\n } else {\n index--;\n }\n\n // Early exit if the index is out of bounds\n if (index < 0 || index > maxIndex) {\n return;\n }\n\n this.removeFocusFromChipsExcept_(index);\n this.focusChipAction_(index, key, source);\n }\n\n private focusChipAction_(index: number, key: string, source: EventSource) {\n const shouldJumpChips = jumpChipKeys.has(key);\n if (shouldJumpChips && source === EventSource.PRIMARY) {\n return this.adapter.focusChipPrimaryActionAtIndex(index);\n }\n\n if (shouldJumpChips && source === EventSource.TRAILING) {\n return this.adapter.focusChipTrailingActionAtIndex(index);\n }\n\n const dir = this.getDirection_(key);\n if (dir === Direction.LEFT) {\n return this.adapter.focusChipTrailingActionAtIndex(index);\n }\n\n if (dir === Direction.RIGHT) {\n return this.adapter.focusChipPrimaryActionAtIndex(index);\n }\n }\n\n private getDirection_(key: string): Direction {\n const isRTL = this.adapter.isRTL();\n const isLeftKey = key === chipStrings.ARROW_LEFT_KEY ||\n key === chipStrings.IE_ARROW_LEFT_KEY;\n const isRightKey = key === chipStrings.ARROW_RIGHT_KEY ||\n key === chipStrings.IE_ARROW_RIGHT_KEY;\n if (!isRTL && isLeftKey || isRTL && isRightKey) {\n return Direction.LEFT;\n }\n\n return Direction.RIGHT;\n }\n\n /**\n * Deselects the chip with the given id and optionally notifies clients.\n */\n private deselect_(chipId: string, shouldNotifyClients = false) {\n const index = this.selectedChipIds_.indexOf(chipId);\n if (index >= 0) {\n this.selectedChipIds_.splice(index, 1);\n const chipIndex = this.adapter.getIndexOfChipById(chipId);\n this.adapter.selectChipAtIndex(\n chipIndex, /** isSelected */ false, shouldNotifyClients);\n }\n }\n\n /**\n * Deselects the chip with the given id and notifies clients.\n */\n private deselectAndNotifyClients_(chipId: string) {\n this.deselect_(chipId, true);\n }\n\n /**\n * Toggles selection of the chip with the given id.\n */\n private toggleSelect_(chipId: string) {\n if (this.selectedChipIds_.indexOf(chipId) >= 0) {\n this.deselectAndNotifyClients_(chipId);\n } else {\n this.selectAndNotifyClients_(chipId);\n }\n }\n\n private removeFocusFromChipsExcept_(index: number) {\n const chipCount = this.adapter.getChipListCount();\n for (let i = 0; i < chipCount; i++) {\n if (i !== index) {\n this.adapter.removeFocusFromChipAtIndex(i);\n }\n }\n }\n\n private selectAndNotifyClients_(chipId: string) {\n this.select_(chipId, true);\n }\n\n private select_(chipId: string, shouldNotifyClients: boolean) {\n if (this.selectedChipIds_.indexOf(chipId) >= 0) {\n return;\n }\n\n if (this.adapter.hasClass(cssClasses.CHOICE) &&\n this.selectedChipIds_.length > 0) {\n const previouslySelectedChip = this.selectedChipIds_[0];\n const previouslySelectedIndex =\n this.adapter.getIndexOfChipById(previouslySelectedChip);\n this.selectedChipIds_ = [];\n this.adapter.selectChipAtIndex(\n previouslySelectedIndex, /** isSelected */ false,\n shouldNotifyClients);\n }\n this.selectedChipIds_.push(chipId);\n const index = this.adapter.getIndexOfChipById(chipId);\n this.adapter.selectChipAtIndex(\n index, /** isSelected */ true, shouldNotifyClients);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCChipSetFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {cssClasses as chipSetCssClasses, strings as chipSetStrings} from './constants';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {CustomEventListener, SpecificEventListener} from '@material/base/types';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple, MDCRippleFactory} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\n\nimport {MDCChipTrailingAction, MDCChipTrailingActionFactory} from '../trailingaction/component';\nimport {strings as trailingActionStrings} from '../trailingaction/constants';\nimport {MDCChipTrailingActionInteractionEvent, MDCChipTrailingActionNavigationEvent} from '../trailingaction/types';\n\nimport {MDCChipAdapter} from './adapter';\nimport {strings} from './constants';\nimport {MDCChipFoundation} from './foundation';\nimport {MDCChipInteractionEventDetail, MDCChipNavigationEventDetail, MDCChipRemovalEventDetail, MDCChipSelectionEventDetail} from './types';\n\nexport type MDCChipFactory = (el: Element, foundation?: MDCChipFoundation) => MDCChip;\n\nexport class MDCChip extends MDCComponent<MDCChipFoundation> implements MDCRippleCapableSurface {\n /**\n * @return Whether the chip is selected.\n */\n get selected(): boolean {\n return this.foundation.isSelected();\n }\n\n /**\n * Sets selected state on the chip.\n */\n set selected(selected: boolean) {\n this.foundation.setSelected(selected);\n }\n\n /**\n * @return Whether a trailing icon click should trigger exit/removal of the chip.\n */\n get shouldRemoveOnTrailingIconClick(): boolean {\n return this.foundation.getShouldRemoveOnTrailingIconClick();\n }\n\n /**\n * Sets whether a trailing icon click should trigger exit/removal of the chip.\n */\n set shouldRemoveOnTrailingIconClick(shouldRemove: boolean) {\n this.foundation.setShouldRemoveOnTrailingIconClick(shouldRemove);\n }\n\n /**\n * Sets whether a clicking on the chip should focus the primary action.\n */\n set setShouldFocusPrimaryActionOnClick(shouldFocus: boolean) {\n this.foundation.setShouldFocusPrimaryActionOnClick(shouldFocus);\n }\n\n get ripple(): MDCRipple {\n return this.ripple_;\n }\n\n get id(): string {\n return this.root.id;\n }\n\n static attachTo(root: Element) {\n return new MDCChip(root);\n }\n\n private leadingIcon_!: Element | null; // assigned in initialize()\n private checkmark_!: Element | null; // assigned in initialize()\n private primaryAction_!: Element|null; // assigned in initialize()\n private trailingAction_!: MDCChipTrailingAction|\n null; // assigned in initialize()\n private ripple_!: MDCRipple; // assigned in initialize()\n\n private handleTrailingActionInteraction_!: CustomEventListener<\n MDCChipTrailingActionInteractionEvent>; // assigned in\n // initialSyncWithDOM()\n private handleTrailingActionNavigation_!: CustomEventListener<\n MDCChipTrailingActionNavigationEvent>; // assigned in\n // initialSyncWithDOM()\n private handleTransitionEnd_!: SpecificEventListener<'transitionend'>; // assigned in initialSyncWithDOM()\n private handleClick_!:\n SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n private handleKeydown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n private handleFocusIn_!:\n SpecificEventListener<'focusin'>; // assigned in initialSyncWIthDOM()\n private handleFocusOut_!:\n SpecificEventListener<'focusout'>; // assigned in initialSyncWIthDOM()\n\n initialize(\n rippleFactory:\n MDCRippleFactory = (el, foundation) => new MDCRipple(el, foundation),\n trailingActionFactory:\n MDCChipTrailingActionFactory = (el) => new MDCChipTrailingAction(el),\n ) {\n this.leadingIcon_ = this.root.querySelector(strings.LEADING_ICON_SELECTOR);\n this.checkmark_ = this.root.querySelector(strings.CHECKMARK_SELECTOR);\n this.primaryAction_ =\n this.root.querySelector(strings.PRIMARY_ACTION_SELECTOR);\n\n const trailingActionEl =\n this.root.querySelector(strings.TRAILING_ACTION_SELECTOR);\n\n if (trailingActionEl) {\n this.trailingAction_ = trailingActionFactory(trailingActionEl);\n }\n\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const rippleAdapter: MDCRippleAdapter = {\n ...MDCRipple.createAdapter(this),\n computeBoundingRect: () => this.foundation.getDimensions(),\n };\n this.ripple_ =\n rippleFactory(this.root, new MDCRippleFoundation(rippleAdapter));\n }\n\n initialSyncWithDOM() {\n // Custom events\n this.handleTrailingActionInteraction_ = () => {\n this.foundation.handleTrailingActionInteraction();\n };\n this.handleTrailingActionNavigation_ =\n (evt: MDCChipTrailingActionNavigationEvent) => {\n this.foundation.handleTrailingActionNavigation(evt);\n };\n // Native events\n this.handleClick_ = () => {\n this.foundation.handleClick();\n };\n this.handleKeydown_ = (evt: KeyboardEvent) => {\n this.foundation.handleKeydown(evt);\n };\n this.handleTransitionEnd_ = (evt: TransitionEvent) => {\n this.foundation.handleTransitionEnd(evt);\n };\n this.handleFocusIn_ = (evt: FocusEvent) => {\n this.foundation.handleFocusIn(evt);\n };\n this.handleFocusOut_ = (evt: FocusEvent) => {\n this.foundation.handleFocusOut(evt);\n };\n\n\n this.listen('transitionend', this.handleTransitionEnd_);\n this.listen('click', this.handleClick_);\n this.listen('keydown', this.handleKeydown_);\n this.listen('focusin', this.handleFocusIn_);\n this.listen('focusout', this.handleFocusOut_);\n\n if (this.trailingAction_) {\n this.listen(\n trailingActionStrings.INTERACTION_EVENT,\n this.handleTrailingActionInteraction_);\n this.listen(\n trailingActionStrings.NAVIGATION_EVENT,\n this.handleTrailingActionNavigation_);\n }\n }\n\n destroy() {\n this.ripple_.destroy();\n\n this.unlisten('transitionend', this.handleTransitionEnd_);\n this.unlisten('keydown', this.handleKeydown_);\n this.unlisten('click', this.handleClick_);\n this.unlisten('focusin', this.handleFocusIn_);\n this.unlisten('focusout', this.handleFocusOut_);\n\n if (this.trailingAction_) {\n this.unlisten(\n trailingActionStrings.INTERACTION_EVENT,\n this.handleTrailingActionInteraction_);\n this.unlisten(\n trailingActionStrings.NAVIGATION_EVENT,\n this.handleTrailingActionNavigation_);\n }\n\n super.destroy();\n }\n\n /**\n * Begins the exit animation which leads to removal of the chip.\n */\n beginExit() {\n this.foundation.beginExit();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCChipAdapter = {\n addClass: (className) => this.root.classList.add(className),\n addClassToLeadingIcon: (className) => {\n if (this.leadingIcon_) {\n this.leadingIcon_.classList.add(className);\n }\n },\n eventTargetHasClass: (target, className) =>\n target ? (target as Element).classList.contains(className) : false,\n focusPrimaryAction: () => {\n if (this.primaryAction_) {\n (this.primaryAction_ as HTMLElement).focus();\n }\n },\n focusTrailingAction: () => {\n if (this.trailingAction_) {\n this.trailingAction_.focus();\n }\n },\n getAttribute: (attr) => this.root.getAttribute(attr),\n getCheckmarkBoundingClientRect: () =>\n this.checkmark_ ? this.checkmark_.getBoundingClientRect() : null,\n getComputedStyleValue: (propertyName) =>\n window.getComputedStyle(this.root).getPropertyValue(propertyName),\n getRootBoundingClientRect: () => this.root.getBoundingClientRect(),\n hasClass: (className) => this.root.classList.contains(className),\n hasLeadingIcon: () => !!this.leadingIcon_,\n isRTL: () => window.getComputedStyle(this.root).getPropertyValue(\n 'direction') === 'rtl',\n isTrailingActionNavigable: () => {\n if (this.trailingAction_) {\n return this.trailingAction_.isNavigable();\n }\n return false;\n },\n notifyInteraction: () => this.emit<MDCChipInteractionEventDetail>(\n strings.INTERACTION_EVENT, {chipId: this.id},\n true /* shouldBubble */),\n notifyNavigation: (key, source) =>\n this.emit<MDCChipNavigationEventDetail>(\n strings.NAVIGATION_EVENT, {chipId: this.id, key, source},\n true /* shouldBubble */),\n notifyRemoval: (removedAnnouncement) => {\n this.emit<MDCChipRemovalEventDetail>(\n strings.REMOVAL_EVENT, {chipId: this.id, removedAnnouncement},\n true /* shouldBubble */);\n },\n notifySelection: (selected, shouldIgnore) =>\n this.emit<MDCChipSelectionEventDetail>(\n strings.SELECTION_EVENT,\n {chipId: this.id, selected, shouldIgnore},\n true /* shouldBubble */),\n notifyTrailingIconInteraction: () =>\n this.emit<MDCChipInteractionEventDetail>(\n strings.TRAILING_ICON_INTERACTION_EVENT, {chipId: this.id},\n true /* shouldBubble */),\n notifyEditStart: () => { /* Not Implemented. */ },\n notifyEditFinish: () => { /* Not Implemented. */ },\n removeClass: (className) => this.root.classList.remove(className),\n removeClassFromLeadingIcon: (className) => {\n if (this.leadingIcon_) {\n this.leadingIcon_.classList.remove(className);\n }\n },\n removeTrailingActionFocus: () => {\n if (this.trailingAction_) {\n this.trailingAction_.removeFocus();\n }\n },\n setPrimaryActionAttr: (attr, value) => {\n if (this.primaryAction_) {\n this.primaryAction_.setAttribute(attr, value);\n }\n },\n setStyleProperty: (propertyName, value) =>\n (this.root as HTMLElement).style.setProperty(propertyName, value),\n };\n return new MDCChipFoundation(adapter);\n }\n\n setSelectedFromChipSet(selected: boolean, shouldNotifyClients: boolean) {\n this.foundation.setSelectedFromChipSet(selected, shouldNotifyClients);\n }\n\n focusPrimaryAction() {\n this.foundation.focusPrimaryAction();\n }\n\n focusTrailingAction() {\n this.foundation.focusTrailingAction();\n }\n\n removeFocus() {\n this.foundation.removeFocus();\n }\n\n remove() {\n const parent = this.root.parentNode;\n if (parent !== null) {\n parent.removeChild(this.root);\n }\n }\n}\n","/**\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 */\n\nexport enum Direction {\n LEFT = 'left',\n RIGHT = 'right',\n}\n\nexport enum EventSource {\n PRIMARY = 'primary',\n TRAILING = 'trailing',\n NONE = 'none',\n}\n\nexport const strings = {\n ADDED_ANNOUNCEMENT_ATTRIBUTE: 'data-mdc-chip-added-announcement',\n ARIA_CHECKED: 'aria-checked',\n ARROW_DOWN_KEY: 'ArrowDown',\n ARROW_LEFT_KEY: 'ArrowLeft',\n ARROW_RIGHT_KEY: 'ArrowRight',\n ARROW_UP_KEY: 'ArrowUp',\n BACKSPACE_KEY: 'Backspace',\n CHECKMARK_SELECTOR: '.mdc-chip__checkmark',\n DELETE_KEY: 'Delete',\n END_KEY: 'End',\n ENTER_KEY: 'Enter',\n ENTRY_ANIMATION_NAME: 'mdc-chip-entry',\n HOME_KEY: 'Home',\n IE_ARROW_DOWN_KEY: 'Down',\n IE_ARROW_LEFT_KEY: 'Left',\n IE_ARROW_RIGHT_KEY: 'Right',\n IE_ARROW_UP_KEY: 'Up',\n IE_DELETE_KEY: 'Del',\n INTERACTION_EVENT: 'MDCChip:interaction',\n LEADING_ICON_SELECTOR: '.mdc-chip__icon--leading',\n NAVIGATION_EVENT: 'MDCChip:navigation',\n PRIMARY_ACTION_SELECTOR: '.mdc-chip__primary-action',\n REMOVED_ANNOUNCEMENT_ATTRIBUTE: 'data-mdc-chip-removed-announcement',\n REMOVAL_EVENT: 'MDCChip:removal',\n SELECTION_EVENT: 'MDCChip:selection',\n SPACEBAR_KEY: ' ',\n TAB_INDEX: 'tabindex',\n TRAILING_ACTION_SELECTOR: '.mdc-chip-trailing-action',\n TRAILING_ICON_INTERACTION_EVENT: 'MDCChip:trailingIconInteraction',\n TRAILING_ICON_SELECTOR: '.mdc-chip__icon--trailing',\n};\n\nexport const cssClasses = {\n CHECKMARK: 'mdc-chip__checkmark',\n CHIP_EXIT: 'mdc-chip--exit',\n DELETABLE: 'mdc-chip--deletable',\n EDITABLE: 'mdc-chip--editable',\n EDITING: 'mdc-chip--editing',\n HIDDEN_LEADING_ICON: 'mdc-chip__icon--leading-hidden',\n LEADING_ICON: 'mdc-chip__icon--leading',\n PRIMARY_ACTION: 'mdc-chip__primary-action',\n PRIMARY_ACTION_FOCUSED: 'mdc-chip--primary-action-focused',\n SELECTED: 'mdc-chip--selected',\n TEXT: 'mdc-chip__text',\n TRAILING_ACTION: 'mdc-chip__trailing-action',\n TRAILING_ICON: 'mdc-chip__icon--trailing',\n};\n\nexport const navigationKeys = new Set<string>();\n// IE11 has no support for new Set with iterable so we need to initialize this by hand\nnavigationKeys.add(strings.ARROW_LEFT_KEY);\nnavigationKeys.add(strings.ARROW_RIGHT_KEY);\nnavigationKeys.add(strings.ARROW_DOWN_KEY);\nnavigationKeys.add(strings.ARROW_UP_KEY);\nnavigationKeys.add(strings.END_KEY);\nnavigationKeys.add(strings.HOME_KEY);\nnavigationKeys.add(strings.IE_ARROW_LEFT_KEY);\nnavigationKeys.add(strings.IE_ARROW_RIGHT_KEY);\nnavigationKeys.add(strings.IE_ARROW_DOWN_KEY);\nnavigationKeys.add(strings.IE_ARROW_UP_KEY);\n\nexport const jumpChipKeys = new Set<string>();\n// IE11 has no support for new Set with iterable so we need to initialize this by hand\njumpChipKeys.add(strings.ARROW_UP_KEY);\njumpChipKeys.add(strings.ARROW_DOWN_KEY);\njumpChipKeys.add(strings.HOME_KEY);\njumpChipKeys.add(strings.END_KEY);\njumpChipKeys.add(strings.IE_ARROW_UP_KEY);\njumpChipKeys.add(strings.IE_ARROW_DOWN_KEY);\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\n\nimport {MDCChipTrailingActionNavigationEvent} from '../trailingaction/types';\n\nimport {MDCChipAdapter} from './adapter';\nimport {cssClasses, Direction, EventSource, jumpChipKeys, navigationKeys, strings} from './constants';\n\nconst emptyClientRect = {\n bottom: 0,\n height: 0,\n left: 0,\n right: 0,\n top: 0,\n width: 0,\n};\n\nenum FocusBehavior {\n SHOULD_FOCUS,\n SHOULD_NOT_FOCUS,\n}\n\nexport class MDCChipFoundation extends MDCFoundation<MDCChipAdapter> {\n static get strings() {\n return strings;\n }\n\n static get cssClasses() {\n return cssClasses;\n }\n\n static get defaultAdapter(): MDCChipAdapter {\n return {\n addClass: () => undefined,\n addClassToLeadingIcon: () => undefined,\n eventTargetHasClass: () => false,\n focusPrimaryAction: () => undefined,\n focusTrailingAction: () => undefined,\n getAttribute: () => null,\n getCheckmarkBoundingClientRect: () => emptyClientRect,\n getComputedStyleValue: () => '',\n getRootBoundingClientRect: () => emptyClientRect,\n hasClass: () => false,\n hasLeadingIcon: () => false,\n isRTL: () => false,\n isTrailingActionNavigable: () => false,\n notifyEditFinish: () => undefined,\n notifyEditStart: () => undefined,\n notifyInteraction: () => undefined,\n notifyNavigation: () => undefined,\n notifyRemoval: () => undefined,\n notifySelection: () => undefined,\n notifyTrailingIconInteraction: () => undefined,\n removeClass: () => undefined,\n removeClassFromLeadingIcon: () => undefined,\n removeTrailingActionFocus: () => undefined,\n setPrimaryActionAttr: () => undefined,\n setStyleProperty: () => undefined,\n };\n }\n\n /** Whether a trailing icon click should immediately trigger exit/removal of the chip. */\n private shouldRemoveOnTrailingIconClick_ = true;\n\n /**\n * Whether the primary action should receive focus on click. Should only be\n * set to true for clients who programmatically give focus to a different\n * element on the page when a chip is clicked (like a menu).\n */\n private shouldFocusPrimaryActionOnClick_ = true;\n\n constructor(adapter?: Partial<MDCChipAdapter>) {\n super({...MDCChipFoundation.defaultAdapter, ...adapter});\n }\n\n isSelected() {\n return this.adapter.hasClass(cssClasses.SELECTED);\n }\n\n isEditable() {\n return this.adapter.hasClass(cssClasses.EDITABLE);\n }\n\n isEditing() {\n return this.adapter.hasClass(cssClasses.EDITING);\n }\n\n setSelected(selected: boolean) {\n this.setSelected_(selected);\n this.notifySelection_(selected);\n }\n\n setSelectedFromChipSet(selected: boolean, shouldNotifyClients: boolean) {\n this.setSelected_(selected);\n if (shouldNotifyClients) {\n this.notifyIgnoredSelection_(selected);\n }\n }\n\n getShouldRemoveOnTrailingIconClick() {\n return this.shouldRemoveOnTrailingIconClick_;\n }\n\n setShouldRemoveOnTrailingIconClick(shouldRemove: boolean) {\n this.shouldRemoveOnTrailingIconClick_ = shouldRemove;\n }\n\n setShouldFocusPrimaryActionOnClick(shouldFocus: boolean) {\n this.shouldFocusPrimaryActionOnClick_ = shouldFocus;\n }\n\n getDimensions(): ClientRect {\n const getRootRect = () => this.adapter.getRootBoundingClientRect();\n const getCheckmarkRect = () =>\n this.adapter.getCheckmarkBoundingClientRect();\n\n // When a chip has a checkmark and not a leading icon, the bounding rect changes in size depending on the current\n // size of the checkmark.\n if (!this.adapter.hasLeadingIcon()) {\n const checkmarkRect = getCheckmarkRect();\n if (checkmarkRect) {\n const rootRect = getRootRect();\n // Checkmark is a square, meaning the client rect's width and height are identical once the animation completes.\n // However, the checkbox is initially hidden by setting the width to 0.\n // To account for an initial width of 0, we use the checkbox's height instead (which equals the end-state width)\n // when adding it to the root client rect's width.\n return {\n bottom: rootRect.bottom,\n height: rootRect.height,\n left: rootRect.left,\n right: rootRect.right,\n top: rootRect.top,\n width: rootRect.width + checkmarkRect.height,\n };\n }\n }\n\n return getRootRect();\n }\n\n /**\n * Begins the exit animation which leads to removal of the chip.\n */\n beginExit() {\n this.adapter.addClass(cssClasses.CHIP_EXIT);\n }\n\n handleClick() {\n this.adapter.notifyInteraction();\n this.setPrimaryActionFocusable_(this.getFocusBehavior_());\n }\n\n handleDoubleClick() {\n if (this.isEditable()) {\n this.startEditing();\n }\n }\n\n /**\n * Handles a transition end event on the root element.\n */\n handleTransitionEnd(evt: TransitionEvent) {\n // Handle transition end event on the chip when it is about to be removed.\n const shouldHandle =\n this.adapter.eventTargetHasClass(evt.target, cssClasses.CHIP_EXIT);\n const widthIsAnimating = evt.propertyName === 'width';\n const opacityIsAnimating = evt.propertyName === 'opacity';\n\n if (shouldHandle && opacityIsAnimating) {\n // See: https://css-tricks.com/using-css-transitions-auto-dimensions/#article-header-id-5\n const chipWidth = this.adapter.getComputedStyleValue('width');\n\n // On the next frame (once we get the computed width), explicitly set the chip's width\n // to its current pixel width, so we aren't transitioning out of 'auto'.\n requestAnimationFrame(() => {\n this.adapter.setStyleProperty('width', chipWidth);\n\n // To mitigate jitter, start transitioning padding and margin before width.\n this.adapter.setStyleProperty('padding', '0');\n this.adapter.setStyleProperty('margin', '0');\n\n // On the next frame (once width is explicitly set), transition width to 0.\n requestAnimationFrame(() => {\n this.adapter.setStyleProperty('width', '0');\n });\n });\n return;\n }\n\n if (shouldHandle && widthIsAnimating) {\n this.removeFocus();\n const removedAnnouncement =\n this.adapter.getAttribute(strings.REMOVED_ANNOUNCEMENT_ATTRIBUTE);\n\n this.adapter.notifyRemoval(removedAnnouncement);\n }\n\n // Handle a transition end event on the leading icon or checkmark, since the transition end event bubbles.\n if (!opacityIsAnimating) {\n return;\n }\n\n const shouldHideLeadingIcon =\n this.adapter.eventTargetHasClass(evt.target, cssClasses.LEADING_ICON) &&\n this.adapter.hasClass(cssClasses.SELECTED);\n const shouldShowLeadingIcon =\n this.adapter.eventTargetHasClass(evt.target, cssClasses.CHECKMARK) &&\n !this.adapter.hasClass(cssClasses.SELECTED);\n\n if (shouldHideLeadingIcon) {\n this.adapter.addClassToLeadingIcon(cssClasses.HIDDEN_LEADING_ICON);\n return;\n }\n\n if (shouldShowLeadingIcon) {\n this.adapter.removeClassFromLeadingIcon(cssClasses.HIDDEN_LEADING_ICON);\n return;\n }\n }\n\n handleFocusIn(evt: FocusEvent) {\n // Early exit if the event doesn't come from the primary action\n if (!this.eventFromPrimaryAction_(evt)) {\n return;\n }\n\n this.adapter.addClass(cssClasses.PRIMARY_ACTION_FOCUSED);\n }\n\n handleFocusOut(evt: FocusEvent) {\n // Early exit if the event doesn't come from the primary action\n if (!this.eventFromPrimaryAction_(evt)) {\n return;\n }\n\n if (this.isEditing()) {\n this.finishEditing();\n }\n\n this.adapter.removeClass(cssClasses.PRIMARY_ACTION_FOCUSED);\n }\n\n /**\n * Handles an interaction event on the trailing icon element. This is used to\n * prevent the ripple from activating on interaction with the trailing icon.\n */\n handleTrailingActionInteraction() {\n this.adapter.notifyTrailingIconInteraction();\n this.removeChip_();\n }\n\n /**\n * Handles a keydown event from the root element.\n */\n handleKeydown(evt: KeyboardEvent) {\n if (this.isEditing()) {\n if (this.shouldFinishEditing(evt)) {\n evt.preventDefault();\n this.finishEditing();\n }\n // When editing, the foundation should only handle key events that finish\n // the editing process.\n return;\n }\n\n if (this.isEditable()) {\n if (this.shouldStartEditing(evt)) {\n evt.preventDefault();\n this.startEditing();\n }\n }\n\n if (this.shouldNotifyInteraction_(evt)) {\n this.adapter.notifyInteraction();\n this.setPrimaryActionFocusable_(this.getFocusBehavior_());\n return;\n }\n\n if (this.isDeleteAction_(evt)) {\n evt.preventDefault();\n this.removeChip_();\n return;\n }\n\n // Early exit if the key is not usable\n if (!navigationKeys.has(evt.key)) {\n return;\n }\n\n // Prevent default behavior for movement keys which could include scrolling\n evt.preventDefault();\n this.focusNextAction_(evt.key, EventSource.PRIMARY);\n }\n\n handleTrailingActionNavigation(evt: MDCChipTrailingActionNavigationEvent) {\n return this.focusNextAction_(evt.detail.key, EventSource.TRAILING);\n }\n\n /**\n * Called by the chip set to remove focus from the chip actions.\n */\n removeFocus() {\n this.adapter.setPrimaryActionAttr(strings.TAB_INDEX, '-1');\n this.adapter.removeTrailingActionFocus();\n }\n\n /**\n * Called by the chip set to focus the primary action.\n *\n */\n focusPrimaryAction() {\n this.setPrimaryActionFocusable_(FocusBehavior.SHOULD_FOCUS);\n }\n\n /**\n * Called by the chip set to focus the trailing action (if present), otherwise\n * gives focus to the trailing action.\n */\n focusTrailingAction() {\n const trailingActionIsNavigable = this.adapter.isTrailingActionNavigable();\n if (trailingActionIsNavigable) {\n this.adapter.setPrimaryActionAttr(strings.TAB_INDEX, '-1');\n this.adapter.focusTrailingAction();\n return;\n }\n\n this.focusPrimaryAction();\n }\n\n private setPrimaryActionFocusable_(focusBehavior: FocusBehavior) {\n this.adapter.setPrimaryActionAttr(strings.TAB_INDEX, '0');\n if (focusBehavior === FocusBehavior.SHOULD_FOCUS) {\n this.adapter.focusPrimaryAction();\n }\n this.adapter.removeTrailingActionFocus();\n }\n\n private getFocusBehavior_(): FocusBehavior {\n if (this.shouldFocusPrimaryActionOnClick_) {\n return FocusBehavior.SHOULD_FOCUS;\n }\n return FocusBehavior.SHOULD_NOT_FOCUS;\n }\n\n private focusNextAction_(key: string, source: EventSource) {\n const isTrailingActionNavigable = this.adapter.isTrailingActionNavigable();\n const dir = this.getDirection_(key);\n\n // Early exit if the key should jump chips\n if (jumpChipKeys.has(key) || !isTrailingActionNavigable) {\n return this.adapter.notifyNavigation(key, source);\n }\n\n if (source === EventSource.PRIMARY && dir === Direction.RIGHT) {\n return this.focusTrailingAction();\n }\n\n if (source === EventSource.TRAILING && dir === Direction.LEFT) {\n return this.focusPrimaryAction();\n }\n\n this.adapter.notifyNavigation(key, EventSource.NONE);\n }\n\n private getDirection_(key: string): Direction {\n const isRTL = this.adapter.isRTL();\n const isLeftKey =\n key === strings.ARROW_LEFT_KEY || key === strings.IE_ARROW_LEFT_KEY;\n const isRightKey =\n key === strings.ARROW_RIGHT_KEY || key === strings.IE_ARROW_RIGHT_KEY;\n if (!isRTL && isLeftKey || isRTL && isRightKey) {\n return Direction.LEFT;\n }\n\n return Direction.RIGHT;\n }\n\n private removeChip_() {\n if (this.shouldRemoveOnTrailingIconClick_) {\n this.beginExit();\n }\n }\n\n private shouldStartEditing(evt: KeyboardEvent): boolean {\n return this.eventFromPrimaryAction_(evt) && evt.key === strings.ENTER_KEY;\n }\n\n private shouldFinishEditing(evt: KeyboardEvent): boolean {\n return evt.key === strings.ENTER_KEY;\n }\n\n private shouldNotifyInteraction_(evt: KeyboardEvent): boolean {\n return evt.key === strings.ENTER_KEY || evt.key === strings.SPACEBAR_KEY;\n }\n\n private isDeleteAction_(evt: KeyboardEvent): boolean {\n const isDeletable = this.adapter.hasClass(cssClasses.DELETABLE);\n return isDeletable &&\n (evt.key === strings.BACKSPACE_KEY || evt.key === strings.DELETE_KEY ||\n evt.key === strings.IE_DELETE_KEY);\n }\n\n private setSelected_(selected: boolean) {\n if (selected) {\n this.adapter.addClass(cssClasses.SELECTED);\n this.adapter.setPrimaryActionAttr(strings.ARIA_CHECKED, 'true');\n } else {\n this.adapter.removeClass(cssClasses.SELECTED);\n this.adapter.setPrimaryActionAttr(strings.ARIA_CHECKED, 'false');\n }\n }\n\n private notifySelection_(selected: boolean) {\n this.adapter.notifySelection(selected, false);\n }\n\n private notifyIgnoredSelection_(selected: boolean) {\n this.adapter.notifySelection(selected, true);\n }\n\n private eventFromPrimaryAction_(evt: Event) {\n return this.adapter.eventTargetHasClass(\n evt.target, cssClasses.PRIMARY_ACTION);\n }\n\n private startEditing() {\n this.adapter.addClass(cssClasses.EDITING);\n this.adapter.notifyEditStart();\n }\n\n private finishEditing() {\n this.adapter.removeClass(cssClasses.EDITING);\n this.adapter.notifyEditFinish();\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCChipFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport * from './types';\nexport {cssClasses as chipCssClasses, strings as chipStrings} from './constants';\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './trailingaction/index';\nexport * from './chip/index';\nexport * from './chip-set/index';\n","/**\n * @license\n * Copyright 2020 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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple, MDCRippleFactory} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\nimport {MDCChipTrailingActionAdapter} from './adapter';\nimport {strings} from './constants';\nimport {MDCChipTrailingActionFoundation} from './foundation';\nimport {MDCChipTrailingActionInteractionEventDetail, MDCChipTrailingActionNavigationEventDetail} from './types';\n\n/**\n * Creates a trailing action component on the given element.\n */\nexport type MDCChipTrailingActionFactory =\n (el: Element, foundation?: MDCChipTrailingActionFoundation) =>\n MDCChipTrailingAction;\n\nexport class MDCChipTrailingAction extends\n MDCComponent<MDCChipTrailingActionFoundation> implements\n MDCRippleCapableSurface {\n get ripple(): MDCRipple {\n return this.ripple_;\n }\n\n static attachTo(root: Element) {\n return new MDCChipTrailingAction(root);\n }\n\n private ripple_!: MDCRipple; // assigned in initialize()\n private handleClick_!:\n SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n private handleKeydown_!:\n SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n\n initialize(\n rippleFactory: MDCRippleFactory = (el, foundation) =>\n new MDCRipple(el, foundation)) {\n // DO NOT INLINE this variable. For backward compatibility, foundations take\n // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n // methods, we need a separate, strongly typed adapter variable.\n const rippleAdapter: MDCRippleAdapter = MDCRipple.createAdapter(this);\n this.ripple_ =\n rippleFactory(this.root, new MDCRippleFoundation(rippleAdapter));\n }\n\n initialSyncWithDOM() {\n this.handleClick_ = (evt: MouseEvent) => {\n this.foundation.handleClick(evt);\n };\n this.handleKeydown_ = (evt: KeyboardEvent) => {\n this.foundation.handleKeydown(evt);\n };\n\n this.listen('click', this.handleClick_);\n this.listen('keydown', this.handleKeydown_);\n }\n\n destroy() {\n this.ripple_.destroy();\n this.unlisten('click', this.handleClick_);\n this.unlisten('keydown', this.handleKeydown_);\n super.destroy();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take\n // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n // methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCChipTrailingActionAdapter = {\n focus: () => {\n // TODO(b/157231863): Migate MDCComponent#root to HTMLElement\n (this.root as HTMLElement).focus();\n },\n getAttribute: (attr) => this.root.getAttribute(attr),\n notifyInteraction: (trigger) =>\n this.emit<MDCChipTrailingActionInteractionEventDetail>(\n strings.INTERACTION_EVENT, {trigger}, true /* shouldBubble */),\n notifyNavigation: (key) => {\n this.emit<MDCChipTrailingActionNavigationEventDetail>(\n strings.NAVIGATION_EVENT, {key}, true /* shouldBubble */);\n },\n setAttribute: (attr, value) => {\n this.root.setAttribute(attr, value);\n },\n };\n return new MDCChipTrailingActionFoundation(adapter);\n }\n\n isNavigable() {\n return this.foundation.isNavigable();\n }\n\n focus() {\n this.foundation.focus();\n }\n\n removeFocus() {\n this.foundation.removeFocus();\n }\n}\n","/**\n * @license\n * Copyright 2020 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 */\n\nexport enum InteractionTrigger {\n UNSPECIFIED, // Default type\n CLICK,\n BACKSPACE_KEY,\n DELETE_KEY,\n SPACEBAR_KEY,\n ENTER_KEY,\n}\n\nexport const strings = {\n ARIA_HIDDEN: 'aria-hidden',\n INTERACTION_EVENT: 'MDCChipTrailingAction:interaction',\n NAVIGATION_EVENT: 'MDCChipTrailingAction:navigation',\n TAB_INDEX: 'tabindex',\n};\n","/**\n * @license\n * Copyright 2020 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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {isNavigationEvent, KEY, normalizeKey} from '@material/dom/keyboard';\n\nimport {MDCChipTrailingActionAdapter} from './adapter';\nimport {InteractionTrigger, strings} from './constants';\n\nexport class MDCChipTrailingActionFoundation extends\n MDCFoundation<MDCChipTrailingActionAdapter> {\n static get strings() {\n return strings;\n }\n\n static get defaultAdapter(): MDCChipTrailingActionAdapter {\n return {\n focus: () => undefined,\n getAttribute: () => null,\n setAttribute: () => undefined,\n notifyInteraction: () => undefined,\n notifyNavigation: () => undefined,\n };\n }\n\n constructor(adapter?: Partial<MDCChipTrailingActionAdapter>) {\n super({...MDCChipTrailingActionFoundation.defaultAdapter, ...adapter});\n }\n\n handleClick(evt: MouseEvent) {\n evt.stopPropagation();\n this.adapter.notifyInteraction(InteractionTrigger.CLICK);\n }\n\n handleKeydown(evt: KeyboardEvent) {\n evt.stopPropagation();\n const key = normalizeKey(evt);\n if (this.shouldNotifyInteractionFromKey_(key)) {\n const trigger = this.getTriggerFromKey_(key);\n this.adapter.notifyInteraction(trigger);\n return;\n }\n\n if (isNavigationEvent(evt)) {\n this.adapter.notifyNavigation(key);\n return;\n }\n }\n\n removeFocus() {\n this.adapter.setAttribute(strings.TAB_INDEX, '-1');\n }\n\n focus() {\n this.adapter.setAttribute(strings.TAB_INDEX, '0');\n this.adapter.focus();\n }\n\n isNavigable() {\n return this.adapter.getAttribute(strings.ARIA_HIDDEN) !== 'true';\n }\n\n private shouldNotifyInteractionFromKey_(key: string): boolean {\n const isFromActionKey = key === KEY.ENTER || key === KEY.SPACEBAR;\n const isFromDeleteKey = key === KEY.BACKSPACE || key === KEY.DELETE;\n\n return isFromActionKey || isFromDeleteKey;\n }\n\n private getTriggerFromKey_(key: string): InteractionTrigger {\n if (key === KEY.SPACEBAR) {\n return InteractionTrigger.SPACEBAR_KEY;\n }\n\n if (key === KEY.ENTER) {\n return InteractionTrigger.ENTER_KEY;\n }\n\n if (key === KEY.DELETE) {\n return InteractionTrigger.DELETE_KEY;\n }\n\n if (key === KEY.BACKSPACE) {\n return InteractionTrigger.BACKSPACE_KEY;\n }\n\n // Default case, should never be returned\n return InteractionTrigger.UNSPECIFIED;\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCChipTrailingActionFoundation;\n","/**\n * @license\n * Copyright 2020 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport * from './types';\nexport {strings as trailingActionStrings} from './constants';\n","/**\n * @license\n * Copyright 2020 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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCProgressIndicator} from '@material/progress-indicator/component';\nimport {MDCCircularProgressAdapter} from './adapter';\nimport {MDCCircularProgressFoundation} from './foundation';\n\nexport class MDCCircularProgress extends\n MDCComponent<MDCCircularProgressFoundation> implements\n MDCProgressIndicator {\n private determinateCircle_!: HTMLElement;\n\n initialize() {\n this.determinateCircle_ = this.root.querySelector<HTMLElement>(\n MDCCircularProgressFoundation.strings.DETERMINATE_CIRCLE_SELECTOR)!;\n }\n\n static attachTo(root: Element) {\n return new MDCCircularProgress(root);\n }\n\n /**\n * Sets whether the progress indicator is in determinate mode.\n * @param isDeterminate Whether the indicator should be determinate.\n */\n set determinate(value: boolean) {\n this.foundation.setDeterminate(value);\n }\n\n /**\n * Sets the current progress value. In indeterminate mode, this has no\n * visual effect but will be reflected if the indicator is switched to\n * determinate mode.\n * @param value The current progress value, which must be between 0 and 1.\n */\n set progress(value: number) {\n this.foundation.setProgress(value);\n }\n\n /**\n * Whether the progress indicator is hidden.\n */\n get isClosed() {\n return this.foundation.isClosed();\n }\n\n /**\n * Shows the progress indicator.\n */\n open() {\n this.foundation.open();\n }\n\n /**\n * Hides the progress indicator.\n */\n close() {\n this.foundation.close();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take\n // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n // methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCCircularProgressAdapter = {\n addClass: (className: string) => this.root.classList.add(className),\n getDeterminateCircleAttribute: (attributeName: string) =>\n this.determinateCircle_.getAttribute(attributeName),\n hasClass: (className: string) => this.root.classList.contains(className),\n removeClass: (className: string) => this.root.classList.remove(className),\n removeAttribute: (attributeName: string) =>\n this.root.removeAttribute(attributeName),\n setAttribute: (attributeName: string, value: string) =>\n this.root.setAttribute(attributeName, value),\n setDeterminateCircleAttribute: (attributeName: string, value: string) =>\n this.determinateCircle_.setAttribute(attributeName, value),\n };\n return new MDCCircularProgressFoundation(adapter);\n }\n}\n","/**\n * @license\n * Copyright 2020 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 */\n\n/**\n * CSS class names used in component.\n */\nexport const cssClasses = {\n INDETERMINATE_CLASS: 'mdc-circular-progress--indeterminate',\n CLOSED_CLASS: 'mdc-circular-progress--closed',\n};\n\n/**\n * Attributes and selectors used in component.\n */\nexport const strings = {\n DETERMINATE_CIRCLE_SELECTOR: '.mdc-circular-progress__determinate-circle',\n ARIA_VALUENOW: 'aria-valuenow',\n RADIUS: 'r',\n STROKE_DASHOFFSET: 'stroke-dashoffset',\n};\n","/**\n * @license\n * Copyright 2020 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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCProgressIndicatorFoundation} from '@material/progress-indicator/foundation';\nimport {MDCCircularProgressAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCCircularProgressFoundation extends\n MDCFoundation<MDCCircularProgressAdapter> implements\n MDCProgressIndicatorFoundation {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get defaultAdapter(): MDCCircularProgressAdapter {\n return {\n addClass: () => undefined,\n getDeterminateCircleAttribute: () => null,\n hasClass: () => false,\n removeClass: () => undefined,\n removeAttribute: () => undefined,\n setAttribute: () => undefined,\n setDeterminateCircleAttribute: () => undefined,\n };\n }\n\n private isClosed_!: boolean;\n private isDeterminate_!: boolean;\n private progress_!: number;\n private radius_!: number;\n\n constructor(adapter?: Partial<MDCCircularProgressAdapter>) {\n super({...MDCCircularProgressFoundation.defaultAdapter, ...adapter});\n }\n\n init() {\n this.isClosed_ = this.adapter.hasClass(cssClasses.CLOSED_CLASS);\n this.isDeterminate_ =\n !this.adapter.hasClass(cssClasses.INDETERMINATE_CLASS);\n this.progress_ = 0;\n\n if (this.isDeterminate_) {\n this.adapter.setAttribute(\n strings.ARIA_VALUENOW, this.progress_.toString());\n }\n\n this.radius_ =\n Number(this.adapter.getDeterminateCircleAttribute(strings.RADIUS));\n }\n\n isDeterminate() {\n return this.isDeterminate_;\n }\n\n getProgress() {\n return this.progress_;\n }\n\n /**\n * @return Returns whether the progress indicator is hidden.\n */\n isClosed() {\n return this.isClosed_;\n }\n\n /**\n * Sets whether the progress indicator is in determinate mode.\n * @param isDeterminate Whether the indicator should be determinate.\n */\n setDeterminate(isDeterminate: boolean) {\n this.isDeterminate_ = isDeterminate;\n\n if (this.isDeterminate_) {\n this.adapter.removeClass(cssClasses.INDETERMINATE_CLASS);\n this.setProgress(this.progress_);\n } else {\n this.adapter.addClass(cssClasses.INDETERMINATE_CLASS);\n this.adapter.removeAttribute(strings.ARIA_VALUENOW);\n }\n }\n\n /**\n * Sets the current progress value. In indeterminate mode, this has no\n * visual effect but will be reflected if the indicator is switched to\n * determinate mode.\n * @param value The current progress value, which must be between 0 and 1.\n */\n setProgress(value: number) {\n this.progress_ = value;\n if (this.isDeterminate_) {\n const unfilledArcLength =\n (1 - this.progress_) * (2 * Math.PI * this.radius_);\n\n this.adapter.setDeterminateCircleAttribute(\n strings.STROKE_DASHOFFSET, `${unfilledArcLength}`);\n this.adapter.setAttribute(\n strings.ARIA_VALUENOW, this.progress_.toString());\n }\n }\n\n /**\n * Shows the progress indicator.\n */\n open() {\n this.isClosed_ = false;\n this.adapter.removeClass(cssClasses.CLOSED_CLASS);\n }\n\n /**\n * Hides the progress indicator\n */\n close() {\n this.isClosed_ = true;\n this.adapter.addClass(cssClasses.CLOSED_CLASS);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCCircularProgressFoundation;\n","/**\n * @license\n * Copyright 2020 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2019 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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCCheckbox, MDCCheckboxFactory} from '@material/checkbox/component';\nimport {closest} from '@material/dom/ponyfill';\n\nimport {MDCDataTableAdapter} from './adapter';\nimport {cssClasses, dataAttributes, events, messages, selectors, SortValue} from './constants';\nimport {MDCDataTableFoundation} from './foundation';\nimport {MDCDataTableRowSelectionChangedEventDetail} from './types';\n\n/**\n * Implementation of `MDCDataTableFoundation`\n */\nexport class MDCDataTable extends MDCComponent<MDCDataTableFoundation> {\n static attachTo(root: Element): MDCDataTable {\n return new MDCDataTable(root);\n }\n\n private headerRowCheckbox!: MDCCheckbox;\n private rowCheckboxList!: MDCCheckbox[];\n private checkboxFactory!: MDCCheckboxFactory;\n private headerRow!: HTMLElement;\n private content!: HTMLElement;\n private handleHeaderRowCheckboxChange!: SpecificEventListener<'change'>;\n private handleRowCheckboxChange!: SpecificEventListener<'change'>;\n private headerRowClickListener!:\n SpecificEventListener<'click'>; // Assigned in `initialSyncWithDOM()`\n\n initialize(checkboxFactory: MDCCheckboxFactory = (el: Element) => new MDCCheckbox(el)) {\n this.checkboxFactory = checkboxFactory;\n }\n\n initialSyncWithDOM() {\n this.headerRow =\n this.root.querySelector(`.${cssClasses.HEADER_ROW}`) as HTMLElement;\n this.handleHeaderRowCheckboxChange = () =>\n this.foundation.handleHeaderRowCheckboxChange();\n this.headerRow.addEventListener(\n 'change', this.handleHeaderRowCheckboxChange);\n\n this.headerRowClickListener = (event) => {\n this.handleHeaderRowClick(event);\n };\n this.headerRow.addEventListener('click', this.headerRowClickListener);\n\n this.content =\n this.root.querySelector(`.${cssClasses.CONTENT}`) as HTMLElement;\n this.handleRowCheckboxChange = (event) =>\n this.foundation.handleRowCheckboxChange(event);\n this.content.addEventListener('change', this.handleRowCheckboxChange);\n\n this.layout();\n }\n\n /**\n * Re-initializes header row checkbox and row checkboxes when selectable rows are added or removed from table.\n */\n layout() {\n this.foundation.layout();\n }\n\n /**\n * @return Returns array of header row cell elements.\n */\n getHeaderCells(): Element[] {\n return [].slice.call(this.root.querySelectorAll(selectors.HEADER_CELL));\n }\n\n /**\n * @return Returns array of row elements.\n */\n getRows(): Element[] {\n return this.foundation.getRows();\n }\n\n /**\n * @return Returns array of selected row ids.\n */\n getSelectedRowIds(): Array<string|null> {\n return this.foundation.getSelectedRowIds();\n }\n\n /**\n * Sets selected row ids. Overwrites previously selected rows.\n * @param rowIds Array of row ids that needs to be selected.\n */\n setSelectedRowIds(rowIds: string[]) {\n this.foundation.setSelectedRowIds(rowIds);\n }\n\n destroy() {\n this.headerRow.removeEventListener(\n 'change', this.handleHeaderRowCheckboxChange);\n this.headerRow.removeEventListener('click', this.headerRowClickListener);\n this.content.removeEventListener('change', this.handleRowCheckboxChange);\n\n this.headerRowCheckbox.destroy();\n this.rowCheckboxList.forEach((checkbox) => {\n checkbox.destroy();\n });\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCDataTableAdapter = {\n addClass: (className) => {\n this.root.classList.add(className);\n },\n removeClass: (className) => {\n this.root.classList.remove(className);\n },\n getHeaderCellElements: () => this.getHeaderCells(),\n getHeaderCellCount: () => this.getHeaderCells().length,\n getAttributeByHeaderCellIndex: (index, attribute) => {\n return this.getHeaderCells()[index].getAttribute(attribute);\n },\n setAttributeByHeaderCellIndex: (index, attribute, value) => {\n this.getHeaderCells()[index].setAttribute(attribute, value);\n },\n setClassNameByHeaderCellIndex: (index, className) => {\n this.getHeaderCells()[index].classList.add(className);\n },\n removeClassNameByHeaderCellIndex: (index, className) => {\n this.getHeaderCells()[index].classList.remove(className);\n },\n notifySortAction: (data) => {\n this.emit(events.SORTED, data, /** shouldBubble */ true);\n },\n getTableBodyHeight: () => {\n const tableBody =\n this.root.querySelector<HTMLElement>(selectors.CONTENT);\n\n if (!tableBody) {\n throw new Error('MDCDataTable: Table body element not found.');\n }\n\n return `${tableBody.getBoundingClientRect().height}px`;\n },\n getTableHeaderHeight: () => {\n const tableHeader =\n this.root.querySelector<HTMLElement>(selectors.HEADER_ROW);\n\n if (!tableHeader) {\n throw new Error('MDCDataTable: Table header element not found.');\n }\n\n return `${tableHeader.getBoundingClientRect().height}px`;\n },\n setProgressIndicatorStyles: (styles) => {\n const progressIndicator =\n this.root.querySelector<HTMLElement>(selectors.PROGRESS_INDICATOR);\n\n if (!progressIndicator) {\n throw new Error(\n 'MDCDataTable: Progress indicator element not found.');\n }\n\n Object.assign(progressIndicator.style, styles);\n },\n addClassAtRowIndex: (rowIndex: number, className: string) => {\n this.getRows()[rowIndex].classList.add(className);\n },\n getRowCount: () => this.getRows().length,\n getRowElements:\n () => [].slice.call(this.root.querySelectorAll(selectors.ROW)),\n getRowIdAtIndex: (rowIndex: number) =>\n this.getRows()[rowIndex].getAttribute(dataAttributes.ROW_ID),\n getRowIndexByChildElement: (el: Element) => {\n return this.getRows().indexOf(\n (closest(el, selectors.ROW) as HTMLElement));\n },\n getSelectedRowCount: () =>\n this.root.querySelectorAll(selectors.ROW_SELECTED).length,\n isCheckboxAtRowIndexChecked: (rowIndex: number) =>\n this.rowCheckboxList[rowIndex].checked,\n isHeaderRowCheckboxChecked: () => this.headerRowCheckbox.checked,\n isRowsSelectable: () => !!this.root.querySelector(selectors.ROW_CHECKBOX),\n notifyRowSelectionChanged:\n (data: MDCDataTableRowSelectionChangedEventDetail) => {\n this.emit(\n events.ROW_SELECTION_CHANGED, {\n row: this.getRowByIndex(data.rowIndex),\n rowId: this.getRowIdByIndex(data.rowIndex),\n rowIndex: data.rowIndex,\n selected: data.selected,\n },\n /** shouldBubble */ true);\n },\n notifySelectedAll: () => {\n this.emit(events.SELECTED_ALL, {}, /** shouldBubble */ true);\n },\n notifyUnselectedAll: () => {\n this.emit(events.UNSELECTED_ALL, {}, /** shouldBubble */ true);\n },\n registerHeaderRowCheckbox: () => {\n if (this.headerRowCheckbox) {\n this.headerRowCheckbox.destroy();\n }\n\n const checkboxEl =\n (this.root.querySelector(selectors.HEADER_ROW_CHECKBOX) as\n HTMLElement);\n this.headerRowCheckbox = this.checkboxFactory(checkboxEl);\n },\n registerRowCheckboxes: () => {\n if (this.rowCheckboxList) {\n this.rowCheckboxList.forEach((checkbox) => {\n checkbox.destroy();\n });\n }\n\n this.rowCheckboxList = [];\n this.getRows().forEach((rowEl) => {\n const checkbox = this.checkboxFactory(\n (rowEl.querySelector(selectors.ROW_CHECKBOX) as HTMLElement));\n this.rowCheckboxList.push(checkbox);\n });\n },\n removeClassAtRowIndex: (rowIndex: number, className: string) => {\n this.getRows()[rowIndex].classList.remove(className);\n },\n setAttributeAtRowIndex:\n (rowIndex: number, attr: string, value: string) => {\n this.getRows()[rowIndex].setAttribute(attr, value);\n },\n setHeaderRowCheckboxChecked: (checked: boolean) => {\n this.headerRowCheckbox.checked = checked;\n },\n setHeaderRowCheckboxIndeterminate: (indeterminate: boolean) => {\n this.headerRowCheckbox.indeterminate = indeterminate;\n },\n setRowCheckboxCheckedAtIndex: (rowIndex: number, checked: boolean) => {\n this.rowCheckboxList[rowIndex].checked = checked;\n },\n setSortStatusLabelByHeaderCellIndex: (\n columnIndex: number, sortValue: SortValue) => {\n const headerCell = this.getHeaderCells()[columnIndex];\n const sortStatusLabel =\n headerCell.querySelector<HTMLElement>(selectors.SORT_STATUS_LABEL);\n\n if (!sortStatusLabel) return;\n\n sortStatusLabel.textContent =\n this.getSortStatusMessageBySortValue(sortValue);\n },\n };\n return new MDCDataTableFoundation(adapter);\n }\n\n private getRowByIndex(index: number): Element {\n return this.getRows()[index];\n }\n\n private getRowIdByIndex(index: number): string|null {\n return this.getRowByIndex(index).getAttribute(dataAttributes.ROW_ID);\n }\n\n private handleHeaderRowClick(event: Event): void {\n const headerCell =\n closest(event.target as Element, selectors.HEADER_CELL_WITH_SORT) as\n HTMLElement;\n\n if (!headerCell) {\n return;\n }\n\n const columnId = headerCell.getAttribute(dataAttributes.COLUMN_ID);\n const columnIndex = this.getHeaderCells().indexOf(headerCell);\n if (columnIndex === -1) {\n return;\n }\n\n this.foundation.handleSortAction({columnId, columnIndex, headerCell});\n }\n\n private getSortStatusMessageBySortValue(sortValue: SortValue): string {\n switch (sortValue) {\n case SortValue.ASCENDING:\n return messages.SORTED_IN_ASCENDING;\n case SortValue.DESCENDING:\n return messages.SORTED_IN_DESCENDING;\n default:\n return '';\n }\n }\n}\n","/**\n * @license\n * Copyright 2019 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 */\n\n/**\n * CSS class names used in component.\n */\nexport const cssClasses = {\n CELL: 'mdc-data-table__cell',\n CELL_NUMERIC: 'mdc-data-table__cell--numeric',\n CONTENT: 'mdc-data-table__content',\n HEADER_CELL: 'mdc-data-table__header-cell',\n HEADER_CELL_LABEL: 'mdc-data-table__header-cell-label',\n HEADER_CELL_SORTED: 'mdc-data-table__header-cell--sorted',\n HEADER_CELL_SORTED_DESCENDING:\n 'mdc-data-table__header-cell--sorted-descending',\n HEADER_CELL_WITH_SORT: 'mdc-data-table__header-cell--with-sort',\n HEADER_CELL_WRAPPER: 'mdc-data-table__header-cell-wrapper',\n HEADER_ROW: 'mdc-data-table__header-row',\n HEADER_ROW_CHECKBOX: 'mdc-data-table__header-row-checkbox',\n IN_PROGRESS: 'mdc-data-table--in-progress',\n PROGRESS_INDICATOR: 'mdc-data-table__progress-indicator',\n ROOT: 'mdc-data-table',\n ROW: 'mdc-data-table__row',\n ROW_CHECKBOX: 'mdc-data-table__row-checkbox',\n ROW_SELECTED: 'mdc-data-table__row--selected',\n SORT_ICON_BUTTON: 'mdc-data-table__sort-icon-button',\n SORT_STATUS_LABEL: 'mdc-data-table__sort-status-label',\n PAGINATION_ROWS_PER_PAGE_SELECT:\n 'mdc-data-table__pagination-rows-per-page-select',\n PAGINATION_ROWS_PER_PAGE_LABEL:\n 'mdc-data-table__pagination-rows-per-page-label',\n};\n\n/**\n * DOM attributes used in component.\n */\nexport const attributes = {\n ARIA_SELECTED: 'aria-selected',\n ARIA_SORT: 'aria-sort',\n};\n\n/**\n * List of data attributes used in component.\n */\nexport const dataAttributes = {\n COLUMN_ID: 'data-column-id',\n ROW_ID: 'data-row-id',\n};\n\n/**\n * CSS selectors used in component.\n */\nexport const selectors = {\n CONTENT: `.${cssClasses.CONTENT}`,\n HEADER_CELL: `.${cssClasses.HEADER_CELL}`,\n HEADER_CELL_WITH_SORT: `.${cssClasses.HEADER_CELL_WITH_SORT}`,\n HEADER_ROW: `.${cssClasses.HEADER_ROW}`,\n HEADER_ROW_CHECKBOX: `.${cssClasses.HEADER_ROW_CHECKBOX}`,\n PROGRESS_INDICATOR: `.${cssClasses.PROGRESS_INDICATOR}`,\n ROW: `.${cssClasses.ROW}`,\n ROW_CHECKBOX: `.${cssClasses.ROW_CHECKBOX}`,\n ROW_SELECTED: `.${cssClasses.ROW_SELECTED}`,\n SORT_ICON_BUTTON: `.${cssClasses.SORT_ICON_BUTTON}`,\n SORT_STATUS_LABEL: `.${cssClasses.SORT_STATUS_LABEL}`,\n};\n\n/**\n * Messages used in component.\n */\nexport const messages = {\n SORTED_IN_DESCENDING: 'Sorted in descending order',\n SORTED_IN_ASCENDING: 'Sorted in ascending order',\n};\n\n/**\n * Attributes and selectors used in component.\n * @deprecated Use `attributes`, `dataAttributes` and `selectors` instead.\n */\nexport const strings = {\n ARIA_SELECTED: attributes.ARIA_SELECTED,\n ARIA_SORT: attributes.ARIA_SORT,\n DATA_ROW_ID_ATTR: dataAttributes.ROW_ID,\n HEADER_ROW_CHECKBOX_SELECTOR: selectors.HEADER_ROW_CHECKBOX,\n ROW_CHECKBOX_SELECTOR: selectors.ROW_CHECKBOX,\n ROW_SELECTED_SELECTOR: selectors.ROW_SELECTED,\n ROW_SELECTOR: selectors.ROW,\n};\n\n/**\n * Sort values defined by ARIA.\n * See https://www.w3.org/WAI/PF/aria/states_and_properties#aria-sort\n */\nexport enum SortValue {\n // Items are sorted in ascending order by this column.\n ASCENDING = 'ascending',\n\n // Items are sorted in descending order by this column.\n DESCENDING = 'descending',\n\n // There is no defined sort applied to the column.\n NONE = 'none',\n\n // A sort algorithm other than ascending or descending has been applied.\n OTHER = 'other',\n}\n\n/**\n * Event names used in component.\n */\nexport const events = {\n ROW_SELECTION_CHANGED: 'MDCDataTable:rowSelectionChanged',\n SELECTED_ALL: 'MDCDataTable:selectedAll',\n UNSELECTED_ALL: 'MDCDataTable:unselectedAll',\n SORTED: 'MDCDataTable:sorted',\n};\n","/**\n * @license\n * Copyright 2019 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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\n\nimport {MDCDataTableAdapter} from './adapter';\nimport {cssClasses, SortValue, strings} from './constants';\nimport {SortActionEventData} from './types';\n\n/**\n * The Foundation of data table component containing pure business logic, any\n * logic requiring DOM manipulation are delegated to adapter methods.\n */\nexport class MDCDataTableFoundation extends MDCFoundation<MDCDataTableAdapter> {\n static get defaultAdapter(): MDCDataTableAdapter {\n return {\n addClass: () => undefined,\n addClassAtRowIndex: () => undefined,\n getAttributeByHeaderCellIndex: () => '',\n getHeaderCellCount: () => 0,\n getHeaderCellElements: () => [],\n getRowCount: () => 0,\n getRowElements: () => [],\n getRowIdAtIndex: () => '',\n getRowIndexByChildElement: () => 0,\n getSelectedRowCount: () => 0,\n getTableBodyHeight: () => '',\n getTableHeaderHeight: () => '',\n isCheckboxAtRowIndexChecked: () => false,\n isHeaderRowCheckboxChecked: () => false,\n isRowsSelectable: () => false,\n notifyRowSelectionChanged: () => undefined,\n notifySelectedAll: () => undefined,\n notifySortAction: () => undefined,\n notifyUnselectedAll: () => undefined,\n registerHeaderRowCheckbox: () => undefined,\n registerRowCheckboxes: () => undefined,\n removeClass: () => undefined,\n removeClassAtRowIndex: () => undefined,\n removeClassNameByHeaderCellIndex: () => undefined,\n setAttributeAtRowIndex: () => undefined,\n setAttributeByHeaderCellIndex: () => undefined,\n setClassNameByHeaderCellIndex: () => undefined,\n setHeaderRowCheckboxChecked: () => undefined,\n setHeaderRowCheckboxIndeterminate: () => undefined,\n setProgressIndicatorStyles: () => undefined,\n setRowCheckboxCheckedAtIndex: () => undefined,\n setSortStatusLabelByHeaderCellIndex: () => undefined,\n };\n }\n\n constructor(adapter?: Partial<MDCDataTableAdapter>) {\n super({...MDCDataTableFoundation.defaultAdapter, ...adapter});\n }\n\n /**\n * Re-initializes header row checkbox and row checkboxes when selectable rows are added or removed from table.\n * Use this if registering checkbox is synchronous.\n */\n layout() {\n if (this.adapter.isRowsSelectable()) {\n this.adapter.registerHeaderRowCheckbox();\n this.adapter.registerRowCheckboxes();\n\n this.setHeaderRowCheckboxState();\n }\n }\n\n /**\n * Re-initializes header row checkbox and row checkboxes when selectable rows are added or removed from table.\n * Use this if registering checkbox is asynchronous.\n */\n async layoutAsync(): Promise<void> {\n if (this.adapter.isRowsSelectable()) {\n await this.adapter.registerHeaderRowCheckbox();\n await this.adapter.registerRowCheckboxes();\n\n this.setHeaderRowCheckboxState();\n }\n }\n\n /**\n * @return Returns array of row elements.\n */\n getRows(): Element[] {\n return this.adapter.getRowElements();\n }\n\n /**\n * @return Array of header cell elements.\n */\n getHeaderCells(): Element[] {\n return this.adapter.getHeaderCellElements();\n }\n\n /**\n * Sets selected row ids. Overwrites previously selected rows.\n * @param rowIds Array of row ids that needs to be selected.\n */\n setSelectedRowIds(rowIds: string[]) {\n for (let rowIndex = 0; rowIndex < this.adapter.getRowCount(); rowIndex++) {\n const rowId = this.adapter.getRowIdAtIndex(rowIndex);\n\n let isSelected = false;\n if (rowId && rowIds.indexOf(rowId) >= 0) {\n isSelected = true;\n }\n\n this.adapter.setRowCheckboxCheckedAtIndex(rowIndex, isSelected);\n this.selectRowAtIndex(rowIndex, isSelected);\n }\n\n this.setHeaderRowCheckboxState();\n }\n\n /**\n * @return Returns array of all row ids.\n */\n getRowIds(): Array<string|null> {\n const rowIds = [];\n for (let rowIndex = 0; rowIndex < this.adapter.getRowCount(); rowIndex++) {\n rowIds.push(this.adapter.getRowIdAtIndex(rowIndex));\n }\n\n return rowIds;\n }\n\n /**\n * @return Returns array of selected row ids.\n */\n getSelectedRowIds(): Array<string|null> {\n const selectedRowIds: Array<string|null> = [];\n for (let rowIndex = 0; rowIndex < this.adapter.getRowCount(); rowIndex++) {\n if (this.adapter.isCheckboxAtRowIndexChecked(rowIndex)) {\n selectedRowIds.push(this.adapter.getRowIdAtIndex(rowIndex));\n }\n }\n\n return selectedRowIds;\n }\n\n /**\n * Handles header row checkbox change event.\n */\n handleHeaderRowCheckboxChange() {\n const isHeaderChecked = this.adapter.isHeaderRowCheckboxChecked();\n\n for (let rowIndex = 0; rowIndex < this.adapter.getRowCount(); rowIndex++) {\n this.adapter.setRowCheckboxCheckedAtIndex(rowIndex, isHeaderChecked);\n this.selectRowAtIndex(rowIndex, isHeaderChecked);\n }\n\n if (isHeaderChecked) {\n this.adapter.notifySelectedAll();\n } else {\n this.adapter.notifyUnselectedAll();\n }\n }\n\n /**\n * Handles change event originated from row checkboxes.\n */\n handleRowCheckboxChange(event: Event) {\n const rowIndex = this.adapter.getRowIndexByChildElement(\n event.target as HTMLInputElement);\n\n if (rowIndex === -1) {\n return;\n }\n\n const selected = this.adapter.isCheckboxAtRowIndexChecked(rowIndex);\n\n this.selectRowAtIndex(rowIndex, selected);\n this.setHeaderRowCheckboxState();\n\n const rowId = this.adapter.getRowIdAtIndex(rowIndex);\n this.adapter.notifyRowSelectionChanged({rowId, rowIndex, selected});\n }\n\n /**\n * Handles sort action on sortable header cell.\n */\n handleSortAction(eventData: SortActionEventData) {\n const {columnId, columnIndex, headerCell} = eventData;\n\n // Reset sort attributes / classes on other header cells.\n for (let index = 0; index < this.adapter.getHeaderCellCount(); index++) {\n if (index === columnIndex) {\n continue;\n }\n\n this.adapter.removeClassNameByHeaderCellIndex(\n index, cssClasses.HEADER_CELL_SORTED);\n this.adapter.removeClassNameByHeaderCellIndex(\n index, cssClasses.HEADER_CELL_SORTED_DESCENDING);\n this.adapter.setAttributeByHeaderCellIndex(\n index, strings.ARIA_SORT, SortValue.NONE);\n this.adapter.setSortStatusLabelByHeaderCellIndex(index, SortValue.NONE);\n }\n\n // Set appropriate sort attributes / classes on target header cell.\n this.adapter.setClassNameByHeaderCellIndex(\n columnIndex, cssClasses.HEADER_CELL_SORTED);\n\n const currentSortValue = this.adapter.getAttributeByHeaderCellIndex(\n columnIndex, strings.ARIA_SORT);\n let sortValue = SortValue.NONE;\n\n // Set to descending if sorted on ascending order.\n if (currentSortValue === SortValue.ASCENDING) {\n this.adapter.setClassNameByHeaderCellIndex(\n columnIndex, cssClasses.HEADER_CELL_SORTED_DESCENDING);\n this.adapter.setAttributeByHeaderCellIndex(\n columnIndex, strings.ARIA_SORT, SortValue.DESCENDING);\n sortValue = SortValue.DESCENDING;\n // Set to ascending if sorted on descending order.\n } else if (currentSortValue === SortValue.DESCENDING) {\n this.adapter.removeClassNameByHeaderCellIndex(\n columnIndex, cssClasses.HEADER_CELL_SORTED_DESCENDING);\n this.adapter.setAttributeByHeaderCellIndex(\n columnIndex, strings.ARIA_SORT, SortValue.ASCENDING);\n sortValue = SortValue.ASCENDING;\n } else {\n // Set to ascending by default when not sorted.\n this.adapter.setAttributeByHeaderCellIndex(\n columnIndex, strings.ARIA_SORT, SortValue.ASCENDING);\n sortValue = SortValue.ASCENDING;\n }\n\n this.adapter.setSortStatusLabelByHeaderCellIndex(columnIndex, sortValue);\n\n this.adapter.notifySortAction({\n columnId,\n columnIndex,\n headerCell,\n sortValue,\n });\n }\n\n /**\n * Shows progress indicator blocking only the table body content when in\n * loading state.\n */\n showProgress() {\n const height = this.adapter.getTableBodyHeight();\n const top = this.adapter.getTableHeaderHeight();\n\n this.adapter.setProgressIndicatorStyles({\n height,\n top,\n });\n this.adapter.addClass(cssClasses.IN_PROGRESS);\n }\n\n /**\n * Hides progress indicator when data table is finished loading.\n */\n hideProgress() {\n this.adapter.removeClass(cssClasses.IN_PROGRESS);\n }\n\n /**\n * Updates header row checkbox state based on number of rows selected.\n */\n private setHeaderRowCheckboxState() {\n if (this.adapter.getSelectedRowCount() === this.adapter.getRowCount()) {\n this.adapter.setHeaderRowCheckboxChecked(true);\n this.adapter.setHeaderRowCheckboxIndeterminate(false);\n } else if (this.adapter.getSelectedRowCount() === 0) {\n this.adapter.setHeaderRowCheckboxIndeterminate(false);\n this.adapter.setHeaderRowCheckboxChecked(false);\n } else {\n this.adapter.setHeaderRowCheckboxIndeterminate(true);\n this.adapter.setHeaderRowCheckboxChecked(false);\n }\n }\n\n /**\n * Sets the attributes of row element based on selection state.\n */\n private selectRowAtIndex(rowIndex: number, selected: boolean) {\n if (selected) {\n this.adapter.addClassAtRowIndex(rowIndex, cssClasses.ROW_SELECTED);\n this.adapter.setAttributeAtRowIndex(\n rowIndex, strings.ARIA_SELECTED, 'true');\n } else {\n this.adapter.removeClassAtRowIndex(rowIndex, cssClasses.ROW_SELECTED);\n this.adapter.setAttributeAtRowIndex(\n rowIndex, strings.ARIA_SELECTED, 'false');\n }\n }\n}\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport * from './constants';\nexport * from './types';\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {FocusTrap} from '@material/dom/focus-trap';\nimport {closest, matches} from '@material/dom/ponyfill';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCDialogAdapter} from './adapter';\nimport {MDCDialogFoundation} from './foundation';\nimport {MDCDialogCloseEventDetail} from './types';\nimport * as util from './util';\nimport {MDCDialogFocusTrapFactory} from './util';\n\nconst {strings} = MDCDialogFoundation;\n\nexport class MDCDialog extends MDCComponent<MDCDialogFoundation> {\n get isOpen() {\n return this.foundation.isOpen();\n }\n\n get escapeKeyAction() {\n return this.foundation.getEscapeKeyAction();\n }\n\n set escapeKeyAction(action) {\n this.foundation.setEscapeKeyAction(action);\n }\n\n get scrimClickAction() {\n return this.foundation.getScrimClickAction();\n }\n\n set scrimClickAction(action) {\n this.foundation.setScrimClickAction(action);\n }\n\n get autoStackButtons() {\n return this.foundation.getAutoStackButtons();\n }\n\n set autoStackButtons(autoStack) {\n this.foundation.setAutoStackButtons(autoStack);\n }\n\n static attachTo(root: Element) {\n return new MDCDialog(root);\n }\n\n private buttonRipples_!: MDCRipple[]; // assigned in initialize()\n private buttons_!: HTMLElement[]; // assigned in initialize()\n private container_!: HTMLElement; // assigned in initialize()\n private content_!: HTMLElement | null; // assigned in initialize()\n private defaultButton_!: HTMLElement | null; // assigned in initialize()\n\n private focusTrap_!: FocusTrap; // assigned in initialSyncWithDOM()\n private focusTrapFactory_!: MDCDialogFocusTrapFactory; // assigned in initialize()\n\n private handleClick_!: SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n private handleKeydown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n private handleDocumentKeydown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n private handleLayout_!: EventListener; // assigned in initialSyncWithDOM()\n private handleOpening_!: EventListener; // assigned in initialSyncWithDOM()\n private handleClosing_!: () => void; // assigned in initialSyncWithDOM()\n\n initialize(\n focusTrapFactory: MDCDialogFocusTrapFactory = (el, focusOptions) => new FocusTrap(el, focusOptions),\n ) {\n const container =\n this.root.querySelector<HTMLElement>(strings.CONTAINER_SELECTOR);\n if (!container) {\n throw new Error(`Dialog component requires a ${strings.CONTAINER_SELECTOR} container element`);\n }\n this.container_ = container;\n this.content_ =\n this.root.querySelector<HTMLElement>(strings.CONTENT_SELECTOR);\n this.buttons_ = [].slice.call(\n this.root.querySelectorAll<HTMLElement>(strings.BUTTON_SELECTOR));\n this.defaultButton_ = this.root.querySelector<HTMLElement>(\n `[${strings.BUTTON_DEFAULT_ATTRIBUTE}]`);\n this.focusTrapFactory_ = focusTrapFactory;\n this.buttonRipples_ = [];\n\n for (const buttonEl of this.buttons_) {\n this.buttonRipples_.push(new MDCRipple(buttonEl));\n }\n }\n\n initialSyncWithDOM() {\n this.focusTrap_ = util.createFocusTrapInstance(\n this.container_, this.focusTrapFactory_, this.getInitialFocusEl_() || undefined);\n\n this.handleClick_ = this.foundation.handleClick.bind(this.foundation);\n this.handleKeydown_ = this.foundation.handleKeydown.bind(this.foundation);\n this.handleDocumentKeydown_ =\n this.foundation.handleDocumentKeydown.bind(this.foundation);\n this.handleLayout_ = this.layout.bind(this);\n\n const LAYOUT_EVENTS = ['resize', 'orientationchange'];\n this.handleOpening_ = () => {\n LAYOUT_EVENTS.forEach((evtType) => window.addEventListener(evtType, this.handleLayout_));\n document.addEventListener('keydown', this.handleDocumentKeydown_);\n };\n this.handleClosing_ = () => {\n LAYOUT_EVENTS.forEach((evtType) => window.removeEventListener(evtType, this.handleLayout_));\n document.removeEventListener('keydown', this.handleDocumentKeydown_);\n };\n\n this.listen('click', this.handleClick_);\n this.listen('keydown', this.handleKeydown_);\n this.listen(strings.OPENING_EVENT, this.handleOpening_);\n this.listen(strings.CLOSING_EVENT, this.handleClosing_);\n }\n\n destroy() {\n this.unlisten('click', this.handleClick_);\n this.unlisten('keydown', this.handleKeydown_);\n this.unlisten(strings.OPENING_EVENT, this.handleOpening_);\n this.unlisten(strings.CLOSING_EVENT, this.handleClosing_);\n this.handleClosing_();\n\n this.buttonRipples_.forEach((ripple) => ripple.destroy());\n super.destroy();\n }\n\n layout() {\n this.foundation.layout();\n }\n\n open() {\n this.foundation.open();\n }\n\n close(action = '') {\n this.foundation.close(action);\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCDialogAdapter = {\n addBodyClass: (className) => document.body.classList.add(className),\n addClass: (className) => this.root.classList.add(className),\n areButtonsStacked: () => util.areTopsMisaligned(this.buttons_),\n clickDefaultButton: () =>\n this.defaultButton_ && this.defaultButton_.click(),\n eventTargetMatches: (target, selector) =>\n target ? matches(target as Element, selector) : false,\n getActionFromEvent: (evt: Event) => {\n if (!evt.target) {\n return '';\n }\n const element = closest(evt.target as Element, `[${strings.ACTION_ATTRIBUTE}]`);\n return element && element.getAttribute(strings.ACTION_ATTRIBUTE);\n },\n getInitialFocusEl: () => this.getInitialFocusEl_(),\n hasClass: (className) => this.root.classList.contains(className),\n isContentScrollable: () => util.isScrollable(this.content_),\n notifyClosed: (action) => this.emit<MDCDialogCloseEventDetail>(\n strings.CLOSED_EVENT, action ? {action} : {}),\n notifyClosing: (action) => this.emit<MDCDialogCloseEventDetail>(\n strings.CLOSING_EVENT, action ? {action} : {}),\n notifyOpened: () => this.emit(strings.OPENED_EVENT, {}),\n notifyOpening: () => this.emit(strings.OPENING_EVENT, {}),\n releaseFocus: () => this.focusTrap_.releaseFocus(),\n removeBodyClass: (className) => document.body.classList.remove(className),\n removeClass: (className) => this.root.classList.remove(className),\n reverseButtons: () => {\n this.buttons_.reverse();\n this.buttons_.forEach((button) => {\n button.parentElement!.appendChild(button);\n });\n },\n trapFocus: () => this.focusTrap_.trapFocus(),\n };\n return new MDCDialogFoundation(adapter);\n }\n\n private getInitialFocusEl_(): HTMLElement|null {\n return document.querySelector(`[${strings.INITIAL_FOCUS_ATTRIBUTE}]`);\n }\n}\n","/**\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 */\n\nexport const cssClasses = {\n CLOSING: 'mdc-dialog--closing',\n OPEN: 'mdc-dialog--open',\n OPENING: 'mdc-dialog--opening',\n SCROLLABLE: 'mdc-dialog--scrollable',\n SCROLL_LOCK: 'mdc-dialog-scroll-lock',\n STACKED: 'mdc-dialog--stacked',\n};\n\nexport const strings = {\n ACTION_ATTRIBUTE: 'data-mdc-dialog-action',\n BUTTON_DEFAULT_ATTRIBUTE: 'data-mdc-dialog-button-default',\n BUTTON_SELECTOR: '.mdc-dialog__button',\n CLOSED_EVENT: 'MDCDialog:closed',\n CLOSE_ACTION: 'close',\n CLOSING_EVENT: 'MDCDialog:closing',\n CONTAINER_SELECTOR: '.mdc-dialog__container',\n CONTENT_SELECTOR: '.mdc-dialog__content',\n DESTROY_ACTION: 'destroy',\n INITIAL_FOCUS_ATTRIBUTE: 'data-mdc-dialog-initial-focus',\n OPENED_EVENT: 'MDCDialog:opened',\n OPENING_EVENT: 'MDCDialog:opening',\n SCRIM_SELECTOR: '.mdc-dialog__scrim',\n SUPPRESS_DEFAULT_PRESS_SELECTOR: [\n 'textarea',\n '.mdc-menu .mdc-list-item',\n ].join(', '),\n SURFACE_SELECTOR: '.mdc-dialog__surface',\n};\n\nexport const numbers = {\n DIALOG_ANIMATION_CLOSE_TIME_MS: 75,\n DIALOG_ANIMATION_OPEN_TIME_MS: 150,\n};\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCDialogAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nexport class MDCDialogFoundation extends MDCFoundation<MDCDialogAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get numbers() {\n return numbers;\n }\n\n static get defaultAdapter(): MDCDialogAdapter {\n return {\n addBodyClass: () => undefined,\n addClass: () => undefined,\n areButtonsStacked: () => false,\n clickDefaultButton: () => undefined,\n eventTargetMatches: () => false,\n getActionFromEvent: () => '',\n getInitialFocusEl: () => null,\n hasClass: () => false,\n isContentScrollable: () => false,\n notifyClosed: () => undefined,\n notifyClosing: () => undefined,\n notifyOpened: () => undefined,\n notifyOpening: () => undefined,\n releaseFocus: () => undefined,\n removeBodyClass: () => undefined,\n removeClass: () => undefined,\n reverseButtons: () => undefined,\n trapFocus: () => undefined,\n };\n }\n\n private isOpen_ = false;\n private animationFrame_ = 0;\n private animationTimer_ = 0;\n private layoutFrame_ = 0;\n private escapeKeyAction_ = strings.CLOSE_ACTION;\n private scrimClickAction_ = strings.CLOSE_ACTION;\n private autoStackButtons_ = true;\n private areButtonsStacked_ = false;\n\n constructor(adapter?: Partial<MDCDialogAdapter>) {\n super({...MDCDialogFoundation.defaultAdapter, ...adapter});\n }\n\n init() {\n if (this.adapter.hasClass(cssClasses.STACKED)) {\n this.setAutoStackButtons(false);\n }\n }\n\n destroy() {\n if (this.isOpen_) {\n this.close(strings.DESTROY_ACTION);\n }\n\n if (this.animationTimer_) {\n clearTimeout(this.animationTimer_);\n this.handleAnimationTimerEnd_();\n }\n\n if (this.layoutFrame_) {\n cancelAnimationFrame(this.layoutFrame_);\n this.layoutFrame_ = 0;\n }\n }\n\n open() {\n this.isOpen_ = true;\n this.adapter.notifyOpening();\n this.adapter.addClass(cssClasses.OPENING);\n\n // Wait a frame once display is no longer \"none\", to establish basis for animation\n this.runNextAnimationFrame_(() => {\n this.adapter.addClass(cssClasses.OPEN);\n this.adapter.addBodyClass(cssClasses.SCROLL_LOCK);\n\n this.layout();\n\n this.animationTimer_ = setTimeout(() => {\n this.handleAnimationTimerEnd_();\n this.adapter.trapFocus(this.adapter.getInitialFocusEl());\n this.adapter.notifyOpened();\n }, numbers.DIALOG_ANIMATION_OPEN_TIME_MS);\n });\n }\n\n close(action = '') {\n if (!this.isOpen_) {\n // Avoid redundant close calls (and events), e.g. from keydown on elements that inherently emit click\n return;\n }\n\n this.isOpen_ = false;\n this.adapter.notifyClosing(action);\n this.adapter.addClass(cssClasses.CLOSING);\n this.adapter.removeClass(cssClasses.OPEN);\n this.adapter.removeBodyClass(cssClasses.SCROLL_LOCK);\n\n cancelAnimationFrame(this.animationFrame_);\n this.animationFrame_ = 0;\n\n clearTimeout(this.animationTimer_);\n this.animationTimer_ = setTimeout(() => {\n this.adapter.releaseFocus();\n this.handleAnimationTimerEnd_();\n this.adapter.notifyClosed(action);\n }, numbers.DIALOG_ANIMATION_CLOSE_TIME_MS);\n }\n\n isOpen() {\n return this.isOpen_;\n }\n\n getEscapeKeyAction(): string {\n return this.escapeKeyAction_;\n }\n\n setEscapeKeyAction(action: string) {\n this.escapeKeyAction_ = action;\n }\n\n getScrimClickAction(): string {\n return this.scrimClickAction_;\n }\n\n setScrimClickAction(action: string) {\n this.scrimClickAction_ = action;\n }\n\n getAutoStackButtons(): boolean {\n return this.autoStackButtons_;\n }\n\n setAutoStackButtons(autoStack: boolean) {\n this.autoStackButtons_ = autoStack;\n }\n\n layout() {\n if (this.layoutFrame_) {\n cancelAnimationFrame(this.layoutFrame_);\n }\n this.layoutFrame_ = requestAnimationFrame(() => {\n this.layoutInternal_();\n this.layoutFrame_ = 0;\n });\n }\n\n /** Handles click on the dialog root element. */\n handleClick(evt: MouseEvent) {\n const isScrim =\n this.adapter.eventTargetMatches(evt.target, strings.SCRIM_SELECTOR);\n // Check for scrim click first since it doesn't require querying ancestors.\n if (isScrim && this.scrimClickAction_ !== '') {\n this.close(this.scrimClickAction_);\n } else {\n const action = this.adapter.getActionFromEvent(evt);\n if (action) {\n this.close(action);\n }\n }\n }\n\n /** Handles keydown on the dialog root element. */\n handleKeydown(evt: KeyboardEvent) {\n const isEnter = evt.key === 'Enter' || evt.keyCode === 13;\n if (!isEnter) {\n return;\n }\n const action = this.adapter.getActionFromEvent(evt);\n if (action) {\n // Action button callback is handled in `handleClick`,\n // since space/enter keydowns on buttons trigger click events.\n return;\n }\n\n const isDefault = !this.adapter.eventTargetMatches(\n evt.target, strings.SUPPRESS_DEFAULT_PRESS_SELECTOR);\n if (isEnter && isDefault) {\n this.adapter.clickDefaultButton();\n }\n }\n\n /** Handles keydown on the document. */\n handleDocumentKeydown(evt: KeyboardEvent) {\n const isEscape = evt.key === 'Escape' || evt.keyCode === 27;\n if (isEscape && this.escapeKeyAction_ !== '') {\n this.close(this.escapeKeyAction_);\n }\n }\n\n private layoutInternal_() {\n if (this.autoStackButtons_) {\n this.detectStackedButtons_();\n }\n this.detectScrollableContent_();\n }\n\n private handleAnimationTimerEnd_() {\n this.animationTimer_ = 0;\n this.adapter.removeClass(cssClasses.OPENING);\n this.adapter.removeClass(cssClasses.CLOSING);\n }\n\n /**\n * Runs the given logic on the next animation frame, using setTimeout to factor in Firefox reflow behavior.\n */\n private runNextAnimationFrame_(callback: () => void) {\n cancelAnimationFrame(this.animationFrame_);\n this.animationFrame_ = requestAnimationFrame(() => {\n this.animationFrame_ = 0;\n clearTimeout(this.animationTimer_);\n this.animationTimer_ = setTimeout(callback, 0);\n });\n }\n\n private detectStackedButtons_() {\n // Remove the class first to let us measure the buttons' natural positions.\n this.adapter.removeClass(cssClasses.STACKED);\n\n const areButtonsStacked = this.adapter.areButtonsStacked();\n\n if (areButtonsStacked) {\n this.adapter.addClass(cssClasses.STACKED);\n }\n\n if (areButtonsStacked !== this.areButtonsStacked_) {\n this.adapter.reverseButtons();\n this.areButtonsStacked_ = areButtonsStacked;\n }\n }\n\n private detectScrollableContent_() {\n // Remove the class first to let us measure the natural height of the content.\n this.adapter.removeClass(cssClasses.SCROLLABLE);\n if (this.adapter.isContentScrollable()) {\n this.adapter.addClass(cssClasses.SCROLLABLE);\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCDialogFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nimport * as util from './util';\n\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\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 */\n\nimport {FocusOptions, FocusTrap} from '@material/dom/focus-trap';\n\nexport type MDCDialogFocusTrapFactory = (\n element: HTMLElement,\n options: FocusOptions,\n) => FocusTrap;\n\nexport function createFocusTrapInstance(\n surfaceEl: HTMLElement,\n focusTrapFactory: MDCDialogFocusTrapFactory,\n initialFocusEl?: HTMLElement,\n): FocusTrap {\n return focusTrapFactory(surfaceEl, {initialFocusEl});\n}\n\nexport function isScrollable(el: HTMLElement | null): boolean {\n return el ? el.scrollHeight > el.offsetHeight : false;\n}\n\nexport function areTopsMisaligned(els: HTMLElement[]): boolean {\n const tops = new Set();\n [].forEach.call(els, (el: HTMLElement) => tops.add(el.offsetTop));\n return tops.size > 1;\n}\n","/**\n * @license\n * Copyright 2020 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 */\n\n/**\n * Priorities for the announce function\n */\nexport enum AnnouncerPriority {\n POLITE = 'polite',\n ASSERTIVE = 'assertive',\n}\n\n/**\n * Announces the given message with optional priority, defaulting to \"polite\"\n */\nexport function announce(message: string, priority?: AnnouncerPriority) {\n Announcer.getInstance().say(message, priority);\n}\n\nclass Announcer {\n private static instance: Announcer;\n private readonly liveRegions: Map<AnnouncerPriority, Element>;\n\n static getInstance(): Announcer {\n if (!Announcer.instance) {\n Announcer.instance = new Announcer();\n }\n\n return Announcer.instance;\n }\n\n // Constructor made private to ensure only the singleton is used\n private constructor() {\n this.liveRegions = new Map();\n }\n\n say(message: string, priority: AnnouncerPriority = AnnouncerPriority.POLITE) {\n const liveRegion = this.getLiveRegion(priority);\n // Reset the region to pick up the message, even if the message is the\n // exact same as before.\n liveRegion.textContent = '';\n // Timeout is necessary for screen readers like NVDA and VoiceOver.\n setTimeout(() => {\n liveRegion.textContent = message;\n document.addEventListener('click', clearLiveRegion);\n }, 1);\n\n function clearLiveRegion() {\n liveRegion.textContent = '';\n document.removeEventListener('click', clearLiveRegion);\n }\n }\n\n private getLiveRegion(priority: AnnouncerPriority): Element {\n const existingLiveRegion = this.liveRegions.get(priority);\n if (existingLiveRegion &&\n document.body.contains(existingLiveRegion as Node)) {\n return existingLiveRegion;\n }\n\n const liveRegion = this.createLiveRegion(priority);\n this.liveRegions.set(priority, liveRegion);\n return liveRegion;\n }\n\n private createLiveRegion(priority: AnnouncerPriority): Element {\n const el = document.createElement('div');\n el.style.position = 'absolute';\n el.style.top = '-9999px';\n el.style.left = '-9999px';\n el.style.height = '1px';\n el.style.overflow = 'hidden';\n el.setAttribute('aria-atomic', 'true');\n el.setAttribute('aria-live', priority);\n document.body.appendChild(el);\n return el;\n }\n}\n","/**\n * @license\n * Copyright 2019 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 */\n\n/**\n * Determine whether the current browser supports passive event listeners, and\n * if so, use them.\n */\nexport function applyPassive(globalObj: Window = window):\n boolean | EventListenerOptions {\n return supportsPassiveOption(globalObj) ?\n {passive: true} as AddEventListenerOptions :\n false;\n}\n\nfunction supportsPassiveOption(globalObj: Window = window): boolean {\n // See\n // https://developer.mozilla.org/en-US/docs/Web/API/EventTarget/addEventListener\n let passiveSupported = false;\n\n try {\n const options = {\n // This function will be called when the browser\n // attempts to access the passive property.\n get passive() {\n passiveSupported = true;\n return false;\n }\n };\n\n const handler = () => {};\n globalObj.document.addEventListener('test', handler, options);\n globalObj.document.removeEventListener(\n 'test', handler, options as EventListenerOptions);\n } catch (err) {\n passiveSupported = false;\n }\n\n return passiveSupported;\n}\n","/**\n * @license\n * Copyright 2020 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 */\n\nconst FOCUS_SENTINEL_CLASS = 'mdc-dom-focus-sentinel';\n\n/**\n * Utility to trap focus in a given root element, e.g. for modal components such\n * as dialogs. The root should have at least one focusable child element,\n * for setting initial focus when trapping focus.\n * Also tracks the previously focused element, and restores focus to that\n * element when releasing focus.\n */\nexport class FocusTrap {\n // Previously focused element before trapping focus.\n private elFocusedBeforeTrapFocus: HTMLElement|null = null;\n\n constructor(\n private readonly root: HTMLElement,\n private readonly options: FocusOptions = {}) {}\n\n /**\n * Traps focus in `root`. Also focuses on either `initialFocusEl` if set;\n * otherwises sets initial focus to the first focusable child element.\n */\n trapFocus() {\n const focusableEls = this.getFocusableElements(this.root);\n if (focusableEls.length === 0) {\n throw new Error(\n 'FocusTrap: Element must have at least one focusable child.');\n }\n\n this.elFocusedBeforeTrapFocus =\n document.activeElement instanceof HTMLElement ? document.activeElement :\n null;\n this.wrapTabFocus(this.root, focusableEls);\n\n if (!this.options.skipInitialFocus) {\n this.focusInitialElement(focusableEls, this.options.initialFocusEl);\n }\n }\n\n /**\n * Releases focus from `root`. Also restores focus to the previously focused\n * element.\n */\n releaseFocus() {\n [].slice.call(this.root.querySelectorAll(`.${FOCUS_SENTINEL_CLASS}`))\n .forEach((sentinelEl: HTMLElement) => {\n sentinelEl.parentElement!.removeChild(sentinelEl);\n });\n\n if (this.elFocusedBeforeTrapFocus) {\n this.elFocusedBeforeTrapFocus.focus();\n }\n }\n\n /**\n * Wraps tab focus within `el` by adding two hidden sentinel divs which are\n * used to mark the beginning and the end of the tabbable region. When\n * focused, these sentinel elements redirect focus to the first/last\n * children elements of the tabbable region, ensuring that focus is trapped\n * within that region.\n */\n private wrapTabFocus(el: HTMLElement, focusableEls: HTMLElement[]) {\n const sentinelStart = this.createSentinel();\n const sentinelEnd = this.createSentinel();\n\n sentinelStart.addEventListener('focus', () => {\n if (focusableEls.length > 0) {\n focusableEls[focusableEls.length - 1].focus();\n }\n });\n sentinelEnd.addEventListener('focus', () => {\n if (focusableEls.length > 0) {\n focusableEls[0].focus();\n }\n });\n\n el.insertBefore(sentinelStart, el.children[0]);\n el.appendChild(sentinelEnd);\n }\n\n /**\n * Focuses on `initialFocusEl` if defined and a child of the root element.\n * Otherwise, focuses on the first focusable child element of the root.\n */\n private focusInitialElement(\n focusableEls: HTMLElement[], initialFocusEl?: HTMLElement) {\n let focusIndex = 0;\n if (initialFocusEl) {\n focusIndex = Math.max(focusableEls.indexOf(initialFocusEl), 0);\n }\n focusableEls[focusIndex].focus();\n }\n\n private getFocusableElements(root: HTMLElement): HTMLElement[] {\n const focusableEls =\n [].slice.call(root.querySelectorAll(\n '[autofocus], [tabindex], a, input, textarea, select, button')) as\n HTMLElement[];\n return focusableEls.filter((el) => {\n const isDisabledOrHidden = el.getAttribute('aria-disabled') === 'true' ||\n el.getAttribute('disabled') != null ||\n el.getAttribute('hidden') != null ||\n el.getAttribute('aria-hidden') === 'true';\n const isTabbableAndVisible = el.tabIndex >= 0 &&\n el.getBoundingClientRect().width > 0 &&\n !el.classList.contains(FOCUS_SENTINEL_CLASS) && !isDisabledOrHidden;\n\n let isProgrammaticallyHidden = false;\n if (isTabbableAndVisible) {\n const style = getComputedStyle(el);\n isProgrammaticallyHidden =\n style.display === 'none' || style.visibility === 'hidden';\n }\n return isTabbableAndVisible && !isProgrammaticallyHidden;\n });\n }\n\n private createSentinel() {\n const sentinel = document.createElement('div');\n sentinel.setAttribute('tabindex', '0');\n // Don't announce in screen readers.\n sentinel.setAttribute('aria-hidden', 'true');\n sentinel.classList.add(FOCUS_SENTINEL_CLASS);\n return sentinel;\n }\n}\n\n/** Customization options. */\nexport interface FocusOptions {\n // The element to focus initially when trapping focus.\n // Must be a child of the root element.\n initialFocusEl?: HTMLElement;\n\n // Whether to skip initially focusing on any element when trapping focus.\n // By default, focus is set on the first focusable child element of the root.\n // This is useful if the caller wants to handle setting initial focus.\n skipInitialFocus?: boolean;\n}\n","/**\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 */\n\nimport * as events from './events';\nimport * as focusTrap from './focus-trap';\nimport * as keyboard from './keyboard';\nimport * as ponyfill from './ponyfill';\n\nexport {events, focusTrap, keyboard, ponyfill};\n","/**\n * @license\n * Copyright 2020 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 */\n\n/**\n * KEY provides normalized string values for keys.\n */\nexport const KEY = {\n UNKNOWN: 'Unknown',\n BACKSPACE: 'Backspace',\n ENTER: 'Enter',\n SPACEBAR: 'Spacebar',\n PAGE_UP: 'PageUp',\n PAGE_DOWN: 'PageDown',\n END: 'End',\n HOME: 'Home',\n ARROW_LEFT: 'ArrowLeft',\n ARROW_UP: 'ArrowUp',\n ARROW_RIGHT: 'ArrowRight',\n ARROW_DOWN: 'ArrowDown',\n DELETE: 'Delete',\n ESCAPE: 'Escape',\n};\n\nconst normalizedKeys = new Set<string>();\n// IE11 has no support for new Map with iterable so we need to initialize this\n// by hand.\nnormalizedKeys.add(KEY.BACKSPACE);\nnormalizedKeys.add(KEY.ENTER);\nnormalizedKeys.add(KEY.SPACEBAR);\nnormalizedKeys.add(KEY.PAGE_UP);\nnormalizedKeys.add(KEY.PAGE_DOWN);\nnormalizedKeys.add(KEY.END);\nnormalizedKeys.add(KEY.HOME);\nnormalizedKeys.add(KEY.ARROW_LEFT);\nnormalizedKeys.add(KEY.ARROW_UP);\nnormalizedKeys.add(KEY.ARROW_RIGHT);\nnormalizedKeys.add(KEY.ARROW_DOWN);\nnormalizedKeys.add(KEY.DELETE);\nnormalizedKeys.add(KEY.ESCAPE);\n\nconst KEY_CODE = {\n BACKSPACE: 8,\n ENTER: 13,\n SPACEBAR: 32,\n PAGE_UP: 33,\n PAGE_DOWN: 34,\n END: 35,\n HOME: 36,\n ARROW_LEFT: 37,\n ARROW_UP: 38,\n ARROW_RIGHT: 39,\n ARROW_DOWN: 40,\n DELETE: 46,\n ESCAPE: 27,\n};\n\nconst mappedKeyCodes = new Map<number, string>();\n// IE11 has no support for new Map with iterable so we need to initialize this\n// by hand.\nmappedKeyCodes.set(KEY_CODE.BACKSPACE, KEY.BACKSPACE);\nmappedKeyCodes.set(KEY_CODE.ENTER, KEY.ENTER);\nmappedKeyCodes.set(KEY_CODE.SPACEBAR, KEY.SPACEBAR);\nmappedKeyCodes.set(KEY_CODE.PAGE_UP, KEY.PAGE_UP);\nmappedKeyCodes.set(KEY_CODE.PAGE_DOWN, KEY.PAGE_DOWN);\nmappedKeyCodes.set(KEY_CODE.END, KEY.END);\nmappedKeyCodes.set(KEY_CODE.HOME, KEY.HOME);\nmappedKeyCodes.set(KEY_CODE.ARROW_LEFT, KEY.ARROW_LEFT);\nmappedKeyCodes.set(KEY_CODE.ARROW_UP, KEY.ARROW_UP);\nmappedKeyCodes.set(KEY_CODE.ARROW_RIGHT, KEY.ARROW_RIGHT);\nmappedKeyCodes.set(KEY_CODE.ARROW_DOWN, KEY.ARROW_DOWN);\nmappedKeyCodes.set(KEY_CODE.DELETE, KEY.DELETE);\nmappedKeyCodes.set(KEY_CODE.ESCAPE, KEY.ESCAPE);\n\nconst navigationKeys = new Set<string>();\n// IE11 has no support for new Set with iterable so we need to initialize this\n// by hand.\nnavigationKeys.add(KEY.PAGE_UP);\nnavigationKeys.add(KEY.PAGE_DOWN);\nnavigationKeys.add(KEY.END);\nnavigationKeys.add(KEY.HOME);\nnavigationKeys.add(KEY.ARROW_LEFT);\nnavigationKeys.add(KEY.ARROW_UP);\nnavigationKeys.add(KEY.ARROW_RIGHT);\nnavigationKeys.add(KEY.ARROW_DOWN);\n\n/**\n * normalizeKey returns the normalized string for a navigational action.\n */\nexport function normalizeKey(evt: KeyboardEvent): string {\n const {key} = evt;\n // If the event already has a normalized key, return it\n if (normalizedKeys.has(key)) {\n return key;\n }\n\n // tslint:disable-next-line:deprecation\n const mappedKey = mappedKeyCodes.get(evt.keyCode);\n if (mappedKey) {\n return mappedKey;\n }\n return KEY.UNKNOWN;\n}\n\n/**\n * isNavigationEvent returns whether the event is a navigation event\n */\nexport function isNavigationEvent(evt: KeyboardEvent): boolean {\n return navigationKeys.has(normalizeKey(evt));\n}\n","/**\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 */\n\n/**\n * @fileoverview A \"ponyfill\" is a polyfill that doesn't modify the global prototype chain.\n * This makes ponyfills safer than traditional polyfills, especially for libraries like MDC.\n */\n\nexport function closest(element: Element, selector: string): Element | null {\n if (element.closest) {\n return element.closest(selector);\n }\n\n let el: Element | null = element;\n while (el) {\n if (matches(el, selector)) {\n return el;\n }\n el = el.parentElement;\n }\n return null;\n}\n\nexport function matches(element: Element, selector: string): boolean {\n const nativeMatches = element.matches\n || element.webkitMatchesSelector\n || element.msMatchesSelector;\n return nativeMatches.call(element, selector);\n}\n\n/**\n * Used to compute the estimated scroll width of elements. When an element is\n * hidden due to display: none; being applied to a parent element, the width is\n * returned as 0. However, the element will have a true width once no longer\n * inside a display: none context. This method computes an estimated width when\n * the element is hidden or returns the true width when the element is visble.\n * @param {Element} element the element whose width to estimate\n */\nexport function estimateScrollWidth(element: Element): number {\n // Check the offsetParent. If the element inherits display: none from any\n // parent, the offsetParent property will be null (see\n // https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/offsetParent).\n // This check ensures we only clone the node when necessary.\n const htmlEl = element as HTMLElement;\n if (htmlEl.offsetParent !== null) {\n return htmlEl.scrollWidth;\n }\n\n const clone = htmlEl.cloneNode(true) as HTMLElement;\n clone.style.setProperty('position', 'absolute');\n clone.style.setProperty('transform', 'translate(-9999px, -9999px)');\n document.documentElement.appendChild(clone);\n const scrollWidth = clone.scrollWidth;\n document.documentElement.removeChild(clone);\n return scrollWidth;\n}\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {FocusTrap} from '@material/dom/focus-trap';\nimport {MDCList, MDCListFactory} from '@material/list/component';\nimport {MDCListFoundation} from '@material/list/foundation';\nimport {MDCDrawerAdapter} from './adapter';\nimport {MDCDismissibleDrawerFoundation} from './dismissible/foundation';\nimport {MDCModalDrawerFoundation} from './modal/foundation';\nimport * as util from './util';\nimport {MDCDrawerFocusTrapFactory} from './util';\n\nconst {cssClasses, strings} = MDCDismissibleDrawerFoundation;\n\n/**\n * @events `MDCDrawer:closed {}` Emits when the navigation drawer has closed.\n * @events `MDCDrawer:opened {}` Emits when the navigation drawer has opened.\n */\nexport class MDCDrawer extends MDCComponent<MDCDismissibleDrawerFoundation> {\n static attachTo(root: Element): MDCDrawer {\n return new MDCDrawer(root);\n }\n\n /**\n * @return boolean Proxies to the foundation's `open`/`close` methods.\n * Also returns true if drawer is in the open position.\n */\n get open(): boolean {\n return this.foundation.isOpen();\n }\n\n /**\n * Toggles the drawer open and closed.\n */\n set open(isOpen: boolean) {\n if (isOpen) {\n this.foundation.open();\n } else {\n this.foundation.close();\n }\n }\n\n private previousFocus_?: Element | null;\n private scrim_!: HTMLElement | null; // assigned in initialSyncWithDOM()\n private list_?: MDCList; // assigned in initialize()\n\n private focusTrap_?: FocusTrap; // assigned in initialSyncWithDOM()\n private focusTrapFactory_!: MDCDrawerFocusTrapFactory; // assigned in initialize()\n\n private handleScrimClick_?: SpecificEventListener<'click'>; // initialized in initialSyncWithDOM()\n private handleKeydown_!: SpecificEventListener<'keydown'>; // initialized in initialSyncWithDOM()\n private handleTransitionEnd_!: SpecificEventListener<'transitionend'>; // initialized in initialSyncWithDOM()\n\n get list(): MDCList | undefined {\n return this.list_;\n }\n\n initialize(\n focusTrapFactory: MDCDrawerFocusTrapFactory = (el) => new FocusTrap(el),\n listFactory: MDCListFactory = (el) => new MDCList(el),\n ) {\n const listEl =\n this.root.querySelector(`.${MDCListFoundation.cssClasses.ROOT}`);\n if (listEl) {\n this.list_ = listFactory(listEl);\n this.list_.wrapFocus = true;\n }\n this.focusTrapFactory_ = focusTrapFactory;\n }\n\n initialSyncWithDOM() {\n const {MODAL} = cssClasses;\n const {SCRIM_SELECTOR} = strings;\n\n this.scrim_ = (this.root.parentNode as Element)\n .querySelector<HTMLElement>(SCRIM_SELECTOR);\n\n if (this.scrim_ && this.root.classList.contains(MODAL)) {\n this.handleScrimClick_ = () =>\n (this.foundation as MDCModalDrawerFoundation).handleScrimClick();\n this.scrim_.addEventListener('click', this.handleScrimClick_);\n this.focusTrap_ = util.createFocusTrapInstance(\n this.root as HTMLElement, this.focusTrapFactory_);\n }\n\n this.handleKeydown_ = (evt) => this.foundation.handleKeydown(evt);\n this.handleTransitionEnd_ = (evt) =>\n this.foundation.handleTransitionEnd(evt);\n\n this.listen('keydown', this.handleKeydown_);\n this.listen('transitionend', this.handleTransitionEnd_);\n }\n\n destroy() {\n this.unlisten('keydown', this.handleKeydown_);\n this.unlisten('transitionend', this.handleTransitionEnd_);\n\n if (this.list_) {\n this.list_.destroy();\n }\n\n const {MODAL} = cssClasses;\n if (this.scrim_ && this.handleScrimClick_ &&\n this.root.classList.contains(MODAL)) {\n this.scrim_.removeEventListener('click', this.handleScrimClick_);\n // Ensure drawer is closed to hide scrim and release focus\n this.open = false;\n }\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCDrawerAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n hasClass: (className) => this.root.classList.contains(className),\n elementHasClass: (element, className) =>\n element.classList.contains(className),\n saveFocus: () => this.previousFocus_ = document.activeElement,\n restoreFocus: () => {\n const previousFocus = this.previousFocus_ as HTMLOrSVGElement | null;\n if (previousFocus && previousFocus.focus &&\n this.root.contains(document.activeElement)) {\n previousFocus.focus();\n }\n },\n focusActiveNavigationItem: () => {\n const activeNavItemEl = this.root.querySelector<HTMLElement>(\n `.${MDCListFoundation.cssClasses.LIST_ITEM_ACTIVATED_CLASS}`);\n if (activeNavItemEl) {\n activeNavItemEl.focus();\n }\n },\n notifyClose: () =>\n this.emit(strings.CLOSE_EVENT, {}, true /* shouldBubble */),\n notifyOpen: () =>\n this.emit(strings.OPEN_EVENT, {}, true /* shouldBubble */),\n trapFocus: () => this.focusTrap_!.trapFocus(),\n releaseFocus: () => this.focusTrap_!.releaseFocus(),\n };\n // tslint:enable:object-literal-sort-keys\n\n const {DISMISSIBLE, MODAL} = cssClasses;\n if (this.root.classList.contains(DISMISSIBLE)) {\n return new MDCDismissibleDrawerFoundation(adapter);\n } else if (this.root.classList.contains(MODAL)) {\n return new MDCModalDrawerFoundation(adapter);\n } else {\n throw new Error(\n `MDCDrawer: Failed to instantiate component. Supported variants are ${DISMISSIBLE} and ${MODAL}.`);\n }\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n ANIMATE: 'mdc-drawer--animate',\n CLOSING: 'mdc-drawer--closing',\n DISMISSIBLE: 'mdc-drawer--dismissible',\n MODAL: 'mdc-drawer--modal',\n OPEN: 'mdc-drawer--open',\n OPENING: 'mdc-drawer--opening',\n ROOT: 'mdc-drawer',\n};\n\nconst strings = {\n APP_CONTENT_SELECTOR: '.mdc-drawer-app-content',\n CLOSE_EVENT: 'MDCDrawer:closed',\n OPEN_EVENT: 'MDCDrawer:opened',\n SCRIM_SELECTOR: '.mdc-drawer-scrim',\n};\n\nexport {cssClasses, strings};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCDrawerAdapter} from '../adapter';\nimport {cssClasses, strings} from '../constants';\n\nexport class MDCDismissibleDrawerFoundation extends MDCFoundation<MDCDrawerAdapter> {\n static get strings() {\n return strings;\n }\n\n static get cssClasses() {\n return cssClasses;\n }\n\n static get defaultAdapter(): MDCDrawerAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n hasClass: () => false,\n elementHasClass: () => false,\n notifyClose: () => undefined,\n notifyOpen: () => undefined,\n saveFocus: () => undefined,\n restoreFocus: () => undefined,\n focusActiveNavigationItem: () => undefined,\n trapFocus: () => undefined,\n releaseFocus: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private animationFrame_ = 0;\n private animationTimer_ = 0;\n\n constructor(adapter?: Partial<MDCDrawerAdapter>) {\n super({...MDCDismissibleDrawerFoundation.defaultAdapter, ...adapter});\n }\n\n destroy() {\n if (this.animationFrame_) {\n cancelAnimationFrame(this.animationFrame_);\n }\n if (this.animationTimer_) {\n clearTimeout(this.animationTimer_);\n }\n }\n\n /**\n * Opens the drawer from the closed state.\n */\n open() {\n if (this.isOpen() || this.isOpening() || this.isClosing()) {\n return;\n }\n\n this.adapter.addClass(cssClasses.OPEN);\n this.adapter.addClass(cssClasses.ANIMATE);\n\n // Wait a frame once display is no longer \"none\", to establish basis for animation\n this.runNextAnimationFrame_(() => {\n this.adapter.addClass(cssClasses.OPENING);\n });\n\n this.adapter.saveFocus();\n }\n\n /**\n * Closes the drawer from the open state.\n */\n close() {\n if (!this.isOpen() || this.isOpening() || this.isClosing()) {\n return;\n }\n\n this.adapter.addClass(cssClasses.CLOSING);\n }\n\n /**\n * Returns true if the drawer is in the open position.\n * @return true if drawer is in open state.\n */\n isOpen(): boolean {\n return this.adapter.hasClass(cssClasses.OPEN);\n }\n\n /**\n * Returns true if the drawer is animating open.\n * @return true if drawer is animating open.\n */\n isOpening(): boolean {\n return this.adapter.hasClass(cssClasses.OPENING) ||\n this.adapter.hasClass(cssClasses.ANIMATE);\n }\n\n /**\n * Returns true if the drawer is animating closed.\n * @return true if drawer is animating closed.\n */\n isClosing(): boolean {\n return this.adapter.hasClass(cssClasses.CLOSING);\n }\n\n /**\n * Keydown handler to close drawer when key is escape.\n */\n handleKeydown(evt: KeyboardEvent) {\n const {keyCode, key} = evt;\n const isEscape = key === 'Escape' || keyCode === 27;\n if (isEscape) {\n this.close();\n }\n }\n\n /**\n * Handles the `transitionend` event when the drawer finishes opening/closing.\n */\n handleTransitionEnd(evt: TransitionEvent) {\n const {OPENING, CLOSING, OPEN, ANIMATE, ROOT} = cssClasses;\n\n // In Edge, transitionend on ripple pseudo-elements yields a target without classList, so check for Element first.\n const isRootElement = this.isElement_(evt.target) &&\n this.adapter.elementHasClass(evt.target, ROOT);\n if (!isRootElement) {\n return;\n }\n\n if (this.isClosing()) {\n this.adapter.removeClass(OPEN);\n this.closed_();\n this.adapter.restoreFocus();\n this.adapter.notifyClose();\n } else {\n this.adapter.focusActiveNavigationItem();\n this.opened_();\n this.adapter.notifyOpen();\n }\n\n this.adapter.removeClass(ANIMATE);\n this.adapter.removeClass(OPENING);\n this.adapter.removeClass(CLOSING);\n }\n\n /**\n * Extension point for when drawer finishes open animation.\n */\n protected opened_() {} // tslint:disable-line:no-empty\n\n /**\n * Extension point for when drawer finishes close animation.\n */\n protected closed_() {} // tslint:disable-line:no-empty\n\n /**\n * Runs the given logic on the next animation frame, using setTimeout to factor in Firefox reflow behavior.\n */\n private runNextAnimationFrame_(callback: () => void) {\n cancelAnimationFrame(this.animationFrame_);\n this.animationFrame_ = requestAnimationFrame(() => {\n this.animationFrame_ = 0;\n clearTimeout(this.animationTimer_);\n this.animationTimer_ = setTimeout(callback, 0);\n });\n }\n\n private isElement_(element: unknown): element is Element {\n // In Edge, transitionend on ripple pseudo-elements yields a target without classList.\n return Boolean((element as Element).classList);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCDismissibleDrawerFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nimport * as util from './util';\n\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './dismissible/foundation';\nexport * from './modal/foundation';\n","/**\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 */\n\nimport {MDCDismissibleDrawerFoundation} from '../dismissible/foundation';\n\n/* istanbul ignore next: subclass is not a branch statement */\nexport class MDCModalDrawerFoundation extends MDCDismissibleDrawerFoundation {\n /**\n * Handles click event on scrim.\n */\n handleScrimClick() {\n this.close();\n }\n\n /**\n * Called when drawer finishes open animation.\n */\n protected opened_() {\n this.adapter.trapFocus();\n }\n\n /**\n * Called when drawer finishes close animation.\n */\n protected closed_() {\n this.adapter.releaseFocus();\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCModalDrawerFoundation;\n","/**\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 */\n\nimport {FocusOptions, FocusTrap} from '@material/dom/focus-trap';\n\nexport type MDCDrawerFocusTrapFactory = (\n element: HTMLElement,\n options: FocusOptions,\n) => FocusTrap;\n\nexport function createFocusTrapInstance(\n surfaceEl: HTMLElement,\n focusTrapFactory: MDCDrawerFocusTrapFactory,\n): FocusTrap {\n return focusTrapFactory(surfaceEl, {\n // Component handles focusing on active nav item.\n skipInitialFocus: true, \n });\n}\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {estimateScrollWidth} from '@material/dom/ponyfill';\nimport {MDCFloatingLabelAdapter} from './adapter';\nimport {MDCFloatingLabelFoundation} from './foundation';\n\nexport type MDCFloatingLabelFactory = (el: Element, foundation?: MDCFloatingLabelFoundation) => MDCFloatingLabel;\n\nexport class MDCFloatingLabel extends MDCComponent<MDCFloatingLabelFoundation> {\n static attachTo(root: Element): MDCFloatingLabel {\n return new MDCFloatingLabel(root);\n }\n\n /**\n * Styles the label to produce the label shake for errors.\n * @param shouldShake If true, shakes the label by adding a CSS class; otherwise, stops shaking by removing the class.\n */\n shake(shouldShake: boolean) {\n this.foundation.shake(shouldShake);\n }\n\n /**\n * Styles the label to float/dock.\n * @param shouldFloat If true, floats the label by adding a CSS class; otherwise, docks it by removing the class.\n */\n float(shouldFloat: boolean) {\n this.foundation.float(shouldFloat);\n }\n\n /**\n * Styles the label as required.\n * @param isRequired If true, adds an asterisk to the label, indicating that it is required.\n */\n setRequired(isRequired: boolean) {\n this.foundation.setRequired(isRequired);\n }\n\n getWidth(): number {\n return this.foundation.getWidth();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCFloatingLabelAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n getWidth: () => estimateScrollWidth(this.root),\n registerInteractionHandler: (evtType, handler) =>\n this.listen(evtType, handler),\n deregisterInteractionHandler: (evtType, handler) =>\n this.unlisten(evtType, handler),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCFloatingLabelFoundation(adapter);\n }\n}\n","/**\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 */\n\nexport const cssClasses = {\n LABEL_FLOAT_ABOVE: 'mdc-floating-label--float-above',\n LABEL_REQUIRED: 'mdc-floating-label--required',\n LABEL_SHAKE: 'mdc-floating-label--shake',\n ROOT: 'mdc-floating-label',\n};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCFloatingLabelAdapter} from './adapter';\nimport {cssClasses} from './constants';\n\nexport class MDCFloatingLabelFoundation extends MDCFoundation<MDCFloatingLabelAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n /**\n * See {@link MDCFloatingLabelAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCFloatingLabelAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n getWidth: () => 0,\n registerInteractionHandler: () => undefined,\n deregisterInteractionHandler: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private readonly shakeAnimationEndHandler_: SpecificEventListener<'animationend'>;\n\n constructor(adapter?: Partial<MDCFloatingLabelAdapter>) {\n super({...MDCFloatingLabelFoundation.defaultAdapter, ...adapter});\n\n this.shakeAnimationEndHandler_ = () => this.handleShakeAnimationEnd_();\n }\n\n init() {\n this.adapter.registerInteractionHandler('animationend', this.shakeAnimationEndHandler_);\n }\n\n destroy() {\n this.adapter.deregisterInteractionHandler('animationend', this.shakeAnimationEndHandler_);\n }\n\n /**\n * Returns the width of the label element.\n */\n getWidth(): number {\n return this.adapter.getWidth();\n }\n\n /**\n * Styles the label to produce a shake animation to indicate an error.\n * @param shouldShake If true, adds the shake CSS class; otherwise, removes shake class.\n */\n shake(shouldShake: boolean) {\n const {LABEL_SHAKE} = MDCFloatingLabelFoundation.cssClasses;\n if (shouldShake) {\n this.adapter.addClass(LABEL_SHAKE);\n } else {\n this.adapter.removeClass(LABEL_SHAKE);\n }\n }\n\n /**\n * Styles the label to float or dock.\n * @param shouldFloat If true, adds the float CSS class; otherwise, removes float and shake classes to dock the label.\n */\n float(shouldFloat: boolean) {\n const {LABEL_FLOAT_ABOVE, LABEL_SHAKE} = MDCFloatingLabelFoundation.cssClasses;\n if (shouldFloat) {\n this.adapter.addClass(LABEL_FLOAT_ABOVE);\n } else {\n this.adapter.removeClass(LABEL_FLOAT_ABOVE);\n this.adapter.removeClass(LABEL_SHAKE);\n }\n }\n\n /**\n * Styles the label as required.\n * @param isRequired If true, adds an asterisk to the label, indicating that it is required.\n */\n setRequired(isRequired: boolean) {\n const {LABEL_REQUIRED} = MDCFloatingLabelFoundation.cssClasses;\n if (isRequired) {\n this.adapter.addClass(LABEL_REQUIRED);\n } else {\n this.adapter.removeClass(LABEL_REQUIRED);\n }\n }\n\n private handleShakeAnimationEnd_() {\n const {LABEL_SHAKE} = MDCFloatingLabelFoundation.cssClasses;\n this.adapter.removeClass(LABEL_SHAKE);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFloatingLabelFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCFormFieldAdapter} from './adapter';\nimport {MDCFormFieldFoundation} from './foundation';\n\nexport interface MDCFormFieldInput {\n readonly ripple: MDCRipple | undefined;\n}\n\nexport class MDCFormField extends MDCComponent<MDCFormFieldFoundation> {\n static attachTo(root: HTMLElement) {\n return new MDCFormField(root);\n }\n\n input?: MDCFormFieldInput;\n\n private labelEl(): Element|null {\n const {LABEL_SELECTOR} = MDCFormFieldFoundation.strings;\n return this.root.querySelector(LABEL_SELECTOR);\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCFormFieldAdapter = {\n activateInputRipple: () => {\n if (this.input && this.input.ripple) {\n this.input.ripple.activate();\n }\n },\n deactivateInputRipple: () => {\n if (this.input && this.input.ripple) {\n this.input.ripple.deactivate();\n }\n },\n deregisterInteractionHandler: (evtType, handler) => {\n const labelEl = this.labelEl();\n if (labelEl) {\n (labelEl as HTMLElement).removeEventListener(evtType, handler);\n }\n },\n registerInteractionHandler: (evtType, handler) => {\n const labelEl = this.labelEl();\n if (labelEl) {\n (labelEl as HTMLElement).addEventListener(evtType, handler);\n }\n },\n };\n return new MDCFormFieldFoundation(adapter);\n }\n}\n","/**\n * @license\n * Copyright 2017 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 */\n\nexport const cssClasses = {\n ROOT: 'mdc-form-field',\n};\n\nexport const strings = {\n LABEL_SELECTOR: '.mdc-form-field > label',\n};\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCFormFieldAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCFormFieldFoundation extends MDCFoundation<MDCFormFieldAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get defaultAdapter(): MDCFormFieldAdapter {\n return {\n activateInputRipple: () => undefined,\n deactivateInputRipple: () => undefined,\n deregisterInteractionHandler: () => undefined,\n registerInteractionHandler: () => undefined,\n };\n }\n\n private readonly click: () => void;\n\n constructor(adapter?: Partial<MDCFormFieldAdapter>) {\n super({...MDCFormFieldFoundation.defaultAdapter, ...adapter});\n\n this.click = () => {\n this.handleClick();\n };\n }\n\n init() {\n this.adapter.registerInteractionHandler('click', this.click);\n }\n\n destroy() {\n this.adapter.deregisterInteractionHandler('click', this.click);\n }\n\n private handleClick() {\n this.adapter.activateInputRipple();\n requestAnimationFrame(() => {\n this.adapter.deactivateInputRipple();\n });\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFormFieldFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCIconButtonToggleAdapter} from './adapter';\nimport {MDCIconButtonToggleFoundation} from './foundation';\nimport {MDCIconButtonToggleEventDetail} from './types';\n\nconst {strings} = MDCIconButtonToggleFoundation;\n\nexport class MDCIconButtonToggle extends MDCComponent<MDCIconButtonToggleFoundation> {\n static attachTo(root: HTMLElement) {\n return new MDCIconButtonToggle(root);\n }\n\n private readonly rippleComponent: MDCRipple = this.createRipple();\n private handleClick!:\n SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n\n initialSyncWithDOM() {\n this.handleClick = () => {\n this.foundation.handleClick();\n };\n this.listen('click', this.handleClick);\n }\n\n destroy() {\n this.unlisten('click', this.handleClick);\n this.ripple.destroy();\n super.destroy();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCIconButtonToggleAdapter = {\n addClass: (className) => this.root.classList.add(className),\n hasClass: (className) => this.root.classList.contains(className),\n notifyChange: (evtData) => {\n this.emit<MDCIconButtonToggleEventDetail>(\n strings.CHANGE_EVENT, evtData);\n },\n removeClass: (className) => this.root.classList.remove(className),\n getAttr: (attrName) => this.root.getAttribute(attrName),\n setAttr: (attrName, attrValue) =>\n this.root.setAttribute(attrName, attrValue),\n };\n return new MDCIconButtonToggleFoundation(adapter);\n }\n\n get ripple(): MDCRipple {\n return this.rippleComponent;\n }\n\n get on(): boolean {\n return this.foundation.isOn();\n }\n\n set on(isOn: boolean) {\n this.foundation.toggle(isOn);\n }\n\n private createRipple(): MDCRipple {\n const ripple = new MDCRipple(this.root);\n ripple.unbounded = true;\n return ripple;\n }\n}\n","/**\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 */\n\nexport const cssClasses = {\n ICON_BUTTON_ON: 'mdc-icon-button--on',\n ROOT: 'mdc-icon-button',\n};\n\nexport const strings = {\n ARIA_LABEL: 'aria-label',\n ARIA_PRESSED: 'aria-pressed',\n DATA_ARIA_LABEL_OFF: 'data-aria-label-off',\n DATA_ARIA_LABEL_ON: 'data-aria-label-on',\n CHANGE_EVENT: 'MDCIconButtonToggle:change',\n};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCIconButtonToggleAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCIconButtonToggleFoundation extends MDCFoundation<MDCIconButtonToggleAdapter> {\n /**\n * Whether the icon button has an aria label that changes depending on\n * toggled state.\n */\n private hasToggledAriaLabel: boolean = false;\n\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get defaultAdapter(): MDCIconButtonToggleAdapter {\n return {\n addClass: () => undefined,\n hasClass: () => false,\n notifyChange: () => undefined,\n removeClass: () => undefined,\n getAttr: () => null,\n setAttr: () => undefined,\n };\n }\n\n constructor(adapter?: Partial<MDCIconButtonToggleAdapter>) {\n super({...MDCIconButtonToggleFoundation.defaultAdapter, ...adapter});\n }\n\n init() {\n const ariaLabelOn = this.adapter.getAttr(strings.DATA_ARIA_LABEL_ON);\n const ariaLabelOff = this.adapter.getAttr(strings.DATA_ARIA_LABEL_OFF);\n if (ariaLabelOn && ariaLabelOff) {\n if (this.adapter.getAttr(strings.ARIA_PRESSED) !== null) {\n throw new Error(\n 'MDCIconButtonToggleFoundation: Button should not set ' +\n '`aria-pressed` if it has a toggled aria label.');\n }\n\n this.hasToggledAriaLabel = true;\n } else {\n this.adapter.setAttr(strings.ARIA_PRESSED, String(this.isOn()));\n }\n }\n\n handleClick() {\n this.toggle();\n this.adapter.notifyChange({isOn: this.isOn()});\n }\n\n isOn(): boolean {\n return this.adapter.hasClass(cssClasses.ICON_BUTTON_ON);\n }\n\n toggle(isOn: boolean = !this.isOn()) {\n // Toggle UI based on state.\n if (isOn) {\n this.adapter.addClass(cssClasses.ICON_BUTTON_ON);\n } else {\n this.adapter.removeClass(cssClasses.ICON_BUTTON_ON);\n }\n\n // Toggle aria attributes based on state.\n if (this.hasToggledAriaLabel) {\n const ariaLabel = isOn ?\n this.adapter.getAttr(strings.DATA_ARIA_LABEL_ON) :\n this.adapter.getAttr(strings.DATA_ARIA_LABEL_OFF);\n this.adapter.setAttr(strings.ARIA_LABEL, ariaLabel || '');\n } else {\n this.adapter.setAttr(strings.ARIA_PRESSED, `${isOn}`);\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCIconButtonToggleFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCLineRippleAdapter} from './adapter';\nimport {MDCLineRippleFoundation} from './foundation';\n\nexport type MDCLineRippleFactory = (el: Element, foundation?: MDCLineRippleFoundation) => MDCLineRipple;\n\nexport class MDCLineRipple extends MDCComponent<MDCLineRippleFoundation> {\n static attachTo(root: Element): MDCLineRipple {\n return new MDCLineRipple(root);\n }\n\n /**\n * Activates the line ripple\n */\n activate() {\n this.foundation.activate();\n }\n\n /**\n * Deactivates the line ripple\n */\n deactivate() {\n this.foundation.deactivate();\n }\n\n /**\n * Sets the transform origin given a user's click location.\n * The `rippleCenter` is the x-coordinate of the middle of the ripple.\n */\n setRippleCenter(xCoordinate: number) {\n this.foundation.setRippleCenter(xCoordinate);\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCLineRippleAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n hasClass: (className) => this.root.classList.contains(className),\n setStyle: (propertyName, value) => (this.root as HTMLElement).style.setProperty(propertyName, value),\n registerEventHandler: (evtType, handler) => this.listen(evtType, handler),\n deregisterEventHandler: (evtType, handler) => this.unlisten(evtType, handler),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCLineRippleFoundation(adapter);\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n LINE_RIPPLE_ACTIVE: 'mdc-line-ripple--active',\n LINE_RIPPLE_DEACTIVATING: 'mdc-line-ripple--deactivating',\n};\n\nexport {cssClasses};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCLineRippleAdapter} from './adapter';\nimport {cssClasses} from './constants';\n\nexport class MDCLineRippleFoundation extends MDCFoundation<MDCLineRippleAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n /**\n * See {@link MDCLineRippleAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCLineRippleAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n hasClass: () => false,\n setStyle: () => undefined,\n registerEventHandler: () => undefined,\n deregisterEventHandler: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private readonly transitionEndHandler_: SpecificEventListener<'transitionend'>;\n\n constructor(adapter?: Partial<MDCLineRippleAdapter>) {\n super({...MDCLineRippleFoundation.defaultAdapter, ...adapter});\n\n this.transitionEndHandler_ = (evt) => this.handleTransitionEnd(evt);\n }\n\n init() {\n this.adapter.registerEventHandler(\n 'transitionend', this.transitionEndHandler_);\n }\n\n destroy() {\n this.adapter.deregisterEventHandler(\n 'transitionend', this.transitionEndHandler_);\n }\n\n activate() {\n this.adapter.removeClass(cssClasses.LINE_RIPPLE_DEACTIVATING);\n this.adapter.addClass(cssClasses.LINE_RIPPLE_ACTIVE);\n }\n\n setRippleCenter(xCoordinate: number) {\n this.adapter.setStyle('transform-origin', `${xCoordinate}px center`);\n }\n\n deactivate() {\n this.adapter.addClass(cssClasses.LINE_RIPPLE_DEACTIVATING);\n }\n\n handleTransitionEnd(evt: TransitionEvent) {\n // Wait for the line ripple to be either transparent or opaque\n // before emitting the animation end event\n const isDeactivating =\n this.adapter.hasClass(cssClasses.LINE_RIPPLE_DEACTIVATING);\n\n if (evt.propertyName === 'opacity') {\n if (isDeactivating) {\n this.adapter.removeClass(cssClasses.LINE_RIPPLE_ACTIVE);\n this.adapter.removeClass(cssClasses.LINE_RIPPLE_DEACTIVATING);\n }\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCLineRippleFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCProgressIndicator} from '@material/progress-indicator/component';\nimport {MDCLinearProgressAdapter} from './adapter';\nimport {MDCLinearProgressFoundation} from './foundation';\n\nexport class MDCLinearProgress extends\n MDCComponent<MDCLinearProgressFoundation> implements MDCProgressIndicator {\n static attachTo(root: Element) {\n return new MDCLinearProgress(root);\n }\n\n set determinate(value: boolean) {\n this.foundation.setDeterminate(value);\n }\n\n set progress(value: number) {\n this.foundation.setProgress(value);\n }\n\n set buffer(value: number) {\n this.foundation.setBuffer(value);\n }\n\n set reverse(value: boolean) {\n this.foundation.setReverse(value);\n }\n\n open() {\n this.foundation.open();\n }\n\n close() {\n this.foundation.close();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCLinearProgressAdapter = {\n addClass: (className: string) => {\n this.root.classList.add(className);\n },\n forceLayout: () => {\n this.root.getBoundingClientRect();\n },\n setBufferBarStyle: (styleProperty: string, value: string) => {\n const bufferBar = this.root.querySelector<HTMLElement>(\n MDCLinearProgressFoundation.strings.BUFFER_BAR_SELECTOR);\n if (bufferBar) {\n bufferBar.style.setProperty(styleProperty, value);\n }\n },\n setPrimaryBarStyle: (styleProperty: string, value: string) => {\n const primaryBar = this.root.querySelector<HTMLElement>(\n MDCLinearProgressFoundation.strings.PRIMARY_BAR_SELECTOR);\n if (primaryBar) {\n primaryBar.style.setProperty(styleProperty, value);\n }\n },\n hasClass: (className: string) => this.root.classList.contains(className),\n removeAttribute: (attributeName: string) => {\n this.root.removeAttribute(attributeName);\n },\n removeClass: (className: string) => {\n this.root.classList.remove(className);\n },\n setAttribute: (attributeName: string, value: string) => {\n this.root.setAttribute(attributeName, value);\n },\n };\n return new MDCLinearProgressFoundation(adapter);\n }\n}\n","/**\n * @license\n * Copyright 2017 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 */\n\nexport const cssClasses = {\n CLOSED_CLASS: 'mdc-linear-progress--closed',\n INDETERMINATE_CLASS: 'mdc-linear-progress--indeterminate',\n REVERSED_CLASS: 'mdc-linear-progress--reversed',\n};\n\nexport const strings = {\n ARIA_VALUENOW: 'aria-valuenow',\n BUFFER_BAR_SELECTOR: '.mdc-linear-progress__buffer-bar',\n FLEX_BASIS: 'flex-basis',\n PRIMARY_BAR_SELECTOR: '.mdc-linear-progress__primary-bar',\n};\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {getCorrectPropertyName} from '@material/animation/util';\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCProgressIndicatorFoundation} from '@material/progress-indicator/foundation';\nimport {MDCLinearProgressAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCLinearProgressFoundation extends\n MDCFoundation<MDCLinearProgressAdapter> implements\n MDCProgressIndicatorFoundation {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get defaultAdapter(): MDCLinearProgressAdapter {\n return {\n addClass: () => undefined,\n forceLayout: () => undefined,\n setBufferBarStyle: () => null,\n setPrimaryBarStyle: () => null,\n hasClass: () => false,\n removeAttribute: () => undefined,\n removeClass: () => undefined,\n setAttribute: () => undefined,\n };\n }\n\n private isDeterminate!: boolean;\n private isReversed!: boolean;\n private progress!: number;\n private buffer!: number;\n\n constructor(adapter?: Partial<MDCLinearProgressAdapter>) {\n super({...MDCLinearProgressFoundation.defaultAdapter, ...adapter});\n }\n\n init() {\n this.isDeterminate = !this.adapter.hasClass(cssClasses.INDETERMINATE_CLASS);\n this.isReversed = this.adapter.hasClass(cssClasses.REVERSED_CLASS);\n this.progress = 0;\n this.buffer = 1;\n }\n\n setDeterminate(isDeterminate: boolean) {\n this.isDeterminate = isDeterminate;\n\n if (this.isDeterminate) {\n this.adapter.removeClass(cssClasses.INDETERMINATE_CLASS);\n this.adapter.setAttribute(\n strings.ARIA_VALUENOW, this.progress.toString());\n this.setPrimaryBarProgress(this.progress);\n this.setBufferBarProgress(this.buffer);\n\n return;\n }\n\n if (this.isReversed) {\n // Adding/removing REVERSED_CLASS starts a translate animation, while\n // adding INDETERMINATE_CLASS starts a scale animation. Here, we reset\n // the translate animation in order to keep it in sync with the new\n // scale animation that will start from adding INDETERMINATE_CLASS\n // below.\n this.adapter.removeClass(cssClasses.REVERSED_CLASS);\n this.adapter.forceLayout();\n this.adapter.addClass(cssClasses.REVERSED_CLASS);\n }\n\n this.adapter.addClass(cssClasses.INDETERMINATE_CLASS);\n this.adapter.removeAttribute(strings.ARIA_VALUENOW);\n this.setPrimaryBarProgress(1);\n this.setBufferBarProgress(1);\n }\n\n getDeterminate() {\n return this.isDeterminate;\n }\n\n setProgress(value: number) {\n this.progress = value;\n if (this.isDeterminate) {\n this.setPrimaryBarProgress(value);\n this.adapter.setAttribute(strings.ARIA_VALUENOW, value.toString());\n }\n }\n\n getProgress() {\n return this.progress;\n }\n\n setBuffer(value: number) {\n this.buffer = value;\n if (this.isDeterminate) {\n this.setBufferBarProgress(value);\n }\n }\n\n setReverse(isReversed: boolean) {\n this.isReversed = isReversed;\n\n if (!this.isDeterminate) {\n // Adding INDETERMINATE_CLASS starts a scale animation, while\n // adding/removing REVERSED_CLASS starts a translate animation. Here, we\n // reset the scale animation in order to keep it in sync with the new\n // translate animation that will start from adding/removing REVERSED_CLASS\n // below.\n this.adapter.removeClass(cssClasses.INDETERMINATE_CLASS);\n this.adapter.forceLayout();\n this.adapter.addClass(cssClasses.INDETERMINATE_CLASS);\n }\n\n if (this.isReversed) {\n this.adapter.addClass(cssClasses.REVERSED_CLASS);\n return;\n }\n\n this.adapter.removeClass(cssClasses.REVERSED_CLASS);\n }\n\n open() {\n this.adapter.removeClass(cssClasses.CLOSED_CLASS);\n }\n\n close() {\n this.adapter.addClass(cssClasses.CLOSED_CLASS);\n }\n\n private setPrimaryBarProgress(progressValue: number) {\n const value = `scaleX(${progressValue})`;\n\n // Accessing `window` without a `typeof` check will throw on Node environments.\n const transformProp = typeof window !== 'undefined' ?\n getCorrectPropertyName(window, 'transform') : 'transform';\n this.adapter.setPrimaryBarStyle(transformProp, value);\n }\n\n private setBufferBarProgress(progressValue: number) {\n const value = `${progressValue * 100}%`;\n this.adapter.setBufferBarStyle(strings.FLEX_BASIS, value);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCLinearProgressFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {closest, matches} from '@material/dom/ponyfill';\nimport {MDCListAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCListFoundation} from './foundation';\nimport {MDCListActionEventDetail, MDCListIndex} from './types';\n\nexport type MDCListFactory = (el: Element, foundation?: MDCListFoundation) => MDCList;\n\nexport class MDCList extends MDCComponent<MDCListFoundation> {\n set vertical(value: boolean) {\n this.foundation.setVerticalOrientation(value);\n }\n\n get listElements(): Element[] {\n return [].slice.call(\n this.root.querySelectorAll(`.${cssClasses.LIST_ITEM_CLASS}`));\n }\n\n set wrapFocus(value: boolean) {\n this.foundation.setWrapFocus(value);\n }\n\n /**\n * @return Whether typeahead is currently matching a user-specified prefix.\n */\n get typeaheadInProgress(): boolean {\n return this.foundation.isTypeaheadInProgress();\n }\n\n /**\n * Sets whether typeahead functionality is enabled on the list.\n * @param hasTypeahead Whether typeahead is enabled.\n */\n set hasTypeahead(hasTypeahead: boolean) {\n this.foundation.setHasTypeahead(hasTypeahead);\n }\n\n set singleSelection(isSingleSelectionList: boolean) {\n this.foundation.setSingleSelection(isSingleSelectionList);\n }\n\n get selectedIndex(): MDCListIndex {\n return this.foundation.getSelectedIndex();\n }\n\n set selectedIndex(index: MDCListIndex) {\n this.foundation.setSelectedIndex(index);\n }\n\n static attachTo(root: Element) {\n return new MDCList(root);\n }\n\n private handleKeydown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n private handleClick_!: SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n private focusInEventListener_!: SpecificEventListener<'focus'>; // assigned in initialSyncWithDOM()\n private focusOutEventListener_!: SpecificEventListener<'focus'>; // assigned in initialSyncWithDOM()\n\n initialSyncWithDOM() {\n this.handleClick_ = this.handleClickEvent_.bind(this);\n this.handleKeydown_ = this.handleKeydownEvent_.bind(this);\n this.focusInEventListener_ = this.handleFocusInEvent_.bind(this);\n this.focusOutEventListener_ = this.handleFocusOutEvent_.bind(this);\n this.listen('keydown', this.handleKeydown_);\n this.listen('click', this.handleClick_);\n this.listen('focusin', this.focusInEventListener_);\n this.listen('focusout', this.focusOutEventListener_);\n this.layout();\n this.initializeListType();\n }\n\n destroy() {\n this.unlisten('keydown', this.handleKeydown_);\n this.unlisten('click', this.handleClick_);\n this.unlisten('focusin', this.focusInEventListener_);\n this.unlisten('focusout', this.focusOutEventListener_);\n }\n\n layout() {\n const direction = this.root.getAttribute(strings.ARIA_ORIENTATION);\n this.vertical = direction !== strings.ARIA_ORIENTATION_HORIZONTAL;\n\n // List items need to have at least tabindex=-1 to be focusable.\n [].slice.call(this.root.querySelectorAll('.mdc-list-item:not([tabindex])'))\n .forEach((el: Element) => {\n el.setAttribute('tabindex', '-1');\n });\n\n // Child button/a elements are not tabbable until the list item is focused.\n [].slice.call(this.root.querySelectorAll(strings.FOCUSABLE_CHILD_ELEMENTS))\n .forEach((el: Element) => el.setAttribute('tabindex', '-1'));\n\n this.foundation.layout();\n }\n\n /**\n * Extracts the primary text from a list item.\n * @param item The list item element.\n * @return The primary text in the element.\n */\n getPrimaryText(item: Element): string {\n const primaryText =\n item.querySelector(`.${cssClasses.LIST_ITEM_PRIMARY_TEXT_CLASS}`);\n if (primaryText) {\n return primaryText.textContent || '';\n }\n\n const singleLineText =\n item.querySelector(`.${cssClasses.LIST_ITEM_TEXT_CLASS}`);\n return (singleLineText && singleLineText.textContent) || '';\n }\n\n /**\n * Initialize selectedIndex value based on pre-selected checkbox list items, single selection or radio.\n */\n initializeListType() {\n const checkboxListItems =\n this.root.querySelectorAll(strings.ARIA_ROLE_CHECKBOX_SELECTOR);\n const singleSelectedListItem = this.root.querySelector(`\n .${cssClasses.LIST_ITEM_ACTIVATED_CLASS},\n .${cssClasses.LIST_ITEM_SELECTED_CLASS}\n `);\n const radioSelectedListItem =\n this.root.querySelector(strings.ARIA_CHECKED_RADIO_SELECTOR);\n\n if (checkboxListItems.length) {\n const preselectedItems =\n this.root.querySelectorAll(strings.ARIA_CHECKED_CHECKBOX_SELECTOR);\n this.selectedIndex =\n [].map.call(preselectedItems, (listItem: Element) => this.listElements.indexOf(listItem)) as number[];\n } else if (singleSelectedListItem) {\n if (singleSelectedListItem.classList.contains(cssClasses.LIST_ITEM_ACTIVATED_CLASS)) {\n this.foundation.setUseActivatedClass(true);\n }\n\n this.singleSelection = true;\n this.selectedIndex = this.listElements.indexOf(singleSelectedListItem);\n } else if (radioSelectedListItem) {\n this.selectedIndex = this.listElements.indexOf(radioSelectedListItem);\n }\n }\n\n /**\n * Updates the list item at itemIndex to the desired isEnabled state.\n * @param itemIndex Index of the list item\n * @param isEnabled Sets the list item to enabled or disabled.\n */\n setEnabled(itemIndex: number, isEnabled: boolean) {\n this.foundation.setEnabled(itemIndex, isEnabled);\n }\n\n /**\n * Given the next desired character from the user, adds it to the typeahead\n * buffer. Then, attempts to find the next option matching the buffer. Wraps\n * around if at the end of options.\n *\n * @param nextChar The next character to add to the prefix buffer.\n * @param startingIndex The index from which to start matching. Defaults to\n * the currently focused index.\n * @return The index of the matched item.\n */\n typeaheadMatchItem(nextChar: string, startingIndex?: number): number {\n return this.foundation.typeaheadMatchItem(\n nextChar, startingIndex, /** skipFocus */ true);\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCListAdapter = {\n addClassForElementIndex: (index, className) => {\n const element = this.listElements[index];\n if (element) {\n element.classList.add(className);\n }\n },\n focusItemAtIndex: (index) => {\n const element = this.listElements[index] as HTMLElement | undefined;\n if (element) {\n element.focus();\n }\n },\n getAttributeForElementIndex: (index, attr) =>\n this.listElements[index].getAttribute(attr),\n getFocusedElementIndex: () =>\n this.listElements.indexOf(document.activeElement!),\n getListItemCount: () => this.listElements.length,\n getPrimaryTextAtIndex: (index) =>\n this.getPrimaryText(this.listElements[index]),\n hasCheckboxAtIndex: (index) => {\n const listItem = this.listElements[index];\n return !!listItem.querySelector(strings.CHECKBOX_SELECTOR);\n },\n hasRadioAtIndex: (index) => {\n const listItem = this.listElements[index];\n return !!listItem.querySelector(strings.RADIO_SELECTOR);\n },\n isCheckboxCheckedAtIndex: (index) => {\n const listItem = this.listElements[index];\n const toggleEl = listItem.querySelector<HTMLInputElement>(strings.CHECKBOX_SELECTOR);\n return toggleEl!.checked;\n },\n isFocusInsideList: () => {\n return this.root.contains(document.activeElement);\n },\n isRootFocused: () => document.activeElement === this.root,\n listItemAtIndexHasClass: (index, className) =>\n this.listElements[index].classList.contains(className),\n notifyAction: (index) => {\n this.emit<MDCListActionEventDetail>(strings.ACTION_EVENT, {index}, /** shouldBubble */ true);\n },\n removeClassForElementIndex: (index, className) => {\n const element = this.listElements[index];\n if (element) {\n element.classList.remove(className);\n }\n },\n setAttributeForElementIndex: (index, attr, value) => {\n const element = this.listElements[index];\n if (element) {\n element.setAttribute(attr, value);\n }\n },\n setCheckedCheckboxOrRadioAtIndex: (index, isChecked) => {\n const listItem = this.listElements[index];\n const toggleEl = listItem.querySelector<HTMLInputElement>(strings.CHECKBOX_RADIO_SELECTOR);\n toggleEl!.checked = isChecked;\n\n const event = document.createEvent('Event');\n event.initEvent('change', true, true);\n toggleEl!.dispatchEvent(event);\n },\n setTabIndexForListItemChildren: (listItemIndex, tabIndexValue) => {\n const element = this.listElements[listItemIndex];\n const listItemChildren: Element[] =\n [].slice.call(element.querySelectorAll(strings.CHILD_ELEMENTS_TO_TOGGLE_TABINDEX));\n listItemChildren.forEach((el) => el.setAttribute('tabindex', tabIndexValue));\n },\n };\n return new MDCListFoundation(adapter);\n }\n\n /**\n * Used to figure out which list item this event is targetting. Or returns -1 if\n * there is no list item\n */\n private getListItemIndex_(evt: Event) {\n const eventTarget = evt.target as Element;\n const nearestParent = closest(eventTarget, `.${cssClasses.LIST_ITEM_CLASS}, .${cssClasses.ROOT}`);\n\n // Get the index of the element if it is a list item.\n if (nearestParent && matches(nearestParent, `.${cssClasses.LIST_ITEM_CLASS}`)) {\n return this.listElements.indexOf(nearestParent);\n }\n\n return -1;\n }\n\n /**\n * Used to figure out which element was clicked before sending the event to the foundation.\n */\n private handleFocusInEvent_(evt: FocusEvent) {\n const index = this.getListItemIndex_(evt);\n this.foundation.handleFocusIn(evt, index);\n }\n\n /**\n * Used to figure out which element was clicked before sending the event to the foundation.\n */\n private handleFocusOutEvent_(evt: FocusEvent) {\n const index = this.getListItemIndex_(evt);\n this.foundation.handleFocusOut(evt, index);\n }\n\n /**\n * Used to figure out which element was focused when keydown event occurred before sending the event to the\n * foundation.\n */\n private handleKeydownEvent_(evt: KeyboardEvent) {\n const index = this.getListItemIndex_(evt);\n const target = evt.target as Element;\n this.foundation.handleKeydown(\n evt, target.classList.contains(cssClasses.LIST_ITEM_CLASS), index);\n }\n\n /**\n * Used to figure out which element was clicked before sending the event to the foundation.\n */\n private handleClickEvent_(evt: MouseEvent) {\n const index = this.getListItemIndex_(evt);\n const target = evt.target as Element;\n\n // Toggle the checkbox only if it's not the target of the event, or the checkbox will have 2 change events.\n const toggleCheckbox = !matches(target, strings.CHECKBOX_RADIO_SELECTOR);\n this.foundation.handleClick(index, toggleCheckbox);\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n LIST_ITEM_ACTIVATED_CLASS: 'mdc-list-item--activated',\n LIST_ITEM_CLASS: 'mdc-list-item',\n LIST_ITEM_DISABLED_CLASS: 'mdc-list-item--disabled',\n LIST_ITEM_SELECTED_CLASS: 'mdc-list-item--selected',\n LIST_ITEM_TEXT_CLASS: 'mdc-list-item__text',\n LIST_ITEM_PRIMARY_TEXT_CLASS: 'mdc-list-item__primary-text',\n ROOT: 'mdc-list',\n};\n\nconst strings = {\n ACTION_EVENT: 'MDCList:action',\n ARIA_CHECKED: 'aria-checked',\n ARIA_CHECKED_CHECKBOX_SELECTOR: '[role=\"checkbox\"][aria-checked=\"true\"]',\n ARIA_CHECKED_RADIO_SELECTOR: '[role=\"radio\"][aria-checked=\"true\"]',\n ARIA_CURRENT: 'aria-current',\n ARIA_DISABLED: 'aria-disabled',\n ARIA_ORIENTATION: 'aria-orientation',\n ARIA_ORIENTATION_HORIZONTAL: 'horizontal',\n ARIA_ROLE_CHECKBOX_SELECTOR: '[role=\"checkbox\"]',\n ARIA_SELECTED: 'aria-selected',\n CHECKBOX_RADIO_SELECTOR: 'input[type=\"checkbox\"], input[type=\"radio\"]',\n CHECKBOX_SELECTOR: 'input[type=\"checkbox\"]',\n CHILD_ELEMENTS_TO_TOGGLE_TABINDEX: `\n .${cssClasses.LIST_ITEM_CLASS} button:not(:disabled),\n .${cssClasses.LIST_ITEM_CLASS} a\n `,\n FOCUSABLE_CHILD_ELEMENTS: `\n .${cssClasses.LIST_ITEM_CLASS} button:not(:disabled),\n .${cssClasses.LIST_ITEM_CLASS} a,\n .${cssClasses.LIST_ITEM_CLASS} input[type=\"radio\"]:not(:disabled),\n .${cssClasses.LIST_ITEM_CLASS} input[type=\"checkbox\"]:not(:disabled)\n `,\n RADIO_SELECTOR: 'input[type=\"radio\"]',\n};\n\nconst numbers = {\n UNSET_INDEX: -1,\n TYPEAHEAD_BUFFER_CLEAR_TIMEOUT_MS: 300\n};\n\nexport {strings, cssClasses, numbers};\n","/**\n * @license\n * Copyright 2020 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 */\n\nconst ELEMENTS_KEY_ALLOWED_IN = ['input', 'button', 'textarea', 'select'];\n\n/**\n * Ensures that preventDefault is only called if the containing element\n * doesn't consume the event, and it will cause an unintended scroll.\n *\n * @param evt keyboard event to be prevented.\n */\nexport const preventDefaultEvent = (evt: KeyboardEvent) => {\n const target = evt.target as Element;\n if (!target) {\n return;\n }\n const tagName = `${target.tagName}`.toLowerCase();\n if (ELEMENTS_KEY_ALLOWED_IN.indexOf(tagName) === -1) {\n evt.preventDefault();\n }\n}\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {normalizeKey} from '@material/dom/keyboard';\n\nimport {MDCListAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\nimport * as typeahead from './typeahead';\nimport {MDCListIndex, MDCListTextAndIndex} from './types';\nimport {preventDefaultEvent} from './events';\n\nfunction isNumberArray(selectedIndex: MDCListIndex): selectedIndex is number[] {\n return selectedIndex instanceof Array;\n}\n\nexport class MDCListFoundation extends MDCFoundation<MDCListAdapter> {\n static get strings() {\n return strings;\n }\n\n static get cssClasses() {\n return cssClasses;\n }\n\n static get numbers() {\n return numbers;\n }\n\n static get defaultAdapter(): MDCListAdapter {\n return {\n addClassForElementIndex: () => undefined,\n focusItemAtIndex: () => undefined,\n getAttributeForElementIndex: () => null,\n getFocusedElementIndex: () => 0,\n getListItemCount: () => 0,\n hasCheckboxAtIndex: () => false,\n hasRadioAtIndex: () => false,\n isCheckboxCheckedAtIndex: () => false,\n isFocusInsideList: () => false,\n isRootFocused: () => false,\n listItemAtIndexHasClass: () => false,\n notifyAction: () => undefined,\n removeClassForElementIndex: () => undefined,\n setAttributeForElementIndex: () => undefined,\n setCheckedCheckboxOrRadioAtIndex: () => undefined,\n setTabIndexForListItemChildren: () => undefined,\n getPrimaryTextAtIndex: () => '',\n };\n }\n\n private wrapFocus_ = false;\n private isVertical_ = true;\n private isSingleSelectionList_ = false;\n private selectedIndex_: MDCListIndex = numbers.UNSET_INDEX;\n private focusedItemIndex = numbers.UNSET_INDEX;\n private useActivatedClass_ = false;\n private ariaCurrentAttrValue_: string | null = null;\n private isCheckboxList_ = false;\n private isRadioList_ = false;\n\n private hasTypeahead = false;\n // Transiently holds current typeahead prefix from user.\n private readonly typeaheadState = typeahead.initState();\n private sortedIndexByFirstChar = new Map<string, MDCListTextAndIndex[]>();\n\n constructor(adapter?: Partial<MDCListAdapter>) {\n super({...MDCListFoundation.defaultAdapter, ...adapter});\n }\n\n layout() {\n if (this.adapter.getListItemCount() === 0) {\n return;\n }\n\n if (this.adapter.hasCheckboxAtIndex(0)) {\n this.isCheckboxList_ = true;\n } else if (this.adapter.hasRadioAtIndex(0)) {\n this.isRadioList_ = true;\n }\n\n if (this.hasTypeahead) {\n this.sortedIndexByFirstChar = this.typeaheadInitSortedIndex();\n }\n }\n\n /**\n * Sets the private wrapFocus_ variable.\n */\n setWrapFocus(value: boolean) {\n this.wrapFocus_ = value;\n }\n\n /**\n * Sets the isVertical_ private variable.\n */\n setVerticalOrientation(value: boolean) {\n this.isVertical_ = value;\n }\n\n /**\n * Sets the isSingleSelectionList_ private variable.\n */\n setSingleSelection(value: boolean) {\n this.isSingleSelectionList_ = value;\n }\n\n /**\n * Sets whether typeahead is enabled on the list.\n * @param hasTypeahead Whether typeahead is enabled.\n */\n setHasTypeahead(hasTypeahead: boolean) {\n this.hasTypeahead = hasTypeahead;\n if (hasTypeahead) {\n this.sortedIndexByFirstChar = this.typeaheadInitSortedIndex();\n }\n }\n\n /**\n * @return Whether typeahead is currently matching a user-specified prefix.\n */\n isTypeaheadInProgress(): boolean {\n return this.hasTypeahead &&\n typeahead.isTypingInProgress(this.typeaheadState);\n }\n\n /**\n * Sets the useActivatedClass_ private variable.\n */\n setUseActivatedClass(useActivated: boolean) {\n this.useActivatedClass_ = useActivated;\n }\n\n getSelectedIndex(): MDCListIndex {\n return this.selectedIndex_;\n }\n\n setSelectedIndex(index: MDCListIndex) {\n if (!this.isIndexValid_(index)) {\n return;\n }\n\n if (this.isCheckboxList_) {\n this.setCheckboxAtIndex_(index as number[]);\n } else if (this.isRadioList_) {\n this.setRadioAtIndex_(index as number);\n } else {\n this.setSingleSelectionAtIndex_(index as number);\n }\n }\n\n /**\n * Focus in handler for the list items.\n */\n handleFocusIn(_: FocusEvent, listItemIndex: number) {\n if (listItemIndex >= 0) {\n this.focusedItemIndex = listItemIndex;\n this.adapter.setTabIndexForListItemChildren(listItemIndex, '0');\n }\n }\n\n /**\n * Focus out handler for the list items.\n */\n handleFocusOut(_: FocusEvent, listItemIndex: number) {\n if (listItemIndex >= 0) {\n this.adapter.setTabIndexForListItemChildren(listItemIndex, '-1');\n }\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(() => {\n if (!this.adapter.isFocusInsideList()) {\n this.setTabindexToFirstSelectedItem_();\n }\n }, 0);\n }\n\n /**\n * Key handler for the list.\n */\n handleKeydown(\n event: KeyboardEvent, isRootListItem: boolean, listItemIndex: number) {\n const isArrowLeft = normalizeKey(event) === 'ArrowLeft';\n const isArrowUp = normalizeKey(event) === 'ArrowUp';\n const isArrowRight = normalizeKey(event) === 'ArrowRight';\n const isArrowDown = normalizeKey(event) === 'ArrowDown';\n const isHome = normalizeKey(event) === 'Home';\n const isEnd = normalizeKey(event) === 'End';\n const isEnter = normalizeKey(event) === 'Enter';\n const isSpace = normalizeKey(event) === 'Spacebar';\n\n if (this.adapter.isRootFocused()) {\n if (isArrowUp || isEnd) {\n event.preventDefault();\n this.focusLastElement();\n } else if (isArrowDown || isHome) {\n event.preventDefault();\n this.focusFirstElement();\n }\n\n if (this.hasTypeahead) {\n const handleKeydownOpts: typeahead.HandleKeydownOpts = {\n event,\n focusItemAtIndex: (index) => {\n this.focusItemAtIndex(index)\n },\n focusedItemIndex: -1,\n isTargetListItem: isRootListItem,\n sortedIndexByFirstChar: this.sortedIndexByFirstChar,\n isItemAtIndexDisabled: (index) =>\n this.adapter.listItemAtIndexHasClass(\n index, cssClasses.LIST_ITEM_DISABLED_CLASS),\n };\n\n typeahead.handleKeydown(handleKeydownOpts, this.typeaheadState);\n }\n\n return;\n }\n\n let 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\n if ((this.isVertical_ && isArrowDown) || (!this.isVertical_ && isArrowRight)) {\n preventDefaultEvent(event);\n this.focusNextElement(currentIndex);\n } else if ((this.isVertical_ && isArrowUp) || (!this.isVertical_ && isArrowLeft)) {\n preventDefaultEvent(event);\n this.focusPrevElement(currentIndex);\n } else if (isHome) {\n preventDefaultEvent(event);\n this.focusFirstElement();\n } else if (isEnd) {\n preventDefaultEvent(event);\n this.focusLastElement();\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 const target = event.target as Element | null;\n if (target && target.tagName === 'A' && isEnter) {\n return;\n }\n preventDefaultEvent(event);\n\n if (this.adapter.listItemAtIndexHasClass(\n currentIndex, cssClasses.LIST_ITEM_DISABLED_CLASS)) {\n return;\n }\n\n if (!this.isTypeaheadInProgress()) {\n if (this.isSelectableList_()) {\n this.setSelectedIndexOnAction_(currentIndex);\n }\n this.adapter.notifyAction(currentIndex);\n }\n }\n }\n\n if (this.hasTypeahead) {\n const handleKeydownOpts: typeahead.HandleKeydownOpts = {\n event,\n focusItemAtIndex: (index) => {\n this.focusItemAtIndex(index)\n },\n focusedItemIndex: this.focusedItemIndex,\n isTargetListItem: isRootListItem,\n sortedIndexByFirstChar: this.sortedIndexByFirstChar,\n isItemAtIndexDisabled: (index) => this.adapter.listItemAtIndexHasClass(\n index, cssClasses.LIST_ITEM_DISABLED_CLASS),\n };\n\n typeahead.handleKeydown(handleKeydownOpts, this.typeaheadState);\n }\n }\n\n /**\n * Click handler for the list.\n */\n handleClick(index: number, toggleCheckbox: boolean) {\n if (index === numbers.UNSET_INDEX) {\n return;\n }\n\n this.setTabindexAtIndex_(index);\n this.focusedItemIndex = index;\n\n if (this.adapter.listItemAtIndexHasClass(\n index, cssClasses.LIST_ITEM_DISABLED_CLASS)) {\n return;\n }\n if (this.isSelectableList_()) {\n this.setSelectedIndexOnAction_(index, toggleCheckbox);\n }\n\n this.adapter.notifyAction(index);\n }\n\n /**\n * Focuses the next element on the list.\n */\n focusNextElement(index: number) {\n const count = this.adapter.getListItemCount();\n let nextIndex = index + 1;\n if (nextIndex >= count) {\n if (this.wrapFocus_) {\n nextIndex = 0;\n } else {\n // Return early because last item is already focused.\n return index;\n }\n }\n this.focusItemAtIndex(nextIndex);\n\n return nextIndex;\n }\n\n /**\n * Focuses the previous element on the list.\n */\n focusPrevElement(index: number) {\n let prevIndex = index - 1;\n if (prevIndex < 0) {\n if (this.wrapFocus_) {\n prevIndex = this.adapter.getListItemCount() - 1;\n } else {\n // Return early because first item is already focused.\n return index;\n }\n }\n this.focusItemAtIndex(prevIndex);\n return prevIndex;\n }\n\n focusFirstElement() {\n this.focusItemAtIndex(0);\n return 0;\n }\n\n focusLastElement() {\n const lastIndex = this.adapter.getListItemCount() - 1;\n this.focusItemAtIndex(lastIndex);\n return lastIndex;\n }\n\n /**\n * @param itemIndex Index of the list item\n * @param isEnabled Sets the list item to enabled or disabled.\n */\n setEnabled(itemIndex: number, isEnabled: boolean): void {\n if (!this.isIndexValid_(itemIndex)) {\n return;\n }\n\n if (isEnabled) {\n this.adapter.removeClassForElementIndex(\n itemIndex, cssClasses.LIST_ITEM_DISABLED_CLASS);\n this.adapter.setAttributeForElementIndex(\n itemIndex, strings.ARIA_DISABLED, 'false');\n } else {\n this.adapter.addClassForElementIndex(\n itemIndex, cssClasses.LIST_ITEM_DISABLED_CLASS);\n this.adapter.setAttributeForElementIndex(\n itemIndex, strings.ARIA_DISABLED, 'true');\n }\n }\n\n\n private setSingleSelectionAtIndex_(index: number) {\n if (this.selectedIndex_ === index) {\n return;\n }\n\n let selectedClassName = cssClasses.LIST_ITEM_SELECTED_CLASS;\n if (this.useActivatedClass_) {\n selectedClassName = cssClasses.LIST_ITEM_ACTIVATED_CLASS;\n }\n\n if (this.selectedIndex_ !== numbers.UNSET_INDEX) {\n this.adapter.removeClassForElementIndex(\n this.selectedIndex_ as number, selectedClassName);\n }\n this.adapter.addClassForElementIndex(index, selectedClassName);\n this.setAriaForSingleSelectionAtIndex_(index);\n\n this.selectedIndex_ = index;\n }\n\n /**\n * Sets aria attribute for single selection at given index.\n */\n private setAriaForSingleSelectionAtIndex_(index: number) {\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\n const isAriaCurrent = this.ariaCurrentAttrValue_ !== null;\n const ariaAttribute = isAriaCurrent ? strings.ARIA_CURRENT : strings.ARIA_SELECTED;\n\n if (this.selectedIndex_ !== numbers.UNSET_INDEX) {\n this.adapter.setAttributeForElementIndex(\n this.selectedIndex_ as number, ariaAttribute, 'false');\n }\n\n const ariaAttributeValue = isAriaCurrent ? this.ariaCurrentAttrValue_ : 'true';\n this.adapter.setAttributeForElementIndex(\n index, ariaAttribute, ariaAttributeValue as string);\n }\n\n /**\n * Toggles radio at give index. Radio doesn't change the checked state if it is already checked.\n */\n private setRadioAtIndex_(index: number) {\n this.adapter.setCheckedCheckboxOrRadioAtIndex(index, true);\n\n if (this.selectedIndex_ !== numbers.UNSET_INDEX) {\n this.adapter.setAttributeForElementIndex(\n this.selectedIndex_ as number, strings.ARIA_CHECKED, 'false');\n }\n\n this.adapter.setAttributeForElementIndex(\n index, strings.ARIA_CHECKED, 'true');\n\n this.selectedIndex_ = index;\n }\n\n private setCheckboxAtIndex_(index: number[]) {\n for (let i = 0; i < this.adapter.getListItemCount(); i++) {\n let isChecked = false;\n if (index.indexOf(i) >= 0) {\n isChecked = true;\n }\n\n this.adapter.setCheckedCheckboxOrRadioAtIndex(i, isChecked);\n this.adapter.setAttributeForElementIndex(\n i, strings.ARIA_CHECKED, isChecked ? 'true' : 'false');\n }\n\n this.selectedIndex_ = index;\n }\n\n private setTabindexAtIndex_(index: number) {\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 } else if (this.focusedItemIndex >= 0 && this.focusedItemIndex !== index) {\n this.adapter.setAttributeForElementIndex(\n this.focusedItemIndex, 'tabindex', '-1');\n }\n\n this.adapter.setAttributeForElementIndex(index, 'tabindex', '0');\n }\n\n /**\n * @return Return true if it is single selectin list, checkbox list or radio list.\n */\n private isSelectableList_() {\n return this.isSingleSelectionList_ || this.isCheckboxList_ || this.isRadioList_;\n }\n\n private setTabindexToFirstSelectedItem_() {\n let targetIndex = 0;\n\n if (this.isSelectableList_()) {\n if (typeof this.selectedIndex_ === 'number' && this.selectedIndex_ !== numbers.UNSET_INDEX) {\n targetIndex = this.selectedIndex_;\n } else if (isNumberArray(this.selectedIndex_) && this.selectedIndex_.length > 0) {\n targetIndex = this.selectedIndex_.reduce((currentIndex, minIndex) => Math.min(currentIndex, minIndex));\n }\n }\n\n this.setTabindexAtIndex_(targetIndex);\n }\n\n private isIndexValid_(index: MDCListIndex) {\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\n if (index.length === 0) {\n return true;\n } else {\n return index.some((i) => this.isIndexInRange_(i));\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 } else {\n return false;\n }\n }\n\n private isIndexInRange_(index: number) {\n const listSize = this.adapter.getListItemCount();\n return index >= 0 && index < listSize;\n }\n\n /**\n * Sets selected index on user action, toggles checkbox / radio based on toggleCheckbox value.\n * User interaction should not toggle list item(s) when disabled.\n */\n private setSelectedIndexOnAction_(index: number, toggleCheckbox = true) {\n if (this.isCheckboxList_) {\n this.toggleCheckboxAtIndex_(index, toggleCheckbox);\n } else {\n this.setSelectedIndex(index);\n }\n }\n\n private toggleCheckboxAtIndex_(index: number, toggleCheckbox: boolean) {\n let isChecked = this.adapter.isCheckboxCheckedAtIndex(index);\n\n if (toggleCheckbox) {\n isChecked = !isChecked;\n this.adapter.setCheckedCheckboxOrRadioAtIndex(index, isChecked);\n }\n\n this.adapter.setAttributeForElementIndex(\n index, strings.ARIA_CHECKED, isChecked ? 'true' : 'false');\n\n // If none of the checkbox items are selected and selectedIndex is not initialized then provide a default value.\n let selectedIndexes = this.selectedIndex_ === numbers.UNSET_INDEX ? [] : (this.selectedIndex_ as number[]).slice();\n\n if (isChecked) {\n selectedIndexes.push(index);\n } else {\n selectedIndexes = selectedIndexes.filter((i) => i !== index);\n }\n\n this.selectedIndex_ = selectedIndexes;\n }\n\n private focusItemAtIndex(index: number) {\n this.setTabindexAtIndex_(index);\n this.adapter.focusItemAtIndex(index);\n this.focusedItemIndex = index;\n }\n\n /**\n * Given the next desired character from the user, adds it to the typeahead\n * buffer. Then, attempts to find the next option matching the buffer. Wraps\n * around if at the end of options.\n *\n * @param nextChar The next character to add to the prefix buffer.\n * @param startingIndex The index from which to start matching. Only relevant\n * when starting a new match sequence. To start a new match sequence,\n * clear the buffer using `clearTypeaheadBuffer`, or wait for the buffer\n * to clear after a set interval defined in list foundation. Defaults to\n * the currently focused index.\n * @return The index of the matched item, or -1 if no match.\n */\n typeaheadMatchItem(\n nextChar: string, startingIndex?: number, skipFocus = false) {\n const opts: typeahead.TypeaheadMatchItemOpts = {\n focusItemAtIndex: (index) => {\n this.focusItemAtIndex(index)\n },\n focusedItemIndex: startingIndex ? startingIndex : this.focusedItemIndex,\n nextChar,\n sortedIndexByFirstChar: this.sortedIndexByFirstChar,\n skipFocus,\n isItemAtIndexDisabled: (index) => this.adapter.listItemAtIndexHasClass(\n index, cssClasses.LIST_ITEM_DISABLED_CLASS)\n };\n return typeahead.matchItem(opts, this.typeaheadState);\n }\n\n /**\n * Initializes the MDCListTextAndIndex data structure by indexing the current\n * list items by primary text.\n *\n * @return The primary texts of all the list items sorted by first character.\n */\n private typeaheadInitSortedIndex() {\n return typeahead.initSortedIndex(\n this.adapter.getListItemCount(), this.adapter.getPrimaryTextAtIndex);\n }\n\n /**\n * Clears the typeahead buffer.\n */\n clearTypeaheadBuffer() {\n typeahead.clearBuffer(this.typeaheadState);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCListFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2020 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 */\n\nimport {normalizeKey} from '@material/dom/keyboard';\n\nimport {numbers} from './constants';\nimport {preventDefaultEvent} from './events';\nimport {MDCListTextAndIndex} from './types';\n\n/**\n * State of a typeahead instance.\n */\nexport interface TypeaheadState {\n typeaheadBuffer: string;\n currentFirstChar: string;\n sortedIndexCursor: number;\n bufferClearTimeout: number;\n}\n\n/**\n * Initializes a state object for typeahead. Use the same reference for calls to\n * typeahead functions.\n *\n * @return The current state of the typeahead process. Each state reference\n * represents a typeahead instance as the reference is typically mutated\n * in-place.\n */\nexport function initState(): TypeaheadState {\n const state: TypeaheadState = {\n bufferClearTimeout: 0,\n currentFirstChar: '',\n sortedIndexCursor: 0,\n typeaheadBuffer: '',\n };\n return state;\n}\n\n/**\n * Initializes typeahead state by indexing the current list items by primary\n * text into the sortedIndexByFirstChar data structure.\n *\n * @param listItemCount numer of items in the list\n * @param getPrimaryTextByItemIndex function that returns the primary text at a\n * given index\n *\n * @return Map that maps the first character of the primary text to the full\n * list text and it's index\n */\nexport function initSortedIndex(\n listItemCount: number,\n getPrimaryTextByItemIndex: (index: number) =>\n string): Map<string, MDCListTextAndIndex[]> {\n const sortedIndexByFirstChar = new Map<string, MDCListTextAndIndex[]>();\n\n // Aggregate item text to index mapping\n for (let i = 0; i < listItemCount; i++) {\n const primaryText = getPrimaryTextByItemIndex(i).trim();\n if (!primaryText) {\n continue;\n }\n\n const firstChar = primaryText[0].toLowerCase();\n if (!sortedIndexByFirstChar.has(firstChar)) {\n sortedIndexByFirstChar.set(firstChar, []);\n }\n sortedIndexByFirstChar.get(firstChar)!.push(\n {text: primaryText.toLowerCase(), index: i});\n }\n\n // Sort the mapping\n // TODO(b/157162694): Investigate replacing forEach with Map.values()\n sortedIndexByFirstChar.forEach((values) => {\n values.sort((first: MDCListTextAndIndex, second: MDCListTextAndIndex) => {\n return first.index - second.index;\n });\n });\n\n return sortedIndexByFirstChar;\n}\n\n/**\n * Arguments for matchItem\n */\nexport interface TypeaheadMatchItemOpts {\n focusItemAtIndex: (index: number) => void;\n nextChar: string;\n focusedItemIndex: number;\n sortedIndexByFirstChar: Map<string, MDCListTextAndIndex[]>;\n skipFocus: boolean;\n isItemAtIndexDisabled: (index: number) => boolean;\n}\n\n/**\n * Given the next desired character from the user, it attempts to find the next\n * list option matching the buffer. Wraps around if at the end of options.\n *\n * @param opts Options and accessors\n * - nextChar - the next character to match against items\n * - sortedIndexByFirstChar - output of `initSortedIndex(...)`\n * - focusedItemIndex - the index of the currently focused item\n * - focusItemAtIndex - function that focuses a list item at given index\n * - skipFocus - whether or not to focus the matched item\n * - isItemAtIndexDisabled - function that determines whether an item at a\n * given index is disabled\n * @param state The typeahead state instance. See `initState`.\n *\n * @return The index of the matched item, or -1 if no match.\n */\nexport function matchItem(\n opts: TypeaheadMatchItemOpts, state: TypeaheadState): number {\n const {\n nextChar,\n focusItemAtIndex,\n sortedIndexByFirstChar,\n focusedItemIndex,\n skipFocus,\n isItemAtIndexDisabled,\n } = opts;\n\n clearTimeout(state.bufferClearTimeout);\n\n state.bufferClearTimeout = setTimeout(() => {\n clearBuffer(state);\n }, numbers.TYPEAHEAD_BUFFER_CLEAR_TIMEOUT_MS);\n\n state.typeaheadBuffer = state.typeaheadBuffer + nextChar;\n\n let index: number;\n if (state.typeaheadBuffer.length === 1) {\n index = matchFirstChar(\n sortedIndexByFirstChar, focusedItemIndex, isItemAtIndexDisabled, state);\n } else {\n index = matchAllChars(sortedIndexByFirstChar, isItemAtIndexDisabled, state);\n }\n\n if (index !== -1 && !skipFocus) {\n focusItemAtIndex(index);\n }\n return index;\n}\n\n/**\n * Matches the user's single input character in the buffer to the\n * next option that begins with such character. Wraps around if at\n * end of options. Returns -1 if no match is found.\n */\nfunction matchFirstChar(\n sortedIndexByFirstChar: Map<string, MDCListTextAndIndex[]>,\n focusedItemIndex: number, isItemAtIndexDisabled: (index: number) => boolean,\n state: TypeaheadState): number {\n const firstChar = state.typeaheadBuffer[0];\n const itemsMatchingFirstChar = sortedIndexByFirstChar.get(firstChar);\n if (!itemsMatchingFirstChar) {\n return -1;\n }\n\n // Has the same firstChar been recently matched?\n // Also, did starting index remain the same between key presses?\n // If both hold true, simply increment index.\n if (firstChar === state.currentFirstChar &&\n itemsMatchingFirstChar[state.sortedIndexCursor].index ===\n focusedItemIndex) {\n state.sortedIndexCursor =\n (state.sortedIndexCursor + 1) % itemsMatchingFirstChar.length;\n\n const newIndex = itemsMatchingFirstChar[state.sortedIndexCursor].index;\n if (!isItemAtIndexDisabled(newIndex)) {\n return newIndex;\n }\n }\n\n // If we're here, it means one of the following happened:\n // - either firstChar or startingIndex has changed, invalidating the\n // cursor.\n // - The next item of typeahead is disabled, so we have to look further.\n state.currentFirstChar = firstChar;\n\n let newCursorPosition = -1;\n let cursorPosition;\n // Find the first non-disabled item as a fallback.\n for (cursorPosition = 0; cursorPosition < itemsMatchingFirstChar.length;\n cursorPosition++) {\n if (!isItemAtIndexDisabled(itemsMatchingFirstChar[cursorPosition].index)) {\n newCursorPosition = cursorPosition;\n break;\n }\n }\n\n // Advance cursor to first item matching the firstChar that is positioned\n // after starting item. Cursor is unchanged from fallback if there's no\n // such item.\n for (; cursorPosition < itemsMatchingFirstChar.length; cursorPosition++) {\n if (itemsMatchingFirstChar[cursorPosition].index > focusedItemIndex &&\n !isItemAtIndexDisabled(itemsMatchingFirstChar[cursorPosition].index)) {\n newCursorPosition = cursorPosition;\n break;\n }\n }\n\n if (newCursorPosition !== -1) {\n state.sortedIndexCursor = newCursorPosition;\n return itemsMatchingFirstChar[state.sortedIndexCursor].index;\n }\n\n return -1;\n}\n\n/**\n * Attempts to find the next item that matches all of the typeahead buffer.\n * Wraps around if at end of options. Returns -1 if no match is found.\n */\nfunction matchAllChars(\n sortedIndexByFirstChar: Map<string, MDCListTextAndIndex[]>,\n isItemAtIndexDisabled: (index: number) => boolean,\n state: TypeaheadState): number {\n const firstChar = state.typeaheadBuffer[0];\n const itemsMatchingFirstChar = sortedIndexByFirstChar.get(firstChar);\n if (!itemsMatchingFirstChar) {\n return -1;\n }\n\n // Do nothing if text already matches\n const startingItem = itemsMatchingFirstChar[state.sortedIndexCursor];\n if (startingItem.text.lastIndexOf(state.typeaheadBuffer, 0) === 0 &&\n !isItemAtIndexDisabled(startingItem.index)) {\n return startingItem.index;\n }\n\n // Find next item that matches completely; if no match, we'll eventually\n // loop around to same position\n let cursorPosition =\n (state.sortedIndexCursor + 1) % itemsMatchingFirstChar.length;\n let nextCursorPosition = -1;\n while (cursorPosition !== state.sortedIndexCursor) {\n const currentItem = itemsMatchingFirstChar[cursorPosition];\n\n const matches =\n currentItem.text.lastIndexOf(state.typeaheadBuffer, 0) === 0;\n const isEnabled = !isItemAtIndexDisabled(currentItem.index);\n if (matches && isEnabled) {\n nextCursorPosition = cursorPosition;\n break;\n }\n\n cursorPosition = (cursorPosition + 1) % itemsMatchingFirstChar.length;\n }\n\n if (nextCursorPosition !== -1) {\n state.sortedIndexCursor = nextCursorPosition;\n return itemsMatchingFirstChar[state.sortedIndexCursor].index;\n }\n\n return -1;\n}\n\n/**\n * Whether or not the given typeahead instaance state is currently typing.\n *\n * @param state The typeahead state instance. See `initState`.\n */\nexport function isTypingInProgress(state: TypeaheadState) {\n return state.typeaheadBuffer.length > 0;\n}\n\n/**\n * Options for handleKeydown.\n */\nexport interface HandleKeydownOpts {\n event: KeyboardEvent;\n isTargetListItem: boolean;\n focusItemAtIndex: (index: number) => void;\n focusedItemIndex: number;\n sortedIndexByFirstChar: Map<string, MDCListTextAndIndex[]>;\n isItemAtIndexDisabled: (index: number) => boolean;\n}\n\n/**\n * Clears the typeahaed buffer so that it resets item matching to the first\n * character.\n *\n * @param state The typeahead state instance. See `initState`.\n */\nexport function clearBuffer(state: TypeaheadState) {\n state.typeaheadBuffer = '';\n}\n\n/**\n * Given a keydown event, it calculates whether or not to automatically focus a\n * list item depending on what was typed mimicing the typeahead functionality of\n * a standard <select> element that is open.\n *\n * @param opts Options and accessors\n * - event - the KeyboardEvent to handle and parse\n * - sortedIndexByFirstChar - output of `initSortedIndex(...)`\n * - focusedItemIndex - the index of the currently focused item\n * - focusItemAtIndex - function that focuses a list item at given index\n * - isItemAtFocusedIndexDisabled - whether or not the currently focused item\n * is disabled\n * - isTargetListItem - whether or not the event target is a list item\n * @param state The typeahead state instance. See `initState`.\n *\n * @returns index of the item matched by the keydown. -1 if not matched.\n */\nexport function handleKeydown(opts: HandleKeydownOpts, state: TypeaheadState) {\n const {\n event,\n isTargetListItem,\n focusedItemIndex,\n focusItemAtIndex,\n sortedIndexByFirstChar,\n isItemAtIndexDisabled,\n } = opts;\n\n const isArrowLeft = normalizeKey(event) === 'ArrowLeft';\n const isArrowUp = normalizeKey(event) === 'ArrowUp';\n const isArrowRight = normalizeKey(event) === 'ArrowRight';\n const isArrowDown = normalizeKey(event) === 'ArrowDown';\n const isHome = normalizeKey(event) === 'Home';\n const isEnd = normalizeKey(event) === 'End';\n const isEnter = normalizeKey(event) === 'Enter';\n const isSpace = normalizeKey(event) === 'Spacebar';\n\n if (isArrowLeft || isArrowUp || isArrowRight || isArrowDown || isHome ||\n isEnd || isEnter) {\n return -1;\n }\n\n const isCharacterKey = !isSpace && event.key.length === 1;\n\n if (isCharacterKey) {\n preventDefaultEvent(event);\n const matchItemOpts: TypeaheadMatchItemOpts = {\n focusItemAtIndex,\n focusedItemIndex,\n nextChar: event.key.toLowerCase(),\n sortedIndexByFirstChar,\n skipFocus: false,\n isItemAtIndexDisabled,\n };\n return matchItem(matchItemOpts, state);\n }\n\n if (!isSpace) {\n return -1;\n }\n\n if (isTargetListItem) {\n preventDefaultEvent(event);\n }\n\n const typeaheadOnListItem = isTargetListItem && isTypingInProgress(state);\n\n if (typeaheadOnListItem) {\n const matchItemOpts: TypeaheadMatchItemOpts = {\n focusItemAtIndex,\n focusedItemIndex,\n nextChar: ' ',\n sortedIndexByFirstChar,\n skipFocus: false,\n isItemAtIndexDisabled,\n };\n // space participates in typeahead matching if in rapid typing mode\n return matchItem(matchItemOpts, state);\n }\n\n return -1;\n}\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCMenuSurfaceAdapter} from './adapter';\nimport {Corner, cssClasses, strings} from './constants';\nimport {MDCMenuSurfaceFoundation} from './foundation';\nimport {MDCMenuDistance} from './types';\nimport * as util from './util';\n\ntype RegisterFunction = () => void;\n\nexport type MDCMenuSurfaceFactory = (el: Element, foundation?: MDCMenuSurfaceFoundation) => MDCMenuSurface;\n\nexport class MDCMenuSurface extends MDCComponent<MDCMenuSurfaceFoundation> {\n static attachTo(root: Element): MDCMenuSurface {\n return new MDCMenuSurface(root);\n }\n\n anchorElement!: Element | null; // assigned in initialSyncWithDOM()\n\n private previousFocus?: HTMLElement|SVGElement|null;\n\n private handleKeydown!:\n SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n private handleBodyClick!:\n SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n\n private registerBodyClickListener!:\n RegisterFunction; // assigned in initialSyncWithDOM()\n private deregisterBodyClickListener!:\n RegisterFunction; // assigned in initialSyncWithDOM()\n\n initialSyncWithDOM() {\n const parentEl = this.root.parentElement;\n this.anchorElement = parentEl && parentEl.classList.contains(cssClasses.ANCHOR) ? parentEl : null;\n\n if (this.root.classList.contains(cssClasses.FIXED)) {\n this.setFixedPosition(true);\n }\n\n this.handleKeydown = (event) => {\n this.foundation.handleKeydown(event);\n };\n this.handleBodyClick = (event) => {\n this.foundation.handleBodyClick(event);\n };\n\n // capture so that no race between handleBodyClick and quickOpen when\n // menusurface opened on button click which registers this listener\n this.registerBodyClickListener = () => {\n document.body.addEventListener(\n 'click', this.handleBodyClick, {capture: true});\n };\n this.deregisterBodyClickListener = () => {\n document.body.removeEventListener('click', this.handleBodyClick);\n };\n\n this.listen('keydown', this.handleKeydown);\n this.listen(strings.OPENED_EVENT, this.registerBodyClickListener);\n this.listen(strings.CLOSED_EVENT, this.deregisterBodyClickListener);\n }\n\n destroy() {\n this.unlisten('keydown', this.handleKeydown);\n this.unlisten(strings.OPENED_EVENT, this.registerBodyClickListener);\n this.unlisten(strings.CLOSED_EVENT, this.deregisterBodyClickListener);\n super.destroy();\n }\n\n isOpen(): boolean {\n return this.foundation.isOpen();\n }\n\n open() {\n this.foundation.open();\n }\n\n close(skipRestoreFocus = false) {\n this.foundation.close(skipRestoreFocus);\n }\n\n set quickOpen(quickOpen: boolean) {\n this.foundation.setQuickOpen(quickOpen);\n }\n\n /** Sets the foundation to use page offsets for an positioning when the menu is hoisted to the body. */\n setIsHoisted(isHoisted: boolean) {\n this.foundation.setIsHoisted(isHoisted);\n }\n\n /** Sets the element that the menu-surface is anchored to. */\n setMenuSurfaceAnchorElement(element: Element) {\n this.anchorElement = element;\n }\n\n /** Sets the menu-surface to position: fixed. */\n setFixedPosition(isFixed: boolean) {\n if (isFixed) {\n this.root.classList.add(cssClasses.FIXED);\n } else {\n this.root.classList.remove(cssClasses.FIXED);\n }\n\n this.foundation.setFixedPosition(isFixed);\n }\n\n /** Sets the absolute x/y position to position based on. Requires the menu to be hoisted. */\n setAbsolutePosition(x: number, y: number) {\n this.foundation.setAbsolutePosition(x, y);\n this.setIsHoisted(true);\n }\n\n /**\n * @param corner Default anchor corner alignment of top-left surface corner.\n */\n setAnchorCorner(corner: Corner) {\n this.foundation.setAnchorCorner(corner);\n }\n\n setAnchorMargin(margin: Partial<MDCMenuDistance>) {\n this.foundation.setAnchorMargin(margin);\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCMenuSurfaceAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n hasClass: (className) => this.root.classList.contains(className),\n hasAnchor: () => !!this.anchorElement,\n notifyClose: () =>\n this.emit(MDCMenuSurfaceFoundation.strings.CLOSED_EVENT, {}),\n notifyOpen: () =>\n this.emit(MDCMenuSurfaceFoundation.strings.OPENED_EVENT, {}),\n isElementInContainer: (el) => this.root.contains(el),\n isRtl: () =>\n getComputedStyle(this.root).getPropertyValue('direction') === 'rtl',\n setTransformOrigin: (origin) => {\n const propertyName = `${util.getTransformPropertyName(window)}-origin`;\n (this.root as HTMLElement).style.setProperty(propertyName, origin);\n },\n\n isFocused: () => document.activeElement === this.root,\n saveFocus: () => {\n this.previousFocus =\n document.activeElement as HTMLElement | SVGElement | null;\n },\n restoreFocus: () => {\n if (this.root.contains(document.activeElement)) {\n if (this.previousFocus && this.previousFocus.focus) {\n this.previousFocus.focus();\n }\n }\n },\n\n getInnerDimensions: () => {\n return {\n width: (this.root as HTMLElement).offsetWidth,\n height: (this.root as HTMLElement).offsetHeight\n };\n },\n getAnchorDimensions: () => this.anchorElement ?\n this.anchorElement.getBoundingClientRect() :\n null,\n getWindowDimensions: () => {\n return {width: window.innerWidth, height: window.innerHeight};\n },\n getBodyDimensions: () => {\n return {width: document.body.clientWidth, height: document.body.clientHeight};\n },\n getWindowScroll: () => {\n return {x: window.pageXOffset, y: window.pageYOffset};\n },\n setPosition: (position) => {\n const rootHTML = this.root as HTMLElement;\n rootHTML.style.left = 'left' in position ? `${position.left}px` : '';\n rootHTML.style.right = 'right' in position ? `${position.right}px` : '';\n rootHTML.style.top = 'top' in position ? `${position.top}px` : '';\n rootHTML.style.bottom =\n 'bottom' in position ? `${position.bottom}px` : '';\n },\n setMaxHeight: (height) => {\n (this.root as HTMLElement).style.maxHeight = height;\n },\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCMenuSurfaceFoundation(adapter);\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n ANCHOR: 'mdc-menu-surface--anchor',\n ANIMATING_CLOSED: 'mdc-menu-surface--animating-closed',\n ANIMATING_OPEN: 'mdc-menu-surface--animating-open',\n FIXED: 'mdc-menu-surface--fixed',\n IS_OPEN_BELOW: 'mdc-menu-surface--is-open-below',\n OPEN: 'mdc-menu-surface--open',\n ROOT: 'mdc-menu-surface',\n};\n\n// tslint:disable:object-literal-sort-keys\nconst strings = {\n CLOSED_EVENT: 'MDCMenuSurface:closed',\n OPENED_EVENT: 'MDCMenuSurface:opened',\n FOCUSABLE_ELEMENTS: [\n 'button:not(:disabled)', '[href]:not([aria-disabled=\"true\"])', 'input:not(:disabled)',\n 'select:not(:disabled)', 'textarea:not(:disabled)', '[tabindex]:not([tabindex=\"-1\"]):not([aria-disabled=\"true\"])',\n ].join(', '),\n};\n// tslint:enable:object-literal-sort-keys\n\nconst numbers = {\n /** Total duration of menu-surface open animation. */\n TRANSITION_OPEN_DURATION: 120,\n\n /** Total duration of menu-surface close animation. */\n TRANSITION_CLOSE_DURATION: 75,\n\n /** Margin left to the edge of the viewport when menu-surface is at maximum possible height. Also used as a viewport margin. */\n MARGIN_TO_EDGE: 32,\n\n /** Ratio of anchor width to menu-surface width for switching from corner positioning to center positioning. */\n ANCHOR_TO_MENU_SURFACE_WIDTH_RATIO: 0.67,\n};\n\n/**\n * Enum for bits in the {@see Corner) bitmap.\n */\nenum CornerBit {\n BOTTOM = 1,\n CENTER = 2,\n RIGHT = 4,\n FLIP_RTL = 8,\n}\n\n/**\n * Enum for representing an element corner for positioning the menu-surface.\n *\n * The START constants map to LEFT if element directionality is left\n * to right and RIGHT if the directionality is right to left.\n * Likewise END maps to RIGHT or LEFT depending on the directionality.\n */\nenum Corner {\n TOP_LEFT = 0,\n TOP_RIGHT = CornerBit.RIGHT,\n BOTTOM_LEFT = CornerBit.BOTTOM,\n BOTTOM_RIGHT = CornerBit.BOTTOM | CornerBit.RIGHT, // tslint:disable-line:no-bitwise\n TOP_START = CornerBit.FLIP_RTL,\n TOP_END = CornerBit.FLIP_RTL | CornerBit.RIGHT, // tslint:disable-line:no-bitwise\n BOTTOM_START = CornerBit.BOTTOM | CornerBit.FLIP_RTL, // tslint:disable-line:no-bitwise\n BOTTOM_END = CornerBit.BOTTOM | CornerBit.RIGHT | CornerBit.FLIP_RTL, // tslint:disable-line:no-bitwise\n}\n\nexport {cssClasses, strings, numbers, CornerBit, Corner};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCMenuSurfaceAdapter} from './adapter';\nimport {Corner, CornerBit, cssClasses, numbers, strings} from './constants';\nimport {MDCMenuDimensions, MDCMenuDistance, MDCMenuPoint} from './types';\n\ninterface AutoLayoutMeasurements {\n anchorSize: MDCMenuDimensions;\n bodySize: MDCMenuDimensions;\n surfaceSize: MDCMenuDimensions;\n viewportDistance: MDCMenuDistance;\n viewportSize: MDCMenuDimensions;\n windowScroll: MDCMenuPoint;\n}\n\nexport class MDCMenuSurfaceFoundation extends MDCFoundation<MDCMenuSurfaceAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get numbers() {\n return numbers;\n }\n\n static get Corner() {\n return Corner;\n }\n\n /**\n * @see {@link MDCMenuSurfaceAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCMenuSurfaceAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n hasClass: () => false,\n hasAnchor: () => false,\n\n isElementInContainer: () => false,\n isFocused: () => false,\n isRtl: () => false,\n\n getInnerDimensions: () => ({height: 0, width: 0}),\n getAnchorDimensions: () => null,\n getWindowDimensions: () => ({height: 0, width: 0}),\n getBodyDimensions: () => ({height: 0, width: 0}),\n getWindowScroll: () => ({x: 0, y: 0}),\n setPosition: () => undefined,\n setMaxHeight: () => undefined,\n setTransformOrigin: () => undefined,\n\n saveFocus: () => undefined,\n restoreFocus: () => undefined,\n\n notifyClose: () => undefined,\n notifyOpen: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private isSurfaceOpen = false;\n private isQuickOpen = false;\n private isHoistedElement = false;\n private isFixedPosition = false;\n\n private openAnimationEndTimerId = 0;\n private closeAnimationEndTimerId = 0;\n private animationRequestId = 0;\n\n private anchorCorner: Corner = Corner.TOP_START;\n\n /**\n * Corner of the menu surface to which menu surface is attached to anchor.\n *\n * Anchor corner --->+----------+\n * | ANCHOR |\n * +----------+\n * Origin corner --->+--------------+\n * | |\n * | |\n * | MENU SURFACE |\n * | |\n * | |\n * +--------------+\n */\n private originCorner: Corner = Corner.TOP_START;\n private readonly anchorMargin:\n MDCMenuDistance = {top: 0, right: 0, bottom: 0, left: 0};\n private readonly position: MDCMenuPoint = {x: 0, y: 0};\n\n private dimensions!: MDCMenuDimensions; // assigned in open()\n private measurements!: AutoLayoutMeasurements; // assigned in open()\n\n constructor(adapter?: Partial<MDCMenuSurfaceAdapter>) {\n super({...MDCMenuSurfaceFoundation.defaultAdapter, ...adapter});\n }\n\n init() {\n const {ROOT, OPEN} = MDCMenuSurfaceFoundation.cssClasses;\n\n if (!this.adapter.hasClass(ROOT)) {\n throw new Error(`${ROOT} class required in root element.`);\n }\n\n if (this.adapter.hasClass(OPEN)) {\n this.isSurfaceOpen = true;\n }\n }\n\n destroy() {\n clearTimeout(this.openAnimationEndTimerId);\n clearTimeout(this.closeAnimationEndTimerId);\n // Cancel any currently running animations.\n cancelAnimationFrame(this.animationRequestId);\n }\n\n /**\n * @param corner Default anchor corner alignment of top-left menu surface corner.\n */\n setAnchorCorner(corner: Corner) {\n this.anchorCorner = corner;\n }\n\n /**\n * Flip menu corner horizontally.\n */\n flipCornerHorizontally() {\n this.originCorner = this.originCorner ^ CornerBit.RIGHT;\n }\n\n /**\n * @param margin Set of margin values from anchor.\n */\n setAnchorMargin(margin: Partial<MDCMenuDistance>) {\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\n /** Used to indicate if the menu-surface is hoisted to the body. */\n setIsHoisted(isHoisted: boolean) {\n this.isHoistedElement = isHoisted;\n }\n\n /** Used to set the menu-surface calculations based on a fixed position menu. */\n setFixedPosition(isFixedPosition: boolean) {\n this.isFixedPosition = isFixedPosition;\n }\n\n /** Sets the menu-surface position on the page. */\n setAbsolutePosition(x: number, y: number) {\n this.position.x = this.isFinite(x) ? x : 0;\n this.position.y = this.isFinite(y) ? y : 0;\n }\n\n setQuickOpen(quickOpen: boolean) {\n this.isQuickOpen = quickOpen;\n }\n\n isOpen() {\n return this.isSurfaceOpen;\n }\n\n /**\n * Open the menu surface.\n */\n open() {\n if (this.isSurfaceOpen) {\n return;\n }\n\n this.adapter.saveFocus();\n\n if (this.isQuickOpen) {\n this.isSurfaceOpen = true;\n this.adapter.addClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n this.dimensions = this.adapter.getInnerDimensions();\n this.autoposition();\n this.adapter.notifyOpen();\n } else {\n this.adapter.addClass(MDCMenuSurfaceFoundation.cssClasses.ANIMATING_OPEN);\n this.animationRequestId = requestAnimationFrame(() => {\n this.adapter.addClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n this.dimensions = this.adapter.getInnerDimensions();\n this.autoposition();\n this.openAnimationEndTimerId = setTimeout(() => {\n this.openAnimationEndTimerId = 0;\n this.adapter.removeClass(\n MDCMenuSurfaceFoundation.cssClasses.ANIMATING_OPEN);\n this.adapter.notifyOpen();\n }, numbers.TRANSITION_OPEN_DURATION);\n });\n\n this.isSurfaceOpen = true;\n }\n }\n\n /**\n * Closes the menu surface.\n */\n close(skipRestoreFocus = false) {\n if (!this.isSurfaceOpen) {\n return;\n }\n\n if (this.isQuickOpen) {\n this.isSurfaceOpen = false;\n if (!skipRestoreFocus) {\n this.maybeRestoreFocus();\n }\n\n this.adapter.removeClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n this.adapter.removeClass(\n MDCMenuSurfaceFoundation.cssClasses.IS_OPEN_BELOW);\n this.adapter.notifyClose();\n\n } else {\n this.adapter.addClass(\n MDCMenuSurfaceFoundation.cssClasses.ANIMATING_CLOSED);\n requestAnimationFrame(() => {\n this.adapter.removeClass(MDCMenuSurfaceFoundation.cssClasses.OPEN);\n this.adapter.removeClass(\n MDCMenuSurfaceFoundation.cssClasses.IS_OPEN_BELOW);\n this.closeAnimationEndTimerId = setTimeout(() => {\n this.closeAnimationEndTimerId = 0;\n this.adapter.removeClass(\n MDCMenuSurfaceFoundation.cssClasses.ANIMATING_CLOSED);\n this.adapter.notifyClose();\n }, numbers.TRANSITION_CLOSE_DURATION);\n });\n\n this.isSurfaceOpen = false;\n if (!skipRestoreFocus) {\n this.maybeRestoreFocus();\n }\n }\n }\n\n /** Handle clicks and close if not within menu-surface element. */\n handleBodyClick(evt: MouseEvent) {\n const el = evt.target as Element;\n if (this.adapter.isElementInContainer(el)) {\n return;\n }\n this.close();\n }\n\n /** Handle keys that close the surface. */\n handleKeydown(evt: KeyboardEvent) {\n const {keyCode, key} = evt;\n\n const isEscape = key === 'Escape' || keyCode === 27;\n if (isEscape) {\n this.close();\n }\n }\n\n private autoposition() {\n // Compute measurements for autoposition methods reuse.\n this.measurements = this.getAutoLayoutmeasurements();\n\n const corner = this.getoriginCorner();\n const maxMenuSurfaceHeight = this.getMenuSurfaceMaxHeight(corner);\n const verticalAlignment =\n this.hasBit(corner, CornerBit.BOTTOM) ? 'bottom' : 'top';\n let horizontalAlignment =\n this.hasBit(corner, CornerBit.RIGHT) ? 'right' : 'left';\n const horizontalOffset = this.getHorizontalOriginOffset(corner);\n const verticalOffset = this.getVerticalOriginOffset(corner);\n const {anchorSize, surfaceSize} = this.measurements;\n\n const position: Partial<MDCMenuDistance> = {\n [horizontalAlignment]: horizontalOffset,\n [verticalAlignment]: verticalOffset,\n };\n\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\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\n this.adapter.setTransformOrigin(\n `${horizontalAlignment} ${verticalAlignment}`);\n this.adapter.setPosition(position);\n this.adapter.setMaxHeight(\n maxMenuSurfaceHeight ? maxMenuSurfaceHeight + 'px' : '');\n\n // If it is opened from the top then add is-open-below class\n if (!this.hasBit(corner, CornerBit.BOTTOM)) {\n this.adapter.addClass(MDCMenuSurfaceFoundation.cssClasses.IS_OPEN_BELOW);\n }\n }\n\n /**\n * @return Measurements used to position menu surface popup.\n */\n private getAutoLayoutmeasurements(): AutoLayoutMeasurements {\n let anchorRect = this.adapter.getAnchorDimensions();\n const bodySize = this.adapter.getBodyDimensions();\n const viewportSize = this.adapter.getWindowDimensions();\n const windowScroll = this.adapter.getWindowScroll();\n\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\n return {\n anchorSize: anchorRect,\n 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 // tslint:enable:object-literal-sort-keys\n },\n viewportSize,\n windowScroll,\n };\n }\n\n /**\n * Computes the corner of the anchor from which to animate and position the\n * menu surface.\n *\n * Only LEFT or RIGHT bit is used to position the menu surface ignoring RTL\n * context. E.g., menu surface will be positioned from right side on TOP_END.\n */\n private getoriginCorner(): Corner {\n let corner = this.originCorner;\n\n const {viewportDistance, anchorSize, surfaceSize} = this.measurements;\n const {MARGIN_TO_EDGE} = MDCMenuSurfaceFoundation.numbers;\n\n const isAnchoredToBottom = this.hasBit(this.anchorCorner, CornerBit.BOTTOM);\n\n let availableTop;\n let availableBottom;\n if (isAnchoredToBottom) {\n availableTop = viewportDistance.top - MARGIN_TO_EDGE + anchorSize.height +\n this.anchorMargin.bottom;\n availableBottom =\n viewportDistance.bottom - MARGIN_TO_EDGE - this.anchorMargin.bottom;\n } else {\n availableTop =\n viewportDistance.top - MARGIN_TO_EDGE + this.anchorMargin.top;\n availableBottom = viewportDistance.bottom - MARGIN_TO_EDGE +\n anchorSize.height - this.anchorMargin.top;\n }\n\n const isAvailableBottom = availableBottom - surfaceSize.height > 0;\n if (!isAvailableBottom && availableTop >= availableBottom) {\n // Attach bottom side of surface to the anchor.\n corner = this.setBit(corner, CornerBit.BOTTOM);\n }\n\n const isRtl = this.adapter.isRtl();\n const isFlipRtl = this.hasBit(this.anchorCorner, CornerBit.FLIP_RTL);\n const hasRightBit = this.hasBit(this.anchorCorner, CornerBit.RIGHT);\n\n // Whether surface attached to right side of anchor element.\n let isAnchoredToRight = false;\n\n // Anchored to start\n if (isRtl && isFlipRtl) {\n isAnchoredToRight = !hasRightBit;\n } else {\n // Anchored to right\n isAnchoredToRight = hasRightBit;\n }\n\n let availableLeft;\n let availableRight;\n if (isAnchoredToRight) {\n availableLeft =\n viewportDistance.left + anchorSize.width + this.anchorMargin.right;\n availableRight = viewportDistance.right - this.anchorMargin.right;\n } else {\n availableLeft = viewportDistance.left + this.anchorMargin.left;\n availableRight =\n viewportDistance.right + anchorSize.width - this.anchorMargin.left;\n }\n\n const isAvailableLeft = availableLeft - surfaceSize.width > 0;\n const isAvailableRight = availableRight - surfaceSize.width > 0;\n const isOriginCornerAlignedToEnd =\n this.hasBit(corner, CornerBit.FLIP_RTL) &&\n this.hasBit(corner, CornerBit.RIGHT);\n\n if (isAvailableRight && isOriginCornerAlignedToEnd && isRtl ||\n !isAvailableLeft && isOriginCornerAlignedToEnd) {\n // Attach left side of surface to the anchor.\n corner = this.unsetBit(corner, CornerBit.RIGHT);\n } else if (\n isAvailableLeft && isAnchoredToRight && isRtl ||\n (isAvailableLeft && !isAnchoredToRight && hasRightBit) ||\n (!isAvailableRight && availableLeft >= availableRight)) {\n // Attach right side of surface to the anchor.\n corner = this.setBit(corner, CornerBit.RIGHT);\n }\n\n return corner;\n }\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 private getMenuSurfaceMaxHeight(corner: Corner): number {\n const {viewportDistance} = this.measurements;\n\n let maxHeight = 0;\n const isBottomAligned = this.hasBit(corner, CornerBit.BOTTOM);\n const isBottomAnchored = this.hasBit(this.anchorCorner, CornerBit.BOTTOM);\n const {MARGIN_TO_EDGE} = MDCMenuSurfaceFoundation.numbers;\n\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 } else {\n maxHeight = viewportDistance.bottom - this.anchorMargin.bottom +\n this.measurements.anchorSize.height - MARGIN_TO_EDGE;\n if (isBottomAnchored) {\n maxHeight -= this.measurements.anchorSize.height;\n }\n }\n\n return maxHeight;\n }\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 private getHorizontalOriginOffset(corner: Corner): number {\n const {anchorSize} = this.measurements;\n\n // isRightAligned corresponds to using the 'right' property on the surface.\n const isRightAligned = this.hasBit(corner, CornerBit.RIGHT);\n const avoidHorizontalOverlap =\n this.hasBit(this.anchorCorner, CornerBit.RIGHT);\n\n if (isRightAligned) {\n const rightOffset = avoidHorizontalOverlap ?\n anchorSize.width - this.anchorMargin.left :\n this.anchorMargin.right;\n\n // For hoisted or fixed elements, adjust the offset by the difference\n // between viewport width and body width so when we calculate the right\n // value (`adjustPositionForHoistedElement`) based on the element\n // position, the right property is correct.\n if (this.isHoistedElement || this.isFixedPosition) {\n return rightOffset -\n (this.measurements.viewportSize.width -\n this.measurements.bodySize.width);\n }\n\n return rightOffset;\n }\n\n return avoidHorizontalOverlap ? anchorSize.width - this.anchorMargin.right :\n this.anchorMargin.left;\n }\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 private getVerticalOriginOffset(corner: Corner): number {\n const {anchorSize} = this.measurements;\n const isBottomAligned = this.hasBit(corner, CornerBit.BOTTOM);\n const avoidVerticalOverlap =\n this.hasBit(this.anchorCorner, CornerBit.BOTTOM);\n\n let y = 0;\n if (isBottomAligned) {\n y = avoidVerticalOverlap ? anchorSize.height - this.anchorMargin.top :\n -this.anchorMargin.bottom;\n } else {\n y = avoidVerticalOverlap ?\n (anchorSize.height + this.anchorMargin.bottom) :\n this.anchorMargin.top;\n }\n return y;\n }\n\n /** Calculates the offsets for positioning the menu-surface when the menu-surface has been hoisted to the body. */\n private adjustPositionForHoistedElement(position: Partial<MDCMenuDistance>) {\n const {windowScroll, viewportDistance} = this.measurements;\n\n const props = Object.keys(position) as Array<keyof Partial<MDCMenuDistance>>;\n\n for (const prop of props) {\n let value = position[prop] || 0;\n\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\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 } else if (prop === 'bottom') {\n value -= windowScroll.y;\n } else if (prop === 'left') {\n value += windowScroll.x;\n } else { // prop === 'right'\n value -= windowScroll.x;\n }\n }\n\n position[prop] = value;\n }\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 private maybeRestoreFocus() {\n const isRootFocused = this.adapter.isFocused();\n const childHasFocus = document.activeElement &&\n this.adapter.isElementInContainer(document.activeElement);\n if (isRootFocused || childHasFocus) {\n this.adapter.restoreFocus();\n }\n }\n\n private hasBit(corner: Corner, bit: CornerBit): boolean {\n return Boolean(corner & bit); // tslint:disable-line:no-bitwise\n }\n\n private setBit(corner: Corner, bit: CornerBit): Corner {\n return corner | bit; // tslint:disable-line:no-bitwise\n }\n\n private unsetBit(corner: Corner, bit: CornerBit): Corner {\n return corner ^ bit;\n }\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 private isFinite(num: number): boolean {\n return typeof num === 'number' && isFinite(num);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCMenuSurfaceFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nimport * as util from './util';\n\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\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 */\n\ntype CssTransformPropertyName = ('transform' | 'webkitTransform');\n\nlet cachedCssTransformPropertyName_: CssTransformPropertyName | undefined;\n\n/**\n * Returns the name of the correct transform property to use on the current browser.\n */\nfunction getTransformPropertyName(globalObj: Window, forceRefresh = false): CssTransformPropertyName {\n if (cachedCssTransformPropertyName_ === undefined || forceRefresh) {\n const el = globalObj.document.createElement('div');\n cachedCssTransformPropertyName_ = 'transform' in el.style ? 'transform' : 'webkitTransform';\n }\n return cachedCssTransformPropertyName_;\n}\n\nexport {getTransformPropertyName};\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {CustomEventListener, SpecificEventListener} from '@material/base/types';\nimport {closest} from '@material/dom/ponyfill';\nimport {MDCList, MDCListFactory} from '@material/list/component';\nimport {MDCListFoundation} from '@material/list/foundation';\nimport {MDCListActionEvent} from '@material/list/types';\nimport {MDCMenuSurface, MDCMenuSurfaceFactory} from '@material/menu-surface/component';\nimport {Corner} from '@material/menu-surface/constants';\nimport {MDCMenuSurfaceFoundation} from '@material/menu-surface/foundation';\nimport {MDCMenuDistance} from '@material/menu-surface/types';\nimport {MDCMenuAdapter} from './adapter';\nimport {cssClasses, DefaultFocusState, strings} from './constants';\nimport {MDCMenuFoundation} from './foundation';\nimport {MDCMenuItemComponentEventDetail} from './types';\n\nexport type MDCMenuFactory = (el: Element, foundation?: MDCMenuFoundation) => MDCMenu;\n\nexport class MDCMenu extends MDCComponent<MDCMenuFoundation> {\n static attachTo(root: Element) {\n return new MDCMenu(root);\n }\n\n private menuSurfaceFactory_!: MDCMenuSurfaceFactory; // assigned in initialize()\n private listFactory_!: MDCListFactory; // assigned in initialize()\n\n private menuSurface_!: MDCMenuSurface; // assigned in initialSyncWithDOM()\n private list_!: MDCList | null; // assigned in initialSyncWithDOM()\n\n private handleKeydown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n private handleItemAction_!: CustomEventListener<MDCListActionEvent>; // assigned in initialSyncWithDOM()\n private handleMenuSurfaceOpened_!: EventListener; // assigned in initialSyncWithDOM()\n\n initialize(\n menuSurfaceFactory: MDCMenuSurfaceFactory = (el) => new MDCMenuSurface(el),\n listFactory: MDCListFactory = (el) => new MDCList(el)) {\n this.menuSurfaceFactory_ = menuSurfaceFactory;\n this.listFactory_ = listFactory;\n }\n\n initialSyncWithDOM() {\n this.menuSurface_ = this.menuSurfaceFactory_(this.root);\n\n const list = this.root.querySelector(strings.LIST_SELECTOR);\n if (list) {\n this.list_ = this.listFactory_(list);\n this.list_.wrapFocus = true;\n } else {\n this.list_ = null;\n }\n\n this.handleKeydown_ = (evt) => this.foundation.handleKeydown(evt);\n this.handleItemAction_ = (evt) =>\n this.foundation.handleItemAction(this.items[evt.detail.index]);\n this.handleMenuSurfaceOpened_ = () =>\n this.foundation.handleMenuSurfaceOpened();\n\n this.menuSurface_.listen(MDCMenuSurfaceFoundation.strings.OPENED_EVENT, this.handleMenuSurfaceOpened_);\n this.listen('keydown', this.handleKeydown_);\n this.listen(MDCListFoundation.strings.ACTION_EVENT, this.handleItemAction_);\n }\n\n destroy() {\n if (this.list_) {\n this.list_.destroy();\n }\n\n this.menuSurface_.destroy();\n this.menuSurface_.unlisten(MDCMenuSurfaceFoundation.strings.OPENED_EVENT, this.handleMenuSurfaceOpened_);\n this.unlisten('keydown', this.handleKeydown_);\n this.unlisten(MDCListFoundation.strings.ACTION_EVENT, this.handleItemAction_);\n super.destroy();\n }\n\n get open(): boolean {\n return this.menuSurface_.isOpen();\n }\n\n set open(value: boolean) {\n if (value) {\n this.menuSurface_.open();\n } else {\n this.menuSurface_.close();\n }\n }\n\n get wrapFocus(): boolean {\n return this.list_ ? this.list_.wrapFocus : false;\n }\n\n set wrapFocus(value: boolean) {\n if (this.list_) {\n this.list_.wrapFocus = value;\n }\n }\n\n /**\n * Sets whether the menu has typeahead functionality.\n * @param value Whether typeahead is enabled.\n */\n set hasTypeahead(value: boolean) {\n if (this.list_) {\n this.list_.hasTypeahead = value;\n }\n }\n\n /**\n * @return Whether typeahead logic is currently matching some user prefix.\n */\n get typeaheadInProgress() {\n return this.list_ ? this.list_.typeaheadInProgress : false;\n }\n\n /**\n * Given the next desired character from the user, adds it to the typeahead\n * buffer. Then, attempts to find the next option matching the buffer. Wraps\n * around if at the end of options.\n *\n * @param nextChar The next character to add to the prefix buffer.\n * @param startingIndex The index from which to start matching. Only relevant\n * when starting a new match sequence. To start a new match sequence,\n * clear the buffer using `clearTypeaheadBuffer`, or wait for the buffer\n * to clear after a set interval defined in list foundation. Defaults to\n * the currently focused index.\n * @return The index of the matched item, or -1 if no match.\n */\n typeaheadMatchItem(nextChar: string, startingIndex?: number): number {\n if (this.list_) {\n return this.list_.typeaheadMatchItem(nextChar, startingIndex);\n }\n return -1;\n }\n\n /**\n * Layout the underlying list element in the case of any dynamic updates\n * to its structure.\n */\n layout() {\n if (this.list_) {\n this.list_.layout();\n }\n }\n\n /**\n * Return the items within the menu. Note that this only contains the set of elements within\n * the items container that are proper list items, and not supplemental / presentational DOM\n * elements.\n */\n get items(): Element[] {\n return this.list_ ? this.list_.listElements : [];\n }\n\n set quickOpen(quickOpen: boolean) {\n this.menuSurface_.quickOpen = quickOpen;\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 * @param focusState Default focus state.\n */\n setDefaultFocusState(focusState: DefaultFocusState) {\n this.foundation.setDefaultFocusState(focusState);\n }\n\n /**\n * @param corner Default anchor corner alignment of top-left menu corner.\n */\n setAnchorCorner(corner: Corner) {\n this.menuSurface_.setAnchorCorner(corner);\n }\n\n setAnchorMargin(margin: Partial<MDCMenuDistance>) {\n this.menuSurface_.setAnchorMargin(margin);\n }\n\n /**\n * Sets the list item as the selected row at the specified index.\n * @param index Index of list item within menu.\n */\n setSelectedIndex(index: number) {\n this.foundation.setSelectedIndex(index);\n }\n\n /**\n * Sets the enabled state to isEnabled for the menu item at the given index.\n * @param index Index of the menu item\n * @param isEnabled The desired enabled state of the menu item.\n */\n setEnabled(index: number, isEnabled: boolean): void {\n this.foundation.setEnabled(index, isEnabled);\n }\n\n /**\n * @return The item within the menu at the index specified.\n */\n getOptionByIndex(index: number): Element | null {\n const items = this.items;\n\n if (index < items.length) {\n return this.items[index];\n } else {\n return null;\n }\n }\n\n /**\n * @param index A menu item's index.\n * @return The primary text within the menu at the index specified.\n */\n getPrimaryTextAtIndex(index: number): string {\n const item = this.getOptionByIndex(index);\n if (item && this.list_) {\n return this.list_.getPrimaryText(item) || '';\n }\n return '';\n }\n\n setFixedPosition(isFixed: boolean) {\n this.menuSurface_.setFixedPosition(isFixed);\n }\n\n setIsHoisted(isHoisted: boolean) {\n this.menuSurface_.setIsHoisted(isHoisted);\n }\n\n setAbsolutePosition(x: number, y: number) {\n this.menuSurface_.setAbsolutePosition(x, y);\n }\n\n /**\n * Sets the element that the menu-surface is anchored to.\n */\n setAnchorElement(element: Element) {\n this.menuSurface_.anchorElement = element;\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCMenuAdapter = {\n addClassToElementAtIndex: (index, className) => {\n const list = this.items;\n list[index].classList.add(className);\n },\n removeClassFromElementAtIndex: (index, className) => {\n const list = this.items;\n list[index].classList.remove(className);\n },\n addAttributeToElementAtIndex: (index, attr, value) => {\n const list = this.items;\n list[index].setAttribute(attr, value);\n },\n removeAttributeFromElementAtIndex: (index, attr) => {\n const list = this.items;\n list[index].removeAttribute(attr);\n },\n elementContainsClass: (element, className) =>\n element.classList.contains(className),\n closeSurface: (skipRestoreFocus: boolean) =>\n this.menuSurface_.close(skipRestoreFocus),\n getElementIndex: (element) => this.items.indexOf(element),\n notifySelected: (evtData) =>\n this.emit<MDCMenuItemComponentEventDetail>(strings.SELECTED_EVENT, {\n index: evtData.index,\n item: this.items[evtData.index],\n }),\n getMenuItemCount: () => this.items.length,\n focusItemAtIndex: (index) => (this.items[index] as HTMLElement).focus(),\n focusListRoot: () =>\n (this.root.querySelector(strings.LIST_SELECTOR) as HTMLElement)\n .focus(),\n isSelectableItemAtIndex: (index) =>\n !!closest(this.items[index], `.${cssClasses.MENU_SELECTION_GROUP}`),\n getSelectedSiblingOfItemAtIndex: (index) => {\n const selectionGroupEl = closest(this.items[index], `.${cssClasses.MENU_SELECTION_GROUP}`) as HTMLElement;\n const selectedItemEl = selectionGroupEl.querySelector(`.${cssClasses.MENU_SELECTED_LIST_ITEM}`);\n return selectedItemEl ? this.items.indexOf(selectedItemEl) : -1;\n },\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCMenuFoundation(adapter);\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n MENU_SELECTED_LIST_ITEM: 'mdc-menu-item--selected',\n MENU_SELECTION_GROUP: 'mdc-menu__selection-group',\n ROOT: 'mdc-menu',\n};\n\nconst strings = {\n ARIA_CHECKED_ATTR: 'aria-checked',\n ARIA_DISABLED_ATTR: 'aria-disabled',\n CHECKBOX_SELECTOR: 'input[type=\"checkbox\"]',\n LIST_SELECTOR: '.mdc-list',\n SELECTED_EVENT: 'MDCMenu:selected',\n};\n\nconst numbers = {\n FOCUS_ROOT_INDEX: -1,\n};\n\nenum DefaultFocusState {\n NONE = 0,\n LIST_ROOT = 1,\n FIRST_ITEM = 2,\n LAST_ITEM = 3,\n}\n\nexport {cssClasses, strings, numbers, DefaultFocusState};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {cssClasses as listCssClasses} from '@material/list/constants';\nimport {MDCMenuSurfaceFoundation} from '@material/menu-surface/foundation';\nimport {MDCMenuAdapter} from './adapter';\nimport {cssClasses, DefaultFocusState, numbers, strings} from './constants';\n\nexport class MDCMenuFoundation extends MDCFoundation<MDCMenuAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get numbers() {\n return numbers;\n }\n\n private closeAnimationEndTimerId_ = 0;\n private defaultFocusState_ = DefaultFocusState.LIST_ROOT;\n\n /**\n * @see {@link MDCMenuAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCMenuAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClassToElementAtIndex: () => undefined,\n removeClassFromElementAtIndex: () => undefined,\n addAttributeToElementAtIndex: () => undefined,\n removeAttributeFromElementAtIndex: () => undefined,\n elementContainsClass: () => false,\n closeSurface: () => undefined,\n getElementIndex: () => -1,\n notifySelected: () => undefined,\n getMenuItemCount: () => 0,\n focusItemAtIndex: () => undefined,\n focusListRoot: () => undefined,\n getSelectedSiblingOfItemAtIndex: () => -1,\n isSelectableItemAtIndex: () => false,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n constructor(adapter?: Partial<MDCMenuAdapter>) {\n super({...MDCMenuFoundation.defaultAdapter, ...adapter});\n }\n\n destroy() {\n if (this.closeAnimationEndTimerId_) {\n clearTimeout(this.closeAnimationEndTimerId_);\n }\n\n this.adapter.closeSurface();\n }\n\n handleKeydown(evt: KeyboardEvent) {\n const {key, keyCode} = evt;\n const isTab = key === 'Tab' || keyCode === 9;\n\n if (isTab) {\n this.adapter.closeSurface(/** skipRestoreFocus */ true);\n }\n }\n\n handleItemAction(listItem: Element) {\n const index = this.adapter.getElementIndex(listItem);\n if (index < 0) {\n return;\n }\n\n this.adapter.notifySelected({index});\n this.adapter.closeSurface();\n\n // Wait for the menu to close before adding/removing classes that affect styles.\n this.closeAnimationEndTimerId_ = setTimeout(() => {\n // Recompute the index in case the menu contents have changed.\n const recomputedIndex = this.adapter.getElementIndex(listItem);\n if (recomputedIndex >= 0 &&\n this.adapter.isSelectableItemAtIndex(recomputedIndex)) {\n this.setSelectedIndex(recomputedIndex);\n }\n }, MDCMenuSurfaceFoundation.numbers.TRANSITION_CLOSE_DURATION);\n }\n\n handleMenuSurfaceOpened() {\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 /**\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 setDefaultFocusState(focusState: DefaultFocusState) {\n this.defaultFocusState_ = focusState;\n }\n\n /**\n * Selects the list item at `index` within the menu.\n * @param index Index of list item within the menu.\n */\n setSelectedIndex(index: number) {\n this.validatedIndex_(index);\n\n if (!this.adapter.isSelectableItemAtIndex(index)) {\n throw new Error('MDCMenuFoundation: No selection group at specified index.');\n }\n\n const prevSelectedIndex =\n this.adapter.getSelectedSiblingOfItemAtIndex(index);\n if (prevSelectedIndex >= 0) {\n this.adapter.removeAttributeFromElementAtIndex(\n prevSelectedIndex, strings.ARIA_CHECKED_ATTR);\n this.adapter.removeClassFromElementAtIndex(\n prevSelectedIndex, cssClasses.MENU_SELECTED_LIST_ITEM);\n }\n\n this.adapter.addClassToElementAtIndex(\n index, cssClasses.MENU_SELECTED_LIST_ITEM);\n this.adapter.addAttributeToElementAtIndex(\n index, strings.ARIA_CHECKED_ATTR, 'true');\n }\n\n /**\n * Sets the enabled state to isEnabled for the menu item at the given index.\n * @param index Index of the menu item\n * @param isEnabled The desired enabled state of the menu item.\n */\n setEnabled(index: number, isEnabled: boolean): void {\n this.validatedIndex_(index);\n\n if (isEnabled) {\n this.adapter.removeClassFromElementAtIndex(\n index, listCssClasses.LIST_ITEM_DISABLED_CLASS);\n this.adapter.addAttributeToElementAtIndex(\n index, strings.ARIA_DISABLED_ATTR, 'false');\n } else {\n this.adapter.addClassToElementAtIndex(\n index, listCssClasses.LIST_ITEM_DISABLED_CLASS);\n this.adapter.addAttributeToElementAtIndex(\n index, strings.ARIA_DISABLED_ATTR, 'true');\n }\n }\n\n private validatedIndex_(index: number): void {\n const menuSize = this.adapter.getMenuItemCount();\n const isIndexInRange = index >= 0 && index < menuSize;\n\n if (!isIndexInRange) {\n throw new Error('MDCMenuFoundation: No list item at specified index.');\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCMenuFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport {Corner} from '@material/menu-surface/constants'; // for backward compatibility\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCFloatingLabelFoundation} from '@material/floating-label/foundation';\nimport {MDCNotchedOutlineAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCNotchedOutlineFoundation} from './foundation';\n\nexport type MDCNotchedOutlineFactory = (el: Element, foundation?: MDCNotchedOutlineFoundation) => MDCNotchedOutline;\n\nexport class MDCNotchedOutline extends MDCComponent<MDCNotchedOutlineFoundation> {\n static attachTo(root: Element): MDCNotchedOutline {\n return new MDCNotchedOutline(root);\n }\n\n private notchElement_!: HTMLElement; // assigned in initialSyncWithDOM()\n\n initialSyncWithDOM() {\n this.notchElement_ =\n this.root.querySelector<HTMLElement>(strings.NOTCH_ELEMENT_SELECTOR)!;\n\n const label = this.root.querySelector<HTMLElement>(\n '.' + MDCFloatingLabelFoundation.cssClasses.ROOT);\n if (label) {\n label.style.transitionDuration = '0s';\n this.root.classList.add(cssClasses.OUTLINE_UPGRADED);\n requestAnimationFrame(() => {\n label.style.transitionDuration = '';\n });\n } else {\n this.root.classList.add(cssClasses.NO_LABEL);\n }\n }\n\n /**\n * Updates classes and styles to open the notch to the specified width.\n * @param notchWidth The notch width in the outline.\n */\n notch(notchWidth: number) {\n this.foundation.notch(notchWidth);\n }\n\n /**\n * Updates classes and styles to close the notch.\n */\n closeNotch() {\n this.foundation.closeNotch();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCNotchedOutlineAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n setNotchWidthProperty: (width) =>\n this.notchElement_.style.setProperty('width', width + 'px'),\n removeNotchWidthProperty: () =>\n this.notchElement_.style.removeProperty('width'),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCNotchedOutlineFoundation(adapter);\n }\n}\n","/**\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 */\n\nconst strings = {\n NOTCH_ELEMENT_SELECTOR: '.mdc-notched-outline__notch',\n};\n\nconst numbers = {\n // This should stay in sync with $mdc-notched-outline-padding * 2.\n NOTCH_ELEMENT_PADDING: 8,\n};\n\nconst cssClasses = {\n NO_LABEL: 'mdc-notched-outline--no-label',\n OUTLINE_NOTCHED: 'mdc-notched-outline--notched',\n OUTLINE_UPGRADED: 'mdc-notched-outline--upgraded',\n};\n\nexport {cssClasses, numbers, strings};\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCNotchedOutlineAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nexport class MDCNotchedOutlineFoundation extends MDCFoundation<MDCNotchedOutlineAdapter> {\n static get strings() {\n return strings;\n }\n\n static get cssClasses() {\n return cssClasses;\n }\n\n static get numbers() {\n return numbers;\n }\n\n /**\n * See {@link MDCNotchedOutlineAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCNotchedOutlineAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n setNotchWidthProperty: () => undefined,\n removeNotchWidthProperty: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n constructor(adapter?: Partial<MDCNotchedOutlineAdapter>) {\n super({...MDCNotchedOutlineFoundation.defaultAdapter, ...adapter});\n }\n\n /**\n * Adds the outline notched selector and updates the notch width calculated based off of notchWidth.\n */\n notch(notchWidth: number) {\n const {OUTLINE_NOTCHED} = MDCNotchedOutlineFoundation.cssClasses;\n\n if (notchWidth > 0) {\n notchWidth += numbers.NOTCH_ELEMENT_PADDING; // Add padding from left/right.\n }\n\n this.adapter.setNotchWidthProperty(notchWidth);\n this.adapter.addClass(OUTLINE_NOTCHED);\n }\n\n /**\n * Removes notched outline selector to close the notch in the outline.\n */\n closeNotch() {\n const {OUTLINE_NOTCHED} = MDCNotchedOutlineFoundation.cssClasses;\n this.adapter.removeClass(OUTLINE_NOTCHED);\n this.adapter.removeNotchWidthProperty();\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCNotchedOutlineFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {applyPassive} from '@material/dom/events';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\nimport {MDCRadioAdapter} from './adapter';\nimport {MDCRadioFoundation} from './foundation';\n\nexport class MDCRadio extends MDCComponent<MDCRadioFoundation> implements MDCRippleCapableSurface {\n static attachTo(root: Element) {\n return new MDCRadio(root);\n }\n\n get checked(): boolean {\n return this.nativeControl_.checked;\n }\n\n set checked(checked: boolean) {\n this.nativeControl_.checked = checked;\n }\n\n get disabled() {\n return this.nativeControl_.disabled;\n }\n\n set disabled(disabled: boolean) {\n this.foundation.setDisabled(disabled);\n }\n\n get value() {\n return this.nativeControl_.value;\n }\n\n set value(value: string) {\n this.nativeControl_.value = value;\n }\n\n get ripple(): MDCRipple {\n return this.ripple_;\n }\n\n private readonly ripple_: MDCRipple = this.createRipple_();\n\n destroy() {\n this.ripple_.destroy();\n super.destroy();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCRadioAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n setNativeControlDisabled: (disabled) => this.nativeControl_.disabled =\n disabled,\n };\n return new MDCRadioFoundation(adapter);\n }\n\n private createRipple_(): MDCRipple {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCRippleAdapter = {\n ...MDCRipple.createAdapter(this),\n registerInteractionHandler: (evtType, handler) => this.nativeControl_.addEventListener(\n evtType, handler, applyPassive()),\n deregisterInteractionHandler: (evtType, handler) => this.nativeControl_.removeEventListener(\n evtType, handler, applyPassive()),\n // Radio buttons technically go \"active\" whenever there is *any* keyboard interaction.\n // This is not the UI we desire.\n isSurfaceActive: () => false,\n isUnbounded: () => true,\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCRipple(this.root, new MDCRippleFoundation(adapter));\n }\n\n private get nativeControl_(): HTMLInputElement {\n const {NATIVE_CONTROL_SELECTOR} = MDCRadioFoundation.strings;\n const el =\n this.root.querySelector<HTMLInputElement>(NATIVE_CONTROL_SELECTOR);\n if (!el) {\n throw new Error(`Radio component requires a ${NATIVE_CONTROL_SELECTOR} element`);\n }\n return el;\n }\n}\n","/**\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 */\n\nconst strings = {\n NATIVE_CONTROL_SELECTOR: '.mdc-radio__native-control',\n};\n\nconst cssClasses = {\n DISABLED: 'mdc-radio--disabled',\n ROOT: 'mdc-radio',\n};\n\nexport {strings, cssClasses};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCRadioAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCRadioFoundation extends MDCFoundation<MDCRadioAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get defaultAdapter(): MDCRadioAdapter {\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n setNativeControlDisabled: () => undefined,\n };\n }\n\n constructor(adapter?: Partial<MDCRadioAdapter>) {\n super({...MDCRadioFoundation.defaultAdapter, ...adapter});\n }\n\n setDisabled(disabled: boolean) {\n const {DISABLED} = MDCRadioFoundation.cssClasses;\n this.adapter.setNativeControlDisabled(disabled);\n if (disabled) {\n this.adapter.addClass(DISABLED);\n } else {\n this.adapter.removeClass(DISABLED);\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCRadioFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\nimport {MDCRippleAdapter} from './adapter';\nimport {MDCRippleFoundation} from './foundation';\nimport {MDCRippleAttachOpts, MDCRippleCapableSurface} from './types';\nimport * as util from './util';\n\nexport type MDCRippleFactory = (el: Element, foundation?: MDCRippleFoundation) => MDCRipple;\n\nexport class MDCRipple extends MDCComponent<MDCRippleFoundation> implements MDCRippleCapableSurface {\n static attachTo(root: Element, opts: MDCRippleAttachOpts = {isUnbounded: undefined}): MDCRipple {\n const ripple = new MDCRipple(root);\n // Only override unbounded behavior if option is explicitly specified\n if (opts.isUnbounded !== undefined) {\n ripple.unbounded = opts.isUnbounded;\n }\n return ripple;\n }\n\n static createAdapter(instance: MDCRippleCapableSurface): MDCRippleAdapter {\n return {\n addClass: (className) => instance.root.classList.add(className),\n browserSupportsCssVars: () => util.supportsCssVariables(window),\n computeBoundingRect: () => instance.root.getBoundingClientRect(),\n containsEventTarget: (target) => instance.root.contains(target as Node),\n deregisterDocumentInteractionHandler: (evtType, handler) =>\n document.documentElement.removeEventListener(\n evtType, handler, applyPassive()),\n deregisterInteractionHandler: (evtType, handler) =>\n (instance.root as HTMLElement)\n .removeEventListener(evtType, handler, applyPassive()),\n deregisterResizeHandler: (handler) =>\n window.removeEventListener('resize', handler),\n getWindowPageOffset: () =>\n ({x: window.pageXOffset, y: window.pageYOffset}),\n isSurfaceActive: () => matches(instance.root, ':active'),\n isSurfaceDisabled: () => Boolean(instance.disabled),\n isUnbounded: () => Boolean(instance.unbounded),\n registerDocumentInteractionHandler: (evtType, handler) =>\n document.documentElement.addEventListener(\n evtType, handler, applyPassive()),\n registerInteractionHandler: (evtType, handler) =>\n (instance.root as HTMLElement)\n .addEventListener(evtType, handler, applyPassive()),\n registerResizeHandler: (handler) =>\n window.addEventListener('resize', handler),\n removeClass: (className) => instance.root.classList.remove(className),\n updateCssVariable: (varName, value) =>\n (instance.root as HTMLElement).style.setProperty(varName, value),\n };\n }\n\n disabled = false;\n\n private unbounded_?: boolean;\n\n get unbounded(): boolean {\n return Boolean(this.unbounded_);\n }\n\n set unbounded(unbounded: boolean) {\n this.unbounded_ = Boolean(unbounded);\n this.setUnbounded_();\n }\n\n activate() {\n this.foundation.activate();\n }\n\n deactivate() {\n this.foundation.deactivate();\n }\n\n layout() {\n this.foundation.layout();\n }\n\n getDefaultFoundation() {\n return new MDCRippleFoundation(MDCRipple.createAdapter(this));\n }\n\n initialSyncWithDOM() {\n const root = this.root as HTMLElement;\n this.unbounded = 'mdcRippleIsUnbounded' in root.dataset;\n }\n\n /**\n * Closure Compiler throws an access control error when directly accessing a\n * protected or private property inside a getter/setter, like unbounded above.\n * By accessing the protected property inside a method, we solve that problem.\n * That's why this function exists.\n */\n private setUnbounded_() {\n this.foundation.setUnbounded(Boolean(this.unbounded_));\n }\n}\n","/**\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 */\n\nexport const cssClasses = {\n // Ripple is a special case where the \"root\" component is really a \"mixin\" of sorts,\n // given that it's an 'upgrade' to an existing component. That being said it is the root\n // CSS class that all other CSS classes derive from.\n BG_FOCUSED: 'mdc-ripple-upgraded--background-focused',\n FG_ACTIVATION: 'mdc-ripple-upgraded--foreground-activation',\n FG_DEACTIVATION: 'mdc-ripple-upgraded--foreground-deactivation',\n ROOT: 'mdc-ripple-upgraded',\n UNBOUNDED: 'mdc-ripple-upgraded--unbounded',\n};\n\nexport const strings = {\n VAR_FG_SCALE: '--mdc-ripple-fg-scale',\n VAR_FG_SIZE: '--mdc-ripple-fg-size',\n VAR_FG_TRANSLATE_END: '--mdc-ripple-fg-translate-end',\n VAR_FG_TRANSLATE_START: '--mdc-ripple-fg-translate-start',\n VAR_LEFT: '--mdc-ripple-left',\n VAR_TOP: '--mdc-ripple-top',\n};\n\nexport const numbers = {\n DEACTIVATION_TIMEOUT_MS: 225, // Corresponds to $mdc-ripple-translate-duration (i.e. activation animation duration)\n FG_DEACTIVATION_MS: 150, // Corresponds to $mdc-ripple-fade-out-duration (i.e. deactivation animation duration)\n INITIAL_ORIGIN_SCALE: 0.6,\n PADDING: 10,\n TAP_DELAY_MS: 300, // Delay between touch and simulated mouse events on touch devices\n};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCRippleAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\nimport {MDCRipplePoint} from './types';\nimport {getNormalizedEventCoords} from './util';\n\ninterface ActivationStateType {\n isActivated?: boolean;\n hasDeactivationUXRun?: boolean;\n wasActivatedByPointer?: boolean;\n wasElementMadeActive?: boolean;\n activationEvent?: Event;\n isProgrammatic?: boolean;\n}\n\ninterface FgTranslationCoordinates {\n startPoint: MDCRipplePoint;\n endPoint: MDCRipplePoint;\n}\n\ninterface Coordinates {\n left: number;\n top: number;\n}\n\ntype ActivationEventType = 'touchstart' | 'pointerdown' | 'mousedown' | 'keydown';\ntype DeactivationEventType = 'touchend' | 'pointerup' | 'mouseup' | 'contextmenu';\n\n// Activation events registered on the root element of each instance for activation\nconst ACTIVATION_EVENT_TYPES: ActivationEventType[] = [\n 'touchstart', 'pointerdown', 'mousedown', 'keydown',\n];\n\n// Deactivation events registered on documentElement when a pointer-related down event occurs\nconst POINTER_DEACTIVATION_EVENT_TYPES: DeactivationEventType[] = [\n 'touchend', 'pointerup', 'mouseup', 'contextmenu',\n];\n\n// simultaneous nested activations\nlet activatedTargets: Array<EventTarget | null> = [];\n\nexport class MDCRippleFoundation extends MDCFoundation<MDCRippleAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get numbers() {\n return numbers;\n }\n\n static get defaultAdapter(): MDCRippleAdapter {\n return {\n addClass: () => undefined,\n browserSupportsCssVars: () => true,\n computeBoundingRect: () => ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n containsEventTarget: () => true,\n deregisterDocumentInteractionHandler: () => undefined,\n deregisterInteractionHandler: () => undefined,\n deregisterResizeHandler: () => undefined,\n getWindowPageOffset: () => ({x: 0, y: 0}),\n isSurfaceActive: () => true,\n isSurfaceDisabled: () => true,\n isUnbounded: () => true,\n registerDocumentInteractionHandler: () => undefined,\n registerInteractionHandler: () => undefined,\n registerResizeHandler: () => undefined,\n removeClass: () => undefined,\n updateCssVariable: () => undefined,\n };\n }\n\n private activationAnimationHasEnded_ = false;\n private activationState_: ActivationStateType;\n private activationTimer_ = 0;\n private fgDeactivationRemovalTimer_ = 0;\n private fgScale_ = '0';\n private frame_ = {width: 0, height: 0};\n private initialSize_ = 0;\n private layoutFrame_ = 0;\n private maxRadius_ = 0;\n private unboundedCoords_: Coordinates = {left: 0, top: 0};\n\n private readonly activationTimerCallback_: () => void;\n private readonly activateHandler_: EventHandlerNonNull;\n private readonly deactivateHandler_: EventHandlerNonNull;\n private readonly focusHandler_: EventHandlerNonNull;\n private readonly blurHandler_: EventHandlerNonNull;\n private readonly resizeHandler_: EventHandlerNonNull;\n\n private previousActivationEvent_?: Event;\n\n constructor(adapter?: Partial<MDCRippleAdapter>) {\n super({...MDCRippleFoundation.defaultAdapter, ...adapter});\n\n this.activationState_ = this.defaultActivationState_();\n\n this.activationTimerCallback_ = () => {\n this.activationAnimationHasEnded_ = true;\n this.runDeactivationUXLogicIfReady_();\n };\n this.activateHandler_ = (e) => this.activate_(e);\n this.deactivateHandler_ = () => this.deactivate_();\n this.focusHandler_ = () => this.handleFocus();\n this.blurHandler_ = () => this.handleBlur();\n this.resizeHandler_ = () => this.layout();\n }\n\n init() {\n const supportsPressRipple = this.supportsPressRipple_();\n\n this.registerRootHandlers_(supportsPressRipple);\n\n if (supportsPressRipple) {\n const {ROOT, UNBOUNDED} = MDCRippleFoundation.cssClasses;\n requestAnimationFrame(() => {\n this.adapter.addClass(ROOT);\n if (this.adapter.isUnbounded()) {\n this.adapter.addClass(UNBOUNDED);\n // Unbounded ripples need layout logic applied immediately to set coordinates for both shade and ripple\n this.layoutInternal_();\n }\n });\n }\n }\n\n destroy() {\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\n if (this.fgDeactivationRemovalTimer_) {\n clearTimeout(this.fgDeactivationRemovalTimer_);\n this.fgDeactivationRemovalTimer_ = 0;\n this.adapter.removeClass(\n MDCRippleFoundation.cssClasses.FG_DEACTIVATION);\n }\n\n const {ROOT, UNBOUNDED} = MDCRippleFoundation.cssClasses;\n requestAnimationFrame(() => {\n this.adapter.removeClass(ROOT);\n this.adapter.removeClass(UNBOUNDED);\n this.removeCssVars_();\n });\n }\n\n this.deregisterRootHandlers_();\n this.deregisterDeactivationHandlers_();\n }\n\n /**\n * @param evt Optional event containing position information.\n */\n activate(evt?: Event): void {\n this.activate_(evt);\n }\n\n deactivate(): void {\n this.deactivate_();\n }\n\n layout(): void {\n if (this.layoutFrame_) {\n cancelAnimationFrame(this.layoutFrame_);\n }\n this.layoutFrame_ = requestAnimationFrame(() => {\n this.layoutInternal_();\n this.layoutFrame_ = 0;\n });\n }\n\n setUnbounded(unbounded: boolean): void {\n const {UNBOUNDED} = MDCRippleFoundation.cssClasses;\n if (unbounded) {\n this.adapter.addClass(UNBOUNDED);\n } else {\n this.adapter.removeClass(UNBOUNDED);\n }\n }\n\n handleFocus(): void {\n requestAnimationFrame(\n () => this.adapter.addClass(MDCRippleFoundation.cssClasses.BG_FOCUSED));\n }\n\n handleBlur(): void {\n requestAnimationFrame(\n () => this.adapter.removeClass(\n 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 private supportsPressRipple_(): boolean {\n return this.adapter.browserSupportsCssVars();\n }\n\n private defaultActivationState_(): ActivationStateType {\n return {\n activationEvent: undefined,\n hasDeactivationUXRun: false,\n isActivated: false,\n isProgrammatic: false,\n wasActivatedByPointer: false,\n wasElementMadeActive: false,\n };\n }\n\n /**\n * supportsPressRipple Passed from init to save a redundant function call\n */\n private registerRootHandlers_(supportsPressRipple: boolean) {\n if (supportsPressRipple) {\n ACTIVATION_EVENT_TYPES.forEach((evtType) => {\n this.adapter.registerInteractionHandler(evtType, this.activateHandler_);\n });\n if (this.adapter.isUnbounded()) {\n this.adapter.registerResizeHandler(this.resizeHandler_);\n }\n }\n\n this.adapter.registerInteractionHandler('focus', this.focusHandler_);\n this.adapter.registerInteractionHandler('blur', this.blurHandler_);\n }\n\n private registerDeactivationHandlers_(evt: Event) {\n if (evt.type === 'keydown') {\n this.adapter.registerInteractionHandler('keyup', this.deactivateHandler_);\n } else {\n POINTER_DEACTIVATION_EVENT_TYPES.forEach((evtType) => {\n this.adapter.registerDocumentInteractionHandler(\n evtType, this.deactivateHandler_);\n });\n }\n }\n\n private deregisterRootHandlers_() {\n ACTIVATION_EVENT_TYPES.forEach((evtType) => {\n this.adapter.deregisterInteractionHandler(evtType, this.activateHandler_);\n });\n this.adapter.deregisterInteractionHandler('focus', this.focusHandler_);\n this.adapter.deregisterInteractionHandler('blur', this.blurHandler_);\n\n if (this.adapter.isUnbounded()) {\n this.adapter.deregisterResizeHandler(this.resizeHandler_);\n }\n }\n\n private deregisterDeactivationHandlers_() {\n this.adapter.deregisterInteractionHandler('keyup', this.deactivateHandler_);\n POINTER_DEACTIVATION_EVENT_TYPES.forEach((evtType) => {\n this.adapter.deregisterDocumentInteractionHandler(\n evtType, this.deactivateHandler_);\n });\n }\n\n private removeCssVars_() {\n const rippleStrings = MDCRippleFoundation.strings;\n const keys = Object.keys(rippleStrings) as Array<keyof typeof rippleStrings>;\n keys.forEach((key) => {\n if (key.indexOf('VAR_') === 0) {\n this.adapter.updateCssVariable(rippleStrings[key], null);\n }\n });\n }\n\n private activate_(evt?: Event) {\n if (this.adapter.isSurfaceDisabled()) {\n return;\n }\n\n const activationState = this.activationState_;\n if (activationState.isActivated) {\n return;\n }\n\n // Avoid reacting to follow-on events fired by touch device after an already-processed user interaction\n const previousActivationEvent = this.previousActivationEvent_;\n const isSameInteraction = previousActivationEvent && evt !== undefined && previousActivationEvent.type !== evt.type;\n if (isSameInteraction) {\n return;\n }\n\n activationState.isActivated = true;\n activationState.isProgrammatic = evt === undefined;\n activationState.activationEvent = evt;\n activationState.wasActivatedByPointer = activationState.isProgrammatic ? false : evt !== undefined && (\n evt.type === 'mousedown' || evt.type === 'touchstart' || evt.type === 'pointerdown'\n );\n\n const hasActivatedChild = evt !== undefined &&\n activatedTargets.length > 0 &&\n activatedTargets.some(\n (target) => 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\n if (evt !== undefined) {\n activatedTargets.push(evt.target);\n this.registerDeactivationHandlers_(evt);\n }\n\n activationState.wasElementMadeActive = this.checkElementMadeActive_(evt);\n if (activationState.wasElementMadeActive) {\n this.animateActivation_();\n }\n\n requestAnimationFrame(() => {\n // Reset array on next frame after the current event has had a chance to bubble to prevent ancestor ripples\n activatedTargets = [];\n\n if (!activationState.wasElementMadeActive\n && evt !== undefined\n && ((evt as KeyboardEvent).key === ' ' || (evt as KeyboardEvent).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\n if (!activationState.wasElementMadeActive) {\n // Reset activation state immediately if element was not made active.\n this.activationState_ = this.defaultActivationState_();\n }\n });\n }\n\n private checkElementMadeActive_(evt?: Event) {\n return (evt !== undefined && evt.type === 'keydown') ?\n this.adapter.isSurfaceActive() :\n true;\n }\n\n private animateActivation_() {\n const {VAR_FG_TRANSLATE_START, VAR_FG_TRANSLATE_END} = MDCRippleFoundation.strings;\n const {FG_DEACTIVATION, FG_ACTIVATION} = MDCRippleFoundation.cssClasses;\n const {DEACTIVATION_TIMEOUT_MS} = MDCRippleFoundation.numbers;\n\n this.layoutInternal_();\n\n let translateStart = '';\n let translateEnd = '';\n\n if (!this.adapter.isUnbounded()) {\n const {startPoint, endPoint} = this.getFgTranslationCoordinates_();\n translateStart = `${startPoint.x}px, ${startPoint.y}px`;\n translateEnd = `${endPoint.x}px, ${endPoint.y}px`;\n }\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\n // Force layout in order to re-trigger the animation.\n this.adapter.computeBoundingRect();\n this.adapter.addClass(FG_ACTIVATION);\n this.activationTimer_ = setTimeout(() => this.activationTimerCallback_(), DEACTIVATION_TIMEOUT_MS);\n }\n\n private getFgTranslationCoordinates_(): FgTranslationCoordinates {\n const {activationEvent, wasActivatedByPointer} = this.activationState_;\n\n let startPoint;\n if (wasActivatedByPointer) {\n startPoint = getNormalizedEventCoords(\n activationEvent,\n this.adapter.getWindowPageOffset(),\n 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\n const endPoint = {\n x: (this.frame_.width / 2) - (this.initialSize_ / 2),\n y: (this.frame_.height / 2) - (this.initialSize_ / 2),\n };\n\n return {startPoint, endPoint};\n }\n\n private runDeactivationUXLogicIfReady_() {\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 const {FG_DEACTIVATION} = MDCRippleFoundation.cssClasses;\n const {hasDeactivationUXRun, isActivated} = this.activationState_;\n const activationHasEnded = hasDeactivationUXRun || !isActivated;\n\n if (activationHasEnded && this.activationAnimationHasEnded_) {\n this.rmBoundedActivationClasses_();\n this.adapter.addClass(FG_DEACTIVATION);\n this.fgDeactivationRemovalTimer_ = setTimeout(() => {\n this.adapter.removeClass(FG_DEACTIVATION);\n }, numbers.FG_DEACTIVATION_MS);\n }\n }\n\n private rmBoundedActivationClasses_() {\n const {FG_ACTIVATION} = MDCRippleFoundation.cssClasses;\n this.adapter.removeClass(FG_ACTIVATION);\n this.activationAnimationHasEnded_ = false;\n this.adapter.computeBoundingRect();\n }\n\n private resetActivationState_() {\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(() => this.previousActivationEvent_ = undefined, MDCRippleFoundation.numbers.TAP_DELAY_MS);\n }\n\n private deactivate_(): void {\n const 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\n const state: ActivationStateType = {...activationState};\n\n if (activationState.isProgrammatic) {\n requestAnimationFrame(() => this.animateDeactivation_(state));\n this.resetActivationState_();\n } else {\n this.deregisterDeactivationHandlers_();\n requestAnimationFrame(() => {\n this.activationState_.hasDeactivationUXRun = true;\n this.animateDeactivation_(state);\n this.resetActivationState_();\n });\n }\n }\n\n private animateDeactivation_({wasActivatedByPointer, wasElementMadeActive}: ActivationStateType) {\n if (wasActivatedByPointer || wasElementMadeActive) {\n this.runDeactivationUXLogicIfReady_();\n }\n }\n\n private layoutInternal_() {\n this.frame_ = this.adapter.computeBoundingRect();\n const maxDim = Math.max(this.frame_.height, this.frame_.width);\n\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 const getBoundedRadius = () => {\n const hypotenuse = Math.sqrt(Math.pow(this.frame_.width, 2) + Math.pow(this.frame_.height, 2));\n return hypotenuse + MDCRippleFoundation.numbers.PADDING;\n };\n\n this.maxRadius_ = this.adapter.isUnbounded() ? maxDim : getBoundedRadius();\n\n // Ripple is sized as a fraction of the largest dimension of the surface, then scales up using a CSS scale transform\n const initialSize = Math.floor(maxDim * MDCRippleFoundation.numbers.INITIAL_ORIGIN_SCALE);\n // Unbounded ripple size should always be even number to equally center align.\n if (this.adapter.isUnbounded() && initialSize % 2 !== 0) {\n this.initialSize_ = initialSize - 1;\n } else {\n this.initialSize_ = initialSize;\n }\n this.fgScale_ = `${this.maxRadius_ / this.initialSize_}`;\n\n this.updateLayoutCssVars_();\n }\n\n private updateLayoutCssVars_() {\n const {\n VAR_FG_SIZE, VAR_LEFT, VAR_TOP, VAR_FG_SCALE,\n } = MDCRippleFoundation.strings;\n\n this.adapter.updateCssVariable(VAR_FG_SIZE, `${this.initialSize_}px`);\n this.adapter.updateCssVariable(VAR_FG_SCALE, this.fgScale_);\n\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\n this.adapter.updateCssVariable(\n VAR_LEFT, `${this.unboundedCoords_.left}px`);\n this.adapter.updateCssVariable(VAR_TOP, `${this.unboundedCoords_.top}px`);\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCRippleFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nimport * as util from './util';\n\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\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 {MDCRipplePoint} from './types';\n\n/**\n * Stores result from supportsCssVariables to avoid redundant processing to\n * detect CSS custom variable support.\n */\nlet supportsCssVariables_: boolean | undefined;\n\nexport function supportsCssVariables(windowObj: Window, forceRefresh = false): boolean {\n const {CSS} = windowObj;\n let supportsCssVars = supportsCssVariables_;\n if (typeof supportsCssVariables_ === 'boolean' && !forceRefresh) {\n return supportsCssVariables_;\n }\n\n const supportsFunctionPresent = CSS && typeof CSS.supports === 'function';\n if (!supportsFunctionPresent) {\n return false;\n }\n\n const explicitlySupportsCssVars = CSS.supports('--css-vars', 'yes');\n // See: https://bugs.webkit.org/show_bug.cgi?id=154669\n // See: README section on Safari\n const weAreFeatureDetectingSafari10plus = (\n CSS.supports('(--css-vars: yes)') &&\n CSS.supports('color', '#00000000')\n );\n\n supportsCssVars =\n explicitlySupportsCssVars || weAreFeatureDetectingSafari10plus;\n\n if (!forceRefresh) {\n supportsCssVariables_ = supportsCssVars;\n }\n return supportsCssVars;\n}\n\nexport function getNormalizedEventCoords(evt: Event | undefined, pageOffset: MDCRipplePoint, clientRect: ClientRect):\n MDCRipplePoint {\n if (!evt) {\n return {x: 0, y: 0};\n }\n const {x, y} = pageOffset;\n const documentX = x + clientRect.left;\n const documentY = y + clientRect.top;\n\n let normalizedX;\n let normalizedY;\n // Determine touch point relative to the ripple container.\n if (evt.type === 'touchstart') {\n const touchEvent = evt as TouchEvent;\n normalizedX = touchEvent.changedTouches[0].pageX - documentX;\n normalizedY = touchEvent.changedTouches[0].pageY - documentY;\n } else {\n const mouseEvent = evt as MouseEvent;\n normalizedX = mouseEvent.pageX - documentX;\n normalizedY = mouseEvent.pageY - documentY;\n }\n\n return {x: normalizedX, y: normalizedY};\n}\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {CustomEventListener, SpecificEventListener} from '@material/base/types';\nimport {MDCFloatingLabel, MDCFloatingLabelFactory} from '@material/floating-label/component';\nimport {MDCLineRipple, MDCLineRippleFactory} from '@material/line-ripple/component';\nimport * as menuSurfaceConstants from '@material/menu-surface/constants';\nimport {MDCMenu, MDCMenuFactory} from '@material/menu/component';\nimport * as menuConstants from '@material/menu/constants';\nimport {MDCMenuItemEvent} from '@material/menu/types';\nimport {MDCNotchedOutline, MDCNotchedOutlineFactory} from '@material/notched-outline/component';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCSelectAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCSelectFoundation} from './foundation';\nimport {MDCSelectHelperText, MDCSelectHelperTextFactory} from './helper-text/component';\nimport {MDCSelectIcon, MDCSelectIconFactory} from './icon/component';\nimport {MDCSelectEventDetail, MDCSelectFoundationMap} from './types';\n\nexport class MDCSelect extends MDCComponent<MDCSelectFoundation> {\n static attachTo(root: Element): MDCSelect {\n return new MDCSelect(root);\n }\n\n private ripple!: MDCRipple|null;\n\n private menu!: MDCMenu; // assigned in menuSetup()\n\n private selectAnchor!: HTMLElement; // assigned in initialize()\n private selectedText!: HTMLElement; // assigned in initialize()\n\n private menuElement!: Element; // assigned in menuSetup()\n private leadingIcon?: MDCSelectIcon; // assigned in initialize()\n private helperText!: MDCSelectHelperText|null; // assigned in initialize()\n private lineRipple!: MDCLineRipple|null; // assigned in initialize()\n private label!: MDCFloatingLabel|null; // assigned in initialize()\n private outline!: MDCNotchedOutline|null; // assigned in initialize()\n private handleChange!:\n SpecificEventListener<'change'>; // assigned in initialize()\n private handleFocus!:\n SpecificEventListener<'focus'>; // assigned in initialize()\n private handleBlur!:\n SpecificEventListener<'blur'>; // assigned in initialize()\n private handleClick!:\n SpecificEventListener<'click'>; // assigned in initialize()\n private handleKeydown!:\n SpecificEventListener<'keydown'>; // assigned in initialize()\n private handleMenuOpened!: EventListener; // assigned in initialize()\n private handleMenuClosed!: EventListener; // assigned in initialize()\n private handleMenuItemAction!:\n CustomEventListener<MDCMenuItemEvent>; // assigned in initialize()\n\n initialize(\n labelFactory: MDCFloatingLabelFactory = (el) => new MDCFloatingLabel(el),\n lineRippleFactory: MDCLineRippleFactory = (el) => new MDCLineRipple(el),\n outlineFactory: MDCNotchedOutlineFactory = (el) => new MDCNotchedOutline(el),\n menuFactory: MDCMenuFactory = (el) => new MDCMenu(el),\n iconFactory: MDCSelectIconFactory = (el) => new MDCSelectIcon(el),\n helperTextFactory: MDCSelectHelperTextFactory = (el) => new MDCSelectHelperText(el),\n ) {\n this.selectAnchor =\n this.root.querySelector(strings.SELECT_ANCHOR_SELECTOR) as HTMLElement;\n this.selectedText =\n this.root.querySelector(strings.SELECTED_TEXT_SELECTOR) as HTMLElement;\n\n if (!this.selectedText) {\n throw new Error(\n 'MDCSelect: Missing required element: The following selector must be present: ' +\n `'${strings.SELECTED_TEXT_SELECTOR}'`,\n );\n }\n\n if (this.selectAnchor.hasAttribute(strings.ARIA_CONTROLS)) {\n const helperTextElement = document.getElementById(\n this.selectAnchor.getAttribute(strings.ARIA_CONTROLS)!);\n if (helperTextElement) {\n this.helperText = helperTextFactory(helperTextElement);\n }\n }\n\n this.menuSetup(menuFactory);\n\n const labelElement = this.root.querySelector(strings.LABEL_SELECTOR);\n this.label = labelElement ? labelFactory(labelElement) : null;\n\n const lineRippleElement =\n this.root.querySelector(strings.LINE_RIPPLE_SELECTOR);\n this.lineRipple =\n lineRippleElement ? lineRippleFactory(lineRippleElement) : null;\n\n const outlineElement = this.root.querySelector(strings.OUTLINE_SELECTOR);\n this.outline = outlineElement ? outlineFactory(outlineElement) : null;\n\n const leadingIcon = this.root.querySelector(strings.LEADING_ICON_SELECTOR);\n if (leadingIcon) {\n this.leadingIcon = iconFactory(leadingIcon);\n }\n\n if (!this.root.classList.contains(cssClasses.OUTLINED)) {\n this.ripple = this.createRipple();\n }\n }\n\n /**\n * Initializes the select's event listeners and internal state based\n * on the environment's state.\n */\n initialSyncWithDOM() {\n this.handleChange = () => {\n this.foundation.handleChange();\n };\n this.handleFocus = () => {\n this.foundation.handleFocus();\n };\n this.handleBlur = () => {\n this.foundation.handleBlur();\n };\n this.handleClick = (evt) => {\n this.selectAnchor.focus();\n this.foundation.handleClick(this.getNormalizedXCoordinate(evt));\n };\n this.handleKeydown = (evt) => {\n this.foundation.handleKeydown(evt);\n };\n this.handleMenuItemAction = (evt) => {\n this.foundation.handleMenuItemAction(evt.detail.index);\n };\n this.handleMenuOpened = () => {\n this.foundation.handleMenuOpened();\n };\n this.handleMenuClosed = () => {\n this.foundation.handleMenuClosed();\n };\n\n this.selectAnchor.addEventListener('focus', this.handleFocus);\n this.selectAnchor.addEventListener('blur', this.handleBlur);\n\n this.selectAnchor.addEventListener(\n 'click', this.handleClick as EventListener);\n\n this.selectAnchor.addEventListener('keydown', this.handleKeydown);\n this.menu.listen(\n menuSurfaceConstants.strings.CLOSED_EVENT, this.handleMenuClosed);\n this.menu.listen(\n menuSurfaceConstants.strings.OPENED_EVENT, this.handleMenuOpened);\n this.menu.listen(\n menuConstants.strings.SELECTED_EVENT, this.handleMenuItemAction);\n }\n\n destroy() {\n this.selectAnchor.removeEventListener('change', this.handleChange);\n this.selectAnchor.removeEventListener('focus', this.handleFocus);\n this.selectAnchor.removeEventListener('blur', this.handleBlur);\n this.selectAnchor.removeEventListener('keydown', this.handleKeydown);\n this.selectAnchor.removeEventListener(\n 'click', this.handleClick as EventListener);\n\n this.menu.unlisten(\n menuSurfaceConstants.strings.CLOSED_EVENT, this.handleMenuClosed);\n this.menu.unlisten(\n menuSurfaceConstants.strings.OPENED_EVENT, this.handleMenuOpened);\n this.menu.unlisten(\n menuConstants.strings.SELECTED_EVENT, this.handleMenuItemAction);\n this.menu.destroy();\n\n if (this.ripple) {\n this.ripple.destroy();\n }\n if (this.outline) {\n this.outline.destroy();\n }\n if (this.leadingIcon) {\n this.leadingIcon.destroy();\n }\n if (this.helperText) {\n this.helperText.destroy();\n }\n\n super.destroy();\n }\n\n get value(): string {\n return this.foundation.getValue();\n }\n\n set value(value: string) {\n this.foundation.setValue(value);\n }\n\n get selectedIndex(): number {\n return this.foundation.getSelectedIndex();\n }\n\n set selectedIndex(selectedIndex: number) {\n this.foundation.setSelectedIndex(selectedIndex, /** closeMenu */ true);\n }\n\n get disabled(): boolean {\n return this.foundation.getDisabled();\n }\n\n set disabled(disabled: boolean) {\n this.foundation.setDisabled(disabled);\n }\n\n set leadingIconAriaLabel(label: string) {\n this.foundation.setLeadingIconAriaLabel(label);\n }\n\n /**\n * Sets the text content of the leading icon.\n */\n set leadingIconContent(content: string) {\n this.foundation.setLeadingIconContent(content);\n }\n\n /**\n * Sets the text content of the helper text.\n */\n set helperTextContent(content: string) {\n this.foundation.setHelperTextContent(content);\n }\n\n /**\n * Enables or disables the default validation scheme where a required select\n * must be non-empty. Set to false for custom validation.\n * @param useDefaultValidation Set this to false to ignore default\n * validation scheme.\n */\n set useDefaultValidation(useDefaultValidation: boolean) {\n this.foundation.setUseDefaultValidation(useDefaultValidation);\n }\n\n /**\n * Sets the current invalid state of the select.\n */\n set valid(isValid: boolean) {\n this.foundation.setValid(isValid);\n }\n\n /**\n * Checks if the select is in a valid state.\n */\n get valid(): boolean {\n return this.foundation.isValid();\n }\n\n /**\n * Sets the control to the required state.\n */\n set required(isRequired: boolean) {\n this.foundation.setRequired(isRequired);\n }\n\n /**\n * Returns whether the select is required.\n */\n get required(): boolean {\n return this.foundation.getRequired();\n }\n\n /**\n * Re-calculates if the notched outline should be notched and if the label\n * should float.\n */\n layout() {\n this.foundation.layout();\n }\n\n /**\n * Synchronizes the list of options with the state of the foundation. Call\n * this whenever menu options are dynamically updated.\n */\n layoutOptions() {\n this.foundation.layoutOptions();\n this.menu.layout();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCSelectAdapter = {\n ...this.getSelectAdapterMethods(),\n ...this.getCommonAdapterMethods(),\n ...this.getOutlineAdapterMethods(),\n ...this.getLabelAdapterMethods(),\n };\n return new MDCSelectFoundation(adapter, this.getFoundationMap());\n }\n\n /**\n * Handles setup for the menu.\n */\n private menuSetup(menuFactory: MDCMenuFactory) {\n this.menuElement = this.root.querySelector(strings.MENU_SELECTOR)!;\n this.menu = menuFactory(this.menuElement);\n this.menu.hasTypeahead = true;\n }\n\n private createRipple(): MDCRipple {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCRippleAdapter = {\n ...MDCRipple.createAdapter({root: this.selectAnchor}),\n registerInteractionHandler: (evtType, handler) => {\n this.selectAnchor.addEventListener(evtType, handler);\n },\n deregisterInteractionHandler: (evtType, handler) => {\n this.selectAnchor.removeEventListener(evtType, handler);\n },\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCRipple(this.selectAnchor, new MDCRippleFoundation(adapter));\n }\n\n private getSelectAdapterMethods() {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n getSelectedMenuItem: () =>\n this.menuElement.querySelector(strings.SELECTED_ITEM_SELECTOR),\n getMenuItemAttr: (menuItem: Element, attr: string) =>\n menuItem.getAttribute(attr),\n setSelectedText: (text: string) => {\n this.selectedText.textContent = text;\n },\n isSelectAnchorFocused: () => document.activeElement === this.selectAnchor,\n getSelectAnchorAttr: (attr: string) =>\n this.selectAnchor.getAttribute(attr),\n setSelectAnchorAttr: (attr: string, value: string) => {\n this.selectAnchor.setAttribute(attr, value);\n },\n removeSelectAnchorAttr: (attr: string) => {\n this.selectAnchor.removeAttribute(attr);\n },\n addMenuClass: (className: string) => {\n this.menuElement.classList.add(className);\n },\n removeMenuClass: (className: string) => {\n this.menuElement.classList.remove(className);\n },\n openMenu: () => {\n this.menu.open = true;\n },\n closeMenu: () => {\n this.menu.open = false;\n },\n getAnchorElement: () =>\n this.root.querySelector(strings.SELECT_ANCHOR_SELECTOR)!,\n setMenuAnchorElement: (anchorEl: HTMLElement) => {\n this.menu.setAnchorElement(anchorEl);\n },\n setMenuAnchorCorner: (anchorCorner: menuSurfaceConstants.Corner) => {\n this.menu.setAnchorCorner(anchorCorner);\n },\n setMenuWrapFocus: (wrapFocus: boolean) => {\n this.menu.wrapFocus = wrapFocus;\n },\n setAttributeAtIndex:\n (index: number, attributeName: string, attributeValue: string) => {\n this.menu.items[index].setAttribute(attributeName, attributeValue);\n },\n removeAttributeAtIndex: (index: number, attributeName: string) => {\n this.menu.items[index].removeAttribute(attributeName);\n },\n focusMenuItemAtIndex: (index: number) => {\n (this.menu.items[index] as HTMLElement).focus();\n },\n getMenuItemCount: () => this.menu.items.length,\n getMenuItemValues: () => this.menu.items.map(\n (el) => el.getAttribute(strings.VALUE_ATTR) || ''),\n getMenuItemTextAtIndex: (index: number) =>\n this.menu.getPrimaryTextAtIndex(index),\n addClassAtIndex: (index: number, className: string) => {\n this.menu.items[index].classList.add(className);\n },\n removeClassAtIndex: (index: number, className: string) => {\n this.menu.items[index].classList.remove(className);\n },\n isTypeaheadInProgress: () => this.menu.typeaheadInProgress,\n typeaheadMatchItem: (nextChar: string, startingIndex: number) =>\n this.menu.typeaheadMatchItem(nextChar, startingIndex),\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private getCommonAdapterMethods() {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: (className: string) => {\n this.root.classList.add(className);\n },\n removeClass: (className: string) => {\n this.root.classList.remove(className);\n },\n hasClass: (className: string) => this.root.classList.contains(className),\n setRippleCenter: (normalizedX: number) => {\n this.lineRipple && this.lineRipple.setRippleCenter(normalizedX)\n },\n activateBottomLine: () => {\n this.lineRipple && this.lineRipple.activate();\n },\n deactivateBottomLine: () => {\n this.lineRipple && this.lineRipple.deactivate();\n },\n notifyChange: (value: string) => {\n const index = this.selectedIndex;\n this.emit<MDCSelectEventDetail>(strings.CHANGE_EVENT, {value, index}, true /* shouldBubble */);\n },\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private getOutlineAdapterMethods() {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n hasOutline: () => Boolean(this.outline),\n notchOutline: (labelWidth: number) => {\n this.outline && this.outline.notch(labelWidth);\n },\n closeOutline: () => {\n this.outline && this.outline.closeNotch();\n },\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private getLabelAdapterMethods() {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n hasLabel: () => !!this.label,\n floatLabel: (shouldFloat: boolean) => {\n this.label && this.label.float(shouldFloat);\n },\n getLabelWidth: () => this.label ? this.label.getWidth() : 0,\n setLabelRequired: (isRequired: boolean) => {\n this.label && this.label.setRequired(isRequired);\n },\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n /**\n * Calculates where the line ripple should start based on the x coordinate within the component.\n */\n private getNormalizedXCoordinate(evt: MouseEvent|TouchEvent): number {\n const targetClientRect = (evt.target as Element).getBoundingClientRect();\n const xCoordinate =\n this.isTouchEvent(evt) ? evt.touches[0].clientX : evt.clientX;\n return xCoordinate - targetClientRect.left;\n }\n\n private isTouchEvent(evt: MouseEvent|TouchEvent): evt is TouchEvent {\n return Boolean((evt as TouchEvent).touches);\n }\n\n /**\n * Returns a map of all subcomponents to subfoundations.\n */\n private getFoundationMap(): Partial<MDCSelectFoundationMap> {\n return {\n helperText: this.helperText ? this.helperText.foundationForSelect :\n undefined,\n leadingIcon: this.leadingIcon ? this.leadingIcon.foundationForSelect :\n undefined,\n };\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n ACTIVATED: 'mdc-select--activated',\n DISABLED: 'mdc-select--disabled',\n FOCUSED: 'mdc-select--focused',\n INVALID: 'mdc-select--invalid',\n MENU_INVALID: 'mdc-select__menu--invalid',\n OUTLINED: 'mdc-select--outlined',\n REQUIRED: 'mdc-select--required',\n ROOT: 'mdc-select',\n SELECTED_ITEM_CLASS: 'mdc-list-item--selected',\n WITH_LEADING_ICON: 'mdc-select--with-leading-icon',\n};\n\nconst strings = {\n ARIA_CONTROLS: 'aria-controls',\n ARIA_SELECTED_ATTR: 'aria-selected',\n CHANGE_EVENT: 'MDCSelect:change',\n LABEL_SELECTOR: '.mdc-floating-label',\n LEADING_ICON_SELECTOR: '.mdc-select__icon',\n LINE_RIPPLE_SELECTOR: '.mdc-line-ripple',\n MENU_SELECTOR: '.mdc-select__menu',\n OUTLINE_SELECTOR: '.mdc-notched-outline',\n SELECTED_ITEM_SELECTOR: `.${cssClasses.SELECTED_ITEM_CLASS}`,\n SELECTED_TEXT_SELECTOR: '.mdc-select__selected-text',\n SELECT_ANCHOR_SELECTOR: '.mdc-select__anchor',\n VALUE_ATTR: 'data-value',\n};\n\nconst numbers = {\n LABEL_SCALE: 0.75,\n UNSET_INDEX: -1,\n};\n\nexport {cssClasses, strings, numbers};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {KEY, normalizeKey} from '@material/dom/keyboard';\nimport {Corner} from '@material/menu-surface/constants';\n\nimport {MDCSelectAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\nimport {MDCSelectHelperTextFoundation} from './helper-text/foundation';\nimport {MDCSelectIconFoundation} from './icon/foundation';\nimport {MDCSelectFoundationMap} from './types';\n\nexport class MDCSelectFoundation extends MDCFoundation<MDCSelectAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get numbers() {\n return numbers;\n }\n\n static get strings() {\n return strings;\n }\n\n /**\n * See {@link MDCSelectAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCSelectAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n hasClass: () => false,\n activateBottomLine: () => undefined,\n deactivateBottomLine: () => undefined,\n getSelectedMenuItem: () => null,\n hasLabel: () => false,\n floatLabel: () => undefined,\n getLabelWidth: () => 0,\n setLabelRequired: () => undefined,\n hasOutline: () => false,\n notchOutline: () => undefined,\n closeOutline: () => undefined,\n setRippleCenter: () => undefined,\n notifyChange: () => undefined,\n setSelectedText: () => undefined,\n isSelectAnchorFocused: () => false,\n getSelectAnchorAttr: () => '',\n setSelectAnchorAttr: () => undefined,\n removeSelectAnchorAttr: () => undefined,\n addMenuClass: () => undefined,\n removeMenuClass: () => undefined,\n openMenu: () => undefined,\n closeMenu: () => undefined,\n getAnchorElement: () => null,\n setMenuAnchorElement: () => undefined,\n setMenuAnchorCorner: () => undefined,\n setMenuWrapFocus: () => undefined,\n setAttributeAtIndex: () => undefined,\n focusMenuItemAtIndex: () => undefined,\n getMenuItemCount: () => 0,\n getMenuItemValues: () => [],\n getMenuItemTextAtIndex: () => '',\n getMenuItemAttr: () => '',\n addClassAtIndex: () => undefined,\n removeClassAtIndex: () => undefined,\n isTypeaheadInProgress: () => false,\n typeaheadMatchItem: () => -1,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private readonly leadingIcon: MDCSelectIconFoundation|undefined;\n private readonly helperText: MDCSelectHelperTextFoundation|undefined;\n\n // Index of the currently selected menu item.\n private selectedIndex: number = numbers.UNSET_INDEX;\n // VALUE_ATTR values of the menu items.\n private menuItemValues: string[] = [];\n // Disabled state\n private disabled = false;\n // isMenuOpen is used to track the state of the menu by listening to the\n // MDCMenuSurface:closed event For reference, menu.open will return false if\n // the menu is still closing, but isMenuOpen returns false only after the menu\n // has closed\n private isMenuOpen = false;\n // By default, select is invalid if it is required but no value is selected.\n private useDefaultValidation = true;\n private customValidity = true;\n\n /* istanbul ignore next: optional argument is not a branch statement */\n /**\n * @param adapter\n * @param foundationMap Map from subcomponent names to their subfoundations.\n */\n constructor(adapter?: Partial<MDCSelectAdapter>, foundationMap: Partial<MDCSelectFoundationMap> = {}) {\n super({...MDCSelectFoundation.defaultAdapter, ...adapter});\n\n this.leadingIcon = foundationMap.leadingIcon;\n this.helperText = foundationMap.helperText;\n }\n\n /** Returns the index of the currently selected menu item, or -1 if none. */\n getSelectedIndex(): number {\n return this.selectedIndex;\n }\n\n setSelectedIndex(index: number, closeMenu = false) {\n if (index >= this.adapter.getMenuItemCount()) {\n return;\n }\n\n this.removeSelectionAtIndex(this.selectedIndex);\n this.setSelectionAtIndex(index);\n\n if (closeMenu) {\n this.adapter.closeMenu();\n }\n\n this.handleChange();\n }\n\n setValue(value: string) {\n const index = this.menuItemValues.indexOf(value);\n this.setSelectedIndex(index);\n }\n\n getValue() {\n const listItem = this.adapter.getSelectedMenuItem();\n if (listItem) {\n return this.adapter.getMenuItemAttr(listItem, strings.VALUE_ATTR) || '';\n }\n return '';\n }\n\n getDisabled() {\n return this.disabled;\n }\n\n setDisabled(isDisabled: boolean) {\n this.disabled = isDisabled;\n if (this.disabled) {\n this.adapter.addClass(cssClasses.DISABLED);\n this.adapter.closeMenu();\n } else {\n this.adapter.removeClass(cssClasses.DISABLED);\n }\n\n if (this.leadingIcon) {\n this.leadingIcon.setDisabled(this.disabled);\n }\n\n if (this.disabled) {\n // Prevent click events from focusing select. Simply pointer-events: none\n // is not enough since screenreader clicks may bypass this.\n this.adapter.removeSelectAnchorAttr('tabindex');\n } else {\n this.adapter.setSelectAnchorAttr('tabindex', '0');\n }\n\n this.adapter.setSelectAnchorAttr('aria-disabled', this.disabled.toString());\n }\n\n /** Opens the menu. */\n openMenu() {\n this.adapter.addClass(cssClasses.ACTIVATED);\n this.adapter.openMenu();\n this.isMenuOpen = true;\n this.adapter.setSelectAnchorAttr('aria-expanded', 'true');\n }\n\n /**\n * @param content Sets the content of the helper text.\n */\n setHelperTextContent(content: string) {\n if (this.helperText) {\n this.helperText.setContent(content);\n }\n }\n\n /**\n * Re-calculates if the notched outline should be notched and if the label\n * should float.\n */\n layout() {\n if (this.adapter.hasLabel()) {\n const optionHasValue = this.getValue().length > 0;\n const isFocused = this.adapter.hasClass(cssClasses.FOCUSED);\n const shouldFloatAndNotch = optionHasValue || isFocused;\n const isRequired = this.adapter.hasClass(cssClasses.REQUIRED);\n\n this.notchOutline(shouldFloatAndNotch);\n this.adapter.floatLabel(shouldFloatAndNotch);\n this.adapter.setLabelRequired(isRequired);\n }\n }\n\n /**\n * Synchronizes the list of options with the state of the foundation. Call\n * this whenever menu options are dynamically updated.\n */\n layoutOptions() {\n this.menuItemValues = this.adapter.getMenuItemValues();\n const selectedIndex = this.menuItemValues.indexOf(this.getValue());\n this.setSelectionAtIndex(selectedIndex);\n }\n\n handleMenuOpened() {\n if (this.menuItemValues.length === 0) {\n return;\n }\n\n // Menu should open to the last selected element, should open to first menu item otherwise.\n const focusItemIndex = this.selectedIndex >= 0 ? this.selectedIndex : 0;\n this.adapter.focusMenuItemAtIndex(focusItemIndex);\n }\n\n handleMenuClosed() {\n this.adapter.removeClass(cssClasses.ACTIVATED);\n this.isMenuOpen = false;\n this.adapter.setSelectAnchorAttr('aria-expanded', 'false');\n\n // Unfocus the select if menu is closed without a selection\n if (!this.adapter.isSelectAnchorFocused()) {\n this.blur();\n }\n }\n\n /**\n * Handles value changes, via change event or programmatic updates.\n */\n handleChange() {\n this.layout();\n this.adapter.notifyChange(this.getValue());\n\n const isRequired = this.adapter.hasClass(cssClasses.REQUIRED);\n if (isRequired && this.useDefaultValidation) {\n this.setValid(this.isValid());\n if (this.helperText) {\n this.helperText.setValidity(this.isValid());\n }\n }\n }\n\n handleMenuItemAction(index: number) {\n this.setSelectedIndex(index, /** closeMenu */ true);\n }\n\n /**\n * Handles focus events from select element.\n */\n handleFocus() {\n this.adapter.addClass(cssClasses.FOCUSED);\n this.layout();\n\n this.adapter.activateBottomLine();\n }\n\n /**\n * Handles blur events from select element.\n */\n handleBlur() {\n if (this.isMenuOpen) {\n return;\n }\n this.blur();\n }\n\n handleClick(normalizedX: number) {\n if (this.disabled) {\n return;\n }\n\n if (this.isMenuOpen) {\n this.adapter.closeMenu();\n return;\n }\n\n this.adapter.setRippleCenter(normalizedX);\n\n this.openMenu();\n }\n\n /**\n * Handles keydown events on select element. Depending on the type of\n * character typed, does typeahead matching or opens menu.\n */\n handleKeydown(event: KeyboardEvent) {\n if (this.isMenuOpen || !this.adapter.hasClass(cssClasses.FOCUSED)) {\n return;\n }\n\n const isEnter = normalizeKey(event) === KEY.ENTER;\n const isSpace = normalizeKey(event) === KEY.SPACEBAR;\n const arrowUp = normalizeKey(event) === KEY.ARROW_UP;\n const arrowDown = normalizeKey(event) === KEY.ARROW_DOWN;\n\n // Typeahead\n if (!isSpace && event.key && event.key.length === 1 ||\n isSpace && this.adapter.isTypeaheadInProgress()) {\n const key = isSpace ? ' ' : event.key;\n const typeaheadNextIndex =\n this.adapter.typeaheadMatchItem(key, this.selectedIndex);\n if (typeaheadNextIndex >= 0) {\n this.setSelectedIndex(typeaheadNextIndex);\n }\n event.preventDefault();\n return;\n }\n\n if (!isEnter && !isSpace && !arrowUp && !arrowDown) {\n return;\n }\n\n // Increment/decrement index as necessary and open menu.\n if (arrowUp && this.selectedIndex > 0) {\n this.setSelectedIndex(this.selectedIndex - 1);\n } else if (\n arrowDown && this.selectedIndex < this.adapter.getMenuItemCount() - 1) {\n this.setSelectedIndex(this.selectedIndex + 1);\n }\n\n this.openMenu();\n event.preventDefault();\n }\n\n /**\n * Opens/closes the notched outline.\n */\n notchOutline(openNotch: boolean) {\n if (!this.adapter.hasOutline()) {\n return;\n }\n const isFocused = this.adapter.hasClass(cssClasses.FOCUSED);\n\n if (openNotch) {\n const labelScale = numbers.LABEL_SCALE;\n const labelWidth = this.adapter.getLabelWidth() * labelScale;\n this.adapter.notchOutline(labelWidth);\n } else if (!isFocused) {\n this.adapter.closeOutline();\n }\n }\n\n /**\n * Sets the aria label of the leading icon.\n */\n setLeadingIconAriaLabel(label: string) {\n if (this.leadingIcon) {\n this.leadingIcon.setAriaLabel(label);\n }\n }\n\n /**\n * Sets the text content of the leading icon.\n */\n setLeadingIconContent(content: string) {\n if (this.leadingIcon) {\n this.leadingIcon.setContent(content);\n }\n }\n\n setUseDefaultValidation(useDefaultValidation: boolean) {\n this.useDefaultValidation = useDefaultValidation;\n }\n\n setValid(isValid: boolean) {\n if (!this.useDefaultValidation) {\n this.customValidity = isValid;\n }\n\n this.adapter.setSelectAnchorAttr('aria-invalid', (!isValid).toString());\n if (isValid) {\n this.adapter.removeClass(cssClasses.INVALID);\n this.adapter.removeMenuClass(cssClasses.MENU_INVALID);\n } else {\n this.adapter.addClass(cssClasses.INVALID);\n this.adapter.addMenuClass(cssClasses.MENU_INVALID);\n }\n }\n\n isValid() {\n if (this.useDefaultValidation &&\n this.adapter.hasClass(cssClasses.REQUIRED) &&\n !this.adapter.hasClass(cssClasses.DISABLED)) {\n // See notes for required attribute under https://www.w3.org/TR/html52/sec-forms.html#the-select-element\n // TL;DR: Invalid if no index is selected, or if the first index is selected and has an empty value.\n return this.selectedIndex !== numbers.UNSET_INDEX &&\n (this.selectedIndex !== 0 || Boolean(this.getValue()));\n }\n return this.customValidity;\n }\n\n setRequired(isRequired: boolean) {\n if (isRequired) {\n this.adapter.addClass(cssClasses.REQUIRED);\n } else {\n this.adapter.removeClass(cssClasses.REQUIRED);\n }\n this.adapter.setSelectAnchorAttr('aria-required', isRequired.toString());\n this.adapter.setLabelRequired(isRequired);\n }\n\n getRequired() {\n return this.adapter.getSelectAnchorAttr('aria-required') === 'true';\n }\n\n init() {\n const anchorEl = this.adapter.getAnchorElement();\n if (anchorEl) {\n this.adapter.setMenuAnchorElement(anchorEl);\n this.adapter.setMenuAnchorCorner(Corner.BOTTOM_START);\n }\n this.adapter.setMenuWrapFocus(false);\n\n this.setDisabled(this.adapter.hasClass(cssClasses.DISABLED));\n this.layoutOptions();\n this.layout();\n }\n\n /**\n * Unfocuses the select component.\n */\n private blur() {\n this.adapter.removeClass(cssClasses.FOCUSED);\n this.layout();\n this.adapter.deactivateBottomLine();\n\n const isRequired = this.adapter.hasClass(cssClasses.REQUIRED);\n if (isRequired && this.useDefaultValidation) {\n this.setValid(this.isValid());\n if (this.helperText) {\n this.helperText.setValidity(this.isValid());\n }\n }\n }\n\n private setSelectionAtIndex(index: number) {\n this.selectedIndex = index;\n\n if (index === numbers.UNSET_INDEX) {\n this.adapter.setSelectedText('');\n return;\n }\n\n this.adapter.setSelectedText(\n this.adapter.getMenuItemTextAtIndex(index).trim());\n this.adapter.addClassAtIndex(index, cssClasses.SELECTED_ITEM_CLASS);\n this.adapter.setAttributeAtIndex(index, strings.ARIA_SELECTED_ATTR, 'true');\n }\n\n private removeSelectionAtIndex(index: number) {\n if (index !== numbers.UNSET_INDEX) {\n this.adapter.removeClassAtIndex(index, cssClasses.SELECTED_ITEM_CLASS);\n this.adapter.setAttributeAtIndex(\n index, strings.ARIA_SELECTED_ATTR, 'false');\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSelectFoundation;\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCSelectHelperTextAdapter} from './adapter';\nimport {MDCSelectHelperTextFoundation} from './foundation';\n\nexport type MDCSelectHelperTextFactory =\n (el: Element, foundation?: MDCSelectHelperTextFoundation) => MDCSelectHelperText;\n\nexport class MDCSelectHelperText extends MDCComponent<MDCSelectHelperTextFoundation> {\n static attachTo(root: Element): MDCSelectHelperText {\n return new MDCSelectHelperText(root);\n }\n\n // Provided for access by MDCSelect component\n get foundationForSelect(): MDCSelectHelperTextFoundation {\n return this.foundation;\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCSelectHelperTextAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n hasClass: (className) => this.root.classList.contains(className),\n setAttr: (attr, value) => this.root.setAttribute(attr, value),\n removeAttr: (attr) => this.root.removeAttribute(attr),\n setContent: (content) => {\n this.root.textContent = content;\n },\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCSelectHelperTextFoundation(adapter);\n }\n}\n","/**\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 */\n\nconst strings = {\n ARIA_HIDDEN: 'aria-hidden',\n ROLE: 'role',\n};\n\nconst cssClasses = {\n HELPER_TEXT_VALIDATION_MSG: 'mdc-select-helper-text--validation-msg',\n HELPER_TEXT_VALIDATION_MSG_PERSISTENT:\n 'mdc-select-helper-text--validation-msg-persistent',\n};\n\nexport {strings, cssClasses};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCSelectHelperTextAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCSelectHelperTextFoundation extends MDCFoundation<MDCSelectHelperTextAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n /**\n * See {@link MDCSelectHelperTextAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCSelectHelperTextAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n hasClass: () => false,\n setAttr: () => undefined,\n removeAttr: () => undefined,\n setContent: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n constructor(adapter?: Partial<MDCSelectHelperTextAdapter>) {\n super({...MDCSelectHelperTextFoundation.defaultAdapter, ...adapter});\n }\n\n /**\n * Sets the content of the helper text field.\n */\n setContent(content: string) {\n this.adapter.setContent(content);\n }\n\n /**\n * Sets the helper text to act as a validation message.\n * By default, validation messages are hidden when the select is valid and\n * visible when the select is invalid.\n *\n * @param isValidation True to make the helper text act as an error validation\n * message.\n */\n setValidation(isValidation: boolean) {\n if (isValidation) {\n this.adapter.addClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n } else {\n this.adapter.removeClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n }\n }\n\n /**\n * Sets the persistency of the validation helper text.\n * This keeps the validation message visible even if the select is valid,\n * though it will be displayed in the normal (grey) color.\n */\n setValidationMsgPersistent(isPersistent: boolean) {\n if (isPersistent) {\n this.adapter.addClass(cssClasses.HELPER_TEXT_VALIDATION_MSG_PERSISTENT);\n } else {\n this.adapter.removeClass(\n cssClasses.HELPER_TEXT_VALIDATION_MSG_PERSISTENT);\n }\n }\n\n /**\n * Makes the helper text visible to screen readers.\n */\n showToScreenReader() {\n this.adapter.removeAttr(strings.ARIA_HIDDEN);\n }\n\n /**\n * When acting as a validation message, shows/hides the helper text and\n * triggers alerts as necessary based on the select's validity.\n */\n setValidity(selectIsValid: boolean) {\n const isValidationMsg =\n this.adapter.hasClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n\n if (!isValidationMsg) {\n // Non-validating helper-text is always displayed and does not participate\n // in validation logic.\n return;\n }\n\n const isPersistentValidationMsg =\n this.adapter.hasClass(cssClasses.HELPER_TEXT_VALIDATION_MSG_PERSISTENT);\n\n // Validating helper text is displayed if select is invalid, unless it is\n // set as persistent, in which case it always displays.\n const msgShouldDisplay = !selectIsValid || isPersistentValidationMsg;\n if (msgShouldDisplay) {\n this.showToScreenReader();\n\n // In addition to displaying, also trigger an alert if the select\n // has become invalid.\n if (!selectIsValid) {\n this.adapter.setAttr(strings.ROLE, 'alert');\n } else {\n this.adapter.removeAttr(strings.ROLE);\n }\n return;\n }\n\n // Hide everything.\n this.adapter.removeAttr(strings.ROLE);\n this.hide();\n }\n\n /**\n * Hides the help text from screen readers.\n */\n private hide() {\n this.adapter.setAttr(strings.ARIA_HIDDEN, 'true');\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSelectHelperTextFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {cssClasses as helperTextCssClasses, strings as helperTextStrings} from './constants';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCSelectIconAdapter} from './adapter';\nimport {MDCSelectIconFoundation} from './foundation';\n\nexport type MDCSelectIconFactory = (el: Element, foundation?: MDCSelectIconFoundation) => MDCSelectIcon;\n\nexport class MDCSelectIcon extends MDCComponent<MDCSelectIconFoundation> {\n static attachTo(root: Element): MDCSelectIcon {\n return new MDCSelectIcon(root);\n }\n\n // Provided for access by MDCSelect component\n get foundationForSelect(): MDCSelectIconFoundation {\n return this.foundation;\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCSelectIconAdapter = {\n getAttr: (attr) => this.root.getAttribute(attr),\n setAttr: (attr, value) => this.root.setAttribute(attr, value),\n removeAttr: (attr) => this.root.removeAttribute(attr),\n setContent: (content) => {\n this.root.textContent = content;\n },\n registerInteractionHandler: (evtType, handler) =>\n this.listen(evtType, handler),\n deregisterInteractionHandler: (evtType, handler) =>\n this.unlisten(evtType, handler),\n notifyIconAction: () => this.emit(\n MDCSelectIconFoundation.strings.ICON_EVENT, {} /* evtData */,\n true /* shouldBubble */),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCSelectIconFoundation(adapter);\n }\n}\n","/**\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 */\n\nconst strings = {\n ICON_EVENT: 'MDCSelect:icon',\n ICON_ROLE: 'button',\n};\n\nexport {strings};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCSelectIconAdapter} from './adapter';\nimport {strings} from './constants';\n\ntype InteractionEventType = 'click' | 'keydown';\n\nconst INTERACTION_EVENTS: InteractionEventType[] = ['click', 'keydown'];\n\nexport class MDCSelectIconFoundation extends MDCFoundation<MDCSelectIconAdapter> {\n static get strings() {\n return strings;\n }\n\n /**\n * See {@link MDCSelectIconAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCSelectIconAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n getAttr: () => null,\n setAttr: () => undefined,\n removeAttr: () => undefined,\n setContent: () => undefined,\n registerInteractionHandler: () => undefined,\n deregisterInteractionHandler: () => undefined,\n notifyIconAction: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private savedTabIndex_: string | null = null;\n\n // assigned in initialSyncWithDOM()\n private readonly interactionHandler_!: SpecificEventListener<InteractionEventType>;\n\n constructor(adapter?: Partial<MDCSelectIconAdapter>) {\n super({...MDCSelectIconFoundation.defaultAdapter, ...adapter});\n\n this.interactionHandler_ = (evt) => this.handleInteraction(evt);\n }\n\n init() {\n this.savedTabIndex_ = this.adapter.getAttr('tabindex');\n\n INTERACTION_EVENTS.forEach((evtType) => {\n this.adapter.registerInteractionHandler(\n evtType, this.interactionHandler_);\n });\n }\n\n destroy() {\n INTERACTION_EVENTS.forEach((evtType) => {\n this.adapter.deregisterInteractionHandler(\n evtType, this.interactionHandler_);\n });\n }\n\n setDisabled(disabled: boolean) {\n if (!this.savedTabIndex_) {\n return;\n }\n\n if (disabled) {\n this.adapter.setAttr('tabindex', '-1');\n this.adapter.removeAttr('role');\n } else {\n this.adapter.setAttr('tabindex', this.savedTabIndex_);\n this.adapter.setAttr('role', strings.ICON_ROLE);\n }\n }\n\n setAriaLabel(label: string) {\n this.adapter.setAttr('aria-label', label);\n }\n\n setContent(content: string) {\n this.adapter.setContent(content);\n }\n\n handleInteraction(evt: MouseEvent | KeyboardEvent) {\n const isEnterKey = (evt as KeyboardEvent).key === 'Enter' || (evt as KeyboardEvent).keyCode === 13;\n if (evt.type === 'click' || isEnterKey) {\n this.adapter.notifyIconAction();\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSelectIconFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {strings as iconStrings} from './constants';\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\nexport * from './helper-text/index';\nexport * from './icon/index';\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {applyPassive} from '@material/dom/events';\nimport {MDCSliderAdapter} from './adapter';\nimport {strings} from './constants';\nimport {MDCSliderFoundation} from './foundation';\n\nexport class MDCSlider extends MDCComponent<MDCSliderFoundation> {\n static attachTo(root: Element) {\n return new MDCSlider(root);\n }\n\n private thumbContainer_!: HTMLElement; // assigned in initialize()\n private track_!: HTMLElement; // assigned in initialize()\n private pinValueMarker_!: HTMLElement; // assigned in initialize()\n private trackMarkerContainer_!: HTMLElement; // assigned in initialize()\n\n get value(): number {\n return this.foundation.getValue();\n }\n\n set value(value: number) {\n this.foundation.setValue(value);\n }\n\n get min(): number {\n return this.foundation.getMin();\n }\n\n set min(min: number) {\n this.foundation.setMin(min);\n }\n\n get max(): number {\n return this.foundation.getMax();\n }\n\n set max(max: number) {\n this.foundation.setMax(max);\n }\n\n get step(): number {\n return this.foundation.getStep();\n }\n\n set step(step: number) {\n this.foundation.setStep(step);\n }\n\n get disabled(): boolean {\n return this.foundation.isDisabled();\n }\n\n set disabled(disabled: boolean) {\n this.foundation.setDisabled(disabled);\n }\n\n initialize() {\n this.thumbContainer_ =\n this.root.querySelector<HTMLElement>(strings.THUMB_CONTAINER_SELECTOR)!;\n this.track_ = this.root.querySelector<HTMLElement>(strings.TRACK_SELECTOR)!;\n this.pinValueMarker_ = this.root.querySelector<HTMLElement>(\n strings.PIN_VALUE_MARKER_SELECTOR)!;\n this.trackMarkerContainer_ = this.root.querySelector<HTMLElement>(\n strings.TRACK_MARKER_CONTAINER_SELECTOR)!;\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take\n // a Partial<MDCFooAdapter>. To ensure we don't accidentally omit any\n // methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same\n // order as the adapter interface.\n const adapter: MDCSliderAdapter = {\n hasClass: (className) => this.root.classList.contains(className),\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n getAttribute: (name) => this.root.getAttribute(name),\n setAttribute: (name, value) => this.root.setAttribute(name, value),\n removeAttribute: (name) => this.root.removeAttribute(name),\n computeBoundingRect: () => this.root.getBoundingClientRect(),\n getTabIndex: () => (this.root as HTMLElement).tabIndex,\n registerInteractionHandler: (evtType, handler) =>\n this.listen(evtType, handler, applyPassive()),\n deregisterInteractionHandler: (evtType, handler) =>\n this.unlisten(evtType, handler, applyPassive()),\n registerThumbContainerInteractionHandler: (evtType, handler) => {\n this.thumbContainer_.addEventListener(evtType, handler, applyPassive());\n },\n deregisterThumbContainerInteractionHandler: (evtType, handler) => {\n this.thumbContainer_.removeEventListener(\n evtType, handler, applyPassive());\n },\n registerBodyInteractionHandler: (evtType, handler) =>\n document.body.addEventListener(evtType, handler),\n deregisterBodyInteractionHandler: (evtType, handler) =>\n document.body.removeEventListener(evtType, handler),\n registerResizeHandler: (handler) =>\n window.addEventListener('resize', handler),\n deregisterResizeHandler: (handler) =>\n window.removeEventListener('resize', handler),\n notifyInput: () => this.emit<MDCSlider>(\n strings.INPUT_EVENT,\n this), // TODO(acdvorak): Create detail interface\n notifyChange: () => this.emit<MDCSlider>(\n strings.CHANGE_EVENT,\n this), // TODO(acdvorak): Create detail interface\n setThumbContainerStyleProperty: (propertyName, value) => {\n this.thumbContainer_.style.setProperty(propertyName, value);\n },\n setTrackStyleProperty: (propertyName, value) =>\n this.track_.style.setProperty(propertyName, value),\n setMarkerValue: (value) => this.pinValueMarker_.innerText =\n value.toLocaleString(),\n setTrackMarkers: (step, max, min) => {\n const stepStr = step.toLocaleString();\n const maxStr = max.toLocaleString();\n const minStr = min.toLocaleString();\n // keep calculation in css for better rounding/subpixel behavior\n const markerAmount = `((${maxStr} - ${minStr}) / ${stepStr})`;\n const markerWidth = `2px`;\n const markerBkgdImage = `linear-gradient(to right, currentColor ${\n markerWidth}, transparent 0)`;\n const markerBkgdLayout = `0 center / calc((100% - ${markerWidth}) / ${\n markerAmount}) 100% repeat-x`;\n const markerBkgdShorthand = `${markerBkgdImage} ${markerBkgdLayout}`;\n this.trackMarkerContainer_.style.setProperty(\n 'background', markerBkgdShorthand);\n },\n isRTL: () => getComputedStyle(this.root).direction === 'rtl',\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCSliderFoundation(adapter);\n }\n\n initialSyncWithDOM() {\n const origValueNow = this.parseFloat_(\n this.root.getAttribute(strings.ARIA_VALUENOW), this.value);\n const min = this.parseFloat_(\n this.root.getAttribute(strings.ARIA_VALUEMIN), this.min);\n const max = this.parseFloat_(\n this.root.getAttribute(strings.ARIA_VALUEMAX), this.max);\n\n // min and max need to be set in the right order to avoid throwing an error\n // when the new min is greater than the default max.\n if (min >= this.max) {\n this.max = max;\n this.min = min;\n } else {\n this.min = min;\n this.max = max;\n }\n\n this.step = this.parseFloat_(\n this.root.getAttribute(strings.STEP_DATA_ATTR), this.step);\n this.value = origValueNow;\n this.disabled =\n (this.root.hasAttribute(strings.ARIA_DISABLED) &&\n this.root.getAttribute(strings.ARIA_DISABLED) !== 'false');\n this.foundation.setupTrackMarker();\n }\n\n layout() {\n this.foundation.layout();\n }\n\n stepUp(amount = (this.step || 1)) {\n this.value += amount;\n }\n\n stepDown(amount = (this.step || 1)) {\n this.value -= amount;\n }\n\n private parseFloat_(str: string|null, defaultValue: number) {\n const num = parseFloat(str!); // tslint:disable-line:ban\n const isNumeric = typeof num === 'number' && isFinite(num);\n return isNumeric ? num : defaultValue;\n }\n}\n","/**\n * @license\n * Copyright 2017 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 */\n\nconst cssClasses = {\n ACTIVE: 'mdc-slider--active',\n DISABLED: 'mdc-slider--disabled',\n DISCRETE: 'mdc-slider--discrete',\n FOCUS: 'mdc-slider--focus',\n HAS_TRACK_MARKER: 'mdc-slider--display-markers',\n IN_TRANSIT: 'mdc-slider--in-transit',\n IS_DISCRETE: 'mdc-slider--discrete',\n DISABLE_TOUCH_ACTION: 'mdc-slider--disable-touch-action',\n};\n\nconst strings = {\n ARIA_DISABLED: 'aria-disabled',\n ARIA_VALUEMAX: 'aria-valuemax',\n ARIA_VALUEMIN: 'aria-valuemin',\n ARIA_VALUENOW: 'aria-valuenow',\n CHANGE_EVENT: 'MDCSlider:change',\n INPUT_EVENT: 'MDCSlider:input',\n PIN_VALUE_MARKER_SELECTOR: '.mdc-slider__pin-value-marker',\n STEP_DATA_ATTR: 'data-step',\n THUMB_CONTAINER_SELECTOR: '.mdc-slider__thumb-container',\n TRACK_MARKER_CONTAINER_SELECTOR: '.mdc-slider__track-marker-container',\n TRACK_SELECTOR: '.mdc-slider__track',\n};\n\nconst numbers = {\n PAGE_FACTOR: 4,\n};\n\nexport {cssClasses, strings, numbers};\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {getCorrectEventName, getCorrectPropertyName} from '@material/animation/util';\nimport {MDCFoundation} from '@material/base/foundation';\nimport {EventType, SpecificEventListener} from '@material/base/types';\nimport {MDCSliderAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\ntype UpEventType = 'mouseup'|'pointerup'|'touchend';\ntype DownEventType = 'mousedown'|'pointerdown'|'touchstart';\ntype MoveEventType = 'mousemove'|'pointermove'|'touchmove';\ntype MouseLikeEvent = MouseEvent|PointerEvent|TouchEvent;\n\ntype MoveEventMap = {\n readonly[K in DownEventType]: MoveEventType;\n};\n\n// Accessing `window` without a `typeof` check will throw on Node environments.\nconst hasWindow = typeof window !== 'undefined';\nconst hasPointerEventSupport = hasWindow && !!window.PointerEvent;\n\nconst DOWN_EVENTS: DownEventType[] =\n hasPointerEventSupport ? ['pointerdown'] : ['mousedown', 'touchstart'];\nconst UP_EVENTS: UpEventType[] =\n hasPointerEventSupport ? ['pointerup'] : ['mouseup', 'touchend'];\n\nconst MOVE_EVENT_MAP: MoveEventMap = {\n mousedown: 'mousemove',\n pointerdown: 'pointermove',\n touchstart: 'touchmove',\n};\n\nconst KEY_IDS = {\n ARROW_DOWN: 'ArrowDown',\n ARROW_LEFT: 'ArrowLeft',\n ARROW_RIGHT: 'ArrowRight',\n ARROW_UP: 'ArrowUp',\n END: 'End',\n HOME: 'Home',\n PAGE_DOWN: 'PageDown',\n PAGE_UP: 'PageUp',\n};\n\nexport class MDCSliderFoundation extends MDCFoundation<MDCSliderAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get numbers() {\n return numbers;\n }\n\n static get defaultAdapter(): MDCSliderAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same\n // order as the adapter interface.\n return {\n hasClass: () => false,\n addClass: () => undefined,\n removeClass: () => undefined,\n getAttribute: () => null,\n setAttribute: () => undefined,\n removeAttribute: () => undefined,\n computeBoundingRect: () =>\n ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n getTabIndex: () => 0,\n registerInteractionHandler: () => undefined,\n deregisterInteractionHandler: () => undefined,\n registerThumbContainerInteractionHandler: () => undefined,\n deregisterThumbContainerInteractionHandler: () => undefined,\n registerBodyInteractionHandler: () => undefined,\n deregisterBodyInteractionHandler: () => undefined,\n registerResizeHandler: () => undefined,\n deregisterResizeHandler: () => undefined,\n notifyInput: () => undefined,\n notifyChange: () => undefined,\n setThumbContainerStyleProperty: () => undefined,\n setTrackStyleProperty: () => undefined,\n setMarkerValue: () => undefined,\n setTrackMarkers: () => undefined,\n isRTL: () => false,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private rect_!: ClientRect; // assigned in layout() via init()\n\n /**\n * We set this to NaN since we want it to be a number, but we can't use '0' or\n * '-1' because those could be valid tabindices set by the client code.\n */\n private savedTabIndex_ = NaN;\n\n private active_ = false;\n private inTransit_ = false;\n private isDiscrete_ = false;\n private hasTrackMarker_ = false;\n private handlingThumbTargetEvt_ = false;\n private min_ = 0;\n private max_ = 100;\n private step_ = 0;\n private value_ = 0;\n private disabled_ = false;\n private preventFocusState_ = false;\n\n private readonly thumbContainerPointerHandler_:\n SpecificEventListener<DownEventType>;\n private readonly interactionStartHandler_:\n SpecificEventListener<DownEventType>;\n private readonly keydownHandler_: SpecificEventListener<'keydown'>;\n private readonly focusHandler_: SpecificEventListener<'focus'>;\n private readonly blurHandler_: SpecificEventListener<'blur'>;\n private readonly resizeHandler_: SpecificEventListener<'resize'>;\n\n constructor(adapter?: Partial<MDCSliderAdapter>) {\n super({...MDCSliderFoundation.defaultAdapter, ...adapter});\n\n this.thumbContainerPointerHandler_ = () => this.handlingThumbTargetEvt_ =\n true;\n this.interactionStartHandler_ = (evt: MouseLikeEvent) =>\n this.handleDown_(evt);\n this.keydownHandler_ = (evt) => this.handleKeydown_(evt);\n this.focusHandler_ = () => this.handleFocus_();\n this.blurHandler_ = () => this.handleBlur_();\n this.resizeHandler_ = () => this.layout();\n }\n\n init() {\n this.isDiscrete_ = this.adapter.hasClass(cssClasses.IS_DISCRETE);\n this.hasTrackMarker_ = this.adapter.hasClass(cssClasses.HAS_TRACK_MARKER);\n\n DOWN_EVENTS.forEach((evtName) => {\n this.adapter.registerInteractionHandler(\n evtName, this.interactionStartHandler_);\n this.adapter.registerThumbContainerInteractionHandler(\n evtName, this.thumbContainerPointerHandler_);\n });\n\n if (hasPointerEventSupport) {\n /*\n * When pointermove happens, if too much sliding happens, the browser\n * believes you are panning in the x direction and stops firing\n * pointermove events and supplies its own gestures. (similar to\n * preventing default on touchmove)\n */\n this.adapter.addClass(cssClasses.DISABLE_TOUCH_ACTION);\n }\n\n this.adapter.registerInteractionHandler('keydown', this.keydownHandler_);\n this.adapter.registerInteractionHandler('focus', this.focusHandler_);\n this.adapter.registerInteractionHandler('blur', this.blurHandler_);\n this.adapter.registerResizeHandler(this.resizeHandler_);\n\n this.layout();\n\n // At last step, provide a reasonable default value to discrete slider\n if (this.isDiscrete_ && this.getStep() === 0) {\n this.step_ = 1;\n }\n }\n\n destroy() {\n DOWN_EVENTS.forEach((evtName) => {\n this.adapter.deregisterInteractionHandler(\n evtName, this.interactionStartHandler_);\n this.adapter.deregisterThumbContainerInteractionHandler(\n evtName, this.thumbContainerPointerHandler_);\n });\n\n this.adapter.deregisterInteractionHandler('keydown', this.keydownHandler_);\n this.adapter.deregisterInteractionHandler('focus', this.focusHandler_);\n this.adapter.deregisterInteractionHandler('blur', this.blurHandler_);\n this.adapter.deregisterResizeHandler(this.resizeHandler_);\n }\n\n setupTrackMarker() {\n if (this.isDiscrete_ && this.hasTrackMarker_ && this.getStep() !== 0) {\n this.adapter.setTrackMarkers(\n this.getStep(), this.getMax(), this.getMin());\n }\n }\n\n layout() {\n this.rect_ = this.adapter.computeBoundingRect();\n this.updateUIForCurrentValue_();\n }\n\n getValue(): number {\n return this.value_;\n }\n\n setValue(value: number) {\n this.setValue_(value, false);\n }\n\n getMax(): number {\n return this.max_;\n }\n\n setMax(max: number) {\n if (max < this.min_) {\n throw new Error(\n 'Cannot set max to be less than the slider\\'s minimum value');\n }\n this.max_ = max;\n this.setValue_(this.value_, false, true);\n this.adapter.setAttribute(strings.ARIA_VALUEMAX, String(this.max_));\n this.setupTrackMarker();\n }\n\n getMin(): number {\n return this.min_;\n }\n\n setMin(min: number) {\n if (min > this.max_) {\n throw new Error(\n 'Cannot set min to be greater than the slider\\'s maximum value');\n }\n this.min_ = min;\n this.setValue_(this.value_, false, true);\n this.adapter.setAttribute(strings.ARIA_VALUEMIN, String(this.min_));\n this.setupTrackMarker();\n }\n\n getStep(): number {\n return this.step_;\n }\n\n setStep(step: number) {\n if (step < 0) {\n throw new Error('Step cannot be set to a negative number');\n }\n if (this.isDiscrete_ && (typeof (step) !== 'number' || step < 1)) {\n step = 1;\n }\n this.step_ = step;\n this.setValue_(this.value_, false, true);\n this.setupTrackMarker();\n }\n\n isDisabled(): boolean {\n return this.disabled_;\n }\n\n setDisabled(disabled: boolean) {\n this.disabled_ = disabled;\n this.toggleClass_(cssClasses.DISABLED, this.disabled_);\n if (this.disabled_) {\n this.savedTabIndex_ = this.adapter.getTabIndex();\n this.adapter.setAttribute(strings.ARIA_DISABLED, 'true');\n this.adapter.removeAttribute('tabindex');\n } else {\n this.adapter.removeAttribute(strings.ARIA_DISABLED);\n if (!isNaN(this.savedTabIndex_)) {\n this.adapter.setAttribute('tabindex', String(this.savedTabIndex_));\n }\n }\n }\n\n /**\n * Called when the user starts interacting with the slider\n */\n private handleDown_(downEvent: MouseLikeEvent) {\n if (this.disabled_) {\n return;\n }\n\n this.preventFocusState_ = true;\n this.setInTransit_(!this.handlingThumbTargetEvt_);\n this.handlingThumbTargetEvt_ = false;\n this.setActive_(true);\n\n const moveHandler = (moveEvent: MouseLikeEvent) => {\n this.handleMove_(moveEvent);\n };\n\n const moveEventType = MOVE_EVENT_MAP[downEvent.type as DownEventType];\n\n // Note: upHandler is [de]registered on ALL potential pointer-related\n // release event types, since some browsers do not always fire these\n // consistently in pairs. (See\n // https://github.com/material-components/material-components-web/issues/1192)\n const upHandler = () => {\n this.handleUp_();\n this.adapter.deregisterBodyInteractionHandler(\n moveEventType, moveHandler);\n UP_EVENTS.forEach(\n (evtName) => this.adapter.deregisterBodyInteractionHandler(\n evtName, upHandler));\n };\n\n this.adapter.registerBodyInteractionHandler(moveEventType, moveHandler);\n UP_EVENTS.forEach(\n (evtName) =>\n this.adapter.registerBodyInteractionHandler(evtName, upHandler));\n this.setValueFromEvt_(downEvent);\n }\n\n /**\n * Called when the user moves the slider\n */\n private handleMove_(evt: MouseLikeEvent) {\n evt.preventDefault();\n this.setValueFromEvt_(evt);\n }\n\n /**\n * Called when the user's interaction with the slider ends\n */\n private handleUp_() {\n this.setActive_(false);\n this.adapter.notifyChange();\n }\n\n /**\n * Returns the clientX of the event\n */\n private getClientX_(evt: MouseLikeEvent): number {\n if ((evt as TouchEvent).targetTouches &&\n (evt as TouchEvent).targetTouches.length > 0) {\n return (evt as TouchEvent).targetTouches[0].clientX;\n }\n return (evt as MouseEvent).clientX;\n }\n\n /**\n * Sets the slider value from an event\n */\n private setValueFromEvt_(evt: MouseLikeEvent) {\n const clientX = this.getClientX_(evt);\n const value = this.computeValueFromClientX_(clientX);\n this.setValue_(value, true);\n }\n\n /**\n * Computes the new value from the clientX position\n */\n private computeValueFromClientX_(clientX: number): number {\n const {max_: max, min_: min} = this;\n const xPos = clientX - this.rect_.left;\n let pctComplete = xPos / this.rect_.width;\n if (this.adapter.isRTL()) {\n pctComplete = 1 - pctComplete;\n }\n // Fit the percentage complete between the range [min,max]\n // by remapping from [0, 1] to [min, min+(max-min)].\n return min + pctComplete * (max - min);\n }\n\n /**\n * Handles keydown events\n */\n private handleKeydown_(evt: KeyboardEvent) {\n const keyId = this.getKeyId_(evt);\n const value = this.getValueForKeyId_(keyId);\n if (isNaN(value)) {\n return;\n }\n\n // Prevent page from scrolling due to key presses that would normally scroll\n // the page\n evt.preventDefault();\n this.adapter.addClass(cssClasses.FOCUS);\n this.setValue_(value, true);\n this.adapter.notifyChange();\n }\n\n /**\n * Returns the computed name of the event\n */\n private getKeyId_(kbdEvt: KeyboardEvent): string {\n if (kbdEvt.key === KEY_IDS.ARROW_LEFT || kbdEvt.keyCode === 37) {\n return KEY_IDS.ARROW_LEFT;\n }\n if (kbdEvt.key === KEY_IDS.ARROW_RIGHT || kbdEvt.keyCode === 39) {\n return KEY_IDS.ARROW_RIGHT;\n }\n if (kbdEvt.key === KEY_IDS.ARROW_UP || kbdEvt.keyCode === 38) {\n return KEY_IDS.ARROW_UP;\n }\n if (kbdEvt.key === KEY_IDS.ARROW_DOWN || kbdEvt.keyCode === 40) {\n return KEY_IDS.ARROW_DOWN;\n }\n if (kbdEvt.key === KEY_IDS.HOME || kbdEvt.keyCode === 36) {\n return KEY_IDS.HOME;\n }\n if (kbdEvt.key === KEY_IDS.END || kbdEvt.keyCode === 35) {\n return KEY_IDS.END;\n }\n if (kbdEvt.key === KEY_IDS.PAGE_UP || kbdEvt.keyCode === 33) {\n return KEY_IDS.PAGE_UP;\n }\n if (kbdEvt.key === KEY_IDS.PAGE_DOWN || kbdEvt.keyCode === 34) {\n return KEY_IDS.PAGE_DOWN;\n }\n return '';\n }\n\n /**\n * Computes the value given a keyboard key ID\n */\n private getValueForKeyId_(keyId: string): number {\n const {max_: max, min_: min, step_: step} = this;\n let delta = step || (max - min) / 100;\n const valueNeedsToBeFlipped = this.adapter.isRTL() &&\n (keyId === KEY_IDS.ARROW_LEFT || keyId === KEY_IDS.ARROW_RIGHT);\n if (valueNeedsToBeFlipped) {\n delta = -delta;\n }\n\n switch (keyId) {\n case KEY_IDS.ARROW_LEFT:\n case KEY_IDS.ARROW_DOWN:\n return this.value_ - delta;\n case KEY_IDS.ARROW_RIGHT:\n case KEY_IDS.ARROW_UP:\n return this.value_ + delta;\n case KEY_IDS.HOME:\n return this.min_;\n case KEY_IDS.END:\n return this.max_;\n case KEY_IDS.PAGE_UP:\n return this.value_ + delta * numbers.PAGE_FACTOR;\n case KEY_IDS.PAGE_DOWN:\n return this.value_ - delta * numbers.PAGE_FACTOR;\n default:\n return NaN;\n }\n }\n\n private handleFocus_() {\n if (this.preventFocusState_) {\n return;\n }\n this.adapter.addClass(cssClasses.FOCUS);\n }\n\n private handleBlur_() {\n this.preventFocusState_ = false;\n this.adapter.removeClass(cssClasses.FOCUS);\n }\n\n /**\n * Sets the value of the slider\n */\n private setValue_(value: number, shouldFireInput: boolean, force = false) {\n if (value === this.value_ && !force) {\n return;\n }\n\n const {min_: min, max_: max} = this;\n const valueSetToBoundary = value === min || value === max;\n if (this.step_ && !valueSetToBoundary) {\n value = this.quantize_(value);\n }\n if (value < min) {\n value = min;\n } else if (value > max) {\n value = max;\n }\n value = value || 0; // coerce -0 to 0\n this.value_ = value;\n this.adapter.setAttribute(strings.ARIA_VALUENOW, String(this.value_));\n this.updateUIForCurrentValue_();\n\n if (shouldFireInput) {\n this.adapter.notifyInput();\n if (this.isDiscrete_) {\n this.adapter.setMarkerValue(value);\n }\n }\n }\n\n /**\n * Calculates the quantized value\n */\n private quantize_(value: number): number {\n const numSteps = Math.round(value / this.step_);\n return numSteps * this.step_;\n }\n\n private updateUIForCurrentValue_() {\n const {max_: max, min_: min, value_: value} = this;\n const pctComplete = (value - min) / (max - min);\n let translatePx = pctComplete * this.rect_.width;\n if (this.adapter.isRTL()) {\n translatePx = this.rect_.width - translatePx;\n }\n\n const transformProp = hasWindow ? getCorrectPropertyName(window, 'transform') : 'transform';\n const transitionendEvtName =\n hasWindow ? getCorrectEventName(window, 'transitionend') as EventType : 'transitionend';\n\n if (this.inTransit_) {\n const onTransitionEnd = () => {\n this.setInTransit_(false);\n this.adapter.deregisterThumbContainerInteractionHandler(\n transitionendEvtName, onTransitionEnd);\n };\n this.adapter.registerThumbContainerInteractionHandler(\n transitionendEvtName, onTransitionEnd);\n }\n\n requestAnimationFrame(() => {\n // NOTE(traviskaufman): It would be nice to use calc() here,\n // but IE cannot handle calcs in transforms correctly.\n // See: https://goo.gl/NC2itk\n // Also note that the -50% offset is used to center the slider thumb.\n this.adapter.setThumbContainerStyleProperty(\n transformProp, `translateX(${translatePx}px) translateX(-50%)`);\n this.adapter.setTrackStyleProperty(\n transformProp, `scaleX(${pctComplete})`);\n });\n }\n\n /**\n * Toggles the active state of the slider\n */\n private setActive_(active: boolean) {\n this.active_ = active;\n this.toggleClass_(cssClasses.ACTIVE, this.active_);\n }\n\n /**\n * Toggles the inTransit state of the slider\n */\n private setInTransit_(inTransit: boolean) {\n this.inTransit_ = inTransit;\n this.toggleClass_(cssClasses.IN_TRANSIT, this.inTransit_);\n }\n\n /**\n * Conditionally adds or removes a class based on shouldBePresent\n */\n private toggleClass_(className: string, shouldBePresent: boolean) {\n if (shouldBePresent) {\n this.adapter.addClass(className);\n } else {\n this.adapter.removeClass(className);\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility\n// with MDC Web v0.44.0 and earlier.\nexport default MDCSliderFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {closest} from '@material/dom/ponyfill';\nimport {MDCSnackbarAdapter} from './adapter';\nimport {strings} from './constants';\nimport {MDCSnackbarFoundation} from './foundation';\nimport {MDCSnackbarAnnouncer, MDCSnackbarAnnouncerFactory, MDCSnackbarCloseEventDetail} from './types';\nimport * as util from './util';\n\nconst {\n SURFACE_SELECTOR, LABEL_SELECTOR, ACTION_SELECTOR, DISMISS_SELECTOR,\n OPENING_EVENT, OPENED_EVENT, CLOSING_EVENT, CLOSED_EVENT,\n} = strings;\n\nexport class MDCSnackbar extends MDCComponent<MDCSnackbarFoundation> {\n static attachTo(root: Element) {\n return new MDCSnackbar(root);\n }\n\n private announce_!: MDCSnackbarAnnouncer; // assigned in initialize()\n\n private actionEl_!: Element; // assigned in initialSyncWithDOM()\n private labelEl_!: Element; // assigned in initialSyncWithDOM()\n private surfaceEl_!: Element; // assigned in initialSyncWithDOM()\n\n private handleKeyDown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n private handleSurfaceClick_!: SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n\n initialize(announcerFactory: MDCSnackbarAnnouncerFactory = () => util.announce) {\n this.announce_ = announcerFactory();\n }\n\n initialSyncWithDOM() {\n this.surfaceEl_ = this.root.querySelector(SURFACE_SELECTOR)!;\n this.labelEl_ = this.root.querySelector(LABEL_SELECTOR)!;\n this.actionEl_ = this.root.querySelector(ACTION_SELECTOR)!;\n\n this.handleKeyDown_ = (evt) => this.foundation.handleKeyDown(evt);\n this.handleSurfaceClick_ = (evt) => {\n const target = evt.target as Element;\n if (this.isActionButton_(target)) {\n this.foundation.handleActionButtonClick(evt);\n } else if (this.isActionIcon_(target)) {\n this.foundation.handleActionIconClick(evt);\n }\n };\n\n this.registerKeyDownHandler_(this.handleKeyDown_);\n this.registerSurfaceClickHandler_(this.handleSurfaceClick_);\n }\n\n destroy() {\n super.destroy();\n this.deregisterKeyDownHandler_(this.handleKeyDown_);\n this.deregisterSurfaceClickHandler_(this.handleSurfaceClick_);\n }\n\n open() {\n this.foundation.open();\n }\n\n /**\n * @param reason Why the snackbar was closed. Value will be passed to CLOSING_EVENT and CLOSED_EVENT via the\n * `event.detail.reason` property. Standard values are REASON_ACTION and REASON_DISMISS, but custom\n * client-specific values may also be used if desired.\n */\n close(reason = '') {\n this.foundation.close(reason);\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCSnackbarAdapter = {\n addClass: (className) => this.root.classList.add(className),\n announce: () => this.announce_(this.labelEl_),\n notifyClosed: (reason) => this.emit<MDCSnackbarCloseEventDetail>(\n CLOSED_EVENT, reason ? {reason} : {}),\n notifyClosing: (reason) => this.emit<MDCSnackbarCloseEventDetail>(\n CLOSING_EVENT, reason ? {reason} : {}),\n notifyOpened: () => this.emit(OPENED_EVENT, {}),\n notifyOpening: () => this.emit(OPENING_EVENT, {}),\n removeClass: (className) => this.root.classList.remove(className),\n };\n return new MDCSnackbarFoundation(adapter);\n }\n\n get timeoutMs(): number {\n return this.foundation.getTimeoutMs();\n }\n\n set timeoutMs(timeoutMs: number) {\n this.foundation.setTimeoutMs(timeoutMs);\n }\n\n get closeOnEscape(): boolean {\n return this.foundation.getCloseOnEscape();\n }\n\n set closeOnEscape(closeOnEscape: boolean) {\n this.foundation.setCloseOnEscape(closeOnEscape);\n }\n\n get isOpen(): boolean {\n return this.foundation.isOpen();\n }\n\n get labelText(): string {\n // This property only returns null if the node is a document, DOCTYPE, or notation.\n // On Element nodes, it always returns a string.\n return this.labelEl_.textContent!;\n }\n\n set labelText(labelText: string) {\n this.labelEl_.textContent = labelText;\n }\n\n get actionButtonText(): string {\n return this.actionEl_.textContent!;\n }\n\n set actionButtonText(actionButtonText: string) {\n this.actionEl_.textContent = actionButtonText;\n }\n\n private registerKeyDownHandler_(handler: SpecificEventListener<'keydown'>) {\n this.listen('keydown', handler);\n }\n\n private deregisterKeyDownHandler_(handler: SpecificEventListener<'keydown'>) {\n this.unlisten('keydown', handler);\n }\n\n private registerSurfaceClickHandler_(handler: SpecificEventListener<'click'>) {\n this.surfaceEl_.addEventListener('click', handler as EventListener);\n }\n\n private deregisterSurfaceClickHandler_(handler: SpecificEventListener<'click'>) {\n this.surfaceEl_.removeEventListener('click', handler as EventListener);\n }\n\n private isActionButton_(target: Element): boolean {\n return Boolean(closest(target, ACTION_SELECTOR));\n }\n\n private isActionIcon_(target: Element): boolean {\n return Boolean(closest(target, DISMISS_SELECTOR));\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n CLOSING: 'mdc-snackbar--closing',\n OPEN: 'mdc-snackbar--open',\n OPENING: 'mdc-snackbar--opening',\n};\n\nconst strings = {\n ACTION_SELECTOR: '.mdc-snackbar__action',\n ARIA_LIVE_LABEL_TEXT_ATTR: 'data-mdc-snackbar-label-text',\n CLOSED_EVENT: 'MDCSnackbar:closed',\n CLOSING_EVENT: 'MDCSnackbar:closing',\n DISMISS_SELECTOR: '.mdc-snackbar__dismiss',\n LABEL_SELECTOR: '.mdc-snackbar__label',\n OPENED_EVENT: 'MDCSnackbar:opened',\n OPENING_EVENT: 'MDCSnackbar:opening',\n REASON_ACTION: 'action',\n REASON_DISMISS: 'dismiss',\n SURFACE_SELECTOR: '.mdc-snackbar__surface',\n};\n\nconst numbers = {\n DEFAULT_AUTO_DISMISS_TIMEOUT_MS: 5000,\n INDETERMINATE: -1,\n MAX_AUTO_DISMISS_TIMEOUT_MS: 10000,\n MIN_AUTO_DISMISS_TIMEOUT_MS: 4000,\n\n // These variables need to be kept in sync with the values in _variables.scss.\n SNACKBAR_ANIMATION_CLOSE_TIME_MS: 75,\n SNACKBAR_ANIMATION_OPEN_TIME_MS: 150,\n\n /**\n * Number of milliseconds to wait between temporarily clearing the label text\n * in the DOM and subsequently restoring it. This is necessary to force IE 11\n * to pick up the `aria-live` content change and announce it to the user.\n */\n ARIA_LIVE_DELAY_MS: 1000,\n};\n\nexport {cssClasses, strings, numbers};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCSnackbarAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nconst {OPENING, OPEN, CLOSING} = cssClasses;\nconst {REASON_ACTION, REASON_DISMISS} = strings;\n\nexport class MDCSnackbarFoundation extends MDCFoundation<MDCSnackbarAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get numbers() {\n return numbers;\n }\n\n static get defaultAdapter(): MDCSnackbarAdapter {\n return {\n addClass: () => undefined,\n announce: () => undefined,\n notifyClosed: () => undefined,\n notifyClosing: () => undefined,\n notifyOpened: () => undefined,\n notifyOpening: () => undefined,\n removeClass: () => undefined,\n };\n }\n\n private isOpen_ = false;\n private animationFrame_ = 0;\n private animationTimer_ = 0;\n private autoDismissTimer_ = 0;\n private autoDismissTimeoutMs_ = numbers.DEFAULT_AUTO_DISMISS_TIMEOUT_MS;\n private closeOnEscape_ = true;\n\n constructor(adapter?: Partial<MDCSnackbarAdapter>) {\n super({...MDCSnackbarFoundation.defaultAdapter, ...adapter});\n }\n\n destroy() {\n this.clearAutoDismissTimer_();\n cancelAnimationFrame(this.animationFrame_);\n this.animationFrame_ = 0;\n clearTimeout(this.animationTimer_);\n this.animationTimer_ = 0;\n this.adapter.removeClass(OPENING);\n this.adapter.removeClass(OPEN);\n this.adapter.removeClass(CLOSING);\n }\n\n open() {\n this.clearAutoDismissTimer_();\n this.isOpen_ = true;\n this.adapter.notifyOpening();\n this.adapter.removeClass(CLOSING);\n this.adapter.addClass(OPENING);\n this.adapter.announce();\n\n // Wait a frame once display is no longer \"none\", to establish basis for animation\n this.runNextAnimationFrame_(() => {\n this.adapter.addClass(OPEN);\n\n this.animationTimer_ = setTimeout(() => {\n const timeoutMs = this.getTimeoutMs();\n this.handleAnimationTimerEnd_();\n this.adapter.notifyOpened();\n if (timeoutMs !== numbers.INDETERMINATE) {\n this.autoDismissTimer_ = setTimeout(() => {\n this.close(REASON_DISMISS);\n }, timeoutMs);\n }\n }, numbers.SNACKBAR_ANIMATION_OPEN_TIME_MS);\n });\n }\n\n /**\n * @param reason Why the snackbar was closed. Value will be passed to CLOSING_EVENT and CLOSED_EVENT via the\n * `event.detail.reason` property. Standard values are REASON_ACTION and REASON_DISMISS, but custom\n * client-specific values may also be used if desired.\n */\n close(reason = '') {\n if (!this.isOpen_) {\n // Avoid redundant close calls (and events), e.g. repeated interactions as the snackbar is animating closed\n return;\n }\n\n cancelAnimationFrame(this.animationFrame_);\n this.animationFrame_ = 0;\n this.clearAutoDismissTimer_();\n\n this.isOpen_ = false;\n this.adapter.notifyClosing(reason);\n this.adapter.addClass(cssClasses.CLOSING);\n this.adapter.removeClass(cssClasses.OPEN);\n this.adapter.removeClass(cssClasses.OPENING);\n\n clearTimeout(this.animationTimer_);\n this.animationTimer_ = setTimeout(() => {\n this.handleAnimationTimerEnd_();\n this.adapter.notifyClosed(reason);\n }, numbers.SNACKBAR_ANIMATION_CLOSE_TIME_MS);\n }\n\n isOpen(): boolean {\n return this.isOpen_;\n }\n\n getTimeoutMs(): number {\n return this.autoDismissTimeoutMs_;\n }\n\n setTimeoutMs(timeoutMs: number) {\n // Use shorter variable names to make the code more readable\n const minValue = numbers.MIN_AUTO_DISMISS_TIMEOUT_MS;\n const maxValue = numbers.MAX_AUTO_DISMISS_TIMEOUT_MS;\n const indeterminateValue = numbers.INDETERMINATE;\n\n if (timeoutMs === numbers.INDETERMINATE || (timeoutMs <= maxValue && timeoutMs >= minValue)) {\n this.autoDismissTimeoutMs_ = timeoutMs;\n } else {\n throw new Error(`\n timeoutMs must be an integer in the range ${minValue}–${maxValue}\n (or ${indeterminateValue} to disable), but got '${timeoutMs}'`);\n }\n }\n\n getCloseOnEscape(): boolean {\n return this.closeOnEscape_;\n }\n\n setCloseOnEscape(closeOnEscape: boolean) {\n this.closeOnEscape_ = closeOnEscape;\n }\n\n handleKeyDown(evt: KeyboardEvent) {\n const isEscapeKey = evt.key === 'Escape' || evt.keyCode === 27;\n if (isEscapeKey && this.getCloseOnEscape()) {\n this.close(REASON_DISMISS);\n }\n }\n\n handleActionButtonClick(_evt: MouseEvent) {\n this.close(REASON_ACTION);\n }\n\n handleActionIconClick(_evt: MouseEvent) {\n this.close(REASON_DISMISS);\n }\n\n private clearAutoDismissTimer_() {\n clearTimeout(this.autoDismissTimer_);\n this.autoDismissTimer_ = 0;\n }\n\n private handleAnimationTimerEnd_() {\n this.animationTimer_ = 0;\n this.adapter.removeClass(cssClasses.OPENING);\n this.adapter.removeClass(cssClasses.CLOSING);\n }\n\n /**\n * Runs the given logic on the next animation frame, using setTimeout to factor in Firefox reflow behavior.\n */\n private runNextAnimationFrame_(callback: () => void) {\n cancelAnimationFrame(this.animationFrame_);\n this.animationFrame_ = requestAnimationFrame(() => {\n this.animationFrame_ = 0;\n clearTimeout(this.animationTimer_);\n this.animationTimer_ = setTimeout(callback, 0);\n });\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSnackbarFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nimport * as util from './util';\n\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\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 */\n\nimport {numbers, strings} from './constants';\n\nconst {ARIA_LIVE_DELAY_MS} = numbers;\nconst {ARIA_LIVE_LABEL_TEXT_ATTR} = strings;\n\nfunction announce(ariaEl: Element, labelEl: Element = ariaEl) {\n const priority = ariaEl.getAttribute('aria-live');\n\n // Trim text to ignore ` ` (see below).\n // textContent is only null if the node is a document, DOCTYPE, or notation.\n const labelText = labelEl.textContent!.trim();\n if (!labelText || !priority) {\n return;\n }\n\n // Temporarily disable `aria-live` to prevent JAWS+Firefox from announcing the message twice.\n ariaEl.setAttribute('aria-live', 'off');\n\n // Temporarily clear `textContent` to force a DOM mutation event that will be detected by screen readers.\n // `aria-live` elements are only announced when the element's `textContent` *changes*, so snackbars\n // sent to the browser in the initial HTML response won't be read unless we clear the element's `textContent` first.\n // Similarly, displaying the same snackbar message twice in a row doesn't trigger a DOM mutation event,\n // so screen readers won't announce the second message unless we first clear `textContent`.\n //\n // We have to clear the label text two different ways to make it work in all browsers and screen readers:\n //\n // 1. `textContent = ''` is required for IE11 + JAWS\n // 2. `innerHTML = ' '` is required for Chrome + JAWS and NVDA\n //\n // All other browser/screen reader combinations support both methods.\n //\n // The wrapper `<span>` visually hides the space character so that it doesn't cause jank when added/removed.\n // N.B.: Setting `position: absolute`, `opacity: 0`, or `height: 0` prevents Chrome from detecting the DOM change.\n //\n // This technique has been tested in:\n //\n // * JAWS 2019:\n // - Chrome 70\n // - Firefox 60 (ESR)\n // - IE 11\n // * NVDA 2018:\n // - Chrome 70\n // - Firefox 60 (ESR)\n // - IE 11\n // * ChromeVox 53\n labelEl.textContent = '';\n labelEl.innerHTML = '<span style=\"display: inline-block; width: 0; height: 1px;\"> </span>';\n\n // Prevent visual jank by temporarily displaying the label text in the ::before pseudo-element.\n // CSS generated content is normally announced by screen readers\n // (except in IE 11; see https://tink.uk/accessibility-support-for-css-generated-content/);\n // however, `aria-live` is turned off, so this DOM update will be ignored by screen readers.\n labelEl.setAttribute(ARIA_LIVE_LABEL_TEXT_ATTR, labelText);\n\n setTimeout(() => {\n // Allow screen readers to announce changes to the DOM again.\n ariaEl.setAttribute('aria-live', priority);\n\n // Remove the message from the ::before pseudo-element.\n labelEl.removeAttribute(ARIA_LIVE_LABEL_TEXT_ATTR);\n\n // Restore the original label text, which will be announced by screen readers.\n labelEl.textContent = labelText;\n }, ARIA_LIVE_DELAY_MS);\n}\n\nexport {announce};\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {EventType, SpecificEventListener} from '@material/base/types';\nimport {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\nimport {MDCSwitchAdapter} from './adapter';\nimport {MDCSwitchFoundation} from './foundation';\n\nexport class MDCSwitch extends MDCComponent<MDCSwitchFoundation> implements MDCRippleCapableSurface {\n static attachTo(root: HTMLElement) {\n return new MDCSwitch(root);\n }\n\n private readonly ripple_ = this.createRipple_();\n\n // Initialized in `initialSyncWithDOM`.\n private changeHandler_!: EventListener;\n\n destroy() {\n super.destroy();\n this.ripple_.destroy();\n this.nativeControl_.removeEventListener('change', this.changeHandler_);\n }\n\n initialSyncWithDOM() {\n this.changeHandler_ = (...args) => this.foundation.handleChange(...args);\n this.nativeControl_.addEventListener('change', this.changeHandler_);\n\n // Sometimes the checked state of the input element is saved in the history.\n // The switch styling should match the checked state of the input element.\n // Do an initial sync between the native control and the foundation.\n this.checked = this.checked;\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCSwitchAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n setNativeControlChecked: (checked) => this.nativeControl_.checked =\n checked,\n setNativeControlDisabled: (disabled) => this.nativeControl_.disabled =\n disabled,\n setNativeControlAttr: (attr, value) =>\n this.nativeControl_.setAttribute(attr, value),\n };\n return new MDCSwitchFoundation(adapter);\n }\n\n get ripple() {\n return this.ripple_;\n }\n\n get checked() {\n return this.nativeControl_.checked;\n }\n\n set checked(checked) {\n this.foundation.setChecked(checked);\n }\n\n get disabled() {\n return this.nativeControl_.disabled;\n }\n\n set disabled(disabled) {\n this.foundation.setDisabled(disabled);\n }\n\n private createRipple_(): MDCRipple {\n const {RIPPLE_SURFACE_SELECTOR} = MDCSwitchFoundation.strings;\n const rippleSurface =\n this.root.querySelector(RIPPLE_SURFACE_SELECTOR) as HTMLElement;\n\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCRippleAdapter = {\n ...MDCRipple.createAdapter(this),\n addClass: (className: string) => rippleSurface.classList.add(className),\n computeBoundingRect: () => rippleSurface.getBoundingClientRect(),\n deregisterInteractionHandler: <K extends EventType>(\n evtType: K, handler: SpecificEventListener<K>) => {\n this.nativeControl_.removeEventListener(evtType, handler, applyPassive());\n },\n isSurfaceActive: () => matches(this.nativeControl_, ':active'),\n isUnbounded: () => true,\n registerInteractionHandler: <K extends EventType>(\n evtType: K, handler: SpecificEventListener<K>) => {\n this.nativeControl_.addEventListener(evtType, handler, applyPassive());\n },\n removeClass: (className: string) => {\n rippleSurface.classList.remove(className);\n },\n updateCssVariable: (varName: string, value: string) => {\n rippleSurface.style.setProperty(varName, value);\n },\n };\n return new MDCRipple(this.root, new MDCRippleFoundation(adapter));\n }\n\n private get nativeControl_() {\n const {NATIVE_CONTROL_SELECTOR} = MDCSwitchFoundation.strings;\n return this.root.querySelector(NATIVE_CONTROL_SELECTOR) as HTMLInputElement;\n }\n}\n","/**\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 */\n\n/** CSS classes used by the switch. */\nconst cssClasses = {\n /** Class used for a switch that is in the \"checked\" (on) position. */\n CHECKED: 'mdc-switch--checked',\n /** Class used for a switch that is disabled. */\n DISABLED: 'mdc-switch--disabled',\n};\n\n/** String constants used by the switch. */\nconst strings = {\n /** Aria attribute for checked or unchecked state of switch */\n ARIA_CHECKED_ATTR: 'aria-checked',\n /** A CSS selector used to locate the native HTML control for the switch. */\n NATIVE_CONTROL_SELECTOR: '.mdc-switch__native-control',\n /** A CSS selector used to locate the ripple surface element for the switch. */\n RIPPLE_SURFACE_SELECTOR: '.mdc-switch__thumb-underlay',\n};\n\nexport {cssClasses, strings};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCSwitchAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCSwitchFoundation extends MDCFoundation<MDCSwitchAdapter> {\n /** The string constants used by the switch. */\n static get strings() {\n return strings;\n }\n\n /** The CSS classes used by the switch. */\n static get cssClasses() {\n return cssClasses;\n }\n\n /** The default Adapter for the switch. */\n static get defaultAdapter(): MDCSwitchAdapter {\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n setNativeControlChecked: () => undefined,\n setNativeControlDisabled: () => undefined,\n setNativeControlAttr: () => undefined,\n };\n }\n\n constructor(adapter?: Partial<MDCSwitchAdapter>) {\n super({...MDCSwitchFoundation.defaultAdapter, ...adapter});\n }\n\n /** Sets the checked state of the switch. */\n setChecked(checked: boolean) {\n this.adapter.setNativeControlChecked(checked);\n this.updateAriaChecked_(checked);\n this.updateCheckedStyling_(checked);\n }\n\n /** Sets the disabled state of the switch. */\n setDisabled(disabled: boolean) {\n this.adapter.setNativeControlDisabled(disabled);\n if (disabled) {\n this.adapter.addClass(cssClasses.DISABLED);\n } else {\n this.adapter.removeClass(cssClasses.DISABLED);\n }\n }\n\n /** Handles the change event for the switch native control. */\n handleChange(evt: Event) {\n const nativeControl = evt.target as HTMLInputElement;\n this.updateAriaChecked_(nativeControl.checked);\n this.updateCheckedStyling_(nativeControl.checked);\n }\n\n /** Updates the styling of the switch based on its checked state. */\n private updateCheckedStyling_(checked: boolean) {\n if (checked) {\n this.adapter.addClass(cssClasses.CHECKED);\n } else {\n this.adapter.removeClass(cssClasses.CHECKED);\n }\n }\n\n private updateAriaChecked_(checked: boolean) {\n this.adapter.setNativeControlAttr(\n strings.ARIA_CHECKED_ATTR, `${!!checked}`);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSwitchFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {CustomEventListener, SpecificEventListener} from '@material/base/types';\nimport {MDCTabScroller, MDCTabScrollerFactory} from '@material/tab-scroller/component';\nimport {MDCTab, MDCTabFactory} from '@material/tab/component';\nimport {MDCTabFoundation} from '@material/tab/foundation';\nimport {MDCTabInteractionEvent} from '@material/tab/types';\nimport {MDCTabBarAdapter} from './adapter';\nimport {MDCTabBarFoundation} from './foundation';\nimport {MDCTabBarActivatedEventDetail} from './types';\n\nconst {strings} = MDCTabBarFoundation;\n\nlet tabIdCounter = 0;\n\nexport class MDCTabBar extends MDCComponent<MDCTabBarFoundation> {\n static attachTo(root: Element): MDCTabBar {\n return new MDCTabBar(root);\n }\n\n private tabList_!: MDCTab[]; // assigned in initialize()\n private tabScroller_!: MDCTabScroller | null; // assigned in initialize()\n private handleTabInteraction_!: CustomEventListener<MDCTabInteractionEvent>; // assigned in initialSyncWithDOM()\n private handleKeyDown_!: SpecificEventListener<'keydown'>; // assigned in initialSyncWithDOM()\n\n set focusOnActivate(focusOnActivate: boolean) {\n this.tabList_.forEach((tab) => tab.focusOnActivate = focusOnActivate);\n }\n\n set useAutomaticActivation(useAutomaticActivation: boolean) {\n this.foundation.setUseAutomaticActivation(useAutomaticActivation);\n }\n\n initialize(\n tabFactory: MDCTabFactory = (el) => new MDCTab(el),\n tabScrollerFactory: MDCTabScrollerFactory = (el) => new MDCTabScroller(el),\n ) {\n this.tabList_ = this.instantiateTabs_(tabFactory);\n this.tabScroller_ = this.instantiateTabScroller_(tabScrollerFactory);\n }\n\n initialSyncWithDOM() {\n this.handleTabInteraction_ = (evt) =>\n this.foundation.handleTabInteraction(evt);\n this.handleKeyDown_ = (evt) => this.foundation.handleKeyDown(evt);\n\n this.listen(MDCTabFoundation.strings.INTERACTED_EVENT, this.handleTabInteraction_);\n this.listen('keydown', this.handleKeyDown_);\n\n for (let i = 0; i < this.tabList_.length; i++) {\n if (this.tabList_[i].active) {\n this.scrollIntoView(i);\n break;\n }\n }\n }\n\n destroy() {\n super.destroy();\n this.unlisten(MDCTabFoundation.strings.INTERACTED_EVENT, this.handleTabInteraction_);\n this.unlisten('keydown', this.handleKeyDown_);\n this.tabList_.forEach((tab) => tab.destroy());\n\n if (this.tabScroller_) {\n this.tabScroller_.destroy();\n }\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCTabBarAdapter = {\n scrollTo: (scrollX) => this.tabScroller_!.scrollTo(scrollX),\n incrementScroll: (scrollXIncrement) =>\n this.tabScroller_!.incrementScroll(scrollXIncrement),\n getScrollPosition: () => this.tabScroller_!.getScrollPosition(),\n getScrollContentWidth: () => this.tabScroller_!.getScrollContentWidth(),\n getOffsetWidth: () => (this.root as HTMLElement).offsetWidth,\n isRTL: () => window.getComputedStyle(this.root).getPropertyValue(\n 'direction') === 'rtl',\n setActiveTab: (index) => this.foundation.activateTab(index),\n activateTabAtIndex: (index, clientRect) =>\n this.tabList_[index].activate(clientRect),\n deactivateTabAtIndex: (index) => this.tabList_[index].deactivate(),\n focusTabAtIndex: (index) => this.tabList_[index].focus(),\n getTabIndicatorClientRectAtIndex: (index) =>\n this.tabList_[index].computeIndicatorClientRect(),\n getTabDimensionsAtIndex: (index) =>\n this.tabList_[index].computeDimensions(),\n getPreviousActiveTabIndex: () => {\n for (let i = 0; i < this.tabList_.length; i++) {\n if (this.tabList_[i].active) {\n return i;\n }\n }\n return -1;\n },\n getFocusedTabIndex: () => {\n const tabElements = this.getTabElements_();\n const activeElement = document.activeElement!;\n return tabElements.indexOf(activeElement);\n },\n getIndexOfTabById: (id) => {\n for (let i = 0; i < this.tabList_.length; i++) {\n if (this.tabList_[i].id === id) {\n return i;\n }\n }\n return -1;\n },\n getTabListLength: () => this.tabList_.length,\n notifyTabActivated: (index) => this.emit<MDCTabBarActivatedEventDetail>(\n strings.TAB_ACTIVATED_EVENT, {index}, true),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCTabBarFoundation(adapter);\n }\n\n /**\n * Activates the tab at the given index\n * @param index The index of the tab\n */\n activateTab(index: number) {\n this.foundation.activateTab(index);\n }\n\n /**\n * Scrolls the tab at the given index into view\n * @param index THe index of the tab\n */\n scrollIntoView(index: number) {\n this.foundation.scrollIntoView(index);\n }\n\n /**\n * Returns all the tab elements in a nice clean array\n */\n private getTabElements_(): Element[] {\n return [].slice.call(this.root.querySelectorAll(strings.TAB_SELECTOR));\n }\n\n /**\n * Instantiates tab components on all child tab elements\n */\n private instantiateTabs_(tabFactory: MDCTabFactory) {\n return this.getTabElements_().map((el) => {\n el.id = el.id || `mdc-tab-${++tabIdCounter}`;\n return tabFactory(el);\n });\n }\n\n /**\n * Instantiates tab scroller component on the child tab scroller element\n */\n private instantiateTabScroller_(tabScrollerFactory: MDCTabScrollerFactory): MDCTabScroller | null {\n const tabScrollerElement =\n this.root.querySelector(strings.TAB_SCROLLER_SELECTOR);\n if (tabScrollerElement) {\n return tabScrollerFactory(tabScrollerElement);\n }\n return null;\n }\n}\n","/**\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 */\n\nconst strings = {\n ARROW_LEFT_KEY: 'ArrowLeft',\n ARROW_RIGHT_KEY: 'ArrowRight',\n END_KEY: 'End',\n ENTER_KEY: 'Enter',\n HOME_KEY: 'Home',\n SPACE_KEY: 'Space',\n TAB_ACTIVATED_EVENT: 'MDCTabBar:activated',\n TAB_SCROLLER_SELECTOR: '.mdc-tab-scroller',\n TAB_SELECTOR: '.mdc-tab',\n};\n\nconst numbers = {\n ARROW_LEFT_KEYCODE: 37,\n ARROW_RIGHT_KEYCODE: 39,\n END_KEYCODE: 35,\n ENTER_KEYCODE: 13,\n EXTRA_SCROLL_AMOUNT: 20,\n HOME_KEYCODE: 36,\n SPACE_KEYCODE: 32,\n};\n\nexport {numbers, strings};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTabDimensions, MDCTabInteractionEvent} from '@material/tab/types';\nimport {MDCTabBarAdapter} from './adapter';\nimport {numbers, strings} from './constants';\n\nconst ACCEPTABLE_KEYS = new Set<string>();\n// IE11 has no support for new Set with iterable so we need to initialize this by hand\nACCEPTABLE_KEYS.add(strings.ARROW_LEFT_KEY);\nACCEPTABLE_KEYS.add(strings.ARROW_RIGHT_KEY);\nACCEPTABLE_KEYS.add(strings.END_KEY);\nACCEPTABLE_KEYS.add(strings.HOME_KEY);\nACCEPTABLE_KEYS.add(strings.ENTER_KEY);\nACCEPTABLE_KEYS.add(strings.SPACE_KEY);\n\nconst KEYCODE_MAP = new Map<number, string>();\n// IE11 has no support for new Map with iterable so we need to initialize this by hand\nKEYCODE_MAP.set(numbers.ARROW_LEFT_KEYCODE, strings.ARROW_LEFT_KEY);\nKEYCODE_MAP.set(numbers.ARROW_RIGHT_KEYCODE, strings.ARROW_RIGHT_KEY);\nKEYCODE_MAP.set(numbers.END_KEYCODE, strings.END_KEY);\nKEYCODE_MAP.set(numbers.HOME_KEYCODE, strings.HOME_KEY);\nKEYCODE_MAP.set(numbers.ENTER_KEYCODE, strings.ENTER_KEY);\nKEYCODE_MAP.set(numbers.SPACE_KEYCODE, strings.SPACE_KEY);\n\nexport class MDCTabBarFoundation extends MDCFoundation<MDCTabBarAdapter> {\n static get strings() {\n return strings;\n }\n\n static get numbers() {\n return numbers;\n }\n\n static get defaultAdapter(): MDCTabBarAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n scrollTo: () => undefined,\n incrementScroll: () => undefined,\n getScrollPosition: () => 0,\n getScrollContentWidth: () => 0,\n getOffsetWidth: () => 0,\n isRTL: () => false,\n setActiveTab: () => undefined,\n activateTabAtIndex: () => undefined,\n deactivateTabAtIndex: () => undefined,\n focusTabAtIndex: () => undefined,\n getTabIndicatorClientRectAtIndex: () => ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n getTabDimensionsAtIndex: () => ({rootLeft: 0, rootRight: 0, contentLeft: 0, contentRight: 0}),\n getPreviousActiveTabIndex: () => -1,\n getFocusedTabIndex: () => -1,\n getIndexOfTabById: () => -1,\n getTabListLength: () => 0,\n notifyTabActivated: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private useAutomaticActivation_ = false;\n\n constructor(adapter?: Partial<MDCTabBarAdapter>) {\n super({...MDCTabBarFoundation.defaultAdapter, ...adapter});\n }\n\n /**\n * Switches between automatic and manual activation modes.\n * See https://www.w3.org/TR/wai-aria-practices/#tabpanel for examples.\n */\n setUseAutomaticActivation(useAutomaticActivation: boolean) {\n this.useAutomaticActivation_ = useAutomaticActivation;\n }\n\n activateTab(index: number) {\n const previousActiveIndex = this.adapter.getPreviousActiveTabIndex();\n if (!this.indexIsInRange_(index) || index === previousActiveIndex) {\n return;\n }\n\n let previousClientRect;\n if (previousActiveIndex !== -1) {\n this.adapter.deactivateTabAtIndex(previousActiveIndex);\n previousClientRect =\n this.adapter.getTabIndicatorClientRectAtIndex(previousActiveIndex);\n }\n\n this.adapter.activateTabAtIndex(index, previousClientRect);\n this.scrollIntoView(index);\n\n this.adapter.notifyTabActivated(index);\n }\n\n handleKeyDown(evt: KeyboardEvent) {\n // Get the key from the event\n const key = this.getKeyFromEvent_(evt);\n\n // Early exit if the event key isn't one of the keyboard navigation keys\n if (key === undefined) {\n return;\n }\n\n // Prevent default behavior for movement keys, but not for activation keys, since :active is used to apply ripple\n if (!this.isActivationKey_(key)) {\n evt.preventDefault();\n }\n\n if (this.useAutomaticActivation_) {\n if (this.isActivationKey_(key)) {\n return;\n }\n\n const index = this.determineTargetFromKey_(\n this.adapter.getPreviousActiveTabIndex(), key);\n this.adapter.setActiveTab(index);\n this.scrollIntoView(index);\n } else {\n const focusedTabIndex = this.adapter.getFocusedTabIndex();\n if (this.isActivationKey_(key)) {\n this.adapter.setActiveTab(focusedTabIndex);\n } else {\n const index = this.determineTargetFromKey_(focusedTabIndex, key);\n this.adapter.focusTabAtIndex(index);\n this.scrollIntoView(index);\n }\n }\n }\n\n /**\n * Handles the MDCTab:interacted event\n */\n handleTabInteraction(evt: MDCTabInteractionEvent) {\n this.adapter.setActiveTab(this.adapter.getIndexOfTabById(evt.detail.tabId));\n }\n\n /**\n * Scrolls the tab at the given index into view\n * @param index The tab index to make visible\n */\n scrollIntoView(index: number) {\n // Early exit if the index is out of range\n if (!this.indexIsInRange_(index)) {\n return;\n }\n\n // Always scroll to 0 if scrolling to the 0th index\n if (index === 0) {\n return this.adapter.scrollTo(0);\n }\n\n // Always scroll to the max value if scrolling to the Nth index\n // MDCTabScroller.scrollTo() will never scroll past the max possible value\n if (index === this.adapter.getTabListLength() - 1) {\n return this.adapter.scrollTo(this.adapter.getScrollContentWidth());\n }\n\n if (this.isRTL_()) {\n return this.scrollIntoViewRTL_(index);\n }\n\n this.scrollIntoView_(index);\n }\n\n /**\n * Private method for determining the index of the destination tab based on what key was pressed\n * @param origin The original index from which to determine the destination\n * @param key The name of the key\n */\n private determineTargetFromKey_(origin: number, key: string): number {\n const isRTL = this.isRTL_();\n const maxIndex = this.adapter.getTabListLength() - 1;\n const shouldGoToEnd = key === strings.END_KEY;\n const shouldDecrement = key === strings.ARROW_LEFT_KEY && !isRTL || key === strings.ARROW_RIGHT_KEY && isRTL;\n const shouldIncrement = key === strings.ARROW_RIGHT_KEY && !isRTL || key === strings.ARROW_LEFT_KEY && isRTL;\n let index = origin;\n\n if (shouldGoToEnd) {\n index = maxIndex;\n } else if (shouldDecrement) {\n index -= 1;\n } else if (shouldIncrement) {\n index += 1;\n } else {\n index = 0;\n }\n\n if (index < 0) {\n index = maxIndex;\n } else if (index > maxIndex) {\n index = 0;\n }\n\n return index;\n }\n\n /**\n * Calculates the scroll increment that will make the tab at the given index visible\n * @param index The index of the tab\n * @param nextIndex The index of the next tab\n * @param scrollPosition The current scroll position\n * @param barWidth The width of the Tab Bar\n */\n private calculateScrollIncrement_(\n index: number,\n nextIndex: number,\n scrollPosition: number,\n barWidth: number,\n ): number {\n const nextTabDimensions = this.adapter.getTabDimensionsAtIndex(nextIndex);\n const relativeContentLeft = nextTabDimensions.contentLeft - scrollPosition - barWidth;\n const relativeContentRight = nextTabDimensions.contentRight - scrollPosition;\n const leftIncrement = relativeContentRight - numbers.EXTRA_SCROLL_AMOUNT;\n const rightIncrement = relativeContentLeft + numbers.EXTRA_SCROLL_AMOUNT;\n\n if (nextIndex < index) {\n return Math.min(leftIncrement, 0);\n }\n\n return Math.max(rightIncrement, 0);\n }\n\n /**\n * Calculates the scroll increment that will make the tab at the given index visible in RTL\n * @param index The index of the tab\n * @param nextIndex The index of the next tab\n * @param scrollPosition The current scroll position\n * @param barWidth The width of the Tab Bar\n * @param scrollContentWidth The width of the scroll content\n */\n private calculateScrollIncrementRTL_(\n index: number,\n nextIndex: number,\n scrollPosition: number,\n barWidth: number,\n scrollContentWidth: number,\n ): number {\n const nextTabDimensions = this.adapter.getTabDimensionsAtIndex(nextIndex);\n const relativeContentLeft = scrollContentWidth - nextTabDimensions.contentLeft - scrollPosition;\n const relativeContentRight = scrollContentWidth - nextTabDimensions.contentRight - scrollPosition - barWidth;\n const leftIncrement = relativeContentRight + numbers.EXTRA_SCROLL_AMOUNT;\n const rightIncrement = relativeContentLeft - numbers.EXTRA_SCROLL_AMOUNT;\n\n if (nextIndex > index) {\n return Math.max(leftIncrement, 0);\n }\n\n return Math.min(rightIncrement, 0);\n }\n\n /**\n * Determines the index of the adjacent tab closest to either edge of the Tab Bar\n * @param index The index of the tab\n * @param tabDimensions The dimensions of the tab\n * @param scrollPosition The current scroll position\n * @param barWidth The width of the tab bar\n */\n private findAdjacentTabIndexClosestToEdge_(\n index: number,\n tabDimensions: MDCTabDimensions,\n scrollPosition: number,\n barWidth: number,\n ): number {\n /**\n * Tabs are laid out in the Tab Scroller like this:\n *\n * Scroll Position\n * +---+\n * | | Bar Width\n * | +-----------------------------------+\n * | | |\n * | V V\n * | +-----------------------------------+\n * V | Tab Scroller |\n * +------------+--------------+-------------------+\n * | Tab | Tab | Tab |\n * +------------+--------------+-------------------+\n * | |\n * +-----------------------------------+\n *\n * To determine the next adjacent index, we look at the Tab root left and\n * Tab root right, both relative to the scroll position. If the Tab root\n * left is less than 0, then we know it's out of view to the left. If the\n * Tab root right minus the bar width is greater than 0, we know the Tab is\n * out of view to the right. From there, we either increment or decrement\n * the index.\n */\n const relativeRootLeft = tabDimensions.rootLeft - scrollPosition;\n const relativeRootRight = tabDimensions.rootRight - scrollPosition - barWidth;\n const relativeRootDelta = relativeRootLeft + relativeRootRight;\n const leftEdgeIsCloser = relativeRootLeft < 0 || relativeRootDelta < 0;\n const rightEdgeIsCloser = relativeRootRight > 0 || relativeRootDelta > 0;\n\n if (leftEdgeIsCloser) {\n return index - 1;\n }\n\n if (rightEdgeIsCloser) {\n return index + 1;\n }\n\n return -1;\n }\n\n /**\n * Determines the index of the adjacent tab closest to either edge of the Tab Bar in RTL\n * @param index The index of the tab\n * @param tabDimensions The dimensions of the tab\n * @param scrollPosition The current scroll position\n * @param barWidth The width of the tab bar\n * @param scrollContentWidth The width of the scroller content\n */\n private findAdjacentTabIndexClosestToEdgeRTL_(\n index: number,\n tabDimensions: MDCTabDimensions,\n scrollPosition: number,\n barWidth: number,\n scrollContentWidth: number,\n ): number {\n const rootLeft = scrollContentWidth - tabDimensions.rootLeft - barWidth - scrollPosition;\n const rootRight = scrollContentWidth - tabDimensions.rootRight - scrollPosition;\n const rootDelta = rootLeft + rootRight;\n const leftEdgeIsCloser = rootLeft > 0 || rootDelta > 0;\n const rightEdgeIsCloser = rootRight < 0 || rootDelta < 0;\n\n if (leftEdgeIsCloser) {\n return index + 1;\n }\n\n if (rightEdgeIsCloser) {\n return index - 1;\n }\n\n return -1;\n }\n\n /**\n * Returns the key associated with a keydown event\n * @param evt The keydown event\n */\n private getKeyFromEvent_(evt: KeyboardEvent): string {\n if (ACCEPTABLE_KEYS.has(evt.key)) {\n return evt.key;\n }\n return KEYCODE_MAP.get(evt.keyCode)!;\n }\n\n private isActivationKey_(key: string) {\n return key === strings.SPACE_KEY || key === strings.ENTER_KEY;\n }\n\n /**\n * Returns whether a given index is inclusively between the ends\n * @param index The index to test\n */\n private indexIsInRange_(index: number) {\n return index >= 0 && index < this.adapter.getTabListLength();\n }\n\n /**\n * Returns the view's RTL property\n */\n private isRTL_(): boolean {\n return this.adapter.isRTL();\n }\n\n /**\n * Scrolls the tab at the given index into view for left-to-right user agents.\n * @param index The index of the tab to scroll into view\n */\n private scrollIntoView_(index: number) {\n const scrollPosition = this.adapter.getScrollPosition();\n const barWidth = this.adapter.getOffsetWidth();\n const tabDimensions = this.adapter.getTabDimensionsAtIndex(index);\n const nextIndex = this.findAdjacentTabIndexClosestToEdge_(index, tabDimensions, scrollPosition, barWidth);\n\n if (!this.indexIsInRange_(nextIndex)) {\n return;\n }\n\n const scrollIncrement = this.calculateScrollIncrement_(index, nextIndex, scrollPosition, barWidth);\n this.adapter.incrementScroll(scrollIncrement);\n }\n\n /**\n * Scrolls the tab at the given index into view in RTL\n * @param index The tab index to make visible\n */\n private scrollIntoViewRTL_(index: number) {\n const scrollPosition = this.adapter.getScrollPosition();\n const barWidth = this.adapter.getOffsetWidth();\n const tabDimensions = this.adapter.getTabDimensionsAtIndex(index);\n const scrollWidth = this.adapter.getScrollContentWidth();\n const nextIndex = this.findAdjacentTabIndexClosestToEdgeRTL_(\n index, tabDimensions, scrollPosition, barWidth, scrollWidth);\n\n if (!this.indexIsInRange_(nextIndex)) {\n return;\n }\n\n const scrollIncrement = this.calculateScrollIncrementRTL_(index, nextIndex, scrollPosition, barWidth, scrollWidth);\n this.adapter.incrementScroll(scrollIncrement);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabBarFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\n\nimport {MDCTabIndicatorAdapter} from './adapter';\nimport {MDCFadingTabIndicatorFoundation} from './fading-foundation';\nimport {MDCTabIndicatorFoundation} from './foundation';\nimport {MDCSlidingTabIndicatorFoundation} from './sliding-foundation';\n\nexport type MDCTabIndicatorFactory = (el: Element, foundation?: MDCTabIndicatorFoundation) => MDCTabIndicator;\n\nexport class MDCTabIndicator extends MDCComponent<MDCTabIndicatorFoundation> {\n static attachTo(root: Element): MDCTabIndicator {\n return new MDCTabIndicator(root);\n }\n\n private content_!: HTMLElement; // assigned in initialize()\n\n initialize() {\n this.content_ = this.root.querySelector<HTMLElement>(\n MDCTabIndicatorFoundation.strings.CONTENT_SELECTOR)!;\n }\n\n computeContentClientRect(): ClientRect {\n return this.foundation.computeContentClientRect();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCTabIndicatorAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n computeContentClientRect: () => this.content_.getBoundingClientRect(),\n setContentStyleProperty: (prop, value) =>\n this.content_.style.setProperty(prop, value),\n };\n // tslint:enable:object-literal-sort-keys\n\n if (this.root.classList.contains(\n MDCTabIndicatorFoundation.cssClasses.FADE)) {\n return new MDCFadingTabIndicatorFoundation(adapter);\n }\n\n // Default to the sliding indicator\n return new MDCSlidingTabIndicatorFoundation(adapter);\n }\n\n activate(previousIndicatorClientRect?: ClientRect) {\n this.foundation.activate(previousIndicatorClientRect);\n }\n\n deactivate() {\n this.foundation.deactivate();\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n ACTIVE: 'mdc-tab-indicator--active',\n FADE: 'mdc-tab-indicator--fade',\n NO_TRANSITION: 'mdc-tab-indicator--no-transition',\n};\n\nconst strings = {\n CONTENT_SELECTOR: '.mdc-tab-indicator__content',\n};\n\nexport {\n cssClasses,\n strings,\n};\n","/**\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 */\n\nimport {MDCTabIndicatorFoundation} from './foundation';\n\n/* istanbul ignore next: subclass is not a branch statement */\nexport class MDCFadingTabIndicatorFoundation extends MDCTabIndicatorFoundation {\n activate() {\n this.adapter.addClass(MDCTabIndicatorFoundation.cssClasses.ACTIVE);\n }\n\n deactivate() {\n this.adapter.removeClass(MDCTabIndicatorFoundation.cssClasses.ACTIVE);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFadingTabIndicatorFoundation;\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTabIndicatorAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport abstract class MDCTabIndicatorFoundation extends MDCFoundation<MDCTabIndicatorAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get defaultAdapter(): MDCTabIndicatorAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n computeContentClientRect: () => ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n setContentStyleProperty: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n constructor(adapter?: Partial<MDCTabIndicatorAdapter>) {\n super({...MDCTabIndicatorFoundation.defaultAdapter, ...adapter});\n }\n\n computeContentClientRect(): ClientRect {\n return this.adapter.computeContentClientRect();\n }\n\n abstract activate(previousIndicatorClientRect?: ClientRect): void;\n abstract deactivate(): void;\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabIndicatorFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './fading-foundation';\nexport * from './sliding-foundation';\n","/**\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 */\n\nimport {MDCTabIndicatorFoundation} from './foundation';\n\n/* istanbul ignore next: subclass is not a branch statement */\nexport class MDCSlidingTabIndicatorFoundation extends MDCTabIndicatorFoundation {\n activate(previousIndicatorClientRect?: ClientRect) {\n // Early exit if no indicator is present to handle cases where an indicator\n // may be activated without a prior indicator state\n if (!previousIndicatorClientRect) {\n this.adapter.addClass(MDCTabIndicatorFoundation.cssClasses.ACTIVE);\n return;\n }\n\n // This animation uses the FLIP approach. You can read more about it at the link below:\n // https://aerotwist.com/blog/flip-your-animations/\n\n // Calculate the dimensions based on the dimensions of the previous indicator\n const currentClientRect = this.computeContentClientRect();\n const widthDelta = previousIndicatorClientRect.width / currentClientRect.width;\n const xPosition = previousIndicatorClientRect.left - currentClientRect.left;\n this.adapter.addClass(MDCTabIndicatorFoundation.cssClasses.NO_TRANSITION);\n this.adapter.setContentStyleProperty(\n 'transform', `translateX(${xPosition}px) scaleX(${widthDelta})`);\n\n // Force repaint before updating classes and transform to ensure the transform properly takes effect\n this.computeContentClientRect();\n\n this.adapter.removeClass(\n MDCTabIndicatorFoundation.cssClasses.NO_TRANSITION);\n this.adapter.addClass(MDCTabIndicatorFoundation.cssClasses.ACTIVE);\n this.adapter.setContentStyleProperty('transform', '');\n }\n\n deactivate() {\n this.adapter.removeClass(MDCTabIndicatorFoundation.cssClasses.ACTIVE);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCSlidingTabIndicatorFoundation;\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\nimport {MDCTabScrollerAdapter} from './adapter';\nimport {MDCTabScrollerFoundation} from './foundation';\nimport * as util from './util';\n\ntype InteractionEventType = 'wheel' | 'touchstart' | 'pointerdown' | 'mousedown' | 'keydown';\n\nexport type MDCTabScrollerFactory = (el: Element, foundation?: MDCTabScrollerFoundation) => MDCTabScroller;\n\nexport class MDCTabScroller extends MDCComponent<MDCTabScrollerFoundation> {\n static attachTo(root: Element): MDCTabScroller {\n return new MDCTabScroller(root);\n }\n\n private content_!: HTMLElement; // assigned in initialize()\n private area_!: HTMLElement; // assigned in initialize()\n private handleInteraction_!: SpecificEventListener<InteractionEventType>; // assigned in initialSyncWithDOM()\n private handleTransitionEnd_!: SpecificEventListener<'transitionend'>; // assigned in initialSyncWithDOM()\n\n initialize() {\n this.area_ = this.root.querySelector<HTMLElement>(\n MDCTabScrollerFoundation.strings.AREA_SELECTOR)!;\n this.content_ = this.root.querySelector<HTMLElement>(\n MDCTabScrollerFoundation.strings.CONTENT_SELECTOR)!;\n }\n\n initialSyncWithDOM() {\n this.handleInteraction_ = () => this.foundation.handleInteraction();\n this.handleTransitionEnd_ = (evt) => this.foundation.handleTransitionEnd(evt);\n\n this.area_.addEventListener('wheel', this.handleInteraction_, applyPassive());\n this.area_.addEventListener('touchstart', this.handleInteraction_, applyPassive());\n this.area_.addEventListener('pointerdown', this.handleInteraction_, applyPassive());\n this.area_.addEventListener('mousedown', this.handleInteraction_, applyPassive());\n this.area_.addEventListener('keydown', this.handleInteraction_, applyPassive());\n this.content_.addEventListener('transitionend', this.handleTransitionEnd_);\n }\n\n destroy() {\n super.destroy();\n\n this.area_.removeEventListener('wheel', this.handleInteraction_, applyPassive());\n this.area_.removeEventListener('touchstart', this.handleInteraction_, applyPassive());\n this.area_.removeEventListener('pointerdown', this.handleInteraction_, applyPassive());\n this.area_.removeEventListener('mousedown', this.handleInteraction_, applyPassive());\n this.area_.removeEventListener('keydown', this.handleInteraction_, applyPassive());\n this.content_.removeEventListener('transitionend', this.handleTransitionEnd_);\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCTabScrollerAdapter = {\n eventTargetMatchesSelector: (evtTarget, selector) =>\n matches(evtTarget as Element, selector),\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n addScrollAreaClass: (className) => this.area_.classList.add(className),\n setScrollAreaStyleProperty: (prop, value) =>\n this.area_.style.setProperty(prop, value),\n setScrollContentStyleProperty: (prop, value) =>\n this.content_.style.setProperty(prop, value),\n getScrollContentStyleValue: (propName) =>\n window.getComputedStyle(this.content_).getPropertyValue(propName),\n setScrollAreaScrollLeft: (scrollX) => this.area_.scrollLeft = scrollX,\n getScrollAreaScrollLeft: () => this.area_.scrollLeft,\n getScrollContentOffsetWidth: () => this.content_.offsetWidth,\n getScrollAreaOffsetWidth: () => this.area_.offsetWidth,\n computeScrollAreaClientRect: () => this.area_.getBoundingClientRect(),\n computeScrollContentClientRect: () =>\n this.content_.getBoundingClientRect(),\n computeHorizontalScrollbarHeight: () =>\n util.computeHorizontalScrollbarHeight(document),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCTabScrollerFoundation(adapter);\n }\n\n /**\n * Returns the current visual scroll position\n */\n getScrollPosition(): number {\n return this.foundation.getScrollPosition();\n }\n\n /**\n * Returns the width of the scroll content\n */\n getScrollContentWidth(): number {\n return this.content_.offsetWidth;\n }\n\n /**\n * Increments the scroll value by the given amount\n * @param scrollXIncrement The pixel value by which to increment the scroll value\n */\n incrementScroll(scrollXIncrement: number) {\n this.foundation.incrementScroll(scrollXIncrement);\n }\n\n /**\n * Scrolls to the given pixel position\n * @param scrollX The pixel value to scroll to\n */\n scrollTo(scrollX: number) {\n this.foundation.scrollTo(scrollX);\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n ANIMATING: 'mdc-tab-scroller--animating',\n SCROLL_AREA_SCROLL: 'mdc-tab-scroller__scroll-area--scroll',\n SCROLL_TEST: 'mdc-tab-scroller__test',\n};\n\nconst strings = {\n AREA_SELECTOR: '.mdc-tab-scroller__scroll-area',\n CONTENT_SELECTOR: '.mdc-tab-scroller__scroll-content',\n};\n\nexport {\n cssClasses,\n strings,\n};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTabScrollerAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCTabScrollerRTLDefault} from './rtl-default-scroller';\nimport {MDCTabScrollerRTLNegative} from './rtl-negative-scroller';\nimport {MDCTabScrollerRTLReverse} from './rtl-reverse-scroller';\nimport {MDCTabScrollerRTL} from './rtl-scroller';\nimport {MDCTabScrollerAnimation, MDCTabScrollerHorizontalEdges} from './types';\n\nexport class MDCTabScrollerFoundation extends MDCFoundation<MDCTabScrollerAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get defaultAdapter(): MDCTabScrollerAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n eventTargetMatchesSelector: () => false,\n addClass: () => undefined,\n removeClass: () => undefined,\n addScrollAreaClass: () => undefined,\n setScrollAreaStyleProperty: () => undefined,\n setScrollContentStyleProperty: () => undefined,\n getScrollContentStyleValue: () => '',\n setScrollAreaScrollLeft: () => undefined,\n getScrollAreaScrollLeft: () => 0,\n getScrollContentOffsetWidth: () => 0,\n getScrollAreaOffsetWidth: () => 0,\n computeScrollAreaClientRect: () => ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n computeScrollContentClientRect: () => ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0}),\n computeHorizontalScrollbarHeight: () => 0,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n /**\n * Controls whether we should handle the transitionend and interaction events during the animation.\n */\n private isAnimating_ = false;\n\n /**\n * The MDCTabScrollerRTL instance varies per browser and allows us to encapsulate the peculiar browser behavior\n * of RTL scrolling in it's own class.\n */\n private rtlScrollerInstance_?: MDCTabScrollerRTL;\n\n constructor(adapter?: Partial<MDCTabScrollerAdapter>) {\n super({...MDCTabScrollerFoundation.defaultAdapter, ...adapter});\n }\n\n init() {\n // Compute horizontal scrollbar height on scroller with overflow initially hidden, then update overflow to scroll\n // and immediately adjust bottom margin to avoid the scrollbar initially appearing before JS runs.\n const horizontalScrollbarHeight =\n this.adapter.computeHorizontalScrollbarHeight();\n this.adapter.setScrollAreaStyleProperty(\n 'margin-bottom', -horizontalScrollbarHeight + 'px');\n this.adapter.addScrollAreaClass(\n MDCTabScrollerFoundation.cssClasses.SCROLL_AREA_SCROLL);\n }\n\n /**\n * Computes the current visual scroll position\n */\n getScrollPosition(): number {\n if (this.isRTL_()) {\n return this.computeCurrentScrollPositionRTL_();\n }\n\n const currentTranslateX = this.calculateCurrentTranslateX_();\n const scrollLeft = this.adapter.getScrollAreaScrollLeft();\n return scrollLeft - currentTranslateX;\n }\n\n /**\n * Handles interaction events that occur during transition\n */\n handleInteraction() {\n // Early exit if we aren't animating\n if (!this.isAnimating_) {\n return;\n }\n\n // Prevent other event listeners from handling this event\n this.stopScrollAnimation_();\n }\n\n /**\n * Handles the transitionend event\n */\n handleTransitionEnd(evt: Event) {\n // Early exit if we aren't animating or the event was triggered by a different element.\n const evtTarget = evt.target as Element;\n if (!this.isAnimating_ ||\n !this.adapter.eventTargetMatchesSelector(\n evtTarget, MDCTabScrollerFoundation.strings.CONTENT_SELECTOR)) {\n return;\n }\n\n this.isAnimating_ = false;\n this.adapter.removeClass(MDCTabScrollerFoundation.cssClasses.ANIMATING);\n }\n\n /**\n * Increment the scroll value by the scrollXIncrement using animation.\n * @param scrollXIncrement The value by which to increment the scroll position\n */\n incrementScroll(scrollXIncrement: number) {\n // Early exit for non-operational increment values\n if (scrollXIncrement === 0) {\n return;\n }\n\n this.animate_(this.getIncrementScrollOperation_(scrollXIncrement));\n }\n\n /**\n * Increment the scroll value by the scrollXIncrement without animation.\n * @param scrollXIncrement The value by which to increment the scroll position\n */\n incrementScrollImmediate(scrollXIncrement: number) {\n // Early exit for non-operational increment values\n if (scrollXIncrement === 0) {\n return;\n }\n\n const operation = this.getIncrementScrollOperation_(scrollXIncrement);\n if (operation.scrollDelta === 0) {\n return;\n }\n\n this.stopScrollAnimation_();\n this.adapter.setScrollAreaScrollLeft(operation.finalScrollPosition);\n }\n\n /**\n * Scrolls to the given scrollX value\n */\n scrollTo(scrollX: number) {\n if (this.isRTL_()) {\n return this.scrollToRTL_(scrollX);\n }\n\n this.scrollTo_(scrollX);\n }\n\n /**\n * @return Browser-specific {@link MDCTabScrollerRTL} instance.\n */\n getRTLScroller(): MDCTabScrollerRTL {\n if (!this.rtlScrollerInstance_) {\n this.rtlScrollerInstance_ = this.rtlScrollerFactory_();\n }\n\n return this.rtlScrollerInstance_;\n }\n\n /**\n * @return translateX value from a CSS matrix transform function string.\n */\n private calculateCurrentTranslateX_(): number {\n const transformValue = this.adapter.getScrollContentStyleValue('transform');\n // Early exit if no transform is present\n if (transformValue === 'none') {\n return 0;\n }\n\n // The transform value comes back as a matrix transformation in the form\n // of `matrix(a, b, c, d, tx, ty)`. We only care about tx (translateX) so\n // we're going to grab all the parenthesized values, strip out tx, and\n // parse it.\n const match = /\\((.+?)\\)/.exec(transformValue);\n if (!match) {\n return 0;\n }\n\n const matrixParams = match[1];\n\n // tslint:disable-next-line:ban-ts-ignore \"Unused vars\" should be a linter warning, not a compiler error.\n // @ts-ignore These unused variables should retain their semantic names for clarity.\n const [a, b, c, d, tx, ty] = matrixParams.split(',');\n\n return parseFloat(tx); // tslint:disable-line:ban\n }\n\n /**\n * Calculates a safe scroll value that is > 0 and < the max scroll value\n * @param scrollX The distance to scroll\n */\n private clampScrollValue_(scrollX: number): number {\n const edges = this.calculateScrollEdges_();\n return Math.min(Math.max(edges.left, scrollX), edges.right);\n }\n\n private computeCurrentScrollPositionRTL_(): number {\n const translateX = this.calculateCurrentTranslateX_();\n return this.getRTLScroller().getScrollPositionRTL(translateX);\n }\n\n private calculateScrollEdges_(): MDCTabScrollerHorizontalEdges {\n const contentWidth = this.adapter.getScrollContentOffsetWidth();\n const rootWidth = this.adapter.getScrollAreaOffsetWidth();\n return {\n left: 0,\n right: contentWidth - rootWidth,\n };\n }\n\n /**\n * Internal scroll method\n * @param scrollX The new scroll position\n */\n private scrollTo_(scrollX: number) {\n const currentScrollX = this.getScrollPosition();\n const safeScrollX = this.clampScrollValue_(scrollX);\n const scrollDelta = safeScrollX - currentScrollX;\n this.animate_({\n finalScrollPosition: safeScrollX,\n scrollDelta,\n });\n }\n\n /**\n * Internal RTL scroll method\n * @param scrollX The new scroll position\n */\n private scrollToRTL_(scrollX: number) {\n const animation = this.getRTLScroller().scrollToRTL(scrollX);\n this.animate_(animation);\n }\n\n /**\n * Internal method to compute the increment scroll operation values.\n * @param scrollX The desired scroll position increment\n * @return MDCTabScrollerAnimation with the sanitized values for performing the scroll operation.\n */\n private getIncrementScrollOperation_(scrollX: number): MDCTabScrollerAnimation {\n if (this.isRTL_()) {\n return this.getRTLScroller().incrementScrollRTL(scrollX);\n }\n\n const currentScrollX = this.getScrollPosition();\n const targetScrollX = scrollX + currentScrollX;\n const safeScrollX = this.clampScrollValue_(targetScrollX);\n const scrollDelta = safeScrollX - currentScrollX;\n return {\n finalScrollPosition: safeScrollX,\n scrollDelta,\n };\n }\n\n /**\n * Animates the tab scrolling\n * @param animation The animation to apply\n */\n private animate_(animation: MDCTabScrollerAnimation) {\n // Early exit if translateX is 0, which means there's no animation to perform\n if (animation.scrollDelta === 0) {\n return;\n }\n\n this.stopScrollAnimation_();\n // This animation uses the FLIP approach.\n // Read more here: https://aerotwist.com/blog/flip-your-animations/\n this.adapter.setScrollAreaScrollLeft(animation.finalScrollPosition);\n this.adapter.setScrollContentStyleProperty(\n 'transform', `translateX(${animation.scrollDelta}px)`);\n // Force repaint\n this.adapter.computeScrollAreaClientRect();\n\n requestAnimationFrame(() => {\n this.adapter.addClass(MDCTabScrollerFoundation.cssClasses.ANIMATING);\n this.adapter.setScrollContentStyleProperty('transform', 'none');\n });\n\n this.isAnimating_ = true;\n }\n\n /**\n * Stops scroll animation\n */\n private stopScrollAnimation_() {\n this.isAnimating_ = false;\n const currentScrollPosition = this.getAnimatingScrollPosition_();\n this.adapter.removeClass(MDCTabScrollerFoundation.cssClasses.ANIMATING);\n this.adapter.setScrollContentStyleProperty('transform', 'translateX(0px)');\n this.adapter.setScrollAreaScrollLeft(currentScrollPosition);\n }\n\n /**\n * Gets the current scroll position during animation\n */\n private getAnimatingScrollPosition_(): number {\n const currentTranslateX = this.calculateCurrentTranslateX_();\n const scrollLeft = this.adapter.getScrollAreaScrollLeft();\n if (this.isRTL_()) {\n return this.getRTLScroller().getAnimatingScrollPosition(scrollLeft, currentTranslateX);\n }\n\n return scrollLeft - currentTranslateX;\n }\n\n /**\n * Determines the RTL Scroller to use\n */\n private rtlScrollerFactory_(): MDCTabScrollerRTL {\n // Browsers have three different implementations of scrollLeft in RTL mode,\n // dependent on the browser. The behavior is based off the max LTR\n // scrollLeft value and 0.\n //\n // * Default scrolling in RTL *\n // - Left-most value: 0\n // - Right-most value: Max LTR scrollLeft value\n //\n // * Negative scrolling in RTL *\n // - Left-most value: Negated max LTR scrollLeft value\n // - Right-most value: 0\n //\n // * Reverse scrolling in RTL *\n // - Left-most value: Max LTR scrollLeft value\n // - Right-most value: 0\n //\n // We use those principles below to determine which RTL scrollLeft\n // behavior is implemented in the current browser.\n const initialScrollLeft = this.adapter.getScrollAreaScrollLeft();\n this.adapter.setScrollAreaScrollLeft(initialScrollLeft - 1);\n const newScrollLeft = this.adapter.getScrollAreaScrollLeft();\n\n // If the newScrollLeft value is negative,then we know that the browser has\n // implemented negative RTL scrolling, since all other implementations have\n // only positive values.\n if (newScrollLeft < 0) {\n // Undo the scrollLeft test check\n this.adapter.setScrollAreaScrollLeft(initialScrollLeft);\n return new MDCTabScrollerRTLNegative(this.adapter);\n }\n\n const rootClientRect = this.adapter.computeScrollAreaClientRect();\n const contentClientRect = this.adapter.computeScrollContentClientRect();\n const rightEdgeDelta = Math.round(contentClientRect.right - rootClientRect.right);\n // Undo the scrollLeft test check\n this.adapter.setScrollAreaScrollLeft(initialScrollLeft);\n\n // By calculating the clientRect of the root element and the clientRect of\n // the content element, we can determine how much the scroll value changed\n // when we performed the scrollLeft subtraction above.\n if (rightEdgeDelta === newScrollLeft) {\n return new MDCTabScrollerRTLReverse(this.adapter);\n }\n\n return new MDCTabScrollerRTLDefault(this.adapter);\n }\n\n private isRTL_(): boolean {\n return this.adapter.getScrollContentStyleValue('direction') === 'rtl';\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabScrollerFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nimport * as util from './util';\n\nexport {util};\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\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 */\n\nimport {MDCTabScrollerRTL} from './rtl-scroller';\nimport {MDCTabScrollerAnimation, MDCTabScrollerHorizontalEdges} from './types';\n\nexport class MDCTabScrollerRTLDefault extends MDCTabScrollerRTL {\n getScrollPositionRTL(): number {\n const currentScrollLeft = this.adapter.getScrollAreaScrollLeft();\n const {right} = this.calculateScrollEdges_();\n // Scroll values on most browsers are ints instead of floats so we round\n return Math.round(right - currentScrollLeft);\n }\n\n scrollToRTL(scrollX: number): MDCTabScrollerAnimation {\n const edges = this.calculateScrollEdges_();\n const currentScrollLeft = this.adapter.getScrollAreaScrollLeft();\n const clampedScrollLeft = this.clampScrollValue_(edges.right - scrollX);\n return {\n finalScrollPosition: clampedScrollLeft,\n scrollDelta: clampedScrollLeft - currentScrollLeft,\n };\n }\n\n incrementScrollRTL(scrollX: number): MDCTabScrollerAnimation {\n const currentScrollLeft = this.adapter.getScrollAreaScrollLeft();\n const clampedScrollLeft = this.clampScrollValue_(currentScrollLeft - scrollX);\n return {\n finalScrollPosition: clampedScrollLeft,\n scrollDelta: clampedScrollLeft - currentScrollLeft,\n };\n }\n\n getAnimatingScrollPosition(scrollX: number): number {\n return scrollX;\n }\n\n private calculateScrollEdges_(): MDCTabScrollerHorizontalEdges {\n const contentWidth = this.adapter.getScrollContentOffsetWidth();\n const rootWidth = this.adapter.getScrollAreaOffsetWidth();\n return {\n left: 0,\n right: contentWidth - rootWidth,\n };\n }\n\n private clampScrollValue_(scrollX: number): number {\n const edges = this.calculateScrollEdges_();\n return Math.min(Math.max(edges.left, scrollX), edges.right);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabScrollerRTLDefault;\n","/**\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 */\n\nimport {MDCTabScrollerRTL} from './rtl-scroller';\nimport {MDCTabScrollerAnimation, MDCTabScrollerHorizontalEdges} from './types';\n\nexport class MDCTabScrollerRTLNegative extends MDCTabScrollerRTL {\n getScrollPositionRTL(translateX: number): number {\n const currentScrollLeft = this.adapter.getScrollAreaScrollLeft();\n return Math.round(translateX - currentScrollLeft);\n }\n\n scrollToRTL(scrollX: number): MDCTabScrollerAnimation {\n const currentScrollLeft = this.adapter.getScrollAreaScrollLeft();\n const clampedScrollLeft = this.clampScrollValue_(-scrollX);\n return {\n finalScrollPosition: clampedScrollLeft,\n scrollDelta: clampedScrollLeft - currentScrollLeft,\n };\n }\n\n incrementScrollRTL(scrollX: number): MDCTabScrollerAnimation {\n const currentScrollLeft = this.adapter.getScrollAreaScrollLeft();\n const clampedScrollLeft = this.clampScrollValue_(currentScrollLeft - scrollX);\n return {\n finalScrollPosition: clampedScrollLeft,\n scrollDelta: clampedScrollLeft - currentScrollLeft,\n };\n }\n\n getAnimatingScrollPosition(scrollX: number, translateX: number): number {\n return scrollX - translateX;\n }\n\n private calculateScrollEdges_(): MDCTabScrollerHorizontalEdges {\n const contentWidth = this.adapter.getScrollContentOffsetWidth();\n const rootWidth = this.adapter.getScrollAreaOffsetWidth();\n return {\n left: rootWidth - contentWidth,\n right: 0,\n };\n }\n\n private clampScrollValue_(scrollX: number): number {\n const edges = this.calculateScrollEdges_();\n return Math.max(Math.min(edges.right, scrollX), edges.left);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabScrollerRTLNegative;\n","/**\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 */\n\nimport {MDCTabScrollerRTL} from './rtl-scroller';\nimport {MDCTabScrollerAnimation, MDCTabScrollerHorizontalEdges} from './types';\n\nexport class MDCTabScrollerRTLReverse extends MDCTabScrollerRTL {\n getScrollPositionRTL(translateX: number): number {\n const currentScrollLeft = this.adapter.getScrollAreaScrollLeft();\n // Scroll values on most browsers are ints instead of floats so we round\n return Math.round(currentScrollLeft - translateX);\n }\n\n scrollToRTL(scrollX: number): MDCTabScrollerAnimation {\n const currentScrollLeft = this.adapter.getScrollAreaScrollLeft();\n const clampedScrollLeft = this.clampScrollValue_(scrollX);\n return {\n finalScrollPosition: clampedScrollLeft,\n scrollDelta: currentScrollLeft - clampedScrollLeft,\n };\n }\n\n incrementScrollRTL(scrollX: number): MDCTabScrollerAnimation {\n const currentScrollLeft = this.adapter.getScrollAreaScrollLeft();\n const clampedScrollLeft = this.clampScrollValue_(currentScrollLeft + scrollX);\n return {\n finalScrollPosition: clampedScrollLeft,\n scrollDelta: currentScrollLeft - clampedScrollLeft,\n };\n }\n\n getAnimatingScrollPosition(scrollX: number, translateX: number): number {\n return scrollX + translateX;\n }\n\n private calculateScrollEdges_(): MDCTabScrollerHorizontalEdges {\n const contentWidth = this.adapter.getScrollContentOffsetWidth();\n const rootWidth = this.adapter.getScrollAreaOffsetWidth();\n return {\n left: contentWidth - rootWidth,\n right: 0,\n };\n }\n\n private clampScrollValue_(scrollX: number): number {\n const edges = this.calculateScrollEdges_();\n return Math.min(Math.max(edges.right, scrollX), edges.left);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabScrollerRTLReverse;\n","/**\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 */\n\nimport {MDCTabScrollerAdapter} from './adapter';\nimport {MDCTabScrollerAnimation} from './types';\n\nexport abstract class MDCTabScrollerRTL {\n constructor(protected readonly adapter: MDCTabScrollerAdapter) {}\n\n abstract getScrollPositionRTL(translateX: number): number;\n\n abstract scrollToRTL(scrollX: number): MDCTabScrollerAnimation;\n\n abstract incrementScrollRTL(scrollX: number): MDCTabScrollerAnimation;\n\n /**\n * @param scrollX The current scrollX position\n * @param translateX The current translateX position\n */\n abstract getAnimatingScrollPosition(scrollX: number, translateX: number): number;\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabScrollerRTL;\n","/**\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 */\n\nimport {cssClasses} from './constants';\n\n/**\n * Stores result from computeHorizontalScrollbarHeight to avoid redundant processing.\n */\nlet horizontalScrollbarHeight_: number | undefined;\n\n/**\n * Computes the height of browser-rendered horizontal scrollbars using a self-created test element.\n * May return 0 (e.g. on OS X browsers under default configuration).\n */\nexport function computeHorizontalScrollbarHeight(documentObj: Document, shouldCacheResult = true): number {\n if (shouldCacheResult && typeof horizontalScrollbarHeight_ !== 'undefined') {\n return horizontalScrollbarHeight_;\n }\n\n const el = documentObj.createElement('div');\n el.classList.add(cssClasses.SCROLL_TEST);\n documentObj.body.appendChild(el);\n\n const horizontalScrollbarHeight = el.offsetHeight - el.clientHeight;\n documentObj.body.removeChild(el);\n\n if (shouldCacheResult) {\n horizontalScrollbarHeight_ = horizontalScrollbarHeight;\n }\n return horizontalScrollbarHeight;\n}\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCRipple, MDCRippleFactory} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\nimport {MDCTabIndicator, MDCTabIndicatorFactory} from '@material/tab-indicator/component';\nimport {MDCTabAdapter} from './adapter';\nimport {MDCTabFoundation} from './foundation';\nimport {MDCTabDimensions, MDCTabInteractionEventDetail} from './types';\n\nexport type MDCTabFactory = (el: Element, foundation?: MDCTabFoundation) => MDCTab;\n\nexport class MDCTab extends MDCComponent<MDCTabFoundation> implements MDCRippleCapableSurface {\n static attachTo(root: Element): MDCTab {\n return new MDCTab(root);\n }\n\n id!: string; // assigned in initialize();\n\n private ripple_!: MDCRipple; // assigned in initialize();\n private tabIndicator_!: MDCTabIndicator; // assigned in initialize();\n private content_!: HTMLElement; // assigned in initialize();\n private handleClick_!: SpecificEventListener<'click'>; // assigned in initialize();\n\n initialize(\n rippleFactory: MDCRippleFactory = (el, foundation) => new MDCRipple(el, foundation),\n tabIndicatorFactory: MDCTabIndicatorFactory = (el) => new MDCTabIndicator(el),\n ) {\n this.id = this.root.id;\n const rippleSurface = this.root.querySelector<HTMLElement>(\n MDCTabFoundation.strings.RIPPLE_SELECTOR)!;\n const rippleAdapter = {\n ...MDCRipple.createAdapter(this),\n addClass: (className: string) => rippleSurface.classList.add(className),\n removeClass: (className: string) => rippleSurface.classList.remove(className),\n updateCssVariable: (varName: string, value: string) => rippleSurface.style.setProperty(varName, value),\n };\n const rippleFoundation = new MDCRippleFoundation(rippleAdapter);\n this.ripple_ = rippleFactory(this.root, rippleFoundation);\n\n const tabIndicatorElement = this.root.querySelector(\n MDCTabFoundation.strings.TAB_INDICATOR_SELECTOR)!;\n this.tabIndicator_ = tabIndicatorFactory(tabIndicatorElement);\n this.content_ = this.root.querySelector<HTMLElement>(\n MDCTabFoundation.strings.CONTENT_SELECTOR)!;\n }\n\n initialSyncWithDOM() {\n this.handleClick_ = () => this.foundation.handleClick();\n this.listen('click', this.handleClick_);\n }\n\n destroy() {\n this.unlisten('click', this.handleClick_);\n this.ripple_.destroy();\n super.destroy();\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCTabAdapter = {\n setAttr: (attr, value) => this.root.setAttribute(attr, value),\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n hasClass: (className) => this.root.classList.contains(className),\n activateIndicator: (previousIndicatorClientRect) =>\n this.tabIndicator_.activate(previousIndicatorClientRect),\n deactivateIndicator: () => this.tabIndicator_.deactivate(),\n notifyInteracted: () => this.emit<MDCTabInteractionEventDetail>(\n MDCTabFoundation.strings.INTERACTED_EVENT, {tabId: this.id},\n true /* bubble */),\n getOffsetLeft: () => (this.root as HTMLElement).offsetLeft,\n getOffsetWidth: () => (this.root as HTMLElement).offsetWidth,\n getContentOffsetLeft: () => this.content_.offsetLeft,\n getContentOffsetWidth: () => this.content_.offsetWidth,\n focus: () => (this.root as HTMLElement).focus(),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCTabFoundation(adapter);\n }\n\n /**\n * Getter for the active state of the tab\n */\n get active(): boolean {\n return this.foundation.isActive();\n }\n\n set focusOnActivate(focusOnActivate: boolean) {\n this.foundation.setFocusOnActivate(focusOnActivate);\n }\n\n /**\n * Activates the tab\n */\n activate(computeIndicatorClientRect?: ClientRect) {\n this.foundation.activate(computeIndicatorClientRect);\n }\n\n /**\n * Deactivates the tab\n */\n deactivate() {\n this.foundation.deactivate();\n }\n\n /**\n * Returns the indicator's client rect\n */\n computeIndicatorClientRect(): ClientRect {\n return this.tabIndicator_.computeContentClientRect();\n }\n\n computeDimensions(): MDCTabDimensions {\n return this.foundation.computeDimensions();\n }\n\n /**\n * Focuses the tab\n */\n focus() {\n (this.root as HTMLElement).focus();\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n ACTIVE: 'mdc-tab--active',\n};\n\nconst strings = {\n ARIA_SELECTED: 'aria-selected',\n CONTENT_SELECTOR: '.mdc-tab__content',\n INTERACTED_EVENT: 'MDCTab:interacted',\n RIPPLE_SELECTOR: '.mdc-tab__ripple',\n TABINDEX: 'tabIndex',\n TAB_INDICATOR_SELECTOR: '.mdc-tab-indicator',\n};\n\nexport {\n cssClasses,\n strings,\n};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTabAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCTabDimensions} from './types';\n\nexport class MDCTabFoundation extends MDCFoundation<MDCTabAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get defaultAdapter(): MDCTabAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n hasClass: () => false,\n setAttr: () => undefined,\n activateIndicator: () => undefined,\n deactivateIndicator: () => undefined,\n notifyInteracted: () => undefined,\n getOffsetLeft: () => 0,\n getOffsetWidth: () => 0,\n getContentOffsetLeft: () => 0,\n getContentOffsetWidth: () => 0,\n focus: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private focusOnActivate_ = true;\n\n constructor(adapter?: Partial<MDCTabAdapter>) {\n super({...MDCTabFoundation.defaultAdapter, ...adapter});\n }\n\n handleClick() {\n // It's up to the parent component to keep track of the active Tab and\n // ensure we don't activate a Tab that's already active.\n this.adapter.notifyInteracted();\n }\n\n isActive(): boolean {\n return this.adapter.hasClass(cssClasses.ACTIVE);\n }\n\n /**\n * Sets whether the tab should focus itself when activated\n */\n setFocusOnActivate(focusOnActivate: boolean) {\n this.focusOnActivate_ = focusOnActivate;\n }\n\n /**\n * Activates the Tab\n */\n activate(previousIndicatorClientRect?: ClientRect) {\n this.adapter.addClass(cssClasses.ACTIVE);\n this.adapter.setAttr(strings.ARIA_SELECTED, 'true');\n this.adapter.setAttr(strings.TABINDEX, '0');\n this.adapter.activateIndicator(previousIndicatorClientRect);\n if (this.focusOnActivate_) {\n this.adapter.focus();\n }\n }\n\n /**\n * Deactivates the Tab\n */\n deactivate() {\n // Early exit\n if (!this.isActive()) {\n return;\n }\n\n this.adapter.removeClass(cssClasses.ACTIVE);\n this.adapter.setAttr(strings.ARIA_SELECTED, 'false');\n this.adapter.setAttr(strings.TABINDEX, '-1');\n this.adapter.deactivateIndicator();\n }\n\n /**\n * Returns the dimensions of the Tab\n */\n computeDimensions(): MDCTabDimensions {\n const rootWidth = this.adapter.getOffsetWidth();\n const rootLeft = this.adapter.getOffsetLeft();\n const contentWidth = this.adapter.getContentOffsetWidth();\n const contentLeft = this.adapter.getContentOffsetLeft();\n\n return {\n contentLeft: rootLeft + contentLeft,\n contentRight: rootLeft + contentLeft + contentWidth,\n rootLeft,\n rootRight: rootLeft + rootWidth,\n };\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTabFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\n","/**\n * @license\n * Copyright 2019 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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCTextFieldCharacterCounterAdapter} from './adapter';\nimport {MDCTextFieldCharacterCounterFoundation} from './foundation';\n\nexport type MDCTextFieldCharacterCounterFactory =\n (el: Element, foundation?: MDCTextFieldCharacterCounterFoundation) => MDCTextFieldCharacterCounter;\n\nexport class MDCTextFieldCharacterCounter extends MDCComponent<MDCTextFieldCharacterCounterFoundation> {\n static attachTo(root: Element): MDCTextFieldCharacterCounter {\n return new MDCTextFieldCharacterCounter(root);\n }\n\n // Provided for access by MDCTextField component\n get foundationForTextField(): MDCTextFieldCharacterCounterFoundation {\n return this.foundation;\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n const adapter: MDCTextFieldCharacterCounterAdapter = {\n setContent: (content) => {\n this.root.textContent = content;\n },\n };\n return new MDCTextFieldCharacterCounterFoundation(adapter);\n }\n}\n","/**\n * @license\n * Copyright 2019 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 */\n\nconst cssClasses = {\n ROOT: 'mdc-text-field-character-counter',\n};\n\nconst strings = {\n ROOT_SELECTOR: `.${cssClasses.ROOT}`,\n};\n\nexport {strings, cssClasses};\n","/**\n * @license\n * Copyright 2019 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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTextFieldCharacterCounterAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCTextFieldCharacterCounterFoundation extends MDCFoundation<MDCTextFieldCharacterCounterAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n /**\n * See {@link MDCTextFieldCharacterCounterAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCTextFieldCharacterCounterAdapter {\n return {\n setContent: () => undefined,\n };\n }\n\n constructor(adapter?: Partial<MDCTextFieldCharacterCounterAdapter>) {\n super({...MDCTextFieldCharacterCounterFoundation.defaultAdapter, ...adapter});\n }\n\n setCounterValue(currentLength: number, maxLength: number) {\n currentLength = Math.min(currentLength, maxLength);\n this.adapter.setContent(`${currentLength} / ${maxLength}`);\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTextFieldCharacterCounterFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {cssClasses as characterCountCssClasses, strings as characterCountStrings} from './constants';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {applyPassive} from '@material/dom/events';\nimport * as ponyfill from '@material/dom/ponyfill';\nimport {MDCFloatingLabel, MDCFloatingLabelFactory} from '@material/floating-label/component';\nimport {MDCLineRipple, MDCLineRippleFactory} from '@material/line-ripple/component';\nimport {MDCNotchedOutline, MDCNotchedOutlineFactory} from '@material/notched-outline/component';\nimport {MDCRippleAdapter} from '@material/ripple/adapter';\nimport {MDCRipple, MDCRippleFactory} from '@material/ripple/component';\nimport {MDCRippleFoundation} from '@material/ripple/foundation';\nimport {MDCRippleCapableSurface} from '@material/ripple/types';\n\nimport {MDCTextFieldAdapter, MDCTextFieldInputAdapter, MDCTextFieldLabelAdapter, MDCTextFieldLineRippleAdapter, MDCTextFieldOutlineAdapter, MDCTextFieldRootAdapter,} from './adapter';\nimport {MDCTextFieldCharacterCounter, MDCTextFieldCharacterCounterFactory,} from './character-counter/component';\nimport {MDCTextFieldCharacterCounterFoundation} from './character-counter/foundation';\nimport {cssClasses, strings} from './constants';\nimport {MDCTextFieldFoundation} from './foundation';\nimport {MDCTextFieldHelperText, MDCTextFieldHelperTextFactory,} from './helper-text/component';\nimport {MDCTextFieldHelperTextFoundation} from './helper-text/foundation';\nimport {MDCTextFieldIcon, MDCTextFieldIconFactory} from './icon/component';\nimport {MDCTextFieldFoundationMap} from './types';\n\nexport class MDCTextField extends MDCComponent<MDCTextFieldFoundation> implements MDCRippleCapableSurface {\n static attachTo(root: Element): MDCTextField {\n return new MDCTextField(root);\n }\n\n ripple!: MDCRipple | null; // assigned in initialize()\n\n // The only required sub-element.\n private input_!: HTMLInputElement; // assigned in initialize()\n\n // Optional sub-elements.\n private characterCounter_!: MDCTextFieldCharacterCounter | null; // assigned in initialize()\n private helperText_!: MDCTextFieldHelperText | null; // assigned in initialize()\n private label_!: MDCFloatingLabel | null; // assigned in initialize()\n private leadingIcon_!: MDCTextFieldIcon | null; // assigned in initialize()\n private lineRipple_!: MDCLineRipple | null; // assigned in initialize()\n private outline_!: MDCNotchedOutline | null; // assigned in initialize()\n private trailingIcon_!: MDCTextFieldIcon | null; // assigned in initialize()\n private prefix_!: Element|null; // assigned in initialize()\n private suffix_!: Element|null; // assigned in initialize()\n\n initialize(\n rippleFactory: MDCRippleFactory = (el, foundation) => new MDCRipple(el, foundation),\n lineRippleFactory: MDCLineRippleFactory = (el) => new MDCLineRipple(el),\n helperTextFactory: MDCTextFieldHelperTextFactory = (el) => new MDCTextFieldHelperText(el),\n characterCounterFactory: MDCTextFieldCharacterCounterFactory = (el) => new MDCTextFieldCharacterCounter(el),\n iconFactory: MDCTextFieldIconFactory = (el) => new MDCTextFieldIcon(el),\n labelFactory: MDCFloatingLabelFactory = (el) => new MDCFloatingLabel(el),\n outlineFactory: MDCNotchedOutlineFactory = (el) => new MDCNotchedOutline(el),\n ) {\n this.input_ = this.root.querySelector<HTMLInputElement>(strings.INPUT_SELECTOR)!;\n\n const labelElement = this.root.querySelector(strings.LABEL_SELECTOR);\n this.label_ = labelElement ? labelFactory(labelElement) : null;\n\n const lineRippleElement = this.root.querySelector(strings.LINE_RIPPLE_SELECTOR);\n this.lineRipple_ = lineRippleElement ? lineRippleFactory(lineRippleElement) : null;\n\n const outlineElement = this.root.querySelector(strings.OUTLINE_SELECTOR);\n this.outline_ = outlineElement ? outlineFactory(outlineElement) : null;\n\n // Helper text\n const helperTextStrings = MDCTextFieldHelperTextFoundation.strings;\n const nextElementSibling = this.root.nextElementSibling;\n const hasHelperLine = (nextElementSibling && nextElementSibling.classList.contains(cssClasses.HELPER_LINE));\n const helperTextEl =\n hasHelperLine && nextElementSibling && nextElementSibling.querySelector(helperTextStrings.ROOT_SELECTOR);\n this.helperText_ = helperTextEl ? helperTextFactory(helperTextEl) : null;\n\n // Character counter\n const characterCounterStrings = MDCTextFieldCharacterCounterFoundation.strings;\n let characterCounterEl = this.root.querySelector(characterCounterStrings.ROOT_SELECTOR);\n // If character counter is not found in root element search in sibling element.\n if (!characterCounterEl && hasHelperLine && nextElementSibling) {\n characterCounterEl = nextElementSibling.querySelector(characterCounterStrings.ROOT_SELECTOR);\n }\n this.characterCounter_ = characterCounterEl ? characterCounterFactory(characterCounterEl) : null;\n\n // Leading icon\n const leadingIconEl =\n this.root.querySelector(strings.LEADING_ICON_SELECTOR);\n this.leadingIcon_ = leadingIconEl ? iconFactory(leadingIconEl) : null;\n\n // Trailing icon\n const trailingIconEl =\n this.root.querySelector(strings.TRAILING_ICON_SELECTOR);\n this.trailingIcon_ = trailingIconEl ? iconFactory(trailingIconEl) : null;\n\n // Prefix and Suffix\n this.prefix_ = this.root.querySelector(strings.PREFIX_SELECTOR);\n this.suffix_ = this.root.querySelector(strings.SUFFIX_SELECTOR);\n\n this.ripple = this.createRipple_(rippleFactory);\n }\n\n destroy() {\n if (this.ripple) {\n this.ripple.destroy();\n }\n if (this.lineRipple_) {\n this.lineRipple_.destroy();\n }\n if (this.helperText_) {\n this.helperText_.destroy();\n }\n if (this.characterCounter_) {\n this.characterCounter_.destroy();\n }\n if (this.leadingIcon_) {\n this.leadingIcon_.destroy();\n }\n if (this.trailingIcon_) {\n this.trailingIcon_.destroy();\n }\n if (this.label_) {\n this.label_.destroy();\n }\n if (this.outline_) {\n this.outline_.destroy();\n }\n super.destroy();\n }\n\n /**\n * Initializes the Text Field's internal state based on the environment's\n * state.\n */\n initialSyncWithDOM() {\n this.disabled = this.input_.disabled;\n }\n\n get value(): string {\n return this.foundation.getValue();\n }\n\n /**\n * @param value The value to set on the input.\n */\n set value(value: string) {\n this.foundation.setValue(value);\n }\n\n get disabled(): boolean {\n return this.foundation.isDisabled();\n }\n\n /**\n * @param disabled Sets the Text Field disabled or enabled.\n */\n set disabled(disabled: boolean) {\n this.foundation.setDisabled(disabled);\n }\n\n get valid(): boolean {\n return this.foundation.isValid();\n }\n\n /**\n * @param valid Sets the Text Field valid or invalid.\n */\n set valid(valid: boolean) {\n this.foundation.setValid(valid);\n }\n\n get required(): boolean {\n return this.input_.required;\n }\n\n /**\n * @param required Sets the Text Field to required.\n */\n set required(required: boolean) {\n this.input_.required = required;\n }\n\n get pattern(): string {\n return this.input_.pattern;\n }\n\n /**\n * @param pattern Sets the input element's validation pattern.\n */\n set pattern(pattern: string) {\n this.input_.pattern = pattern;\n }\n\n get minLength(): number {\n return this.input_.minLength;\n }\n\n /**\n * @param minLength Sets the input element's minLength.\n */\n set minLength(minLength: number) {\n this.input_.minLength = minLength;\n }\n\n get maxLength(): number {\n return this.input_.maxLength;\n }\n\n /**\n * @param maxLength Sets the input element's maxLength.\n */\n set maxLength(maxLength: number) {\n // Chrome throws exception if maxLength is set to a value less than zero\n if (maxLength < 0) {\n this.input_.removeAttribute('maxLength');\n } else {\n this.input_.maxLength = maxLength;\n }\n }\n\n get min(): string {\n return this.input_.min;\n }\n\n /**\n * @param min Sets the input element's min.\n */\n set min(min: string) {\n this.input_.min = min;\n }\n\n get max(): string {\n return this.input_.max;\n }\n\n /**\n * @param max Sets the input element's max.\n */\n set max(max: string) {\n this.input_.max = max;\n }\n\n get step(): string {\n return this.input_.step;\n }\n\n /**\n * @param step Sets the input element's step.\n */\n set step(step: string) {\n this.input_.step = step;\n }\n\n /**\n * Sets the helper text element content.\n */\n set helperTextContent(content: string) {\n this.foundation.setHelperTextContent(content);\n }\n\n /**\n * Sets the aria label of the leading icon.\n */\n set leadingIconAriaLabel(label: string) {\n this.foundation.setLeadingIconAriaLabel(label);\n }\n\n /**\n * Sets the text content of the leading icon.\n */\n set leadingIconContent(content: string) {\n this.foundation.setLeadingIconContent(content);\n }\n\n /**\n * Sets the aria label of the trailing icon.\n */\n set trailingIconAriaLabel(label: string) {\n this.foundation.setTrailingIconAriaLabel(label);\n }\n\n /**\n * Sets the text content of the trailing icon.\n */\n set trailingIconContent(content: string) {\n this.foundation.setTrailingIconContent(content);\n }\n\n /**\n * Enables or disables the use of native validation. Use this for custom validation.\n * @param useNativeValidation Set this to false to ignore native input validation.\n */\n set useNativeValidation(useNativeValidation: boolean) {\n this.foundation.setUseNativeValidation(useNativeValidation);\n }\n\n /**\n * Gets the text content of the prefix, or null if it does not exist.\n */\n get prefixText(): string|null {\n return this.prefix_ ? this.prefix_.textContent : null;\n }\n\n /**\n * Sets the text content of the prefix, if it exists.\n */\n set prefixText(prefixText: string|null) {\n if (this.prefix_) {\n this.prefix_.textContent = prefixText;\n }\n }\n\n /**\n * Gets the text content of the suffix, or null if it does not exist.\n */\n get suffixText(): string|null {\n return this.suffix_ ? this.suffix_.textContent : null;\n }\n\n /**\n * Sets the text content of the suffix, if it exists.\n */\n set suffixText(suffixText: string|null) {\n if (this.suffix_) {\n this.suffix_.textContent = suffixText;\n }\n }\n\n /**\n * Focuses the input element.\n */\n focus() {\n this.input_.focus();\n }\n\n /**\n * Recomputes the outline SVG path for the outline element.\n */\n layout() {\n const openNotch = this.foundation.shouldFloat;\n this.foundation.notchOutline(openNotch);\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCTextFieldAdapter = {\n ...this.getRootAdapterMethods_(),\n ...this.getInputAdapterMethods_(),\n ...this.getLabelAdapterMethods_(),\n ...this.getLineRippleAdapterMethods_(),\n ...this.getOutlineAdapterMethods_(),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCTextFieldFoundation(adapter, this.getFoundationMap_());\n }\n\n private getRootAdapterMethods_(): MDCTextFieldRootAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n hasClass: (className) => this.root.classList.contains(className),\n registerTextFieldInteractionHandler: (evtType, handler) => this.listen(evtType, handler),\n deregisterTextFieldInteractionHandler: (evtType, handler) => this.unlisten(evtType, handler),\n registerValidationAttributeChangeHandler: (handler) => {\n const getAttributesList = (mutationsList: MutationRecord[]): string[] => {\n return mutationsList\n .map((mutation) => mutation.attributeName)\n .filter((attributeName) => attributeName) as string[];\n };\n const observer = new MutationObserver((mutationsList) => handler(getAttributesList(mutationsList)));\n const config = {attributes: true};\n observer.observe(this.input_, config);\n return observer;\n },\n deregisterValidationAttributeChangeHandler: (observer) => observer.disconnect(),\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private getInputAdapterMethods_(): MDCTextFieldInputAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n getNativeInput: () => this.input_,\n isFocused: () => document.activeElement === this.input_,\n registerInputInteractionHandler: (evtType, handler) =>\n this.input_.addEventListener(evtType, handler, applyPassive()),\n deregisterInputInteractionHandler: (evtType, handler) =>\n this.input_.removeEventListener(evtType, handler, applyPassive()),\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private getLabelAdapterMethods_(): MDCTextFieldLabelAdapter {\n return {\n floatLabel: (shouldFloat) => this.label_ && this.label_.float(shouldFloat),\n getLabelWidth: () => this.label_ ? this.label_.getWidth() : 0,\n hasLabel: () => Boolean(this.label_),\n shakeLabel: (shouldShake) => this.label_ && this.label_.shake(shouldShake),\n setLabelRequired: (isRequired) => this.label_ && this.label_.setRequired(isRequired),\n };\n }\n\n private getLineRippleAdapterMethods_(): MDCTextFieldLineRippleAdapter {\n return {\n activateLineRipple: () => {\n if (this.lineRipple_) {\n this.lineRipple_.activate();\n }\n },\n deactivateLineRipple: () => {\n if (this.lineRipple_) {\n this.lineRipple_.deactivate();\n }\n },\n setLineRippleTransformOrigin: (normalizedX) => {\n if (this.lineRipple_) {\n this.lineRipple_.setRippleCenter(normalizedX);\n }\n },\n };\n }\n\n private getOutlineAdapterMethods_(): MDCTextFieldOutlineAdapter {\n return {\n closeOutline: () => this.outline_ && this.outline_.closeNotch(),\n hasOutline: () => Boolean(this.outline_),\n notchOutline: (labelWidth) => this.outline_ && this.outline_.notch(labelWidth),\n };\n }\n\n /**\n * @return A map of all subcomponents to subfoundations.\n */\n private getFoundationMap_(): Partial<MDCTextFieldFoundationMap> {\n return {\n characterCounter: this.characterCounter_ ?\n this.characterCounter_.foundationForTextField :\n undefined,\n helperText: this.helperText_ ? this.helperText_.foundationForTextField :\n undefined,\n leadingIcon: this.leadingIcon_ ?\n this.leadingIcon_.foundationForTextField :\n undefined,\n trailingIcon: this.trailingIcon_ ?\n this.trailingIcon_.foundationForTextField :\n undefined,\n };\n }\n\n private createRipple_(rippleFactory: MDCRippleFactory): MDCRipple | null {\n const isTextArea = this.root.classList.contains(cssClasses.TEXTAREA);\n const isOutlined = this.root.classList.contains(cssClasses.OUTLINED);\n\n if (isTextArea || isOutlined) {\n return null;\n }\n\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCRippleAdapter = {\n ...MDCRipple.createAdapter(this),\n isSurfaceActive: () => ponyfill.matches(this.input_, ':active'),\n registerInteractionHandler: (evtType, handler) => this.input_.addEventListener(evtType, handler, applyPassive()),\n deregisterInteractionHandler: (evtType, handler) =>\n this.input_.removeEventListener(evtType, handler, applyPassive()),\n };\n // tslint:enable:object-literal-sort-keys\n return rippleFactory(this.root, new MDCRippleFoundation(adapter));\n }\n}\n","/**\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 */\n\nconst strings = {\n ARIA_CONTROLS: 'aria-controls',\n INPUT_SELECTOR: '.mdc-text-field__input',\n LABEL_SELECTOR: '.mdc-floating-label',\n LEADING_ICON_SELECTOR: '.mdc-text-field__icon--leading',\n LINE_RIPPLE_SELECTOR: '.mdc-line-ripple',\n OUTLINE_SELECTOR: '.mdc-notched-outline',\n PREFIX_SELECTOR: '.mdc-text-field__affix--prefix',\n SUFFIX_SELECTOR: '.mdc-text-field__affix--suffix',\n TRAILING_ICON_SELECTOR: '.mdc-text-field__icon--trailing'\n};\n\nconst cssClasses = {\n DISABLED: 'mdc-text-field--disabled',\n FOCUSED: 'mdc-text-field--focused',\n FULLWIDTH: 'mdc-text-field--fullwidth',\n HELPER_LINE: 'mdc-text-field-helper-line',\n INVALID: 'mdc-text-field--invalid',\n LABEL_FLOATING: 'mdc-text-field--label-floating',\n NO_LABEL: 'mdc-text-field--no-label',\n OUTLINED: 'mdc-text-field--outlined',\n ROOT: 'mdc-text-field',\n TEXTAREA: 'mdc-text-field--textarea',\n WITH_LEADING_ICON: 'mdc-text-field--with-leading-icon',\n WITH_TRAILING_ICON: 'mdc-text-field--with-trailing-icon',\n};\n\nconst numbers = {\n LABEL_SCALE: 0.75,\n};\n\n/**\n * Whitelist based off of https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/HTML5/Constraint_validation\n * under the \"Validation-related attributes\" section.\n */\nconst VALIDATION_ATTR_WHITELIST = [\n 'pattern', 'min', 'max', 'required', 'step', 'minlength', 'maxlength',\n];\n\n/**\n * Label should always float for these types as they show some UI even if value is empty.\n */\nconst ALWAYS_FLOAT_TYPES = [\n 'color', 'date', 'datetime-local', 'month', 'range', 'time', 'week',\n];\n\nexport {cssClasses, strings, numbers, VALIDATION_ATTR_WHITELIST, ALWAYS_FLOAT_TYPES};\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCTextFieldAdapter} from './adapter';\nimport {MDCTextFieldCharacterCounterFoundation} from './character-counter/foundation';\nimport {ALWAYS_FLOAT_TYPES, cssClasses, numbers, strings, VALIDATION_ATTR_WHITELIST} from './constants';\nimport {MDCTextFieldHelperTextFoundation} from './helper-text/foundation';\nimport {MDCTextFieldIconFoundation} from './icon/foundation';\nimport {MDCTextFieldFoundationMap, MDCTextFieldNativeInputElement} from './types';\n\ntype PointerDownEventType = 'mousedown' | 'touchstart';\ntype InteractionEventType = 'click' | 'keydown';\n\nconst POINTERDOWN_EVENTS: PointerDownEventType[] = ['mousedown', 'touchstart'];\nconst INTERACTION_EVENTS: InteractionEventType[] = ['click', 'keydown'];\n\nexport class MDCTextFieldFoundation extends MDCFoundation<MDCTextFieldAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n static get numbers() {\n return numbers;\n }\n\n private get shouldAlwaysFloat_(): boolean {\n const type = this.getNativeInput_().type;\n return ALWAYS_FLOAT_TYPES.indexOf(type) >= 0;\n }\n\n get shouldFloat(): boolean {\n return this.shouldAlwaysFloat_ || this.isFocused_ || !!this.getValue() || this.isBadInput_();\n }\n\n get shouldShake(): boolean {\n return !this.isFocused_ && !this.isValid() && !!this.getValue();\n }\n\n /**\n * See {@link MDCTextFieldAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCTextFieldAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n hasClass: () => true,\n registerTextFieldInteractionHandler: () => undefined,\n deregisterTextFieldInteractionHandler: () => undefined,\n registerInputInteractionHandler: () => undefined,\n deregisterInputInteractionHandler: () => undefined,\n registerValidationAttributeChangeHandler: () => new MutationObserver(() => undefined),\n deregisterValidationAttributeChangeHandler: () => undefined,\n getNativeInput: () => null,\n isFocused: () => false,\n activateLineRipple: () => undefined,\n deactivateLineRipple: () => undefined,\n setLineRippleTransformOrigin: () => undefined,\n shakeLabel: () => undefined,\n floatLabel: () => undefined,\n setLabelRequired: () => undefined,\n hasLabel: () => false,\n getLabelWidth: () => 0,\n hasOutline: () => false,\n notchOutline: () => undefined,\n closeOutline: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private isFocused_ = false;\n private receivedUserInput_ = false;\n private isValid_ = true;\n private useNativeValidation_ = true;\n\n private readonly inputFocusHandler_: () => void;\n private readonly inputBlurHandler_: SpecificEventListener<'blur'>;\n private readonly inputInputHandler_: SpecificEventListener<'input'>;\n private readonly setPointerXOffset_: SpecificEventListener<PointerDownEventType>;\n private readonly textFieldInteractionHandler_: SpecificEventListener<InteractionEventType>;\n private readonly validationAttributeChangeHandler_: (attributesList: string[]) => void;\n private validationObserver_!: MutationObserver; // assigned in init()\n\n private readonly helperText_?: MDCTextFieldHelperTextFoundation;\n private readonly characterCounter_?: MDCTextFieldCharacterCounterFoundation;\n private readonly leadingIcon_?: MDCTextFieldIconFoundation;\n private readonly trailingIcon_?: MDCTextFieldIconFoundation;\n\n /**\n * @param adapter\n * @param foundationMap Map from subcomponent names to their subfoundations.\n */\n constructor(adapter?: Partial<MDCTextFieldAdapter>, foundationMap: Partial<MDCTextFieldFoundationMap> = {}) {\n super({...MDCTextFieldFoundation.defaultAdapter, ...adapter});\n\n this.helperText_ = foundationMap.helperText;\n this.characterCounter_ = foundationMap.characterCounter;\n this.leadingIcon_ = foundationMap.leadingIcon;\n this.trailingIcon_ = foundationMap.trailingIcon;\n\n this.inputFocusHandler_ = () => this.activateFocus();\n this.inputBlurHandler_ = () => this.deactivateFocus();\n this.inputInputHandler_ = () => this.handleInput();\n this.setPointerXOffset_ = (evt) => this.setTransformOrigin(evt);\n this.textFieldInteractionHandler_ = () => this.handleTextFieldInteraction();\n this.validationAttributeChangeHandler_ = (attributesList) => this.handleValidationAttributeChange(attributesList);\n }\n\n init() {\n if (this.adapter.hasLabel() && this.getNativeInput_().required) {\n this.adapter.setLabelRequired(true);\n }\n\n if (this.adapter.isFocused()) {\n this.inputFocusHandler_();\n } else if (this.adapter.hasLabel() && this.shouldFloat) {\n this.notchOutline(true);\n this.adapter.floatLabel(true);\n this.styleFloating_(true);\n }\n\n this.adapter.registerInputInteractionHandler('focus', this.inputFocusHandler_);\n this.adapter.registerInputInteractionHandler('blur', this.inputBlurHandler_);\n this.adapter.registerInputInteractionHandler('input', this.inputInputHandler_);\n POINTERDOWN_EVENTS.forEach((evtType) => {\n this.adapter.registerInputInteractionHandler(evtType, this.setPointerXOffset_);\n });\n INTERACTION_EVENTS.forEach((evtType) => {\n this.adapter.registerTextFieldInteractionHandler(evtType, this.textFieldInteractionHandler_);\n });\n this.validationObserver_ =\n this.adapter.registerValidationAttributeChangeHandler(this.validationAttributeChangeHandler_);\n this.setCharacterCounter_(this.getValue().length);\n }\n\n destroy() {\n this.adapter.deregisterInputInteractionHandler('focus', this.inputFocusHandler_);\n this.adapter.deregisterInputInteractionHandler('blur', this.inputBlurHandler_);\n this.adapter.deregisterInputInteractionHandler('input', this.inputInputHandler_);\n POINTERDOWN_EVENTS.forEach((evtType) => {\n this.adapter.deregisterInputInteractionHandler(evtType, this.setPointerXOffset_);\n });\n INTERACTION_EVENTS.forEach((evtType) => {\n this.adapter.deregisterTextFieldInteractionHandler(evtType, this.textFieldInteractionHandler_);\n });\n this.adapter.deregisterValidationAttributeChangeHandler(this.validationObserver_);\n }\n\n /**\n * Handles user interactions with the Text Field.\n */\n handleTextFieldInteraction() {\n const nativeInput = this.adapter.getNativeInput();\n if (nativeInput && nativeInput.disabled) {\n return;\n }\n this.receivedUserInput_ = true;\n }\n\n /**\n * Handles validation attribute changes\n */\n handleValidationAttributeChange(attributesList: string[]): void {\n attributesList.some((attributeName) => {\n if (VALIDATION_ATTR_WHITELIST.indexOf(attributeName) > -1) {\n this.styleValidity_(true);\n this.adapter.setLabelRequired(this.getNativeInput_().required);\n return true;\n }\n return false;\n });\n\n if (attributesList.indexOf('maxlength') > -1) {\n this.setCharacterCounter_(this.getValue().length);\n }\n }\n\n /**\n * Opens/closes the notched outline.\n */\n notchOutline(openNotch: boolean) {\n if (!this.adapter.hasOutline()) {\n return;\n }\n\n if (openNotch) {\n const labelWidth = this.adapter.getLabelWidth() * numbers.LABEL_SCALE;\n this.adapter.notchOutline(labelWidth);\n } else {\n this.adapter.closeOutline();\n }\n }\n\n /**\n * Activates the text field focus state.\n */\n activateFocus() {\n this.isFocused_ = true;\n this.styleFocused_(this.isFocused_);\n this.adapter.activateLineRipple();\n if (this.adapter.hasLabel()) {\n this.notchOutline(this.shouldFloat);\n this.adapter.floatLabel(this.shouldFloat);\n this.styleFloating_(this.shouldFloat);\n this.adapter.shakeLabel(this.shouldShake);\n }\n if (this.helperText_) {\n this.helperText_.showToScreenReader();\n }\n }\n\n /**\n * Sets the line ripple's transform origin, so that the line ripple activate\n * animation will animate out from the user's click location.\n */\n setTransformOrigin(evt: TouchEvent | MouseEvent): void {\n if (this.isDisabled() || this.adapter.hasOutline()) {\n return;\n }\n\n const touches = (evt as TouchEvent).touches;\n const targetEvent = touches ? touches[0] : evt;\n const targetClientRect = (targetEvent.target as Element).getBoundingClientRect();\n const normalizedX = (targetEvent as MouseEvent).clientX - targetClientRect.left;\n this.adapter.setLineRippleTransformOrigin(normalizedX);\n }\n\n /**\n * Handles input change of text input and text area.\n */\n handleInput() {\n this.autoCompleteFocus();\n this.setCharacterCounter_(this.getValue().length);\n }\n\n /**\n * Activates the Text Field's focus state in cases when the input value\n * changes without user input (e.g. programmatically).\n */\n autoCompleteFocus() {\n if (!this.receivedUserInput_) {\n this.activateFocus();\n }\n }\n\n /**\n * Deactivates the Text Field's focus state.\n */\n deactivateFocus() {\n this.isFocused_ = false;\n this.adapter.deactivateLineRipple();\n const isValid = this.isValid();\n this.styleValidity_(isValid);\n this.styleFocused_(this.isFocused_);\n if (this.adapter.hasLabel()) {\n this.notchOutline(this.shouldFloat);\n this.adapter.floatLabel(this.shouldFloat);\n this.styleFloating_(this.shouldFloat);\n this.adapter.shakeLabel(this.shouldShake);\n }\n if (!this.shouldFloat) {\n this.receivedUserInput_ = false;\n }\n }\n\n getValue(): string {\n return this.getNativeInput_().value;\n }\n\n /**\n * @param value The value to set on the input Element.\n */\n setValue(value: string): void {\n // Prevent Safari from moving the caret to the end of the input when the value has not changed.\n if (this.getValue() !== value) {\n this.getNativeInput_().value = value;\n }\n this.setCharacterCounter_(value.length);\n const isValid = this.isValid();\n this.styleValidity_(isValid);\n if (this.adapter.hasLabel()) {\n this.notchOutline(this.shouldFloat);\n this.adapter.floatLabel(this.shouldFloat);\n this.styleFloating_(this.shouldFloat);\n this.adapter.shakeLabel(this.shouldShake);\n }\n }\n\n /**\n * @return The custom validity state, if set; otherwise, the result of a native validity check.\n */\n isValid(): boolean {\n return this.useNativeValidation_\n ? this.isNativeInputValid_() : this.isValid_;\n }\n\n /**\n * @param isValid Sets the custom validity state of the Text Field.\n */\n setValid(isValid: boolean): void {\n this.isValid_ = isValid;\n this.styleValidity_(isValid);\n\n const shouldShake = !isValid && !this.isFocused_ && !!this.getValue();\n if (this.adapter.hasLabel()) {\n this.adapter.shakeLabel(shouldShake);\n }\n }\n\n /**\n * Enables or disables the use of native validation. Use this for custom validation.\n * @param useNativeValidation Set this to false to ignore native input validation.\n */\n setUseNativeValidation(useNativeValidation: boolean): void {\n this.useNativeValidation_ = useNativeValidation;\n }\n\n isDisabled(): boolean {\n return this.getNativeInput_().disabled;\n }\n\n /**\n * @param disabled Sets the text-field disabled or enabled.\n */\n setDisabled(disabled: boolean): void {\n this.getNativeInput_().disabled = disabled;\n this.styleDisabled_(disabled);\n }\n\n /**\n * @param content Sets the content of the helper text.\n */\n setHelperTextContent(content: string): void {\n if (this.helperText_) {\n this.helperText_.setContent(content);\n }\n }\n\n /**\n * Sets the aria label of the leading icon.\n */\n setLeadingIconAriaLabel(label: string): void {\n if (this.leadingIcon_) {\n this.leadingIcon_.setAriaLabel(label);\n }\n }\n\n /**\n * Sets the text content of the leading icon.\n */\n setLeadingIconContent(content: string): void {\n if (this.leadingIcon_) {\n this.leadingIcon_.setContent(content);\n }\n }\n\n /**\n * Sets the aria label of the trailing icon.\n */\n setTrailingIconAriaLabel(label: string): void {\n if (this.trailingIcon_) {\n this.trailingIcon_.setAriaLabel(label);\n }\n }\n\n /**\n * Sets the text content of the trailing icon.\n */\n setTrailingIconContent(content: string): void {\n if (this.trailingIcon_) {\n this.trailingIcon_.setContent(content);\n }\n }\n\n /**\n * Sets character counter values that shows characters used and the total character limit.\n */\n private setCharacterCounter_(currentLength: number): void {\n if (!this.characterCounter_) {\n return;\n }\n\n const maxLength = this.getNativeInput_().maxLength;\n if (maxLength === -1) {\n throw new Error('MDCTextFieldFoundation: Expected maxlength html property on text input or textarea.');\n }\n\n this.characterCounter_.setCounterValue(currentLength, maxLength);\n }\n\n /**\n * @return True if the Text Field input fails in converting the user-supplied value.\n */\n private isBadInput_(): boolean {\n // The badInput property is not supported in IE 11 💩.\n return this.getNativeInput_().validity.badInput || false;\n }\n\n /**\n * @return The result of native validity checking (ValidityState.valid).\n */\n private isNativeInputValid_(): boolean {\n return this.getNativeInput_().validity.valid;\n }\n\n /**\n * Styles the component based on the validity state.\n */\n private styleValidity_(isValid: boolean): void {\n const {INVALID} = MDCTextFieldFoundation.cssClasses;\n if (isValid) {\n this.adapter.removeClass(INVALID);\n } else {\n this.adapter.addClass(INVALID);\n }\n if (this.helperText_) {\n this.helperText_.setValidity(isValid);\n }\n }\n\n /**\n * Styles the component based on the focused state.\n */\n private styleFocused_(isFocused: boolean): void {\n const {FOCUSED} = MDCTextFieldFoundation.cssClasses;\n if (isFocused) {\n this.adapter.addClass(FOCUSED);\n } else {\n this.adapter.removeClass(FOCUSED);\n }\n }\n\n /**\n * Styles the component based on the disabled state.\n */\n private styleDisabled_(isDisabled: boolean): void {\n const {DISABLED, INVALID} = MDCTextFieldFoundation.cssClasses;\n if (isDisabled) {\n this.adapter.addClass(DISABLED);\n this.adapter.removeClass(INVALID);\n } else {\n this.adapter.removeClass(DISABLED);\n }\n\n if (this.leadingIcon_) {\n this.leadingIcon_.setDisabled(isDisabled);\n }\n\n if (this.trailingIcon_) {\n this.trailingIcon_.setDisabled(isDisabled);\n }\n }\n\n /**\n * Styles the component based on the label floating state.\n */\n private styleFloating_(isFloating: boolean): void {\n const {LABEL_FLOATING} = MDCTextFieldFoundation.cssClasses;\n if (isFloating) {\n this.adapter.addClass(LABEL_FLOATING);\n } else {\n this.adapter.removeClass(LABEL_FLOATING);\n }\n }\n\n /**\n * @return The native text input element from the host environment, or an object with the same shape for unit tests.\n */\n private getNativeInput_(): MDCTextFieldNativeInputElement {\n // this.adapter may be undefined in foundation unit tests. This happens when testdouble is creating a mock object\n // and invokes the shouldShake/shouldFloat getters (which in turn call getValue(), which calls this method) before\n // init() has been called from the MDCTextField constructor. To work around that issue, we return a dummy object.\n const nativeInput = this.adapter ? this.adapter.getNativeInput() : null;\n return nativeInput || {\n disabled: false,\n maxLength: -1,\n required: false,\n type: 'input',\n validity: {\n badInput: false,\n valid: true,\n },\n value: '',\n };\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTextFieldFoundation;\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCTextFieldHelperTextAdapter} from './adapter';\nimport {MDCTextFieldHelperTextFoundation} from './foundation';\n\nexport type MDCTextFieldHelperTextFactory =\n (el: Element, foundation?: MDCTextFieldHelperTextFoundation) => MDCTextFieldHelperText;\n\nexport class MDCTextFieldHelperText extends MDCComponent<MDCTextFieldHelperTextFoundation> {\n static attachTo(root: Element): MDCTextFieldHelperText {\n return new MDCTextFieldHelperText(root);\n }\n\n // Provided for access by MDCTextField component\n get foundationForTextField(): MDCTextFieldHelperTextFoundation {\n return this.foundation;\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCTextFieldHelperTextAdapter = {\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n hasClass: (className) => this.root.classList.contains(className),\n setAttr: (attr, value) => this.root.setAttribute(attr, value),\n removeAttr: (attr) => this.root.removeAttribute(attr),\n setContent: (content) => {\n this.root.textContent = content;\n },\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCTextFieldHelperTextFoundation(adapter);\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n HELPER_TEXT_PERSISTENT: 'mdc-text-field-helper-text--persistent',\n HELPER_TEXT_VALIDATION_MSG: 'mdc-text-field-helper-text--validation-msg',\n ROOT: 'mdc-text-field-helper-text',\n};\n\nconst strings = {\n ARIA_HIDDEN: 'aria-hidden',\n ROLE: 'role',\n ROOT_SELECTOR: `.${cssClasses.ROOT}`,\n};\n\nexport {strings, cssClasses};\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTextFieldHelperTextAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\nexport class MDCTextFieldHelperTextFoundation extends MDCFoundation<MDCTextFieldHelperTextAdapter> {\n static get cssClasses() {\n return cssClasses;\n }\n\n static get strings() {\n return strings;\n }\n\n /**\n * See {@link MDCTextFieldHelperTextAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCTextFieldHelperTextAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n hasClass: () => false,\n setAttr: () => undefined,\n removeAttr: () => undefined,\n setContent: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n constructor(adapter?: Partial<MDCTextFieldHelperTextAdapter>) {\n super({...MDCTextFieldHelperTextFoundation.defaultAdapter, ...adapter});\n }\n\n /**\n * Sets the content of the helper text field.\n */\n setContent(content: string) {\n this.adapter.setContent(content);\n }\n\n /**\n * @param isPersistent Sets the persistency of the helper text.\n */\n setPersistent(isPersistent: boolean) {\n if (isPersistent) {\n this.adapter.addClass(cssClasses.HELPER_TEXT_PERSISTENT);\n } else {\n this.adapter.removeClass(cssClasses.HELPER_TEXT_PERSISTENT);\n }\n }\n\n /**\n * @param isValidation True to make the helper text act as an error validation message.\n */\n setValidation(isValidation: boolean) {\n if (isValidation) {\n this.adapter.addClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n } else {\n this.adapter.removeClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n }\n }\n\n /**\n * Makes the helper text visible to the screen reader.\n */\n showToScreenReader() {\n this.adapter.removeAttr(strings.ARIA_HIDDEN);\n }\n\n /**\n * Sets the validity of the helper text based on the input validity.\n */\n setValidity(inputIsValid: boolean) {\n const helperTextIsPersistent = this.adapter.hasClass(cssClasses.HELPER_TEXT_PERSISTENT);\n const helperTextIsValidationMsg = this.adapter.hasClass(cssClasses.HELPER_TEXT_VALIDATION_MSG);\n const validationMsgNeedsDisplay = helperTextIsValidationMsg && !inputIsValid;\n\n if (validationMsgNeedsDisplay) {\n this.adapter.setAttr(strings.ROLE, 'alert');\n } else {\n this.adapter.removeAttr(strings.ROLE);\n }\n\n if (!helperTextIsPersistent && !validationMsgNeedsDisplay) {\n this.hide_();\n }\n }\n\n /**\n * Hides the help text from screen readers.\n */\n private hide_() {\n this.adapter.setAttr(strings.ARIA_HIDDEN, 'true');\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTextFieldHelperTextFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {cssClasses as helperTextCssClasses, strings as helperTextStrings} from './constants';\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {MDCTextFieldIconAdapter} from './adapter';\nimport {MDCTextFieldIconFoundation} from './foundation';\n\nexport type MDCTextFieldIconFactory = (el: Element, foundation?: MDCTextFieldIconFoundation) => MDCTextFieldIcon;\n\nexport class MDCTextFieldIcon extends MDCComponent<MDCTextFieldIconFoundation> {\n static attachTo(root: Element): MDCTextFieldIcon {\n return new MDCTextFieldIcon(root);\n }\n\n // Provided for access by MDCTextField component\n get foundationForTextField(): MDCTextFieldIconFoundation {\n return this.foundation;\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCTextFieldIconAdapter = {\n getAttr: (attr) => this.root.getAttribute(attr),\n setAttr: (attr, value) => this.root.setAttribute(attr, value),\n removeAttr: (attr) => this.root.removeAttribute(attr),\n setContent: (content) => {\n this.root.textContent = content;\n },\n registerInteractionHandler: (evtType, handler) => this.listen(evtType, handler),\n deregisterInteractionHandler: (evtType, handler) => this.unlisten(evtType, handler),\n notifyIconAction: () => this.emit(\n MDCTextFieldIconFoundation.strings.ICON_EVENT, {} /* evtData */, true /* shouldBubble */),\n };\n // tslint:enable:object-literal-sort-keys\n return new MDCTextFieldIconFoundation(adapter);\n }\n}\n","/**\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 */\n\nconst strings = {\n ICON_EVENT: 'MDCTextField:icon',\n ICON_ROLE: 'button',\n};\n\nconst cssClasses = {\n ROOT: 'mdc-text-field__icon',\n};\n\nexport {strings, cssClasses};\n","/**\n * @license\n * Copyright 2017 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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCTextFieldIconAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\ntype InteractionEventType = 'click' | 'keydown';\n\nconst INTERACTION_EVENTS: InteractionEventType[] = ['click', 'keydown'];\n\nexport class MDCTextFieldIconFoundation extends MDCFoundation<MDCTextFieldIconAdapter> {\n static get strings() {\n return strings;\n }\n\n static get cssClasses() {\n return cssClasses;\n }\n\n /**\n * See {@link MDCTextFieldIconAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCTextFieldIconAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n getAttr: () => null,\n setAttr: () => undefined,\n removeAttr: () => undefined,\n setContent: () => undefined,\n registerInteractionHandler: () => undefined,\n deregisterInteractionHandler: () => undefined,\n notifyIconAction: () => undefined,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n private savedTabIndex_: string | null = null;\n private readonly interactionHandler_: SpecificEventListener<InteractionEventType>;\n\n constructor(adapter?: Partial<MDCTextFieldIconAdapter>) {\n super({...MDCTextFieldIconFoundation.defaultAdapter, ...adapter});\n\n this.interactionHandler_ = (evt) => this.handleInteraction(evt);\n }\n\n init() {\n this.savedTabIndex_ = this.adapter.getAttr('tabindex');\n\n INTERACTION_EVENTS.forEach((evtType) => {\n this.adapter.registerInteractionHandler(evtType, this.interactionHandler_);\n });\n }\n\n destroy() {\n INTERACTION_EVENTS.forEach((evtType) => {\n this.adapter.deregisterInteractionHandler(evtType, this.interactionHandler_);\n });\n }\n\n setDisabled(disabled: boolean) {\n if (!this.savedTabIndex_) {\n return;\n }\n\n if (disabled) {\n this.adapter.setAttr('tabindex', '-1');\n this.adapter.removeAttr('role');\n } else {\n this.adapter.setAttr('tabindex', this.savedTabIndex_);\n this.adapter.setAttr('role', strings.ICON_ROLE);\n }\n }\n\n setAriaLabel(label: string) {\n this.adapter.setAttr('aria-label', label);\n }\n\n setContent(content: string) {\n this.adapter.setContent(content);\n }\n\n handleInteraction(evt: MouseEvent | KeyboardEvent) {\n const isEnterKey = (evt as KeyboardEvent).key === 'Enter' || (evt as KeyboardEvent).keyCode === 13;\n if (evt.type === 'click' || isEnterKey) {\n evt.preventDefault(); // stop click from causing host label to focus\n // input\n this.adapter.notifyIconAction();\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTextFieldIconFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './foundation';\nexport {cssClasses as iconCssClasses, strings as iconStrings} from './constants';\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './types';\nexport * from './character-counter/index';\nexport * from './helper-text/index';\nexport * from './icon/index';\n","/**\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 */\n\nimport {MDCComponent} from '@material/base/component';\nimport {SpecificEventListener} from '@material/base/types';\nimport {MDCRipple, MDCRippleFactory} from '@material/ripple/component';\nimport {MDCTopAppBarAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCFixedTopAppBarFoundation} from './fixed/foundation';\nimport {MDCTopAppBarBaseFoundation} from './foundation';\nimport {MDCShortTopAppBarFoundation} from './short/foundation';\nimport {MDCTopAppBarFoundation} from './standard/foundation';\n\nexport class MDCTopAppBar extends MDCComponent<MDCTopAppBarBaseFoundation> {\n static attachTo(root: Element): MDCTopAppBar {\n return new MDCTopAppBar(root);\n }\n\n private handleNavigationClick_!: SpecificEventListener<'click'>; // assigned in initialSyncWithDOM()\n private handleWindowResize_!: SpecificEventListener<'resize'>; // assigned in initialSyncWithDOM()\n private handleTargetScroll_!: SpecificEventListener<'scroll'>; // assigned in initialSyncWithDOM()\n private navIcon_!: Element | null;\n private iconRipples_!: MDCRipple[];\n private scrollTarget_!: EventTarget;\n\n initialize(rippleFactory: MDCRippleFactory = (el) => MDCRipple.attachTo(el)) {\n this.navIcon_ = this.root.querySelector(strings.NAVIGATION_ICON_SELECTOR);\n\n // Get all icons in the toolbar and instantiate the ripples\n const icons: Element[] =\n [].slice.call(this.root.querySelectorAll(strings.ACTION_ITEM_SELECTOR));\n if (this.navIcon_) {\n icons.push(this.navIcon_);\n }\n\n this.iconRipples_ = icons.map((icon) => {\n const ripple = rippleFactory(icon);\n ripple.unbounded = true;\n return ripple;\n });\n\n this.scrollTarget_ = window;\n }\n\n initialSyncWithDOM() {\n this.handleNavigationClick_ =\n this.foundation.handleNavigationClick.bind(this.foundation);\n this.handleWindowResize_ =\n this.foundation.handleWindowResize.bind(this.foundation);\n this.handleTargetScroll_ =\n this.foundation.handleTargetScroll.bind(this.foundation);\n\n this.scrollTarget_.addEventListener('scroll', this.handleTargetScroll_ as EventListener);\n\n if (this.navIcon_) {\n this.navIcon_.addEventListener('click', this.handleNavigationClick_ as EventListener);\n }\n\n const isFixed = this.root.classList.contains(cssClasses.FIXED_CLASS);\n const isShort = this.root.classList.contains(cssClasses.SHORT_CLASS);\n if (!isShort && !isFixed) {\n window.addEventListener('resize', this.handleWindowResize_ as EventListener);\n }\n }\n\n destroy() {\n this.iconRipples_.forEach((iconRipple) => iconRipple.destroy());\n this.scrollTarget_.removeEventListener('scroll', this.handleTargetScroll_ as EventListener);\n if (this.navIcon_) {\n this.navIcon_.removeEventListener('click', this.handleNavigationClick_ as EventListener);\n }\n const isFixed = this.root.classList.contains(cssClasses.FIXED_CLASS);\n const isShort = this.root.classList.contains(cssClasses.SHORT_CLASS);\n if (!isShort && !isFixed) {\n window.removeEventListener('resize', this.handleWindowResize_ as EventListener);\n }\n super.destroy();\n }\n\n setScrollTarget(target: EventTarget) {\n // Remove scroll handler from the previous scroll target\n this.scrollTarget_.removeEventListener('scroll', this.handleTargetScroll_ as EventListener);\n\n this.scrollTarget_ = target;\n\n // Initialize scroll handler on the new scroll target\n this.handleTargetScroll_ =\n this.foundation.handleTargetScroll.bind(this.foundation);\n this.scrollTarget_.addEventListener('scroll', this.handleTargetScroll_ as EventListener);\n }\n\n getDefaultFoundation() {\n // DO NOT INLINE this variable. For backward compatibility, foundations take a Partial<MDCFooAdapter>.\n // To ensure we don't accidentally omit any methods, we need a separate, strongly typed adapter variable.\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n const adapter: MDCTopAppBarAdapter = {\n hasClass: (className) => this.root.classList.contains(className),\n addClass: (className) => this.root.classList.add(className),\n removeClass: (className) => this.root.classList.remove(className),\n setStyle: (property, value) =>\n (this.root as HTMLElement).style.setProperty(property, value),\n getTopAppBarHeight: () => this.root.clientHeight,\n notifyNavigationIconClicked: () =>\n this.emit(strings.NAVIGATION_EVENT, {}),\n getViewportScrollY: () => {\n const win = this.scrollTarget_ as Window;\n const el = this.scrollTarget_ as Element;\n return win.pageYOffset !== undefined ? win.pageYOffset : el.scrollTop;\n },\n getTotalActionItems: () =>\n this.root.querySelectorAll(strings.ACTION_ITEM_SELECTOR).length,\n };\n // tslint:enable:object-literal-sort-keys\n\n let foundation: MDCTopAppBarBaseFoundation;\n if (this.root.classList.contains(cssClasses.SHORT_CLASS)) {\n foundation = new MDCShortTopAppBarFoundation(adapter);\n } else if (this.root.classList.contains(cssClasses.FIXED_CLASS)) {\n foundation = new MDCFixedTopAppBarFoundation(adapter);\n } else {\n foundation = new MDCTopAppBarFoundation(adapter);\n }\n\n return foundation;\n }\n}\n","/**\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 */\n\nconst cssClasses = {\n FIXED_CLASS: 'mdc-top-app-bar--fixed',\n FIXED_SCROLLED_CLASS: 'mdc-top-app-bar--fixed-scrolled',\n SHORT_CLASS: 'mdc-top-app-bar--short',\n SHORT_COLLAPSED_CLASS: 'mdc-top-app-bar--short-collapsed',\n SHORT_HAS_ACTION_ITEM_CLASS: 'mdc-top-app-bar--short-has-action-item',\n};\n\nconst numbers = {\n DEBOUNCE_THROTTLE_RESIZE_TIME_MS: 100,\n MAX_TOP_APP_BAR_HEIGHT: 128,\n};\n\nconst strings = {\n ACTION_ITEM_SELECTOR: '.mdc-top-app-bar__action-item',\n NAVIGATION_EVENT: 'MDCTopAppBar:nav',\n NAVIGATION_ICON_SELECTOR: '.mdc-top-app-bar__navigation-icon',\n ROOT_SELECTOR: '.mdc-top-app-bar',\n TITLE_SELECTOR: '.mdc-top-app-bar__title',\n};\n\nexport {cssClasses, numbers, strings};\n","/**\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 */\n\nimport {cssClasses} from '../constants';\nimport {MDCTopAppBarFoundation} from '../standard/foundation';\n\nexport class MDCFixedTopAppBarFoundation extends MDCTopAppBarFoundation {\n /**\n * State variable for the previous scroll iteration top app bar state\n */\n private wasScrolled_ = false;\n\n /**\n * Scroll handler for applying/removing the modifier class on the fixed top app bar.\n * @override\n */\n handleTargetScroll() {\n const currentScroll = this.adapter.getViewportScrollY();\n\n if (currentScroll <= 0) {\n if (this.wasScrolled_) {\n this.adapter.removeClass(cssClasses.FIXED_SCROLLED_CLASS);\n this.wasScrolled_ = false;\n }\n } else {\n if (!this.wasScrolled_) {\n this.adapter.addClass(cssClasses.FIXED_SCROLLED_CLASS);\n this.wasScrolled_ = true;\n }\n }\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCFixedTopAppBarFoundation;\n","/**\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 */\n\nimport {MDCFoundation} from '@material/base/foundation';\nimport {MDCTopAppBarAdapter} from './adapter';\nimport {cssClasses, numbers, strings} from './constants';\n\nexport class MDCTopAppBarBaseFoundation extends MDCFoundation<MDCTopAppBarAdapter> {\n static get strings() {\n return strings;\n }\n\n static get cssClasses() {\n return cssClasses;\n }\n\n static get numbers() {\n return numbers;\n }\n\n /**\n * See {@link MDCTopAppBarAdapter} for typing information on parameters and return types.\n */\n static get defaultAdapter(): MDCTopAppBarAdapter {\n // tslint:disable:object-literal-sort-keys Methods should be in the same order as the adapter interface.\n return {\n addClass: () => undefined,\n removeClass: () => undefined,\n hasClass: () => false,\n setStyle: () => undefined,\n getTopAppBarHeight: () => 0,\n notifyNavigationIconClicked: () => undefined,\n getViewportScrollY: () => 0,\n getTotalActionItems: () => 0,\n };\n // tslint:enable:object-literal-sort-keys\n }\n\n /* istanbul ignore next: optional argument is not a branch statement */\n constructor(adapter?: Partial<MDCTopAppBarAdapter>) {\n super({...MDCTopAppBarBaseFoundation.defaultAdapter, ...adapter});\n }\n\n /** Other variants of TopAppBar foundation overrides this method */\n handleTargetScroll() {} // tslint:disable-line:no-empty\n /** Other variants of TopAppBar foundation overrides this method */\n handleWindowResize() {} // tslint:disable-line:no-empty\n\n handleNavigationClick() {\n this.adapter.notifyNavigationIconClicked();\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTopAppBarBaseFoundation;\n","/**\n * @license\n * Copyright 2019 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 */\n\nexport * from './adapter';\nexport * from './component';\nexport * from './constants';\nexport * from './foundation';\nexport * from './fixed/foundation';\nexport * from './short/foundation';\nexport * from './standard/foundation';\n","/**\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 */\n\nimport {MDCTopAppBarAdapter} from '../adapter';\nimport {cssClasses} from '../constants';\nimport {MDCTopAppBarBaseFoundation} from '../foundation';\n\nexport class MDCShortTopAppBarFoundation extends MDCTopAppBarBaseFoundation {\n // Public visibility for backward compatibility.\n get isCollapsed(): boolean {\n return this.isCollapsed_;\n }\n\n private isCollapsed_ = false;\n\n private isAlwaysCollapsed_ = false;\n\n /* istanbul ignore next: optional argument is not a branch statement */\n constructor(adapter?: Partial<MDCTopAppBarAdapter>) {\n super(adapter);\n }\n\n init() {\n super.init();\n\n if (this.adapter.getTotalActionItems() > 0) {\n this.adapter.addClass(cssClasses.SHORT_HAS_ACTION_ITEM_CLASS);\n }\n\n // If initialized with SHORT_COLLAPSED_CLASS, the bar should always be collapsed\n this.setAlwaysCollapsed(\n this.adapter.hasClass(cssClasses.SHORT_COLLAPSED_CLASS));\n }\n\n /**\n * Set if the short top app bar should always be collapsed.\n *\n * @param value When `true`, bar will always be collapsed. When `false`, bar may collapse or expand based on scroll.\n */\n setAlwaysCollapsed(value: boolean) {\n this.isAlwaysCollapsed_ = !!value;\n if (this.isAlwaysCollapsed_) {\n this.collapse_();\n } else {\n // let maybeCollapseBar_ determine if the bar should be collapsed\n this.maybeCollapseBar_();\n }\n }\n\n getAlwaysCollapsed() {\n return this.isAlwaysCollapsed_;\n }\n\n /**\n * Scroll handler for applying/removing the collapsed modifier class on the short top app bar.\n * @override\n */\n handleTargetScroll() {\n this.maybeCollapseBar_();\n }\n\n private maybeCollapseBar_() {\n if (this.isAlwaysCollapsed_) {\n return;\n }\n const currentScroll = this.adapter.getViewportScrollY();\n\n if (currentScroll <= 0) {\n if (this.isCollapsed_) {\n this.uncollapse_();\n }\n } else {\n if (!this.isCollapsed_) {\n this.collapse_();\n }\n }\n }\n\n private uncollapse_() {\n this.adapter.removeClass(cssClasses.SHORT_COLLAPSED_CLASS);\n this.isCollapsed_ = false;\n }\n\n private collapse_() {\n this.adapter.addClass(cssClasses.SHORT_COLLAPSED_CLASS);\n this.isCollapsed_ = true;\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCShortTopAppBarFoundation;\n","/**\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 */\n\nimport {MDCTopAppBarAdapter} from '../adapter';\nimport {numbers} from '../constants';\nimport {MDCTopAppBarBaseFoundation} from '../foundation';\n\nconst INITIAL_VALUE = 0;\n\nexport class MDCTopAppBarFoundation extends MDCTopAppBarBaseFoundation {\n /**\n * Indicates if the top app bar was docked in the previous scroll handler iteration.\n */\n private wasDocked_ = true;\n\n /**\n * Indicates if the top app bar is docked in the fully shown position.\n */\n private isDockedShowing_ = true;\n\n /**\n * Variable for current scroll position of the top app bar\n */\n private currentAppBarOffsetTop_ = 0;\n\n /**\n * Used to prevent the top app bar from being scrolled out of view during resize events\n */\n private isCurrentlyBeingResized_ = false;\n\n /**\n * The timeout that's used to throttle the resize events\n */\n private resizeThrottleId_ = INITIAL_VALUE;\n\n /**\n * Used for diffs of current scroll position vs previous scroll position\n */\n private lastScrollPosition_: number;\n\n /**\n * Used to verify when the top app bar is completely showing or completely hidden\n */\n private topAppBarHeight_: number;\n\n /**\n * The timeout that's used to debounce toggling the isCurrentlyBeingResized_ variable after a resize\n */\n private resizeDebounceId_ = INITIAL_VALUE;\n\n /* istanbul ignore next: optional argument is not a branch statement */\n constructor(adapter?: Partial<MDCTopAppBarAdapter>) {\n super(adapter);\n\n this.lastScrollPosition_ = this.adapter.getViewportScrollY();\n this.topAppBarHeight_ = this.adapter.getTopAppBarHeight();\n }\n\n destroy() {\n super.destroy();\n this.adapter.setStyle('top', '');\n }\n\n /**\n * Scroll handler for the default scroll behavior of the top app bar.\n * @override\n */\n handleTargetScroll() {\n const currentScrollPosition = Math.max(this.adapter.getViewportScrollY(), 0);\n const diff = currentScrollPosition - this.lastScrollPosition_;\n this.lastScrollPosition_ = currentScrollPosition;\n\n // If the window is being resized the lastScrollPosition_ needs to be updated but the\n // current scroll of the top app bar should stay in the same position.\n if (!this.isCurrentlyBeingResized_) {\n this.currentAppBarOffsetTop_ -= diff;\n\n if (this.currentAppBarOffsetTop_ > 0) {\n this.currentAppBarOffsetTop_ = 0;\n } else if (Math.abs(this.currentAppBarOffsetTop_) > this.topAppBarHeight_) {\n this.currentAppBarOffsetTop_ = -this.topAppBarHeight_;\n }\n\n this.moveTopAppBar_();\n }\n }\n\n /**\n * Top app bar resize handler that throttle/debounce functions that execute updates.\n * @override\n */\n handleWindowResize() {\n // Throttle resize events 10 p/s\n if (!this.resizeThrottleId_) {\n this.resizeThrottleId_ = setTimeout(() => {\n this.resizeThrottleId_ = INITIAL_VALUE;\n this.throttledResizeHandler_();\n }, numbers.DEBOUNCE_THROTTLE_RESIZE_TIME_MS);\n }\n\n this.isCurrentlyBeingResized_ = true;\n\n if (this.resizeDebounceId_) {\n clearTimeout(this.resizeDebounceId_);\n }\n\n this.resizeDebounceId_ = setTimeout(() => {\n this.handleTargetScroll();\n this.isCurrentlyBeingResized_ = false;\n this.resizeDebounceId_ = INITIAL_VALUE;\n }, numbers.DEBOUNCE_THROTTLE_RESIZE_TIME_MS);\n }\n\n /**\n * Function to determine if the DOM needs to update.\n */\n private checkForUpdate_(): boolean {\n const offscreenBoundaryTop = -this.topAppBarHeight_;\n const hasAnyPixelsOffscreen = this.currentAppBarOffsetTop_ < 0;\n const hasAnyPixelsOnscreen = this.currentAppBarOffsetTop_ > offscreenBoundaryTop;\n const partiallyShowing = hasAnyPixelsOffscreen && hasAnyPixelsOnscreen;\n\n // If it's partially showing, it can't be docked.\n if (partiallyShowing) {\n this.wasDocked_ = false;\n } else {\n // Not previously docked and not partially showing, it's now docked.\n if (!this.wasDocked_) {\n this.wasDocked_ = true;\n return true;\n } else if (this.isDockedShowing_ !== hasAnyPixelsOnscreen) {\n this.isDockedShowing_ = hasAnyPixelsOnscreen;\n return true;\n }\n }\n\n return partiallyShowing;\n }\n\n /**\n * Function to move the top app bar if needed.\n */\n private moveTopAppBar_() {\n if (this.checkForUpdate_()) {\n // Once the top app bar is fully hidden we use the max potential top app bar height as our offset\n // so the top app bar doesn't show if the window resizes and the new height > the old height.\n let offset = this.currentAppBarOffsetTop_;\n if (Math.abs(offset) >= this.topAppBarHeight_) {\n offset = -numbers.MAX_TOP_APP_BAR_HEIGHT;\n }\n\n this.adapter.setStyle('top', offset + 'px');\n }\n }\n\n /**\n * Throttled function that updates the top app bar scrolled values if the\n * top app bar height changes.\n */\n private throttledResizeHandler_() {\n const currentHeight = this.adapter.getTopAppBarHeight();\n if (this.topAppBarHeight_ !== currentHeight) {\n this.wasDocked_ = false;\n\n // Since the top app bar has a different height depending on the screen width, this\n // will ensure that the top app bar remains in the correct location if\n // completely hidden and a resize makes the top app bar a different height.\n this.currentAppBarOffsetTop_ -= this.topAppBarHeight_ - currentHeight;\n this.topAppBarHeight_ = currentHeight;\n }\n this.handleTargetScroll();\n }\n}\n\n// tslint:disable-next-line:no-default-export Needed for backward compatibility with MDC Web v0.44.0 and earlier.\nexport default MDCTopAppBarFoundation;\n"],"sourceRoot":""}
|
