@taiga-ui/cdk 2.55.0 → 3.0.0-rc.0

package/fesm2015/taiga-ui-cdk-services.js

@@ -1,13 +1,14 @@
-import { __decorate, __param } from 'tslib';
-import { Injectable, ComponentFactoryResolver, Inject, Injector, INJECTOR, Renderer2, ɵɵdefineInjectable, ɵɵinject, ElementRef, ChangeDetectorRef, NgZone, Self } from '@angular/core';
-import { ReplaySubject, Observable, merge, defer, fromEvent, of, timer } from 'rxjs';
+import * as i0 from '@angular/core';
+import { Injectable, ComponentFactoryResolver, INJECTOR, Inject, ElementRef, ChangeDetectorRef, NgZone, Self } from '@angular/core';
+import * as i1 from 'rxjs';
+import { ReplaySubject, Observable, defer, merge, fromEvent, of, timer } from 'rxjs';
 import { DOCUMENT } from '@angular/common';
 import { TUI_DEFAULT_RENDERER, TUI_SWIPE_OPTIONS, TUI_ZOOM_OPTIONS } from '@taiga-ui/cdk/tokens';
 import { focusVisibleObservable, watch, typedFromEvent, tuiZoneOptimized, tuiZonefree, preventDefault } from '@taiga-ui/cdk/observables';
-import { takeUntil, switchMap, filter, take, mapTo, startWith, distinctUntilChanged, delay, throttleTime, map, switchMapTo, pairwise, repeat, catchError, debounceTime, tap, shareReplay, scan } from 'rxjs/operators';
-import { getActualTarget, getElementObscurers } from '@taiga-ui/cdk/utils/dom';
+import { takeUntil, delay, throttleTime, map, startWith, distinctUntilChanged, switchMapTo, filter, pairwise, repeat, catchError, mapTo, debounceTime, switchMap, tap, shareReplay, scan } from 'rxjs/operators';
 import { WINDOW, ANIMATION_FRAME, PERFORMANCE } from '@ng-web-apis/common';
 import { POLLING_TIME, EMPTY_ARRAY } from '@taiga-ui/cdk/constants';
+import { getElementObscurers } from '@taiga-ui/cdk/utils/dom';
 import { ResizeObserverService, RESIZE_OBSERVER_SUPPORT, RESIZE_OPTION_BOX } from '@ng-web-apis/resize-observer';
 import { tuiAssert } from '@taiga-ui/cdk/classes';
 import { clamp } from '@taiga-ui/cdk/utils/math';
@@ -17,7 +18,7 @@ import { distanceBetweenTouches } from '@taiga-ui/cdk/utils';
 /**
  * Observable abstraction over ngOnDestroy to use with takeUntil
  */
-let TuiDestroyService = class TuiDestroyService extends ReplaySubject {
+class TuiDestroyService extends ReplaySubject {
     constructor() {
         super(1);
     }
@@ -25,16 +26,18 @@ let TuiDestroyService = class TuiDestroyService extends ReplaySubject {
         this.next();
         this.complete();
     }
-};
-TuiDestroyService = __decorate([
-    Injectable()
-], TuiDestroyService);
+}
+TuiDestroyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDestroyService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TuiDestroyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDestroyService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDestroyService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
 
 /**
  * Service to use styles with directives
  * @dynamic
  */
-let TuiDirectiveStylesService = class TuiDirectiveStylesService {
+class TuiDirectiveStylesService {
     constructor(resolver, injector, documentRef, renderer) {
         this.resolver = resolver;
         this.injector = injector;
@@ -54,28 +57,32 @@ let TuiDirectiveStylesService = class TuiDirectiveStylesService {
         if (this.documentRef.head.querySelector(`style[${attribute}]`)) {
             return;
         }
-        const style = this.renderer.createElement('style');
-        this.renderer.setProperty(style, 'textContent', styles);
-        this.renderer.setAttribute(style, attribute, '');
+        const style = this.renderer.createElement(`style`);
+        this.renderer.setProperty(style, `textContent`, styles);
+        this.renderer.setAttribute(style, attribute, ``);
         this.documentRef.head.appendChild(style);
     }
-};
-TuiDirectiveStylesService.ctorParameters = () => [
-    { type: ComponentFactoryResolver, decorators: [{ type: Inject, args: [ComponentFactoryResolver,] }] },
-    { type: Injector, decorators: [{ type: Inject, args: [INJECTOR,] }] },
-    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-    { type: Renderer2, decorators: [{ type: Inject, args: [TUI_DEFAULT_RENDERER,] }] }
-];
-TuiDirectiveStylesService.ɵprov = ɵɵdefineInjectable({ factory: function TuiDirectiveStylesService_Factory() { return new TuiDirectiveStylesService(ɵɵinject(ComponentFactoryResolver), ɵɵinject(INJECTOR), ɵɵinject(DOCUMENT), ɵɵinject(TUI_DEFAULT_RENDERER)); }, token: TuiDirectiveStylesService, providedIn: "root" });
-TuiDirectiveStylesService = __decorate([
-    Injectable({
-        providedIn: 'root',
-    }),
-    __param(0, Inject(ComponentFactoryResolver)),
-    __param(1, Inject(INJECTOR)),
-    __param(2, Inject(DOCUMENT)),
-    __param(3, Inject(TUI_DEFAULT_RENDERER))
-], TuiDirectiveStylesService);
+}
+TuiDirectiveStylesService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDirectiveStylesService, deps: [{ token: ComponentFactoryResolver }, { token: INJECTOR }, { token: DOCUMENT }, { token: TUI_DEFAULT_RENDERER }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiDirectiveStylesService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDirectiveStylesService, providedIn: `root` });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiDirectiveStylesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: `root`,
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver, decorators: [{
+                    type: Inject,
+                    args: [ComponentFactoryResolver]
+                }] }, { type: i0.Injector, decorators: [{
+                    type: Inject,
+                    args: [INJECTOR]
+                }] }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.Renderer2, decorators: [{
+                    type: Inject,
+                    args: [TUI_DEFAULT_RENDERER]
+                }] }]; } });
 
 /**
  * Service to imitate :focus-visible
@@ -83,72 +90,52 @@ TuiDirectiveStylesService = __decorate([
  * in browsers that do not support it
  * @dynamic
  */
-let TuiFocusVisibleService = class TuiFocusVisibleService extends Observable {
+class TuiFocusVisibleService extends Observable {
     constructor({ nativeElement }, changeDetectorRef, destroy$) {
         super(subscriber => this.focusVisible$.subscribe(subscriber));
         this.focusVisible$ = focusVisibleObservable(nativeElement).pipe(watch(changeDetectorRef), takeUntil(destroy$));
     }
-};
-TuiFocusVisibleService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: ChangeDetectorRef, decorators: [{ type: Inject, args: [ChangeDetectorRef,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [TuiDestroyService,] }] }
-];
-TuiFocusVisibleService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(ChangeDetectorRef)),
-    __param(2, Inject(TuiDestroyService))
-], TuiFocusVisibleService);
+}
+TuiFocusVisibleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiFocusVisibleService, deps: [{ token: ElementRef }, { token: ChangeDetectorRef }, { token: TuiDestroyService }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiFocusVisibleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiFocusVisibleService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiFocusVisibleService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i0.ChangeDetectorRef, decorators: [{
+                    type: Inject,
+                    args: [ChangeDetectorRef]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [TuiDestroyService]
+                }] }]; } });
 
-/** @deprecated TODO remove in v3.0 */
-// @dynamic
-let TuiHoveredService = class TuiHoveredService {
-    constructor(documentRef, ngZone) {
-        this.ngZone = ngZone;
-        this.documentEvents$ = merge(typedFromEvent(documentRef, 'mousemove'), typedFromEvent(documentRef, 'touchstart', { capture: true }));
-    }
-    createHovered$(target, options = { passive: true }) {
-        return merge(typedFromEvent(target, 'mouseenter', options), typedFromEvent(target, 'touchstart', options)).pipe(switchMap(() => merge(typedFromEvent(target, 'mouseleave', options), this.documentEvents$.pipe(filter(event => !target.contains(getActualTarget(event))), tuiZoneOptimized(this.ngZone), take(1))).pipe(mapTo(false), startWith(true))), distinctUntilChanged());
-    }
-};
-TuiHoveredService.ctorParameters = () => [
-    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] },
-    { type: NgZone, decorators: [{ type: Inject, args: [NgZone,] }] }
-];
-TuiHoveredService.ɵprov = ɵɵdefineInjectable({ factory: function TuiHoveredService_Factory() { return new TuiHoveredService(ɵɵinject(DOCUMENT), ɵɵinject(NgZone)); }, token: TuiHoveredService, providedIn: "root" });
-TuiHoveredService = __decorate([
-    Injectable({
-        providedIn: 'root',
-    }),
-    __param(0, Inject(DOCUMENT)),
-    __param(1, Inject(NgZone))
-], TuiHoveredService);
-
-var TuiIdService_1;
-const TUI = 'tui_';
+const TUI = `tui_`;
 /**
  * Generates unique ids
  */
-let TuiIdService = TuiIdService_1 = class TuiIdService {
+class TuiIdService {
     generate() {
-        return `${TUI}${TuiIdService_1.autoId++}${Date.now()}`;
+        return `${TUI}${TuiIdService.autoId++}${Date.now()}`;
     }
-};
+}
 TuiIdService.autoId = 0;
-TuiIdService.ɵprov = ɵɵdefineInjectable({ factory: function TuiIdService_Factory() { return new TuiIdService(); }, token: TuiIdService, providedIn: "root" });
-TuiIdService = TuiIdService_1 = __decorate([
-    Injectable({
-        providedIn: 'root',
-    })
-], TuiIdService);
+TuiIdService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiIdService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TuiIdService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiIdService, providedIn: `root` });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiIdService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: `root`,
+                }]
+        }] });
 
 /**
  * Service that subscribes to scroll events of all parent elements
  */
 // Ambient type cannot be used without dynamic https://github.com/angular/angular/issues/23395
 // @dynamic
-let TuiParentsScrollService = class TuiParentsScrollService extends Observable {
+class TuiParentsScrollService extends Observable {
     constructor(elementRef, windowRef) {
         super(subscriber => this.callback$.subscribe(subscriber));
         this.callback$ = defer(() => {
@@ -158,19 +145,21 @@ let TuiParentsScrollService = class TuiParentsScrollService extends Observable {
                 nativeElement = nativeElement.parentElement;
                 eventTargets.push(nativeElement);
             }
-            return merge(...eventTargets.map(element => typedFromEvent(element, 'scroll')));
+            return merge(...eventTargets.map(element => typedFromEvent(element, `scroll`)));
         });
     }
-};
-TuiParentsScrollService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: Window, decorators: [{ type: Inject, args: [WINDOW,] }] }
-];
-TuiParentsScrollService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(WINDOW))
-], TuiParentsScrollService);
+}
+TuiParentsScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiParentsScrollService, deps: [{ token: ElementRef }, { token: WINDOW }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiParentsScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiParentsScrollService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiParentsScrollService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: Window, decorators: [{
+                    type: Inject,
+                    args: [WINDOW]
+                }] }]; } });
 
 // @bad TODO: Consider Intersection Observer with fallback to current implementation
 /**
@@ -180,99 +169,114 @@ TuiParentsScrollService = __decorate([
  */
 // Ambient type cannot be used without dynamic https://github.com/angular/angular/issues/23395
 // @dynamic
-let TuiObscuredService = class TuiObscuredService extends Observable {
+class TuiObscuredService extends Observable {
     constructor(parentsScroll$, { nativeElement }, ngZone, windowRef, destroy$, animationFrame$) {
         super(subscriber => this.obscured$.subscribe(subscriber));
         this.obscured$ = merge(
         // delay is added so it will not interfere with other listeners
-        merge(parentsScroll$, fromEvent(windowRef, 'resize')).pipe(delay(0)), animationFrame$.pipe(throttleTime(POLLING_TIME))).pipe(map(() => getElementObscurers(nativeElement)), startWith(null), distinctUntilChanged(), tuiZoneOptimized(ngZone), takeUntil(destroy$));
+        merge(parentsScroll$, fromEvent(windowRef, `resize`)).pipe(delay(0)), animationFrame$.pipe(throttleTime(POLLING_TIME))).pipe(map(() => getElementObscurers(nativeElement)), startWith(null), distinctUntilChanged(), tuiZoneOptimized(ngZone), takeUntil(destroy$));
     }
-};
-TuiObscuredService.ctorParameters = () => [
-    { type: TuiParentsScrollService, decorators: [{ type: Inject, args: [TuiParentsScrollService,] }, { type: Self }] },
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: NgZone, decorators: [{ type: Inject, args: [NgZone,] }] },
-    { type: Window, decorators: [{ type: Inject, args: [WINDOW,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [TuiDestroyService,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [ANIMATION_FRAME,] }] }
-];
-TuiObscuredService = __decorate([
-    Injectable(),
-    __param(0, Inject(TuiParentsScrollService)),
-    __param(0, Self()),
-    __param(1, Inject(ElementRef)),
-    __param(2, Inject(NgZone)),
-    __param(3, Inject(WINDOW)),
-    __param(4, Inject(TuiDestroyService)),
-    __param(5, Inject(ANIMATION_FRAME))
-], TuiObscuredService);
+}
+TuiObscuredService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiObscuredService, deps: [{ token: TuiParentsScrollService, self: true }, { token: ElementRef }, { token: NgZone }, { token: WINDOW }, { token: TuiDestroyService }, { token: ANIMATION_FRAME }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiObscuredService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiObscuredService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiObscuredService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: TuiParentsScrollService, decorators: [{
+                    type: Inject,
+                    args: [TuiParentsScrollService]
+                }, {
+                    type: Self
+                }] }, { type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i0.NgZone, decorators: [{
+                    type: Inject,
+                    args: [NgZone]
+                }] }, { type: Window, decorators: [{
+                    type: Inject,
+                    args: [WINDOW]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [TuiDestroyService]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [ANIMATION_FRAME]
+                }] }]; } });
 
 /**
  * @dynamic
  */
-let TuiPanService = class TuiPanService extends Observable {
+class TuiPanService extends Observable {
     constructor({ nativeElement }, documentRef) {
         super(subscriber => {
-            merge(typedFromEvent(nativeElement, 'touchstart', { passive: true }), typedFromEvent(nativeElement, 'mousedown'))
-                .pipe(switchMapTo(merge(typedFromEvent(documentRef, 'touchmove', {
+            merge(typedFromEvent(nativeElement, `touchstart`, { passive: true }), typedFromEvent(nativeElement, `mousedown`))
+                .pipe(switchMapTo(merge(typedFromEvent(documentRef, `touchmove`, {
                 passive: true,
-            }).pipe(filter(({ touches }) => touches.length < 2), map(({ touches }) => touches[0])), typedFromEvent(documentRef, 'mousemove'))), pairwise(), map(([first, second]) => {
+            }).pipe(filter(({ touches }) => touches.length < 2), map(({ touches }) => touches[0])), typedFromEvent(documentRef, `mousemove`))), pairwise(), map(([first, second]) => {
                 const deltaX = second.clientX - first.clientX;
                 const deltaY = second.clientY - first.clientY;
                 return [deltaX, deltaY];
             }), 
             // eslint-disable-next-line rxjs/no-unsafe-takeuntil
-            takeUntil(merge(typedFromEvent(documentRef, 'touchend'), typedFromEvent(documentRef, 'mouseup'))), repeat())
+            takeUntil(merge(typedFromEvent(documentRef, `touchend`), typedFromEvent(documentRef, `mouseup`))), repeat())
                 .subscribe(subscriber);
         });
     }
-};
-TuiPanService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-];
-TuiPanService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(DOCUMENT))
-], TuiPanService);
+}
+TuiPanService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiPanService, deps: [{ token: ElementRef }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiPanService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiPanService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiPanService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
 
 // @dynamic
-let TuiResizeService = class TuiResizeService extends ResizeObserverService {
+class TuiResizeService extends ResizeObserverService {
     constructor(elementRef, ngZone, destroy$, support, box, animationFrame$) {
         super(elementRef, ngZone, support, box);
         return this.pipe(catchError(() => animationFrame$.pipe(throttleTime(POLLING_TIME), map(() => `${elementRef.nativeElement.clientWidth} ${elementRef.nativeElement.clientHeight}`), distinctUntilChanged(), mapTo(EMPTY_ARRAY))), debounceTime(0), tuiZonefree(ngZone), takeUntil(destroy$));
     }
-};
-TuiResizeService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: NgZone, decorators: [{ type: Inject, args: [NgZone,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [TuiDestroyService,] }] },
-    { type: Boolean, decorators: [{ type: Inject, args: [RESIZE_OBSERVER_SUPPORT,] }] },
-    { type: undefined, decorators: [{ type: Inject, args: [RESIZE_OPTION_BOX,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [ANIMATION_FRAME,] }] }
-];
-TuiResizeService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(NgZone)),
-    __param(2, Inject(TuiDestroyService)),
-    __param(3, Inject(RESIZE_OBSERVER_SUPPORT)),
-    __param(4, Inject(RESIZE_OPTION_BOX)),
-    __param(5, Inject(ANIMATION_FRAME))
-], TuiResizeService);
+}
+TuiResizeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiResizeService, deps: [{ token: ElementRef }, { token: NgZone }, { token: TuiDestroyService }, { token: RESIZE_OBSERVER_SUPPORT }, { token: RESIZE_OPTION_BOX }, { token: ANIMATION_FRAME }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiResizeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiResizeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiResizeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: i0.NgZone, decorators: [{
+                    type: Inject,
+                    args: [NgZone]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [TuiDestroyService]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [RESIZE_OBSERVER_SUPPORT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [RESIZE_OPTION_BOX]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [ANIMATION_FRAME]
+                }] }]; } });
 
 const SCROLL_TIME = 300;
 // @dynamic
-let TuiScrollService = class TuiScrollService {
+class TuiScrollService {
     constructor(performanceRef, animationFrame$) {
         this.performanceRef = performanceRef;
         this.animationFrame$ = animationFrame$;
     }
     scroll$(element, scrollTop, scrollLeft = element.scrollLeft, duration = SCROLL_TIME) {
-        tuiAssert.assert(duration >= 0, 'Duration cannot be negative');
-        tuiAssert.assert(scrollTop >= 0, 'scrollTop cannot be negative');
-        tuiAssert.assert(scrollLeft >= 0, 'scrollLeft cannot be negative');
+        tuiAssert.assert(duration >= 0, `Duration cannot be negative`);
+        tuiAssert.assert(scrollTop >= 0, `scrollTop cannot be negative`);
+        tuiAssert.assert(scrollLeft >= 0, `scrollLeft cannot be negative`);
         const initialTop = element.scrollTop;
         const initialLeft = element.scrollLeft;
         const deltaTop = scrollTop - initialTop;
@@ -288,21 +292,23 @@ let TuiScrollService = class TuiScrollService {
             element.scrollLeft = scrollLeft;
         }));
     }
-};
-TuiScrollService.ctorParameters = () => [
-    { type: Performance, decorators: [{ type: Inject, args: [PERFORMANCE,] }] },
-    { type: Observable, decorators: [{ type: Inject, args: [ANIMATION_FRAME,] }] }
-];
-TuiScrollService.ɵprov = ɵɵdefineInjectable({ factory: function TuiScrollService_Factory() { return new TuiScrollService(ɵɵinject(PERFORMANCE), ɵɵinject(ANIMATION_FRAME)); }, token: TuiScrollService, providedIn: "root" });
-TuiScrollService = __decorate([
-    Injectable({
-        providedIn: 'root',
-    }),
-    __param(0, Inject(PERFORMANCE)),
-    __param(1, Inject(ANIMATION_FRAME))
-], TuiScrollService);
+}
+TuiScrollService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiScrollService, deps: [{ token: PERFORMANCE }, { token: ANIMATION_FRAME }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiScrollService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiScrollService, providedIn: `root` });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiScrollService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: `root`,
+                }]
+        }], ctorParameters: function () { return [{ type: Performance, decorators: [{
+                    type: Inject,
+                    args: [PERFORMANCE]
+                }] }, { type: i1.Observable, decorators: [{
+                    type: Inject,
+                    args: [ANIMATION_FRAME]
+                }] }]; } });
 
-let TuiStaticRequestService = class TuiStaticRequestService {
+class TuiStaticRequestService {
     constructor() {
         this.cache = new Map();
     }
@@ -325,7 +331,7 @@ let TuiStaticRequestService = class TuiStaticRequestService {
                     }
                 }
             };
-            xhr.open('GET', url);
+            xhr.open(`GET`, url);
             xhr.send();
             return () => {
                 xhr.abort();
@@ -335,21 +341,23 @@ let TuiStaticRequestService = class TuiStaticRequestService {
         this.cache.set(url, piped);
         return piped;
     }
-};
-TuiStaticRequestService.ɵprov = ɵɵdefineInjectable({ factory: function TuiStaticRequestService_Factory() { return new TuiStaticRequestService(); }, token: TuiStaticRequestService, providedIn: "root" });
-TuiStaticRequestService = __decorate([
-    Injectable({
-        providedIn: 'root',
-    })
-], TuiStaticRequestService);
+}
+TuiStaticRequestService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiStaticRequestService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+TuiStaticRequestService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiStaticRequestService, providedIn: `root` });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiStaticRequestService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: `root`,
+                }]
+        }] });
 
 /**
  * @dynamic
  */
-let TuiSwipeService = class TuiSwipeService extends Observable {
+class TuiSwipeService extends Observable {
     constructor({ nativeElement }, { timeout, threshold }, documentRef) {
         super(subscriber => {
-            merge(typedFromEvent(nativeElement, 'touchstart', { passive: true }), typedFromEvent(documentRef, 'touchend'))
+            merge(typedFromEvent(nativeElement, `touchstart`, { passive: true }), typedFromEvent(documentRef, `touchend`))
                 .pipe(pairwise(), filter(([first, second]) => !!first.touches.length &&
                 first.touches[0].identifier ===
                     second.changedTouches[0].identifier), map(([start, end]) => {
@@ -373,25 +381,28 @@ let TuiSwipeService = class TuiSwipeService extends Observable {
                 .subscribe(subscriber);
         });
     }
-};
-TuiSwipeService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: undefined, decorators: [{ type: Inject, args: [TUI_SWIPE_OPTIONS,] }] },
-    { type: Document, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
-];
-TuiSwipeService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(TUI_SWIPE_OPTIONS)),
-    __param(2, Inject(DOCUMENT))
-], TuiSwipeService);
+}
+TuiSwipeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiSwipeService, deps: [{ token: ElementRef }, { token: TUI_SWIPE_OPTIONS }, { token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiSwipeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiSwipeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiSwipeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TUI_SWIPE_OPTIONS]
+                }] }, { type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
 
 const TOUCH_SENSITIVITY = 0.01;
 // @dynamic
-let TuiZoomService = class TuiZoomService extends Observable {
+class TuiZoomService extends Observable {
     constructor({ nativeElement }, { wheelSensitivity }) {
         super(subscriber => {
-            merge(typedFromEvent(nativeElement, 'touchstart', { passive: true }).pipe(filter(({ touches }) => touches.length > 1), switchMap(startEvent => typedFromEvent(nativeElement, 'touchmove', {
+            merge(typedFromEvent(nativeElement, `touchstart`, { passive: true }).pipe(filter(({ touches }) => touches.length > 1), switchMap(startEvent => typedFromEvent(nativeElement, `touchmove`, {
                 passive: true,
             }).pipe(preventDefault(), scan((prev, event) => {
                 const distance = distanceBetweenTouches(event);
@@ -413,7 +424,7 @@ let TuiZoomService = class TuiZoomService extends Observable {
                     event.touches[1].clientY) /
                     2;
                 return { clientX, clientY, delta, event };
-            }), takeUntil(typedFromEvent(nativeElement, 'touchend'))))), typedFromEvent(nativeElement, 'wheel', { passive: false }).pipe(preventDefault(), map(wheel => ({
+            }), takeUntil(typedFromEvent(nativeElement, `touchend`))))), typedFromEvent(nativeElement, `wheel`, { passive: false }).pipe(preventDefault(), map(wheel => ({
                 clientX: wheel.clientX,
                 clientY: wheel.clientY,
                 delta: -wheel.deltaY * wheelSensitivity,
@@ -421,20 +432,22 @@ let TuiZoomService = class TuiZoomService extends Observable {
             })))).subscribe(subscriber);
         });
     }
-};
-TuiZoomService.ctorParameters = () => [
-    { type: ElementRef, decorators: [{ type: Inject, args: [ElementRef,] }] },
-    { type: undefined, decorators: [{ type: Inject, args: [TUI_ZOOM_OPTIONS,] }] }
-];
-TuiZoomService = __decorate([
-    Injectable(),
-    __param(0, Inject(ElementRef)),
-    __param(1, Inject(TUI_ZOOM_OPTIONS))
-], TuiZoomService);
+}
+TuiZoomService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiZoomService, deps: [{ token: ElementRef }, { token: TUI_ZOOM_OPTIONS }], target: i0.ɵɵFactoryTarget.Injectable });
+TuiZoomService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiZoomService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TuiZoomService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ElementRef, decorators: [{
+                    type: Inject,
+                    args: [ElementRef]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [TUI_ZOOM_OPTIONS]
+                }] }]; } });
 
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { TuiDestroyService, TuiDirectiveStylesService, TuiFocusVisibleService, TuiHoveredService, TuiIdService, TuiObscuredService, TuiPanService, TuiParentsScrollService, TuiResizeService, TuiScrollService, TuiStaticRequestService, TuiSwipeService, TuiZoomService };
+export { TuiDestroyService, TuiDirectiveStylesService, TuiFocusVisibleService, TuiIdService, TuiObscuredService, TuiPanService, TuiParentsScrollService, TuiResizeService, TuiScrollService, TuiStaticRequestService, TuiSwipeService, TuiZoomService };
 //# sourceMappingURL=taiga-ui-cdk-services.js.map