/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { coerceBooleanProperty } from '@angular/cdk/coercion';
import { Subscription, Subject, Observable } from 'rxjs';
import { extendStyles, toggleNativeDragInteractions } from './drag-styling';
import { getTransformTransitionDurationInMs } from './transition-duration';
import { normalizePassiveListenerOptions } from './utils/passive-listeners';
import { coerceElement } from './utils/element';
/**
 * @ignore
 * Object that can be used to configure the behavior of DragRef.
 * @record
 */
export function DragRefConfig() { }
if (false) {
    /**
     * Minimum amount of pixels that the user should
     * drag, before the CDK initiates a drag sequence.
     * @type {?}
     */
    DragRefConfig.prototype.dragStartThreshold;
    /**
     * Amount the pixels the user should drag before the CDK
     * considers them to have changed the drag direction.
     * @type {?}
     */
    DragRefConfig.prototype.pointerDirectionChangeThreshold;
}
/**
 * Options that can be used to bind a passive event listener.
 * @type {?}
 */
const passiveEventListenerOptions = normalizePassiveListenerOptions({ passive: true });
/**
 * Options that can be used to bind an active event listener.
 * @type {?}
 */
const activeEventListenerOptions = normalizePassiveListenerOptions({ passive: false });
/**
 * Time in milliseconds for which to ignore mouse events, after
 * receiving a touch event. Used to avoid doing double work for
 * touch devices where the browser fires fake mouse events, in
 * addition to touch events.
 * @type {?}
 */
const MOUSE_EVENT_IGNORE_TIME = 800;
/**
 * @ignore
 * Internal compile-time-only representation of a `DragRef`.
 * Used to avoid circular import issues between the `DragRef` and the `DropListRef`.
 * \@docs-private
 * @record
 */
export function DragRefInternal() { }
/**
 * @ignore
 * Template that can be used to create a drag helper element (e.g. a preview or a placeholder).
 * @record
 * @template T
 */
function DragHelperTemplate() { }
if (false) {
    /** @type {?} */
    DragHelperTemplate.prototype.template;
    /** @type {?} */
    DragHelperTemplate.prototype.viewContainer;
    /** @type {?} */
    DragHelperTemplate.prototype.context;
}
/**
 * @ignore
 * Reference to a draggable item. Used to manipulate or dispose of the item.
 * \@docs-private
 * @template T
 */
export class DragRef {
    /**
     * @param {?} element
     * @param {?} _config
     * @param {?} _document
     * @param {?} _ngZone
     * @param {?} _viewportRuler
     * @param {?} _dragDropRegistry
     */
    constructor(element, _config, _document, _ngZone, _viewportRuler, _dragDropRegistry) {
        this._config = _config;
        this._document = _document;
        this._ngZone = _ngZone;
        this._viewportRuler = _viewportRuler;
        this._dragDropRegistry = _dragDropRegistry;
        /**
         * CSS `transform` applied to the element when it isn't being dragged. We need a
         * passive transform in order for the dragged element to retain its new position
         * after the user has stopped dragging and because we need to know the relative
         * position in case they start dragging again. This corresponds to `element.style.transform`.
         */
        this._passiveTransform = { x: 0, y: 0 };
        /**
         * CSS `transform` that is applied to the element while it's being dragged.
         */
        this._activeTransform = { x: 0, y: 0 };
        /**
         * Emits when the item is being moved.
         */
        this._moveEvents = new Subject();
        /**
         * Amount of subscriptions to the move event. Used to avoid
         * hitting the zone if the consumer didn't subscribe to it.
         */
        this._moveEventSubscriptions = 0;
        /**
         * Subscription to pointer movement events.
         */
        this._pointerMoveSubscription = Subscription.EMPTY;
        /**
         * Subscription to the event that is dispatched when the user lifts their pointer.
         */
        this._pointerUpSubscription = Subscription.EMPTY;
        /**
         * Cached reference to the boundary element.
         */
        this._boundaryElement = null;
        /**
         * Whether the native dragging interactions have been enabled on the root element.
         */
        this._nativeInteractionsEnabled = true;
        /**
         * Elements that can be used to drag the draggable item.
         */
        this._handles = [];
        /**
         * Registered handles that are currently disabled.
         */
        this._disabledHandles = new Set();
        /**
         * Layout direction of the item.
         */
        this._direction = 'ltr';
        this._disabled = false;
        /**
         * Emits as the drag sequence is being prepared.
         */
        this.beforeStarted = new Subject();
        /**
         * Emits when the user starts dragging the item.
         */
        this.started = new Subject();
        /**
         * Emits when the user has released a drag item, before any animations have started.
         */
        this.released = new Subject();
        /**
         * Emits when the user stops dragging an item in the container.
         */
        this.ended = new Subject();
        /**
         * Emits when the user has moved the item into a new container.
         */
        this.entered = new Subject();
        /**
         * Emits when the user removes the item its container by dragging it into another container.
         */
        this.exited = new Subject();
        /**
         * Emits when the user drops the item inside a container.
         */
        this.dropped = new Subject();
        /**
         * Emits as the user is dragging the item. Use with caution,
         * because this event will fire for every pixel that the user has dragged.
         */
        this.moved = new Observable((/**
         * @param {?} observer
         * @return {?}
         */
        (observer) => {
            /** @type {?} */
            const subscription = this._moveEvents.subscribe(observer);
            this._moveEventSubscriptions++;
            return (/**
             * @return {?}
             */
            () => {
                subscription.unsubscribe();
                this._moveEventSubscriptions--;
            });
        }));
        /**
         * Handler for the `mousedown`/`touchstart` events.
         */
        this._pointerDown = (/**
         * @param {?} event
         * @return {?}
         */
        (event) => {
            this.beforeStarted.next();
            // Delegate the event based on whether it started from a handle or the element itself.
            if (this._handles.length) {
                /** @type {?} */
                const targetHandle = this._handles.find((/**
                 * @param {?} handle
                 * @return {?}
                 */
                handle => {
                    /** @type {?} */
                    const target = event.target;
                    return !!target && (target === handle || handle.contains((/** @type {?} */ (target))));
                }));
                if (targetHandle && !this._disabledHandles.has(targetHandle) && !this.disabled) {
                    this._initializeDragSequence(targetHandle, event);
                }
            }
            else if (!this.disabled) {
                this._initializeDragSequence(this._rootElement, event);
            }
        });
        /**
         * Handler that is invoked when the user moves their pointer after they've initiated a drag.
         */
        this._pointerMove = (/**
         * @param {?} event
         * @return {?}
         */
        (event) => {
            if (!this._hasStartedDragging) {
                /** @type {?} */
                const pointerPosition = this._getPointerPositionOnPage(event);
                /** @type {?} */
                const distanceX = Math.abs(pointerPosition.x - this._pickupPositionOnPage.x);
                /** @type {?} */
                const distanceY = Math.abs(pointerPosition.y - this._pickupPositionOnPage.y);
                // Only start dragging after the user has moved more than the minimum distance in either
                // direction. Note that this is preferrable over doing something like `skip(minimumDistance)`
                // in the `pointerMove` subscription, because we're not guaranteed to have one move event
                // per pixel of movement (e.g. if the user moves their pointer quickly).
                if (distanceX + distanceY >= this._config.dragStartThreshold) {
                    this._hasStartedDragging = true;
                    this._ngZone.run((/**
                     * @return {?}
                     */
                    () => this._startDragSequence(event)));
                }
                return;
            }
            // We only need the preview dimensions if we have a boundary element.
            if (this._boundaryElement) {
                // Cache the preview element rect if we haven't cached it already or if
                // we cached it too early before the element dimensions were computed.
                if (!this._previewRect || (!this._previewRect.width && !this._previewRect.height)) {
                    this._previewRect = (this._preview || this._rootElement).getBoundingClientRect();
                }
            }
            /** @type {?} */
            const constrainedPointerPosition = this._getConstrainedPointerPosition(event);
            this._hasMoved = true;
            event.preventDefault();
            this._updatePointerDirectionDelta(constrainedPointerPosition);
            if (this._dropContainer) {
                this._updateActiveDropContainer(constrainedPointerPosition);
            }
            else {
                /** @type {?} */
                const activeTransform = this._activeTransform;
                activeTransform.x =
                    constrainedPointerPosition.x - this._pickupPositionOnPage.x + this._passiveTransform.x;
                activeTransform.y =
                    constrainedPointerPosition.y - this._pickupPositionOnPage.y + this._passiveTransform.y;
                /** @type {?} */
                const transform = getTransform(activeTransform.x, activeTransform.y);
                // Preserve the previous `transform` value, if there was one. Note that we apply our own
                // transform before the user's, because things like rotation can affect which direction
                // the element will be translated towards.
                this._rootElement.style.transform = this._initialTransform ?
                    transform + ' ' + this._initialTransform : transform;
                // Apply transform as attribute if dragging and svg element to work for IE
                if (typeof SVGElement !== 'undefined' && this._rootElement instanceof SVGElement) {
                    /** @type {?} */
                    const appliedTransform = `translate(${activeTransform.x} ${activeTransform.y})`;
                    this._rootElement.setAttribute('transform', appliedTransform);
                }
            }
            // Since this event gets fired for every pixel while dragging, we only
            // want to fire it if the consumer opted into it. Also we have to
            // re-enter the zone because we run all of the events on the outside.
            if (this._moveEventSubscriptions > 0) {
                this._ngZone.run((/**
                 * @return {?}
                 */
                () => {
                    this._moveEvents.next({
                        source: this,
                        pointerPosition: constrainedPointerPosition,
                        event,
                        delta: this._pointerDirectionDelta
                    });
                }));
            }
        });
        /**
         * Handler that is invoked when the user lifts their pointer up, after initiating a drag.
         */
        this._pointerUp = (/**
         * @param {?} event
         * @return {?}
         */
        (event) => {
            // Note that here we use `isDragging` from the service, rather than from `this`.
            // The difference is that the one from the service reflects whether a dragging sequence
            // has been initiated, whereas the one on `this` includes whether the user has passed
            // the minimum dragging threshold.
            if (!this._dragDropRegistry.isDragging(this)) {
                return;
            }
            this._removeSubscriptions();
            this._dragDropRegistry.stopDragging(this);
            if (this._handles) {
                this._rootElement.style.webkitTapHighlightColor = this._rootElementTapHighlight;
            }
            if (!this._hasStartedDragging) {
                return;
            }
            this.released.next({ source: this });
            if (!this._dropContainer) {
                // Convert the active transform into a passive one. This means that next time
                // the user starts dragging the item, its position will be calculated relatively
                // to the new passive transform.
                this._passiveTransform.x = this._activeTransform.x;
                this._passiveTransform.y = this._activeTransform.y;
                this._ngZone.run((/**
                 * @return {?}
                 */
                () => this.ended.next({ source: this })));
                this._dragDropRegistry.stopDragging(this);
                return;
            }
            this._animatePreviewToPlaceholder().then((/**
             * @return {?}
             */
            () => {
                this._cleanupDragArtifacts(event);
                this._dragDropRegistry.stopDragging(this);
            }));
        });
        this.withRootElement(element);
        _dragDropRegistry.registerDragItem(this);
    }
    /**
     * Whether starting to drag this element is disabled.
     * @return {?}
     */
    get disabled() {
        return this._disabled || !!(this._dropContainer && this._dropContainer.disabled);
    }
    /**
     * @param {?} value
     * @return {?}
     */
    set disabled(value) {
        /** @type {?} */
        const newValue = coerceBooleanProperty(value);
        if (newValue !== this._disabled) {
            this._disabled = newValue;
            this._toggleNativeDragInteractions();
        }
    }
    /**
     * Returns the element that is being used as a placeholder
     * while the current element is being dragged.
     * @return {?}
     */
    getPlaceholderElement() {
        return this._placeholder;
    }
    /**
     * Returns the root draggable element.
     * @return {?}
     */
    getRootElement() {
        return this._rootElement;
    }
    /**
     * Registers the handles that can be used to drag the element.
     * @template THIS
     * @this {THIS}
     * @param {?} handles
     * @return {THIS}
     */
    withHandles(handles) {
        (/** @type {?} */ (this))._handles = handles.map((/**
         * @param {?} handle
         * @return {?}
         */
        handle => coerceElement(handle)));
        (/** @type {?} */ (this))._handles.forEach((/**
         * @param {?} handle
         * @return {?}
         */
        handle => toggleNativeDragInteractions(handle, false)));
        (/** @type {?} */ (this))._toggleNativeDragInteractions();
        return (/** @type {?} */ (this));
    }
    /**
     * Registers the template that should be used for the drag preview.
     * @template THIS
     * @this {THIS}
     * @param {?} template Template that from which to stamp out the preview.
     * @return {THIS}
     */
    withPreviewTemplate(template) {
        (/** @type {?} */ (this))._previewTemplate = template;
        return (/** @type {?} */ (this));
    }
    /**
     * Registers the template that should be used for the drag placeholder.
     * @template THIS
     * @this {THIS}
     * @param {?} template Template that from which to stamp out the placeholder.
     * @return {THIS}
     */
    withPlaceholderTemplate(template) {
        (/** @type {?} */ (this))._placeholderTemplate = template;
        return (/** @type {?} */ (this));
    }
    /**
     * Sets an alternate drag root element. The root element is the element that will be moved as
     * the user is dragging. Passing an alternate root element is useful when trying to enable
     * dragging on an element that you might not have access to.
     * @template THIS
     * @this {THIS}
     * @param {?} rootElement
     * @return {THIS}
     */
    withRootElement(rootElement) {
        /** @type {?} */
        const element = coerceElement(rootElement);
        if (element !== (/** @type {?} */ (this))._rootElement) {
            if ((/** @type {?} */ (this))._rootElement) {
                (/** @type {?} */ (this))._removeRootElementListeners((/** @type {?} */ (this))._rootElement);
            }
            element.addEventListener('mousedown', (/** @type {?} */ (this))._pointerDown, activeEventListenerOptions);
            element.addEventListener('touchstart', (/** @type {?} */ (this))._pointerDown, passiveEventListenerOptions);
            (/** @type {?} */ (this))._initialTransform = undefined;
            (/** @type {?} */ (this))._rootElement = element;
        }
        return (/** @type {?} */ (this));
    }
    /**
     * Element to which the draggable's position will be constrained.
     * @template THIS
     * @this {THIS}
     * @param {?} boundaryElement
     * @return {THIS}
     */
    withBoundaryElement(boundaryElement) {
        (/** @type {?} */ (this))._boundaryElement = boundaryElement ? coerceElement(boundaryElement) : null;
        return (/** @type {?} */ (this));
    }
    /**
     * Removes the dragging functionality from the DOM element.
     * @return {?}
     */
    dispose() {
        this._removeRootElementListeners(this._rootElement);
        // Do this check before removing from the registry since it'll
        // stop being considered as dragged once it is removed.
        if (this.isDragging()) {
            // Since we move out the element to the end of the body while it's being
            // dragged, we have to make sure that it's removed if it gets destroyed.
            removeElement(this._rootElement);
        }
        this._destroyPreview();
        this._destroyPlaceholder();
        this._dragDropRegistry.removeDragItem(this);
        this._removeSubscriptions();
        this.beforeStarted.complete();
        this.started.complete();
        this.released.complete();
        this.ended.complete();
        this.entered.complete();
        this.exited.complete();
        this.dropped.complete();
        this._moveEvents.complete();
        this._handles = [];
        this._disabledHandles.clear();
        this._dropContainer = undefined;
        this._boundaryElement = this._rootElement = this._placeholderTemplate =
            this._previewTemplate = this._nextSibling = (/** @type {?} */ (null));
    }
    /**
     * Checks whether the element is currently being dragged.
     * @return {?}
     */
    isDragging() {
        return this._hasStartedDragging && this._dragDropRegistry.isDragging(this);
    }
    /**
     * Resets a standalone drag item to its initial position.
     * @return {?}
     */
    reset() {
        this._rootElement.style.transform = this._initialTransform || '';
        this._activeTransform = { x: 0, y: 0 };
        this._passiveTransform = { x: 0, y: 0 };
    }
    /**
     * Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.
     * @param {?} handle Handle element that should be disabled.
     * @return {?}
     */
    disableHandle(handle) {
        if (this._handles.indexOf(handle) > -1) {
            this._disabledHandles.add(handle);
        }
    }
    /**
     * Enables a handle, if it has been disabled.
     * @param {?} handle Handle element to be enabled.
     * @return {?}
     */
    enableHandle(handle) {
        this._disabledHandles.delete(handle);
    }
    /**
     * Sets the layout direction of the draggable item.
     * @template THIS
     * @this {THIS}
     * @param {?} direction
     * @return {THIS}
     */
    withDirection(direction) {
        (/** @type {?} */ (this))._direction = direction;
        return (/** @type {?} */ (this));
    }
    /**
     * Sets the container that the item is part of.
     * @param {?} container
     * @return {?}
     */
    _withDropContainer(container) {
        this._dropContainer = container;
    }
    /**
     * Unsubscribes from the global subscriptions.
     * @private
     * @return {?}
     */
    _removeSubscriptions() {
        this._pointerMoveSubscription.unsubscribe();
        this._pointerUpSubscription.unsubscribe();
    }
    /**
     * Destroys the preview element and its ViewRef.
     * @private
     * @return {?}
     */
    _destroyPreview() {
        if (this._preview) {
            removeElement(this._preview);
        }
        if (this._previewRef) {
            this._previewRef.destroy();
        }
        this._preview = this._previewRef = (/** @type {?} */ (null));
    }
    /**
     * Destroys the placeholder element and its ViewRef.
     * @private
     * @return {?}
     */
    _destroyPlaceholder() {
        if (this._placeholder) {
            removeElement(this._placeholder);
        }
        if (this._placeholderRef) {
            this._placeholderRef.destroy();
        }
        this._placeholder = this._placeholderRef = (/** @type {?} */ (null));
    }
    /**
     * Starts the dragging sequence.
     * @private
     * @param {?} event
     * @return {?}
     */
    _startDragSequence(event) {
        // Emit the event on the item before the one on the container.
        this.started.next({ source: this });
        if (isTouchEvent(event)) {
            this._lastTouchEventTime = Date.now();
        }
        if (this._dropContainer) {
            /** @type {?} */
            const element = this._rootElement;
            // Grab the `nextSibling` before the preview and placeholder
            // have been created so we don't get the preview by accident.
            this._nextSibling = element.nextSibling;
            /** @type {?} */
            const preview = this._preview = this._createPreviewElement();
            /** @type {?} */
            const placeholder = this._placeholder = this._createPlaceholderElement();
            // We move the element out at the end of the body and we make it hidden, because keeping it in
            // place will throw off the consumer's `:last-child` selectors. We can't remove the element
            // from the DOM completely, because iOS will stop firing all subsequent events in the chain.
            element.style.display = 'none';
            this._document.body.appendChild((/** @type {?} */ (element.parentNode)).replaceChild(placeholder, element));
            this._document.body.appendChild(preview);
            this._dropContainer.start();
        }
    }
    /**
     * Sets up the different variables and subscriptions
     * that will be necessary for the dragging sequence.
     * @private
     * @param {?} referenceElement Element that started the drag sequence.
     * @param {?} event Browser event object that started the sequence.
     * @return {?}
     */
    _initializeDragSequence(referenceElement, event) {
        // Always stop propagation for the event that initializes
        // the dragging sequence, in order to prevent it from potentially
        // starting another sequence for a draggable parent somewhere up the DOM tree.
        event.stopPropagation();
        /** @type {?} */
        const isDragging = this.isDragging();
        /** @type {?} */
        const isTouchSequence = isTouchEvent(event);
        /** @type {?} */
        const isAuxiliaryMouseButton = !isTouchSequence && ((/** @type {?} */ (event))).button !== 0;
        /** @type {?} */
        const rootElement = this._rootElement;
        /** @type {?} */
        const isSyntheticEvent = !isTouchSequence && this._lastTouchEventTime &&
            this._lastTouchEventTime + MOUSE_EVENT_IGNORE_TIME > Date.now();
        // If the event started from an element with the native HTML drag&drop, it'll interfere
        // with our own dragging (e.g. `img` tags do it by default). Prevent the default action
        // to stop it from happening. Note that preventing on `dragstart` also seems to work, but
        // it's flaky and it fails if the user drags it away quickly. Also note that we only want
        // to do this for `mousedown` since doing the same for `touchstart` will stop any `click`
        // events from firing on touch devices.
        if (event.target && ((/** @type {?} */ (event.target))).draggable && event.type === 'mousedown') {
            event.preventDefault();
        }
        // Abort if the user is already dragging or is using a mouse button other than the primary one.
        if (isDragging || isAuxiliaryMouseButton || isSyntheticEvent) {
            return;
        }
        // Cache the previous transform amount only after the first drag sequence, because
        // we don't want our own transforms to stack on top of each other.
        if (this._initialTransform == null) {
            this._initialTransform = this._rootElement.style.transform || '';
        }
        // If we've got handles, we need to disable the tap highlight on the entire root element,
        // otherwise iOS will still add it, even though all the drag interactions on the handle
        // are disabled.
        if (this._handles.length) {
            this._rootElementTapHighlight = rootElement.style.webkitTapHighlightColor;
            rootElement.style.webkitTapHighlightColor = 'transparent';
        }
        this._toggleNativeDragInteractions();
        this._hasStartedDragging = this._hasMoved = false;
        this._initialContainer = (/** @type {?} */ (this._dropContainer));
        this._pointerMoveSubscription = this._dragDropRegistry.pointerMove.subscribe(this._pointerMove);
        this._pointerUpSubscription = this._dragDropRegistry.pointerUp.subscribe(this._pointerUp);
        this._scrollPosition = this._viewportRuler.getViewportScrollPosition();
        if (this._boundaryElement) {
            this._boundaryRect = this._boundaryElement.getBoundingClientRect();
        }
        // If we have a custom preview template, the element won't be visible anyway so we avoid the
        // extra `getBoundingClientRect` calls and just move the preview next to the cursor.
        this._pickupPositionInElement = this._previewTemplate && this._previewTemplate.template ?
            { x: 0, y: 0 } :
            this._getPointerPositionInElement(referenceElement, event);
        /** @type {?} */
        const pointerPosition = this._pickupPositionOnPage = this._getPointerPositionOnPage(event);
        this._pointerDirectionDelta = { x: 0, y: 0 };
        this._pointerPositionAtLastDirectionChange = { x: pointerPosition.x, y: pointerPosition.y };
        this._dragDropRegistry.startDragging(this, event);
    }
    /**
     * Cleans up the DOM artifacts that were added to fanpitate the element being dragged.
     * @private
     * @param {?} event
     * @return {?}
     */
    _cleanupDragArtifacts(event) {
        // Restore the element's visibility and insert it at its old position in the DOM.
        // It's important that we maintain the position, because moving the element around in the DOM
        // can throw off `NgFor` which does smart diffing and re-creates elements only when necessary,
        // while moving the existing elements in all other cases.
        this._rootElement.style.display = '';
        if (this._nextSibling) {
            (/** @type {?} */ (this._nextSibling.parentNode)).insertBefore(this._rootElement, this._nextSibling);
        }
        else {
            this._initialContainer.element.appendChild(this._rootElement);
        }
        this._destroyPreview();
        this._destroyPlaceholder();
        this._boundaryRect = this._previewRect = undefined;
        // Re-enter the NgZone since we bound `document` events on the outside.
        this._ngZone.run((/**
         * @return {?}
         */
        () => {
            /** @type {?} */
            const container = (/** @type {?} */ (this._dropContainer));
            /** @type {?} */
            const currentIndex = container.getItemIndex(this);
            const { x, y } = this._getPointerPositionOnPage(event);
            /** @type {?} */
            const isPointerOverContainer = container._isOverContainer(x, y);
            this.ended.next({ source: this });
            this.dropped.next({
                item: this,
                currentIndex,
                previousIndex: this._initialContainer.getItemIndex(this),
                container: container,
                previousContainer: this._initialContainer,
                isPointerOverContainer
            });
            container.drop(this, currentIndex, this._initialContainer, isPointerOverContainer);
            this._dropContainer = this._initialContainer;
        }));
    }
    /**
     * Updates the item's position in its drop container, or moves it
     * into a new one, depending on its current drag position.
     * @private
     * @param {?} __0
     * @return {?}
     */
    _updateActiveDropContainer({ x, y }) {
        // Drop container that draggable has been moved into.
        /** @type {?} */
        let newContainer = (/** @type {?} */ (this._dropContainer))._getSiblingContainerFromPosition(this, x, y) ||
            this._initialContainer._getSiblingContainerFromPosition(this, x, y);
        // If we couldn't find a new container to move the item into, and the item has left it's
        // initial container, check whether the it's over the initial container. This handles the
        // case where two containers are connected one way and the user tries to undo dragging an
        // item into a new container.
        if (!newContainer && this._dropContainer !== this._initialContainer &&
            this._initialContainer._isOverContainer(x, y)) {
            newContainer = this._initialContainer;
        }
        if (newContainer && newContainer !== this._dropContainer) {
            this._ngZone.run((/**
             * @return {?}
             */
            () => {
                // Notify the old container that the item has left.
                this.exited.next({ item: this, container: (/** @type {?} */ (this._dropContainer)) });
                (/** @type {?} */ (this._dropContainer)).exit(this);
                // Notify the new container that the item has entered.
                this.entered.next({ item: this, container: (/** @type {?} */ (newContainer)) });
                this._dropContainer = (/** @type {?} */ (newContainer));
                this._dropContainer.enter(this, x, y);
            }));
        }
        (/** @type {?} */ (this._dropContainer))._sortItem(this, x, y, this._pointerDirectionDelta);
        this._preview.style.transform =
            getTransform(x - this._pickupPositionInElement.x, y - this._pickupPositionInElement.y);
    }
    /**
     * Creates the element that will be rendered next to the user's pointer
     * and will be used as a preview of the element that is being dragged.
     * @private
     * @return {?}
     */
    _createPreviewElement() {
        /** @type {?} */
        const previewConfig = this._previewTemplate;
        /** @type {?} */
        const previewTemplate = previewConfig ? previewConfig.template : null;
        /** @type {?} */
        let preview;
        if (previewTemplate) {
            /** @type {?} */
            const viewRef = (/** @type {?} */ (previewConfig)).viewContainer.createEmbeddedView(previewTemplate, (/** @type {?} */ (previewConfig)).context);
            preview = viewRef.rootNodes[0];
            this._previewRef = viewRef;
            preview.style.transform =
                getTransform(this._pickupPositionOnPage.x, this._pickupPositionOnPage.y);
        }
        else {
            /** @type {?} */
            const element = this._rootElement;
            /** @type {?} */
            const elementRect = element.getBoundingClientRect();
            preview = deepCloneNode(element);
            preview.style.width = `${elementRect.width}px`;
            preview.style.height = `${elementRect.height}px`;
            preview.style.transform = getTransform(elementRect.left, elementRect.top);
        }
        extendStyles(preview.style, {
            // It's important that we disable the pointer events on the preview, because
            // it can throw off the `document.elementFromPoint` calls in the `CdkDropList`.
            pointerEvents: 'none',
            position: 'fixed',
            top: '0',
            left: '0',
            zIndex: '1000'
        });
        toggleNativeDragInteractions(preview, false);
        preview.classList.add('cdk-drag-preview');
        preview.setAttribute('dir', this._direction);
        return preview;
    }
    /**
     * Animates the preview element from its current position to the location of the drop placeholder.
     * @private
     * @return {?} Promise that resolves when the animation completes.
     */
    _animatePreviewToPlaceholder() {
        // If the user hasn't moved yet, the transitionend event won't fire.
        if (!this._hasMoved) {
            return Promise.resolve();
        }
        /** @type {?} */
        const placeholderRect = this._placeholder.getBoundingClientRect();
        // Apply the class that adds a transition to the preview.
        this._preview.classList.add('cdk-drag-animating');
        // Move the preview to the placeholder position.
        this._preview.style.transform = getTransform(placeholderRect.left, placeholderRect.top);
        // If the element doesn't have a `transition`, the `transitionend` event won't fire. Since
        // we need to trigger a style recalculation in order for the `cdk-drag-animating` class to
        // apply its style, we take advantage of the available info to figure out whether we need to
        // bind the event in the first place.
        /** @type {?} */
        const duration = getTransformTransitionDurationInMs(this._preview);
        if (duration === 0) {
            return Promise.resolve();
        }
        return this._ngZone.runOutsideAngular((/**
         * @return {?}
         */
        () => {
            return new Promise((/**
             * @param {?} resolve
             * @return {?}
             */
            resolve => {
                /** @type {?} */
                const handler = (/** @type {?} */ (((/**
                 * @param {?} event
                 * @return {?}
                 */
                (event) => {
                    if (!event || (event.target === this._preview && event.propertyName === 'transform')) {
                        this._preview.removeEventListener('transitionend', handler);
                        resolve();
                        clearTimeout(timeout);
                    }
                }))));
                // If a transition is short enough, the browser might not fire the `transitionend` event.
                // Since we know how long it's supposed to take, add a timeout with a 50% buffer that'll
                // fire if the transition hasn't completed when it was supposed to.
                /** @type {?} */
                const timeout = setTimeout((/** @type {?} */ (handler)), duration * 1.5);
                this._preview.addEventListener('transitionend', handler);
            }));
        }));
    }
    /**
     * Creates an element that will be shown instead of the current element while dragging.
     * @private
     * @return {?}
     */
    _createPlaceholderElement() {
        /** @type {?} */
        const placeholderConfig = this._placeholderTemplate;
        /** @type {?} */
        const placeholderTemplate = placeholderConfig ? placeholderConfig.template : null;
        /** @type {?} */
        let placeholder;
        if (placeholderTemplate) {
            this._placeholderRef = (/** @type {?} */ (placeholderConfig)).viewContainer.createEmbeddedView(placeholderTemplate, (/** @type {?} */ (placeholderConfig)).context);
            placeholder = this._placeholderRef.rootNodes[0];
        }
        else {
            placeholder = deepCloneNode(this._rootElement);
        }
        placeholder.classList.add('cdk-drag-placeholder');
        return placeholder;
    }
    /**
     * Figures out the coordinates at which an element was picked up.
     * @private
     * @param {?} referenceElement Element that initiated the dragging.
     * @param {?} event Event that initiated the dragging.
     * @return {?}
     */
    _getPointerPositionInElement(referenceElement, event) {
        /** @type {?} */
        const elementRect = this._rootElement.getBoundingClientRect();
        /** @type {?} */
        const handleElement = referenceElement === this._rootElement ? null : referenceElement;
        /** @type {?} */
        const referenceRect = handleElement ? handleElement.getBoundingClientRect() : elementRect;
        /** @type {?} */
        const point = isTouchEvent(event) ? event.targetTouches[0] : event;
        /** @type {?} */
        const x = point.pageX - referenceRect.left - this._scrollPosition.left;
        /** @type {?} */
        const y = point.pageY - referenceRect.top - this._scrollPosition.top;
        return {
            x: referenceRect.left - elementRect.left + x,
            y: referenceRect.top - elementRect.top + y
        };
    }
    /**
     * Determines the point of the page that was touched by the user.
     * @private
     * @param {?} event
     * @return {?}
     */
    _getPointerPositionOnPage(event) {
        // `touches` will be empty for start/end events so we have to fall back to `changedTouches`.
        /** @type {?} */
        const point = isTouchEvent(event) ? (event.touches[0] || event.changedTouches[0]) : event;
        return {
            x: point.pageX - this._scrollPosition.left,
            y: point.pageY - this._scrollPosition.top
        };
    }
    /**
     * Gets the pointer position on the page, accounting for any position constraints.
     * @private
     * @param {?} event
     * @return {?}
     */
    _getConstrainedPointerPosition(event) {
        /** @type {?} */
        const point = this._getPointerPositionOnPage(event);
        /** @type {?} */
        const dropContainerLock = this._dropContainer ? this._dropContainer.lockAxis : null;
        if (this.lockAxis === 'x' || dropContainerLock === 'x') {
            point.y = this._pickupPositionOnPage.y;
        }
        else if (this.lockAxis === 'y' || dropContainerLock === 'y') {
            point.x = this._pickupPositionOnPage.x;
        }
        if (this._boundaryRect) {
            const { x: pickupX, y: pickupY } = this._pickupPositionInElement;
            /** @type {?} */
            const boundaryRect = this._boundaryRect;
            /** @type {?} */
            const previewRect = (/** @type {?} */ (this._previewRect));
            /** @type {?} */
            const minY = boundaryRect.top + pickupY;
            /** @type {?} */
            const maxY = boundaryRect.bottom - (previewRect.height - pickupY);
            /** @type {?} */
            const minX = boundaryRect.left + pickupX;
            /** @type {?} */
            const maxX = boundaryRect.right - (previewRect.width - pickupX);
            point.x = clamp(point.x, minX, maxX);
            point.y = clamp(point.y, minY, maxY);
        }
        return point;
    }
    /**
     * Updates the current drag delta, based on the user's current pointer position on the page.
     * @private
     * @param {?} pointerPositionOnPage
     * @return {?}
     */
    _updatePointerDirectionDelta(pointerPositionOnPage) {
        const { x, y } = pointerPositionOnPage;
        /** @type {?} */
        const delta = this._pointerDirectionDelta;
        /** @type {?} */
        const positionSinceLastChange = this._pointerPositionAtLastDirectionChange;
        // Amount of pixels the user has dragged since the last time the direction changed.
        /** @type {?} */
        const changeX = Math.abs(x - positionSinceLastChange.x);
        /** @type {?} */
        const changeY = Math.abs(y - positionSinceLastChange.y);
        // Because we handle pointer events on a per-pixel basis, we don't want the delta
        // to change for every pixel, otherwise anything that depends on it can look erratic.
        // To make the delta more consistent, we track how much the user has moved since the last
        // delta change and we only update it after it has reached a certain threshold.
        if (changeX > this._config.pointerDirectionChangeThreshold) {
            delta.x = x > positionSinceLastChange.x ? 1 : -1;
            positionSinceLastChange.x = x;
        }
        if (changeY > this._config.pointerDirectionChangeThreshold) {
            delta.y = y > positionSinceLastChange.y ? 1 : -1;
            positionSinceLastChange.y = y;
        }
        return delta;
    }
    /**
     * Toggles the native drag interactions, based on how many handles are registered.
     * @private
     * @return {?}
     */
    _toggleNativeDragInteractions() {
        if (!this._rootElement || !this._handles) {
            return;
        }
        /** @type {?} */
        const shouldEnable = this.disabled || this._handles.length > 0;
        if (shouldEnable !== this._nativeInteractionsEnabled) {
            this._nativeInteractionsEnabled = shouldEnable;
            toggleNativeDragInteractions(this._rootElement, shouldEnable);
        }
    }
    /**
     * Removes the manually-added event listeners from the root element.
     * @private
     * @param {?} element
     * @return {?}
     */
    _removeRootElementListeners(element) {
        element.removeEventListener('mousedown', this._pointerDown, activeEventListenerOptions);
        element.removeEventListener('touchstart', this._pointerDown, passiveEventListenerOptions);
    }
}
if (false) {
    /**
     * Element displayed next to the user's pointer while the element is dragged.
     * @type {?}
     * @private
     */
    DragRef.prototype._preview;
    /**
     * Reference to the view of the preview element.
     * @type {?}
     * @private
     */
    DragRef.prototype._previewRef;
    /**
     * Reference to the view of the placeholder element.
     * @type {?}
     * @private
     */
    DragRef.prototype._placeholderRef;
    /**
     * Element that is rendered instead of the draggable item while it is being sorted.
     * @type {?}
     * @private
     */
    DragRef.prototype._placeholder;
    /**
     * Coordinates within the element at which the user picked up the element.
     * @type {?}
     * @private
     */
    DragRef.prototype._pickupPositionInElement;
    /**
     * Coordinates on the page at which the user picked up the element.
     * @type {?}
     * @private
     */
    DragRef.prototype._pickupPositionOnPage;
    /**
     * Reference to the element that comes after the draggable in the DOM, at the time
     * it was picked up. Used for restoring its initial position when it's dropped.
     * @type {?}
     * @private
     */
    DragRef.prototype._nextSibling;
    /**
     * CSS `transform` applied to the element when it isn't being dragged. We need a
     * passive transform in order for the dragged element to retain its new position
     * after the user has stopped dragging and because we need to know the relative
     * position in case they start dragging again. This corresponds to `element.style.transform`.
     * @type {?}
     * @private
     */
    DragRef.prototype._passiveTransform;
    /**
     * CSS `transform` that is applied to the element while it's being dragged.
     * @type {?}
     * @private
     */
    DragRef.prototype._activeTransform;
    /**
     * Inline `transform` value that the element had before the first dragging sequence.
     * @type {?}
     * @private
     */
    DragRef.prototype._initialTransform;
    /**
     * Whether the dragging sequence has been started. Doesn't
     * necessarily mean that the element has been moved.
     * @type {?}
     * @private
     */
    DragRef.prototype._hasStartedDragging;
    /**
     * Whether the element has moved since the user started dragging it.
     * @type {?}
     * @private
     */
    DragRef.prototype._hasMoved;
    /**
     * Drop container in which the DragRef resided when dragging began.
     * @type {?}
     * @private
     */
    DragRef.prototype._initialContainer;
    /**
     * Cached scroll position on the page when the element was picked up.
     * @type {?}
     * @private
     */
    DragRef.prototype._scrollPosition;
    /**
     * Emits when the item is being moved.
     * @type {?}
     * @private
     */
    DragRef.prototype._moveEvents;
    /**
     * Amount of subscriptions to the move event. Used to avoid
     * hitting the zone if the consumer didn't subscribe to it.
     * @type {?}
     * @private
     */
    DragRef.prototype._moveEventSubscriptions;
    /**
     * Keeps track of the direction in which the user is dragging along each axis.
     * @type {?}
     * @private
     */
    DragRef.prototype._pointerDirectionDelta;
    /**
     * Pointer position at which the last change in the delta occurred.
     * @type {?}
     * @private
     */
    DragRef.prototype._pointerPositionAtLastDirectionChange;
    /**
     * Root DOM node of the drag instance. This is the element that will
     * be moved around as the user is dragging.
     * @type {?}
     * @private
     */
    DragRef.prototype._rootElement;
    /**
     * Inline style value of `-webkit-tap-highlight-color` at the time the
     * dragging was started. Used to restore the value once we're done dragging.
     * @type {?}
     * @private
     */
    DragRef.prototype._rootElementTapHighlight;
    /**
     * Subscription to pointer movement events.
     * @type {?}
     * @private
     */
    DragRef.prototype._pointerMoveSubscription;
    /**
     * Subscription to the event that is dispatched when the user lifts their pointer.
     * @type {?}
     * @private
     */
    DragRef.prototype._pointerUpSubscription;
    /**
     * Time at which the last touch event occurred. Used to avoid firing the same
     * events multiple times on touch devices where the browser will fire a fake
     * mouse event for each touch event, after a certain time.
     * @type {?}
     * @private
     */
    DragRef.prototype._lastTouchEventTime;
    /**
     * Cached reference to the boundary element.
     * @type {?}
     * @private
     */
    DragRef.prototype._boundaryElement;
    /**
     * Whether the native dragging interactions have been enabled on the root element.
     * @type {?}
     * @private
     */
    DragRef.prototype._nativeInteractionsEnabled;
    /**
     * Cached dimensions of the preview element.
     * @type {?}
     * @private
     */
    DragRef.prototype._previewRect;
    /**
     * Cached dimensions of the boundary element.
     * @type {?}
     * @private
     */
    DragRef.prototype._boundaryRect;
    /**
     * Element that will be used as a template to create the draggable item's preview.
     * @type {?}
     * @private
     */
    DragRef.prototype._previewTemplate;
    /**
     * Template for placeholder element rendered to show where a draggable would be dropped.
     * @type {?}
     * @private
     */
    DragRef.prototype._placeholderTemplate;
    /**
     * Elements that can be used to drag the draggable item.
     * @type {?}
     * @private
     */
    DragRef.prototype._handles;
    /**
     * Registered handles that are currently disabled.
     * @type {?}
     * @private
     */
    DragRef.prototype._disabledHandles;
    /**
     * Droppable container that the draggable is a part of.
     * @type {?}
     * @private
     */
    DragRef.prototype._dropContainer;
    /**
     * Layout direction of the item.
     * @type {?}
     * @private
     */
    DragRef.prototype._direction;
    /**
     * Axis along which dragging is locked.
     * @type {?}
     */
    DragRef.prototype.lockAxis;
    /**
     * @type {?}
     * @private
     */
    DragRef.prototype._disabled;
    /**
     * Emits as the drag sequence is being prepared.
     * @type {?}
     */
    DragRef.prototype.beforeStarted;
    /**
     * Emits when the user starts dragging the item.
     * @type {?}
     */
    DragRef.prototype.started;
    /**
     * Emits when the user has released a drag item, before any animations have started.
     * @type {?}
     */
    DragRef.prototype.released;
    /**
     * Emits when the user stops dragging an item in the container.
     * @type {?}
     */
    DragRef.prototype.ended;
    /**
     * Emits when the user has moved the item into a new container.
     * @type {?}
     */
    DragRef.prototype.entered;
    /**
     * Emits when the user removes the item its container by dragging it into another container.
     * @type {?}
     */
    DragRef.prototype.exited;
    /**
     * Emits when the user drops the item inside a container.
     * @type {?}
     */
    DragRef.prototype.dropped;
    /**
     * Emits as the user is dragging the item. Use with caution,
     * because this event will fire for every pixel that the user has dragged.
     * @type {?}
     */
    DragRef.prototype.moved;
    /**
     * Arbitrary data that can be attached to the drag item.
     * @type {?}
     */
    DragRef.prototype.data;
    /**
     * Handler for the `mousedown`/`touchstart` events.
     * @type {?}
     * @private
     */
    DragRef.prototype._pointerDown;
    /**
     * Handler that is invoked when the user moves their pointer after they've initiated a drag.
     * @type {?}
     * @private
     */
    DragRef.prototype._pointerMove;
    /**
     * Handler that is invoked when the user lifts their pointer up, after initiating a drag.
     * @type {?}
     * @private
     */
    DragRef.prototype._pointerUp;
    /**
     * @type {?}
     * @private
     */
    DragRef.prototype._config;
    /**
     * @type {?}
     * @private
     */
    DragRef.prototype._document;
    /**
     * @type {?}
     * @private
     */
    DragRef.prototype._ngZone;
    /**
     * @type {?}
     * @private
     */
    DragRef.prototype._viewportRuler;
    /**
     * @type {?}
     * @private
     */
    DragRef.prototype._dragDropRegistry;
}
/**
 * @ignore
 * Point on the page or within an element.
 * @record
 */
export function Point() { }
if (false) {
    /** @type {?} */
    Point.prototype.x;
    /** @type {?} */
    Point.prototype.y;
}
/**
 * Gets a 3d `transform` that can be applied to an element.
 * @param {?} x Desired position of the element along the X axis.
 * @param {?} y Desired position of the element along the Y axis.
 * @return {?}
 */
function getTransform(x, y) {
    // Round the transforms since some browsers will
    // blur the elements for sub-pixel transforms.
    return `translate3d(${Math.round(x)}px, ${Math.round(y)}px, 0)`;
}
/**
 * Creates a deep clone of an element.
 * @param {?} node
 * @return {?}
 */
function deepCloneNode(node) {
    /** @type {?} */
    const clone = (/** @type {?} */ (node.cloneNode(true)));
    // Remove the `id` to avoid having multiple elements with the same id on the page.
    clone.removeAttribute('id');
    return clone;
}
/**
 * Clamps a value between a minimum and a maximum.
 * @param {?} value
 * @param {?} min
 * @param {?} max
 * @return {?}
 */
function clamp(value, min, max) {
    return Math.max(min, Math.min(max, value));
}
/**
 * Helper to remove an element from the DOM and to do all the necessary null checks.
 * @param {?} element Element to be removed.
 * @return {?}
 */
function removeElement(element) {
    if (element && element.parentNode) {
        element.parentNode.removeChild(element);
    }
}
/**
 * Determines whether an event is a touch event.
 * @param {?} event
 * @return {?}
 */
function isTouchEvent(event) {
    return event.type.startsWith('touch');
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"drag-ref.js","sourceRoot":"ng://ngx-pluto/","sources":["lib/drag-drop/drag-ref.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * @license\r\n * Copyright Google LLC All Rights Reserved.\r\n *\r\n * Use of this source code is governed by an MIT-style license that can be\r\n * found in the LICENSE file at https://angular.io/license\r\n */\r\n\r\nimport {EmbeddedViewRef, ElementRef, NgZone, ViewContainerRef, TemplateRef} from '@angular/core';\r\nimport {ViewportRuler} from '@angular/cdk/scrolling';\r\nimport {Direction} from '@angular/cdk/bidi';\r\nimport {coerceBooleanProperty} from '@angular/cdk/coercion';\r\nimport {Subscription, Subject, Observable, Observer} from 'rxjs';\r\nimport {DropListRefInternal as DropListRef} from './drop-list-ref';\r\nimport {DragDropRegistry} from './drag-drop-registry';\r\nimport {extendStyles, toggleNativeDragInteractions} from './drag-styling';\r\nimport {getTransformTransitionDurationInMs} from './transition-duration';\r\nimport { normalizePassiveListenerOptions } from './utils/passive-listeners';\r\nimport { coerceElement } from './utils/element';\r\n\r\n/** @ignore\r\n * Object that can be used to configure the behavior of DragRef. */\r\nexport interface DragRefConfig {\r\n  /**\r\n   * Minimum amount of pixels that the user should\r\n   * drag, before the CDK initiates a drag sequence.\r\n   */\r\n  dragStartThreshold: number;\r\n\r\n  /**\r\n   * Amount the pixels the user should drag before the CDK\r\n   * considers them to have changed the drag direction.\r\n   */\r\n  pointerDirectionChangeThreshold: number;\r\n}\r\n\r\n/** Options that can be used to bind a passive event listener. */\r\nconst passiveEventListenerOptions = normalizePassiveListenerOptions({passive: true});\r\n\r\n/** Options that can be used to bind an active event listener. */\r\nconst activeEventListenerOptions = normalizePassiveListenerOptions({passive: false});\r\n\r\n/**\r\n * Time in milliseconds for which to ignore mouse events, after\r\n * receiving a touch event. Used to avoid doing double work for\r\n * touch devices where the browser fires fake mouse events, in\r\n * addition to touch events.\r\n */\r\nconst MOUSE_EVENT_IGNORE_TIME = 800;\r\n\r\n// TODO(crisbeto): add auto-scrolling functionality.\r\n// TODO(crisbeto): add an API for moving a draggable up/down the\r\n// list programmatically. Useful for keyboard controls.\r\n\r\n/**\r\n * @ignore\r\n * Internal compile-time-only representation of a `DragRef`.\r\n * Used to avoid circular import issues between the `DragRef` and the `DropListRef`.\r\n * @docs-private\r\n */\r\nexport interface DragRefInternal extends DragRef {}\r\n\r\n/** @ignore\r\n * Template that can be used to create a drag helper element (e.g. a preview or a placeholder). */\r\ninterface DragHelperTemplate<T = any> {\r\n  template: TemplateRef<T> | null;\r\n  viewContainer: ViewContainerRef;\r\n  context: T;\r\n}\r\n\r\n/**\r\n * @ignore\r\n * Reference to a draggable item. Used to manipulate or dispose of the item.\r\n * @docs-private\r\n */\r\nexport class DragRef<T = any> {\r\n  /** Element displayed next to the user's pointer while the element is dragged. */\r\n  private _preview: HTMLElement;\r\n\r\n  /** Reference to the view of the preview element. */\r\n  private _previewRef: EmbeddedViewRef<any> | null;\r\n\r\n  /** Reference to the view of the placeholder element. */\r\n  private _placeholderRef: EmbeddedViewRef<any> | null;\r\n\r\n  /** Element that is rendered instead of the draggable item while it is being sorted. */\r\n  private _placeholder: HTMLElement;\r\n\r\n  /** Coordinates within the element at which the user picked up the element. */\r\n  private _pickupPositionInElement: Point;\r\n\r\n  /** Coordinates on the page at which the user picked up the element. */\r\n  private _pickupPositionOnPage: Point;\r\n\r\n  /**\r\n   * Reference to the element that comes after the draggable in the DOM, at the time\r\n   * it was picked up. Used for restoring its initial position when it's dropped.\r\n   */\r\n  private _nextSibling: Node | null;\r\n\r\n  /**\r\n   * CSS `transform` applied to the element when it isn't being dragged. We need a\r\n   * passive transform in order for the dragged element to retain its new position\r\n   * after the user has stopped dragging and because we need to know the relative\r\n   * position in case they start dragging again. This corresponds to `element.style.transform`.\r\n   */\r\n  private _passiveTransform: Point = {x: 0, y: 0};\r\n\r\n  /** CSS `transform` that is applied to the element while it's being dragged. */\r\n  private _activeTransform: Point = {x: 0, y: 0};\r\n\r\n  /** Inline `transform` value that the element had before the first dragging sequence. */\r\n  private _initialTransform?: string;\r\n\r\n  /**\r\n   * Whether the dragging sequence has been started. Doesn't\r\n   * necessarily mean that the element has been moved.\r\n   */\r\n  private _hasStartedDragging: boolean;\r\n\r\n  /** Whether the element has moved since the user started dragging it. */\r\n  private _hasMoved: boolean;\r\n\r\n  /** Drop container in which the DragRef resided when dragging began. */\r\n  private _initialContainer: DropListRef;\r\n\r\n  /** Cached scroll position on the page when the element was picked up. */\r\n  private _scrollPosition: {top: number, left: number};\r\n\r\n  /** Emits when the item is being moved. */\r\n  private _moveEvents = new Subject<{\r\n    source: DragRef;\r\n    pointerPosition: {x: number, y: number};\r\n    event: MouseEvent | TouchEvent;\r\n    delta: {x: -1 | 0 | 1, y: -1 | 0 | 1};\r\n  }>();\r\n\r\n  /**\r\n   * Amount of subscriptions to the move event. Used to avoid\r\n   * hitting the zone if the consumer didn't subscribe to it.\r\n   */\r\n  private _moveEventSubscriptions = 0;\r\n\r\n  /** Keeps track of the direction in which the user is dragging along each axis. */\r\n  private _pointerDirectionDelta: {x: -1 | 0 | 1, y: -1 | 0 | 1};\r\n\r\n  /** Pointer position at which the last change in the delta occurred. */\r\n  private _pointerPositionAtLastDirectionChange: Point;\r\n\r\n  /**\r\n   * Root DOM node of the drag instance. This is the element that will\r\n   * be moved around as the user is dragging.\r\n   */\r\n  private _rootElement: HTMLElement;\r\n\r\n  /**\r\n   * Inline style value of `-webkit-tap-highlight-color` at the time the\r\n   * dragging was started. Used to restore the value once we're done dragging.\r\n   */\r\n  private _rootElementTapHighlight: string | null;\r\n\r\n  /** Subscription to pointer movement events. */\r\n  private _pointerMoveSubscription = Subscription.EMPTY;\r\n\r\n  /** Subscription to the event that is dispatched when the user lifts their pointer. */\r\n  private _pointerUpSubscription = Subscription.EMPTY;\r\n\r\n  /**\r\n   * Time at which the last touch event occurred. Used to avoid firing the same\r\n   * events multiple times on touch devices where the browser will fire a fake\r\n   * mouse event for each touch event, after a certain time.\r\n   */\r\n  private _lastTouchEventTime: number;\r\n\r\n  /** Cached reference to the boundary element. */\r\n  private _boundaryElement: HTMLElement | null = null;\r\n\r\n  /** Whether the native dragging interactions have been enabled on the root element. */\r\n  private _nativeInteractionsEnabled = true;\r\n\r\n  /** Cached dimensions of the preview element. */\r\n  private _previewRect?: ClientRect;\r\n\r\n  /** Cached dimensions of the boundary element. */\r\n  private _boundaryRect?: ClientRect;\r\n\r\n  /** Element that will be used as a template to create the draggable item's preview. */\r\n  private _previewTemplate?: DragHelperTemplate | null;\r\n\r\n  /** Template for placeholder element rendered to show where a draggable would be dropped. */\r\n  private _placeholderTemplate?: DragHelperTemplate | null;\r\n\r\n  /** Elements that can be used to drag the draggable item. */\r\n  private _handles: HTMLElement[] = [];\r\n\r\n  /** Registered handles that are currently disabled. */\r\n  private _disabledHandles = new Set<HTMLElement>();\r\n\r\n  /** Droppable container that the draggable is a part of. */\r\n  private _dropContainer?: DropListRef;\r\n\r\n  /** Layout direction of the item. */\r\n  private _direction: Direction = 'ltr';\r\n\r\n  /** Axis along which dragging is locked. */\r\n  lockAxis: 'x' | 'y';\r\n\r\n  /** Whether starting to drag this element is disabled. */\r\n  get disabled(): boolean {\r\n    return this._disabled || !!(this._dropContainer && this._dropContainer.disabled);\r\n  }\r\n  set disabled(value: boolean) {\r\n    const newValue = coerceBooleanProperty(value);\r\n\r\n    if (newValue !== this._disabled) {\r\n      this._disabled = newValue;\r\n      this._toggleNativeDragInteractions();\r\n    }\r\n  }\r\n  private _disabled = false;\r\n\r\n  /** Emits as the drag sequence is being prepared. */\r\n  beforeStarted = new Subject<void>();\r\n\r\n  /** Emits when the user starts dragging the item. */\r\n  started = new Subject<{source: DragRef}>();\r\n\r\n  /** Emits when the user has released a drag item, before any animations have started. */\r\n  released = new Subject<{source: DragRef}>();\r\n\r\n  /** Emits when the user stops dragging an item in the container. */\r\n  ended = new Subject<{source: DragRef}>();\r\n\r\n  /** Emits when the user has moved the item into a new container. */\r\n  entered = new Subject<{container: DropListRef, item: DragRef}>();\r\n\r\n  /** Emits when the user removes the item its container by dragging it into another container. */\r\n  exited = new Subject<{container: DropListRef, item: DragRef}>();\r\n\r\n  /** Emits when the user drops the item inside a container. */\r\n  dropped = new Subject<{\r\n    previousIndex: number;\r\n    currentIndex: number;\r\n    item: DragRef;\r\n    container: DropListRef;\r\n    previousContainer: DropListRef;\r\n    isPointerOverContainer: boolean;\r\n  }>();\r\n\r\n  /**\r\n   * Emits as the user is dragging the item. Use with caution,\r\n   * because this event will fire for every pixel that the user has dragged.\r\n   */\r\n  moved: Observable<{\r\n    source: DragRef;\r\n    pointerPosition: {x: number, y: number};\r\n    event: MouseEvent | TouchEvent;\r\n    delta: {x: -1 | 0 | 1, y: -1 | 0 | 1};\r\n  }> = new Observable((observer: Observer<any>) => {\r\n    const subscription = this._moveEvents.subscribe(observer);\r\n    this._moveEventSubscriptions++;\r\n\r\n    return () => {\r\n      subscription.unsubscribe();\r\n      this._moveEventSubscriptions--;\r\n    };\r\n  });\r\n\r\n  /** Arbitrary data that can be attached to the drag item. */\r\n  data: T;\r\n\r\n  constructor(\r\n    element: ElementRef<HTMLElement> | HTMLElement,\r\n    private _config: DragRefConfig,\r\n    private _document: Document,\r\n    private _ngZone: NgZone,\r\n    private _viewportRuler: ViewportRuler,\r\n    private _dragDropRegistry: DragDropRegistry<DragRef, DropListRef>) {\r\n\r\n    this.withRootElement(element);\r\n    _dragDropRegistry.registerDragItem(this);\r\n  }\r\n\r\n  /**\r\n   * Returns the element that is being used as a placeholder\r\n   * while the current element is being dragged.\r\n   */\r\n  getPlaceholderElement(): HTMLElement {\r\n    return this._placeholder;\r\n  }\r\n\r\n  /** Returns the root draggable element. */\r\n  getRootElement(): HTMLElement {\r\n    return this._rootElement;\r\n  }\r\n\r\n  /** Registers the handles that can be used to drag the element. */\r\n  withHandles(handles: (HTMLElement | ElementRef<HTMLElement>)[]): this {\r\n    this._handles = handles.map(handle => coerceElement(handle));\r\n    this._handles.forEach(handle => toggleNativeDragInteractions(handle, false));\r\n    this._toggleNativeDragInteractions();\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Registers the template that should be used for the drag preview.\r\n   * @param template Template that from which to stamp out the preview.\r\n   */\r\n  withPreviewTemplate(template: DragHelperTemplate | null): this {\r\n    this._previewTemplate = template;\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Registers the template that should be used for the drag placeholder.\r\n   * @param template Template that from which to stamp out the placeholder.\r\n   */\r\n  withPlaceholderTemplate(template: DragHelperTemplate | null): this {\r\n    this._placeholderTemplate = template;\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Sets an alternate drag root element. The root element is the element that will be moved as\r\n   * the user is dragging. Passing an alternate root element is useful when trying to enable\r\n   * dragging on an element that you might not have access to.\r\n   */\r\n  withRootElement(rootElement: ElementRef<HTMLElement> | HTMLElement): this {\r\n    const element = coerceElement(rootElement);\r\n\r\n    if (element !== this._rootElement) {\r\n      if (this._rootElement) {\r\n        this._removeRootElementListeners(this._rootElement);\r\n      }\r\n\r\n      element.addEventListener('mousedown', this._pointerDown, activeEventListenerOptions);\r\n      element.addEventListener('touchstart', this._pointerDown, passiveEventListenerOptions);\r\n      this._initialTransform = undefined;\r\n      this._rootElement = element;\r\n    }\r\n\r\n    return this;\r\n  }\r\n\r\n  /**\r\n   * Element to which the draggable's position will be constrained.\r\n   */\r\n  withBoundaryElement(boundaryElement: ElementRef<HTMLElement> | HTMLElement | null): this {\r\n    this._boundaryElement = boundaryElement ? coerceElement(boundaryElement) : null;\r\n    return this;\r\n  }\r\n\r\n  /** Removes the dragging functionality from the DOM element. */\r\n  dispose() {\r\n    this._removeRootElementListeners(this._rootElement);\r\n\r\n    // Do this check before removing from the registry since it'll\r\n    // stop being considered as dragged once it is removed.\r\n    if (this.isDragging()) {\r\n      // Since we move out the element to the end of the body while it's being\r\n      // dragged, we have to make sure that it's removed if it gets destroyed.\r\n      removeElement(this._rootElement);\r\n    }\r\n\r\n    this._destroyPreview();\r\n    this._destroyPlaceholder();\r\n    this._dragDropRegistry.removeDragItem(this);\r\n    this._removeSubscriptions();\r\n    this.beforeStarted.complete();\r\n    this.started.complete();\r\n    this.released.complete();\r\n    this.ended.complete();\r\n    this.entered.complete();\r\n    this.exited.complete();\r\n    this.dropped.complete();\r\n    this._moveEvents.complete();\r\n    this._handles = [];\r\n    this._disabledHandles.clear();\r\n    this._dropContainer = undefined;\r\n    this._boundaryElement = this._rootElement = this._placeholderTemplate =\r\n        this._previewTemplate = this._nextSibling = null!;\r\n  }\r\n\r\n  /** Checks whether the element is currently being dragged. */\r\n  isDragging(): boolean {\r\n    return this._hasStartedDragging && this._dragDropRegistry.isDragging(this);\r\n  }\r\n\r\n  /** Resets a standalone drag item to its initial position. */\r\n  reset(): void {\r\n    this._rootElement.style.transform = this._initialTransform || '';\r\n    this._activeTransform = {x: 0, y: 0};\r\n    this._passiveTransform = {x: 0, y: 0};\r\n  }\r\n\r\n  /**\r\n   * Sets a handle as disabled. While a handle is disabled, it'll capture and interrupt dragging.\r\n   * @param handle Handle element that should be disabled.\r\n   */\r\n  disableHandle(handle: HTMLElement) {\r\n    if (this._handles.indexOf(handle) > -1) {\r\n      this._disabledHandles.add(handle);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Enables a handle, if it has been disabled.\r\n   * @param handle Handle element to be enabled.\r\n   */\r\n  enableHandle(handle: HTMLElement) {\r\n    this._disabledHandles.delete(handle);\r\n  }\r\n\r\n  /** Sets the layout direction of the draggable item. */\r\n  withDirection(direction: Direction): this {\r\n    this._direction = direction;\r\n    return this;\r\n  }\r\n\r\n  /** Sets the container that the item is part of. */\r\n  _withDropContainer(container: DropListRef) {\r\n    this._dropContainer = container;\r\n  }\r\n\r\n  /** Unsubscribes from the global subscriptions. */\r\n  private _removeSubscriptions() {\r\n    this._pointerMoveSubscription.unsubscribe();\r\n    this._pointerUpSubscription.unsubscribe();\r\n  }\r\n\r\n  /** Destroys the preview element and its ViewRef. */\r\n  private _destroyPreview() {\r\n    if (this._preview) {\r\n      removeElement(this._preview);\r\n    }\r\n\r\n    if (this._previewRef) {\r\n      this._previewRef.destroy();\r\n    }\r\n\r\n    this._preview = this._previewRef = null!;\r\n  }\r\n\r\n  /** Destroys the placeholder element and its ViewRef. */\r\n  private _destroyPlaceholder() {\r\n    if (this._placeholder) {\r\n      removeElement(this._placeholder);\r\n    }\r\n\r\n    if (this._placeholderRef) {\r\n      this._placeholderRef.destroy();\r\n    }\r\n\r\n    this._placeholder = this._placeholderRef = null!;\r\n  }\r\n\r\n  /** Handler for the `mousedown`/`touchstart` events. */\r\n  private _pointerDown = (event: MouseEvent | TouchEvent) => {\r\n    this.beforeStarted.next();\r\n\r\n    // Delegate the event based on whether it started from a handle or the element itself.\r\n    if (this._handles.length) {\r\n      const targetHandle = this._handles.find(handle => {\r\n        const target = event.target;\r\n        return !!target && (target === handle || handle.contains(target as HTMLElement));\r\n      });\r\n\r\n      if (targetHandle && !this._disabledHandles.has(targetHandle) && !this.disabled) {\r\n        this._initializeDragSequence(targetHandle, event);\r\n      }\r\n    } else if (!this.disabled) {\r\n      this._initializeDragSequence(this._rootElement, event);\r\n    }\r\n  }\r\n\r\n  /** Handler that is invoked when the user moves their pointer after they've initiated a drag. */\r\n  private _pointerMove = (event: MouseEvent | TouchEvent) => {\r\n    if (!this._hasStartedDragging) {\r\n      const pointerPosition = this._getPointerPositionOnPage(event);\r\n      const distanceX = Math.abs(pointerPosition.x - this._pickupPositionOnPage.x);\r\n      const distanceY = Math.abs(pointerPosition.y - this._pickupPositionOnPage.y);\r\n\r\n      // Only start dragging after the user has moved more than the minimum distance in either\r\n      // direction. Note that this is preferrable over doing something like `skip(minimumDistance)`\r\n      // in the `pointerMove` subscription, because we're not guaranteed to have one move event\r\n      // per pixel of movement (e.g. if the user moves their pointer quickly).\r\n      if (distanceX + distanceY >= this._config.dragStartThreshold) {\r\n        this._hasStartedDragging = true;\r\n        this._ngZone.run(() => this._startDragSequence(event));\r\n      }\r\n\r\n      return;\r\n    }\r\n\r\n    // We only need the preview dimensions if we have a boundary element.\r\n    if (this._boundaryElement) {\r\n      // Cache the preview element rect if we haven't cached it already or if\r\n      // we cached it too early before the element dimensions were computed.\r\n      if (!this._previewRect || (!this._previewRect.width && !this._previewRect.height)) {\r\n        this._previewRect = (this._preview || this._rootElement).getBoundingClientRect();\r\n      }\r\n    }\r\n\r\n    const constrainedPointerPosition = this._getConstrainedPointerPosition(event);\r\n    this._hasMoved = true;\r\n    event.preventDefault();\r\n    this._updatePointerDirectionDelta(constrainedPointerPosition);\r\n\r\n    if (this._dropContainer) {\r\n      this._updateActiveDropContainer(constrainedPointerPosition);\r\n    } else {\r\n      const activeTransform = this._activeTransform;\r\n      activeTransform.x =\r\n          constrainedPointerPosition.x - this._pickupPositionOnPage.x + this._passiveTransform.x;\r\n      activeTransform.y =\r\n          constrainedPointerPosition.y - this._pickupPositionOnPage.y + this._passiveTransform.y;\r\n      const transform = getTransform(activeTransform.x, activeTransform.y);\r\n\r\n      // Preserve the previous `transform` value, if there was one. Note that we apply our own\r\n      // transform before the user's, because things like rotation can affect which direction\r\n      // the element will be translated towards.\r\n      this._rootElement.style.transform = this._initialTransform ?\r\n          transform + ' ' + this._initialTransform  : transform;\r\n\r\n      // Apply transform as attribute if dragging and svg element to work for IE\r\n      if (typeof SVGElement !== 'undefined' && this._rootElement instanceof SVGElement) {\r\n        const appliedTransform = `translate(${activeTransform.x} ${activeTransform.y})`;\r\n        this._rootElement.setAttribute('transform', appliedTransform);\r\n      }\r\n    }\r\n\r\n    // Since this event gets fired for every pixel while dragging, we only\r\n    // want to fire it if the consumer opted into it. Also we have to\r\n    // re-enter the zone because we run all of the events on the outside.\r\n    if (this._moveEventSubscriptions > 0) {\r\n      this._ngZone.run(() => {\r\n        this._moveEvents.next({\r\n          source: this,\r\n          pointerPosition: constrainedPointerPosition,\r\n          event,\r\n          delta: this._pointerDirectionDelta\r\n        });\r\n      });\r\n    }\r\n  }\r\n\r\n  /** Handler that is invoked when the user lifts their pointer up, after initiating a drag. */\r\n  private _pointerUp = (event: MouseEvent | TouchEvent) => {\r\n    // Note that here we use `isDragging` from the service, rather than from `this`.\r\n    // The difference is that the one from the service reflects whether a dragging sequence\r\n    // has been initiated, whereas the one on `this` includes whether the user has passed\r\n    // the minimum dragging threshold.\r\n    if (!this._dragDropRegistry.isDragging(this)) {\r\n      return;\r\n    }\r\n\r\n    this._removeSubscriptions();\r\n    this._dragDropRegistry.stopDragging(this);\r\n\r\n    if (this._handles) {\r\n      this._rootElement.style.webkitTapHighlightColor = this._rootElementTapHighlight;\r\n    }\r\n\r\n    if (!this._hasStartedDragging) {\r\n      return;\r\n    }\r\n\r\n    this.released.next({source: this});\r\n\r\n    if (!this._dropContainer) {\r\n      // Convert the active transform into a passive one. This means that next time\r\n      // the user starts dragging the item, its position will be calculated relatively\r\n      // to the new passive transform.\r\n      this._passiveTransform.x = this._activeTransform.x;\r\n      this._passiveTransform.y = this._activeTransform.y;\r\n      this._ngZone.run(() => this.ended.next({source: this}));\r\n      this._dragDropRegistry.stopDragging(this);\r\n      return;\r\n    }\r\n\r\n    this._animatePreviewToPlaceholder().then(() => {\r\n      this._cleanupDragArtifacts(event);\r\n      this._dragDropRegistry.stopDragging(this);\r\n    });\r\n  }\r\n\r\n  /** Starts the dragging sequence. */\r\n  private _startDragSequence(event: MouseEvent | TouchEvent) {\r\n    // Emit the event on the item before the one on the container.\r\n    this.started.next({source: this});\r\n\r\n    if (isTouchEvent(event)) {\r\n      this._lastTouchEventTime = Date.now();\r\n    }\r\n\r\n    if (this._dropContainer) {\r\n      const element = this._rootElement;\r\n\r\n      // Grab the `nextSibling` before the preview and placeholder\r\n      // have been created so we don't get the preview by accident.\r\n      this._nextSibling = element.nextSibling;\r\n\r\n      const preview = this._preview = this._createPreviewElement();\r\n      const placeholder = this._placeholder = this._createPlaceholderElement();\r\n\r\n      // We move the element out at the end of the body and we make it hidden, because keeping it in\r\n      // place will throw off the consumer's `:last-child` selectors. We can't remove the element\r\n      // from the DOM completely, because iOS will stop firing all subsequent events in the chain.\r\n      element.style.display = 'none';\r\n      this._document.body.appendChild(element.parentNode!.replaceChild(placeholder, element));\r\n      this._document.body.appendChild(preview);\r\n      this._dropContainer.start();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Sets up the different variables and subscriptions\r\n   * that will be necessary for the dragging sequence.\r\n   * @param referenceElement Element that started the drag sequence.\r\n   * @param event Browser event object that started the sequence.\r\n   */\r\n  private _initializeDragSequence(referenceElement: HTMLElement, event: MouseEvent | TouchEvent) {\r\n    // Always stop propagation for the event that initializes\r\n    // the dragging sequence, in order to prevent it from potentially\r\n    // starting another sequence for a draggable parent somewhere up the DOM tree.\r\n    event.stopPropagation();\r\n\r\n    const isDragging = this.isDragging();\r\n    const isTouchSequence = isTouchEvent(event);\r\n    const isAuxiliaryMouseButton = !isTouchSequence && (event as MouseEvent).button !== 0;\r\n    const rootElement = this._rootElement;\r\n    const isSyntheticEvent = !isTouchSequence && this._lastTouchEventTime &&\r\n      this._lastTouchEventTime + MOUSE_EVENT_IGNORE_TIME > Date.now();\r\n\r\n    // If the event started from an element with the native HTML drag&drop, it'll interfere\r\n    // with our own dragging (e.g. `img` tags do it by default). Prevent the default action\r\n    // to stop it from happening. Note that preventing on `dragstart` also seems to work, but\r\n    // it's flaky and it fails if the user drags it away quickly. Also note that we only want\r\n    // to do this for `mousedown` since doing the same for `touchstart` will stop any `click`\r\n    // events from firing on touch devices.\r\n    if (event.target && (event.target as HTMLElement).draggable && event.type === 'mousedown') {\r\n      event.preventDefault();\r\n    }\r\n\r\n    // Abort if the user is already dragging or is using a mouse button other than the primary one.\r\n    if (isDragging || isAuxiliaryMouseButton || isSyntheticEvent) {\r\n      return;\r\n    }\r\n\r\n    // Cache the previous transform amount only after the first drag sequence, because\r\n    // we don't want our own transforms to stack on top of each other.\r\n    if (this._initialTransform == null) {\r\n      this._initialTransform = this._rootElement.style.transform || '';\r\n    }\r\n\r\n    // If we've got handles, we need to disable the tap highlight on the entire root element,\r\n    // otherwise iOS will still add it, even though all the drag interactions on the handle\r\n    // are disabled.\r\n    if (this._handles.length) {\r\n      this._rootElementTapHighlight = rootElement.style.webkitTapHighlightColor;\r\n      rootElement.style.webkitTapHighlightColor = 'transparent';\r\n    }\r\n\r\n    this._toggleNativeDragInteractions();\r\n    this._hasStartedDragging = this._hasMoved = false;\r\n    this._initialContainer = this._dropContainer!;\r\n    this._pointerMoveSubscription = this._dragDropRegistry.pointerMove.subscribe(this._pointerMove);\r\n    this._pointerUpSubscription = this._dragDropRegistry.pointerUp.subscribe(this._pointerUp);\r\n    this._scrollPosition = this._viewportRuler.getViewportScrollPosition();\r\n\r\n    if (this._boundaryElement) {\r\n      this._boundaryRect = this._boundaryElement.getBoundingClientRect();\r\n    }\r\n\r\n    // If we have a custom preview template, the element won't be visible anyway so we avoid the\r\n    // extra `getBoundingClientRect` calls and just move the preview next to the cursor.\r\n    this._pickupPositionInElement = this._previewTemplate && this._previewTemplate.template ?\r\n      {x: 0, y: 0} :\r\n      this._getPointerPositionInElement(referenceElement, event);\r\n    const pointerPosition = this._pickupPositionOnPage = this._getPointerPositionOnPage(event);\r\n    this._pointerDirectionDelta = {x: 0, y: 0};\r\n    this._pointerPositionAtLastDirectionChange = {x: pointerPosition.x, y: pointerPosition.y};\r\n    this._dragDropRegistry.startDragging(this, event);\r\n  }\r\n\r\n  /** Cleans up the DOM artifacts that were added to fanpitate the element being dragged. */\r\n  private _cleanupDragArtifacts(event: MouseEvent | TouchEvent) {\r\n    // Restore the element's visibility and insert it at its old position in the DOM.\r\n    // It's important that we maintain the position, because moving the element around in the DOM\r\n    // can throw off `NgFor` which does smart diffing and re-creates elements only when necessary,\r\n    // while moving the existing elements in all other cases.\r\n    this._rootElement.style.display = '';\r\n\r\n    if (this._nextSibling) {\r\n      this._nextSibling.parentNode!.insertBefore(this._rootElement, this._nextSibling);\r\n    } else {\r\n      this._initialContainer.element.appendChild(this._rootElement);\r\n    }\r\n\r\n    this._destroyPreview();\r\n    this._destroyPlaceholder();\r\n    this._boundaryRect = this._previewRect = undefined;\r\n\r\n    // Re-enter the NgZone since we bound `document` events on the outside.\r\n    this._ngZone.run(() => {\r\n      const container = this._dropContainer!;\r\n      const currentIndex = container.getItemIndex(this);\r\n      const {x, y} = this._getPointerPositionOnPage(event);\r\n      const isPointerOverContainer = container._isOverContainer(x, y);\r\n\r\n      this.ended.next({source: this});\r\n      this.dropped.next({\r\n        item: this,\r\n        currentIndex,\r\n        previousIndex: this._initialContainer.getItemIndex(this),\r\n        container: container,\r\n        previousContainer: this._initialContainer,\r\n        isPointerOverContainer\r\n      });\r\n      container.drop(this, currentIndex, this._initialContainer, isPointerOverContainer);\r\n      this._dropContainer = this._initialContainer;\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Updates the item's position in its drop container, or moves it\r\n   * into a new one, depending on its current drag position.\r\n   */\r\n  private _updateActiveDropContainer({x, y}: Point) {\r\n    // Drop container that draggable has been moved into.\r\n    let newContainer = this._dropContainer!._getSiblingContainerFromPosition(this, x, y) ||\r\n        this._initialContainer._getSiblingContainerFromPosition(this, x, y);\r\n\r\n    // If we couldn't find a new container to move the item into, and the item has left it's\r\n    // initial container, check whether the it's over the initial container. This handles the\r\n    // case where two containers are connected one way and the user tries to undo dragging an\r\n    // item into a new container.\r\n    if (!newContainer && this._dropContainer !== this._initialContainer &&\r\n        this._initialContainer._isOverContainer(x, y)) {\r\n      newContainer = this._initialContainer;\r\n    }\r\n\r\n    if (newContainer && newContainer !== this._dropContainer) {\r\n      this._ngZone.run(() => {\r\n        // Notify the old container that the item has left.\r\n        this.exited.next({item: this, container: this._dropContainer!});\r\n        this._dropContainer!.exit(this);\r\n        // Notify the new container that the item has entered.\r\n        this.entered.next({item: this, container: newContainer!});\r\n        this._dropContainer = newContainer!;\r\n        this._dropContainer.enter(this, x, y);\r\n      });\r\n    }\r\n\r\n    this._dropContainer!._sortItem(this, x, y, this._pointerDirectionDelta);\r\n    this._preview.style.transform =\r\n        getTransform(x - this._pickupPositionInElement.x, y - this._pickupPositionInElement.y);\r\n  }\r\n\r\n  /**\r\n   * Creates the element that will be rendered next to the user's pointer\r\n   * and will be used as a preview of the element that is being dragged.\r\n   */\r\n  private _createPreviewElement(): HTMLElement {\r\n    const previewConfig = this._previewTemplate;\r\n    const previewTemplate = previewConfig ? previewConfig.template : null;\r\n    let preview: HTMLElement;\r\n\r\n    if (previewTemplate) {\r\n      const viewRef = previewConfig!.viewContainer.createEmbeddedView(previewTemplate,\r\n                                                                      previewConfig!.context);\r\n      preview = viewRef.rootNodes[0];\r\n      this._previewRef = viewRef;\r\n      preview.style.transform =\r\n          getTransform(this._pickupPositionOnPage.x, this._pickupPositionOnPage.y);\r\n    } else {\r\n      const element = this._rootElement;\r\n      const elementRect = element.getBoundingClientRect();\r\n\r\n      preview = deepCloneNode(element);\r\n      preview.style.width = `${elementRect.width}px`;\r\n      preview.style.height = `${elementRect.height}px`;\r\n      preview.style.transform = getTransform(elementRect.left, elementRect.top);\r\n    }\r\n\r\n    extendStyles(preview.style, {\r\n      // It's important that we disable the pointer events on the preview, because\r\n      // it can throw off the `document.elementFromPoint` calls in the `CdkDropList`.\r\n      pointerEvents: 'none',\r\n      position: 'fixed',\r\n      top: '0',\r\n      left: '0',\r\n      zIndex: '1000'\r\n    });\r\n\r\n    toggleNativeDragInteractions(preview, false);\r\n\r\n    preview.classList.add('cdk-drag-preview');\r\n    preview.setAttribute('dir', this._direction);\r\n\r\n    return preview;\r\n  }\r\n\r\n  /**\r\n   * Animates the preview element from its current position to the location of the drop placeholder.\r\n   * @returns Promise that resolves when the animation completes.\r\n   */\r\n  private _animatePreviewToPlaceholder(): Promise<void> {\r\n    // If the user hasn't moved yet, the transitionend event won't fire.\r\n    if (!this._hasMoved) {\r\n      return Promise.resolve();\r\n    }\r\n\r\n    const placeholderRect = this._placeholder.getBoundingClientRect();\r\n\r\n    // Apply the class that adds a transition to the preview.\r\n    this._preview.classList.add('cdk-drag-animating');\r\n\r\n    // Move the preview to the placeholder position.\r\n    this._preview.style.transform = getTransform(placeholderRect.left, placeholderRect.top);\r\n\r\n    // If the element doesn't have a `transition`, the `transitionend` event won't fire. Since\r\n    // we need to trigger a style recalculation in order for the `cdk-drag-animating` class to\r\n    // apply its style, we take advantage of the available info to figure out whether we need to\r\n    // bind the event in the first place.\r\n    const duration = getTransformTransitionDurationInMs(this._preview);\r\n\r\n    if (duration === 0) {\r\n      return Promise.resolve();\r\n    }\r\n\r\n    return this._ngZone.runOutsideAngular(() => {\r\n      return new Promise(resolve => {\r\n        const handler = ((event: TransitionEvent) => {\r\n          if (!event || (event.target === this._preview && event.propertyName === 'transform')) {\r\n            this._preview.removeEventListener('transitionend', handler);\r\n            resolve();\r\n            clearTimeout(timeout);\r\n          }\r\n        }) as EventListenerOrEventListenerObject;\r\n\r\n        // If a transition is short enough, the browser might not fire the `transitionend` event.\r\n        // Since we know how long it's supposed to take, add a timeout with a 50% buffer that'll\r\n        // fire if the transition hasn't completed when it was supposed to.\r\n        const timeout = setTimeout(handler as Function, duration * 1.5);\r\n        this._preview.addEventListener('transitionend', handler);\r\n      });\r\n    });\r\n  }\r\n\r\n  /** Creates an element that will be shown instead of the current element while dragging. */\r\n  private _createPlaceholderElement(): HTMLElement {\r\n    const placeholderConfig = this._placeholderTemplate;\r\n    const placeholderTemplate = placeholderConfig ? placeholderConfig.template : null;\r\n    let placeholder: HTMLElement;\r\n\r\n    if (placeholderTemplate) {\r\n      this._placeholderRef = placeholderConfig!.viewContainer.createEmbeddedView(\r\n        placeholderTemplate,\r\n        placeholderConfig!.context\r\n      );\r\n      placeholder = this._placeholderRef.rootNodes[0];\r\n    } else {\r\n      placeholder = deepCloneNode(this._rootElement);\r\n    }\r\n\r\n    placeholder.classList.add('cdk-drag-placeholder');\r\n    return placeholder;\r\n  }\r\n\r\n  /**\r\n   * Figures out the coordinates at which an element was picked up.\r\n   * @param referenceElement Element that initiated the dragging.\r\n   * @param event Event that initiated the dragging.\r\n   */\r\n  private _getPointerPositionInElement(referenceElement: HTMLElement,\r\n                                       event: MouseEvent | TouchEvent): Point {\r\n    const elementRect = this._rootElement.getBoundingClientRect();\r\n    const handleElement = referenceElement === this._rootElement ? null : referenceElement;\r\n    const referenceRect = handleElement ? handleElement.getBoundingClientRect() : elementRect;\r\n    const point = isTouchEvent(event) ? event.targetTouches[0] : event;\r\n    const x = point.pageX - referenceRect.left - this._scrollPosition.left;\r\n    const y = point.pageY - referenceRect.top - this._scrollPosition.top;\r\n\r\n    return {\r\n      x: referenceRect.left - elementRect.left + x,\r\n      y: referenceRect.top - elementRect.top + y\r\n    };\r\n  }\r\n\r\n  /** Determines the point of the page that was touched by the user. */\r\n  private _getPointerPositionOnPage(event: MouseEvent | TouchEvent): Point {\r\n    // `touches` will be empty for start/end events so we have to fall back to `changedTouches`.\r\n    const point = isTouchEvent(event) ? (event.touches[0] || event.changedTouches[0]) : event;\r\n\r\n    return {\r\n      x: point.pageX - this._scrollPosition.left,\r\n      y: point.pageY - this._scrollPosition.top\r\n    };\r\n  }\r\n\r\n\r\n  /** Gets the pointer position on the page, accounting for any position constraints. */\r\n  private _getConstrainedPointerPosition(event: MouseEvent | TouchEvent): Point {\r\n    const point = this._getPointerPositionOnPage(event);\r\n    const dropContainerLock = this._dropContainer ? this._dropContainer.lockAxis : null;\r\n\r\n    if (this.lockAxis === 'x' || dropContainerLock === 'x') {\r\n      point.y = this._pickupPositionOnPage.y;\r\n    } else if (this.lockAxis === 'y' || dropContainerLock === 'y') {\r\n      point.x = this._pickupPositionOnPage.x;\r\n    }\r\n\r\n    if (this._boundaryRect) {\r\n      const {x: pickupX, y: pickupY} = this._pickupPositionInElement;\r\n      const boundaryRect = this._boundaryRect;\r\n      const previewRect = this._previewRect!;\r\n      const minY = boundaryRect.top + pickupY;\r\n      const maxY = boundaryRect.bottom - (previewRect.height - pickupY);\r\n      const minX = boundaryRect.left + pickupX;\r\n      const maxX = boundaryRect.right - (previewRect.width - pickupX);\r\n\r\n      point.x = clamp(point.x, minX, maxX);\r\n      point.y = clamp(point.y, minY, maxY);\r\n    }\r\n\r\n    return point;\r\n  }\r\n\r\n\r\n  /** Updates the current drag delta, based on the user's current pointer position on the page. */\r\n  private _updatePointerDirectionDelta(pointerPositionOnPage: Point) {\r\n    const {x, y} = pointerPositionOnPage;\r\n    const delta = this._pointerDirectionDelta;\r\n    const positionSinceLastChange = this._pointerPositionAtLastDirectionChange;\r\n\r\n    // Amount of pixels the user has dragged since the last time the direction changed.\r\n    const changeX = Math.abs(x - positionSinceLastChange.x);\r\n    const changeY = Math.abs(y - positionSinceLastChange.y);\r\n\r\n    // Because we handle pointer events on a per-pixel basis, we don't want the delta\r\n    // to change for every pixel, otherwise anything that depends on it can look erratic.\r\n    // To make the delta more consistent, we track how much the user has moved since the last\r\n    // delta change and we only update it after it has reached a certain threshold.\r\n    if (changeX > this._config.pointerDirectionChangeThreshold) {\r\n      delta.x = x > positionSinceLastChange.x ? 1 : -1;\r\n      positionSinceLastChange.x = x;\r\n    }\r\n\r\n    if (changeY > this._config.pointerDirectionChangeThreshold) {\r\n      delta.y = y > positionSinceLastChange.y ? 1 : -1;\r\n      positionSinceLastChange.y = y;\r\n    }\r\n\r\n    return delta;\r\n  }\r\n\r\n  /** Toggles the native drag interactions, based on how many handles are registered. */\r\n  private _toggleNativeDragInteractions() {\r\n    if (!this._rootElement || !this._handles) {\r\n      return;\r\n    }\r\n\r\n    const shouldEnable = this.disabled || this._handles.length > 0;\r\n\r\n    if (shouldEnable !== this._nativeInteractionsEnabled) {\r\n      this._nativeInteractionsEnabled = shouldEnable;\r\n      toggleNativeDragInteractions(this._rootElement, shouldEnable);\r\n    }\r\n  }\r\n\r\n  /** Removes the manually-added event listeners from the root element. */\r\n  private _removeRootElementListeners(element: HTMLElement) {\r\n    element.removeEventListener('mousedown', this._pointerDown, activeEventListenerOptions);\r\n    element.removeEventListener('touchstart', this._pointerDown, passiveEventListenerOptions);\r\n  }\r\n\r\n}\r\n\r\n/** @ignore\r\n * Point on the page or within an element. */\r\nexport interface Point {\r\n  x: number;\r\n  y: number;\r\n}\r\n\r\n/**\r\n * Gets a 3d `transform` that can be applied to an element.\r\n * @param x Desired position of the element along the X axis.\r\n * @param y Desired position of the element along the Y axis.\r\n */\r\nfunction getTransform(x: number, y: number): string {\r\n  // Round the transforms since some browsers will\r\n  // blur the elements for sub-pixel transforms.\r\n  return `translate3d(${Math.round(x)}px, ${Math.round(y)}px, 0)`;\r\n}\r\n\r\n/** Creates a deep clone of an element. */\r\nfunction deepCloneNode(node: HTMLElement): HTMLElement {\r\n  const clone = node.cloneNode(true) as HTMLElement;\r\n  // Remove the `id` to avoid having multiple elements with the same id on the page.\r\n  clone.removeAttribute('id');\r\n  return clone;\r\n}\r\n\r\n/** Clamps a value between a minimum and a maximum. */\r\nfunction clamp(value: number, min: number, max: number) {\r\n  return Math.max(min, Math.min(max, value));\r\n}\r\n\r\n/**\r\n * Helper to remove an element from the DOM and to do all the necessary null checks.\r\n * @param element Element to be removed.\r\n */\r\nfunction removeElement(element: HTMLElement | null) {\r\n  if (element && element.parentNode) {\r\n    element.parentNode.removeChild(element);\r\n  }\r\n}\r\n\r\n/** Determines whether an event is a touch event. */\r\nfunction isTouchEvent(event: MouseEvent | TouchEvent): event is TouchEvent {\r\n  return event.type.startsWith('touch');\r\n}\r\n"]}