{"version":3,"sources":["webpack:///src/app/routes/page/page.module.ts","webpack:///src/app/layout/header/header.component.ts","webpack:///src/app/layout/header/header.component.html","webpack:///src/app/core/menu/menu.service.ts","webpack:///src/app/shared/style/theme/theme-e.scss","webpack:///src/app/shared/waitingSpinner/waitingSpinner.component.ts","webpack:///src/app/shared/waitingSpinner/waitingSpinner.component.html","webpack:///src/app/shared/style/theme/theme-f.scss","webpack:///src/app/shared/style/theme/theme-b.scss","webpack:///src/app/core/globalVariable.ts","webpack:///src/environments/environment.ts","webpack:///src/app/routes/menu.ts","webpack:///src/app/shared/style/theme/theme-h.scss","webpack:///src/app/shared/directive/scrollable/scrollable.directive.ts","webpack:///src/app/core/service/login.service.ts","webpack:///src/app/core/theme/theme.service.ts","webpack:///src/app/layout/sidebar/sidebar.component.ts","webpack:///src/app/layout/sidebar/sidebar.component.html","webpack:///src/app/core/settings/settings.service.ts","webpack:///src/app/shared/style/theme/theme-d.scss","webpack:///src/app/shared/shared.module.ts","webpack:///src/app/core/directive/hideIfUnauthorized.directive.ts","webpack:///node_modules/moment/locale sync ^\\.\\/.*$","webpack:///src/app/app.component.ts","webpack:///src/app/app.component.html","webpack:///src/app/layout/layout.module.ts","webpack:///src/app/routes/routes.ts","webpack:///src/app/core/translator/translator.service.ts","webpack:///src/app/layout/offsidebar/offsidebar.component.ts","webpack:///src/app/layout/offsidebar/offsidebar.component.html","webpack:///src/app/core/module-import-guard.ts","webpack:///src/app/routes/page/login/login.component.html","webpack:///src/app/routes/page/login/login.component.ts","webpack:///src/app/shared/style/theme/theme-g.scss","webpack:///src/app/core/model/procedure.model.ts","webpack:///src/app/app.module.ts","webpack:///src/app/shared/directive/checkall/checkall.directive.ts","webpack:///src/app/routes/page/register/register.component.ts","webpack:///src/app/routes/page/register/register.component.html","webpack:///src/app/routes/page/error500/error500.component.ts","webpack:///src/app/routes/page/error500/error500.component.html","webpack:///src/app/shared/style/theme/theme-a.scss","webpack:///src/app/shared/style/theme/theme-c.scss","webpack:///src/app/shared/color/color.service.ts","webpack:///src/modernizr.js","webpack:///src/app/layout/sidebar/userblock/userblock.component.ts","webpack:///src/app/layout/sidebar/userblock/userblock.component.html","webpack:///src/vendor.ts","webpack:///src/app/shared/directive/jqcloud/jqcloud.directive.ts","webpack:///src/app/routes/page/error404/error404.component.ts","webpack:///src/app/routes/page/error404/error404.component.html","webpack:///src/app/layout/sidebar/userblock/userblock.service.ts","webpack:///src/app/core/core.module.ts","webpack:///src/app/layout/layout.component.ts","webpack:///src/app/layout/layout.component.html","webpack:///src/app/routes/routes.module.ts","webpack:///src/app/shared/directive/now/now.directive.ts","webpack:///src/main.ts","webpack:///$_lazy_route_resource lazy namespace object"],"names":["PageModule","imports","declarations","exports","screenfull","HeaderComponent","menu","login","injector","settings","navCollapsed","angle","onInit","getLayoutSetting","onInitFullScreen","onInitRouter","router","get","events","subscribe","val","window","scrollTo","logout","e","fsbutton","nativeElement","isNone","style","display","c","firstElementChild","on","fa","className","isFullscreen","event","enabled","toggle","sbbutton","transform","rotate","toggleLayoutSetting","a","navigator","userAgent","ok","indexOf","match","$event","stopPropagation","toggleFullScreen","selector","templateUrl","styleUrls","MenuService","entries","items","iitems","service","permission","length","forEach","item","hasPermission","push","WaitingSpinnerComponent","Data","Admin","Search","Publish","environment","production","home","text","link","icon","report","ScrollableDirective","element","defaultHeight","$","slimScroll","height","LoginService","http","baseUrl","isClient","isEmployee","keyUserType","keyCurrentUser","keyLogIn","keyNavigateItems","httpOptions","headers","loggedInItem","userInfoItem","appUrl","apiUrl","searchParam","searchResult","userDetailInfo","setLoggedIn","setUserInfo","prilivages","securityPrivileges","requirePermission","v","asObservable","i","value","next","url","getURL","set","username","password","software","data","params","id","userInfo","Object","keys","count","key","user","last","first","position","info","lastName","firstName","name","responseType","search","authenticate","isValid","valid","localStorage","setItem","JSON","stringify","error","console","navigate","removeItem","isLoggedIn","bad","history","state","prevPage","providedIn","themeA","themeB","themeC","themeD","themeE","themeF","themeG","themeH","ThemeService","create","theme","defaultTheme","head","document","getElementsByTagName","createElement","type","appendChild","defaultStyle","css","innerHTML","SidebarComponent","menuService","sbclickEvent","$doc","add","menuItems","removeFloatingNav","setLayoutSetting","anyClickClose","off","target","parents","elem","scrollHeight","removeClass","remove","preventDefault","isSidebarCollapsed","isSidebarCollapsedText","isEnabledHover","ul","currentTarget","nextElementSibling","parentNav","each","idx","el","$el","closeMenu","find","ulHeight","parseInt","addClass","self","anchor","$aside","$asideInner","children","$sidebar","mar","itemTop","parent","top","scrollTop","floatingNav","clone","appendTo","vwHeight","body","clientHeight","safeOffsetValue","navHeight","outerHeight","safeOffset","displacement","menuTop","bottom","routeTo","attr","listenForExternalClicks","SettingsService","app","year","Date","getFullYear","copyright","description","version","layout","isFixed","isCollapsed","isBoxed","isRTL","horizontal","isFloat","asideHover","asideScrollbar","isCollapsedText","useFullLayout","hiddenFooter","offsidebarOpen","asideToggled","viewAnimation","SharedModule","ngModule","forRoot","providers","HideIfUnauthorizedDirective","map","webpackContext","req","webpackContextResolve","__webpack_require__","o","Error","code","webpackContextKeys","resolve","module","AppComponent","addEventListener","tagName","getAttribute","LayoutModule","routes","path","component","redirectTo","pathMatch","loadChildren","then","HomeModule","ReportModule","TranslatorService","translate","defaultLanguage","availablelangs","getDefaultLang","setDefaultLang","useLanguage","lang","use","OffsidebarComponent","translator","checkCloseOffsidebar","contains","currentTheme","selectedLanguage","getLangs","getAvailableLanguages","removeEventListener","throwIfAlreadyLoaded","parentModule","moduleName","defaultEnterButton","keyCode","click","LoginComponent","fb","email","message","department","showSpinner","keyLock","keyInput","idUser","valForm","group","required","setTimeout","loginUser","focus","onInitUser","s","userType","r","undefined","err","onByPass","result","em","pw","sp","getUserId","initialPermissions","onMessage","m","color","interval","setInterval","clearInterval","doMessage","lock","k","$e","getElementById","onLock","byPassOff","onLogin","p","toLowerCase","d","u","eg","loginGo","ep","loginPassword","onKey","onLockHover","onLockLeave","ContactGroup","ContactInfo","Location","LoginModel","SecurityInfo","SecurityRole","SecurityPrivilege","eUserType","UserStatus","createTranslateLoader","AppModule","loader","provide","useFactory","deps","bootstrap","CheckallDirective","$element","index","checkbox","table","prop","checked","RegisterComponent","compose","pattern","certainPassword","equalTo","passwordForm","$ev","controls","markAsTouched","log","submitForm","Error500Component","ColorService","APP_COLORS","tests","ModernizrProto","_version","_config","_q","test","cb","addTest","fn","options","addAsyncTest","Modernizr","prototype","classes","is","obj","testRunner","featureNames","feature","aliasIdx","nameIdx","featureName","featureNameSplit","featureIdx","hasOwnProperty","aliases","split","Boolean","join","docElement","documentElement","isSVG","nodeName","setClasses","classPrefix","baseVal","enableJSClass","reJS","RegExp","replace","enableClasses","arguments","createElementNS","call","apply","eStyle","cssText","backgroundPosition","omPrefixes","cssomPrefixes","usePrefixes","_cssomPrefixes","str","substr","modElem","mStyle","unshift","getBody","fake","injectElementWithStyles","rule","callback","nodes","testnames","mod","ret","node","docOverflow","div","styleSheet","createTextNode","background","overflow","parentNode","removeChild","offsetHeight","domToCSS","m1","nativeTestProps","props","CSS","supports","conditionText","getComputedStyle","cssToDOM","m2","toUpperCase","testProps","prefixed","skipValueTest","afterInit","propsLength","before","elems","shift","cleanElems","domPrefixes","_domPrefixes","fnBind","that","testDOMProps","testPropsAll","ucProp","charAt","slice","testAllProps","prefixes","_prefixes","testStyles","newSyntax","oldSyntax","usePrefix","mq","offsetWidth","blacklist","ua","wkvers","parseFloat","$1","webos","wppre8","oldandroid","sheet","cssRules","bool","createSVGRect","hasOwnProp","_hasOwnProperty","object","property","constructor","_l","_trigger","res","cbs","implementation","hasFeature","toStringFn","toString","SVGFEColorMatrixElement","SVG_FECOLORMATRIX_TYPE_SATURATE","SVGRect","firstChild","namespaceURI","sessionStorage","UserblockComponent","getVisibility","JqcloudDirective","initialized","$elem","jQCloud","defaults","opts","width","steps","extend","words","changes","Error404Component","UserblockService","userBlockVisible","stat","CoreModule","LayoutComponent","isLoggedIn$","RoutesModule","tr","relativeLinkResolution","NowDirective","updateTime","intervalId","bind","dt","format","getBaseUrl","href","bootstrapModule","appBootstrap","webpackEmptyAsyncContext","Promise"],"mappings":"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","file":"main-es5.js","sourcesContent":["import { NgModule } from '@angular/core';\r\nimport { RouterModule } from '@angular/router';\r\n\r\nimport { SharedModule } from '../../shared/shared.module';\r\nimport { LoginComponent } from './login/login.component';\r\nimport { RegisterComponent } from './register/register.component';\r\nimport { Error404Component } from './error404/error404.component';\r\nimport { Error500Component } from './error500/error500.component';\r\n\r\n@NgModule({\r\n    imports: [\r\n        SharedModule\r\n    ],\r\n    declarations: [\r\n        LoginComponent,\r\n        RegisterComponent,\r\n        Error404Component,\r\n        Error500Component\r\n    ],\r\n    exports: [\r\n        RouterModule,\r\n        LoginComponent,\r\n        RegisterComponent,\r\n        Error404Component,\r\n        Error500Component\r\n    ]\r\n})\r\n\r\nexport class PageModule {\r\n}\r\n","import { Component, OnInit, ViewChild, Injector } from '@angular/core';\r\nimport { Router } from '@angular/router';\r\n\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { MenuService } from '../../core/menu/menu.service';\r\nimport { LoginService } from '../../core/service/login.service';\r\nimport { SettingsService } from '../../core/settings/settings.service';\r\n\r\nconst screenfull = require('screenfull');\r\n\r\n@Component({\r\n    selector: 'app-header',\r\n    templateUrl: './header.component.html',\r\n    styleUrls: ['./header.component.scss']\r\n})\r\n\r\nexport class HeaderComponent implements OnInit {\r\n\r\n    navCollapsed = true; // for horizontal layout\r\n    router: Router;\r\n    angle = 0;\r\n\r\n    @ViewChild('fsbutton', { static: true }) private fsbutton;\r\n    @ViewChild('sbbutton') private sbbutton;\r\n\r\n    constructor(\r\n        public menu: MenuService,\r\n        private login: LoginService,\r\n        public injector: Injector,\r\n        public settings: SettingsService) {\r\n\r\n    }\r\n\r\n    ngOnInit() {\r\n        this.onInit();\r\n    }\r\n    isCollapsedText() {\r\n        return this.settings.getLayoutSetting('isCollapsedText');\r\n    }\r\n    onInit() {\r\n        this.onInitFullScreen();\r\n        this.onInitRouter();\r\n    }\r\n    onInitRouter() {\r\n        this.router = this.injector.get(Router);\r\n        // autoclose navbar on mobile when route change\r\n        this.router.events.subscribe((val) => {\r\n            // scroll view to top\r\n            window.scrollTo(0, 0);\r\n            // close collapse menu\r\n            this.navCollapsed = true;\r\n        });\r\n    }\r\n    logout() {\r\n        this.login.logout(true);\r\n    }\r\n    //screen\r\n    onInitFullScreen() {\r\n        var e = this.fsbutton.nativeElement;\r\n\r\n        if (this.isNone) {\r\n            e.style.display = 'none';\r\n        }\r\n        else {\r\n            const c = e.firstElementChild;\r\n\r\n            screenfull.on('change',\r\n                () => {\r\n                    if (c) {\r\n                        let fa = 'fa fa-';\r\n\r\n                        c.className = fa + (screenfull.isFullscreen ? 'compress' : 'expand');\r\n                    }\r\n                });\r\n        }\r\n    }\r\n    toggleFullScreen(event) {\r\n        if (screenfull.enabled) {\r\n            screenfull.toggle();\r\n        }\r\n    }\r\n    //sidebar\r\n    toggleCollapsedSideabar() {\r\n        var e = this.sbbutton.nativeElement;\r\n        var c = e.firstElementChild;\r\n\r\n        if (c) {\r\n            c.style.transform = this.rotate;\r\n            this.settings.toggleLayoutSetting('isCollapsed');\r\n        }\r\n    }\r\n    //is\r\n    get isNone(): boolean {\r\n        var a: string = window.navigator.userAgent;\r\n        let ok: boolean = a.indexOf(\"MSIE \") > 0;\r\n\r\n        if (!ok) {\r\n            ok = !!a.match(/Trident.*rv\\:11\\./);\r\n        }\r\n\r\n        return ok;\r\n    }\r\n    //other\r\n    get rotate(): string {\r\n        this.angle = this.angle > 0 ? 0 : 180;\r\n\r\n        return 'rotate(' + this.angle + 'deg)';\r\n    }\r\n\r\n}\r\n","<!-- START Top Navbar-->\r\n<nav class=\"navbar topnavbar\" role=\"navigation\">\r\n    <!--START navbar header-->\r\n    <div class=\"navbar-header\">\r\n        <a class=\"navbar-brand\" href=\"#/\">\r\n            <div class=\"brand-logo\">\r\n                <img sizes=\"100%\" class=\"img-fluid\" src=\"assets/img/logo/AGAT.logo.small.png\" />\r\n            </div>\r\n            <div class=\"brand-logo-collapsed\">\r\n                <img class=\"img-fluid\" src=\"assets/img/logo/AGAT.logo.small.png\" />\r\n            </div>\r\n        </a>\r\n    </div>\r\n    <!--END navbar header-->\r\n    <!--START Left navbar-->\r\n    <ul class=\"navbar-nav mr-auto flex-row\">\r\n        <li class=\"nav-item\">\r\n            <!--Button used to collapse the left sidebar. Only visible on tablet and desktops-->\r\n            <a class=\"nav-link d-none d-md-block d-lg-block d-xl-block\" #sbbutton trigger-resize=\"\" (click)=\"toggleCollapsedSideabar()\" *ngIf=\"!isCollapsedText()\">\r\n                <em class=\"fa fa-arrow-left\"></em>\r\n            </a>\r\n            <!--Button to show/hide the sidebar on mobile. Visible on mobile only.-->\r\n            <a class=\"nav-link sidebar-toggle d-md-none\"\r\n               #sbbutton\r\n               title='Expand\\Collapsed sidebar'\r\n               ngbTooltip='Collapsed\\Expand sidebar'\r\n               (click)=\"settings.toggleLayoutSetting('asideToggled'); $event.stopPropagation()\">\r\n                <em class=\"fa fa-arrow-left\">\r\n                </em>\r\n            </a>\r\n        </li>\r\n    </ul>\r\n    <!--END Left navbar-->\r\n    <!--START Right Navbar-->\r\n    <ul class=\"navbar-nav flex-row\">\r\n        <!--Fullscreen (only desktops)-->\r\n        <li class=\"nav-item d-none d-md-block\">\r\n            <a class=\"nav-link\"\r\n               #fsbutton\r\n               (click)=\"toggleFullScreen($event)\">\r\n                <em class=\"fa fa-expand\"></em>\r\n            </a>\r\n        </li>\r\n        <!--START Logout menu-->\r\n        <li class=\"nav-item\">\r\n            <a class=\"nav-link\"\r\n               title=\"Logout\"\r\n               (click)=\"logout();\">\r\n                <em class=\"icon-logout\"></em>\r\n            </a>\r\n        </li>\r\n        <!--END Logout menu-->\r\n    </ul>\r\n    <!--END Right Navbar-->\r\n</nav>\r\n<!-- END Top Navbar-->\r\n","import { Injectable } from '@angular/core';\r\n\r\nimport { LoginService } from '../../core/service/login.service';\r\n\r\n@Injectable()\r\n\r\nexport class MenuService {\r\n\r\n    entries: Array<any>;\r\n\r\n    constructor(private login: LoginService) {\r\n        this.entries = [];\r\n    }\r\n\r\n    add(items: Array<{\r\n        text: string,\r\n        heading?: boolean,\r\n        link?: string,     // internal route links\r\n        elink?: string,    // used only for external links\r\n        target?: string,   // anchor target=\"_blank|_self|_parent|_top|framename\"\r\n        icon?: string,\r\n        alert?: string,\r\n        submenu?: Array<any>,\r\n        permission?: string\r\n    }>) {\r\n        let iitems = this.items;\r\n        let service = this.login;\r\n        let permission: string;\r\n\r\n        //AG20220819\r\n        if (iitems.length > 0) {\r\n            iitems.length = 0;\r\n        }\r\n        items.forEach((item) => {\r\n            permission = item.permission;\r\n            if (!permission || service.hasPermission(permission)) {\r\n                iitems.push(item);\r\n            }\r\n        });\r\n    }\r\n    get items() {\r\n        return this.entries;\r\n    }\r\n\r\n}\r\n","export default \"/* ========================================================================\\n   Component: layout\\n ========================================================================== */\\nbody, .wrapper .section-container {\\n  background-color: #f5f7fa;\\n}\\n.wrapper .aside-container {\\n  background-color: #3a3f51;\\n}\\n/* ========================================================================\\n   Component: top-navbar\\n ========================================================================== */\\n.topnavbar {\\n  background-color: #1797be;\\n  background-image: linear-gradient(to right, #1797be 0%, #23b7e5 100%);\\n  background-repeat: repeat-x;\\n}\\n@media (min-width: 992px) {\\n  .topnavbar .navbar-nav > .nav-item.show > .nav-link, .topnavbar .navbar-nav > .nav-item.show > .nav-link:hover, .topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n    box-shadow: 0 -3px 0 #1381a3 inset;\\n  }\\n}\\n.topnavbar .navbar-nav > .nav-item > .navbar-text {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link:hover, .topnavbar .navbar-nav > .nav-item > .nav-link:focus,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:hover,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n  color: #0c4f63;\\n}\\n.topnavbar .dropdown-item.active, .topnavbar .dropdown-item:active {\\n  background-color: #1797be;\\n}\\n/* ========================================================================\\n   Component: sidebar\\n ========================================================================== */\\n.sidebar {\\n  background-color: #3a3f51;\\n}\\n.sidebar .nav-heading {\\n  color: #919DA8;\\n}\\n.sidebar-nav > li > a, .sidebar-nav > li > .nav-item {\\n  color: #e1e2e3;\\n}\\n.sidebar-nav > li > a:focus, .sidebar-nav > li > a:hover, .sidebar-nav > li > .nav-item:focus, .sidebar-nav > li > .nav-item:hover {\\n  color: #1797be;\\n}\\n.sidebar-nav > li > a > em, .sidebar-nav > li > .nav-item > em {\\n  color: inherits;\\n}\\n.sidebar-nav > li.active, .sidebar-nav > li.active > a, .sidebar-nav > li.active > .nav-item, .sidebar-nav > li.active .sidebar-nav, .sidebar-nav > li.open, .sidebar-nav > li.open > a, .sidebar-nav > li.open > .nav-item, .sidebar-nav > li.open .sidebar-nav {\\n  background-color: #383d4e;\\n  color: #1797be;\\n}\\n.sidebar-nav > li.active > .nav-item > em, .sidebar-nav > li.active > a > em, .sidebar-nav > li.open > .nav-item > em, .sidebar-nav > li.open > a > em {\\n  color: #1797be;\\n}\\n.sidebar-nav > li.active {\\n  border-left-color: #1797be;\\n}\\n.sidebar-subnav {\\n  background-color: #3a3f51;\\n}\\n.sidebar-subnav > .sidebar-subnav-header {\\n  color: #e1e2e3;\\n}\\n.sidebar-subnav > li > a, .sidebar-subnav > li > .nav-item {\\n  color: #e1e2e3;\\n}\\n.sidebar-subnav > li > a:focus, .sidebar-subnav > li > a:hover, .sidebar-subnav > li > .nav-item:focus, .sidebar-subnav > li > .nav-item:hover {\\n  color: #1797be;\\n}\\n.sidebar-subnav > li.active > a, .sidebar-subnav > li.active > .nav-item {\\n  color: #1797be;\\n}\\n.sidebar-subnav > li.active > a:after, .sidebar-subnav > li.active > .nav-item:after {\\n  border-color: #1797be;\\n  background-color: #1797be;\\n}\\n/* ========================================================================\\n   Component: offsidebar\\n ========================================================================== */\\n.offsidebar {\\n  border-left: 1px solid greyscale(#cccccc);\\n  background-color: #fff;\\n  color: #656565;\\n}\\n/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/app/shared/style/theme/theme-e.scss","src/app/shared/style/app/variables.scss","src/app/shared/style/bootstrap/mixins/_gradients.scss","src/app/shared/style/bootstrap/mixins/_breakpoints.scss"],"names":[],"mappings":"AA8CA;;6EAAA;AAGA;EACI,yBAzC4B;AAJhC;AAgDA;EACI,yBCnDoB;ADMxB;AAgDA;;6EAAA;AAGA;EACI,yBCvBoB;ECxBtB,qEAAA;EACA,2BAAA;AFGF;AG0CI;EHMQ;IACI,kCAAA;EA7Cd;AACF;AAiDI;EACI,WAtDwB;AAOhC;AAkDI;;EAEI,WA3DwB;AAWhC;AAiDQ;;;EACI,cA5DoB;AAehC;AAiDI;EACI,yBC/CgB;ADAxB;AAmDA;;6EAAA;AAGA;EACI,yBC1FoB;AD0CxB;AAkDI;EACI,cA5D0B;AAYlC;AAuDQ;EACI,cA9EsB;AA0BlC;AAsDY;EACI,cCrEQ;ADiBxB;AAwDY;EACI,eAlFkB;AA4BlC;AA6DY;EACI,yBA5FkB;EA6FlB,cCnFQ;ADwBxB;AA8DY;EACI,cCvFQ;AD2BxB;AAiEQ;EACI,0BC7FY;AD8BxB;AAsEA;EACI,yBCxIoB;ADqExB;AAqEI;EACI,cApH0B;AAiDlC;AAuEQ;EACI,cAzHsB;AAoDlC;AAuEY;EACI,cChHQ;AD2CxB;AA2EY;EACI,cCvHQ;AD8CxB;AA2EgB;EACI,qBC1HI;ED2HJ,yBC3HI;ADkDxB;AAoFA;;6EAAA;AAGA;EACI,yCAAA;EACA,sBAxIsB;EAyItB,cCrCwB;AD5C5B","file":"src/app/shared/style/theme/theme-e.scss","sourcesContent":["// Bootstrap\r\n@import \"../bootstrap/functions\";\r\n@import \"../bootstrap/variables\";\r\n@import \"../bootstrap/mixins\";\r\n@import '../app/variables';\r\n\r\n\r\n// LAYOUT\r\n\r\n$content-bg:                    #f5f7fa;\r\n$aside-bg:                      $gray-dark;\r\n\r\n// NAVBAR TOP\r\n\r\n$nav-top-bg:                    $info-dark;\r\n$nav-top-bg-start:              $nav-top-bg;\r\n$nav-top-bg-end:                $info;\r\n$nav-header-bg:                 transparent;\r\n\r\n$nav-top-item:                  #fff;\r\n$nav-top-item-active:           darken($nav-top-bg, 20%);\r\n\r\n// SIDEBAR\r\n\r\n$sidebar-bg:                      $aside-bg;\r\n\r\n$sidebar-item-color:              #e1e2e3;\r\n$sidebar-item-color-active:       $nav-top-bg;\r\n$sidebar-item-bg-active:          darken($sidebar-bg, 1%);\r\n\r\n$sidebar-icon-color:              inherits;\r\n$sidebar-icon-color-active:       $nav-top-bg;\r\n\r\n$sidebar-bullet-color:            rgba(0,0,0,.25);\r\n$sidebar-bullet-color-active:     $sidebar-icon-color-active;\r\n\r\n$sidebar-heading-color:           #919DA8;\r\n$sidebar-label-color:             $sidebar-item-color;\r\n\r\n// OFFSIDEBAR\r\n\r\n$offsidebar-bg:           #fff;\r\n$offsidebar-border-color: greyscale(darken($offsidebar-bg, 20%));\r\n$offsidebar-color:        $body-color;\r\n\r\n\r\n/* ========================================================================\r\n   Component: layout\r\n ========================================================================== */\r\nbody, .wrapper .section-container {\r\n    background-color: $content-bg;\r\n}\r\n\r\n.wrapper .aside-container {\r\n    background-color: $aside-bg;\r\n}\r\n\r\n/* ========================================================================\r\n   Component: top-navbar\r\n ========================================================================== */\r\n.topnavbar {\r\n    background-color: $nav-top-bg;\r\n    @include gradient-x($nav-top-bg-start, $nav-top-bg-end);\r\n\r\n    @include media-breakpoint-up(lg) {\r\n        .navbar-nav > .nav-item.show > .nav-link {\r\n            &, &:hover, &:focus {\r\n                box-shadow: 0 -3px 0 darken($nav-top-bg, 6%) inset;\r\n            }\r\n        }\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .navbar-text {\r\n        color: $nav-top-item;\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .nav-link,\r\n    .navbar-nav > .nav-item.show > .nav-link {\r\n        color: $nav-top-item;\r\n        &:hover, &:focus {\r\n            color: $nav-top-item-active;\r\n        }\r\n    }\r\n\r\n    .dropdown-item.active, .dropdown-item:active {\r\n        background-color: $nav-top-bg;\r\n    }\r\n}\r\n\r\n/* ========================================================================\r\n   Component: sidebar\r\n ========================================================================== */\r\n.sidebar {\r\n    background-color: $sidebar-bg;\r\n\r\n    .nav-heading {\r\n        color: $sidebar-heading-color;\r\n    }\r\n}\r\n\r\n// Items\r\n.sidebar-nav {\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            // Item icon\r\n            > em {\r\n                color: $sidebar-icon-color;\r\n            }\r\n\r\n        }\r\n\r\n        // Active item state\r\n        &.active, &.open {\r\n            &, > a, > .nav-item, .sidebar-nav {\r\n                background-color: $sidebar-item-bg-active;\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            > .nav-item > em, > a > em {\r\n                color: $sidebar-icon-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            border-left-color: $sidebar-item-color-active;\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n.sidebar-subnav {\r\n    background-color: $sidebar-bg;\r\n\r\n    > .sidebar-subnav-header {\r\n        color: $sidebar-item-color;\r\n    }\r\n\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            > a, > .nav-item {\r\n                color: $sidebar-icon-color-active;\r\n\r\n                &:after {\r\n                    border-color: $sidebar-bullet-color-active;\r\n                    background-color: $sidebar-bullet-color-active;\r\n                }\r\n\r\n            }\r\n\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n/* ========================================================================\r\n   Component: offsidebar\r\n ========================================================================== */\r\n.offsidebar {\r\n    border-left: 1px solid $offsidebar-border-color;\r\n    background-color: $offsidebar-bg;\r\n    color: $offsidebar-color;\r\n}\r\n","\r\n// Cutoms Gray colors for theme\r\n$gray-darker:           #232735;\r\n$gray-dark:             #3a3f51;\r\n$gray:                  #dde6e9;\r\n$gray-light:            #e4eaec;\r\n$gray-lighter:          #edf1f2;\r\n\r\n// Custom brand colors for theme\r\n$inverse:               #131e26;\r\n$purple:                #7266ba;\r\n$pink:                  #f532e5;\r\n$yellow:                #fad732;\r\n$green:                 #37bc9b;\r\n\r\n$primary:               #5d9cec;\r\n$secondary:             #fff;\r\n$success:               #27c24c;\r\n$info:                  #23b7e5;\r\n$warning:               #ff902b;\r\n$danger:                #f05050;\r\n$dark:                  #3a3f51;\r\n\r\n// Custom color variants\r\n$amountOfLight: 10%;\r\n\r\n$primary-light:         lighten($primary, $amountOfLight);\r\n$success-light:         lighten($success, $amountOfLight);\r\n$info-light:            lighten($info, $amountOfLight);\r\n$warning-light:         lighten($warning, $amountOfLight);\r\n$danger-light:          lighten($danger, $amountOfLight);\r\n$inverse-light:         lighten($inverse, $amountOfLight);\r\n$green-light:           lighten($green, $amountOfLight);\r\n$pink-light:            lighten($pink, $amountOfLight);\r\n$purple-light:          lighten($purple, $amountOfLight);\r\n$yellow-light:          lighten($yellow, $amountOfLight);\r\n$primary-dark:          darken($primary, $amountOfLight);\r\n$success-dark:          darken($success, $amountOfLight);\r\n$info-dark:             darken($info, $amountOfLight);\r\n$warning-dark:          darken($warning, $amountOfLight);\r\n$danger-dark:           darken($danger, $amountOfLight);\r\n$inverse-dark:          darken($inverse, $amountOfLight);\r\n$green-dark:            darken($green, $amountOfLight);\r\n$pink-dark:             darken($pink, $amountOfLight);\r\n$purple-dark:           darken($purple, $amountOfLight);\r\n$yellow-dark:           darken($yellow, $amountOfLight);\r\n\r\n// Theme variables\r\n\r\n// used for sidebars and content spacing\r\n$navbar-height:                    55px;\r\n\r\n// Button secondary redefinition style for theme\r\n$btn-secondary-color:              #333;\r\n$btn-secondary-bg:                 #fff;\r\n$btn-secondary-border:             #eaeaea;\r\n\r\n// Top Border color for custom default cards (.card-default)\r\n$card-default-border-color:        #cfdbe2;\r\n\r\n\r\n// ---------------------\r\n// Utilities variables\r\n// ---------------------\r\n\r\n$text-alpha:            rgba(255,255,255,.5);\r\n$text-alpha-inverse:    rgba(0,0,0,.5);\r\n\r\n$font-size-base:        1rem;\r\n$text-sm:               $font-size-base * 0.74375;\r\n$text-md:               $font-size-base * 1.6625;\r\n$text-lg:               $font-size-base * 2.625;\r\n\r\n$border-color:          rgba(0,0,0,.12);\r\n\r\n$wd-xxs:                60px;\r\n$wd-xs:                 90px;\r\n$wd-sm:                 150px;\r\n$wd-sd:                 200px; // sd == standard\r\n$wd-md:                 240px;\r\n$wd-lg:                 280px;\r\n$wd-xl:                 320px;\r\n$wd-xxl:                360px;\r\n$wd-wide:               100%;\r\n$wd-auto:               auto;\r\n$wd-zero:               0;\r\n\r\n\r\n// ---------------------\r\n// Bootstrap 4 Variables Override\r\n// ---------------------\r\n\r\n// Color system\r\n\r\n$colors: (\r\n    \"purple\":     $purple,\r\n    \"pink\":       $pink,\r\n    \"yellow\":     $yellow,\r\n    \"green\":      $green,\r\n    \"primary\":    $primary,\r\n    \"success\":    $success,\r\n    \"info\":       $info,\r\n    \"warning\":    $warning,\r\n    \"danger\":     $danger,\r\n    'inverse':    $inverse,\r\n\r\n    'primary-light': $primary-light,\r\n    'primary-dark':  $primary-dark,\r\n    'success-light': $success-light,\r\n    'success-dark':  $success-dark,\r\n    'info-light':    $info-light,\r\n    'info-dark':     $info-dark,\r\n    'warning-light': $warning-light,\r\n    'warning-dark':  $warning-dark,\r\n    'danger-light':  $danger-light,\r\n    'danger-dark':   $danger-dark,\r\n    'green-light':   $green-light,\r\n    'green-dark':    $green-dark,\r\n    'pink-light':    $pink-light,\r\n    'pink-dark':     $pink-dark,\r\n    'purple-light':  $purple-light,\r\n    'purple-dark':   $purple-dark,\r\n    'inverse-light': $inverse-light,\r\n    'inverse-dark':  $inverse-dark,\r\n    'yellow-light':  $yellow-light,\r\n    'yellow-dark':   $yellow-dark,\r\n);\r\n\r\n\r\n$theme-colors: (\r\n  \"primary\":    $primary,\r\n  \"secondary\":  $secondary,\r\n  \"success\":    $success,\r\n  \"info\":       $info,\r\n  \"warning\":    $warning,\r\n  \"danger\":     $danger\r\n);\r\n\r\n// Body\r\n\r\n$body-bg:                   #f5f7fa;\r\n$body-color:                #656565;\r\n\r\n$border-radius:               .25rem;\r\n$border-radius-lg:            .375rem;\r\n\r\n$line-height-base:            1.528571429;\r\n\r\n$headings-line-height:        1.1;\r\n\r\n$text-muted:                  #909FA7;\r\n\r\n// Tables\r\n\r\n$table-accent-bg:             #fafbfc;\r\n$table-hover-bg:              #fafbfc;\r\n\r\n$table-border-color:          #eee;\r\n\r\n// Buttons + Forms\r\n\r\n$input-btn-padding-y:         .375rem;\r\n$input-btn-padding-x:         1rem;\r\n\r\n$input-btn-padding-y-sm:      .3125rem;\r\n$input-btn-padding-x-sm:      .625rem;\r\n\r\n$input-btn-padding-y-lg:      .625rem;\r\n$input-btn-padding-x-lg:      1.25rem;\r\n\r\n$input-height:                2.1875rem; // 35px\r\n\r\n// Forms\r\n\r\n$input-disabled-bg:                     $gray-lighter;\r\n$input-border-color:                    $gray;\r\n$input-focus-border-color:              #66afe9;\r\n$input-placeholder-color:               #b7bac9;\r\n\r\n$form-feedback-icon-valid:              none;\r\n$form-feedback-icon-invalid:            none;\r\n\r\n$custom-control-indicator-active-bg:    lighten($primary, 25%);\r\n\r\n// Dropdowns\r\n\r\n$dropdown-border-color:             #e1e1e1;\r\n\r\n// Navs\r\n\r\n$nav-tabs-link-active-bg:           #fff;\r\n\r\n// Jumbotron\r\n\r\n$jumbotron-bg:                      #fcfcfc;\r\n\r\n// List group\r\n\r\n$list-group-border-color:           #e4eaec;\r\n\r\n// Image thumbnails\r\n\r\n$thumbnail-padding:                 .125rem;\r\n\r\n\r\n// Breadcrumbs\r\n\r\n$breadcrumb-bg:                     #fafafa;\r\n$breadcrumb-divider-color:          #c1c2c3;\r\n$breadcrumb-active-color:           $body-color;\r\n","// Gradients\r\n\r\n@mixin gradient-bg($color) {\r\n  @if $enable-gradients {\r\n    background: $color linear-gradient(180deg, mix($body-bg, $color, 15%), $color) repeat-x;\r\n  } @else {\r\n    background-color: $color;\r\n  }\r\n}\r\n\r\n// Horizontal gradient, from left to right\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-x($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to right, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n// Vertical gradient, from top to bottom\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-y($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to bottom, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n@mixin gradient-directional($start-color: $gray-700, $end-color: $gray-800, $deg: 45deg) {\r\n  background-image: linear-gradient($deg, $start-color, $end-color);\r\n  background-repeat: repeat-x;\r\n}\r\n@mixin gradient-x-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient(to right, $start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-y-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient($start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-radial($inner-color: $gray-700, $outer-color: $gray-800) {\r\n  background-image: radial-gradient(circle, $inner-color, $outer-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-striped($color: rgba($white, .15), $angle: 45deg) {\r\n  background-image: linear-gradient($angle, $color 25%, transparent 25%, transparent 50%, $color 50%, $color 75%, transparent 75%, transparent);\r\n}\r\n","// Breakpoint viewport sizes and media queries.\r\n//\r\n// Breakpoints are defined as a map of (name: minimum width), order from small to large:\r\n//\r\n//    (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px)\r\n//\r\n// The map defined in the `$grid-breakpoints` global variable is used as the `$breakpoints` argument by default.\r\n\r\n// Name of the next breakpoint, or null for the last breakpoint.\r\n//\r\n//    >> breakpoint-next(sm)\r\n//    md\r\n//    >> breakpoint-next(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    md\r\n//    >> breakpoint-next(sm, $breakpoint-names: (xs sm md lg xl))\r\n//    md\r\n@function breakpoint-next($name, $breakpoints: $grid-breakpoints, $breakpoint-names: map-keys($breakpoints)) {\r\n  $n: index($breakpoint-names, $name);\r\n  @return if($n != null and $n < length($breakpoint-names), nth($breakpoint-names, $n + 1), null);\r\n}\r\n\r\n// Minimum breakpoint width. Null for the smallest (first) breakpoint.\r\n//\r\n//    >> breakpoint-min(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    576px\r\n@function breakpoint-min($name, $breakpoints: $grid-breakpoints) {\r\n  $min: map-get($breakpoints, $name);\r\n  @return if($min != 0, $min, null);\r\n}\r\n\r\n// Maximum breakpoint width. Null for the largest (last) breakpoint.\r\n// The maximum value is calculated as the minimum of the next one less 0.02px\r\n// to work around the limitations of `min-` and `max-` prefixes and viewports with fractional widths.\r\n// See https://www.w3.org/TR/mediaqueries-4/#mq-min-max\r\n// Uses 0.02px rather than 0.01px to work around a current rounding bug in Safari.\r\n// See https://bugs.webkit.org/show_bug.cgi?id=178261\r\n//\r\n//    >> breakpoint-max(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    767.98px\r\n@function breakpoint-max($name, $breakpoints: $grid-breakpoints) {\r\n  $next: breakpoint-next($name, $breakpoints);\r\n  @return if($next, breakpoint-min($next, $breakpoints) - .02, null);\r\n}\r\n\r\n// Returns a blank string if smallest breakpoint, otherwise returns the name with a dash in front.\r\n// Useful for making responsive utilities.\r\n//\r\n//    >> breakpoint-infix(xs, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"\"  (Returns a blank string)\r\n//    >> breakpoint-infix(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"-sm\"\r\n@function breakpoint-infix($name, $breakpoints: $grid-breakpoints) {\r\n  @return if(breakpoint-min($name, $breakpoints) == null, \"\", \"-#{$name}\");\r\n}\r\n\r\n// Media of at least the minimum breakpoint width. No query for the smallest breakpoint.\r\n// Makes the @content apply to the given breakpoint and wider.\r\n@mixin media-breakpoint-up($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  @if $min {\r\n    @media (min-width: $min) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media of at most the maximum breakpoint width. No query for the largest breakpoint.\r\n// Makes the @content apply to the given breakpoint and narrower.\r\n@mixin media-breakpoint-down($name, $breakpoints: $grid-breakpoints) {\r\n  $max: breakpoint-max($name, $breakpoints);\r\n  @if $max {\r\n    @media (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media that spans multiple breakpoint widths.\r\n// Makes the @content apply between the min and max breakpoints\r\n@mixin media-breakpoint-between($lower, $upper, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($lower, $breakpoints);\r\n  $max: breakpoint-max($upper, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($lower, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($upper, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n\r\n// Media between the breakpoint's minimum and maximum widths.\r\n// No minimum for the smallest breakpoint, and no maximum for the largest one.\r\n// Makes the @content apply only to the given breakpoint, not viewports any wider or narrower.\r\n@mixin media-breakpoint-only($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  $max: breakpoint-max($name, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n"]} */\";","import { Component, OnInit } from '@angular/core';\n\n@Component({\n  selector: 'app-waitingSpinner',\n  templateUrl: './waitingSpinner.component.html',\n  styleUrls: ['./waitingSpinner.component.scss']\n})\nexport class WaitingSpinnerComponent implements OnInit {\n\n  constructor() { }\n\n  ngOnInit() {\n  }\n\n}\n","\n<!--<div class=\"ball-pulse\">\n  <div></div>\n  <div></div>\n  <div></div> \n</div>-->\n\n<div class=\"ball-grid-pulse\">\n  <div></div>\n  <div></div>\n  <div></div>\n  <div></div>\n  <div></div>\n  <div></div>\n  <div></div>\n  <div></div>\n  <div></div>\n</div>\n","export default \"/* ========================================================================\\n   Component: layout\\n ========================================================================== */\\nbody, .wrapper .section-container {\\n  background-color: #f5f7fa;\\n}\\n.wrapper .aside-container {\\n  background-color: #3a3f51;\\n}\\n/* ========================================================================\\n   Component: top-navbar\\n ========================================================================== */\\n.topnavbar {\\n  background-color: #2b957a;\\n  background-image: linear-gradient(to right, #2b957a 0%, #37bc9b 100%);\\n  background-repeat: repeat-x;\\n}\\n@media (min-width: 992px) {\\n  .topnavbar .navbar-nav > .nav-item.show > .nav-link, .topnavbar .navbar-nav > .nav-item.show > .nav-link:hover, .topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n    box-shadow: 0 -3px 0 #257d67 inset;\\n  }\\n}\\n.topnavbar .navbar-nav > .nav-item > .navbar-text {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link:hover, .topnavbar .navbar-nav > .nav-item > .nav-link:focus,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:hover,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n  color: #144639;\\n}\\n.topnavbar .dropdown-item.active, .topnavbar .dropdown-item:active {\\n  background-color: #2b957a;\\n}\\n/* ========================================================================\\n   Component: sidebar\\n ========================================================================== */\\n.sidebar {\\n  background-color: #3a3f51;\\n}\\n.sidebar .nav-heading {\\n  color: #919DA8;\\n}\\n.sidebar-nav > li > a, .sidebar-nav > li > .nav-item {\\n  color: #e1e2e3;\\n}\\n.sidebar-nav > li > a:focus, .sidebar-nav > li > a:hover, .sidebar-nav > li > .nav-item:focus, .sidebar-nav > li > .nav-item:hover {\\n  color: #2b957a;\\n}\\n.sidebar-nav > li > a > em, .sidebar-nav > li > .nav-item > em {\\n  color: inherits;\\n}\\n.sidebar-nav > li.active, .sidebar-nav > li.active > a, .sidebar-nav > li.active > .nav-item, .sidebar-nav > li.active .sidebar-nav, .sidebar-nav > li.open, .sidebar-nav > li.open > a, .sidebar-nav > li.open > .nav-item, .sidebar-nav > li.open .sidebar-nav {\\n  background-color: #383d4e;\\n  color: #2b957a;\\n}\\n.sidebar-nav > li.active > .nav-item > em, .sidebar-nav > li.active > a > em, .sidebar-nav > li.open > .nav-item > em, .sidebar-nav > li.open > a > em {\\n  color: #2b957a;\\n}\\n.sidebar-nav > li.active {\\n  border-left-color: #2b957a;\\n}\\n.sidebar-subnav {\\n  background-color: #3a3f51;\\n}\\n.sidebar-subnav > .sidebar-subnav-header {\\n  color: #e1e2e3;\\n}\\n.sidebar-subnav > li > a, .sidebar-subnav > li > .nav-item {\\n  color: #e1e2e3;\\n}\\n.sidebar-subnav > li > a:focus, .sidebar-subnav > li > a:hover, .sidebar-subnav > li > .nav-item:focus, .sidebar-subnav > li > .nav-item:hover {\\n  color: #2b957a;\\n}\\n.sidebar-subnav > li.active > a, .sidebar-subnav > li.active > .nav-item {\\n  color: #2b957a;\\n}\\n.sidebar-subnav > li.active > a:after, .sidebar-subnav > li.active > .nav-item:after {\\n  border-color: #2b957a;\\n  background-color: #2b957a;\\n}\\n/* ========================================================================\\n   Component: offsidebar\\n ========================================================================== */\\n.offsidebar {\\n  border-left: 1px solid greyscale(#cccccc);\\n  background-color: #fff;\\n  color: #656565;\\n}\\n/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/app/shared/style/theme/theme-f.scss","src/app/shared/style/app/variables.scss","src/app/shared/style/bootstrap/mixins/_gradients.scss","src/app/shared/style/bootstrap/mixins/_breakpoints.scss"],"names":[],"mappings":"AA8CA;;6EAAA;AAGA;EACI,yBAzC4B;AAJhC;AAgDA;EACI,yBCnDoB;ADMxB;AAgDA;;6EAAA;AAGA;EACI,yBCnBoB;EC5BtB,qEAAA;EACA,2BAAA;AFGF;AG0CI;EHMQ;IACI,kCAAA;EA7Cd;AACF;AAiDI;EACI,WAtDwB;AAOhC;AAkDI;;EAEI,WA3DwB;AAWhC;AAiDQ;;;EACI,cA5DoB;AAehC;AAiDI;EACI,yBC3CgB;ADJxB;AAmDA;;6EAAA;AAGA;EACI,yBC1FoB;AD0CxB;AAkDI;EACI,cA5D0B;AAYlC;AAuDQ;EACI,cA9EsB;AA0BlC;AAsDY;EACI,cCjEQ;ADaxB;AAwDY;EACI,eAlFkB;AA4BlC;AA6DY;EACI,yBA5FkB;EA6FlB,cC/EQ;ADoBxB;AA8DY;EACI,cCnFQ;ADuBxB;AAiEQ;EACI,0BCzFY;AD0BxB;AAsEA;EACI,yBCxIoB;ADqExB;AAqEI;EACI,cApH0B;AAiDlC;AAuEQ;EACI,cAzHsB;AAoDlC;AAuEY;EACI,cC5GQ;ADuCxB;AA2EY;EACI,cCnHQ;AD0CxB;AA2EgB;EACI,qBCtHI;EDuHJ,yBCvHI;AD8CxB;AAoFA;;6EAAA;AAGA;EACI,yCAAA;EACA,sBAxIsB;EAyItB,cCrCwB;AD5C5B","file":"src/app/shared/style/theme/theme-f.scss","sourcesContent":["// Bootstrap\r\n@import \"../bootstrap/functions\";\r\n@import \"../bootstrap/variables\";\r\n@import \"../bootstrap/mixins\";\r\n@import '../app/variables';\r\n\r\n\r\n// LAYOUT\r\n\r\n$content-bg:                    #f5f7fa;\r\n$aside-bg:                      $gray-dark;\r\n\r\n// NAVBAR TOP\r\n\r\n$nav-top-bg:                    $green-dark;\r\n$nav-top-bg-start:              $nav-top-bg;\r\n$nav-top-bg-end:                $green;\r\n$nav-header-bg:                 transparent;\r\n\r\n$nav-top-item:                  #fff;\r\n$nav-top-item-active:           darken($nav-top-bg, 20%);\r\n\r\n// SIDEBAR\r\n\r\n$sidebar-bg:                      $aside-bg;\r\n\r\n$sidebar-item-color:              #e1e2e3;\r\n$sidebar-item-color-active:       $nav-top-bg;\r\n$sidebar-item-bg-active:          darken($sidebar-bg, 1%);\r\n\r\n$sidebar-icon-color:              inherits;\r\n$sidebar-icon-color-active:       $nav-top-bg;\r\n\r\n$sidebar-bullet-color:            rgba(0,0,0,.25);\r\n$sidebar-bullet-color-active:     $sidebar-icon-color-active;\r\n\r\n$sidebar-heading-color:           #919DA8;\r\n$sidebar-label-color:             $sidebar-item-color;\r\n\r\n// OFFSIDEBAR\r\n\r\n$offsidebar-bg:           #fff;\r\n$offsidebar-border-color: greyscale(darken($offsidebar-bg, 20%));\r\n$offsidebar-color:        $body-color;\r\n\r\n\r\n/* ========================================================================\r\n   Component: layout\r\n ========================================================================== */\r\nbody, .wrapper .section-container {\r\n    background-color: $content-bg;\r\n}\r\n\r\n.wrapper .aside-container {\r\n    background-color: $aside-bg;\r\n}\r\n\r\n/* ========================================================================\r\n   Component: top-navbar\r\n ========================================================================== */\r\n.topnavbar {\r\n    background-color: $nav-top-bg;\r\n    @include gradient-x($nav-top-bg-start, $nav-top-bg-end);\r\n\r\n    @include media-breakpoint-up(lg) {\r\n        .navbar-nav > .nav-item.show > .nav-link {\r\n            &, &:hover, &:focus {\r\n                box-shadow: 0 -3px 0 darken($nav-top-bg, 6%) inset;\r\n            }\r\n        }\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .navbar-text {\r\n        color: $nav-top-item;\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .nav-link,\r\n    .navbar-nav > .nav-item.show > .nav-link {\r\n        color: $nav-top-item;\r\n        &:hover, &:focus {\r\n            color: $nav-top-item-active;\r\n        }\r\n    }\r\n\r\n    .dropdown-item.active, .dropdown-item:active {\r\n        background-color: $nav-top-bg;\r\n    }\r\n}\r\n\r\n/* ========================================================================\r\n   Component: sidebar\r\n ========================================================================== */\r\n.sidebar {\r\n    background-color: $sidebar-bg;\r\n\r\n    .nav-heading {\r\n        color: $sidebar-heading-color;\r\n    }\r\n}\r\n\r\n// Items\r\n.sidebar-nav {\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            // Item icon\r\n            > em {\r\n                color: $sidebar-icon-color;\r\n            }\r\n\r\n        }\r\n\r\n        // Active item state\r\n        &.active, &.open {\r\n            &, > a, > .nav-item, .sidebar-nav {\r\n                background-color: $sidebar-item-bg-active;\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            > .nav-item > em, > a > em {\r\n                color: $sidebar-icon-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            border-left-color: $sidebar-item-color-active;\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n.sidebar-subnav {\r\n    background-color: $sidebar-bg;\r\n\r\n    > .sidebar-subnav-header {\r\n        color: $sidebar-item-color;\r\n    }\r\n\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            > a, > .nav-item {\r\n                color: $sidebar-icon-color-active;\r\n\r\n                &:after {\r\n                    border-color: $sidebar-bullet-color-active;\r\n                    background-color: $sidebar-bullet-color-active;\r\n                }\r\n\r\n            }\r\n\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n/* ========================================================================\r\n   Component: offsidebar\r\n ========================================================================== */\r\n.offsidebar {\r\n    border-left: 1px solid $offsidebar-border-color;\r\n    background-color: $offsidebar-bg;\r\n    color: $offsidebar-color;\r\n}\r\n","\r\n// Cutoms Gray colors for theme\r\n$gray-darker:           #232735;\r\n$gray-dark:             #3a3f51;\r\n$gray:                  #dde6e9;\r\n$gray-light:            #e4eaec;\r\n$gray-lighter:          #edf1f2;\r\n\r\n// Custom brand colors for theme\r\n$inverse:               #131e26;\r\n$purple:                #7266ba;\r\n$pink:                  #f532e5;\r\n$yellow:                #fad732;\r\n$green:                 #37bc9b;\r\n\r\n$primary:               #5d9cec;\r\n$secondary:             #fff;\r\n$success:               #27c24c;\r\n$info:                  #23b7e5;\r\n$warning:               #ff902b;\r\n$danger:                #f05050;\r\n$dark:                  #3a3f51;\r\n\r\n// Custom color variants\r\n$amountOfLight: 10%;\r\n\r\n$primary-light:         lighten($primary, $amountOfLight);\r\n$success-light:         lighten($success, $amountOfLight);\r\n$info-light:            lighten($info, $amountOfLight);\r\n$warning-light:         lighten($warning, $amountOfLight);\r\n$danger-light:          lighten($danger, $amountOfLight);\r\n$inverse-light:         lighten($inverse, $amountOfLight);\r\n$green-light:           lighten($green, $amountOfLight);\r\n$pink-light:            lighten($pink, $amountOfLight);\r\n$purple-light:          lighten($purple, $amountOfLight);\r\n$yellow-light:          lighten($yellow, $amountOfLight);\r\n$primary-dark:          darken($primary, $amountOfLight);\r\n$success-dark:          darken($success, $amountOfLight);\r\n$info-dark:             darken($info, $amountOfLight);\r\n$warning-dark:          darken($warning, $amountOfLight);\r\n$danger-dark:           darken($danger, $amountOfLight);\r\n$inverse-dark:          darken($inverse, $amountOfLight);\r\n$green-dark:            darken($green, $amountOfLight);\r\n$pink-dark:             darken($pink, $amountOfLight);\r\n$purple-dark:           darken($purple, $amountOfLight);\r\n$yellow-dark:           darken($yellow, $amountOfLight);\r\n\r\n// Theme variables\r\n\r\n// used for sidebars and content spacing\r\n$navbar-height:                    55px;\r\n\r\n// Button secondary redefinition style for theme\r\n$btn-secondary-color:              #333;\r\n$btn-secondary-bg:                 #fff;\r\n$btn-secondary-border:             #eaeaea;\r\n\r\n// Top Border color for custom default cards (.card-default)\r\n$card-default-border-color:        #cfdbe2;\r\n\r\n\r\n// ---------------------\r\n// Utilities variables\r\n// ---------------------\r\n\r\n$text-alpha:            rgba(255,255,255,.5);\r\n$text-alpha-inverse:    rgba(0,0,0,.5);\r\n\r\n$font-size-base:        1rem;\r\n$text-sm:               $font-size-base * 0.74375;\r\n$text-md:               $font-size-base * 1.6625;\r\n$text-lg:               $font-size-base * 2.625;\r\n\r\n$border-color:          rgba(0,0,0,.12);\r\n\r\n$wd-xxs:                60px;\r\n$wd-xs:                 90px;\r\n$wd-sm:                 150px;\r\n$wd-sd:                 200px; // sd == standard\r\n$wd-md:                 240px;\r\n$wd-lg:                 280px;\r\n$wd-xl:                 320px;\r\n$wd-xxl:                360px;\r\n$wd-wide:               100%;\r\n$wd-auto:               auto;\r\n$wd-zero:               0;\r\n\r\n\r\n// ---------------------\r\n// Bootstrap 4 Variables Override\r\n// ---------------------\r\n\r\n// Color system\r\n\r\n$colors: (\r\n    \"purple\":     $purple,\r\n    \"pink\":       $pink,\r\n    \"yellow\":     $yellow,\r\n    \"green\":      $green,\r\n    \"primary\":    $primary,\r\n    \"success\":    $success,\r\n    \"info\":       $info,\r\n    \"warning\":    $warning,\r\n    \"danger\":     $danger,\r\n    'inverse':    $inverse,\r\n\r\n    'primary-light': $primary-light,\r\n    'primary-dark':  $primary-dark,\r\n    'success-light': $success-light,\r\n    'success-dark':  $success-dark,\r\n    'info-light':    $info-light,\r\n    'info-dark':     $info-dark,\r\n    'warning-light': $warning-light,\r\n    'warning-dark':  $warning-dark,\r\n    'danger-light':  $danger-light,\r\n    'danger-dark':   $danger-dark,\r\n    'green-light':   $green-light,\r\n    'green-dark':    $green-dark,\r\n    'pink-light':    $pink-light,\r\n    'pink-dark':     $pink-dark,\r\n    'purple-light':  $purple-light,\r\n    'purple-dark':   $purple-dark,\r\n    'inverse-light': $inverse-light,\r\n    'inverse-dark':  $inverse-dark,\r\n    'yellow-light':  $yellow-light,\r\n    'yellow-dark':   $yellow-dark,\r\n);\r\n\r\n\r\n$theme-colors: (\r\n  \"primary\":    $primary,\r\n  \"secondary\":  $secondary,\r\n  \"success\":    $success,\r\n  \"info\":       $info,\r\n  \"warning\":    $warning,\r\n  \"danger\":     $danger\r\n);\r\n\r\n// Body\r\n\r\n$body-bg:                   #f5f7fa;\r\n$body-color:                #656565;\r\n\r\n$border-radius:               .25rem;\r\n$border-radius-lg:            .375rem;\r\n\r\n$line-height-base:            1.528571429;\r\n\r\n$headings-line-height:        1.1;\r\n\r\n$text-muted:                  #909FA7;\r\n\r\n// Tables\r\n\r\n$table-accent-bg:             #fafbfc;\r\n$table-hover-bg:              #fafbfc;\r\n\r\n$table-border-color:          #eee;\r\n\r\n// Buttons + Forms\r\n\r\n$input-btn-padding-y:         .375rem;\r\n$input-btn-padding-x:         1rem;\r\n\r\n$input-btn-padding-y-sm:      .3125rem;\r\n$input-btn-padding-x-sm:      .625rem;\r\n\r\n$input-btn-padding-y-lg:      .625rem;\r\n$input-btn-padding-x-lg:      1.25rem;\r\n\r\n$input-height:                2.1875rem; // 35px\r\n\r\n// Forms\r\n\r\n$input-disabled-bg:                     $gray-lighter;\r\n$input-border-color:                    $gray;\r\n$input-focus-border-color:              #66afe9;\r\n$input-placeholder-color:               #b7bac9;\r\n\r\n$form-feedback-icon-valid:              none;\r\n$form-feedback-icon-invalid:            none;\r\n\r\n$custom-control-indicator-active-bg:    lighten($primary, 25%);\r\n\r\n// Dropdowns\r\n\r\n$dropdown-border-color:             #e1e1e1;\r\n\r\n// Navs\r\n\r\n$nav-tabs-link-active-bg:           #fff;\r\n\r\n// Jumbotron\r\n\r\n$jumbotron-bg:                      #fcfcfc;\r\n\r\n// List group\r\n\r\n$list-group-border-color:           #e4eaec;\r\n\r\n// Image thumbnails\r\n\r\n$thumbnail-padding:                 .125rem;\r\n\r\n\r\n// Breadcrumbs\r\n\r\n$breadcrumb-bg:                     #fafafa;\r\n$breadcrumb-divider-color:          #c1c2c3;\r\n$breadcrumb-active-color:           $body-color;\r\n","// Gradients\r\n\r\n@mixin gradient-bg($color) {\r\n  @if $enable-gradients {\r\n    background: $color linear-gradient(180deg, mix($body-bg, $color, 15%), $color) repeat-x;\r\n  } @else {\r\n    background-color: $color;\r\n  }\r\n}\r\n\r\n// Horizontal gradient, from left to right\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-x($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to right, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n// Vertical gradient, from top to bottom\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-y($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to bottom, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n@mixin gradient-directional($start-color: $gray-700, $end-color: $gray-800, $deg: 45deg) {\r\n  background-image: linear-gradient($deg, $start-color, $end-color);\r\n  background-repeat: repeat-x;\r\n}\r\n@mixin gradient-x-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient(to right, $start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-y-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient($start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-radial($inner-color: $gray-700, $outer-color: $gray-800) {\r\n  background-image: radial-gradient(circle, $inner-color, $outer-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-striped($color: rgba($white, .15), $angle: 45deg) {\r\n  background-image: linear-gradient($angle, $color 25%, transparent 25%, transparent 50%, $color 50%, $color 75%, transparent 75%, transparent);\r\n}\r\n","// Breakpoint viewport sizes and media queries.\r\n//\r\n// Breakpoints are defined as a map of (name: minimum width), order from small to large:\r\n//\r\n//    (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px)\r\n//\r\n// The map defined in the `$grid-breakpoints` global variable is used as the `$breakpoints` argument by default.\r\n\r\n// Name of the next breakpoint, or null for the last breakpoint.\r\n//\r\n//    >> breakpoint-next(sm)\r\n//    md\r\n//    >> breakpoint-next(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    md\r\n//    >> breakpoint-next(sm, $breakpoint-names: (xs sm md lg xl))\r\n//    md\r\n@function breakpoint-next($name, $breakpoints: $grid-breakpoints, $breakpoint-names: map-keys($breakpoints)) {\r\n  $n: index($breakpoint-names, $name);\r\n  @return if($n != null and $n < length($breakpoint-names), nth($breakpoint-names, $n + 1), null);\r\n}\r\n\r\n// Minimum breakpoint width. Null for the smallest (first) breakpoint.\r\n//\r\n//    >> breakpoint-min(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    576px\r\n@function breakpoint-min($name, $breakpoints: $grid-breakpoints) {\r\n  $min: map-get($breakpoints, $name);\r\n  @return if($min != 0, $min, null);\r\n}\r\n\r\n// Maximum breakpoint width. Null for the largest (last) breakpoint.\r\n// The maximum value is calculated as the minimum of the next one less 0.02px\r\n// to work around the limitations of `min-` and `max-` prefixes and viewports with fractional widths.\r\n// See https://www.w3.org/TR/mediaqueries-4/#mq-min-max\r\n// Uses 0.02px rather than 0.01px to work around a current rounding bug in Safari.\r\n// See https://bugs.webkit.org/show_bug.cgi?id=178261\r\n//\r\n//    >> breakpoint-max(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    767.98px\r\n@function breakpoint-max($name, $breakpoints: $grid-breakpoints) {\r\n  $next: breakpoint-next($name, $breakpoints);\r\n  @return if($next, breakpoint-min($next, $breakpoints) - .02, null);\r\n}\r\n\r\n// Returns a blank string if smallest breakpoint, otherwise returns the name with a dash in front.\r\n// Useful for making responsive utilities.\r\n//\r\n//    >> breakpoint-infix(xs, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"\"  (Returns a blank string)\r\n//    >> breakpoint-infix(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"-sm\"\r\n@function breakpoint-infix($name, $breakpoints: $grid-breakpoints) {\r\n  @return if(breakpoint-min($name, $breakpoints) == null, \"\", \"-#{$name}\");\r\n}\r\n\r\n// Media of at least the minimum breakpoint width. No query for the smallest breakpoint.\r\n// Makes the @content apply to the given breakpoint and wider.\r\n@mixin media-breakpoint-up($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  @if $min {\r\n    @media (min-width: $min) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media of at most the maximum breakpoint width. No query for the largest breakpoint.\r\n// Makes the @content apply to the given breakpoint and narrower.\r\n@mixin media-breakpoint-down($name, $breakpoints: $grid-breakpoints) {\r\n  $max: breakpoint-max($name, $breakpoints);\r\n  @if $max {\r\n    @media (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media that spans multiple breakpoint widths.\r\n// Makes the @content apply between the min and max breakpoints\r\n@mixin media-breakpoint-between($lower, $upper, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($lower, $breakpoints);\r\n  $max: breakpoint-max($upper, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($lower, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($upper, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n\r\n// Media between the breakpoint's minimum and maximum widths.\r\n// No minimum for the smallest breakpoint, and no maximum for the largest one.\r\n// Makes the @content apply only to the given breakpoint, not viewports any wider or narrower.\r\n@mixin media-breakpoint-only($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  $max: breakpoint-max($name, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n"]} */\";","export default \"/* ========================================================================\\n   Component: layout\\n ========================================================================== */\\nbody, .wrapper .section-container {\\n  background-color: #f5f7fa;\\n}\\n.wrapper .aside-container {\\n  background-color: #fff;\\n}\\n/* ========================================================================\\n   Component: top-navbar\\n ========================================================================== */\\n.topnavbar {\\n  background-color: #37bc9b;\\n  background-image: linear-gradient(to right, #37bc9b 0%, #58ceb1 100%);\\n  background-repeat: repeat-x;\\n}\\n@media (min-width: 992px) {\\n  .topnavbar .navbar-nav > .nav-item.show > .nav-link, .topnavbar .navbar-nav > .nav-item.show > .nav-link:hover, .topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n    box-shadow: 0 -3px 0 #30a487 inset;\\n  }\\n}\\n.topnavbar .navbar-nav > .nav-item > .navbar-text {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link:hover, .topnavbar .navbar-nav > .nav-item > .nav-link:focus,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:hover,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n  color: #206d5a;\\n}\\n.topnavbar .dropdown-item.active, .topnavbar .dropdown-item:active {\\n  background-color: #37bc9b;\\n}\\n/* ========================================================================\\n   Component: sidebar\\n ========================================================================== */\\n.sidebar {\\n  background-color: #fff;\\n}\\n.sidebar .nav-heading {\\n  color: #919DA8;\\n}\\n.sidebar-nav > li > a, .sidebar-nav > li > .nav-item {\\n  color: #515253;\\n}\\n.sidebar-nav > li > a:focus, .sidebar-nav > li > a:hover, .sidebar-nav > li > .nav-item:focus, .sidebar-nav > li > .nav-item:hover {\\n  color: #37bc9b;\\n}\\n.sidebar-nav > li > a > em, .sidebar-nav > li > .nav-item > em {\\n  color: inherits;\\n}\\n.sidebar-nav > li.active, .sidebar-nav > li.active > a, .sidebar-nav > li.active > .nav-item, .sidebar-nav > li.active .sidebar-nav, .sidebar-nav > li.open, .sidebar-nav > li.open > a, .sidebar-nav > li.open > .nav-item, .sidebar-nav > li.open .sidebar-nav {\\n  background-color: #fcfcfc;\\n  color: #37bc9b;\\n}\\n.sidebar-nav > li.active > .nav-item > em, .sidebar-nav > li.active > a > em, .sidebar-nav > li.open > .nav-item > em, .sidebar-nav > li.open > a > em {\\n  color: #37bc9b;\\n}\\n.sidebar-nav > li.active {\\n  border-left-color: #37bc9b;\\n}\\n.sidebar-subnav {\\n  background-color: #fff;\\n}\\n.sidebar-subnav > .sidebar-subnav-header {\\n  color: #515253;\\n}\\n.sidebar-subnav > li > a, .sidebar-subnav > li > .nav-item {\\n  color: #515253;\\n}\\n.sidebar-subnav > li > a:focus, .sidebar-subnav > li > a:hover, .sidebar-subnav > li > .nav-item:focus, .sidebar-subnav > li > .nav-item:hover {\\n  color: #37bc9b;\\n}\\n.sidebar-subnav > li.active > a, .sidebar-subnav > li.active > .nav-item {\\n  color: #37bc9b;\\n}\\n.sidebar-subnav > li.active > a:after, .sidebar-subnav > li.active > .nav-item:after {\\n  border-color: #37bc9b;\\n  background-color: #37bc9b;\\n}\\n/* ========================================================================\\n   Component: offsidebar\\n ========================================================================== */\\n.offsidebar {\\n  border-left: 1px solid greyscale(#cccccc);\\n  background-color: #fff;\\n  color: #656565;\\n}\\n/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/app/shared/style/theme/theme-b.scss","src/app/shared/style/app/variables.scss","src/app/shared/style/bootstrap/mixins/_gradients.scss","src/app/shared/style/bootstrap/mixins/_breakpoints.scss"],"names":[],"mappings":"AA8CA;;6EAAA;AAGA;EACI,yBAzC4B;AAJhC;AAgDA;EACI,sBA5C4B;AADhC;AAgDA;;6EAAA;AAGA;EACI,yBChDoB;ECCtB,qEAAA;EACA,2BAAA;AFGF;AG0CI;EHMQ;IACI,kCAAA;EA7Cd;AACF;AAiDI;EACI,WAtDwB;AAOhC;AAkDI;;EAEI,WA3DwB;AAWhC;AAiDQ;;;EACI,cA5DoB;AAehC;AAiDI;EACI,yBCxEgB;ADyBxB;AAmDA;;6EAAA;AAGA;EACI,sBAnF4B;AAmChC;AAkDI;EACI,cA5D0B;AAYlC;AAuDQ;EACI,cA9EsB;AA0BlC;AAsDY;EACI,cC9FQ;AD0CxB;AAwDY;EACI,eAlFkB;AA4BlC;AA6DY;EACI,yBA5FkB;EA6FlB,cC5GQ;ADiDxB;AA8DY;EACI,cChHQ;ADoDxB;AAiEQ;EACI,0BCtHY;ADuDxB;AAsEA;EACI,sBAjI4B;AA8DhC;AAqEI;EACI,cApH0B;AAiDlC;AAuEQ;EACI,cAzHsB;AAoDlC;AAuEY;EACI,cCzIQ;ADoExB;AA2EY;EACI,cChJQ;ADuExB;AA2EgB;EACI,qBCnJI;EDoJJ,yBCpJI;AD2ExB;AAoFA;;6EAAA;AAGA;EACI,yCAAA;EACA,sBAxIsB;EAyItB,cCrCwB;AD5C5B","file":"src/app/shared/style/theme/theme-b.scss","sourcesContent":["// Bootstrap\r\n@import \"../bootstrap/functions\";\r\n@import \"../bootstrap/variables\";\r\n@import \"../bootstrap/mixins\";\r\n@import '../app/variables';\r\n\r\n\r\n// LAYOUT\r\n\r\n$content-bg:                    #f5f7fa;\r\n$aside-bg:                      #fff;\r\n\r\n// NAVBAR TOP\r\n\r\n$nav-top-bg:                    $green;\r\n$nav-top-bg-start:              $nav-top-bg;\r\n$nav-top-bg-end:                $green-light;\r\n$nav-header-bg:                 transparent;\r\n\r\n$nav-top-item:                  #fff;\r\n$nav-top-item-active:           darken($nav-top-bg, 20%);\r\n\r\n// SIDEBAR\r\n\r\n$sidebar-bg:                      $aside-bg;\r\n\r\n$sidebar-item-color:              #515253;\r\n$sidebar-item-color-active:       $nav-top-bg;\r\n$sidebar-item-bg-active:          darken($sidebar-bg, 1%);\r\n\r\n$sidebar-icon-color:              inherits;\r\n$sidebar-icon-color-active:       $nav-top-bg;\r\n\r\n$sidebar-bullet-color:            rgba(0,0,0,.25);\r\n$sidebar-bullet-color-active:     $sidebar-icon-color-active;\r\n\r\n$sidebar-heading-color:           #919DA8;\r\n$sidebar-label-color:             $sidebar-item-color;\r\n\r\n// OFFSIDEBAR\r\n\r\n$offsidebar-bg:           #fff;\r\n$offsidebar-border-color: greyscale(darken($offsidebar-bg, 20%));\r\n$offsidebar-color:        $body-color;\r\n\r\n\r\n/* ========================================================================\r\n   Component: layout\r\n ========================================================================== */\r\nbody, .wrapper .section-container {\r\n    background-color: $content-bg;\r\n}\r\n\r\n.wrapper .aside-container {\r\n    background-color: $aside-bg;\r\n}\r\n\r\n/* ========================================================================\r\n   Component: top-navbar\r\n ========================================================================== */\r\n.topnavbar {\r\n    background-color: $nav-top-bg;\r\n    @include gradient-x($nav-top-bg-start, $nav-top-bg-end);\r\n\r\n    @include media-breakpoint-up(lg) {\r\n        .navbar-nav > .nav-item.show > .nav-link {\r\n            &, &:hover, &:focus {\r\n                box-shadow: 0 -3px 0 darken($nav-top-bg, 6%) inset;\r\n            }\r\n        }\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .navbar-text {\r\n        color: $nav-top-item;\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .nav-link,\r\n    .navbar-nav > .nav-item.show > .nav-link {\r\n        color: $nav-top-item;\r\n        &:hover, &:focus {\r\n            color: $nav-top-item-active;\r\n        }\r\n    }\r\n\r\n    .dropdown-item.active, .dropdown-item:active {\r\n        background-color: $nav-top-bg;\r\n    }\r\n}\r\n\r\n/* ========================================================================\r\n   Component: sidebar\r\n ========================================================================== */\r\n.sidebar {\r\n    background-color: $sidebar-bg;\r\n\r\n    .nav-heading {\r\n        color: $sidebar-heading-color;\r\n    }\r\n}\r\n\r\n// Items\r\n.sidebar-nav {\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            // Item icon\r\n            > em {\r\n                color: $sidebar-icon-color;\r\n            }\r\n\r\n        }\r\n\r\n        // Active item state\r\n        &.active, &.open {\r\n            &, > a, > .nav-item, .sidebar-nav {\r\n                background-color: $sidebar-item-bg-active;\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            > .nav-item > em, > a > em {\r\n                color: $sidebar-icon-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            border-left-color: $sidebar-item-color-active;\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n.sidebar-subnav {\r\n    background-color: $sidebar-bg;\r\n\r\n    > .sidebar-subnav-header {\r\n        color: $sidebar-item-color;\r\n    }\r\n\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            > a, > .nav-item {\r\n                color: $sidebar-icon-color-active;\r\n\r\n                &:after {\r\n                    border-color: $sidebar-bullet-color-active;\r\n                    background-color: $sidebar-bullet-color-active;\r\n                }\r\n\r\n            }\r\n\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n/* ========================================================================\r\n   Component: offsidebar\r\n ========================================================================== */\r\n.offsidebar {\r\n    border-left: 1px solid $offsidebar-border-color;\r\n    background-color: $offsidebar-bg;\r\n    color: $offsidebar-color;\r\n}\r\n","\r\n// Cutoms Gray colors for theme\r\n$gray-darker:           #232735;\r\n$gray-dark:             #3a3f51;\r\n$gray:                  #dde6e9;\r\n$gray-light:            #e4eaec;\r\n$gray-lighter:          #edf1f2;\r\n\r\n// Custom brand colors for theme\r\n$inverse:               #131e26;\r\n$purple:                #7266ba;\r\n$pink:                  #f532e5;\r\n$yellow:                #fad732;\r\n$green:                 #37bc9b;\r\n\r\n$primary:               #5d9cec;\r\n$secondary:             #fff;\r\n$success:               #27c24c;\r\n$info:                  #23b7e5;\r\n$warning:               #ff902b;\r\n$danger:                #f05050;\r\n$dark:                  #3a3f51;\r\n\r\n// Custom color variants\r\n$amountOfLight: 10%;\r\n\r\n$primary-light:         lighten($primary, $amountOfLight);\r\n$success-light:         lighten($success, $amountOfLight);\r\n$info-light:            lighten($info, $amountOfLight);\r\n$warning-light:         lighten($warning, $amountOfLight);\r\n$danger-light:          lighten($danger, $amountOfLight);\r\n$inverse-light:         lighten($inverse, $amountOfLight);\r\n$green-light:           lighten($green, $amountOfLight);\r\n$pink-light:            lighten($pink, $amountOfLight);\r\n$purple-light:          lighten($purple, $amountOfLight);\r\n$yellow-light:          lighten($yellow, $amountOfLight);\r\n$primary-dark:          darken($primary, $amountOfLight);\r\n$success-dark:          darken($success, $amountOfLight);\r\n$info-dark:             darken($info, $amountOfLight);\r\n$warning-dark:          darken($warning, $amountOfLight);\r\n$danger-dark:           darken($danger, $amountOfLight);\r\n$inverse-dark:          darken($inverse, $amountOfLight);\r\n$green-dark:            darken($green, $amountOfLight);\r\n$pink-dark:             darken($pink, $amountOfLight);\r\n$purple-dark:           darken($purple, $amountOfLight);\r\n$yellow-dark:           darken($yellow, $amountOfLight);\r\n\r\n// Theme variables\r\n\r\n// used for sidebars and content spacing\r\n$navbar-height:                    55px;\r\n\r\n// Button secondary redefinition style for theme\r\n$btn-secondary-color:              #333;\r\n$btn-secondary-bg:                 #fff;\r\n$btn-secondary-border:             #eaeaea;\r\n\r\n// Top Border color for custom default cards (.card-default)\r\n$card-default-border-color:        #cfdbe2;\r\n\r\n\r\n// ---------------------\r\n// Utilities variables\r\n// ---------------------\r\n\r\n$text-alpha:            rgba(255,255,255,.5);\r\n$text-alpha-inverse:    rgba(0,0,0,.5);\r\n\r\n$font-size-base:        1rem;\r\n$text-sm:               $font-size-base * 0.74375;\r\n$text-md:               $font-size-base * 1.6625;\r\n$text-lg:               $font-size-base * 2.625;\r\n\r\n$border-color:          rgba(0,0,0,.12);\r\n\r\n$wd-xxs:                60px;\r\n$wd-xs:                 90px;\r\n$wd-sm:                 150px;\r\n$wd-sd:                 200px; // sd == standard\r\n$wd-md:                 240px;\r\n$wd-lg:                 280px;\r\n$wd-xl:                 320px;\r\n$wd-xxl:                360px;\r\n$wd-wide:               100%;\r\n$wd-auto:               auto;\r\n$wd-zero:               0;\r\n\r\n\r\n// ---------------------\r\n// Bootstrap 4 Variables Override\r\n// ---------------------\r\n\r\n// Color system\r\n\r\n$colors: (\r\n    \"purple\":     $purple,\r\n    \"pink\":       $pink,\r\n    \"yellow\":     $yellow,\r\n    \"green\":      $green,\r\n    \"primary\":    $primary,\r\n    \"success\":    $success,\r\n    \"info\":       $info,\r\n    \"warning\":    $warning,\r\n    \"danger\":     $danger,\r\n    'inverse':    $inverse,\r\n\r\n    'primary-light': $primary-light,\r\n    'primary-dark':  $primary-dark,\r\n    'success-light': $success-light,\r\n    'success-dark':  $success-dark,\r\n    'info-light':    $info-light,\r\n    'info-dark':     $info-dark,\r\n    'warning-light': $warning-light,\r\n    'warning-dark':  $warning-dark,\r\n    'danger-light':  $danger-light,\r\n    'danger-dark':   $danger-dark,\r\n    'green-light':   $green-light,\r\n    'green-dark':    $green-dark,\r\n    'pink-light':    $pink-light,\r\n    'pink-dark':     $pink-dark,\r\n    'purple-light':  $purple-light,\r\n    'purple-dark':   $purple-dark,\r\n    'inverse-light': $inverse-light,\r\n    'inverse-dark':  $inverse-dark,\r\n    'yellow-light':  $yellow-light,\r\n    'yellow-dark':   $yellow-dark,\r\n);\r\n\r\n\r\n$theme-colors: (\r\n  \"primary\":    $primary,\r\n  \"secondary\":  $secondary,\r\n  \"success\":    $success,\r\n  \"info\":       $info,\r\n  \"warning\":    $warning,\r\n  \"danger\":     $danger\r\n);\r\n\r\n// Body\r\n\r\n$body-bg:                   #f5f7fa;\r\n$body-color:                #656565;\r\n\r\n$border-radius:               .25rem;\r\n$border-radius-lg:            .375rem;\r\n\r\n$line-height-base:            1.528571429;\r\n\r\n$headings-line-height:        1.1;\r\n\r\n$text-muted:                  #909FA7;\r\n\r\n// Tables\r\n\r\n$table-accent-bg:             #fafbfc;\r\n$table-hover-bg:              #fafbfc;\r\n\r\n$table-border-color:          #eee;\r\n\r\n// Buttons + Forms\r\n\r\n$input-btn-padding-y:         .375rem;\r\n$input-btn-padding-x:         1rem;\r\n\r\n$input-btn-padding-y-sm:      .3125rem;\r\n$input-btn-padding-x-sm:      .625rem;\r\n\r\n$input-btn-padding-y-lg:      .625rem;\r\n$input-btn-padding-x-lg:      1.25rem;\r\n\r\n$input-height:                2.1875rem; // 35px\r\n\r\n// Forms\r\n\r\n$input-disabled-bg:                     $gray-lighter;\r\n$input-border-color:                    $gray;\r\n$input-focus-border-color:              #66afe9;\r\n$input-placeholder-color:               #b7bac9;\r\n\r\n$form-feedback-icon-valid:              none;\r\n$form-feedback-icon-invalid:            none;\r\n\r\n$custom-control-indicator-active-bg:    lighten($primary, 25%);\r\n\r\n// Dropdowns\r\n\r\n$dropdown-border-color:             #e1e1e1;\r\n\r\n// Navs\r\n\r\n$nav-tabs-link-active-bg:           #fff;\r\n\r\n// Jumbotron\r\n\r\n$jumbotron-bg:                      #fcfcfc;\r\n\r\n// List group\r\n\r\n$list-group-border-color:           #e4eaec;\r\n\r\n// Image thumbnails\r\n\r\n$thumbnail-padding:                 .125rem;\r\n\r\n\r\n// Breadcrumbs\r\n\r\n$breadcrumb-bg:                     #fafafa;\r\n$breadcrumb-divider-color:          #c1c2c3;\r\n$breadcrumb-active-color:           $body-color;\r\n","// Gradients\r\n\r\n@mixin gradient-bg($color) {\r\n  @if $enable-gradients {\r\n    background: $color linear-gradient(180deg, mix($body-bg, $color, 15%), $color) repeat-x;\r\n  } @else {\r\n    background-color: $color;\r\n  }\r\n}\r\n\r\n// Horizontal gradient, from left to right\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-x($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to right, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n// Vertical gradient, from top to bottom\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-y($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to bottom, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n@mixin gradient-directional($start-color: $gray-700, $end-color: $gray-800, $deg: 45deg) {\r\n  background-image: linear-gradient($deg, $start-color, $end-color);\r\n  background-repeat: repeat-x;\r\n}\r\n@mixin gradient-x-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient(to right, $start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-y-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient($start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-radial($inner-color: $gray-700, $outer-color: $gray-800) {\r\n  background-image: radial-gradient(circle, $inner-color, $outer-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-striped($color: rgba($white, .15), $angle: 45deg) {\r\n  background-image: linear-gradient($angle, $color 25%, transparent 25%, transparent 50%, $color 50%, $color 75%, transparent 75%, transparent);\r\n}\r\n","// Breakpoint viewport sizes and media queries.\r\n//\r\n// Breakpoints are defined as a map of (name: minimum width), order from small to large:\r\n//\r\n//    (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px)\r\n//\r\n// The map defined in the `$grid-breakpoints` global variable is used as the `$breakpoints` argument by default.\r\n\r\n// Name of the next breakpoint, or null for the last breakpoint.\r\n//\r\n//    >> breakpoint-next(sm)\r\n//    md\r\n//    >> breakpoint-next(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    md\r\n//    >> breakpoint-next(sm, $breakpoint-names: (xs sm md lg xl))\r\n//    md\r\n@function breakpoint-next($name, $breakpoints: $grid-breakpoints, $breakpoint-names: map-keys($breakpoints)) {\r\n  $n: index($breakpoint-names, $name);\r\n  @return if($n != null and $n < length($breakpoint-names), nth($breakpoint-names, $n + 1), null);\r\n}\r\n\r\n// Minimum breakpoint width. Null for the smallest (first) breakpoint.\r\n//\r\n//    >> breakpoint-min(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    576px\r\n@function breakpoint-min($name, $breakpoints: $grid-breakpoints) {\r\n  $min: map-get($breakpoints, $name);\r\n  @return if($min != 0, $min, null);\r\n}\r\n\r\n// Maximum breakpoint width. Null for the largest (last) breakpoint.\r\n// The maximum value is calculated as the minimum of the next one less 0.02px\r\n// to work around the limitations of `min-` and `max-` prefixes and viewports with fractional widths.\r\n// See https://www.w3.org/TR/mediaqueries-4/#mq-min-max\r\n// Uses 0.02px rather than 0.01px to work around a current rounding bug in Safari.\r\n// See https://bugs.webkit.org/show_bug.cgi?id=178261\r\n//\r\n//    >> breakpoint-max(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    767.98px\r\n@function breakpoint-max($name, $breakpoints: $grid-breakpoints) {\r\n  $next: breakpoint-next($name, $breakpoints);\r\n  @return if($next, breakpoint-min($next, $breakpoints) - .02, null);\r\n}\r\n\r\n// Returns a blank string if smallest breakpoint, otherwise returns the name with a dash in front.\r\n// Useful for making responsive utilities.\r\n//\r\n//    >> breakpoint-infix(xs, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"\"  (Returns a blank string)\r\n//    >> breakpoint-infix(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"-sm\"\r\n@function breakpoint-infix($name, $breakpoints: $grid-breakpoints) {\r\n  @return if(breakpoint-min($name, $breakpoints) == null, \"\", \"-#{$name}\");\r\n}\r\n\r\n// Media of at least the minimum breakpoint width. No query for the smallest breakpoint.\r\n// Makes the @content apply to the given breakpoint and wider.\r\n@mixin media-breakpoint-up($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  @if $min {\r\n    @media (min-width: $min) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media of at most the maximum breakpoint width. No query for the largest breakpoint.\r\n// Makes the @content apply to the given breakpoint and narrower.\r\n@mixin media-breakpoint-down($name, $breakpoints: $grid-breakpoints) {\r\n  $max: breakpoint-max($name, $breakpoints);\r\n  @if $max {\r\n    @media (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media that spans multiple breakpoint widths.\r\n// Makes the @content apply between the min and max breakpoints\r\n@mixin media-breakpoint-between($lower, $upper, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($lower, $breakpoints);\r\n  $max: breakpoint-max($upper, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($lower, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($upper, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n\r\n// Media between the breakpoint's minimum and maximum widths.\r\n// No minimum for the smallest breakpoint, and no maximum for the largest one.\r\n// Makes the @content apply only to the given breakpoint, not viewports any wider or narrower.\r\n@mixin media-breakpoint-only($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  $max: breakpoint-max($name, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n"]} */\";","'use strict';\r\n\r\n//Simulate for Admin\r\n export const Data = 'Search'; \r\n export const Admin = 'Search'; \r\n export const Search = 'Search';\r\n export const Publish = 'Search';\r\n","// This file can be replaced during build by using the `fileReplacements` array.\r\n// `ng build --prod` replaces `environment.ts` with `environment.prod.ts`.\r\n// The list of file replacements can be found in `angular.json`.\r\n\r\nexport const environment = {\r\n  production: false\r\n};\r\n\r\n/*\r\n * For easier debugging in development mode, you can import the following file\r\n * to ignore zone related error stack frames such as `zone.run`, `zoneDelegate.invokeTask`.\r\n *\r\n * This import should be commented out in production mode because it will have a negative impact\r\n * on performance if an error is thrown.\r\n */\r\n// import 'zone.js/dist/zone-error';  // Included with Angular CLI.\r\n","import * as globalVariable from '../core/globalVariable';\r\n\r\nconst permission = globalVariable.Admin;\r\n\r\nconst home = {\r\n    text: 'Home',\r\n    link: '/home',\r\n    icon: 'icon-home',\r\n    permission: permission\r\n};\r\n\r\nconst report = {\r\n    text: 'Report',\r\n    link: '/report',\r\n    icon: 'icon-grid',\r\n    permission: permission\r\n};\r\n\r\nexport const menu = [\r\n    home,\r\n    report\r\n];\r\n","export default \"/* ========================================================================\\n   Component: layout\\n ========================================================================== */\\nbody, .wrapper .section-container {\\n  background-color: #f5f7fa;\\n}\\n.wrapper .aside-container {\\n  background-color: #3a3f51;\\n}\\n/* ========================================================================\\n   Component: top-navbar\\n ========================================================================== */\\n.topnavbar {\\n  background-color: #ec2121;\\n  background-image: linear-gradient(to right, #ec2121 0%, #f05050 100%);\\n  background-repeat: repeat-x;\\n}\\n@media (min-width: 992px) {\\n  .topnavbar .navbar-nav > .nav-item.show > .nav-link, .topnavbar .navbar-nav > .nav-item.show > .nav-link:hover, .topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n    box-shadow: 0 -3px 0 #dc1313 inset;\\n  }\\n}\\n.topnavbar .navbar-nav > .nav-item > .navbar-text {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link:hover, .topnavbar .navbar-nav > .nav-item > .nav-link:focus,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:hover,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n  color: #9a0d0d;\\n}\\n.topnavbar .dropdown-item.active, .topnavbar .dropdown-item:active {\\n  background-color: #ec2121;\\n}\\n/* ========================================================================\\n   Component: sidebar\\n ========================================================================== */\\n.sidebar {\\n  background-color: #3a3f51;\\n}\\n.sidebar .nav-heading {\\n  color: #919DA8;\\n}\\n.sidebar-nav > li > a, .sidebar-nav > li > .nav-item {\\n  color: #e1e2e3;\\n}\\n.sidebar-nav > li > a:focus, .sidebar-nav > li > a:hover, .sidebar-nav > li > .nav-item:focus, .sidebar-nav > li > .nav-item:hover {\\n  color: #f05050;\\n}\\n.sidebar-nav > li > a > em, .sidebar-nav > li > .nav-item > em {\\n  color: inherits;\\n}\\n.sidebar-nav > li.active, .sidebar-nav > li.active > a, .sidebar-nav > li.active > .nav-item, .sidebar-nav > li.active .sidebar-nav, .sidebar-nav > li.open, .sidebar-nav > li.open > a, .sidebar-nav > li.open > .nav-item, .sidebar-nav > li.open .sidebar-nav {\\n  background-color: #383d4e;\\n  color: #f05050;\\n}\\n.sidebar-nav > li.active > .nav-item > em, .sidebar-nav > li.active > a > em, .sidebar-nav > li.open > .nav-item > em, .sidebar-nav > li.open > a > em {\\n  color: #f05050;\\n}\\n.sidebar-nav > li.active {\\n  border-left-color: #f05050;\\n}\\n.sidebar-subnav {\\n  background-color: #3a3f51;\\n}\\n.sidebar-subnav > .sidebar-subnav-header {\\n  color: #e1e2e3;\\n}\\n.sidebar-subnav > li > a, .sidebar-subnav > li > .nav-item {\\n  color: #e1e2e3;\\n}\\n.sidebar-subnav > li > a:focus, .sidebar-subnav > li > a:hover, .sidebar-subnav > li > .nav-item:focus, .sidebar-subnav > li > .nav-item:hover {\\n  color: #f05050;\\n}\\n.sidebar-subnav > li.active > a, .sidebar-subnav > li.active > .nav-item {\\n  color: #f05050;\\n}\\n.sidebar-subnav > li.active > a:after, .sidebar-subnav > li.active > .nav-item:after {\\n  border-color: #f05050;\\n  background-color: #f05050;\\n}\\n/* ========================================================================\\n   Component: offsidebar\\n ========================================================================== */\\n.offsidebar {\\n  border-left: 1px solid greyscale(#cccccc);\\n  background-color: #fff;\\n  color: #656565;\\n}\\n/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/app/shared/style/theme/theme-h.scss","src/app/shared/style/app/variables.scss","src/app/shared/style/bootstrap/mixins/_gradients.scss","src/app/shared/style/bootstrap/mixins/_breakpoints.scss"],"names":[],"mappings":"AA8CA;;6EAAA;AAGA;EACI,yBAzC4B;AAJhC;AAgDA;EACI,yBCnDoB;ADMxB;AAgDA;;6EAAA;AAGA;EACI,yBCrBoB;EC1BtB,qEAAA;EACA,2BAAA;AFGF;AG0CI;EHMQ;IACI,kCAAA;EA7Cd;AACF;AAiDI;EACI,WAtDwB;AAOhC;AAkDI;;EAEI,WA3DwB;AAWhC;AAiDQ;;;EACI,cA5DoB;AAehC;AAiDI;EACI,yBC7CgB;ADFxB;AAmDA;;6EAAA;AAGA;EACI,yBC1FoB;AD0CxB;AAkDI;EACI,cA5D0B;AAYlC;AAuDQ;EACI,cA9EsB;AA0BlC;AAsDY;EACI,cCvFQ;ADmCxB;AAwDY;EACI,eAlFkB;AA4BlC;AA6DY;EACI,yBA5FkB;EA6FlB,cCrGQ;AD0CxB;AA8DY;EACI,cCzGQ;AD6CxB;AAiEQ;EACI,0BC/GY;ADgDxB;AAsEA;EACI,yBCxIoB;ADqExB;AAqEI;EACI,cApH0B;AAiDlC;AAuEQ;EACI,cAzHsB;AAoDlC;AAuEY;EACI,cClIQ;AD6DxB;AA2EY;EACI,cCzIQ;ADgExB;AA2EgB;EACI,qBC5II;ED6IJ,yBC7II;ADoExB;AAoFA;;6EAAA;AAGA;EACI,yCAAA;EACA,sBAxIsB;EAyItB,cCrCwB;AD5C5B","file":"src/app/shared/style/theme/theme-h.scss","sourcesContent":["// Bootstrap\r\n@import \"../bootstrap/functions\";\r\n@import \"../bootstrap/variables\";\r\n@import \"../bootstrap/mixins\";\r\n@import '../app/variables';\r\n\r\n\r\n// LAYOUT\r\n\r\n$content-bg:                    #f5f7fa;\r\n$aside-bg:                      $gray-dark;\r\n\r\n// NAVBAR TOP\r\n\r\n$nav-top-bg:                    $danger-dark;\r\n$nav-top-bg-start:              $nav-top-bg;\r\n$nav-top-bg-end:                $danger;\r\n$nav-header-bg:                 transparent;\r\n\r\n$nav-top-item:                  #fff;\r\n$nav-top-item-active:           darken($nav-top-bg, 20%);\r\n\r\n// SIDEBAR\r\n\r\n$sidebar-bg:                      $aside-bg;\r\n\r\n$sidebar-item-color:              #e1e2e3;\r\n$sidebar-item-color-active:       $danger;\r\n$sidebar-item-bg-active:          darken($sidebar-bg, 1%);\r\n\r\n$sidebar-icon-color:              inherits;\r\n$sidebar-icon-color-active:       $sidebar-item-color-active;\r\n\r\n$sidebar-bullet-color:            rgba(0,0,0,.25);\r\n$sidebar-bullet-color-active:     $sidebar-icon-color-active;\r\n\r\n$sidebar-heading-color:           #919DA8;\r\n$sidebar-label-color:             $sidebar-item-color;\r\n\r\n// OFFSIDEBAR\r\n\r\n$offsidebar-bg:           #fff;\r\n$offsidebar-border-color: greyscale(darken($offsidebar-bg, 20%));\r\n$offsidebar-color:        $body-color;\r\n\r\n\r\n/* ========================================================================\r\n   Component: layout\r\n ========================================================================== */\r\nbody, .wrapper .section-container {\r\n    background-color: $content-bg;\r\n}\r\n\r\n.wrapper .aside-container {\r\n    background-color: $aside-bg;\r\n}\r\n\r\n/* ========================================================================\r\n   Component: top-navbar\r\n ========================================================================== */\r\n.topnavbar {\r\n    background-color: $nav-top-bg;\r\n    @include gradient-x($nav-top-bg-start, $nav-top-bg-end);\r\n\r\n    @include media-breakpoint-up(lg) {\r\n        .navbar-nav > .nav-item.show > .nav-link {\r\n            &, &:hover, &:focus {\r\n                box-shadow: 0 -3px 0 darken($nav-top-bg, 6%) inset;\r\n            }\r\n        }\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .navbar-text {\r\n        color: $nav-top-item;\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .nav-link,\r\n    .navbar-nav > .nav-item.show > .nav-link {\r\n        color: $nav-top-item;\r\n        &:hover, &:focus {\r\n            color: $nav-top-item-active;\r\n        }\r\n    }\r\n\r\n    .dropdown-item.active, .dropdown-item:active {\r\n        background-color: $nav-top-bg;\r\n    }\r\n}\r\n\r\n/* ========================================================================\r\n   Component: sidebar\r\n ========================================================================== */\r\n.sidebar {\r\n    background-color: $sidebar-bg;\r\n\r\n    .nav-heading {\r\n        color: $sidebar-heading-color;\r\n    }\r\n}\r\n\r\n// Items\r\n.sidebar-nav {\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            // Item icon\r\n            > em {\r\n                color: $sidebar-icon-color;\r\n            }\r\n\r\n        }\r\n\r\n        // Active item state\r\n        &.active, &.open {\r\n            &, > a, > .nav-item, .sidebar-nav {\r\n                background-color: $sidebar-item-bg-active;\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            > .nav-item > em, > a > em {\r\n                color: $sidebar-icon-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            border-left-color: $sidebar-item-color-active;\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n.sidebar-subnav {\r\n    background-color: $sidebar-bg;\r\n\r\n    > .sidebar-subnav-header {\r\n        color: $sidebar-item-color;\r\n    }\r\n\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            > a, > .nav-item {\r\n                color: $sidebar-icon-color-active;\r\n\r\n                &:after {\r\n                    border-color: $sidebar-bullet-color-active;\r\n                    background-color: $sidebar-bullet-color-active;\r\n                }\r\n\r\n            }\r\n\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n/* ========================================================================\r\n   Component: offsidebar\r\n ========================================================================== */\r\n.offsidebar {\r\n    border-left: 1px solid $offsidebar-border-color;\r\n    background-color: $offsidebar-bg;\r\n    color: $offsidebar-color;\r\n}\r\n","\r\n// Cutoms Gray colors for theme\r\n$gray-darker:           #232735;\r\n$gray-dark:             #3a3f51;\r\n$gray:                  #dde6e9;\r\n$gray-light:            #e4eaec;\r\n$gray-lighter:          #edf1f2;\r\n\r\n// Custom brand colors for theme\r\n$inverse:               #131e26;\r\n$purple:                #7266ba;\r\n$pink:                  #f532e5;\r\n$yellow:                #fad732;\r\n$green:                 #37bc9b;\r\n\r\n$primary:               #5d9cec;\r\n$secondary:             #fff;\r\n$success:               #27c24c;\r\n$info:                  #23b7e5;\r\n$warning:               #ff902b;\r\n$danger:                #f05050;\r\n$dark:                  #3a3f51;\r\n\r\n// Custom color variants\r\n$amountOfLight: 10%;\r\n\r\n$primary-light:         lighten($primary, $amountOfLight);\r\n$success-light:         lighten($success, $amountOfLight);\r\n$info-light:            lighten($info, $amountOfLight);\r\n$warning-light:         lighten($warning, $amountOfLight);\r\n$danger-light:          lighten($danger, $amountOfLight);\r\n$inverse-light:         lighten($inverse, $amountOfLight);\r\n$green-light:           lighten($green, $amountOfLight);\r\n$pink-light:            lighten($pink, $amountOfLight);\r\n$purple-light:          lighten($purple, $amountOfLight);\r\n$yellow-light:          lighten($yellow, $amountOfLight);\r\n$primary-dark:          darken($primary, $amountOfLight);\r\n$success-dark:          darken($success, $amountOfLight);\r\n$info-dark:             darken($info, $amountOfLight);\r\n$warning-dark:          darken($warning, $amountOfLight);\r\n$danger-dark:           darken($danger, $amountOfLight);\r\n$inverse-dark:          darken($inverse, $amountOfLight);\r\n$green-dark:            darken($green, $amountOfLight);\r\n$pink-dark:             darken($pink, $amountOfLight);\r\n$purple-dark:           darken($purple, $amountOfLight);\r\n$yellow-dark:           darken($yellow, $amountOfLight);\r\n\r\n// Theme variables\r\n\r\n// used for sidebars and content spacing\r\n$navbar-height:                    55px;\r\n\r\n// Button secondary redefinition style for theme\r\n$btn-secondary-color:              #333;\r\n$btn-secondary-bg:                 #fff;\r\n$btn-secondary-border:             #eaeaea;\r\n\r\n// Top Border color for custom default cards (.card-default)\r\n$card-default-border-color:        #cfdbe2;\r\n\r\n\r\n// ---------------------\r\n// Utilities variables\r\n// ---------------------\r\n\r\n$text-alpha:            rgba(255,255,255,.5);\r\n$text-alpha-inverse:    rgba(0,0,0,.5);\r\n\r\n$font-size-base:        1rem;\r\n$text-sm:               $font-size-base * 0.74375;\r\n$text-md:               $font-size-base * 1.6625;\r\n$text-lg:               $font-size-base * 2.625;\r\n\r\n$border-color:          rgba(0,0,0,.12);\r\n\r\n$wd-xxs:                60px;\r\n$wd-xs:                 90px;\r\n$wd-sm:                 150px;\r\n$wd-sd:                 200px; // sd == standard\r\n$wd-md:                 240px;\r\n$wd-lg:                 280px;\r\n$wd-xl:                 320px;\r\n$wd-xxl:                360px;\r\n$wd-wide:               100%;\r\n$wd-auto:               auto;\r\n$wd-zero:               0;\r\n\r\n\r\n// ---------------------\r\n// Bootstrap 4 Variables Override\r\n// ---------------------\r\n\r\n// Color system\r\n\r\n$colors: (\r\n    \"purple\":     $purple,\r\n    \"pink\":       $pink,\r\n    \"yellow\":     $yellow,\r\n    \"green\":      $green,\r\n    \"primary\":    $primary,\r\n    \"success\":    $success,\r\n    \"info\":       $info,\r\n    \"warning\":    $warning,\r\n    \"danger\":     $danger,\r\n    'inverse':    $inverse,\r\n\r\n    'primary-light': $primary-light,\r\n    'primary-dark':  $primary-dark,\r\n    'success-light': $success-light,\r\n    'success-dark':  $success-dark,\r\n    'info-light':    $info-light,\r\n    'info-dark':     $info-dark,\r\n    'warning-light': $warning-light,\r\n    'warning-dark':  $warning-dark,\r\n    'danger-light':  $danger-light,\r\n    'danger-dark':   $danger-dark,\r\n    'green-light':   $green-light,\r\n    'green-dark':    $green-dark,\r\n    'pink-light':    $pink-light,\r\n    'pink-dark':     $pink-dark,\r\n    'purple-light':  $purple-light,\r\n    'purple-dark':   $purple-dark,\r\n    'inverse-light': $inverse-light,\r\n    'inverse-dark':  $inverse-dark,\r\n    'yellow-light':  $yellow-light,\r\n    'yellow-dark':   $yellow-dark,\r\n);\r\n\r\n\r\n$theme-colors: (\r\n  \"primary\":    $primary,\r\n  \"secondary\":  $secondary,\r\n  \"success\":    $success,\r\n  \"info\":       $info,\r\n  \"warning\":    $warning,\r\n  \"danger\":     $danger\r\n);\r\n\r\n// Body\r\n\r\n$body-bg:                   #f5f7fa;\r\n$body-color:                #656565;\r\n\r\n$border-radius:               .25rem;\r\n$border-radius-lg:            .375rem;\r\n\r\n$line-height-base:            1.528571429;\r\n\r\n$headings-line-height:        1.1;\r\n\r\n$text-muted:                  #909FA7;\r\n\r\n// Tables\r\n\r\n$table-accent-bg:             #fafbfc;\r\n$table-hover-bg:              #fafbfc;\r\n\r\n$table-border-color:          #eee;\r\n\r\n// Buttons + Forms\r\n\r\n$input-btn-padding-y:         .375rem;\r\n$input-btn-padding-x:         1rem;\r\n\r\n$input-btn-padding-y-sm:      .3125rem;\r\n$input-btn-padding-x-sm:      .625rem;\r\n\r\n$input-btn-padding-y-lg:      .625rem;\r\n$input-btn-padding-x-lg:      1.25rem;\r\n\r\n$input-height:                2.1875rem; // 35px\r\n\r\n// Forms\r\n\r\n$input-disabled-bg:                     $gray-lighter;\r\n$input-border-color:                    $gray;\r\n$input-focus-border-color:              #66afe9;\r\n$input-placeholder-color:               #b7bac9;\r\n\r\n$form-feedback-icon-valid:              none;\r\n$form-feedback-icon-invalid:            none;\r\n\r\n$custom-control-indicator-active-bg:    lighten($primary, 25%);\r\n\r\n// Dropdowns\r\n\r\n$dropdown-border-color:             #e1e1e1;\r\n\r\n// Navs\r\n\r\n$nav-tabs-link-active-bg:           #fff;\r\n\r\n// Jumbotron\r\n\r\n$jumbotron-bg:                      #fcfcfc;\r\n\r\n// List group\r\n\r\n$list-group-border-color:           #e4eaec;\r\n\r\n// Image thumbnails\r\n\r\n$thumbnail-padding:                 .125rem;\r\n\r\n\r\n// Breadcrumbs\r\n\r\n$breadcrumb-bg:                     #fafafa;\r\n$breadcrumb-divider-color:          #c1c2c3;\r\n$breadcrumb-active-color:           $body-color;\r\n","// Gradients\r\n\r\n@mixin gradient-bg($color) {\r\n  @if $enable-gradients {\r\n    background: $color linear-gradient(180deg, mix($body-bg, $color, 15%), $color) repeat-x;\r\n  } @else {\r\n    background-color: $color;\r\n  }\r\n}\r\n\r\n// Horizontal gradient, from left to right\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-x($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to right, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n// Vertical gradient, from top to bottom\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-y($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to bottom, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n@mixin gradient-directional($start-color: $gray-700, $end-color: $gray-800, $deg: 45deg) {\r\n  background-image: linear-gradient($deg, $start-color, $end-color);\r\n  background-repeat: repeat-x;\r\n}\r\n@mixin gradient-x-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient(to right, $start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-y-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient($start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-radial($inner-color: $gray-700, $outer-color: $gray-800) {\r\n  background-image: radial-gradient(circle, $inner-color, $outer-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-striped($color: rgba($white, .15), $angle: 45deg) {\r\n  background-image: linear-gradient($angle, $color 25%, transparent 25%, transparent 50%, $color 50%, $color 75%, transparent 75%, transparent);\r\n}\r\n","// Breakpoint viewport sizes and media queries.\r\n//\r\n// Breakpoints are defined as a map of (name: minimum width), order from small to large:\r\n//\r\n//    (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px)\r\n//\r\n// The map defined in the `$grid-breakpoints` global variable is used as the `$breakpoints` argument by default.\r\n\r\n// Name of the next breakpoint, or null for the last breakpoint.\r\n//\r\n//    >> breakpoint-next(sm)\r\n//    md\r\n//    >> breakpoint-next(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    md\r\n//    >> breakpoint-next(sm, $breakpoint-names: (xs sm md lg xl))\r\n//    md\r\n@function breakpoint-next($name, $breakpoints: $grid-breakpoints, $breakpoint-names: map-keys($breakpoints)) {\r\n  $n: index($breakpoint-names, $name);\r\n  @return if($n != null and $n < length($breakpoint-names), nth($breakpoint-names, $n + 1), null);\r\n}\r\n\r\n// Minimum breakpoint width. Null for the smallest (first) breakpoint.\r\n//\r\n//    >> breakpoint-min(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    576px\r\n@function breakpoint-min($name, $breakpoints: $grid-breakpoints) {\r\n  $min: map-get($breakpoints, $name);\r\n  @return if($min != 0, $min, null);\r\n}\r\n\r\n// Maximum breakpoint width. Null for the largest (last) breakpoint.\r\n// The maximum value is calculated as the minimum of the next one less 0.02px\r\n// to work around the limitations of `min-` and `max-` prefixes and viewports with fractional widths.\r\n// See https://www.w3.org/TR/mediaqueries-4/#mq-min-max\r\n// Uses 0.02px rather than 0.01px to work around a current rounding bug in Safari.\r\n// See https://bugs.webkit.org/show_bug.cgi?id=178261\r\n//\r\n//    >> breakpoint-max(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    767.98px\r\n@function breakpoint-max($name, $breakpoints: $grid-breakpoints) {\r\n  $next: breakpoint-next($name, $breakpoints);\r\n  @return if($next, breakpoint-min($next, $breakpoints) - .02, null);\r\n}\r\n\r\n// Returns a blank string if smallest breakpoint, otherwise returns the name with a dash in front.\r\n// Useful for making responsive utilities.\r\n//\r\n//    >> breakpoint-infix(xs, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"\"  (Returns a blank string)\r\n//    >> breakpoint-infix(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"-sm\"\r\n@function breakpoint-infix($name, $breakpoints: $grid-breakpoints) {\r\n  @return if(breakpoint-min($name, $breakpoints) == null, \"\", \"-#{$name}\");\r\n}\r\n\r\n// Media of at least the minimum breakpoint width. No query for the smallest breakpoint.\r\n// Makes the @content apply to the given breakpoint and wider.\r\n@mixin media-breakpoint-up($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  @if $min {\r\n    @media (min-width: $min) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media of at most the maximum breakpoint width. No query for the largest breakpoint.\r\n// Makes the @content apply to the given breakpoint and narrower.\r\n@mixin media-breakpoint-down($name, $breakpoints: $grid-breakpoints) {\r\n  $max: breakpoint-max($name, $breakpoints);\r\n  @if $max {\r\n    @media (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media that spans multiple breakpoint widths.\r\n// Makes the @content apply between the min and max breakpoints\r\n@mixin media-breakpoint-between($lower, $upper, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($lower, $breakpoints);\r\n  $max: breakpoint-max($upper, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($lower, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($upper, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n\r\n// Media between the breakpoint's minimum and maximum widths.\r\n// No minimum for the smallest breakpoint, and no maximum for the largest one.\r\n// Makes the @content apply only to the given breakpoint, not viewports any wider or narrower.\r\n@mixin media-breakpoint-only($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  $max: breakpoint-max($name, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n"]} */\";","import { OnInit, Directive, Input, ElementRef } from '@angular/core';\r\ndeclare var $: any;\r\n\r\n@Directive({\r\n    selector: 'scrollable'\r\n})\r\nexport class ScrollableDirective implements OnInit {\r\n\r\n    @Input() height: number;\r\n    defaultHeight = 250;\r\n\r\n    constructor(public element: ElementRef) { }\r\n\r\n    ngOnInit() {\r\n        $(this.element.nativeElement).slimScroll({\r\n            height: (this.height || this.defaultHeight)\r\n        });\r\n    }\r\n\r\n}\r\n","import { Inject, Injectable } from '@angular/core';\r\nimport { HttpClient, HttpParams, HttpHeaders } from '@angular/common/http';\r\nimport { Router } from '@angular/router';\r\n\r\nimport { BehaviorSubject, Observable } from 'rxjs';\r\n\r\nimport { LoginModel, SecurityInfo, SecurityPrivilege } from '../model/procedure.model';\r\n\r\nimport { SettingsService } from '../../core/settings/settings.service';\r\n\r\n@Injectable({\r\n    providedIn: 'root'\r\n})\r\n\r\nexport class LoginService {\r\n\r\n    appUrl: string;\r\n    apiUrl: string;\r\n    urlStr: string;\r\n    isValid: boolean;\r\n    searchParam: LoginModel;\r\n    searchResult: SecurityInfo;\r\n    warningLabel: string;\r\n    //is\r\n    isClient: boolean = true;\r\n    isEmployee: boolean = false;\r\n    //key\r\n    keyUserType = 'UserType';\r\n    keyCurrentUser = 'CurrentUser';\r\n    keyLogIn = 'login';\r\n    keyNavigateItems = [\r\n        '/' + this.keyLogIn\r\n    ];\r\n    httpOptions = {\r\n        headers: new HttpHeaders({\r\n            'Content-Type': 'application/json; charset=utf-8'\r\n        })\r\n    };\r\n\r\n    prilivages: SecurityPrivilege[];\r\n\r\n    user: Observable<SecurityInfo>;\r\n    value: Observable<boolean>;\r\n\r\n    private loggedInItem = new BehaviorSubject<boolean>(false);\r\n    private userInfoItem = new BehaviorSubject<SecurityInfo>(new SecurityInfo);\r\n\r\n    constructor(\r\n        private http: HttpClient,\r\n        private router: Router,\r\n        public settings: SettingsService,\r\n        @Inject('BASE_URL') private baseUrl: string) {\r\n        this.appUrl = this.baseUrl\r\n        this.apiUrl = this.keyLogIn + '/';\r\n        this.searchParam = new LoginModel();\r\n        this.searchResult = new SecurityInfo();\r\n    }\r\n\r\n    initialPermissions(userDetailInfo) {\r\n        this.setLoggedIn();\r\n        this.setUserInfo(userDetailInfo);\r\n        this.prilivages = userDetailInfo.securityPrivileges;\r\n    }\r\n    //has\r\n    hasPermission(requirePermission: string) {\r\n        /*\r\n        let tmpstr:string ='';\r\n     \r\n        if (this.prilivages) {\r\n          for (let i = 0; i < this.prilivages.length; ++i) { \r\n            if(this.prilivages[i].privilegeName==requirePermission){         \r\n              return true;\r\n            }\r\n          }\r\n        }\r\n        */\r\n        return true;\r\n    }\r\n    //is\r\n    get isLogged() {\r\n        let v: boolean = false;\r\n        let items = this.loggedInItem.asObservable();\r\n\r\n        items.subscribe((i: boolean) => { v = i; })\r\n\r\n        return v;\r\n    }\r\n    get isLoggedIn() {\r\n        this.value = this.loggedInItem.asObservable();\r\n\r\n        return this.value;\r\n    }\r\n    //set\r\n    setLoggedIn() {\r\n        this.loggedInItem.next(true);\r\n    }\r\n    //authenticate\r\n    authenticate(item: LoginModel) {\r\n        let url = this.getURL('Authenticate');\r\n        let items = new HttpParams();\r\n\r\n        items = items.set('username', item.username);\r\n        items = items.set('password', item.password);\r\n        items = items.set('software', item.software);\r\n\r\n        let data = this.http.get<SecurityInfo>(url,\r\n            {\r\n                params: items\r\n            });\r\n\r\n        return data;\r\n    }\r\n    //user\r\n    get userId() {\r\n        let id = 0;\r\n\r\n        this.userInfo\r\n            .subscribe(\r\n                (data: any) => {\r\n                    if (data != null) {\r\n                        let items = Object.keys(data);\r\n\r\n                        if (items != null) {\r\n                            let count = items.length;\r\n\r\n                            if (count > 0) {\r\n                                let key = (this.isEmployee ? 'contact' : 'externalContact') + 'Id';\r\n\r\n                                if (items.indexOf(key) > -1) {\r\n                                    id = data[key];\r\n                                }\r\n                            }\r\n                        }\r\n                    }\r\n                });\r\n\r\n        return id;\r\n    }\r\n    get userInfo() {\r\n        this.user = this.userInfoItem.asObservable();\r\n\r\n        return this.user;\r\n    }\r\n    userData() {\r\n        let last: string = '';\r\n        let first: string = '';\r\n        let position: string = '';\r\n        let info: SecurityInfo = null;\r\n\r\n        this.userInfo\r\n            .subscribe((i: SecurityInfo) => {\r\n                info = i;\r\n                last = i.lastName;\r\n                first = i.firstName;\r\n                position = i.position;\r\n            });\r\n\r\n        return {\r\n            info: info,\r\n            last: last,\r\n            first: first,\r\n            name: first + ' ' + last,\r\n            position: position\r\n        };\r\n    }\r\n    async userType() {\r\n        let data = await this.http.get(this.getURL(this.keyUserType),\r\n            {\r\n                responseType: 'text'\r\n            });\r\n\r\n        return data;\r\n    }\r\n    setUserInfo(val) {\r\n        this.userInfoItem.next(val);\r\n    }\r\n    //url\r\n    getURL(value: string): string {\r\n        return this.appUrl + this.apiUrl + value + '/';\r\n    }\r\n    //do\r\n    login(search: LoginModel): SecurityInfo {\r\n        this.searchParam.username = search.username;\r\n        this.searchParam.password = search.password;\r\n\r\n        this.authenticate(this.searchParam).subscribe((data: SecurityInfo) => {\r\n            this.searchResult = data;\r\n            if (data != null) {\r\n                this.isValid = this.searchResult.valid;\r\n            }\r\n            if (this.isValid) {\r\n                localStorage.setItem(this.keyCurrentUser, JSON.stringify(this.searchResult));\r\n                this.loggedInItem.next(true);\r\n                this.userInfoItem.next(this.searchResult);\r\n            }\r\n        },\r\n            error => console.error(error));\r\n\r\n        return this.searchResult;\r\n    }\r\n    logout(navigate: boolean = false) {\r\n        this.loggedInItem.next(false);\r\n        localStorage.removeItem(this.keyCurrentUser);\r\n        if (navigate) {\r\n            this.navigate();\r\n        }\r\n    }\r\n    audit(): boolean {\r\n        let ok: boolean;\r\n        let items = this.isLoggedIn;\r\n\r\n        items.subscribe((i: boolean) => {\r\n            ok = i;\r\n        });\r\n\r\n        let bad: boolean = !ok;\r\n\r\n        if (bad) {\r\n            this.logout(bad);\r\n        }\r\n\r\n        return ok;\r\n    }\r\n    history(): void {\r\n        let url = window.history.state.prevPage ?? null;\r\n\r\n        if (!url) {\r\n            //console.log('page was refreshed!');\r\n            this.logout(true)\r\n        }\r\n    }\r\n    navigate() {\r\n        this.router.navigate(this.keyNavigateItems);\r\n    }\r\n\r\n}\r\n","import { Injectable, OnInit } from '@angular/core';\r\n\r\nconst themeA = require('../../shared/style/theme/theme-a.scss');\r\nconst themeB = require('../../shared/style/theme/theme-b.scss');\r\nconst themeC = require('../../shared/style/theme/theme-c.scss');\r\nconst themeD = require('../../shared/style/theme/theme-d.scss');\r\nconst themeE = require('../../shared/style/theme/theme-e.scss');\r\nconst themeF = require('../../shared/style/theme/theme-f.scss');\r\nconst themeG = require('../../shared/style/theme/theme-g.scss');\r\nconst themeH = require('../../shared/style/theme/theme-h.scss');\r\n\r\n@Injectable()\r\n\r\nexport class ThemeService implements OnInit {\r\n\r\n    style: any;\r\n    default: string = 'E';\r\n\r\n    constructor() {\r\n        this.create();\r\n        this.theme = this.defaultTheme;\r\n    }\r\n\r\n    ngOnInit() {\r\n    }\r\n\r\n    private create() {\r\n        const head = document.head || document.getElementsByTagName('head')[0];\r\n\r\n        this.style = document.createElement('style');\r\n        this.style.type = 'text/css';\r\n        this.style.id = 'appthemes';\r\n        head.appendChild(this.style);\r\n    }\r\n\r\n    set theme(name) {\r\n        let v;\r\n\r\n        switch (name) {\r\n            case 'A':\r\n                v = themeA;\r\n                break;\r\n            case 'B':\r\n                v = themeB;\r\n                break;\r\n            case 'C':\r\n                v = themeC;\r\n                break;\r\n            case 'D':\r\n                v = themeD;\r\n                break;\r\n            case 'F':\r\n                v = themeF;\r\n                break;\r\n            case 'G':\r\n                v = themeG;\r\n                break;\r\n            case 'H':\r\n                v = themeH;\r\n                break;\r\n            case 'E':\r\n            default:\r\n                v = themeE;\r\n                break;\r\n        }\r\n        this.defaultStyle = v;\r\n    }\r\n    // since v9, content is available in 'default'\r\n    set defaultStyle(css) {\r\n        this.style.innerHTML = css.default;\r\n    }\r\n    get defaultTheme() {\r\n        return this.default;\r\n    }\r\n\r\n}\r\n","import { Component, OnInit, Injector, OnDestroy } from '@angular/core';\r\nimport { Router } from '@angular/router';\r\n\r\nimport { MenuService } from '../../core/menu/menu.service';\r\nimport { SettingsService } from '../../core/settings/settings.service';\r\n\r\nimport { menu } from '../../routes/menu';\r\n\r\ndeclare var $: any;\r\n\r\n@Component({\r\n    selector: 'app-sidebar',\r\n    templateUrl: './sidebar.component.html',\r\n    styleUrls: ['./sidebar.component.scss']\r\n})\r\n\r\nexport class SidebarComponent implements OnInit, OnDestroy {\r\n\r\n    menuItems: Array<any>;\r\n    router: Router;\r\n    sbclickEvent = 'click.sidebar-toggle';\r\n    $doc: any = null;\r\n\r\n    constructor(\r\n        public menuService: MenuService,\r\n        public settings: SettingsService,\r\n        public injector: Injector) {\r\n        this.menuService.add(menu);\r\n        this.menuItems = menuService.items;\r\n    }\r\n\r\n    ngOnInit() {\r\n        this.router = this.injector.get(Router);\r\n        this.router.events.subscribe((val) => {\r\n            // close any submenu opened when route changes\r\n            this.removeFloatingNav();\r\n            // scroll view to top\r\n            window.scrollTo(0, 0);\r\n            // close sidebar on route change\r\n            this.settings.setLayoutSetting('asideToggled', false);\r\n        });\r\n        // enable sidebar autoclose from extenal clicks\r\n        this.anyClickClose();\r\n    }\r\n    ngOnDestroy() {\r\n        if (this.$doc) {\r\n            this.$doc.off(this.sbclickEvent);\r\n        }\r\n    }\r\n\r\n    anyClickClose() {\r\n        this.$doc = $(document).on(this.sbclickEvent, (e) => {\r\n            if (!$(e.target).parents('.aside-container').length) {\r\n                this.settings.setLayoutSetting('asideToggled', false);\r\n            }\r\n        });\r\n    }\r\n    closeMenu(elem) {\r\n        elem.css('height', elem[0].scrollHeight); // set height\r\n        elem.css('height', 0); // and move to zero to collapse\r\n        elem.removeClass('opening');\r\n    }\r\n    isSidebarCollapsed() {\r\n        return this.settings.getLayoutSetting('isCollapsed');\r\n    }\r\n    isSidebarCollapsedText() {\r\n        return this.settings.getLayoutSetting('isCollapsedText');\r\n    }\r\n    isEnabledHover() {\r\n        return this.settings.getLayoutSetting('asideHover');\r\n    }\r\n    listenForExternalClicks() {\r\n        let $doc = $(document).on('click.sidebar', (e) => {\r\n            if (!$(e.target).parents('.aside-container').length) {\r\n                this.removeFloatingNav();\r\n                $doc.off('click.sidebar');\r\n            }\r\n        });\r\n    }\r\n    removeFloatingNav() {\r\n        $('.nav-floating').remove();\r\n    }\r\n    toggleSubmenuClick(event) {\r\n        event.preventDefault();\r\n        if (!this.isSidebarCollapsed() && !this.isSidebarCollapsedText() && !this.isEnabledHover()) {\r\n            let ul = $(event.currentTarget.nextElementSibling);\r\n            // hide other submenus\r\n            let parentNav = ul.parents('.sidebar-subnav');\r\n            $('.sidebar-subnav').each((idx, el) => {\r\n                let $el = $(el);\r\n                // if element is not a parent or self ul\r\n                if (el !== parentNav[0] && el !== ul[0]) {\r\n                    this.closeMenu($el);\r\n                }\r\n            });\r\n\r\n            // abort if not UL to process\r\n            if (!ul.length) {\r\n                return;\r\n            }\r\n\r\n            // any child menu should start closed\r\n            ul.find('.sidebar-subnav').each((idx, el) => {\r\n                this.closeMenu($(el));\r\n            });\r\n\r\n            // toggle UL height\r\n            const ulHeight = ul.css('height')\r\n\r\n            if (ulHeight === 'auto' || parseInt(ulHeight, 10)) {\r\n                this.closeMenu(ul);\r\n            }\r\n            else {\r\n                // expand menu\r\n                ul.on('transitionend', () => {\r\n                    ul.css('height', 'auto').off('transitionend');\r\n                }).css('height', ul[0].scrollHeight);\r\n                // add class to manage animation\r\n                ul.addClass('opening');\r\n            }\r\n        }\r\n    }\r\n    toggleSubmenuHover(event) {\r\n        let self = this;\r\n\r\n        if (this.isSidebarCollapsed() || this.isSidebarCollapsedText() || this.isEnabledHover()) {\r\n            event.preventDefault();\r\n\r\n            this.removeFloatingNav();\r\n\r\n            let ul = $(event.currentTarget.nextElementSibling);\r\n            let anchor = $(event.currentTarget);\r\n\r\n            if (!ul.length) {\r\n                return; // if not submenu return\r\n            }\r\n\r\n            let $aside = $('.aside-container');\r\n            let $asideInner = $aside.children('.aside-inner'); // for top offset calculation\r\n            let $sidebar = $asideInner.children('.sidebar');\r\n            let mar = parseInt($asideInner.css('padding-top'), 0) + parseInt($aside.css('padding-top'), 0);\r\n            let itemTop = ((anchor.parent().position().top) + mar) - $sidebar.scrollTop();\r\n            let floatingNav = ul.clone().appendTo($aside);\r\n            let vwHeight = document.body.clientHeight;\r\n\r\n            floatingNav\r\n                .addClass('nav-floating')\r\n\r\n            // each item has ~40px height\r\n            // multiply to force space for at least N items\r\n            var safeOffsetValue = (40 * 5)\r\n            var navHeight = floatingNav.outerHeight(true) + 2; // 2px border\r\n            var safeOffset = navHeight < safeOffsetValue ? navHeight : safeOffsetValue;\r\n            var displacement = 25; // displacement in px from bottom\r\n            // if not enough space to show N items, use then calculated 'safeOffset'\r\n            var menuTop = (vwHeight - itemTop > safeOffset) ? itemTop : (vwHeight - safeOffset - displacement);\r\n\r\n            floatingNav\r\n                .removeClass('opening') // necesary for demo if switched between normal//collapsed mode\r\n                .css({\r\n                    position: this.settings.getLayoutSetting('isFixed') ? 'fixed' : 'absolute',\r\n                    top: menuTop,\r\n                    bottom: (floatingNav.outerHeight(true) + menuTop > vwHeight) ? (displacement + 'px') : 'auto'\r\n                });\r\n            floatingNav\r\n                .on('mouseleave', () => { floatingNav.remove(); })\r\n                .find('a').on('click', function (e) {\r\n                    e.preventDefault(); // prevents page reload on click\r\n                    // get the exact route path to navigate\r\n                    let routeTo = $(this).attr('route');\r\n                    if (routeTo) self.router.navigate([routeTo]);\r\n                });\r\n\r\n            this.listenForExternalClicks();\r\n        }\r\n    }\r\n\r\n}\r\n","<!-- START Sidebar (left)-->\r\n<div class=\"aside-inner\">\r\n    <nav class=\"sidebar\" sidebar-anyclick-close=\"\" [class.show-scrollbar]=\"settings.getLayoutSetting('asideScrollbar')\">\r\n        <!-- START sidebar nav-->\r\n        <ul class=\"sidebar-nav\">\r\n            <!-- START user info-->\r\n            <li class=\"has-user-block\">\r\n                <app-userblock></app-userblock>\r\n            </li>\r\n            <!-- END user info-->\r\n            <li *ngFor='let item of menuItems' [ngClass]=\"{'nav-heading': item.heading}\" [routerLinkActive]=\"['active']\">\r\n                <!-- menu heading -->\r\n                <span *ngIf=\"item.heading\">{{(item.translate | translate) || item.text}}</span>\r\n                <!-- external links -->\r\n                <a href *ngIf=\"!item.heading && !item.submenu && item.elink\" [attr.target]=\"item.target\" [attr.href]=\"item.elink\" title=\"{{item.text}}\">\r\n                    <span class=\"float-right\" *ngIf=\"item.alert\" [ngClass]=\"item.label || 'badge badge-success'\">{{item.alert}}</span>\r\n                    <em class=\"{{item.icon}}\" *ngIf=\"item.icon\"></em>\r\n                    <span>{{(item.translate | translate) || item.text}}</span>\r\n                </a>\r\n                <!-- single menu item -->\r\n                <a href *ngIf=\"!item.heading && !item.submenu && !item.elink\" [routerLink]=\"item.link\" [attr.route]=\"item.link\" title=\"{{item.text}}\"\r\n                   (click)=\"toggleSubmenuClick($event)\" (mouseenter)=\"toggleSubmenuHover($event)\">\r\n                    <span class=\"float-right\" *ngIf=\"item.alert\" [ngClass]=\"item.label || 'badge badge-success'\">{{item.alert}}</span>\r\n                    <em class=\"{{item.icon}}\" *ngIf=\"item.icon\"></em>\r\n                    <span>{{(item.translate | translate) || item.text}}</span>\r\n                </a>\r\n            </li>\r\n        </ul>\r\n        <!-- END sidebar nav-->\r\n        <div style=\"width: 100%;\">\r\n            <span style=\"font-size: smaller; color: gray; opacity: 0.6; text-align: center; display: block; max-width: 100%;\">\r\n                {{ settings.getAppSetting('version') }}\r\n            </span>\r\n        </div>\r\n    </nav>\r\n</div>\r\n<!-- END Sidebar (left)-->\r\n","import { Injectable, OnInit } from '@angular/core';\r\nimport { HttpClient } from '@angular/common/http';\r\n\r\nimport { lowerCase } from 'lodash';\r\n\r\n@Injectable()\r\n\r\nexport class SettingsService implements OnInit {\r\n\r\n    private app: any;\r\n    private layout: any;\r\n\r\n    constructor(private http: HttpClient) {\r\n        this.app = {\r\n            name: 'AGAT Laboratories Ltd.',\r\n            year: ((new Date()).getFullYear()),\r\n            copyright: 'Copyright', //�\r\n            description: 'All Rights Reserved.',\r\n            version: 'stg[20230501]'\r\n        };\r\n        this.layout = {\r\n            isFixed: true,\r\n            isCollapsed: false,\r\n            isBoxed: false,\r\n            isRTL: false,\r\n            horizontal: false,\r\n            isFloat: false,\r\n            asideHover: false,\r\n            theme: null,\r\n            asideScrollbar: false,\r\n            isCollapsedText: false,\r\n            useFullLayout: false,\r\n            hiddenFooter: false,\r\n            offsidebarOpen: false,\r\n            asideToggled: false,\r\n            viewAnimation: 'ng-fadeInUp'\r\n        };\r\n    }\r\n\r\n    ngOnInit() {\r\n    }\r\n    //app\r\n    getAppSetting(name) {\r\n        return name ? this.app[name] : this.app;\r\n    }\r\n    setAppSetting(name, value) {\r\n        if (typeof this.app[name] !== 'undefined') {\r\n            this.app[name] = value;\r\n        }\r\n    }\r\n    //layout\r\n    getLayoutSetting(name) {\r\n        return name ? this.layout[name] : this.layout;\r\n    }\r\n    setLayoutSetting(name, value) {\r\n        if (typeof this.layout[name] !== 'undefined') {\r\n            return this.layout[name] = value;\r\n        }\r\n    }\r\n    toggleLayoutSetting(name) {\r\n        return this.setLayoutSetting(name, !this.getLayoutSetting(name));\r\n    }\r\n\r\n}\r\n","export default \"/* ========================================================================\\n   Component: layout\\n ========================================================================== */\\nbody, .wrapper .section-container {\\n  background-color: #f5f7fa;\\n}\\n.wrapper .aside-container {\\n  background-color: #fff;\\n}\\n/* ========================================================================\\n   Component: top-navbar\\n ========================================================================== */\\n.topnavbar {\\n  background-color: #f05050;\\n  background-image: linear-gradient(to right, #f05050 0%, #f47f7f 100%);\\n  background-repeat: repeat-x;\\n}\\n@media (min-width: 992px) {\\n  .topnavbar .navbar-nav > .nav-item.show > .nav-link, .topnavbar .navbar-nav > .nav-item.show > .nav-link:hover, .topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n    box-shadow: 0 -3px 0 #ee3434 inset;\\n  }\\n}\\n.topnavbar .navbar-nav > .nav-item > .navbar-text {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link:hover, .topnavbar .navbar-nav > .nav-item > .nav-link:focus,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:hover,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n  color: #c91111;\\n}\\n.topnavbar .dropdown-item.active, .topnavbar .dropdown-item:active {\\n  background-color: #f05050;\\n}\\n/* ========================================================================\\n   Component: sidebar\\n ========================================================================== */\\n.sidebar {\\n  background-color: #fff;\\n}\\n.sidebar .nav-heading {\\n  color: #919DA8;\\n}\\n.sidebar-nav > li > a, .sidebar-nav > li > .nav-item {\\n  color: #515253;\\n}\\n.sidebar-nav > li > a:focus, .sidebar-nav > li > a:hover, .sidebar-nav > li > .nav-item:focus, .sidebar-nav > li > .nav-item:hover {\\n  color: #f05050;\\n}\\n.sidebar-nav > li > a > em, .sidebar-nav > li > .nav-item > em {\\n  color: inherits;\\n}\\n.sidebar-nav > li.active, .sidebar-nav > li.active > a, .sidebar-nav > li.active > .nav-item, .sidebar-nav > li.active .sidebar-nav, .sidebar-nav > li.open, .sidebar-nav > li.open > a, .sidebar-nav > li.open > .nav-item, .sidebar-nav > li.open .sidebar-nav {\\n  background-color: #fcfcfc;\\n  color: #f05050;\\n}\\n.sidebar-nav > li.active > .nav-item > em, .sidebar-nav > li.active > a > em, .sidebar-nav > li.open > .nav-item > em, .sidebar-nav > li.open > a > em {\\n  color: #f05050;\\n}\\n.sidebar-nav > li.active {\\n  border-left-color: #f05050;\\n}\\n.sidebar-subnav {\\n  background-color: #fff;\\n}\\n.sidebar-subnav > .sidebar-subnav-header {\\n  color: #515253;\\n}\\n.sidebar-subnav > li > a, .sidebar-subnav > li > .nav-item {\\n  color: #515253;\\n}\\n.sidebar-subnav > li > a:focus, .sidebar-subnav > li > a:hover, .sidebar-subnav > li > .nav-item:focus, .sidebar-subnav > li > .nav-item:hover {\\n  color: #f05050;\\n}\\n.sidebar-subnav > li.active > a, .sidebar-subnav > li.active > .nav-item {\\n  color: #f05050;\\n}\\n.sidebar-subnav > li.active > a:after, .sidebar-subnav > li.active > .nav-item:after {\\n  border-color: #f05050;\\n  background-color: #f05050;\\n}\\n/* ========================================================================\\n   Component: offsidebar\\n ========================================================================== */\\n.offsidebar {\\n  border-left: 1px solid greyscale(#cccccc);\\n  background-color: #fff;\\n  color: #656565;\\n}\\n/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/app/shared/style/theme/theme-d.scss","src/app/shared/style/app/variables.scss","src/app/shared/style/bootstrap/mixins/_gradients.scss","src/app/shared/style/bootstrap/mixins/_breakpoints.scss"],"names":[],"mappings":"AA8CA;;6EAAA;AAGA;EACI,yBAzC4B;AAJhC;AAgDA;EACI,sBA5C4B;AADhC;AAgDA;;6EAAA;AAGA;EACI,yBCzCoB;ECNtB,qEAAA;EACA,2BAAA;AFGF;AG0CI;EHMQ;IACI,kCAAA;EA7Cd;AACF;AAiDI;EACI,WAtDwB;AAOhC;AAkDI;;EAEI,WA3DwB;AAWhC;AAiDQ;;;EACI,cA5DoB;AAehC;AAiDI;EACI,yBCjEgB;ADkBxB;AAmDA;;6EAAA;AAGA;EACI,sBAnF4B;AAmChC;AAkDI;EACI,cA5D0B;AAYlC;AAuDQ;EACI,cA9EsB;AA0BlC;AAsDY;EACI,cCvFQ;ADmCxB;AAwDY;EACI,eAlFkB;AA4BlC;AA6DY;EACI,yBA5FkB;EA6FlB,cCrGQ;AD0CxB;AA8DY;EACI,cCzGQ;AD6CxB;AAiEQ;EACI,0BC/GY;ADgDxB;AAsEA;EACI,sBAjI4B;AA8DhC;AAqEI;EACI,cApH0B;AAiDlC;AAuEQ;EACI,cAzHsB;AAoDlC;AAuEY;EACI,cClIQ;AD6DxB;AA2EY;EACI,cCzIQ;ADgExB;AA2EgB;EACI,qBC5II;ED6IJ,yBC7II;ADoExB;AAoFA;;6EAAA;AAGA;EACI,yCAAA;EACA,sBAxIsB;EAyItB,cCrCwB;AD5C5B","file":"src/app/shared/style/theme/theme-d.scss","sourcesContent":["// Bootstrap\r\n@import \"../bootstrap/functions\";\r\n@import \"../bootstrap/variables\";\r\n@import \"../bootstrap/mixins\";\r\n@import '../app/variables';\r\n\r\n\r\n// LAYOUT\r\n\r\n$content-bg:                    #f5f7fa;\r\n$aside-bg:                      #fff;\r\n\r\n// NAVBAR TOP\r\n\r\n$nav-top-bg:                    $danger;\r\n$nav-top-bg-start:              $nav-top-bg;\r\n$nav-top-bg-end:                $danger-light;\r\n$nav-header-bg:                 transparent;\r\n\r\n$nav-top-item:                  #fff;\r\n$nav-top-item-active:           darken($nav-top-bg, 20%);\r\n\r\n// SIDEBAR\r\n\r\n$sidebar-bg:                      $aside-bg;\r\n\r\n$sidebar-item-color:              #515253;\r\n$sidebar-item-color-active:       $nav-top-bg;\r\n$sidebar-item-bg-active:          darken($sidebar-bg, 1%);\r\n\r\n$sidebar-icon-color:              inherits;\r\n$sidebar-icon-color-active:       $nav-top-bg;\r\n\r\n$sidebar-bullet-color:            rgba(0,0,0,.25);\r\n$sidebar-bullet-color-active:     $sidebar-icon-color-active;\r\n\r\n$sidebar-heading-color:           #919DA8;\r\n$sidebar-label-color:             $sidebar-item-color;\r\n\r\n// OFFSIDEBAR\r\n\r\n$offsidebar-bg:           #fff;\r\n$offsidebar-border-color: greyscale(darken($offsidebar-bg, 20%));\r\n$offsidebar-color:        $body-color;\r\n\r\n\r\n/* ========================================================================\r\n   Component: layout\r\n ========================================================================== */\r\nbody, .wrapper .section-container {\r\n    background-color: $content-bg;\r\n}\r\n\r\n.wrapper .aside-container {\r\n    background-color: $aside-bg;\r\n}\r\n\r\n/* ========================================================================\r\n   Component: top-navbar\r\n ========================================================================== */\r\n.topnavbar {\r\n    background-color: $nav-top-bg;\r\n    @include gradient-x($nav-top-bg-start, $nav-top-bg-end);\r\n\r\n    @include media-breakpoint-up(lg) {\r\n        .navbar-nav > .nav-item.show > .nav-link {\r\n            &, &:hover, &:focus {\r\n                box-shadow: 0 -3px 0 darken($nav-top-bg, 6%) inset;\r\n            }\r\n        }\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .navbar-text {\r\n        color: $nav-top-item;\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .nav-link,\r\n    .navbar-nav > .nav-item.show > .nav-link {\r\n        color: $nav-top-item;\r\n        &:hover, &:focus {\r\n            color: $nav-top-item-active;\r\n        }\r\n    }\r\n\r\n    .dropdown-item.active, .dropdown-item:active {\r\n        background-color: $nav-top-bg;\r\n    }\r\n}\r\n\r\n/* ========================================================================\r\n   Component: sidebar\r\n ========================================================================== */\r\n.sidebar {\r\n    background-color: $sidebar-bg;\r\n\r\n    .nav-heading {\r\n        color: $sidebar-heading-color;\r\n    }\r\n}\r\n\r\n// Items\r\n.sidebar-nav {\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            // Item icon\r\n            > em {\r\n                color: $sidebar-icon-color;\r\n            }\r\n\r\n        }\r\n\r\n        // Active item state\r\n        &.active, &.open {\r\n            &, > a, > .nav-item, .sidebar-nav {\r\n                background-color: $sidebar-item-bg-active;\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            > .nav-item > em, > a > em {\r\n                color: $sidebar-icon-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            border-left-color: $sidebar-item-color-active;\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n.sidebar-subnav {\r\n    background-color: $sidebar-bg;\r\n\r\n    > .sidebar-subnav-header {\r\n        color: $sidebar-item-color;\r\n    }\r\n\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            > a, > .nav-item {\r\n                color: $sidebar-icon-color-active;\r\n\r\n                &:after {\r\n                    border-color: $sidebar-bullet-color-active;\r\n                    background-color: $sidebar-bullet-color-active;\r\n                }\r\n\r\n            }\r\n\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n/* ========================================================================\r\n   Component: offsidebar\r\n ========================================================================== */\r\n.offsidebar {\r\n    border-left: 1px solid $offsidebar-border-color;\r\n    background-color: $offsidebar-bg;\r\n    color: $offsidebar-color;\r\n}\r\n","\r\n// Cutoms Gray colors for theme\r\n$gray-darker:           #232735;\r\n$gray-dark:             #3a3f51;\r\n$gray:                  #dde6e9;\r\n$gray-light:            #e4eaec;\r\n$gray-lighter:          #edf1f2;\r\n\r\n// Custom brand colors for theme\r\n$inverse:               #131e26;\r\n$purple:                #7266ba;\r\n$pink:                  #f532e5;\r\n$yellow:                #fad732;\r\n$green:                 #37bc9b;\r\n\r\n$primary:               #5d9cec;\r\n$secondary:             #fff;\r\n$success:               #27c24c;\r\n$info:                  #23b7e5;\r\n$warning:               #ff902b;\r\n$danger:                #f05050;\r\n$dark:                  #3a3f51;\r\n\r\n// Custom color variants\r\n$amountOfLight: 10%;\r\n\r\n$primary-light:         lighten($primary, $amountOfLight);\r\n$success-light:         lighten($success, $amountOfLight);\r\n$info-light:            lighten($info, $amountOfLight);\r\n$warning-light:         lighten($warning, $amountOfLight);\r\n$danger-light:          lighten($danger, $amountOfLight);\r\n$inverse-light:         lighten($inverse, $amountOfLight);\r\n$green-light:           lighten($green, $amountOfLight);\r\n$pink-light:            lighten($pink, $amountOfLight);\r\n$purple-light:          lighten($purple, $amountOfLight);\r\n$yellow-light:          lighten($yellow, $amountOfLight);\r\n$primary-dark:          darken($primary, $amountOfLight);\r\n$success-dark:          darken($success, $amountOfLight);\r\n$info-dark:             darken($info, $amountOfLight);\r\n$warning-dark:          darken($warning, $amountOfLight);\r\n$danger-dark:           darken($danger, $amountOfLight);\r\n$inverse-dark:          darken($inverse, $amountOfLight);\r\n$green-dark:            darken($green, $amountOfLight);\r\n$pink-dark:             darken($pink, $amountOfLight);\r\n$purple-dark:           darken($purple, $amountOfLight);\r\n$yellow-dark:           darken($yellow, $amountOfLight);\r\n\r\n// Theme variables\r\n\r\n// used for sidebars and content spacing\r\n$navbar-height:                    55px;\r\n\r\n// Button secondary redefinition style for theme\r\n$btn-secondary-color:              #333;\r\n$btn-secondary-bg:                 #fff;\r\n$btn-secondary-border:             #eaeaea;\r\n\r\n// Top Border color for custom default cards (.card-default)\r\n$card-default-border-color:        #cfdbe2;\r\n\r\n\r\n// ---------------------\r\n// Utilities variables\r\n// ---------------------\r\n\r\n$text-alpha:            rgba(255,255,255,.5);\r\n$text-alpha-inverse:    rgba(0,0,0,.5);\r\n\r\n$font-size-base:        1rem;\r\n$text-sm:               $font-size-base * 0.74375;\r\n$text-md:               $font-size-base * 1.6625;\r\n$text-lg:               $font-size-base * 2.625;\r\n\r\n$border-color:          rgba(0,0,0,.12);\r\n\r\n$wd-xxs:                60px;\r\n$wd-xs:                 90px;\r\n$wd-sm:                 150px;\r\n$wd-sd:                 200px; // sd == standard\r\n$wd-md:                 240px;\r\n$wd-lg:                 280px;\r\n$wd-xl:                 320px;\r\n$wd-xxl:                360px;\r\n$wd-wide:               100%;\r\n$wd-auto:               auto;\r\n$wd-zero:               0;\r\n\r\n\r\n// ---------------------\r\n// Bootstrap 4 Variables Override\r\n// ---------------------\r\n\r\n// Color system\r\n\r\n$colors: (\r\n    \"purple\":     $purple,\r\n    \"pink\":       $pink,\r\n    \"yellow\":     $yellow,\r\n    \"green\":      $green,\r\n    \"primary\":    $primary,\r\n    \"success\":    $success,\r\n    \"info\":       $info,\r\n    \"warning\":    $warning,\r\n    \"danger\":     $danger,\r\n    'inverse':    $inverse,\r\n\r\n    'primary-light': $primary-light,\r\n    'primary-dark':  $primary-dark,\r\n    'success-light': $success-light,\r\n    'success-dark':  $success-dark,\r\n    'info-light':    $info-light,\r\n    'info-dark':     $info-dark,\r\n    'warning-light': $warning-light,\r\n    'warning-dark':  $warning-dark,\r\n    'danger-light':  $danger-light,\r\n    'danger-dark':   $danger-dark,\r\n    'green-light':   $green-light,\r\n    'green-dark':    $green-dark,\r\n    'pink-light':    $pink-light,\r\n    'pink-dark':     $pink-dark,\r\n    'purple-light':  $purple-light,\r\n    'purple-dark':   $purple-dark,\r\n    'inverse-light': $inverse-light,\r\n    'inverse-dark':  $inverse-dark,\r\n    'yellow-light':  $yellow-light,\r\n    'yellow-dark':   $yellow-dark,\r\n);\r\n\r\n\r\n$theme-colors: (\r\n  \"primary\":    $primary,\r\n  \"secondary\":  $secondary,\r\n  \"success\":    $success,\r\n  \"info\":       $info,\r\n  \"warning\":    $warning,\r\n  \"danger\":     $danger\r\n);\r\n\r\n// Body\r\n\r\n$body-bg:                   #f5f7fa;\r\n$body-color:                #656565;\r\n\r\n$border-radius:               .25rem;\r\n$border-radius-lg:            .375rem;\r\n\r\n$line-height-base:            1.528571429;\r\n\r\n$headings-line-height:        1.1;\r\n\r\n$text-muted:                  #909FA7;\r\n\r\n// Tables\r\n\r\n$table-accent-bg:             #fafbfc;\r\n$table-hover-bg:              #fafbfc;\r\n\r\n$table-border-color:          #eee;\r\n\r\n// Buttons + Forms\r\n\r\n$input-btn-padding-y:         .375rem;\r\n$input-btn-padding-x:         1rem;\r\n\r\n$input-btn-padding-y-sm:      .3125rem;\r\n$input-btn-padding-x-sm:      .625rem;\r\n\r\n$input-btn-padding-y-lg:      .625rem;\r\n$input-btn-padding-x-lg:      1.25rem;\r\n\r\n$input-height:                2.1875rem; // 35px\r\n\r\n// Forms\r\n\r\n$input-disabled-bg:                     $gray-lighter;\r\n$input-border-color:                    $gray;\r\n$input-focus-border-color:              #66afe9;\r\n$input-placeholder-color:               #b7bac9;\r\n\r\n$form-feedback-icon-valid:              none;\r\n$form-feedback-icon-invalid:            none;\r\n\r\n$custom-control-indicator-active-bg:    lighten($primary, 25%);\r\n\r\n// Dropdowns\r\n\r\n$dropdown-border-color:             #e1e1e1;\r\n\r\n// Navs\r\n\r\n$nav-tabs-link-active-bg:           #fff;\r\n\r\n// Jumbotron\r\n\r\n$jumbotron-bg:                      #fcfcfc;\r\n\r\n// List group\r\n\r\n$list-group-border-color:           #e4eaec;\r\n\r\n// Image thumbnails\r\n\r\n$thumbnail-padding:                 .125rem;\r\n\r\n\r\n// Breadcrumbs\r\n\r\n$breadcrumb-bg:                     #fafafa;\r\n$breadcrumb-divider-color:          #c1c2c3;\r\n$breadcrumb-active-color:           $body-color;\r\n","// Gradients\r\n\r\n@mixin gradient-bg($color) {\r\n  @if $enable-gradients {\r\n    background: $color linear-gradient(180deg, mix($body-bg, $color, 15%), $color) repeat-x;\r\n  } @else {\r\n    background-color: $color;\r\n  }\r\n}\r\n\r\n// Horizontal gradient, from left to right\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-x($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to right, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n// Vertical gradient, from top to bottom\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-y($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to bottom, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n@mixin gradient-directional($start-color: $gray-700, $end-color: $gray-800, $deg: 45deg) {\r\n  background-image: linear-gradient($deg, $start-color, $end-color);\r\n  background-repeat: repeat-x;\r\n}\r\n@mixin gradient-x-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient(to right, $start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-y-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient($start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-radial($inner-color: $gray-700, $outer-color: $gray-800) {\r\n  background-image: radial-gradient(circle, $inner-color, $outer-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-striped($color: rgba($white, .15), $angle: 45deg) {\r\n  background-image: linear-gradient($angle, $color 25%, transparent 25%, transparent 50%, $color 50%, $color 75%, transparent 75%, transparent);\r\n}\r\n","// Breakpoint viewport sizes and media queries.\r\n//\r\n// Breakpoints are defined as a map of (name: minimum width), order from small to large:\r\n//\r\n//    (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px)\r\n//\r\n// The map defined in the `$grid-breakpoints` global variable is used as the `$breakpoints` argument by default.\r\n\r\n// Name of the next breakpoint, or null for the last breakpoint.\r\n//\r\n//    >> breakpoint-next(sm)\r\n//    md\r\n//    >> breakpoint-next(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    md\r\n//    >> breakpoint-next(sm, $breakpoint-names: (xs sm md lg xl))\r\n//    md\r\n@function breakpoint-next($name, $breakpoints: $grid-breakpoints, $breakpoint-names: map-keys($breakpoints)) {\r\n  $n: index($breakpoint-names, $name);\r\n  @return if($n != null and $n < length($breakpoint-names), nth($breakpoint-names, $n + 1), null);\r\n}\r\n\r\n// Minimum breakpoint width. Null for the smallest (first) breakpoint.\r\n//\r\n//    >> breakpoint-min(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    576px\r\n@function breakpoint-min($name, $breakpoints: $grid-breakpoints) {\r\n  $min: map-get($breakpoints, $name);\r\n  @return if($min != 0, $min, null);\r\n}\r\n\r\n// Maximum breakpoint width. Null for the largest (last) breakpoint.\r\n// The maximum value is calculated as the minimum of the next one less 0.02px\r\n// to work around the limitations of `min-` and `max-` prefixes and viewports with fractional widths.\r\n// See https://www.w3.org/TR/mediaqueries-4/#mq-min-max\r\n// Uses 0.02px rather than 0.01px to work around a current rounding bug in Safari.\r\n// See https://bugs.webkit.org/show_bug.cgi?id=178261\r\n//\r\n//    >> breakpoint-max(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    767.98px\r\n@function breakpoint-max($name, $breakpoints: $grid-breakpoints) {\r\n  $next: breakpoint-next($name, $breakpoints);\r\n  @return if($next, breakpoint-min($next, $breakpoints) - .02, null);\r\n}\r\n\r\n// Returns a blank string if smallest breakpoint, otherwise returns the name with a dash in front.\r\n// Useful for making responsive utilities.\r\n//\r\n//    >> breakpoint-infix(xs, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"\"  (Returns a blank string)\r\n//    >> breakpoint-infix(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"-sm\"\r\n@function breakpoint-infix($name, $breakpoints: $grid-breakpoints) {\r\n  @return if(breakpoint-min($name, $breakpoints) == null, \"\", \"-#{$name}\");\r\n}\r\n\r\n// Media of at least the minimum breakpoint width. No query for the smallest breakpoint.\r\n// Makes the @content apply to the given breakpoint and wider.\r\n@mixin media-breakpoint-up($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  @if $min {\r\n    @media (min-width: $min) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media of at most the maximum breakpoint width. No query for the largest breakpoint.\r\n// Makes the @content apply to the given breakpoint and narrower.\r\n@mixin media-breakpoint-down($name, $breakpoints: $grid-breakpoints) {\r\n  $max: breakpoint-max($name, $breakpoints);\r\n  @if $max {\r\n    @media (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media that spans multiple breakpoint widths.\r\n// Makes the @content apply between the min and max breakpoints\r\n@mixin media-breakpoint-between($lower, $upper, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($lower, $breakpoints);\r\n  $max: breakpoint-max($upper, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($lower, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($upper, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n\r\n// Media between the breakpoint's minimum and maximum widths.\r\n// No minimum for the smallest breakpoint, and no maximum for the largest one.\r\n// Makes the @content apply only to the given breakpoint, not viewports any wider or narrower.\r\n@mixin media-breakpoint-only($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  $max: breakpoint-max($name, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n"]} */\";","import { NgModule, ModuleWithProviders } from '@angular/core';\r\nimport { CommonModule } from '@angular/common';\r\nimport { FormsModule, ReactiveFormsModule } from '@angular/forms';\r\nimport { RouterModule } from '@angular/router';\r\nimport { TranslateModule } from '@ngx-translate/core';\r\nimport { ToastrModule } from 'ngx-toastr';\r\n\r\nimport { AccordionModule } from 'ngx-bootstrap/accordion';\r\nimport { AlertModule } from 'ngx-bootstrap/alert';\r\nimport { ButtonsModule } from 'ngx-bootstrap/buttons';\r\nimport { CarouselModule } from 'ngx-bootstrap/carousel';\r\nimport { CollapseModule } from 'ngx-bootstrap/collapse';\r\nimport { BsDropdownModule } from 'ngx-bootstrap/dropdown';\r\nimport { ModalModule } from 'ngx-bootstrap/modal';\r\nimport { PaginationModule } from 'ngx-bootstrap/pagination';\r\nimport { ProgressbarModule } from 'ngx-bootstrap/progressbar';\r\nimport { RatingModule } from 'ngx-bootstrap/rating';\r\nimport { TabsModule } from 'ngx-bootstrap/tabs';\r\nimport { TimepickerModule } from 'ngx-bootstrap/timepicker';\r\nimport { TooltipModule } from 'ngx-bootstrap/tooltip';\r\nimport { PopoverModule } from 'ngx-bootstrap/popover';\r\nimport { TypeaheadModule } from 'ngx-bootstrap/typeahead';\r\nimport { DatepickerModule } from 'ngx-bootstrap/datepicker';\r\nimport { BsDatepickerModule } from 'ngx-bootstrap/datepicker';\r\nimport { HideIfUnauthorizedDirective } from '../core/directive/hideIfUnauthorized.directive';\r\n\r\nimport { ColorService } from './color/color.service';\r\nimport { CheckallDirective } from './directive/checkall/checkall.directive';\r\nimport { NowDirective } from './directive/now/now.directive';\r\nimport { ScrollableDirective } from './directive/scrollable/scrollable.directive';\r\nimport { JqcloudDirective } from './directive/jqcloud/jqcloud.directive';\r\n\r\nimport { WaitingSpinnerComponent } from './waitingSpinner/waitingSpinner.component';\r\n\r\n// https://angular.io/styleguide#!#04-10\r\n@NgModule({\r\n    imports: [\r\n        CommonModule,\r\n        FormsModule,\r\n        ReactiveFormsModule,\r\n        TranslateModule,\r\n        AccordionModule.forRoot(),\r\n        AlertModule.forRoot(),\r\n        ButtonsModule.forRoot(),\r\n        CarouselModule.forRoot(),\r\n        CollapseModule.forRoot(),\r\n        DatepickerModule.forRoot(),\r\n        BsDatepickerModule.forRoot(),\r\n        BsDropdownModule.forRoot(),\r\n        ModalModule.forRoot(),\r\n        PaginationModule.forRoot(),\r\n        ProgressbarModule.forRoot(),\r\n        RatingModule.forRoot(),\r\n        TabsModule.forRoot(),\r\n        TimepickerModule.forRoot(),\r\n        TooltipModule.forRoot(),\r\n        PopoverModule.forRoot(),\r\n        TypeaheadModule.forRoot(),\r\n        ToastrModule.forRoot()\r\n    ],\r\n    providers: [ColorService],\r\n    declarations: [\r\n        CheckallDirective,\r\n        NowDirective,\r\n        ScrollableDirective,\r\n        JqcloudDirective,\r\n        WaitingSpinnerComponent,\r\n        HideIfUnauthorizedDirective,\r\n    ],\r\n    exports: [\r\n        CommonModule,\r\n        FormsModule,\r\n        ReactiveFormsModule,\r\n        TranslateModule,\r\n        RouterModule,\r\n        AccordionModule,\r\n        AlertModule,\r\n        ButtonsModule,\r\n        CarouselModule,\r\n        CollapseModule,\r\n        DatepickerModule,\r\n        BsDatepickerModule,\r\n        BsDropdownModule,\r\n        ModalModule,\r\n        PaginationModule,\r\n        ProgressbarModule,\r\n        RatingModule,\r\n        TabsModule,\r\n        TimepickerModule,\r\n        TooltipModule,\r\n        PopoverModule,\r\n        TypeaheadModule,\r\n        ToastrModule,\r\n        CheckallDirective,\r\n        NowDirective,\r\n        ScrollableDirective,\r\n        JqcloudDirective,\r\n        WaitingSpinnerComponent,\r\n        HideIfUnauthorizedDirective\r\n    ],\r\n})\r\n\r\n// https://github.com/ocombe/ng2-translate/issues/209\r\nexport class SharedModule {\r\n    static forRoot(): ModuleWithProviders<SharedModule> {\r\n        return {\r\n            ngModule: SharedModule,\r\n        };\r\n    }\r\n}\r\n","import { Directive, ElementRef, OnInit, HostListener, Input } from '@angular/core';\n\nimport { LoginService } from '../../core/service/login.service';\n\n@Directive({\n    selector: '[appHideIfUnauthorized]'\n})\nexport class HideIfUnauthorizedDirective /*implements OnInit*/ {\n\n    @Input('appHideIfUnauthorized') permission: string;\n\n    constructor(\n        private element: ElementRef,\n        private login: LoginService) {\n        // this.element.nativeElement.style.fontSize = \"x-large\";   \n    }\n\n    ngOnInit() {\n        if (!this.login.hasPermission(this.permission)) {\n            this.element.nativeElement.style.display = 'none';\n        }\n    }\n\n}\n","var map = {\n\t\"./af\": \"K/tc\",\n\t\"./af.js\": \"K/tc\",\n\t\"./ar\": \"jnO4\",\n\t\"./ar-dz\": \"o1bE\",\n\t\"./ar-dz.js\": \"o1bE\",\n\t\"./ar-kw\": \"Qj4J\",\n\t\"./ar-kw.js\": \"Qj4J\",\n\t\"./ar-ly\": \"HP3h\",\n\t\"./ar-ly.js\": \"HP3h\",\n\t\"./ar-ma\": \"CoRJ\",\n\t\"./ar-ma.js\": \"CoRJ\",\n\t\"./ar-sa\": \"gjCT\",\n\t\"./ar-sa.js\": \"gjCT\",\n\t\"./ar-tn\": \"bYM6\",\n\t\"./ar-tn.js\": \"bYM6\",\n\t\"./ar.js\": \"jnO4\",\n\t\"./az\": \"SFxW\",\n\t\"./az.js\": \"SFxW\",\n\t\"./be\": \"H8ED\",\n\t\"./be.js\": \"H8ED\",\n\t\"./bg\": \"hKrs\",\n\t\"./bg.js\": \"hKrs\",\n\t\"./bm\": \"p/rL\",\n\t\"./bm.js\": \"p/rL\",\n\t\"./bn\": \"kEOa\",\n\t\"./bn.js\": \"kEOa\",\n\t\"./bo\": \"0mo+\",\n\t\"./bo.js\": \"0mo+\",\n\t\"./br\": \"aIdf\",\n\t\"./br.js\": \"aIdf\",\n\t\"./bs\": \"JVSJ\",\n\t\"./bs.js\": \"JVSJ\",\n\t\"./ca\": \"1xZ4\",\n\t\"./ca.js\": \"1xZ4\",\n\t\"./cs\": \"PA2r\",\n\t\"./cs.js\": \"PA2r\",\n\t\"./cv\": \"A+xa\",\n\t\"./cv.js\": \"A+xa\",\n\t\"./cy\": \"l5ep\",\n\t\"./cy.js\": \"l5ep\",\n\t\"./da\": \"DxQv\",\n\t\"./da.js\": \"DxQv\",\n\t\"./de\": \"tGlX\",\n\t\"./de-at\": \"s+uk\",\n\t\"./de-at.js\": \"s+uk\",\n\t\"./de-ch\": \"u3GI\",\n\t\"./de-ch.js\": \"u3GI\",\n\t\"./de.js\": \"tGlX\",\n\t\"./dv\": \"WYrj\",\n\t\"./dv.js\": \"WYrj\",\n\t\"./el\": \"jUeY\",\n\t\"./el.js\": \"jUeY\",\n\t\"./en-au\": \"Dmvi\",\n\t\"./en-au.js\": \"Dmvi\",\n\t\"./en-ca\": \"OIYi\",\n\t\"./en-ca.js\": \"OIYi\",\n\t\"./en-gb\": \"Oaa7\",\n\t\"./en-gb.js\": \"Oaa7\",\n\t\"./en-ie\": \"4dOw\",\n\t\"./en-ie.js\": \"4dOw\",\n\t\"./en-il\": \"czMo\",\n\t\"./en-il.js\": \"czMo\",\n\t\"./en-nz\": \"b1Dy\",\n\t\"./en-nz.js\": \"b1Dy\",\n\t\"./eo\": \"Zduo\",\n\t\"./eo.js\": \"Zduo\",\n\t\"./es\": \"iYuL\",\n\t\"./es-do\": \"CjzT\",\n\t\"./es-do.js\": \"CjzT\",\n\t\"./es-us\": \"Vclq\",\n\t\"./es-us.js\": \"Vclq\",\n\t\"./es.js\": \"iYuL\",\n\t\"./et\": \"7BjC\",\n\t\"./et.js\": \"7BjC\",\n\t\"./eu\": \"D/JM\",\n\t\"./eu.js\": \"D/JM\",\n\t\"./fa\": \"jfSC\",\n\t\"./fa.js\": \"jfSC\",\n\t\"./fi\": \"gekB\",\n\t\"./fi.js\": \"gekB\",\n\t\"./fo\": \"ByF4\",\n\t\"./fo.js\": \"ByF4\",\n\t\"./fr\": \"nyYc\",\n\t\"./fr-ca\": \"2fjn\",\n\t\"./fr-ca.js\": \"2fjn\",\n\t\"./fr-ch\": \"Dkky\",\n\t\"./fr-ch.js\": \"Dkky\",\n\t\"./fr.js\": \"nyYc\",\n\t\"./fy\": \"cRix\",\n\t\"./fy.js\": \"cRix\",\n\t\"./gd\": \"9rRi\",\n\t\"./gd.js\": \"9rRi\",\n\t\"./gl\": \"iEDd\",\n\t\"./gl.js\": \"iEDd\",\n\t\"./gom-latn\": \"DKr+\",\n\t\"./gom-latn.js\": \"DKr+\",\n\t\"./gu\": \"4MV3\",\n\t\"./gu.js\": \"4MV3\",\n\t\"./he\": \"x6pH\",\n\t\"./he.js\": \"x6pH\",\n\t\"./hi\": \"3E1r\",\n\t\"./hi.js\": \"3E1r\",\n\t\"./hr\": \"S6ln\",\n\t\"./hr.js\": \"S6ln\",\n\t\"./hu\": \"WxRl\",\n\t\"./hu.js\": \"WxRl\",\n\t\"./hy-am\": \"1rYy\",\n\t\"./hy-am.js\": \"1rYy\",\n\t\"./id\": \"UDhR\",\n\t\"./id.js\": \"UDhR\",\n\t\"./is\": \"BVg3\",\n\t\"./is.js\": \"BVg3\",\n\t\"./it\": \"bpih\",\n\t\"./it.js\": \"bpih\",\n\t\"./ja\": \"B55N\",\n\t\"./ja.js\": \"B55N\",\n\t\"./jv\": \"tUCv\",\n\t\"./jv.js\": \"tUCv\",\n\t\"./ka\": \"IBtZ\",\n\t\"./ka.js\": \"IBtZ\",\n\t\"./kk\": \"bXm7\",\n\t\"./kk.js\": \"bXm7\",\n\t\"./km\": \"6B0Y\",\n\t\"./km.js\": \"6B0Y\",\n\t\"./kn\": \"PpIw\",\n\t\"./kn.js\": \"PpIw\",\n\t\"./ko\": \"Ivi+\",\n\t\"./ko.js\": \"Ivi+\",\n\t\"./ky\": \"lgnt\",\n\t\"./ky.js\": \"lgnt\",\n\t\"./lb\": \"RAwQ\",\n\t\"./lb.js\": \"RAwQ\",\n\t\"./lo\": \"sp3z\",\n\t\"./lo.js\": \"sp3z\",\n\t\"./lt\": \"JvlW\",\n\t\"./lt.js\": \"JvlW\",\n\t\"./lv\": \"uXwI\",\n\t\"./lv.js\": \"uXwI\",\n\t\"./me\": \"KTz0\",\n\t\"./me.js\": \"KTz0\",\n\t\"./mi\": \"aIsn\",\n\t\"./mi.js\": \"aIsn\",\n\t\"./mk\": \"aQkU\",\n\t\"./mk.js\": \"aQkU\",\n\t\"./ml\": \"AvvY\",\n\t\"./ml.js\": \"AvvY\",\n\t\"./mn\": \"lYtQ\",\n\t\"./mn.js\": \"lYtQ\",\n\t\"./mr\": \"Ob0Z\",\n\t\"./mr.js\": \"Ob0Z\",\n\t\"./ms\": \"6+QB\",\n\t\"./ms-my\": \"ZAMP\",\n\t\"./ms-my.js\": \"ZAMP\",\n\t\"./ms.js\": \"6+QB\",\n\t\"./mt\": \"G0Uy\",\n\t\"./mt.js\": \"G0Uy\",\n\t\"./my\": \"honF\",\n\t\"./my.js\": \"honF\",\n\t\"./nb\": \"bOMt\",\n\t\"./nb.js\": \"bOMt\",\n\t\"./ne\": \"OjkT\",\n\t\"./ne.js\": \"OjkT\",\n\t\"./nl\": \"+s0g\",\n\t\"./nl-be\": \"2ykv\",\n\t\"./nl-be.js\": \"2ykv\",\n\t\"./nl.js\": \"+s0g\",\n\t\"./nn\": \"uEye\",\n\t\"./nn.js\": \"uEye\",\n\t\"./pa-in\": \"8/+R\",\n\t\"./pa-in.js\": \"8/+R\",\n\t\"./pl\": \"jVdC\",\n\t\"./pl.js\": \"jVdC\",\n\t\"./pt\": \"8mBD\",\n\t\"./pt-br\": \"0tRk\",\n\t\"./pt-br.js\": \"0tRk\",\n\t\"./pt.js\": \"8mBD\",\n\t\"./ro\": \"lyxo\",\n\t\"./ro.js\": \"lyxo\",\n\t\"./ru\": \"lXzo\",\n\t\"./ru.js\": \"lXzo\",\n\t\"./sd\": \"Z4QM\",\n\t\"./sd.js\": \"Z4QM\",\n\t\"./se\": \"//9w\",\n\t\"./se.js\": \"//9w\",\n\t\"./si\": \"7aV9\",\n\t\"./si.js\": \"7aV9\",\n\t\"./sk\": \"e+ae\",\n\t\"./sk.js\": \"e+ae\",\n\t\"./sl\": \"gVVK\",\n\t\"./sl.js\": \"gVVK\",\n\t\"./sq\": \"yPMs\",\n\t\"./sq.js\": \"yPMs\",\n\t\"./sr\": \"zx6S\",\n\t\"./sr-cyrl\": \"E+lV\",\n\t\"./sr-cyrl.js\": \"E+lV\",\n\t\"./sr.js\": \"zx6S\",\n\t\"./ss\": \"Ur1D\",\n\t\"./ss.js\": \"Ur1D\",\n\t\"./sv\": \"X709\",\n\t\"./sv.js\": \"X709\",\n\t\"./sw\": \"dNwA\",\n\t\"./sw.js\": \"dNwA\",\n\t\"./ta\": \"PeUW\",\n\t\"./ta.js\": \"PeUW\",\n\t\"./te\": \"XLvN\",\n\t\"./te.js\": \"XLvN\",\n\t\"./tet\": \"V2x9\",\n\t\"./tet.js\": \"V2x9\",\n\t\"./tg\": \"Oxv6\",\n\t\"./tg.js\": \"Oxv6\",\n\t\"./th\": \"EOgW\",\n\t\"./th.js\": \"EOgW\",\n\t\"./tl-ph\": \"Dzi0\",\n\t\"./tl-ph.js\": \"Dzi0\",\n\t\"./tlh\": \"z3Vd\",\n\t\"./tlh.js\": \"z3Vd\",\n\t\"./tr\": \"DoHr\",\n\t\"./tr.js\": \"DoHr\",\n\t\"./tzl\": \"z1FC\",\n\t\"./tzl.js\": \"z1FC\",\n\t\"./tzm\": \"wQk9\",\n\t\"./tzm-latn\": \"tT3J\",\n\t\"./tzm-latn.js\": \"tT3J\",\n\t\"./tzm.js\": \"wQk9\",\n\t\"./ug-cn\": \"YRex\",\n\t\"./ug-cn.js\": \"YRex\",\n\t\"./uk\": \"raLr\",\n\t\"./uk.js\": \"raLr\",\n\t\"./ur\": \"UpQW\",\n\t\"./ur.js\": \"UpQW\",\n\t\"./uz\": \"Loxo\",\n\t\"./uz-latn\": \"AQ68\",\n\t\"./uz-latn.js\": \"AQ68\",\n\t\"./uz.js\": \"Loxo\",\n\t\"./vi\": \"KSF8\",\n\t\"./vi.js\": \"KSF8\",\n\t\"./x-pseudo\": \"/X5v\",\n\t\"./x-pseudo.js\": \"/X5v\",\n\t\"./yo\": \"fzPg\",\n\t\"./yo.js\": \"fzPg\",\n\t\"./zh-cn\": \"XDpg\",\n\t\"./zh-cn.js\": \"XDpg\",\n\t\"./zh-hk\": \"SatO\",\n\t\"./zh-hk.js\": \"SatO\",\n\t\"./zh-tw\": \"kOpN\",\n\t\"./zh-tw.js\": \"kOpN\"\n};\n\n\nfunction webpackContext(req) {\n\tvar id = webpackContextResolve(req);\n\treturn __webpack_require__(id);\n}\nfunction webpackContextResolve(req) {\n\tif(!__webpack_require__.o(map, req)) {\n\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\te.code = 'MODULE_NOT_FOUND';\n\t\tthrow e;\n\t}\n\treturn map[req];\n}\nwebpackContext.keys = function webpackContextKeys() {\n\treturn Object.keys(map);\n};\nwebpackContext.resolve = webpackContextResolve;\nmodule.exports = webpackContext;\nwebpackContext.id = \"RnhZ\";","import { Component, HostBinding, OnInit } from '@angular/core';\r\n\r\nimport { SettingsService } from './core/settings/settings.service';\r\n\r\n@Component({\r\n    selector: 'app-root',\r\n    templateUrl: './app.component.html',\r\n    styleUrls: ['./app.component.scss']\r\n})\r\nexport class AppComponent implements OnInit {\r\n\r\n    @HostBinding('class.layout-fixed') get isFixed() { return this.settings.getLayoutSetting('isFixed'); };\r\n    @HostBinding('class.aside-collapsed') get isCollapsed() { return this.settings.getLayoutSetting('isCollapsed'); };\r\n    @HostBinding('class.layout-boxed') get isBoxed() { return this.settings.getLayoutSetting('isBoxed'); };\r\n    @HostBinding('class.layout-fs') get useFullLayout() { return this.settings.getLayoutSetting('useFullLayout'); };\r\n    @HostBinding('class.hidden-footer') get hiddenFooter() { return this.settings.getLayoutSetting('hiddenFooter'); };\r\n    @HostBinding('class.layout-h') get horizontal() { return this.settings.getLayoutSetting('horizontal'); };\r\n    @HostBinding('class.aside-float') get isFloat() { return this.settings.getLayoutSetting('isFloat'); };\r\n    @HostBinding('class.offsidebar-open') get offsidebarOpen() { return this.settings.getLayoutSetting('offsidebarOpen'); };\r\n    @HostBinding('class.aside-toggled') get asideToggled() { return this.settings.getLayoutSetting('asideToggled'); };\r\n    @HostBinding('class.aside-collapsed-text') get isCollapsedText() { return this.settings.getLayoutSetting('isCollapsedText'); };\r\n\r\n    constructor(public settings: SettingsService) { }\r\n\r\n    ngOnInit() {\r\n        // prevent empty links to reload the page\r\n        document.addEventListener('click', e => {\r\n            const target = e.target as HTMLElement;\r\n            if (target.tagName === 'A' && ['', '#'].indexOf(target.getAttribute('href')) > -1)\r\n                e.preventDefault();\r\n        });\r\n    }\r\n}\r\n","<router-outlet></router-outlet>\r\n","import { NgModule } from '@angular/core';\r\n\r\nimport { LayoutComponent } from './layout.component';\r\nimport { SidebarComponent } from './sidebar/sidebar.component';\r\nimport { HeaderComponent } from './header/header.component';\r\nimport { OffsidebarComponent } from './offsidebar/offsidebar.component';\r\nimport { UserblockComponent } from './sidebar/userblock/userblock.component';\r\nimport { UserblockService } from './sidebar/userblock/userblock.service';\r\n\r\nimport { SharedModule } from '../shared/shared.module';\r\n\r\n@NgModule({\r\n    imports: [\r\n        SharedModule\r\n    ],\r\n    providers: [\r\n        UserblockService\r\n    ],\r\n    declarations: [\r\n        LayoutComponent,\r\n        SidebarComponent,\r\n        UserblockComponent,\r\n        HeaderComponent,\r\n        OffsidebarComponent\r\n    ],\r\n    exports: [\r\n        LayoutComponent,\r\n        SidebarComponent,\r\n        UserblockComponent,\r\n        HeaderComponent,\r\n        OffsidebarComponent\r\n    ]\r\n})\r\n\r\nexport class LayoutModule { }\r\n","import { Routes } from '@angular/router';\r\n\r\nimport { LayoutComponent } from '../layout/layout.component';\r\nimport { LoginComponent } from './page/login/login.component';\r\nimport { Error404Component } from './page/error404/error404.component';\r\nimport { Error500Component } from './page/error500/error500.component';\r\n\r\nexport const routes: Routes = [\r\n  {\r\n    path: '',\r\n    component: LayoutComponent,\r\n    children: [\r\n      {\r\n        path: '',\r\n        redirectTo: 'login',\r\n        pathMatch: 'full'\r\n      },\r\n      {\r\n        path: 'login',\r\n        component: LoginComponent\r\n      },\r\n      {\r\n        path: 'home',\r\n        loadChildren: () => import('./home/home.module').then(i => i.HomeModule)\r\n      },\r\n      {\r\n        path: 'report',\r\n        loadChildren: () => import('./report/report.module').then(i => i.ReportModule),\r\n      }\r\n    ]\r\n  },\r\n  // Not lazy-loaded routes\r\n  {\r\n    path: '404',\r\n    component: Error404Component\r\n  },\r\n  {\r\n    path: '500',\r\n    component: Error500Component\r\n  },\r\n  // Not found\r\n  {\r\n    path: '**',\r\n    redirectTo: 'login'\r\n  }\r\n];\r\n","import { Injectable } from '@angular/core';\r\nimport { TranslateService } from '@ngx-translate/core';\r\n\r\n@Injectable()\r\nexport class TranslatorService {\r\n\r\n    private defaultLanguage: string = 'en';\r\n\r\n    private availablelangs = [\r\n        { code: 'en', text: 'English' },\r\n        { code: 'es_AR', text: 'Spanish' }\r\n    ];\r\n\r\n    constructor(public translate: TranslateService) {\r\n\r\n        if (!translate.getDefaultLang())\r\n            translate.setDefaultLang(this.defaultLanguage);\r\n\r\n        this.useLanguage();\r\n\r\n    }\r\n\r\n    useLanguage(lang: string = null) {\r\n        this.translate.use(lang || this.translate.getDefaultLang());\r\n    }\r\n\r\n    getAvailableLanguages() {\r\n        return this.availablelangs;\r\n    }\r\n\r\n}\r\n","import { Component, OnInit, OnDestroy, ElementRef } from '@angular/core';\r\n\r\nimport { SettingsService } from '../../core/settings/settings.service';\r\nimport { ThemeService } from '../../core/theme/theme.service';\r\nimport { TranslatorService } from '../../core/translator/translator.service';\r\n\r\n@Component({\r\n    selector: 'app-offsidebar',\r\n    templateUrl: './offsidebar.component.html',\r\n    styleUrls: ['./offsidebar.component.scss']\r\n})\r\n\r\nexport class OffsidebarComponent implements OnInit, OnDestroy {\r\n\r\n    currentTheme: any;\r\n    selectedLanguage: string;\r\n\r\n    constructor(\r\n        public settings: SettingsService,\r\n        public theme: ThemeService,\r\n        public translator: TranslatorService,\r\n        public elem: ElementRef) {\r\n        this.currentTheme = theme.defaultTheme;\r\n        this.selectedLanguage = this.getLangs()[0].code;\r\n    }\r\n\r\n    ngOnInit() {\r\n        this.anyClickClose();\r\n    }\r\n    setTheme() {\r\n        this.theme.theme = this.currentTheme;\r\n    }\r\n    getLangs() {\r\n        return this.translator.getAvailableLanguages();\r\n    }\r\n    setLang(value) {\r\n        this.translator.useLanguage(value);\r\n    }\r\n    anyClickClose() {\r\n        document.addEventListener('click', this.checkCloseOffsidebar, false);\r\n    }\r\n    checkCloseOffsidebar = e => {\r\n        const contains = (this.elem.nativeElement !== e.target && this.elem.nativeElement.contains(e.target));\r\n        if (!contains) {\r\n            this.settings.setLayoutSetting('offsidebarOpen', false);\r\n        }\r\n    }\r\n    ngOnDestroy() {\r\n        document.removeEventListener('click', this.checkCloseOffsidebar);\r\n    }\r\n\r\n}\r\n","<tabset [justified]=\"true\">\r\n</tabset>\r\n","// https://angular.io/styleguide#!#04-12\r\nexport function throwIfAlreadyLoaded(parentModule: any, moduleName: string) {\r\n  if (parentModule) {\r\n    throw new Error(`${moduleName} has already been loaded. Import Core modules in the AppModule only.`);\r\n  }\r\n}\r\n","<div class=\"wrapper\">\r\n    <div class=\"overlay\" *ngIf=\"showSpinner\">\r\n        <div class=\"spinner-wrapper align-items-center justify-content-center\">\r\n            <app-waitingSpinner></app-waitingSpinner>\r\n        </div>\r\n    </div>\r\n    <div class=\"block-center mt-4 wd-xl\">\r\n        <!-- START card-->\r\n        <div class=\"middle-box text-center loginscreen animated fadeInDown\">\r\n            <div class=\"card-header text-center bg-transparent\" style=\"padding: 0px; margin-top: 5px; position: relative; text-align: center; left: inherit; border:none\">\r\n                <a href=\"#\">\r\n                    <img class=\"block-center rounded\" style=\"border:none\" src=\"assets/img/logo/AGAT.logo.ShadedNoLeaf.png\" alt=\"AGAT\" />\r\n                </a>\r\n            </div>\r\n            <div class=\"text-center\">\r\n                <h5 style=\"text-align:center;\" font-weight-light>\r\n                    Air Quality Monitoring\r\n                </h5>\r\n            </div>\r\n            <br />\r\n            <div class=\"small font-weight-light text-center\">\r\n                <h6 style=\"text-align:center;\">\r\n                    Please login using your existing credentials\r\n                </h6>\r\n            </div>\r\n            <div class=\"card-body\">\r\n                <form name=\"loginForm\"\r\n                      class=\"form-validate mb-3\"\r\n                      [formGroup]=\"valForm\"\r\n                      role=\"form\"\r\n                      novalidate=\"\">\r\n                    <div class=\"form-group\">\r\n                        <div class=\"input-group with-focus\">\r\n                            <input id=\"idEmail\"\r\n                                   #loginUser\r\n                                   formControlName=\"email\"\r\n                                   class=\"form-control border-right-0\"\r\n                                   [(ngModel)]=\"email\"\r\n                                   autocomplete=\"on\"\r\n                                   type=\"{{ isEmployee ? 'text' : 'email'}}\"\r\n                                   placeholder=\"{{ isEmployee ? 'user name' : 'email'}}\"\r\n                                   required=\"\"\r\n                                   autofocus\r\n                                   tabindex=\"1\"\r\n                                   (keydown.arrowup)=\"onKey($event)\"\r\n                                   (keydown.arrowdown)=\"onKey($event)\"\r\n                                   (keydown.tab)=\"onKey($event)\" />\r\n                            <div class=\"input-group-append\">\r\n                                <span class=\"input-group-text text-muted bg-transparent border-left-0\">\r\n                                    <em [className]=\"isEmployee ? 'fa fa-user' : 'fa fa-envelope'\">\r\n                                    </em>\r\n                                </span>\r\n                            </div>\r\n                        </div>\r\n                        <div class=\"pink-to-red\"\r\n                             *ngIf=\"valForm.controls['email'].hasError('required') && (valForm.controls['email'].dirty || valForm.controls['email'].touched)\">\r\n                            This field is required\r\n                        </div>\r\n                    </div>\r\n                    <div class=\"form-group\">\r\n                        <div class=\"input-group with-focus\">\r\n                            <input id=\"idPassword\"\r\n                                   #loginPassword\r\n                                   formControlName=\"password\"\r\n                                   class=\"form-control border-right-0\"\r\n                                   type=\"password\"\r\n                                   [(ngModel)]=\"password\"\r\n                                   placeholder=\"password\"\r\n                                   required=\"\"\r\n                                   tabindex=\"2\"\r\n                                   (keydown.arrowup)=\"onKey($event)\"\r\n                                   (keydown.arrowdown)=\"onKey($event)\"\r\n                                   (keydown.tab)=\"onKey($event)\" />\r\n                            <div class=\"input-group-append\">\r\n                                <span class=\"input-group-text text-muted bg-transparent border-left-0\">\r\n                                    <em id=\"idLock\"\r\n                                        class=\"fa fa-lock\"\r\n                                        (mouseover)=\"onLockHover()\"\r\n                                        (mouseout)=\"onLockLeave()\">\r\n                                    </em>\r\n                                </span>\r\n                            </div>\r\n                        </div>\r\n                        <div class=\"pink-to-red\"\r\n                             *ngIf=\"valForm.controls['password'].hasError('required') && (valForm.controls['password'].dirty || valForm.controls['password'].touched)\">\r\n                            This field is required\r\n                        </div>\r\n                    </div>\r\n                    <button id=\"idButton\"\r\n                            #loginGo\r\n                            class=\"btn btn-block btn-primary mt-3\"\r\n                            tabindex=\"2\"\r\n                            (click)=\"onLogin()\"\r\n                            (keydown.arrowup)=\"onKey($event)\"\r\n                            (keydown.arrowdown)=\"onKey($event)\"\r\n                            (keydown.tab)=\"onKey($event)\">\r\n                        Login\r\n                    </button>\r\n                    <div>\r\n                        <div>\r\n                            <label id=\"idMessage\"\r\n                                   class=\"pink-to-red\">\r\n                                {{ message }}\r\n                            </label>\r\n                        </div>\r\n                    </div>\r\n                </form>\r\n            </div>\r\n        </div>\r\n        <!-- END card-->\r\n        <div class=\"text-center\"\r\n             style=\"margin-bottom:25px;\">\r\n            <a href=\"https://webairold.agatlabs.com/\" target=\"_blank\">\r\n                Click here for the old system\r\n            </a>\r\n            <div class=\"small font-weight-light text-center\"\r\n                 style=\"color: gray;\">\r\n                <span>\r\n                    [which will remain available for a short time]\r\n                </span>\r\n            </div>\r\n        </div>\r\n        <div class=\"small font-weight-light text-center\">\r\n            <span>&copy; {{ settings.getAppSetting('copyright') }} {{ settings.getAppSetting('year') }}</span>\r\n            <br />\r\n            <span>{{ settings.getAppSetting('description') }}</span>\r\n        </div>\r\n        <div class=\"small font-weight-light text-center\">\r\n            <span>{{ settings.getAppSetting('version') }}</span>\r\n        </div>\r\n    </div>\r\n</div>\r\n","import {\r\n    AfterViewInit,\r\n    Component, Inject,\r\n    OnInit, ViewChild,\r\n    ElementRef\r\n} from '@angular/core';\r\nimport {\r\n    FormGroup,\r\n    FormBuilder,\r\n    Validators\r\n} from '@angular/forms';\r\n\r\nimport {\r\n    Router\r\n} from '@angular/router';\r\n\r\nimport {\r\n    Observable\r\n} from 'rxjs';\r\n\r\nimport {\r\n    LoginModel,\r\n    SecurityInfo\r\n} from '../../../core/model/procedure.model';\r\nimport {\r\n    LoginService\r\n} from '../../../core/service/login.service';\r\nimport {\r\n    SettingsService\r\n} from '../../../core/settings/settings.service';\r\n\r\nimport {\r\n    lowerCase\r\n} from 'lodash';\r\n\r\nfunction defaultEnterButton() {\r\n    $('.password').on('keydown', function (e) {\r\n        if (e.keyCode == 13) {\r\n            $('.onLogin').click();\r\n        }\r\n    })\r\n}\r\n\r\n@Component({\r\n    selector: 'app-login',\r\n    templateUrl: './login.component.html',\r\n    styleUrls: ['./login.component.scss'],\r\n    //encapsulation: ViewEncapsulation.None\r\n})\r\n\r\nexport class LoginComponent implements OnInit, AfterViewInit {\r\n\r\n    email: string = '';\r\n    password: string = '';\r\n    message: string = '';\r\n    department: string = '';\r\n    showSpinner: boolean = false;\r\n    valForm: FormGroup;\r\n    searchParam: LoginModel;\r\n\r\n    //is\r\n    isValid: boolean = false;\r\n    isClient: boolean = true;\r\n    isEmployee: boolean = false;\r\n    //key\r\n    keyLock: string = 'idLock';\r\n    keyInput: string = 'idPassword';\r\n\r\n    public idUser = 0;\r\n\r\n    @ViewChild('loginGo') loginGo!: ElementRef<HTMLElement>;\r\n    @ViewChild('loginUser') loginUser!: ElementRef<HTMLElement>;\r\n    @ViewChild('loginPassword') loginPassword!: ElementRef<HTMLElement>;\r\n\r\n    constructor(\r\n        private fb: FormBuilder,\r\n        private service: LoginService,\r\n        public settings: SettingsService,\r\n        private router: Router,\r\n        @Inject('BASE_URL') private baseUrl: string) {\r\n        this.valForm = fb.group({\r\n            'email': [null, Validators.required],\r\n            'password': [null, Validators.required]\r\n        });\r\n    }\r\n\r\n    ngOnInit() {\r\n        this.onInit();\r\n    }\r\n    ngAfterViewInit(): void {\r\n        setTimeout(() => {\r\n            this.loginUser.nativeElement.focus();\r\n        }, 100);\r\n        this.onInitUser();\r\n    }\r\n    //init\r\n    onInit() {\r\n        let e = '';\r\n\r\n        this.email = e;\r\n        this.password = e;\r\n        this.message = e;\r\n        this.isValid = false;\r\n    }\r\n    async onInitUser() {\r\n        let s = this.service;\r\n        let r = await s.userType();\r\n\r\n        r.subscribe((data: string) => {\r\n            let e = data != undefined;\r\n\r\n            if (e) {\r\n                let v = '' + data;\r\n\r\n                e = v != undefined;\r\n                if (e) {\r\n                    e = lowerCase(v) == 'employee';\r\n                }\r\n            }\r\n            this.isEmployee = e;\r\n            s.isEmployee = e;\r\n            e = !e;\r\n            this.isClient = e;\r\n            s.isClient = e;\r\n        },\r\n            err => {\r\n                console.error(err);\r\n            },\r\n            () => {\r\n                this.onByPass();\r\n            });\r\n    }\r\n    //authenticate\r\n    authenticate(item: LoginModel): Observable<SecurityInfo> {\r\n        let result = this.service.authenticate(item);\r\n\r\n        return result;\r\n    }\r\n    //login\r\n    onLogin() {\r\n        let ok = true;\r\n        let em = this.email;\r\n        let pw = this.password;\r\n        let sp = new LoginModel();\r\n\r\n        this.idUser = 0;\r\n        this.showSpinner = ok;\r\n        this.searchParam = sp;\r\n        ok = em.length > 0 && pw.length > 0;\r\n        if (ok) {\r\n            sp.username = em;\r\n            sp.password = pw;\r\n\r\n            let result = this.authenticate(sp);\r\n\r\n            result.subscribe((data: SecurityInfo) => {\r\n                let id = 0;\r\n\r\n                ok = data != null;\r\n                if (ok) {\r\n                    ok = data.valid;\r\n                    if (ok) {\r\n                        id = this.getUserId(data);\r\n                    }\r\n                }\r\n                /*\r\n                //by pass\r\n                ok = true;\r\n                */\r\n                this.idUser = id;\r\n                this.isValid = ok;\r\n                if (ok) {\r\n                    this.router\r\n                        .navigate(['/home']);\r\n                    this.service\r\n                        .initialPermissions(data);\r\n                }\r\n                else {\r\n                    this.onMessage('User not authorized for software');\r\n                }\r\n                this.isValid = ok;\r\n                ok = false;\r\n                this.showSpinner = ok;\r\n            });\r\n        }\r\n        else {\r\n            let m = 'Please enter ';\r\n\r\n            if (this.isEmployee) {\r\n                m += 'User Name';\r\n            }\r\n            else /*if (this.isClient)*/ {\r\n                m += 'Email';\r\n            }\r\n            m += ' / Password';\r\n            this.onMessage(m)\r\n            this.isValid = ok;\r\n            ok = false;\r\n            this.showSpinner = ok;\r\n        }\r\n    }\r\n    //message\r\n    doMessage(style) {\r\n        style.color = 'pink';\r\n        var interval = window.setInterval(() => {\r\n            style.color = 'red';\r\n            window.clearInterval(interval);\r\n            window.setTimeout(() => {\r\n                this.doMessage(style);\r\n            },\r\n                1000);\r\n        },\r\n            1000);\r\n    }\r\n    onMessage(value: string) {\r\n        this.message = value;\r\n        /*\r\n        if (value.length > 0) {\r\n            let e;\r\n    \r\n            e = document.getElementById('idMessage');\r\n            this.doMessage(e.style);\r\n        }\r\n        */\r\n    }\r\n    //lock\r\n    onLock(lock: boolean) {\r\n        let c;\r\n        let e;\r\n        let k = this.keyInput;\r\n        let $e;\r\n        let icon;\r\n        let type;\r\n\r\n        e = document.getElementById(k);\r\n        $e = $('#' + k);\r\n        if (lock) {\r\n            c = 'black';\r\n            icon = 'lock';\r\n            type = 'password';\r\n        }\r\n        else {\r\n            c = 'lightgray';\r\n            icon = 'eye';\r\n            type = 'text';\r\n        }\r\n        e.type = type;\r\n        $e.css({\r\n            'color': c\r\n        });\r\n        $e = $('#' + this.keyLock);\r\n        $e.removeClass();\r\n        $e.addClass('fa fa-' + icon);\r\n    }\r\n    onLockHover() {\r\n        this.onLock(false);\r\n    }\r\n    onLockLeave() {\r\n        this.onLock(true);\r\n    }\r\n    //user\r\n    getUserId(item: object): number {\r\n        let id = 0;\r\n        let items = Object.keys(item);\r\n\r\n        if (items != null) {\r\n            let count = items.length;\r\n\r\n            if (count > 0) {\r\n                let key = (this.isEmployee ? 'contact' : 'externalContact') + 'Id';\r\n\r\n                if (items.indexOf(key) > -1) {\r\n                    id = item[key];\r\n                }\r\n            }\r\n        }\r\n\r\n        return id;\r\n    }\r\n    //by pass\r\n    onByPass() {\r\n        /*\r\n        this.byPassOn();\r\n       */\r\n        this.byPassOff();\r\n        this.onLogin();\r\n    }\r\n    byPassOn() {\r\n        let e,\r\n            p;\r\n\r\n        if (this.isEmployee) {\r\n            e = 'employee';\r\n            p = 'agat';\r\n        }\r\n        else /*if (this.isClient)*/ {\r\n            e = 'testuser@shell.com';\r\n            //e = 'testuser@directenergy.com';\r\n            p = 'sp33dbump';\r\n        }\r\n        this.email = e;\r\n        this.password = p;\r\n    }\r\n    byPassOff() {\r\n        let e = '';\r\n\r\n        this.email = e;\r\n        this.password = e;\r\n    }\r\n    onKey(event: KeyboardEvent) {\r\n        let key = event.key.toLowerCase();\r\n        let d = key === 'tab' || key == 'arrowdown';\r\n        let u = key == 'arrowup';\r\n\r\n        if (d ||\r\n            u) {\r\n            event.preventDefault();\r\n            let e = <HTMLElement>event.currentTarget;\r\n            let id = e.id;\r\n            let eg = this.loginGo.nativeElement;\r\n            let em = this.loginUser.nativeElement;\r\n            let ep = this.loginPassword.nativeElement;\r\n\r\n            switch (id) {\r\n                case 'idEmail':\r\n                    e = d ? ep : eg;\r\n                    break;\r\n                case 'idPassword':\r\n                    e = d ? eg : em;\r\n                    break;\r\n                case 'idButtonLogin':\r\n                case 'idUser':\r\n                default:\r\n                    e = d ? em : ep;\r\n                    break;\r\n            }\r\n            e.focus();\r\n        }\r\n    }\r\n\r\n}\r\n","export default \"/* ========================================================================\\n   Component: layout\\n ========================================================================== */\\nbody, .wrapper .section-container {\\n  background-color: #f5f7fa;\\n}\\n.wrapper .aside-container {\\n  background-color: #3a3f51;\\n}\\n/* ========================================================================\\n   Component: top-navbar\\n ========================================================================== */\\n.topnavbar {\\n  background-color: #564aa3;\\n  background-image: linear-gradient(to right, #564aa3 0%, #7266ba 100%);\\n  background-repeat: repeat-x;\\n}\\n@media (min-width: 992px) {\\n  .topnavbar .navbar-nav > .nav-item.show > .nav-link, .topnavbar .navbar-nav > .nav-item.show > .nav-link:hover, .topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n    box-shadow: 0 -3px 0 #4b408e inset;\\n  }\\n}\\n.topnavbar .navbar-nav > .nav-item > .navbar-text {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link:hover, .topnavbar .navbar-nav > .nav-item > .nav-link:focus,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:hover,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n  color: #312a5d;\\n}\\n.topnavbar .dropdown-item.active, .topnavbar .dropdown-item:active {\\n  background-color: #564aa3;\\n}\\n/* ========================================================================\\n   Component: sidebar\\n ========================================================================== */\\n.sidebar {\\n  background-color: #3a3f51;\\n}\\n.sidebar .nav-heading {\\n  color: #919DA8;\\n}\\n.sidebar-nav > li > a, .sidebar-nav > li > .nav-item {\\n  color: #e1e2e3;\\n}\\n.sidebar-nav > li > a:focus, .sidebar-nav > li > a:hover, .sidebar-nav > li > .nav-item:focus, .sidebar-nav > li > .nav-item:hover {\\n  color: #9289ca;\\n}\\n.sidebar-nav > li > a > em, .sidebar-nav > li > .nav-item > em {\\n  color: inherits;\\n}\\n.sidebar-nav > li.active, .sidebar-nav > li.active > a, .sidebar-nav > li.active > .nav-item, .sidebar-nav > li.active .sidebar-nav, .sidebar-nav > li.open, .sidebar-nav > li.open > a, .sidebar-nav > li.open > .nav-item, .sidebar-nav > li.open .sidebar-nav {\\n  background-color: #383d4e;\\n  color: #9289ca;\\n}\\n.sidebar-nav > li.active > .nav-item > em, .sidebar-nav > li.active > a > em, .sidebar-nav > li.open > .nav-item > em, .sidebar-nav > li.open > a > em {\\n  color: #9289ca;\\n}\\n.sidebar-nav > li.active {\\n  border-left-color: #9289ca;\\n}\\n.sidebar-subnav {\\n  background-color: #3a3f51;\\n}\\n.sidebar-subnav > .sidebar-subnav-header {\\n  color: #e1e2e3;\\n}\\n.sidebar-subnav > li > a, .sidebar-subnav > li > .nav-item {\\n  color: #e1e2e3;\\n}\\n.sidebar-subnav > li > a:focus, .sidebar-subnav > li > a:hover, .sidebar-subnav > li > .nav-item:focus, .sidebar-subnav > li > .nav-item:hover {\\n  color: #9289ca;\\n}\\n.sidebar-subnav > li.active > a, .sidebar-subnav > li.active > .nav-item {\\n  color: #9289ca;\\n}\\n.sidebar-subnav > li.active > a:after, .sidebar-subnav > li.active > .nav-item:after {\\n  border-color: #9289ca;\\n  background-color: #9289ca;\\n}\\n/* ========================================================================\\n   Component: offsidebar\\n ========================================================================== */\\n.offsidebar {\\n  border-left: 1px solid greyscale(#cccccc);\\n  background-color: #fff;\\n  color: #656565;\\n}\\n/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/app/shared/style/theme/theme-g.scss","src/app/shared/style/app/variables.scss","src/app/shared/style/bootstrap/mixins/_gradients.scss","src/app/shared/style/bootstrap/mixins/_breakpoints.scss"],"names":[],"mappings":"AA8CA;;6EAAA;AAGA;EACI,yBAzC4B;AAJhC;AAgDA;EACI,yBCnDoB;ADMxB;AAgDA;;6EAAA;AAGA;EACI,yBCjBoB;EC9BtB,qEAAA;EACA,2BAAA;AFGF;AG0CI;EHMQ;IACI,kCAAA;EA7Cd;AACF;AAiDI;EACI,WAtDwB;AAOhC;AAkDI;;EAEI,WA3DwB;AAWhC;AAiDQ;;;EACI,cA5DoB;AAehC;AAiDI;EACI,yBCzCgB;ADNxB;AAmDA;;6EAAA;AAGA;EACI,yBC1FoB;AD0CxB;AAkDI;EACI,cA5D0B;AAYlC;AAuDQ;EACI,cA9EsB;AA0BlC;AAsDY;EACI,cCzEQ;ADqBxB;AAwDY;EACI,eAlFkB;AA4BlC;AA6DY;EACI,yBA5FkB;EA6FlB,cCvFQ;AD4BxB;AA8DY;EACI,cC3FQ;AD+BxB;AAiEQ;EACI,0BCjGY;ADkCxB;AAsEA;EACI,yBCxIoB;ADqExB;AAqEI;EACI,cApH0B;AAiDlC;AAuEQ;EACI,cAzHsB;AAoDlC;AAuEY;EACI,cCpHQ;AD+CxB;AA2EY;EACI,cC3HQ;ADkDxB;AA2EgB;EACI,qBC9HI;ED+HJ,yBC/HI;ADsDxB;AAoFA;;6EAAA;AAGA;EACI,yCAAA;EACA,sBAxIsB;EAyItB,cCrCwB;AD5C5B","file":"src/app/shared/style/theme/theme-g.scss","sourcesContent":["// Bootstrap\r\n@import \"../bootstrap/functions\";\r\n@import \"../bootstrap/variables\";\r\n@import \"../bootstrap/mixins\";\r\n@import '../app/variables';\r\n\r\n\r\n// LAYOUT\r\n\r\n$content-bg:                    #f5f7fa;\r\n$aside-bg:                      $gray-dark;\r\n\r\n// NAVBAR TOP\r\n\r\n$nav-top-bg:                    $purple-dark;\r\n$nav-top-bg-start:              $nav-top-bg;\r\n$nav-top-bg-end:                $purple;\r\n$nav-header-bg:                 transparent;\r\n\r\n$nav-top-item:                  #fff;\r\n$nav-top-item-active:           darken($nav-top-bg, 20%);\r\n\r\n// SIDEBAR\r\n\r\n$sidebar-bg:                      $aside-bg;\r\n\r\n$sidebar-item-color:              #e1e2e3;\r\n$sidebar-item-color-active:       $purple-light;\r\n$sidebar-item-bg-active:          darken($sidebar-bg, 1%);\r\n\r\n$sidebar-icon-color:              inherits;\r\n$sidebar-icon-color-active:       $sidebar-item-color-active;\r\n\r\n$sidebar-bullet-color:            rgba(0,0,0,.25);\r\n$sidebar-bullet-color-active:     $sidebar-icon-color-active;\r\n\r\n$sidebar-heading-color:           #919DA8;\r\n$sidebar-label-color:             $sidebar-item-color;\r\n\r\n// OFFSIDEBAR\r\n\r\n$offsidebar-bg:           #fff;\r\n$offsidebar-border-color: greyscale(darken($offsidebar-bg, 20%));\r\n$offsidebar-color:        $body-color;\r\n\r\n\r\n/* ========================================================================\r\n   Component: layout\r\n ========================================================================== */\r\nbody, .wrapper .section-container {\r\n    background-color: $content-bg;\r\n}\r\n\r\n.wrapper .aside-container {\r\n    background-color: $aside-bg;\r\n}\r\n\r\n/* ========================================================================\r\n   Component: top-navbar\r\n ========================================================================== */\r\n.topnavbar {\r\n    background-color: $nav-top-bg;\r\n    @include gradient-x($nav-top-bg-start, $nav-top-bg-end);\r\n\r\n    @include media-breakpoint-up(lg) {\r\n        .navbar-nav > .nav-item.show > .nav-link {\r\n            &, &:hover, &:focus {\r\n                box-shadow: 0 -3px 0 darken($nav-top-bg, 6%) inset;\r\n            }\r\n        }\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .navbar-text {\r\n        color: $nav-top-item;\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .nav-link,\r\n    .navbar-nav > .nav-item.show > .nav-link {\r\n        color: $nav-top-item;\r\n        &:hover, &:focus {\r\n            color: $nav-top-item-active;\r\n        }\r\n    }\r\n\r\n    .dropdown-item.active, .dropdown-item:active {\r\n        background-color: $nav-top-bg;\r\n    }\r\n}\r\n\r\n/* ========================================================================\r\n   Component: sidebar\r\n ========================================================================== */\r\n.sidebar {\r\n    background-color: $sidebar-bg;\r\n\r\n    .nav-heading {\r\n        color: $sidebar-heading-color;\r\n    }\r\n}\r\n\r\n// Items\r\n.sidebar-nav {\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            // Item icon\r\n            > em {\r\n                color: $sidebar-icon-color;\r\n            }\r\n\r\n        }\r\n\r\n        // Active item state\r\n        &.active, &.open {\r\n            &, > a, > .nav-item, .sidebar-nav {\r\n                background-color: $sidebar-item-bg-active;\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            > .nav-item > em, > a > em {\r\n                color: $sidebar-icon-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            border-left-color: $sidebar-item-color-active;\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n.sidebar-subnav {\r\n    background-color: $sidebar-bg;\r\n\r\n    > .sidebar-subnav-header {\r\n        color: $sidebar-item-color;\r\n    }\r\n\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            > a, > .nav-item {\r\n                color: $sidebar-icon-color-active;\r\n\r\n                &:after {\r\n                    border-color: $sidebar-bullet-color-active;\r\n                    background-color: $sidebar-bullet-color-active;\r\n                }\r\n\r\n            }\r\n\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n/* ========================================================================\r\n   Component: offsidebar\r\n ========================================================================== */\r\n.offsidebar {\r\n    border-left: 1px solid $offsidebar-border-color;\r\n    background-color: $offsidebar-bg;\r\n    color: $offsidebar-color;\r\n}\r\n","\r\n// Cutoms Gray colors for theme\r\n$gray-darker:           #232735;\r\n$gray-dark:             #3a3f51;\r\n$gray:                  #dde6e9;\r\n$gray-light:            #e4eaec;\r\n$gray-lighter:          #edf1f2;\r\n\r\n// Custom brand colors for theme\r\n$inverse:               #131e26;\r\n$purple:                #7266ba;\r\n$pink:                  #f532e5;\r\n$yellow:                #fad732;\r\n$green:                 #37bc9b;\r\n\r\n$primary:               #5d9cec;\r\n$secondary:             #fff;\r\n$success:               #27c24c;\r\n$info:                  #23b7e5;\r\n$warning:               #ff902b;\r\n$danger:                #f05050;\r\n$dark:                  #3a3f51;\r\n\r\n// Custom color variants\r\n$amountOfLight: 10%;\r\n\r\n$primary-light:         lighten($primary, $amountOfLight);\r\n$success-light:         lighten($success, $amountOfLight);\r\n$info-light:            lighten($info, $amountOfLight);\r\n$warning-light:         lighten($warning, $amountOfLight);\r\n$danger-light:          lighten($danger, $amountOfLight);\r\n$inverse-light:         lighten($inverse, $amountOfLight);\r\n$green-light:           lighten($green, $amountOfLight);\r\n$pink-light:            lighten($pink, $amountOfLight);\r\n$purple-light:          lighten($purple, $amountOfLight);\r\n$yellow-light:          lighten($yellow, $amountOfLight);\r\n$primary-dark:          darken($primary, $amountOfLight);\r\n$success-dark:          darken($success, $amountOfLight);\r\n$info-dark:             darken($info, $amountOfLight);\r\n$warning-dark:          darken($warning, $amountOfLight);\r\n$danger-dark:           darken($danger, $amountOfLight);\r\n$inverse-dark:          darken($inverse, $amountOfLight);\r\n$green-dark:            darken($green, $amountOfLight);\r\n$pink-dark:             darken($pink, $amountOfLight);\r\n$purple-dark:           darken($purple, $amountOfLight);\r\n$yellow-dark:           darken($yellow, $amountOfLight);\r\n\r\n// Theme variables\r\n\r\n// used for sidebars and content spacing\r\n$navbar-height:                    55px;\r\n\r\n// Button secondary redefinition style for theme\r\n$btn-secondary-color:              #333;\r\n$btn-secondary-bg:                 #fff;\r\n$btn-secondary-border:             #eaeaea;\r\n\r\n// Top Border color for custom default cards (.card-default)\r\n$card-default-border-color:        #cfdbe2;\r\n\r\n\r\n// ---------------------\r\n// Utilities variables\r\n// ---------------------\r\n\r\n$text-alpha:            rgba(255,255,255,.5);\r\n$text-alpha-inverse:    rgba(0,0,0,.5);\r\n\r\n$font-size-base:        1rem;\r\n$text-sm:               $font-size-base * 0.74375;\r\n$text-md:               $font-size-base * 1.6625;\r\n$text-lg:               $font-size-base * 2.625;\r\n\r\n$border-color:          rgba(0,0,0,.12);\r\n\r\n$wd-xxs:                60px;\r\n$wd-xs:                 90px;\r\n$wd-sm:                 150px;\r\n$wd-sd:                 200px; // sd == standard\r\n$wd-md:                 240px;\r\n$wd-lg:                 280px;\r\n$wd-xl:                 320px;\r\n$wd-xxl:                360px;\r\n$wd-wide:               100%;\r\n$wd-auto:               auto;\r\n$wd-zero:               0;\r\n\r\n\r\n// ---------------------\r\n// Bootstrap 4 Variables Override\r\n// ---------------------\r\n\r\n// Color system\r\n\r\n$colors: (\r\n    \"purple\":     $purple,\r\n    \"pink\":       $pink,\r\n    \"yellow\":     $yellow,\r\n    \"green\":      $green,\r\n    \"primary\":    $primary,\r\n    \"success\":    $success,\r\n    \"info\":       $info,\r\n    \"warning\":    $warning,\r\n    \"danger\":     $danger,\r\n    'inverse':    $inverse,\r\n\r\n    'primary-light': $primary-light,\r\n    'primary-dark':  $primary-dark,\r\n    'success-light': $success-light,\r\n    'success-dark':  $success-dark,\r\n    'info-light':    $info-light,\r\n    'info-dark':     $info-dark,\r\n    'warning-light': $warning-light,\r\n    'warning-dark':  $warning-dark,\r\n    'danger-light':  $danger-light,\r\n    'danger-dark':   $danger-dark,\r\n    'green-light':   $green-light,\r\n    'green-dark':    $green-dark,\r\n    'pink-light':    $pink-light,\r\n    'pink-dark':     $pink-dark,\r\n    'purple-light':  $purple-light,\r\n    'purple-dark':   $purple-dark,\r\n    'inverse-light': $inverse-light,\r\n    'inverse-dark':  $inverse-dark,\r\n    'yellow-light':  $yellow-light,\r\n    'yellow-dark':   $yellow-dark,\r\n);\r\n\r\n\r\n$theme-colors: (\r\n  \"primary\":    $primary,\r\n  \"secondary\":  $secondary,\r\n  \"success\":    $success,\r\n  \"info\":       $info,\r\n  \"warning\":    $warning,\r\n  \"danger\":     $danger\r\n);\r\n\r\n// Body\r\n\r\n$body-bg:                   #f5f7fa;\r\n$body-color:                #656565;\r\n\r\n$border-radius:               .25rem;\r\n$border-radius-lg:            .375rem;\r\n\r\n$line-height-base:            1.528571429;\r\n\r\n$headings-line-height:        1.1;\r\n\r\n$text-muted:                  #909FA7;\r\n\r\n// Tables\r\n\r\n$table-accent-bg:             #fafbfc;\r\n$table-hover-bg:              #fafbfc;\r\n\r\n$table-border-color:          #eee;\r\n\r\n// Buttons + Forms\r\n\r\n$input-btn-padding-y:         .375rem;\r\n$input-btn-padding-x:         1rem;\r\n\r\n$input-btn-padding-y-sm:      .3125rem;\r\n$input-btn-padding-x-sm:      .625rem;\r\n\r\n$input-btn-padding-y-lg:      .625rem;\r\n$input-btn-padding-x-lg:      1.25rem;\r\n\r\n$input-height:                2.1875rem; // 35px\r\n\r\n// Forms\r\n\r\n$input-disabled-bg:                     $gray-lighter;\r\n$input-border-color:                    $gray;\r\n$input-focus-border-color:              #66afe9;\r\n$input-placeholder-color:               #b7bac9;\r\n\r\n$form-feedback-icon-valid:              none;\r\n$form-feedback-icon-invalid:            none;\r\n\r\n$custom-control-indicator-active-bg:    lighten($primary, 25%);\r\n\r\n// Dropdowns\r\n\r\n$dropdown-border-color:             #e1e1e1;\r\n\r\n// Navs\r\n\r\n$nav-tabs-link-active-bg:           #fff;\r\n\r\n// Jumbotron\r\n\r\n$jumbotron-bg:                      #fcfcfc;\r\n\r\n// List group\r\n\r\n$list-group-border-color:           #e4eaec;\r\n\r\n// Image thumbnails\r\n\r\n$thumbnail-padding:                 .125rem;\r\n\r\n\r\n// Breadcrumbs\r\n\r\n$breadcrumb-bg:                     #fafafa;\r\n$breadcrumb-divider-color:          #c1c2c3;\r\n$breadcrumb-active-color:           $body-color;\r\n","// Gradients\r\n\r\n@mixin gradient-bg($color) {\r\n  @if $enable-gradients {\r\n    background: $color linear-gradient(180deg, mix($body-bg, $color, 15%), $color) repeat-x;\r\n  } @else {\r\n    background-color: $color;\r\n  }\r\n}\r\n\r\n// Horizontal gradient, from left to right\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-x($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to right, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n// Vertical gradient, from top to bottom\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-y($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to bottom, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n@mixin gradient-directional($start-color: $gray-700, $end-color: $gray-800, $deg: 45deg) {\r\n  background-image: linear-gradient($deg, $start-color, $end-color);\r\n  background-repeat: repeat-x;\r\n}\r\n@mixin gradient-x-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient(to right, $start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-y-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient($start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-radial($inner-color: $gray-700, $outer-color: $gray-800) {\r\n  background-image: radial-gradient(circle, $inner-color, $outer-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-striped($color: rgba($white, .15), $angle: 45deg) {\r\n  background-image: linear-gradient($angle, $color 25%, transparent 25%, transparent 50%, $color 50%, $color 75%, transparent 75%, transparent);\r\n}\r\n","// Breakpoint viewport sizes and media queries.\r\n//\r\n// Breakpoints are defined as a map of (name: minimum width), order from small to large:\r\n//\r\n//    (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px)\r\n//\r\n// The map defined in the `$grid-breakpoints` global variable is used as the `$breakpoints` argument by default.\r\n\r\n// Name of the next breakpoint, or null for the last breakpoint.\r\n//\r\n//    >> breakpoint-next(sm)\r\n//    md\r\n//    >> breakpoint-next(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    md\r\n//    >> breakpoint-next(sm, $breakpoint-names: (xs sm md lg xl))\r\n//    md\r\n@function breakpoint-next($name, $breakpoints: $grid-breakpoints, $breakpoint-names: map-keys($breakpoints)) {\r\n  $n: index($breakpoint-names, $name);\r\n  @return if($n != null and $n < length($breakpoint-names), nth($breakpoint-names, $n + 1), null);\r\n}\r\n\r\n// Minimum breakpoint width. Null for the smallest (first) breakpoint.\r\n//\r\n//    >> breakpoint-min(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    576px\r\n@function breakpoint-min($name, $breakpoints: $grid-breakpoints) {\r\n  $min: map-get($breakpoints, $name);\r\n  @return if($min != 0, $min, null);\r\n}\r\n\r\n// Maximum breakpoint width. Null for the largest (last) breakpoint.\r\n// The maximum value is calculated as the minimum of the next one less 0.02px\r\n// to work around the limitations of `min-` and `max-` prefixes and viewports with fractional widths.\r\n// See https://www.w3.org/TR/mediaqueries-4/#mq-min-max\r\n// Uses 0.02px rather than 0.01px to work around a current rounding bug in Safari.\r\n// See https://bugs.webkit.org/show_bug.cgi?id=178261\r\n//\r\n//    >> breakpoint-max(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    767.98px\r\n@function breakpoint-max($name, $breakpoints: $grid-breakpoints) {\r\n  $next: breakpoint-next($name, $breakpoints);\r\n  @return if($next, breakpoint-min($next, $breakpoints) - .02, null);\r\n}\r\n\r\n// Returns a blank string if smallest breakpoint, otherwise returns the name with a dash in front.\r\n// Useful for making responsive utilities.\r\n//\r\n//    >> breakpoint-infix(xs, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"\"  (Returns a blank string)\r\n//    >> breakpoint-infix(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"-sm\"\r\n@function breakpoint-infix($name, $breakpoints: $grid-breakpoints) {\r\n  @return if(breakpoint-min($name, $breakpoints) == null, \"\", \"-#{$name}\");\r\n}\r\n\r\n// Media of at least the minimum breakpoint width. No query for the smallest breakpoint.\r\n// Makes the @content apply to the given breakpoint and wider.\r\n@mixin media-breakpoint-up($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  @if $min {\r\n    @media (min-width: $min) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media of at most the maximum breakpoint width. No query for the largest breakpoint.\r\n// Makes the @content apply to the given breakpoint and narrower.\r\n@mixin media-breakpoint-down($name, $breakpoints: $grid-breakpoints) {\r\n  $max: breakpoint-max($name, $breakpoints);\r\n  @if $max {\r\n    @media (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media that spans multiple breakpoint widths.\r\n// Makes the @content apply between the min and max breakpoints\r\n@mixin media-breakpoint-between($lower, $upper, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($lower, $breakpoints);\r\n  $max: breakpoint-max($upper, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($lower, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($upper, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n\r\n// Media between the breakpoint's minimum and maximum widths.\r\n// No minimum for the smallest breakpoint, and no maximum for the largest one.\r\n// Makes the @content apply only to the given breakpoint, not viewports any wider or narrower.\r\n@mixin media-breakpoint-only($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  $max: breakpoint-max($name, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n"]} */\";","export class ContactGroup {\r\n    groupId: string;\r\n    groupParentId: string;\r\n    groupName: string;\r\n    groupDescription: string;\r\n    groupSoftwarePackageID: string;\r\n    groupLIMSCompanyCode: string;\r\n    groupActive: string;\r\n    groupPriority: string;\r\n}\r\n\r\nexport class ContactInfo {\r\n    primaryContactMethodType: string;\r\n    primaryContactValue: string;\r\n    status: UserStatus;\r\n    locationID: number;\r\n    contactID: number;\r\n}\r\n\r\nexport class Location {\r\n    locationType: string;\r\n    locationName: string;\r\n    locationAddressLine1: string;\r\n    locationAddressLine2: string;\r\n    locationAddressLine3: string;\r\n    locationCity: string;\r\n    locationProvince: string;\r\n    locationPostalCode: string;\r\n    locationCountry: string;\r\n    locationLatitude: string;\r\n    locationLongitude: string\r\n    locationRemark: string;\r\n}\r\n\r\nexport class LoginModel {\r\n    username: string;\r\n    password: string;\r\n    software: string;\r\n}\r\n\r\nexport class SecurityInfo {\r\n    valid: boolean;\r\n    userType: eUserType;\r\n    firstName: string;\r\n    lastName: string;\r\n    contactGroups: ContactGroup[];\r\n    securityRoles: SecurityRole[];\r\n    securityPrivileges: SecurityPrivilege[];\r\n    contactId: number;\r\n    contactInfo: ContactInfo[];\r\n    decisionMaker: number;\r\n    location: Location;\r\n    employeeId: number;\r\n    inPrivilege: boolean;\r\n    inRole: boolean;\r\n    emailAddress: string;\r\n    employeePhone: string;\r\n    position: string;\r\n}\r\n\r\nexport class SecurityRole {\r\n    id: number;\r\n    roleName: string;\r\n    roleDescription: string;\r\n}\r\n\r\nexport class SecurityPrivilege {\r\n    id: number;\r\n    privilegeName: string;\r\n    privilegeDescription: string;\r\n    securityRoleId: number;\r\n    securityPrivilegeId: number;\r\n    securityRolePrivilegeId: number;\r\n    roleName: string;\r\n    isInherited: boolean;\r\n}\r\n\r\nexport enum eUserType {\r\n    notFound = 0,\r\n    employee = 1,\r\n    externalContact = 2,\r\n    internalExternalContact = 3\r\n}\r\n\r\nexport enum UserStatus {\r\n    awaitingActivation = 1,\r\n    active = 2,\r\n    inactive = 3,\r\n    suspended = 4,\r\n    disabled = 5,\r\n    passwordReset = 6\r\n}\r\n","import { NgModule } from '@angular/core';\r\nimport { BrowserAnimationsModule } from '@angular/platform-browser/animations'; // this is needed!\r\nimport { HttpClientModule, HttpClient } from '@angular/common/http';\r\n\r\nimport { TranslateModule, TranslateLoader } from '@ngx-translate/core';\r\nimport { TranslateHttpLoader } from '@ngx-translate/http-loader';\r\n\r\nimport { AppComponent } from './app.component';\r\nimport { CoreModule } from './core/core.module';\r\nimport { LayoutModule } from './layout/layout.module';\r\nimport { SharedModule } from './shared/shared.module';\r\nimport { RoutesModule } from './routes/routes.module';\r\n\r\n// https://github.com/ocombe/ng2-translate/issues/218\r\nexport function createTranslateLoader(http: HttpClient) {\r\n    return new TranslateHttpLoader(http, './assets/i18n/', '.json');\r\n}\r\n\r\n@NgModule({\r\n    declarations: [\r\n        AppComponent, \r\n    ],\r\n    imports: [\r\n        HttpClientModule,\r\n        BrowserAnimationsModule, // required for ng2-tag-input\r\n        CoreModule,\r\n        LayoutModule,\r\n        SharedModule.forRoot(),\r\n        RoutesModule,\r\n        TranslateModule.forRoot({\r\n            loader: {\r\n                provide: TranslateLoader,\r\n                useFactory: (createTranslateLoader),\r\n                deps: [HttpClient]\r\n            }\r\n        })\r\n    ],\r\n    providers: [],\r\n    bootstrap: [AppComponent]\r\n})\r\n\r\nexport class AppModule {\r\n}\r\n","import { Directive, ElementRef } from '@angular/core';\r\ndeclare var $: any;\r\n\r\n@Directive({\r\n    selector: '[checkAll]'\r\n})\r\nexport class CheckallDirective {\r\n\r\n    constructor(public el: ElementRef) {\r\n        let $element = $(el.nativeElement);\r\n\r\n        $element.on('change', function() {\r\n            let index = $element.index() + 1,\r\n                checkbox = $element.find('input[type=\"checkbox\"]'),\r\n                table = $element.parents('table');\r\n            // Make sure to affect only the correct checkbox column\r\n            table.find('tbody > tr > td:nth-child(' + index + ') input[type=\"checkbox\"]')\r\n                .prop('checked', checkbox[0].checked);\r\n\r\n        });\r\n\r\n    }\r\n\r\n}\r\n","import { Component, OnInit } from '@angular/core';\r\nimport { SettingsService } from '../../../core/settings/settings.service';\r\nimport { FormGroup, FormBuilder, Validators, FormControl } from '@angular/forms';\r\nimport { CustomValidators } from 'ngx-custom-validators';\r\n\r\n@Component({\r\n    selector: 'app-register',\r\n    templateUrl: './register.component.html',\r\n    styleUrls: ['./register.component.scss']\r\n})\r\nexport class RegisterComponent implements OnInit {\r\n\r\n    valForm: FormGroup;\r\n    passwordForm: FormGroup;\r\n\r\n    constructor(public settings: SettingsService, fb: FormBuilder) {\r\n\r\n        let password = new FormControl('', Validators.compose([Validators.required, Validators.pattern('^[a-zA-Z0-9]{6,10}$')]));\r\n        let certainPassword = new FormControl('', [Validators.required, CustomValidators.equalTo(password)]);\r\n\r\n        this.passwordForm = fb.group({\r\n            'password': password,\r\n            'confirmPassword': certainPassword\r\n        });\r\n\r\n        this.valForm = fb.group({\r\n            'email': [null, Validators.compose([Validators.required, CustomValidators.email])],\r\n            'accountagreed': [null, Validators.required],\r\n            'passwordGroup': this.passwordForm\r\n        });\r\n    }\r\n\r\n    submitForm($ev, value: any) {\r\n        $ev.preventDefault();\r\n        for (let c in this.valForm.controls) {\r\n            this.valForm.controls[c].markAsTouched();\r\n        }\r\n        for (let c in this.passwordForm.controls) {\r\n            this.passwordForm.controls[c].markAsTouched();\r\n        }\r\n\r\n        if (this.valForm.valid) {\r\n            console.log('Valid!');\r\n            console.log(value);\r\n        }\r\n    }\r\n\r\n    ngOnInit() {\r\n    }\r\n\r\n}\r\n","<div class=\"wrapper\">\r\n    <div class=\"block-center mt-4 wd-xl\">\r\n        <!-- START card-->\r\n        <div class=\"card card-flat\">\r\n            <div class=\"card-header text-center bg-dark\">\r\n                <a href=\"#\">\r\n                    <img class=\"block-center rounded\" src=\"assets/img/logo/AGAT.logo.air.png\" alt=\"AGAT\" />\r\n                </a>\r\n            </div>\r\n            <div class=\"card-body\">\r\n                <p class=\"text-center py-2\">SIGNUP TO GET INSTANT ACCESS</p>\r\n                <form [formGroup]=\"valForm\" class=\"form-validate mb-3\" role=\"form\" name=\"registerForm\" novalidate=\"\" (submit)=\"submitForm($event, valForm.value)\">\r\n                    <div class=\"form-group\">\r\n                        <label class=\"text-muted mb-1\">Email address</label>\r\n                        <div class=\"input-group with-focus\">\r\n                            <input class=\"form-control border-right-0\" type=\"email\" name=\"account_email\" placeholder=\"Enter email\" autocomplete=\"off\" formControlName=\"email\" required=\"\" />\r\n                            <div class=\"input-group-append\">\r\n                                <span class=\"input-group-text text-muted bg-transparent border-left-0\">\r\n                                    <em class=\"fa fa-envelope\"></em>\r\n                                </span>\r\n                            </div>\r\n                        </div>\r\n                        <div class=\"text-danger\" *ngIf=\"valForm.controls['email'].hasError('required') && (valForm.controls['email'].dirty || valForm.controls['email'].touched)\">This field is required</div>\r\n                        <div class=\"text-danger\" *ngIf=\"valForm.controls['email'].hasError('email') && (valForm.controls['email'].dirty || valForm.controls['email'].touched)\">This field must be a valid email address</div>\r\n                    </div>\r\n                    <div formGroupName=\"passwordGroup\">\r\n                        <div class=\"form-group\">\r\n                            <label class=\"text-muted mb-1\">Password</label>\r\n                            <div class=\"input-group with-focus\">\r\n                                <input class=\"form-control border-right-0\" id=\"id-password\" type=\"password\" name=\"password\" formControlName=\"password\" [formControl]=\"valForm.get('passwordGroup.password')\" />\r\n                                <div class=\"input-group-append\">\r\n                                    <span class=\"input-group-text text-muted bg-transparent border-left-0\">\r\n                                        <em class=\"fa fa-lock\"></em>\r\n                                    </span>\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"text-danger\" *ngIf=\"valForm.get('passwordGroup.password').hasError('required') && (valForm.get('passwordGroup.password').dirty || valForm.get('passwordGroup.password').touched)\">This field is required</div>\r\n                            <div class=\"text-danger\" *ngIf=\"valForm.get('passwordGroup.password').hasError('pattern') && (valForm.get('passwordGroup.password').dirty || valForm.get('passwordGroup.password').touched)\">Input should match 'a-zA-Z0-9' and 6-10 length</div>\r\n                        </div>\r\n                        <div class=\"form-group\">\r\n                            <label class=\"text-muted mb-1\">Retype Password</label>\r\n                            <div class=\"input-group with-focus\">\r\n                                <input class=\"form-control border-right-0\" type=\"password\" name=\"confirmPassword\" formControlName=\"confirmPassword\" [formControl]=\"valForm.get('passwordGroup.confirmPassword')\" />\r\n                                <div class=\"input-group-append\">\r\n                                    <span class=\"input-group-text text-muted bg-transparent border-left-0\">\r\n                                        <em class=\"fa fa-lock\"></em>\r\n                                    </span>\r\n                                </div>\r\n                            </div>\r\n                            <div class=\"text-danger\" *ngIf=\"valForm.get('passwordGroup.confirmPassword').hasError('required') && (valForm.get('passwordGroup.confirmPassword').dirty || valForm.get('passwordGroup.confirmPassword').touched)\">This field is required</div>\r\n                            <div class=\"text-danger\" *ngIf=\"valForm.get('passwordGroup.confirmPassword').hasError('equalTo')\">Password does not match</div>\r\n                        </div>\r\n                    </div>\r\n                    <div class=\"clearfix\">\r\n                        <div class=\"checkbox c-checkbox float-left mt0\">\r\n                            <label>\r\n                                <input type=\"checkbox\" required=\"\" name=\"account_agreed\" formControlName=\"accountagreed\" />\r\n                                <span class=\"fa fa-check\"></span>I agree with the <a href=\"#\">terms</a>\r\n                            </label>\r\n                        </div>\r\n                    </div>\r\n                    <span class=\"text-danger\" *ngIf=\"valForm.controls['accountagreed'].hasError('required') && (valForm.controls['accountagreed'].dirty || valForm.controls['accountagreed'].touched)\">You must agree the terms</span>\r\n                    <button class=\"btn btn-block btn-primary mt-3\" type=\"submit\">Create account</button>\r\n                </form>\r\n                <p class=\"pt-3 text-center\">Have an account?</p>\r\n                <a class=\"btn btn-block btn-secondary\" [routerLink]=\"'/login'\">Signup</a>\r\n            </div>\r\n        </div>\r\n        <!-- END card-->\r\n        <div class=\"p-3 text-center\">\r\n            <span>&copy;</span>\r\n            <span>{{ settings.getAppSetting('year') }}</span>\r\n            <span class=\"mx-2\">-</span>\r\n            <span>{{ settings.getAppSetting('name') }}</span>\r\n            <br/>\r\n            <span>{{ settings.getAppSetting('description') }}</span>\r\n        </div>\r\n    </div>\r\n</div>\r\n","import { Component, OnInit } from '@angular/core';\r\nimport { SettingsService } from '../../../core/settings/settings.service';\r\n\r\n@Component({\r\n  selector: 'app-error500',\r\n  templateUrl: './error500.component.html',\r\n  styleUrls: ['./error500.component.scss']\r\n})\r\nexport class Error500Component implements OnInit {\r\n\r\n  constructor(public settings: SettingsService) { }\r\n\r\n  ngOnInit() {\r\n  }\r\n\r\n}\r\n","<div class=\"wrapper\">\r\n    <div class=\"abs-center wd-xl\">\r\n        <!-- START card-->\r\n        <div class=\"text-center mb-4\">\r\n            <div class=\"text-lg mb-3\">\r\n                <em class=\"fa fa-wrench fa-2x text-muted\"></em>\r\n            </div>\r\n            <div class=\"text-lg mb-3\">500</div>\r\n            <p class=\"lead m-0\">Oh! Something went wrong :(</p>\r\n            <p>Don't worry, we're now checking this.</p>\r\n            <p>In the meantime, please try one of those links below or come back in a moment</p>\r\n        </div>\r\n        <ul class=\"list-inline text-center text-sm mb-4\">\r\n            <li class=\"list-inline-item\">\r\n                <a class=\"text-muted\" [routerLink]=\"'/home'\">Go to App</a>\r\n            </li>\r\n            <li class=\"text-muted list-inline-item\">|</li>\r\n            <li class=\"list-inline-item\">\r\n                <a class=\"text-muted\" [routerLink]=\"'/login'\">Login</a>\r\n            </li>\r\n            <li class=\"text-muted list-inline-item\">|</li>\r\n            <li class=\"list-inline-item\">\r\n                <a class=\"text-muted\" [routerLink]=\"'/register'\">Register</a>\r\n            </li>\r\n        </ul>\r\n        <div class=\"p-3 text-center\">\r\n            <span>&copy;</span>\r\n            <span>{{ settings.getAppSetting('year') }}</span>\r\n            <span class=\"mx-2\">-</span>\r\n            <span>{{ settings.getAppSetting('name') }}</span>\r\n            <br/>\r\n            <span>{{ settings.getAppSetting('description') }}</span>\r\n        </div>\r\n    </div>\r\n</div>\r\n","export default \"/* ========================================================================\\n   Component: layout\\n ========================================================================== */\\nbody, .wrapper .section-container {\\n  background-color: #f5f7fa;\\n}\\n.wrapper .aside-container {\\n  background-color: #fff;\\n}\\n/* ========================================================================\\n   Component: top-navbar\\n ========================================================================== */\\n.topnavbar {\\n  background-color: #23b7e5;\\n  background-image: linear-gradient(to right, #23b7e5 0%, #51c6ea 100%);\\n  background-repeat: repeat-x;\\n}\\n@media (min-width: 992px) {\\n  .topnavbar .navbar-nav > .nav-item.show > .nav-link, .topnavbar .navbar-nav > .nav-item.show > .nav-link:hover, .topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n    box-shadow: 0 -3px 0 #19a5d1 inset;\\n  }\\n}\\n.topnavbar .navbar-nav > .nav-item > .navbar-text {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link:hover, .topnavbar .navbar-nav > .nav-item > .nav-link:focus,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:hover,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n  color: #117391;\\n}\\n.topnavbar .dropdown-item.active, .topnavbar .dropdown-item:active {\\n  background-color: #23b7e5;\\n}\\n/* ========================================================================\\n   Component: sidebar\\n ========================================================================== */\\n.sidebar {\\n  background-color: #fff;\\n}\\n.sidebar .nav-heading {\\n  color: #919DA8;\\n}\\n.sidebar-nav > li > a, .sidebar-nav > li > .nav-item {\\n  color: #515253;\\n}\\n.sidebar-nav > li > a:focus, .sidebar-nav > li > a:hover, .sidebar-nav > li > .nav-item:focus, .sidebar-nav > li > .nav-item:hover {\\n  color: #23b7e5;\\n}\\n.sidebar-nav > li > a > em, .sidebar-nav > li > .nav-item > em {\\n  color: inherits;\\n}\\n.sidebar-nav > li.active, .sidebar-nav > li.active > a, .sidebar-nav > li.active > .nav-item, .sidebar-nav > li.active .sidebar-nav, .sidebar-nav > li.open, .sidebar-nav > li.open > a, .sidebar-nav > li.open > .nav-item, .sidebar-nav > li.open .sidebar-nav {\\n  background-color: #fcfcfc;\\n  color: #23b7e5;\\n}\\n.sidebar-nav > li.active > .nav-item > em, .sidebar-nav > li.active > a > em, .sidebar-nav > li.open > .nav-item > em, .sidebar-nav > li.open > a > em {\\n  color: #23b7e5;\\n}\\n.sidebar-nav > li.active {\\n  border-left-color: #23b7e5;\\n}\\n.sidebar-subnav {\\n  background-color: #fff;\\n}\\n.sidebar-subnav > .sidebar-subnav-header {\\n  color: #515253;\\n}\\n.sidebar-subnav > li > a, .sidebar-subnav > li > .nav-item {\\n  color: #515253;\\n}\\n.sidebar-subnav > li > a:focus, .sidebar-subnav > li > a:hover, .sidebar-subnav > li > .nav-item:focus, .sidebar-subnav > li > .nav-item:hover {\\n  color: #23b7e5;\\n}\\n.sidebar-subnav > li.active > a, .sidebar-subnav > li.active > .nav-item {\\n  color: #23b7e5;\\n}\\n.sidebar-subnav > li.active > a:after, .sidebar-subnav > li.active > .nav-item:after {\\n  border-color: #23b7e5;\\n  background-color: #23b7e5;\\n}\\n/* ========================================================================\\n   Component: offsidebar\\n ========================================================================== */\\n.offsidebar {\\n  border-left: 1px solid greyscale(#cccccc);\\n  background-color: #fff;\\n  color: #656565;\\n}\\n/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/app/shared/style/theme/theme-a.scss","src/app/shared/style/app/variables.scss","src/app/shared/style/bootstrap/mixins/_gradients.scss","src/app/shared/style/bootstrap/mixins/_breakpoints.scss"],"names":[],"mappings":"AA8CA;;6EAAA;AAGA;EACI,yBAzC4B;AAJhC;AAgDA;EACI,sBA5C4B;AADhC;AAgDA;;6EAAA;AAGA;EACI,yBC3CoB;ECJtB,qEAAA;EACA,2BAAA;AFGF;AG0CI;EHMQ;IACI,kCAAA;EA7Cd;AACF;AAiDI;EACI,WAtDwB;AAOhC;AAkDI;;EAEI,WA3DwB;AAWhC;AAiDQ;;;EACI,cA5DoB;AAehC;AAiDI;EACI,yBCnEgB;ADoBxB;AAmDA;;6EAAA;AAGA;EACI,sBAnF4B;AAmChC;AAkDI;EACI,cA5D0B;AAYlC;AAuDQ;EACI,cA9EsB;AA0BlC;AAsDY;EACI,cCzFQ;ADqCxB;AAwDY;EACI,eAlFkB;AA4BlC;AA6DY;EACI,yBA5FkB;EA6FlB,cCvGQ;AD4CxB;AA8DY;EACI,cC3GQ;AD+CxB;AAiEQ;EACI,0BCjHY;ADkDxB;AAsEA;EACI,sBAjI4B;AA8DhC;AAqEI;EACI,cApH0B;AAiDlC;AAuEQ;EACI,cAzHsB;AAoDlC;AAuEY;EACI,cCpIQ;AD+DxB;AA2EY;EACI,cC3IQ;ADkExB;AA2EgB;EACI,qBC9II;ED+IJ,yBC/II;ADsExB;AAoFA;;6EAAA;AAGA;EACI,yCAAA;EACA,sBAxIsB;EAyItB,cCrCwB;AD5C5B","file":"src/app/shared/style/theme/theme-a.scss","sourcesContent":["// Bootstrap\r\n@import \"../bootstrap/functions\";\r\n@import \"../bootstrap/variables\";\r\n@import \"../bootstrap/mixins\";\r\n@import '../app/variables';\r\n\r\n\r\n// LAYOUT\r\n\r\n$content-bg:                    #f5f7fa;\r\n$aside-bg:                      #fff;\r\n\r\n// NAVBAR TOP\r\n\r\n$nav-top-bg:                    $info;\r\n$nav-top-bg-start:              $nav-top-bg;\r\n$nav-top-bg-end:                $info-light;\r\n$nav-header-bg:                 transparent;\r\n\r\n$nav-top-item:                  #fff;\r\n$nav-top-item-active:           darken($nav-top-bg, 20%);\r\n\r\n// SIDEBAR\r\n\r\n$sidebar-bg:                      $aside-bg;\r\n\r\n$sidebar-item-color:              #515253;\r\n$sidebar-item-color-active:       $nav-top-bg;\r\n$sidebar-item-bg-active:          darken($sidebar-bg, 1%);\r\n\r\n$sidebar-icon-color:              inherits;\r\n$sidebar-icon-color-active:       $nav-top-bg;\r\n\r\n$sidebar-bullet-color:            rgba(0,0,0,.25);\r\n$sidebar-bullet-color-active:     $sidebar-icon-color-active;\r\n\r\n$sidebar-heading-color:           #919DA8;\r\n$sidebar-label-color:             $sidebar-item-color;\r\n\r\n// OFFSIDEBAR\r\n\r\n$offsidebar-bg:           #fff;\r\n$offsidebar-border-color: greyscale(darken($offsidebar-bg, 20%));\r\n$offsidebar-color:        $body-color;\r\n\r\n\r\n/* ========================================================================\r\n   Component: layout\r\n ========================================================================== */\r\nbody, .wrapper .section-container {\r\n    background-color: $content-bg;\r\n}\r\n\r\n.wrapper .aside-container {\r\n    background-color: $aside-bg;\r\n}\r\n\r\n/* ========================================================================\r\n   Component: top-navbar\r\n ========================================================================== */\r\n.topnavbar {\r\n    background-color: $nav-top-bg;\r\n    @include gradient-x($nav-top-bg-start, $nav-top-bg-end);\r\n\r\n    @include media-breakpoint-up(lg) {\r\n        .navbar-nav > .nav-item.show > .nav-link {\r\n            &, &:hover, &:focus {\r\n                box-shadow: 0 -3px 0 darken($nav-top-bg, 6%) inset;\r\n            }\r\n        }\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .navbar-text {\r\n        color: $nav-top-item;\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .nav-link,\r\n    .navbar-nav > .nav-item.show > .nav-link {\r\n        color: $nav-top-item;\r\n        &:hover, &:focus {\r\n            color: $nav-top-item-active;\r\n        }\r\n    }\r\n\r\n    .dropdown-item.active, .dropdown-item:active {\r\n        background-color: $nav-top-bg;\r\n    }\r\n}\r\n\r\n/* ========================================================================\r\n   Component: sidebar\r\n ========================================================================== */\r\n.sidebar {\r\n    background-color: $sidebar-bg;\r\n\r\n    .nav-heading {\r\n        color: $sidebar-heading-color;\r\n    }\r\n}\r\n\r\n// Items\r\n.sidebar-nav {\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            // Item icon\r\n            > em {\r\n                color: $sidebar-icon-color;\r\n            }\r\n\r\n        }\r\n\r\n        // Active item state\r\n        &.active, &.open {\r\n            &, > a, > .nav-item, .sidebar-nav {\r\n                background-color: $sidebar-item-bg-active;\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            > .nav-item > em, > a > em {\r\n                color: $sidebar-icon-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            border-left-color: $sidebar-item-color-active;\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n.sidebar-subnav {\r\n    background-color: $sidebar-bg;\r\n\r\n    > .sidebar-subnav-header {\r\n        color: $sidebar-item-color;\r\n    }\r\n\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            > a, > .nav-item {\r\n                color: $sidebar-icon-color-active;\r\n\r\n                &:after {\r\n                    border-color: $sidebar-bullet-color-active;\r\n                    background-color: $sidebar-bullet-color-active;\r\n                }\r\n\r\n            }\r\n\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n/* ========================================================================\r\n   Component: offsidebar\r\n ========================================================================== */\r\n.offsidebar {\r\n    border-left: 1px solid $offsidebar-border-color;\r\n    background-color: $offsidebar-bg;\r\n    color: $offsidebar-color;\r\n}\r\n","\r\n// Cutoms Gray colors for theme\r\n$gray-darker:           #232735;\r\n$gray-dark:             #3a3f51;\r\n$gray:                  #dde6e9;\r\n$gray-light:            #e4eaec;\r\n$gray-lighter:          #edf1f2;\r\n\r\n// Custom brand colors for theme\r\n$inverse:               #131e26;\r\n$purple:                #7266ba;\r\n$pink:                  #f532e5;\r\n$yellow:                #fad732;\r\n$green:                 #37bc9b;\r\n\r\n$primary:               #5d9cec;\r\n$secondary:             #fff;\r\n$success:               #27c24c;\r\n$info:                  #23b7e5;\r\n$warning:               #ff902b;\r\n$danger:                #f05050;\r\n$dark:                  #3a3f51;\r\n\r\n// Custom color variants\r\n$amountOfLight: 10%;\r\n\r\n$primary-light:         lighten($primary, $amountOfLight);\r\n$success-light:         lighten($success, $amountOfLight);\r\n$info-light:            lighten($info, $amountOfLight);\r\n$warning-light:         lighten($warning, $amountOfLight);\r\n$danger-light:          lighten($danger, $amountOfLight);\r\n$inverse-light:         lighten($inverse, $amountOfLight);\r\n$green-light:           lighten($green, $amountOfLight);\r\n$pink-light:            lighten($pink, $amountOfLight);\r\n$purple-light:          lighten($purple, $amountOfLight);\r\n$yellow-light:          lighten($yellow, $amountOfLight);\r\n$primary-dark:          darken($primary, $amountOfLight);\r\n$success-dark:          darken($success, $amountOfLight);\r\n$info-dark:             darken($info, $amountOfLight);\r\n$warning-dark:          darken($warning, $amountOfLight);\r\n$danger-dark:           darken($danger, $amountOfLight);\r\n$inverse-dark:          darken($inverse, $amountOfLight);\r\n$green-dark:            darken($green, $amountOfLight);\r\n$pink-dark:             darken($pink, $amountOfLight);\r\n$purple-dark:           darken($purple, $amountOfLight);\r\n$yellow-dark:           darken($yellow, $amountOfLight);\r\n\r\n// Theme variables\r\n\r\n// used for sidebars and content spacing\r\n$navbar-height:                    55px;\r\n\r\n// Button secondary redefinition style for theme\r\n$btn-secondary-color:              #333;\r\n$btn-secondary-bg:                 #fff;\r\n$btn-secondary-border:             #eaeaea;\r\n\r\n// Top Border color for custom default cards (.card-default)\r\n$card-default-border-color:        #cfdbe2;\r\n\r\n\r\n// ---------------------\r\n// Utilities variables\r\n// ---------------------\r\n\r\n$text-alpha:            rgba(255,255,255,.5);\r\n$text-alpha-inverse:    rgba(0,0,0,.5);\r\n\r\n$font-size-base:        1rem;\r\n$text-sm:               $font-size-base * 0.74375;\r\n$text-md:               $font-size-base * 1.6625;\r\n$text-lg:               $font-size-base * 2.625;\r\n\r\n$border-color:          rgba(0,0,0,.12);\r\n\r\n$wd-xxs:                60px;\r\n$wd-xs:                 90px;\r\n$wd-sm:                 150px;\r\n$wd-sd:                 200px; // sd == standard\r\n$wd-md:                 240px;\r\n$wd-lg:                 280px;\r\n$wd-xl:                 320px;\r\n$wd-xxl:                360px;\r\n$wd-wide:               100%;\r\n$wd-auto:               auto;\r\n$wd-zero:               0;\r\n\r\n\r\n// ---------------------\r\n// Bootstrap 4 Variables Override\r\n// ---------------------\r\n\r\n// Color system\r\n\r\n$colors: (\r\n    \"purple\":     $purple,\r\n    \"pink\":       $pink,\r\n    \"yellow\":     $yellow,\r\n    \"green\":      $green,\r\n    \"primary\":    $primary,\r\n    \"success\":    $success,\r\n    \"info\":       $info,\r\n    \"warning\":    $warning,\r\n    \"danger\":     $danger,\r\n    'inverse':    $inverse,\r\n\r\n    'primary-light': $primary-light,\r\n    'primary-dark':  $primary-dark,\r\n    'success-light': $success-light,\r\n    'success-dark':  $success-dark,\r\n    'info-light':    $info-light,\r\n    'info-dark':     $info-dark,\r\n    'warning-light': $warning-light,\r\n    'warning-dark':  $warning-dark,\r\n    'danger-light':  $danger-light,\r\n    'danger-dark':   $danger-dark,\r\n    'green-light':   $green-light,\r\n    'green-dark':    $green-dark,\r\n    'pink-light':    $pink-light,\r\n    'pink-dark':     $pink-dark,\r\n    'purple-light':  $purple-light,\r\n    'purple-dark':   $purple-dark,\r\n    'inverse-light': $inverse-light,\r\n    'inverse-dark':  $inverse-dark,\r\n    'yellow-light':  $yellow-light,\r\n    'yellow-dark':   $yellow-dark,\r\n);\r\n\r\n\r\n$theme-colors: (\r\n  \"primary\":    $primary,\r\n  \"secondary\":  $secondary,\r\n  \"success\":    $success,\r\n  \"info\":       $info,\r\n  \"warning\":    $warning,\r\n  \"danger\":     $danger\r\n);\r\n\r\n// Body\r\n\r\n$body-bg:                   #f5f7fa;\r\n$body-color:                #656565;\r\n\r\n$border-radius:               .25rem;\r\n$border-radius-lg:            .375rem;\r\n\r\n$line-height-base:            1.528571429;\r\n\r\n$headings-line-height:        1.1;\r\n\r\n$text-muted:                  #909FA7;\r\n\r\n// Tables\r\n\r\n$table-accent-bg:             #fafbfc;\r\n$table-hover-bg:              #fafbfc;\r\n\r\n$table-border-color:          #eee;\r\n\r\n// Buttons + Forms\r\n\r\n$input-btn-padding-y:         .375rem;\r\n$input-btn-padding-x:         1rem;\r\n\r\n$input-btn-padding-y-sm:      .3125rem;\r\n$input-btn-padding-x-sm:      .625rem;\r\n\r\n$input-btn-padding-y-lg:      .625rem;\r\n$input-btn-padding-x-lg:      1.25rem;\r\n\r\n$input-height:                2.1875rem; // 35px\r\n\r\n// Forms\r\n\r\n$input-disabled-bg:                     $gray-lighter;\r\n$input-border-color:                    $gray;\r\n$input-focus-border-color:              #66afe9;\r\n$input-placeholder-color:               #b7bac9;\r\n\r\n$form-feedback-icon-valid:              none;\r\n$form-feedback-icon-invalid:            none;\r\n\r\n$custom-control-indicator-active-bg:    lighten($primary, 25%);\r\n\r\n// Dropdowns\r\n\r\n$dropdown-border-color:             #e1e1e1;\r\n\r\n// Navs\r\n\r\n$nav-tabs-link-active-bg:           #fff;\r\n\r\n// Jumbotron\r\n\r\n$jumbotron-bg:                      #fcfcfc;\r\n\r\n// List group\r\n\r\n$list-group-border-color:           #e4eaec;\r\n\r\n// Image thumbnails\r\n\r\n$thumbnail-padding:                 .125rem;\r\n\r\n\r\n// Breadcrumbs\r\n\r\n$breadcrumb-bg:                     #fafafa;\r\n$breadcrumb-divider-color:          #c1c2c3;\r\n$breadcrumb-active-color:           $body-color;\r\n","// Gradients\r\n\r\n@mixin gradient-bg($color) {\r\n  @if $enable-gradients {\r\n    background: $color linear-gradient(180deg, mix($body-bg, $color, 15%), $color) repeat-x;\r\n  } @else {\r\n    background-color: $color;\r\n  }\r\n}\r\n\r\n// Horizontal gradient, from left to right\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-x($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to right, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n// Vertical gradient, from top to bottom\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-y($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to bottom, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n@mixin gradient-directional($start-color: $gray-700, $end-color: $gray-800, $deg: 45deg) {\r\n  background-image: linear-gradient($deg, $start-color, $end-color);\r\n  background-repeat: repeat-x;\r\n}\r\n@mixin gradient-x-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient(to right, $start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-y-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient($start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-radial($inner-color: $gray-700, $outer-color: $gray-800) {\r\n  background-image: radial-gradient(circle, $inner-color, $outer-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-striped($color: rgba($white, .15), $angle: 45deg) {\r\n  background-image: linear-gradient($angle, $color 25%, transparent 25%, transparent 50%, $color 50%, $color 75%, transparent 75%, transparent);\r\n}\r\n","// Breakpoint viewport sizes and media queries.\r\n//\r\n// Breakpoints are defined as a map of (name: minimum width), order from small to large:\r\n//\r\n//    (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px)\r\n//\r\n// The map defined in the `$grid-breakpoints` global variable is used as the `$breakpoints` argument by default.\r\n\r\n// Name of the next breakpoint, or null for the last breakpoint.\r\n//\r\n//    >> breakpoint-next(sm)\r\n//    md\r\n//    >> breakpoint-next(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    md\r\n//    >> breakpoint-next(sm, $breakpoint-names: (xs sm md lg xl))\r\n//    md\r\n@function breakpoint-next($name, $breakpoints: $grid-breakpoints, $breakpoint-names: map-keys($breakpoints)) {\r\n  $n: index($breakpoint-names, $name);\r\n  @return if($n != null and $n < length($breakpoint-names), nth($breakpoint-names, $n + 1), null);\r\n}\r\n\r\n// Minimum breakpoint width. Null for the smallest (first) breakpoint.\r\n//\r\n//    >> breakpoint-min(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    576px\r\n@function breakpoint-min($name, $breakpoints: $grid-breakpoints) {\r\n  $min: map-get($breakpoints, $name);\r\n  @return if($min != 0, $min, null);\r\n}\r\n\r\n// Maximum breakpoint width. Null for the largest (last) breakpoint.\r\n// The maximum value is calculated as the minimum of the next one less 0.02px\r\n// to work around the limitations of `min-` and `max-` prefixes and viewports with fractional widths.\r\n// See https://www.w3.org/TR/mediaqueries-4/#mq-min-max\r\n// Uses 0.02px rather than 0.01px to work around a current rounding bug in Safari.\r\n// See https://bugs.webkit.org/show_bug.cgi?id=178261\r\n//\r\n//    >> breakpoint-max(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    767.98px\r\n@function breakpoint-max($name, $breakpoints: $grid-breakpoints) {\r\n  $next: breakpoint-next($name, $breakpoints);\r\n  @return if($next, breakpoint-min($next, $breakpoints) - .02, null);\r\n}\r\n\r\n// Returns a blank string if smallest breakpoint, otherwise returns the name with a dash in front.\r\n// Useful for making responsive utilities.\r\n//\r\n//    >> breakpoint-infix(xs, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"\"  (Returns a blank string)\r\n//    >> breakpoint-infix(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"-sm\"\r\n@function breakpoint-infix($name, $breakpoints: $grid-breakpoints) {\r\n  @return if(breakpoint-min($name, $breakpoints) == null, \"\", \"-#{$name}\");\r\n}\r\n\r\n// Media of at least the minimum breakpoint width. No query for the smallest breakpoint.\r\n// Makes the @content apply to the given breakpoint and wider.\r\n@mixin media-breakpoint-up($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  @if $min {\r\n    @media (min-width: $min) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media of at most the maximum breakpoint width. No query for the largest breakpoint.\r\n// Makes the @content apply to the given breakpoint and narrower.\r\n@mixin media-breakpoint-down($name, $breakpoints: $grid-breakpoints) {\r\n  $max: breakpoint-max($name, $breakpoints);\r\n  @if $max {\r\n    @media (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media that spans multiple breakpoint widths.\r\n// Makes the @content apply between the min and max breakpoints\r\n@mixin media-breakpoint-between($lower, $upper, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($lower, $breakpoints);\r\n  $max: breakpoint-max($upper, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($lower, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($upper, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n\r\n// Media between the breakpoint's minimum and maximum widths.\r\n// No minimum for the smallest breakpoint, and no maximum for the largest one.\r\n// Makes the @content apply only to the given breakpoint, not viewports any wider or narrower.\r\n@mixin media-breakpoint-only($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  $max: breakpoint-max($name, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n"]} */\";","export default \"/* ========================================================================\\n   Component: layout\\n ========================================================================== */\\nbody, .wrapper .section-container {\\n  background-color: #f5f7fa;\\n}\\n.wrapper .aside-container {\\n  background-color: #fff;\\n}\\n/* ========================================================================\\n   Component: top-navbar\\n ========================================================================== */\\n.topnavbar {\\n  background-color: #7266ba;\\n  background-image: linear-gradient(to right, #7266ba 0%, #9289ca 100%);\\n  background-repeat: repeat-x;\\n}\\n@media (min-width: 992px) {\\n  .topnavbar .navbar-nav > .nav-item.show > .nav-link, .topnavbar .navbar-nav > .nav-item.show > .nav-link:hover, .topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n    box-shadow: 0 -3px 0 #5f51b0 inset;\\n  }\\n}\\n.topnavbar .navbar-nav > .nav-item > .navbar-text {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link {\\n  color: #fff;\\n}\\n.topnavbar .navbar-nav > .nav-item > .nav-link:hover, .topnavbar .navbar-nav > .nav-item > .nav-link:focus,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:hover,\\n.topnavbar .navbar-nav > .nav-item.show > .nav-link:focus {\\n  color: #443a80;\\n}\\n.topnavbar .dropdown-item.active, .topnavbar .dropdown-item:active {\\n  background-color: #7266ba;\\n}\\n/* ========================================================================\\n   Component: sidebar\\n ========================================================================== */\\n.sidebar {\\n  background-color: #fff;\\n}\\n.sidebar .nav-heading {\\n  color: #919DA8;\\n}\\n.sidebar-nav > li > a, .sidebar-nav > li > .nav-item {\\n  color: #515253;\\n}\\n.sidebar-nav > li > a:focus, .sidebar-nav > li > a:hover, .sidebar-nav > li > .nav-item:focus, .sidebar-nav > li > .nav-item:hover {\\n  color: #7266ba;\\n}\\n.sidebar-nav > li > a > em, .sidebar-nav > li > .nav-item > em {\\n  color: inherits;\\n}\\n.sidebar-nav > li.active, .sidebar-nav > li.active > a, .sidebar-nav > li.active > .nav-item, .sidebar-nav > li.active .sidebar-nav, .sidebar-nav > li.open, .sidebar-nav > li.open > a, .sidebar-nav > li.open > .nav-item, .sidebar-nav > li.open .sidebar-nav {\\n  background-color: #fcfcfc;\\n  color: #7266ba;\\n}\\n.sidebar-nav > li.active > .nav-item > em, .sidebar-nav > li.active > a > em, .sidebar-nav > li.open > .nav-item > em, .sidebar-nav > li.open > a > em {\\n  color: #7266ba;\\n}\\n.sidebar-nav > li.active {\\n  border-left-color: #7266ba;\\n}\\n.sidebar-subnav {\\n  background-color: #fff;\\n}\\n.sidebar-subnav > .sidebar-subnav-header {\\n  color: #515253;\\n}\\n.sidebar-subnav > li > a, .sidebar-subnav > li > .nav-item {\\n  color: #515253;\\n}\\n.sidebar-subnav > li > a:focus, .sidebar-subnav > li > a:hover, .sidebar-subnav > li > .nav-item:focus, .sidebar-subnav > li > .nav-item:hover {\\n  color: #7266ba;\\n}\\n.sidebar-subnav > li.active > a, .sidebar-subnav > li.active > .nav-item {\\n  color: #7266ba;\\n}\\n.sidebar-subnav > li.active > a:after, .sidebar-subnav > li.active > .nav-item:after {\\n  border-color: #7266ba;\\n  background-color: #7266ba;\\n}\\n/* ========================================================================\\n   Component: offsidebar\\n ========================================================================== */\\n.offsidebar {\\n  border-left: 1px solid greyscale(#cccccc);\\n  background-color: #fff;\\n  color: #656565;\\n}\\n/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["src/app/shared/style/theme/theme-c.scss","src/app/shared/style/app/variables.scss","src/app/shared/style/bootstrap/mixins/_gradients.scss","src/app/shared/style/bootstrap/mixins/_breakpoints.scss"],"names":[],"mappings":"AA8CA;;6EAAA;AAGA;EACI,yBAzC4B;AAJhC;AAgDA;EACI,sBA5C4B;AADhC;AAgDA;;6EAAA;AAGA;EACI,yBCnDoB;ECItB,qEAAA;EACA,2BAAA;AFGF;AG0CI;EHMQ;IACI,kCAAA;EA7Cd;AACF;AAiDI;EACI,WAtDwB;AAOhC;AAkDI;;EAEI,WA3DwB;AAWhC;AAiDQ;;;EACI,cA5DoB;AAehC;AAiDI;EACI,yBC3EgB;AD4BxB;AAmDA;;6EAAA;AAGA;EACI,sBAnF4B;AAmChC;AAkDI;EACI,cA5D0B;AAYlC;AAuDQ;EACI,cA9EsB;AA0BlC;AAsDY;EACI,cCjGQ;AD6CxB;AAwDY;EACI,eAlFkB;AA4BlC;AA6DY;EACI,yBA5FkB;EA6FlB,cC/GQ;ADoDxB;AA8DY;EACI,cCnHQ;ADuDxB;AAiEQ;EACI,0BCzHY;AD0DxB;AAsEA;EACI,sBAjI4B;AA8DhC;AAqEI;EACI,cApH0B;AAiDlC;AAuEQ;EACI,cAzHsB;AAoDlC;AAuEY;EACI,cC5IQ;ADuExB;AA2EY;EACI,cCnJQ;AD0ExB;AA2EgB;EACI,qBCtJI;EDuJJ,yBCvJI;AD8ExB;AAoFA;;6EAAA;AAGA;EACI,yCAAA;EACA,sBAxIsB;EAyItB,cCrCwB;AD5C5B","file":"src/app/shared/style/theme/theme-c.scss","sourcesContent":["// Bootstrap\r\n@import \"../bootstrap/functions\";\r\n@import \"../bootstrap/variables\";\r\n@import \"../bootstrap/mixins\";\r\n@import '../app/variables';\r\n\r\n\r\n// LAYOUT\r\n\r\n$content-bg:                    #f5f7fa;\r\n$aside-bg:                      #fff;\r\n\r\n// NAVBAR TOP\r\n\r\n$nav-top-bg:                    $purple;\r\n$nav-top-bg-start:              $nav-top-bg;\r\n$nav-top-bg-end:                $purple-light;\r\n$nav-header-bg:                 transparent;\r\n\r\n$nav-top-item:                  #fff;\r\n$nav-top-item-active:           darken($nav-top-bg, 20%);\r\n\r\n// SIDEBAR\r\n\r\n$sidebar-bg:                      $aside-bg;\r\n\r\n$sidebar-item-color:              #515253;\r\n$sidebar-item-color-active:       $nav-top-bg;\r\n$sidebar-item-bg-active:          darken($sidebar-bg, 1%);\r\n\r\n$sidebar-icon-color:              inherits;\r\n$sidebar-icon-color-active:       $nav-top-bg;\r\n\r\n$sidebar-bullet-color:            rgba(0,0,0,.25);\r\n$sidebar-bullet-color-active:     $sidebar-icon-color-active;\r\n\r\n$sidebar-heading-color:           #919DA8;\r\n$sidebar-label-color:             $sidebar-item-color;\r\n\r\n// OFFSIDEBAR\r\n\r\n$offsidebar-bg:           #fff;\r\n$offsidebar-border-color: greyscale(darken($offsidebar-bg, 20%));\r\n$offsidebar-color:        $body-color;\r\n\r\n\r\n/* ========================================================================\r\n   Component: layout\r\n ========================================================================== */\r\nbody, .wrapper .section-container {\r\n    background-color: $content-bg;\r\n}\r\n\r\n.wrapper .aside-container {\r\n    background-color: $aside-bg;\r\n}\r\n\r\n/* ========================================================================\r\n   Component: top-navbar\r\n ========================================================================== */\r\n.topnavbar {\r\n    background-color: $nav-top-bg;\r\n    @include gradient-x($nav-top-bg-start, $nav-top-bg-end);\r\n\r\n    @include media-breakpoint-up(lg) {\r\n        .navbar-nav > .nav-item.show > .nav-link {\r\n            &, &:hover, &:focus {\r\n                box-shadow: 0 -3px 0 darken($nav-top-bg, 6%) inset;\r\n            }\r\n        }\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .navbar-text {\r\n        color: $nav-top-item;\r\n    }\r\n\r\n    .navbar-nav > .nav-item > .nav-link,\r\n    .navbar-nav > .nav-item.show > .nav-link {\r\n        color: $nav-top-item;\r\n        &:hover, &:focus {\r\n            color: $nav-top-item-active;\r\n        }\r\n    }\r\n\r\n    .dropdown-item.active, .dropdown-item:active {\r\n        background-color: $nav-top-bg;\r\n    }\r\n}\r\n\r\n/* ========================================================================\r\n   Component: sidebar\r\n ========================================================================== */\r\n.sidebar {\r\n    background-color: $sidebar-bg;\r\n\r\n    .nav-heading {\r\n        color: $sidebar-heading-color;\r\n    }\r\n}\r\n\r\n// Items\r\n.sidebar-nav {\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            // Item icon\r\n            > em {\r\n                color: $sidebar-icon-color;\r\n            }\r\n\r\n        }\r\n\r\n        // Active item state\r\n        &.active, &.open {\r\n            &, > a, > .nav-item, .sidebar-nav {\r\n                background-color: $sidebar-item-bg-active;\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n            > .nav-item > em, > a > em {\r\n                color: $sidebar-icon-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            border-left-color: $sidebar-item-color-active;\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n.sidebar-subnav {\r\n    background-color: $sidebar-bg;\r\n\r\n    > .sidebar-subnav-header {\r\n        color: $sidebar-item-color;\r\n    }\r\n\r\n    > li {\r\n        > a, > .nav-item {\r\n            color: $sidebar-item-color;\r\n\r\n            &:focus, &:hover {\r\n                color: $sidebar-item-color-active;\r\n            }\r\n\r\n        }\r\n\r\n        &.active {\r\n            > a, > .nav-item {\r\n                color: $sidebar-icon-color-active;\r\n\r\n                &:after {\r\n                    border-color: $sidebar-bullet-color-active;\r\n                    background-color: $sidebar-bullet-color-active;\r\n                }\r\n\r\n            }\r\n\r\n        }\r\n\r\n    }\r\n\r\n}\r\n\r\n/* ========================================================================\r\n   Component: offsidebar\r\n ========================================================================== */\r\n.offsidebar {\r\n    border-left: 1px solid $offsidebar-border-color;\r\n    background-color: $offsidebar-bg;\r\n    color: $offsidebar-color;\r\n}\r\n","\r\n// Cutoms Gray colors for theme\r\n$gray-darker:           #232735;\r\n$gray-dark:             #3a3f51;\r\n$gray:                  #dde6e9;\r\n$gray-light:            #e4eaec;\r\n$gray-lighter:          #edf1f2;\r\n\r\n// Custom brand colors for theme\r\n$inverse:               #131e26;\r\n$purple:                #7266ba;\r\n$pink:                  #f532e5;\r\n$yellow:                #fad732;\r\n$green:                 #37bc9b;\r\n\r\n$primary:               #5d9cec;\r\n$secondary:             #fff;\r\n$success:               #27c24c;\r\n$info:                  #23b7e5;\r\n$warning:               #ff902b;\r\n$danger:                #f05050;\r\n$dark:                  #3a3f51;\r\n\r\n// Custom color variants\r\n$amountOfLight: 10%;\r\n\r\n$primary-light:         lighten($primary, $amountOfLight);\r\n$success-light:         lighten($success, $amountOfLight);\r\n$info-light:            lighten($info, $amountOfLight);\r\n$warning-light:         lighten($warning, $amountOfLight);\r\n$danger-light:          lighten($danger, $amountOfLight);\r\n$inverse-light:         lighten($inverse, $amountOfLight);\r\n$green-light:           lighten($green, $amountOfLight);\r\n$pink-light:            lighten($pink, $amountOfLight);\r\n$purple-light:          lighten($purple, $amountOfLight);\r\n$yellow-light:          lighten($yellow, $amountOfLight);\r\n$primary-dark:          darken($primary, $amountOfLight);\r\n$success-dark:          darken($success, $amountOfLight);\r\n$info-dark:             darken($info, $amountOfLight);\r\n$warning-dark:          darken($warning, $amountOfLight);\r\n$danger-dark:           darken($danger, $amountOfLight);\r\n$inverse-dark:          darken($inverse, $amountOfLight);\r\n$green-dark:            darken($green, $amountOfLight);\r\n$pink-dark:             darken($pink, $amountOfLight);\r\n$purple-dark:           darken($purple, $amountOfLight);\r\n$yellow-dark:           darken($yellow, $amountOfLight);\r\n\r\n// Theme variables\r\n\r\n// used for sidebars and content spacing\r\n$navbar-height:                    55px;\r\n\r\n// Button secondary redefinition style for theme\r\n$btn-secondary-color:              #333;\r\n$btn-secondary-bg:                 #fff;\r\n$btn-secondary-border:             #eaeaea;\r\n\r\n// Top Border color for custom default cards (.card-default)\r\n$card-default-border-color:        #cfdbe2;\r\n\r\n\r\n// ---------------------\r\n// Utilities variables\r\n// ---------------------\r\n\r\n$text-alpha:            rgba(255,255,255,.5);\r\n$text-alpha-inverse:    rgba(0,0,0,.5);\r\n\r\n$font-size-base:        1rem;\r\n$text-sm:               $font-size-base * 0.74375;\r\n$text-md:               $font-size-base * 1.6625;\r\n$text-lg:               $font-size-base * 2.625;\r\n\r\n$border-color:          rgba(0,0,0,.12);\r\n\r\n$wd-xxs:                60px;\r\n$wd-xs:                 90px;\r\n$wd-sm:                 150px;\r\n$wd-sd:                 200px; // sd == standard\r\n$wd-md:                 240px;\r\n$wd-lg:                 280px;\r\n$wd-xl:                 320px;\r\n$wd-xxl:                360px;\r\n$wd-wide:               100%;\r\n$wd-auto:               auto;\r\n$wd-zero:               0;\r\n\r\n\r\n// ---------------------\r\n// Bootstrap 4 Variables Override\r\n// ---------------------\r\n\r\n// Color system\r\n\r\n$colors: (\r\n    \"purple\":     $purple,\r\n    \"pink\":       $pink,\r\n    \"yellow\":     $yellow,\r\n    \"green\":      $green,\r\n    \"primary\":    $primary,\r\n    \"success\":    $success,\r\n    \"info\":       $info,\r\n    \"warning\":    $warning,\r\n    \"danger\":     $danger,\r\n    'inverse':    $inverse,\r\n\r\n    'primary-light': $primary-light,\r\n    'primary-dark':  $primary-dark,\r\n    'success-light': $success-light,\r\n    'success-dark':  $success-dark,\r\n    'info-light':    $info-light,\r\n    'info-dark':     $info-dark,\r\n    'warning-light': $warning-light,\r\n    'warning-dark':  $warning-dark,\r\n    'danger-light':  $danger-light,\r\n    'danger-dark':   $danger-dark,\r\n    'green-light':   $green-light,\r\n    'green-dark':    $green-dark,\r\n    'pink-light':    $pink-light,\r\n    'pink-dark':     $pink-dark,\r\n    'purple-light':  $purple-light,\r\n    'purple-dark':   $purple-dark,\r\n    'inverse-light': $inverse-light,\r\n    'inverse-dark':  $inverse-dark,\r\n    'yellow-light':  $yellow-light,\r\n    'yellow-dark':   $yellow-dark,\r\n);\r\n\r\n\r\n$theme-colors: (\r\n  \"primary\":    $primary,\r\n  \"secondary\":  $secondary,\r\n  \"success\":    $success,\r\n  \"info\":       $info,\r\n  \"warning\":    $warning,\r\n  \"danger\":     $danger\r\n);\r\n\r\n// Body\r\n\r\n$body-bg:                   #f5f7fa;\r\n$body-color:                #656565;\r\n\r\n$border-radius:               .25rem;\r\n$border-radius-lg:            .375rem;\r\n\r\n$line-height-base:            1.528571429;\r\n\r\n$headings-line-height:        1.1;\r\n\r\n$text-muted:                  #909FA7;\r\n\r\n// Tables\r\n\r\n$table-accent-bg:             #fafbfc;\r\n$table-hover-bg:              #fafbfc;\r\n\r\n$table-border-color:          #eee;\r\n\r\n// Buttons + Forms\r\n\r\n$input-btn-padding-y:         .375rem;\r\n$input-btn-padding-x:         1rem;\r\n\r\n$input-btn-padding-y-sm:      .3125rem;\r\n$input-btn-padding-x-sm:      .625rem;\r\n\r\n$input-btn-padding-y-lg:      .625rem;\r\n$input-btn-padding-x-lg:      1.25rem;\r\n\r\n$input-height:                2.1875rem; // 35px\r\n\r\n// Forms\r\n\r\n$input-disabled-bg:                     $gray-lighter;\r\n$input-border-color:                    $gray;\r\n$input-focus-border-color:              #66afe9;\r\n$input-placeholder-color:               #b7bac9;\r\n\r\n$form-feedback-icon-valid:              none;\r\n$form-feedback-icon-invalid:            none;\r\n\r\n$custom-control-indicator-active-bg:    lighten($primary, 25%);\r\n\r\n// Dropdowns\r\n\r\n$dropdown-border-color:             #e1e1e1;\r\n\r\n// Navs\r\n\r\n$nav-tabs-link-active-bg:           #fff;\r\n\r\n// Jumbotron\r\n\r\n$jumbotron-bg:                      #fcfcfc;\r\n\r\n// List group\r\n\r\n$list-group-border-color:           #e4eaec;\r\n\r\n// Image thumbnails\r\n\r\n$thumbnail-padding:                 .125rem;\r\n\r\n\r\n// Breadcrumbs\r\n\r\n$breadcrumb-bg:                     #fafafa;\r\n$breadcrumb-divider-color:          #c1c2c3;\r\n$breadcrumb-active-color:           $body-color;\r\n","// Gradients\r\n\r\n@mixin gradient-bg($color) {\r\n  @if $enable-gradients {\r\n    background: $color linear-gradient(180deg, mix($body-bg, $color, 15%), $color) repeat-x;\r\n  } @else {\r\n    background-color: $color;\r\n  }\r\n}\r\n\r\n// Horizontal gradient, from left to right\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-x($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to right, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n// Vertical gradient, from top to bottom\r\n//\r\n// Creates two color stops, start and end, by specifying a color and position for each color stop.\r\n@mixin gradient-y($start-color: $gray-700, $end-color: $gray-800, $start-percent: 0%, $end-percent: 100%) {\r\n  background-image: linear-gradient(to bottom, $start-color $start-percent, $end-color $end-percent);\r\n  background-repeat: repeat-x;\r\n}\r\n\r\n@mixin gradient-directional($start-color: $gray-700, $end-color: $gray-800, $deg: 45deg) {\r\n  background-image: linear-gradient($deg, $start-color, $end-color);\r\n  background-repeat: repeat-x;\r\n}\r\n@mixin gradient-x-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient(to right, $start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-y-three-colors($start-color: $blue, $mid-color: $purple, $color-stop: 50%, $end-color: $red) {\r\n  background-image: linear-gradient($start-color, $mid-color $color-stop, $end-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-radial($inner-color: $gray-700, $outer-color: $gray-800) {\r\n  background-image: radial-gradient(circle, $inner-color, $outer-color);\r\n  background-repeat: no-repeat;\r\n}\r\n@mixin gradient-striped($color: rgba($white, .15), $angle: 45deg) {\r\n  background-image: linear-gradient($angle, $color 25%, transparent 25%, transparent 50%, $color 50%, $color 75%, transparent 75%, transparent);\r\n}\r\n","// Breakpoint viewport sizes and media queries.\r\n//\r\n// Breakpoints are defined as a map of (name: minimum width), order from small to large:\r\n//\r\n//    (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px)\r\n//\r\n// The map defined in the `$grid-breakpoints` global variable is used as the `$breakpoints` argument by default.\r\n\r\n// Name of the next breakpoint, or null for the last breakpoint.\r\n//\r\n//    >> breakpoint-next(sm)\r\n//    md\r\n//    >> breakpoint-next(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    md\r\n//    >> breakpoint-next(sm, $breakpoint-names: (xs sm md lg xl))\r\n//    md\r\n@function breakpoint-next($name, $breakpoints: $grid-breakpoints, $breakpoint-names: map-keys($breakpoints)) {\r\n  $n: index($breakpoint-names, $name);\r\n  @return if($n != null and $n < length($breakpoint-names), nth($breakpoint-names, $n + 1), null);\r\n}\r\n\r\n// Minimum breakpoint width. Null for the smallest (first) breakpoint.\r\n//\r\n//    >> breakpoint-min(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    576px\r\n@function breakpoint-min($name, $breakpoints: $grid-breakpoints) {\r\n  $min: map-get($breakpoints, $name);\r\n  @return if($min != 0, $min, null);\r\n}\r\n\r\n// Maximum breakpoint width. Null for the largest (last) breakpoint.\r\n// The maximum value is calculated as the minimum of the next one less 0.02px\r\n// to work around the limitations of `min-` and `max-` prefixes and viewports with fractional widths.\r\n// See https://www.w3.org/TR/mediaqueries-4/#mq-min-max\r\n// Uses 0.02px rather than 0.01px to work around a current rounding bug in Safari.\r\n// See https://bugs.webkit.org/show_bug.cgi?id=178261\r\n//\r\n//    >> breakpoint-max(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    767.98px\r\n@function breakpoint-max($name, $breakpoints: $grid-breakpoints) {\r\n  $next: breakpoint-next($name, $breakpoints);\r\n  @return if($next, breakpoint-min($next, $breakpoints) - .02, null);\r\n}\r\n\r\n// Returns a blank string if smallest breakpoint, otherwise returns the name with a dash in front.\r\n// Useful for making responsive utilities.\r\n//\r\n//    >> breakpoint-infix(xs, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"\"  (Returns a blank string)\r\n//    >> breakpoint-infix(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))\r\n//    \"-sm\"\r\n@function breakpoint-infix($name, $breakpoints: $grid-breakpoints) {\r\n  @return if(breakpoint-min($name, $breakpoints) == null, \"\", \"-#{$name}\");\r\n}\r\n\r\n// Media of at least the minimum breakpoint width. No query for the smallest breakpoint.\r\n// Makes the @content apply to the given breakpoint and wider.\r\n@mixin media-breakpoint-up($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  @if $min {\r\n    @media (min-width: $min) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media of at most the maximum breakpoint width. No query for the largest breakpoint.\r\n// Makes the @content apply to the given breakpoint and narrower.\r\n@mixin media-breakpoint-down($name, $breakpoints: $grid-breakpoints) {\r\n  $max: breakpoint-max($name, $breakpoints);\r\n  @if $max {\r\n    @media (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else {\r\n    @content;\r\n  }\r\n}\r\n\r\n// Media that spans multiple breakpoint widths.\r\n// Makes the @content apply between the min and max breakpoints\r\n@mixin media-breakpoint-between($lower, $upper, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($lower, $breakpoints);\r\n  $max: breakpoint-max($upper, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($lower, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($upper, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n\r\n// Media between the breakpoint's minimum and maximum widths.\r\n// No minimum for the smallest breakpoint, and no maximum for the largest one.\r\n// Makes the @content apply only to the given breakpoint, not viewports any wider or narrower.\r\n@mixin media-breakpoint-only($name, $breakpoints: $grid-breakpoints) {\r\n  $min: breakpoint-min($name, $breakpoints);\r\n  $max: breakpoint-max($name, $breakpoints);\r\n\r\n  @if $min != null and $max != null {\r\n    @media (min-width: $min) and (max-width: $max) {\r\n      @content;\r\n    }\r\n  } @else if $max == null {\r\n    @include media-breakpoint-up($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  } @else if $min == null {\r\n    @include media-breakpoint-down($name, $breakpoints) {\r\n      @content;\r\n    }\r\n  }\r\n}\r\n"]} */\";","import { Injectable } from '@angular/core';\r\n\r\n@Injectable()\r\n\r\nexport class ColorService {\r\n\r\n    APP_COLORS = {\r\n        'primary': '#5d9cec',\r\n        'success': '#27c24c',\r\n        'info': '#23b7e5',\r\n        'warning': '#ff902b',\r\n        'danger': '#f05050',\r\n        'inverse': '#131e26',\r\n        'green': '#37bc9b',\r\n        'pink': '#f532e5',\r\n        'purple': '#7266ba',\r\n        'dark': '#3a3f51',\r\n        'yellow': '#fad732',\r\n        'gray-darker': '#232735',\r\n        'gray-dark': '#3a3f51',\r\n        'gray': '#dde6e9',\r\n        'gray-light': '#e4eaec',\r\n        'gray-lighter': '#edf1f2'\r\n    };\r\n\r\n    constructor() { }\r\n\r\n    byName(name) {\r\n        // console.log(name +' -> ' + this.APP_COLORS[name])\r\n        return (this.APP_COLORS[name] || '#fff');\r\n    }\r\n\r\n}\r\n","/*!\r\n * modernizr v3.3.1\r\n * Build http://modernizr.com/download?-bgpositionshorthand-bgpositionxy-bgrepeatspace_bgrepeatround-bgsizecover-borderradius-cssanimations-csscalc-csstransforms-csstransforms3d-csstransitions-flexboxtweener-fontface-inlinesvg-localstorage-multiplebgs-preserve3d-sessionstorage-smil-svg-svgasimg-svgclippaths-svgfilters-svgforeignobject-websqldatabase-setclasses-dontmin\r\n *\r\n * Copyright (c)\r\n *  Faruk Ates\r\n *  Paul Irish\r\n *  Alex Sexton\r\n *  Ryan Seddon\r\n *  Patrick Kettner\r\n *  Stu Cox\r\n *  Richard Herrera\r\n\r\n * MIT License\r\n */\r\n\r\n/*\r\n * Modernizr tests which native CSS3 and HTML5 features are available in the\r\n * current UA and makes the results available to you in two ways: as properties on\r\n * a global `Modernizr` object, and as classes on the `<html>` element. This\r\n * information allows you to progressively enhance your pages with a granular level\r\n * of control over the experience.\r\n*/\r\n\r\n;(function(window, document, undefined){\r\n  var tests = [];\r\n  \r\n\r\n  /**\r\n   *\r\n   * ModernizrProto is the constructor for Modernizr\r\n   *\r\n   * @class\r\n   * @access public\r\n   */\r\n\r\n  var ModernizrProto = {\r\n    // The current version, dummy\r\n    _version: '3.3.1',\r\n\r\n    // Any settings that don't work as separate modules\r\n    // can go in here as configuration.\r\n    _config: {\r\n      'classPrefix': '',\r\n      'enableClasses': true,\r\n      'enableJSClass': true,\r\n      'usePrefixes': true\r\n    },\r\n\r\n    // Queue of tests\r\n    _q: [],\r\n\r\n    // Stub these for people who are listening\r\n    on: function(test, cb) {\r\n      // I don't really think people should do this, but we can\r\n      // safe guard it a bit.\r\n      // -- NOTE:: this gets WAY overridden in src/addTest for actual async tests.\r\n      // This is in case people listen to synchronous tests. I would leave it out,\r\n      // but the code to *disallow* sync tests in the real version of this\r\n      // function is actually larger than this.\r\n      var self = this;\r\n      setTimeout(function() {\r\n        cb(self[test]);\r\n      }, 0);\r\n    },\r\n\r\n    addTest: function(name, fn, options) {\r\n      tests.push({name: name, fn: fn, options: options});\r\n    },\r\n\r\n    addAsyncTest: function(fn) {\r\n      tests.push({name: null, fn: fn});\r\n    }\r\n  };\r\n\r\n  \r\n\r\n  // Fake some of Object.create so we can force non test results to be non \"own\" properties.\r\n  var Modernizr = function() {};\r\n  Modernizr.prototype = ModernizrProto;\r\n\r\n  // Leak modernizr globally when you `require` it rather than force it here.\r\n  // Overwrite name so constructor name is nicer :D\r\n  Modernizr = new Modernizr();\r\n\r\n  \r\n\r\n  var classes = [];\r\n  \r\n\r\n  /**\r\n   * is returns a boolean if the typeof an obj is exactly type.\r\n   *\r\n   * @access private\r\n   * @function is\r\n   * @param {*} obj - A thing we want to check the type of\r\n   * @param {string} type - A string to compare the typeof against\r\n   * @returns {boolean}\r\n   */\r\n\r\n  function is(obj, type) {\r\n    return typeof obj === type;\r\n  }\r\n  ;\r\n\r\n  /**\r\n   * Run through all tests and detect their support in the current UA.\r\n   *\r\n   * @access private\r\n   */\r\n\r\n  function testRunner() {\r\n    var featureNames;\r\n    var feature;\r\n    var aliasIdx;\r\n    var result;\r\n    var nameIdx;\r\n    var featureName;\r\n    var featureNameSplit;\r\n\r\n    for (var featureIdx in tests) {\r\n      if (tests.hasOwnProperty(featureIdx)) {\r\n        featureNames = [];\r\n        feature = tests[featureIdx];\r\n        // run the test, throw the return value into the Modernizr,\r\n        // then based on that boolean, define an appropriate className\r\n        // and push it into an array of classes we'll join later.\r\n        //\r\n        // If there is no name, it's an 'async' test that is run,\r\n        // but not directly added to the object. That should\r\n        // be done with a post-run addTest call.\r\n        if (feature.name) {\r\n          featureNames.push(feature.name.toLowerCase());\r\n\r\n          if (feature.options && feature.options.aliases && feature.options.aliases.length) {\r\n            // Add all the aliases into the names list\r\n            for (aliasIdx = 0; aliasIdx < feature.options.aliases.length; aliasIdx++) {\r\n              featureNames.push(feature.options.aliases[aliasIdx].toLowerCase());\r\n            }\r\n          }\r\n        }\r\n\r\n        // Run the test, or use the raw value if it's not a function\r\n        result = is(feature.fn, 'function') ? feature.fn() : feature.fn;\r\n\r\n\r\n        // Set each of the names on the Modernizr object\r\n        for (nameIdx = 0; nameIdx < featureNames.length; nameIdx++) {\r\n          featureName = featureNames[nameIdx];\r\n          // Support dot properties as sub tests. We don't do checking to make sure\r\n          // that the implied parent tests have been added. You must call them in\r\n          // order (either in the test, or make the parent test a dependency).\r\n          //\r\n          // Cap it to TWO to make the logic simple and because who needs that kind of subtesting\r\n          // hashtag famous last words\r\n          featureNameSplit = featureName.split('.');\r\n\r\n          if (featureNameSplit.length === 1) {\r\n            Modernizr[featureNameSplit[0]] = result;\r\n          } else {\r\n            // cast to a Boolean, if not one already\r\n            /* jshint -W053 */\r\n            if (Modernizr[featureNameSplit[0]] && !(Modernizr[featureNameSplit[0]] instanceof Boolean)) {\r\n              Modernizr[featureNameSplit[0]] = new Boolean(Modernizr[featureNameSplit[0]]);\r\n            }\r\n\r\n            Modernizr[featureNameSplit[0]][featureNameSplit[1]] = result;\r\n          }\r\n\r\n          classes.push((result ? '' : 'no-') + featureNameSplit.join('-'));\r\n        }\r\n      }\r\n    }\r\n  }\r\n  ;\r\n\r\n  /**\r\n   * docElement is a convenience wrapper to grab the root element of the document\r\n   *\r\n   * @access private\r\n   * @returns {HTMLElement|SVGElement} The root element of the document\r\n   */\r\n\r\n  var docElement = document.documentElement;\r\n  \r\n\r\n  /**\r\n   * A convenience helper to check if the document we are running in is an SVG document\r\n   *\r\n   * @access private\r\n   * @returns {boolean}\r\n   */\r\n\r\n  var isSVG = docElement.nodeName.toLowerCase() === 'svg';\r\n  \r\n\r\n  /**\r\n   * setClasses takes an array of class names and adds them to the root element\r\n   *\r\n   * @access private\r\n   * @function setClasses\r\n   * @param {string[]} classes - Array of class names\r\n   */\r\n\r\n  // Pass in an and array of class names, e.g.:\r\n  //  ['no-webp', 'borderradius', ...]\r\n  function setClasses(classes) {\r\n    var className = docElement.className;\r\n    var classPrefix = Modernizr._config.classPrefix || '';\r\n\r\n    if (isSVG) {\r\n      className = className.baseVal;\r\n    }\r\n\r\n    // Change `no-js` to `js` (independently of the `enableClasses` option)\r\n    // Handle classPrefix on this too\r\n    if (Modernizr._config.enableJSClass) {\r\n      var reJS = new RegExp('(^|\\\\s)' + classPrefix + 'no-js(\\\\s|$)');\r\n      className = className.replace(reJS, '$1' + classPrefix + 'js$2');\r\n    }\r\n\r\n    if (Modernizr._config.enableClasses) {\r\n      // Add the new classes\r\n      className += ' ' + classPrefix + classes.join(' ' + classPrefix);\r\n      isSVG ? docElement.className.baseVal = className : docElement.className = className;\r\n    }\r\n\r\n  }\r\n\r\n  ;\r\n\r\n  /**\r\n   * createElement is a convenience wrapper around document.createElement. Since we\r\n   * use createElement all over the place, this allows for (slightly) smaller code\r\n   * as well as abstracting away issues with creating elements in contexts other than\r\n   * HTML documents (e.g. SVG documents).\r\n   *\r\n   * @access private\r\n   * @function createElement\r\n   * @returns {HTMLElement|SVGElement} An HTML or SVG element\r\n   */\r\n\r\n  function createElement() {\r\n    if (typeof document.createElement !== 'function') {\r\n      // This is the case in IE7, where the type of createElement is \"object\".\r\n      // For this reason, we cannot call apply() as Object is not a Function.\r\n      return document.createElement(arguments[0]);\r\n    } else if (isSVG) {\r\n      return document.createElementNS.call(document, 'http://www.w3.org/2000/svg', arguments[0]);\r\n    } else {\r\n      return document.createElement.apply(document, arguments);\r\n    }\r\n  }\r\n\r\n  ;\r\n/*!\r\n{\r\n  \"name\": \"Background Position Shorthand\",\r\n  \"property\": \"bgpositionshorthand\",\r\n  \"tags\": [\"css\"],\r\n  \"builderAliases\": [\"css_backgroundposition_shorthand\"],\r\n  \"notes\": [{\r\n    \"name\": \"MDN Docs\",\r\n    \"href\": \"https://developer.mozilla.org/en/CSS/background-position\"\r\n  }, {\r\n    \"name\": \"W3 Spec\",\r\n    \"href\": \"https://www.w3.org/TR/css3-background/#background-position\"\r\n  }, {\r\n    \"name\": \"Demo\",\r\n    \"href\": \"https://jsfiddle.net/Blink/bBXvt/\"\r\n  }]\r\n}\r\n!*/\r\n/* DOC\r\nDetects if you can use the shorthand method to define multiple parts of an\r\nelement's background-position simultaniously.\r\n\r\neg `background-position: right 10px bottom 10px`\r\n*/\r\n\r\n  Modernizr.addTest('bgpositionshorthand', function() {\r\n    var elem = createElement('a');\r\n    var eStyle = elem.style;\r\n    var val = 'right 10px bottom 10px';\r\n    eStyle.cssText = 'background-position: ' + val + ';';\r\n    return (eStyle.backgroundPosition === val);\r\n  });\r\n\r\n\r\n  /**\r\n   * If the browsers follow the spec, then they would expose vendor-specific style as:\r\n   *   elem.style.WebkitBorderRadius\r\n   * instead of something like the following, which would be technically incorrect:\r\n   *   elem.style.webkitBorderRadius\r\n\r\n   * Webkit ghosts their properties in lowercase but Opera & Moz do not.\r\n   * Microsoft uses a lowercase `ms` instead of the correct `Ms` in IE8+\r\n   *   erik.eae.net/archives/2008/03/10/21.48.10/\r\n\r\n   * More here: github.com/Modernizr/Modernizr/issues/issue/21\r\n   *\r\n   * @access private\r\n   * @returns {string} The string representing the vendor-specific style properties\r\n   */\r\n\r\n  var omPrefixes = 'Moz O ms Webkit';\r\n  \r\n\r\n  var cssomPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.split(' ') : []);\r\n  ModernizrProto._cssomPrefixes = cssomPrefixes;\r\n  \r\n\r\n\r\n  /**\r\n   * contains checks to see if a string contains another string\r\n   *\r\n   * @access private\r\n   * @function contains\r\n   * @param {string} str - The string we want to check for substrings\r\n   * @param {string} substr - The substring we want to search the first string for\r\n   * @returns {boolean}\r\n   */\r\n\r\n  function contains(str, substr) {\r\n    return !!~('' + str).indexOf(substr);\r\n  }\r\n\r\n  ;\r\n\r\n  /**\r\n   * Create our \"modernizr\" element that we do most feature tests on.\r\n   *\r\n   * @access private\r\n   */\r\n\r\n  var modElem = {\r\n    elem: createElement('modernizr')\r\n  };\r\n\r\n  // Clean up this element\r\n  Modernizr._q.push(function() {\r\n    delete modElem.elem;\r\n  });\r\n\r\n  \r\n\r\n  var mStyle = {\r\n    style: modElem.elem.style\r\n  };\r\n\r\n  // kill ref for gc, must happen before mod.elem is removed, so we unshift on to\r\n  // the front of the queue.\r\n  Modernizr._q.unshift(function() {\r\n    delete mStyle.style;\r\n  });\r\n\r\n  \r\n\r\n  /**\r\n   * getBody returns the body of a document, or an element that can stand in for\r\n   * the body if a real body does not exist\r\n   *\r\n   * @access private\r\n   * @function getBody\r\n   * @returns {HTMLElement|SVGElement} Returns the real body of a document, or an\r\n   * artificially created element that stands in for the body\r\n   */\r\n\r\n  function getBody() {\r\n    // After page load injecting a fake body doesn't work so check if body exists\r\n    var body = document.body;\r\n\r\n    if (!body) {\r\n      // Can't use the real body create a fake one.\r\n      body = createElement(isSVG ? 'svg' : 'body');\r\n      body.fake = true;\r\n    }\r\n\r\n    return body;\r\n  }\r\n\r\n  ;\r\n\r\n  /**\r\n   * injectElementWithStyles injects an element with style element and some CSS rules\r\n   *\r\n   * @access private\r\n   * @function injectElementWithStyles\r\n   * @param {string} rule - String representing a css rule\r\n   * @param {function} callback - A function that is used to test the injected element\r\n   * @param {number} [nodes] - An integer representing the number of additional nodes you want injected\r\n   * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes\r\n   * @returns {boolean}\r\n   */\r\n\r\n  function injectElementWithStyles(rule, callback, nodes, testnames) {\r\n    var mod = 'modernizr';\r\n    var style;\r\n    var ret;\r\n    var node;\r\n    var docOverflow;\r\n    var div = createElement('div');\r\n    var body = getBody();\r\n\r\n    if (parseInt(nodes, 10)) {\r\n      // In order not to give false positives we create a node for each test\r\n      // This also allows the method to scale for unspecified uses\r\n      while (nodes--) {\r\n        node = createElement('div');\r\n        node.id = testnames ? testnames[nodes] : mod + (nodes + 1);\r\n        div.appendChild(node);\r\n      }\r\n    }\r\n\r\n    style = createElement('style');\r\n    style.type = 'text/css';\r\n    style.id = 's' + mod;\r\n\r\n    // IE6 will false positive on some tests due to the style element inside the test div somehow interfering offsetHeight, so insert it into body or fakebody.\r\n    // Opera will act all quirky when injecting elements in documentElement when page is served as xml, needs fakebody too. #270\r\n    (!body.fake ? div : body).appendChild(style);\r\n    body.appendChild(div);\r\n\r\n    if (style.styleSheet) {\r\n      style.styleSheet.cssText = rule;\r\n    } else {\r\n      style.appendChild(document.createTextNode(rule));\r\n    }\r\n    div.id = mod;\r\n\r\n    if (body.fake) {\r\n      //avoid crashing IE8, if background image is used\r\n      body.style.background = '';\r\n      //Safari 5.13/5.1.4 OSX stops loading if ::-webkit-scrollbar is used and scrollbars are visible\r\n      body.style.overflow = 'hidden';\r\n      docOverflow = docElement.style.overflow;\r\n      docElement.style.overflow = 'hidden';\r\n      docElement.appendChild(body);\r\n    }\r\n\r\n    ret = callback(div, rule);\r\n    // If this is done after page load we don't want to remove the body so check if body exists\r\n    if (body.fake) {\r\n      body.parentNode.removeChild(body);\r\n      docElement.style.overflow = docOverflow;\r\n      // Trigger layout so kinetic scrolling isn't disabled in iOS6+\r\n      docElement.offsetHeight;\r\n    } else {\r\n      div.parentNode.removeChild(div);\r\n    }\r\n\r\n    return !!ret;\r\n\r\n  }\r\n\r\n  ;\r\n\r\n  /**\r\n   * domToCSS takes a camelCase string and converts it to kebab-case\r\n   * e.g. boxSizing -> box-sizing\r\n   *\r\n   * @access private\r\n   * @function domToCSS\r\n   * @param {string} name - String name of camelCase prop we want to convert\r\n   * @returns {string} The kebab-case version of the supplied name\r\n   */\r\n\r\n  function domToCSS(name) {\r\n    return name.replace(/([A-Z])/g, function(str, m1) {\r\n      return '-' + m1.toLowerCase();\r\n    }).replace(/^ms-/, '-ms-');\r\n  }\r\n  ;\r\n\r\n  /**\r\n   * nativeTestProps allows for us to use native feature detection functionality if available.\r\n   * some prefixed form, or false, in the case of an unsupported rule\r\n   *\r\n   * @access private\r\n   * @function nativeTestProps\r\n   * @param {array} props - An array of property names\r\n   * @param {string} value - A string representing the value we want to check via @supports\r\n   * @returns {boolean|undefined} A boolean when @supports exists, undefined otherwise\r\n   */\r\n\r\n  // Accepts a list of property names and a single value\r\n  // Returns `undefined` if native detection not available\r\n  function nativeTestProps(props, value) {\r\n    var i = props.length;\r\n    // Start with the JS API: http://www.w3.org/TR/css3-conditional/#the-css-interface\r\n    if ('CSS' in window && 'supports' in window.CSS) {\r\n      // Try every prefixed variant of the property\r\n      while (i--) {\r\n        if (window.CSS.supports(domToCSS(props[i]), value)) {\r\n          return true;\r\n        }\r\n      }\r\n      return false;\r\n    }\r\n    // Otherwise fall back to at-rule (for Opera 12.x)\r\n    else if ('CSSSupportsRule' in window) {\r\n      // Build a condition string for every prefixed variant\r\n      var conditionText = [];\r\n      while (i--) {\r\n        conditionText.push('(' + domToCSS(props[i]) + ':' + value + ')');\r\n      }\r\n      conditionText = conditionText.join(' or ');\r\n      return injectElementWithStyles('@supports (' + conditionText + ') { #modernizr { position: absolute; } }', function(node) {\r\n        return getComputedStyle(node, null).position == 'absolute';\r\n      });\r\n    }\r\n    return undefined;\r\n  }\r\n  ;\r\n\r\n  /**\r\n   * cssToDOM takes a kebab-case string and converts it to camelCase\r\n   * e.g. box-sizing -> boxSizing\r\n   *\r\n   * @access private\r\n   * @function cssToDOM\r\n   * @param {string} name - String name of kebab-case prop we want to convert\r\n   * @returns {string} The camelCase version of the supplied name\r\n   */\r\n\r\n  function cssToDOM(name) {\r\n    return name.replace(/([a-z])-([a-z])/g, function(str, m1, m2) {\r\n      return m1 + m2.toUpperCase();\r\n    }).replace(/^-/, '');\r\n  }\r\n  ;\r\n\r\n  // testProps is a generic CSS / DOM property test.\r\n\r\n  // In testing support for a given CSS property, it's legit to test:\r\n  //    `elem.style[styleName] !== undefined`\r\n  // If the property is supported it will return an empty string,\r\n  // if unsupported it will return undefined.\r\n\r\n  // We'll take advantage of this quick test and skip setting a style\r\n  // on our modernizr element, but instead just testing undefined vs\r\n  // empty string.\r\n\r\n  // Property names can be provided in either camelCase or kebab-case.\r\n\r\n  function testProps(props, prefixed, value, skipValueTest) {\r\n    skipValueTest = is(skipValueTest, 'undefined') ? false : skipValueTest;\r\n\r\n    // Try native detect first\r\n    if (!is(value, 'undefined')) {\r\n      var result = nativeTestProps(props, value);\r\n      if (!is(result, 'undefined')) {\r\n        return result;\r\n      }\r\n    }\r\n\r\n    // Otherwise do it properly\r\n    var afterInit, i, propsLength, prop, before;\r\n\r\n    // If we don't have a style element, that means we're running async or after\r\n    // the core tests, so we'll need to create our own elements to use\r\n\r\n    // inside of an SVG element, in certain browsers, the `style` element is only\r\n    // defined for valid tags. Therefore, if `modernizr` does not have one, we\r\n    // fall back to a less used element and hope for the best.\r\n    var elems = ['modernizr', 'tspan'];\r\n    while (!mStyle.style) {\r\n      afterInit = true;\r\n      mStyle.modElem = createElement(elems.shift());\r\n      mStyle.style = mStyle.modElem.style;\r\n    }\r\n\r\n    // Delete the objects if we created them.\r\n    function cleanElems() {\r\n      if (afterInit) {\r\n        delete mStyle.style;\r\n        delete mStyle.modElem;\r\n      }\r\n    }\r\n\r\n    propsLength = props.length;\r\n    for (i = 0; i < propsLength; i++) {\r\n      prop = props[i];\r\n      before = mStyle.style[prop];\r\n\r\n      if (contains(prop, '-')) {\r\n        prop = cssToDOM(prop);\r\n      }\r\n\r\n      if (mStyle.style[prop] !== undefined) {\r\n\r\n        // If value to test has been passed in, do a set-and-check test.\r\n        // 0 (integer) is a valid property value, so check that `value` isn't\r\n        // undefined, rather than just checking it's truthy.\r\n        if (!skipValueTest && !is(value, 'undefined')) {\r\n\r\n          // Needs a try catch block because of old IE. This is slow, but will\r\n          // be avoided in most cases because `skipValueTest` will be used.\r\n          try {\r\n            mStyle.style[prop] = value;\r\n          } catch (e) {}\r\n\r\n          // If the property value has changed, we assume the value used is\r\n          // supported. If `value` is empty string, it'll fail here (because\r\n          // it hasn't changed), which matches how browsers have implemented\r\n          // CSS.supports()\r\n          if (mStyle.style[prop] != before) {\r\n            cleanElems();\r\n            return prefixed == 'pfx' ? prop : true;\r\n          }\r\n        }\r\n        // Otherwise just return true, or the property name if this is a\r\n        // `prefixed()` call\r\n        else {\r\n          cleanElems();\r\n          return prefixed == 'pfx' ? prop : true;\r\n        }\r\n      }\r\n    }\r\n    cleanElems();\r\n    return false;\r\n  }\r\n\r\n  ;\r\n\r\n  /**\r\n   * List of JavaScript DOM values used for tests\r\n   *\r\n   * @memberof Modernizr\r\n   * @name Modernizr._domPrefixes\r\n   * @optionName Modernizr._domPrefixes\r\n   * @optionProp domPrefixes\r\n   * @access public\r\n   * @example\r\n   *\r\n   * Modernizr._domPrefixes is exactly the same as [_prefixes](#modernizr-_prefixes), but rather\r\n   * than kebab-case properties, all properties are their Capitalized variant\r\n   *\r\n   * ```js\r\n   * Modernizr._domPrefixes === [ \"Moz\", \"O\", \"ms\", \"Webkit\" ];\r\n   * ```\r\n   */\r\n\r\n  var domPrefixes = (ModernizrProto._config.usePrefixes ? omPrefixes.toLowerCase().split(' ') : []);\r\n  ModernizrProto._domPrefixes = domPrefixes;\r\n  \r\n\r\n  /**\r\n   * fnBind is a super small [bind](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind) polyfill.\r\n   *\r\n   * @access private\r\n   * @function fnBind\r\n   * @param {function} fn - a function you want to change `this` reference to\r\n   * @param {object} that - the `this` you want to call the function with\r\n   * @returns {function} The wrapped version of the supplied function\r\n   */\r\n\r\n  function fnBind(fn, that) {\r\n    return function() {\r\n      return fn.apply(that, arguments);\r\n    };\r\n  }\r\n\r\n  ;\r\n\r\n  /**\r\n   * testDOMProps is a generic DOM property test; if a browser supports\r\n   *   a certain property, it won't return undefined for it.\r\n   *\r\n   * @access private\r\n   * @function testDOMProps\r\n   * @param {array.<string>} props - An array of properties to test for\r\n   * @param {object} obj - An object or Element you want to use to test the parameters again\r\n   * @param {boolean|object} elem - An Element to bind the property lookup again. Use `false` to prevent the check\r\n   */\r\n  function testDOMProps(props, obj, elem) {\r\n    var item;\r\n\r\n    for (var i in props) {\r\n      if (props[i] in obj) {\r\n\r\n        // return the property name as a string\r\n        if (elem === false) {\r\n          return props[i];\r\n        }\r\n\r\n        item = obj[props[i]];\r\n\r\n        // let's bind a function\r\n        if (is(item, 'function')) {\r\n          // bind to obj unless overriden\r\n          return fnBind(item, elem || obj);\r\n        }\r\n\r\n        // return the unbound function or obj or value\r\n        return item;\r\n      }\r\n    }\r\n    return false;\r\n  }\r\n\r\n  ;\r\n\r\n  /**\r\n   * testPropsAll tests a list of DOM properties we want to check against.\r\n   * We specify literally ALL possible (known and/or likely) properties on\r\n   * the element including the non-vendor prefixed one, for forward-\r\n   * compatibility.\r\n   *\r\n   * @access private\r\n   * @function testPropsAll\r\n   * @param {string} prop - A string of the property to test for\r\n   * @param {string|object} [prefixed] - An object to check the prefixed properties on. Use a string to skip\r\n   * @param {HTMLElement|SVGElement} [elem] - An element used to test the property and value against\r\n   * @param {string} [value] - A string of a css value\r\n   * @param {boolean} [skipValueTest] - An boolean representing if you want to test if value sticks when set\r\n   */\r\n  function testPropsAll(prop, prefixed, elem, value, skipValueTest) {\r\n\r\n    var ucProp = prop.charAt(0).toUpperCase() + prop.slice(1),\r\n    props = (prop + ' ' + cssomPrefixes.join(ucProp + ' ') + ucProp).split(' ');\r\n\r\n    // did they call .prefixed('boxSizing') or are we just testing a prop?\r\n    if (is(prefixed, 'string') || is(prefixed, 'undefined')) {\r\n      return testProps(props, prefixed, value, skipValueTest);\r\n\r\n      // otherwise, they called .prefixed('requestAnimationFrame', window[, elem])\r\n    } else {\r\n      props = (prop + ' ' + (domPrefixes).join(ucProp + ' ') + ucProp).split(' ');\r\n      return testDOMProps(props, prefixed, elem);\r\n    }\r\n  }\r\n\r\n  // Modernizr.testAllProps() investigates whether a given style property,\r\n  // or any of its vendor-prefixed variants, is recognized\r\n  //\r\n  // Note that the property names must be provided in the camelCase variant.\r\n  // Modernizr.testAllProps('boxSizing')\r\n  ModernizrProto.testAllProps = testPropsAll;\r\n\r\n  \r\n\r\n  /**\r\n   * testAllProps determines whether a given CSS property is supported in the browser\r\n   *\r\n   * @memberof Modernizr\r\n   * @name Modernizr.testAllProps\r\n   * @optionName Modernizr.testAllProps()\r\n   * @optionProp testAllProps\r\n   * @access public\r\n   * @function testAllProps\r\n   * @param {string} prop - String naming the property to test (either camelCase or kebab-case)\r\n   * @param {string} [value] - String of the value to test\r\n   * @param {boolean} [skipValueTest=false] - Whether to skip testing that the value is supported when using non-native detection\r\n   * @example\r\n   *\r\n   * testAllProps determines whether a given CSS property, in some prefixed form,\r\n   * is supported by the browser.\r\n   *\r\n   * ```js\r\n   * testAllProps('boxSizing')  // true\r\n   * ```\r\n   *\r\n   * It can optionally be given a CSS value in string form to test if a property\r\n   * value is valid\r\n   *\r\n   * ```js\r\n   * testAllProps('display', 'block') // true\r\n   * testAllProps('display', 'penguin') // false\r\n   * ```\r\n   *\r\n   * A boolean can be passed as a third parameter to skip the value check when\r\n   * native detection (@supports) isn't available.\r\n   *\r\n   * ```js\r\n   * testAllProps('shapeOutside', 'content-box', true);\r\n   * ```\r\n   */\r\n\r\n  function testAllProps(prop, value, skipValueTest) {\r\n    return testPropsAll(prop, undefined, undefined, value, skipValueTest);\r\n  }\r\n  ModernizrProto.testAllProps = testAllProps;\r\n  \r\n/*!\r\n{\r\n  \"name\": \"Background Position XY\",\r\n  \"property\": \"bgpositionxy\",\r\n  \"tags\": [\"css\"],\r\n  \"builderAliases\": [\"css_backgroundposition_xy\"],\r\n  \"authors\": [\"Allan Lei\", \"Brandom Aaron\"],\r\n  \"notes\": [{\r\n    \"name\": \"Demo\",\r\n    \"href\": \"https://jsfiddle.net/allanlei/R8AYS/\"\r\n  }, {\r\n    \"name\": \"Adapted From\",\r\n    \"href\": \"https://github.com/brandonaaron/jquery-cssHooks/blob/master/bgpos.js\"\r\n  }]\r\n}\r\n!*/\r\n/* DOC\r\nDetects the ability to control an element's background position using css\r\n*/\r\n\r\n  Modernizr.addTest('bgpositionxy', function() {\r\n    return testAllProps('backgroundPositionX', '3px', true) && testAllProps('backgroundPositionY', '5px', true);\r\n  });\r\n\r\n/*!\r\n{\r\n  \"name\": \"Background Repeat\",\r\n  \"property\": [\"bgrepeatspace\", \"bgrepeatround\"],\r\n  \"tags\": [\"css\"],\r\n  \"builderAliases\": [\"css_backgroundrepeat\"],\r\n  \"authors\": [\"Ryan Seddon\"],\r\n  \"notes\": [{\r\n    \"name\": \"MDN Docs\",\r\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/background-repeat\"\r\n  }, {\r\n    \"name\": \"Test Page\",\r\n    \"href\": \"https://jsbin.com/uzesun/\"\r\n  }, {\r\n    \"name\": \"Demo\",\r\n    \"href\": \"https://jsfiddle.net/ryanseddon/yMLTQ/6/\"\r\n  }]\r\n}\r\n!*/\r\n/* DOC\r\nDetects the ability to use round and space as properties for background-repeat\r\n*/\r\n\r\n  // Must value-test these\r\n  Modernizr.addTest('bgrepeatround', testAllProps('backgroundRepeat', 'round'));\r\n  Modernizr.addTest('bgrepeatspace', testAllProps('backgroundRepeat', 'space'));\r\n\r\n/*!\r\n{\r\n  \"name\": \"Background Size Cover\",\r\n  \"property\": \"bgsizecover\",\r\n  \"tags\": [\"css\"],\r\n  \"builderAliases\": [\"css_backgroundsizecover\"],\r\n  \"notes\": [{\r\n    \"name\" : \"MDN Docs\",\r\n    \"href\": \"https://developer.mozilla.org/en/CSS/background-size\"\r\n  }]\r\n}\r\n!*/\r\n\r\n  // Must test value, as this specifically tests the `cover` value\r\n  Modernizr.addTest('bgsizecover', testAllProps('backgroundSize', 'cover'));\r\n\r\n/*!\r\n{\r\n  \"name\": \"Border Radius\",\r\n  \"property\": \"borderradius\",\r\n  \"caniuse\": \"border-radius\",\r\n  \"polyfills\": [\"css3pie\"],\r\n  \"tags\": [\"css\"],\r\n  \"notes\": [{\r\n    \"name\": \"Comprehensive Compat Chart\",\r\n    \"href\": \"https://muddledramblings.com/table-of-css3-border-radius-compliance\"\r\n  }]\r\n}\r\n!*/\r\n\r\n  Modernizr.addTest('borderradius', testAllProps('borderRadius', '0px', true));\r\n\r\n/*!\r\n{\r\n  \"name\": \"CSS Animations\",\r\n  \"property\": \"cssanimations\",\r\n  \"caniuse\": \"css-animation\",\r\n  \"polyfills\": [\"transformie\", \"csssandpaper\"],\r\n  \"tags\": [\"css\"],\r\n  \"warnings\": [\"Android < 4 will pass this test, but can only animate a single property at a time\"],\r\n  \"notes\": [{\r\n    \"name\" : \"Article: 'Dispelling the Android CSS animation myths'\",\r\n    \"href\": \"https://goo.gl/OGw5Gm\"\r\n  }]\r\n}\r\n!*/\r\n/* DOC\r\nDetects whether or not elements can be animated using CSS\r\n*/\r\n\r\n  Modernizr.addTest('cssanimations', testAllProps('animationName', 'a', true));\r\n\r\n\r\n  /**\r\n   * List of property values to set for css tests. See ticket #21\r\n   * http://git.io/vUGl4\r\n   *\r\n   * @memberof Modernizr\r\n   * @name Modernizr._prefixes\r\n   * @optionName Modernizr._prefixes\r\n   * @optionProp prefixes\r\n   * @access public\r\n   * @example\r\n   *\r\n   * Modernizr._prefixes is the internal list of prefixes that we test against\r\n   * inside of things like [prefixed](#modernizr-prefixed) and [prefixedCSS](#-code-modernizr-prefixedcss). It is simply\r\n   * an array of kebab-case vendor prefixes you can use within your code.\r\n   *\r\n   * Some common use cases include\r\n   *\r\n   * Generating all possible prefixed version of a CSS property\r\n   * ```js\r\n   * var rule = Modernizr._prefixes.join('transform: rotate(20deg); ');\r\n   *\r\n   * rule === 'transform: rotate(20deg); webkit-transform: rotate(20deg); moz-transform: rotate(20deg); o-transform: rotate(20deg); ms-transform: rotate(20deg);'\r\n   * ```\r\n   *\r\n   * Generating all possible prefixed version of a CSS value\r\n   * ```js\r\n   * rule = 'display:' +  Modernizr._prefixes.join('flex; display:') + 'flex';\r\n   *\r\n   * rule === 'display:flex; display:-webkit-flex; display:-moz-flex; display:-o-flex; display:-ms-flex; display:flex'\r\n   * ```\r\n   */\r\n\r\n  var prefixes = (ModernizrProto._config.usePrefixes ? ' -webkit- -moz- -o- -ms- '.split(' ') : []);\r\n\r\n  // expose these for the plugin API. Look in the source for how to join() them against your input\r\n  ModernizrProto._prefixes = prefixes;\r\n\r\n  \r\n/*!\r\n{\r\n  \"name\": \"CSS Calc\",\r\n  \"property\": \"csscalc\",\r\n  \"caniuse\": \"calc\",\r\n  \"tags\": [\"css\"],\r\n  \"builderAliases\": [\"css_calc\"],\r\n  \"authors\": [\"@calvein\"]\r\n}\r\n!*/\r\n/* DOC\r\nMethod of allowing calculated values for length units. For example:\r\n\r\n```css\r\n//lem {\r\n  width: calc(100% - 3em);\r\n}\r\n```\r\n*/\r\n\r\n  Modernizr.addTest('csscalc', function() {\r\n    var prop = 'width:';\r\n    var value = 'calc(10px);';\r\n    var el = createElement('a');\r\n\r\n    el.style.cssText = prop + prefixes.join(value + prop);\r\n\r\n    return !!el.style.length;\r\n  });\r\n\r\n/*!\r\n{\r\n  \"name\": \"CSS Transforms\",\r\n  \"property\": \"csstransforms\",\r\n  \"caniuse\": \"transforms2d\",\r\n  \"tags\": [\"css\"]\r\n}\r\n!*/\r\n\r\n  Modernizr.addTest('csstransforms', function() {\r\n    // Android < 3.0 is buggy, so we sniff and blacklist\r\n    // http://git.io/hHzL7w\r\n    return navigator.userAgent.indexOf('Android 2.') === -1 &&\r\n           testAllProps('transform', 'scale(1)', true);\r\n  });\r\n\r\n\r\n  /**\r\n   * testStyles injects an element with style element and some CSS rules\r\n   *\r\n   * @memberof Modernizr\r\n   * @name Modernizr.testStyles\r\n   * @optionName Modernizr.testStyles()\r\n   * @optionProp testStyles\r\n   * @access public\r\n   * @function testStyles\r\n   * @param {string} rule - String representing a css rule\r\n   * @param {function} callback - A function that is used to test the injected element\r\n   * @param {number} [nodes] - An integer representing the number of additional nodes you want injected\r\n   * @param {string[]} [testnames] - An array of strings that are used as ids for the additional nodes\r\n   * @returns {boolean}\r\n   * @example\r\n   *\r\n   * `Modernizr.testStyles` takes a CSS rule and injects it onto the current page\r\n   * along with (possibly multiple) DOM elements. This lets you check for features\r\n   * that can not be detected by simply checking the [IDL](https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Interface_development_guide/IDL_interface_rules).\r\n   *\r\n   * ```js\r\n   * Modernizr.testStyles('#modernizr { width: 9px; color: papayawhip; }', function(elem, rule) {\r\n   *   // elem is the first DOM node in the page (by default #modernizr)\r\n   *   // rule is the first argument you supplied - the CSS rule in string form\r\n   *\r\n   *   addTest('widthworks', elem.style.width === '9px')\r\n   * });\r\n   * ```\r\n   *\r\n   * If your test requires multiple nodes, you can include a third argument\r\n   * indicating how many additional div elements to include on the page. The\r\n   * additional nodes are injected as children of the `elem` that is returned as\r\n   * the first argument to the callback.\r\n   *\r\n   * ```js\r\n   * Modernizr.testStyles('#modernizr {width: 1px}; #modernizr2 {width: 2px}', function(elem) {\r\n   *   document.getElementById('modernizr').style.width === '1px'; // true\r\n   *   document.getElementById('modernizr2').style.width === '2px'; // true\r\n   *   elem.firstChild === document.getElementById('modernizr2'); // true\r\n   * }, 1);\r\n   * ```\r\n   *\r\n   * By default, all of the additional elements have an ID of `modernizr[n]`, where\r\n   * `n` is its index (e.g. the first additional, second overall is `#modernizr2`,\r\n   * the second additional is `#modernizr3`, etc.).\r\n   * If you want to have more meaningful IDs for your function, you can provide\r\n   * them as the fourth argument, as an array of strings\r\n   *\r\n   * ```js\r\n   * Modernizr.testStyles('#foo {width: 10px}; #bar {height: 20px}', function(elem) {\r\n   *   elem.firstChild === document.getElementById('foo'); // true\r\n   *   elem.lastChild === document.getElementById('bar'); // true\r\n   * }, 2, ['foo', 'bar']);\r\n   * ```\r\n   *\r\n   */\r\n\r\n  var testStyles = ModernizrProto.testStyles = injectElementWithStyles;\r\n  \r\n/*!\r\n{\r\n  \"name\": \"CSS Supports\",\r\n  \"property\": \"supports\",\r\n  \"caniuse\": \"css-featurequeries\",\r\n  \"tags\": [\"css\"],\r\n  \"builderAliases\": [\"css_supports\"],\r\n  \"notes\": [{\r\n    \"name\": \"W3 Spec\",\r\n    \"href\": \"http://dev.w3.org/csswg/css3-conditional/#at-supports\"\r\n  },{\r\n    \"name\": \"Related Github Issue\",\r\n    \"href\": \"github.com/Modernizr/Modernizr/issues/648\"\r\n  },{\r\n    \"name\": \"W3 Info\",\r\n    \"href\": \"http://dev.w3.org/csswg/css3-conditional/#the-csssupportsrule-interface\"\r\n  }]\r\n}\r\n!*/\r\n\r\n  var newSyntax = 'CSS' in window && 'supports' in window.CSS;\r\n  var oldSyntax = 'supportsCSS' in window;\r\n  Modernizr.addTest('supports', newSyntax || oldSyntax);\r\n\r\n/*!\r\n{\r\n  \"name\": \"CSS Transforms 3D\",\r\n  \"property\": \"csstransforms3d\",\r\n  \"caniuse\": \"transforms3d\",\r\n  \"tags\": [\"css\"],\r\n  \"warnings\": [\r\n    \"Chrome may occassionally fail this test on some systems; more info: https://code.google.com/p/chromium/issues/detail?id=129004\"\r\n  ]\r\n}\r\n!*/\r\n\r\n  Modernizr.addTest('csstransforms3d', function() {\r\n    var ret = !!testAllProps('perspective', '1px', true);\r\n    var usePrefix = Modernizr._config.usePrefixes;\r\n\r\n    // Webkit's 3D transforms are passed off to the browser's own graphics renderer.\r\n    //   It works fine in Safari on Leopard and Snow Leopard, but not in Chrome in\r\n    //   some conditions. As a result, Webkit typically recognizes the syntax but\r\n    //   will sometimes throw a false positive, thus we must do a more thorough check:\r\n    if (ret && (!usePrefix || 'webkitPerspective' in docElement.style)) {\r\n      var mq;\r\n      var defaultStyle = '#modernizr{width:0;height:0}';\r\n      // Use CSS Conditional Rules if available\r\n      if (Modernizr.supports) {\r\n        mq = '@supports (perspective: 1px)';\r\n      } else {\r\n        // Otherwise, Webkit allows this media query to succeed only if the feature is enabled.\r\n        // `@media (transform-3d),(-webkit-transform-3d){ ... }`\r\n        mq = '@media (transform-3d)';\r\n        if (usePrefix) {\r\n          mq += ',(-webkit-transform-3d)';\r\n        }\r\n      }\r\n\r\n      mq += '{#modernizr{width:7px;height:18px;margin:0;padding:0;border:0}}';\r\n\r\n      testStyles(defaultStyle + mq, function(elem) {\r\n        ret = elem.offsetWidth === 7 && elem.offsetHeight === 18;\r\n      });\r\n    }\r\n\r\n    return ret;\r\n  });\r\n\r\n/*!\r\n{\r\n  \"name\": \"CSS Transform Style preserve-3d\",\r\n  \"property\": \"preserve3d\",\r\n  \"authors\": [\"edmellum\"],\r\n  \"tags\": [\"css\"],\r\n  \"notes\": [{\r\n    \"name\": \"MDN Docs\",\r\n    \"href\": \"https://developer.mozilla.org/en-US/docs/Web/CSS/transform-style\"\r\n  },{\r\n    \"name\": \"Related Github Issue\",\r\n    \"href\": \"https://github.com/Modernizr/Modernizr/issues/762\"\r\n  }]\r\n}\r\n!*/\r\n/* DOC\r\nDetects support for `transform-style: preserve-3d`, for getting a proper 3D perspective on elements.\r\n*/\r\n\r\n  Modernizr.addTest('preserve3d', testAllProps('transformStyle', 'preserve-3d'));\r\n\r\n/*!\r\n{\r\n  \"name\": \"CSS Transitions\",\r\n  \"property\": \"csstransitions\",\r\n  \"caniuse\": \"css-transitions\",\r\n  \"tags\": [\"css\"]\r\n}\r\n!*/\r\n\r\n  Modernizr.addTest('csstransitions', testAllProps('transition', 'all', true));\r\n\r\n/*!\r\n{\r\n  \"name\": \"Flexbox (tweener)\",\r\n  \"property\": \"flexboxtweener\",\r\n  \"tags\": [\"css\"],\r\n  \"polyfills\": [\"flexie\"],\r\n  \"notes\": [{\r\n    \"name\": \"The _inbetween_ flexbox\",\r\n    \"href\": \"https://www.w3.org/TR/2011/WD-css3-flexbox-20111129/\"\r\n  }],\r\n  \"warnings\": [\"This represents an old syntax, not the latest standard syntax.\"]\r\n}\r\n!*/\r\n\r\n  Modernizr.addTest('flexboxtweener', testAllProps('flexAlign', 'end', true));\r\n\r\n/*!\r\n{\r\n  \"name\": \"@font-face\",\r\n  \"property\": \"fontface\",\r\n  \"authors\": [\"Diego Perini\", \"Mat Marquis\"],\r\n  \"tags\": [\"css\"],\r\n  \"knownBugs\": [\r\n    \"False Positive: WebOS https://github.com/Modernizr/Modernizr/issues/342\",\r\n    \"False Postive: WP7 https://github.com/Modernizr/Modernizr/issues/538\"\r\n  ],\r\n  \"notes\": [{\r\n    \"name\": \"@font-face detection routine by Diego Perini\",\r\n    \"href\": \"http://javascript.nwbox.com/CSSSupport/\"\r\n  },{\r\n    \"name\": \"Filament Group @font-face compatibility research\",\r\n    \"href\": \"https://docs.google.com/presentation/d/1n4NyG4uPRjAA8zn_pSQ_Ket0RhcWC6QlZ6LMjKeECo0/edit#slide=id.p\"\r\n  },{\r\n    \"name\": \"Filament Grunticon/@font-face device testing results\",\r\n    \"href\": \"https://docs.google.com/spreadsheet/ccc?key=0Ag5_yGvxpINRdHFYeUJPNnZMWUZKR2ItMEpRTXZPdUE#gid=0\"\r\n  },{\r\n    \"name\": \"CSS fonts on Android\",\r\n    \"href\": \"https://stackoverflow.com/questions/3200069/css-fonts-on-android\"\r\n  },{\r\n    \"name\": \"@font-face and Android\",\r\n    \"href\": \"http://archivist.incutio.com/viewlist/css-discuss/115960\"\r\n  }]\r\n}\r\n!*/\r\n\r\n  var blacklist = (function() {\r\n    var ua = navigator.userAgent;\r\n    var wkvers = ua.match(/applewebkit\\/([0-9]+)/gi) && parseFloat(RegExp.$1);\r\n    var webos = ua.match(/w(eb)?osbrowser/gi);\r\n    var wppre8 = ua.match(/windows phone/gi) && ua.match(/iemobile\\/([0-9])+/gi) && parseFloat(RegExp.$1) >= 9;\r\n    var oldandroid = wkvers < 533 && ua.match(/android/gi);\r\n    return webos || oldandroid || wppre8;\r\n  }());\r\n  if (blacklist) {\r\n    Modernizr.addTest('fontface', false);\r\n  } else {\r\n    testStyles('@font-face {font-family:\"font\";src:url(\"https://\")}', function(node, rule) {\r\n      var style = document.getElementById('smodernizr');\r\n      var sheet = style.sheet || style.styleSheet;\r\n      var cssText = sheet ? (sheet.cssRules && sheet.cssRules[0] ? sheet.cssRules[0].cssText : sheet.cssText || '') : '';\r\n      var bool = /src/i.test(cssText) && cssText.indexOf(rule.split(' ')[0]) === 0;\r\n      Modernizr.addTest('fontface', bool);\r\n    });\r\n  }\r\n;\r\n/*!\r\n{\r\n  \"name\": \"SVG\",\r\n  \"property\": \"svg\",\r\n  \"caniuse\": \"svg\",\r\n  \"tags\": [\"svg\"],\r\n  \"authors\": [\"Erik Dahlstrom\"],\r\n  \"polyfills\": [\r\n    \"svgweb\",\r\n    \"raphael\",\r\n    \"amplesdk\",\r\n    \"canvg\",\r\n    \"svg-boilerplate\",\r\n    \"sie\",\r\n    \"dojogfx\",\r\n    \"fabricjs\"\r\n  ]\r\n}\r\n!*/\r\n/* DOC\r\nDetects support for SVG in `<embed>` or `<object>` elements.\r\n*/\r\n\r\n  Modernizr.addTest('svg', !!document.createElementNS && !!document.createElementNS('http://www.w3.org/2000/svg', 'svg').createSVGRect);\r\n\r\n\r\n  /**\r\n   * hasOwnProp is a shim for hasOwnProperty that is needed for Safari 2.0 support\r\n   *\r\n   * @author kangax\r\n   * @access private\r\n   * @function hasOwnProp\r\n   * @param {object} object - The object to check for a property\r\n   * @param {string} property - The property to check for\r\n   * @returns {boolean}\r\n   */\r\n\r\n  // hasOwnProperty shim by kangax needed for Safari 2.0 support\r\n  var hasOwnProp;\r\n\r\n  (function() {\r\n    var _hasOwnProperty = ({}).hasOwnProperty;\r\n    /* istanbul ignore else */\r\n    /* we have no way of testing IE 5.5 or safari 2,\r\n     * so just assume the else gets hit */\r\n    if (!is(_hasOwnProperty, 'undefined') && !is(_hasOwnProperty.call, 'undefined')) {\r\n      hasOwnProp = function(object, property) {\r\n        return _hasOwnProperty.call(object, property);\r\n      };\r\n    }\r\n    else {\r\n      hasOwnProp = function(object, property) { /* yes, this can give false positives/negatives, but most of the time we don't care about those */\r\n        return ((property in object) && is(object.constructor.prototype[property], 'undefined'));\r\n      };\r\n    }\r\n  })();\r\n\r\n  \r\n\r\n\r\n   // _l tracks listeners for async tests, as well as tests that execute after the initial run\r\n  ModernizrProto._l = {};\r\n\r\n  /**\r\n   * Modernizr.on is a way to listen for the completion of async tests. Being\r\n   * asynchronous, they may not finish before your scripts run. As a result you\r\n   * will get a possibly false negative `undefined` value.\r\n   *\r\n   * @memberof Modernizr\r\n   * @name Modernizr.on\r\n   * @access public\r\n   * @function on\r\n   * @param {string} feature - String name of the feature detect\r\n   * @param {function} cb - Callback function returning a Boolean - true if feature is supported, false if not\r\n   * @example\r\n   *\r\n   * ```js\r\n   * Modernizr.on('flash', function( result ) {\r\n   *   if (result) {\r\n   *    // the browser has flash\r\n   *   } else {\r\n   *     // the browser does not have flash\r\n   *   }\r\n   * });\r\n   * ```\r\n   */\r\n\r\n  ModernizrProto.on = function(feature, cb) {\r\n    // Create the list of listeners if it doesn't exist\r\n    if (!this._l[feature]) {\r\n      this._l[feature] = [];\r\n    }\r\n\r\n    // Push this test on to the listener list\r\n    this._l[feature].push(cb);\r\n\r\n    // If it's already been resolved, trigger it on next tick\r\n    if (Modernizr.hasOwnProperty(feature)) {\r\n      // Next Tick\r\n      setTimeout(function() {\r\n        Modernizr._trigger(feature, Modernizr[feature]);\r\n      }, 0);\r\n    }\r\n  };\r\n\r\n  /**\r\n   * _trigger is the private function used to signal test completion and run any\r\n   * callbacks registered through [Modernizr.on](#modernizr-on)\r\n   *\r\n   * @memberof Modernizr\r\n   * @name Modernizr._trigger\r\n   * @access private\r\n   * @function _trigger\r\n   * @param {string} feature - string name of the feature detect\r\n   * @param {function|boolean} [res] - A feature detection function, or the boolean =\r\n   * result of a feature detection function\r\n   */\r\n\r\n  ModernizrProto._trigger = function(feature, res) {\r\n    if (!this._l[feature]) {\r\n      return;\r\n    }\r\n\r\n    var cbs = this._l[feature];\r\n\r\n    // Force async\r\n    setTimeout(function() {\r\n      var i, cb;\r\n      for (i = 0; i < cbs.length; i++) {\r\n        cb = cbs[i];\r\n        cb(res);\r\n      }\r\n    }, 0);\r\n\r\n    // Don't trigger these again\r\n    delete this._l[feature];\r\n  };\r\n\r\n  /**\r\n   * addTest allows you to define your own feature detects that are not currently\r\n   * included in Modernizr (under the covers it's the exact same code Modernizr\r\n   * uses for its own [feature detections](https://github.com/Modernizr/Modernizr/tree/master/feature-detects)). Just like the offical detects, the result\r\n   * will be added onto the Modernizr object, as well as an appropriate className set on\r\n   * the html element when configured to do so\r\n   *\r\n   * @memberof Modernizr\r\n   * @name Modernizr.addTest\r\n   * @optionName Modernizr.addTest()\r\n   * @optionProp addTest\r\n   * @access public\r\n   * @function addTest\r\n   * @param {string|object} feature - The string name of the feature detect, or an\r\n   * object of feature detect names and test\r\n   * @param {function|boolean} test - Function returning true if feature is supported,\r\n   * false if not. Otherwise a boolean representing the results of a feature detection\r\n   * @example\r\n   *\r\n   * The most common way of creating your own feature detects is by calling\r\n   * `Modernizr.addTest` with a string (preferably just lowercase, without any\r\n   * punctuation), and a function you want executed that will return a boolean result\r\n   *\r\n   * ```js\r\n   * Modernizr.addTest('itsTuesday', function() {\r\n   *  var d = new Date();\r\n   *  return d.getDay() === 2;\r\n   * });\r\n   * ```\r\n   *\r\n   * When the above is run, it will set Modernizr.itstuesday to `true` when it is tuesday,\r\n   * and to `false` every other day of the week. One thing to notice is that the names of\r\n   * feature detect functions are always lowercased when added to the Modernizr object. That\r\n   * means that `Modernizr.itsTuesday` will not exist, but `Modernizr.itstuesday` will.\r\n   *\r\n   *\r\n   *  Since we only look at the returned value from any feature detection function,\r\n   *  you do not need to actually use a function. For simple detections, just passing\r\n   *  in a statement that will return a boolean value works just fine.\r\n   *\r\n   * ```js\r\n   * Modernizr.addTest('hasJquery', 'jQuery' in window);\r\n   * ```\r\n   *\r\n   * Just like before, when the above runs `Modernizr.hasjquery` will be true if\r\n   * jQuery has been included on the page. Not using a function saves a small amount\r\n   * of overhead for the browser, as well as making your code much more readable.\r\n   *\r\n   * Finally, you also have the ability to pass in an object of feature names and\r\n   * their tests. This is handy if you want to add multiple detections in one go.\r\n   * The keys should always be a string, and the value can be either a boolean or\r\n   * function that returns a boolean.\r\n   *\r\n   * ```js\r\n   * var detects = {\r\n   *  'hasjquery': 'jQuery' in window,\r\n   *  'itstuesday': function() {\r\n   *    var d = new Date();\r\n   *    return d.getDay() === 2;\r\n   *  }\r\n   * }\r\n   *\r\n   * Modernizr.addTest(detects);\r\n   * ```\r\n   *\r\n   * There is really no difference between the first methods and this one, it is\r\n   * just a convenience to let you write more readable code.\r\n   */\r\n\r\n  function addTest(feature, test) {\r\n\r\n    if (typeof feature == 'object') {\r\n      for (var key in feature) {\r\n        if (hasOwnProp(feature, key)) {\r\n          addTest(key, feature[ key ]);\r\n        }\r\n      }\r\n    } else {\r\n\r\n      feature = feature.toLowerCase();\r\n      var featureNameSplit = feature.split('.');\r\n      var last = Modernizr[featureNameSplit[0]];\r\n\r\n      // Again, we don't check for parent test existence. Get that right, though.\r\n      if (featureNameSplit.length == 2) {\r\n        last = last[featureNameSplit[1]];\r\n      }\r\n\r\n      if (typeof last != 'undefined') {\r\n        // we're going to quit if you're trying to overwrite an existing test\r\n        // if we were to allow it, we'd do this:\r\n        //   var re = new RegExp(\"\\\\b(no-)?\" + feature + \"\\\\b\");\r\n        //   docElement.className = docElement.className.replace( re, '' );\r\n        // but, no rly, stuff 'em.\r\n        return Modernizr;\r\n      }\r\n\r\n      test = typeof test == 'function' ? test() : test;\r\n\r\n      // Set the value (this is the magic, right here).\r\n      if (featureNameSplit.length == 1) {\r\n        Modernizr[featureNameSplit[0]] = test;\r\n      } else {\r\n        // cast to a Boolean, if not one already\r\n        /* jshint -W053 */\r\n        if (Modernizr[featureNameSplit[0]] && !(Modernizr[featureNameSplit[0]] instanceof Boolean)) {\r\n          Modernizr[featureNameSplit[0]] = new Boolean(Modernizr[featureNameSplit[0]]);\r\n        }\r\n\r\n        Modernizr[featureNameSplit[0]][featureNameSplit[1]] = test;\r\n      }\r\n\r\n      // Set a single class (either `feature` or `no-feature`)\r\n      /* jshint -W041 */\r\n      setClasses([(!!test && test != false ? '' : 'no-') + featureNameSplit.join('-')]);\r\n      /* jshint +W041 */\r\n\r\n      // Trigger the event\r\n      Modernizr._trigger(feature, test);\r\n    }\r\n\r\n    return Modernizr; // allow chaining.\r\n  }\r\n\r\n  // After all the tests are run, add self to the Modernizr prototype\r\n  Modernizr._q.push(function() {\r\n    ModernizrProto.addTest = addTest;\r\n  });\r\n\r\n  \r\n\r\n/*!\r\n{\r\n  \"name\": \"SVG as an <img> tag source\",\r\n  \"property\": \"svgasimg\",\r\n  \"caniuse\" : \"svg-img\",\r\n  \"tags\": [\"svg\"],\r\n  \"authors\": [\"Chris Coyier\"],\r\n  \"notes\": [{\r\n    \"name\": \"HTML5 Spec\",\r\n    \"href\": \"http://www.w3.org/TR/html5/embedded-content-0.html#the-img-element\"\r\n  }]\r\n}\r\n!*/\r\n\r\n\r\n  // Original Async test by Stu Cox\r\n  // https://gist.github.com/chriscoyier/8774501\r\n\r\n  // Now a Sync test based on good results here\r\n  // http://codepen.io/chriscoyier/pen/bADFx\r\n\r\n  // Note http://www.w3.org/TR/SVG11/feature#Image is *supposed* to represent\r\n  // support for the `<image>` tag in SVG, not an SVG file linked from an `<img>`\r\n  // tag in HTML – but it’s a heuristic which works\r\n  Modernizr.addTest('svgasimg', document.implementation.hasFeature('http://www.w3.org/TR/SVG11/feature#Image', '1.1'));\r\n\r\n\r\n  /**\r\n   * Object.prototype.toString can be used with every object and allows you to\r\n   * get its class easily. Abstracting it off of an object prevents situations\r\n   * where the toString property has been overridden\r\n   *\r\n   * @access private\r\n   * @function toStringFn\r\n   * @returns {function} An abstracted toString function\r\n   */\r\n\r\n  var toStringFn = ({}).toString;\r\n  \r\n/*!\r\n{\r\n  \"name\": \"SVG clip paths\",\r\n  \"property\": \"svgclippaths\",\r\n  \"tags\": [\"svg\"],\r\n  \"notes\": [{\r\n    \"name\": \"Demo\",\r\n    \"href\": \"http://srufaculty.sru.edu/david.dailey/svg/newstuff/clipPath4.svg\"\r\n  }]\r\n}\r\n!*/\r\n/* DOC\r\nDetects support for clip paths in SVG (only, not on HTML content).\r\n\r\nSee [this discussion](https://github.com/Modernizr/Modernizr/issues/213) regarding applying SVG clip paths to HTML content.\r\n*/\r\n\r\n  Modernizr.addTest('svgclippaths', function() {\r\n    return !!document.createElementNS &&\r\n      /SVGClipPath/.test(toStringFn.call(document.createElementNS('http://www.w3.org/2000/svg', 'clipPath')));\r\n  });\r\n\r\n/*!\r\n{\r\n  \"name\": \"SVG filters\",\r\n  \"property\": \"svgfilters\",\r\n  \"caniuse\": \"svg-filters\",\r\n  \"tags\": [\"svg\"],\r\n  \"builderAliases\": [\"svg_filters\"],\r\n  \"authors\": [\"Erik Dahlstrom\"],\r\n  \"notes\": [{\r\n    \"name\": \"W3C Spec\",\r\n    \"href\": \"https://www.w3.org/TR/SVG11/filters.html\"\r\n  }]\r\n}\r\n!*/\r\n\r\n  // Should fail in Safari: https://stackoverflow.com/questions/9739955/feature-detecting-support-for-svg-filters.\r\n  Modernizr.addTest('svgfilters', function() {\r\n    var result = false;\r\n    try {\r\n      result = 'SVGFEColorMatrixElement' in window &&\r\n        SVGFEColorMatrixElement.SVG_FECOLORMATRIX_TYPE_SATURATE == 2;\r\n    }\r\n    catch (e) {}\r\n    return result;\r\n  });\r\n\r\n/*!\r\n{\r\n  \"name\": \"SVG foreignObject\",\r\n  \"property\": \"svgforeignobject\",\r\n  \"tags\": [\"svg\"],\r\n  \"notes\": [{\r\n    \"name\": \"W3C Spec\",\r\n    \"href\": \"https://www.w3.org/TR/SVG11/extend.html\"\r\n  }]\r\n}\r\n!*/\r\n/* DOC\r\nDetects support for foreignObject tag in SVG.\r\n*/\r\n\r\n  Modernizr.addTest('svgforeignobject', function() {\r\n    return !!document.createElementNS &&\r\n      /SVGForeignObject/.test(toStringFn.call(document.createElementNS('http://www.w3.org/2000/svg', 'foreignObject')));\r\n  });\r\n\r\n/*!\r\n{\r\n  \"name\": \"Inline SVG\",\r\n  \"property\": \"inlinesvg\",\r\n  \"caniuse\": \"svg-html5\",\r\n  \"tags\": [\"svg\"],\r\n  \"notes\": [{\r\n    \"name\": \"Test page\",\r\n    \"href\": \"https://paulirish.com/demo/inline-svg\"\r\n  }, {\r\n    \"name\": \"Test page and results\",\r\n    \"href\": \"https://codepen.io/eltonmesquita/full/GgXbvo/\"\r\n  }],\r\n  \"polyfills\": [\"inline-svg-polyfill\"],\r\n  \"knownBugs\": [\"False negative on some Chromia browsers.\"]\r\n}\r\n!*/\r\n/* DOC\r\nDetects support for inline SVG in HTML (not within XHTML).\r\n*/\r\n\r\n  Modernizr.addTest('inlinesvg', function() {\r\n    var div = createElement('div');\r\n    div.innerHTML = '<svg/>';\r\n    return (typeof SVGRect != 'undefined' && div.firstChild && div.firstChild.namespaceURI) == 'http://www.w3.org/2000/svg';\r\n  });\r\n\r\n/*!\r\n{\r\n  \"name\": \"SVG SMIL animation\",\r\n  \"property\": \"smil\",\r\n  \"caniuse\": \"svg-smil\",\r\n  \"tags\": [\"svg\"],\r\n  \"notes\": [{\r\n  \"name\": \"W3C Synchronised Multimedia spec\",\r\n  \"href\": \"https://www.w3.org/AudioVideo/\"\r\n  }]\r\n}\r\n!*/\r\n\r\n  // SVG SMIL animation\r\n  Modernizr.addTest('smil', function() {\r\n    return !!document.createElementNS &&\r\n      /SVGAnimate/.test(toStringFn.call(document.createElementNS('http://www.w3.org/2000/svg', 'animate')));\r\n  });\r\n\r\n/*!\r\n{\r\n  \"name\": \"Local Storage\",\r\n  \"property\": \"localstorage\",\r\n  \"caniuse\": \"namevalue-storage\",\r\n  \"tags\": [\"storage\"],\r\n  \"knownBugs\": [],\r\n  \"notes\": [],\r\n  \"warnings\": [],\r\n  \"polyfills\": [\r\n    \"joshuabell-polyfill\",\r\n    \"cupcake\",\r\n    \"storagepolyfill\",\r\n    \"amplifyjs\",\r\n    \"yui-cacheoffline\"\r\n  ]\r\n}\r\n!*/\r\n\r\n  // In FF4, if disabled, window.localStorage should === null.\r\n\r\n  // Normally, we could not test that directly and need to do a\r\n  //   `('localStorage' in window) && ` test first because otherwise Firefox will\r\n  //   throw bugzil.la/365772 if cookies are disabled\r\n\r\n  // Also in iOS5 Private Browsing mode, attempting to use localStorage.setItem\r\n  // will throw the exception:\r\n  //   QUOTA_EXCEEDED_ERROR DOM Exception 22.\r\n  // Peculiarly, getItem and removeItem calls do not throw.\r\n\r\n  // Because we are forced to try/catch this, we'll go aggressive.\r\n\r\n  // Just FWIW: IE8 Compat mode supports these features completely:\r\n  //   www.quirksmode.org/dom/html5.html\r\n  // But IE8 doesn't support either with local files\r\n\r\n  Modernizr.addTest('localstorage', function() {\r\n    var mod = 'modernizr';\r\n    try {\r\n      localStorage.setItem(mod, mod);\r\n      localStorage.removeItem(mod);\r\n      return true;\r\n    } catch (e) {\r\n      return false;\r\n    }\r\n  });\r\n\r\n/*!\r\n{\r\n  \"name\": \"Session Storage\",\r\n  \"property\": \"sessionstorage\",\r\n  \"tags\": [\"storage\"],\r\n  \"polyfills\": [\"joshuabell-polyfill\", \"cupcake\", \"sessionstorage\"]\r\n}\r\n!*/\r\n\r\n  // Because we are forced to try/catch this, we'll go aggressive.\r\n\r\n  // Just FWIW: IE8 Compat mode supports these features completely:\r\n  //   www.quirksmode.org/dom/html5.html\r\n  // But IE8 doesn't support either with local files\r\n  Modernizr.addTest('sessionstorage', function() {\r\n    var mod = 'modernizr';\r\n    try {\r\n      sessionStorage.setItem(mod, mod);\r\n      sessionStorage.removeItem(mod);\r\n      return true;\r\n    } catch (e) {\r\n      return false;\r\n    }\r\n  });\r\n\r\n/*!\r\n{\r\n  \"name\": \"Web SQL Database\",\r\n  \"property\": \"websqldatabase\",\r\n  \"caniuse\": \"sql-storage\",\r\n  \"tags\": [\"storage\"]\r\n}\r\n!*/\r\n\r\n  // Chrome incognito mode used to throw an exception when using openDatabase\r\n  // It doesn't anymore.\r\n  Modernizr.addTest('websqldatabase', 'openDatabase' in window);\r\n\r\n/*!\r\n{\r\n  \"name\": \"CSS Multiple Backgrounds\",\r\n  \"caniuse\": \"multibackgrounds\",\r\n  \"property\": \"multiplebgs\",\r\n  \"tags\": [\"css\"]\r\n}\r\n!*/\r\n\r\n  // Setting multiple images AND a color on the background shorthand property\r\n  // and then querying the style.background property value for the number of\r\n  // occurrences of \"url(\" is a reliable method for detecting ACTUAL support for this!\r\n\r\n  Modernizr.addTest('multiplebgs', function() {\r\n    var style = createElement('a').style;\r\n    style.cssText = 'background:url(https://),url(https://),red url(https://)';\r\n\r\n    // If the UA supports multiple backgrounds, there should be three occurrences\r\n    // of the string \"url(\" in the return value for elemStyle.background\r\n    return (/(url\\s*\\(.*?){3}/).test(style.background);\r\n  });\r\n\r\n\r\n  // Run each test\r\n  testRunner();\r\n\r\n  // Remove the \"no-js\" class if it exists\r\n  setClasses(classes);\r\n\r\n  delete ModernizrProto.addTest;\r\n  delete ModernizrProto.addAsyncTest;\r\n\r\n  // Run the things that are supposed to run after the tests\r\n  for (var i = 0; i < Modernizr._q.length; i++) {\r\n    Modernizr._q[i]();\r\n  }\r\n\r\n  // Leak Modernizr namespace\r\n  window.Modernizr = Modernizr;\r\n\r\n\r\n;\r\n\r\n})(window, document);","import { Component, OnInit } from '@angular/core';\r\n\r\nimport { UserblockService } from './userblock.service';\r\n\r\n@Component({\r\n    selector: 'app-userblock',\r\n    templateUrl: './userblock.component.html',\r\n    styleUrls: ['./userblock.component.scss']\r\n})\r\n\r\nexport class UserblockComponent implements OnInit {\r\n\r\n    constructor(\r\n        public service: UserblockService) {\r\n\r\n    }\r\n\r\n    ngOnInit() {\r\n    }\r\n\r\n    userBlockIsVisible() {\r\n        return this.service.getVisibility();\r\n    }\r\n\r\n}\r\n","<div class=\"item user-block\" *ngIf=\"userBlockIsVisible()\">\r\n  <div>\r\n    <img class=\"img-fluid\" sizes=\"100%\" src=\"assets/img/logo/AGAT.logo.air.png\" alt=\"AGAT\" />\r\n  </div>\r\n</div>\r\n","\r\nimport './modernizr.js'; // 'npm run modernizr' to create this file\r\n\r\nimport '../node_modules/jquery-slimscroll/jquery.slimscroll.js';\r\n\r\nimport '../node_modules/codemirror/lib/codemirror.js';\r\nimport '../node_modules/codemirror/mode/javascript/javascript.js';\r\nimport '../node_modules/codemirror/mode/xml/xml.js';\r\nimport '../node_modules/codemirror/mode/htmlmixed/htmlmixed.js';\r\nimport '../node_modules/codemirror/mode/css/css.js';\r\n","import { Directive, Input, OnInit, OnDestroy, ElementRef, OnChanges, SimpleChange } from '@angular/core';\r\ndeclare var $: any;\r\n\r\n@Directive({\r\n    selector: '[jqcloud]'\r\n})\r\nexport class JqcloudDirective implements OnInit, OnDestroy, OnChanges {\r\n\r\n    @Input() words;\r\n    @Input() width;\r\n    @Input() height;\r\n    @Input() steps;\r\n    $elem: any;\r\n    options: any;\r\n    initialized = false; // flag to not update before plugin was initialized\r\n\r\n    constructor(element: ElementRef) {\r\n        this.$elem = $(element.nativeElement);\r\n        this.options = $.fn.jQCloud.defaults.get();\r\n    }\r\n\r\n    ngOnInit() {\r\n        let opts: any = {};\r\n        if (this.width) {\r\n            opts.width = this.width;\r\n        }\r\n        if (this.height) {\r\n            opts.height = this.height;\r\n        }\r\n        if (this.steps) {\r\n            opts.steps = this.steps;\r\n        }\r\n\r\n        $.extend(this.options, opts);\r\n        this.$elem.jQCloud(this.words, opts);\r\n        this.initialized = true;\r\n    }\r\n\r\n    ngOnChanges(changes: { [propertyName: string]: SimpleChange }) {\r\n        if (this.initialized && this.words && changes['words']) {\r\n            this.$elem.jQCloud('update', this.words);\r\n        }\r\n    }\r\n\r\n    ngOnDestroy() {\r\n        this.$elem.jQCloud('destroy');\r\n    }\r\n}\r\n","import { Component, OnInit } from '@angular/core';\r\nimport { SettingsService } from '../../../core/settings/settings.service';\r\n\r\n@Component({\r\n  selector: 'app-error404',\r\n  templateUrl: './error404.component.html',\r\n  styleUrls: ['./error404.component.scss']\r\n})\r\nexport class Error404Component implements OnInit {\r\n\r\n  constructor(public settings: SettingsService) { }\r\n\r\n  ngOnInit() {\r\n  }\r\n\r\n}\r\n","<div class=\"wrapper\">\r\n    <div class=\"abs-center wd-xl\">\r\n        <!-- START card-->\r\n        <div class=\"text-center mb-4\">\r\n            <div class=\"text-lg mb-3\">404</div>\r\n            <p class=\"lead m0\">We couldn't find this page.</p>\r\n            <p>The page you are looking for does not exists.</p>\r\n        </div>\r\n        <div class=\"input-group mb-4\">\r\n            <input class=\"form-control\" type=\"text\" placeholder=\"Try with a search\" />\r\n            <span class=\"input-group-btn\">\r\n                <button class=\"btn btn-secondary\" type=\"button\">\r\n                    <em class=\"fa fa-search\"></em>\r\n                </button>\r\n            </span>\r\n        </div>\r\n        <ul class=\"list-inline text-center text-sm mb-4\">\r\n            <li class=\"list-inline-item\">\r\n                <a class=\"text-muted\" [routerLink]=\"'/home'\">Go to App</a>\r\n            </li>\r\n            <li class=\"text-muted list-inline-item\">|</li>\r\n            <li class=\"list-inline-item\">\r\n                <a class=\"text-muted\" [routerLink]=\"'/login'\">Login</a>\r\n            </li>\r\n            <li class=\"text-muted list-inline-item\">|</li>\r\n            <li class=\"list-inline-item\">\r\n                <a class=\"text-muted\" [routerLink]=\"'/register'\">Register</a>\r\n            </li>\r\n        </ul>\r\n        <div class=\"p-3 text-center\">\r\n            <span>&copy;</span>\r\n            <span>{{ settings.getAppSetting('year') }}</span>\r\n            <span class=\"mx-2\">-</span>\r\n            <span>{{ settings.getAppSetting('name') }}</span>\r\n            <br/>\r\n            <span>{{ settings.getAppSetting('description') }}</span>\r\n        </div>\r\n    </div>\r\n</div>\r\n","import { Injectable } from '@angular/core';\r\n\r\n@Injectable()\r\n\r\nexport class UserblockService {\r\n\r\n    public userBlockVisible: boolean;\r\n\r\n    constructor() {\r\n        // initially visible\r\n        this.userBlockVisible = true;\r\n    }\r\n\r\n    getVisibility() {\r\n        return this.userBlockVisible;\r\n    }\r\n    setVisibility(stat = true) {\r\n        this.userBlockVisible = stat;\r\n    }\r\n    toggleVisibility() {\r\n        this.userBlockVisible = !this.userBlockVisible;\r\n    }\r\n\r\n}\r\n","import { NgModule, Optional, SkipSelf } from '@angular/core';\r\n\r\nimport { MenuService } from './menu/menu.service';\r\nimport { SettingsService } from './settings/settings.service';\r\nimport { ThemeService } from './theme/theme.service';\r\nimport { TranslatorService } from './translator/translator.service';\r\n\r\nimport { throwIfAlreadyLoaded } from './module-import-guard';\r\n\r\n@NgModule({\r\n    imports: [\r\n    ],\r\n    providers: [\r\n        SettingsService,\r\n        ThemeService,\r\n        TranslatorService,\r\n        MenuService\r\n    ],\r\n    declarations: [\r\n    ],\r\n    exports: [\r\n    ]\r\n})\r\nexport class CoreModule {\r\n\r\n    constructor(\r\n        @Optional() @SkipSelf() parentModule: CoreModule) {\r\n        throwIfAlreadyLoaded(parentModule, 'CoreModule');\r\n    }\r\n\r\n}\r\n","import { Component, OnInit } from '@angular/core';\r\n\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { LoginService } from '../core/service/login.service';\r\n\r\n@Component({\r\n    selector: 'app-layout',\r\n    templateUrl: './layout.component.html',\r\n    styleUrls: ['./layout.component.scss']\r\n})\r\n\r\nexport class LayoutComponent implements OnInit {\r\n\r\n    isLoggedIn$: Observable<boolean>;\r\n\r\n    constructor(\r\n        private login: LoginService) {\r\n        this.isLoggedIn$ = this.login.isLoggedIn;\r\n    }\r\n\r\n    ngOnInit() {\r\n    }\r\n\r\n}\r\n","<div class=\"wrapper\" *ngIf=\"isLoggedIn$ | async\">\r\n  <!-- top navbar-->\r\n  <app-header class=\"topnavbar-wrapper\" *ngIf=\"isLoggedIn$ | async\"></app-header>\r\n  <!-- sidebar-->\r\n  <app-sidebar class=\"aside-container\" *ngIf=\"isLoggedIn$ | async\"></app-sidebar>\r\n  <!-- offsidebar-->\r\n  <app-offsidebar class=\"offsidebar\" *ngIf=\"isLoggedIn$ | async\"></app-offsidebar>\r\n  <!-- main section-->\r\n  <section class=\"section-container\" *ngIf=\"isLoggedIn$ | async\">\r\n    <!-- page content-->\r\n    <div class=\"content-wrapper\" *ngIf=\"isLoggedIn$ | async\">\r\n      <router-outlet></router-outlet>\r\n    </div>\r\n  </section>\r\n</div>\r\n<div class=\"wrapper\" *ngIf=\"!(isLoggedIn$ | async)\">\r\n    <!-- page content-->\r\n    <div class=\"content-wrapper\">\r\n      <router-outlet></router-outlet>\r\n    </div>\r\n</div>\r\n","import { NgModule } from '@angular/core';\r\nimport { RouterModule } from '@angular/router';\r\n\r\nimport { TranslatorService } from '../core/translator/translator.service';\r\nimport { MenuService } from '../core/menu/menu.service';\r\nimport { SharedModule } from '../shared/shared.module';\r\nimport { PageModule } from './page/page.module';\r\n\r\nimport { routes } from './routes';\r\n\r\n@NgModule({\r\n    imports: [\r\n        SharedModule,\r\n        RouterModule.forRoot(routes, { relativeLinkResolution: 'legacy' }),\r\n        PageModule\r\n    ],\r\n    declarations: [\r\n],\r\n    exports: [\r\n        RouterModule\r\n    ]\r\n})\r\n\r\nexport class RoutesModule {\r\n    constructor(\r\n        public menu: MenuService,\r\n        tr: TranslatorService) {\r\n    }\r\n}\r\n","import { OnInit, OnDestroy, Directive, Input, ElementRef } from '@angular/core';\r\nimport * as moment from 'moment';\r\n\r\n@Directive({\r\n    selector: '[now]'\r\n})\r\nexport class NowDirective implements OnInit, OnDestroy {\r\n\r\n    @Input() format;\r\n    intervalId;\r\n\r\n    constructor(public element: ElementRef) { }\r\n\r\n    ngOnInit() {\r\n        this.updateTime();\r\n        this.intervalId = setInterval(this.updateTime.bind(this), 1000);\r\n    }\r\n\r\n    updateTime() {\r\n        let dt = moment().format(this.format);\r\n        this.element.nativeElement.innerHTML = dt;\r\n    }\r\n\r\n    ngOnDestroy() {\r\n        clearInterval(this.intervalId);\r\n    }\r\n\r\n}\r\n","/*!\r\n *\r\n * Angle - Bootstrap Admin Template\r\n *\r\n * Version: 4.7.8\r\n * Author: @themicon_co\r\n * Website: http://themicon.co\r\n * License: https://wrapbootstrap.com/help/licenses\r\n *\r\n */\r\n\r\nimport './vendor.ts';\r\nimport { enableProdMode } from '@angular/core';\r\nimport { platformBrowserDynamic } from '@angular/platform-browser-dynamic';\r\nimport \"jquery\";\r\nimport { AppModule } from './app/app.module';\r\nimport { environment } from './environments/environment';\r\n\r\nif (environment.production) {\r\n    enableProdMode();\r\n}\r\n\r\nexport function getBaseUrl() {\r\n    return document.getElementsByTagName('base')[0].href;\r\n}\r\n\r\nconst providers = [{ provide: 'BASE_URL', useFactory: getBaseUrl, deps: [] }];\r\n\r\nlet p = platformBrowserDynamic(providers).bootstrapModule(AppModule);\r\np.then(() => { (<any>window).appBootstrap && (<any>window).appBootstrap(); })\r\n// .catch(err => console.error(err));\r\n","function webpackEmptyAsyncContext(req) {\n\t// Here Promise.resolve().then() is used instead of new Promise() to prevent\n\t// uncaught exception popping up in devtools\n\treturn Promise.resolve().then(function() {\n\t\tvar e = new Error(\"Cannot find module '\" + req + \"'\");\n\t\te.code = 'MODULE_NOT_FOUND';\n\t\tthrow e;\n\t});\n}\nwebpackEmptyAsyncContext.keys = function() { return []; };\nwebpackEmptyAsyncContext.resolve = webpackEmptyAsyncContext;\nmodule.exports = webpackEmptyAsyncContext;\nwebpackEmptyAsyncContext.id = \"zn8P\";"]}