{"version":3,"sources":["webpack://mdc.[name]/webpack/universalModuleDefinition","webpack://mdc.[name]/webpack/bootstrap","webpack://mdc.[name]/./node_modules/process/browser.js","webpack://mdc.[name]/./node_modules/safevalues/builders/attribute_builders.js","webpack://mdc.[name]/./node_modules/safevalues/builders/html_builders.js","webpack://mdc.[name]/./node_modules/safevalues/builders/html_sanitizer/html_sanitizer.js","webpack://mdc.[name]/./node_modules/safevalues/builders/html_sanitizer/html_sanitizer_builder.js","webpack://mdc.[name]/./node_modules/safevalues/builders/html_sanitizer/inert_fragment.js","webpack://mdc.[name]/./node_modules/safevalues/builders/html_sanitizer/no_clobber.js","webpack://mdc.[name]/./node_modules/safevalues/builders/html_sanitizer/sanitizer_table/default_sanitizer_table.js","webpack://mdc.[name]/./node_modules/safevalues/builders/html_sanitizer/sanitizer_table/sanitizer_table.js","webpack://mdc.[name]/./node_modules/safevalues/builders/resource_url_builders.js","webpack://mdc.[name]/./node_modules/safevalues/builders/script_builders.js","webpack://mdc.[name]/./node_modules/safevalues/builders/sensitive_attributes.js","webpack://mdc.[name]/./node_modules/safevalues/builders/style_builders.js","webpack://mdc.[name]/./node_modules/safevalues/builders/style_sheet_builders.js","webpack://mdc.[name]/./node_modules/safevalues/builders/url_sanitizer.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/anchor.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/area.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/button.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/element.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/embed.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/form.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/iframe.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/input.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/link.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/object.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/script.js","webpack://mdc.[name]/./node_modules/safevalues/dom/elements/style.js","webpack://mdc.[name]/./node_modules/safevalues/dom/globals/document.js","webpack://mdc.[name]/./node_modules/safevalues/dom/globals/dom_parser.js","webpack://mdc.[name]/./node_modules/safevalues/dom/globals/global.js","webpack://mdc.[name]/./node_modules/safevalues/dom/globals/location.js","webpack://mdc.[name]/./node_modules/safevalues/dom/globals/range.js","webpack://mdc.[name]/./node_modules/safevalues/dom/globals/service_worker_container.js","webpack://mdc.[name]/./node_modules/safevalues/dom/globals/window.js","webpack://mdc.[name]/./node_modules/safevalues/dom/globals/worker.js","webpack://mdc.[name]/./node_modules/safevalues/dom/index.js","webpack://mdc.[name]/./node_modules/safevalues/environment/dev.js","webpack://mdc.[name]/./node_modules/safevalues/index.js","webpack://mdc.[name]/./node_modules/safevalues/internals/attribute_impl.js","webpack://mdc.[name]/./node_modules/safevalues/internals/html_impl.js","webpack://mdc.[name]/./node_modules/safevalues/internals/resource_url_impl.js","webpack://mdc.[name]/./node_modules/safevalues/internals/script_impl.js","webpack://mdc.[name]/./node_modules/safevalues/internals/secrets.js","webpack://mdc.[name]/./node_modules/safevalues/internals/string_literal.js","webpack://mdc.[name]/./node_modules/safevalues/internals/style_impl.js","webpack://mdc.[name]/./node_modules/safevalues/internals/style_sheet_impl.js","webpack://mdc.[name]/./node_modules/safevalues/internals/trusted_types.js","webpack://mdc.[name]/./packages/mdc-base/component.ts","webpack://mdc.[name]/./packages/mdc-base/foundation.ts","webpack://mdc.[name]/./packages/mdc-dom/events.ts","webpack://mdc.[name]/./packages/mdc-dom/ponyfill.ts","webpack://mdc.[name]/./packages/mdc-ripple/component.ts","webpack://mdc.[name]/./packages/mdc-ripple/constants.ts","webpack://mdc.[name]/./packages/mdc-ripple/foundation.ts","webpack://mdc.[name]/./packages/mdc-ripple/util.ts","webpack://mdc.[name]/./packages/mdc-tab-bar/adapter.ts","webpack://mdc.[name]/./packages/mdc-tab-bar/component.ts","webpack://mdc.[name]/./packages/mdc-tab-bar/constants.ts","webpack://mdc.[name]/./packages/mdc-tab-bar/foundation.ts","webpack://mdc.[name]/./packages/mdc-tab-bar/index.ts","webpack://mdc.[name]/./packages/mdc-tab-bar/types.ts","webpack://mdc.[name]/./packages/mdc-tab-indicator/component.ts","webpack://mdc.[name]/./packages/mdc-tab-indicator/constants.ts","webpack://mdc.[name]/./packages/mdc-tab-indicator/fading-foundation.ts","webpack://mdc.[name]/./packages/mdc-tab-indicator/foundation.ts","webpack://mdc.[name]/./packages/mdc-tab-indicator/sliding-foundation.ts","webpack://mdc.[name]/./packages/mdc-tab-scroller/component.ts","webpack://mdc.[name]/./packages/mdc-tab-scroller/constants.ts","webpack://mdc.[name]/./packages/mdc-tab-scroller/foundation.ts","webpack://mdc.[name]/./packages/mdc-tab-scroller/rtl-default-scroller.ts","webpack://mdc.[name]/./packages/mdc-tab-scroller/rtl-negative-scroller.ts","webpack://mdc.[name]/./packages/mdc-tab-scroller/rtl-reverse-scroller.ts","webpack://mdc.[name]/./packages/mdc-tab-scroller/rtl-scroller.ts","webpack://mdc.[name]/./packages/mdc-tab-scroller/util.ts","webpack://mdc.[name]/./packages/mdc-tab/component.ts","webpack://mdc.[name]/./packages/mdc-tab/constants.ts","webpack://mdc.[name]/./packages/mdc-tab/foundation.ts"],"names":[],"mappings":";;;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iCAAiC;AACjC,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;;;;;;;;;;;;AClFA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;;;AAIA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,uBAAuB,sBAAsB;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,qCAAqC;;AAErC;AACA;AACA;;AAEA,2BAA2B;AAC3B;AACA;AACA;AACA,4BAA4B,UAAU;;;;;;;;;;;;;ACvLzB;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D,6BAA6B,mBAAO,CAAC,0FAAwB;AAC7D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA,wCAAwC;AACxC;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;;;;;;;;;;;;;AC3Ca;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,kBAAkB,mBAAO,CAAC,gFAAwB;AAClD,0BAA0B,mBAAO,CAAC,gGAAgC;AAClE,oBAAoB,mBAAO,CAAC,oFAA0B;AACtD;AACA;AACA;AACA;AACA;AACA,sCAAsC;AACtC;AACA;AACA;AACA;AACA,6BAA6B,cAAc;AAC3C;AACA;AACA;AACA;AACA,kEAAkE;AAClE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B,cAAc;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C;AAC3C,4BAA4B;AAC5B,4BAA4B;AAC5B,8BAA8B;AAC9B,8BAA8B;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACxFa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,gBAAgB;AACzC;AACA;AACA;AACA;AACA,iBAAiB,sBAAsB;AACvC;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,2EAAuB;AAC/B,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD;AACA,gBAAgB,mBAAO,CAAC,+EAAyB;AACjD,sBAAsB,mBAAO,CAAC,6EAAkB;AAChD,uBAAuB,mBAAO,CAAC,6FAAkB;AACjD,mBAAmB,mBAAO,CAAC,qFAAc;AACzC,gCAAgC,mBAAO,CAAC,+IAA2C;AACnF,wBAAwB,mBAAO,CAAC,+HAAmC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,IAAqC;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,4BAA4B,EAAE;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mHAAmH,2BAA2B;AAC9I;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA,aAAa,EAEJ;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+FAA+F,sBAAsB;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA,8BAA8B,sGAAsG,EAAE;AACtI;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,8CAA8C;AACvE;AACA;;;;;;;;;;;;;ACvQa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,gBAAgB;AACzC;AACA;AACA;AACA;AACA,iBAAiB,sBAAsB;AACvC;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,gBAAgB,mBAAO,CAAC,+EAAyB;AACjD,uBAAuB,mBAAO,CAAC,6FAAkB;AACjD,gCAAgC,mBAAO,CAAC,+IAA2C;AACnF,wBAAwB,mBAAO,CAAC,+HAAmC;AACnE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+FAA+F,sBAAsB;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uGAAuG,wBAAwB;AAC/H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA,4DAA4D,UAAU;AACtE;AACA;AACA;AACA;AACA,qDAAqD,UAAU;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B,QAAQ,gBAAgB;AACvD;AACA;AACA;AACA;AACA,6BAA6B,0BAA0B;AACvD;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+FAA+F,sBAAsB;AACrH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,QAAQ,gBAAgB;AAC/C;AACA;AACA;AACA;AACA,qBAAqB,0BAA0B;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,gFAAgF;AAC9H;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,6DAA6D;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2CAA2C,6DAA6D;AACxG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;;;;;;;;;;;;;ACpNa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,gBAAgB,mBAAO,CAAC,qFAA4B;AACpD,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACtBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC/Ba;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,wBAAwB,mBAAO,CAAC,+GAAmB;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sBAAsB,8EAA8E;AACpG;AACA;AACA;AACA;AACA,sBAAsB,8EAA8E;AACpG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB,8EAA8E;AACnG;AACA;AACA;AACA;AACA,qBAAqB,8EAA8E;AACnG;AACA;AACA;AACA;AACA,qBAAqB,8EAA8E;AACnG;AACA;AACA;AACA;AACA,qBAAqB,8EAA8E;AACnG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,8EAA8E;AAC5F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,8EAA8E;AAC9F;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjPa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA,gCAAgC;AAChC;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC,8FAA8F;;;;;;;;;;;;;ACnDlF;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,0BAA0B,mBAAO,CAAC,gGAAgC;AAClE,oBAAoB,mBAAO,CAAC,oFAA0B;AACtD,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oDAAoD,IAAI;AACxD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,iBAAiB;AACpC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,mBAAmB;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C,0BAA0B;AACpE;AACA;AACA;;;;;;;;;;;;;ACzNa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,oBAAoB,mBAAO,CAAC,oFAA0B;AACtD,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA,0CAA0C;AAC1C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,UAAU,YAAY;AAC1B;AACA;AACA;AACA;AACA;AACA,IAAI,SAAS,SAAS;AACtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA,QAAQ,IAAqC;AAC7C,yCAAyC,iBAAiB,EAAE;AAC5D;AACA;AACA;AACA;AACA;AACA,kDAAkD;AAClD;AACA;AACA;AACA,wBAAwB,uBAAuB;AAC/C;AACA;AACA,iDAAiD,qCAAqC,EAAE;AACxF;AACA;AACA;AACA;;;;;;;;;;;;;AC1Fa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACvBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D,mBAAmB,mBAAO,CAAC,kFAAyB;AACpD;AACA;AACA;AACA;AACA;AACA,iBAAiB,cAAc;AAC/B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+CAA+C,MAAM;AACrD;AACA;AACA;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA,yCAAyC;AACzC;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA;AACA,eAAe;AACf,8DAA8D;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACxDa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,uBAAuB,mBAAO,CAAC,0FAA6B;AAC5D,yBAAyB,mBAAO,CAAC,8FAA+B;AAChE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA,2DAA2D;AAC3D;AACA;AACA,QAAQ,IAAqC;AAC7C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC7Ca;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA,mBAAO,CAAC,wEAAoB;AAC5B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACvEa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,gBAAgB;AACzC;AACA;AACA;AACA;AACA,iBAAiB,sBAAsB;AACvC;AACA;AACA;AACA;AACA,4EAA4E,OAAO;AACnF;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,mBAAO,CAAC,6FAAgC;AAC/D,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD,mBAAmB,mBAAO,CAAC,qFAA4B;AACvD;AACA,eAAe,wBAAwB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,wBAAwB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB,iCAAiC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,uBAAuB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,kDAAkD,uDAAuD,EAAE;AAC3G;AACA,qCAAqC,mCAAmC,EAAE;AAC1E;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACpIa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACda;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACrBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC5Ca;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACZa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE,oBAAoB,mBAAO,CAAC,uFAA6B;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC3Ca;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,yBAAyB,mBAAO,CAAC,iGAAkC;AACnE;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACZa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD;AACA,uBAAuB,qBAAqB,eAAe,eAAe;AAC1E,cAAc,eAAe;AAC7B;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,2BAA2B;AAC5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iBAAiB,2BAA2B;AAC5C;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACpCa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACjBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,oBAAoB,mBAAO,CAAC,uFAA6B;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACvBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA,wBAAwB,oBAAoB,eAAe,eAAe;AAC1E,UAAU,UAAU;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB,uBAAuB,eAAe;AAC/D,eAAe,UAAU;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB,sBAAsB,eAAe;AAC7D,eAAe,UAAU;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACxCa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,kBAAkB,mBAAO,CAAC,mFAA2B;AACrD;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACZa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,0BAA0B,mBAAO,CAAC,mGAAmC;AACrE;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACZa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,sBAAsB,mBAAO,CAAC,yFAA8B;AAC5D;AACA,eAAe,kBAAkB,eAAe,aAAa;AAC7D,WAAW,UAAU;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACnBa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,MAAM,gBAAgB;AACzC;AACA;AACA;AACA;AACA,iBAAiB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;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACxEa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B;AACA,gBAAgB,mBAAO,CAAC,iEAAW;AACnC,sBAAsB,mBAAO,CAAC,6EAAiB;AAC/C;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,QAAQ,gIAAgI,EAAE;AACxK;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AClFa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,gBAAgB,mBAAO,CAAC,iEAAW;AACnC,sBAAsB,mBAAO,CAAC,6EAAiB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC3Ea;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B;AACA,gBAAgB,mBAAO,CAAC,iEAAW;AACnC,sBAAsB,mBAAO,CAAC,6EAAiB;AAC/C;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,QAAQ,oIAAoI,EAAE;AAC5K;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACnFa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACvBa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;ACtBa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,gBAAgB,sCAAsC,iBAAiB,EAAE;AACvF,6BAA6B,8EAA8E;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,sBAAsB;AAC7C;AACA;AACA,CAAC;AACD,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,gBAAgB,mBAAO,CAAC,iEAAW;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AClFa;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc,gBAAgB,sCAAsC,iBAAiB,EAAE;AACvF,6BAA6B,8EAA8E;AAC3G;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,sBAAsB;AAC7C;AACA;AACA,CAAC;AACD,8CAA8C,cAAc;AAC5D;AACA,mBAAO,CAAC,wEAAoB;AAC5B,gBAAgB,mBAAO,CAAC,iEAAW;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,IAAqC;AACjD;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AClFa;AACb;AACA;AACA;AACA;AACA,8CAA8C,cAAc;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8CAA8C,UAAU,EAAE;AAC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","file":"mdc.tabBar.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(\"@material/tab-bar\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"tab-bar\"] = factory();\n\telse\n\t\troot[\"mdc\"] = root[\"mdc\"] || {}, root[\"mdc\"][\"tab-bar\"] = 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/mdc-tab-bar/index.ts\");\n","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.safeAttrPrefix = void 0;\nrequire(\"../environment/dev\");\nvar attribute_impl_1 = require(\"../internals/attribute_impl\");\nvar string_literal_1 = require(\"../internals/string_literal\");\nvar sensitive_attributes_1 = require(\"./sensitive_attributes\");\n/**\n * Creates a SafeAttributePrefix object from a template literal with no\n * interpolations for attributes that share a common prefix guaranteed to be not\n * security sensitive.\n *\n * The template literal is a prefix that makes it obvious this attribute is not\n * security sensitive. If it doesn't, this function will throw.\n */\nfunction safeAttrPrefix(templ) {\n    if (process.env.NODE_ENV !== 'production') {\n        (0, string_literal_1.assertIsTemplateObject)(templ, true, 'safeAttr is a template literal tag function ' +\n            'and should be called using the tagged template syntax. ' +\n            'For example, safeAttr`foo`;');\n    }\n    var attrPrefix = templ[0].toLowerCase();\n    if (process.env.NODE_ENV !== 'production') {\n        if (attrPrefix.indexOf('on') === 0 || 'on'.indexOf(attrPrefix) === 0) {\n            throw new Error(\"Prefix '\".concat(templ[0], \"' does not guarantee the attribute \") +\n                \"to be safe as it is also a prefix for event handler attributes\" +\n                \"Please use 'addEventListener' to set event handlers.\");\n        }\n        sensitive_attributes_1.SECURITY_SENSITIVE_ATTRIBUTES.forEach(function (sensitiveAttr) {\n            if (sensitiveAttr.indexOf(attrPrefix) === 0) {\n                throw new Error(\"Prefix '\".concat(templ[0], \"' does not guarantee the attribute \") +\n                    \"to be safe as it is also a prefix for \" +\n                    \"the security sensitive attribute '\".concat(sensitiveAttr, \"'. \") +\n                    \"Please use native or safe DOM APIs to set the attribute.\");\n            }\n        });\n    }\n    return (0, attribute_impl_1.createAttributePrefix)(attrPrefix);\n}\nexports.safeAttrPrefix = safeAttrPrefix;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.concatHtmls = exports.createScriptSrc = exports.createScript = exports.htmlEscape = void 0;\nvar html_impl_1 = require(\"../internals/html_impl\");\nvar resource_url_impl_1 = require(\"../internals/resource_url_impl\");\nvar script_impl_1 = require(\"../internals/script_impl\");\n/**\n * Returns HTML-escaped text as a `SafeHtml` object.\n *\n * Available options:\n * - `preserveSpaces` turns every second consecutive space character into its\n * HTML entity representation (`&#160;`).\n * - `preserveNewlines` turns newline characters into breaks (`<br>`).\n * - `preserveTabs` wraps tab characters in a span with style=white-space:pre.\n */\nfunction htmlEscape(text, options) {\n    if (options === void 0) { options = {}; }\n    var htmlEscapedString = htmlEscapeToString(text);\n    if (options.preserveSpaces) {\n        // Do this first to ensure we preserve spaces after newlines and tabs.\n        htmlEscapedString =\n            htmlEscapedString.replace(/(^|[\\r\\n\\t ]) /g, '$1&#160;');\n    }\n    if (options.preserveNewlines) {\n        htmlEscapedString = htmlEscapedString.replace(/(\\r\\n|\\n|\\r)/g, '<br>');\n    }\n    if (options.preserveTabs) {\n        htmlEscapedString = htmlEscapedString.replace(/(\\t+)/g, '<span style=\"white-space:pre\">$1</span>');\n    }\n    return (0, html_impl_1.createHtml)(htmlEscapedString);\n}\nexports.htmlEscape = htmlEscape;\n/**\n * Creates a `SafeHtml` representing a script tag with inline script content.\n */\nfunction createScript(script, options) {\n    if (options === void 0) { options = {}; }\n    var unwrappedScript = (0, script_impl_1.unwrapScript)(script).toString();\n    var stringTag = \"<script\";\n    if (options.id) {\n        stringTag += \" id=\\\"\".concat(htmlEscapeToString(options.id), \"\\\"\");\n    }\n    if (options.nonce) {\n        stringTag += \" nonce=\\\"\".concat(htmlEscapeToString(options.nonce), \"\\\"\");\n    }\n    if (options.type) {\n        stringTag += \" type=\\\"\".concat(htmlEscapeToString(options.type), \"\\\"\");\n    }\n    stringTag += \">\".concat(unwrappedScript, \"</script>\");\n    return (0, html_impl_1.createHtml)(stringTag);\n}\nexports.createScript = createScript;\n/**\n * Creates a `SafeHtml` representing a script tag with the src attribute.\n * This also supports CSP nonces and async loading.\n */\nfunction createScriptSrc(src, async, nonce) {\n    var unwrappedSrc = (0, resource_url_impl_1.unwrapResourceUrl)(src).toString();\n    var stringTag = \"<script src=\\\"\".concat(htmlEscapeToString(unwrappedSrc), \"\\\"\");\n    if (async) {\n        stringTag += ' async';\n    }\n    if (nonce) {\n        stringTag += \" nonce=\\\"\".concat(htmlEscapeToString(nonce), \"\\\"\");\n    }\n    stringTag += '>\\x3c/script>';\n    return (0, html_impl_1.createHtml)(stringTag);\n}\nexports.createScriptSrc = createScriptSrc;\n/**\n * HTML-escapes the given text (`&`, `<`, `>`, `\"` and `'`).\n */\nfunction htmlEscapeToString(text) {\n    var escaped = text.replace(/&/g, '&amp;')\n        .replace(/</g, '&lt;')\n        .replace(/>/g, '&gt;')\n        .replace(/\"/g, '&quot;')\n        .replace(/'/g, '&apos;');\n    return escaped;\n}\n/** Creates a `SafeHtml` value by concatenating multiple `SafeHtml`s. */\nfunction concatHtmls(htmls) {\n    return (0, html_impl_1.createHtml)(htmls.map(html_impl_1.unwrapHtml).join(''));\n}\nexports.concatHtmls = concatHtmls;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.sanitizeHtmlToFragment = exports.sanitizeHtmlAssertUnchanged = exports.sanitizeHtml = exports.HtmlSanitizerImpl = void 0;\nrequire(\"../../environment/dev\");\nvar html_impl_1 = require(\"../../internals/html_impl\");\n/* g3_import_pure from '../../internals/pure' */\nvar secrets_1 = require(\"../../internals/secrets\");\nvar url_sanitizer_1 = require(\"../url_sanitizer\");\nvar inert_fragment_1 = require(\"./inert_fragment\");\nvar no_clobber_1 = require(\"./no_clobber\");\nvar default_sanitizer_table_1 = require(\"./sanitizer_table/default_sanitizer_table\");\nvar sanitizer_table_1 = require(\"./sanitizer_table/sanitizer_table\");\n/** Implementation for `HtmlSanitizer` */\nvar HtmlSanitizerImpl = /** @class */ (function () {\n    function HtmlSanitizerImpl(sanitizerTable, token) {\n        this.sanitizerTable = sanitizerTable;\n        this.changes = [];\n        (0, secrets_1.ensureTokenIsValid)(token);\n    }\n    HtmlSanitizerImpl.prototype.sanitizeAssertUnchanged = function (html) {\n        this.changes = [];\n        var sanitizedHtml = this.sanitize(html);\n        if (this.changes.length !== 0) {\n            var message = '';\n            if (process.env.NODE_ENV !== 'production') {\n                message =\n                    \"Unexpected change to HTML value as a result of sanitization. \" +\n                        \"Input: \\\"\".concat(html, \"\\\", sanitized output: \\\"\").concat(sanitizedHtml, \"\\\"\\n\") +\n                        \"List of changes:\".concat(this.changes.join('\\n'));\n            }\n            throw new Error(message);\n        }\n        return sanitizedHtml;\n    };\n    HtmlSanitizerImpl.prototype.sanitize = function (html) {\n        var fakeRoot = document.createElement('span');\n        fakeRoot.appendChild(this.sanitizeToFragment(html));\n        // XML serialization is preferred over HTML serialization as it is\n        // stricter and makes sure all attributes are properly escaped, avoiding\n        // cases where the tree might mutate when parsed again later due to the\n        // complexities of the HTML parsing algorithm\n        var serializedNewTree = new XMLSerializer().serializeToString(fakeRoot);\n        // We remove the outer most element as this is the span node created as\n        // the root for the sanitized tree and contains a spurious xmlns attribute\n        // from the XML serialization step.\n        serializedNewTree = serializedNewTree.slice(serializedNewTree.indexOf('>') + 1, serializedNewTree.lastIndexOf('</'));\n        return (0, html_impl_1.createHtml)(serializedNewTree);\n    };\n    HtmlSanitizerImpl.prototype.sanitizeToFragment = function (html) {\n        var _this = this;\n        var dirtyFragment = (0, inert_fragment_1.createInertFragment)(html);\n        var treeWalker = document.createTreeWalker(dirtyFragment, NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_TEXT, \n        // IE10 and IE11 won't accept a proper `NodeFilter` interface, and\n        // expect the filtering function to be passed directly. It seems that\n        // other browsers also do not mind getting the function directly. see\n        // https://stackoverflow.com/q/38245898\n        (function (n) { return _this.nodeFilter(n); }), \n        // @ts-ignore: error TS2554: Expected 1-3 arguments, but got 4.\n        false);\n        // `nextNode` is called so we skip the root `DocumentFragment`.\n        var currentNode = treeWalker.nextNode();\n        // We create a root element to attach all the children of the body to. We\n        // use div as it as a semantic-free, generic container and does not\n        // represent anything. This is removed when we serialize the tree back\n        // into a string.\n        var sanitizedFragment = document.createDocumentFragment();\n        var sanitizedParent = sanitizedFragment;\n        while (currentNode !== null) {\n            var sanitizedNode = void 0;\n            if ((0, no_clobber_1.isText)(currentNode)) {\n                sanitizedNode = this.sanitizeTextNode(currentNode);\n            }\n            else if ((0, no_clobber_1.isElement)(currentNode)) {\n                sanitizedNode = this.sanitizeElementNode(currentNode);\n            }\n            else {\n                throw new Error('Node is not of type text or element');\n            }\n            sanitizedParent.appendChild(sanitizedNode);\n            // Advance iterator while keeping track of the sanitized parent for the\n            // current node\n            currentNode = treeWalker.firstChild();\n            if (currentNode) {\n                sanitizedParent = sanitizedNode;\n            }\n            else {\n                while (!(currentNode = treeWalker.nextSibling())) {\n                    if (!(currentNode = treeWalker.parentNode())) {\n                        break;\n                    }\n                    sanitizedParent = sanitizedParent.parentNode;\n                }\n            }\n        }\n        return sanitizedFragment;\n    };\n    HtmlSanitizerImpl.prototype.sanitizeTextNode = function (textNode) {\n        return document.createTextNode(textNode.data);\n    };\n    HtmlSanitizerImpl.prototype.sanitizeElementNode = function (elementNode) {\n        var e_1, _a;\n        var elementName = (0, no_clobber_1.getNodeName)(elementNode);\n        var newNode = document.createElement(elementName);\n        var dirtyAttributes = elementNode.attributes;\n        try {\n            for (var dirtyAttributes_1 = __values(dirtyAttributes), dirtyAttributes_1_1 = dirtyAttributes_1.next(); !dirtyAttributes_1_1.done; dirtyAttributes_1_1 = dirtyAttributes_1.next()) {\n                var _b = dirtyAttributes_1_1.value, name_1 = _b.name, value = _b.value;\n                var policy = this.sanitizerTable.getAttributePolicy(name_1, elementName);\n                if (!this.satisfiesAllConditions(policy.conditions, dirtyAttributes)) {\n                    this.recordChange(\"Not all conditions satisfied for attribute: \".concat(name_1, \".\"));\n                    continue;\n                }\n                switch (policy.policyAction) {\n                    case sanitizer_table_1.AttributePolicyAction.KEEP:\n                        newNode.setAttribute(name_1, value);\n                        break;\n                    case sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL:\n                        var sanitizedAttrUrl = (0, url_sanitizer_1.restrictivelySanitizeUrl)(value);\n                        if (sanitizedAttrUrl !== value) {\n                            this.recordChange(\"Url in attribute \".concat(name_1, \" was modified during sanitization. Original url:\\\"\").concat(value, \"\\\" was sanitized to: \\\"\").concat(sanitizedAttrUrl, \"\\\"\"));\n                        }\n                        newNode.setAttribute(name_1, sanitizedAttrUrl);\n                        break;\n                    case sanitizer_table_1.AttributePolicyAction.KEEP_AND_NORMALIZE:\n                        // We don't consider changing the case of an attribute value to be a\n                        // semantic change\n                        newNode.setAttribute(name_1, value.toLowerCase());\n                        break;\n                    case sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_STYLE:\n                        newNode.setAttribute(name_1, value);\n                        break;\n                    case sanitizer_table_1.AttributePolicyAction.DROP:\n                        this.recordChange(\"Attribute: \".concat(name_1, \" was dropped\"));\n                        break;\n                    default:\n                        checkExhaustive(policy.policyAction, 'Unhandled AttributePolicyAction case');\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (dirtyAttributes_1_1 && !dirtyAttributes_1_1.done && (_a = dirtyAttributes_1.return)) _a.call(dirtyAttributes_1);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        return newNode;\n    };\n    HtmlSanitizerImpl.prototype.nodeFilter = function (node) {\n        if ((0, no_clobber_1.isText)(node)) {\n            return NodeFilter.FILTER_ACCEPT;\n        }\n        else if (!(0, no_clobber_1.isElement)(node)) {\n            // Getting a node that is neither an `Element` or a `Text` node. This is\n            // likely due to something that is not supposed to be an element in user\n            // code but recognized as such by the TreeWalker (e.g. a polyfill for\n            // other kind of nodes). Since we can't recognize it as an element, we\n            // drop the node, but we don't record it as a meaningful change.\n            return NodeFilter.FILTER_REJECT;\n        }\n        var nodeName = (0, no_clobber_1.getNodeName)(node);\n        if (nodeName === null) {\n            this.recordChange(\"Node name was null for node: \".concat(node));\n            return NodeFilter.FILTER_REJECT;\n        }\n        if (this.sanitizerTable.isAllowedElement(nodeName)) {\n            return NodeFilter.FILTER_ACCEPT;\n        }\n        this.recordChange(\"Element: \".concat(nodeName, \" was dropped\"));\n        return NodeFilter.FILTER_REJECT;\n    };\n    HtmlSanitizerImpl.prototype.recordChange = function (errorMessage) {\n        if (process.env.NODE_ENV !== 'production') {\n            this.changes.push(errorMessage);\n        }\n        else if (this.changes.length === 0) {\n            this.changes.push('');\n        }\n    };\n    HtmlSanitizerImpl.prototype.satisfiesAllConditions = function (conditions, attrs) {\n        var e_2, _a;\n        var _b;\n        if (!conditions) {\n            return true;\n        }\n        try {\n            for (var conditions_1 = __values(conditions), conditions_1_1 = conditions_1.next(); !conditions_1_1.done; conditions_1_1 = conditions_1.next()) {\n                var _c = __read(conditions_1_1.value, 2), attrName = _c[0], expectedValues = _c[1];\n                var value = (_b = attrs.getNamedItem(attrName)) === null || _b === void 0 ? void 0 : _b.value;\n                if (value && !expectedValues.has(value)) {\n                    return false;\n                }\n            }\n        }\n        catch (e_2_1) { e_2 = { error: e_2_1 }; }\n        finally {\n            try {\n                if (conditions_1_1 && !conditions_1_1.done && (_a = conditions_1.return)) _a.call(conditions_1);\n            }\n            finally { if (e_2) throw e_2.error; }\n        }\n        return true;\n    };\n    return HtmlSanitizerImpl;\n}());\nexports.HtmlSanitizerImpl = HtmlSanitizerImpl;\nvar defaultHtmlSanitizer = \n/* #__PURE__ */ (function () { return new HtmlSanitizerImpl(default_sanitizer_table_1.defaultSanitizerTable, secrets_1.secretToken); })();\n/** Sanitizes untrusted html using the default sanitizer configuration. */\nfunction sanitizeHtml(html) {\n    return defaultHtmlSanitizer.sanitize(html);\n}\nexports.sanitizeHtml = sanitizeHtml;\n/**\n * Sanitizes untrusted html using the default sanitizer configuration. Throws\n * an error if the html was changed.\n */\nfunction sanitizeHtmlAssertUnchanged(html) {\n    return defaultHtmlSanitizer.sanitizeAssertUnchanged(html);\n}\nexports.sanitizeHtmlAssertUnchanged = sanitizeHtmlAssertUnchanged;\n/**\n * Sanitizes untrusted html using the default sanitizer configuration. Throws\n * an error if the html was changed.\n */\nfunction sanitizeHtmlToFragment(html) {\n    return defaultHtmlSanitizer.sanitizeToFragment(html);\n}\nexports.sanitizeHtmlToFragment = sanitizeHtmlToFragment;\nfunction checkExhaustive(value, msg) {\n    if (msg === void 0) { msg = \"unexpected value \".concat(value, \"!\"); }\n    throw new Error(msg);\n}\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __values = (this && this.__values) || function(o) {\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\n    if (m) return m.call(o);\n    if (o && typeof o.length === \"number\") return {\n        next: function () {\n            if (o && i >= o.length) o = void 0;\n            return { value: o && o[i++], done: !o };\n        }\n    };\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\n};\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.HtmlSanitizerBuilder = void 0;\nvar secrets_1 = require(\"../../internals/secrets\");\nvar html_sanitizer_1 = require(\"./html_sanitizer\");\nvar default_sanitizer_table_1 = require(\"./sanitizer_table/default_sanitizer_table\");\nvar sanitizer_table_1 = require(\"./sanitizer_table/sanitizer_table\");\n/** This class allows modifications to the default sanitizer configuration. */\nvar HtmlSanitizerBuilder = /** @class */ (function () {\n    function HtmlSanitizerBuilder() {\n        // To denote if the builder has called build() and therefore should make no\n        // further changes to the sanitizer table.\n        this.calledBuild = false;\n        this.sanitizerTable = default_sanitizer_table_1.defaultSanitizerTable;\n    }\n    /** Builder option to restrict allowed elements to a smaller subset. */\n    HtmlSanitizerBuilder.prototype.onlyAllowElements = function (elementSet) {\n        var e_1, _a;\n        var allowedElements = new Set();\n        var allowedElementPolicies = new Map();\n        try {\n            for (var elementSet_1 = __values(elementSet), elementSet_1_1 = elementSet_1.next(); !elementSet_1_1.done; elementSet_1_1 = elementSet_1.next()) {\n                var element = elementSet_1_1.value;\n                element = element.toUpperCase();\n                if (!this.sanitizerTable.isAllowedElement(element)) {\n                    throw new Error(\"Element: \".concat(element, \", is not allowed by html5_contract.textpb\"));\n                }\n                var elementPolicy = this.sanitizerTable.elementPolicies.get(element);\n                if (elementPolicy !== undefined) {\n                    allowedElementPolicies.set(element, elementPolicy);\n                }\n                else {\n                    allowedElements.add(element);\n                }\n            }\n        }\n        catch (e_1_1) { e_1 = { error: e_1_1 }; }\n        finally {\n            try {\n                if (elementSet_1_1 && !elementSet_1_1.done && (_a = elementSet_1.return)) _a.call(elementSet_1);\n            }\n            finally { if (e_1) throw e_1.error; }\n        }\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(allowedElements, allowedElementPolicies, this.sanitizerTable.allowedGlobalAttributes, this.sanitizerTable.globalAttributePolicies);\n        return this;\n    };\n    /**\n     * Builder option to restrict allowed attributes to a smaller subset.\n     *\n     * If the attribute isn't currently allowed then it won't be added.\n     */\n    HtmlSanitizerBuilder.prototype.onlyAllowAttributes = function (attributeSet) {\n        var e_2, _a, e_3, _b, e_4, _c;\n        var allowedGlobalAttributes = new Set();\n        var globalAttributePolicies = new Map();\n        var elementPolicies = new Map();\n        try {\n            for (var attributeSet_1 = __values(attributeSet), attributeSet_1_1 = attributeSet_1.next(); !attributeSet_1_1.done; attributeSet_1_1 = attributeSet_1.next()) {\n                var attribute = attributeSet_1_1.value;\n                if (this.sanitizerTable.allowedGlobalAttributes.has(attribute)) {\n                    allowedGlobalAttributes.add(attribute);\n                }\n                if (this.sanitizerTable.globalAttributePolicies.has(attribute)) {\n                    globalAttributePolicies.set(attribute, this.sanitizerTable.globalAttributePolicies.get(attribute));\n                }\n            }\n        }\n        catch (e_2_1) { e_2 = { error: e_2_1 }; }\n        finally {\n            try {\n                if (attributeSet_1_1 && !attributeSet_1_1.done && (_a = attributeSet_1.return)) _a.call(attributeSet_1);\n            }\n            finally { if (e_2) throw e_2.error; }\n        }\n        try {\n            for (var _d = __values(this.sanitizerTable\n                .elementPolicies.entries()), _e = _d.next(); !_e.done; _e = _d.next()) {\n                var _f = __read(_e.value, 2), elementName = _f[0], originalElementPolicy = _f[1];\n                var newElementPolicy = new Map();\n                try {\n                    for (var _g = (e_4 = void 0, __values(originalElementPolicy\n                        .entries())), _h = _g.next(); !_h.done; _h = _g.next()) {\n                        var _j = __read(_h.value, 2), attribute = _j[0], attributePolicy = _j[1];\n                        if (attributeSet.has(attribute)) {\n                            newElementPolicy.set(attribute, attributePolicy);\n                        }\n                    }\n                }\n                catch (e_4_1) { e_4 = { error: e_4_1 }; }\n                finally {\n                    try {\n                        if (_h && !_h.done && (_c = _g.return)) _c.call(_g);\n                    }\n                    finally { if (e_4) throw e_4.error; }\n                }\n                elementPolicies.set(elementName, newElementPolicy);\n            }\n        }\n        catch (e_3_1) { e_3 = { error: e_3_1 }; }\n        finally {\n            try {\n                if (_e && !_e.done && (_b = _d.return)) _b.call(_d);\n            }\n            finally { if (e_3) throw e_3.error; }\n        }\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(this.sanitizerTable.allowedElements, elementPolicies, allowedGlobalAttributes, globalAttributePolicies);\n        return this;\n    };\n    /**\n     * Allows the set of data attributes passed.\n     *\n     * These values must be prefixed with \"data-\"\n     *\n     * If called with onlyAllowElements or onlyAllowAttributes, those methods must\n     * be called first.\n     */\n    HtmlSanitizerBuilder.prototype.allowDataAttributes = function (attributes) {\n        var e_5, _a;\n        var allowedGlobalAttributes = new Set(this.sanitizerTable.allowedGlobalAttributes);\n        try {\n            for (var attributes_1 = __values(attributes), attributes_1_1 = attributes_1.next(); !attributes_1_1.done; attributes_1_1 = attributes_1.next()) {\n                var attribute = attributes_1_1.value;\n                if (attribute.indexOf('data-') !== 0) {\n                    throw new Error(\"data attribute: \".concat(attribute, \" does not begin with the prefix \\\"data-\\\"\"));\n                }\n                allowedGlobalAttributes.add(attribute);\n            }\n        }\n        catch (e_5_1) { e_5 = { error: e_5_1 }; }\n        finally {\n            try {\n                if (attributes_1_1 && !attributes_1_1.done && (_a = attributes_1.return)) _a.call(attributes_1);\n            }\n            finally { if (e_5) throw e_5.error; }\n        }\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(this.sanitizerTable.allowedElements, this.sanitizerTable.elementPolicies, allowedGlobalAttributes, this.sanitizerTable.globalAttributePolicies);\n        return this;\n    };\n    /**\n     * Preserves style attributes. Note that the sanitizer won't parse and\n     * sanitize the values but keep them as they are. In particular this means\n     * that the code will be able to call functions that could do undesirable\n     * things (e.g. `url` to trigger a network request), as well as any custom\n     * properties or functions defined by the application.\n     */\n    HtmlSanitizerBuilder.prototype.allowStyleAttributes = function () {\n        var globalAttributePolicies = new Map(this.sanitizerTable.globalAttributePolicies);\n        globalAttributePolicies.set('style', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_STYLE });\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(this.sanitizerTable.allowedElements, this.sanitizerTable.elementPolicies, this.sanitizerTable.allowedGlobalAttributes, globalAttributePolicies);\n        return this;\n    };\n    /**\n     * Preserves the class attribute on all elements. This means contents can\n     * adopt CSS styles from other page elements and possibly mask themselves as\n     * legitimate UI elements, which can lead to phishing.\n     */\n    HtmlSanitizerBuilder.prototype.allowClassAttributes = function () {\n        var globalAttributePolicies = new Map(this.sanitizerTable.globalAttributePolicies);\n        globalAttributePolicies.set('class', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP });\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(this.sanitizerTable.allowedElements, this.sanitizerTable.elementPolicies, this.sanitizerTable.allowedGlobalAttributes, globalAttributePolicies);\n        return this;\n    };\n    /**\n     * Preserves id attributes. This carries moderate risk as it allows an\n     * element to override other elements with the same ID.\n     */\n    HtmlSanitizerBuilder.prototype.allowIdAttributes = function () {\n        var globalAttributePolicies = new Map(this.sanitizerTable.globalAttributePolicies);\n        globalAttributePolicies.set('id', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP });\n        this.sanitizerTable = new sanitizer_table_1.SanitizerTable(this.sanitizerTable.allowedElements, this.sanitizerTable.elementPolicies, this.sanitizerTable.allowedGlobalAttributes, globalAttributePolicies);\n        return this;\n    };\n    HtmlSanitizerBuilder.prototype.build = function () {\n        if (this.calledBuild) {\n            throw new Error('this sanitizer has already called build');\n        }\n        this.calledBuild = true;\n        return new html_sanitizer_1.HtmlSanitizerImpl(this.sanitizerTable, secrets_1.secretToken);\n    };\n    return HtmlSanitizerBuilder;\n}());\nexports.HtmlSanitizerBuilder = HtmlSanitizerBuilder;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createInertFragment = void 0;\nvar element_1 = require(\"../../dom/elements/element\");\nvar html_impl_1 = require(\"../../internals/html_impl\");\n/**\n * Returns a fragment that contains the parsed HTML for `dirtyHtml` without\n * executing any of the potential payload.\n */\nfunction createInertFragment(dirtyHtml) {\n    var template = document.createElement('template');\n    // This call is only used to create an inert tree for the sanitizer to\n    // further process and is never returned directly to the caller. We can't use\n    // a reviewed conversion in order to avoid an import loop.\n    var temporarySafeHtml = (0, html_impl_1.createHtml)(dirtyHtml);\n    (0, element_1.setInnerHtml)(template, temporarySafeHtml);\n    return template.content;\n}\nexports.createInertFragment = createInertFragment;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.isElement = exports.isText = exports.getNodeName = void 0;\n/**\n * Library that provides safe getters for different node properties and\n * checks for clobbering.\n */\n/** Gets a reasonable nodeName, even for clobbered nodes. */\nfunction getNodeName(node) {\n    var nodeName = node.nodeName;\n    // If the property is clobbered, assume it is an `HTMLFormElement`.\n    return (typeof nodeName === 'string') ? nodeName : 'FORM';\n}\nexports.getNodeName = getNodeName;\n/** Returns true if the object passed is a Text node. */\nfunction isText(node) {\n    // The property cannot get clobbered on Text nodes.\n    return node.nodeType === Node.TEXT_NODE;\n}\nexports.isText = isText;\n/** Returns true if the object passed is an Element node. */\nfunction isElement(node) {\n    var nodeType = node.nodeType;\n    // If the property is clobbered, we can assume it is an `HTMLFormElement`, and\n    // thus an `Element`.\n    return (nodeType === Node.ELEMENT_NODE) || (typeof nodeType !== 'number');\n}\nexports.isElement = isElement;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.defaultSanitizerTable = void 0;\nvar sanitizer_table_1 = require(\"./sanitizer_table\");\n/**\n * GENERATED CODE, DO NOT MODIFY\n * This SanitizerTable was generated from the checked in html contract:\n *  webutil/html/types/codegen/html5_contract.textpb\n *\n * You can regenerate this file with:\n * webutil/html/types/codegen/update_generated_source_files.sh\n */\nexports.defaultSanitizerTable = new sanitizer_table_1.SanitizerTable(new Set([\n    'ARTICLE', 'SECTION', 'NAV', 'ASIDE', 'H1', 'H2',\n    'H3', 'H4', 'H5', 'H6', 'HEADER', 'FOOTER',\n    'ADDRESS', 'P', 'HR', 'PRE', 'BLOCKQUOTE', 'OL',\n    'UL', 'LH', 'LI', 'DL', 'DT', 'DD',\n    'FIGURE', 'FIGCAPTION', 'MAIN', 'DIV', 'EM', 'STRONG',\n    'SMALL', 'S', 'CITE', 'Q', 'DFN', 'ABBR',\n    'RUBY', 'RB', 'RT', 'RTC', 'RP', 'DATA',\n    'TIME', 'CODE', 'VAR', 'SAMP', 'KBD', 'SUB',\n    'SUP', 'I', 'B', 'U', 'MARK', 'BDI',\n    'BDO', 'SPAN', 'BR', 'WBR', 'INS', 'DEL',\n    'PICTURE', 'PARAM', 'TRACK', 'MAP', 'TABLE', 'CAPTION',\n    'COLGROUP', 'COL', 'TBODY', 'THEAD', 'TFOOT', 'TR',\n    'TD', 'TH', 'SELECT', 'DATALIST', 'OPTGROUP', 'OPTION',\n    'OUTPUT', 'PROGRESS', 'METER', 'FIELDSET', 'LEGEND', 'DETAILS',\n    'SUMMARY', 'MENU', 'DIALOG', 'SLOT', 'CANVAS', 'FONT',\n    'CENTER',\n]), new Map([\n    [\n        'A', new Map([\n            ['href', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n    [\n        'AREA', new Map([\n            ['href', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n    [\n        'LINK', new Map([\n            [\n                'href', {\n                    policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL,\n                    conditions: new Map([[\n                            'rel', new Set([\n                                'alternate',\n                                'author',\n                                'bookmark',\n                                'canonical',\n                                'cite',\n                                'help',\n                                'icon',\n                                'license',\n                                'next',\n                                'prefetch',\n                                'dns-prefetch',\n                                'prerender',\n                                'preconnect',\n                                'preload',\n                                'prev',\n                                'search',\n                                'subresource',\n                            ])\n                        ]])\n                }\n            ],\n        ])\n    ],\n    [\n        'SOURCE', new Map([\n            ['src', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n    [\n        'IMG', new Map([\n            ['src', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n    [\n        'VIDEO', new Map([\n            ['src', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n    [\n        'AUDIO', new Map([\n            ['src', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n        ])\n    ],\n]), new Set([\n    'title',\n    'aria-atomic',\n    'aria-autocomplete',\n    'aria-busy',\n    'aria-checked',\n    'aria-current',\n    'aria-disabled',\n    'aria-dropeffect',\n    'aria-expanded',\n    'aria-haspopup',\n    'aria-hidden',\n    'aria-invalid',\n    'aria-label',\n    'aria-level',\n    'aria-live',\n    'aria-multiline',\n    'aria-multiselectable',\n    'aria-orientation',\n    'aria-posinset',\n    'aria-pressed',\n    'aria-readonly',\n    'aria-relevant',\n    'aria-required',\n    'aria-selected',\n    'aria-setsize',\n    'aria-sort',\n    'aria-valuemax',\n    'aria-valuemin',\n    'aria-valuenow',\n    'aria-valuetext',\n    'alt',\n    'align',\n    'autocapitalize',\n    'autocomplete',\n    'autocorrect',\n    'autofocus',\n    'autoplay',\n    'bgcolor',\n    'border',\n    'cellpadding',\n    'cellspacing',\n    'checked',\n    'color',\n    'cols',\n    'colspan',\n    'controls',\n    'datetime',\n    'disabled',\n    'download',\n    'draggable',\n    'enctype',\n    'face',\n    'formenctype',\n    'frameborder',\n    'height',\n    'hreflang',\n    'hidden',\n    'ismap',\n    'label',\n    'lang',\n    'loop',\n    'max',\n    'maxlength',\n    'media',\n    'minlength',\n    'min',\n    'multiple',\n    'muted',\n    'nonce',\n    'open',\n    'placeholder',\n    'preload',\n    'rel',\n    'required',\n    'reversed',\n    'role',\n    'rows',\n    'rowspan',\n    'selected',\n    'shape',\n    'size',\n    'sizes',\n    'slot',\n    'span',\n    'spellcheck',\n    'start',\n    'step',\n    'summary',\n    'translate',\n    'type',\n    'valign',\n    'value',\n    'width',\n    'wrap',\n    'itemscope',\n    'itemtype',\n    'itemid',\n    'itemprop',\n    'itemref',\n]), new Map([\n    [\n        'dir', {\n            policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_NORMALIZE,\n            conditions: new Map([[\n                    'dir', new Set([\n                        'auto',\n                        'ltr',\n                        'rtl',\n                    ])\n                ]])\n        }\n    ],\n    [\n        'async', {\n            policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_NORMALIZE,\n            conditions: new Map([[\n                    'async', new Set([\n                        'async',\n                    ])\n                ]])\n        }\n    ],\n    ['cite', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n    [\n        'loading', {\n            policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_NORMALIZE,\n            conditions: new Map([[\n                    'loading', new Set([\n                        'eager',\n                        'lazy',\n                    ])\n                ]])\n        }\n    ],\n    ['poster', { policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_SANITIZE_URL }],\n    [\n        'target', {\n            policyAction: sanitizer_table_1.AttributePolicyAction.KEEP_AND_NORMALIZE,\n            conditions: new Map([[\n                    'target', new Set([\n                        '_self',\n                        '_blank',\n                    ])\n                ]])\n        }\n    ],\n]));\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.AttributePolicyAction = exports.SanitizerTable = void 0;\n/** Class for holding element and attribute policies used for sanitization. */\nvar SanitizerTable = /** @class */ (function () {\n    function SanitizerTable(allowedElements, elementPolicies, allowedGlobalAttributes, globalAttributePolicies) {\n        this.allowedElements = allowedElements;\n        this.elementPolicies = elementPolicies;\n        this.allowedGlobalAttributes = allowedGlobalAttributes;\n        this.globalAttributePolicies = globalAttributePolicies;\n    }\n    SanitizerTable.prototype.isAllowedElement = function (elementName) {\n        // Note: `HTMLFormElement`s are always dropped, supporting them is very\n        // costly because of the DOM clobberring they can cause. The additional code\n        // size required to properly work around DOM clobberring issues is large and\n        // shouldn't be put on every user of the sanitizer. Thoroughly review\n        // b/210975025 and the CLs linked there before you start allowing form\n        // elements.\n        return elementName.toLowerCase() !== 'form' &&\n            (this.allowedElements.has(elementName) ||\n                this.elementPolicies.has(elementName));\n    };\n    SanitizerTable.prototype.getAttributePolicy = function (attributeName, elementName) {\n        var elementPolicy = this.elementPolicies.get(elementName);\n        if (elementPolicy === null || elementPolicy === void 0 ? void 0 : elementPolicy.has(attributeName)) {\n            return elementPolicy.get(attributeName);\n        }\n        if (this.allowedGlobalAttributes.has(attributeName)) {\n            return { policyAction: AttributePolicyAction.KEEP };\n        }\n        var globalPolicy = this.globalAttributePolicies.get(attributeName);\n        return globalPolicy || { policyAction: AttributePolicyAction.DROP };\n    };\n    return SanitizerTable;\n}());\nexports.SanitizerTable = SanitizerTable;\n/**\n * Values derived from\n * https://godoc.corp.google.com/pkg/google3/third_party/safehtml/sanitizer/policy#AttributePolicy\n */\nvar AttributePolicyAction;\n(function (AttributePolicyAction) {\n    AttributePolicyAction[AttributePolicyAction[\"DROP\"] = 0] = \"DROP\";\n    AttributePolicyAction[AttributePolicyAction[\"KEEP\"] = 1] = \"KEEP\";\n    AttributePolicyAction[AttributePolicyAction[\"KEEP_AND_SANITIZE_URL\"] = 2] = \"KEEP_AND_SANITIZE_URL\";\n    AttributePolicyAction[AttributePolicyAction[\"KEEP_AND_NORMALIZE\"] = 3] = \"KEEP_AND_NORMALIZE\";\n    AttributePolicyAction[AttributePolicyAction[\"KEEP_AND_SANITIZE_STYLE\"] = 4] = \"KEEP_AND_SANITIZE_STYLE\";\n})(AttributePolicyAction = exports.AttributePolicyAction || (exports.AttributePolicyAction = {}));\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.blobUrlFromScript = exports.replaceFragment = exports.appendParams = exports.trustedResourceUrl = void 0;\nrequire(\"../environment/dev\");\nvar resource_url_impl_1 = require(\"../internals/resource_url_impl\");\nvar script_impl_1 = require(\"../internals/script_impl\");\nvar string_literal_1 = require(\"../internals/string_literal\");\n/**\n * Check whether the base url contains a valid origin,\n *\n * A string for an origin must contain only alphanumeric or any of the\n * following: `-.:`, and must not be an IP address. Remember that, as per the\n * documentation for TrustedResourceUrl, the origin must be trustworthy.\n *\n * @param base The base url that contains an origin.\n */\nfunction hasValidOrigin(base) {\n    if (!(/^https:\\/\\//.test(base) || /^\\/\\//.test(base))) {\n        return false;\n    }\n    var originStart = base.indexOf('//') + 2;\n    var originEnd = base.indexOf('/', originStart);\n    // If the base url only contains the prefix (e.g. //), or the slash\n    // for the origin is right after the prefix (e.g. ///), the origin is\n    // missing.\n    if (originEnd <= originStart) {\n        throw new Error(\"Can't interpolate data in a url's origin, \" +\n            \"Please make sure to fully specify the origin, terminated with '/'.\");\n    }\n    var origin = base.substring(originStart, originEnd);\n    if (!/^[0-9a-z.:-]+$/i.test(origin)) {\n        throw new Error('The origin contains unsupported characters.');\n    }\n    if (!/^[^:]*(:[0-9]+)?$/i.test(origin)) {\n        throw new Error('Invalid port number.');\n    }\n    if (!/(^|\\.)[a-z][^.]*$/i.test(origin)) {\n        throw new Error('The top-level domain must start with a letter.');\n    }\n    return true;\n}\n/**\n * Check whether the base url contains a valid about url at its beginning.\n *\n * An about url is either exactly 'about:blank' or 'about:blank#<str>' where\n * <str> can be an arbitrary string.\n *\n * @param base The base url.\n */\nfunction isValidAboutUrl(base) {\n    if (!/^about:blank/.test(base)) {\n        return false;\n    }\n    if (base !== 'about:blank' && !/^about:blank#/.test(base)) {\n        throw new Error('The about url is invalid.');\n    }\n    return true;\n}\n/**\n * Check whether the base url contains a valid path start at its beginning.\n *\n * A valid path start is either a '/' or a '/' followed by at least one\n * character that is not '/' or '\\'.\n *\n * @param base The base url.\n */\nfunction isValidPathStart(base) {\n    if (!/^\\//.test(base)) {\n        return false;\n    }\n    if ((base === '/') ||\n        (base.length > 1 && base[1] !== '/' && base[1] !== '\\\\')) {\n        return true;\n    }\n    throw new Error('The path start in the url is invalid.');\n}\n/**\n * Builds TrustedResourceUrl from a template literal.\n *\n * This factory is a template literal tag function. It should be called with\n * a template literal, with or without embedded expressions. For example,\n *               trustedResourceUrl`//example.com/${bar}`;\n * or\n *               trustedResourceUrl`//example.com`;\n *\n * When this function is called with a template literal without any embedded\n * expressions, the template string may contain anything as the whole URL is\n * a compile-time string constant.\n *\n * When this function is called with a template literal that contains embedded\n * expressions, the template must start with one of the following:\n * - `https://<origin>/`\n * - `//<origin>/`\n * - `/<pathStart>`\n * - `about:blank`\n * - `data:`\n *\n * `<origin>` must contain only alphanumeric or any of the following: `-.:`.\n * Remember that, as per the documentation for TrustedResourceUrl, the origin\n * must be trustworthy. An origin of \"example.com\" could be set with this\n * method, but would tie the security of your site to the security of\n * example.com. Similarly, formats that potentially cover redirects hosted\n * on a trusted origin are problematic, since that could lead to untrusted\n * origins.\n *\n * `<pathStart>` is either an empty string, or a non empty string that does not\n * start with '/' or '\\'.\n * In other words, `/<pathStart>` is either a '/' or a\n * '/' followed by at least one character that is not '/' or '\\'.\n *\n * `data:` (data URL) does not allow embedded expressions in the template\n * literal input.\n *\n * All embedded expressions are URL encoded when they are interpolated. Do not\n * embed expressions that are already URL encoded as they will be double encoded\n * by the builder.\n *\n * @param templateObj This contains the literal part of the template literal.\n * @param rest This represents the template's embedded expressions.\n */\nfunction trustedResourceUrl(templateObj) {\n    var rest = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        rest[_i - 1] = arguments[_i];\n    }\n    // Check if templateObj is actually from a template literal.\n    if (process.env.NODE_ENV !== 'production') {\n        (0, string_literal_1.assertIsTemplateObject)(templateObj, true, 'trustedResourceUrl is a template literal tag function and ' +\n            'can only be called as such (e.g. trustedResourceUrl`/somepath.js`)');\n    }\n    if (rest.length === 0) {\n        return (0, resource_url_impl_1.createResourceUrl)(templateObj[0]);\n    }\n    var base = templateObj[0].toLowerCase();\n    if (process.env.NODE_ENV !== 'production') {\n        if (/^data:/.test(base)) {\n            throw new Error('Data URLs cannot have expressions in the template literal input.');\n        }\n        if (!hasValidOrigin(base) && !isValidPathStart(base) &&\n            !isValidAboutUrl(base)) {\n            throw new Error('Trying to interpolate expressions in an unsupported url format.');\n        }\n    }\n    var urlParts = [templateObj[0]];\n    for (var i = 0; i < rest.length; i++) {\n        urlParts.push(encodeURIComponent(rest[i]));\n        urlParts.push(templateObj[i + 1]);\n    }\n    return (0, resource_url_impl_1.createResourceUrl)(urlParts.join(''));\n}\nexports.trustedResourceUrl = trustedResourceUrl;\n/**\n * Creates a new TrustedResourceUrl with params added to the URL's search\n * parameters.\n *\n * @param params What to add to the URL. Parameters with value `null` or\n * `undefined` are skipped. Both keys and values will be encoded. Do not pass\n * pre-encoded values as this will result them being double encoded. If the\n * value is an array then the same parameter is added for every element in the\n * array.\n */\nfunction appendParams(trustedUrl, params) {\n    var url = (0, resource_url_impl_1.unwrapResourceUrl)(trustedUrl).toString();\n    if (/#/.test(url)) {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = \"Found a hash in url (\".concat(url, \"), appending not supported\");\n        }\n        throw new Error(message);\n    }\n    var separator = /\\?/.test(url) ? '&' : '?';\n    // for-of has a big polyfill.\n    // tslint:disable-next-line:ban-iterable-foreach\n    params.forEach(function (value, key) {\n        var values = (value instanceof Array) ? value : [value];\n        for (var i = 0; i < values.length; i++) {\n            var v = values[i];\n            if (v === null || v === undefined) {\n                continue;\n            }\n            url += separator + encodeURIComponent(key) + '=' +\n                encodeURIComponent(String(v));\n            separator = '&';\n        }\n    });\n    return (0, resource_url_impl_1.createResourceUrl)(url);\n}\nexports.appendParams = appendParams;\nvar BEFORE_FRAGMENT_REGEXP = /[^#]*/;\n/**\n * Creates a new TrustedResourceUrl based on an existing one but with the\n * addition of a fragment (the part after `#`). If the URL already has a\n * fragment, it is replaced with the new one.\n * @param fragment The fragment to add to the URL, verbatim, without the leading\n * `#`. No additional escaping is applied.\n */\nfunction replaceFragment(trustedUrl, fragment) {\n    var urlString = (0, resource_url_impl_1.unwrapResourceUrl)(trustedUrl).toString();\n    return (0, resource_url_impl_1.createResourceUrl)(BEFORE_FRAGMENT_REGEXP.exec(urlString)[0] + '#' + fragment);\n}\nexports.replaceFragment = replaceFragment;\n/**\n * Creates a `TrustedResourceUrl` by generating a `Blob` from a\n * `SafeScript` and then calling `URL.createObjectURL` with that `Blob`.\n *\n * Caller must call `URL.revokeObjectUrl()` on the stringified url to\n * release the underlying `Blob`.\n */\nfunction blobUrlFromScript(safeScript) {\n    var scriptContent = (0, script_impl_1.unwrapScript)(safeScript).toString();\n    var blob = new Blob([scriptContent], { type: 'text/javascript' });\n    return (0, resource_url_impl_1.createResourceUrl)(URL.createObjectURL(blob));\n}\nexports.blobUrlFromScript = blobUrlFromScript;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.safeScriptWithArgs = exports.scriptFromJson = exports.concatScripts = exports.safeScript = void 0;\nrequire(\"../environment/dev\");\nvar script_impl_1 = require(\"../internals/script_impl\");\nvar string_literal_1 = require(\"../internals/string_literal\");\n/**\n * Creates a SafeScript object from a template literal (without any embedded\n * expressions).\n *\n * This function is a template literal tag function. It should be called with\n * a template literal that does not contain any expressions. For example,\n *                           safeScript`foo`;\n *\n * @param templateObj This contains the literal part of the template literal.\n */\nfunction safeScript(templateObj) {\n    if (process.env.NODE_ENV !== 'production') {\n        (0, string_literal_1.assertIsTemplateObject)(templateObj, false, 'safeScript is a template literal tag function ' +\n            'that only accepts template literals without expressions. ' +\n            'For example, safeScript`foo`;');\n    }\n    return (0, script_impl_1.createScript)(templateObj[0]);\n}\nexports.safeScript = safeScript;\n/** Creates a `SafeScript` value by concatenating multiple `SafeScript`s. */\nfunction concatScripts(scripts) {\n    return (0, script_impl_1.createScript)(scripts.map(script_impl_1.unwrapScript).join(''));\n}\nexports.concatScripts = concatScripts;\n/**\n * Converts a serializable value into JSON that is safe to interpolate into a\n * script context. In particular it escapes < characters so that a value of\n * \"</script>\" doesn't break out of the context.\n * @param value The value to serialize.\n */\nfunction scriptFromJson(value) {\n    return (0, script_impl_1.createScript)(JSON.stringify(value).replace(/</g, '\\\\x3c'));\n}\nexports.scriptFromJson = scriptFromJson;\n/**\n * Creates a `SafeScript` object from a template literal (without any embedded\n * expressions) along with additional arguments that the script should have\n * access to. These arguments will be JSON-encoded and passed to the script as\n * a function call.\n * @example\n * ```ts\n * safeScriptWithArgs`function (name, props) {\n *  console.log(name + ' is ' + props.age);\n * }`('Bob', { 'age': 42 })\n * ```\n * would return a `SafeScript` that represents the following code:\n * ```js\n * (function (name, props) {\n *  console.log(name + ' is ' + props.age);\n * })(\"Bob\",{\"age\":42})\n * ```\n * @note Be careful when passing objects as arguments, as unquoted property\n * names may be changed during compilation.\n * @param templateObj This contains the literal part of the template literal.\n * @param emptyArgs Expressions that evaluate to the empty string to enable\n *     inline comments.\n */\nfunction safeScriptWithArgs(templateObj) {\n    var emptyArgs = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        emptyArgs[_i - 1] = arguments[_i];\n    }\n    if (process.env.NODE_ENV !== 'production') {\n        if (emptyArgs.some(function (a) { return a !== ''; })) {\n            throw new Error('safeScriptWithArgs only allows empty string expressions ' +\n                'to enable inline comments.');\n        }\n        (0, string_literal_1.assertIsTemplateObject)(templateObj, true, 'safeScriptWithArgs is a template literal tag function ' +\n            'that only accepts template literals. ' +\n            'For example, safeScriptWithArgs`foo`;');\n    }\n    return function () {\n        var argValues = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            argValues[_i] = arguments[_i];\n        }\n        var values = argValues.map(function (v) { return scriptFromJson(v).toString(); });\n        return (0, script_impl_1.createScript)(\"(\".concat(templateObj.join(''), \")(\").concat(values.join(','), \")\"));\n    };\n}\nexports.safeScriptWithArgs = safeScriptWithArgs;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.SECURITY_SENSITIVE_ATTRIBUTES = void 0;\n// AUTOGENERATED. DO NOT EDIT.\n/**\n * Security sensitive attribute names that should not be set through\n * `setAttribute` or similar functions.\n */\nexports.SECURITY_SENSITIVE_ATTRIBUTES = [\n    'href',\n    'rel',\n    'src',\n    'srcdoc',\n    'action',\n    'formaction',\n    'sandbox',\n    'cite',\n    'poster',\n    'icon',\n];\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.concatStyles = exports.safeStyle = void 0;\nrequire(\"../environment/dev\");\nvar string_literal_1 = require(\"../internals/string_literal\");\nvar style_impl_1 = require(\"../internals/style_impl\");\n/**\n * Creates a SafeStyle object from a template literal (without any embedded\n * expressions).\n *\n * ` style` should be in the format\n * ` name: value; [name: value; ...]` and must not have any < or >\n * characters in it. This is so that SafeStyle's contract is preserved,\n * allowing the SafeStyle to correctly be interpreted as a sequence of CSS\n * declarations and without affecting the syntactic structure of any\n * surrounding CSS and HTML.\n *\n * This function is a template literal tag function. It should be called with\n * a template literal that does not contain any expressions. For example,\n *                          safeStyle`foo`;\n * This function first checks if it is called with a literal template, and\n * then performs basic sanity checks on the format of ` style`\n * but does not constrain the format of ` name} and {@code value`, except\n * for disallowing tag characters.\n *\n * @param templateObj This contains the literal part of the template literal.\n */\nfunction safeStyle(templateObj) {\n    if (process.env.NODE_ENV !== 'production') {\n        (0, string_literal_1.assertIsTemplateObject)(templateObj, false, 'safeStyle is a template literal tag function ' +\n            'that only accepts template literals without expressions. ' +\n            'For example, safeStyle`foo`;');\n    }\n    var style = templateObj[0];\n    if (process.env.NODE_ENV !== 'production') {\n        if (/[<>]/.test(style)) {\n            throw new Error('Forbidden characters in style string: ' + style);\n        }\n        if (!/;$/.test(style)) {\n            throw new Error('Style string does not end with \";\": ' + style);\n        }\n        if (!/:/.test(style)) {\n            throw new Error('Style string should contain one or more \":\": ' + style);\n        }\n    }\n    return (0, style_impl_1.createStyle)(style);\n}\nexports.safeStyle = safeStyle;\n/** Creates a `SafeStyle` value by concatenating multiple `SafeStyle`s. */\nfunction concatStyles(styles) {\n    return (0, style_impl_1.createStyle)(styles.map(style_impl_1.unwrapStyle).join(''));\n}\nexports.concatStyles = concatStyles;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.concatStyleSheets = exports.safeStyleSheet = void 0;\nrequire(\"../environment/dev\");\nvar string_literal_1 = require(\"../internals/string_literal\");\nvar style_sheet_impl_1 = require(\"../internals/style_sheet_impl\");\n/**\n * Creates a SafeStyleSheet object from a template literal (without any\n * embedded expressions).\n *\n * This function is a template literal tag function. It should be called with\n * a template literal that does not contain any expressions. For example,\n *                         safeStyleSheet`foo`;\n * The argument must not have any < or > characters in it. This is so that\n * SafeStyleSheet's contract is preserved, allowing the SafeStyleSheet to\n * correctly be interpreted as a sequence of CSS declarations and without\n * affecting the syntactic structure of any surrounding CSS and HTML.\n *\n * @param templateObj This contains the literal part of the template literal.\n */\nfunction safeStyleSheet(templateObj) {\n    if (process.env.NODE_ENV !== 'production') {\n        (0, string_literal_1.assertIsTemplateObject)(templateObj, false, 'safeStyleSheet is a template literal tag ' +\n            'function that only accepts template literals without ' +\n            'expressions. For example, safeStyleSheet`foo`;');\n    }\n    var styleSheet = templateObj[0];\n    if (process.env.NODE_ENV !== 'production') {\n        if (/[<>]/.test(styleSheet)) {\n            throw new Error('Forbidden characters in styleSheet string: ' + styleSheet);\n        }\n    }\n    return (0, style_sheet_impl_1.createStyleSheet)(styleSheet);\n}\nexports.safeStyleSheet = safeStyleSheet;\n/**\n * Creates a `SafeStyleSheet` value by concatenating multiple `SafeStyleSheet`s.\n */\nfunction concatStyleSheets(sheets) {\n    return (0, style_sheet_impl_1.createStyleSheet)(sheets.map(style_sheet_impl_1.unwrapStyleSheet).join(''));\n}\nexports.concatStyleSheets = concatStyleSheets;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.restrictivelySanitizeUrl = exports.unwrapUrlOrSanitize = exports.sanitizeJavascriptUrl = void 0;\n/**\n * @fileoverview Provides functions to enforce the SafeUrl contract at the sink\n * level.\n */\nrequire(\"../environment/dev\");\nfunction extractScheme(url) {\n    var parsedUrl;\n    try {\n        parsedUrl = new URL(url);\n    }\n    catch (e) {\n        // According to https://url.spec.whatwg.org/#constructors, the URL\n        // constructor with one parameter throws if `url` is not absolute. In this\n        // case, we are sure that no explicit scheme (javascript: ) is set.\n        // This can also be a URL parsing error, but in this case the URL won't be\n        // run anyway.\n        return 'https:';\n    }\n    return parsedUrl.protocol;\n}\n// We can't use an ES6 Set here because gws somehow depends on this code and\n// doesn't want to pay the cost of a polyfill.\nvar ALLOWED_SCHEMES = ['data:', 'http:', 'https:', 'mailto:', 'ftp:'];\n/**\n * Checks that the URL scheme is not javascript.\n * The URL parsing relies on the URL API in browsers that support it.\n * @param url The URL to sanitize for a SafeUrl sink.\n * @return undefined if url has a javascript: scheme, the original URL\n *     otherwise.\n */\nfunction sanitizeJavascriptUrl(url) {\n    var parsedScheme = extractScheme(url);\n    if (parsedScheme === 'javascript:') {\n        if (process.env.NODE_ENV !== 'production') {\n            console.error(\"A URL with content '\".concat(url, \"' was sanitized away.\"));\n        }\n        return undefined;\n    }\n    return url;\n}\nexports.sanitizeJavascriptUrl = sanitizeJavascriptUrl;\n/**\n * Adapter to sanitize string URLs in DOM sink wrappers.\n * @return undefined if the URL was sanitized.\n */\nfunction unwrapUrlOrSanitize(url) {\n    return sanitizeJavascriptUrl(url);\n}\nexports.unwrapUrlOrSanitize = unwrapUrlOrSanitize;\n/**\n * Sanitizes a URL restrictively.\n * This sanitizer protects against XSS and potentially other uncommon and\n * undesirable schemes that an attacker could use for e.g. phishing (tel:,\n * callto: ssh: etc schemes). This sanitizer is primarily meant to be used by\n * the HTML sanitizer.\n */\nfunction restrictivelySanitizeUrl(url) {\n    var parsedScheme = extractScheme(url);\n    if (parsedScheme !== undefined &&\n        ALLOWED_SCHEMES.indexOf(parsedScheme.toLowerCase()) !== -1) {\n        return url;\n    }\n    return 'about:invalid#zClosurez';\n}\nexports.restrictivelySanitizeUrl = restrictivelySanitizeUrl;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setHref = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * Sets the Href attribute from the given Url.\n */\nfunction setHref(anchor, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        anchor.href = sanitizedUrl;\n    }\n}\nexports.setHref = setHref;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setHref = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * Sets the Href attribute from the given Url.\n */\nfunction setHref(area, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        area.href = sanitizedUrl;\n    }\n}\nexports.setHref = setHref;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setFormaction = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * Sets the Formaction attribute from the given Url.\n */\nfunction setFormaction(button, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        button.formAction = sanitizedUrl;\n    }\n}\nexports.setFormaction = setFormaction;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setPrefixedAttribute = exports.buildPrefixedAttributeSetter = exports.insertAdjacentHtml = exports.setCssText = exports.setOuterHtml = exports.setInnerHtml = void 0;\n/**\n * @fileoverview This contains safe wrappers for properties that aren't specific\n * to one kind of HTMLElement (like innerHTML), plus other setters and functions\n * that are not tied to elements (like location.href or Worker constructor).\n */\nvar attribute_impl_1 = require(\"../../internals/attribute_impl\");\nvar html_impl_1 = require(\"../../internals/html_impl\");\nvar style_impl_1 = require(\"../../internals/style_impl\");\n/**\n * Safely set {@link Element.innerHTML} on a given ShadowRoot or Element which\n * may not be a `<script>` element or a `<style>` element.\n */\nfunction setInnerHtml(elOrRoot, v) {\n    if (isElement(elOrRoot)) {\n        throwIfScriptOrStyle(elOrRoot);\n    }\n    elOrRoot.innerHTML = (0, html_impl_1.unwrapHtml)(v);\n}\nexports.setInnerHtml = setInnerHtml;\n/**\n * Safely set {@link Element.outerHTML} for the given Element.\n */\nfunction setOuterHtml(e, v) {\n    var parent = e.parentElement;\n    if (parent !== null) {\n        throwIfScriptOrStyle(parent);\n    }\n    e.outerHTML = (0, html_impl_1.unwrapHtml)(v);\n}\nexports.setOuterHtml = setOuterHtml;\n/**\n * Set `ElementCSSInlineStyle.cssText` for the given `ElementCSSInlineStyle`.\n */\nfunction setCssText(e, v) {\n    e.style.cssText = (0, style_impl_1.unwrapStyle)(v);\n}\nexports.setCssText = setCssText;\n/**\n * Safely call {@link Element.insertAdjacentHTML} for the given Element.\n */\nfunction insertAdjacentHtml(element, position, v) {\n    var tagContext = (position === 'beforebegin' || position === 'afterend') ?\n        element.parentElement :\n        element;\n    if (tagContext !== null) {\n        throwIfScriptOrStyle(tagContext);\n    }\n    element.insertAdjacentHTML(position, (0, html_impl_1.unwrapHtml)(v));\n}\nexports.insertAdjacentHtml = insertAdjacentHtml;\n/**\n * Given a set of known-to-be-safe prefixes (e.g., \"data-\", \"aria-\", \"js\"),\n * return a setter function that allows you to set attributes on an element,\n * as long as the names of the attributes to be set has one of the prefixes.\n *\n * The returned setter ensures that setting any dangerous attribute, e.g.,\n * \"src\", \"href\" will cause an exception. This is intended to be used as the\n * safe alterantive of `Element#setAttribute`, when applications need to set\n * attributes that do not have security implications and do not have a\n * corresponding DOM property.\n */\nfunction buildPrefixedAttributeSetter(prefix) {\n    var otherPrefixes = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        otherPrefixes[_i - 1] = arguments[_i];\n    }\n    var prefixes = __spreadArray([prefix], __read(otherPrefixes), false);\n    return function (e, attr, value) {\n        setPrefixedAttribute(prefixes, e, attr, value);\n    };\n}\nexports.buildPrefixedAttributeSetter = buildPrefixedAttributeSetter;\n/**\n * The safe alternative to Element#setAttribute. The function takes a list of\n * `SafeAttributePrefix`, making developer intention explicit. The attribute\n * to be set must has one of the safe prefixes, otherwise the function throws\n * an Error.\n */\nfunction setPrefixedAttribute(attrPrefixes, e, attr, value) {\n    if (attrPrefixes.length === 0) {\n        throw new Error('No prefixes are provided');\n    }\n    var prefixes = attrPrefixes.map(function (s) { return (0, attribute_impl_1.unwrapAttributePrefix)(s); });\n    var attrLower = attr.toLowerCase();\n    if (prefixes.every(function (p) { return attrLower.indexOf(p) !== 0; })) {\n        throw new Error(\"Attribute \\\"\".concat(attr, \"\\\" does not match any of the allowed prefixes.\"));\n    }\n    e.setAttribute(attr, value);\n}\nexports.setPrefixedAttribute = setPrefixedAttribute;\nfunction throwIfScriptOrStyle(element) {\n    if (element.tagName.toLowerCase() === 'script') {\n        throw new Error('Use setTextContent with a SafeScript.');\n    }\n    else if (element.tagName.toLowerCase() === 'style') {\n        throw new Error('Use setTextContent with a SafeStyleSheet.');\n    }\n}\nfunction isElement(elOrRoot) {\n    return elOrRoot.tagName !== undefined;\n}\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setSrc = void 0;\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\n/**\n * Sets the Src attribute from the given SafeUrl.\n */\nfunction setSrc(embedEl, url) {\n    embedEl.src = (0, resource_url_impl_1.unwrapResourceUrl)(url);\n}\nexports.setSrc = setSrc;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setAction = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * Sets the Action attribute from the given Url.\n */\nfunction setAction(form, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        form.action = sanitizedUrl;\n    }\n}\nexports.setAction = setAction;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setSrcdoc = exports.setSrc = void 0;\n/**\n * @fileoverview Safe iframe helpers and go/intents-for-iframes-for-closure\n */\nvar html_impl_1 = require(\"../../internals/html_impl\");\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\n/** Sets the Src attribute using a TrustedResourceUrl */\nfunction setSrc(iframe, v) {\n    iframe.src = (0, resource_url_impl_1.unwrapResourceUrl)(v).toString();\n}\nexports.setSrc = setSrc;\n/** Sets the Srcdoc attribute using a SafeHtml */\nfunction setSrcdoc(iframe, v) {\n    iframe.srcdoc = (0, html_impl_1.unwrapHtml)(v);\n}\nexports.setSrcdoc = setSrcdoc;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setFormaction = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * Sets the Formaction attribute from the given Url.\n */\nfunction setFormaction(input, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        input.formAction = sanitizedUrl;\n    }\n}\nexports.setFormaction = setFormaction;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setHrefAndRel = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\nvar SAFE_URL_REL_VALUES = [\n    'alternate',\n    'author',\n    'bookmark',\n    'canonical',\n    'cite',\n    'help',\n    'icon',\n    'license',\n    'next',\n    'prefetch',\n    'dns-prefetch',\n    'prerender',\n    'preconnect',\n    'preload',\n    'prev',\n    'search',\n    'subresource',\n];\nfunction setHrefAndRel(link, url, rel) {\n    if (url instanceof resource_url_impl_1.TrustedResourceUrl) {\n        link.href = (0, resource_url_impl_1.unwrapResourceUrl)(url).toString();\n    }\n    else {\n        if (SAFE_URL_REL_VALUES.indexOf(rel) === -1) {\n            throw new Error(\"TrustedResourceUrl href attribute required with rel=\\\"\".concat(rel, \"\\\"\"));\n        }\n        var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n        if (sanitizedUrl === undefined) {\n            return;\n        }\n        link.href = sanitizedUrl;\n    }\n    link.rel = rel;\n}\nexports.setHrefAndRel = setHrefAndRel;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setData = void 0;\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\n/** Sets the data attribute using a TrustedResourceUrl */\nfunction setData(obj, v) {\n    obj.data = (0, resource_url_impl_1.unwrapResourceUrl)(v);\n}\nexports.setData = setData;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setSrc = exports.setTextContent = void 0;\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\nvar script_impl_1 = require(\"../../internals/script_impl\");\n/** Returns CSP nonce, if set for any script tag. */\nfunction getScriptNonceFromWindow(win) {\n    var _a;\n    var doc = win.document;\n    // document.querySelector can be undefined in non-browser environments.\n    var script = (_a = doc.querySelector) === null || _a === void 0 ? void 0 : _a.call(doc, 'script[nonce]');\n    if (script) {\n        // Try to get the nonce from the IDL property first, because browsers that\n        // implement additional nonce protection features (currently only Chrome) to\n        // prevent nonce stealing via CSS do not expose the nonce via attributes.\n        // See https://github.com/whatwg/html/issues/2369\n        return script['nonce'] || script.getAttribute('nonce') || '';\n    }\n    return '';\n}\n/** Propagates CSP nonce to dynamically created scripts. */\nfunction setNonceForScriptElement(script) {\n    var win = script.ownerDocument && script.ownerDocument.defaultView;\n    var nonce = getScriptNonceFromWindow(win || window);\n    if (nonce) {\n        script.setAttribute('nonce', nonce);\n    }\n}\n/** Sets textContent from the given SafeScript. */\nfunction setTextContent(script, v) {\n    script.textContent = (0, script_impl_1.unwrapScript)(v);\n    setNonceForScriptElement(script);\n}\nexports.setTextContent = setTextContent;\n/** Sets the Src attribute using a TrustedResourceUrl */\nfunction setSrc(script, v) {\n    script.src = (0, resource_url_impl_1.unwrapResourceUrl)(v);\n    setNonceForScriptElement(script);\n}\nexports.setSrc = setSrc;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.setTextContent = void 0;\nvar style_sheet_impl_1 = require(\"../../internals/style_sheet_impl\");\n/** Safe setters for `HTMLStyleElement`s. */\nfunction setTextContent(elem, safeStyleSheet) {\n    elem.textContent = (0, style_sheet_impl_1.unwrapStyleSheet)(safeStyleSheet);\n}\nexports.setTextContent = setTextContent;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.execCommandInsertHtml = exports.execCommand = exports.write = void 0;\nvar html_impl_1 = require(\"../../internals/html_impl\");\n/**\n * write safely calls {@link Document.write} on the given {@link Document} with\n * the given {@link SafeHtml}.\n */\nfunction write(doc, text) {\n    doc.write((0, html_impl_1.unwrapHtml)(text));\n}\nexports.write = write;\n/**\n * Safely calls {@link Document.execCommand}. When command is insertHtml, a\n * SafeHtml must be passed in as value.\n */\nfunction execCommand(doc, command, value) {\n    var commandString = String(command);\n    var valueArgument = value;\n    if (commandString.toLowerCase() === 'inserthtml') {\n        valueArgument = (0, html_impl_1.unwrapHtml)(value);\n    }\n    return doc.execCommand(commandString, /* showUi= */ false, valueArgument);\n}\nexports.execCommand = execCommand;\n/**\n * Safely calls {@link Document.execCommand}('insertHtml').\n * @deprecated Use safeDocument.execCommand.\n */\nfunction execCommandInsertHtml(doc, html) {\n    return doc.execCommand('insertHTML', /* showUi= */ false, (0, html_impl_1.unwrapHtml)(html));\n}\nexports.execCommandInsertHtml = execCommandInsertHtml;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.parseFromString = exports.parseHtml = void 0;\nvar html_impl_1 = require(\"../../internals/html_impl\");\n/** Safely parses a string using the HTML parser. */\nfunction parseHtml(parser, html) {\n    return parseFromString(parser, html, 'text/html');\n}\nexports.parseHtml = parseHtml;\n/** Safely parses a string using the HTML or XML parser. */\nfunction parseFromString(parser, content, contentType) {\n    return parser.parseFromString((0, html_impl_1.unwrapHtml)(content), contentType);\n}\nexports.parseFromString = parseFromString;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.globalEval = void 0;\nvar script_impl_1 = require(\"../../internals/script_impl\");\n/**\n * Evaluates a SafeScript value in the given scope using eval.\n *\n * Strongly consider avoiding this, as eval blocks CSP adoption and does not\n * benefit from compiler optimizations.\n */\nfunction globalEval(win, script) {\n    var trustedScript = (0, script_impl_1.unwrapScript)(script);\n    var result = win.eval(trustedScript);\n    if (result === trustedScript) {\n        // https://crbug.com/1024786 manifesting in workers.\n        result = win.eval(trustedScript.toString());\n    }\n    return result;\n}\nexports.globalEval = globalEval;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assign = exports.replace = exports.setHref = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * setHref safely sets {@link Location.href} on the given {@link Location} with\n * given {@link Url}.\n */\nfunction setHref(loc, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        loc.href = sanitizedUrl;\n    }\n}\nexports.setHref = setHref;\n/**\n * replace safely calls {@link Location.replace} on the given {@link Location}\n * with given {@link Url}.\n */\nfunction replace(loc, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        loc.replace(sanitizedUrl);\n    }\n}\nexports.replace = replace;\n/**\n * assign safely calls {@link Location.assign} on the given {@link Location}\n * with given {@link Url}.\n */\nfunction assign(loc, url) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        loc.assign(sanitizedUrl);\n    }\n}\nexports.assign = assign;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.createContextualFragment = void 0;\nvar html_impl_1 = require(\"../../internals/html_impl\");\n/** Safely creates a contextualFragment. */\nfunction createContextualFragment(range, html) {\n    return range.createContextualFragment((0, html_impl_1.unwrapHtml)(html));\n}\nexports.createContextualFragment = createContextualFragment;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.register = void 0;\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\n/** Safely registers a service worker by URL */\nfunction register(container, scriptURL, options) {\n    return container.register((0, resource_url_impl_1.unwrapResourceUrl)(scriptURL), options);\n}\nexports.register = register;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.open = void 0;\nvar url_sanitizer_1 = require(\"../../builders/url_sanitizer\");\n/**\n * open calls {@link Window.open} on the given {@link Window}, given a\n * target {@link Url}.\n */\nfunction open(win, url, target, features) {\n    var sanitizedUrl = (0, url_sanitizer_1.unwrapUrlOrSanitize)(url);\n    if (sanitizedUrl !== undefined) {\n        return win.open(sanitizedUrl, target, features);\n    }\n    return null;\n}\nexports.open = open;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __read = (this && this.__read) || function (o, n) {\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\n    if (!m) return o;\n    var i = m.call(o), r, ar = [], e;\n    try {\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\n    }\n    catch (error) { e = { error: error }; }\n    finally {\n        try {\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\n        }\n        finally { if (e) throw e.error; }\n    }\n    return ar;\n};\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.importScripts = exports.createShared = exports.create = void 0;\nvar resource_url_impl_1 = require(\"../../internals/resource_url_impl\");\n/**\n * Safely creates a Web Worker.\n *\n * Example usage:\n *   const trustedResourceUrl = trustedResourceUrl`/safe_script.js`;\n *   safedom.safeWorker.create(trustedResourceUrl);\n * which is a safe alternative to\n *   new Worker(url);\n * The latter can result in loading untrusted code.\n */\nfunction create(url, options) {\n    return new Worker((0, resource_url_impl_1.unwrapResourceUrl)(url), options);\n}\nexports.create = create;\n/** Safely creates a shared Web Worker. */\nfunction createShared(url, options) {\n    return new SharedWorker((0, resource_url_impl_1.unwrapResourceUrl)(url), options);\n}\nexports.createShared = createShared;\n/** Safely calls importScripts */\nfunction importScripts(scope) {\n    var urls = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        urls[_i - 1] = arguments[_i];\n    }\n    scope.importScripts.apply(scope, __spreadArray([], __read(urls.map(function (url) { return (0, resource_url_impl_1.unwrapResourceUrl)(url); })), false));\n}\nexports.importScripts = importScripts;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.safeWorker = exports.safeWindow = exports.safeServiceWorkerContainer = exports.safeRange = exports.safeLocation = exports.safeGlobal = exports.safeDomParser = exports.safeDocument = exports.safeStyleEl = exports.safeScriptEl = exports.safeObjectEl = exports.safeLinkEl = exports.safeInputEl = exports.safeIframeEl = exports.safeFormEl = exports.safeEmbedEl = exports.safeElement = exports.safeButtonEl = exports.safeAreaEl = exports.safeAnchorEl = void 0;\n/**\n * @fileoverview This file re-exports all of the wrappers to ensure that we have\n * a clearly defined interface.\n */\nexports.safeAnchorEl = __importStar(require(\"./elements/anchor\"));\nexports.safeAreaEl = __importStar(require(\"./elements/area\"));\nexports.safeButtonEl = __importStar(require(\"./elements/button\"));\nexports.safeElement = __importStar(require(\"./elements/element\"));\nexports.safeEmbedEl = __importStar(require(\"./elements/embed\"));\nexports.safeFormEl = __importStar(require(\"./elements/form\"));\nexports.safeIframeEl = __importStar(require(\"./elements/iframe\"));\nexports.safeInputEl = __importStar(require(\"./elements/input\"));\nexports.safeLinkEl = __importStar(require(\"./elements/link\"));\nexports.safeObjectEl = __importStar(require(\"./elements/object\"));\nexports.safeScriptEl = __importStar(require(\"./elements/script\"));\nexports.safeStyleEl = __importStar(require(\"./elements/style\"));\nexports.safeDocument = __importStar(require(\"./globals/document\"));\nexports.safeDomParser = __importStar(require(\"./globals/dom_parser\"));\nexports.safeGlobal = __importStar(require(\"./globals/global\"));\nexports.safeLocation = __importStar(require(\"./globals/location\"));\nexports.safeRange = __importStar(require(\"./globals/range\"));\nexports.safeServiceWorkerContainer = __importStar(require(\"./globals/service_worker_container\"));\nexports.safeWindow = __importStar(require(\"./globals/window\"));\nexports.safeWorker = __importStar(require(\"./globals/worker\"));\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\n/**\n * Ensure process.env.NODE_ENV is set even when not running under Webpack or\n * Node. Terser will strip this out of production binaries.\n */\n/*#__PURE__*/ (function () {\n    if (typeof process === 'undefined') {\n        window.process = { env: { NODE_ENV: 'development' } };\n    }\n})();\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapStyleSheet = exports.SafeStyleSheet = exports.isStyleSheet = exports.unwrapStyle = exports.SafeStyle = exports.isStyle = exports.unwrapScript = exports.SafeScript = exports.isScript = exports.EMPTY_SCRIPT = exports.unwrapResourceUrl = exports.TrustedResourceUrl = exports.isResourceUrl = exports.unwrapHtml = exports.SafeHtml = exports.isHtml = exports.EMPTY_HTML = exports.unwrapAttributePrefix = exports.SafeAttributePrefix = exports.safeStyleSheet = exports.concatStyleSheets = exports.safeStyle = exports.concatStyles = exports.scriptFromJson = exports.safeScriptWithArgs = exports.safeScript = exports.concatScripts = exports.trustedResourceUrl = exports.replaceFragment = exports.blobUrlFromScript = exports.appendParams = exports.HtmlSanitizerBuilder = exports.sanitizeHtmlToFragment = exports.sanitizeHtmlAssertUnchanged = exports.sanitizeHtml = exports.htmlEscape = exports.createScriptSrc = exports.createScript = exports.concatHtmls = exports.safeAttrPrefix = void 0;\n/** Safe builders */\nvar attribute_builders_1 = require(\"./builders/attribute_builders\");\nObject.defineProperty(exports, \"safeAttrPrefix\", { enumerable: true, get: function () { return attribute_builders_1.safeAttrPrefix; } });\nvar html_builders_1 = require(\"./builders/html_builders\");\nObject.defineProperty(exports, \"concatHtmls\", { enumerable: true, get: function () { return html_builders_1.concatHtmls; } });\nObject.defineProperty(exports, \"createScript\", { enumerable: true, get: function () { return html_builders_1.createScript; } });\nObject.defineProperty(exports, \"createScriptSrc\", { enumerable: true, get: function () { return html_builders_1.createScriptSrc; } });\nObject.defineProperty(exports, \"htmlEscape\", { enumerable: true, get: function () { return html_builders_1.htmlEscape; } });\nvar html_sanitizer_1 = require(\"./builders/html_sanitizer/html_sanitizer\");\nObject.defineProperty(exports, \"sanitizeHtml\", { enumerable: true, get: function () { return html_sanitizer_1.sanitizeHtml; } });\nObject.defineProperty(exports, \"sanitizeHtmlAssertUnchanged\", { enumerable: true, get: function () { return html_sanitizer_1.sanitizeHtmlAssertUnchanged; } });\nObject.defineProperty(exports, \"sanitizeHtmlToFragment\", { enumerable: true, get: function () { return html_sanitizer_1.sanitizeHtmlToFragment; } });\nvar html_sanitizer_builder_1 = require(\"./builders/html_sanitizer/html_sanitizer_builder\");\nObject.defineProperty(exports, \"HtmlSanitizerBuilder\", { enumerable: true, get: function () { return html_sanitizer_builder_1.HtmlSanitizerBuilder; } });\nvar resource_url_builders_1 = require(\"./builders/resource_url_builders\");\nObject.defineProperty(exports, \"appendParams\", { enumerable: true, get: function () { return resource_url_builders_1.appendParams; } });\nObject.defineProperty(exports, \"blobUrlFromScript\", { enumerable: true, get: function () { return resource_url_builders_1.blobUrlFromScript; } });\nObject.defineProperty(exports, \"replaceFragment\", { enumerable: true, get: function () { return resource_url_builders_1.replaceFragment; } });\nObject.defineProperty(exports, \"trustedResourceUrl\", { enumerable: true, get: function () { return resource_url_builders_1.trustedResourceUrl; } });\nvar script_builders_1 = require(\"./builders/script_builders\");\nObject.defineProperty(exports, \"concatScripts\", { enumerable: true, get: function () { return script_builders_1.concatScripts; } });\nObject.defineProperty(exports, \"safeScript\", { enumerable: true, get: function () { return script_builders_1.safeScript; } });\nObject.defineProperty(exports, \"safeScriptWithArgs\", { enumerable: true, get: function () { return script_builders_1.safeScriptWithArgs; } });\nObject.defineProperty(exports, \"scriptFromJson\", { enumerable: true, get: function () { return script_builders_1.scriptFromJson; } });\nvar style_builders_1 = require(\"./builders/style_builders\");\nObject.defineProperty(exports, \"concatStyles\", { enumerable: true, get: function () { return style_builders_1.concatStyles; } });\nObject.defineProperty(exports, \"safeStyle\", { enumerable: true, get: function () { return style_builders_1.safeStyle; } });\nvar style_sheet_builders_1 = require(\"./builders/style_sheet_builders\");\nObject.defineProperty(exports, \"concatStyleSheets\", { enumerable: true, get: function () { return style_sheet_builders_1.concatStyleSheets; } });\nObject.defineProperty(exports, \"safeStyleSheet\", { enumerable: true, get: function () { return style_sheet_builders_1.safeStyleSheet; } });\n/** Types, constants and unwrappers */\nvar attribute_impl_1 = require(\"./internals/attribute_impl\");\nObject.defineProperty(exports, \"SafeAttributePrefix\", { enumerable: true, get: function () { return attribute_impl_1.SafeAttributePrefix; } });\nObject.defineProperty(exports, \"unwrapAttributePrefix\", { enumerable: true, get: function () { return attribute_impl_1.unwrapAttributePrefix; } });\nvar html_impl_1 = require(\"./internals/html_impl\");\nObject.defineProperty(exports, \"EMPTY_HTML\", { enumerable: true, get: function () { return html_impl_1.EMPTY_HTML; } });\nObject.defineProperty(exports, \"isHtml\", { enumerable: true, get: function () { return html_impl_1.isHtml; } });\nObject.defineProperty(exports, \"SafeHtml\", { enumerable: true, get: function () { return html_impl_1.SafeHtml; } });\nObject.defineProperty(exports, \"unwrapHtml\", { enumerable: true, get: function () { return html_impl_1.unwrapHtml; } });\nvar resource_url_impl_1 = require(\"./internals/resource_url_impl\");\nObject.defineProperty(exports, \"isResourceUrl\", { enumerable: true, get: function () { return resource_url_impl_1.isResourceUrl; } });\nObject.defineProperty(exports, \"TrustedResourceUrl\", { enumerable: true, get: function () { return resource_url_impl_1.TrustedResourceUrl; } });\nObject.defineProperty(exports, \"unwrapResourceUrl\", { enumerable: true, get: function () { return resource_url_impl_1.unwrapResourceUrl; } });\nvar script_impl_1 = require(\"./internals/script_impl\");\nObject.defineProperty(exports, \"EMPTY_SCRIPT\", { enumerable: true, get: function () { return script_impl_1.EMPTY_SCRIPT; } });\nObject.defineProperty(exports, \"isScript\", { enumerable: true, get: function () { return script_impl_1.isScript; } });\nObject.defineProperty(exports, \"SafeScript\", { enumerable: true, get: function () { return script_impl_1.SafeScript; } });\nObject.defineProperty(exports, \"unwrapScript\", { enumerable: true, get: function () { return script_impl_1.unwrapScript; } });\nvar style_impl_1 = require(\"./internals/style_impl\");\nObject.defineProperty(exports, \"isStyle\", { enumerable: true, get: function () { return style_impl_1.isStyle; } });\nObject.defineProperty(exports, \"SafeStyle\", { enumerable: true, get: function () { return style_impl_1.SafeStyle; } });\nObject.defineProperty(exports, \"unwrapStyle\", { enumerable: true, get: function () { return style_impl_1.unwrapStyle; } });\nvar style_sheet_impl_1 = require(\"./internals/style_sheet_impl\");\nObject.defineProperty(exports, \"isStyleSheet\", { enumerable: true, get: function () { return style_sheet_impl_1.isStyleSheet; } });\nObject.defineProperty(exports, \"SafeStyleSheet\", { enumerable: true, get: function () { return style_sheet_impl_1.SafeStyleSheet; } });\nObject.defineProperty(exports, \"unwrapStyleSheet\", { enumerable: true, get: function () { return style_sheet_impl_1.unwrapStyleSheet; } });\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapAttributePrefix = exports.createAttributePrefix = exports.SafeAttributePrefix = void 0;\nrequire(\"../environment/dev\");\nvar secrets_1 = require(\"./secrets\");\n/** A prefix with which an attribute is safe to set using plain strings. */\nvar SafeAttributePrefix = /** @class */ (function () {\n    function SafeAttributePrefix() {\n    }\n    return SafeAttributePrefix;\n}());\nexports.SafeAttributePrefix = SafeAttributePrefix;\n/** Implementation for `SafeAttributePrefix` */\nvar AttributePrefixImpl = /** @class */ (function (_super) {\n    __extends(AttributePrefixImpl, _super);\n    function AttributePrefixImpl(attrPrefix, token) {\n        var _this = _super.call(this) || this;\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        _this.privateDoNotAccessOrElseWrappedAttrPrefix = attrPrefix;\n        return _this;\n    }\n    AttributePrefixImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedAttrPrefix;\n    };\n    return AttributePrefixImpl;\n}(SafeAttributePrefix));\n/**\n * Builds a new `SafeAttribute` from the given string, without enforcing\n * safety guarantees. This shouldn't be exposed to application developers, and\n * must only be used as a step towards safe builders or safe constants.\n */\nfunction createAttributePrefix(attrPrefix) {\n    return new AttributePrefixImpl(attrPrefix, secrets_1.secretToken);\n}\nexports.createAttributePrefix = createAttributePrefix;\n/**\n * Returns the string value of the passed `SafeAttributePrefix` object while\n * ensuring it has the correct type.\n */\nfunction unwrapAttributePrefix(value) {\n    if (value instanceof AttributePrefixImpl) {\n        return value.privateDoNotAccessOrElseWrappedAttrPrefix;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping SafeAttributePrefix';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapAttributePrefix = unwrapAttributePrefix;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapHtml = exports.isHtml = exports.EMPTY_HTML = exports.createHtml = exports.SafeHtml = void 0;\nrequire(\"../environment/dev\");\n/* g3_import_pure from './pure' */\nvar secrets_1 = require(\"./secrets\");\nvar trusted_types_1 = require(\"./trusted_types\");\n/**\n * Runtime implementation of `TrustedHTML` in browsers that don't support it.\n */\nvar HtmlImpl = /** @class */ (function () {\n    function HtmlImpl(html, token) {\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        this.privateDoNotAccessOrElseWrappedHtml = html;\n    }\n    HtmlImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedHtml.toString();\n    };\n    return HtmlImpl;\n}());\nfunction createHtmlInternal(html, trusted) {\n    return (trusted !== null && trusted !== void 0 ? trusted : new HtmlImpl(html, secrets_1.secretToken));\n}\nvar GlobalTrustedHTML = (typeof window !== undefined) ? window.TrustedHTML : undefined;\n/**\n * Also exports the constructor so that instanceof checks work.\n */\nexports.SafeHtml = (GlobalTrustedHTML !== null && GlobalTrustedHTML !== void 0 ? GlobalTrustedHTML : HtmlImpl);\n/**\n * Builds a new `SafeHtml` from the given string, without enforcing safety\n * guarantees. It may cause side effects by creating a Trusted Types policy.\n * This shouldn't be exposed to application developers, and must only be used as\n * a step towards safe builders or safe constants.\n */\nfunction createHtml(html) {\n    var _a;\n    /** @noinline */\n    var noinlineHtml = html;\n    return createHtmlInternal(noinlineHtml, (_a = (0, trusted_types_1.getTrustedTypesPolicy)()) === null || _a === void 0 ? void 0 : _a.createHTML(noinlineHtml));\n}\nexports.createHtml = createHtml;\n/**\n * An empty `SafeHtml` constant.\n * Unlike the function above, using this will not create a policy.\n */\nexports.EMPTY_HTML = \n/* #__PURE__ */ (function () { var _a; return createHtmlInternal('', (_a = (0, trusted_types_1.getTrustedTypes)()) === null || _a === void 0 ? void 0 : _a.emptyHTML); })();\n/**\n * Checks if the given value is a `SafeHtml` instance.\n */\nfunction isHtml(value) {\n    return value instanceof exports.SafeHtml;\n}\nexports.isHtml = isHtml;\n/**\n * Returns the value of the passed `SafeHtml` object while ensuring it\n * has the correct type.\n *\n * Returns a native `TrustedHTML` or a string if Trusted Types are disabled.\n */\nfunction unwrapHtml(value) {\n    var _a;\n    if ((_a = (0, trusted_types_1.getTrustedTypes)()) === null || _a === void 0 ? void 0 : _a.isHTML(value)) {\n        return value;\n    }\n    else if (value instanceof HtmlImpl) {\n        return value.privateDoNotAccessOrElseWrappedHtml;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping SafeHtml';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapHtml = unwrapHtml;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapResourceUrl = exports.isResourceUrl = exports.createResourceUrl = exports.TrustedResourceUrl = void 0;\nrequire(\"../environment/dev\");\nvar secrets_1 = require(\"./secrets\");\nvar trusted_types_1 = require(\"./trusted_types\");\n/**\n * Runtime implementation of `TrustedScriptURL` in browsers that don't support\n * it.\n */\nvar ResourceUrlImpl = /** @class */ (function () {\n    function ResourceUrlImpl(url, token) {\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        this.privateDoNotAccessOrElseWrappedResourceUrl = url;\n    }\n    ResourceUrlImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedResourceUrl.toString();\n    };\n    return ResourceUrlImpl;\n}());\nvar GlobalTrustedScriptURL = (typeof window !== undefined) ? window.TrustedScriptURL : undefined;\n/**\n * Also exports the constructor so that instanceof checks work.\n */\nexports.TrustedResourceUrl = (GlobalTrustedScriptURL !== null && GlobalTrustedScriptURL !== void 0 ? GlobalTrustedScriptURL : ResourceUrlImpl);\n/**\n * Builds a new `TrustedResourceUrl` from the given string, without\n * enforcing safety guarantees. It may cause side effects by creating a Trusted\n * Types policy. This shouldn't be exposed to application developers, and must\n * only be used as a step towards safe builders or safe constants.\n */\nfunction createResourceUrl(url) {\n    var _a;\n    /** @noinline */\n    var noinlineUrl = url;\n    var trustedScriptURL = (_a = (0, trusted_types_1.getTrustedTypesPolicy)()) === null || _a === void 0 ? void 0 : _a.createScriptURL(noinlineUrl);\n    return (trustedScriptURL !== null && trustedScriptURL !== void 0 ? trustedScriptURL : new ResourceUrlImpl(noinlineUrl, secrets_1.secretToken));\n}\nexports.createResourceUrl = createResourceUrl;\n/**\n * Checks if the given value is a `TrustedResourceUrl` instance.\n */\nfunction isResourceUrl(value) {\n    return value instanceof exports.TrustedResourceUrl;\n}\nexports.isResourceUrl = isResourceUrl;\n/**\n * Returns the value of the passed `TrustedResourceUrl` object while ensuring it\n * has the correct type.\n *\n * Returns a native `TrustedScriptURL` or a string if Trusted Types are\n * disabled.\n */\nfunction unwrapResourceUrl(value) {\n    var _a;\n    if ((_a = (0, trusted_types_1.getTrustedTypes)()) === null || _a === void 0 ? void 0 : _a.isScriptURL(value)) {\n        return value;\n    }\n    else if (value instanceof ResourceUrlImpl) {\n        return value.privateDoNotAccessOrElseWrappedResourceUrl;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping TrustedResourceUrl';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapResourceUrl = unwrapResourceUrl;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapScript = exports.isScript = exports.EMPTY_SCRIPT = exports.createScript = exports.SafeScript = void 0;\nrequire(\"../environment/dev\");\n/* g3_import_pure from './pure' */\nvar secrets_1 = require(\"./secrets\");\nvar trusted_types_1 = require(\"./trusted_types\");\n/**\n * Runtime implementation of `TrustedScript` in browswers that don't support it.\n * script element.\n */\nvar ScriptImpl = /** @class */ (function () {\n    function ScriptImpl(script, token) {\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        this.privateDoNotAccessOrElseWrappedScript = script;\n    }\n    ScriptImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedScript.toString();\n    };\n    return ScriptImpl;\n}());\nfunction createScriptInternal(script, trusted) {\n    return (trusted !== null && trusted !== void 0 ? trusted : new ScriptImpl(script, secrets_1.secretToken));\n}\nvar GlobalTrustedScript = (typeof window !== undefined) ? window.TrustedScript : undefined;\n/**\n * Also exports the constructor so that instanceof checks work.\n */\nexports.SafeScript = (GlobalTrustedScript !== null && GlobalTrustedScript !== void 0 ? GlobalTrustedScript : ScriptImpl);\n/**\n * Builds a new `SafeScript` from the given string, without enforcing\n * safety guarantees. It may cause side effects by creating a Trusted Types\n * policy. This shouldn't be exposed to application developers, and must only be\n * used as a step towards safe builders or safe constants.\n */\nfunction createScript(script) {\n    var _a;\n    /** @noinline */\n    var noinlineScript = script;\n    return createScriptInternal(noinlineScript, (_a = (0, trusted_types_1.getTrustedTypesPolicy)()) === null || _a === void 0 ? void 0 : _a.createScript(noinlineScript));\n}\nexports.createScript = createScript;\n/**\n * An empty `SafeScript` constant.\n * Unlike the functions above, using this will not create a policy.\n */\nexports.EMPTY_SCRIPT = \n/* #__PURE__ */ (function () { var _a; return createScriptInternal('', (_a = (0, trusted_types_1.getTrustedTypes)()) === null || _a === void 0 ? void 0 : _a.emptyScript); })();\n/**\n * Checks if the given value is a `SafeScript` instance.\n */\nfunction isScript(value) {\n    return value instanceof exports.SafeScript;\n}\nexports.isScript = isScript;\n/**\n * Returns the value of the passed `SafeScript` object while ensuring it\n * has the correct type.\n *\n * Returns a native `TrustedScript` or a string if Trusted Types are disabled.\n */\nfunction unwrapScript(value) {\n    var _a;\n    if ((_a = (0, trusted_types_1.getTrustedTypes)()) === null || _a === void 0 ? void 0 : _a.isScript(value)) {\n        return value;\n    }\n    else if (value instanceof ScriptImpl) {\n        return value.privateDoNotAccessOrElseWrappedScript;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping SafeScript';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapScript = unwrapScript;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ensureTokenIsValid = exports.secretToken = void 0;\n/**\n * A secret token that must be passed to safe type constructors. It is only\n * accessible from within safevalues, ensuring that unrestricted safe type\n * creation is only possible within safevalues. In particular, this prevents\n * forgery such as `safeHtmlValue.constructor('javascript:evil')`.\n */\nexports.secretToken = {};\n/**\n * Asserts that the given token matches the secret safevalues token. An\n * exception is thrown if that is not the case.\n */\nfunction ensureTokenIsValid(token) {\n    if (token !== exports.secretToken) {\n        throw new Error('Bad secret');\n    }\n}\nexports.ensureTokenIsValid = ensureTokenIsValid;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.assertIsTemplateObject = void 0;\n/**\n * An object of type TemplateStringsArray represents the literal part(s) of a\n * template literal. This function checks if a TemplateStringsArray object is\n * actually from a template literal.\n *\n * @param templateObj This contains the literal part of the template literal.\n * @param hasExprs If true, the input template may contain embedded expressions.\n * @param errorMsg The custom error message in case any checks fail.\n */\nfunction assertIsTemplateObject(templateObj, hasExprs, errorMsg) {\n    if (!Array.isArray(templateObj) || !Array.isArray(templateObj.raw) ||\n        (!hasExprs && templateObj.length !== 1)) {\n        throw new TypeError(errorMsg);\n    }\n}\nexports.assertIsTemplateObject = assertIsTemplateObject;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapStyle = exports.isStyle = exports.createStyle = exports.SafeStyle = void 0;\nrequire(\"../environment/dev\");\nvar secrets_1 = require(\"./secrets\");\n/**\n * Sequence of CSS declarations safe to use in style contexts in an HTML\n * document or in DOM APIs.\n */\nvar SafeStyle = /** @class */ (function () {\n    function SafeStyle() {\n    }\n    return SafeStyle;\n}());\nexports.SafeStyle = SafeStyle;\n/** Implementation for `SafeStyle` */\nvar StyleImpl = /** @class */ (function (_super) {\n    __extends(StyleImpl, _super);\n    function StyleImpl(style, token) {\n        var _this = _super.call(this) || this;\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        _this.privateDoNotAccessOrElseWrappedStyle = style;\n        return _this;\n    }\n    StyleImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedStyle;\n    };\n    return StyleImpl;\n}(SafeStyle));\n/**\n * Builds a new `SafeStyle` from the given string, without enforcing\n * safety guarantees. This shouldn't be exposed to application developers, and\n * must only be used as a step towards safe builders or safe constants.\n */\nfunction createStyle(style) {\n    return new StyleImpl(style, secrets_1.secretToken);\n}\nexports.createStyle = createStyle;\n/**\n * Checks if the given value is a `SafeStyle` instance.\n */\nfunction isStyle(value) {\n    return value instanceof StyleImpl;\n}\nexports.isStyle = isStyle;\n/**\n * Returns the string value of the passed `SafeStyle` object while ensuring it\n * has the correct type.\n */\nfunction unwrapStyle(value) {\n    if (value instanceof StyleImpl) {\n        return value.privateDoNotAccessOrElseWrappedStyle;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping SafeStyle';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapStyle = unwrapStyle;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.unwrapStyleSheet = exports.isStyleSheet = exports.createStyleSheet = exports.SafeStyleSheet = void 0;\nrequire(\"../environment/dev\");\nvar secrets_1 = require(\"./secrets\");\n/**\n * A complete CSS style sheet, safe to use in style contexts in an HTML document\n * or DOM APIs.\n */\nvar SafeStyleSheet = /** @class */ (function () {\n    function SafeStyleSheet() {\n    }\n    return SafeStyleSheet;\n}());\nexports.SafeStyleSheet = SafeStyleSheet;\n/** Implementation for `SafeStyleSheet` */\nvar StyleSheetImpl = /** @class */ (function (_super) {\n    __extends(StyleSheetImpl, _super);\n    function StyleSheetImpl(styleSheet, token) {\n        var _this = _super.call(this) || this;\n        if (process.env.NODE_ENV !== 'production') {\n            (0, secrets_1.ensureTokenIsValid)(token);\n        }\n        _this.privateDoNotAccessOrElseWrappedStyleSheet = styleSheet;\n        return _this;\n    }\n    StyleSheetImpl.prototype.toString = function () {\n        return this.privateDoNotAccessOrElseWrappedStyleSheet;\n    };\n    return StyleSheetImpl;\n}(SafeStyleSheet));\n/**\n * Builds a new `SafeStyleSheet` from the given string, without enforcing\n * safety guarantees. This shouldn't be exposed to application developers, and\n * must only be used as a step towards safe builders or safe constants.\n */\nfunction createStyleSheet(styleSheet) {\n    return new StyleSheetImpl(styleSheet, secrets_1.secretToken);\n}\nexports.createStyleSheet = createStyleSheet;\n/**\n * Checks if the given value is a `SafeStyleSheet` instance.\n */\nfunction isStyleSheet(value) {\n    return value instanceof StyleSheetImpl;\n}\nexports.isStyleSheet = isStyleSheet;\n/**\n * Returns the string value of the passed `SafeStyleSheet` object while\n * ensuring it has the correct type.\n */\nfunction unwrapStyleSheet(value) {\n    if (value instanceof StyleSheetImpl) {\n        return value.privateDoNotAccessOrElseWrappedStyleSheet;\n    }\n    else {\n        var message = '';\n        if (process.env.NODE_ENV !== 'production') {\n            message = 'Unexpected type when unwrapping SafeStyleSheet';\n        }\n        throw new Error(message);\n    }\n}\nexports.unwrapStyleSheet = unwrapStyleSheet;\n","\"use strict\";\n/**\n * @license\n * SPDX-License-Identifier: Apache-2.0\n */\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.TEST_ONLY = exports.getTrustedTypesPolicy = exports.getTrustedTypes = void 0;\n/**\n * The name of the Trusted Types policy used by TS safevalues, or empty\n * to disable Trusted Types. This duplicates the 'google#safe', but\n * can be overridden in tests.\n */\nvar trustedTypesPolicyName = 'google#safe';\n/** Helper to retrieve the value of `window.trustedTypes`. */\nfunction trustedTypes() {\n    if (typeof window !== 'undefined') {\n        return window.trustedTypes;\n    }\n    return undefined;\n}\n/**\n * Returns window.trustedTypes if Trusted Types are enabled and supported, or\n * null otherwise.\n */\nfunction getTrustedTypes() {\n    var _a;\n    return (trustedTypesPolicyName !== '') ? ((_a = trustedTypes()) !== null && _a !== void 0 ? _a : null) : null;\n}\nexports.getTrustedTypes = getTrustedTypes;\n/**\n * The Trusted Types policy used by TS safevalues, or null if Trusted Types\n * are not enabled/supported, or undefined if the policy has not been created\n * yet.\n */\nvar trustedTypesPolicy;\n/**\n * Returns the Trusted Types policy used by TS safevalues, or null if Trusted\n * Types are not enabled/supported. The first call to this function will\n * create the policy.\n */\nfunction getTrustedTypesPolicy() {\n    var _a, _b;\n    if (trustedTypesPolicy === undefined) {\n        try {\n            trustedTypesPolicy =\n                (_b = (_a = getTrustedTypes()) === null || _a === void 0 ? void 0 : _a.createPolicy(trustedTypesPolicyName, {\n                    createHTML: function (s) { return s; },\n                    createScript: function (s) { return s; },\n                    createScriptURL: function (s) { return s; }\n                })) !== null && _b !== void 0 ? _b : null;\n        }\n        catch (_c) {\n            // In Chromium versions before 81, trustedTypes.createPolicy throws if\n            // called with a name that is already registered, even if no CSP is set.\n            // Until users have largely migrated to 81 or above, catch the error not\n            // to break the applications functionally. In such case, the code will\n            // fall back to using regular Safe Types.\n            trustedTypesPolicy = null;\n        }\n    }\n    return trustedTypesPolicy;\n}\nexports.getTrustedTypesPolicy = getTrustedTypesPolicy;\n/** Helpers for tests. */\nexports.TEST_ONLY = {\n    resetDefaults: function () {\n        trustedTypesPolicy = undefined;\n        trustedTypesPolicyName = 'google#safe';\n    },\n    setTrustedTypesPolicyName: function (name) {\n        trustedTypesPolicyName = name;\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 {safeAttrPrefix} from 'safevalues';\nimport {safeElement} from 'safevalues/dom';\n\nimport {MDCFoundation} from './foundation';\nimport {CustomEventListener, EventType, SpecificEventListener} from './types';\n\nfunction toCamelCase(str: string) {\n  // tslint:disable-next-line:enforce-name-casing\n  return String(str).replace(/\\-([a-z])/g, (_, match) => match.toUpperCase());\n}\n\n/** MDC Component base */\nexport class MDCComponent<FoundationType extends MDCFoundation> {\n  static attachTo(root: HTMLElement): MDCComponent<MDCFoundation<{}>> {\n    // Subclasses which extend MDCBase should provide an attachTo() method that\n    // takes a root element and returns an instantiated component with its root\n    // set to that element. Also note that in the cases of subclasses, an\n    // explicit foundation class will not have to be passed in; it will simply\n    // be initialized from getDefaultFoundation().\n    return new MDCComponent(root, new MDCFoundation({}));\n  }\n\n  protected foundation: FoundationType;\n\n  constructor(\n      public root: HTMLElement, foundation?: FoundationType,\n      ...args: unknown[]) {\n    this.initialize(...args);\n    // Note that we initialize foundation here and not within the constructor's\n    // default param so that this.root is defined and can be used within the\n    // 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\n   * not need to be unit tested */\n  // tslint:disable-next-line:enforce-name-casing\n  initialize(..._args: unknown[]) {\n    // Subclasses can override this to do any additional setup work that would\n    // be considered part of a \"constructor\". Essentially, it is a hook into the\n    // parent constructor before the foundation is initialized. Any additional\n    // 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\n    // foundation class for the component.\n    throw new Error(\n        '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\n    // synchronize with a host DOM object. An example of this would be a form\n    // control wrapper that needs to synchronize its internal state to some\n    // property or attribute of the host DOM. Please note: this is *not* the\n    // place to perform DOM reads/writes that would cause layout / paint, as\n    // this is called synchronously from within the constructor.\n  }\n\n  destroy() {\n    // Subclasses may implement this method to release any resources /\n    // deregister any listeners they have attached. An example of this might be\n    // 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.\n   * This is most useful when listening for custom events.\n   */\n  listen<K extends EventType>(\n      evtType: K, handler: SpecificEventListener<K>,\n      options?: AddEventListenerOptions|boolean): void;\n  listen<E extends Event>(\n      evtType: string, handler: CustomEventListener<E>,\n      options?: AddEventListenerOptions|boolean): void;\n  listen(\n      evtType: string, handler: EventListener,\n      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.\n   * This is most useful when unlistening for custom events.\n   */\n  unlisten<K extends EventType>(\n      evtType: K, handler: SpecificEventListener<K>,\n      options?: AddEventListenerOptions|boolean): void;\n  unlisten<E extends Event>(\n      evtType: string, handler: CustomEventListener<E>,\n      options?: AddEventListenerOptions|boolean): void;\n  unlisten(\n      evtType: string, handler: EventListener,\n      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\n   * 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   * This is a intermediate fix to allow components to use safevalues. This\n   * limits setAttribute to setting tabindex, data attributes, and aria\n   * attributes.\n   *\n   * TODO(b/263990206): remove this method and add these directly in each\n   * component. This will remove this abstraction and make it clear that the\n   * caller can't set any attribute.\n   */\n  protected safeSetAttribute(\n      element: HTMLElement,\n      attribute: string,\n      value: string,\n  ) {\n    if (attribute.toLowerCase() === 'tabindex') {\n      element.tabIndex = Number(value);\n    } else if (attribute.indexOf('data-') === 0) {\n      const dataKey = toCamelCase(attribute.replace(/^data-/, ''));\n      element.dataset[dataKey] = value;\n    } else {\n      safeElement.setPrefixedAttribute(\n          [safeAttrPrefix`aria-`, safeAttrPrefix`role`],\n          element,\n          attribute,\n          value,\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 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\n/** MDC Foundation */\nexport class MDCFoundation<AdapterType extends {} = {}> {\n  static get cssClasses(): {[key: string]: string} {\n    // Classes extending MDCFoundation should implement this method to return an\n    // object which exports every CSS class the foundation class needs as a\n    // 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\n    // object which exports all semantic strings as constants. e.g. {ARIA_ROLE:\n    // 'tablist'}\n    return {};\n  }\n\n  static get numbers(): {[key: string]: number} {\n    // Classes extending MDCFoundation should implement this method to return an\n    // object which exports all of its semantic numbers as constants.\n    // 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\n    // order to provide a convenient way of viewing the necessary methods of an\n    // adapter. In the future, this could also be used for adapter 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\n    // (registering events, etc.)\n  }\n\n  destroy() {\n    // Subclasses should override this method to perform de-initialization\n    // routines (de-registering events, etc.)\n  }\n}\n\n/**\n * The constructor for MDCFoundation.\n */\nexport interface MDCFoundationConstructor<AdapterType extends object = any> {\n  new(adapter: AdapterType): MDCFoundation<AdapterType>;\n  readonly prototype: MDCFoundation<AdapterType>;\n}\n\n/**\n * The deprecated constructor for MDCFoundation.\n */\nexport interface MDCFoundationDeprecatedConstructor<\n    AdapterType extends object = any> {\n  readonly cssClasses: Record<string, string>;\n  readonly strings: Record<string, string>;\n  readonly numbers: Record<string, number>;\n  readonly defaultAdapter: AdapterType;\n\n  new(adapter?: Partial<AdapterType>): MDCFoundation<AdapterType>;\n  readonly prototype: MDCFoundation<AdapterType>;\n}\n\n/**\n * Retrieves the AdapaterType from the provided MDCFoundation generic type.\n */\nexport type MDCFoundationAdapter<T> =\n    T extends MDCFoundation<infer A>? A : never;\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\n/**\n * Determine whether the current browser supports passive event listeners, and\n * if so, use them.\n */\nexport function applyPassive(globalObj: Window = window): boolean|\n    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 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\n * prototype chain. This makes ponyfills safer than traditional polyfills,\n * 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\n/** Element.matches with support for webkit and IE. */\nexport function matches(element: Element, selector: string): boolean {\n  const nativeMatches = element.matches || element.webkitMatchesSelector ||\n      (element as any).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 {applyPassive} from '@material/dom/events';\nimport {matches} from '@material/dom/ponyfill';\n\nimport {MDCRippleAdapter} from './adapter';\nimport {MDCRippleFoundation} from './foundation';\nimport {MDCRippleAttachOpts, MDCRippleCapableSurface} from './types';\nimport * as util from './util';\n\n/** MDC Ripple Factory */\nexport type MDCRippleFactory =\n    (el: HTMLElement, foundation?: MDCRippleFoundation) => MDCRipple;\n\n/** MDC Ripple */\nexport class MDCRipple extends MDCComponent<MDCRippleFoundation> implements\n    MDCRippleCapableSurface {\n  static override attachTo(root: HTMLElement, opts: MDCRippleAttachOpts = {\n    isUnbounded: undefined\n  }): 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) => {\n        instance.root.classList.add(className);\n      },\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      },\n      deregisterInteractionHandler: (evtType, handler) => {\n        instance.root.removeEventListener(evtType, handler, applyPassive());\n      },\n      deregisterResizeHandler: (handler) => {\n        window.removeEventListener('resize', handler);\n      },\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      },\n      registerInteractionHandler: (evtType, handler) => {\n        instance.root.addEventListener(evtType, handler, applyPassive());\n      },\n      registerResizeHandler: (handler) => {\n        window.addEventListener('resize', handler);\n      },\n      removeClass: (className) => {\n        instance.root.classList.remove(className);\n      },\n      updateCssVariable: (varName, value) => {\n        instance.root.style.setProperty(varName, value);\n      },\n    };\n  }\n\n  disabled = false;\n\n  private isUnbounded?: boolean;\n\n  get unbounded(): boolean {\n    return Boolean(this.isUnbounded);\n  }\n\n  set unbounded(unbounded: boolean) {\n    this.isUnbounded = 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  override getDefaultFoundation() {\n    return new MDCRippleFoundation(MDCRipple.createAdapter(this));\n  }\n\n  override initialSyncWithDOM() {\n    const root = this.root;\n    this.isUnbounded = '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.isUnbounded));\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\n  // sorts,\n  // given that it's an 'upgrade' to an existing component. That being said it\n  // 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:\n      225,  // Corresponds to $mdc-ripple-translate-duration (i.e. activation\n            // animation duration)\n  FG_DEACTIVATION_MS: 150,  // Corresponds to $mdc-ripple-fade-out-duration\n                            // (i.e. deactivation animation duration)\n  INITIAL_ORIGIN_SCALE: 0.6,\n  PADDING: 10,\n  TAP_DELAY_MS:\n      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';\n\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\ninterface EventHandlerNonNull {\n  (event: Event): any;\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\n// activation\nconst ACTIVATION_EVENT_TYPES: ActivationEventType[] = [\n  'touchstart',\n  'pointerdown',\n  'mousedown',\n  'keydown',\n];\n\n// Deactivation events registered on documentElement when a pointer-related down\n// event occurs\nconst POINTER_DEACTIVATION_EVENT_TYPES: DeactivationEventType[] = [\n  'touchend',\n  'pointerup',\n  'mouseup',\n  'contextmenu',\n];\n\n// simultaneous nested activations\nlet activatedTargets: Array<EventTarget|null> = [];\n\n/** MDC Ripple Foundation */\nexport class MDCRippleFoundation extends MDCFoundation<MDCRippleAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  static override get defaultAdapter(): MDCRippleAdapter {\n    return {\n      addClass: () => undefined,\n      browserSupportsCssVars: () => true,\n      computeBoundingRect: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\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) => {\n      this.activateImpl(e);\n    };\n    this.deactivateHandler = () => {\n      this.deactivateImpl();\n    };\n    this.focusHandler = () => {\n      this.handleFocus();\n    };\n    this.blurHandler = () => {\n      this.handleBlur();\n    };\n    this.resizeHandler = () => {\n      this.layout();\n    };\n  }\n\n  override 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\n          // coordinates for both shade and ripple\n          this.layoutInternal();\n        }\n      });\n    }\n  }\n\n  override 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.activateImpl(evt);\n  }\n\n  deactivate(): void {\n    this.deactivateImpl();\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\n  handleBlur(): void {\n    requestAnimationFrame(() => {\n      this.adapter.removeClass(MDCRippleFoundation.cssClasses.BG_FOCUSED);\n    });\n  }\n\n  /**\n   * We compute this property so that we are not querying information about the\n   * client until the point in time where the foundation requests it. This\n   * prevents scenarios where client-side feature-detection may happen too\n   * early, such as when components are rendered on the server and then\n   * 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      for (const evtType of ACTIVATION_EVENT_TYPES) {\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      for (const evtType of POINTER_DEACTIVATION_EVENT_TYPES) {\n        this.adapter.registerDocumentInteractionHandler(\n            evtType, this.deactivateHandler);\n      }\n    }\n  }\n\n  private deregisterRootHandlers() {\n    for (const evtType of ACTIVATION_EVENT_TYPES) {\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    for (const evtType of POINTER_DEACTIVATION_EVENT_TYPES) {\n      this.adapter.deregisterDocumentInteractionHandler(\n          evtType, this.deactivateHandler);\n    }\n  }\n\n  private removeCssVars() {\n    const rippleStrings = MDCRippleFoundation.strings;\n    const keys =\n        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 activateImpl(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\n    // already-processed user interaction\n    const previousActivationEvent = this.previousActivationEvent;\n    const isSameInteraction = previousActivationEvent && evt !== undefined &&\n        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 ?\n        false :\n        evt !== undefined &&\n            (evt.type === 'mousedown' || evt.type === 'touchstart' ||\n             evt.type === 'pointerdown');\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\n      // 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\n      // bubble to prevent ancestor ripples\n      activatedTargets = [];\n\n      if (!activationState.wasElementMadeActive && evt !== undefined &&\n          ((evt as KeyboardEvent).key === ' ' ||\n           (evt as KeyboardEvent).keyCode === 32)) {\n        // If space was pressed, try again within an rAF call to detect :active,\n        // because different UAs report active states inconsistently when\n        // 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\n        // problem, but will crash if a CSS variable is set within a rAF\n        // 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} =\n        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(() => {\n      this.activationTimerCallback();\n    }, 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\n    // the activation animation ends. The deactivation animation should only run\n    // 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\n    // a short time. Store the previous event until it's safe to assume that\n    // subsequent events are for new interactions.\n    setTimeout(\n        () => this.previousActivationEvent = undefined,\n        MDCRippleFoundation.numbers.TAP_DELAY_MS);\n  }\n\n  private deactivateImpl(): void {\n    const activationState = this.activationState;\n    // This can happen in scenarios such as when you have a keyup event that\n    // blurs the element.\n    if (!activationState.isActivated) {\n      return;\n    }\n\n    const state: ActivationStateType = {...activationState};\n\n    if (activationState.isProgrammatic) {\n      requestAnimationFrame(() => {\n        this.animateDeactivation(state);\n      });\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}:\n                                  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\n    // ripples. Unbounded ripple diameter is calculated smaller since the\n    // surface is expected to already be padded appropriately to extend the\n    // hitbox, and the ripple is expected to meet the edges of the padded hitbox\n    // (which is typically square). Bounded ripples, on the other hand, are\n    // fully expected to expand beyond the surface's longest diameter\n    // (calculated based on the diagonal plus a constant padding), and are\n    // clipped at the surface's border via `overflow: hidden`.\n    const getBoundedRadius = () => {\n      const hypotenuse = Math.sqrt(\n          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,\n    // then scales up using a CSS scale transform\n    const initialSize =\n        Math.floor(maxDim * MDCRippleFoundation.numbers.INITIAL_ORIGIN_SCALE);\n    // Unbounded ripple size should always be even number to equally center\n    // 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,\n      VAR_LEFT,\n      VAR_TOP,\n      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 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(\n    windowObj: typeof globalThis, 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)') && CSS.supports('color', '#00000000'));\n\n  supportsCssVars =\n      explicitlySupportsCssVars || weAreFeatureDetectingSafari10plus;\n\n  if (!forceRefresh) {\n    supportsCssVariables_ = supportsCssVars;\n  }\n  return supportsCssVars;\n}\n\nexport function getNormalizedEventCoords(\n    evt: Event|undefined, pageOffset: MDCRipplePoint,\n    clientRect: DOMRect): 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 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 {MDCTabDimensions} from '@material/tab/types';\n\n/**\n * Defines the shape of the adapter expected by the foundation.\n * Implement this adapter for your framework of choice to delegate updates to\n * the component in your framework of choice. See architecture documentation\n * for more details.\n * https://github.com/material-components/material-components-web/blob/master/docs/code/architecture.md\n */\nexport interface MDCTabBarAdapter {\n  /**\n   * Scrolls to the given position\n   * @param scrollX The position to scroll to\n   */\n  scrollTo(scrollX: number): void;\n\n  /**\n   * Increments the current scroll position by the given amount\n   * @param scrollXIncrement The amount to increment scroll\n   */\n  incrementScroll(scrollXIncrement: number): void;\n\n  /**\n   * Returns the current scroll position\n   */\n  getScrollPosition(): number;\n\n  /**\n   * Returns the width of the scroll content\n   */\n  getScrollContentWidth(): number;\n\n  /**\n   * Returns the root element's offsetWidth\n   */\n  getOffsetWidth(): number;\n\n  /**\n   * Returns if the Tab Bar language direction is RTL\n   */\n  isRTL(): boolean;\n\n  /**\n   * Sets the tab at the given index to be activated\n   * @param index The index of the tab to activate\n   */\n  setActiveTab(index: number): void;\n\n  /**\n   * Activates the tab at the given index with the given client rect\n   * @param index The index of the tab to activate\n   * @param clientRect The client rect of the previously active Tab Indicator\n   */\n  activateTabAtIndex(index: number, clientRect?: DOMRect): void;\n\n  /**\n   * Deactivates the tab at the given index\n   * @param index The index of the tab to deactivate\n   */\n  deactivateTabAtIndex(index: number): void;\n\n  /**\n   * Focuses the tab at the given index\n   * @param index The index of the tab to focus\n   */\n  focusTabAtIndex(index: number): void;\n\n  /**\n   * Returns the client rect of the tab's indicator\n   * @param index The index of the tab\n   */\n  getTabIndicatorClientRectAtIndex(index: number): DOMRect;\n\n  /**\n   * Returns the tab dimensions of the tab at the given index\n   * @param index The index of the tab\n   */\n  getTabDimensionsAtIndex(index: number): MDCTabDimensions;\n\n  /**\n   * Returns the length of the tab list\n   */\n  getTabListLength(): number;\n\n  /**\n   * Returns the index of the previously active tab\n   */\n  getPreviousActiveTabIndex(): number;\n\n  /**\n   * Returns the index of the focused tab\n   */\n  getFocusedTabIndex(): number;\n\n  /**\n   * Returns the index of the given tab\n   * @param id The ID of the tab whose index to determine\n   */\n  getIndexOfTabById(id: string): number;\n\n  /**\n   * Emits the MDCTabBar:activated event\n   * @param index The index of the activated tab\n   */\n  notifyTabActivated(index: number): void;\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 {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';\n\nimport {MDCTabBarAdapter} from './adapter';\nimport {MDCTabBarFoundation} from './foundation';\nimport {MDCTabBarActivatedEventDetail} from './types';\n\nconst {strings} = MDCTabBarFoundation;\n\nlet tabIdCounter = 0;\n\n/** MDC Tab Bar */\nexport class MDCTabBar extends MDCComponent<MDCTabBarFoundation> {\n  static override attachTo(root: HTMLElement): 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!:\n      CustomEventListener<MDCTabInteractionEvent>;  // assigned in\n                                                    // initialSyncWithDOM()\n  private handleKeyDown!:\n      SpecificEventListener<'keydown'>;  // assigned in initialSyncWithDOM()\n\n  set focusOnActivate(focusOnActivate: boolean) {\n    for (const tab of this.tabList) {\n      tab.focusOnActivate = focusOnActivate;\n    }\n  }\n\n  set useAutomaticActivation(useAutomaticActivation: boolean) {\n    this.foundation.setUseAutomaticActivation(useAutomaticActivation);\n  }\n\n  override initialize(\n      tabFactory: MDCTabFactory = (el) => new MDCTab(el),\n      tabScrollerFactory:\n          MDCTabScrollerFactory = (el) => new MDCTabScroller(el),\n  ) {\n    this.tabList = this.instantiateTabs(tabFactory);\n    this.tabScroller = this.instantiatetabScroller(tabScrollerFactory);\n  }\n\n  override initialSyncWithDOM() {\n    this.handleTabInteraction = (evt) => {\n      this.foundation.handleTabInteraction(evt);\n    };\n    this.handleKeyDown = (evt) => {\n      this.foundation.handleKeyDown(evt);\n    };\n\n    this.listen(\n        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  override destroy() {\n    super.destroy();\n    this.unlisten(\n        MDCTabFoundation.strings.INTERACTED_EVENT, this.handleTabInteraction);\n    this.unlisten('keydown', this.handleKeyDown);\n    for (const tab of this.tabList) {\n      tab.destroy();\n    }\n\n    if (this.tabScroller) {\n      this.tabScroller.destroy();\n    }\n  }\n\n  override 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 order as the adapter interface.\n    const adapter: MDCTabBarAdapter = {\n      scrollTo: (scrollX) => {\n        this.tabScroller!.scrollTo(scrollX);\n      },\n      incrementScroll: (scrollXIncrement) => {\n        this.tabScroller!.incrementScroll(scrollXIncrement);\n      },\n      getScrollPosition: () => this.tabScroller!.getScrollPosition(),\n      getScrollContentWidth: () => this.tabScroller!.getScrollContentWidth(),\n      getOffsetWidth: () => this.root.offsetWidth,\n      isRTL: () => window.getComputedStyle(this.root).getPropertyValue(\n                       'direction') === 'rtl',\n      setActiveTab: (index) => {\n        this.foundation.activateTab(index);\n      },\n      activateTabAtIndex: (index, clientRect) => {\n        this.tabList[index].activate(clientRect);\n      },\n      deactivateTabAtIndex: (index) => {\n        this.tabList[index].deactivate();\n      },\n      focusTabAtIndex: (index) => {\n        this.tabList[index].focus();\n      },\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 as HTMLElement);\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) => {\n        this.emit<MDCTabBarActivatedEventDetail>(\n            strings.TAB_ACTIVATED_EVENT, {index}, true);\n      },\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() {\n    return Array.from(\n        this.root.querySelectorAll<HTMLElement>(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):\n      MDCTabScroller|null {\n    const tabScrollerElement =\n        this.root.querySelector<HTMLElement>(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';\n\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\n// 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\n// 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\n/** MDC Tab Bar Foundation */\nexport class MDCTabBarFoundation extends MDCFoundation<MDCTabBarAdapter> {\n  static override get strings() {\n    return strings;\n  }\n\n  static override get numbers() {\n    return numbers;\n  }\n\n  static override 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: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\n      getTabDimensionsAtIndex: () =>\n          ({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,\n    // since :active is used to apply ripple\n    if (!this.isActivationKey(key)) {\n      evt.preventDefault();\n    }\n\n    if (this.useAutomaticActivation && this.isActivationKey(key)) {\n      return;\n    }\n    const focusedTabIndex = this.adapter.getFocusedTabIndex();\n    if (this.isActivationKey(key)) {\n      this.adapter.setActiveTab(focusedTabIndex);\n      return;\n    }\n    const index = this.determineTargetFromKey(focusedTabIndex, key);\n    this.adapter.focusTabAtIndex(index);\n    this.scrollIntoView(index);\n    if (this.useAutomaticActivation) {\n      this.adapter.setActiveTab(index);\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      this.adapter.scrollTo(0);\n      return;\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      this.adapter.scrollTo(this.adapter.getScrollContentWidth());\n      return;\n    }\n\n    if (this.isRTL()) {\n      this.scrollIntoViewImplRTL(index);\n      return;\n    }\n\n    this.scrollIntoViewImpl(index);\n  }\n\n  /**\n   * Private method for determining the index of the destination tab based on\n   * 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 ||\n        key === strings.ARROW_RIGHT_KEY && isRTL;\n    const shouldIncrement = key === strings.ARROW_RIGHT_KEY && !isRTL ||\n        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\n   * 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 =\n        nextTabDimensions.contentLeft - scrollPosition - barWidth;\n    const relativeContentRight =\n        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\n   * 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 =\n        scrollContentWidth - nextTabDimensions.contentLeft - scrollPosition;\n    const relativeContentRight = scrollContentWidth -\n        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\n   * 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 =\n        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\n   * 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 =\n        scrollContentWidth - tabDimensions.rootLeft - barWidth - scrollPosition;\n    const rootRight =\n        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 scrollIntoViewImpl(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(\n        index, tabDimensions, scrollPosition, barWidth);\n\n    if (!this.indexIsInRange(nextIndex)) {\n      return;\n    }\n\n    const scrollIncrement = this.calculateScrollIncrement(\n        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 scrollIntoViewImplRTL(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(\n        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 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 interface MDCTabBarActivatedEventDetail {\n  index: number;\n}\n\n// Note: CustomEvent<T> is not supported by Closure Compiler.\n\nexport interface MDCTabBarActivatedEvent extends Event {\n  readonly detail: MDCTabBarActivatedEventDetail;\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';\n\nimport {MDCTabIndicatorAdapter} from './adapter';\nimport {MDCFadingTabIndicatorFoundation} from './fading-foundation';\nimport {MDCTabIndicatorFoundation} from './foundation';\nimport {MDCSlidingTabIndicatorFoundation} from './sliding-foundation';\n\n/** MDC Tab Indicator Factory */\nexport type MDCTabIndicatorFactory =\n    (el: HTMLElement, foundation?: MDCTabIndicatorFoundation) =>\n        MDCTabIndicator;\n\n/** MDC Tab Indicator */\nexport class MDCTabIndicator extends MDCComponent<MDCTabIndicatorFoundation> {\n  static override attachTo(root: HTMLElement): MDCTabIndicator {\n    return new MDCTabIndicator(root);\n  }\n\n  private content!: HTMLElement;  // assigned in initialize()\n\n  override initialize() {\n    this.content = this.root.querySelector<HTMLElement>(\n        MDCTabIndicatorFoundation.strings.CONTENT_SELECTOR)!;\n  }\n\n  computeContentClientRect(): DOMRect {\n    return this.foundation.computeContentClientRect();\n  }\n\n  override 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 order as the adapter interface.\n    const adapter: MDCTabIndicatorAdapter = {\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      computeContentClientRect: () => this.content.getBoundingClientRect(),\n      setContentStyleProperty: (prop, value) => {\n        this.content.style.setProperty(prop, value);\n      },\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?: DOMRect) {\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';\n\nimport {MDCTabIndicatorAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\n\n/** MDC Tab Indicator Foundation */\nexport abstract class MDCTabIndicatorFoundation extends\n    MDCFoundation<MDCTabIndicatorAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override 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: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\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(): DOMRect {\n    return this.adapter.computeContentClientRect();\n  }\n\n  abstract activate(previousIndicatorClientRect?: DOMRect): 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 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\n    MDCTabIndicatorFoundation {\n  activate(previousIndicatorClientRect?: DOMRect) {\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\n    // link below: https://aerotwist.com/blog/flip-your-animations/\n\n    // Calculate the dimensions based on the dimensions of the previous\n    // indicator\n    const currentClientRect = this.computeContentClientRect();\n    const widthDelta =\n        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\n    // 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';\n\nimport {MDCTabScrollerAdapter} from './adapter';\nimport {MDCTabScrollerFoundation} from './foundation';\nimport * as util from './util';\n\ntype InteractionEventType =\n    'wheel'|'touchstart'|'pointerdown'|'mousedown'|'keydown';\n\n/** MDC Tab Scroller Factory */\nexport type MDCTabScrollerFactory =\n    (el: HTMLElement, foundation?: MDCTabScrollerFoundation) => MDCTabScroller;\n\n/** MDC Tab Scroller */\nexport class MDCTabScroller extends MDCComponent<MDCTabScrollerFoundation> {\n  static override attachTo(root: HTMLElement): 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!:\n      SpecificEventListener<InteractionEventType>;  // assigned in\n                                                    // initialSyncWithDOM()\n  private handleTransitionEnd!:\n      SpecificEventListener<'transitionend'>;  // assigned in\n                                               // initialSyncWithDOM()\n\n  override 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  override initialSyncWithDOM() {\n    this.handleInteraction = () => {\n      this.foundation.handleInteraction();\n    };\n    this.handleTransitionEnd = (evt) => {\n      this.foundation.handleTransitionEnd(evt);\n    };\n\n    this.area.addEventListener('wheel', this.handleInteraction, applyPassive());\n    this.area.addEventListener(\n        'touchstart', this.handleInteraction, applyPassive());\n    this.area.addEventListener(\n        'pointerdown', this.handleInteraction, applyPassive());\n    this.area.addEventListener(\n        'mousedown', this.handleInteraction, applyPassive());\n    this.area.addEventListener(\n        'keydown', this.handleInteraction, applyPassive());\n    this.content.addEventListener('transitionend', this.handleTransitionEnd);\n  }\n\n  override destroy() {\n    super.destroy();\n\n    this.area.removeEventListener(\n        'wheel', this.handleInteraction, applyPassive());\n    this.area.removeEventListener(\n        'touchstart', this.handleInteraction, applyPassive());\n    this.area.removeEventListener(\n        'pointerdown', this.handleInteraction, applyPassive());\n    this.area.removeEventListener(\n        'mousedown', this.handleInteraction, applyPassive());\n    this.area.removeEventListener(\n        'keydown', this.handleInteraction, applyPassive());\n    this.content.removeEventListener('transitionend', this.handleTransitionEnd);\n  }\n\n  override 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 order as the adapter interface.\n    const adapter: MDCTabScrollerAdapter = {\n      eventTargetMatchesSelector: (evtTarget, selector) =>\n          matches(evtTarget as Element, selector),\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      addScrollAreaClass: (className) => {\n        this.area.classList.add(className);\n      },\n      setScrollAreaStyleProperty: (prop, value) => {\n        this.area.style.setProperty(prop, value);\n      },\n      setScrollContentStyleProperty: (prop, value) => {\n        this.content.style.setProperty(prop, value);\n      },\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\n   *     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';\n\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\n/** MDC Tab Scroller Foundation */\nexport class MDCTabScrollerFoundation extends\n    MDCFoundation<MDCTabScrollerAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override 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: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\n      computeScrollContentClientRect: () =>\n          ({top: 0, right: 0, bottom: 0, left: 0, width: 0, height: 0} as any),\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\n   * during the animation.\n   */\n  private isAnimating = false;\n\n  /**\n   * The MDCTabScrollerRTL instance varies per browser and allows us to\n   * encapsulate the peculiar browser behavior of RTL scrolling in its own\n   * class.\n   */\n  private rtlScrollerInstance?: MDCTabScrollerRTL;\n\n  constructor(adapter?: Partial<MDCTabScrollerAdapter>) {\n    super({...MDCTabScrollerFoundation.defaultAdapter, ...adapter});\n  }\n\n  override init() {\n    // Compute horizontal scrollbar height on scroller with overflow initially\n    // hidden, then update overflow to scroll and immediately adjust bottom\n    // 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\n    // 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      this.scrollToImplRTL(scrollX);\n      return;\n    }\n\n    this.scrollToImpl(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-suppressions \"Unused vars\" should be a linter warning, not a compiler error.\n    // @ts-ignore These unused variables should retain their semantic names for\n    // 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 scrollToImpl(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 scrollToImplRTL(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\n   *     the scroll operation.\n   */\n  private getIncrementScrollOperation(scrollX: number):\n      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\n    // 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(\n          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 =\n        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 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\n/** MDC Tab Scroller RTL Default */\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 =\n        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\n/** MDC Tab Scroller RTL Negative */\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 =\n        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\n/** MDC Tab Scroller RTL Reverse */\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 =\n        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\n/** MDC Tab Scroller RTL */\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):\n      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\n * processing.\n */\nlet horizontalScrollbarHeight_: number|undefined;\n\n/**\n * Computes the height of browser-rendered horizontal scrollbars using a\n * self-created test element. May return 0 (e.g. on OS X browsers under default\n * configuration).\n */\nexport function computeHorizontalScrollbarHeight(\n    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';\n\nimport {MDCTabAdapter} from './adapter';\nimport {MDCTabFoundation} from './foundation';\nimport {MDCTabDimensions, MDCTabInteractionEventDetail} from './types';\n\n/** MDC Tab Factory */\nexport type MDCTabFactory = (el: HTMLElement, foundation?: MDCTabFoundation) =>\n    MDCTab;\n\n/** MDC Tab */\nexport class MDCTab extends MDCComponent<MDCTabFoundation> implements\n    MDCRippleCapableSurface {\n  static override attachTo(root: HTMLElement): 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!:\n      SpecificEventListener<'click'>;  // assigned in initialize();\n\n  override initialize(\n      rippleFactory:\n          MDCRippleFactory = (el, foundation) => new MDCRipple(el, foundation),\n      tabIndicatorFactory:\n          MDCTabIndicatorFactory = (el) => new MDCTabIndicator(el),\n  ) {\n    this.id = this.root.id;\n    const rippleFoundation =\n        new MDCRippleFoundation(MDCRipple.createAdapter(this));\n    this.ripple = rippleFactory(this.root, rippleFoundation);\n\n    const tabIndicatorElement = this.root.querySelector<HTMLElement>(\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  override initialSyncWithDOM() {\n    this.handleClick = () => {\n      this.foundation.handleClick();\n    };\n    this.listen('click', this.handleClick);\n  }\n\n  override destroy() {\n    this.unlisten('click', this.handleClick);\n    this.ripple.destroy();\n    super.destroy();\n  }\n\n  override 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 order as the adapter interface.\n    const adapter: MDCTabAdapter = {\n      setAttr: (attr, value) => {\n        this.safeSetAttribute(this.root, attr, value);\n      },\n      addClass: (className) => {\n        this.root.classList.add(className);\n      },\n      removeClass: (className) => {\n        this.root.classList.remove(className);\n      },\n      hasClass: (className) => this.root.classList.contains(className),\n      activateIndicator: (previousIndicatorClientRect) => {\n        this.tabIndicator.activate(previousIndicatorClientRect);\n      },\n      deactivateIndicator: () => {\n        this.tabIndicator.deactivate();\n      },\n      notifyInteracted: () => {\n        this.emit<MDCTabInteractionEventDetail>(\n            MDCTabFoundation.strings.INTERACTED_EVENT, {tabId: this.id},\n            true /* bubble */);\n      },\n      getOffsetLeft: () => this.root.offsetLeft,\n      getOffsetWidth: () => this.root.offsetWidth,\n      getContentOffsetLeft: () => this.content.offsetLeft,\n      getContentOffsetWidth: () => this.content.offsetWidth,\n      focus: () => {\n        this.root.focus();\n      },\n      isFocused: () => this.root === document.activeElement,\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?: DOMRect) {\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(): DOMRect {\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.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';\n\nimport {MDCTabAdapter} from './adapter';\nimport {cssClasses, strings} from './constants';\nimport {MDCTabDimensions} from './types';\n\n/** MDC Tab Foundation */\nexport class MDCTabFoundation extends MDCFoundation<MDCTabAdapter> {\n  static override get cssClasses() {\n    return cssClasses;\n  }\n\n  static override get strings() {\n    return strings;\n  }\n\n  static override 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      isFocused: () => false,\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?: DOMRect) {\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 && !this.adapter.isFocused()) {\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"],"sourceRoot":""}