diff --git a/README.md b/README.md
index 4f685336..16c7b586 100644
--- a/README.md
+++ b/README.md
@@ -55,12 +55,6 @@ $ npm install @coreui/angular --save
$ yarn add @coreui/angular@2.0.0
```
-### Composer
-
-``` bash
-$ composer require coreui/coreui-angular:2.0.0
-```
-
## Usage
### CSS
diff --git a/angular.json b/angular.json
new file mode 100644
index 00000000..9a211136
--- /dev/null
+++ b/angular.json
@@ -0,0 +1,162 @@
+{
+ "$schema": "./node_modules/@angular/cli/lib/config/schema.json",
+ "version": 1,
+ "newProjectRoot": "projects",
+ "projects": {
+ "coreui": {
+ "root": "",
+ "sourceRoot": "src",
+ "projectType": "application",
+ "prefix": "app",
+ "schematics": {},
+ "architect": {
+ "build": {
+ "builder": "@angular-devkit/build-angular:browser",
+ "options": {
+ "outputPath": "dist/coreui",
+ "index": "src/index.html",
+ "main": "src/main.ts",
+ "polyfills": "src/polyfills.ts",
+ "tsConfig": "src/tsconfig.app.json",
+ "assets": [
+ "src/favicon.ico",
+ "src/assets"
+ ],
+ "styles": [
+ "src/styles.css"
+ ],
+ "scripts": []
+ },
+ "configurations": {
+ "production": {
+ "fileReplacements": [
+ {
+ "replace": "src/environments/environment.ts",
+ "with": "src/environments/environment.prod.ts"
+ }
+ ],
+ "optimization": true,
+ "outputHashing": "all",
+ "sourceMap": false,
+ "extractCss": true,
+ "namedChunks": false,
+ "aot": true,
+ "extractLicenses": true,
+ "vendorChunk": false,
+ "buildOptimizer": true
+ }
+ }
+ },
+ "serve": {
+ "builder": "@angular-devkit/build-angular:dev-server",
+ "options": {
+ "browserTarget": "coreui:build"
+ },
+ "configurations": {
+ "production": {
+ "browserTarget": "coreui:build:production"
+ }
+ }
+ },
+ "extract-i18n": {
+ "builder": "@angular-devkit/build-angular:extract-i18n",
+ "options": {
+ "browserTarget": "coreui:build"
+ }
+ },
+ "test": {
+ "builder": "@angular-devkit/build-angular:karma",
+ "options": {
+ "main": "src/test.ts",
+ "polyfills": "src/polyfills.ts",
+ "tsConfig": "src/tsconfig.spec.json",
+ "karmaConfig": "src/karma.conf.js",
+ "styles": [
+ "styles.css"
+ ],
+ "scripts": [],
+ "assets": [
+ "src/favicon.ico",
+ "src/assets"
+ ]
+ }
+ },
+ "lint": {
+ "builder": "@angular-devkit/build-angular:tslint",
+ "options": {
+ "tsConfig": [
+ "src/tsconfig.app.json",
+ "src/tsconfig.spec.json"
+ ],
+ "exclude": [
+ "**/node_modules/**"
+ ]
+ }
+ }
+ }
+ },
+ "coreui-e2e": {
+ "root": "e2e/",
+ "projectType": "application",
+ "architect": {
+ "e2e": {
+ "builder": "@angular-devkit/build-angular:protractor",
+ "options": {
+ "protractorConfig": "e2e/protractor.conf.js",
+ "devServerTarget": "coreui:serve"
+ }
+ },
+ "lint": {
+ "builder": "@angular-devkit/build-angular:tslint",
+ "options": {
+ "tsConfig": "e2e/tsconfig.e2e.json",
+ "exclude": [
+ "**/node_modules/**"
+ ]
+ }
+ }
+ }
+ },
+ "@coreui/angular": {
+ "root": "projects/coreui/angular",
+ "sourceRoot": "projects/coreui/angular/src",
+ "projectType": "library",
+ "prefix": "lib",
+ "architect": {
+ "build": {
+ "builder": "@angular-devkit/build-ng-packagr:build",
+ "options": {
+ "tsConfig": "projects/coreui/angular/tsconfig.lib.json",
+ "project": "projects/coreui/angular/ng-package.json"
+ },
+ "configurations": {
+ "production": {
+ "project": "projects/coreui/angular/ng-package.prod.json"
+ }
+ }
+ },
+ "test": {
+ "builder": "@angular-devkit/build-angular:karma",
+ "options": {
+ "main": "projects/coreui/angular/src/test.ts",
+ "tsConfig": "projects/coreui/angular/tsconfig.spec.json",
+ "karmaConfig": "projects/coreui/angular/karma.conf.js"
+ }
+ },
+ "lint": {
+ "builder": "@angular-devkit/build-angular:tslint",
+ "options": {
+ "tsConfig": [
+ "projects/coreui/angular/tsconfig.lib.json",
+ "projects/coreui/angular/tsconfig.spec.json"
+ ],
+ "exclude": [
+ "**/node_modules/**"
+ ]
+ }
+ }
+ }
+ }
+ },
+ "defaultProject": "coreui"
+}
diff --git a/dist/@coreui/angular/bundles/coreui-angular.umd.js b/dist/@coreui/angular/bundles/coreui-angular.umd.js
new file mode 100644
index 00000000..b397e767
--- /dev/null
+++ b/dist/@coreui/angular/bundles/coreui-angular.umd.js
@@ -0,0 +1,1493 @@
+(function (global, factory) {
+ typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/common'), require('@angular/router'), require('rxjs/index'), require('rxjs/operators')) :
+ typeof define === 'function' && define.amd ? define('@coreui/angular', ['exports', '@angular/core', '@angular/common', '@angular/router', 'rxjs/index', 'rxjs/operators'], factory) :
+ (factory((global.coreui = global.coreui || {}, global.coreui.angular = {}),global.ng.core,global.ng.common,global.ng.router,global.Rx,global.Rx.Observable.prototype));
+}(this, (function (exports,core,common,router,index,operators) { 'use strict';
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var /** @type {?} */ sidebarCssClasses = [
+ 'sidebar-show',
+ 'sidebar-sm-show',
+ 'sidebar-md-show',
+ 'sidebar-lg-show',
+ 'sidebar-xl-show'
+ ];
+ var /** @type {?} */ asideMenuCssClasses = [
+ 'aside-menu-show',
+ 'aside-menu-sm-show',
+ 'aside-menu-md-show',
+ 'aside-menu-lg-show',
+ 'aside-menu-xl-show'
+ ];
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var /** @type {?} */ RemoveClasses = function (NewClassNames) {
+ var /** @type {?} */ MatchClasses = NewClassNames.map(function (Class) { return document.querySelector('body').classList.contains(Class); });
+ return MatchClasses.indexOf(true) !== -1;
+ };
+ var /** @type {?} */ ToggleClasses = function (Toggle, ClassNames) {
+ var /** @type {?} */ Level = ClassNames.indexOf(Toggle);
+ var /** @type {?} */ NewClassNames = ClassNames.slice(0, Level + 1);
+ if (RemoveClasses(NewClassNames)) {
+ NewClassNames.map(function (Class) { return document.querySelector('body').classList.remove(Class); });
+ }
+ else {
+ document.querySelector('body').classList.add(Toggle);
+ }
+ };
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ /**
+ * Allows the sidebar to be toggled via click.
+ */
+ var SidebarToggleDirective = (function () {
+ function SidebarToggleDirective() {
+ }
+ /**
+ * @return {?}
+ */
+ SidebarToggleDirective.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ this.bp = this.breakpoint;
+ };
+ /**
+ * @param {?} $event
+ * @return {?}
+ */
+ SidebarToggleDirective.prototype.toggleOpen = /**
+ * @param {?} $event
+ * @return {?}
+ */
+ function ($event) {
+ $event.preventDefault();
+ var /** @type {?} */ cssClass;
+ this.bp ? cssClass = "sidebar-" + this.bp + "-show" : cssClass = sidebarCssClasses[0];
+ ToggleClasses(cssClass, sidebarCssClasses);
+ };
+ SidebarToggleDirective.decorators = [
+ { type: core.Directive, args: [{
+ selector: '[appSidebarToggler]'
+ },] },
+ ];
+ /** @nocollapse */
+ SidebarToggleDirective.ctorParameters = function () { return []; };
+ SidebarToggleDirective.propDecorators = {
+ "breakpoint": [{ type: core.Input, args: ['appSidebarToggler',] },],
+ "toggleOpen": [{ type: core.HostListener, args: ['click', ['$event'],] },],
+ };
+ return SidebarToggleDirective;
+ }());
+ var SidebarMinimizeDirective = (function () {
+ function SidebarMinimizeDirective() {
+ }
+ /**
+ * @param {?} $event
+ * @return {?}
+ */
+ SidebarMinimizeDirective.prototype.toggleOpen = /**
+ * @param {?} $event
+ * @return {?}
+ */
+ function ($event) {
+ $event.preventDefault();
+ document.querySelector('body').classList.toggle('sidebar-minimized');
+ };
+ SidebarMinimizeDirective.decorators = [
+ { type: core.Directive, args: [{
+ selector: '[appSidebarMinimizer]'
+ },] },
+ ];
+ /** @nocollapse */
+ SidebarMinimizeDirective.ctorParameters = function () { return []; };
+ SidebarMinimizeDirective.propDecorators = {
+ "toggleOpen": [{ type: core.HostListener, args: ['click', ['$event'],] },],
+ };
+ return SidebarMinimizeDirective;
+ }());
+ var MobileSidebarToggleDirective = (function () {
+ function MobileSidebarToggleDirective() {
+ }
+ /**
+ * @param {?} target
+ * @param {?} elementClassName
+ * @return {?}
+ */
+ MobileSidebarToggleDirective.prototype.hasClass = /**
+ * @param {?} target
+ * @param {?} elementClassName
+ * @return {?}
+ */
+ function (target, elementClassName) {
+ return new RegExp('(\\s|^)' + elementClassName + '(\\s|$)').test(target.className);
+ };
+ /**
+ * @param {?} $event
+ * @return {?}
+ */
+ MobileSidebarToggleDirective.prototype.toggleOpen = /**
+ * @param {?} $event
+ * @return {?}
+ */
+ function ($event) {
+ $event.preventDefault();
+ document.querySelector('body').classList.toggle('sidebar-mobile-show');
+ };
+ MobileSidebarToggleDirective.decorators = [
+ { type: core.Directive, args: [{
+ selector: '[appMobileSidebarToggler]'
+ },] },
+ ];
+ /** @nocollapse */
+ MobileSidebarToggleDirective.ctorParameters = function () { return []; };
+ MobileSidebarToggleDirective.propDecorators = {
+ "toggleOpen": [{ type: core.HostListener, args: ['click', ['$event'],] },],
+ };
+ return MobileSidebarToggleDirective;
+ }());
+ /**
+ * Allows the off-canvas sidebar to be closed via click.
+ */
+ var SidebarOffCanvasCloseDirective = (function () {
+ function SidebarOffCanvasCloseDirective() {
+ }
+ /**
+ * @param {?} target
+ * @param {?} elementClassName
+ * @return {?}
+ */
+ SidebarOffCanvasCloseDirective.prototype.hasClass = /**
+ * @param {?} target
+ * @param {?} elementClassName
+ * @return {?}
+ */
+ function (target, elementClassName) {
+ return new RegExp('(\\s|^)' + elementClassName + '(\\s|$)').test(target.className);
+ };
+ /**
+ * @param {?} elem
+ * @param {?} elementClassName
+ * @return {?}
+ */
+ SidebarOffCanvasCloseDirective.prototype.toggleClass = /**
+ * @param {?} elem
+ * @param {?} elementClassName
+ * @return {?}
+ */
+ function (elem, elementClassName) {
+ var /** @type {?} */ newClass = ' ' + elem.className.replace(/[\t\r\n]/g, ' ') + ' ';
+ if (this.hasClass(elem, elementClassName)) {
+ while (newClass.indexOf(' ' + elementClassName + ' ') >= 0) {
+ newClass = newClass.replace(' ' + elementClassName + ' ', ' ');
+ }
+ elem.className = newClass.replace(/^\s+|\s+$/g, '');
+ }
+ else {
+ elem.className += ' ' + elementClassName;
+ }
+ };
+ /**
+ * @param {?} $event
+ * @return {?}
+ */
+ SidebarOffCanvasCloseDirective.prototype.toggleOpen = /**
+ * @param {?} $event
+ * @return {?}
+ */
+ function ($event) {
+ $event.preventDefault();
+ if (this.hasClass(document.querySelector('body'), 'sidebar-off-canvas')) {
+ this.toggleClass(document.querySelector('body'), 'sidebar-opened');
+ }
+ };
+ SidebarOffCanvasCloseDirective.decorators = [
+ { type: core.Directive, args: [{
+ selector: '[appSidebarClose]'
+ },] },
+ ];
+ /** @nocollapse */
+ SidebarOffCanvasCloseDirective.ctorParameters = function () { return []; };
+ SidebarOffCanvasCloseDirective.propDecorators = {
+ "toggleOpen": [{ type: core.HostListener, args: ['click', ['$event'],] },],
+ };
+ return SidebarOffCanvasCloseDirective;
+ }());
+ var BrandMinimizeDirective = (function () {
+ function BrandMinimizeDirective() {
+ }
+ /**
+ * @param {?} $event
+ * @return {?}
+ */
+ BrandMinimizeDirective.prototype.toggleOpen = /**
+ * @param {?} $event
+ * @return {?}
+ */
+ function ($event) {
+ $event.preventDefault();
+ document.querySelector('body').classList.toggle('brand-minimized');
+ };
+ BrandMinimizeDirective.decorators = [
+ { type: core.Directive, args: [{
+ selector: '[appBrandMinimizer]'
+ },] },
+ ];
+ /** @nocollapse */
+ BrandMinimizeDirective.ctorParameters = function () { return []; };
+ BrandMinimizeDirective.propDecorators = {
+ "toggleOpen": [{ type: core.HostListener, args: ['click', ['$event'],] },],
+ };
+ return BrandMinimizeDirective;
+ }());
+ /**
+ * Allows the aside to be toggled via click.
+ */
+ var AsideToggleDirective = (function () {
+ function AsideToggleDirective() {
+ }
+ /**
+ * @return {?}
+ */
+ AsideToggleDirective.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ this.bp = this.breakpoint;
+ };
+ /**
+ * @param {?} $event
+ * @return {?}
+ */
+ AsideToggleDirective.prototype.toggleOpen = /**
+ * @param {?} $event
+ * @return {?}
+ */
+ function ($event) {
+ $event.preventDefault();
+ var /** @type {?} */ cssClass;
+ this.bp ? cssClass = "aside-menu-" + this.bp + "-show" : cssClass = asideMenuCssClasses[0];
+ ToggleClasses(cssClass, asideMenuCssClasses);
+ };
+ AsideToggleDirective.decorators = [
+ { type: core.Directive, args: [{
+ selector: '[appAsideMenuToggler]',
+ },] },
+ ];
+ /** @nocollapse */
+ AsideToggleDirective.ctorParameters = function () { return []; };
+ AsideToggleDirective.propDecorators = {
+ "breakpoint": [{ type: core.Input, args: ['appAsideMenuToggler',] },],
+ "toggleOpen": [{ type: core.HostListener, args: ['click', ['$event'],] },],
+ };
+ return AsideToggleDirective;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var LayoutModule = (function () {
+ function LayoutModule() {
+ }
+ LayoutModule.decorators = [
+ { type: core.NgModule, args: [{
+ imports: [
+ common.CommonModule
+ ],
+ exports: [
+ AsideToggleDirective,
+ BrandMinimizeDirective,
+ MobileSidebarToggleDirective,
+ SidebarToggleDirective,
+ SidebarMinimizeDirective,
+ SidebarOffCanvasCloseDirective
+ ],
+ declarations: [
+ AsideToggleDirective,
+ BrandMinimizeDirective,
+ MobileSidebarToggleDirective,
+ SidebarToggleDirective,
+ SidebarMinimizeDirective,
+ SidebarOffCanvasCloseDirective
+ ]
+ },] },
+ ];
+ return LayoutModule;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ /**
+ * @param {?} el
+ * @return {?}
+ */
+ function Replace(el) {
+ var /** @type {?} */ nativeElement = el.nativeElement;
+ var /** @type {?} */ parentElement = nativeElement.parentElement;
+ // move all children out of the element
+ while (nativeElement.firstChild) {
+ parentElement.insertBefore(nativeElement.firstChild, nativeElement);
+ }
+ // remove the empty element(the host)
+ parentElement.removeChild(nativeElement);
+ }
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppAsideComponent = (function () {
+ function AppAsideComponent(el) {
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ AppAsideComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ Replace(this.el);
+ this.isFixed(this.fixed);
+ this.displayBreakpoint(this.display);
+ };
+ /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ AppAsideComponent.prototype.isFixed = /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ function (fixed) {
+ if (this.fixed) {
+ document.querySelector('body').classList.add('aside-menu-fixed');
+ }
+ };
+ /**
+ * @param {?} offCanvas
+ * @return {?}
+ */
+ AppAsideComponent.prototype.isOffCanvas = /**
+ * @param {?} offCanvas
+ * @return {?}
+ */
+ function (offCanvas) {
+ if (this.offCanvas) {
+ document.querySelector('body').classList.add('aside-menu-off-canvas');
+ }
+ };
+ /**
+ * @param {?} display
+ * @return {?}
+ */
+ AppAsideComponent.prototype.displayBreakpoint = /**
+ * @param {?} display
+ * @return {?}
+ */
+ function (display) {
+ if (this.display !== false) {
+ var /** @type {?} */ cssClass = void 0;
+ this.display ? cssClass = "aside-menu-" + this.display + "-show" : cssClass = asideMenuCssClasses[0];
+ document.querySelector('body').classList.add(cssClass);
+ }
+ };
+ AppAsideComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-aside',
+ template: "\n \n "
+ },] },
+ ];
+ /** @nocollapse */
+ AppAsideComponent.ctorParameters = function () {
+ return [
+ { type: core.ElementRef, },
+ ];
+ };
+ AppAsideComponent.propDecorators = {
+ "display": [{ type: core.Input },],
+ "fixed": [{ type: core.Input },],
+ "offCanvas": [{ type: core.Input },],
+ };
+ return AppAsideComponent;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppAsideModule = (function () {
+ function AppAsideModule() {
+ }
+ AppAsideModule.decorators = [
+ { type: core.NgModule, args: [{
+ imports: [
+ common.CommonModule,
+ LayoutModule
+ ],
+ exports: [
+ AppAsideComponent,
+ LayoutModule
+ ],
+ declarations: [
+ AppAsideComponent
+ ]
+ },] },
+ ];
+ return AppAsideModule;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppBreadcrumbService = (function () {
+ function AppBreadcrumbService(router$$1, route) {
+ var _this = this;
+ this.router = router$$1;
+ this.route = route;
+ this._breadcrumbs = new index.BehaviorSubject(new Array());
+ this.breadcrumbs = this._breadcrumbs.asObservable();
+ this.router.events.pipe(operators.filter(function (event) { return event instanceof router.NavigationEnd; })).subscribe(function (event) {
+ var /** @type {?} */ breadcrumbs = [];
+ var /** @type {?} */ currentRoute = _this.route.root, /** @type {?} */ url = '';
+ do {
+ var /** @type {?} */ childrenRoutes = currentRoute.children;
+ currentRoute = null;
+ // tslint:disable-next-line:no-shadowed-variable
+ childrenRoutes.forEach(function (route) {
+ if (route.outlet === 'primary') {
+ var /** @type {?} */ routeSnapshot = route.snapshot;
+ url += '/' + routeSnapshot.url.map(function (segment) { return segment.path; }).join('/');
+ breadcrumbs.push({
+ label: route.snapshot.data,
+ url: url
+ });
+ currentRoute = route;
+ }
+ });
+ } while (currentRoute);
+ _this._breadcrumbs.next(Object.assign([], breadcrumbs));
+ return breadcrumbs;
+ });
+ }
+ AppBreadcrumbService.decorators = [
+ { type: core.Injectable },
+ ];
+ /** @nocollapse */
+ AppBreadcrumbService.ctorParameters = function () {
+ return [
+ { type: router.Router, },
+ { type: router.ActivatedRoute, },
+ ];
+ };
+ return AppBreadcrumbService;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppBreadcrumbComponent = (function () {
+ function AppBreadcrumbComponent(service, el) {
+ this.service = service;
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ AppBreadcrumbComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ Replace(this.el);
+ this.isFixed(this.fixed);
+ this.breadcrumbs = this.service.breadcrumbs;
+ };
+ /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ AppBreadcrumbComponent.prototype.isFixed = /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ function (fixed) {
+ if (this.fixed) {
+ document.querySelector('body').classList.add('breadcrumb-fixed');
+ }
+ };
+ AppBreadcrumbComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-breadcrumb',
+ template: "\n \n \n {{breadcrumb.label.title}}\n {{breadcrumb.label.title}}\n \n \n "
+ },] },
+ ];
+ /** @nocollapse */
+ AppBreadcrumbComponent.ctorParameters = function () {
+ return [
+ { type: AppBreadcrumbService, },
+ { type: core.ElementRef, },
+ ];
+ };
+ AppBreadcrumbComponent.propDecorators = {
+ "fixed": [{ type: core.Input },],
+ };
+ return AppBreadcrumbComponent;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppBreadcrumbModule = (function () {
+ function AppBreadcrumbModule() {
+ }
+ /**
+ * @param {?=} config
+ * @return {?}
+ */
+ AppBreadcrumbModule.forRoot = /**
+ * @param {?=} config
+ * @return {?}
+ */
+ function (config) {
+ return {
+ ngModule: AppBreadcrumbModule,
+ providers: [
+ AppBreadcrumbService
+ ]
+ };
+ };
+ AppBreadcrumbModule.decorators = [
+ { type: core.NgModule, args: [{
+ imports: [common.CommonModule, router.RouterModule],
+ exports: [AppBreadcrumbComponent],
+ declarations: [AppBreadcrumbComponent]
+ },] },
+ ];
+ return AppBreadcrumbModule;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppFooterComponent = (function () {
+ function AppFooterComponent(el) {
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ AppFooterComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ Replace(this.el);
+ this.isFixed(this.fixed);
+ };
+ /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ AppFooterComponent.prototype.isFixed = /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ function (fixed) {
+ if (this.fixed) {
+ document.querySelector('body').classList.add('footer-fixed');
+ }
+ };
+ AppFooterComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-footer',
+ template: "\n \n "
+ },] },
+ ];
+ /** @nocollapse */
+ AppFooterComponent.ctorParameters = function () {
+ return [
+ { type: core.ElementRef, },
+ ];
+ };
+ AppFooterComponent.propDecorators = {
+ "fixed": [{ type: core.Input },],
+ };
+ return AppFooterComponent;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppFooterModule = (function () {
+ function AppFooterModule() {
+ }
+ AppFooterModule.decorators = [
+ { type: core.NgModule, args: [{
+ imports: [common.CommonModule],
+ exports: [AppFooterComponent],
+ declarations: [AppFooterComponent]
+ },] },
+ ];
+ return AppFooterModule;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppHeaderComponent = (function () {
+ function AppHeaderComponent(el) {
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ AppHeaderComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ Replace(this.el);
+ this.isFixed(this.fixed);
+ };
+ /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ AppHeaderComponent.prototype.isFixed = /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ function (fixed) {
+ if (this.fixed) {
+ document.querySelector('body').classList.add('header-fixed');
+ }
+ };
+ /**
+ * @param {?} brand
+ * @return {?}
+ */
+ AppHeaderComponent.prototype.imgSrc = /**
+ * @param {?} brand
+ * @return {?}
+ */
+ function (brand) {
+ return brand.src ? brand.src : '';
+ };
+ /**
+ * @param {?} brand
+ * @return {?}
+ */
+ AppHeaderComponent.prototype.imgWidth = /**
+ * @param {?} brand
+ * @return {?}
+ */
+ function (brand) {
+ return brand.width ? brand.width : 'auto';
+ };
+ /**
+ * @param {?} brand
+ * @return {?}
+ */
+ AppHeaderComponent.prototype.imgHeight = /**
+ * @param {?} brand
+ * @return {?}
+ */
+ function (brand) {
+ return brand.height ? brand.height : 'auto';
+ };
+ /**
+ * @param {?} brand
+ * @return {?}
+ */
+ AppHeaderComponent.prototype.imgAlt = /**
+ * @param {?} brand
+ * @return {?}
+ */
+ function (brand) {
+ return brand.alt ? brand.alt : '';
+ };
+ /**
+ * @param {?} breakpoint
+ * @return {?}
+ */
+ AppHeaderComponent.prototype.breakpoint = /**
+ * @param {?} breakpoint
+ * @return {?}
+ */
+ function (breakpoint) {
+ console.log(breakpoint);
+ return breakpoint ? breakpoint : '';
+ };
+ AppHeaderComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-header',
+ template: "\n \n "
+ },] },
+ ];
+ /** @nocollapse */
+ AppHeaderComponent.ctorParameters = function () {
+ return [
+ { type: core.ElementRef, },
+ ];
+ };
+ AppHeaderComponent.propDecorators = {
+ "fixed": [{ type: core.Input },],
+ "navbarBrand": [{ type: core.Input },],
+ "navbarBrandFull": [{ type: core.Input },],
+ "navbarBrandMinimized": [{ type: core.Input },],
+ "sidebarToggler": [{ type: core.Input },],
+ "mobileSidebarToggler": [{ type: core.Input },],
+ "asideMenuToggler": [{ type: core.Input },],
+ "mobileAsideMenuToggler": [{ type: core.Input },],
+ };
+ return AppHeaderComponent;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppHeaderModule = (function () {
+ function AppHeaderModule() {
+ }
+ AppHeaderModule.decorators = [
+ { type: core.NgModule, args: [{
+ imports: [
+ common.CommonModule,
+ LayoutModule
+ ],
+ exports: [
+ AppHeaderComponent,
+ LayoutModule
+ ],
+ declarations: [
+ AppHeaderComponent
+ ]
+ },] },
+ ];
+ return AppHeaderModule;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppSidebarFooterComponent = (function () {
+ function AppSidebarFooterComponent(el) {
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ AppSidebarFooterComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ Replace(this.el);
+ };
+ AppSidebarFooterComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-sidebar-footer',
+ template: "\n
"
+ },] },
+ ];
+ /** @nocollapse */
+ AppSidebarFooterComponent.ctorParameters = function () {
+ return [
+ { type: core.ElementRef, },
+ ];
+ };
+ return AppSidebarFooterComponent;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppSidebarFormComponent = (function () {
+ function AppSidebarFormComponent(el) {
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ AppSidebarFormComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ Replace(this.el);
+ };
+ AppSidebarFormComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-sidebar-form',
+ template: "\n \n "
+ },] },
+ ];
+ /** @nocollapse */
+ AppSidebarFormComponent.ctorParameters = function () {
+ return [
+ { type: core.ElementRef, },
+ ];
+ };
+ return AppSidebarFormComponent;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppSidebarHeaderComponent = (function () {
+ function AppSidebarHeaderComponent(el) {
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ AppSidebarHeaderComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ Replace(this.el);
+ };
+ AppSidebarHeaderComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-sidebar-header',
+ template: "\n \n "
+ },] },
+ ];
+ /** @nocollapse */
+ AppSidebarHeaderComponent.ctorParameters = function () {
+ return [
+ { type: core.ElementRef, },
+ ];
+ };
+ return AppSidebarHeaderComponent;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppSidebarMinimizerComponent = (function () {
+ function AppSidebarMinimizerComponent(el) {
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ AppSidebarMinimizerComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ Replace(this.el);
+ };
+ AppSidebarMinimizerComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-sidebar-minimizer',
+ template: "\n \n "
+ },] },
+ ];
+ /** @nocollapse */
+ AppSidebarMinimizerComponent.ctorParameters = function () {
+ return [
+ { type: core.ElementRef, },
+ ];
+ };
+ return AppSidebarMinimizerComponent;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppSidebarComponent = (function () {
+ function AppSidebarComponent() {
+ }
+ /**
+ * @return {?}
+ */
+ AppSidebarComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ this.displayBreakpoint(this.display);
+ this.isCompact(this.compact);
+ this.isFixed(this.fixed);
+ this.isMinimized(this.minimized);
+ this.isOffCanvas(this.offCanvas);
+ };
+ /**
+ * @param {?} compact
+ * @return {?}
+ */
+ AppSidebarComponent.prototype.isCompact = /**
+ * @param {?} compact
+ * @return {?}
+ */
+ function (compact) {
+ if (this.compact) {
+ document.querySelector('body').classList.add('sidebar-compact');
+ }
+ };
+ /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ AppSidebarComponent.prototype.isFixed = /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ function (fixed) {
+ if (this.fixed) {
+ document.querySelector('body').classList.add('sidebar-fixed');
+ }
+ };
+ /**
+ * @param {?} minimized
+ * @return {?}
+ */
+ AppSidebarComponent.prototype.isMinimized = /**
+ * @param {?} minimized
+ * @return {?}
+ */
+ function (minimized) {
+ if (this.minimized) {
+ document.querySelector('body').classList.add('sidebar-minimized');
+ }
+ };
+ /**
+ * @param {?} offCanvas
+ * @return {?}
+ */
+ AppSidebarComponent.prototype.isOffCanvas = /**
+ * @param {?} offCanvas
+ * @return {?}
+ */
+ function (offCanvas) {
+ if (this.offCanvas) {
+ document.querySelector('body').classList.add('sidebar-off-canvas');
+ }
+ };
+ /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ AppSidebarComponent.prototype.fixedPosition = /**
+ * @param {?} fixed
+ * @return {?}
+ */
+ function (fixed) {
+ if (this.fixed) {
+ document.querySelector('body').classList.add('sidebar-fixed');
+ }
+ };
+ /**
+ * @param {?} display
+ * @return {?}
+ */
+ AppSidebarComponent.prototype.displayBreakpoint = /**
+ * @param {?} display
+ * @return {?}
+ */
+ function (display) {
+ if (this.display !== false) {
+ var /** @type {?} */ cssClass = void 0;
+ this.display ? cssClass = "sidebar-" + this.display + "-show" : cssClass = sidebarCssClasses[0];
+ document.querySelector('body').classList.add(cssClass);
+ }
+ };
+ AppSidebarComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-sidebar',
+ template: ""
+ },] },
+ ];
+ /** @nocollapse */
+ AppSidebarComponent.ctorParameters = function () { return []; };
+ AppSidebarComponent.propDecorators = {
+ "compact": [{ type: core.Input },],
+ "display": [{ type: core.Input },],
+ "fixed": [{ type: core.Input },],
+ "minimized": [{ type: core.Input },],
+ "offCanvas": [{ type: core.Input },],
+ "true": [{ type: core.HostBinding, args: ['class.sidebar',] },],
+ };
+ return AppSidebarComponent;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var NavDropdownDirective = (function () {
+ function NavDropdownDirective(el) {
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ NavDropdownDirective.prototype.toggle = /**
+ * @return {?}
+ */
+ function () {
+ this.el.nativeElement.classList.toggle('open');
+ };
+ NavDropdownDirective.decorators = [
+ { type: core.Directive, args: [{
+ selector: '[appNavDropdown]'
+ },] },
+ ];
+ /** @nocollapse */
+ NavDropdownDirective.ctorParameters = function () {
+ return [
+ { type: core.ElementRef, },
+ ];
+ };
+ return NavDropdownDirective;
+ }());
+ /**
+ * Allows the dropdown to be toggled via click.
+ */
+ var NavDropdownToggleDirective = (function () {
+ function NavDropdownToggleDirective(dropdown) {
+ this.dropdown = dropdown;
+ }
+ /**
+ * @param {?} $event
+ * @return {?}
+ */
+ NavDropdownToggleDirective.prototype.toggleOpen = /**
+ * @param {?} $event
+ * @return {?}
+ */
+ function ($event) {
+ $event.preventDefault();
+ this.dropdown.toggle();
+ };
+ NavDropdownToggleDirective.decorators = [
+ { type: core.Directive, args: [{
+ selector: '[appNavDropdownToggle]'
+ },] },
+ ];
+ /** @nocollapse */
+ NavDropdownToggleDirective.ctorParameters = function () {
+ return [
+ { type: NavDropdownDirective, },
+ ];
+ };
+ NavDropdownToggleDirective.propDecorators = {
+ "toggleOpen": [{ type: core.HostListener, args: ['click', ['$event'],] },],
+ };
+ return NavDropdownToggleDirective;
+ }());
+ var AppSidebarNavComponent = (function () {
+ function AppSidebarNavComponent() {
+ this.role = 'nav';
+ }
+ /**
+ * @param {?} item
+ * @return {?}
+ */
+ AppSidebarNavComponent.prototype.isDivider = /**
+ * @param {?} item
+ * @return {?}
+ */
+ function (item) {
+ return item.divider ? true : false;
+ };
+ /**
+ * @param {?} item
+ * @return {?}
+ */
+ AppSidebarNavComponent.prototype.isTitle = /**
+ * @param {?} item
+ * @return {?}
+ */
+ function (item) {
+ return item.title ? true : false;
+ };
+ AppSidebarNavComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-sidebar-nav',
+ template: "\n \n \n \n \n \n \n \n \n \n \n
"
+ },] },
+ ];
+ /** @nocollapse */
+ AppSidebarNavComponent.ctorParameters = function () { return []; };
+ AppSidebarNavComponent.propDecorators = {
+ "navItems": [{ type: core.Input },],
+ "true": [{ type: core.HostBinding, args: ['class.sidebar-nav',] },],
+ "role": [{ type: core.HostBinding, args: ['attr.role',] },],
+ };
+ return AppSidebarNavComponent;
+ }());
+ var AppSidebarNavItemComponent = (function () {
+ function AppSidebarNavItemComponent(router$$1, el) {
+ this.router = router$$1;
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ AppSidebarNavItemComponent.prototype.hasClass = /**
+ * @return {?}
+ */
+ function () {
+ return this.item.class ? true : false;
+ };
+ /**
+ * @return {?}
+ */
+ AppSidebarNavItemComponent.prototype.isDropdown = /**
+ * @return {?}
+ */
+ function () {
+ return this.item.children ? true : false;
+ };
+ /**
+ * @return {?}
+ */
+ AppSidebarNavItemComponent.prototype.thisUrl = /**
+ * @return {?}
+ */
+ function () {
+ return this.item.url;
+ };
+ /**
+ * @return {?}
+ */
+ AppSidebarNavItemComponent.prototype.isActive = /**
+ * @return {?}
+ */
+ function () {
+ return this.router.isActive(this.thisUrl(), false);
+ };
+ /**
+ * @return {?}
+ */
+ AppSidebarNavItemComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ Replace(this.el);
+ };
+ AppSidebarNavItemComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-sidebar-nav-item',
+ template: "\n \n \n \n \n \n \n \n \n "
+ },] },
+ ];
+ /** @nocollapse */
+ AppSidebarNavItemComponent.ctorParameters = function () {
+ return [
+ { type: router.Router, },
+ { type: core.ElementRef, },
+ ];
+ };
+ AppSidebarNavItemComponent.propDecorators = {
+ "item": [{ type: core.Input },],
+ };
+ return AppSidebarNavItemComponent;
+ }());
+ var AppSidebarNavLinkComponent = (function () {
+ function AppSidebarNavLinkComponent(router$$1, el) {
+ this.router = router$$1;
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ AppSidebarNavLinkComponent.prototype.hasVariant = /**
+ * @return {?}
+ */
+ function () {
+ return this.link.variant ? true : false;
+ };
+ /**
+ * @return {?}
+ */
+ AppSidebarNavLinkComponent.prototype.isBadge = /**
+ * @return {?}
+ */
+ function () {
+ return this.link.badge ? true : false;
+ };
+ /**
+ * @return {?}
+ */
+ AppSidebarNavLinkComponent.prototype.isExternalLink = /**
+ * @return {?}
+ */
+ function () {
+ return this.link.url.substring(0, 4) === 'http' ? true : false;
+ };
+ /**
+ * @return {?}
+ */
+ AppSidebarNavLinkComponent.prototype.isIcon = /**
+ * @return {?}
+ */
+ function () {
+ return this.link.icon ? true : false;
+ };
+ /**
+ * @return {?}
+ */
+ AppSidebarNavLinkComponent.prototype.hideMobile = /**
+ * @return {?}
+ */
+ function () {
+ if (document.body.classList.contains('sidebar-mobile-show')) {
+ document.body.classList.toggle('sidebar-mobile-show');
+ }
+ };
+ /**
+ * @return {?}
+ */
+ AppSidebarNavLinkComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ Replace(this.el);
+ };
+ AppSidebarNavLinkComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-sidebar-nav-link',
+ template: "\n \n \n {{ link.name }}\n {{ link.badge.text }}\n \n \n \n \n {{ link.name }}\n {{ link.badge.text }}\n \n \n "
+ },] },
+ ];
+ /** @nocollapse */
+ AppSidebarNavLinkComponent.ctorParameters = function () {
+ return [
+ { type: router.Router, },
+ { type: core.ElementRef, },
+ ];
+ };
+ AppSidebarNavLinkComponent.propDecorators = {
+ "link": [{ type: core.Input },],
+ };
+ return AppSidebarNavLinkComponent;
+ }());
+ var AppSidebarNavDropdownComponent = (function () {
+ function AppSidebarNavDropdownComponent(router$$1, el) {
+ this.router = router$$1;
+ this.el = el;
+ }
+ /**
+ * @return {?}
+ */
+ AppSidebarNavDropdownComponent.prototype.isBadge = /**
+ * @return {?}
+ */
+ function () {
+ return this.link.badge ? true : false;
+ };
+ /**
+ * @return {?}
+ */
+ AppSidebarNavDropdownComponent.prototype.isIcon = /**
+ * @return {?}
+ */
+ function () {
+ return this.link.icon ? true : false;
+ };
+ /**
+ * @return {?}
+ */
+ AppSidebarNavDropdownComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ Replace(this.el);
+ };
+ AppSidebarNavDropdownComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-sidebar-nav-dropdown',
+ template: "\n \n \n {{ link.name }}\n {{ link.badge.text }}\n \n \n ",
+ styles: ['.nav-dropdown-toggle { cursor: pointer; }']
+ },] },
+ ];
+ /** @nocollapse */
+ AppSidebarNavDropdownComponent.ctorParameters = function () {
+ return [
+ { type: router.Router, },
+ { type: core.ElementRef, },
+ ];
+ };
+ AppSidebarNavDropdownComponent.propDecorators = {
+ "link": [{ type: core.Input },],
+ };
+ return AppSidebarNavDropdownComponent;
+ }());
+ var AppSidebarNavTitleComponent = (function () {
+ function AppSidebarNavTitleComponent(el, renderer) {
+ this.el = el;
+ this.renderer = renderer;
+ }
+ /**
+ * @return {?}
+ */
+ AppSidebarNavTitleComponent.prototype.ngOnInit = /**
+ * @return {?}
+ */
+ function () {
+ var /** @type {?} */ nativeElement = this.el.nativeElement;
+ var /** @type {?} */ li = this.renderer.createElement('li');
+ var /** @type {?} */ name = this.renderer.createText(this.title.name);
+ this.renderer.addClass(li, 'nav-title');
+ if (this.title.class) {
+ var /** @type {?} */ classes = this.title.class;
+ this.renderer.addClass(li, classes);
+ }
+ if (this.title.wrapper) {
+ var /** @type {?} */ wrapper = this.renderer.createElement(this.title.wrapper.element);
+ this.renderer.appendChild(wrapper, name);
+ this.renderer.appendChild(li, wrapper);
+ }
+ else {
+ this.renderer.appendChild(li, name);
+ }
+ this.renderer.appendChild(nativeElement, li);
+ Replace(this.el);
+ };
+ AppSidebarNavTitleComponent.decorators = [
+ { type: core.Component, args: [{
+ selector: 'app-sidebar-nav-title',
+ template: ''
+ },] },
+ ];
+ /** @nocollapse */
+ AppSidebarNavTitleComponent.ctorParameters = function () {
+ return [
+ { type: core.ElementRef, },
+ { type: core.Renderer2, },
+ ];
+ };
+ AppSidebarNavTitleComponent.propDecorators = {
+ "title": [{ type: core.Input },],
+ };
+ return AppSidebarNavTitleComponent;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+ var AppSidebarModule = (function () {
+ function AppSidebarModule() {
+ }
+ AppSidebarModule.decorators = [
+ { type: core.NgModule, args: [{
+ imports: [
+ common.CommonModule,
+ router.RouterModule,
+ LayoutModule
+ ],
+ exports: [
+ AppSidebarFooterComponent,
+ AppSidebarFormComponent,
+ AppSidebarHeaderComponent,
+ AppSidebarMinimizerComponent,
+ AppSidebarComponent,
+ AppSidebarNavComponent,
+ AppSidebarNavDropdownComponent,
+ AppSidebarNavItemComponent,
+ AppSidebarNavLinkComponent,
+ AppSidebarNavTitleComponent,
+ NavDropdownDirective,
+ NavDropdownToggleDirective,
+ LayoutModule
+ ],
+ declarations: [
+ AppSidebarFooterComponent,
+ AppSidebarFormComponent,
+ AppSidebarHeaderComponent,
+ AppSidebarMinimizerComponent,
+ AppSidebarMinimizerComponent,
+ AppSidebarComponent,
+ AppSidebarNavComponent,
+ AppSidebarNavDropdownComponent,
+ AppSidebarNavItemComponent,
+ AppSidebarNavLinkComponent,
+ AppSidebarNavTitleComponent,
+ NavDropdownDirective,
+ NavDropdownToggleDirective
+ ]
+ },] },
+ ];
+ return AppSidebarModule;
+ }());
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+ /**
+ * @fileoverview added by tsickle
+ * @suppress {checkTypes} checked by tsc
+ */
+
+ exports.AppAsideModule = AppAsideModule;
+ exports.AppBreadcrumbModule = AppBreadcrumbModule;
+ exports.AppFooterModule = AppFooterModule;
+ exports.AppHeaderModule = AppHeaderModule;
+ exports.AppSidebarModule = AppSidebarModule;
+ exports.LayoutModule = LayoutModule;
+
+ Object.defineProperty(exports, '__esModule', { value: true });
+
+})));
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"coreui-angular.umd.js.map","sources":["ng://@coreui/angular/lib/shared/classes.ts","ng://@coreui/angular/lib/shared/toggle-classes.ts","ng://@coreui/angular/lib/shared/layout/layout.directive.ts","ng://@coreui/angular/lib/shared/layout/layout.module.ts","ng://@coreui/angular/lib/shared/replace.ts","ng://@coreui/angular/lib/aside/app-aside.component.ts","ng://@coreui/angular/lib/aside/app-aside.module.ts","ng://@coreui/angular/lib/breadcrumb/app-breadcrumb.service.ts","ng://@coreui/angular/lib/breadcrumb/app-breadcrumb.component.ts","ng://@coreui/angular/lib/breadcrumb/app-breadcrumb.module.ts","ng://@coreui/angular/lib/footer/app-footer.component.ts","ng://@coreui/angular/lib/footer/app-footer.module.ts","ng://@coreui/angular/lib/header/app-header.component.ts","ng://@coreui/angular/lib/header/app-header.module.ts","ng://@coreui/angular/lib/sidebar/app-sidebar-footer.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar-form.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar-header.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar-minimizer.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar-nav.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar.module.ts"],"sourcesContent":["export const sidebarCssClasses: Array<string> = [\n  'sidebar-show',\n  'sidebar-sm-show',\n  'sidebar-md-show',\n  'sidebar-lg-show',\n  'sidebar-xl-show'\n];\n\nexport const asideMenuCssClasses: Array<string> = [\n  'aside-menu-show',\n  'aside-menu-sm-show',\n  'aside-menu-md-show',\n  'aside-menu-lg-show',\n  'aside-menu-xl-show'\n];\n","const RemoveClasses = (NewClassNames) => {\n  const MatchClasses = NewClassNames.map((Class) => document.querySelector('body').classList.contains(Class));\n  return MatchClasses.indexOf(true) !== -1;\n};\n\nexport const ToggleClasses = (Toggle, ClassNames) => {\n  const Level = ClassNames.indexOf(Toggle);\n  const NewClassNames = ClassNames.slice(0, Level + 1);\n\n  if (RemoveClasses(NewClassNames)) {\n    NewClassNames.map((Class) => document.querySelector('body').classList.remove(Class));\n  } else {\n    document.querySelector('body').classList.add(Toggle);\n  }\n};\n","import { Directive, HostListener, Input, ElementRef, OnInit } from '@angular/core';\nimport { sidebarCssClasses, asideMenuCssClasses } from './../classes';\nimport { ToggleClasses } from './../toggle-classes';\n\n/**\n* Allows the sidebar to be toggled via click.\n*/\n@Directive({\n  selector: '[appSidebarToggler]'\n})\nexport class SidebarToggleDirective implements OnInit {\n  @Input('appSidebarToggler') breakpoint: string;\n  public bp;\n  constructor() {}\n  ngOnInit(): void {\n    this.bp = this.breakpoint;\n  }\n  @HostListener('click', ['$event'])\n  toggleOpen($event: any) {\n    $event.preventDefault();\n    let cssClass;\n    this.bp ? cssClass = `sidebar-${this.bp}-show` : cssClass = sidebarCssClasses[0];\n    ToggleClasses(cssClass, sidebarCssClasses);\n  }\n}\n\n@Directive({\n  selector: '[appSidebarMinimizer]'\n})\nexport class SidebarMinimizeDirective {\n  constructor() { }\n\n  @HostListener('click', ['$event'])\n  toggleOpen($event: any) {\n    $event.preventDefault();\n    document.querySelector('body').classList.toggle('sidebar-minimized');\n  }\n}\n\n@Directive({\n  selector: '[appMobileSidebarToggler]'\n})\nexport class MobileSidebarToggleDirective {\n  constructor() { }\n\n  // Check if element has class\n  private hasClass(target: any, elementClassName: string) {\n    return new RegExp('(\\\\s|^)' + elementClassName + '(\\\\s|$)').test(target.className);\n  }\n\n  @HostListener('click', ['$event'])\n  toggleOpen($event: any) {\n    $event.preventDefault();\n    document.querySelector('body').classList.toggle('sidebar-mobile-show');\n  }\n}\n\n/**\n* Allows the off-canvas sidebar to be closed via click.\n*/\n@Directive({\n  selector: '[appSidebarClose]'\n})\nexport class SidebarOffCanvasCloseDirective {\n  constructor() { }\n\n  // Check if element has class\n  private hasClass(target: any, elementClassName: string) {\n    return new RegExp('(\\\\s|^)' + elementClassName + '(\\\\s|$)').test(target.className);\n  }\n\n  // Toggle element class\n  private toggleClass(elem: any, elementClassName: string) {\n    let newClass = ' ' + elem.className.replace( /[\\t\\r\\n]/g, ' ' ) + ' ';\n    if (this.hasClass(elem, elementClassName)) {\n      while (newClass.indexOf(' ' + elementClassName + ' ') >= 0 ) {\n        newClass = newClass.replace( ' ' + elementClassName + ' ' , ' ' );\n      }\n      elem.className = newClass.replace(/^\\s+|\\s+$/g, '');\n    } else {\n      elem.className += ' ' + elementClassName;\n    }\n  }\n\n  @HostListener('click', ['$event'])\n  toggleOpen($event: any) {\n    $event.preventDefault();\n\n    if (this.hasClass(document.querySelector('body'), 'sidebar-off-canvas')) {\n      this.toggleClass(document.querySelector('body'), 'sidebar-opened');\n    }\n  }\n}\n\n@Directive({\n  selector: '[appBrandMinimizer]'\n})\nexport class BrandMinimizeDirective {\n  constructor() { }\n\n  @HostListener('click', ['$event'])\n  toggleOpen($event: any) {\n    $event.preventDefault();\n    document.querySelector('body').classList.toggle('brand-minimized');\n  }\n}\n\n\n/**\n* Allows the aside to be toggled via click.\n*/\n@Directive({\n  selector: '[appAsideMenuToggler]',\n})\nexport class AsideToggleDirective implements OnInit {\n  @Input('appAsideMenuToggler') breakpoint: string;\n  public bp;\n  constructor() {}\n  ngOnInit(): void {\n    this.bp = this.breakpoint;\n  }\n  @HostListener('click', ['$event'])\n  toggleOpen($event: any) {\n    $event.preventDefault();\n    let cssClass;\n    this.bp ? cssClass = `aside-menu-${this.bp}-show` : cssClass = asideMenuCssClasses[0];\n    ToggleClasses(cssClass, asideMenuCssClasses);\n  }\n}\n","import { CommonModule } from '@angular/common';\nimport { NgModule} from '@angular/core';\nimport {\n  AsideToggleDirective,\n  BrandMinimizeDirective,\n  MobileSidebarToggleDirective,\n  SidebarToggleDirective,\n  SidebarMinimizeDirective,\n  SidebarOffCanvasCloseDirective\n} from './layout.directive';\n\n@NgModule({\n  imports: [\n    CommonModule\n  ],\n  exports: [\n    AsideToggleDirective,\n    BrandMinimizeDirective,\n    MobileSidebarToggleDirective,\n    SidebarToggleDirective,\n    SidebarMinimizeDirective,\n    SidebarOffCanvasCloseDirective\n  ],\n  declarations: [\n    AsideToggleDirective,\n    BrandMinimizeDirective,\n    MobileSidebarToggleDirective,\n    SidebarToggleDirective,\n    SidebarMinimizeDirective,\n    SidebarOffCanvasCloseDirective\n  ]\n})\nexport class LayoutModule { }\n","export function Replace(el: any): any {\n  const nativeElement: HTMLElement = el.nativeElement;\n  const parentElement: HTMLElement = nativeElement.parentElement;\n  // move all children out of the element\n  while (nativeElement.firstChild) {\n    parentElement.insertBefore(nativeElement.firstChild, nativeElement);\n  }\n  // remove the empty element(the host)\n  parentElement.removeChild(nativeElement);\n}\n","import { Component, ElementRef, Input, OnInit } from '@angular/core';\nimport { asideMenuCssClasses, Replace } from './../shared';\n\n@Component({\n  selector: 'app-aside',\n  template: `\n    <aside class=\"aside-menu\">\n      <ng-content></ng-content>\n    </aside>\n  `\n})\nexport class AppAsideComponent implements OnInit {\n  @Input() display: any;\n  @Input() fixed: boolean;\n  @Input() offCanvas: boolean;\n\n  constructor(private el: ElementRef) {}\n\n  ngOnInit() {\n    Replace(this.el);\n    this.isFixed(this.fixed);\n    this.displayBreakpoint(this.display);\n  }\n\n  isFixed(fixed: boolean): void {\n    if (this.fixed) { document.querySelector('body').classList.add('aside-menu-fixed'); }\n  }\n\n  isOffCanvas(offCanvas: boolean): void {\n    if (this.offCanvas) { document.querySelector('body').classList.add('aside-menu-off-canvas'); }\n  }\n\n  displayBreakpoint(display: any): void {\n    if (this.display !== false ) {\n      let cssClass;\n      this.display ? cssClass = `aside-menu-${this.display}-show` : cssClass = asideMenuCssClasses[0];\n      document.querySelector('body').classList.add(cssClass);\n    }\n  }\n}\n","import { CommonModule} from '@angular/common';\nimport { NgModule } from '@angular/core';\nimport { LayoutModule } from './../shared';\n\nimport { AppAsideComponent } from './app-aside.component';\n\n@NgModule({\n  imports: [\n    CommonModule,\n    LayoutModule\n  ],\n  exports: [\n    AppAsideComponent,\n    LayoutModule\n  ],\n  declarations: [\n    AppAsideComponent\n  ]\n})\nexport class AppAsideModule {}\n","import { Injectable, Injector } from '@angular/core';\r\nimport { Router, ActivatedRoute, NavigationEnd } from '@angular/router';\r\nimport { BehaviorSubject, Observable } from 'rxjs/index';\r\nimport { filter } from 'rxjs/operators';\r\n\r\n@Injectable()\r\nexport class AppBreadcrumbService {\r\n\r\n  breadcrumbs: Observable<Array<Object>>;\r\n\r\n  private _breadcrumbs: BehaviorSubject<Array<Object>>;\r\n\r\n  constructor(private router: Router, private route: ActivatedRoute) {\r\n\r\n    this._breadcrumbs = new BehaviorSubject<Object[]>(new Array<Object>());\r\n\r\n    this.breadcrumbs = this._breadcrumbs.asObservable();\r\n\r\n    this.router.events.pipe(filter(event => event instanceof NavigationEnd)).subscribe((event) => {\r\n      const breadcrumbs = [];\r\n      let currentRoute = this.route.root,\r\n      url = '';\r\n      do {\r\n        const childrenRoutes = currentRoute.children;\r\n        currentRoute = null;\r\n        // tslint:disable-next-line:no-shadowed-variable\r\n        childrenRoutes.forEach(route => {\r\n          if (route.outlet === 'primary') {\r\n            const routeSnapshot = route.snapshot;\r\n            url += '/' + routeSnapshot.url.map(segment => segment.path).join('/');\r\n            breadcrumbs.push({\r\n              label: route.snapshot.data,\r\n              url:   url\r\n            });\r\n            currentRoute = route;\r\n          }\r\n        });\r\n      } while (currentRoute);\r\n\r\n      this._breadcrumbs.next(Object.assign([], breadcrumbs));\r\n\r\n      return breadcrumbs;\r\n    });\r\n  }\r\n}\r\n","import { Component, ElementRef, Input, OnInit  } from '@angular/core';\nimport { Replace } from './../shared';\nimport { AppBreadcrumbService } from './app-breadcrumb.service';\n\n@Component({\n  selector: 'app-breadcrumb',\n  template: `\n    <ng-template ngFor let-breadcrumb [ngForOf]=\"breadcrumbs | async\" let-last = last>\n      <li class=\"breadcrumb-item\"\n          *ngIf=\"breadcrumb.label.title && (breadcrumb.url.slice(-1) == '/' || last)\"\n          [ngClass]=\"{active: last}\">\n        <a *ngIf=\"!last\" [routerLink]=\"breadcrumb.url\">{{breadcrumb.label.title}}</a>\n        <span *ngIf=\"last\" [routerLink]=\"breadcrumb.url\">{{breadcrumb.label.title}}</span>\n      </li>\n    </ng-template>\n  `\n})\nexport class AppBreadcrumbComponent implements OnInit {\n  @Input() fixed: boolean;\n  public breadcrumbs;\n\n  constructor(public service: AppBreadcrumbService, public el: ElementRef) { }\n\n  public ngOnInit(): void {\n    Replace(this.el);\n    this.isFixed(this.fixed);\n    this.breadcrumbs = this.service.breadcrumbs;\n  }\n\n  isFixed(fixed: boolean): void {\n    if (this.fixed) { document.querySelector('body').classList.add('breadcrumb-fixed'); }\n  }\n}\n","import { CommonModule} from '@angular/common';\nimport { NgModule, ModuleWithProviders} from '@angular/core';\nimport { RouterModule } from '@angular/router';\n\n// App Breadcrumb Component\nimport { AppBreadcrumbService } from './app-breadcrumb.service';\nimport { AppBreadcrumbComponent } from './app-breadcrumb.component';\n\n@NgModule({\n  imports: [ CommonModule, RouterModule ],\n  exports: [ AppBreadcrumbComponent ],\n  declarations: [ AppBreadcrumbComponent ]\n})\nexport class AppBreadcrumbModule {\n  static forRoot(config?: any): ModuleWithProviders {\n    return {\n      ngModule: AppBreadcrumbModule,\n      providers: [\n        AppBreadcrumbService\n      ]\n    };\n  }\n}\n","import { Component, ElementRef, Input, OnInit  } from '@angular/core';\nimport { Replace } from './../shared';\n\n@Component({\n  selector: 'app-footer',\n  template: `\n    <footer class=\"app-footer\">\n      <ng-content></ng-content>\n    </footer>\n  `\n})\nexport class AppFooterComponent implements OnInit {\n  @Input() fixed: boolean;\n\n  constructor(private el: ElementRef) {}\n\n  ngOnInit() {\n    Replace(this.el);\n    this.isFixed(this.fixed);\n  }\n\n  isFixed(fixed: boolean): void {\n    if (this.fixed) { document.querySelector('body').classList.add('footer-fixed'); }\n  }\n}\n","import { CommonModule} from '@angular/common';\nimport { NgModule } from '@angular/core';\n\nimport { AppFooterComponent } from './app-footer.component';\n\n@NgModule({\n  imports: [ CommonModule ],\n  exports: [ AppFooterComponent ],\n  declarations: [ AppFooterComponent ]\n})\nexport class AppFooterModule {}\n","import { Component, ElementRef, Input, OnInit } from '@angular/core';\nimport { Replace } from './../shared';\n\n@Component({\n  selector: 'app-header',\n  template: `\n    <header class=\"app-header navbar\">\n      <ng-template [ngIf]=\"mobileSidebarToggler != false\">\n        <button class=\"navbar-toggler d-lg-none\" type=\"button\" appSidebarToggler>\n          <span class=\"navbar-toggler-icon\"></span>\n        </button>\n      </ng-template>\n      <ng-template [ngIf]=\"navbarBrand || navbarBrandFull || navbarBrandMinimized\">\n        <a class=\"navbar-brand\" href=\"#\">\n          <img *ngIf=\"navbarBrand\"\n               [src]=\"imgSrc(navbarBrand)\"\n               [attr.width]=\"imgWidth(navbarBrand)\"\n               [attr.height]=\"imgHeight(navbarBrand)\"\n               [attr.alt]=\"imgAlt(navbarBrand)\"\n               class=\"navbar-brand\">\n          <img *ngIf=\"navbarBrandFull\"\n               [src]=\"imgSrc(navbarBrandFull)\"\n               [attr.width]=\"imgWidth(navbarBrandFull)\"\n               [attr.height]=\"imgHeight(navbarBrandFull)\"\n               [attr.alt]=\"imgAlt(navbarBrandFull)\"\n               class=\"navbar-brand-full\">\n          <img *ngIf=\"navbarBrandMinimized\"\n               [src]=\"imgSrc(navbarBrandMinimized)\"\n               [attr.width]=\"imgWidth(navbarBrandMinimized)\"\n               [attr.height]=\"imgHeight(navbarBrandMinimized)\"\n               [attr.alt]=\"imgAlt(navbarBrandMinimized)\"\n               class=\"navbar-brand-minimized\">\n        </a>\n      </ng-template>\n      <ng-template [ngIf]=\"sidebarToggler != false\">\n        <button class=\"navbar-toggler d-md-down-none\" type=\"button\" [appSidebarToggler]=\"sidebarToggler\">\n          <span class=\"navbar-toggler-icon\"></span>\n        </button>\n      </ng-template>\n      <ng-content></ng-content>\n      <ng-template [ngIf]=\"asideMenuToggler != false\">\n        <button class=\"navbar-toggler d-md-down-none\" type=\"button\" [appAsideMenuToggler]=\"asideMenuToggler\">\n          <span class=\"navbar-toggler-icon\"></span>\n        </button>\n      </ng-template>\n      <ng-template [ngIf]=\"mobileAsideMenuToggler != false\">\n        <button class=\"navbar-toggler d-lg-none\" type=\"button\" appAsideMenuToggler>\n          <span class=\"navbar-toggler-icon\"></span>\n        </button>\n      </ng-template>\n    </header>\n  `\n})\nexport class AppHeaderComponent implements OnInit {\n\n  @Input() fixed: boolean;\n\n  @Input() navbarBrand: any;\n  @Input() navbarBrandFull: any;\n  @Input() navbarBrandMinimized: any;\n\n  @Input() sidebarToggler: any;\n  @Input() mobileSidebarToggler: any;\n\n  @Input() asideMenuToggler: any;\n  @Input() mobileAsideMenuToggler: any;\n\n  constructor(private el: ElementRef) {}\n\n  ngOnInit() {\n    Replace(this.el);\n    this.isFixed(this.fixed);\n  }\n\n  isFixed(fixed: boolean): void {\n    if (this.fixed) { document.querySelector('body').classList.add('header-fixed'); }\n  }\n\n  imgSrc(brand: any): void {\n    return brand.src ? brand.src : '';\n  }\n\n  imgWidth(brand: any): void {\n    return brand.width ? brand.width : 'auto';\n  }\n\n  imgHeight(brand: any): void {\n    return brand.height ? brand.height : 'auto';\n  }\n\n  imgAlt(brand: any): void {\n    return brand.alt ? brand.alt : '';\n  }\n\n  breakpoint(breakpoint: any): void {\n    console.log(breakpoint);\n    return breakpoint ? breakpoint : '';\n  }\n}\n","import { CommonModule} from '@angular/common';\nimport { NgModule } from '@angular/core';\nimport { LayoutModule } from './../shared';\n\nimport { AppHeaderComponent } from './app-header.component';\n\n@NgModule({\n  imports: [\n    CommonModule,\n    LayoutModule\n  ],\n  exports: [\n    AppHeaderComponent,\n    LayoutModule\n  ],\n  declarations: [\n    AppHeaderComponent\n  ]\n})\nexport class AppHeaderModule {}\n","import { Component, ElementRef, OnInit  } from '@angular/core';\nimport { Replace } from './../shared';\n\n@Component({\n  selector: 'app-sidebar-footer',\n  template: `\n    <div class=\"sidebar-footer\">\n      <ng-content></ng-content>\n    </div>`\n})\nexport class AppSidebarFooterComponent implements OnInit {\n\n  constructor(private el: ElementRef) { }\n\n  ngOnInit() {\n    Replace(this.el);\n  }\n}\n","import { Component, ElementRef, OnInit  } from '@angular/core';\nimport { Replace } from './../shared';\n\n@Component({\n  selector: 'app-sidebar-form',\n  template: `\n    <form class=\"sidebar-form\">\n      <ng-content></ng-content>\n    </form>\n  `\n})\nexport class AppSidebarFormComponent implements OnInit {\n\n  constructor(private el: ElementRef) { }\n\n  ngOnInit() {\n    Replace(this.el);\n  }\n}\n","import { Component, ElementRef, OnInit  } from '@angular/core';\nimport { Replace } from './../shared';\n\n@Component({\n  selector: 'app-sidebar-header',\n  template: `\n    <div class=\"sidebar-header\">\n      <ng-content></ng-content>\n    </div>\n  `\n})\nexport class AppSidebarHeaderComponent implements OnInit {\n\n  constructor(private el: ElementRef) { }\n\n  ngOnInit() {\n    Replace(this.el);\n  }\n}\n","import { Component, ElementRef, OnInit  } from '@angular/core';\nimport { Replace } from './../shared';\n\n@Component({\n  selector: 'app-sidebar-minimizer',\n  template: `\n    <button class=\"sidebar-minimizer\" type=\"button\" appSidebarMinimizer appBrandMinimizer></button>\n  `\n})\nexport class AppSidebarMinimizerComponent implements OnInit {\n\n  constructor(private el: ElementRef) { }\n\n  ngOnInit() {\n    Replace(this.el);\n  }\n}\n","import { Component, Input, HostBinding, OnInit } from '@angular/core';\nimport { sidebarCssClasses } from './../shared';\n\n@Component({\n  selector: 'app-sidebar',\n  template: `<ng-content></ng-content>`\n})\nexport class AppSidebarComponent implements OnInit {\n  @Input() compact: boolean;\n  @Input() display: any;\n  @Input() fixed: boolean;\n  @Input() minimized: boolean;\n  @Input() offCanvas: boolean;\n\n  @HostBinding('class.sidebar') true;\n\n  constructor() {}\n\n  ngOnInit() {\n    this.displayBreakpoint(this.display);\n    this.isCompact(this.compact);\n    this.isFixed(this.fixed);\n    this.isMinimized(this.minimized);\n    this.isOffCanvas(this.offCanvas);\n  }\n\n  isCompact(compact: boolean): void {\n    if (this.compact) { document.querySelector('body').classList.add('sidebar-compact'); }\n  }\n\n  isFixed(fixed: boolean): void {\n    if (this.fixed) { document.querySelector('body').classList.add('sidebar-fixed'); }\n  }\n\n  isMinimized(minimized: boolean): void {\n    if (this.minimized) { document.querySelector('body').classList.add('sidebar-minimized'); }\n  }\n\n  isOffCanvas(offCanvas: boolean): void {\n    if (this.offCanvas) { document.querySelector('body').classList.add('sidebar-off-canvas'); }\n  }\n\n  fixedPosition(fixed: boolean): void {\n    if (this.fixed) { document.querySelector('body').classList.add('sidebar-fixed'); }\n  }\n\n  displayBreakpoint(display: any): void {\n    if (this.display !== false ) {\n      let cssClass;\n      this.display ? cssClass = `sidebar-${this.display}-show` : cssClass = sidebarCssClasses[0];\n      document.querySelector('body').classList.add(cssClass);\n    }\n  }\n}\n","import { Component, Directive, ElementRef, HostBinding, HostListener, Input, OnInit, Renderer2, ViewEncapsulation } from '@angular/core';\nimport { Replace } from './../shared';\n\n@Directive({\n  selector: '[appNavDropdown]'\n})\nexport class NavDropdownDirective {\n\n  constructor(private el: ElementRef) { }\n\n  toggle() {\n    this.el.nativeElement.classList.toggle('open');\n  }\n}\n\n/**\n* Allows the dropdown to be toggled via click.\n*/\n@Directive({\n  selector: '[appNavDropdownToggle]'\n})\nexport class NavDropdownToggleDirective {\n  constructor(private dropdown: NavDropdownDirective) {}\n\n  @HostListener('click', ['$event'])\n  toggleOpen($event: any) {\n    $event.preventDefault();\n    this.dropdown.toggle();\n  }\n}\n\n@Component({\n  selector: 'app-sidebar-nav',\n  template: `\n    <ul class=\"nav\">\n      <ng-template ngFor let-navitem [ngForOf]=\"navItems\">\n        <li *ngIf=\"isDivider(navitem)\" class=\"nav-divider\"></li>\n        <ng-template [ngIf]=\"isTitle(navitem)\">\n          <app-sidebar-nav-title [title]='navitem'></app-sidebar-nav-title>\n        </ng-template>\n        <ng-template [ngIf]=\"!isDivider(navitem)&&!isTitle(navitem)\">\n          <app-sidebar-nav-item [item]='navitem'></app-sidebar-nav-item>\n        </ng-template>\n      </ng-template>\n    </ul>`\n})\nexport class AppSidebarNavComponent {\n  @Input() navItems: any;\n\n  @HostBinding('class.sidebar-nav') true;\n  @HostBinding('attr.role') role = 'nav';\n\n  public isDivider(item) {\n    return item.divider ? true : false;\n  }\n\n  public isTitle(item) {\n    return item.title ? true : false;\n  }\n\n  constructor() { }\n}\n\nimport { Router } from '@angular/router';\n\n@Component({\n  selector: 'app-sidebar-nav-item',\n  template: `\n    <li *ngIf=\"!isDropdown(); else dropdown\" [ngClass]=\"hasClass() ? 'nav-item ' + item.class : 'nav-item'\">\n      <app-sidebar-nav-link [link]='item'></app-sidebar-nav-link>\n    </li>\n    <ng-template #dropdown>\n      <li [ngClass]=\"hasClass() ? 'nav-item nav-dropdown ' + item.class : 'nav-item nav-dropdown'\"\n          [class.open]=\"isActive()\"\n          routerLinkActive=\"open\"\n          appNavDropdown>\n        <app-sidebar-nav-dropdown [link]='item'></app-sidebar-nav-dropdown>\n      </li>\n    </ng-template>\n    `\n})\nexport class AppSidebarNavItemComponent implements OnInit {\n  @Input() item: any;\n\n  public hasClass() {\n    return this.item.class ? true : false;\n  }\n\n  public isDropdown() {\n    return this.item.children ? true : false;\n  }\n\n  public thisUrl() {\n    return this.item.url;\n  }\n\n  public isActive() {\n    return this.router.isActive(this.thisUrl(), false);\n  }\n\n  constructor( private router: Router, private el: ElementRef ) { }\n\n  ngOnInit() {\n    Replace(this.el);\n  }\n\n}\n\n@Component({\n  selector: 'app-sidebar-nav-link',\n  template: `\n    <a *ngIf=\"!isExternalLink(); else external\"\n      [ngClass]=\"hasVariant() ? 'nav-link nav-link-' + link.variant : 'nav-link'\"\n      routerLinkActive=\"active\"\n      [routerLink]=\"[link.url]\"\n      (click)=\"hideMobile()\">\n      <i *ngIf=\"isIcon()\" class=\"nav-icon {{ link.icon }}\"></i>\n      {{ link.name }}\n      <span *ngIf=\"isBadge()\" [ngClass]=\"'badge badge-' + link.badge.variant\">{{ link.badge.text }}</span>\n    </a>\n    <ng-template #external>\n      <a [ngClass]=\"hasVariant() ? 'nav-link nav-link-' + link.variant : 'nav-link'\" href=\"{{link.url}}\">\n        <i *ngIf=\"isIcon()\" class=\"nav-icon {{ link.icon }}\"></i>\n        {{ link.name }}\n        <span *ngIf=\"isBadge()\" [ngClass]=\"'badge badge-' + link.badge.variant\">{{ link.badge.text }}</span>\n      </a>\n    </ng-template>\n  `\n})\nexport class AppSidebarNavLinkComponent implements OnInit {\n  @Input() link: any;\n\n  public hasVariant() {\n    return this.link.variant ? true : false;\n  }\n\n  public isBadge() {\n    return this.link.badge ? true : false;\n  }\n\n  public isExternalLink() {\n    return this.link.url.substring(0, 4) === 'http' ? true : false;\n  }\n\n  public isIcon() {\n    return this.link.icon ? true : false;\n  }\n\n  public hideMobile() {\n    if (document.body.classList.contains('sidebar-mobile-show')) {\n      document.body.classList.toggle('sidebar-mobile-show');\n    }\n  }\n\n  constructor( private router: Router, private el: ElementRef ) { }\n\n  ngOnInit() {\n    Replace(this.el);\n  }\n}\n\n@Component({\n  selector: 'app-sidebar-nav-dropdown',\n  template: `\n    <a class=\"nav-link nav-dropdown-toggle\" appNavDropdownToggle>\n      <i *ngIf=\"isIcon()\" class=\"nav-icon {{ link.icon }}\"></i>\n      {{ link.name }}\n      <span *ngIf=\"isBadge()\" [ngClass]=\"'badge badge-' + link.badge.variant\">{{ link.badge.text }}</span>\n    </a>\n    <ul class=\"nav-dropdown-items\">\n      <ng-template ngFor let-child [ngForOf]=\"link.children\">\n        <app-sidebar-nav-item [item]='child'></app-sidebar-nav-item>\n      </ng-template>\n    </ul>\n  `,\n  styles: ['.nav-dropdown-toggle { cursor: pointer; }']\n})\nexport class AppSidebarNavDropdownComponent implements OnInit {\n  @Input() link: any;\n\n  public isBadge() {\n    return this.link.badge ? true : false;\n  }\n\n  public isIcon() {\n    return this.link.icon ? true : false;\n  }\n\n  constructor( private router: Router, private el: ElementRef ) { }\n\n  ngOnInit() {\n    Replace(this.el);\n  }\n}\n\n@Component({\n  selector: 'app-sidebar-nav-title',\n  template: ''\n})\nexport class AppSidebarNavTitleComponent implements OnInit {\n  @Input() title: any;\n\n  constructor(private el: ElementRef, private renderer: Renderer2) { }\n\n  ngOnInit() {\n    const nativeElement: HTMLElement = this.el.nativeElement;\n    const li = this.renderer.createElement('li');\n    const name = this.renderer.createText(this.title.name);\n\n    this.renderer.addClass(li, 'nav-title');\n\n    if ( this.title.class ) {\n      const classes = this.title.class;\n      this.renderer.addClass(li, classes);\n    }\n\n    if ( this.title.wrapper ) {\n      const wrapper = this.renderer.createElement(this.title.wrapper.element);\n\n      this.renderer.appendChild(wrapper, name);\n      this.renderer.appendChild(li, wrapper);\n    } else {\n      this.renderer.appendChild(li, name);\n    }\n    this.renderer.appendChild(nativeElement, li);\n    Replace(this.el);\n  }\n}\n","import { CommonModule } from '@angular/common';\nimport { NgModule} from '@angular/core';\nimport { RouterModule } from '@angular/router';\nimport { HttpClientModule } from '@angular/common/http';\nimport { LayoutModule } from './../shared';\n\n// App Sidebar Component\nimport { AppSidebarFooterComponent } from './app-sidebar-footer.component';\nimport { AppSidebarFormComponent } from './app-sidebar-form.component';\nimport { AppSidebarHeaderComponent } from './app-sidebar-header.component';\nimport { AppSidebarMinimizerComponent } from './app-sidebar-minimizer.component';\nimport { AppSidebarComponent } from './app-sidebar.component';\nimport {\n  AppSidebarNavComponent,\n  AppSidebarNavDropdownComponent,\n  AppSidebarNavItemComponent,\n  AppSidebarNavLinkComponent,\n  AppSidebarNavTitleComponent,\n  NavDropdownDirective,\n  NavDropdownToggleDirective\n} from './app-sidebar-nav.component';\n\n@NgModule({\n  imports: [\n    CommonModule,\n    RouterModule,\n    LayoutModule\n  ],\n  exports: [\n    AppSidebarFooterComponent,\n    AppSidebarFormComponent,\n    AppSidebarHeaderComponent,\n    AppSidebarMinimizerComponent,\n    AppSidebarComponent,\n    AppSidebarNavComponent,\n    AppSidebarNavDropdownComponent,\n    AppSidebarNavItemComponent,\n    AppSidebarNavLinkComponent,\n    AppSidebarNavTitleComponent,\n    NavDropdownDirective,\n    NavDropdownToggleDirective,\n    LayoutModule\n  ],\n  declarations: [\n    AppSidebarFooterComponent,\n    AppSidebarFormComponent,\n    AppSidebarHeaderComponent,\n    AppSidebarMinimizerComponent,\n    AppSidebarMinimizerComponent,\n    AppSidebarComponent,\n    AppSidebarNavComponent,\n    AppSidebarNavDropdownComponent,\n    AppSidebarNavItemComponent,\n    AppSidebarNavLinkComponent,\n    AppSidebarNavTitleComponent,\n    NavDropdownDirective,\n    NavDropdownToggleDirective\n  ]\n})\nexport class AppSidebarModule { }\n"],"names":["Directive","Input","HostListener","NgModule","CommonModule","Component","ElementRef","router","BehaviorSubject","filter","NavigationEnd","Injectable","Router","ActivatedRoute","RouterModule","HostBinding","Renderer2"],"mappings":"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"}
\ No newline at end of file
diff --git a/dist/@coreui/angular/bundles/coreui-angular.umd.js.map b/dist/@coreui/angular/bundles/coreui-angular.umd.js.map
new file mode 100644
index 00000000..0bd68248
--- /dev/null
+++ b/dist/@coreui/angular/bundles/coreui-angular.umd.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"coreui-angular.umd.js.map","sources":["ng://@coreui/angular/lib/shared/classes.ts","ng://@coreui/angular/lib/shared/toggle-classes.ts","ng://@coreui/angular/lib/shared/layout/layout.directive.ts","ng://@coreui/angular/lib/shared/layout/layout.module.ts","ng://@coreui/angular/lib/shared/replace.ts","ng://@coreui/angular/lib/aside/app-aside.component.ts","ng://@coreui/angular/lib/aside/app-aside.module.ts","ng://@coreui/angular/lib/breadcrumb/app-breadcrumb.service.ts","ng://@coreui/angular/lib/breadcrumb/app-breadcrumb.component.ts","ng://@coreui/angular/lib/breadcrumb/app-breadcrumb.module.ts","ng://@coreui/angular/lib/footer/app-footer.component.ts","ng://@coreui/angular/lib/footer/app-footer.module.ts","ng://@coreui/angular/lib/header/app-header.component.ts","ng://@coreui/angular/lib/header/app-header.module.ts","ng://@coreui/angular/lib/sidebar/app-sidebar-footer.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar-form.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar-header.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar-minimizer.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar-nav.component.ts","ng://@coreui/angular/lib/sidebar/app-sidebar.module.ts"],"sourcesContent":["export const sidebarCssClasses: Array = [\n 'sidebar-show',\n 'sidebar-sm-show',\n 'sidebar-md-show',\n 'sidebar-lg-show',\n 'sidebar-xl-show'\n];\n\nexport const asideMenuCssClasses: Array = [\n 'aside-menu-show',\n 'aside-menu-sm-show',\n 'aside-menu-md-show',\n 'aside-menu-lg-show',\n 'aside-menu-xl-show'\n];\n","const RemoveClasses = (NewClassNames) => {\n const MatchClasses = NewClassNames.map((Class) => document.querySelector('body').classList.contains(Class));\n return MatchClasses.indexOf(true) !== -1;\n};\n\nexport const ToggleClasses = (Toggle, ClassNames) => {\n const Level = ClassNames.indexOf(Toggle);\n const NewClassNames = ClassNames.slice(0, Level + 1);\n\n if (RemoveClasses(NewClassNames)) {\n NewClassNames.map((Class) => document.querySelector('body').classList.remove(Class));\n } else {\n document.querySelector('body').classList.add(Toggle);\n }\n};\n","import { Directive, HostListener, Input, ElementRef, OnInit } from '@angular/core';\nimport { sidebarCssClasses, asideMenuCssClasses } from './../classes';\nimport { ToggleClasses } from './../toggle-classes';\n\n/**\n* Allows the sidebar to be toggled via click.\n*/\n@Directive({\n selector: '[appSidebarToggler]'\n})\nexport class SidebarToggleDirective implements OnInit {\n @Input('appSidebarToggler') breakpoint: string;\n public bp;\n constructor() {}\n ngOnInit(): void {\n this.bp = this.breakpoint;\n }\n @HostListener('click', ['$event'])\n toggleOpen($event: any) {\n $event.preventDefault();\n let cssClass;\n this.bp ? cssClass = `sidebar-${this.bp}-show` : cssClass = sidebarCssClasses[0];\n ToggleClasses(cssClass, sidebarCssClasses);\n }\n}\n\n@Directive({\n selector: '[appSidebarMinimizer]'\n})\nexport class SidebarMinimizeDirective {\n constructor() { }\n\n @HostListener('click', ['$event'])\n toggleOpen($event: any) {\n $event.preventDefault();\n document.querySelector('body').classList.toggle('sidebar-minimized');\n }\n}\n\n@Directive({\n selector: '[appMobileSidebarToggler]'\n})\nexport class MobileSidebarToggleDirective {\n constructor() { }\n\n // Check if element has class\n private hasClass(target: any, elementClassName: string) {\n return new RegExp('(\\\\s|^)' + elementClassName + '(\\\\s|$)').test(target.className);\n }\n\n @HostListener('click', ['$event'])\n toggleOpen($event: any) {\n $event.preventDefault();\n document.querySelector('body').classList.toggle('sidebar-mobile-show');\n }\n}\n\n/**\n* Allows the off-canvas sidebar to be closed via click.\n*/\n@Directive({\n selector: '[appSidebarClose]'\n})\nexport class SidebarOffCanvasCloseDirective {\n constructor() { }\n\n // Check if element has class\n private hasClass(target: any, elementClassName: string) {\n return new RegExp('(\\\\s|^)' + elementClassName + '(\\\\s|$)').test(target.className);\n }\n\n // Toggle element class\n private toggleClass(elem: any, elementClassName: string) {\n let newClass = ' ' + elem.className.replace( /[\\t\\r\\n]/g, ' ' ) + ' ';\n if (this.hasClass(elem, elementClassName)) {\n while (newClass.indexOf(' ' + elementClassName + ' ') >= 0 ) {\n newClass = newClass.replace( ' ' + elementClassName + ' ' , ' ' );\n }\n elem.className = newClass.replace(/^\\s+|\\s+$/g, '');\n } else {\n elem.className += ' ' + elementClassName;\n }\n }\n\n @HostListener('click', ['$event'])\n toggleOpen($event: any) {\n $event.preventDefault();\n\n if (this.hasClass(document.querySelector('body'), 'sidebar-off-canvas')) {\n this.toggleClass(document.querySelector('body'), 'sidebar-opened');\n }\n }\n}\n\n@Directive({\n selector: '[appBrandMinimizer]'\n})\nexport class BrandMinimizeDirective {\n constructor() { }\n\n @HostListener('click', ['$event'])\n toggleOpen($event: any) {\n $event.preventDefault();\n document.querySelector('body').classList.toggle('brand-minimized');\n }\n}\n\n\n/**\n* Allows the aside to be toggled via click.\n*/\n@Directive({\n selector: '[appAsideMenuToggler]',\n})\nexport class AsideToggleDirective implements OnInit {\n @Input('appAsideMenuToggler') breakpoint: string;\n public bp;\n constructor() {}\n ngOnInit(): void {\n this.bp = this.breakpoint;\n }\n @HostListener('click', ['$event'])\n toggleOpen($event: any) {\n $event.preventDefault();\n let cssClass;\n this.bp ? cssClass = `aside-menu-${this.bp}-show` : cssClass = asideMenuCssClasses[0];\n ToggleClasses(cssClass, asideMenuCssClasses);\n }\n}\n","import { CommonModule } from '@angular/common';\nimport { NgModule} from '@angular/core';\nimport {\n AsideToggleDirective,\n BrandMinimizeDirective,\n MobileSidebarToggleDirective,\n SidebarToggleDirective,\n SidebarMinimizeDirective,\n SidebarOffCanvasCloseDirective\n} from './layout.directive';\n\n@NgModule({\n imports: [\n CommonModule\n ],\n exports: [\n AsideToggleDirective,\n BrandMinimizeDirective,\n MobileSidebarToggleDirective,\n SidebarToggleDirective,\n SidebarMinimizeDirective,\n SidebarOffCanvasCloseDirective\n ],\n declarations: [\n AsideToggleDirective,\n BrandMinimizeDirective,\n MobileSidebarToggleDirective,\n SidebarToggleDirective,\n SidebarMinimizeDirective,\n SidebarOffCanvasCloseDirective\n ]\n})\nexport class LayoutModule { }\n","export function Replace(el: any): any {\n const nativeElement: HTMLElement = el.nativeElement;\n const parentElement: HTMLElement = nativeElement.parentElement;\n // move all children out of the element\n while (nativeElement.firstChild) {\n parentElement.insertBefore(nativeElement.firstChild, nativeElement);\n }\n // remove the empty element(the host)\n parentElement.removeChild(nativeElement);\n}\n","import { Component, ElementRef, Input, OnInit } from '@angular/core';\nimport { asideMenuCssClasses, Replace } from './../shared';\n\n@Component({\n selector: 'app-aside',\n template: `\n \n `\n})\nexport class AppAsideComponent implements OnInit {\n @Input() display: any;\n @Input() fixed: boolean;\n @Input() offCanvas: boolean;\n\n constructor(private el: ElementRef) {}\n\n ngOnInit() {\n Replace(this.el);\n this.isFixed(this.fixed);\n this.displayBreakpoint(this.display);\n }\n\n isFixed(fixed: boolean): void {\n if (this.fixed) { document.querySelector('body').classList.add('aside-menu-fixed'); }\n }\n\n isOffCanvas(offCanvas: boolean): void {\n if (this.offCanvas) { document.querySelector('body').classList.add('aside-menu-off-canvas'); }\n }\n\n displayBreakpoint(display: any): void {\n if (this.display !== false ) {\n let cssClass;\n this.display ? cssClass = `aside-menu-${this.display}-show` : cssClass = asideMenuCssClasses[0];\n document.querySelector('body').classList.add(cssClass);\n }\n }\n}\n","import { CommonModule} from '@angular/common';\nimport { NgModule } from '@angular/core';\nimport { LayoutModule } from './../shared';\n\nimport { AppAsideComponent } from './app-aside.component';\n\n@NgModule({\n imports: [\n CommonModule,\n LayoutModule\n ],\n exports: [\n AppAsideComponent,\n LayoutModule\n ],\n declarations: [\n AppAsideComponent\n ]\n})\nexport class AppAsideModule {}\n","import { Injectable, Injector } from '@angular/core';\r\nimport { Router, ActivatedRoute, NavigationEnd } from '@angular/router';\r\nimport { BehaviorSubject, Observable } from 'rxjs/index';\r\nimport { filter } from 'rxjs/operators';\r\n\r\n@Injectable()\r\nexport class AppBreadcrumbService {\r\n\r\n breadcrumbs: Observable>;\r\n\r\n private _breadcrumbs: BehaviorSubject>;\r\n\r\n constructor(private router: Router, private route: ActivatedRoute) {\r\n\r\n this._breadcrumbs = new BehaviorSubject