{"version":3,"sources":["./node_modules/@angular/material/autocomplete/typings/index.d.ts.MatAutocomplete.html","./node_modules/@angular/material/esm5/autocomplete.es5.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qGAAa,q3BAA2F,6DAAY,iDAAlG,wCAA8B,EAA0B,mBAAsB,aAAnF,YAA2F,EAAtF,SAA8B,EAA0B,SAAsB,mDAAhC,mBAAS,KAA5D,YAA2F,EAAxC,SAAS;wQAAzE,6GAAa;;;;;;;;;;;;;;;;ACAb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACkC;AAC6B;AACD;AACgO;AACxD;AACnL;AAC8B;AACJ;AAClB;AACN;AACE;AACE;AACN;AACS;AACc;AACA;;AAE1E;AACA;AACA,cAAc,uFAAuF;AACrG;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD,WAAW,EAAE;AACb,gCAAgC,iFAAkB;AAClD;AACA;AACA,UAAU;AACV;AACA,2CAA2C,4DAAc;AACzD;AACA;AACA,CAAC;AACD;AACA;AACA,YAAY;AACZ;AACA;AACA,YAAY;AACZ;AACA;AACA,IAAI,uDAAS;AACb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mCAAmC,0DAAY;AAC/C;AACA;AACA;AACA,2BAA2B,0DAAY;AACvC;AACA;AACA;AACA,2BAA2B,0DAAY;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA,qBAAqB,uCAAuC,EAAE;AAC9D;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA,qBAAqB,oCAAoC,EAAE;AAC3D;AACA,mBAAmB,EAAE;AACrB,oBAAoB;AACpB;AACA;AACA,0CAA0C,mFAAqB;AAC/D,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,EAAE;AACrB,oBAAoB;AACpB;AACA;AACA;AACA;AACA,2BAA2B,EAAE;AAC7B,2BAA2B,EAAE;AAC7B,4BAA4B;AAC5B;AACA;AACA;AACA;AACA,iBAAiB,eAAe,EAAE,OAAO;AACzC;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA,gBAAgB;AAChB;AACA;AACA,gBAAgB;AAChB;AACA;AACA,+BAA+B,4EAA0B;AACzD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA,mBAAmB,EAAE;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,OAAO,uDAAS,UAAU;AACnC;AACA,sDAAsD,gBAAgB,gBAAgB,cAAc,iCAAiC,kBAAkB,eAAe,iBAAiB,kBAAkB,WAAW,8BAA8B,+BAA+B,iDAAiD,mBAAmB,gDAAgD,kBAAkB,sDAAsD,gBAAgB,2BAA2B,4BAA4B,gDAAgD,gBAAgB,kCAAkC,wBAAwB,mBAAmB;AACjqB,mCAAmC,+DAAiB;AACpD,qCAAqC,qEAAuB;AAC5D;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA,yBAAyB,UAAU,kFAA2B;AAC9D;AACA,iBAAiB,IAAI;AACrB;AACA;AACA,kDAAkD;AAClD,SAAS,OAAO,+DAAiB,EAAE;AACnC,SAAS,OAAO,wDAAU,EAAE;AAC5B,SAAS,gCAAgC,OAAO,oDAAM,6CAA6C;AACnG,MAAM;AACN;AACA,oBAAoB,OAAO,uDAAS,SAAS,yDAAW,GAAG,eAAe,IAAI;AAC9E,iBAAiB,OAAO,uDAAS,mBAAmB,gBAAgB,IAAI;AACxE,mBAAmB,OAAO,6DAAe,SAAS,gEAAS,GAAG,oBAAoB,IAAI;AACtF,wBAAwB,OAAO,6DAAe,SAAS,kEAAW,IAAI;AACtE,uBAAuB,OAAO,mDAAK,EAAE;AACrC,iCAAiC,OAAO,mDAAK,EAAE;AAC/C,sBAAsB,OAAO,mDAAK,EAAE;AACpC,0BAA0B,OAAO,oDAAM,EAAE;AACzC,kBAAkB,OAAO,oDAAM,EAAE;AACjC,kBAAkB,OAAO,oDAAM,EAAE;AACjC,qBAAqB,OAAO,mDAAK,oBAAoB;AACrD;AACA;AACA,CAAC;;AAED;AACA;AACA,cAAc,uFAAuF;AACrG;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,OAAO,uDAAS;AACzB;AACA;AACA,iBAAiB,IAAI;AACrB;AACA;AACA,wDAAwD;AACxD,SAAS,OAAO,wDAAU;AAC1B,MAAM;AACN;AACA,CAAC;;AAED;AACA;AACA,cAAc,uFAAuF;AACrG;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA;AACA,UAAU;AACV;AACA,2CAA2C,4DAAc;AACzD;AACA;AACA,WAAW,EAAE;AACb,YAAY;AACZ;AACA;AACA;AACA,gBAAgB;AAChB;AACA,iBAAiB,8CAA8C,EAAE;AACjE;AACA;AACA;AACA,UAAU;AACV;AACA;AACA;AACA,WAAW,4DAAO;AAClB;AACA;AACA;AACA;AACA;AACA,UAAU;AACV;AACA;AACA,aAAa,iEAAiB;AAC9B,iBAAiB,gEAAU;AAC3B,gBAAgB;AAChB;AACA,iBAAiB,+BAA+B,EAAE;AAClD;AACA;AACA;AACA;AACA;AACA,YAAY;AACZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qCAAqC,kDAAY;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC,6CAAO;AAC/C;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA,qBAAqB,EAAE;AACvB;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA,qBAAqB,EAAE;AACvB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,4CAA4C,EAAE,KAAK,mDAAK;AACxD,oBAAoB;AACpB;AACA;AACA;AACA,uBAAuB,2CAAK;AAC5B,2BAA2B,EAAE;AAC7B,4BAA4B;AAC5B;AACA,mCAAmC,iCAAiC,EAAE;AACtE;AACA;AACA;AACA;AACA;AACA,sBAAsB,4DAAI,KAAK,iEAAS;AACxC,wBAAwB;AACxB;AACA,yBAAyB,+BAA+B,EAAE;AAC1D,SAAS;AACT;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA,qBAAqB,mCAAmC,EAAE;AAC1D;AACA,mBAAmB,EAAE;AACrB,oBAAoB;AACpB;AACA;AACA,yCAAyC,mFAAqB;AAC9D,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA,gBAAgB;AAChB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB;AACA;AACA;AACA,aAAa;AACb,gBAAgB,gFAAkB;AAClC,2BAA2B,EAAE;AAC7B;AACA,2BAA2B,EAAE;AAC7B;AACA;AACA;AACA,4EAA4E,EAAE;AAC9E;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA,4BAA4B,EAAE;AAC9B;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,wBAAwB,EAAE;AAC1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA,mBAAmB,mDAAK,kEAAkE,8DAAM;AAChG,wBAAwB;AACxB;AACA,yBAAyB,+BAA+B,EAAE;AAC1D,oDAAoD,8DAAM;AAC1D,4BAA4B;AAC5B;AACA,6BAA6B,+BAA+B,EAAE;AAC9D,gBAAgB,gDAAE;AAClB;AACA,YAAY,2DAAG;AACf,uBAAuB,EAAE;AACzB,wBAAwB;AACxB;AACA,8BAA8B,yBAAyB,+EAAwB,gBAAgB,EAAE;AACjG,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,eAAe,mDAAK,aAAa,EAAE,KAAK,uDAAS,yCAAyC,EAAE,KAAK,uDAAS;AAC1G,kBAAkB,8DAAM;AACxB,mBAAmB,EAAE;AACrB,oBAAoB;AACpB;AACA;AACA;AACA;AACA,uBAAuB,EAAE;AACzB,0CAA0C,EAAE;AAC5C;AACA,uBAAuB,EAAE;AACzB;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA,oBAAoB;AACpB;AACA,qBAAqB,sCAAsC,EAAE;AAC7D;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA,mBAAmB,EAAE;AACrB;AACA;AACA;AACA;AACA;AACA,wBAAwB,4DAAM;AAC9B;AACA;AACA,6CAA6C,2DAAK;AAClD;AACA;AACA;AACA;AACA;AACA,uBAAuB,EAAE;AACzB;AACA,uBAAuB,EAAE;AACzB,yCAAyC,8DAAQ,gBAAgB,gEAAU;AAC3E,8CAA8C,yDAAG;AACjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA,mBAAmB,EAAE;AACrB,iCAAiC,EAAE;AACnC,mBAAmB,EAAE;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,GAAG;AAClB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,GAAG;AAClB,gBAAgB;AAChB;AACA;AACA,uCAAuC,uBAAuB;AAC9D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA,mBAAmB,EAAE;AACrB;AACA,mBAAmB,EAAE;AACrB,yBAAyB,4FAA6B;AACtD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,uBAAuB,EAAE;AACzB,oCAAoC,uFAAwB;AAC5D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,mBAAmB,EAAE;AACrB,kEAAkE,4DAAI;AACtE,mBAAmB,EAAE;AACrB,mEAAmE,2DAAG;AACtE,oBAAoB;AACpB;AACA,qBAAqB,sDAAsD,EAAE;AAC7E;AACA;AACA,QAAQ,6DAAK;AACb;AACA,eAAe,mDAAK;AACpB;AACA;AACA;AACA,QAAQ,iEAAS;AACjB,oBAAoB;AACpB;AACA;AACA,uBAAuB,EAAE;AACzB;AACA;AACA;AACA;AACA,4BAA4B,EAAE;AAC9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,QAAQ,4DAAI;AACZ;AACA;AACA,mBAAmB,EAAE;AACrB,oBAAoB;AACpB;AACA,0BAA0B,uCAAuC,EAAE;AACnE;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA,mBAAmB,EAAE;AACrB;AACA;AACA;AACA;AACA;AACA,mBAAmB,EAAE;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA,mBAAmB,EAAE;AACrB,oBAAoB;AACpB;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,EAAE;AACrB;AACA;AACA,+BAA+B,kEAAc;AAC7C;AACA;AACA;AACA;AACA;AACA,uBAAuB,EAAE;AACzB,wBAAwB;AACxB;AACA;AACA;AACA;AACA,sCAAsC,4DAAM,uBAAuB,8DAAQ;AAC3E;AACA;AACA;AACA;AACA;AACA;AACA;AACA,aAAa;AACb;AACA;AACA,4BAA4B;AAC5B;AACA;AACA;AACA,+CAA+C,gCAAgC;AAC/E;AACA,iBAAiB;AACjB;AACA;AACA;AACA;AACA;AACA,mCAAmC,+BAA+B;AAClE;AACA;AACA;AACA;AACA;AACA,mBAAmB,EAAE;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA,mBAAmB,kEAAa;AAChC;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA,mBAAmB,EAAE;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA;AACA;AACA,eAAe,EAAE;AACjB,gBAAgB;AAChB;AACA;AACA,mBAAmB,EAAE;AACrB;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,EAAE;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB,EAAE;AACrB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA;AACA;AACA,gBAAgB;AAChB;AACA;AACA,mBAAmB,EAAE;AACrB;AACA;AACA;AACA;AACA,SAAS,OAAO,uDAAS;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;AACA;AACA,iBAAiB,IAAI;AACrB;AACA;AACA,yDAAyD;AACzD,SAAS,OAAO,wDAAU,EAAE;AAC5B,SAAS,OAAO,4DAAO,EAAE;AACzB,SAAS,OAAO,8DAAgB,EAAE;AAClC,SAAS,OAAO,oDAAM,EAAE;AACxB,SAAS,OAAO,+DAAiB,EAAE;AACnC,SAAS,gCAAgC,OAAO,oDAAM,6CAA6C,GAAG;AACtG,SAAS,OAAO,gEAAc,gBAAgB,OAAO,sDAAQ,EAAE,GAAG;AAClE,SAAS,OAAO,0EAAY,gBAAgB,OAAO,sDAAQ,EAAE,GAAG,OAAO,kDAAI,EAAE,GAAG;AAChF,SAAS,gCAAgC,OAAO,sDAAQ,EAAE,GAAG,OAAO,oDAAM,SAAS,yDAAQ,IAAI,GAAG;AAClG,SAAS,OAAO,qEAAa;AAC7B,MAAM;AACN;AACA,wBAAwB,OAAO,mDAAK,8BAA8B;AAClE,oBAAoB,OAAO,mDAAK,sCAAsC;AACtE,uBAAuB,OAAO,mDAAK,yCAAyC;AAC5E,iCAAiC,OAAO,mDAAK,2BAA2B;AACxE,gCAAgC,OAAO,mDAAK,sCAAsC;AAClF;AACA;AACA,CAAC;;AAED;AACA;AACA,cAAc,uFAAuF;AACrG;AACA;AACA;AACA;AACA;AACA,SAAS,OAAO,sDAAQ;AACxB,8BAA8B,sEAAe,EAAE,kEAAa,EAAE,sEAAe,EAAE,6DAAY;AAC3F;AACA;AACA,wBAAwB,sEAAe;AACvC;AACA;AACA,wBAAwB,sEAAe;AACvC;AACA;AACA;AACA,iBAAiB,IAAI;AACrB;AACA;AACA,CAAC;;AAED;AACA;AACA,cAAc,uFAAuF;AACrG;;AAEA;AACA;AACA,cAAc,uFAAuF;AACrG;;AAEuc;AACvc","file":"default~modules-ranch-home-module-ngfactory~modules-ranches-admin-ranches-module-ngfactory.f2ccd67472a007a46c25.js","sourcesContent":["<ng-template><div class=\"mat-autocomplete-panel\" role=\"listbox\" [id]=\"id\" [ngClass]=\"_classList\" #panel><ng-content></ng-content></div></ng-template>","/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { __extends } from 'tslib';\nimport { ActiveDescendantKeyManager } from '@angular/cdk/a11y';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChildren, ElementRef, EventEmitter, Inject, InjectionToken, Input, Output, TemplateRef, ViewChild, ViewEncapsulation, Directive, forwardRef, Host, NgZone, Optional, ViewContainerRef, NgModule } from '@angular/core';\nimport { MAT_OPTION_PARENT_COMPONENT, MatOptgroup, MatOption, mixinDisableRipple, _countGroupLabelsBeforeOption, _getOptionScrollPosition, MatOptionSelectionChange, MatOptionModule, MatCommonModule } from '@angular/material/core';\nimport { Directionality } from '@angular/cdk/bidi';\nimport { DOWN_ARROW, ENTER, ESCAPE, TAB, UP_ARROW } from '@angular/cdk/keycodes';\nimport { Overlay, OverlayConfig, OverlayModule } from '@angular/cdk/overlay';\nimport { _supportsShadowDom } from '@angular/cdk/platform';\nimport { TemplatePortal } from '@angular/cdk/portal';\nimport { ViewportRuler } from '@angular/cdk/scrolling';\nimport { DOCUMENT, CommonModule } from '@angular/common';\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { MatFormField } from '@angular/material/form-field';\nimport { defer, fromEvent, merge, of, Subject, Subscription } from 'rxjs';\nimport { delay, filter, map, switchMap, take, tap } from 'rxjs/operators';\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Autocomplete IDs need to be unique across components, so this counter exists outside of\n * the component definition.\n * @type {?}\n */\nvar _uniqueAutocompleteIdCounter = 0;\n/**\n * Event object that is emitted when an autocomplete option is selected.\n */\nvar /**\n * Event object that is emitted when an autocomplete option is selected.\n */\nMatAutocompleteSelectedEvent = /** @class */ (function () {\n function MatAutocompleteSelectedEvent(source, option) {\n this.source = source;\n this.option = option;\n }\n return MatAutocompleteSelectedEvent;\n}());\n// Boilerplate for applying mixins to MatAutocomplete.\n/**\n * \\@docs-private\n */\nvar \n// Boilerplate for applying mixins to MatAutocomplete.\n/**\n * \\@docs-private\n */\nMatAutocompleteBase = /** @class */ (function () {\n function MatAutocompleteBase() {\n }\n return MatAutocompleteBase;\n}());\n/** @type {?} */\nvar _MatAutocompleteMixinBase = mixinDisableRipple(MatAutocompleteBase);\n/**\n * Injection token to be used to override the default options for `mat-autocomplete`.\n * @type {?}\n */\nvar MAT_AUTOCOMPLETE_DEFAULT_OPTIONS = new InjectionToken('mat-autocomplete-default-options', {\n providedIn: 'root',\n factory: MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY,\n});\n/**\n * \\@docs-private\n * @return {?}\n */\nfunction MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY() {\n return { autoActiveFirstOption: false };\n}\nvar MatAutocomplete = /** @class */ (function (_super) {\n __extends(MatAutocomplete, _super);\n function MatAutocomplete(_changeDetectorRef, _elementRef, defaults) {\n var _this = _super.call(this) || this;\n _this._changeDetectorRef = _changeDetectorRef;\n _this._elementRef = _elementRef;\n /**\n * Whether the autocomplete panel should be visible, depending on option length.\n */\n _this.showPanel = false;\n _this._isOpen = false;\n /**\n * Function that maps an option's control value to its display value in the trigger.\n */\n _this.displayWith = null;\n /**\n * Event that is emitted whenever an option from the list is selected.\n */\n _this.optionSelected = new EventEmitter();\n /**\n * Event that is emitted when the autocomplete panel is opened.\n */\n _this.opened = new EventEmitter();\n /**\n * Event that is emitted when the autocomplete panel is closed.\n */\n _this.closed = new EventEmitter();\n _this._classList = {};\n /**\n * Unique ID to be used by autocomplete trigger's \"aria-owns\" property.\n */\n _this.id = \"mat-autocomplete-\" + _uniqueAutocompleteIdCounter++;\n _this._autoActiveFirstOption = !!defaults.autoActiveFirstOption;\n return _this;\n }\n Object.defineProperty(MatAutocomplete.prototype, \"isOpen\", {\n /** Whether the autocomplete panel is open. */\n get: /**\n * Whether the autocomplete panel is open.\n * @return {?}\n */\n function () { return this._isOpen && this.showPanel; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(MatAutocomplete.prototype, \"autoActiveFirstOption\", {\n /**\n * Whether the first option should be highlighted when the autocomplete panel is opened.\n * Can be configured globally through the `MAT_AUTOCOMPLETE_DEFAULT_OPTIONS` token.\n */\n get: /**\n * Whether the first option should be highlighted when the autocomplete panel is opened.\n * Can be configured globally through the `MAT_AUTOCOMPLETE_DEFAULT_OPTIONS` token.\n * @return {?}\n */\n function () { return this._autoActiveFirstOption; },\n set: /**\n * @param {?} value\n * @return {?}\n */\n function (value) {\n this._autoActiveFirstOption = coerceBooleanProperty(value);\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(MatAutocomplete.prototype, \"classList\", {\n /**\n * Takes classes set on the host mat-autocomplete element and applies them to the panel\n * inside the overlay container to allow for easy styling.\n */\n set: /**\n * Takes classes set on the host mat-autocomplete element and applies them to the panel\n * inside the overlay container to allow for easy styling.\n * @param {?} value\n * @return {?}\n */\n function (value) {\n if (value && value.length) {\n this._classList = value.split(' ').reduce((/**\n * @param {?} classList\n * @param {?} className\n * @return {?}\n */\n function (classList, className) {\n classList[className.trim()] = true;\n return classList;\n }), (/** @type {?} */ ({})));\n }\n else {\n this._classList = {};\n }\n this._setVisibilityClasses(this._classList);\n this._elementRef.nativeElement.className = '';\n },\n enumerable: true,\n configurable: true\n });\n /**\n * @return {?}\n */\n MatAutocomplete.prototype.ngAfterContentInit = /**\n * @return {?}\n */\n function () {\n this._keyManager = new ActiveDescendantKeyManager(this.options).withWrap();\n // Set the initial visibility state.\n this._setVisibility();\n };\n /**\n * Sets the panel scrollTop. This allows us to manually scroll to display options\n * above or below the fold, as they are not actually being focused when active.\n */\n /**\n * Sets the panel scrollTop. This allows us to manually scroll to display options\n * above or below the fold, as they are not actually being focused when active.\n * @param {?} scrollTop\n * @return {?}\n */\n MatAutocomplete.prototype._setScrollTop = /**\n * Sets the panel scrollTop. This allows us to manually scroll to display options\n * above or below the fold, as they are not actually being focused when active.\n * @param {?} scrollTop\n * @return {?}\n */\n function (scrollTop) {\n if (this.panel) {\n this.panel.nativeElement.scrollTop = scrollTop;\n }\n };\n /** Returns the panel's scrollTop. */\n /**\n * Returns the panel's scrollTop.\n * @return {?}\n */\n MatAutocomplete.prototype._getScrollTop = /**\n * Returns the panel's scrollTop.\n * @return {?}\n */\n function () {\n return this.panel ? this.panel.nativeElement.scrollTop : 0;\n };\n /** Panel should hide itself when the option list is empty. */\n /**\n * Panel should hide itself when the option list is empty.\n * @return {?}\n */\n MatAutocomplete.prototype._setVisibility = /**\n * Panel should hide itself when the option list is empty.\n * @return {?}\n */\n function () {\n this.showPanel = !!this.options.length;\n this._setVisibilityClasses(this._classList);\n this._changeDetectorRef.markForCheck();\n };\n /** Emits the `select` event. */\n /**\n * Emits the `select` event.\n * @param {?} option\n * @return {?}\n */\n MatAutocomplete.prototype._emitSelectEvent = /**\n * Emits the `select` event.\n * @param {?} option\n * @return {?}\n */\n function (option) {\n /** @type {?} */\n var event = new MatAutocompleteSelectedEvent(this, option);\n this.optionSelected.emit(event);\n };\n /** Sets the autocomplete visibility classes on a classlist based on the panel is visible. */\n /**\n * Sets the autocomplete visibility classes on a classlist based on the panel is visible.\n * @private\n * @param {?} classList\n * @return {?}\n */\n MatAutocomplete.prototype._setVisibilityClasses = /**\n * Sets the autocomplete visibility classes on a classlist based on the panel is visible.\n * @private\n * @param {?} classList\n * @return {?}\n */\n function (classList) {\n classList['mat-autocomplete-visible'] = this.showPanel;\n classList['mat-autocomplete-hidden'] = !this.showPanel;\n };\n MatAutocomplete.decorators = [\n { type: Component, args: [{selector: 'mat-autocomplete',\n template: \"<ng-template><div class=\\\"mat-autocomplete-panel\\\" role=\\\"listbox\\\" [id]=\\\"id\\\" [ngClass]=\\\"_classList\\\" #panel><ng-content></ng-content></div></ng-template>\",\n styles: [\".mat-autocomplete-panel{min-width:112px;max-width:280px;overflow:auto;-webkit-overflow-scrolling:touch;visibility:hidden;max-width:none;max-height:256px;position:relative;width:100%;border-bottom-left-radius:4px;border-bottom-right-radius:4px}.mat-autocomplete-panel.mat-autocomplete-visible{visibility:visible}.mat-autocomplete-panel.mat-autocomplete-hidden{visibility:hidden}.mat-autocomplete-panel-above .mat-autocomplete-panel{border-radius:0;border-top-left-radius:4px;border-top-right-radius:4px}.mat-autocomplete-panel .mat-divider-horizontal{margin-top:-1px}@media (-ms-high-contrast:active){.mat-autocomplete-panel{outline:solid 1px}}\"],\n encapsulation: ViewEncapsulation.None,\n changeDetection: ChangeDetectionStrategy.OnPush,\n exportAs: 'matAutocomplete',\n inputs: ['disableRipple'],\n host: {\n 'class': 'mat-autocomplete'\n },\n providers: [\n { provide: MAT_OPTION_PARENT_COMPONENT, useExisting: MatAutocomplete }\n ]\n },] },\n ];\n /** @nocollapse */\n MatAutocomplete.ctorParameters = function () { return [\n { type: ChangeDetectorRef },\n { type: ElementRef },\n { type: undefined, decorators: [{ type: Inject, args: [MAT_AUTOCOMPLETE_DEFAULT_OPTIONS,] }] }\n ]; };\n MatAutocomplete.propDecorators = {\n template: [{ type: ViewChild, args: [TemplateRef, { static: true },] }],\n panel: [{ type: ViewChild, args: ['panel', { static: false },] }],\n options: [{ type: ContentChildren, args: [MatOption, { descendants: true },] }],\n optionGroups: [{ type: ContentChildren, args: [MatOptgroup,] }],\n displayWith: [{ type: Input }],\n autoActiveFirstOption: [{ type: Input }],\n panelWidth: [{ type: Input }],\n optionSelected: [{ type: Output }],\n opened: [{ type: Output }],\n closed: [{ type: Output }],\n classList: [{ type: Input, args: ['class',] }]\n };\n return MatAutocomplete;\n}(_MatAutocompleteMixinBase));\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Directive applied to an element to make it usable\n * as a connection point for an autocomplete panel.\n */\nvar MatAutocompleteOrigin = /** @class */ (function () {\n function MatAutocompleteOrigin(elementRef) {\n this.elementRef = elementRef;\n }\n MatAutocompleteOrigin.decorators = [\n { type: Directive, args: [{\n selector: '[matAutocompleteOrigin]',\n exportAs: 'matAutocompleteOrigin',\n },] },\n ];\n /** @nocollapse */\n MatAutocompleteOrigin.ctorParameters = function () { return [\n { type: ElementRef }\n ]; };\n return MatAutocompleteOrigin;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * The height of each autocomplete option.\n * @type {?}\n */\nvar AUTOCOMPLETE_OPTION_HEIGHT = 48;\n/**\n * The total height of the autocomplete panel.\n * @type {?}\n */\nvar AUTOCOMPLETE_PANEL_HEIGHT = 256;\n/**\n * Injection token that determines the scroll handling while the autocomplete panel is open.\n * @type {?}\n */\nvar MAT_AUTOCOMPLETE_SCROLL_STRATEGY = new InjectionToken('mat-autocomplete-scroll-strategy');\n/**\n * \\@docs-private\n * @param {?} overlay\n * @return {?}\n */\nfunction MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY(overlay) {\n return (/**\n * @return {?}\n */\n function () { return overlay.scrollStrategies.reposition(); });\n}\n/**\n * \\@docs-private\n * @type {?}\n */\nvar MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER = {\n provide: MAT_AUTOCOMPLETE_SCROLL_STRATEGY,\n deps: [Overlay],\n useFactory: MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY,\n};\n/**\n * Provider that allows the autocomplete to register as a ControlValueAccessor.\n * \\@docs-private\n * @type {?}\n */\nvar MAT_AUTOCOMPLETE_VALUE_ACCESSOR = {\n provide: NG_VALUE_ACCESSOR,\n useExisting: forwardRef((/**\n * @return {?}\n */\n function () { return MatAutocompleteTrigger; })),\n multi: true\n};\n/**\n * Creates an error to be thrown when attempting to use an autocomplete trigger without a panel.\n * \\@docs-private\n * @return {?}\n */\nfunction getMatAutocompleteMissingPanelError() {\n return Error('Attempting to open an undefined instance of `mat-autocomplete`. ' +\n 'Make sure that the id passed to the `matAutocomplete` is correct and that ' +\n 'you\\'re attempting to open it after the ngAfterContentInit hook.');\n}\nvar MatAutocompleteTrigger = /** @class */ (function () {\n function MatAutocompleteTrigger(_element, _overlay, _viewContainerRef, _zone, _changeDetectorRef, scrollStrategy, _dir, _formField, _document, _viewportRuler) {\n var _this = this;\n this._element = _element;\n this._overlay = _overlay;\n this._viewContainerRef = _viewContainerRef;\n this._zone = _zone;\n this._changeDetectorRef = _changeDetectorRef;\n this._dir = _dir;\n this._formField = _formField;\n this._document = _document;\n this._viewportRuler = _viewportRuler;\n this._componentDestroyed = false;\n this._autocompleteDisabled = false;\n /**\n * Whether or not the label state is being overridden.\n */\n this._manuallyFloatingLabel = false;\n /**\n * Subscription to viewport size changes.\n */\n this._viewportSubscription = Subscription.EMPTY;\n /**\n * Whether the autocomplete can open the next time it is focused. Used to prevent a focused,\n * closed autocomplete from being reopened if the user switches to another browser tab and then\n * comes back.\n */\n this._canOpenOnNextFocus = true;\n /**\n * Stream of keyboard events that can close the panel.\n */\n this._closeKeyEventStream = new Subject();\n /**\n * Event handler for when the window is blurred. Needs to be an\n * arrow function in order to preserve the context.\n */\n this._windowBlurHandler = (/**\n * @return {?}\n */\n function () {\n // If the user blurred the window while the autocomplete is focused, it means that it'll be\n // refocused when they come back. In this case we want to skip the first focus event, if the\n // pane was closed, in order to avoid reopening it unintentionally.\n _this._canOpenOnNextFocus =\n _this._document.activeElement !== _this._element.nativeElement || _this.panelOpen;\n });\n /**\n * `View -> model callback called when value changes`\n */\n this._onChange = (/**\n * @return {?}\n */\n function () { });\n /**\n * `View -> model callback called when autocomplete has been touched`\n */\n this._onTouched = (/**\n * @return {?}\n */\n function () { });\n /**\n * Position of the autocomplete panel relative to the trigger element. A position of `auto`\n * will render the panel underneath the trigger if there is enough space for it to fit in\n * the viewport, otherwise the panel will be shown above it. If the position is set to\n * `above` or `below`, the panel will always be shown above or below the trigger. no matter\n * whether it fits completely in the viewport.\n */\n this.position = 'auto';\n /**\n * `autocomplete` attribute to be set on the input element.\n * \\@docs-private\n */\n this.autocompleteAttribute = 'off';\n this._overlayAttached = false;\n /**\n * Stream of autocomplete option selections.\n */\n this.optionSelections = (/** @type {?} */ (defer((/**\n * @return {?}\n */\n function () {\n if (_this.autocomplete && _this.autocomplete.options) {\n return merge.apply(void 0, _this.autocomplete.options.map((/**\n * @param {?} option\n * @return {?}\n */\n function (option) { return option.onSelectionChange; })));\n }\n // If there are any subscribers before `ngAfterViewInit`, the `autocomplete` will be undefined.\n // Return a stream that we'll replace with the real one once everything is in place.\n return _this._zone.onStable\n .asObservable()\n .pipe(take(1), switchMap((/**\n * @return {?}\n */\n function () { return _this.optionSelections; })));\n }))));\n this._scrollStrategy = scrollStrategy;\n }\n Object.defineProperty(MatAutocompleteTrigger.prototype, \"autocompleteDisabled\", {\n /**\n * Whether the autocomplete is disabled. When disabled, the element will\n * act as a regular input and the user won't be able to open the panel.\n */\n get: /**\n * Whether the autocomplete is disabled. When disabled, the element will\n * act as a regular input and the user won't be able to open the panel.\n * @return {?}\n */\n function () { return this._autocompleteDisabled; },\n set: /**\n * @param {?} value\n * @return {?}\n */\n function (value) {\n this._autocompleteDisabled = coerceBooleanProperty(value);\n },\n enumerable: true,\n configurable: true\n });\n /**\n * @return {?}\n */\n MatAutocompleteTrigger.prototype.ngAfterViewInit = /**\n * @return {?}\n */\n function () {\n var _this = this;\n if (typeof window !== 'undefined') {\n this._zone.runOutsideAngular((/**\n * @return {?}\n */\n function () {\n window.addEventListener('blur', _this._windowBlurHandler);\n }));\n if (_supportsShadowDom()) {\n /** @type {?} */\n var element = this._element.nativeElement;\n /** @type {?} */\n var rootNode = element.getRootNode ? element.getRootNode() : null;\n // We need to take the `ShadowRoot` off of `window`, because the built-in types are\n // incorrect. See https://github.com/Microsoft/TypeScript/issues/27929.\n this._isInsideShadowRoot = rootNode instanceof ((/** @type {?} */ (window))).ShadowRoot;\n }\n }\n };\n /**\n * @param {?} changes\n * @return {?}\n */\n MatAutocompleteTrigger.prototype.ngOnChanges = /**\n * @param {?} changes\n * @return {?}\n */\n function (changes) {\n if (changes['position'] && this._positionStrategy) {\n this._setStrategyPositions(this._positionStrategy);\n if (this.panelOpen) {\n (/** @type {?} */ (this._overlayRef)).updatePosition();\n }\n }\n };\n /**\n * @return {?}\n */\n MatAutocompleteTrigger.prototype.ngOnDestroy = /**\n * @return {?}\n */\n function () {\n if (typeof window !== 'undefined') {\n window.removeEventListener('blur', this._windowBlurHandler);\n }\n this._viewportSubscription.unsubscribe();\n this._componentDestroyed = true;\n this._destroyPanel();\n this._closeKeyEventStream.complete();\n };\n Object.defineProperty(MatAutocompleteTrigger.prototype, \"panelOpen\", {\n /** Whether or not the autocomplete panel is open. */\n get: /**\n * Whether or not the autocomplete panel is open.\n * @return {?}\n */\n function () {\n return this._overlayAttached && this.autocomplete.showPanel;\n },\n enumerable: true,\n configurable: true\n });\n /** Opens the autocomplete suggestion panel. */\n /**\n * Opens the autocomplete suggestion panel.\n * @return {?}\n */\n MatAutocompleteTrigger.prototype.openPanel = /**\n * Opens the autocomplete suggestion panel.\n * @return {?}\n */\n function () {\n this._attachOverlay();\n this._floatLabel();\n };\n /** Closes the autocomplete suggestion panel. */\n /**\n * Closes the autocomplete suggestion panel.\n * @return {?}\n */\n MatAutocompleteTrigger.prototype.closePanel = /**\n * Closes the autocomplete suggestion panel.\n * @return {?}\n */\n function () {\n this._resetLabel();\n if (!this._overlayAttached) {\n return;\n }\n if (this.panelOpen) {\n // Only emit if the panel was visible.\n this.autocomplete.closed.emit();\n }\n this.autocomplete._isOpen = this._overlayAttached = false;\n if (this._overlayRef && this._overlayRef.hasAttached()) {\n this._overlayRef.detach();\n this._closingActionsSubscription.unsubscribe();\n }\n // Note that in some cases this can end up being called after the component is destroyed.\n // Add a check to ensure that we don't try to run change detection on a destroyed view.\n if (!this._componentDestroyed) {\n // We need to trigger change detection manually, because\n // `fromEvent` doesn't seem to do it at the proper time.\n // This ensures that the label is reset when the\n // user clicks outside.\n this._changeDetectorRef.detectChanges();\n }\n };\n /**\n * Updates the position of the autocomplete suggestion panel to ensure that it fits all options\n * within the viewport.\n */\n /**\n * Updates the position of the autocomplete suggestion panel to ensure that it fits all options\n * within the viewport.\n * @return {?}\n */\n MatAutocompleteTrigger.prototype.updatePosition = /**\n * Updates the position of the autocomplete suggestion panel to ensure that it fits all options\n * within the viewport.\n * @return {?}\n */\n function () {\n if (this._overlayAttached) {\n (/** @type {?} */ (this._overlayRef)).updatePosition();\n }\n };\n Object.defineProperty(MatAutocompleteTrigger.prototype, \"panelClosingActions\", {\n /**\n * A stream of actions that should close the autocomplete panel, including\n * when an option is selected, on blur, and when TAB is pressed.\n */\n get: /**\n * A stream of actions that should close the autocomplete panel, including\n * when an option is selected, on blur, and when TAB is pressed.\n * @return {?}\n */\n function () {\n var _this = this;\n return merge(this.optionSelections, this.autocomplete._keyManager.tabOut.pipe(filter((/**\n * @return {?}\n */\n function () { return _this._overlayAttached; }))), this._closeKeyEventStream, this._getOutsideClickStream(), this._overlayRef ?\n this._overlayRef.detachments().pipe(filter((/**\n * @return {?}\n */\n function () { return _this._overlayAttached; }))) :\n of()).pipe(\n // Normalize the output so we return a consistent type.\n map((/**\n * @param {?} event\n * @return {?}\n */\n function (event) { return event instanceof MatOptionSelectionChange ? event : null; })));\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(MatAutocompleteTrigger.prototype, \"activeOption\", {\n /** The currently active option, coerced to MatOption type. */\n get: /**\n * The currently active option, coerced to MatOption type.\n * @return {?}\n */\n function () {\n if (this.autocomplete && this.autocomplete._keyManager) {\n return this.autocomplete._keyManager.activeItem;\n }\n return null;\n },\n enumerable: true,\n configurable: true\n });\n /** Stream of clicks outside of the autocomplete panel. */\n /**\n * Stream of clicks outside of the autocomplete panel.\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._getOutsideClickStream = /**\n * Stream of clicks outside of the autocomplete panel.\n * @private\n * @return {?}\n */\n function () {\n var _this = this;\n return merge((/** @type {?} */ (fromEvent(this._document, 'click'))), (/** @type {?} */ (fromEvent(this._document, 'touchend'))))\n .pipe(filter((/**\n * @param {?} event\n * @return {?}\n */\n function (event) {\n // If we're in the Shadow DOM, the event target will be the shadow root, so we have to\n // fall back to check the first element in the path of the click event.\n /** @type {?} */\n var clickTarget = (/** @type {?} */ ((_this._isInsideShadowRoot && event.composedPath ? event.composedPath()[0] :\n event.target)));\n /** @type {?} */\n var formField = _this._formField ? _this._formField._elementRef.nativeElement : null;\n return _this._overlayAttached && clickTarget !== _this._element.nativeElement &&\n (!formField || !formField.contains(clickTarget)) &&\n (!!_this._overlayRef && !_this._overlayRef.overlayElement.contains(clickTarget));\n })));\n };\n // Implemented as part of ControlValueAccessor.\n // Implemented as part of ControlValueAccessor.\n /**\n * @param {?} value\n * @return {?}\n */\n MatAutocompleteTrigger.prototype.writeValue = \n // Implemented as part of ControlValueAccessor.\n /**\n * @param {?} value\n * @return {?}\n */\n function (value) {\n var _this = this;\n Promise.resolve(null).then((/**\n * @return {?}\n */\n function () { return _this._setTriggerValue(value); }));\n };\n // Implemented as part of ControlValueAccessor.\n // Implemented as part of ControlValueAccessor.\n /**\n * @param {?} fn\n * @return {?}\n */\n MatAutocompleteTrigger.prototype.registerOnChange = \n // Implemented as part of ControlValueAccessor.\n /**\n * @param {?} fn\n * @return {?}\n */\n function (fn) {\n this._onChange = fn;\n };\n // Implemented as part of ControlValueAccessor.\n // Implemented as part of ControlValueAccessor.\n /**\n * @param {?} fn\n * @return {?}\n */\n MatAutocompleteTrigger.prototype.registerOnTouched = \n // Implemented as part of ControlValueAccessor.\n /**\n * @param {?} fn\n * @return {?}\n */\n function (fn) {\n this._onTouched = fn;\n };\n // Implemented as part of ControlValueAccessor.\n // Implemented as part of ControlValueAccessor.\n /**\n * @param {?} isDisabled\n * @return {?}\n */\n MatAutocompleteTrigger.prototype.setDisabledState = \n // Implemented as part of ControlValueAccessor.\n /**\n * @param {?} isDisabled\n * @return {?}\n */\n function (isDisabled) {\n this._element.nativeElement.disabled = isDisabled;\n };\n /**\n * @param {?} event\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._handleKeydown = /**\n * @param {?} event\n * @return {?}\n */\n function (event) {\n /** @type {?} */\n var keyCode = event.keyCode;\n // Prevent the default action on all escape key presses. This is here primarily to bring IE\n // in line with other browsers. By default, pressing escape on IE will cause it to revert\n // the input value to the one that it had on focus, however it won't dispatch any events\n // which means that the model value will be out of sync with the view.\n if (keyCode === ESCAPE) {\n event.preventDefault();\n }\n if (this.activeOption && keyCode === ENTER && this.panelOpen) {\n this.activeOption._selectViaInteraction();\n this._resetActiveItem();\n event.preventDefault();\n }\n else if (this.autocomplete) {\n /** @type {?} */\n var prevActiveItem = this.autocomplete._keyManager.activeItem;\n /** @type {?} */\n var isArrowKey = keyCode === UP_ARROW || keyCode === DOWN_ARROW;\n if (this.panelOpen || keyCode === TAB) {\n this.autocomplete._keyManager.onKeydown(event);\n }\n else if (isArrowKey && this._canOpen()) {\n this.openPanel();\n }\n if (isArrowKey || this.autocomplete._keyManager.activeItem !== prevActiveItem) {\n this._scrollToOption();\n }\n }\n };\n /**\n * @param {?} event\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._handleInput = /**\n * @param {?} event\n * @return {?}\n */\n function (event) {\n /** @type {?} */\n var target = (/** @type {?} */ (event.target));\n /** @type {?} */\n var value = target.value;\n // Based on `NumberValueAccessor` from forms.\n if (target.type === 'number') {\n value = value == '' ? null : parseFloat(value);\n }\n // If the input has a placeholder, IE will fire the `input` event on page load,\n // focus and blur, in addition to when the user actually changed the value. To\n // filter out all of the extra events, we save the value on focus and between\n // `input` events, and we check whether it changed.\n // See: https://connect.microsoft.com/IE/feedback/details/885747/\n if (this._previousValue !== value) {\n this._previousValue = value;\n this._onChange(value);\n if (this._canOpen() && this._document.activeElement === event.target) {\n this.openPanel();\n }\n }\n };\n /**\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._handleFocus = /**\n * @return {?}\n */\n function () {\n if (!this._canOpenOnNextFocus) {\n this._canOpenOnNextFocus = true;\n }\n else if (this._canOpen()) {\n this._previousValue = this._element.nativeElement.value;\n this._attachOverlay();\n this._floatLabel(true);\n }\n };\n /**\n * In \"auto\" mode, the label will animate down as soon as focus is lost.\n * This causes the value to jump when selecting an option with the mouse.\n * This method manually floats the label until the panel can be closed.\n * @param shouldAnimate Whether the label should be animated when it is floated.\n */\n /**\n * In \"auto\" mode, the label will animate down as soon as focus is lost.\n * This causes the value to jump when selecting an option with the mouse.\n * This method manually floats the label until the panel can be closed.\n * @private\n * @param {?=} shouldAnimate Whether the label should be animated when it is floated.\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._floatLabel = /**\n * In \"auto\" mode, the label will animate down as soon as focus is lost.\n * This causes the value to jump when selecting an option with the mouse.\n * This method manually floats the label until the panel can be closed.\n * @private\n * @param {?=} shouldAnimate Whether the label should be animated when it is floated.\n * @return {?}\n */\n function (shouldAnimate) {\n if (shouldAnimate === void 0) { shouldAnimate = false; }\n if (this._formField && this._formField.floatLabel === 'auto') {\n if (shouldAnimate) {\n this._formField._animateAndLockLabel();\n }\n else {\n this._formField.floatLabel = 'always';\n }\n this._manuallyFloatingLabel = true;\n }\n };\n /** If the label has been manually elevated, return it to its normal state. */\n /**\n * If the label has been manually elevated, return it to its normal state.\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._resetLabel = /**\n * If the label has been manually elevated, return it to its normal state.\n * @private\n * @return {?}\n */\n function () {\n if (this._manuallyFloatingLabel) {\n this._formField.floatLabel = 'auto';\n this._manuallyFloatingLabel = false;\n }\n };\n /**\n * Given that we are not actually focusing active options, we must manually adjust scroll\n * to reveal options below the fold. First, we find the offset of the option from the top\n * of the panel. If that offset is below the fold, the new scrollTop will be the offset -\n * the panel height + the option height, so the active option will be just visible at the\n * bottom of the panel. If that offset is above the top of the visible panel, the new scrollTop\n * will become the offset. If that offset is visible within the panel already, the scrollTop is\n * not adjusted.\n */\n /**\n * Given that we are not actually focusing active options, we must manually adjust scroll\n * to reveal options below the fold. First, we find the offset of the option from the top\n * of the panel. If that offset is below the fold, the new scrollTop will be the offset -\n * the panel height + the option height, so the active option will be just visible at the\n * bottom of the panel. If that offset is above the top of the visible panel, the new scrollTop\n * will become the offset. If that offset is visible within the panel already, the scrollTop is\n * not adjusted.\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._scrollToOption = /**\n * Given that we are not actually focusing active options, we must manually adjust scroll\n * to reveal options below the fold. First, we find the offset of the option from the top\n * of the panel. If that offset is below the fold, the new scrollTop will be the offset -\n * the panel height + the option height, so the active option will be just visible at the\n * bottom of the panel. If that offset is above the top of the visible panel, the new scrollTop\n * will become the offset. If that offset is visible within the panel already, the scrollTop is\n * not adjusted.\n * @private\n * @return {?}\n */\n function () {\n /** @type {?} */\n var index = this.autocomplete._keyManager.activeItemIndex || 0;\n /** @type {?} */\n var labelCount = _countGroupLabelsBeforeOption(index, this.autocomplete.options, this.autocomplete.optionGroups);\n if (index === 0 && labelCount === 1) {\n // If we've got one group label before the option and we're at the top option,\n // scroll the list to the top. This is better UX than scrolling the list to the\n // top of the option, because it allows the user to read the top group's label.\n this.autocomplete._setScrollTop(0);\n }\n else {\n /** @type {?} */\n var newScrollPosition = _getOptionScrollPosition(index + labelCount, AUTOCOMPLETE_OPTION_HEIGHT, this.autocomplete._getScrollTop(), AUTOCOMPLETE_PANEL_HEIGHT);\n this.autocomplete._setScrollTop(newScrollPosition);\n }\n };\n /**\n * This method listens to a stream of panel closing actions and resets the\n * stream every time the option list changes.\n */\n /**\n * This method listens to a stream of panel closing actions and resets the\n * stream every time the option list changes.\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._subscribeToClosingActions = /**\n * This method listens to a stream of panel closing actions and resets the\n * stream every time the option list changes.\n * @private\n * @return {?}\n */\n function () {\n var _this = this;\n /** @type {?} */\n var firstStable = this._zone.onStable.asObservable().pipe(take(1));\n /** @type {?} */\n var optionChanges = this.autocomplete.options.changes.pipe(tap((/**\n * @return {?}\n */\n function () { return _this._positionStrategy.reapplyLastPosition(); })), \n // Defer emitting to the stream until the next tick, because changing\n // bindings in here will cause \"changed after checked\" errors.\n delay(0));\n // When the zone is stable initially, and when the option list changes...\n return merge(firstStable, optionChanges)\n .pipe(\n // create a new stream of panelClosingActions, replacing any previous streams\n // that were created, and flatten it so our stream only emits closing events...\n switchMap((/**\n * @return {?}\n */\n function () {\n /** @type {?} */\n var wasOpen = _this.panelOpen;\n _this._resetActiveItem();\n _this.autocomplete._setVisibility();\n if (_this.panelOpen) {\n (/** @type {?} */ (_this._overlayRef)).updatePosition();\n // If the `panelOpen` state changed, we need to make sure to emit the `opened`\n // event, because we may not have emitted it when the panel was attached. This\n // can happen if the users opens the panel and there are no options, but the\n // options come in slightly later or as a result of the value changing.\n if (wasOpen !== _this.panelOpen) {\n _this.autocomplete.opened.emit();\n }\n }\n return _this.panelClosingActions;\n })), \n // when the first closing event occurs...\n take(1))\n // set the value, close the panel, and complete.\n .subscribe((/**\n * @param {?} event\n * @return {?}\n */\n function (event) { return _this._setValueAndClose(event); }));\n };\n /** Destroys the autocomplete suggestion panel. */\n /**\n * Destroys the autocomplete suggestion panel.\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._destroyPanel = /**\n * Destroys the autocomplete suggestion panel.\n * @private\n * @return {?}\n */\n function () {\n if (this._overlayRef) {\n this.closePanel();\n this._overlayRef.dispose();\n this._overlayRef = null;\n }\n };\n /**\n * @private\n * @param {?} value\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._setTriggerValue = /**\n * @private\n * @param {?} value\n * @return {?}\n */\n function (value) {\n /** @type {?} */\n var toDisplay = this.autocomplete && this.autocomplete.displayWith ?\n this.autocomplete.displayWith(value) :\n value;\n // Simply falling back to an empty string if the display value is falsy does not work properly.\n // The display value can also be the number zero and shouldn't fall back to an empty string.\n /** @type {?} */\n var inputValue = toDisplay != null ? toDisplay : '';\n // If it's used within a `MatFormField`, we should set it through the property so it can go\n // through change detection.\n if (this._formField) {\n this._formField._control.value = inputValue;\n }\n else {\n this._element.nativeElement.value = inputValue;\n }\n this._previousValue = inputValue;\n };\n /**\n * This method closes the panel, and if a value is specified, also sets the associated\n * control to that value. It will also mark the control as dirty if this interaction\n * stemmed from the user.\n */\n /**\n * This method closes the panel, and if a value is specified, also sets the associated\n * control to that value. It will also mark the control as dirty if this interaction\n * stemmed from the user.\n * @private\n * @param {?} event\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._setValueAndClose = /**\n * This method closes the panel, and if a value is specified, also sets the associated\n * control to that value. It will also mark the control as dirty if this interaction\n * stemmed from the user.\n * @private\n * @param {?} event\n * @return {?}\n */\n function (event) {\n if (event && event.source) {\n this._clearPreviousSelectedOption(event.source);\n this._setTriggerValue(event.source.value);\n this._onChange(event.source.value);\n this._element.nativeElement.focus();\n this.autocomplete._emitSelectEvent(event.source);\n }\n this.closePanel();\n };\n /**\n * Clear any previous selected option and emit a selection change event for this option\n */\n /**\n * Clear any previous selected option and emit a selection change event for this option\n * @private\n * @param {?} skip\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._clearPreviousSelectedOption = /**\n * Clear any previous selected option and emit a selection change event for this option\n * @private\n * @param {?} skip\n * @return {?}\n */\n function (skip) {\n this.autocomplete.options.forEach((/**\n * @param {?} option\n * @return {?}\n */\n function (option) {\n if (option != skip && option.selected) {\n option.deselect();\n }\n }));\n };\n /**\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._attachOverlay = /**\n * @private\n * @return {?}\n */\n function () {\n var _this = this;\n if (!this.autocomplete) {\n throw getMatAutocompleteMissingPanelError();\n }\n /** @type {?} */\n var overlayRef = this._overlayRef;\n if (!overlayRef) {\n this._portal = new TemplatePortal(this.autocomplete.template, this._viewContainerRef);\n overlayRef = this._overlay.create(this._getOverlayConfig());\n this._overlayRef = overlayRef;\n // Use the `keydownEvents` in order to take advantage of\n // the overlay event targeting provided by the CDK overlay.\n overlayRef.keydownEvents().subscribe((/**\n * @param {?} event\n * @return {?}\n */\n function (event) {\n // Close when pressing ESCAPE or ALT + UP_ARROW, based on the a11y guidelines.\n // See: https://www.w3.org/TR/wai-aria-practices-1.1/#textbox-keyboard-interaction\n if (event.keyCode === ESCAPE || (event.keyCode === UP_ARROW && event.altKey)) {\n _this._resetActiveItem();\n _this._closeKeyEventStream.next();\n // We need to stop propagation, otherwise the event will eventually\n // reach the input itself and cause the overlay to be reopened.\n event.stopPropagation();\n event.preventDefault();\n }\n }));\n if (this._viewportRuler) {\n this._viewportSubscription = this._viewportRuler.change().subscribe((/**\n * @return {?}\n */\n function () {\n if (_this.panelOpen && overlayRef) {\n overlayRef.updateSize({ width: _this._getPanelWidth() });\n }\n }));\n }\n }\n else {\n // Update the trigger, panel width and direction, in case anything has changed.\n this._positionStrategy.setOrigin(this._getConnectedElement());\n overlayRef.updateSize({ width: this._getPanelWidth() });\n }\n if (overlayRef && !overlayRef.hasAttached()) {\n overlayRef.attach(this._portal);\n this._closingActionsSubscription = this._subscribeToClosingActions();\n }\n /** @type {?} */\n var wasOpen = this.panelOpen;\n this.autocomplete._setVisibility();\n this.autocomplete._isOpen = this._overlayAttached = true;\n // We need to do an extra `panelOpen` check in here, because the\n // autocomplete won't be shown if there are no options.\n if (this.panelOpen && wasOpen !== this.panelOpen) {\n this.autocomplete.opened.emit();\n }\n };\n /**\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._getOverlayConfig = /**\n * @private\n * @return {?}\n */\n function () {\n return new OverlayConfig({\n positionStrategy: this._getOverlayPosition(),\n scrollStrategy: this._scrollStrategy(),\n width: this._getPanelWidth(),\n direction: this._dir\n });\n };\n /**\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._getOverlayPosition = /**\n * @private\n * @return {?}\n */\n function () {\n /** @type {?} */\n var strategy = this._overlay.position()\n .flexibleConnectedTo(this._getConnectedElement())\n .withFlexibleDimensions(false)\n .withPush(false);\n this._setStrategyPositions(strategy);\n this._positionStrategy = strategy;\n return strategy;\n };\n /** Sets the positions on a position strategy based on the directive's input state. */\n /**\n * Sets the positions on a position strategy based on the directive's input state.\n * @private\n * @param {?} positionStrategy\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._setStrategyPositions = /**\n * Sets the positions on a position strategy based on the directive's input state.\n * @private\n * @param {?} positionStrategy\n * @return {?}\n */\n function (positionStrategy) {\n /** @type {?} */\n var belowPosition = {\n originX: 'start',\n originY: 'bottom',\n overlayX: 'start',\n overlayY: 'top'\n };\n /** @type {?} */\n var abovePosition = {\n originX: 'start',\n originY: 'top',\n overlayX: 'start',\n overlayY: 'bottom',\n // The overlay edge connected to the trigger should have squared corners, while\n // the opposite end has rounded corners. We apply a CSS class to swap the\n // border-radius based on the overlay position.\n panelClass: 'mat-autocomplete-panel-above'\n };\n /** @type {?} */\n var positions;\n if (this.position === 'above') {\n positions = [abovePosition];\n }\n else if (this.position === 'below') {\n positions = [belowPosition];\n }\n else {\n positions = [belowPosition, abovePosition];\n }\n positionStrategy.withPositions(positions);\n };\n /**\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._getConnectedElement = /**\n * @private\n * @return {?}\n */\n function () {\n if (this.connectedTo) {\n return this.connectedTo.elementRef;\n }\n return this._formField ? this._formField.getConnectedOverlayOrigin() : this._element;\n };\n /**\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._getPanelWidth = /**\n * @private\n * @return {?}\n */\n function () {\n return this.autocomplete.panelWidth || this._getHostWidth();\n };\n /** Returns the width of the input element, so the panel width can match it. */\n /**\n * Returns the width of the input element, so the panel width can match it.\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._getHostWidth = /**\n * Returns the width of the input element, so the panel width can match it.\n * @private\n * @return {?}\n */\n function () {\n return this._getConnectedElement().nativeElement.getBoundingClientRect().width;\n };\n /**\n * Resets the active item to -1 so arrow events will activate the\n * correct options, or to 0 if the consumer opted into it.\n */\n /**\n * Resets the active item to -1 so arrow events will activate the\n * correct options, or to 0 if the consumer opted into it.\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._resetActiveItem = /**\n * Resets the active item to -1 so arrow events will activate the\n * correct options, or to 0 if the consumer opted into it.\n * @private\n * @return {?}\n */\n function () {\n this.autocomplete._keyManager.setActiveItem(this.autocomplete.autoActiveFirstOption ? 0 : -1);\n };\n /** Determines whether the panel can be opened. */\n /**\n * Determines whether the panel can be opened.\n * @private\n * @return {?}\n */\n MatAutocompleteTrigger.prototype._canOpen = /**\n * Determines whether the panel can be opened.\n * @private\n * @return {?}\n */\n function () {\n /** @type {?} */\n var element = this._element.nativeElement;\n return !element.readOnly && !element.disabled && !this._autocompleteDisabled;\n };\n MatAutocompleteTrigger.decorators = [\n { type: Directive, args: [{\n selector: \"input[matAutocomplete], textarea[matAutocomplete]\",\n host: {\n 'class': 'mat-autocomplete-trigger',\n '[attr.autocomplete]': 'autocompleteAttribute',\n '[attr.role]': 'autocompleteDisabled ? null : \"combobox\"',\n '[attr.aria-autocomplete]': 'autocompleteDisabled ? null : \"list\"',\n '[attr.aria-activedescendant]': '(panelOpen && activeOption) ? activeOption.id : null',\n '[attr.aria-expanded]': 'autocompleteDisabled ? null : panelOpen.toString()',\n '[attr.aria-owns]': '(autocompleteDisabled || !panelOpen) ? null : autocomplete?.id',\n '[attr.aria-haspopup]': '!autocompleteDisabled',\n // Note: we use `focusin`, as opposed to `focus`, in order to open the panel\n // a little earlier. This avoids issues where IE delays the focusing of the input.\n '(focusin)': '_handleFocus()',\n '(blur)': '_onTouched()',\n '(input)': '_handleInput($event)',\n '(keydown)': '_handleKeydown($event)',\n },\n exportAs: 'matAutocompleteTrigger',\n providers: [MAT_AUTOCOMPLETE_VALUE_ACCESSOR]\n },] },\n ];\n /** @nocollapse */\n MatAutocompleteTrigger.ctorParameters = function () { return [\n { type: ElementRef },\n { type: Overlay },\n { type: ViewContainerRef },\n { type: NgZone },\n { type: ChangeDetectorRef },\n { type: undefined, decorators: [{ type: Inject, args: [MAT_AUTOCOMPLETE_SCROLL_STRATEGY,] }] },\n { type: Directionality, decorators: [{ type: Optional }] },\n { type: MatFormField, decorators: [{ type: Optional }, { type: Host }] },\n { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [DOCUMENT,] }] },\n { type: ViewportRuler }\n ]; };\n MatAutocompleteTrigger.propDecorators = {\n autocomplete: [{ type: Input, args: ['matAutocomplete',] }],\n position: [{ type: Input, args: ['matAutocompletePosition',] }],\n connectedTo: [{ type: Input, args: ['matAutocompleteConnectedTo',] }],\n autocompleteAttribute: [{ type: Input, args: ['autocomplete',] }],\n autocompleteDisabled: [{ type: Input, args: ['matAutocompleteDisabled',] }]\n };\n return MatAutocompleteTrigger;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\nvar MatAutocompleteModule = /** @class */ (function () {\n function MatAutocompleteModule() {\n }\n MatAutocompleteModule.decorators = [\n { type: NgModule, args: [{\n imports: [MatOptionModule, OverlayModule, MatCommonModule, CommonModule],\n exports: [\n MatAutocomplete,\n MatOptionModule,\n MatAutocompleteTrigger,\n MatAutocompleteOrigin,\n MatCommonModule\n ],\n declarations: [MatAutocomplete, MatAutocompleteTrigger, MatAutocompleteOrigin],\n providers: [MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER],\n },] },\n ];\n return MatAutocompleteModule;\n}());\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n\nexport { MAT_AUTOCOMPLETE_DEFAULT_OPTIONS_FACTORY, MatAutocompleteSelectedEvent, MAT_AUTOCOMPLETE_DEFAULT_OPTIONS, MatAutocomplete, MatAutocompleteModule, MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY, getMatAutocompleteMissingPanelError, AUTOCOMPLETE_OPTION_HEIGHT, AUTOCOMPLETE_PANEL_HEIGHT, MAT_AUTOCOMPLETE_SCROLL_STRATEGY, MAT_AUTOCOMPLETE_SCROLL_STRATEGY_FACTORY_PROVIDER, MAT_AUTOCOMPLETE_VALUE_ACCESSOR, MatAutocompleteTrigger, MatAutocompleteOrigin };\n//# sourceMappingURL=autocomplete.es5.js.map\n"],"sourceRoot":"webpack:///"}