@clr/angular 12.0.7 → 13.0.0-next.1

package/esm2020/utils/drag-and-drop/if-dragged.mjs

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Directive, Optional, SkipSelf } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/drag-event-listener.service";
+// This structural directive will be used mainly together with `clr-draggable-ghost` directive inside of clrDraggable
+// directive. The directive is responsible for instantiating `clr-draggable-ghost` directive only during dragging so
+// that Angular Change Detection is prevented from running if a component or directive is placed inside of the
+// `clr-draggable-ghost` directive.
+export class ClrIfDragged {
+    constructor(template, container, dragEventListener) {
+        this.template = template;
+        this.container = container;
+        this.dragEventListener = dragEventListener;
+        this.subscriptions = [];
+        if (!this.dragEventListener || !this.container) {
+            throw new Error('The *clrIfDragged directive can only be used inside of a clrDraggable directive.');
+        }
+        this.subscriptions.push(this.dragEventListener.dragStarted.subscribe(() => {
+            this.container.createEmbeddedView(this.template);
+        }));
+        this.subscriptions.push(this.dragEventListener.dragEnded.subscribe(() => {
+            this.container.clear();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach((sub) => sub.unsubscribe());
+    }
+}
+ClrIfDragged.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrIfDragged, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef, optional: true, skipSelf: true }, { token: i1.DragEventListenerService, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+ClrIfDragged.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrIfDragged, selector: "[clrIfDragged]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrIfDragged, decorators: [{
+            type: Directive,
+            args: [{ selector: '[clrIfDragged]' }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i1.DragEventListenerService, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/utils/drag-and-drop/providers/drag-and-drop-event-bus.service.js → esm2020/utils/drag-and-drop/providers/drag-and-drop-event-bus.service.mjs}

@@ -45,8 +45,10 @@ export class DragAndDropEventBusService {
         }
     }
 }
-DragAndDropEventBusService.ɵprov = i0.ɵɵdefineInjectable({ factory: function DragAndDropEventBusService_Factory() { return new DragAndDropEventBusService(); }, token: DragAndDropEventBusService, providedIn: "root" });
-DragAndDropEventBusService.decorators = [
-    { type: Injectable, args: [{ providedIn: 'root' },] }
-];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHJhZy1hbmQtZHJvcC1ldmVudC1idXMuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXIvc3JjL3V0aWxzL2RyYWctYW5kLWRyb3AvcHJvdmlkZXJzL2RyYWctYW5kLWRyb3AtZXZlbnQtYnVzLnNlcnZpY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUNILE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFjLE9BQU8sRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUUzQyxPQUFPLEVBQXNCLGFBQWEsRUFBRSxNQUFNLG9DQUFvQyxDQUFDOztBQUd2RixNQUFNLE9BQU8sMEJBQTBCO0lBRHZDO1FBRVUsY0FBUyxHQUFtQyxJQUFJLE9BQU8sRUFBeUIsQ0FBQztRQUNqRixhQUFRLEdBQW1DLElBQUksT0FBTyxFQUF5QixDQUFDO1FBQ2hGLFlBQU8sR0FBbUMsSUFBSSxPQUFPLEVBQXlCLENBQUM7UUFDL0UsU0FBSSxHQUFtQyxJQUFJLE9BQU8sRUFBeUIsQ0FBQztLQW9DckY7SUFsQ0MsSUFBSSxXQUFXO1FBQ2IsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLFlBQVksRUFBRSxDQUFDO0lBQ3ZDLENBQUM7SUFFRCxJQUFJLFNBQVM7UUFDWCxPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsWUFBWSxFQUFFLENBQUM7SUFDdEMsQ0FBQztJQUVELElBQUksU0FBUztRQUNYLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxZQUFZLEVBQUUsQ0FBQztJQUNyQyxDQUFDO0lBRUQsSUFBSSxPQUFPO1FBQ1QsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO0lBQ2xDLENBQUM7SUFFRCxTQUFTLENBQUMsS0FBNEI7UUFDcEMsUUFBUSxLQUFLLENBQUMsSUFBSSxFQUFFO1lBQ2xCLEtBQUssYUFBYSxDQUFDLFVBQVU7Z0JBQzNCLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO2dCQUMzQixNQUFNO1lBQ1IsS0FBSyxhQUFhLENBQUMsU0FBUztnQkFDMUIsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUM7Z0JBQzFCLE1BQU07WUFDUixLQUFLLGFBQWEsQ0FBQyxRQUFRO2dCQUN6QixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztnQkFDekIsTUFBTTtZQUNSLEtBQUssYUFBYSxDQUFDLElBQUk7Z0JBQ3JCLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO2dCQUN0QixNQUFNO1lBQ1I7Z0JBQ0UsTUFBTTtTQUNUO0lBQ0gsQ0FBQzs7OztZQXhDRixVQUFVLFNBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAoYykgMjAxNi0yMDIxIFZNd2FyZSwgSW5jLiBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICogVGhpcyBzb2Z0d2FyZSBpcyByZWxlYXNlZCB1bmRlciBNSVQgbGljZW5zZS5cbiAqIFRoZSBmdWxsIGxpY2Vuc2UgaW5mb3JtYXRpb24gY2FuIGJlIGZvdW5kIGluIExJQ0VOU0UgaW4gdGhlIHJvb3QgZGlyZWN0b3J5IG9mIHRoaXMgcHJvamVjdC5cbiAqL1xuaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgT2JzZXJ2YWJsZSwgU3ViamVjdCB9IGZyb20gJ3J4anMnO1xuXG5pbXBvcnQgeyBEcmFnRXZlbnRJbnRlcmZhY2UsIERyYWdFdmVudFR5cGUgfSBmcm9tICcuLi9pbnRlcmZhY2VzL2RyYWctZXZlbnQuaW50ZXJmYWNlJztcblxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcbmV4cG9ydCBjbGFzcyBEcmFnQW5kRHJvcEV2ZW50QnVzU2VydmljZTxUPiB7XG4gIHByaXZhdGUgZHJhZ1N0YXJ0OiBTdWJqZWN0PERyYWdFdmVudEludGVyZmFjZTxUPj4gPSBuZXcgU3ViamVjdDxEcmFnRXZlbnRJbnRlcmZhY2U8VD4+KCk7XG4gIHByaXZhdGUgZHJhZ01vdmU6IFN1YmplY3Q8RHJhZ0V2ZW50SW50ZXJmYWNlPFQ+PiA9IG5ldyBTdWJqZWN0PERyYWdFdmVudEludGVyZmFjZTxUPj4oKTtcbiAgcHJpdmF0ZSBkcmFnRW5kOiBTdWJqZWN0PERyYWdFdmVudEludGVyZmFjZTxUPj4gPSBuZXcgU3ViamVjdDxEcmFnRXZlbnRJbnRlcmZhY2U8VD4+KCk7XG4gIHByaXZhdGUgZHJvcDogU3ViamVjdDxEcmFnRXZlbnRJbnRlcmZhY2U8VD4+ID0gbmV3IFN1YmplY3Q8RHJhZ0V2ZW50SW50ZXJmYWNlPFQ+PigpO1xuXG4gIGdldCBkcmFnU3RhcnRlZCgpOiBPYnNlcnZhYmxlPERyYWdFdmVudEludGVyZmFjZTxUPj4ge1xuICAgIHJldHVybiB0aGlzLmRyYWdTdGFydC5hc09ic2VydmFibGUoKTtcbiAgfVxuXG4gIGdldCBkcmFnTW92ZWQoKTogT2JzZXJ2YWJsZTxEcmFnRXZlbnRJbnRlcmZhY2U8VD4+IHtcbiAgICByZXR1cm4gdGhpcy5kcmFnTW92ZS5hc09ic2VydmFibGUoKTtcbiAgfVxuXG4gIGdldCBkcmFnRW5kZWQoKTogT2JzZXJ2YWJsZTxEcmFnRXZlbnRJbnRlcmZhY2U8VD4+IHtcbiAgICByZXR1cm4gdGhpcy5kcmFnRW5kLmFzT2JzZXJ2YWJsZSgpO1xuICB9XG5cbiAgZ2V0IGRyb3BwZWQoKTogT2JzZXJ2YWJsZTxEcmFnRXZlbnRJbnRlcmZhY2U8VD4+IHtcbiAgICByZXR1cm4gdGhpcy5kcm9wLmFzT2JzZXJ2YWJsZSgpO1xuICB9XG5cbiAgYnJvYWRjYXN0KGV2ZW50OiBEcmFnRXZlbnRJbnRlcmZhY2U8VD4pOiB2b2lkIHtcbiAgICBzd2l0Y2ggKGV2ZW50LnR5cGUpIHtcbiAgICAgIGNhc2UgRHJhZ0V2ZW50VHlwZS5EUkFHX1NUQVJUOlxuICAgICAgICB0aGlzLmRyYWdTdGFydC5uZXh0KGV2ZW50KTtcbiAgICAgICAgYnJlYWs7XG4gICAgICBjYXNlIERyYWdFdmVudFR5cGUuRFJBR19NT1ZFOlxuICAgICAgICB0aGlzLmRyYWdNb3ZlLm5leHQoZXZlbnQpO1xuICAgICAgICBicmVhaztcbiAgICAgIGNhc2UgRHJhZ0V2ZW50VHlwZS5EUkFHX0VORDpcbiAgICAgICAgdGhpcy5kcmFnRW5kLm5leHQoZXZlbnQpO1xuICAgICAgICBicmVhaztcbiAgICAgIGNhc2UgRHJhZ0V2ZW50VHlwZS5EUk9QOlxuICAgICAgICB0aGlzLmRyb3AubmV4dChldmVudCk7XG4gICAgICAgIGJyZWFrO1xuICAgICAgZGVmYXVsdDpcbiAgICAgICAgYnJlYWs7XG4gICAgfVxuICB9XG59XG4iXX0=
+DragAndDropEventBusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DragAndDropEventBusService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DragAndDropEventBusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DragAndDropEventBusService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DragAndDropEventBusService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/drag-and-drop/providers/drag-event-listener.service.mjs

@@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { DragEventType } from '../interfaces/drag-event.interface';
+import * as i0 from "@angular/core";
+import * as i1 from "./drag-and-drop-event-bus.service";
+export class DragEventListenerService {
+    constructor(ngZone, renderer, eventBus) {
+        this.ngZone = ngZone;
+        this.renderer = renderer;
+        this.eventBus = eventBus;
+        // contains listeners for the starting events such as mousedown and touchstart
+        this.listeners = [];
+        this.dragStart = new Subject();
+        this.dragMove = new Subject();
+        this.dragEnd = new Subject();
+        this.hasDragStarted = false;
+        this.dragStartDelay = 0;
+    }
+    get dragStarted() {
+        return this.dragStart.asObservable();
+    }
+    get dragMoved() {
+        return this.dragMove.asObservable();
+    }
+    get dragEnded() {
+        return this.dragEnd.asObservable();
+    }
+    get dragStartPosition() {
+        return this.initialPosition;
+    }
+    attachDragListeners(draggableEl) {
+        this.draggableEl = draggableEl;
+        this.listeners.push(this.customDragEvent(this.draggableEl, 'mousedown', 'mousemove', 'mouseup'));
+        this.listeners.push(this.customDragEvent(this.draggableEl, 'touchstart', 'touchmove', 'touchend'));
+    }
+    detachDragListeners() {
+        if (this.listeners) {
+            this.listeners.map(event => event());
+        }
+        // In most cases, once users start dragging with mousedown/touchstart events,
+        // they will end dragging at one point with mouseup/touchend.
+        // However, there might be a few cases where mousedown/touchstart events get registered,
+        // but the draggable element gets removed before user ends dragging.
+        // In that case, we need to remove the attached listeners that happened during the mousedown/touchstart events.
+        if (this.nestedListeners) {
+            this.nestedListeners.map(event => event());
+        }
+        if (this.checkDragStartBoundaryListener) {
+            this.checkDragStartBoundaryListener();
+        }
+    }
+    getNativeEventObject(event) {
+        if (event.hasOwnProperty('changedTouches')) {
+            return event.changedTouches[0];
+        }
+        else {
+            return event;
+        }
+    }
+    customDragEvent(element, startOnEvent, moveOnEvent, endOnEvent) {
+        return this.renderer.listen(element, startOnEvent, (startEvent) => {
+            // save the initial point to initialPosition
+            // this will be used to calculate how far the draggable has been dragged from its initial position
+            this.initialPosition = {
+                pageX: this.getNativeEventObject(startEvent).pageX,
+                pageY: this.getNativeEventObject(startEvent).pageY,
+            };
+            // Initialize nested listeners' property with a new empty array;
+            this.nestedListeners = [];
+            // This is needed to disable selection during dragging (especially in EDGE/IE11).
+            this.nestedListeners.push(this.renderer.listen('document', 'selectstart', (selectEvent) => {
+                selectEvent.preventDefault();
+                selectEvent.stopImmediatePropagation();
+            }));
+            // Listen to mousemove/touchmove events outside of angular zone.
+            this.ngZone.runOutsideAngular(() => {
+                // During the drag start delay, pointer should stay within the boundary.
+                this.checkDragStartBoundary(moveOnEvent);
+                this.dragStartDelayTimeout = setTimeout(() => {
+                    if (this.checkDragStartBoundaryListener) {
+                        this.checkDragStartBoundaryListener();
+                    }
+                    this.hasDragStarted = true;
+                    // Fire "dragstart"
+                    this.broadcast(startEvent, DragEventType.DRAG_START);
+                    this.nestedListeners.push(this.renderer.listen('document', moveOnEvent, (moveEvent) => {
+                        // Event.stopImmediatePropagation() is needed here to prevent nested draggables from getting dragged
+                        // altogether. We shouldn't use Event.stopPropagation() here as we are listening to the events
+                        // on the global element level.
+                        // With Event.stopImmediatePropagation(), it registers the events sent from the inner most draggable
+                        // first. Then immediately after that, it stops listening to the same type of events on the same
+                        // element. So this will help us to not register the same events that would come from the parent
+                        // level draggables eventually.
+                        moveEvent.stopImmediatePropagation();
+                        if (this.hasDragStarted) {
+                            // Fire "dragmove"
+                            this.broadcast(moveEvent, DragEventType.DRAG_MOVE);
+                        }
+                    }));
+                }, this.dragStartDelay);
+            });
+            // Listen to mouseup/touchend events.
+            this.nestedListeners.push(this.renderer.listen('document', endOnEvent, (endEvent) => {
+                if (this.hasDragStarted) {
+                    // Fire "dragend" only if dragstart is registered
+                    this.hasDragStarted = false;
+                    this.broadcast(endEvent, DragEventType.DRAG_END);
+                }
+                clearTimeout(this.dragStartDelayTimeout);
+                // We must remove the the nested listeners every time drag completes.
+                this.nestedListeners.map(event => event());
+                // We must remove the event listener from checkDragStartBoundary
+                if (this.checkDragStartBoundaryListener) {
+                    this.checkDragStartBoundaryListener();
+                }
+            }));
+        });
+    }
+    checkDragStartBoundary(eventType) {
+        this.checkDragStartBoundaryListener = this.renderer.listen('document', eventType, (moveEvent) => {
+            const deltaX = Math.abs(this.getNativeEventObject(moveEvent).pageX - this.initialPosition.pageX);
+            const deltaY = Math.abs(this.getNativeEventObject(moveEvent).pageY - this.initialPosition.pageY);
+            // If pointer move delta exceeds horizontal or vertical threshold,
+            // we should cancel drag initiation.
+            if (deltaX > 1 || deltaY > 1) {
+                clearTimeout(this.dragStartDelayTimeout);
+                if (this.checkDragStartBoundaryListener) {
+                    this.checkDragStartBoundaryListener();
+                }
+            }
+        });
+    }
+    broadcast(event, eventType) {
+        const dragEvent = this.generateDragEvent(event, eventType);
+        switch (dragEvent.type) {
+            case DragEventType.DRAG_START:
+                this.dragStart.next(dragEvent);
+                break;
+            case DragEventType.DRAG_MOVE:
+                this.dragMove.next(dragEvent);
+                break;
+            case DragEventType.DRAG_END:
+                this.dragEnd.next(dragEvent);
+                break;
+            default:
+                break;
+        }
+        // The following properties are set after they are broadcasted to the DraggableGhost component.
+        dragEvent.ghostElement = this.ghostElement;
+        dragEvent.dropPointPosition = this.dropPointPosition;
+        this.eventBus.broadcast(dragEvent);
+    }
+    generateDragEvent(event, eventType) {
+        const nativeEvent = this.getNativeEventObject(event);
+        return {
+            type: eventType,
+            dragPosition: {
+                pageX: nativeEvent.pageX,
+                pageY: nativeEvent.pageY,
+                moveX: nativeEvent.pageX - this.initialPosition.pageX,
+                moveY: nativeEvent.pageY - this.initialPosition.pageY,
+            },
+            group: this.group,
+            dragDataTransfer: this.dragDataTransfer,
+            ghostElement: this.ghostElement,
+        };
+    }
+}
+DragEventListenerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DragEventListenerService, deps: [{ token: i0.NgZone }, { token: i0.Renderer2 }, { token: i1.DragAndDropEventBusService }], target: i0.ɵɵFactoryTarget.Injectable });
+DragEventListenerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DragEventListenerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DragEventListenerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: i0.Renderer2 }, { type: i1.DragAndDropEventBusService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-event-listener.service.js","sourceRoot":"","sources":["../../../../../../projects/angular/src/utils/drag-and-drop/providers/drag-event-listener.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\nimport { Injectable, NgZone, Renderer2 } from '@angular/core';\nimport { Observable, Subject } from 'rxjs';\n\nimport { DragEventInterface, DragEventType, DragPointPosition } from '../interfaces/drag-event.interface';\nimport { DragAndDropEventBusService } from './drag-and-drop-event-bus.service';\n\n@Injectable()\nexport class DragEventListenerService<T> {\n  private draggableEl: any;\n\n  // contains listeners for the starting events such as mousedown and touchstart\n  private listeners: (() => void)[] = [];\n  // contains listeners for nested events that happens after/inside the starting events\n  // such as selectstart, mousemove/touchmove, mouseup/touchend\n  private nestedListeners: (() => void)[];\n\n  // contains listener for mousemove/touchmove before delay\n  private checkDragStartBoundaryListener: () => void;\n\n  private dragStart: Subject<DragEventInterface<T>> = new Subject<DragEventInterface<T>>();\n  private dragMove: Subject<DragEventInterface<T>> = new Subject<DragEventInterface<T>>();\n  private dragEnd: Subject<DragEventInterface<T>> = new Subject<DragEventInterface<T>>();\n\n  private hasDragStarted = false;\n\n  private dragStartDelayTimeout: ReturnType<typeof setTimeout>;\n\n  get dragStarted(): Observable<DragEventInterface<T>> {\n    return this.dragStart.asObservable();\n  }\n\n  get dragMoved(): Observable<DragEventInterface<T>> {\n    return this.dragMove.asObservable();\n  }\n\n  get dragEnded(): Observable<DragEventInterface<T>> {\n    return this.dragEnd.asObservable();\n  }\n\n  get dragStartPosition(): DragPointPosition {\n    return this.initialPosition;\n  }\n\n  constructor(private ngZone: NgZone, private renderer: Renderer2, private eventBus: DragAndDropEventBusService<T>) {}\n\n  private initialPosition: DragPointPosition;\n\n  // Draggable component sets these properties:\n  public dragDataTransfer?: T;\n  public group?: string | string[];\n  public dragStartDelay = 0;\n\n  // DraggableGhost component sets these properties:\n  public ghostElement?: any;\n  public dropPointPosition?: DragPointPosition;\n\n  public attachDragListeners(draggableEl: Node) {\n    this.draggableEl = draggableEl;\n    this.listeners.push(this.customDragEvent(this.draggableEl, 'mousedown', 'mousemove', 'mouseup'));\n    this.listeners.push(this.customDragEvent(this.draggableEl, 'touchstart', 'touchmove', 'touchend'));\n  }\n\n  public detachDragListeners() {\n    if (this.listeners) {\n      this.listeners.map(event => event());\n    }\n\n    // In most cases, once users start dragging with mousedown/touchstart events,\n    // they will end dragging at one point with mouseup/touchend.\n    // However, there might be a few cases where mousedown/touchstart events get registered,\n    // but the draggable element gets removed before user ends dragging.\n    // In that case, we need to remove the attached listeners that happened during the mousedown/touchstart events.\n    if (this.nestedListeners) {\n      this.nestedListeners.map(event => event());\n    }\n\n    if (this.checkDragStartBoundaryListener) {\n      this.checkDragStartBoundaryListener();\n    }\n  }\n\n  private getNativeEventObject(event: MouseEvent | TouchEvent): any {\n    if ((event as TouchEvent).hasOwnProperty('changedTouches')) {\n      return (event as TouchEvent).changedTouches[0];\n    } else {\n      return event;\n    }\n  }\n\n  private customDragEvent(element: Node, startOnEvent: string, moveOnEvent: string, endOnEvent: string): () => void {\n    return this.renderer.listen(element, startOnEvent, (startEvent: MouseEvent | TouchEvent) => {\n      // save the initial point to initialPosition\n      // this will be used to calculate how far the draggable has been dragged from its initial position\n      this.initialPosition = {\n        pageX: this.getNativeEventObject(startEvent).pageX,\n        pageY: this.getNativeEventObject(startEvent).pageY,\n      };\n\n      // Initialize nested listeners' property with a new empty array;\n      this.nestedListeners = [];\n\n      // This is needed to disable selection during dragging (especially in EDGE/IE11).\n      this.nestedListeners.push(\n        this.renderer.listen('document', 'selectstart', (selectEvent: Event) => {\n          selectEvent.preventDefault();\n          selectEvent.stopImmediatePropagation();\n        })\n      );\n\n      // Listen to mousemove/touchmove events outside of angular zone.\n      this.ngZone.runOutsideAngular(() => {\n        // During the drag start delay, pointer should stay within the boundary.\n        this.checkDragStartBoundary(moveOnEvent);\n\n        this.dragStartDelayTimeout = setTimeout(() => {\n          if (this.checkDragStartBoundaryListener) {\n            this.checkDragStartBoundaryListener();\n          }\n\n          this.hasDragStarted = true;\n          // Fire \"dragstart\"\n          this.broadcast(startEvent, DragEventType.DRAG_START);\n\n          this.nestedListeners.push(\n            this.renderer.listen('document', moveOnEvent, (moveEvent: MouseEvent | TouchEvent) => {\n              // Event.stopImmediatePropagation() is needed here to prevent nested draggables from getting dragged\n              // altogether. We shouldn't use Event.stopPropagation() here as we are listening to the events\n              // on the global element level.\n\n              // With Event.stopImmediatePropagation(), it registers the events sent from the inner most draggable\n              // first. Then immediately after that, it stops listening to the same type of events on the same\n              // element. So this will help us to not register the same events that would come from the parent\n              // level draggables eventually.\n\n              moveEvent.stopImmediatePropagation();\n\n              if (this.hasDragStarted) {\n                // Fire \"dragmove\"\n                this.broadcast(moveEvent, DragEventType.DRAG_MOVE);\n              }\n            })\n          );\n        }, this.dragStartDelay);\n      });\n\n      // Listen to mouseup/touchend events.\n      this.nestedListeners.push(\n        this.renderer.listen('document', endOnEvent, (endEvent: MouseEvent | TouchEvent) => {\n          if (this.hasDragStarted) {\n            // Fire \"dragend\" only if dragstart is registered\n            this.hasDragStarted = false;\n            this.broadcast(endEvent, DragEventType.DRAG_END);\n          }\n\n          clearTimeout(this.dragStartDelayTimeout);\n\n          // We must remove the the nested listeners every time drag completes.\n          this.nestedListeners.map(event => event());\n\n          // We must remove the event listener from checkDragStartBoundary\n          if (this.checkDragStartBoundaryListener) {\n            this.checkDragStartBoundaryListener();\n          }\n        })\n      );\n    });\n  }\n\n  private checkDragStartBoundary(eventType: string): void {\n    this.checkDragStartBoundaryListener = this.renderer.listen(\n      'document',\n      eventType,\n      (moveEvent: MouseEvent | TouchEvent) => {\n        const deltaX = Math.abs(this.getNativeEventObject(moveEvent).pageX - this.initialPosition.pageX);\n        const deltaY = Math.abs(this.getNativeEventObject(moveEvent).pageY - this.initialPosition.pageY);\n\n        // If pointer move delta exceeds horizontal or vertical threshold,\n        // we should cancel drag initiation.\n        if (deltaX > 1 || deltaY > 1) {\n          clearTimeout(this.dragStartDelayTimeout);\n          if (this.checkDragStartBoundaryListener) {\n            this.checkDragStartBoundaryListener();\n          }\n        }\n      }\n    );\n  }\n\n  private broadcast(event: MouseEvent | TouchEvent, eventType: DragEventType): void {\n    const dragEvent: DragEventInterface<T> = this.generateDragEvent(event, eventType);\n\n    switch (dragEvent.type) {\n      case DragEventType.DRAG_START:\n        this.dragStart.next(dragEvent);\n        break;\n      case DragEventType.DRAG_MOVE:\n        this.dragMove.next(dragEvent);\n        break;\n      case DragEventType.DRAG_END:\n        this.dragEnd.next(dragEvent);\n        break;\n      default:\n        break;\n    }\n\n    // The following properties are set after they are broadcasted to the DraggableGhost component.\n    dragEvent.ghostElement = this.ghostElement;\n    dragEvent.dropPointPosition = this.dropPointPosition;\n\n    this.eventBus.broadcast(dragEvent);\n  }\n\n  private generateDragEvent(event: MouseEvent | TouchEvent, eventType: DragEventType): DragEventInterface<T> {\n    const nativeEvent: any = this.getNativeEventObject(event);\n\n    return {\n      type: eventType,\n      dragPosition: {\n        pageX: nativeEvent.pageX,\n        pageY: nativeEvent.pageY,\n        moveX: nativeEvent.pageX - this.initialPosition.pageX,\n        moveY: nativeEvent.pageY - this.initialPosition.pageY,\n      },\n      group: this.group,\n      dragDataTransfer: this.dragDataTransfer,\n      ghostElement: this.ghostElement,\n    };\n  }\n}\n"]}

package/esm2020/utils/drag-and-drop/providers/drag-handle-registrar.service.mjs

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./drag-event-listener.service";
+// This provider registers the drag handle element.
+// When it registers a element as a drag handle, it attaches that element to the listeners from ClrDragEventListener.
+// Also, it adds the "drag-handle" css class to the registered element through Renderer.
+export class DragHandleRegistrarService {
+    constructor(dragEventListener, renderer) {
+        this.dragEventListener = dragEventListener;
+        this.renderer = renderer;
+    }
+    get defaultHandleEl() {
+        return this._defaultHandleEl;
+    }
+    set defaultHandleEl(el) {
+        this._defaultHandleEl = el; // defaultHandleEl will be usually the clrDraggable element.
+        // If the customHandleEl has been registered,
+        // don't make the defaultHandleEl the drag handle yet until the customHandleEl is unregistered.
+        if (!this._customHandleEl) {
+            this.makeElementHandle(this._defaultHandleEl);
+        }
+    }
+    makeElementHandle(el) {
+        if (this._defaultHandleEl && this._defaultHandleEl !== el) {
+            // Before making an element the custom handle element,
+            // we should remove the existing drag-handle class from the draggable element.
+            this.renderer.removeClass(this._defaultHandleEl, 'drag-handle');
+        }
+        this.dragEventListener.attachDragListeners(el);
+        this.renderer.addClass(el, 'drag-handle');
+    }
+    get customHandleEl() {
+        return this._customHandleEl;
+    }
+    registerCustomHandle(el) {
+        this.dragEventListener.detachDragListeners(); // removes the existing listeners
+        this._customHandleEl = el;
+        this.makeElementHandle(this._customHandleEl);
+    }
+    unregisterCustomHandle() {
+        this.dragEventListener.detachDragListeners(); // removes the existing listeners
+        this.renderer.removeClass(this._customHandleEl, 'drag-handle');
+        delete this._customHandleEl;
+        // if default handle is set, make that handle
+        if (this._defaultHandleEl) {
+            this.makeElementHandle(this._defaultHandleEl);
+        }
+    }
+}
+DragHandleRegistrarService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DragHandleRegistrarService, deps: [{ token: i1.DragEventListenerService }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Injectable });
+DragHandleRegistrarService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DragHandleRegistrarService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DragHandleRegistrarService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DragEventListenerService }, { type: i0.Renderer2 }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/drag-and-drop/providers/draggable-snapshot.service.mjs

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../../dom-adapter/dom-adapter";
+// This service is used to capture the state of clrDraggable element
+// at a certain event and passes it to clrDraggableGhost component.
+export class DraggableSnapshotService {
+    constructor(domAdapter) {
+        this.domAdapter = domAdapter;
+    }
+    capture(el, event) {
+        this.draggableElClientRect = this.domAdapter.clientRect(el);
+        this.snapshotDragEvent = event;
+    }
+    discard() {
+        delete this.draggableElClientRect;
+        delete this.snapshotDragEvent;
+    }
+    get hasDraggableState() {
+        return !!this.snapshotDragEvent && !!this.draggableElClientRect;
+    }
+    get clientRect() {
+        return this.draggableElClientRect;
+    }
+    get dragEvent() {
+        return this.snapshotDragEvent;
+    }
+}
+DraggableSnapshotService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DraggableSnapshotService, deps: [{ token: i1.DomAdapter }], target: i0.ɵɵFactoryTarget.Injectable });
+DraggableSnapshotService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DraggableSnapshotService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DraggableSnapshotService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DomAdapter }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/drag-and-drop/providers/global-drag-mode.service.mjs

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+// This service class adds and removes the "in-drag" class to the document body element
+// through its public enter() and exit() methods.
+export class GlobalDragModeService {
+    constructor(renderer) {
+        this.renderer = renderer;
+    }
+    enter() {
+        this.renderer.addClass(document.body, 'in-drag');
+    }
+    exit() {
+        this.renderer.removeClass(document.body, 'in-drag');
+    }
+}
+GlobalDragModeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: GlobalDragModeService, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Injectable });
+GlobalDragModeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: GlobalDragModeService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: GlobalDragModeService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2xvYmFsLWRyYWctbW9kZS5zZXJ2aWNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci9zcmMvdXRpbHMvZHJhZy1hbmQtZHJvcC9wcm92aWRlcnMvZ2xvYmFsLWRyYWctbW9kZS5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxPQUFPLEVBQUUsVUFBVSxFQUFhLE1BQU0sZUFBZSxDQUFDOztBQUV0RCx1RkFBdUY7QUFDdkYsaURBQWlEO0FBRWpELE1BQU0sT0FBTyxxQkFBcUI7SUFDaEMsWUFBb0IsUUFBbUI7UUFBbkIsYUFBUSxHQUFSLFFBQVEsQ0FBVztJQUFHLENBQUM7SUFFM0MsS0FBSztRQUNILElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxJQUFJLEVBQUUsU0FBUyxDQUFDLENBQUM7SUFDbkQsQ0FBQztJQUVELElBQUk7UUFDRixJQUFJLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQ3RELENBQUM7O2tIQVRVLHFCQUFxQjtzSEFBckIscUJBQXFCOzJGQUFyQixxQkFBcUI7a0JBRGpDLFVBQVUiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSAyMDE2LTIwMjEgVk13YXJlLCBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKiBUaGlzIHNvZnR3YXJlIGlzIHJlbGVhc2VkIHVuZGVyIE1JVCBsaWNlbnNlLlxuICogVGhlIGZ1bGwgbGljZW5zZSBpbmZvcm1hdGlvbiBjYW4gYmUgZm91bmQgaW4gTElDRU5TRSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBwcm9qZWN0LlxuICovXG5pbXBvcnQgeyBJbmplY3RhYmxlLCBSZW5kZXJlcjIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuLy8gVGhpcyBzZXJ2aWNlIGNsYXNzIGFkZHMgYW5kIHJlbW92ZXMgdGhlIFwiaW4tZHJhZ1wiIGNsYXNzIHRvIHRoZSBkb2N1bWVudCBib2R5IGVsZW1lbnRcbi8vIHRocm91Z2ggaXRzIHB1YmxpYyBlbnRlcigpIGFuZCBleGl0KCkgbWV0aG9kcy5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBHbG9iYWxEcmFnTW9kZVNlcnZpY2Uge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlbmRlcmVyOiBSZW5kZXJlcjIpIHt9XG5cbiAgZW50ZXIoKTogdm9pZCB7XG4gICAgdGhpcy5yZW5kZXJlci5hZGRDbGFzcyhkb2N1bWVudC5ib2R5LCAnaW4tZHJhZycpO1xuICB9XG5cbiAgZXhpdCgpOiB2b2lkIHtcbiAgICB0aGlzLnJlbmRlcmVyLnJlbW92ZUNsYXNzKGRvY3VtZW50LmJvZHksICdpbi1kcmFnJyk7XG4gIH1cbn1cbiJdfQ==

package/esm2020/utils/focus/focus-on-view-init/focus-on-view-init.mjs

@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { DOCUMENT, isPlatformBrowser } from '@angular/common';
+import { Directive, HostListener, Inject, Input, PLATFORM_ID, } from '@angular/core';
+import { FOCUS_ON_VIEW_INIT } from './focus-on-view-init.provider';
+import * as i0 from "@angular/core";
+/*  This directive is for guiding the document focus to the newly added content when its view is initialized
+    so that assistive technologies can read its content. */
+export class ClrFocusOnViewInit {
+    constructor(el, platformId, focusOnViewInit, document, renderer) {
+        this.el = el;
+        this.platformId = platformId;
+        this.focusOnViewInit = focusOnViewInit;
+        this.renderer = renderer;
+        this.directFocus = true; // true if the element gets focused without need to set tabindex;
+        this._isEnabled = this.focusOnViewInit;
+        // Angular compiler doesn't understand the type Document
+        // when working out the metadata for injectable parameters,
+        // even though it understands the injection token DOCUMENT
+        // https://github.com/angular/angular/issues/20351
+        this.document = document;
+    }
+    onFocusout() {
+        if (!this.directFocus) {
+            // manually set attributes and styles should be removed
+            this.renderer.removeAttribute(this.el.nativeElement, 'tabindex');
+            this.renderer.setStyle(this.el.nativeElement, 'outline', null);
+        }
+    }
+    set isEnabled(value) {
+        if (this.focusOnViewInit && typeof value === 'boolean') {
+            this._isEnabled = value;
+        }
+    }
+    ngAfterViewInit() {
+        this.focus();
+    }
+    focus() {
+        if (!isPlatformBrowser(this.platformId)) {
+            return;
+        }
+        if (!this._isEnabled) {
+            return;
+        }
+        if (this.document && this.document.activeElement !== this.el.nativeElement) {
+            this.el.nativeElement.focus();
+            if (this.document.activeElement !== this.el.nativeElement) {
+                // if it's not directly focused now, it means it was a non-interactive element
+                // so we need to give it a tabindex.
+                this.directFocus = false;
+                this.renderer.setAttribute(this.el.nativeElement, 'tabindex', '-1');
+                this.renderer.setStyle(this.el.nativeElement, 'outline', 'none');
+                this.el.nativeElement.focus();
+            }
+        }
+    }
+}
+ClrFocusOnViewInit.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrFocusOnViewInit, deps: [{ token: i0.ElementRef }, { token: PLATFORM_ID }, { token: FOCUS_ON_VIEW_INIT }, { token: DOCUMENT }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+ClrFocusOnViewInit.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrFocusOnViewInit, selector: "[clrFocusOnViewInit]", inputs: { isEnabled: ["clrFocusOnViewInit", "isEnabled"] }, host: { listeners: { "focusout": "onFocusout()" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrFocusOnViewInit, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrFocusOnViewInit]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [FOCUS_ON_VIEW_INIT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.Renderer2 }]; }, propDecorators: { onFocusout: [{
+                type: HostListener,
+                args: ['focusout']
+            }], isEnabled: [{
+                type: Input,
+                args: ['clrFocusOnViewInit']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/utils/focus/focus-on-view-init/focus-on-view-init.module.mjs

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ClrFocusOnViewInit } from './focus-on-view-init';
+import { FOCUS_ON_VIEW_INIT_PROVIDER } from './focus-on-view-init.provider';
+import * as i0 from "@angular/core";
+export const FOCUS_ON_VIEW_INIT_DIRECTIVES = [ClrFocusOnViewInit];
+export class ClrFocusOnViewInitModule {
+}
+ClrFocusOnViewInitModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrFocusOnViewInitModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ClrFocusOnViewInitModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrFocusOnViewInitModule, declarations: [ClrFocusOnViewInit], imports: [CommonModule], exports: [ClrFocusOnViewInit] });
+ClrFocusOnViewInitModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrFocusOnViewInitModule, providers: [FOCUS_ON_VIEW_INIT_PROVIDER], imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrFocusOnViewInitModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: [FOCUS_ON_VIEW_INIT_DIRECTIVES],
+                    providers: [FOCUS_ON_VIEW_INIT_PROVIDER],
+                    exports: [FOCUS_ON_VIEW_INIT_DIRECTIVES],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZm9jdXMtb24tdmlldy1pbml0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXIvc3JjL3V0aWxzL2ZvY3VzL2ZvY3VzLW9uLXZpZXctaW5pdC9mb2N1cy1vbi12aWV3LWluaXQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFDSCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBUSxNQUFNLGVBQWUsQ0FBQztBQUMvQyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUMxRCxPQUFPLEVBQUUsMkJBQTJCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQzs7QUFFNUUsTUFBTSxDQUFDLE1BQU0sNkJBQTZCLEdBQWdCLENBQUMsa0JBQWtCLENBQUMsQ0FBQztBQVEvRSxNQUFNLE9BQU8sd0JBQXdCOztxSEFBeEIsd0JBQXdCO3NIQUF4Qix3QkFBd0IsaUJBUnNCLGtCQUFrQixhQUdqRSxZQUFZLGFBSG1DLGtCQUFrQjtzSEFRaEUsd0JBQXdCLGFBSHhCLENBQUMsMkJBQTJCLENBQUMsWUFGL0IsQ0FBQyxZQUFZLENBQUM7MkZBS1osd0JBQXdCO2tCQU5wQyxRQUFRO21CQUFDO29CQUNSLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsWUFBWSxFQUFFLENBQUMsNkJBQTZCLENBQUM7b0JBQzdDLFNBQVMsRUFBRSxDQUFDLDJCQUEyQixDQUFDO29CQUN4QyxPQUFPLEVBQUUsQ0FBQyw2QkFBNkIsQ0FBQztpQkFDekMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IChjKSAyMDE2LTIwMjEgVk13YXJlLCBJbmMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKiBUaGlzIHNvZnR3YXJlIGlzIHJlbGVhc2VkIHVuZGVyIE1JVCBsaWNlbnNlLlxuICogVGhlIGZ1bGwgbGljZW5zZSBpbmZvcm1hdGlvbiBjYW4gYmUgZm91bmQgaW4gTElDRU5TRSBpbiB0aGUgcm9vdCBkaXJlY3Rvcnkgb2YgdGhpcyBwcm9qZWN0LlxuICovXG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUsIFR5cGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENsckZvY3VzT25WaWV3SW5pdCB9IGZyb20gJy4vZm9jdXMtb24tdmlldy1pbml0JztcbmltcG9ydCB7IEZPQ1VTX09OX1ZJRVdfSU5JVF9QUk9WSURFUiB9IGZyb20gJy4vZm9jdXMtb24tdmlldy1pbml0LnByb3ZpZGVyJztcblxuZXhwb3J0IGNvbnN0IEZPQ1VTX09OX1ZJRVdfSU5JVF9ESVJFQ1RJVkVTOiBUeXBlPGFueT5bXSA9IFtDbHJGb2N1c09uVmlld0luaXRdO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlXSxcbiAgZGVjbGFyYXRpb25zOiBbRk9DVVNfT05fVklFV19JTklUX0RJUkVDVElWRVNdLFxuICBwcm92aWRlcnM6IFtGT0NVU19PTl9WSUVXX0lOSVRfUFJPVklERVJdLFxuICBleHBvcnRzOiBbRk9DVVNfT05fVklFV19JTklUX0RJUkVDVElWRVNdLFxufSlcbmV4cG9ydCBjbGFzcyBDbHJGb2N1c09uVmlld0luaXRNb2R1bGUge31cbiJdfQ==