@cuby-ui/cdk 0.0.231 → 0.0.232

package/directives/drag-drop/drag-drop.directive.d.ts

@@ -0,0 +1,42 @@
+import type { OnDestroy } from '@angular/core';
+import type { CuiNullable } from '../../types';
+import type { CuiDragData, CuiDragDropData } from './drag-drop.options';
+import * as i0 from "@angular/core";
+export declare class CuiDragDropDirective implements OnDestroy {
+    private readonly zone;
+    private readonly document;
+    private readonly renderer;
+    private readonly element;
+    private readonly dragListDirective;
+    private readonly PLACEHOLDER_CLASS;
+    private readonly listId;
+    private readonly itemAttribute;
+    private index;
+    private prevIndex;
+    private abortController;
+    private hostAbortController;
+    protected readonly draggingElement: import("@angular/core").WritableSignal<CuiNullable<HTMLElement>>;
+    protected readonly placeholderElement: import("@angular/core").WritableSignal<CuiNullable<HTMLElement>>;
+    protected readonly dragData: import("@angular/core").WritableSignal<CuiDragData>;
+    readonly disabled: import("@angular/core").InputSignal<boolean>;
+    readonly elementDragged: import("@angular/core").OutputEmitterRef<CuiDragDropData>;
+    constructor();
+    ngOnDestroy(): void;
+    changePointerEvents(element: HTMLElement): void;
+    private onDrag;
+    private onDragStart;
+    private onDragEnd;
+    private initDragItem;
+    private initPointerEvents;
+    private destroyEvents;
+    private prepareMoving;
+    private configurateDragData;
+    private createDragElement;
+    private createPlaceholderElement;
+    private removeDragElement;
+    private removePlaceholder;
+    private calculateIndex;
+    private calculatePreviousIndex;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiDragDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiDragDropDirective, "[cuiDragDrop]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "elementDragged": "elementDragged"; }, never, never, true, never>;
+}

package/directives/drag-drop/drag-drop.options.d.ts

@@ -0,0 +1,11 @@
+export interface CuiDragDropData {
+    readonly index: number;
+    readonly prevIndex: number;
+    readonly pointer: CuiDropPointer;
+    readonly targetElement: HTMLElement;
+}
+export interface CuiDragData {
+    readonly pointer?: CuiDropPointer;
+    readonly targetElement?: HTMLElement;
+}
+export type CuiDropPointer = 'BEFORE' | 'AFTER';

package/directives/drag-drop/drag-list.directive.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class CuiDragListDirective {
+    private readonly renderer;
+    private readonly element;
+    readonly id: string;
+    readonly listId: string;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiDragListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiDragListDirective, "[cuiDragList]", never, {}, {}, never, never, true, never>;
+}

package/directives/drag-drop/drag-pointer.directive.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class CuiDragPointerDirective {
+    private readonly dragDropDirective;
+    private readonly element;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiDragPointerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiDragPointerDirective, "[cuiDragPointer]", never, {}, {}, never, never, true, never>;
+}

package/directives/drag-drop/index.d.ts

@@ -0,0 +1,4 @@
+export { CuiDragDropData, CuiDragData } from './drag-drop.options';
+export { CuiDragDropDirective } from './drag-drop.directive';
+export { CuiDragListDirective } from './drag-list.directive';
+export { CuiDragPointerDirective } from './drag-pointer.directive';

package/directives/handle-scroll.directive.d.ts

@@ -0,0 +1,23 @@
+import type { OnDestroy } from '@angular/core';
+import type { CuiNullable } from '../types';
+import * as i0 from "@angular/core";
+export declare class CuiHandleScrollDirective implements OnDestroy {
+    private readonly window;
+    private readonly document;
+    private readonly renderer;
+    private readonly zone;
+    private abortController;
+    private scrollSubscription?;
+    protected readonly SCROLL_AREA_HEIGHT = 100;
+    protected readonly scrollGapElements: import("@angular/core").WritableSignal<CuiNullable<HTMLDivElement[]>>;
+    readonly scrollSpeed: import("@angular/core").InputSignal<number>;
+    ngOnDestroy(): void;
+    onTargetMove(): void;
+    private initScrollEvent;
+    private handleScroll;
+    private setScrollGapElements;
+    private startScrolling;
+    private removeSubscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CuiHandleScrollDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CuiHandleScrollDirective, "[cuiHandleScroll]", never, { "scrollSpeed": { "alias": "scrollSpeed"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/directives/index.d.ts

@@ -1,6 +1,8 @@
 export * from './active-zone';
 export * from './hovered';
+export * from './drag-drop';
 export * from './auto-resizing.directive';
+export * from './handle-scroll.directive';
 export * from './click-outside.directive';
 export * from './dimensions-observer.directive';
 export * from './content-editable-value-accessor.directive';

package/esm2022/directives/drag-drop/drag-drop.directive.mjs

@@ -0,0 +1,184 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, ElementRef, inject, input, NgZone, output, Renderer2, signal } from '@angular/core';
+import { CuiDragListDirective } from './drag-list.directive';
+import * as i0 from "@angular/core";
+export class CuiDragDropDirective {
+    constructor() {
+        this.zone = inject(NgZone);
+        this.document = inject(DOCUMENT);
+        this.renderer = inject(Renderer2);
+        this.element = inject(ElementRef).nativeElement;
+        this.dragListDirective = inject(CuiDragListDirective);
+        this.PLACEHOLDER_CLASS = 'cc-drag-drop-placeholder';
+        this.listId = this.dragListDirective.listId;
+        this.itemAttribute = `${this.listId}-drag-item`;
+        this.abortController = new AbortController();
+        this.hostAbortController = new AbortController();
+        this.draggingElement = signal(null);
+        this.placeholderElement = signal(null);
+        this.dragData = signal({});
+        this.disabled = input(false);
+        this.elementDragged = output();
+        this.initDragItem();
+        this.initPointerEvents(this.element);
+    }
+    ngOnDestroy() {
+        this.destroyEvents();
+    }
+    changePointerEvents(element) {
+        this.hostAbortController.abort();
+        this.hostAbortController = new AbortController();
+        this.initPointerEvents(element);
+    }
+    onDrag(clientX, clientY) {
+        if (!this.draggingElement()) {
+            return;
+        }
+        const elementsFromPoint = this.document.elementsFromPoint(clientX, clientY);
+        const elementFromPoint = elementsFromPoint.find((element) => element.closest(`#${this.listId}`));
+        if (!elementFromPoint) {
+            return;
+        }
+        const targetElement = elementFromPoint.closest(`[${this.itemAttribute}]`);
+        if (!targetElement || targetElement === this.draggingElement()) {
+            return;
+        }
+        this.configurateDragData(targetElement, clientY);
+    }
+    onDragStart(event) {
+        if (this.disabled()) {
+            return;
+        }
+        let isClicked = true;
+        const elementClientRect = this.element.getBoundingClientRect();
+        const shiftX = event.clientX - elementClientRect.left;
+        const shiftY = event.clientY - elementClientRect.top;
+        this.prevIndex = this.calculatePreviousIndex();
+        this.document.addEventListener('pointermove', ({ clientX, clientY }) => {
+            if (isClicked) {
+                this.prepareMoving();
+                isClicked = false;
+            }
+            const draggingElement = this.draggingElement();
+            this.renderer.setStyle(draggingElement, 'left', clientX - shiftX + 'px');
+            this.renderer.setStyle(draggingElement, 'top', clientY - shiftY + 'px');
+            this.onDrag(clientX, clientY);
+        }, { signal: this.abortController.signal });
+    }
+    onDragEnd() {
+        const { targetElement, pointer } = this.dragData();
+        if (targetElement && pointer) {
+            this.elementDragged.emit({
+                index: this.index,
+                prevIndex: this.prevIndex,
+                targetElement,
+                pointer
+            });
+        }
+        // remove document events
+        this.abortController.abort();
+        this.abortController = new AbortController();
+        this.removeDragElement();
+        this.removePlaceholder();
+        this.dragData.set({});
+    }
+    initDragItem() {
+        this.renderer.setAttribute(this.element, this.itemAttribute, 'true');
+    }
+    initPointerEvents(element) {
+        const signal = this.hostAbortController.signal;
+        this.zone.runOutsideAngular(() => {
+            element.addEventListener('pointerup', this.onDragEnd.bind(this), { signal });
+            element.addEventListener('pointerdown', this.onDragStart.bind(this), { signal });
+        });
+    }
+    destroyEvents() {
+        this.hostAbortController.abort();
+        this.abortController.abort();
+    }
+    prepareMoving() {
+        const placeholderElement = this.createPlaceholderElement();
+        const draggingElement = this.createDragElement();
+        this.document.addEventListener('pointerup', this.onDragEnd.bind(this), {
+            signal: this.abortController.signal
+        });
+        this.element.after(placeholderElement);
+        this.draggingElement.set(draggingElement);
+        this.element.remove();
+        this.document.body.append(draggingElement);
+    }
+    configurateDragData(targetElement, clientY) {
+        const placeholderElement = this.placeholderElement();
+        const boundingRect = targetElement.getBoundingClientRect();
+        const middleY = boundingRect.top + boundingRect.height / 2;
+        if (clientY < middleY) {
+            targetElement.before(placeholderElement);
+            this.dragData.set({ targetElement, pointer: 'BEFORE' });
+        }
+        else {
+            targetElement.after(placeholderElement);
+            this.dragData.set({ targetElement, pointer: 'AFTER' });
+        }
+        this.index = this.calculateIndex(placeholderElement);
+    }
+    createDragElement() {
+        const width = this.element.clientWidth;
+        const draggingElement = this.element.cloneNode(true);
+        this.renderer.setStyle(draggingElement, 'position', 'fixed');
+        this.renderer.setStyle(draggingElement, 'display', 'block');
+        this.renderer.setStyle(draggingElement, 'margin', '0');
+        this.renderer.setStyle(draggingElement, 'width', `${width}px`);
+        return draggingElement;
+    }
+    createPlaceholderElement() {
+        const element = this.placeholderElement();
+        if (element) {
+            return element;
+        }
+        const placeholderElement = this.renderer.createElement('div');
+        this.renderer.addClass(placeholderElement, this.PLACEHOLDER_CLASS);
+        this.placeholderElement.set(placeholderElement);
+        return placeholderElement;
+    }
+    removeDragElement() {
+        const draggingElement = this.draggingElement();
+        if (!draggingElement) {
+            return;
+        }
+        draggingElement.remove();
+        this.draggingElement.set(null);
+    }
+    removePlaceholder() {
+        const placeholderElement = this.placeholderElement();
+        if (!placeholderElement) {
+            return;
+        }
+        placeholderElement.after(this.element);
+        placeholderElement.remove();
+        this.placeholderElement.set(null);
+    }
+    calculateIndex(placeholderElement) {
+        const childNodes = placeholderElement.parentElement.childNodes;
+        const elements = Array.from(childNodes).filter((node) => node instanceof HTMLElement);
+        return elements.indexOf(placeholderElement);
+    }
+    calculatePreviousIndex() {
+        let index = 0;
+        let currentElement = this.element;
+        while (currentElement && currentElement.previousElementSibling) {
+            index++;
+            currentElement = currentElement.previousElementSibling;
+        }
+        return index;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiDragDropDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.13", type: CuiDragDropDirective, isStandalone: true, selector: "[cuiDragDrop]", inputs: { disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { elementDragged: "elementDragged" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiDragDropDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cuiDragDrop]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-drop.directive.js","sourceRoot":"","sources":["../../../../../projects/cdk/directives/drag-drop/drag-drop.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\r\nimport type { OnDestroy } from '@angular/core';\r\nimport { Directive, ElementRef, inject, input, NgZone, output, Renderer2, signal } from '@angular/core';\r\nimport type { CuiNullable } from '../../types';\r\n\r\nimport type { CuiDragData, CuiDragDropData } from './drag-drop.options';\r\nimport { CuiDragListDirective } from './drag-list.directive';\r\n\r\n@Directive({\r\n    selector: '[cuiDragDrop]',\r\n    standalone: true\r\n})\r\nexport class CuiDragDropDirective implements OnDestroy {\r\n    private readonly zone = inject(NgZone);\r\n    private readonly document = inject(DOCUMENT);\r\n    private readonly renderer = inject(Renderer2);\r\n    private readonly element = inject(ElementRef).nativeElement;\r\n    private readonly dragListDirective = inject(CuiDragListDirective);\r\n\r\n    private readonly PLACEHOLDER_CLASS = 'cc-drag-drop-placeholder';\r\n\r\n    private readonly listId = this.dragListDirective.listId;\r\n    private readonly itemAttribute = `${this.listId}-drag-item`;\r\n\r\n    private index!: number;\r\n    private prevIndex!: number;\r\n    private abortController = new AbortController();\r\n    private hostAbortController = new AbortController();\r\n\r\n    protected readonly draggingElement = signal<CuiNullable<HTMLElement>>(null);\r\n    protected readonly placeholderElement = signal<CuiNullable<HTMLElement>>(null);\r\n    protected readonly dragData = signal<CuiDragData>({});\r\n\r\n    public readonly disabled = input(false);\r\n\r\n    public readonly elementDragged = output<CuiDragDropData>();\r\n\r\n    constructor() {\r\n        this.initDragItem();\r\n        this.initPointerEvents(this.element);\r\n    }\r\n\r\n    public ngOnDestroy(): void {\r\n        this.destroyEvents();\r\n    }\r\n\r\n    public changePointerEvents(element: HTMLElement): void {\r\n        this.hostAbortController.abort();\r\n        this.hostAbortController = new AbortController();\r\n\r\n        this.initPointerEvents(element);\r\n    }\r\n\r\n    private onDrag(clientX: number, clientY: number): void {\r\n        if (!this.draggingElement()) {\r\n            return;\r\n        }\r\n\r\n        const elementsFromPoint = this.document.elementsFromPoint(clientX, clientY);\r\n        const elementFromPoint = elementsFromPoint.find((element) => element.closest(`#${this.listId}`));\r\n\r\n        if (!elementFromPoint) {\r\n            return;\r\n        }\r\n\r\n        const targetElement = elementFromPoint.closest<HTMLElement>(`[${this.itemAttribute}]`);\r\n\r\n        if (!targetElement || targetElement === this.draggingElement()) {\r\n            return;\r\n        }\r\n\r\n        this.configurateDragData(targetElement, clientY);\r\n    }\r\n\r\n    private onDragStart(event: MouseEvent): void {\r\n        if (this.disabled()) {\r\n            return;\r\n        }\r\n\r\n        let isClicked = true;\r\n\r\n        const elementClientRect = this.element.getBoundingClientRect();\r\n        const shiftX = event.clientX - elementClientRect.left;\r\n        const shiftY = event.clientY - elementClientRect.top;\r\n\r\n        this.prevIndex = this.calculatePreviousIndex();\r\n\r\n        this.document.addEventListener(\r\n            'pointermove',\r\n            ({ clientX, clientY }) => {\r\n                if (isClicked) {\r\n                    this.prepareMoving();\r\n\r\n                    isClicked = false;\r\n                }\r\n\r\n                const draggingElement = this.draggingElement();\r\n\r\n                this.renderer.setStyle(draggingElement, 'left', clientX - shiftX + 'px');\r\n                this.renderer.setStyle(draggingElement, 'top', clientY - shiftY + 'px');\r\n                this.onDrag(clientX, clientY);\r\n            },\r\n            { signal: this.abortController.signal }\r\n        );\r\n    }\r\n\r\n    private onDragEnd(): void {\r\n        const { targetElement, pointer } = this.dragData();\r\n\r\n        if (targetElement && pointer) {\r\n            this.elementDragged.emit({\r\n                index: this.index,\r\n                prevIndex: this.prevIndex,\r\n                targetElement,\r\n                pointer\r\n            });\r\n        }\r\n\r\n        // remove document events\r\n        this.abortController.abort();\r\n        this.abortController = new AbortController();\r\n\r\n        this.removeDragElement();\r\n        this.removePlaceholder();\r\n        this.dragData.set({});\r\n    }\r\n\r\n    private initDragItem(): void {\r\n        this.renderer.setAttribute(this.element, this.itemAttribute, 'true');\r\n    }\r\n\r\n    private initPointerEvents(element: HTMLElement): void {\r\n        const signal = this.hostAbortController.signal;\r\n\r\n        this.zone.runOutsideAngular(() => {\r\n            element.addEventListener('pointerup', this.onDragEnd.bind(this), { signal });\r\n            element.addEventListener('pointerdown', this.onDragStart.bind(this), { signal });\r\n        });\r\n    }\r\n\r\n    private destroyEvents(): void {\r\n        this.hostAbortController.abort();\r\n        this.abortController.abort();\r\n    }\r\n\r\n    private prepareMoving(): void {\r\n        const placeholderElement = this.createPlaceholderElement();\r\n        const draggingElement = this.createDragElement();\r\n\r\n        this.document.addEventListener('pointerup', this.onDragEnd.bind(this), {\r\n            signal: this.abortController.signal\r\n        });\r\n\r\n        this.element.after(placeholderElement);\r\n        this.draggingElement.set(draggingElement);\r\n\r\n        this.element.remove();\r\n        this.document.body.append(draggingElement);\r\n    }\r\n\r\n    private configurateDragData(targetElement: HTMLElement, clientY: number): void {\r\n        const placeholderElement = this.placeholderElement();\r\n        const boundingRect = targetElement.getBoundingClientRect();\r\n        const middleY = boundingRect.top + boundingRect.height / 2;\r\n\r\n        if (clientY < middleY) {\r\n            targetElement.before(placeholderElement!);\r\n            this.dragData.set({ targetElement, pointer: 'BEFORE' });\r\n        } else {\r\n            targetElement.after(placeholderElement!);\r\n            this.dragData.set({ targetElement, pointer: 'AFTER' });\r\n        }\r\n\r\n        this.index = this.calculateIndex(placeholderElement!);\r\n    }\r\n\r\n    private createDragElement(): HTMLElement {\r\n        const width = this.element.clientWidth;\r\n        const draggingElement = this.element.cloneNode(true) as HTMLElement;\r\n\r\n        this.renderer.setStyle(draggingElement, 'position', 'fixed');\r\n        this.renderer.setStyle(draggingElement, 'display', 'block');\r\n        this.renderer.setStyle(draggingElement, 'margin', '0');\r\n        this.renderer.setStyle(draggingElement, 'width', `${width}px`);\r\n\r\n        return draggingElement;\r\n    }\r\n\r\n    private createPlaceholderElement(): HTMLElement {\r\n        const element = this.placeholderElement();\r\n\r\n        if (element) {\r\n            return element;\r\n        }\r\n\r\n        const placeholderElement = this.renderer.createElement('div');\r\n\r\n        this.renderer.addClass(placeholderElement, this.PLACEHOLDER_CLASS);\r\n        this.placeholderElement.set(placeholderElement);\r\n\r\n        return placeholderElement;\r\n    }\r\n\r\n    private removeDragElement(): void {\r\n        const draggingElement = this.draggingElement();\r\n\r\n        if (!draggingElement) {\r\n            return;\r\n        }\r\n\r\n        draggingElement.remove();\r\n        this.draggingElement.set(null);\r\n    }\r\n\r\n    private removePlaceholder(): void {\r\n        const placeholderElement = this.placeholderElement();\r\n\r\n        if (!placeholderElement) {\r\n            return;\r\n        }\r\n\r\n        placeholderElement.after(this.element);\r\n        placeholderElement.remove();\r\n        this.placeholderElement.set(null);\r\n    }\r\n\r\n    private calculateIndex(placeholderElement: HTMLElement): number {\r\n        const childNodes = placeholderElement.parentElement!.childNodes;\r\n        const elements = Array.from(childNodes).filter((node) => node instanceof HTMLElement);\r\n\r\n        return elements.indexOf(placeholderElement!);\r\n    }\r\n\r\n    private calculatePreviousIndex(): number {\r\n        let index = 0;\r\n        let currentElement: Element = this.element;\r\n\r\n        while (currentElement && currentElement.previousElementSibling) {\r\n            index++;\r\n            currentElement = currentElement.previousElementSibling;\r\n        }\r\n\r\n        return index;\r\n    }\r\n}\r\n"]}

package/esm2022/directives/drag-drop/drag-drop.options.mjs

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

package/esm2022/directives/drag-drop/drag-list.directive.mjs

@@ -0,0 +1,22 @@
+import { Directive, ElementRef, inject, Renderer2 } from '@angular/core';
+import { CuiIdService } from '../../services';
+import * as i0 from "@angular/core";
+export class CuiDragListDirective {
+    constructor() {
+        this.renderer = inject(Renderer2);
+        this.element = inject(ElementRef).nativeElement;
+        this.id = inject(CuiIdService).generate();
+        this.listId = `${this.id}-list`;
+        this.renderer.setAttribute(this.element, 'id', this.listId);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiDragListDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CuiDragListDirective, isStandalone: true, selector: "[cuiDragList]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiDragListDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cuiDragList]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1saXN0LmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9kaXJlY3RpdmVzL2RyYWctZHJvcC9kcmFnLWxpc3QuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFekUsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGdCQUFnQixDQUFDOztBQU05QyxNQUFNLE9BQU8sb0JBQW9CO0lBTzdCO1FBTmlCLGFBQVEsR0FBRyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDN0IsWUFBTyxHQUFHLE1BQU0sQ0FBQyxVQUFVLENBQUMsQ0FBQyxhQUFhLENBQUM7UUFDNUMsT0FBRSxHQUFHLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUVyQyxXQUFNLEdBQUcsR0FBRyxJQUFJLENBQUMsRUFBRSxPQUFPLENBQUM7UUFHdkMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxJQUFJLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQ2hFLENBQUM7K0dBVFEsb0JBQW9CO21HQUFwQixvQkFBb0I7OzRGQUFwQixvQkFBb0I7a0JBSmhDLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLGVBQWU7b0JBQ3pCLFVBQVUsRUFBRSxJQUFJO2lCQUNuQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgRWxlbWVudFJlZiwgaW5qZWN0LCBSZW5kZXJlcjIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbmltcG9ydCB7IEN1aUlkU2VydmljZSB9IGZyb20gJy4uLy4uL3NlcnZpY2VzJztcclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gICAgc2VsZWN0b3I6ICdbY3VpRHJhZ0xpc3RdJyxcclxuICAgIHN0YW5kYWxvbmU6IHRydWVcclxufSlcclxuZXhwb3J0IGNsYXNzIEN1aURyYWdMaXN0RGlyZWN0aXZlIHtcclxuICAgIHByaXZhdGUgcmVhZG9ubHkgcmVuZGVyZXIgPSBpbmplY3QoUmVuZGVyZXIyKTtcclxuICAgIHByaXZhdGUgcmVhZG9ubHkgZWxlbWVudCA9IGluamVjdChFbGVtZW50UmVmKS5uYXRpdmVFbGVtZW50O1xyXG4gICAgcHVibGljIHJlYWRvbmx5IGlkID0gaW5qZWN0KEN1aUlkU2VydmljZSkuZ2VuZXJhdGUoKTtcclxuXHJcbiAgICBwdWJsaWMgcmVhZG9ubHkgbGlzdElkID0gYCR7dGhpcy5pZH0tbGlzdGA7XHJcblxyXG4gICAgY29uc3RydWN0b3IoKSB7XHJcbiAgICAgICAgdGhpcy5yZW5kZXJlci5zZXRBdHRyaWJ1dGUodGhpcy5lbGVtZW50LCAnaWQnLCB0aGlzLmxpc3RJZCk7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2022/directives/drag-drop/drag-pointer.directive.mjs

@@ -0,0 +1,20 @@
+import { Directive, ElementRef, inject } from '@angular/core';
+import { CuiDragDropDirective } from './drag-drop.directive';
+import * as i0 from "@angular/core";
+export class CuiDragPointerDirective {
+    constructor() {
+        this.dragDropDirective = inject(CuiDragDropDirective);
+        this.element = inject(ElementRef).nativeElement;
+        this.dragDropDirective.changePointerEvents(this.element);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiDragPointerDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CuiDragPointerDirective, isStandalone: true, selector: "[cuiDragPointer]", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiDragPointerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cuiDragPointer]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1wb2ludGVyLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2Nkay9kaXJlY3RpdmVzL2RyYWctZHJvcC9kcmFnLXBvaW50ZXIuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUU5RCxPQUFPLEVBQUUsb0JBQW9CLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQzs7QUFNN0QsTUFBTSxPQUFPLHVCQUF1QjtJQUloQztRQUhpQixzQkFBaUIsR0FBRyxNQUFNLENBQUMsb0JBQW9CLENBQUMsQ0FBQztRQUNqRCxZQUFPLEdBQUcsTUFBTSxDQUFDLFVBQVUsQ0FBQyxDQUFDLGFBQWEsQ0FBQztRQUd4RCxJQUFJLENBQUMsaUJBQWlCLENBQUMsbUJBQW1CLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxDQUFDO0lBQzdELENBQUM7K0dBTlEsdUJBQXVCO21HQUF2Qix1QkFBdUI7OzRGQUF2Qix1QkFBdUI7a0JBSm5DLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLGtCQUFrQjtvQkFDNUIsVUFBVSxFQUFFLElBQUk7aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBFbGVtZW50UmVmLCBpbmplY3QgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuXHJcbmltcG9ydCB7IEN1aURyYWdEcm9wRGlyZWN0aXZlIH0gZnJvbSAnLi9kcmFnLWRyb3AuZGlyZWN0aXZlJztcclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gICAgc2VsZWN0b3I6ICdbY3VpRHJhZ1BvaW50ZXJdJyxcclxuICAgIHN0YW5kYWxvbmU6IHRydWVcclxufSlcclxuZXhwb3J0IGNsYXNzIEN1aURyYWdQb2ludGVyRGlyZWN0aXZlIHtcclxuICAgIHByaXZhdGUgcmVhZG9ubHkgZHJhZ0Ryb3BEaXJlY3RpdmUgPSBpbmplY3QoQ3VpRHJhZ0Ryb3BEaXJlY3RpdmUpO1xyXG4gICAgcHJpdmF0ZSByZWFkb25seSBlbGVtZW50ID0gaW5qZWN0KEVsZW1lbnRSZWYpLm5hdGl2ZUVsZW1lbnQ7XHJcblxyXG4gICAgY29uc3RydWN0b3IoKSB7XHJcbiAgICAgICAgdGhpcy5kcmFnRHJvcERpcmVjdGl2ZS5jaGFuZ2VQb2ludGVyRXZlbnRzKHRoaXMuZWxlbWVudCk7XHJcbiAgICB9XHJcbn1cclxuIl19

package/esm2022/directives/drag-drop/index.mjs

@@ -0,0 +1,4 @@
+export { CuiDragDropDirective } from './drag-drop.directive';
+export { CuiDragListDirective } from './drag-list.directive';
+export { CuiDragPointerDirective } from './drag-pointer.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jZGsvZGlyZWN0aXZlcy9kcmFnLWRyb3AvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDN0QsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFDN0QsT0FBTyxFQUFFLHVCQUF1QixFQUFFLE1BQU0sMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBDdWlEcmFnRHJvcERhdGEsIEN1aURyYWdEYXRhIH0gZnJvbSAnLi9kcmFnLWRyb3Aub3B0aW9ucyc7XHJcbmV4cG9ydCB7IEN1aURyYWdEcm9wRGlyZWN0aXZlIH0gZnJvbSAnLi9kcmFnLWRyb3AuZGlyZWN0aXZlJztcclxuZXhwb3J0IHsgQ3VpRHJhZ0xpc3REaXJlY3RpdmUgfSBmcm9tICcuL2RyYWctbGlzdC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgeyBDdWlEcmFnUG9pbnRlckRpcmVjdGl2ZSB9IGZyb20gJy4vZHJhZy1wb2ludGVyLmRpcmVjdGl2ZSc7XHJcbiJdfQ==

package/esm2022/directives/handle-scroll.directive.mjs

@@ -0,0 +1,81 @@
+import { DOCUMENT } from '@angular/common';
+import { Directive, inject, input, NgZone, Renderer2, signal } from '@angular/core';
+import { interval } from 'rxjs';
+import { CUI_WINDOW } from '../tokens';
+import * as i0 from "@angular/core";
+export class CuiHandleScrollDirective {
+    constructor() {
+        this.window = inject(CUI_WINDOW);
+        this.document = inject(DOCUMENT);
+        this.renderer = inject(Renderer2);
+        this.zone = inject(NgZone);
+        this.abortController = new AbortController();
+        this.SCROLL_AREA_HEIGHT = 100;
+        this.scrollGapElements = signal(null);
+        this.scrollSpeed = input(100);
+    }
+    ngOnDestroy() {
+        this.removeSubscription();
+    }
+    onTargetMove() {
+        const signal = this.abortController.signal;
+        this.zone.runOutsideAngular(this.initScrollEvent.bind(this, signal));
+    }
+    initScrollEvent(signal) {
+        this.document.addEventListener('pointermove', ({ clientY }) => this.handleScroll(clientY), { signal });
+        this.document.addEventListener('pointerup', () => {
+            this.scrollGapElements()?.forEach((element) => element.remove());
+            this.scrollGapElements.set(null);
+            this.removeSubscription();
+            this.abortController.abort();
+            this.abortController = new AbortController();
+        }, { signal });
+    }
+    handleScroll(clientY) {
+        const windowHeight = this.document.documentElement.clientHeight;
+        const scrollSpeed = this.scrollSpeed();
+        if (!this.scrollGapElements()) {
+            this.setScrollGapElements();
+        }
+        if (clientY <= this.SCROLL_AREA_HEIGHT) {
+            this.startScrolling(-scrollSpeed);
+            return;
+        }
+        if (clientY >= windowHeight - this.SCROLL_AREA_HEIGHT) {
+            this.startScrolling(scrollSpeed);
+            return;
+        }
+        this.removeSubscription();
+    }
+    setScrollGapElements() {
+        const scrollGapElement = this.renderer.createElement('div');
+        this.renderer.setStyle(scrollGapElement, 'position', 'fixed');
+        this.renderer.setStyle(scrollGapElement, 'width', '100%');
+        this.renderer.setStyle(scrollGapElement, 'height', '48px');
+        this.renderer.setStyle(scrollGapElement, 'top', '0');
+        const scrollGapBottomElement = scrollGapElement.cloneNode(true);
+        this.renderer.appendChild(this.document.body, scrollGapElement);
+        this.renderer.appendChild(this.document.body, scrollGapBottomElement);
+        this.scrollGapElements.set([scrollGapElement, scrollGapBottomElement]);
+    }
+    startScrolling(speed) {
+        this.removeSubscription();
+        this.scrollSubscription = interval(this.scrollSpeed()).subscribe(() => this.window.scrollBy({ top: speed, behavior: 'smooth' }));
+    }
+    removeSubscription() {
+        this.scrollSubscription?.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiHandleScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.13", type: CuiHandleScrollDirective, isStandalone: true, selector: "[cuiHandleScroll]", inputs: { scrollSpeed: { classPropertyName: "scrollSpeed", publicName: "scrollSpeed", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "pointerdown": "onTargetMove()" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CuiHandleScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cuiHandleScroll]',
+                    standalone: true,
+                    host: {
+                        '(pointerdown)': 'onTargetMove()'
+                    }
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handle-scroll.directive.js","sourceRoot":"","sources":["../../../../projects/cdk/directives/handle-scroll.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOCUMENT } from '@angular/common';\r\nimport type { OnDestroy } from '@angular/core';\r\nimport { Directive, inject, input, NgZone, Renderer2, signal } from '@angular/core';\r\nimport type { Subscription } from 'rxjs';\r\nimport { interval } from 'rxjs';\r\n\r\nimport type { CuiNullable } from '../types';\r\nimport { CUI_WINDOW } from '../tokens';\r\n\r\n@Directive({\r\n    selector: '[cuiHandleScroll]',\r\n    standalone: true,\r\n    host: {\r\n        '(pointerdown)': 'onTargetMove()'\r\n    }\r\n})\r\nexport class CuiHandleScrollDirective implements OnDestroy {\r\n    private readonly window = inject(CUI_WINDOW);\r\n    private readonly document = inject(DOCUMENT);\r\n    private readonly renderer = inject(Renderer2);\r\n    private readonly zone = inject(NgZone);\r\n\r\n    private abortController = new AbortController();\r\n    private scrollSubscription?: Subscription;\r\n\r\n    protected readonly SCROLL_AREA_HEIGHT = 100;\r\n\r\n    protected readonly scrollGapElements = signal<CuiNullable<HTMLDivElement[]>>(null);\r\n\r\n    public readonly scrollSpeed = input(100);\r\n\r\n    public ngOnDestroy(): void {\r\n        this.removeSubscription();\r\n    }\r\n\r\n    public onTargetMove(): void {\r\n        const signal = this.abortController.signal;\r\n\r\n        this.zone.runOutsideAngular(this.initScrollEvent.bind(this, signal));\r\n    }\r\n\r\n    private initScrollEvent(signal: AbortSignal): void {\r\n        this.document.addEventListener('pointermove', ({ clientY }) => this.handleScroll(clientY), { signal });\r\n        this.document.addEventListener(\r\n            'pointerup',\r\n            () => {\r\n                this.scrollGapElements()?.forEach((element) => element.remove());\r\n                this.scrollGapElements.set(null);\r\n\r\n                this.removeSubscription();\r\n                this.abortController.abort();\r\n                this.abortController = new AbortController();\r\n            },\r\n            { signal }\r\n        );\r\n    }\r\n\r\n    private handleScroll(clientY: number): void {\r\n        const windowHeight = this.document.documentElement.clientHeight;\r\n        const scrollSpeed = this.scrollSpeed();\r\n\r\n        if (!this.scrollGapElements()) {\r\n            this.setScrollGapElements();\r\n        }\r\n\r\n        if (clientY <= this.SCROLL_AREA_HEIGHT) {\r\n            this.startScrolling(-scrollSpeed);\r\n\r\n            return;\r\n        }\r\n\r\n        if (clientY >= windowHeight - this.SCROLL_AREA_HEIGHT) {\r\n            this.startScrolling(scrollSpeed);\r\n\r\n            return;\r\n        }\r\n\r\n        this.removeSubscription();\r\n    }\r\n\r\n    private setScrollGapElements(): void {\r\n        const scrollGapElement = this.renderer.createElement('div');\r\n\r\n        this.renderer.setStyle(scrollGapElement, 'position', 'fixed');\r\n        this.renderer.setStyle(scrollGapElement, 'width', '100%');\r\n        this.renderer.setStyle(scrollGapElement, 'height', '48px');\r\n        this.renderer.setStyle(scrollGapElement, 'top', '0');\r\n\r\n        const scrollGapBottomElement = scrollGapElement.cloneNode(true) as HTMLDivElement;\r\n\r\n        this.renderer.appendChild(this.document.body, scrollGapElement);\r\n        this.renderer.appendChild(this.document.body, scrollGapBottomElement);\r\n\r\n        this.scrollGapElements.set([scrollGapElement, scrollGapBottomElement]);\r\n    }\r\n\r\n    private startScrolling(speed: number): void {\r\n        this.removeSubscription();\r\n\r\n        this.scrollSubscription = interval(this.scrollSpeed()).subscribe(() =>\r\n            this.window.scrollBy({ top: speed, behavior: 'smooth' })\r\n        );\r\n    }\r\n\r\n    private removeSubscription(): void {\r\n        this.scrollSubscription?.unsubscribe();\r\n    }\r\n}\r\n"]}

package/esm2022/directives/index.mjs

@@ -1,6 +1,8 @@
 export * from './active-zone';
 export * from './hovered';
+export * from './drag-drop';
 export * from './auto-resizing.directive';
+export * from './handle-scroll.directive';
 export * from './click-outside.directive';
 export * from './dimensions-observer.directive';
 export * from './content-editable-value-accessor.directive';
@@ -11,4 +13,4 @@ export * from './let.context';
 export * from './let.directive';
 export * from './target.directive';
 export * from './ladder-list.directive';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jZGsvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxpQ0FBaUMsQ0FBQztBQUNoRCxjQUFjLDZDQUE2QyxDQUFDO0FBQzVELGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLHlCQUF5QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hY3RpdmUtem9uZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vaG92ZXJlZCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vYXV0by1yZXNpemluZy5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2NsaWNrLW91dHNpZGUuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9kaW1lbnNpb25zLW9ic2VydmVyLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY29udGVudC1lZGl0YWJsZS12YWx1ZS1hY2Nlc3Nvci5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2VsZW1lbnQuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9mb2N1cy10cmFwLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vaXRlbS5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xldC5jb250ZXh0JztcclxuZXhwb3J0ICogZnJvbSAnLi9sZXQuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi90YXJnZXQuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9sYWRkZXItbGlzdC5kaXJlY3RpdmUnO1xyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jZGsvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQztBQUM5QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsNkNBQTZDLENBQUM7QUFDNUQsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FjdGl2ZS16b25lJztcclxuZXhwb3J0ICogZnJvbSAnLi9ob3ZlcmVkJztcclxuZXhwb3J0ICogZnJvbSAnLi9kcmFnLWRyb3AnO1xyXG5leHBvcnQgKiBmcm9tICcuL2F1dG8tcmVzaXppbmcuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9oYW5kbGUtc2Nyb2xsLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vY2xpY2stb3V0c2lkZS5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2RpbWVuc2lvbnMtb2JzZXJ2ZXIuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9jb250ZW50LWVkaXRhYmxlLXZhbHVlLWFjY2Vzc29yLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZWxlbWVudC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2ZvY3VzLXRyYXAuZGlyZWN0aXZlJztcclxuZXhwb3J0ICogZnJvbSAnLi9pdGVtLmRpcmVjdGl2ZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbGV0LmNvbnRleHQnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xldC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL3RhcmdldC5kaXJlY3RpdmUnO1xyXG5leHBvcnQgKiBmcm9tICcuL2xhZGRlci1saXN0LmRpcmVjdGl2ZSc7XHJcbiJdfQ==