@evotor-dev/ui-kit 6.17.1 → 6.17.2

package/esm2015/lib/components/evo-navigation-tabs/evo-navigation-tab.directive.js

@@ -0,0 +1,52 @@
+import { Directive, HostBinding, Optional } from '@angular/core';
+import { EMPTY, fromEvent, merge, Subject } from 'rxjs';
+import { filter, switchMap, take, takeUntil, tap } from 'rxjs/operators';
+import { RouterLinkActiveService } from '../../services/router-link-active.service';
+import { MutationObserverService } from '../../services/mutation-observer.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/router-link-active.service";
+import * as i2 from "@angular/router";
+import * as i3 from "../../services/mutation-observer.service";
+export const EVO_TAB_ACTIVATE = 'evo-tab-activate';
+export class EvoNavigationTabDirective {
+    constructor(el, routerLinkActiveService, rla, mutation) {
+        this.el = el;
+        this.routerLinkActiveService = routerLinkActiveService;
+        this.rla = rla;
+        this.mutation = mutation;
+        this.tabClass = true;
+        this.destroy$ = new Subject();
+        this.initSubscriptions();
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    initSubscriptions() {
+        const mutationObserver = this.rla && this.mutation ? this.mutation.pipe(filter(() => this.rla.isActive)) : EMPTY;
+        merge(mutationObserver, this.routerLinkActiveService.pipe(filter((r) => r)), fromEvent(this.el.nativeElement, 'click').pipe(
+        // Delaying execution until after all other click callbacks
+        switchMap(() => fromEvent(this.el.nativeElement.parentElement, 'click').pipe(take(1)))))
+            .pipe(tap(() => {
+            this.el.nativeElement.dispatchEvent(new CustomEvent(EVO_TAB_ACTIVATE, { bubbles: true }));
+        }), takeUntil(this.destroy$))
+            .subscribe();
+    }
+}
+EvoNavigationTabDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoNavigationTabDirective, deps: [{ token: i0.ElementRef }, { token: i1.RouterLinkActiveService }, { token: i2.RouterLinkActive, optional: true }, { token: i3.MutationObserverService, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+EvoNavigationTabDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.17", type: EvoNavigationTabDirective, selector: "button[evoNavigationTab]:not([routerLink]), button[evoNavigationTab][routerLink][routerLinkActive]", host: { properties: { "class.evo-navigation-tab": "this.tabClass" } }, providers: [MutationObserverService, RouterLinkActiveService], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoNavigationTabDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'button[evoNavigationTab]:not([routerLink]), button[evoNavigationTab][routerLink][routerLinkActive]',
+                    providers: [MutationObserverService, RouterLinkActiveService],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.RouterLinkActiveService }, { type: i2.RouterLinkActive, decorators: [{
+                    type: Optional
+                }] }, { type: i3.MutationObserverService, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { tabClass: [{
+                type: HostBinding,
+                args: ['class.evo-navigation-tab']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/evo-navigation-tabs/evo-navigation-tabs.component.js

@@ -0,0 +1,112 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, HostListener, Input, Output, ViewEncapsulation, } from '@angular/core';
+import { Subject } from 'rxjs';
+import { switchMap, take, takeUntil, tap } from 'rxjs/operators';
+import { EVO_TAB_ACTIVATE } from './evo-navigation-tab.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./evo-navigation-tab.directive";
+import * as i3 from "@angular/router";
+export class EvoNavigationTabsComponent {
+    constructor(el) {
+        this.el = el;
+        this.tabs = [];
+        this.size = 'normal';
+        this.activeItemIndexChange = new EventEmitter();
+        this.disabled = false;
+        this.activeIndex = 0;
+        this.disabledSubject$ = new Subject();
+        this.nextRenderSubject$ = new Subject();
+        this.destroy$ = new Subject();
+        this.initSubscriptions();
+    }
+    set setActiveIndex(index) {
+        this.activeIndex = index;
+        this.markTabAsActive();
+    }
+    set setDisabled(disabled) {
+        this.disabled = disabled;
+        this.disabledSubject$.next(disabled);
+    }
+    ngAfterViewInit() {
+        this.markTabAsActive();
+    }
+    ngAfterViewChecked() {
+        this.nextRenderSubject$.next();
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    onActivate(event, element) {
+        const index = this.tabsList.findIndex((tab) => tab === element);
+        event.stopPropagation();
+        if (index === this.activeIndex) {
+            return;
+        }
+        this.activeItemIndexChange.emit(index);
+        this.activeIndex = index;
+        this.markTabAsActive();
+    }
+    get tabsList() {
+        return Array.from(this.el.nativeElement.querySelectorAll('[evoNavigationTab]'));
+    }
+    get activeElement() {
+        return this.tabsList[this.activeIndex] || undefined;
+    }
+    markTabAsActive() {
+        const { tabsList, activeElement } = this;
+        tabsList.forEach((nativeElement) => {
+            const active = nativeElement === activeElement;
+            nativeElement.classList.toggle('_active', active);
+            nativeElement.setAttribute('tabIndex', active ? '0' : '-1');
+        });
+    }
+    markTabAsDisabled() {
+        this.tabsList.forEach((nativeElement) => {
+            const allDisabledClassName = '_all_disabled';
+            if (this.disabled && !nativeElement.disabled) {
+                nativeElement.classList.add(allDisabledClassName);
+                nativeElement.setAttribute('disabled', '');
+            }
+            if (!this.disabled && nativeElement.classList.contains(allDisabledClassName)) {
+                nativeElement.classList.remove(allDisabledClassName);
+                nativeElement.removeAttribute('disabled');
+            }
+        });
+    }
+    initSubscriptions() {
+        this.disabledSubject$
+            .pipe(switchMap(() => this.nextRenderSubject$.pipe(take(1))), tap(() => {
+            this.markTabAsDisabled();
+        }), takeUntil(this.destroy$))
+            .subscribe();
+    }
+}
+EvoNavigationTabsComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoNavigationTabsComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+EvoNavigationTabsComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: EvoNavigationTabsComponent, selector: "evo-navigation-tabs", inputs: { tabs: "tabs", size: "size", setActiveIndex: ["activeIndex", "setActiveIndex"], setDisabled: ["disabled", "setDisabled"] }, outputs: { activeItemIndexChange: "activeItemIndexChange" }, host: { listeners: { "evo-tab-activate": "onActivate($event,$event.target)" } }, ngImport: i0, template: "<div class=\"evo-navigation-tabs\" [class]=\"{ 'evo-navigation-tabs_size_small': size === 'small' }\">\n    <ng-content select=\"[position=start]\"></ng-content>\n\n    <ng-container *ngFor=\"let tab of tabs; let i = index\">\n        <button\n            *ngIf=\"tab.link\"\n            evoNavigationTab\n            routerLinkActive=\"active\"\n            queryParamsHandling=\"merge\"\n            [routerLink]=\"tab.link\"\n            [routerLinkActiveOptions]=\"{exact: true}\"\n            [disabled]=\"tab.disabled || disabled\"\n        >\n            {{ tab.label }}\n        </button>\n        <button *ngIf=\"!tab.link\" evoNavigationTab [disabled]=\"tab.disabled || disabled\">{{ tab.label }}</button>\n    </ng-container>\n\n    <ng-content></ng-content>\n</div>\n", styles: ["@charset \"UTF-8\";:host{display:block}.evo-navigation-tabs{display:flex;box-shadow:inset 0 -1px #c6c6c6;overflow-x:auto;-webkit-overflow-scrolling:touch;scrollbar-width:none}.evo-navigation-tabs::-webkit-scrollbar{display:none}.evo-navigation-tab{display:flex;align-items:center;box-sizing:border-box;padding:12px 16px;border:none;background:none;color:#212121;white-space:nowrap;text-transform:uppercase;text-decoration:none;cursor:pointer;transition:box-shadow .3s,color .3s;font-family:var(--evo-font);font-style:normal;font-size:14px;line-height:24px;font-weight:600}.evo-navigation-tabs_size_small .evo-navigation-tab{padding:7px 8px;text-transform:none;font-family:var(--evo-font);font-style:normal;font-size:12px;line-height:18px;font-weight:400}.evo-navigation-tab:hover{color:#f05023}.evo-navigation-tab:focus-visible{outline:none}.evo-navigation-tab._active:not(:disabled){color:#f05023;box-shadow:inset 0 -2px #f05023;cursor:default}.evo-navigation-tabs_size_small .evo-navigation-tab._active:not(:disabled){box-shadow:inset 0 -1px #f05023}.evo-navigation-tab:disabled{color:#b0b0b0;pointer-events:none;cursor:default}\n"], directives: [{ type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.EvoNavigationTabDirective, selector: "button[evoNavigationTab]:not([routerLink]), button[evoNavigationTab][routerLink][routerLinkActive]" }, { type: i3.RouterLinkActive, selector: "[routerLinkActive]", inputs: ["routerLinkActiveOptions", "routerLinkActive"], exportAs: ["routerLinkActive"] }, { type: i3.RouterLink, selector: ":not(a):not(area)[routerLink]", inputs: ["routerLink", "queryParams", "fragment", "queryParamsHandling", "preserveFragment", "skipLocationChange", "replaceUrl", "state", "relativeTo"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoNavigationTabsComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'evo-navigation-tabs',
+                    templateUrl: './evo-navigation-tabs.component.html',
+                    styleUrls: ['./evo-navigation-tabs.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { tabs: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], setActiveIndex: [{
+                type: Input,
+                args: ['activeIndex']
+            }], setDisabled: [{
+                type: Input,
+                args: ['disabled']
+            }], activeItemIndexChange: [{
+                type: Output
+            }], onActivate: [{
+                type: HostListener,
+                args: [EVO_TAB_ACTIVATE, ['$event', '$event.target']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"evo-navigation-tabs.component.js","sourceRoot":"","sources":["../../../../../../projects/evo-ui-kit/src/lib/components/evo-navigation-tabs/evo-navigation-tabs.component.ts","../../../../../../projects/evo-ui-kit/src/lib/components/evo-navigation-tabs/evo-navigation-tabs.component.html"],"names":[],"mappings":"AAAA,OAAO,EAGH,uBAAuB,EACvB,SAAS,EAET,YAAY,EACZ,YAAY,EACZ,KAAK,EACL,MAAM,EACN,iBAAiB,GACpB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAC,OAAO,EAAC,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AACjE,OAAO,EAAC,gBAAgB,EAAC,MAAM,gCAAgC,CAAC;;;;;AAUhE,MAAM,OAAO,0BAA0B;IAsBnC,YAA6B,EAAc;QAAd,OAAE,GAAF,EAAE,CAAY;QArBlC,SAAI,GAAyD,EAAE,CAAC;QAChE,SAAI,GAA0B,QAAQ,CAAC;QAUtC,0BAAqB,GAAG,IAAI,YAAY,EAAU,CAAC;QAE7D,aAAQ,GAAG,KAAK,CAAC;QAET,gBAAW,GAAG,CAAC,CAAC;QAEP,qBAAgB,GAAG,IAAI,OAAO,EAAW,CAAC;QAC1C,uBAAkB,GAAG,IAAI,OAAO,EAAQ,CAAC;QACzC,aAAQ,GAAG,IAAI,OAAO,EAAQ,CAAC;QAG5C,IAAI,CAAC,iBAAiB,EAAE,CAAC;IAC7B,CAAC;IArBD,IAA0B,cAAc,CAAC,KAAa;QAClD,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,eAAe,EAAE,CAAC;IAC3B,CAAC;IACD,IAAuB,WAAW,CAAC,QAAiB;QAChD,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IAgBD,eAAe;QACX,IAAI,CAAC,eAAe,EAAE,CAAC;IAC3B,CAAC;IAED,kBAAkB;QACd,IAAI,CAAC,kBAAkB,CAAC,IAAI,EAAE,CAAC;IACnC,CAAC;IAED,WAAW;QACP,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC;QACrB,IAAI,CAAC,QAAQ,CAAC,QAAQ,EAAE,CAAC;IAC7B,CAAC;IAGD,UAAU,CAAC,KAAY,EAAE,OAA0B;QAC/C,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC;QAEhE,KAAK,CAAC,eAAe,EAAE,CAAC;QAExB,IAAI,KAAK,KAAK,IAAI,CAAC,WAAW,EAAE;YAC5B,OAAO;SACV;QAED,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACvC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;QACzB,IAAI,CAAC,eAAe,EAAE,CAAC;IAC3B,CAAC;IAED,IAAY,QAAQ;QAChB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,aAAa,CAAC,gBAAgB,CAAC,oBAAoB,CAAC,CAAC,CAAC;IACpF,CAAC;IAED,IAAY,aAAa;QACrB,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,SAAS,CAAC;IACxD,CAAC;IAEO,eAAe;QACnB,MAAM,EAAC,QAAQ,EAAE,aAAa,EAAC,GAAG,IAAI,CAAC;QAEvC,QAAQ,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,EAAE;YAC/B,MAAM,MAAM,GAAG,aAAa,KAAK,aAAa,CAAC;YAE/C,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,SAAS,EAAE,MAAM,CAAC,CAAC;YAClD,aAAa,CAAC,YAAY,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QAChE,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,iBAAiB;QACrB,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,aAAa,EAAE,EAAE;YACpC,MAAM,oBAAoB,GAAG,eAAe,CAAC;YAE7C,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE;gBAC1C,aAAa,CAAC,SAAS,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;gBAClD,aAAa,CAAC,YAAY,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;aAC9C;YAED,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,aAAa,CAAC,SAAS,CAAC,QAAQ,CAAC,oBAAoB,CAAC,EAAE;gBAC1E,aAAa,CAAC,SAAS,CAAC,MAAM,CAAC,oBAAoB,CAAC,CAAC;gBACrD,aAAa,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC;aAC7C;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAEO,iBAAiB;QACrB,IAAI,CAAC,gBAAgB;aAChB,IAAI,CACD,SAAS,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,EACtD,GAAG,CAAC,GAAG,EAAE;YACL,IAAI,CAAC,iBAAiB,EAAE,CAAC;QAC7B,CAAC,CAAC,EACF,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAC3B;aACA,SAAS,EAAE,CAAC;IACrB,CAAC;;wHAnGQ,0BAA0B;4GAA1B,0BAA0B,8UCxBvC,6wBAoBA;4FDIa,0BAA0B;kBAPtC,SAAS;mBAAC;oBACP,QAAQ,EAAE,qBAAqB;oBAC/B,WAAW,EAAE,sCAAsC;oBACnD,SAAS,EAAE,CAAC,sCAAsC,CAAC;oBACnD,eAAe,EAAE,uBAAuB,CAAC,MAAM;oBAC/C,aAAa,EAAE,iBAAiB,CAAC,IAAI;iBACxC;iGAEY,IAAI;sBAAZ,KAAK;gBACG,IAAI;sBAAZ,KAAK;gBACoB,cAAc;sBAAvC,KAAK;uBAAC,aAAa;gBAIG,WAAW;sBAAjC,KAAK;uBAAC,UAAU;gBAKP,qBAAqB;sBAA9B,MAAM;gBA4BP,UAAU;sBADT,YAAY;uBAAC,gBAAgB,EAAE,CAAC,QAAQ,EAAE,eAAe,CAAC","sourcesContent":["import {\n    AfterViewChecked,\n    AfterViewInit,\n    ChangeDetectionStrategy,\n    Component,\n    ElementRef,\n    EventEmitter,\n    HostListener,\n    Input, OnDestroy,\n    Output,\n    ViewEncapsulation,\n} from '@angular/core';\nimport {Subject} from 'rxjs';\nimport { switchMap, take, takeUntil, tap } from 'rxjs/operators';\nimport {EVO_TAB_ACTIVATE} from './evo-navigation-tab.directive';\nimport {EvoNavigationTabsSize} from './types/evo-navigation-tabs-size';\n\n@Component({\n    selector: 'evo-navigation-tabs',\n    templateUrl: './evo-navigation-tabs.component.html',\n    styleUrls: ['./evo-navigation-tabs.component.scss'],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n})\nexport class EvoNavigationTabsComponent implements AfterViewInit, AfterViewChecked, OnDestroy {\n    @Input() tabs: {label: string; link?: string; disabled?: boolean}[] = [];\n    @Input() size: EvoNavigationTabsSize = 'normal';\n    @Input('activeIndex') set setActiveIndex(index: number) {\n        this.activeIndex = index;\n        this.markTabAsActive();\n    }\n    @Input('disabled') set setDisabled(disabled: boolean) {\n        this.disabled = disabled;\n        this.disabledSubject$.next(disabled);\n    }\n\n    @Output() activeItemIndexChange = new EventEmitter<number>();\n\n    disabled = false;\n\n    private activeIndex = 0;\n\n    private readonly disabledSubject$ = new Subject<boolean>();\n    private readonly nextRenderSubject$ = new Subject<void>();\n    private readonly destroy$ = new Subject<void>();\n\n    constructor(private readonly el: ElementRef) {\n        this.initSubscriptions();\n    }\n\n    ngAfterViewInit(): void {\n        this.markTabAsActive();\n    }\n\n    ngAfterViewChecked(): void {\n        this.nextRenderSubject$.next();\n    }\n\n    ngOnDestroy(): void {\n        this.destroy$.next();\n        this.destroy$.complete();\n    }\n\n    @HostListener(EVO_TAB_ACTIVATE, ['$event', '$event.target'])\n    onActivate(event: Event, element: HTMLButtonElement): void {\n        const index = this.tabsList.findIndex((tab) => tab === element);\n\n        event.stopPropagation();\n\n        if (index === this.activeIndex) {\n            return;\n        }\n\n        this.activeItemIndexChange.emit(index);\n        this.activeIndex = index;\n        this.markTabAsActive();\n    }\n\n    private get tabsList(): readonly HTMLButtonElement[] {\n        return Array.from(this.el.nativeElement.querySelectorAll('[evoNavigationTab]'));\n    }\n\n    private get activeElement(): HTMLButtonElement | undefined {\n        return this.tabsList[this.activeIndex] || undefined;\n    }\n\n    private markTabAsActive(): void {\n        const {tabsList, activeElement} = this;\n\n        tabsList.forEach((nativeElement) => {\n            const active = nativeElement === activeElement;\n\n            nativeElement.classList.toggle('_active', active);\n            nativeElement.setAttribute('tabIndex', active ? '0' : '-1');\n        });\n    }\n\n    private markTabAsDisabled(): void {\n        this.tabsList.forEach((nativeElement) => {\n            const allDisabledClassName = '_all_disabled';\n\n            if (this.disabled && !nativeElement.disabled) {\n                nativeElement.classList.add(allDisabledClassName);\n                nativeElement.setAttribute('disabled', '');\n            }\n\n            if (!this.disabled && nativeElement.classList.contains(allDisabledClassName)) {\n                nativeElement.classList.remove(allDisabledClassName);\n                nativeElement.removeAttribute('disabled');\n            }\n        });\n    }\n\n    private initSubscriptions(): void {\n        this.disabledSubject$\n            .pipe(\n                switchMap(() => this.nextRenderSubject$.pipe(take(1))),\n                tap(() => {\n                    this.markTabAsDisabled();\n                }),\n                takeUntil(this.destroy$)\n            )\n            .subscribe();\n    }\n}\n","<div class=\"evo-navigation-tabs\" [class]=\"{ 'evo-navigation-tabs_size_small': size === 'small' }\">\n    <ng-content select=\"[position=start]\"></ng-content>\n\n    <ng-container *ngFor=\"let tab of tabs; let i = index\">\n        <button\n            *ngIf=\"tab.link\"\n            evoNavigationTab\n            routerLinkActive=\"active\"\n            queryParamsHandling=\"merge\"\n            [routerLink]=\"tab.link\"\n            [routerLinkActiveOptions]=\"{exact: true}\"\n            [disabled]=\"tab.disabled || disabled\"\n        >\n            {{ tab.label }}\n        </button>\n        <button *ngIf=\"!tab.link\" evoNavigationTab [disabled]=\"tab.disabled || disabled\">{{ tab.label }}</button>\n    </ng-container>\n\n    <ng-content></ng-content>\n</div>\n"]}

package/esm2015/lib/components/evo-navigation-tabs/evo-navigation-tabs.module.js

@@ -0,0 +1,20 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { RouterModule } from '@angular/router';
+import { EvoNavigationTabsComponent } from './evo-navigation-tabs.component';
+import { EvoNavigationTabDirective } from './evo-navigation-tab.directive';
+import * as i0 from "@angular/core";
+export class EvoNavigationTabsModule {
+}
+EvoNavigationTabsModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoNavigationTabsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+EvoNavigationTabsModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoNavigationTabsModule, declarations: [EvoNavigationTabsComponent, EvoNavigationTabDirective], imports: [CommonModule, RouterModule], exports: [EvoNavigationTabsComponent, EvoNavigationTabDirective] });
+EvoNavigationTabsModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoNavigationTabsModule, imports: [[CommonModule, RouterModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: EvoNavigationTabsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [EvoNavigationTabsComponent, EvoNavigationTabDirective],
+                    imports: [CommonModule, RouterModule],
+                    exports: [EvoNavigationTabsComponent, EvoNavigationTabDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZvLW5hdmlnYXRpb24tdGFicy5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ldm8tdWkta2l0L3NyYy9saWIvY29tcG9uZW50cy9ldm8tbmF2aWdhdGlvbi10YWJzL2V2by1uYXZpZ2F0aW9uLXRhYnMubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxRQUFRLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFDdkMsT0FBTyxFQUFDLFlBQVksRUFBQyxNQUFNLGlCQUFpQixDQUFDO0FBQzdDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsMEJBQTBCLEVBQUMsTUFBTSxpQ0FBaUMsQ0FBQztBQUMzRSxPQUFPLEVBQUMseUJBQXlCLEVBQUMsTUFBTSxnQ0FBZ0MsQ0FBQzs7QUFPekUsTUFBTSxPQUFPLHVCQUF1Qjs7cUhBQXZCLHVCQUF1QjtzSEFBdkIsdUJBQXVCLGlCQUpqQiwwQkFBMEIsRUFBRSx5QkFBeUIsYUFDMUQsWUFBWSxFQUFFLFlBQVksYUFDMUIsMEJBQTBCLEVBQUUseUJBQXlCO3NIQUV0RCx1QkFBdUIsWUFIdkIsQ0FBQyxZQUFZLEVBQUUsWUFBWSxDQUFDOzRGQUc1Qix1QkFBdUI7a0JBTG5DLFFBQVE7bUJBQUM7b0JBQ04sWUFBWSxFQUFFLENBQUMsMEJBQTBCLEVBQUUseUJBQXlCLENBQUM7b0JBQ3JFLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxZQUFZLENBQUM7b0JBQ3JDLE9BQU8sRUFBRSxDQUFDLDBCQUEwQixFQUFFLHlCQUF5QixDQUFDO2lCQUNuRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtDb21tb25Nb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQge1JvdXRlck1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvcm91dGVyJztcbmltcG9ydCB7RXZvTmF2aWdhdGlvblRhYnNDb21wb25lbnR9IGZyb20gJy4vZXZvLW5hdmlnYXRpb24tdGFicy5jb21wb25lbnQnO1xuaW1wb3J0IHtFdm9OYXZpZ2F0aW9uVGFiRGlyZWN0aXZlfSBmcm9tICcuL2V2by1uYXZpZ2F0aW9uLXRhYi5kaXJlY3RpdmUnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGRlY2xhcmF0aW9uczogW0V2b05hdmlnYXRpb25UYWJzQ29tcG9uZW50LCBFdm9OYXZpZ2F0aW9uVGFiRGlyZWN0aXZlXSxcbiAgICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBSb3V0ZXJNb2R1bGVdLFxuICAgIGV4cG9ydHM6IFtFdm9OYXZpZ2F0aW9uVGFic0NvbXBvbmVudCwgRXZvTmF2aWdhdGlvblRhYkRpcmVjdGl2ZV0sXG59KVxuZXhwb3J0IGNsYXNzIEV2b05hdmlnYXRpb25UYWJzTW9kdWxlIHt9XG4iXX0=

package/esm2015/lib/components/evo-navigation-tabs/index.js

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9ldm8tdWkta2l0L3NyYy9saWIvY29tcG9uZW50cy9ldm8tbmF2aWdhdGlvbi10YWJzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2015/lib/components/evo-navigation-tabs/public-api.js

@@ -0,0 +1,5 @@
+export * from './evo-navigation-tabs.module';
+export * from './evo-navigation-tabs.component';
+export * from './evo-navigation-tab.directive';
+export * from "./types/evo-navigation-tabs-size";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2V2by11aS1raXQvc3JjL2xpYi9jb21wb25lbnRzL2V2by1uYXZpZ2F0aW9uLXRhYnMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLGtDQUFrQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ldm8tbmF2aWdhdGlvbi10YWJzLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2V2by1uYXZpZ2F0aW9uLXRhYnMuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vZXZvLW5hdmlnYXRpb24tdGFiLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tIFwiLi90eXBlcy9ldm8tbmF2aWdhdGlvbi10YWJzLXNpemVcIjtcbiJdfQ==

package/esm2015/lib/components/evo-navigation-tabs/types/evo-navigation-tabs-size.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZvLW5hdmlnYXRpb24tdGFicy1zaXplLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvZXZvLXVpLWtpdC9zcmMvbGliL2NvbXBvbmVudHMvZXZvLW5hdmlnYXRpb24tdGFicy90eXBlcy9ldm8tbmF2aWdhdGlvbi10YWJzLXNpemUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIEV2b05hdmlnYXRpb25UYWJzU2l6ZSA9ICdzbWFsbCcgfCAnbm9ybWFsJztcbiJdfQ==

package/esm2015/lib/services/mutation-observer.service.js

@@ -0,0 +1,59 @@
+import { ElementRef, inject, Injectable } from '@angular/core';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Безопасная обёртка над `MutationObserver`, которая гарантирует,
+ * что код не упадёт в средах, где `MutationObserver` недоступен
+ * (например, серверный рендеринг или тесты без DOM).
+ *
+ * Если `MutationObserver` существует — используется он.
+ * Если нет — используется заглушка с пустыми методами.
+ */
+export const SafeObserver = typeof MutationObserver !== 'undefined'
+    ? MutationObserver
+    : class {
+        observe() { }
+        disconnect() { }
+        takeRecords() {
+            return [];
+        }
+    };
+/**
+ * Сервис `MutationObserverService` предоставляет поток `Observable<MutationRecord[]>`,
+ * который эмитит записи изменений DOM для текущего элемента (`ElementRef`).
+ *
+ * Наблюдает за изменениями потомков, текстового содержимого и вложенных структур (`subtree: true`).
+ *
+ * Используется `SafeObserver`, чтобы гарантировать совместимость с SSR и тестовой средой.
+ *
+ * ⚠️ Важно: требует, чтобы `ElementRef` был доступен через DI-контекст (т.е. работает в компонентах/директивах).
+ *
+ * @example
+ * this.mutationObserverService.subscribe(records => {
+ *   console.log('Mutation detected!', records);
+ * });
+ */
+export class MutationObserverService extends Observable {
+    constructor() {
+        const nativeElement = inject(ElementRef).nativeElement;
+        super((subscriber) => {
+            const observer = new SafeObserver((records) => {
+                subscriber.next(records);
+            });
+            observer.observe(nativeElement, {
+                childList: true,
+                characterData: true,
+                subtree: true,
+            });
+            return () => {
+                observer.disconnect();
+            };
+        });
+    }
+}
+MutationObserverService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MutationObserverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+MutationObserverService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MutationObserverService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: MutationObserverService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/services/router-link-active.service.js

@@ -0,0 +1,41 @@
+import { Inject, Injectable, NgZone, Optional } from '@angular/core';
+import { RouterLinkActive } from '@angular/router';
+import { EMPTY, merge, Observable, timer } from 'rxjs';
+import { distinctUntilChanged, map } from 'rxjs/operators';
+import { ANIMATION_FRAME } from '../utils/tokens/animation-frame';
+import { evoZoneOptimized } from '../utils/observables/zone-free';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "rxjs";
+/**
+ * Сервис создает поток, отслеживающий состояние активности
+ * `RouterLinkActive` в реальном времени с использованием `requestAnimationFrame`.
+ *
+ * Наследуется от `Observable<boolean>` и эмитит `true` или `false`, когда состояние `isActive`
+ * меняется. Если `RouterLinkActive` не передан — поток будет пустым (`EMPTY`).
+ */
+export class RouterLinkActiveService extends Observable {
+    constructor(routerLinkActive, ngZone, animationFrame$) {
+        const stream$ = routerLinkActive
+            ? merge(timer(0), animationFrame$).pipe(map(() => routerLinkActive.isActive), distinctUntilChanged(), evoZoneOptimized(ngZone))
+            : EMPTY;
+        super((subscriber) => stream$.subscribe(subscriber));
+    }
+}
+RouterLinkActiveService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RouterLinkActiveService, deps: [{ token: RouterLinkActive, optional: true }, { token: NgZone }, { token: ANIMATION_FRAME }], target: i0.ɵɵFactoryTarget.Injectable });
+RouterLinkActiveService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RouterLinkActiveService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: RouterLinkActiveService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.RouterLinkActive, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [RouterLinkActive]
+                }] }, { type: i0.NgZone, decorators: [{
+                    type: Inject,
+                    args: [NgZone]
+                }] }, { type: i2.Observable, decorators: [{
+                    type: Inject,
+                    args: [ANIMATION_FRAME]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utils/observables/zone-free.js

@@ -0,0 +1,64 @@
+import { Observable, pipe } from 'rxjs';
+/**
+ * Кратко:
+ * 🔥 evoZonefull — тащит всё в Angular-зону.
+ * 🧊 evoZonefree — игнорирует Angular-зону, экономит CD.
+ * ⚖️ evoZoneOptimized — как утро с кофе: просыпаешься вовремя и не дергаешь лишний раз change detection.
+ */
+/**
+ * Оператор `evoZonefull` обеспечивает полное выполнение потока внутри зоны Angular.
+ *
+ * Все `next`, `error` и `complete` вызовы оборачиваются в `NgZone.run`, чтобы гарантировать
+ * корректный запуск change detection.
+ *
+ * Используй, если поток формируется вне зоны или ты не уверен, что Angular узнает об изменениях.
+ *
+ * @param zone Сервис `NgZone` из Angular DI.
+ * @returns Оператор, оборачивающий поток в `NgZone.run()`.
+ *
+ * @example
+ * source$.pipe(evoZonefull(this.ngZone)).subscribe(...);
+ */
+export function evoZonefull(zone) {
+    return (source) => new Observable((subscriber) => source.subscribe({
+        next: (value) => zone.run(() => subscriber.next(value)),
+        error: (error) => zone.run(() => subscriber.error(error)),
+        complete: () => zone.run(() => subscriber.complete()),
+    }));
+}
+/**
+ * Оператор `evoZonefree` исполняет весь поток вне зоны Angular.
+ *
+ * Это помогает избежать лишних срабатываний change detection и повысить производительность,
+ * особенно для часто испускаемых потоков (например, `scroll`, `animationFrame`, таймеры).
+ *
+ * Используй, если тебе не нужно обновлять Angular view внутри этого потока.
+ *
+ * @param zone Сервис `NgZone` из Angular DI.
+ * @returns Оператор, исполняющий подписку вне Angular-зоны.
+ *
+ * @example
+ * source$.pipe(evoZonefree(this.ngZone)).subscribe(...);
+ */
+export function evoZonefree(zone) {
+    return (source) => new Observable((subscriber) => zone.runOutsideAngular(() => source.subscribe(subscriber)));
+}
+/**
+ * Оператор `evoZoneOptimized` — комбо из `evoZonefree` и `evoZonefull`.
+ *
+ * Сначала поток исполняется вне Angular-зоны (`runOutsideAngular`), чтобы избежать лишнего
+ * change detection. Но события `next`, `error` и `complete` всё равно возвращаются в Angular-зону.
+ *
+ * Это идеальный баланс, если тебе нужен быстрый поток без лишнего CD, но ты всё равно хочешь,
+ * чтобы Angular знал о результатах.
+ *
+ * @param zone Сервис `NgZone` из Angular DI.
+ * @returns Оператор, оптимизированный по производительности.
+ *
+ * @example
+ * source$.pipe(evoZoneOptimized(this.ngZone)).subscribe(...);
+ */
+export function evoZoneOptimized(zone) {
+    return pipe(evoZonefree(zone), evoZonefull(zone));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/utils/tokens/animation-frame.js

@@ -0,0 +1,27 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { share } from 'rxjs/operators';
+/**
+ * Токен `ANIMATION_FRAME` предоставляет поток значений времени из `requestAnimationFrame`,
+ * испускаемый каждый кадр анимации.
+ *
+ * Может быть полезен для задач, которые требуют частого обновления, например, отслеживания
+ * активности или плавной анимации в UI.
+ */
+export const ANIMATION_FRAME = new InjectionToken('[ANIMATION_FRAME]', {
+    factory: () => {
+        const animationFrame$ = new Observable((subscriber) => {
+            let id = NaN;
+            const callback = (timestamp) => {
+                subscriber.next(timestamp);
+                id = requestAnimationFrame(callback);
+            };
+            id = requestAnimationFrame(callback);
+            return () => {
+                cancelAnimationFrame(id);
+            };
+        });
+        return animationFrame$.pipe(share());
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/public_api.js

@@ -61,6 +61,7 @@ export * from './lib/components/evo-dropdown/index';
 export * from './lib/components/evo-navbar/index';
 export * from './lib/components/evo-navigation-button/index';
 export * from './lib/components/evo-tooltip/index';
+export * from './lib/components/evo-navigation-tabs/index';
 export * from './lib/pipes/index';
 // Services
 export * from './lib/services/index';
@@ -72,4 +73,4 @@ export * from './lib/common/constants/view-breakpoint-streams';
 export * from './lib/common/types/index';
 export * from './lib/common/evo-base-control';
 export * from './lib/common/Serializable';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2V2by11aS1raXQvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHlCQUF5QixDQUFDO0FBRXhDLGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyxrRUFBa0UsQ0FBQztBQUNqRixjQUFjLGdFQUFnRSxDQUFDO0FBQy9FLGNBQWMsb0VBQW9FLENBQUM7QUFDbkYsY0FBYywrQkFBK0IsQ0FBQztBQUU5QyxhQUFhO0FBQ2IsY0FBYywrQkFBK0IsQ0FBQztBQUU5QyxhQUFhO0FBQ2IsY0FBYywrQkFBK0IsQ0FBQztBQUU5QyxhQUFhO0FBQ2IsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxhQUFhO0FBQ2IsY0FBYyx3QkFBd0IsQ0FBQztBQUV2QyxZQUFZO0FBQ1osY0FBYyx1QkFBdUIsQ0FBQztBQUV0QyxhQUFhO0FBQ2IsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsMENBQTBDLENBQUM7QUFDekQsY0FBYywwQ0FBMEMsQ0FBQztBQUN6RCxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLHdDQUF3QyxDQUFDO0FBQ3ZELGNBQWMsd0NBQXdDLENBQUE7QUFDdEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLGtEQUFrRCxDQUFDO0FBQ2pFLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsc0NBQXNDLENBQUM7QUFDckQsY0FBYyx1Q0FBdUMsQ0FBQztBQUN0RCxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLHdDQUF3QyxDQUFDO0FBQ3ZELGNBQWMsdUNBQXVDLENBQUM7QUFDdEQsY0FBYywwQ0FBMEMsQ0FBQztBQUN6RCxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsb0NBQW9DLENBQUM7QUFDbkQsY0FBYyxvQ0FBb0MsQ0FBQztBQUNuRCxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMscUNBQXFDLENBQUM7QUFDcEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLG1DQUFtQyxDQUFDO0FBQ2xELGNBQWMsOENBQThDLENBQUM7QUFDN0QsY0FBYyxvQ0FBb0MsQ0FBQztBQUVuRCxjQUFjLG1CQUFtQixDQUFDO0FBRWxDLFdBQVc7QUFDWCxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsbUNBQW1DLENBQUM7QUFFbEQsY0FBYyxrRUFBa0UsQ0FBQztBQUNqRixjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsd0NBQXdDLENBQUM7QUFDdkQsY0FBYyxnREFBZ0QsQ0FBQztBQUMvRCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywyQkFBMkIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgZXZvLXVpLWtpdFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2V2by11aS1raXQubW9kdWxlJztcblxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tbW9uL2Zvcm0taGVscGVyL2Zvcm0taGVscGVyJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbW1vbi9ldm8tY29udHJvbC1zdGF0ZS1tYW5hZ2VyL2V2by1jb250cm9sLXN0YXRlLW1hbmFnZXInO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tbW9uL2V2by1jb250cm9sLXN0YXRlLW1hbmFnZXIvZXZvLWNvbnRyb2wtc3RhdGVzLmVudW0nO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tbW9uL2V2by1jb250cm9sLXN0YXRlLW1hbmFnZXIvZXZvLWNvbnRyb2wtc3RhdGUuaW50ZXJmYWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbW1vbi9ldm8tYmFzZS1jb250cm9sJztcblxuLy8gQW5pbWF0aW9uc1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tbW9uL2FuaW1hdGlvbnMvaW5kZXgnO1xuXG4vLyBDb2xsZWN0aW9uXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21tb24vY29sbGVjdGlvbi9pbmRleCc7XG5cbi8vIERlY29yYXRvcnNcbmV4cG9ydCAqIGZyb20gJy4vbGliL2RlY29yYXRvcnMvaW5kZXgnO1xuXG4vLyBEaXJlY3RpdmVzXG5leHBvcnQgKiBmcm9tICcuL2xpYi9kaXJlY3RpdmVzL2luZGV4JztcblxuLy8gT3BlcmF0b3JzXG5leHBvcnQgKiBmcm9tICcuL2xpYi9vcGVyYXRvcnMvaW5kZXgnO1xuXG4vLyBDb21wb25lbnRzXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by1hY2NvcmRpb24vaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tYWxlcnQvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tYXV0b2NvbXBsZXRlL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLWJhZGdlL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLWJhbm5lci9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by1idXR0b24vaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tY2hlY2tib3gvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tY2hpcC9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by1jb250cm9sLWVycm9yL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLWNvbnRyb2wtbGFiZWwvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tY291bnRlci9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by1kYXRlcGlja2VyL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLWljb24vaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8taWNvbi1idXR0b24vaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8taWNvbi1udW1iZXIvaW5kZXgnXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by1pbnB1dC9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by1pbnB1dC1jb250ZW50ZWRpdGFibGUvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tbG9hZGVyL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLW1vZGFsL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLW5vdGUvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tcGFnaW5hdG9yL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLXBsdXMtbWludXMvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tcG9wb3Zlci9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by1wb3J0YWwvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tcmFkaW8vaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tcmFkaW8tZ3JvdXAvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tcmFkaW9zaGFwZS9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by1zZWdtZW50ZWQtYmFyL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLXNlbGVjdC9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by1zaWRlYmFyL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLXN0ZXBwZXIvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tc3VibWVudS9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by1zd2l0Y2hlci9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by10YWJsZS9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by10YWJzL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLXRleHRhcmVhL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLXRvYXN0L2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLXRvZ2dsZS9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by11cGxvYWQvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tZHJvcGRvd24vaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9ldm8tbmF2YmFyL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLW5hdmlnYXRpb24tYnV0dG9uL2luZGV4JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvZXZvLXRvb2x0aXAvaW5kZXgnO1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9waXBlcy9pbmRleCc7XG5cbi8vIFNlcnZpY2VzXG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2V2by1wb3J0YWwvaW5kZXgnO1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21tb24vZXZvLWNvbnRyb2wtc3RhdGUtbWFuYWdlci9ldm8tY29udHJvbC1zdGF0ZS1tYW5hZ2VyJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbW1vbi9mb3JtLWhlbHBlci9mb3JtLWhlbHBlcic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21tb24vY29uc3RhbnRzL2Nzcy1icmVha3BvaW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21tb24vY29uc3RhbnRzL3ZpZXctYnJlYWtwb2ludC1zdHJlYW1zJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbW1vbi90eXBlcy9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21tb24vZXZvLWJhc2UtY29udHJvbCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21tb24vU2VyaWFsaXphYmxlJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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