@mintplayer/ng-bootstrap 15.26.2 → 16.0.0

package/esm2022/navbar/src/navbar-item/navbar-item.component.mjs

@@ -0,0 +1,105 @@
+import { Component, ContentChildren, ElementRef, forwardRef, Inject, Optional, PLATFORM_ID, QueryList } from '@angular/core';
+import { isPlatformServer } from '@angular/common';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { BsNavbarComponent } from '../navbar/navbar.component';
+import { BsNavbarDropdownComponent } from '../navbar-dropdown/navbar-dropdown.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../navbar/navbar.component";
+import * as i2 from "../navbar-dropdown/navbar-dropdown.component";
+class BsNavbarItemComponent {
+    constructor(navbar, element, 
+    // private injector: Injector,
+    platformId, parentDropdown) {
+        this.navbar = navbar;
+        this.platformId = platformId;
+        this.hasDropdown = false;
+        this.anchorTag = null;
+        this.destroyed$ = new Subject();
+        this.element = element;
+        this.parentDropdown = parentDropdown;
+    }
+    ngAfterContentChecked() {
+        this.anchorTag = this.element.nativeElement.querySelector('li a');
+        if (this.hasDropdown) {
+            if (this.anchorTag) {
+                this.anchorTag.classList.add('dropdown-toggle');
+                if (isPlatformServer(this.platformId)) {
+                    this.anchorTag.href = 'javascript:;';
+                }
+                if (!this.anchorTag.getAttribute('close-init-b')) {
+                    this.anchorTag.setAttribute('close-init-b', '1');
+                    this.anchorTag.addEventListener('click', (ev) => {
+                        ev.preventDefault();
+                        // Normally there should be only one dropdown in this list
+                        this.dropdowns.forEach((dropdown) => {
+                            if (!(dropdown.isVisible = !dropdown.isVisible)) {
+                                dropdown.childDropdowns.forEach((child) => {
+                                    child.isVisible = false;
+                                });
+                            }
+                            else if (this.parentDropdown) {
+                                // import('@angular/cdk/overlay').then(({ OverlayModule, Overlay }) => {
+                                //   const overlayService = this.injector.get(Overlay);
+                                //   return overlayService;
+                                // }).then((overlayService) => {
+                                //   const p = new DomPortal(dropdown.element);
+                                //   const overlayRef = overlayService.create({
+                                //     positionStrategy: overlayService.position()
+                                //       .flexibleConnectedTo(this.element)
+                                //       .withPositions([
+                                //         { originX: 'end', originY: 'top', overlayX: 'start', overlayY: 'top' }
+                                //       ])
+                                //   });
+                                // overlayRef.attach(p);
+                                // });
+                                // dropdown.showInOverlay = true;
+                                this.navbar.isSmallMode$
+                                    .pipe(takeUntil(this.destroyed$))
+                                    .subscribe((isSmallMode) => {
+                                    dropdown.showInOverlay = !isSmallMode;
+                                });
+                            }
+                        });
+                        return false;
+                    });
+                }
+            }
+        }
+        else {
+            // Close if this is a link
+            if ((this.dropdowns.length === 0) && this.anchorTag && !this.anchorTag.getAttribute('close-init-a')) {
+                this.anchorTag.setAttribute('close-init-a', '1');
+                this.anchorTag.addEventListener('click', (ev) => {
+                    let d = this.parentDropdown;
+                    while (d && d.autoclose) {
+                        d.isVisible = false;
+                        d = d.parentDropdown;
+                    }
+                    if (this.navbar.autoclose) {
+                        this.navbar.isExpanded$.next(false);
+                    }
+                });
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.destroyed$.next(true);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavbarItemComponent, deps: [{ token: i1.BsNavbarComponent }, { token: i0.ElementRef }, { token: PLATFORM_ID }, { token: i2.BsNavbarDropdownComponent, optional: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: BsNavbarItemComponent, selector: "bs-navbar-item", queries: [{ propertyName: "dropdowns", predicate: i0.forwardRef(function () { return BsNavbarDropdownComponent; }) }], ngImport: i0, template: "<li [class.nav-item]=\"parentDropdown === null\" [class.dropdown]=\"(dropdowns.length > 0) && (parentDropdown === null)\" [class.dropend]=\"(dropdowns.length > 0) && (parentDropdown !== null)\">\n    <ng-content></ng-content>\n</li>", styles: ["li.dropend ::ng-deep a.dropdown-toggle{padding-right:1.5rem}li.dropend ::ng-deep a.dropdown-toggle:after{position:absolute;right:.5rem;top:.75rem}\n"] }); }
+}
+export { BsNavbarItemComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavbarItemComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bs-navbar-item', template: "<li [class.nav-item]=\"parentDropdown === null\" [class.dropdown]=\"(dropdowns.length > 0) && (parentDropdown === null)\" [class.dropend]=\"(dropdowns.length > 0) && (parentDropdown !== null)\">\n    <ng-content></ng-content>\n</li>", styles: ["li.dropend ::ng-deep a.dropdown-toggle{padding-right:1.5rem}li.dropend ::ng-deep a.dropdown-toggle:after{position:absolute;right:.5rem;top:.75rem}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.BsNavbarComponent }, { type: i0.ElementRef }, { type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i2.BsNavbarDropdownComponent, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { dropdowns: [{
+                type: ContentChildren,
+                args: [forwardRef(() => BsNavbarDropdownComponent)]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"navbar-item.component.js","sourceRoot":"","sources":["../../../../../../../libs/mintplayer-ng-bootstrap/navbar/src/navbar-item/navbar-item.component.ts","../../../../../../../libs/mintplayer-ng-bootstrap/navbar/src/navbar-item/navbar-item.component.html"],"names":[],"mappings":"AAAA,OAAO,EAAkC,SAAS,EAAE,eAAe,EAAE,UAAU,EAAE,UAAU,EAAE,MAAM,EAAY,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAoB,MAAM,eAAe,CAAC;AACzL,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAEnD,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AAC/D,OAAO,EAAE,yBAAyB,EAAE,MAAM,8CAA8C,CAAC;;;;AAEzF,MAKa,qBAAqB;IAEhC,YACU,MAAyB,EACjC,OAAmB;IACnB,8BAA8B;IACD,UAAkB,EACnC,cAAyC;QAJ7C,WAAM,GAAN,MAAM,CAAmB;QAGJ,eAAU,GAAV,UAAU,CAAQ;QASjD,gBAAW,GAAG,KAAK,CAAC;QACpB,cAAS,GAA6B,IAAI,CAAC;QACnC,eAAU,GAAG,IAAI,OAAO,EAAE,CAAC;QARjC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACvC,CAAC;IASD,qBAAqB;QACnB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;QAElE,IAAI,IAAI,CAAC,WAAW,EAAE;YACpB,IAAI,IAAI,CAAC,SAAS,EAAE;gBAClB,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,iBAAiB,CAAC,CAAC;gBAEhD,IAAI,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE;oBACrC,IAAI,CAAC,SAAS,CAAC,IAAI,GAAG,cAAc,CAAC;iBACtC;gBAED,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE;oBAChD,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;oBACjD,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,EAAc,EAAE,EAAE;wBAC1D,EAAE,CAAC,cAAc,EAAE,CAAC;wBACpB,0DAA0D;wBAC1D,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;4BAClC,IAAI,CAAC,CAAC,QAAQ,CAAC,SAAS,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE;gCAC/C,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;oCACxC,KAAK,CAAC,SAAS,GAAG,KAAK,CAAC;gCAC1B,CAAC,CAAC,CAAC;6BACJ;iCAAM,IAAI,IAAI,CAAC,cAAc,EAAE;gCAC9B,wEAAwE;gCACxE,uDAAuD;gCACvD,2BAA2B;gCAC3B,gCAAgC;gCAEhC,+CAA+C;gCAC/C,+CAA+C;gCAC/C,kDAAkD;gCAClD,2CAA2C;gCAC3C,yBAAyB;gCACzB,iFAAiF;gCACjF,WAAW;gCACX,QAAQ;gCACN,wBAAwB;gCAE1B,MAAM;gCACN,iCAAiC;gCAEjC,IAAI,CAAC,MAAM,CAAC,YAAY;qCACrB,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;qCAChC,SAAS,CAAC,CAAC,WAAW,EAAE,EAAE;oCACzB,QAAQ,CAAC,aAAa,GAAG,CAAC,WAAW,CAAC;gCACxC,CAAC,CAAC,CAAC;6BACN;wBACH,CAAC,CAAC,CAAC;wBACH,OAAO,KAAK,CAAC;oBACf,CAAC,CAAC,CAAC;iBACJ;aACF;SACF;aAAM;YAEL,0BAA0B;YAC1B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,CAAC,IAAI,IAAI,CAAC,SAAS,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,cAAc,CAAC,EAAE;gBACnG,IAAI,CAAC,SAAS,CAAC,YAAY,CAAC,cAAc,EAAE,GAAG,CAAC,CAAC;gBACjD,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAAC,OAAO,EAAE,CAAC,EAAc,EAAE,EAAE;oBAC1D,IAAI,CAAC,GAAG,IAAI,CAAC,cAAc,CAAC;oBAC5B,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE;wBACvB,CAAC,CAAC,SAAS,GAAG,KAAK,CAAC;wBACpB,CAAC,GAAG,CAAC,CAAC,cAAc,CAAC;qBACtB;oBACD,IAAI,IAAI,CAAC,MAAM,CAAC,SAAS,EAAE;wBACzB,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;qBACrC;gBACH,CAAC,CAAC,CAAC;aACJ;SAEF;IACH,CAAC;IAED,WAAW;QACT,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC7B,CAAC;8GA7FU,qBAAqB,6EAMtB,WAAW;kGANV,qBAAqB,mHAkBE,yBAAyB,iCC/B7D,0OAEK;;SDWQ,qBAAqB;2FAArB,qBAAqB;kBALjC,SAAS;+BACE,gBAAgB;;0BAUvB,MAAM;2BAAC,WAAW;;0BAClB,QAAQ;4CAWmD,SAAS;sBAAtE,eAAe;uBAAC,UAAU,CAAC,GAAG,EAAE,CAAC,yBAAyB,CAAC","sourcesContent":["import { AfterContentChecked, OnDestroy, Component, ContentChildren, ElementRef, forwardRef, Inject, Injector, Optional, PLATFORM_ID, QueryList, ViewContainerRef } from '@angular/core';\nimport { isPlatformServer } from '@angular/common';\nimport { DomPortal } from '@angular/cdk/portal';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { BsNavbarComponent } from '../navbar/navbar.component';\nimport { BsNavbarDropdownComponent } from '../navbar-dropdown/navbar-dropdown.component';\n\n@Component({\n  selector: 'bs-navbar-item',\n  templateUrl: './navbar-item.component.html',\n  styleUrls: ['./navbar-item.component.scss']\n})\nexport class BsNavbarItemComponent implements AfterContentChecked, OnDestroy {\n\n  constructor(\n    private navbar: BsNavbarComponent,\n    element: ElementRef,\n    // private injector: Injector,\n    @Inject(PLATFORM_ID) private platformId: Object,\n    @Optional() parentDropdown: BsNavbarDropdownComponent,\n  ) {\n    this.element = element;\n    this.parentDropdown = parentDropdown;\n  }\n\n  element: ElementRef;\n  parentDropdown: BsNavbarDropdownComponent;\n  hasDropdown = false;\n  anchorTag: HTMLAnchorElement | null = null;\n  private destroyed$ = new Subject();\n  @ContentChildren(forwardRef(() => BsNavbarDropdownComponent)) dropdowns!: QueryList<BsNavbarDropdownComponent>;\n\n  ngAfterContentChecked() {\n    this.anchorTag = this.element.nativeElement.querySelector('li a');\n\n    if (this.hasDropdown) {\n      if (this.anchorTag) {\n        this.anchorTag.classList.add('dropdown-toggle');\n\n        if (isPlatformServer(this.platformId)) {\n          this.anchorTag.href = 'javascript:;';\n        }\n  \n        if (!this.anchorTag.getAttribute('close-init-b')) {\n          this.anchorTag.setAttribute('close-init-b', '1');\n          this.anchorTag.addEventListener('click', (ev: MouseEvent) => {\n            ev.preventDefault();\n            // Normally there should be only one dropdown in this list\n            this.dropdowns.forEach((dropdown) => {\n              if (!(dropdown.isVisible = !dropdown.isVisible)) {\n                dropdown.childDropdowns.forEach((child) => {\n                  child.isVisible = false;\n                });\n              } else if (this.parentDropdown) {\n                // import('@angular/cdk/overlay').then(({ OverlayModule, Overlay }) => {\n                //   const overlayService = this.injector.get(Overlay);\n                //   return overlayService;\n                // }).then((overlayService) => {\n\n                //   const p = new DomPortal(dropdown.element);\n                //   const overlayRef = overlayService.create({\n                //     positionStrategy: overlayService.position()\n                //       .flexibleConnectedTo(this.element)\n                //       .withPositions([\n                //         { originX: 'end', originY: 'top', overlayX: 'start', overlayY: 'top' }\n                //       ])\n                //   });\n                  // overlayRef.attach(p);\n\n                // });\n                // dropdown.showInOverlay = true;\n\n                this.navbar.isSmallMode$\n                  .pipe(takeUntil(this.destroyed$))\n                  .subscribe((isSmallMode) => {\n                    dropdown.showInOverlay = !isSmallMode;\n                  });\n              }\n            });\n            return false;\n          });\n        }\n      }\n    } else {\n\n      // Close if this is a link\n      if ((this.dropdowns.length === 0) && this.anchorTag && !this.anchorTag.getAttribute('close-init-a')) {\n        this.anchorTag.setAttribute('close-init-a', '1');\n        this.anchorTag.addEventListener('click', (ev: MouseEvent) => {\n          let d = this.parentDropdown;\n          while (d && d.autoclose) {\n            d.isVisible = false;\n            d = d.parentDropdown;\n          }\n          if (this.navbar.autoclose) {\n            this.navbar.isExpanded$.next(false);\n          }\n        });\n      }\n\n    }\n  }\n\n  ngOnDestroy() {\n    this.destroyed$.next(true);\n  }\n}\n","<li [class.nav-item]=\"parentDropdown === null\" [class.dropdown]=\"(dropdowns.length > 0) && (parentDropdown === null)\" [class.dropend]=\"(dropdowns.length > 0) && (parentDropdown !== null)\">\n    <ng-content></ng-content>\n</li>"]}

package/esm2022/navbar/src/navbar-nav/navbar-nav.component.mjs

@@ -0,0 +1,70 @@
+import { Component, HostListener, Input } from '@angular/core';
+import { SlideUpDownAnimation } from '@mintplayer/ng-animations';
+import { BehaviorSubject, combineLatest, debounceTime, filter, map, Subject, takeUntil } from 'rxjs';
+import { BsNavbarComponent } from '../navbar/navbar.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../navbar/navbar.component";
+import * as i2 from "@angular/common";
+class BsNavbarNavComponent {
+    constructor(bsNavbar) {
+        this.collapse$ = new BehaviorSubject(true);
+        this.windowWidth$ = new BehaviorSubject(null);
+        this.isResizing$ = new BehaviorSubject(false);
+        this.destroyed$ = new Subject();
+        this.bsNavbar = bsNavbar;
+        this.showNavs$ = combineLatest([this.bsNavbar.isExpanded$, this.bsNavbar.expandAt$, this.windowWidth$])
+            .pipe(filter(([isExpanded, expandAt, windowWidth]) => {
+            return windowWidth !== null;
+        }))
+            .pipe(map(([isExpanded, expandAt, windowWidth]) => {
+            if (windowWidth === null) {
+                throw 'windowWidth should not be null here';
+            }
+            else if (expandAt === null) {
+                return isExpanded;
+            }
+            else if (windowWidth >= expandAt) {
+                return true;
+            }
+            else {
+                return isExpanded;
+            }
+        }));
+        this.windowWidth$
+            .pipe(debounceTime(300), takeUntil(this.destroyed$))
+            .subscribe(() => {
+            this.isResizing$.next(false);
+        });
+        this.onWindowResize();
+    }
+    ngOnDestroy() {
+        this.destroyed$.next(true);
+    }
+    //#region collapse
+    set collapse(value) {
+        this.collapse$.next(value);
+    }
+    get collapse() {
+        return this.collapse$.value;
+    }
+    //#endregion
+    onWindowResize() {
+        this.isResizing$.next(true);
+        if (typeof window !== 'undefined') {
+            this.windowWidth$.next(window.innerWidth);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavbarNavComponent, deps: [{ token: i1.BsNavbarComponent }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: BsNavbarNavComponent, selector: "bs-navbar-nav", inputs: { collapse: "collapse" }, host: { listeners: { "window:resize": "onWindowResize()" } }, ngImport: i0, template: "<div class=\"navbar-collapse w-100 show\" [class.collapse]=\"collapse$ | async\" [@slideUpDown]=\"showNavs$ | async\" [@.disabled]=\"isResizing$ | async\">\n    <ul class=\"navbar-nav mr-auto\">\n        <ng-content></ng-content>\n    </ul>\n</div>", styles: [":host{margin-right:auto}@media screen and (max-width: 767px){:host{width:100%!important}.navbar-collapse.collapse{overflow:hidden}}\n"], dependencies: [{ kind: "pipe", type: i2.AsyncPipe, name: "async" }], animations: [SlideUpDownAnimation] }); }
+}
+export { BsNavbarNavComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavbarNavComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bs-navbar-nav', animations: [SlideUpDownAnimation], template: "<div class=\"navbar-collapse w-100 show\" [class.collapse]=\"collapse$ | async\" [@slideUpDown]=\"showNavs$ | async\" [@.disabled]=\"isResizing$ | async\">\n    <ul class=\"navbar-nav mr-auto\">\n        <ng-content></ng-content>\n    </ul>\n</div>", styles: [":host{margin-right:auto}@media screen and (max-width: 767px){:host{width:100%!important}.navbar-collapse.collapse{overflow:hidden}}\n"] }]
+        }], ctorParameters: function () { return [{ type: i1.BsNavbarComponent }]; }, propDecorators: { collapse: [{
+                type: Input
+            }], onWindowResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/navbar/src/navbar-toggler/navbar-toggler.component.mjs

@@ -0,0 +1,48 @@
+import { Component, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+class BsNavbarTogglerComponent {
+    constructor() {
+        //#region State
+        this._state = 'closed';
+        this.stateChange = new EventEmitter();
+        //#endregion
+        this.toggleOnClick = true;
+    }
+    get state() {
+        return this._state;
+    }
+    set state(value) {
+        this._state = value;
+        this.stateChange.emit(this._state);
+    }
+    toggleState(ev) {
+        if (this.toggleOnClick) {
+            switch (this._state) {
+                case 'open':
+                    this.state = 'closed';
+                    break;
+                default:
+                    this.state = 'open';
+                    break;
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavbarTogglerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.0", type: BsNavbarTogglerComponent, selector: "bs-navbar-toggler", inputs: { state: "state", toggleOnClick: "toggleOnClick" }, outputs: { stateChange: "stateChange" }, host: { listeners: { "click": "toggleState($event)" } }, ngImport: i0, template: "<div class=\"navbar-toggler float-left\" [ngClass]=\"state\">\n    <div></div>\n    <div></div>\n    <div></div>\n</div>", styles: [":host{align-self:start;top:0;right:0}.navbar-toggler{padding:.75rem 1rem;border:none}.navbar-toggler>div{width:25px;height:2px;background:#BBB;margin:6px 0;transition:.4s}.navbar-toggler.open>div:nth-of-type(1){transform:rotate(-45deg) translate(-7px,5px)}.navbar-toggler.open>div:nth-of-type(2){opacity:0}.navbar-toggler.open>div:nth-of-type(3){transform:rotate(45deg) translate(-6px,-4px)}@media (min-width: 768px){.navbar-toggler.auto>div:nth-of-type(1){transform:rotate(-45deg) translate(-7px,5px)}.navbar-toggler.auto>div:nth-of-type(2){opacity:0}.navbar-toggler.auto>div:nth-of-type(3){transform:rotate(45deg) translate(-6px,-4px)}}\n"], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] }); }
+}
+export { BsNavbarTogglerComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavbarTogglerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bs-navbar-toggler', template: "<div class=\"navbar-toggler float-left\" [ngClass]=\"state\">\n    <div></div>\n    <div></div>\n    <div></div>\n</div>", styles: [":host{align-self:start;top:0;right:0}.navbar-toggler{padding:.75rem 1rem;border:none}.navbar-toggler>div{width:25px;height:2px;background:#BBB;margin:6px 0;transition:.4s}.navbar-toggler.open>div:nth-of-type(1){transform:rotate(-45deg) translate(-7px,5px)}.navbar-toggler.open>div:nth-of-type(2){opacity:0}.navbar-toggler.open>div:nth-of-type(3){transform:rotate(45deg) translate(-6px,-4px)}@media (min-width: 768px){.navbar-toggler.auto>div:nth-of-type(1){transform:rotate(-45deg) translate(-7px,5px)}.navbar-toggler.auto>div:nth-of-type(2){opacity:0}.navbar-toggler.auto>div:nth-of-type(3){transform:rotate(45deg) translate(-6px,-4px)}}\n"] }]
+        }], propDecorators: { stateChange: [{
+                type: Output
+            }], state: [{
+                type: Input
+            }], toggleOnClick: [{
+                type: Input
+            }], toggleState: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/navbar/src/navbar.module.mjs

@@ -0,0 +1,92 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ClickOutsideModule } from '@mintplayer/ng-click-outside';
+import { BsUserAgentModule } from '@mintplayer/ng-bootstrap/user-agent';
+import { BsNoNoscriptModule } from '@mintplayer/ng-bootstrap/no-noscript';
+import { BsHasOverlayModule } from '@mintplayer/ng-bootstrap/has-overlay';
+import { BsNavbarComponent } from './navbar/navbar.component';
+import { BsNavbarNavComponent } from './navbar-nav/navbar-nav.component';
+import { BsNavbarDropdownComponent } from './navbar-dropdown/navbar-dropdown.component';
+import { BsNavbarItemComponent } from './navbar-item/navbar-item.component';
+import { DropdownToggleDirective } from './dropdown-toggle/dropdown-toggle.directive';
+import { NavLinkDirective } from './nav-link/nav-link.directive';
+import { BsNavbarContentDirective } from './navbar-content/navbar-content.directive';
+import { BsNavbarBrandComponent } from './navbar-brand/navbar-brand.component';
+import { BsExpandButtonDirective } from './expand-button/expand-button.directive';
+import { BsNavbarTogglerComponent } from './navbar-toggler/navbar-toggler.component';
+import { BsDropdownDividerDirective, BsDropdownDividerModule } from '@mintplayer/ng-bootstrap/dropdown-divider';
+import * as i0 from "@angular/core";
+class BsNavbarModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavbarModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: BsNavbarModule, declarations: [BsNavbarComponent,
+            BsNavbarNavComponent,
+            BsNavbarDropdownComponent,
+            BsNavbarItemComponent,
+            DropdownToggleDirective,
+            NavLinkDirective,
+            BsNavbarContentDirective,
+            BsNavbarBrandComponent,
+            BsExpandButtonDirective,
+            BsNavbarTogglerComponent], imports: [CommonModule,
+            ClickOutsideModule,
+            BsUserAgentModule,
+            BsNoNoscriptModule,
+            BsHasOverlayModule,
+            BsDropdownDividerModule], exports: [BsNavbarComponent,
+            BsNavbarNavComponent,
+            BsNavbarDropdownComponent,
+            BsNavbarItemComponent,
+            DropdownToggleDirective,
+            NavLinkDirective,
+            BsNavbarContentDirective,
+            BsNavbarBrandComponent,
+            BsExpandButtonDirective,
+            BsNavbarTogglerComponent,
+            BsDropdownDividerDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavbarModule, imports: [CommonModule,
+            ClickOutsideModule,
+            BsUserAgentModule,
+            BsNoNoscriptModule,
+            BsHasOverlayModule,
+            BsDropdownDividerModule] }); }
+}
+export { BsNavbarModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavbarModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        BsNavbarComponent,
+                        BsNavbarNavComponent,
+                        BsNavbarDropdownComponent,
+                        BsNavbarItemComponent,
+                        DropdownToggleDirective,
+                        NavLinkDirective,
+                        BsNavbarContentDirective,
+                        BsNavbarBrandComponent,
+                        BsExpandButtonDirective,
+                        BsNavbarTogglerComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        ClickOutsideModule,
+                        BsUserAgentModule,
+                        BsNoNoscriptModule,
+                        BsHasOverlayModule,
+                        BsDropdownDividerModule,
+                    ],
+                    exports: [
+                        BsNavbarComponent,
+                        BsNavbarNavComponent,
+                        BsNavbarDropdownComponent,
+                        BsNavbarItemComponent,
+                        DropdownToggleDirective,
+                        NavLinkDirective,
+                        BsNavbarContentDirective,
+                        BsNavbarBrandComponent,
+                        BsExpandButtonDirective,
+                        BsNavbarTogglerComponent,
+                        BsDropdownDividerDirective,
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/navigation-lock/src/directive/navigation-lock.directive.mjs

@@ -0,0 +1,95 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import { ActivatedRoute, Router } from '@angular/router';
+import { Subject, take } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+/**
+ * Places a navigation lock on this page.
+ *
+ * Don't forget to add the following to your route:
+ *
+ * ```ts
+ * canDeactivate: [BsNavigationLockGuard]
+ * ```
+ *
+ * and implement the `BsHasNavigationLock` on the page:
+ *
+ * ```ts
+ * ViewChild('navigationLock') navigationLock!: BsNavigationLockDirective;
+ * ```
+ *
+ **/
+class BsNavigationLockDirective {
+    constructor(router, route) {
+        // console.log('initial navigation', this.route.snapshot.pathFromRoot.flatMap(ars => ars.url));
+        // combineLatest([this.route.fragment])
+        //   .pipe(takeUntil(this.destroyed$))
+        //   .subscribe((fragment) => {
+        //     console.log('fragments', fragment);
+        //   });
+        this.router = router;
+        this.route = route;
+        this.destroyed$ = new Subject();
+        // router.events.subscribe((ev) => {
+        //   // if (ev instanceof RouterEvent) {
+        //   //   (<RouterEvent>ev).
+        //   // }
+        //   // console.log('router event', ev);
+        // });
+    }
+    requestCanExit() {
+        return new Promise((resolve, reject) => {
+            if (typeof this.canExit === 'undefined') {
+                resolve(true);
+            }
+            else if (typeof this.canExit === 'boolean') {
+                resolve(this.canExit);
+            }
+            else if (typeof this.canExit === 'function') {
+                const result = this.canExit();
+                resolve(result);
+            }
+            else {
+                this.canExit.pipe(take(1))
+                    .subscribe((result) => resolve(result));
+            }
+        });
+    }
+    async onBeforeUnload(ev) {
+        const canExit = await this.requestCanExit();
+        if (!canExit) {
+            ev.preventDefault();
+            ev.returnValue = false;
+            return 'Are you sure?';
+        }
+        else {
+            return undefined;
+        }
+    }
+    onUnload(ev) {
+    }
+    ngOnDestroy() {
+        this.destroyed$.next(true);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavigationLockDirective, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: BsNavigationLockDirective, selector: "[bsNavigationLock]", inputs: { canExit: "canExit", exitMessage: "exitMessage" }, host: { listeners: { "window:beforeunload": "onBeforeUnload($event)", "window:unload": "onUnload($event)" } }, exportAs: ["bsNavigationLock"], ngImport: i0 }); }
+}
+export { BsNavigationLockDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavigationLockDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[bsNavigationLock]',
+                    exportAs: 'bsNavigationLock'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }]; }, propDecorators: { canExit: [{
+                type: Input
+            }], exitMessage: [{
+                type: Input
+            }], onBeforeUnload: [{
+                type: HostListener,
+                args: ['window:beforeunload', ['$event']]
+            }], onUnload: [{
+                type: HostListener,
+                args: ['window:unload', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/navigation-lock/src/guard/navigation-lock.guard.mjs

@@ -0,0 +1,23 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+class BsNavigationLockGuard {
+    canDeactivate(component, currentRoute, currentState, nextState) {
+        if (component.navigationLock) {
+            return component.navigationLock.requestCanExit();
+        }
+        else {
+            console.warn('When using <bs-navigation-lock>, you should implement BsHasNavigationLock and add "@ViewChild(\'navigationLock\') navigationLock!: BsNavigationLockDirective;" to your page');
+            return new Promise(resolve => resolve(false));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavigationLockGuard, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavigationLockGuard, providedIn: 'root' }); }
+}
+export { BsNavigationLockGuard };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavigationLockGuard, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/navigation-lock/src/navigation-lock.module.mjs

@@ -0,0 +1,29 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RouterModule } from '@angular/router';
+import { BsNavigationLockDirective } from './directive/navigation-lock.directive';
+import * as i0 from "@angular/core";
+class BsNavigationLockModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavigationLockModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: BsNavigationLockModule, declarations: [BsNavigationLockDirective], imports: [CommonModule,
+            RouterModule], exports: [BsNavigationLockDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavigationLockModule, imports: [CommonModule,
+            RouterModule] }); }
+}
+export { BsNavigationLockModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNavigationLockModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        BsNavigationLockDirective
+                    ],
+                    imports: [
+                        CommonModule,
+                        RouterModule
+                    ],
+                    exports: [
+                        BsNavigationLockDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF2aWdhdGlvbi1sb2NrLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvbWludHBsYXllci1uZy1ib290c3RyYXAvbmF2aWdhdGlvbi1sb2NrL3NyYy9uYXZpZ2F0aW9uLWxvY2subW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSx1Q0FBdUMsQ0FBQzs7QUFFbEYsTUFZYSxzQkFBc0I7OEdBQXRCLHNCQUFzQjsrR0FBdEIsc0JBQXNCLGlCQVYvQix5QkFBeUIsYUFHekIsWUFBWTtZQUNaLFlBQVksYUFHWix5QkFBeUI7K0dBR2hCLHNCQUFzQixZQVAvQixZQUFZO1lBQ1osWUFBWTs7U0FNSCxzQkFBc0I7MkZBQXRCLHNCQUFzQjtrQkFabEMsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUU7d0JBQ1oseUJBQXlCO3FCQUMxQjtvQkFDRCxPQUFPLEVBQUU7d0JBQ1AsWUFBWTt3QkFDWixZQUFZO3FCQUNiO29CQUNELE9BQU8sRUFBRTt3QkFDUCx5QkFBeUI7cUJBQzFCO2lCQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBSb3V0ZXJNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuaW1wb3J0IHsgQnNOYXZpZ2F0aW9uTG9ja0RpcmVjdGl2ZSB9IGZyb20gJy4vZGlyZWN0aXZlL25hdmlnYXRpb24tbG9jay5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtcbiAgICBCc05hdmlnYXRpb25Mb2NrRGlyZWN0aXZlXG4gIF0sXG4gIGltcG9ydHM6IFtcbiAgICBDb21tb25Nb2R1bGUsXG4gICAgUm91dGVyTW9kdWxlXG4gIF0sXG4gIGV4cG9ydHM6IFtcbiAgICBCc05hdmlnYXRpb25Mb2NrRGlyZWN0aXZlXG4gIF1cbn0pXG5leHBvcnQgY2xhc3MgQnNOYXZpZ2F0aW9uTG9ja01vZHVsZSB7IH1cbiJdfQ==

package/esm2022/no-noscript/src/no-noscript/no-noscript.directive.mjs

@@ -0,0 +1,28 @@
+import { isPlatformServer } from '@angular/common';
+import { Directive, HostBinding, Inject, PLATFORM_ID } from '@angular/core';
+import * as i0 from "@angular/core";
+class BsNoNoscriptDirective {
+    constructor(platformId) {
+        this.platformId = platformId;
+        this.isNoScript = false;
+        if (isPlatformServer(platformId)) {
+            this.isNoScript = true;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNoNoscriptDirective, deps: [{ token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.0", type: BsNoNoscriptDirective, selector: "[bsNoNoscript]", host: { properties: { "class.noscript": "this.isNoScript" } }, ngImport: i0 }); }
+}
+export { BsNoNoscriptDirective };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNoNoscriptDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[bsNoNoscript]'
+                }]
+        }], ctorParameters: function () { return [{ type: Object, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; }, propDecorators: { isNoScript: [{
+                type: HostBinding,
+                args: ['class.noscript']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm8tbm9zY3JpcHQuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9taW50cGxheWVyLW5nLWJvb3RzdHJhcC9uby1ub3NjcmlwdC9zcmMvbm8tbm9zY3JpcHQvbm8tbm9zY3JpcHQuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxTQUFTLEVBQUUsV0FBVyxFQUFFLE1BQU0sRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRTVFLE1BR2EscUJBQXFCO0lBRWhDLFlBQXlDLFVBQWtCO1FBQWxCLGVBQVUsR0FBVixVQUFVLENBQVE7UUFNNUIsZUFBVSxHQUFHLEtBQUssQ0FBQztRQUxoRCxJQUFJLGdCQUFnQixDQUFDLFVBQVUsQ0FBQyxFQUFFO1lBQ2hDLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDO1NBQ3hCO0lBQ0gsQ0FBQzs4R0FOVSxxQkFBcUIsa0JBRVosV0FBVztrR0FGcEIscUJBQXFCOztTQUFyQixxQkFBcUI7MkZBQXJCLHFCQUFxQjtrQkFIakMsU0FBUzttQkFBQztvQkFDVCxRQUFRLEVBQUUsZ0JBQWdCO2lCQUMzQjs7MEJBR2MsTUFBTTsyQkFBQyxXQUFXOzRDQU1BLFVBQVU7c0JBQXhDLFdBQVc7dUJBQUMsZ0JBQWdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaXNQbGF0Zm9ybVNlcnZlciB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBEaXJlY3RpdmUsIEhvc3RCaW5kaW5nLCBJbmplY3QsIFBMQVRGT1JNX0lEIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1tic05vTm9zY3JpcHRdJ1xufSlcbmV4cG9ydCBjbGFzcyBCc05vTm9zY3JpcHREaXJlY3RpdmUge1xuXG4gIGNvbnN0cnVjdG9yKEBJbmplY3QoUExBVEZPUk1fSUQpIHByaXZhdGUgcGxhdGZvcm1JZDogT2JqZWN0KSB7XG4gICAgaWYgKGlzUGxhdGZvcm1TZXJ2ZXIocGxhdGZvcm1JZCkpIHtcbiAgICAgIHRoaXMuaXNOb1NjcmlwdCA9IHRydWU7XG4gICAgfVxuICB9XG5cbiAgQEhvc3RCaW5kaW5nKCdjbGFzcy5ub3NjcmlwdCcpIGlzTm9TY3JpcHQgPSBmYWxzZTtcblxufVxuIl19

package/esm2022/no-noscript/src/no-noscript.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { BsNoNoscriptDirective } from './no-noscript/no-noscript.directive';
+import * as i0 from "@angular/core";
+class BsNoNoscriptModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNoNoscriptModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.0", ngImport: i0, type: BsNoNoscriptModule, declarations: [BsNoNoscriptDirective], imports: [CommonModule], exports: [BsNoNoscriptDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNoNoscriptModule, imports: [CommonModule] }); }
+}
+export { BsNoNoscriptModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.0", ngImport: i0, type: BsNoNoscriptModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [BsNoNoscriptDirective],
+                    imports: [CommonModule],
+                    exports: [BsNoNoscriptDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm8tbm9zY3JpcHQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9taW50cGxheWVyLW5nLWJvb3RzdHJhcC9uby1ub3NjcmlwdC9zcmMvbm8tbm9zY3JpcHQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHFDQUFxQyxDQUFDOztBQUk1RSxNQUthLGtCQUFrQjs4R0FBbEIsa0JBQWtCOytHQUFsQixrQkFBa0IsaUJBSmQscUJBQXFCLGFBQzFCLFlBQVksYUFDWixxQkFBcUI7K0dBRXBCLGtCQUFrQixZQUhuQixZQUFZOztTQUdYLGtCQUFrQjsyRkFBbEIsa0JBQWtCO2tCQUw5QixRQUFRO21CQUFDO29CQUNSLFlBQVksRUFBRSxDQUFDLHFCQUFxQixDQUFDO29CQUNyQyxPQUFPLEVBQUUsQ0FBQyxZQUFZLENBQUM7b0JBQ3ZCLE9BQU8sRUFBRSxDQUFDLHFCQUFxQixDQUFDO2lCQUNqQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgQnNOb05vc2NyaXB0RGlyZWN0aXZlIH0gZnJvbSAnLi9uby1ub3NjcmlwdC9uby1ub3NjcmlwdC5kaXJlY3RpdmUnO1xuXG5cblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbQnNOb05vc2NyaXB0RGlyZWN0aXZlXSxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGV4cG9ydHM6IFtCc05vTm9zY3JpcHREaXJlY3RpdmVdXG59KVxuZXhwb3J0IGNsYXNzIEJzTm9Ob3NjcmlwdE1vZHVsZSB7IH1cbiJdfQ==